Automatic date update in version.in
[external/binutils.git] / gdb / hppa-linux-tdep.c
1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
2
3    Copyright (C) 2004-2018 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 3 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, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "gdbcore.h"
22 #include "osabi.h"
23 #include "target.h"
24 #include "objfiles.h"
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"
30 #include "value.h"
31 #include "regset.h"
32 #include "regcache.h"
33 #include "hppa-tdep.h"
34 #include "linux-tdep.h"
35 #include "elf/common.h"
36
37 /* Map DWARF DBX register numbers to GDB register numbers.  */
38 static int
39 hppa_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
40 {
41   /* The general registers and the sar are the same in both sets.  */
42   if (reg >= 0 && reg <= 32)
43     return reg;
44
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);
48
49   return -1;
50 }
51
52 static void
53 hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v)
54 {
55   /* Probably this should be done by the kernel, but it isn't.  */
56   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3);
57   regcache_cooked_write_unsigned (regcache,
58                                   HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3);
59 }
60
61 /* An instruction to match.  */
62 struct insn_pattern
63 {
64   unsigned int data;            /* See if it matches this....  */
65   unsigned int mask;            /* ... with this mask.  */
66 };
67
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 },
75   /* nop */
76   { 0x08000240, 0xffffffff },
77   { 0, 0 }
78 };
79
80 #define HPPA_MAX_INSN_PATTERN_LEN (4)
81
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
85    zero.
86
87    When the match is successful, fill INSN[i] with what PATTERN[i]
88    matched.  */
89 static int
90 insns_match_pattern (struct gdbarch *gdbarch, CORE_ADDR pc,
91                      struct insn_pattern *pattern,
92                      unsigned int *insn)
93 {
94   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
95   int i;
96   CORE_ADDR npc = pc;
97
98   for (i = 0; pattern[i].mask; i++)
99     {
100       gdb_byte buf[4];
101
102       target_read_memory (npc, buf, 4);
103       insn[i] = extract_unsigned_integer (buf, 4, byte_order);
104       if ((insn[i] & pattern[i].mask) == pattern[i].data)
105         npc += 4;
106       else
107         return 0;
108     }
109   return 1;
110 }
111
112 /* Signal frames.  */
113
114 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
115  
116    Unfortunately, because of various bugs and changes to the kernel,
117    we have several cases to deal with.
118
119    In 2.4, the signal trampoline is 4 bytes, and pc should point directly at 
120    the beginning of the trampoline and struct rt_sigframe.
121
122    In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
123    the 4th word in the trampoline structure.  This is wrong, it should point 
124    at the 5th word.  This is fixed in 2.6.5-rc2-pa4.
125
126    To detect these cases, we first take pc, align it to 64-bytes
127    to get the beginning of the signal frame, and then check offsets 0, 4
128    and 5 to see if we found the beginning of the trampoline.  This will
129    tell us how to locate the sigcontext structure.
130
131    Note that with a 2.4 64-bit kernel, the signal context is not properly
132    passed back to userspace so the unwind will not work correctly.  */
133 static CORE_ADDR
134 hppa_linux_sigtramp_find_sigcontext (struct gdbarch *gdbarch, CORE_ADDR pc)
135 {
136   unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
137   int offs = 0;
138   int attempt;
139   /* offsets to try to find the trampoline */
140   static int pcoffs[] = { 0, 4*4, 5*4 };
141   /* offsets to the rt_sigframe structure */
142   static int sfoffs[] = { 4*4, 10*4, 10*4 };
143   CORE_ADDR sp;
144
145   /* Most of the time, this will be correct.  The one case when this will
146      fail is if the user defined an alternate stack, in which case the
147      beginning of the stack will not be align_down (pc, 64).  */
148   sp = align_down (pc, 64);
149
150   /* rt_sigreturn trampoline:
151      3419000x ldi 0, %r25 or ldi 1, %r25   (x = 0 or 2)
152      3414015a ldi __NR_rt_sigreturn, %r20 
153      e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
154      08000240 nop  */
155
156   for (attempt = 0; attempt < ARRAY_SIZE (pcoffs); attempt++)
157     {
158       if (insns_match_pattern (gdbarch, sp + pcoffs[attempt],
159                                hppa_sigtramp, dummy))
160         {
161           offs = sfoffs[attempt];
162           break;
163         }
164     }
165
166   if (offs == 0)
167     {
168       if (insns_match_pattern (gdbarch, pc, hppa_sigtramp, dummy))
169         {
170           /* sigaltstack case: we have no way of knowing which offset to 
171              use in this case; default to new kernel handling.  If this is
172              wrong the unwinding will fail.  */
173           attempt = 2;
174           sp = pc - pcoffs[attempt];
175         }
176       else
177       {
178         return 0;
179       }
180     }
181
182   /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
183      a struct siginfo and a struct ucontext.  struct ucontext contains
184      a struct sigcontext.  Return an offset to this sigcontext here.  Too 
185      bad we cannot include system specific headers :-(.
186      sizeof(struct siginfo) == 128
187      offsetof(struct ucontext, uc_mcontext) == 24.  */
188   return sp + sfoffs[attempt] + 128 + 24;
189 }
190
191 struct hppa_linux_sigtramp_unwind_cache
192 {
193   CORE_ADDR base;
194   struct trad_frame_saved_reg *saved_regs;
195 };
196
197 static struct hppa_linux_sigtramp_unwind_cache *
198 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
199                                         void **this_cache)
200 {
201   struct gdbarch *gdbarch = get_frame_arch (this_frame);
202   struct hppa_linux_sigtramp_unwind_cache *info;
203   CORE_ADDR pc, scptr;
204   int i;
205
206   if (*this_cache)
207     return (struct hppa_linux_sigtramp_unwind_cache *) *this_cache;
208
209   info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
210   *this_cache = info;
211   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
212
213   pc = get_frame_pc (this_frame);
214   scptr = hppa_linux_sigtramp_find_sigcontext (gdbarch, pc);
215
216   /* structure of struct sigcontext:
217    
218      struct sigcontext {
219         unsigned long sc_flags;
220         unsigned long sc_gr[32]; 
221         unsigned long long sc_fr[32];
222         unsigned long sc_iasq[2];
223         unsigned long sc_iaoq[2];
224         unsigned long sc_sar;           */
225
226   /* Skip sc_flags.  */
227   scptr += 4;
228
229   /* GR[0] is the psw.  */
230   info->saved_regs[HPPA_IPSW_REGNUM].addr = scptr;
231   scptr += 4;
232
233   /* General registers.  */
234   for (i = 1; i < 32; i++)
235     {
236       info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
237       scptr += 4;
238     }
239
240   /* Pad to long long boundary.  */
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.  */
255   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
256   scptr += 4;
257   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
258   scptr += 4;
259
260   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
261   scptr += 4;
262   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
263   scptr += 4;
264
265   info->saved_regs[HPPA_SAR_REGNUM].addr = scptr;
266
267   info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
268
269   return info;
270 }
271
272 static void
273 hppa_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
274                                    void **this_prologue_cache,
275                                    struct frame_id *this_id)
276 {
277   struct hppa_linux_sigtramp_unwind_cache *info
278     = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
279   *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
280 }
281
282 static struct value *
283 hppa_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
284                                          void **this_prologue_cache,
285                                          int regnum)
286 {
287   struct hppa_linux_sigtramp_unwind_cache *info
288     = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
289   return hppa_frame_prev_register_helper (this_frame,
290                                           info->saved_regs, regnum);
291 }
292
293 /* hppa-linux always uses "new-style" rt-signals.  The signal handler's return
294    address should point to a signal trampoline on the stack.  The signal
295    trampoline is embedded in a rt_sigframe structure that is aligned on
296    the stack.  We take advantage of the fact that sp must be 64-byte aligned,
297    and the trampoline is small, so by rounding down the trampoline address
298    we can find the beginning of the struct rt_sigframe.  */
299 static int
300 hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
301                                    struct frame_info *this_frame,
302                                    void **this_prologue_cache)
303 {
304   struct gdbarch *gdbarch = get_frame_arch (this_frame);
305   CORE_ADDR pc = get_frame_pc (this_frame);
306
307   if (hppa_linux_sigtramp_find_sigcontext (gdbarch, pc))
308     return 1;
309
310   return 0;
311 }
312
313 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
314   SIGTRAMP_FRAME,
315   default_frame_unwind_stop_reason,
316   hppa_linux_sigtramp_frame_this_id,
317   hppa_linux_sigtramp_frame_prev_register,
318   NULL,
319   hppa_linux_sigtramp_frame_sniffer
320 };
321
322 /* Attempt to find (and return) the global pointer for the given
323    function.
324
325    This is a rather nasty bit of code searchs for the .dynamic section
326    in the objfile corresponding to the pc of the function we're trying
327    to call.  Once it finds the addresses at which the .dynamic section
328    lives in the child process, it scans the Elf32_Dyn entries for a
329    DT_PLTGOT tag.  If it finds one of these, the corresponding
330    d_un.d_ptr value is the global pointer.  */
331
332 static CORE_ADDR
333 hppa_linux_find_global_pointer (struct gdbarch *gdbarch,
334                                 struct value *function)
335 {
336   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
337   struct obj_section *faddr_sect;
338   CORE_ADDR faddr;
339   
340   faddr = value_as_address (function);
341
342   /* Is this a plabel? If so, dereference it to get the gp value.  */
343   if (faddr & 2)
344     {
345       int status;
346       gdb_byte buf[4];
347
348       faddr &= ~3;
349
350       status = target_read_memory (faddr + 4, buf, sizeof (buf));
351       if (status == 0)
352         return extract_unsigned_integer (buf, sizeof (buf), byte_order);
353     }
354
355   /* If the address is in the plt section, then the real function hasn't 
356      yet been fixed up by the linker so we cannot determine the gp of 
357      that function.  */
358   if (in_plt_section (faddr))
359     return 0;
360
361   faddr_sect = find_pc_section (faddr);
362   if (faddr_sect != NULL)
363     {
364       struct obj_section *osect;
365
366       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
367         {
368           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
369             break;
370         }
371
372       if (osect < faddr_sect->objfile->sections_end)
373         {
374           CORE_ADDR addr, endaddr;
375
376           addr = obj_section_addr (osect);
377           endaddr = obj_section_endaddr (osect);
378
379           while (addr < endaddr)
380             {
381               int status;
382               LONGEST tag;
383               gdb_byte buf[4];
384
385               status = target_read_memory (addr, buf, sizeof (buf));
386               if (status != 0)
387                 break;
388               tag = extract_signed_integer (buf, sizeof (buf), byte_order);
389
390               if (tag == DT_PLTGOT)
391                 {
392                   CORE_ADDR global_pointer;
393
394                   status = target_read_memory (addr + 4, buf, sizeof (buf));
395                   if (status != 0)
396                     break;
397                   global_pointer = extract_unsigned_integer (buf, sizeof (buf),
398                                                              byte_order);
399                   /* The payoff...  */
400                   return global_pointer;
401                 }
402
403               if (tag == DT_NULL)
404                 break;
405
406               addr += 8;
407             }
408         }
409     }
410   return 0;
411 }
412 \f
413 /*
414  * Registers saved in a coredump:
415  * gr0..gr31
416  * sr0..sr7
417  * iaoq0..iaoq1
418  * iasq0..iasq1
419  * sar, iir, isr, ior, ipsw
420  * cr0, cr24..cr31
421  * cr8,9,12,13
422  * cr10, cr15
423  */
424
425 static const struct regcache_map_entry hppa_linux_gregmap[] =
426   {
427     { 32, HPPA_R0_REGNUM },
428     { 1, HPPA_SR4_REGNUM+1 },
429     { 1, HPPA_SR4_REGNUM+2 },
430     { 1, HPPA_SR4_REGNUM+3 },
431     { 1, HPPA_SR4_REGNUM+4 },
432     { 1, HPPA_SR4_REGNUM },
433     { 1, HPPA_SR4_REGNUM+5 },
434     { 1, HPPA_SR4_REGNUM+6 },
435     { 1, HPPA_SR4_REGNUM+7 },
436     { 1, HPPA_PCOQ_HEAD_REGNUM },
437     { 1, HPPA_PCOQ_TAIL_REGNUM },
438     { 1, HPPA_PCSQ_HEAD_REGNUM },
439     { 1, HPPA_PCSQ_TAIL_REGNUM },
440     { 1, HPPA_SAR_REGNUM },
441     { 1, HPPA_IIR_REGNUM },
442     { 1, HPPA_ISR_REGNUM },
443     { 1, HPPA_IOR_REGNUM },
444     { 1, HPPA_IPSW_REGNUM },
445     { 1, HPPA_RCR_REGNUM },
446     { 8, HPPA_TR0_REGNUM },
447     { 4, HPPA_PID0_REGNUM },
448     { 1, HPPA_CCR_REGNUM },
449     { 1, HPPA_EIEM_REGNUM },
450     { 0 }
451   };
452
453 static const struct regcache_map_entry hppa_linux_fpregmap[] =
454   {
455     /* FIXME: Only works for 32-bit mode.  In 64-bit mode there should
456        be 32 fpregs, 8 bytes each.  */
457     { 64, HPPA_FP0_REGNUM, 4 },
458     { 0 }
459   };
460
461 /* HPPA Linux kernel register set.  */
462 static const struct regset hppa_linux_regset =
463 {
464   hppa_linux_gregmap,
465   regcache_supply_regset, regcache_collect_regset
466 };
467
468 static const struct regset hppa_linux_fpregset =
469 {
470   hppa_linux_fpregmap,
471   regcache_supply_regset, regcache_collect_regset
472 };
473
474 static void
475 hppa_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
476                                          iterate_over_regset_sections_cb *cb,
477                                          void *cb_data,
478                                          const struct regcache *regcache)
479 {
480   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
481
482   cb (".reg", 80 * tdep->bytes_per_address, 80 * tdep->bytes_per_address,
483       &hppa_linux_regset, NULL, cb_data);
484   cb (".reg2", 64 * 4, 64 * 4, &hppa_linux_fpregset, NULL, cb_data);
485 }
486
487 static void
488 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
489 {
490   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
491
492   linux_init_abi (info, gdbarch);
493
494   /* GNU/Linux is always ELF.  */
495   tdep->is_elf = 1;
496
497   tdep->find_global_pointer = hppa_linux_find_global_pointer;
498
499   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
500
501   frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind);
502
503   /* GNU/Linux uses SVR4-style shared libraries.  */
504   set_solib_svr4_fetch_link_map_offsets
505     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
506
507   tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
508   set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
509
510   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
511   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
512
513   /* On hppa-linux, currently, sizeof(long double) == 8.  There has been
514      some discussions to support 128-bit long double, but it requires some
515      more work in gcc and glibc first.  */
516   set_gdbarch_long_double_bit (gdbarch, 64);
517   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
518
519   set_gdbarch_iterate_over_regset_sections
520     (gdbarch, hppa_linux_iterate_over_regset_sections);
521
522   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
523
524   /* Enable TLS support.  */
525   set_gdbarch_fetch_tls_load_module_address (gdbarch,
526                                              svr4_fetch_objfile_link_map);
527 }
528
529 void
530 _initialize_hppa_linux_tdep (void)
531 {
532   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX,
533                           hppa_linux_init_abi);
534   gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w,
535                           GDB_OSABI_LINUX, hppa_linux_init_abi);
536 }