gdb/hppa-linux-tdep.c

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