gdb/hppa-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB.
   2
   3    Copyright (C) 2004-2024 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 "gdbcore.h"
  21 #include "osabi.h"
  22 #include "target.h"
  23 #include "objfiles.h"
  24 #include "solib-svr4.h"
  25 #include "glibc-tdep.h"
  26 #include "frame-unwind.h"
  27 #include "trad-frame.h"
  28 #include "dwarf2/frame.h"
  29 #include "value.h"
  30 #include "regset.h"
  31 #include "regcache.h"
  32 #include "hppa-tdep.h"
  33 #include "linux-tdep.h"
  34 #include "elf/common.h"
  35
  36 /* Map DWARF DBX register numbers to GDB register numbers.  */
  37 static int
  38 hppa_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
  39 {
  40   /* The general registers and the sar are the same in both sets.  */
  41   if (reg >= 0 && reg <= 32)
  42     return reg;
  43
  44   /* fr4-fr31 (left and right halves) are mapped from 72.  */
  45   if (reg >= 72 && reg <= 72 + 28 * 2)
  46     return HPPA_FP4_REGNUM + (reg - 72);
  47
  48   return -1;
  49 }
  50
  51 static void
  52 hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v)
  53 {
  54   /* Probably this should be done by the kernel, but it isn't.  */
  55   regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3);
  56   regcache_cooked_write_unsigned (regcache,
  57                                   HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3);
  58 }
  59
  60 /* An instruction to match.  */
  61 struct insn_pattern
  62 {
  63   unsigned int data;            /* See if it matches this....  */
  64   unsigned int mask;            /* ... with this mask.  */
  65 };
  66
  67 static struct insn_pattern hppa_sigtramp[] = {
  68   /* ldi 0, %r25 or ldi 1, %r25 */
  69   { 0x34190000, 0xfffffffd },
  70   /* ldi __NR_rt_sigreturn, %r20 */
  71   { 0x3414015a, 0xffffffff },
  72   /* be,l 0x100(%sr2, %r0), %sr0, %r31 */
  73   { 0xe4008200, 0xffffffff },
  74   /* nop */
  75   { 0x08000240, 0xffffffff },
  76   { 0, 0 }
  77 };
  78
  79 #define HPPA_MAX_INSN_PATTERN_LEN (4)
  80
  81 /* Return non-zero if the instructions at PC match the series
  82    described in PATTERN, or zero otherwise.  PATTERN is an array of
  83    'struct insn_pattern' objects, terminated by an entry whose mask is
  84    zero.
  85
  86    When the match is successful, fill INSN[i] with what PATTERN[i]
  87    matched.  */
  88 static int
  89 insns_match_pattern (struct gdbarch *gdbarch, CORE_ADDR pc,
  90                      struct insn_pattern *pattern,
  91                      unsigned int *insn)
  92 {
  93   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  94   int i;
  95   CORE_ADDR npc = pc;
  96
  97   for (i = 0; pattern[i].mask; i++)
  98     {
  99       gdb_byte buf[4];
 100
 101       target_read_memory (npc, buf, 4);
 102       insn[i] = extract_unsigned_integer (buf, 4, byte_order);
 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 (struct gdbarch *gdbarch, CORE_ADDR pc)
 134 {
 135   unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN];
 136   int offs = 0;
 137   int attempt;
 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 (attempt = 0; attempt < ARRAY_SIZE (pcoffs); attempt++)
 156     {
 157       if (insns_match_pattern (gdbarch, sp + pcoffs[attempt],
 158                                hppa_sigtramp, dummy))
 159         {
 160           offs = sfoffs[attempt];
 161           break;
 162         }
 163     }
 164
 165   if (offs == 0)
 166     {
 167       if (insns_match_pattern (gdbarch, pc, hppa_sigtramp, dummy))
 168         {
 169           /* sigaltstack case: we have no way of knowing which offset to
 170              use in this case; default to new kernel handling.  If this is
 171              wrong the unwinding will fail.  */
 172           attempt = 2;
 173           sp = pc - pcoffs[attempt];
 174         }
 175       else
 176         return 0;
 177     }
 178
 179   /* sp + sfoffs[try] points to a struct rt_sigframe, which contains
 180      a struct siginfo and a struct ucontext.  struct ucontext contains
 181      a struct sigcontext.  Return an offset to this sigcontext here.  Too
 182      bad we cannot include system specific headers :-(.
 183      sizeof(struct siginfo) == 128
 184      offsetof(struct ucontext, uc_mcontext) == 24.  */
 185   return sp + sfoffs[attempt] + 128 + 24;
 186 }
 187
 188 struct hppa_linux_sigtramp_unwind_cache
 189 {
 190   CORE_ADDR base;
 191   trad_frame_saved_reg *saved_regs;
 192 };
 193
 194 static struct hppa_linux_sigtramp_unwind_cache *
 195 hppa_linux_sigtramp_frame_unwind_cache (const frame_info_ptr &this_frame,
 196                                         void **this_cache)
 197 {
 198   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 199   struct hppa_linux_sigtramp_unwind_cache *info;
 200   CORE_ADDR pc, scptr;
 201   int i;
 202
 203   if (*this_cache)
 204     return (struct hppa_linux_sigtramp_unwind_cache *) *this_cache;
 205
 206   info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
 207   *this_cache = info;
 208   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 209
 210   pc = get_frame_pc (this_frame);
 211   scptr = hppa_linux_sigtramp_find_sigcontext (gdbarch, pc);
 212
 213   /* structure of struct sigcontext:
 214
 215      struct sigcontext {
 216         unsigned long sc_flags;
 217         unsigned long sc_gr[32];
 218         unsigned long long sc_fr[32];
 219         unsigned long sc_iasq[2];
 220         unsigned long sc_iaoq[2];
 221         unsigned long sc_sar;           */
 222
 223   /* Skip sc_flags.  */
 224   scptr += 4;
 225
 226   /* GR[0] is the psw.  */
 227   info->saved_regs[HPPA_IPSW_REGNUM].set_addr (scptr);
 228   scptr += 4;
 229
 230   /* General registers.  */
 231   for (i = 1; i < 32; i++)
 232     {
 233       info->saved_regs[HPPA_R0_REGNUM + i].set_addr (scptr);
 234       scptr += 4;
 235     }
 236
 237   /* Pad to long long boundary.  */
 238   scptr += 4;
 239
 240   /* FP regs; FP0-3 are not restored.  */
 241   scptr += (8 * 4);
 242
 243   for (i = 4; i < 32; i++)
 244     {
 245       info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].set_addr (scptr);
 246       scptr += 4;
 247       info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].set_addr (scptr);
 248       scptr += 4;
 249     }
 250
 251   /* IASQ/IAOQ.  */
 252   info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].set_addr (scptr);
 253   scptr += 4;
 254   info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].set_addr (scptr);
 255   scptr += 4;
 256
 257   info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].set_addr (scptr);
 258   scptr += 4;
 259   info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].set_addr (scptr);
 260   scptr += 4;
 261
 262   info->saved_regs[HPPA_SAR_REGNUM].set_addr (scptr);
 263
 264   info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
 265
 266   return info;
 267 }
 268
 269 static void
 270 hppa_linux_sigtramp_frame_this_id (const frame_info_ptr &this_frame,
 271                                    void **this_prologue_cache,
 272                                    struct frame_id *this_id)
 273 {
 274   struct hppa_linux_sigtramp_unwind_cache *info
 275     = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 276   *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
 277 }
 278
 279 static struct value *
 280 hppa_linux_sigtramp_frame_prev_register (const frame_info_ptr &this_frame,
 281                                          void **this_prologue_cache,
 282                                          int regnum)
 283 {
 284   struct hppa_linux_sigtramp_unwind_cache *info
 285     = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
 286   return hppa_frame_prev_register_helper (this_frame,
 287                                           info->saved_regs, regnum);
 288 }
 289
 290 /* hppa-linux always uses "new-style" rt-signals.  The signal handler's return
 291    address should point to a signal trampoline on the stack.  The signal
 292    trampoline is embedded in a rt_sigframe structure that is aligned on
 293    the stack.  We take advantage of the fact that sp must be 64-byte aligned,
 294    and the trampoline is small, so by rounding down the trampoline address
 295    we can find the beginning of the struct rt_sigframe.  */
 296 static int
 297 hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
 298                                    const frame_info_ptr &this_frame,
 299                                    void **this_prologue_cache)
 300 {
 301   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 302   CORE_ADDR pc = get_frame_pc (this_frame);
 303
 304   if (hppa_linux_sigtramp_find_sigcontext (gdbarch, pc))
 305     return 1;
 306
 307   return 0;
 308 }
 309
 310 static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = {
 311   "hppa linux sigtramp",
 312   SIGTRAMP_FRAME,
 313   default_frame_unwind_stop_reason,
 314   hppa_linux_sigtramp_frame_this_id,
 315   hppa_linux_sigtramp_frame_prev_register,
 316   NULL,
 317   hppa_linux_sigtramp_frame_sniffer
 318 };
 319
 320 /* Attempt to find (and return) the global pointer for the given
 321    function.
 322
 323    This is a rather nasty bit of code searchs for the .dynamic section
 324    in the objfile corresponding to the pc of the function we're trying
 325    to call.  Once it finds the addresses at which the .dynamic section
 326    lives in the child process, it scans the Elf32_Dyn entries for a
 327    DT_PLTGOT tag.  If it finds one of these, the corresponding
 328    d_un.d_ptr value is the global pointer.  */
 329
 330 static CORE_ADDR
 331 hppa_linux_find_global_pointer (struct gdbarch *gdbarch,
 332                                 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       gdb_byte 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))
 357     return 0;
 358
 359   faddr_sect = find_pc_section (faddr);
 360   if (faddr_sect != NULL)
 361     {
 362       for (obj_section *osect : faddr_sect->objfile->sections ())
 363         {
 364           if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0)
 365             {
 366               CORE_ADDR addr, endaddr;
 367
 368               addr = osect->addr ();
 369               endaddr = osect->endaddr ();
 370
 371               while (addr < endaddr)
 372                 {
 373                   int status;
 374                   LONGEST tag;
 375                   gdb_byte buf[4];
 376
 377                   status = target_read_memory (addr, buf, sizeof (buf));
 378                   if (status != 0)
 379                     break;
 380                   tag = extract_signed_integer (buf, byte_order);
 381
 382                   if (tag == DT_PLTGOT)
 383                     {
 384                       CORE_ADDR global_pointer;
 385
 386                       status = target_read_memory (addr + 4, buf,
 387                                                    sizeof (buf));
 388                       if (status != 0)
 389                         break;
 390                       global_pointer
 391                         = extract_unsigned_integer (buf, sizeof (buf),
 392                                                     byte_order);
 393                       /* The payoff...  */
 394                       return global_pointer;
 395                     }
 396
 397                   if (tag == DT_NULL)
 398                     break;
 399
 400                   addr += 8;
 401                 }
 402               break;
 403             }
 404         }
 405     }
 406   return 0;
 407 }
 408 \f
 409 /*
 410  * Registers saved in a coredump:
 411  * gr0..gr31
 412  * sr0..sr7
 413  * iaoq0..iaoq1
 414  * iasq0..iasq1
 415  * sar, iir, isr, ior, ipsw
 416  * cr0, cr24..cr31
 417  * cr8,9,12,13
 418  * cr10, cr15
 419  */
 420
 421 static const struct regcache_map_entry hppa_linux_gregmap[] =
 422   {
 423     { 32, HPPA_R0_REGNUM },
 424     { 1, HPPA_SR4_REGNUM+1 },
 425     { 1, HPPA_SR4_REGNUM+2 },
 426     { 1, HPPA_SR4_REGNUM+3 },
 427     { 1, HPPA_SR4_REGNUM+4 },
 428     { 1, HPPA_SR4_REGNUM },
 429     { 1, HPPA_SR4_REGNUM+5 },
 430     { 1, HPPA_SR4_REGNUM+6 },
 431     { 1, HPPA_SR4_REGNUM+7 },
 432     { 1, HPPA_PCOQ_HEAD_REGNUM },
 433     { 1, HPPA_PCOQ_TAIL_REGNUM },
 434     { 1, HPPA_PCSQ_HEAD_REGNUM },
 435     { 1, HPPA_PCSQ_TAIL_REGNUM },
 436     { 1, HPPA_SAR_REGNUM },
 437     { 1, HPPA_IIR_REGNUM },
 438     { 1, HPPA_ISR_REGNUM },
 439     { 1, HPPA_IOR_REGNUM },
 440     { 1, HPPA_IPSW_REGNUM },
 441     { 1, HPPA_RCR_REGNUM },
 442     { 8, HPPA_TR0_REGNUM },
 443     { 4, HPPA_PID0_REGNUM },
 444     { 1, HPPA_CCR_REGNUM },
 445     { 1, HPPA_EIEM_REGNUM },
 446     { 0 }
 447   };
 448
 449 static const struct regcache_map_entry hppa_linux_fpregmap[] =
 450   {
 451     /* FIXME: Only works for 32-bit mode.  In 64-bit mode there should
 452        be 32 fpregs, 8 bytes each.  */
 453     { 64, HPPA_FP0_REGNUM, 4 },
 454     { 0 }
 455   };
 456
 457 /* HPPA Linux kernel register set.  */
 458 static const struct regset hppa_linux_regset =
 459 {
 460   hppa_linux_gregmap,
 461   regcache_supply_regset, regcache_collect_regset
 462 };
 463
 464 static const struct regset hppa_linux_fpregset =
 465 {
 466   hppa_linux_fpregmap,
 467   regcache_supply_regset, regcache_collect_regset
 468 };
 469
 470 static void
 471 hppa_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 472                                          iterate_over_regset_sections_cb *cb,
 473                                          void *cb_data,
 474                                          const struct regcache *regcache)
 475 {
 476   hppa_gdbarch_tdep *tdep = gdbarch_tdep<hppa_gdbarch_tdep> (gdbarch);
 477
 478   cb (".reg", 80 * tdep->bytes_per_address, 80 * tdep->bytes_per_address,
 479       &hppa_linux_regset, NULL, cb_data);
 480   cb (".reg2", 64 * 4, 64 * 4, &hppa_linux_fpregset, NULL, cb_data);
 481 }
 482
 483 static void
 484 hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 485 {
 486   hppa_gdbarch_tdep *tdep = gdbarch_tdep<hppa_gdbarch_tdep> (gdbarch);
 487
 488   linux_init_abi (info, gdbarch, 0);
 489
 490   /* GNU/Linux is always ELF.  */
 491   tdep->is_elf = 1;
 492
 493   tdep->find_global_pointer = hppa_linux_find_global_pointer;
 494
 495   set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc);
 496
 497   frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind);
 498
 499   /* GNU/Linux uses SVR4-style shared libraries.  */
 500   set_solib_svr4_fetch_link_map_offsets
 501     (gdbarch, linux_ilp32_fetch_link_map_offsets);
 502
 503   tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline;
 504   set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
 505
 506   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 507   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 508
 509   /* On hppa-linux, currently, sizeof(long double) == 8.  There has been
 510      some discussions to support 128-bit long double, but it requires some
 511      more work in gcc and glibc first.  */
 512   set_gdbarch_long_double_bit (gdbarch, 64);
 513   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
 514
 515   set_gdbarch_iterate_over_regset_sections
 516     (gdbarch, hppa_linux_iterate_over_regset_sections);
 517
 518   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum);
 519
 520   /* Enable TLS support.  */
 521   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 522                                              svr4_fetch_objfile_link_map);
 523 }
 524
 525 void _initialize_hppa_linux_tdep ();
 526 void
 527 _initialize_hppa_linux_tdep ()
 528 {
 529   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX,
 530                           hppa_linux_init_abi);
 531   gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w,
 532                           GDB_OSABI_LINUX, hppa_linux_init_abi);
 533 }