gdb/hppa-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
   2
   3    Copyright (C) 2004, 2006, 2007 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., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdbcore.h"
  24 #include "osabi.h"
  25 #include "target.h"
  26 #include "objfiles.h"
  27 #include "solib-svr4.h"
  28 #include "glibc-tdep.h"
  29 #include "frame-unwind.h"
  30 #include "trad-frame.h"
  31 #include "dwarf2-frame.h"
  32 #include "value.h"
  33 #include "regset.h"
  34 #include "regcache.h"
  35 #include "hppa-tdep.h"
  36
  37 #include "elf/common.h"
  38
  39 #if 0
  40 /* Convert DWARF register number REG to the appropriate register
  41    number used by GDB.  */
  42 static int
  43 hppa_dwarf_reg_to_regnum (int reg)
  44 {
  45   /* registers 0 - 31 are the same in both sets */
  46   if (reg < 32)
  47     return reg;
  48
  49   /* dwarf regs 32 to 85 are fpregs 4 - 31 */
  50   if (reg >= 32 && reg <= 85)
  51     return HPPA_FP4_REGNUM + (reg - 32);
  52
  53   warning (_("Unmapped DWARF Register #%d encountered."), reg);
  54   return -1;
  55 }
  56 #endif
  57
  58 static void
  59 hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid)
  60 {
  61   /* Probably this should be done by the kernel, but it isn't.  */
  62   write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid);
  63   write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid);
  64 }
  65
  66 /* An instruction to match.  */
  67 struct insn_pattern
  68 {
  69   unsigned int data;            /* See if it matches this....  */
  70   unsigned int mask;            /* ... with this mask.  */
  71 };
  72
  73 static struct insn_pattern hppa_sigtramp[] = {
  74   /* ldi 0, %r25 or ldi 1, %r25 */
  75   { 0x34190000, 0xfffffffd },
  76   /* ldi __NR_rt_sigreturn, %r20 */
  77   { 0x3414015a, 0xffffffff },
  78   /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
  79   { 0xe4008200, 0xffffffff },
  80   /* nop */
  81   { 0x08000240, 0xffffffff },
  82   { 0, 0 }
  83 };
  84
  85 #define HPPA_MAX_INSN_PATTERN_LEN (4)
  86
  87 /* Return non-zero if the instructions at PC match the series
  88    described in PATTERN, or zero otherwise.  PATTERN is an array of
  89    'struct insn_pattern' objects, terminated by an entry whose mask is
  90    zero.
  91
  92    When the match is successful, fill INSN[i] with what PATTERN[i]
  93    matched.  */
  94 static int
  95 insns_match_pattern (CORE_ADDR pc,
  96                      struct insn_pattern *pattern,
  97                      unsigned int *insn)
  98 {
  99   int i;
 100   CORE_ADDR npc = pc;
 101
 102   for (i = 0; pattern[i].mask; i++)
 103     {
 104       char buf[4];
 105
 106       read_memory_nobpt (npc, buf, 4);
 107       insn[i] = extract_unsigned_integer (buf, 4);
 108       if ((insn[i] & pattern[i].mask) == pattern[i].data)
 109         npc += 4;
 110       else
 111         return 0;
 112     }
 113   return 1;
 114 }
 115
 116 /* Signal frames.  */
 117
 118 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
 119
 120    Unfortunately, because of various bugs and changes to the kernel,
 121    we have several cases to deal with.
 122
 123    In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
 124    the beginning of the trampoline and struct rt_sigframe.
 125
 126    In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
 127    the 4th word in the trampoline structure.  This is wrong, it should point
 128    at the 5th word.  This is fixed in 2.6.5-rc2-pa4.
 129
 130    To detect these cases, we first take pc, align it to 64-bytes
 131    to get the beginning of the signal frame, and then check offsets 0, 4
 132    and 5 to see if we found the beginning of the trampoline.  This will
 133    tell us how to locate the sigcontext structure.
 134
 135    Note that with a 2.4 64-bit kernel, the signal context is not properly
 136    passed back to userspace so the unwind will not work correctly.  */
 137 static CORE_ADDR
 138 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
 139 {
 140   unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
 141   int offs = 0;
 142   int try;
 143   /* offsets to try to find the trampoline */
 144   static int pcoffs[] = { 0, 4*4, 5*4 };
 145   /* offsets to the rt_sigframe structure */
 146   static int sfoffs[] = { 4*4, 10*4, 10*4 };
 147   CORE_ADDR sp;
 148
 149   /* Most of the time, this will be correct.  The one case when this will
 150      fail is if the user defined an alternate stack, in which case the
 151      beginning of the stack will not be align_down (pc, 64).  */
 152   sp = align_down (pc, 64);
 153
 154   /* rt_sigreturn trampoline:
 155      3419000x ldi 0, %r25 or ldi 1, %r25   (x = 0 or 2)
 156      3414015a ldi __NR_rt_sigreturn, %r20
 157      e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
 158      08000240 nop  */
 159
 160   for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
 161     {
 162       if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
 163         {
 164           offs = sfoffs[try];
 165           break;
 166         }
 167     }
 168
 169   if (offs == 0)
 170     {
 171       if (insns_match_pattern (pc, hppa_sigtramp, dummy))
 172         {
 173           /* sigaltstack case: we have no way of knowing which offset to
 174              use in this case; default to new kernel handling. If this is
 175              wrong the unwinding will fail.  */
 176           try = 2;
 177           sp = pc - pcoffs[try];
 178         }
 179       else
 180       {
 181         return 0;
 182       }
 183     }
 184
 185   /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
 186      a struct siginfo and a struct ucontext.  struct ucontext contains
 187      a struct sigcontext. Return an offset to this sigcontext here.  Too
 188      bad we cannot include system specific headers :-(.
 189      sizeof(struct siginfo) == 128
 190      offsetof(struct ucontext, uc_mcontext) == 24.  */
 191   return sp + sfoffs[try] + 128 + 24;
 192 }
 193
 194 struct hppa_linux_sigtramp_unwind_cache
 195 {
 196   CORE_ADDR base;
 197   struct trad_frame_saved_reg *saved_regs;
 198 };
 199
 200 static struct hppa_linux_sigtramp_unwind_cache *
 201 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
 202                                         void **this_cache)
 203 {
 204   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 205   struct hppa_linux_sigtramp_unwind_cache *info;
 206   CORE_ADDR pc, scptr;
 207   int i;
 208
 209   if (*this_cache)
 210     return *this_cache;
 211
 212   info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
 213   *this_cache = info;
 214   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 215
 216   pc = frame_pc_unwind (next_frame);
 217   scptr = hppa_linux_sigtramp_find_sigcontext (pc);
 218
 219   /* structure of struct sigcontext:
 220
 221      struct sigcontext {
 222         unsigned long sc_flags;
 223         unsigned long sc_gr[32];
 224         unsigned long long sc_fr[32];
 225         unsigned long sc_iasq[2];
 226         unsigned long sc_iaoq[2];
 227         unsigned long sc_sar;           */
 228
 229   /* Skip sc_flags.  */
 230   scptr += 4;
 231
 232   /* GR[0] is the psw, we don't restore that.  */
 233   scptr += 4;
 234
 235   /* General registers.  */
 236   for (i = 1; i < 32; i++)
 237     {
 238       info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
 239       scptr += 4;
 240     }
 241
 242   /* Pad.  */
 243   scptr += 4;
 244
 245   /* FP regs; FP0-3 are not restored.  */
 246   scptr += (8 * 4);
 247
 248   for (i = 4; i < 32; i++)
 249     {
 250       info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
 251       scptr += 4;
 252       info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
 253       scptr += 4;
 254     }
 255
 256   /* IASQ/IAOQ. */
 257   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
 258   scptr += 4;
 259   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
 260   scptr += 4;
 261
 262   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
 263   scptr += 4;
 264   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
 265   scptr += 4;
 266
 267   info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
 268
 269   return info;
 270 }
 271
 272 static void
 273 hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
 274                                    void **this_prologue_cache,
 275                                    struct frame_id *this_id)
 276 {
 277   struct hppa_linux_sigtramp_unwind_cache *info
 278     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 279   *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
 280 }
 281
 282 static void
 283 hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
 284                                          void **this_prologue_cache,
 285                                          int regnum, int *optimizedp,
 286                                          enum lval_type *lvalp,
 287                                          CORE_ADDR *addrp,
 288                                          int *realnump, gdb_byte *valuep)
 289 {
 290   struct hppa_linux_sigtramp_unwind_cache *info
 291     = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
 292   hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
 293                                    optimizedp, lvalp, addrp, realnump, valuep);
 294 }
 295
 296 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
 297   SIGTRAMP_FRAME,
 298   hppa_linux_sigtramp_frame_this_id,
 299   hppa_linux_sigtramp_frame_prev_register
 300 };
 301
 302 /* hppa-linux always uses "new-style" rt-signals.  The signal handler's return
 303    address should point to a signal trampoline on the stack.  The signal
 304    trampoline is embedded in a rt_sigframe structure that is aligned on
 305    the stack.  We take advantage of the fact that sp must be 64-byte aligned,
 306    and the trampoline is small, so by rounding down the trampoline address
 307    we can find the beginning of the struct rt_sigframe.  */
 308 static const struct frame_unwind *
 309 hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
 310 {
 311   CORE_ADDR pc = frame_pc_unwind (next_frame);
 312
 313   if (hppa_linux_sigtramp_find_sigcontext (pc))
 314     return &hppa_linux_sigtramp_frame_unwind;
 315
 316   return NULL;
 317 }
 318
 319 /* Attempt to find (and return) the global pointer for the given
 320    function.
 321
 322    This is a rather nasty bit of code searchs for the .dynamic section
 323    in the objfile corresponding to the pc of the function we're trying
 324    to call.  Once it finds the addresses at which the .dynamic section
 325    lives in the child process, it scans the Elf32_Dyn entries for a
 326    DT_PLTGOT tag.  If it finds one of these, the corresponding
 327    d_un.d_ptr value is the global pointer.  */
 328
 329 static CORE_ADDR
 330 hppa_linux_find_global_pointer (struct value *function)
 331 {
 332   struct obj_section *faddr_sect;
 333   CORE_ADDR faddr;
 334
 335   faddr = value_as_address (function);
 336
 337   /* Is this a plabel? If so, dereference it to get the gp value.  */
 338   if (faddr & 2)
 339     {
 340       int status;
 341       char buf[4];
 342
 343       faddr &= ~3;
 344
 345       status = target_read_memory (faddr + 4, buf, sizeof (buf));
 346       if (status == 0)
 347         return extract_unsigned_integer (buf, sizeof (buf));
 348     }
 349
 350   /* If the address is in the plt section, then the real function hasn't
 351      yet been fixed up by the linker so we cannot determine the gp of
 352      that function.  */
 353   if (in_plt_section (faddr, NULL))
 354     return 0;
 355
 356   faddr_sect = find_pc_section (faddr);
 357   if (faddr_sect != NULL)
 358     {
 359       struct obj_section *osect;
 360
 361       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
 362         {
 363           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
 364             break;
 365         }
 366
 367       if (osect < faddr_sect->objfile->sections_end)
 368         {
 369           CORE_ADDR addr;
 370
 371           addr = osect->addr;
 372           while (addr < osect->endaddr)
 373             {
 374               int status;
 375               LONGEST tag;
 376               char buf[4];
 377
 378               status = target_read_memory (addr, buf, sizeof (buf));
 379               if (status != 0)
 380                 break;
 381               tag = extract_signed_integer (buf, sizeof (buf));
 382
 383               if (tag == DT_PLTGOT)
 384                 {
 385                   CORE_ADDR global_pointer;
 386
 387                   status = target_read_memory (addr + 4, buf, sizeof (buf));
 388                   if (status != 0)
 389                     break;
 390                   global_pointer = extract_unsigned_integer (buf, sizeof (buf));
 391
 392                   /* The payoff... */
 393                   return global_pointer;
 394                 }
 395
 396               if (tag == DT_NULL)
 397                 break;
 398
 399               addr += 8;
 400             }
 401         }
 402     }
 403   return 0;
 404 }
 405 \f
 406 /*
 407  * Registers saved in a coredump:
 408  * gr0..gr31
 409  * sr0..sr7
 410  * iaoq0..iaoq1
 411  * iasq0..iasq1
 412  * sar, iir, isr, ior, ipsw
 413  * cr0, cr24..cr31
 414  * cr8,9,12,13
 415  * cr10, cr15
 416  */
 417
 418 #define GR_REGNUM(_n)   (HPPA_R0_REGNUM+_n)
 419 #define TR_REGNUM(_n)   (HPPA_TR0_REGNUM+_n)
 420 static const int greg_map[] =
 421   {
 422     GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
 423     GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
 424     GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
 425     GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
 426     GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
 427     GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
 428     GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
 429     GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
 430
 431     HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
 432     HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
 433
 434     HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
 435     HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
 436
 437     HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
 438     HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
 439
 440     TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
 441     TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
 442
 443     HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
 444     HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
 445   };
 446
 447 static void
 448 hppa_linux_supply_regset (const struct regset *regset,
 449                           struct regcache *regcache,
 450                           int regnum, const void *regs, size_t len)
 451 {
 452   struct gdbarch *arch = get_regcache_arch (regcache);
 453   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
 454   const char *buf = regs;
 455   int i, offset;
 456
 457   offset = 0;
 458   for (i = 0; i < ARRAY_SIZE (greg_map); i++)
 459     {
 460       if (regnum == greg_map[i] || regnum == -1)
 461         regcache_raw_supply (regcache, greg_map[i], buf + offset);
 462
 463       offset += tdep->bytes_per_address;
 464     }
 465 }
 466
 467 static void
 468 hppa_linux_supply_fpregset (const struct regset *regset,
 469                             struct regcache *regcache,
 470                             int regnum, const void *regs, size_t len)
 471 {
 472   const char *buf = regs;
 473   int i, offset;
 474
 475   offset = 0;
 476   for (i = 0; i < 31; i++)
 477     {
 478       if (regnum == HPPA_FP0_REGNUM + i || regnum == -1)
 479         regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i,
 480                              buf + offset);
 481       offset += 8;
 482     }
 483 }
 484
 485 /* HPPA Linux kernel register set.  */
 486 static struct regset hppa_linux_regset =
 487 {
 488   NULL,
 489   hppa_linux_supply_regset
 490 };
 491
 492 static struct regset hppa_linux_fpregset =
 493 {
 494   NULL,
 495   hppa_linux_supply_fpregset
 496 };
 497
 498 static const struct regset *
 499 hppa_linux_regset_from_core_section (struct gdbarch *gdbarch,
 500                                      const char *sect_name,
 501                                      size_t sect_size)
 502 {
 503   if (strcmp (sect_name, ".reg") == 0)
 504     return &hppa_linux_regset;
 505   else if (strcmp (sect_name, ".reg2") == 0)
 506     return &hppa_linux_fpregset;
 507
 508   return NULL;
 509 }
 510 \f
 511
 512 /* Forward declarations.  */
 513 extern initialize_file_ftype _initialize_hppa_linux_tdep;
 514
 515 static void
 516 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 517 {
 518   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 519
 520   /* GNU/Linux is always ELF.  */
 521   tdep->is_elf = 1;
 522
 523   tdep->find_global_pointer = hppa_linux_find_global_pointer;
 524
 525   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
 526
 527   frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer);
 528
 529   /* GNU/Linux uses SVR4-style shared libraries.  */
 530   set_solib_svr4_fetch_link_map_offsets
 531     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 532
 533   tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
 534   set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
 535
 536   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 537   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 538
 539   /* On hppa-linux, currently, sizeof(long double) == 8.  There has been
 540      some discussions to support 128-bit long double, but it requires some
 541      more work in gcc and glibc first.  */
 542   set_gdbarch_long_double_bit (gdbarch, 64);
 543
 544   set_gdbarch_regset_from_core_section
 545     (gdbarch, hppa_linux_regset_from_core_section);
 546
 547 #if 0
 548   /* Dwarf-2 unwinding support.  Not yet working.  */
 549   set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 550   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 551   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 552   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
 553 #endif
 554
 555   /* Enable TLS support.  */
 556   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 557                                              svr4_fetch_objfile_link_map);
 558 }
 559
 560 void
 561 _initialize_hppa_linux_tdep (void)
 562 {
 563   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
 564   gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_LINUX, hppa_linux_init_abi);
 565 }