gdb/sparc-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux SPARC.
   2
   3    Copyright (C) 2003-2022 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 "dwarf2/frame.h"
  22 #include "frame.h"
  23 #include "frame-unwind.h"
  24 #include "gdbtypes.h"
  25 #include "regset.h"
  26 #include "gdbarch.h"
  27 #include "gdbcore.h"
  28 #include "osabi.h"
  29 #include "regcache.h"
  30 #include "solib-svr4.h"
  31 #include "symtab.h"
  32 #include "trad-frame.h"
  33 #include "tramp-frame.h"
  34 #include "xml-syscall.h"
  35 #include "linux-tdep.h"
  36
  37 /* The syscall's XML filename for sparc 32-bit.  */
  38 #define XML_SYSCALL_FILENAME_SPARC32 "syscalls/sparc-linux.xml"
  39
  40 #include "sparc-tdep.h"
  41
  42 /* Signal trampoline support.  */
  43
  44 static void sparc32_linux_sigframe_init (const struct tramp_frame *self,
  45                                          struct frame_info *this_frame,
  46                                          struct trad_frame_cache *this_cache,
  47                                          CORE_ADDR func);
  48
  49 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  50    "realtime" (RT) signals.  The RT signals can provide additional
  51    information to the signal handler if the SA_SIGINFO flag is set
  52    when establishing a signal handler using `sigaction'.  It is not
  53    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  54    for normal signals too.  */
  55
  56 /* When the sparc Linux kernel calls a signal handler and the
  57    SA_RESTORER flag isn't set, the return address points to a bit of
  58    code on the stack.  This code checks whether the PC appears to be
  59    within this bit of code.
  60
  61    The instruction sequence for normal signals is encoded below.
  62    Checking for the code sequence should be somewhat reliable, because
  63    the effect is to call the system call sigreturn.  This is unlikely
  64    to occur anywhere other than a signal trampoline.  */
  65
  66 static const struct tramp_frame sparc32_linux_sigframe =
  67 {
  68   SIGTRAMP_FRAME,
  69   4,
  70   {
  71     { 0x821020d8, ULONGEST_MAX },               /* mov __NR_sigreturn, %g1 */
  72     { 0x91d02010, ULONGEST_MAX },               /* ta  0x10 */
  73     { TRAMP_SENTINEL_INSN, ULONGEST_MAX }
  74   },
  75   sparc32_linux_sigframe_init
  76 };
  77
  78 /* The instruction sequence for RT signals is slightly different.  The
  79    effect is to call the system call rt_sigreturn.  */
  80
  81 static const struct tramp_frame sparc32_linux_rt_sigframe =
  82 {
  83   SIGTRAMP_FRAME,
  84   4,
  85   {
  86     { 0x82102065, ULONGEST_MAX },               /* mov __NR_rt_sigreturn, %g1 */
  87     { 0x91d02010, ULONGEST_MAX },               /* ta  0x10 */
  88     { TRAMP_SENTINEL_INSN, ULONGEST_MAX }
  89   },
  90   sparc32_linux_sigframe_init
  91 };
  92
  93 /* This enum represents the signals' numbers on the SPARC
  94    architecture.  It just contains the signal definitions which are
  95    different from the generic implementation.
  96
  97    It is derived from the file <arch/sparc/include/uapi/asm/signal.h>,
  98    from the Linux kernel tree.  */
  99
 100 enum
 101   {
 102     SPARC_LINUX_SIGEMT = 7,
 103     SPARC_LINUX_SIGBUS = 10,
 104     SPARC_LINUX_SIGSYS = 12,
 105     SPARC_LINUX_SIGURG = 16,
 106     SPARC_LINUX_SIGSTOP = 17,
 107     SPARC_LINUX_SIGTSTP = 18,
 108     SPARC_LINUX_SIGCONT = 19,
 109     SPARC_LINUX_SIGCHLD = 20,
 110     SPARC_LINUX_SIGIO = 23,
 111     SPARC_LINUX_SIGPOLL = SPARC_LINUX_SIGIO,
 112     SPARC_LINUX_SIGLOST = 29,
 113     SPARC_LINUX_SIGPWR = SPARC_LINUX_SIGLOST,
 114     SPARC_LINUX_SIGUSR1 = 30,
 115     SPARC_LINUX_SIGUSR2 = 31,
 116   };
 117
 118 static void
 119 sparc32_linux_sigframe_init (const struct tramp_frame *self,
 120                              struct frame_info *this_frame,
 121                              struct trad_frame_cache *this_cache,
 122                              CORE_ADDR func)
 123 {
 124   CORE_ADDR base, addr, sp_addr;
 125   int regnum;
 126
 127   base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM);
 128   if (self == &sparc32_linux_rt_sigframe)
 129     base += 128;
 130
 131   /* Offsets from <bits/sigcontext.h>.  */
 132
 133   trad_frame_set_reg_addr (this_cache, SPARC32_PSR_REGNUM, base + 0);
 134   trad_frame_set_reg_addr (this_cache, SPARC32_PC_REGNUM, base + 4);
 135   trad_frame_set_reg_addr (this_cache, SPARC32_NPC_REGNUM, base + 8);
 136   trad_frame_set_reg_addr (this_cache, SPARC32_Y_REGNUM, base + 12);
 137
 138   /* Since %g0 is always zero, keep the identity encoding.  */
 139   addr = base + 20;
 140   sp_addr = base + 16 + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 4);
 141   for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
 142     {
 143       trad_frame_set_reg_addr (this_cache, regnum, addr);
 144       addr += 4;
 145     }
 146
 147   base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
 148   addr = get_frame_memory_unsigned (this_frame, sp_addr, 4);
 149
 150   for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
 151     {
 152       trad_frame_set_reg_addr (this_cache, regnum, addr);
 153       addr += 4;
 154     }
 155   trad_frame_set_id (this_cache, frame_id_build (base, func));
 156 }
 157 \f
 158 /* Return the address of a system call's alternative return
 159    address.  */
 160
 161 static CORE_ADDR
 162 sparc32_linux_step_trap (struct frame_info *frame, unsigned long insn)
 163 {
 164   if (insn == 0x91d02010)
 165     {
 166       ULONGEST sc_num = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
 167
 168       /* __NR_rt_sigreturn is 101 and __NR_sigreturn is 216.  */
 169       if (sc_num == 101 || sc_num == 216)
 170         {
 171           struct gdbarch *gdbarch = get_frame_arch (frame);
 172           enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 173
 174           ULONGEST sp, pc_offset;
 175
 176           sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
 177
 178           /* The kernel puts the sigreturn registers on the stack,
 179              and this is where the signal unwinding state is take from
 180              when returning from a signal.
 181
 182              For __NR_sigreturn, this register area sits 96 bytes from
 183              the base of the stack.  The saved PC sits 4 bytes into the
 184              sigreturn register save area.
 185
 186              For __NR_rt_sigreturn a siginfo_t, which is 128 bytes, sits
 187              right before the sigreturn register save area.  */
 188
 189           pc_offset = 96 + 4;
 190           if (sc_num == 101)
 191             pc_offset += 128;
 192
 193           return read_memory_unsigned_integer (sp + pc_offset, 4, byte_order);
 194         }
 195     }
 196
 197   return 0;
 198 }
 199 \f
 200
 201 const struct sparc_gregmap sparc32_linux_core_gregmap =
 202 {
 203   32 * 4,                       /* %psr */
 204   33 * 4,                       /* %pc */
 205   34 * 4,                       /* %npc */
 206   35 * 4,                       /* %y */
 207   -1,                           /* %wim */
 208   -1,                           /* %tbr */
 209   1 * 4,                        /* %g1 */
 210   16 * 4,                       /* %l0 */
 211   4,                            /* y size */
 212 };
 213 \f
 214
 215 static void
 216 sparc32_linux_supply_core_gregset (const struct regset *regset,
 217                                    struct regcache *regcache,
 218                                    int regnum, const void *gregs, size_t len)
 219 {
 220   sparc32_supply_gregset (&sparc32_linux_core_gregmap,
 221                           regcache, regnum, gregs);
 222 }
 223
 224 static void
 225 sparc32_linux_collect_core_gregset (const struct regset *regset,
 226                                     const struct regcache *regcache,
 227                                     int regnum, void *gregs, size_t len)
 228 {
 229   sparc32_collect_gregset (&sparc32_linux_core_gregmap,
 230                            regcache, regnum, gregs);
 231 }
 232
 233 static void
 234 sparc32_linux_supply_core_fpregset (const struct regset *regset,
 235                                     struct regcache *regcache,
 236                                     int regnum, const void *fpregs, size_t len)
 237 {
 238   sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
 239 }
 240
 241 static void
 242 sparc32_linux_collect_core_fpregset (const struct regset *regset,
 243                                      const struct regcache *regcache,
 244                                      int regnum, void *fpregs, size_t len)
 245 {
 246   sparc32_collect_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
 247 }
 248
 249 /* Set the program counter for process PTID to PC.  */
 250
 251 #define PSR_SYSCALL     0x00004000
 252
 253 static void
 254 sparc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 255 {
 256   gdbarch *arch = regcache->arch ();
 257   sparc_gdbarch_tdep *tdep = (sparc_gdbarch_tdep *) gdbarch_tdep (arch);
 258   ULONGEST psr;
 259
 260   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
 261   regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
 262
 263   /* Clear the "in syscall" bit to prevent the kernel from
 264      messing with the PCs we just installed, if we happen to be
 265      within an interrupted system call that the kernel wants to
 266      restart.
 267
 268      Note that after we return from the dummy call, the PSR et al.
 269      registers will be automatically restored, and the kernel
 270      continues to restart the system call at this point.  */
 271   regcache_cooked_read_unsigned (regcache, SPARC32_PSR_REGNUM, &psr);
 272   psr &= ~PSR_SYSCALL;
 273   regcache_cooked_write_unsigned (regcache, SPARC32_PSR_REGNUM, psr);
 274 }
 275
 276 static LONGEST
 277 sparc32_linux_get_syscall_number (struct gdbarch *gdbarch,
 278                                   thread_info *thread)
 279 {
 280   struct regcache *regcache = get_thread_regcache (thread);
 281   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 282   /* The content of a register.  */
 283   gdb_byte buf[4];
 284   /* The result.  */
 285   LONGEST ret;
 286
 287   /* Getting the system call number from the register.
 288      When dealing with the sparc architecture, this information
 289      is stored at the %g1 register.  */
 290   regcache->cooked_read (SPARC_G1_REGNUM, buf);
 291
 292   ret = extract_signed_integer (buf, 4, byte_order);
 293
 294   return ret;
 295 }
 296
 297 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
 298    gdbarch.h.  */
 299
 300 static enum gdb_signal
 301 sparc32_linux_gdb_signal_from_target (struct gdbarch *gdbarch,
 302                                       int signal)
 303 {
 304   switch (signal)
 305     {
 306     case SPARC_LINUX_SIGEMT:
 307       return GDB_SIGNAL_EMT;
 308
 309     case SPARC_LINUX_SIGBUS:
 310       return GDB_SIGNAL_BUS;
 311
 312     case SPARC_LINUX_SIGSYS:
 313       return GDB_SIGNAL_SYS;
 314
 315     case SPARC_LINUX_SIGURG:
 316       return GDB_SIGNAL_URG;
 317
 318     case SPARC_LINUX_SIGSTOP:
 319       return GDB_SIGNAL_STOP;
 320
 321     case SPARC_LINUX_SIGTSTP:
 322       return GDB_SIGNAL_TSTP;
 323
 324     case SPARC_LINUX_SIGCONT:
 325       return GDB_SIGNAL_CONT;
 326
 327     case SPARC_LINUX_SIGCHLD:
 328       return GDB_SIGNAL_CHLD;
 329
 330     /* No way to differentiate between SIGIO and SIGPOLL.
 331        Therefore, we just handle the first one.  */
 332     case SPARC_LINUX_SIGIO:
 333       return GDB_SIGNAL_IO;
 334
 335     /* No way to differentiate between SIGLOST and SIGPWR.
 336        Therefore, we just handle the first one.  */
 337     case SPARC_LINUX_SIGLOST:
 338       return GDB_SIGNAL_LOST;
 339
 340     case SPARC_LINUX_SIGUSR1:
 341       return GDB_SIGNAL_USR1;
 342
 343     case SPARC_LINUX_SIGUSR2:
 344       return GDB_SIGNAL_USR2;
 345     }
 346
 347   return linux_gdb_signal_from_target (gdbarch, signal);
 348 }
 349
 350 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
 351    gdbarch.h.  */
 352
 353 static int
 354 sparc32_linux_gdb_signal_to_target (struct gdbarch *gdbarch,
 355                                     enum gdb_signal signal)
 356 {
 357   switch (signal)
 358     {
 359     case GDB_SIGNAL_EMT:
 360       return SPARC_LINUX_SIGEMT;
 361
 362     case GDB_SIGNAL_BUS:
 363       return SPARC_LINUX_SIGBUS;
 364
 365     case GDB_SIGNAL_SYS:
 366       return SPARC_LINUX_SIGSYS;
 367
 368     case GDB_SIGNAL_URG:
 369       return SPARC_LINUX_SIGURG;
 370
 371     case GDB_SIGNAL_STOP:
 372       return SPARC_LINUX_SIGSTOP;
 373
 374     case GDB_SIGNAL_TSTP:
 375       return SPARC_LINUX_SIGTSTP;
 376
 377     case GDB_SIGNAL_CONT:
 378       return SPARC_LINUX_SIGCONT;
 379
 380     case GDB_SIGNAL_CHLD:
 381       return SPARC_LINUX_SIGCHLD;
 382
 383     case GDB_SIGNAL_IO:
 384       return SPARC_LINUX_SIGIO;
 385
 386     case GDB_SIGNAL_POLL:
 387       return SPARC_LINUX_SIGPOLL;
 388
 389     case GDB_SIGNAL_LOST:
 390       return SPARC_LINUX_SIGLOST;
 391
 392     case GDB_SIGNAL_PWR:
 393       return SPARC_LINUX_SIGPWR;
 394
 395     case GDB_SIGNAL_USR1:
 396       return SPARC_LINUX_SIGUSR1;
 397
 398     case GDB_SIGNAL_USR2:
 399       return SPARC_LINUX_SIGUSR2;
 400     }
 401
 402   return linux_gdb_signal_to_target (gdbarch, signal);
 403 }
 404
 405 \f
 406
 407 static const struct regset sparc32_linux_gregset =
 408   {
 409     NULL,
 410     sparc32_linux_supply_core_gregset,
 411     sparc32_linux_collect_core_gregset
 412   };
 413
 414 static const struct regset sparc32_linux_fpregset =
 415   {
 416     NULL,
 417     sparc32_linux_supply_core_fpregset,
 418     sparc32_linux_collect_core_fpregset
 419   };
 420
 421 static void
 422 sparc32_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 423 {
 424   sparc_gdbarch_tdep *tdep = (sparc_gdbarch_tdep *) gdbarch_tdep (gdbarch);
 425
 426   linux_init_abi (info, gdbarch, 0);
 427
 428   tdep->gregset = &sparc32_linux_gregset;
 429   tdep->sizeof_gregset = 152;
 430
 431   tdep->fpregset = &sparc32_linux_fpregset;
 432   tdep->sizeof_fpregset = 396;
 433
 434   tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_sigframe);
 435   tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_rt_sigframe);
 436
 437   /* GNU/Linux has SVR4-style shared libraries...  */
 438   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 439   set_solib_svr4_fetch_link_map_offsets
 440     (gdbarch, linux_ilp32_fetch_link_map_offsets);
 441
 442   /* ...which means that we need some special handling when doing
 443      prologue analysis.  */
 444   tdep->plt_entry_size = 12;
 445
 446   /* Enable TLS support.  */
 447   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 448                                              svr4_fetch_objfile_link_map);
 449
 450   /* Make sure we can single-step over signal return system calls.  */
 451   tdep->step_trap = sparc32_linux_step_trap;
 452
 453   /* Hook in the DWARF CFI frame unwinder.  */
 454   dwarf2_append_unwinders (gdbarch);
 455
 456   set_gdbarch_write_pc (gdbarch, sparc_linux_write_pc);
 457
 458   /* Functions for 'catch syscall'.  */
 459   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC32);
 460   set_gdbarch_get_syscall_number (gdbarch,
 461                                   sparc32_linux_get_syscall_number);
 462
 463   set_gdbarch_gdb_signal_from_target (gdbarch,
 464                                       sparc32_linux_gdb_signal_from_target);
 465   set_gdbarch_gdb_signal_to_target (gdbarch,
 466                                     sparc32_linux_gdb_signal_to_target);
 467 }
 468
 469 void _initialize_sparc_linux_tdep ();
 470 void
 471 _initialize_sparc_linux_tdep ()
 472 {
 473   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
 474                           sparc32_linux_init_abi);
 475 }