Commit | Line | Data |
---|---|---|
9cbc6ef0 | 1 | /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB. |
50306a9d | 2 | |
34f55018 | 3 | Copyright (C) 2004, 2006 Free Software Foundation, Inc. |
50306a9d | 4 | |
c0f96416 | 5 | This file is part of GDB. |
50306a9d | 6 | |
c0f96416 MK |
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. | |
50306a9d | 11 | |
c0f96416 MK |
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. | |
50306a9d | 16 | |
c0f96416 MK |
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. */ | |
50306a9d RC |
21 | |
22 | #include "defs.h" | |
23 | #include "gdbcore.h" | |
24 | #include "osabi.h" | |
25 | #include "target.h" | |
26 | #include "objfiles.h" | |
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" | |
d49771ef | 32 | #include "value.h" |
50306a9d RC |
33 | #include "hppa-tdep.h" |
34 | ||
d49771ef RC |
35 | #include "elf/common.h" |
36 | ||
50306a9d RC |
37 | #if 0 |
38 | /* Convert DWARF register number REG to the appropriate register | |
39 | number used by GDB. */ | |
40 | static int | |
41 | hppa_dwarf_reg_to_regnum (int reg) | |
42 | { | |
43 | /* registers 0 - 31 are the same in both sets */ | |
44 | if (reg < 32) | |
45 | return reg; | |
46 | ||
47 | /* dwarf regs 32 to 85 are fpregs 4 - 31 */ | |
48 | if (reg >= 32 && reg <= 85) | |
34f75cc1 | 49 | return HPPA_FP4_REGNUM + (reg - 32); |
50306a9d | 50 | |
8a3fe4f8 | 51 | warning (_("Unmapped DWARF Register #%d encountered."), reg); |
50306a9d RC |
52 | return -1; |
53 | } | |
54 | #endif | |
55 | ||
56 | static void | |
57 | hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid) | |
58 | { | |
59 | /* Probably this should be done by the kernel, but it isn't. */ | |
34f75cc1 RC |
60 | write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid); |
61 | write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid); | |
50306a9d RC |
62 | } |
63 | ||
64 | /* An instruction to match. */ | |
65 | struct insn_pattern | |
66 | { | |
67 | unsigned int data; /* See if it matches this.... */ | |
68 | unsigned int mask; /* ... with this mask. */ | |
69 | }; | |
70 | ||
50306a9d RC |
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 }, | |
78 | /* nop */ | |
79 | { 0x08000240, 0xffffffff }, | |
80 | { 0, 0 } | |
81 | }; | |
82 | ||
83 | #define HPPA_MAX_INSN_PATTERN_LEN (4) | |
84 | ||
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 | |
88 | zero. | |
89 | ||
90 | When the match is successful, fill INSN[i] with what PATTERN[i] | |
91 | matched. */ | |
92 | static int | |
93 | insns_match_pattern (CORE_ADDR pc, | |
94 | struct insn_pattern *pattern, | |
95 | unsigned int *insn) | |
96 | { | |
97 | int i; | |
98 | CORE_ADDR npc = pc; | |
99 | ||
100 | for (i = 0; pattern[i].mask; i++) | |
101 | { | |
f4ca1d1f RC |
102 | char buf[4]; |
103 | ||
1f602b35 | 104 | deprecated_read_memory_nobpt (npc, buf, 4); |
f4ca1d1f | 105 | insn[i] = extract_unsigned_integer (buf, 4); |
50306a9d RC |
106 | if ((insn[i] & pattern[i].mask) == pattern[i].data) |
107 | npc += 4; | |
108 | else | |
109 | return 0; | |
110 | } | |
111 | return 1; | |
112 | } | |
113 | ||
50306a9d RC |
114 | /* Signal frames. */ |
115 | ||
116 | /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.) | |
117 | ||
118 | Unfortunately, because of various bugs and changes to the kernel, | |
119 | we have several cases to deal with. | |
120 | ||
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. | |
123 | ||
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. | |
127 | ||
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. | |
132 | ||
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. */ | |
135 | static CORE_ADDR | |
2f0e8c7a | 136 | hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc) |
50306a9d RC |
137 | { |
138 | unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN]; | |
139 | int offs = 0; | |
140 | int try; | |
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 }; | |
2f0e8c7a RC |
145 | CORE_ADDR sp; |
146 | ||
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); | |
50306a9d RC |
151 | |
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 | |
156 | 08000240 nop */ | |
157 | ||
158 | for (try = 0; try < ARRAY_SIZE (pcoffs); try++) | |
159 | { | |
160 | if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy)) | |
161 | { | |
162 | offs = sfoffs[try]; | |
163 | break; | |
164 | } | |
165 | } | |
166 | ||
167 | if (offs == 0) | |
2f0e8c7a RC |
168 | { |
169 | if (insns_match_pattern (pc, hppa_sigtramp, dummy)) | |
170 | { | |
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. */ | |
174 | try = 2; | |
175 | sp = pc - pcoffs[try]; | |
176 | } | |
177 | else | |
178 | { | |
179 | return 0; | |
180 | } | |
181 | } | |
50306a9d RC |
182 | |
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; | |
190 | } | |
191 | ||
192 | struct hppa_linux_sigtramp_unwind_cache | |
193 | { | |
194 | CORE_ADDR base; | |
195 | struct trad_frame_saved_reg *saved_regs; | |
196 | }; | |
197 | ||
198 | static struct hppa_linux_sigtramp_unwind_cache * | |
199 | hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame, | |
200 | void **this_cache) | |
201 | { | |
202 | struct gdbarch *gdbarch = get_frame_arch (next_frame); | |
203 | struct hppa_linux_sigtramp_unwind_cache *info; | |
2f0e8c7a | 204 | CORE_ADDR pc, scptr; |
50306a9d RC |
205 | int i; |
206 | ||
207 | if (*this_cache) | |
208 | return *this_cache; | |
209 | ||
210 | info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache); | |
211 | *this_cache = info; | |
212 | info->saved_regs = trad_frame_alloc_saved_regs (next_frame); | |
213 | ||
214 | pc = frame_pc_unwind (next_frame); | |
2f0e8c7a | 215 | scptr = hppa_linux_sigtramp_find_sigcontext (pc); |
50306a9d RC |
216 | |
217 | /* structure of struct sigcontext: | |
218 | ||
219 | 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; */ | |
226 | ||
227 | /* Skip sc_flags. */ | |
228 | scptr += 4; | |
229 | ||
230 | /* GR[0] is the psw, we don't restore that. */ | |
231 | scptr += 4; | |
232 | ||
233 | /* General registers. */ | |
234 | for (i = 1; i < 32; i++) | |
235 | { | |
34f75cc1 | 236 | info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr; |
50306a9d RC |
237 | scptr += 4; |
238 | } | |
239 | ||
240 | /* Pad. */ | |
241 | scptr += 4; | |
242 | ||
243 | /* FP regs; FP0-3 are not restored. */ | |
244 | scptr += (8 * 4); | |
245 | ||
246 | for (i = 4; i < 32; i++) | |
247 | { | |
248 | info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr; | |
249 | scptr += 4; | |
250 | info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr; | |
251 | scptr += 4; | |
252 | } | |
253 | ||
254 | /* IASQ/IAOQ. */ | |
34f75cc1 | 255 | info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr; |
50306a9d | 256 | scptr += 4; |
34f75cc1 | 257 | info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr; |
50306a9d RC |
258 | scptr += 4; |
259 | ||
34f75cc1 | 260 | info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr; |
50306a9d | 261 | scptr += 4; |
34f75cc1 | 262 | info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr; |
50306a9d RC |
263 | scptr += 4; |
264 | ||
2f0e8c7a | 265 | info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM); |
50306a9d RC |
266 | |
267 | return info; | |
268 | } | |
269 | ||
270 | static void | |
271 | hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame, | |
272 | void **this_prologue_cache, | |
273 | struct frame_id *this_id) | |
274 | { | |
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)); | |
278 | } | |
279 | ||
280 | static void | |
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, | |
285 | CORE_ADDR *addrp, | |
4577207e | 286 | int *realnump, gdb_byte *valuep) |
50306a9d RC |
287 | { |
288 | struct hppa_linux_sigtramp_unwind_cache *info | |
289 | = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); | |
0da28f8a RC |
290 | hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum, |
291 | optimizedp, lvalp, addrp, realnump, valuep); | |
50306a9d RC |
292 | } |
293 | ||
294 | static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = { | |
295 | SIGTRAMP_FRAME, | |
296 | hppa_linux_sigtramp_frame_this_id, | |
297 | hppa_linux_sigtramp_frame_prev_register | |
298 | }; | |
299 | ||
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) | |
308 | { | |
309 | CORE_ADDR pc = frame_pc_unwind (next_frame); | |
50306a9d | 310 | |
2f0e8c7a | 311 | if (hppa_linux_sigtramp_find_sigcontext (pc)) |
50306a9d RC |
312 | return &hppa_linux_sigtramp_frame_unwind; |
313 | ||
314 | return NULL; | |
315 | } | |
316 | ||
d49771ef RC |
317 | /* Attempt to find (and return) the global pointer for the given |
318 | function. | |
319 | ||
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. */ | |
326 | ||
327 | static CORE_ADDR | |
328 | hppa_linux_find_global_pointer (struct value *function) | |
329 | { | |
330 | struct obj_section *faddr_sect; | |
331 | CORE_ADDR faddr; | |
332 | ||
333 | faddr = value_as_address (function); | |
334 | ||
335 | /* Is this a plabel? If so, dereference it to get the gp value. */ | |
336 | if (faddr & 2) | |
337 | { | |
338 | int status; | |
339 | char buf[4]; | |
340 | ||
341 | faddr &= ~3; | |
342 | ||
343 | status = target_read_memory (faddr + 4, buf, sizeof (buf)); | |
344 | if (status == 0) | |
345 | return extract_unsigned_integer (buf, sizeof (buf)); | |
346 | } | |
347 | ||
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 | |
350 | that function. */ | |
351 | if (in_plt_section (faddr, NULL)) | |
352 | return 0; | |
353 | ||
354 | faddr_sect = find_pc_section (faddr); | |
355 | if (faddr_sect != NULL) | |
356 | { | |
357 | struct obj_section *osect; | |
358 | ||
359 | ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect) | |
360 | { | |
361 | if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0) | |
362 | break; | |
363 | } | |
364 | ||
365 | if (osect < faddr_sect->objfile->sections_end) | |
366 | { | |
367 | CORE_ADDR addr; | |
368 | ||
369 | addr = osect->addr; | |
370 | while (addr < osect->endaddr) | |
371 | { | |
372 | int status; | |
373 | LONGEST tag; | |
374 | char buf[4]; | |
375 | ||
376 | status = target_read_memory (addr, buf, sizeof (buf)); | |
377 | if (status != 0) | |
378 | break; | |
379 | tag = extract_signed_integer (buf, sizeof (buf)); | |
380 | ||
381 | if (tag == DT_PLTGOT) | |
382 | { | |
383 | CORE_ADDR global_pointer; | |
384 | ||
385 | status = target_read_memory (addr + 4, buf, sizeof (buf)); | |
386 | if (status != 0) | |
387 | break; | |
388 | global_pointer = extract_unsigned_integer (buf, sizeof (buf)); | |
389 | ||
390 | /* The payoff... */ | |
391 | return global_pointer; | |
392 | } | |
393 | ||
394 | if (tag == DT_NULL) | |
395 | break; | |
396 | ||
397 | addr += 8; | |
398 | } | |
399 | } | |
400 | } | |
401 | return 0; | |
402 | } | |
403 | ||
50306a9d RC |
404 | /* Forward declarations. */ |
405 | extern initialize_file_ftype _initialize_hppa_linux_tdep; | |
406 | ||
407 | static void | |
408 | hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
409 | { | |
410 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
411 | ||
9cbc6ef0 | 412 | /* GNU/Linux is always ELF. */ |
50306a9d RC |
413 | tdep->is_elf = 1; |
414 | ||
d49771ef RC |
415 | tdep->find_global_pointer = hppa_linux_find_global_pointer; |
416 | ||
50306a9d RC |
417 | set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc); |
418 | ||
419 | frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer); | |
420 | ||
421 | /* GNU/Linux uses SVR4-style shared libraries. */ | |
422 | set_solib_svr4_fetch_link_map_offsets | |
423 | (gdbarch, svr4_ilp32_fetch_link_map_offsets); | |
424 | ||
34f55018 MK |
425 | tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline; |
426 | set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code); | |
50306a9d RC |
427 | |
428 | /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ | |
429 | set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); | |
430 | ||
3a7d1c27 RC |
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); | |
435 | ||
50306a9d RC |
436 | #if 0 |
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); | |
442 | #endif | |
b2756930 KB |
443 | |
444 | /* Enable TLS support. */ | |
445 | set_gdbarch_fetch_tls_load_module_address (gdbarch, | |
446 | svr4_fetch_objfile_link_map); | |
50306a9d RC |
447 | } |
448 | ||
449 | void | |
450 | _initialize_hppa_linux_tdep (void) | |
451 | { | |
452 | gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi); | |
453 | } |