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