1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
2
3 Copyright 2004 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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. */
20
21 #include "defs.h"
22 #include "gdbcore.h"
23 #include "osabi.h"
24 #include "target.h"
25 #include "objfiles.h"
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 "value.h"
32 #include "hppa-tdep.h"
33
34 #include "elf/common.h"
35
36 #if 0
37 /* Convert DWARF register number REG to the appropriate register
38 number used by GDB. */
39 static int
40 hppa_dwarf_reg_to_regnum (int reg)
41 {
42 /* registers 0 - 31 are the same in both sets */
43 if (reg < 32)
44 return reg;
45
46 /* dwarf regs 32 to 85 are fpregs 4 - 31 */
47 if (reg >= 32 && reg <= 85)
48 return HPPA_FP4_REGNUM + (reg - 32);
49
50 warning ("Unmapped DWARF Register #%d encountered\n", reg);
51 return -1;
52 }
53 #endif
54
55 static void
hppa_linux_target_write_pc(CORE_ADDR v,ptid_t ptid)56 hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid)
57 {
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);
61 }
62
63 /* An instruction to match. */
64 struct insn_pattern
65 {
66 unsigned int data; /* See if it matches this.... */
67 unsigned int mask; /* ... with this mask. */
68 };
69
70 /* See bfd/elf32-hppa.c */
71 static struct insn_pattern hppa_long_branch_stub[] = {
72 /* ldil LR'xxx,%r1 */
73 { 0x20200000, 0xffe00000 },
74 /* be,n RR'xxx(%sr4,%r1) */
75 { 0xe0202002, 0xffe02002 },
76 { 0, 0 }
77 };
78
79 static struct insn_pattern hppa_long_branch_pic_stub[] = {
80 /* b,l .+8, %r1 */
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 },
86 { 0, 0 }
87 };
88
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 },
94 /* bv %r0(%r21) */
95 { 0xeaa0c000, 0xffffffff },
96 /* ldw RR'xxx+4(%r1), %r19 */
97 { 0x48330000, 0xffffb000 },
98 { 0, 0 }
99 };
100
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 },
106 /* bv %r0(%r21) */
107 { 0xeaa0c000, 0xffffffff },
108 /* ldw RR'xxx+4(%r1),%r19 */
109 { 0x48330000, 0xffffb000 },
110 { 0, 0 },
111 };
112
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 },
118 { 0, 0 }
119 };
120
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 },
128 /* nop */
129 { 0x08000240, 0xffffffff },
130 { 0, 0 }
131 };
132
133 #define HPPA_MAX_INSN_PATTERN_LEN (4)
134
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
138 zero.
139
140 When the match is successful, fill INSN[i] with what PATTERN[i]
141 matched. */
142 static int
insns_match_pattern(CORE_ADDR pc,struct insn_pattern * pattern,unsigned int * insn)143 insns_match_pattern (CORE_ADDR pc,
144 struct insn_pattern *pattern,
145 unsigned int *insn)
146 {
147 int i;
148 CORE_ADDR npc = pc;
149
150 for (i = 0; pattern[i].mask; i++)
151 {
152 char buf[4];
153
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)
157 npc += 4;
158 else
159 return 0;
160 }
161 return 1;
162 }
163
164 static int
hppa_linux_in_dyncall(CORE_ADDR pc)165 hppa_linux_in_dyncall (CORE_ADDR pc)
166 {
167 return pc == hppa_symbol_address("$$dyncall");
168 }
169
170 /* There are several kinds of "trampolines" that we need to deal with:
171 - long branch stubs: these are inserted by the linker when a branch
172 target is too far away for a branch insn to reach
173 - plt stubs: these should go into the .plt section, so are easy to find
174 - import stubs: used to call from object to shared lib or shared lib to
175 shared lib; these go in regular text sections. In fact the linker tries
176 to put them throughout the code because branches have limited reachability.
177 We use the same mechanism as ppc64 to recognize the stub insn patterns.
178 - $$dyncall: similar to hpux, hppa-linux uses $$dyncall for indirect function
179 calls. $$dyncall is exported by libgcc.a */
180 static int
hppa_linux_in_solib_call_trampoline(CORE_ADDR pc,char * name)181 hppa_linux_in_solib_call_trampoline (CORE_ADDR pc, char *name)
182 {
183 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
184 int r;
185
186 r = in_plt_section (pc, name)
187 || hppa_linux_in_dyncall (pc)
188 || insns_match_pattern (pc, hppa_import_stub, insn)
189 || insns_match_pattern (pc, hppa_import_pic_stub, insn)
190 || insns_match_pattern (pc, hppa_long_branch_stub, insn)
191 || insns_match_pattern (pc, hppa_long_branch_pic_stub, insn);
192
193 return r;
194 }
195
196 static CORE_ADDR
hppa_linux_skip_trampoline_code(CORE_ADDR pc)197 hppa_linux_skip_trampoline_code (CORE_ADDR pc)
198 {
199 unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
200 int dp_rel, pic_rel;
201
202 /* dyncall handles both PLABELs and direct addresses */
203 if (hppa_linux_in_dyncall (pc))
204 {
205 pc = (CORE_ADDR) read_register (22);
206
207 /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */
208 if (pc & 0x2)
209 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
210
211 return pc;
212 }
213
214 dp_rel = pic_rel = 0;
215 if ((dp_rel = insns_match_pattern (pc, hppa_import_stub, insn))
216 || (pic_rel = insns_match_pattern (pc, hppa_import_pic_stub, insn)))
217 {
218 /* Extract the target address from the addil/ldw sequence. */
219 pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
220
221 if (dp_rel)
222 pc += (CORE_ADDR) read_register (27);
223 else
224 pc += (CORE_ADDR) read_register (19);
225
226 /* fallthrough */
227 }
228
229 if (in_plt_section (pc, NULL))
230 {
231 pc = (CORE_ADDR) read_memory_integer (pc, TARGET_PTR_BIT / 8);
232
233 /* if the plt slot has not yet been resolved, the target will
234 be the plt stub */
235 if (in_plt_section (pc, NULL))
236 {
237 /* Sanity check: are we pointing to the plt stub? */
238 if (insns_match_pattern (pc, hppa_plt_stub, insn))
239 {
240 /* this should point to the fixup routine */
241 pc = (CORE_ADDR) read_memory_integer (pc + 8, TARGET_PTR_BIT / 8);
242 }
243 else
244 {
245 error ("Cannot resolve plt stub at 0x%s\n",
246 paddr_nz (pc));
247 pc = 0;
248 }
249 }
250 }
251
252 return pc;
253 }
254
255 /* Signal frames. */
256
257 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
258
259 Unfortunately, because of various bugs and changes to the kernel,
260 we have several cases to deal with.
261
262 In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
263 the beginning of the trampoline and struct rt_sigframe.
264
265 In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
266 the 4th word in the trampoline structure. This is wrong, it should point
267 at the 5th word. This is fixed in 2.6.5-rc2-pa4.
268
269 To detect these cases, we first take pc, align it to 64-bytes
270 to get the beginning of the signal frame, and then check offsets 0, 4
271 and 5 to see if we found the beginning of the trampoline. This will
272 tell us how to locate the sigcontext structure.
273
274 Note that with a 2.4 64-bit kernel, the signal context is not properly
275 passed back to userspace so the unwind will not work correctly. */
276 static CORE_ADDR
hppa_linux_sigtramp_find_sigcontext(CORE_ADDR pc)277 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
278 {
279 unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
280 int offs = 0;
281 int try;
282 /* offsets to try to find the trampoline */
283 static int pcoffs[] = { 0, 4*4, 5*4 };
284 /* offsets to the rt_sigframe structure */
285 static int sfoffs[] = { 4*4, 10*4, 10*4 };
286 CORE_ADDR sp;
287
288 /* Most of the time, this will be correct. The one case when this will
289 fail is if the user defined an alternate stack, in which case the
290 beginning of the stack will not be align_down (pc, 64). */
291 sp = align_down (pc, 64);
292
293 /* rt_sigreturn trampoline:
294 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2)
295 3414015a ldi __NR_rt_sigreturn, %r20
296 e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
297 08000240 nop */
298
299 for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
300 {
301 if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
302 {
303 offs = sfoffs[try];
304 break;
305 }
306 }
307
308 if (offs == 0)
309 {
310 if (insns_match_pattern (pc, hppa_sigtramp, dummy))
311 {
312 /* sigaltstack case: we have no way of knowing which offset to
313 use in this case; default to new kernel handling. If this is
314 wrong the unwinding will fail. */
315 try = 2;
316 sp = pc - pcoffs[try];
317 }
318 else
319 {
320 return 0;
321 }
322 }
323
324 /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
325 a struct siginfo and a struct ucontext. struct ucontext contains
326 a struct sigcontext. Return an offset to this sigcontext here. Too
327 bad we cannot include system specific headers :-(.
328 sizeof(struct siginfo) == 128
329 offsetof(struct ucontext, uc_mcontext) == 24. */
330 return sp + sfoffs[try] + 128 + 24;
331 }
332
333 struct hppa_linux_sigtramp_unwind_cache
334 {
335 CORE_ADDR base;
336 struct trad_frame_saved_reg *saved_regs;
337 };
338
339 static struct hppa_linux_sigtramp_unwind_cache *
hppa_linux_sigtramp_frame_unwind_cache(struct frame_info * next_frame,void ** this_cache)340 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
341 void **this_cache)
342 {
343 struct gdbarch *gdbarch = get_frame_arch (next_frame);
344 struct hppa_linux_sigtramp_unwind_cache *info;
345 CORE_ADDR pc, scptr;
346 int i;
347
348 if (*this_cache)
349 return *this_cache;
350
351 info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
352 *this_cache = info;
353 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
354
355 pc = frame_pc_unwind (next_frame);
356 scptr = hppa_linux_sigtramp_find_sigcontext (pc);
357
358 /* structure of struct sigcontext:
359
360 struct sigcontext {
361 unsigned long sc_flags;
362 unsigned long sc_gr[32];
363 unsigned long long sc_fr[32];
364 unsigned long sc_iasq[2];
365 unsigned long sc_iaoq[2];
366 unsigned long sc_sar; */
367
368 /* Skip sc_flags. */
369 scptr += 4;
370
371 /* GR[0] is the psw, we don't restore that. */
372 scptr += 4;
373
374 /* General registers. */
375 for (i = 1; i < 32; i++)
376 {
377 info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
378 scptr += 4;
379 }
380
381 /* Pad. */
382 scptr += 4;
383
384 /* FP regs; FP0-3 are not restored. */
385 scptr += (8 * 4);
386
387 for (i = 4; i < 32; i++)
388 {
389 info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
390 scptr += 4;
391 info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
392 scptr += 4;
393 }
394
395 /* IASQ/IAOQ. */
396 info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
397 scptr += 4;
398 info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
399 scptr += 4;
400
401 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
402 scptr += 4;
403 info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
404 scptr += 4;
405
406 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
407
408 return info;
409 }
410
411 static void
hppa_linux_sigtramp_frame_this_id(struct frame_info * next_frame,void ** this_prologue_cache,struct frame_id * this_id)412 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
413 void **this_prologue_cache,
414 struct frame_id *this_id)
415 {
416 struct hppa_linux_sigtramp_unwind_cache *info
417 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
418 *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
419 }
420
421 static void
hppa_linux_sigtramp_frame_prev_register(struct frame_info * next_frame,void ** this_prologue_cache,int regnum,int * optimizedp,enum lval_type * lvalp,CORE_ADDR * addrp,int * realnump,void * valuep)422 hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
423 void **this_prologue_cache,
424 int regnum, int *optimizedp,
425 enum lval_type *lvalp,
426 CORE_ADDR *addrp,
427 int *realnump, void *valuep)
428 {
429 struct hppa_linux_sigtramp_unwind_cache *info
430 = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
431 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
432 optimizedp, lvalp, addrp, realnump, valuep);
433 }
434
435 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
436 SIGTRAMP_FRAME,
437 hppa_linux_sigtramp_frame_this_id,
438 hppa_linux_sigtramp_frame_prev_register
439 };
440
441 /* hppa-linux always uses "new-style" rt-signals. The signal handler's return
442 address should point to a signal trampoline on the stack. The signal
443 trampoline is embedded in a rt_sigframe structure that is aligned on
444 the stack. We take advantage of the fact that sp must be 64-byte aligned,
445 and the trampoline is small, so by rounding down the trampoline address
446 we can find the beginning of the struct rt_sigframe. */
447 static const struct frame_unwind *
hppa_linux_sigtramp_unwind_sniffer(struct frame_info * next_frame)448 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
449 {
450 CORE_ADDR pc = frame_pc_unwind (next_frame);
451
452 if (hppa_linux_sigtramp_find_sigcontext (pc))
453 return &hppa_linux_sigtramp_frame_unwind;
454
455 return NULL;
456 }
457
458 /* Attempt to find (and return) the global pointer for the given
459 function.
460
461 This is a rather nasty bit of code searchs for the .dynamic section
462 in the objfile corresponding to the pc of the function we're trying
463 to call. Once it finds the addresses at which the .dynamic section
464 lives in the child process, it scans the Elf32_Dyn entries for a
465 DT_PLTGOT tag. If it finds one of these, the corresponding
466 d_un.d_ptr value is the global pointer. */
467
468 static CORE_ADDR
hppa_linux_find_global_pointer(struct value * function)469 hppa_linux_find_global_pointer (struct value *function)
470 {
471 struct obj_section *faddr_sect;
472 CORE_ADDR faddr;
473
474 faddr = value_as_address (function);
475
476 /* Is this a plabel? If so, dereference it to get the gp value. */
477 if (faddr & 2)
478 {
479 int status;
480 char buf[4];
481
482 faddr &= ~3;
483
484 status = target_read_memory (faddr + 4, buf, sizeof (buf));
485 if (status == 0)
486 return extract_unsigned_integer (buf, sizeof (buf));
487 }
488
489 /* If the address is in the plt section, then the real function hasn't
490 yet been fixed up by the linker so we cannot determine the gp of
491 that function. */
492 if (in_plt_section (faddr, NULL))
493 return 0;
494
495 faddr_sect = find_pc_section (faddr);
496 if (faddr_sect != NULL)
497 {
498 struct obj_section *osect;
499
500 ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
501 {
502 if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
503 break;
504 }
505
506 if (osect < faddr_sect->objfile->sections_end)
507 {
508 CORE_ADDR addr;
509
510 addr = osect->addr;
511 while (addr < osect->endaddr)
512 {
513 int status;
514 LONGEST tag;
515 char buf[4];
516
517 status = target_read_memory (addr, buf, sizeof (buf));
518 if (status != 0)
519 break;
520 tag = extract_signed_integer (buf, sizeof (buf));
521
522 if (tag == DT_PLTGOT)
523 {
524 CORE_ADDR global_pointer;
525
526 status = target_read_memory (addr + 4, buf, sizeof (buf));
527 if (status != 0)
528 break;
529 global_pointer = extract_unsigned_integer (buf, sizeof (buf));
530
531 /* The payoff... */
532 return global_pointer;
533 }
534
535 if (tag == DT_NULL)
536 break;
537
538 addr += 8;
539 }
540 }
541 }
542 return 0;
543 }
544
545 /* Forward declarations. */
546 extern initialize_file_ftype _initialize_hppa_linux_tdep;
547
548 static void
hppa_linux_init_abi(struct gdbarch_info info,struct gdbarch * gdbarch)549 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
550 {
551 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
552
553 /* GNU/Linux is always ELF. */
554 tdep->is_elf = 1;
555
556 tdep->find_global_pointer = hppa_linux_find_global_pointer;
557
558 set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
559
560 frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
561
562 /* GNU/Linux uses SVR4-style shared libraries. */
563 set_solib_svr4_fetch_link_map_offsets
564 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
565
566 set_gdbarch_in_solib_call_trampoline
567 (gdbarch, hppa_linux_in_solib_call_trampoline);
568 set_gdbarch_skip_trampoline_code
569 (gdbarch, hppa_linux_skip_trampoline_code);
570
571 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */
572 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
573
574 /* On hppa-linux, currently, sizeof(long double) == 8. There has been
575 some discussions to support 128-bit long double, but it requires some
576 more work in gcc and glibc first. */
577 set_gdbarch_long_double_bit (gdbarch, 64);
578
579 #if 0
580 /* Dwarf-2 unwinding support. Not yet working. */
581 set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
582 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
583 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
584 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
585 #endif
586 }
587
588 void
_initialize_hppa_linux_tdep(void)589 _initialize_hppa_linux_tdep (void)
590 {
591 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
592 }
593