gdb/hppa-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
   2
   3    Copyright (C) 2004-2023 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 #include "linux-tdep.h"
  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 >= 0 && 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   return -1;
  50 }
  51
  52 static void
  53 hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v)
  54 {
  55   /* Probably this should be done by the kernel, but it isn't.  */
  56   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3);
  57   regcache_cooked_write_unsigned (regcache,
  58                                   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       gdb_byte 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 attempt;
 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 (attempt = 0; attempt < ARRAY_SIZE (pcoffs); attempt++)
 157     {
 158       if (insns_match_pattern (gdbarch, sp + pcoffs[attempt],
 159                                hppa_sigtramp, dummy))
 160         {
 161           offs = sfoffs[attempt];
 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           attempt = 2;
 174           sp = pc - pcoffs[attempt];
 175         }
 176       else
 177         return 0;
 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[attempt] + 128 + 24;
 187 }
 188
 189 struct hppa_linux_sigtramp_unwind_cache
 190 {
 191   CORE_ADDR base;
 192   trad_frame_saved_reg *saved_regs;
 193 };
 194
 195 static struct hppa_linux_sigtramp_unwind_cache *
 196 hppa_linux_sigtramp_frame_unwind_cache (frame_info_ptr 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 (struct hppa_linux_sigtramp_unwind_cache *) *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 (gdbarch, 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].set_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].set_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)].set_addr (scptr);
 247       scptr += 4;
 248       info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].set_addr (scptr);
 249       scptr += 4;
 250     }
 251
 252   /* IASQ/IAOQ.  */
 253   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].set_addr (scptr);
 254   scptr += 4;
 255   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].set_addr (scptr);
 256   scptr += 4;
 257
 258   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_addr (scptr);
 259   scptr += 4;
 260   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].set_addr (scptr);
 261   scptr += 4;
 262
 263   info->saved_regs[HPPA_SAR_REGNUM].set_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 (frame_info_ptr 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 (frame_info_ptr 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                                    frame_info_ptr this_frame,
 300                                    void **this_prologue_cache)
 301 {
 302   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 303   CORE_ADDR pc = get_frame_pc (this_frame);
 304
 305   if (hppa_linux_sigtramp_find_sigcontext (gdbarch, pc))
 306     return 1;
 307
 308   return 0;
 309 }
 310
 311 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
 312   "hppa linux sigtramp",
 313   SIGTRAMP_FRAME,
 314   default_frame_unwind_stop_reason,
 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,
 333                                 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       gdb_byte 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))
 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 = osect->addr ();
 376           endaddr = osect->endaddr ();
 377
 378           while (addr < endaddr)
 379             {
 380               int status;
 381               LONGEST tag;
 382               gdb_byte buf[4];
 383
 384               status = target_read_memory (addr, buf, sizeof (buf));
 385               if (status != 0)
 386                 break;
 387               tag = extract_signed_integer (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 static const struct regcache_map_entry hppa_linux_gregmap[] =
 425   {
 426     { 32, HPPA_R0_REGNUM },
 427     { 1, HPPA_SR4_REGNUM+1 },
 428     { 1, HPPA_SR4_REGNUM+2 },
 429     { 1, HPPA_SR4_REGNUM+3 },
 430     { 1, HPPA_SR4_REGNUM+4 },
 431     { 1, HPPA_SR4_REGNUM },
 432     { 1, HPPA_SR4_REGNUM+5 },
 433     { 1, HPPA_SR4_REGNUM+6 },
 434     { 1, HPPA_SR4_REGNUM+7 },
 435     { 1, HPPA_PCOQ_HEAD_REGNUM },
 436     { 1, HPPA_PCOQ_TAIL_REGNUM },
 437     { 1, HPPA_PCSQ_HEAD_REGNUM },
 438     { 1, HPPA_PCSQ_TAIL_REGNUM },
 439     { 1, HPPA_SAR_REGNUM },
 440     { 1, HPPA_IIR_REGNUM },
 441     { 1, HPPA_ISR_REGNUM },
 442     { 1, HPPA_IOR_REGNUM },
 443     { 1, HPPA_IPSW_REGNUM },
 444     { 1, HPPA_RCR_REGNUM },
 445     { 8, HPPA_TR0_REGNUM },
 446     { 4, HPPA_PID0_REGNUM },
 447     { 1, HPPA_CCR_REGNUM },
 448     { 1, HPPA_EIEM_REGNUM },
 449     { 0 }
 450   };
 451
 452 static const struct regcache_map_entry hppa_linux_fpregmap[] =
 453   {
 454     /* FIXME: Only works for 32-bit mode.  In 64-bit mode there should
 455        be 32 fpregs, 8 bytes each.  */
 456     { 64, HPPA_FP0_REGNUM, 4 },
 457     { 0 }
 458   };
 459
 460 /* HPPA Linux kernel register set.  */
 461 static const struct regset hppa_linux_regset =
 462 {
 463   hppa_linux_gregmap,
 464   regcache_supply_regset, regcache_collect_regset
 465 };
 466
 467 static const struct regset hppa_linux_fpregset =
 468 {
 469   hppa_linux_fpregmap,
 470   regcache_supply_regset, regcache_collect_regset
 471 };
 472
 473 static void
 474 hppa_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 475                                          iterate_over_regset_sections_cb *cb,
 476                                          void *cb_data,
 477                                          const struct regcache *regcache)
 478 {
 479   hppa_gdbarch_tdep *tdep = gdbarch_tdep<hppa_gdbarch_tdep> (gdbarch);
 480
 481   cb (".reg", 80 * tdep->bytes_per_address, 80 * tdep->bytes_per_address,
 482       &hppa_linux_regset, NULL, cb_data);
 483   cb (".reg2", 64 * 4, 64 * 4, &hppa_linux_fpregset, NULL, cb_data);
 484 }
 485
 486 static void
 487 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 488 {
 489   hppa_gdbarch_tdep *tdep = gdbarch_tdep<hppa_gdbarch_tdep> (gdbarch);
 490
 491   linux_init_abi (info, gdbarch, 0);
 492
 493   /* GNU/Linux is always ELF.  */
 494   tdep->is_elf = 1;
 495
 496   tdep->find_global_pointer = hppa_linux_find_global_pointer;
 497
 498   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
 499
 500   frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind);
 501
 502   /* GNU/Linux uses SVR4-style shared libraries.  */
 503   set_solib_svr4_fetch_link_map_offsets
 504     (gdbarch, linux_ilp32_fetch_link_map_offsets);
 505
 506   tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
 507   set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
 508
 509   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 510   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 511
 512   /* On hppa-linux, currently, sizeof(long double) == 8.  There has been
 513      some discussions to support 128-bit long double, but it requires some
 514      more work in gcc and glibc first.  */
 515   set_gdbarch_long_double_bit (gdbarch, 64);
 516   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
 517
 518   set_gdbarch_iterate_over_regset_sections
 519     (gdbarch, hppa_linux_iterate_over_regset_sections);
 520
 521   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 522
 523   /* Enable TLS support.  */
 524   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 525                                              svr4_fetch_objfile_link_map);
 526 }
 527
 528 void _initialize_hppa_linux_tdep ();
 529 void
 530 _initialize_hppa_linux_tdep ()
 531 {
 532   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX,
 533                           hppa_linux_init_abi);
 534   gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w,
 535                           GDB_OSABI_LINUX, hppa_linux_init_abi);
 536 }