1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
3 Copyright (C) 2004, 2006 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"
33 #include "hppa-tdep.h"
35 #include "elf/common.h"
38 /* Convert DWARF register number REG to the appropriate register
39 number used by GDB. */
41 hppa_dwarf_reg_to_regnum (int reg
)
43 /* registers 0 - 31 are the same in both sets */
47 /* dwarf regs 32 to 85 are fpregs 4 - 31 */
48 if (reg
>= 32 && reg
<= 85)
49 return HPPA_FP4_REGNUM
+ (reg
- 32);
51 warning (_("Unmapped DWARF Register #%d encountered."), reg
);
57 hppa_linux_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
59 /* Probably this should be done by the kernel, but it isn't. */
60 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, v
| 0x3, ptid
);
61 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, (v
+ 4) | 0x3, ptid
);
64 /* An instruction to match. */
67 unsigned int data
; /* See if it matches this.... */
68 unsigned int mask
; /* ... with this mask. */
71 static struct insn_pattern hppa_sigtramp
[] = {
72 /* ldi 0, %r25 or ldi 1, %r25 */
73 { 0x34190000, 0xfffffffd },
74 /* ldi __NR_rt_sigreturn, %r20 */
75 { 0x3414015a, 0xffffffff },
76 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
77 { 0xe4008200, 0xffffffff },
79 { 0x08000240, 0xffffffff },
83 #define HPPA_MAX_INSN_PATTERN_LEN (4)
85 /* Return non-zero if the instructions at PC match the series
86 described in PATTERN, or zero otherwise. PATTERN is an array of
87 'struct insn_pattern' objects, terminated by an entry whose mask is
90 When the match is successful, fill INSN[i] with what PATTERN[i]
93 insns_match_pattern (CORE_ADDR pc
,
94 struct insn_pattern
*pattern
,
100 for (i
= 0; pattern
[i
].mask
; i
++)
104 deprecated_read_memory_nobpt (npc
, buf
, 4);
105 insn
[i
] = extract_unsigned_integer (buf
, 4);
106 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
116 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
118 Unfortunately, because of various bugs and changes to the kernel,
119 we have several cases to deal with.
121 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
122 the beginning of the trampoline and struct rt_sigframe.
124 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
125 the 4th word in the trampoline structure. This is wrong, it should point
126 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
128 To detect these cases, we first take pc, align it to 64-bytes
129 to get the beginning of the signal frame, and then check offsets 0, 4
130 and 5 to see if we found the beginning of the trampoline. This will
131 tell us how to locate the sigcontext structure.
133 Note that with a 2.4 64-bit kernel, the signal context is not properly
134 passed back to userspace so the unwind will not work correctly. */
136 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc
)
138 unsigned int dummy
[HPPA_MAX_INSN_PATTERN_LEN
];
141 /* offsets to try to find the trampoline */
142 static int pcoffs
[] = { 0, 4*4, 5*4 };
143 /* offsets to the rt_sigframe structure */
144 static int sfoffs
[] = { 4*4, 10*4, 10*4 };
147 /* Most of the time, this will be correct. The one case when this will
148 fail is if the user defined an alternate stack, in which case the
149 beginning of the stack will not be align_down (pc, 64). */
150 sp
= align_down (pc
, 64);
152 /* rt_sigreturn trampoline:
153 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
154 3414015a ldi __NR_rt_sigreturn, %r20
155 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
158 for (try = 0; try < ARRAY_SIZE (pcoffs
); try++)
160 if (insns_match_pattern (sp
+ pcoffs
[try], hppa_sigtramp
, dummy
))
169 if (insns_match_pattern (pc
, hppa_sigtramp
, dummy
))
171 /* sigaltstack case: we have no way of knowing which offset to
172 use in this case; default to new kernel handling. If this is
173 wrong the unwinding will fail. */
175 sp
= pc
- pcoffs
[try];
183 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
184 a struct siginfo and a struct ucontext. struct ucontext contains
185 a struct sigcontext. Return an offset to this sigcontext here. Too
186 bad we cannot include system specific headers :-(.
187 sizeof(struct siginfo) == 128
188 offsetof(struct ucontext, uc_mcontext) == 24. */
189 return sp
+ sfoffs
[try] + 128 + 24;
192 struct hppa_linux_sigtramp_unwind_cache
195 struct trad_frame_saved_reg
*saved_regs
;
198 static struct hppa_linux_sigtramp_unwind_cache
*
199 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
202 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
203 struct hppa_linux_sigtramp_unwind_cache
*info
;
210 info
= FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache
);
212 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
214 pc
= frame_pc_unwind (next_frame
);
215 scptr
= hppa_linux_sigtramp_find_sigcontext (pc
);
217 /* structure of struct sigcontext:
220 unsigned long sc_flags;
221 unsigned long sc_gr[32];
222 unsigned long long sc_fr[32];
223 unsigned long sc_iasq[2];
224 unsigned long sc_iaoq[2];
225 unsigned long sc_sar; */
230 /* GR[0] is the psw, we don't restore that. */
233 /* General registers. */
234 for (i
= 1; i
< 32; i
++)
236 info
->saved_regs
[HPPA_R0_REGNUM
+ i
].addr
= scptr
;
243 /* FP regs; FP0-3 are not restored. */
246 for (i
= 4; i
< 32; i
++)
248 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2)].addr
= scptr
;
250 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2) + 1].addr
= scptr
;
255 info
->saved_regs
[HPPA_PCSQ_HEAD_REGNUM
].addr
= scptr
;
257 info
->saved_regs
[HPPA_PCSQ_TAIL_REGNUM
].addr
= scptr
;
260 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= scptr
;
262 info
->saved_regs
[HPPA_PCOQ_TAIL_REGNUM
].addr
= scptr
;
265 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
271 hppa_linux_sigtramp_frame_this_id (struct frame_info
*next_frame
,
272 void **this_prologue_cache
,
273 struct frame_id
*this_id
)
275 struct hppa_linux_sigtramp_unwind_cache
*info
276 = hppa_linux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
277 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
281 hppa_linux_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
282 void **this_prologue_cache
,
283 int regnum
, int *optimizedp
,
284 enum lval_type
*lvalp
,
286 int *realnump
, gdb_byte
*valuep
)
288 struct hppa_linux_sigtramp_unwind_cache
*info
289 = hppa_linux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
290 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
291 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
294 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind
= {
296 hppa_linux_sigtramp_frame_this_id
,
297 hppa_linux_sigtramp_frame_prev_register
300 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return
301 address should point to a signal trampoline on the stack. The signal
302 trampoline is embedded in a rt_sigframe structure that is aligned on
303 the stack. We take advantage of the fact that sp must be 64-byte aligned,
304 and the trampoline is small, so by rounding down the trampoline address
305 we can find the beginning of the struct rt_sigframe. */
306 static const struct frame_unwind
*
307 hppa_linux_sigtramp_unwind_sniffer (struct frame_info
*next_frame
)
309 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
311 if (hppa_linux_sigtramp_find_sigcontext (pc
))
312 return &hppa_linux_sigtramp_frame_unwind
;
317 /* Attempt to find (and return) the global pointer for the given
320 This is a rather nasty bit of code searchs for the .dynamic section
321 in the objfile corresponding to the pc of the function we're trying
322 to call. Once it finds the addresses at which the .dynamic section
323 lives in the child process, it scans the Elf32_Dyn entries for a
324 DT_PLTGOT tag. If it finds one of these, the corresponding
325 d_un.d_ptr value is the global pointer. */
328 hppa_linux_find_global_pointer (struct value
*function
)
330 struct obj_section
*faddr_sect
;
333 faddr
= value_as_address (function
);
335 /* Is this a plabel? If so, dereference it to get the gp value. */
343 status
= target_read_memory (faddr
+ 4, buf
, sizeof (buf
));
345 return extract_unsigned_integer (buf
, sizeof (buf
));
348 /* If the address is in the plt section, then the real function hasn't
349 yet been fixed up by the linker so we cannot determine the gp of
351 if (in_plt_section (faddr
, NULL
))
354 faddr_sect
= find_pc_section (faddr
);
355 if (faddr_sect
!= NULL
)
357 struct obj_section
*osect
;
359 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
361 if (strcmp (osect
->the_bfd_section
->name
, ".dynamic") == 0)
365 if (osect
< faddr_sect
->objfile
->sections_end
)
370 while (addr
< osect
->endaddr
)
376 status
= target_read_memory (addr
, buf
, sizeof (buf
));
379 tag
= extract_signed_integer (buf
, sizeof (buf
));
381 if (tag
== DT_PLTGOT
)
383 CORE_ADDR global_pointer
;
385 status
= target_read_memory (addr
+ 4, buf
, sizeof (buf
));
388 global_pointer
= extract_unsigned_integer (buf
, sizeof (buf
));
391 return global_pointer
;
404 /* Forward declarations. */
405 extern initialize_file_ftype _initialize_hppa_linux_tdep
;
408 hppa_linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
410 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
412 /* GNU/Linux is always ELF. */
415 tdep
->find_global_pointer
= hppa_linux_find_global_pointer
;
417 set_gdbarch_write_pc (gdbarch
, hppa_linux_target_write_pc
);
419 frame_unwind_append_sniffer (gdbarch
, hppa_linux_sigtramp_unwind_sniffer
);
421 /* GNU/Linux uses SVR4-style shared libraries. */
422 set_solib_svr4_fetch_link_map_offsets
423 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
425 tdep
->in_solib_call_trampoline
= hppa_in_solib_call_trampoline
;
426 set_gdbarch_skip_trampoline_code (gdbarch
, hppa_skip_trampoline_code
);
428 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
429 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
431 /* On hppa-linux, currently, sizeof(long double) == 8. There has been
432 some discussions to support 128-bit long double, but it requires some
433 more work in gcc and glibc first. */
434 set_gdbarch_long_double_bit (gdbarch
, 64);
437 /* Dwarf-2 unwinding support. Not yet working. */
438 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, hppa_dwarf_reg_to_regnum
);
439 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa_dwarf_reg_to_regnum
);
440 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
441 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
444 /* Enable TLS support. */
445 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
446 svr4_fetch_objfile_link_map
);
450 _initialize_hppa_linux_tdep (void)
452 gdbarch_register_osabi (bfd_arch_hppa
, 0, GDB_OSABI_LINUX
, hppa_linux_init_abi
);