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