gdb/hppa-linux-tdep.c

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