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