1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
3 Copyright (C) 2004, 2006, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>. */
25 #include "solib-svr4.h"
26 #include "glibc-tdep.h"
27 #include "frame-unwind.h"
28 #include "trad-frame.h"
29 #include "dwarf2-frame.h"
33 #include "hppa-tdep.h"
35 #include "elf/common.h"
37 /* Map DWARF DBX register numbers to GDB register numbers. */
39 hppa_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
41 /* The general registers and the sar are the same in both sets. */
45 /* fr4-fr31 (left and right halves) are mapped from 72. */
46 if (reg
>= 72 && reg
<= 72 + 28 * 2)
47 return HPPA_FP4_REGNUM
+ (reg
- 72);
49 warning (_("Unmapped DWARF DBX Register #%d encountered."), reg
);
54 hppa_linux_target_write_pc (struct regcache
*regcache
, CORE_ADDR v
)
56 /* Probably this should be done by the kernel, but it isn't. */
57 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, v
| 0x3);
58 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, (v
+ 4) | 0x3);
61 /* An instruction to match. */
64 unsigned int data
; /* See if it matches this.... */
65 unsigned int mask
; /* ... with this mask. */
68 static struct insn_pattern hppa_sigtramp
[] = {
69 /* ldi 0, %r25 or ldi 1, %r25 */
70 { 0x34190000, 0xfffffffd },
71 /* ldi __NR_rt_sigreturn, %r20 */
72 { 0x3414015a, 0xffffffff },
73 /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
74 { 0xe4008200, 0xffffffff },
76 { 0x08000240, 0xffffffff },
80 #define HPPA_MAX_INSN_PATTERN_LEN (4)
82 /* Return non-zero if the instructions at PC match the series
83 described in PATTERN, or zero otherwise. PATTERN is an array of
84 'struct insn_pattern' objects, terminated by an entry whose mask is
87 When the match is successful, fill INSN[i] with what PATTERN[i]
90 insns_match_pattern (CORE_ADDR pc
,
91 struct insn_pattern
*pattern
,
97 for (i
= 0; pattern
[i
].mask
; i
++)
101 target_read_memory (npc
, buf
, 4);
102 insn
[i
] = extract_unsigned_integer (buf
, 4);
103 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
113 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
115 Unfortunately, because of various bugs and changes to the kernel,
116 we have several cases to deal with.
118 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
119 the beginning of the trampoline and struct rt_sigframe.
121 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
122 the 4th word in the trampoline structure. This is wrong, it should point
123 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
125 To detect these cases, we first take pc, align it to 64-bytes
126 to get the beginning of the signal frame, and then check offsets 0, 4
127 and 5 to see if we found the beginning of the trampoline. This will
128 tell us how to locate the sigcontext structure.
130 Note that with a 2.4 64-bit kernel, the signal context is not properly
131 passed back to userspace so the unwind will not work correctly. */
133 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc
)
135 unsigned int dummy
[HPPA_MAX_INSN_PATTERN_LEN
];
138 /* offsets to try to find the trampoline */
139 static int pcoffs
[] = { 0, 4*4, 5*4 };
140 /* offsets to the rt_sigframe structure */
141 static int sfoffs
[] = { 4*4, 10*4, 10*4 };
144 /* Most of the time, this will be correct. The one case when this will
145 fail is if the user defined an alternate stack, in which case the
146 beginning of the stack will not be align_down (pc, 64). */
147 sp
= align_down (pc
, 64);
149 /* rt_sigreturn trampoline:
150 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
151 3414015a ldi __NR_rt_sigreturn, %r20
152 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
155 for (try = 0; try < ARRAY_SIZE (pcoffs
); try++)
157 if (insns_match_pattern (sp
+ pcoffs
[try], hppa_sigtramp
, dummy
))
166 if (insns_match_pattern (pc
, hppa_sigtramp
, dummy
))
168 /* sigaltstack case: we have no way of knowing which offset to
169 use in this case; default to new kernel handling. If this is
170 wrong the unwinding will fail. */
172 sp
= pc
- pcoffs
[try];
180 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
181 a struct siginfo and a struct ucontext. struct ucontext contains
182 a struct sigcontext. Return an offset to this sigcontext here. Too
183 bad we cannot include system specific headers :-(.
184 sizeof(struct siginfo) == 128
185 offsetof(struct ucontext, uc_mcontext) == 24. */
186 return sp
+ sfoffs
[try] + 128 + 24;
189 struct hppa_linux_sigtramp_unwind_cache
192 struct trad_frame_saved_reg
*saved_regs
;
195 static struct hppa_linux_sigtramp_unwind_cache
*
196 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
199 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
200 struct hppa_linux_sigtramp_unwind_cache
*info
;
207 info
= FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache
);
209 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
211 pc
= get_frame_pc (this_frame
);
212 scptr
= hppa_linux_sigtramp_find_sigcontext (pc
);
214 /* structure of struct sigcontext:
217 unsigned long sc_flags;
218 unsigned long sc_gr[32];
219 unsigned long long sc_fr[32];
220 unsigned long sc_iasq[2];
221 unsigned long sc_iaoq[2];
222 unsigned long sc_sar; */
227 /* GR[0] is the psw, we don't restore that. */
230 /* General registers. */
231 for (i
= 1; i
< 32; i
++)
233 info
->saved_regs
[HPPA_R0_REGNUM
+ i
].addr
= scptr
;
240 /* FP regs; FP0-3 are not restored. */
243 for (i
= 4; i
< 32; i
++)
245 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2)].addr
= scptr
;
247 info
->saved_regs
[HPPA_FP0_REGNUM
+ (i
* 2) + 1].addr
= scptr
;
252 info
->saved_regs
[HPPA_PCSQ_HEAD_REGNUM
].addr
= scptr
;
254 info
->saved_regs
[HPPA_PCSQ_TAIL_REGNUM
].addr
= scptr
;
257 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= scptr
;
259 info
->saved_regs
[HPPA_PCOQ_TAIL_REGNUM
].addr
= scptr
;
262 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
268 hppa_linux_sigtramp_frame_this_id (struct frame_info
*this_frame
,
269 void **this_prologue_cache
,
270 struct frame_id
*this_id
)
272 struct hppa_linux_sigtramp_unwind_cache
*info
273 = hppa_linux_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
274 *this_id
= frame_id_build (info
->base
, get_frame_pc (this_frame
));
277 static struct value
*
278 hppa_linux_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
279 void **this_prologue_cache
,
282 struct hppa_linux_sigtramp_unwind_cache
*info
283 = hppa_linux_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
284 return hppa_frame_prev_register_helper (this_frame
,
285 info
->saved_regs
, regnum
);
288 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return
289 address should point to a signal trampoline on the stack. The signal
290 trampoline is embedded in a rt_sigframe structure that is aligned on
291 the stack. We take advantage of the fact that sp must be 64-byte aligned,
292 and the trampoline is small, so by rounding down the trampoline address
293 we can find the beginning of the struct rt_sigframe. */
295 hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind
*self
,
296 struct frame_info
*this_frame
,
297 void **this_prologue_cache
)
299 CORE_ADDR pc
= get_frame_pc (this_frame
);
301 if (hppa_linux_sigtramp_find_sigcontext (pc
))
307 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind
= {
309 hppa_linux_sigtramp_frame_this_id
,
310 hppa_linux_sigtramp_frame_prev_register
,
312 hppa_linux_sigtramp_frame_sniffer
315 /* Attempt to find (and return) the global pointer for the given
318 This is a rather nasty bit of code searchs for the .dynamic section
319 in the objfile corresponding to the pc of the function we're trying
320 to call. Once it finds the addresses at which the .dynamic section
321 lives in the child process, it scans the Elf32_Dyn entries for a
322 DT_PLTGOT tag. If it finds one of these, the corresponding
323 d_un.d_ptr value is the global pointer. */
326 hppa_linux_find_global_pointer (struct gdbarch
*gdbarch
, struct value
*function
)
328 struct obj_section
*faddr_sect
;
331 faddr
= value_as_address (function
);
333 /* Is this a plabel? If so, dereference it to get the gp value. */
341 status
= target_read_memory (faddr
+ 4, buf
, sizeof (buf
));
343 return extract_unsigned_integer (buf
, sizeof (buf
));
346 /* If the address is in the plt section, then the real function hasn't
347 yet been fixed up by the linker so we cannot determine the gp of
349 if (in_plt_section (faddr
, NULL
))
352 faddr_sect
= find_pc_section (faddr
);
353 if (faddr_sect
!= NULL
)
355 struct obj_section
*osect
;
357 ALL_OBJFILE_OSECTIONS (faddr_sect
->objfile
, osect
)
359 if (strcmp (osect
->the_bfd_section
->name
, ".dynamic") == 0)
363 if (osect
< faddr_sect
->objfile
->sections_end
)
365 CORE_ADDR addr
, endaddr
;
367 addr
= obj_section_addr (osect
);
368 endaddr
= obj_section_endaddr (osect
);
370 while (addr
< 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
;
405 * Registers saved in a coredump:
410 * sar, iir, isr, ior, ipsw
416 #define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n)
417 #define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n)
418 static const int greg_map
[] =
420 GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
421 GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
422 GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
423 GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
424 GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
425 GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
426 GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
427 GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
429 HPPA_SR4_REGNUM
+1, HPPA_SR4_REGNUM
+2, HPPA_SR4_REGNUM
+3, HPPA_SR4_REGNUM
+4,
430 HPPA_SR4_REGNUM
, HPPA_SR4_REGNUM
+5, HPPA_SR4_REGNUM
+6, HPPA_SR4_REGNUM
+7,
432 HPPA_PCOQ_HEAD_REGNUM
, HPPA_PCOQ_TAIL_REGNUM
,
433 HPPA_PCSQ_HEAD_REGNUM
, HPPA_PCSQ_TAIL_REGNUM
,
435 HPPA_SAR_REGNUM
, HPPA_IIR_REGNUM
, HPPA_ISR_REGNUM
, HPPA_IOR_REGNUM
,
436 HPPA_IPSW_REGNUM
, HPPA_RCR_REGNUM
,
438 TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
439 TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
441 HPPA_PID0_REGNUM
, HPPA_PID1_REGNUM
, HPPA_PID2_REGNUM
, HPPA_PID3_REGNUM
,
442 HPPA_CCR_REGNUM
, HPPA_EIEM_REGNUM
,
446 hppa_linux_supply_regset (const struct regset
*regset
,
447 struct regcache
*regcache
,
448 int regnum
, const void *regs
, size_t len
)
450 struct gdbarch
*arch
= get_regcache_arch (regcache
);
451 struct gdbarch_tdep
*tdep
= gdbarch_tdep (arch
);
452 const char *buf
= regs
;
456 for (i
= 0; i
< ARRAY_SIZE (greg_map
); i
++)
458 if (regnum
== greg_map
[i
] || regnum
== -1)
459 regcache_raw_supply (regcache
, greg_map
[i
], buf
+ offset
);
461 offset
+= tdep
->bytes_per_address
;
466 hppa_linux_supply_fpregset (const struct regset
*regset
,
467 struct regcache
*regcache
,
468 int regnum
, const void *regs
, size_t len
)
470 const char *buf
= regs
;
474 for (i
= 0; i
< 64; i
++)
476 if (regnum
== HPPA_FP0_REGNUM
+ i
|| regnum
== -1)
477 regcache_raw_supply (regcache
, HPPA_FP0_REGNUM
+ i
,
483 /* HPPA Linux kernel register set. */
484 static struct regset hppa_linux_regset
=
487 hppa_linux_supply_regset
490 static struct regset hppa_linux_fpregset
=
493 hppa_linux_supply_fpregset
496 static const struct regset
*
497 hppa_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
498 const char *sect_name
,
501 if (strcmp (sect_name
, ".reg") == 0)
502 return &hppa_linux_regset
;
503 else if (strcmp (sect_name
, ".reg2") == 0)
504 return &hppa_linux_fpregset
;
510 /* Forward declarations. */
511 extern initialize_file_ftype _initialize_hppa_linux_tdep
;
514 hppa_linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
516 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
518 /* GNU/Linux is always ELF. */
521 tdep
->find_global_pointer
= hppa_linux_find_global_pointer
;
523 set_gdbarch_write_pc (gdbarch
, hppa_linux_target_write_pc
);
525 frame_unwind_append_unwinder (gdbarch
, &hppa_linux_sigtramp_frame_unwind
);
527 /* GNU/Linux uses SVR4-style shared libraries. */
528 set_solib_svr4_fetch_link_map_offsets
529 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
531 tdep
->in_solib_call_trampoline
= hppa_in_solib_call_trampoline
;
532 set_gdbarch_skip_trampoline_code (gdbarch
, hppa_skip_trampoline_code
);
534 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
535 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
537 /* On hppa-linux, currently, sizeof(long double) == 8. There has been
538 some discussions to support 128-bit long double, but it requires some
539 more work in gcc and glibc first. */
540 set_gdbarch_long_double_bit (gdbarch
, 64);
542 set_gdbarch_regset_from_core_section
543 (gdbarch
, hppa_linux_regset_from_core_section
);
545 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, hppa_dwarf_reg_to_regnum
);
547 /* Enable TLS support. */
548 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
549 svr4_fetch_objfile_link_map
);
553 _initialize_hppa_linux_tdep (void)
555 gdbarch_register_osabi (bfd_arch_hppa
, 0, GDB_OSABI_LINUX
, hppa_linux_init_abi
);
556 gdbarch_register_osabi (bfd_arch_hppa
, bfd_mach_hppa20w
, GDB_OSABI_LINUX
, hppa_linux_init_abi
);