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       insn[i] = read_memory_unsigned_integer (npc, 4);
 150       if ((insn[i] & pattern[i].mask) == pattern[i].data)
 151         npc += 4;
 152       else
 153         return 0;
 154     }
 155   return 1;
 156 }
 157
 158 static int
 159 hppa_linux_in_dyncall (CORE_ADDR pc)
 160 {
 161   static CORE_ADDR dyncall = 0;
 162
 163   /* FIXME: if we switch exec files, dyncall should be reinitialized */
 164   if (!dyncall)
 165     {
 166       struct minimal_symbol *minsym;
 167
 168       minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
 169       if (minsym)
 170         dyncall = SYMBOL_VALUE_ADDRESS (minsym);
 171       else
 172         dyncall = -1;
 173     }
 174
 175   return pc == dyncall;
 176 }
 177
 178 /* There are several kinds of "trampolines" that we need to deal with:
 179    - long branch stubs: these are inserted by the linker when a branch
 180      target is too far away for a branch insn to reach
 181    - plt stubs: these should go into the .plt section, so are easy to find
 182    - import stubs: used to call from object to shared lib or shared lib to
 183      shared lib; these go in regular text sections.  In fact the linker tries
 184      to put them throughout the code because branches have limited reachability.
 185      We use the same mechanism as ppc64 to recognize the stub insn patterns.
 186    - $$dyncall: similar to hpux, hppa-linux uses $$dyncall for indirect function
 187      calls. $$dyncall is exported by libgcc.a  */
 188 static int
 189 hppa_linux_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 190 {
 191   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
 192   int r;
 193
 194   r = in_plt_section (pc, name)
 195       || hppa_linux_in_dyncall (pc)
 196       || insns_match_pattern (pc, hppa_import_stub, insn)
 197       || insns_match_pattern (pc, hppa_import_pic_stub, insn)
 198       || insns_match_pattern (pc, hppa_long_branch_stub, insn)
 199       || insns_match_pattern (pc, hppa_long_branch_pic_stub, insn);
 200
 201   return r;
 202 }
 203
 204 static CORE_ADDR
 205 hppa_linux_skip_trampoline_code (CORE_ADDR pc)
 206 {
 207   unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
 208   int dp_rel, pic_rel;
 209
 210   /* dyncall handles both PLABELs and direct addresses */
 211   if (hppa_linux_in_dyncall (pc))
 212     {
 213       pc = (CORE_ADDR) read_register (22);
 214
 215       /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */
 216       if (pc & 0x2)
 217         pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
 218
 219       return pc;
 220     }
 221
 222   dp_rel = pic_rel = 0;
 223   if ((dp_rel = insns_match_pattern (pc, hppa_import_stub, insn))
 224       || (pic_rel = insns_match_pattern (pc, hppa_import_pic_stub, insn)))
 225     {
 226       /* Extract the target address from the addil/ldw sequence.  */
 227       pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
 228
 229       if (dp_rel)
 230         pc += (CORE_ADDR) read_register (27);
 231       else
 232         pc += (CORE_ADDR) read_register (19);
 233
 234       /* fallthrough */
 235     }
 236
 237   if (in_plt_section (pc, NULL))
 238     {
 239       pc = (CORE_ADDR) read_memory_integer (pc, TARGET_PTR_BIT / 8);
 240
 241       /* if the plt slot has not yet been resolved, the target will
 242          be the plt stub */
 243       if (in_plt_section (pc, NULL))
 244         {
 245           /* Sanity check: are we pointing to the plt stub? */
 246           if (insns_match_pattern (pc, hppa_plt_stub, insn))
 247             {
 248               /* this should point to the fixup routine */
 249               pc = (CORE_ADDR) read_memory_integer (pc + 8, TARGET_PTR_BIT / 8);
 250             }
 251           else
 252             {
 253               error ("Cannot resolve plt stub at 0x%s\n",
 254                      paddr_nz (pc));
 255               pc = 0;
 256             }
 257         }
 258     }
 259
 260   return pc;
 261 }
 262
 263 /* Signal frames.  */
 264
 265 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
 266
 267    Unfortunately, because of various bugs and changes to the kernel,
 268    we have several cases to deal with.
 269
 270    In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
 271    the beginning of the trampoline and struct rt_sigframe.
 272
 273    In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
 274    the 4th word in the trampoline structure.  This is wrong, it should point
 275    at the 5th word.  This is fixed in 2.6.5-rc2-pa4.
 276
 277    To detect these cases, we first take pc, align it to 64-bytes
 278    to get the beginning of the signal frame, and then check offsets 0, 4
 279    and 5 to see if we found the beginning of the trampoline.  This will
 280    tell us how to locate the sigcontext structure.
 281
 282    Note that with a 2.4 64-bit kernel, the signal context is not properly
 283    passed back to userspace so the unwind will not work correctly.  */
 284 static CORE_ADDR
 285 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR sp)
 286 {
 287   unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
 288   int offs = 0;
 289   int try;
 290   /* offsets to try to find the trampoline */
 291   static int pcoffs[] = { 0, 4*4, 5*4 };
 292   /* offsets to the rt_sigframe structure */
 293   static int sfoffs[] = { 4*4, 10*4, 10*4 };
 294
 295   /* rt_sigreturn trampoline:
 296      3419000x ldi 0, %r25 or ldi 1, %r25   (x = 0 or 2)
 297      3414015a ldi __NR_rt_sigreturn, %r20
 298      e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
 299      08000240 nop  */
 300
 301   for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
 302     {
 303       if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
 304         {
 305           offs = sfoffs[try];
 306           break;
 307         }
 308     }
 309
 310   if (offs == 0)
 311     return 0;
 312
 313   /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
 314      a struct siginfo and a struct ucontext.  struct ucontext contains
 315      a struct sigcontext. Return an offset to this sigcontext here.  Too
 316      bad we cannot include system specific headers :-(.
 317      sizeof(struct siginfo) == 128
 318      offsetof(struct ucontext, uc_mcontext) == 24.  */
 319   return sp + sfoffs[try] + 128 + 24;
 320 }
 321
 322 struct hppa_linux_sigtramp_unwind_cache
 323 {
 324   CORE_ADDR base;
 325   struct trad_frame_saved_reg *saved_regs;
 326 };
 327
 328 static struct hppa_linux_sigtramp_unwind_cache *
 329 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
 330                                         void **this_cache)
 331 {
 332   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 333   struct hppa_linux_sigtramp_unwind_cache *info;
 334   CORE_ADDR sp, pc, scptr;
 335   int i;
 336
 337   if (*this_cache)
 338     return *this_cache;
 339
 340   info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
 341   *this_cache = info;
 342   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 343
 344   pc = frame_pc_unwind (next_frame);
 345   sp = (pc & ~63);
 346   scptr = hppa_linux_sigtramp_find_sigcontext (sp);
 347
 348   /* structure of struct sigcontext:
 349
 350      struct sigcontext {
 351         unsigned long sc_flags;
 352         unsigned long sc_gr[32];
 353         unsigned long long sc_fr[32];
 354         unsigned long sc_iasq[2];
 355         unsigned long sc_iaoq[2];
 356         unsigned long sc_sar;           */
 357
 358   /* Skip sc_flags.  */
 359   scptr += 4;
 360
 361   /* GR[0] is the psw, we don't restore that.  */
 362   scptr += 4;
 363
 364   /* General registers.  */
 365   for (i = 1; i < 32; i++)
 366     {
 367       info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
 368       scptr += 4;
 369     }
 370
 371   /* Pad.  */
 372   scptr += 4;
 373
 374   /* FP regs; FP0-3 are not restored.  */
 375   scptr += (8 * 4);
 376
 377   for (i = 4; i < 32; i++)
 378     {
 379       info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
 380       scptr += 4;
 381       info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
 382       scptr += 4;
 383     }
 384
 385   /* IASQ/IAOQ. */
 386   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
 387   scptr += 4;
 388   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
 389   scptr += 4;
 390
 391   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
 392   scptr += 4;
 393   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
 394   scptr += 4;
 395
 396   info->base = read_memory_unsigned_integer (
 397                   info->saved_regs[HPPA_SP_REGNUM].addr, 4);
 398
 399   return info;
 400 }
 401
 402 static void
 403 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
 404                                    void **this_prologue_cache,
 405                                    struct frame_id *this_id)
 406 {
 407   struct hppa_linux_sigtramp_unwind_cache *info
 408     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 409   *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
 410 }
 411
 412 static void
 413 hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
 414                                          void **this_prologue_cache,
 415                                          int regnum, int *optimizedp,
 416                                          enum lval_type *lvalp,
 417                                          CORE_ADDR *addrp,
 418                                          int *realnump, void *bufferp)
 419 {
 420   struct hppa_linux_sigtramp_unwind_cache *info
 421     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 422   int pcoqt = (regnum == HPPA_PCOQ_TAIL_REGNUM);
 423
 424   if (pcoqt)
 425     regnum = HPPA_PCOQ_HEAD_REGNUM;
 426
 427   trad_frame_prev_register (next_frame, info->saved_regs, regnum,
 428                             optimizedp, lvalp, addrp, realnump, bufferp);
 429
 430   if (pcoqt)
 431     store_unsigned_integer (bufferp, 4,
 432                             extract_unsigned_integer (bufferp, 4) + 4);
 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 *
 448 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
 449 {
 450   CORE_ADDR pc = frame_pc_unwind (next_frame);
 451   CORE_ADDR sp = (pc & ~63);
 452
 453   if (hppa_linux_sigtramp_find_sigcontext (sp))
 454     return &hppa_linux_sigtramp_frame_unwind;
 455
 456   return NULL;
 457 }
 458
 459 /* Forward declarations.  */
 460 extern initialize_file_ftype _initialize_hppa_linux_tdep;
 461
 462 static void
 463 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 464 {
 465   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 466
 467   /* Linux is always ELF.  */
 468   tdep->is_elf = 1;
 469
 470   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
 471
 472   frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
 473
 474   /* GNU/Linux uses SVR4-style shared libraries.  */
 475   set_solib_svr4_fetch_link_map_offsets
 476     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 477
 478   set_gdbarch_in_solib_call_trampoline
 479         (gdbarch, hppa_linux_in_solib_call_trampoline);
 480   set_gdbarch_skip_trampoline_code
 481         (gdbarch, hppa_linux_skip_trampoline_code);
 482
 483   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 484   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 485
 486 #if 0
 487   /* Dwarf-2 unwinding support.  Not yet working.  */
 488   set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 489   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 490   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 491   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
 492 #endif
 493 }
 494
 495 void
 496 _initialize_hppa_linux_tdep (void)
 497 {
 498   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
 499 }