gdb/hppa-linux-tdep.c

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