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 pc)
 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   CORE_ADDR sp;
 295
 296   /* Most of the time, this will be correct.  The one case when this will
 297      fail is if the user defined an alternate stack, in which case the
 298      beginning of the stack will not be align_down (pc, 64).  */
 299   sp = align_down (pc, 64);
 300
 301   /* rt_sigreturn trampoline:
 302      3419000x ldi 0, %r25 or ldi 1, %r25   (x = 0 or 2)
 303      3414015a ldi __NR_rt_sigreturn, %r20
 304      e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
 305      08000240 nop  */
 306
 307   for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
 308     {
 309       if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
 310         {
 311           offs = sfoffs[try];
 312           break;
 313         }
 314     }
 315
 316   if (offs == 0)
 317     {
 318       if (insns_match_pattern (pc, hppa_sigtramp, dummy))
 319         {
 320           /* sigaltstack case: we have no way of knowing which offset to
 321              use in this case; default to new kernel handling. If this is
 322              wrong the unwinding will fail.  */
 323           try = 2;
 324           sp = pc - pcoffs[try];
 325         }
 326       else
 327       {
 328         return 0;
 329       }
 330     }
 331
 332   /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
 333      a struct siginfo and a struct ucontext.  struct ucontext contains
 334      a struct sigcontext. Return an offset to this sigcontext here.  Too
 335      bad we cannot include system specific headers :-(.
 336      sizeof(struct siginfo) == 128
 337      offsetof(struct ucontext, uc_mcontext) == 24.  */
 338   return sp + sfoffs[try] + 128 + 24;
 339 }
 340
 341 struct hppa_linux_sigtramp_unwind_cache
 342 {
 343   CORE_ADDR base;
 344   struct trad_frame_saved_reg *saved_regs;
 345 };
 346
 347 static struct hppa_linux_sigtramp_unwind_cache *
 348 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
 349                                         void **this_cache)
 350 {
 351   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 352   struct hppa_linux_sigtramp_unwind_cache *info;
 353   CORE_ADDR pc, scptr;
 354   int i;
 355
 356   if (*this_cache)
 357     return *this_cache;
 358
 359   info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
 360   *this_cache = info;
 361   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 362
 363   pc = frame_pc_unwind (next_frame);
 364   scptr = hppa_linux_sigtramp_find_sigcontext (pc);
 365
 366   /* structure of struct sigcontext:
 367
 368      struct sigcontext {
 369         unsigned long sc_flags;
 370         unsigned long sc_gr[32];
 371         unsigned long long sc_fr[32];
 372         unsigned long sc_iasq[2];
 373         unsigned long sc_iaoq[2];
 374         unsigned long sc_sar;           */
 375
 376   /* Skip sc_flags.  */
 377   scptr += 4;
 378
 379   /* GR[0] is the psw, we don't restore that.  */
 380   scptr += 4;
 381
 382   /* General registers.  */
 383   for (i = 1; i < 32; i++)
 384     {
 385       info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
 386       scptr += 4;
 387     }
 388
 389   /* Pad.  */
 390   scptr += 4;
 391
 392   /* FP regs; FP0-3 are not restored.  */
 393   scptr += (8 * 4);
 394
 395   for (i = 4; i < 32; i++)
 396     {
 397       info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
 398       scptr += 4;
 399       info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
 400       scptr += 4;
 401     }
 402
 403   /* IASQ/IAOQ. */
 404   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
 405   scptr += 4;
 406   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
 407   scptr += 4;
 408
 409   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
 410   scptr += 4;
 411   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
 412   scptr += 4;
 413
 414   info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
 415
 416   return info;
 417 }
 418
 419 static void
 420 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
 421                                    void **this_prologue_cache,
 422                                    struct frame_id *this_id)
 423 {
 424   struct hppa_linux_sigtramp_unwind_cache *info
 425     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 426   *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
 427 }
 428
 429 static void
 430 hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
 431                                          void **this_prologue_cache,
 432                                          int regnum, int *optimizedp,
 433                                          enum lval_type *lvalp,
 434                                          CORE_ADDR *addrp,
 435                                          int *realnump, void *valuep)
 436 {
 437   struct hppa_linux_sigtramp_unwind_cache *info
 438     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 439   hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
 440                                    optimizedp, lvalp, addrp, realnump, valuep);
 441 }
 442
 443 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
 444   SIGTRAMP_FRAME,
 445   hppa_linux_sigtramp_frame_this_id,
 446   hppa_linux_sigtramp_frame_prev_register
 447 };
 448
 449 /* hppa-linux always uses "new-style" rt-signals.  The signal handler's return
 450    address should point to a signal trampoline on the stack.  The signal
 451    trampoline is embedded in a rt_sigframe structure that is aligned on
 452    the stack.  We take advantage of the fact that sp must be 64-byte aligned,
 453    and the trampoline is small, so by rounding down the trampoline address
 454    we can find the beginning of the struct rt_sigframe.  */
 455 static const struct frame_unwind *
 456 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
 457 {
 458   CORE_ADDR pc = frame_pc_unwind (next_frame);
 459
 460   if (hppa_linux_sigtramp_find_sigcontext (pc))
 461     return &hppa_linux_sigtramp_frame_unwind;
 462
 463   return NULL;
 464 }
 465
 466 /* Forward declarations.  */
 467 extern initialize_file_ftype _initialize_hppa_linux_tdep;
 468
 469 static void
 470 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 471 {
 472   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 473
 474   /* Linux is always ELF.  */
 475   tdep->is_elf = 1;
 476
 477   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
 478
 479   frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
 480
 481   /* GNU/Linux uses SVR4-style shared libraries.  */
 482   set_solib_svr4_fetch_link_map_offsets
 483     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 484
 485   set_gdbarch_in_solib_call_trampoline
 486         (gdbarch, hppa_linux_in_solib_call_trampoline);
 487   set_gdbarch_skip_trampoline_code
 488         (gdbarch, hppa_linux_skip_trampoline_code);
 489
 490   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 491   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 492
 493 #if 0
 494   /* Dwarf-2 unwinding support.  Not yet working.  */
 495   set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 496   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 497   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 498   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
 499 #endif
 500 }
 501
 502 void
 503 _initialize_hppa_linux_tdep (void)
 504 {
 505   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
 506 }