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 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 (CORE_ADDR pc,
  91                      struct insn_pattern *pattern,
  92                      unsigned int *insn)
  93 {
  94   int i;
  95   CORE_ADDR npc = pc;
  96
  97   for (i = 0; pattern[i].mask; i++)
  98     {
  99       char buf[4];
 100
 101       target_read_memory (npc, buf, 4);
 102       insn[i] = extract_unsigned_integer (buf, 4);
 103       if ((insn[i] & pattern[i].mask) == pattern[i].data)
 104         npc += 4;
 105       else
 106         return 0;
 107     }
 108   return 1;
 109 }
 110
 111 /* Signal frames.  */
 112
 113 /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.)
 114
 115    Unfortunately, because of various bugs and changes to the kernel,
 116    we have several cases to deal with.
 117
 118    In 2.4, the signal trampoline is 4 bytes, and pc should point directly at
 119    the beginning of the trampoline and struct rt_sigframe.
 120
 121    In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at
 122    the 4th word in the trampoline structure.  This is wrong, it should point
 123    at the 5th word.  This is fixed in 2.6.5-rc2-pa4.
 124
 125    To detect these cases, we first take pc, align it to 64-bytes
 126    to get the beginning of the signal frame, and then check offsets 0, 4
 127    and 5 to see if we found the beginning of the trampoline.  This will
 128    tell us how to locate the sigcontext structure.
 129
 130    Note that with a 2.4 64-bit kernel, the signal context is not properly
 131    passed back to userspace so the unwind will not work correctly.  */
 132 static CORE_ADDR
 133 hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc)
 134 {
 135   unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
 136   int offs = 0;
 137   int try;
 138   /* offsets to try to find the trampoline */
 139   static int pcoffs[] = { 0, 4*4, 5*4 };
 140   /* offsets to the rt_sigframe structure */
 141   static int sfoffs[] = { 4*4, 10*4, 10*4 };
 142   CORE_ADDR sp;
 143
 144   /* Most of the time, this will be correct.  The one case when this will
 145      fail is if the user defined an alternate stack, in which case the
 146      beginning of the stack will not be align_down (pc, 64).  */
 147   sp = align_down (pc, 64);
 148
 149   /* rt_sigreturn trampoline:
 150      3419000x ldi 0, %r25 or ldi 1, %r25   (x = 0 or 2)
 151      3414015a ldi __NR_rt_sigreturn, %r20
 152      e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31
 153      08000240 nop  */
 154
 155   for (try = 0; try < ARRAY_SIZE (pcoffs); try++)
 156     {
 157       if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy))
 158         {
 159           offs = sfoffs[try];
 160           break;
 161         }
 162     }
 163
 164   if (offs == 0)
 165     {
 166       if (insns_match_pattern (pc, hppa_sigtramp, dummy))
 167         {
 168           /* sigaltstack case: we have no way of knowing which offset to
 169              use in this case; default to new kernel handling. If this is
 170              wrong the unwinding will fail.  */
 171           try = 2;
 172           sp = pc - pcoffs[try];
 173         }
 174       else
 175       {
 176         return 0;
 177       }
 178     }
 179
 180   /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
 181      a struct siginfo and a struct ucontext.  struct ucontext contains
 182      a struct sigcontext. Return an offset to this sigcontext here.  Too
 183      bad we cannot include system specific headers :-(.
 184      sizeof(struct siginfo) == 128
 185      offsetof(struct ucontext, uc_mcontext) == 24.  */
 186   return sp + sfoffs[try] + 128 + 24;
 187 }
 188
 189 struct hppa_linux_sigtramp_unwind_cache
 190 {
 191   CORE_ADDR base;
 192   struct trad_frame_saved_reg *saved_regs;
 193 };
 194
 195 static struct hppa_linux_sigtramp_unwind_cache *
 196 hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
 197                                         void **this_cache)
 198 {
 199   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 200   struct hppa_linux_sigtramp_unwind_cache *info;
 201   CORE_ADDR pc, scptr;
 202   int i;
 203
 204   if (*this_cache)
 205     return *this_cache;
 206
 207   info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
 208   *this_cache = info;
 209   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 210
 211   pc = get_frame_pc (this_frame);
 212   scptr = hppa_linux_sigtramp_find_sigcontext (pc);
 213
 214   /* structure of struct sigcontext:
 215
 216      struct sigcontext {
 217         unsigned long sc_flags;
 218         unsigned long sc_gr[32];
 219         unsigned long long sc_fr[32];
 220         unsigned long sc_iasq[2];
 221         unsigned long sc_iaoq[2];
 222         unsigned long sc_sar;           */
 223
 224   /* Skip sc_flags.  */
 225   scptr += 4;
 226
 227   /* GR[0] is the psw.  */
 228   info->saved_regs[HPPA_IPSW_REGNUM].addr = scptr;
 229   scptr += 4;
 230
 231   /* General registers.  */
 232   for (i = 1; i < 32; i++)
 233     {
 234       info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr;
 235       scptr += 4;
 236     }
 237
 238   /* Pad to long long boundary.  */
 239   scptr += 4;
 240
 241   /* FP regs; FP0-3 are not restored.  */
 242   scptr += (8 * 4);
 243
 244   for (i = 4; i < 32; i++)
 245     {
 246       info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr;
 247       scptr += 4;
 248       info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr;
 249       scptr += 4;
 250     }
 251
 252   /* IASQ/IAOQ. */
 253   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr;
 254   scptr += 4;
 255   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr;
 256   scptr += 4;
 257
 258   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr;
 259   scptr += 4;
 260   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr;
 261   scptr += 4;
 262
 263   info->saved_regs[HPPA_SAR_REGNUM].addr = scptr;
 264
 265   info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
 266
 267   return info;
 268 }
 269
 270 static void
 271 hppa_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
 272                                    void **this_prologue_cache,
 273                                    struct frame_id *this_id)
 274 {
 275   struct hppa_linux_sigtramp_unwind_cache *info
 276     = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 277   *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
 278 }
 279
 280 static struct value *
 281 hppa_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
 282                                          void **this_prologue_cache,
 283                                          int regnum)
 284 {
 285   struct hppa_linux_sigtramp_unwind_cache *info
 286     = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 287   return hppa_frame_prev_register_helper (this_frame,
 288                                           info->saved_regs, regnum);
 289 }
 290
 291 /* hppa-linux always uses "new-style" rt-signals.  The signal handler's return
 292    address should point to a signal trampoline on the stack.  The signal
 293    trampoline is embedded in a rt_sigframe structure that is aligned on
 294    the stack.  We take advantage of the fact that sp must be 64-byte aligned,
 295    and the trampoline is small, so by rounding down the trampoline address
 296    we can find the beginning of the struct rt_sigframe.  */
 297 static int
 298 hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
 299                                    struct frame_info *this_frame,
 300                                    void **this_prologue_cache)
 301 {
 302   CORE_ADDR pc = get_frame_pc (this_frame);
 303
 304   if (hppa_linux_sigtramp_find_sigcontext (pc))
 305     return 1;
 306
 307   return 0;
 308 }
 309
 310 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
 311   SIGTRAMP_FRAME,
 312   hppa_linux_sigtramp_frame_this_id,
 313   hppa_linux_sigtramp_frame_prev_register,
 314   NULL,
 315   hppa_linux_sigtramp_frame_sniffer
 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 gdbarch *gdbarch, 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, endaddr;
 369
 370           addr = obj_section_addr (osect);
 371           endaddr = obj_section_endaddr (osect);
 372
 373           while (addr < endaddr)
 374             {
 375               int status;
 376               LONGEST tag;
 377               char buf[4];
 378
 379               status = target_read_memory (addr, buf, sizeof (buf));
 380               if (status != 0)
 381                 break;
 382               tag = extract_signed_integer (buf, sizeof (buf));
 383
 384               if (tag == DT_PLTGOT)
 385                 {
 386                   CORE_ADDR global_pointer;
 387
 388                   status = target_read_memory (addr + 4, buf, sizeof (buf));
 389                   if (status != 0)
 390                     break;
 391                   global_pointer = extract_unsigned_integer (buf, sizeof (buf));
 392
 393                   /* The payoff... */
 394                   return global_pointer;
 395                 }
 396
 397               if (tag == DT_NULL)
 398                 break;
 399
 400               addr += 8;
 401             }
 402         }
 403     }
 404   return 0;
 405 }
 406 \f
 407 /*
 408  * Registers saved in a coredump:
 409  * gr0..gr31
 410  * sr0..sr7
 411  * iaoq0..iaoq1
 412  * iasq0..iasq1
 413  * sar, iir, isr, ior, ipsw
 414  * cr0, cr24..cr31
 415  * cr8,9,12,13
 416  * cr10, cr15
 417  */
 418
 419 #define GR_REGNUM(_n)   (HPPA_R0_REGNUM+_n)
 420 #define TR_REGNUM(_n)   (HPPA_TR0_REGNUM+_n)
 421 static const int greg_map[] =
 422   {
 423     GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3),
 424     GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7),
 425     GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11),
 426     GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15),
 427     GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19),
 428     GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23),
 429     GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27),
 430     GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31),
 431
 432     HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4,
 433     HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7,
 434
 435     HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM,
 436     HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM,
 437
 438     HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM,
 439     HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM,
 440
 441     TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3),
 442     TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7),
 443
 444     HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM,
 445     HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM,
 446   };
 447
 448 static void
 449 hppa_linux_supply_regset (const struct regset *regset,
 450                           struct regcache *regcache,
 451                           int regnum, const void *regs, size_t len)
 452 {
 453   struct gdbarch *arch = get_regcache_arch (regcache);
 454   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
 455   const char *buf = regs;
 456   int i, offset;
 457
 458   offset = 0;
 459   for (i = 0; i < ARRAY_SIZE (greg_map); i++)
 460     {
 461       if (regnum == greg_map[i] || regnum == -1)
 462         regcache_raw_supply (regcache, greg_map[i], buf + offset);
 463
 464       offset += tdep->bytes_per_address;
 465     }
 466 }
 467
 468 static void
 469 hppa_linux_supply_fpregset (const struct regset *regset,
 470                             struct regcache *regcache,
 471                             int regnum, const void *regs, size_t len)
 472 {
 473   const char *buf = regs;
 474   int i, offset;
 475
 476   offset = 0;
 477   for (i = 0; i < 64; i++)
 478     {
 479       if (regnum == HPPA_FP0_REGNUM + i || regnum == -1)
 480         regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i,
 481                              buf + offset);
 482       offset += 4;
 483     }
 484 }
 485
 486 /* HPPA Linux kernel register set.  */
 487 static struct regset hppa_linux_regset =
 488 {
 489   NULL,
 490   hppa_linux_supply_regset
 491 };
 492
 493 static struct regset hppa_linux_fpregset =
 494 {
 495   NULL,
 496   hppa_linux_supply_fpregset
 497 };
 498
 499 static const struct regset *
 500 hppa_linux_regset_from_core_section (struct gdbarch *gdbarch,
 501                                      const char *sect_name,
 502                                      size_t sect_size)
 503 {
 504   if (strcmp (sect_name, ".reg") == 0)
 505     return &hppa_linux_regset;
 506   else if (strcmp (sect_name, ".reg2") == 0)
 507     return &hppa_linux_fpregset;
 508
 509   return NULL;
 510 }
 511 \f
 512
 513 /* Forward declarations.  */
 514 extern initialize_file_ftype _initialize_hppa_linux_tdep;
 515
 516 static void
 517 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 518 {
 519   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 520
 521   /* GNU/Linux is always ELF.  */
 522   tdep->is_elf = 1;
 523
 524   tdep->find_global_pointer = hppa_linux_find_global_pointer;
 525
 526   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
 527
 528   frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind);
 529
 530   /* GNU/Linux uses SVR4-style shared libraries.  */
 531   set_solib_svr4_fetch_link_map_offsets
 532     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 533
 534   tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
 535   set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
 536
 537   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 538   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 539
 540   /* On hppa-linux, currently, sizeof(long double) == 8.  There has been
 541      some discussions to support 128-bit long double, but it requires some
 542      more work in gcc and glibc first.  */
 543   set_gdbarch_long_double_bit (gdbarch, 64);
 544
 545   set_gdbarch_regset_from_core_section
 546     (gdbarch, hppa_linux_regset_from_core_section);
 547
 548   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 549
 550   /* Enable TLS support.  */
 551   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 552                                              svr4_fetch_objfile_link_map);
 553 }
 554
 555 void
 556 _initialize_hppa_linux_tdep (void)
 557 {
 558   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi);
 559   gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_LINUX, hppa_linux_init_abi);
 560 }