gdb/sparc-nat.c

   1 /* Native-dependent code for SPARC.
   2
   3    Copyright (C) 2003-2025 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 "inferior.h"
  21 #include "regcache.h"
  22 #include "target.h"
  23
  24 #include <signal.h>
  25 #include <sys/ptrace.h>
  26 #include "gdbsupport/gdb_wait.h"
  27 #ifdef HAVE_MACHINE_REG_H
  28 #include <machine/reg.h>
  29 #endif
  30
  31 #include "sparc-tdep.h"
  32 #include "sparc-nat.h"
  33 #include "inf-ptrace.h"
  34
  35 /* With some trickery we can use the code in this file for most (if
  36    not all) ptrace(2) based SPARC systems, which includes SunOS 4,
  37    GNU/Linux and the various SPARC BSD's.
  38
  39    First, we need a data structure for use with ptrace(2).  SunOS has
  40    `struct regs' and `struct fp_status' in <machine/reg.h>.  BSD's
  41    have `struct reg' and `struct fpreg' in <machine/reg.h>.  GNU/Linux
  42    has the same structures as SunOS 4, but they're in <asm/reg.h>,
  43    which is a kernel header.  As a general rule we avoid including
  44    GNU/Linux kernel headers.  Fortunately GNU/Linux has a `gregset_t'
  45    and a `fpregset_t' that are equivalent to `struct regs' and `struct
  46    fp_status' in <sys/ucontext.h>, which is automatically included by
  47    <signal.h>.  Settling on using the `gregset_t' and `fpregset_t'
  48    typedefs, providing them for the other systems, therefore solves
  49    the puzzle.  */
  50
  51 #ifdef HAVE_MACHINE_REG_H
  52 #ifdef HAVE_STRUCT_REG
  53 typedef struct reg gregset_t;
  54 typedef struct fpreg fpregset_t;
  55 #else
  56 typedef struct regs gregset_t;
  57 typedef struct fp_status fpregset_t;
  58 #endif
  59 #endif
  60
  61 /* Second, we need to remap the BSD ptrace(2) requests to their SunOS
  62    equivalents.  GNU/Linux already follows SunOS here.  */
  63
  64 #ifndef PTRACE_GETREGS
  65 #define PTRACE_GETREGS PT_GETREGS
  66 #endif
  67
  68 #ifndef PTRACE_SETREGS
  69 #define PTRACE_SETREGS PT_SETREGS
  70 #endif
  71
  72 #ifndef PTRACE_GETFPREGS
  73 #define PTRACE_GETFPREGS PT_GETFPREGS
  74 #endif
  75
  76 #ifndef PTRACE_SETFPREGS
  77 #define PTRACE_SETFPREGS PT_SETFPREGS
  78 #endif
  79
  80 static PTRACE_TYPE_RET
  81 gdb_ptrace (PTRACE_TYPE_ARG1 request, ptid_t ptid, PTRACE_TYPE_ARG3 addr)
  82 {
  83 #ifdef __NetBSD__
  84   /* Support for NetBSD threads: unlike other ptrace implementations in this
  85      file, NetBSD requires that we pass both the pid and lwp.  */
  86   return ptrace (request, ptid.pid (), addr, ptid.lwp ());
  87 #else
  88   pid_t pid = get_ptrace_pid (ptid);
  89   return ptrace (request, pid, addr, 0);
  90 #endif
  91 }
  92
  93 /* Register set description.  */
  94 const struct sparc_gregmap *sparc_gregmap;
  95 const struct sparc_fpregmap *sparc_fpregmap;
  96 void (*sparc_supply_gregset) (const struct sparc_gregmap *,
  97                               struct regcache *, int , const void *);
  98 void (*sparc_collect_gregset) (const struct sparc_gregmap *,
  99                                const struct regcache *, int, void *);
 100 void (*sparc_supply_fpregset) (const struct sparc_fpregmap *,
 101                                struct regcache *, int , const void *);
 102 void (*sparc_collect_fpregset) (const struct sparc_fpregmap *,
 103                                 const struct regcache *, int , void *);
 104 int (*sparc_gregset_supplies_p) (struct gdbarch *, int);
 105 int (*sparc_fpregset_supplies_p) (struct gdbarch *, int);
 106
 107 /* Determine whether `gregset_t' contains register REGNUM.  */
 108
 109 int
 110 sparc32_gregset_supplies_p (struct gdbarch *gdbarch, int regnum)
 111 {
 112   /* Integer registers.  */
 113   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM)
 114       || (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
 115       || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM)
 116       || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM))
 117     return 1;
 118
 119   /* Control registers.  */
 120   if (regnum == SPARC32_PC_REGNUM
 121       || regnum == SPARC32_NPC_REGNUM
 122       || regnum == SPARC32_PSR_REGNUM
 123       || regnum == SPARC32_Y_REGNUM)
 124     return 1;
 125
 126   return 0;
 127 }
 128
 129 /* Determine whether `fpregset_t' contains register REGNUM.  */
 130
 131 int
 132 sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, int regnum)
 133 {
 134   /* Floating-point registers.  */
 135   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
 136     return 1;
 137
 138   /* Control registers.  */
 139   if (regnum == SPARC32_FSR_REGNUM)
 140     return 1;
 141
 142   return 0;
 143 }
 144
 145 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 146    for all registers (including the floating-point registers).  */
 147
 148 void
 149 sparc_fetch_inferior_registers (process_stratum_target *proc_target,
 150                                 regcache *regcache, int regnum)
 151 {
 152   struct gdbarch *gdbarch = regcache->arch ();
 153   ptid_t ptid = regcache->ptid ();
 154
 155   if (regnum == SPARC_G0_REGNUM)
 156     {
 157       regcache->raw_supply_zeroed (SPARC_G0_REGNUM);
 158       return;
 159     }
 160
 161   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 162     {
 163       gregset_t regs;
 164
 165       if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs) == -1)
 166         perror_with_name (_("Couldn't get registers"));
 167
 168       /* Deep down, sparc_supply_rwindow reads memory, so needs the global
 169          thread context to be set.  */
 170       scoped_restore restore_inferior_ptid
 171         = make_scoped_restore (&inferior_ptid, ptid);
 172
 173       sparc_supply_gregset (sparc_gregmap, regcache, -1, &regs);
 174       if (regnum != -1)
 175         return;
 176     }
 177
 178   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
 179     {
 180       fpregset_t fpregs;
 181
 182       if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1)
 183         perror_with_name (_("Couldn't get floating point status"));
 184
 185       sparc_supply_fpregset (sparc_fpregmap, regcache, -1, &fpregs);
 186     }
 187 }
 188
 189 void
 190 sparc_store_inferior_registers (process_stratum_target *proc_target,
 191                                 regcache *regcache, int regnum)
 192 {
 193   struct gdbarch *gdbarch = regcache->arch ();
 194   ptid_t ptid = regcache->ptid ();
 195
 196   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 197     {
 198       gregset_t regs;
 199
 200       if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs) == -1)
 201         perror_with_name (_("Couldn't get registers"));
 202
 203       sparc_collect_gregset (sparc_gregmap, regcache, regnum, &regs);
 204
 205       if (gdb_ptrace (PTRACE_SETREGS, ptid, (PTRACE_TYPE_ARG3) &regs) == -1)
 206         perror_with_name (_("Couldn't write registers"));
 207
 208       /* Deal with the stack regs.  */
 209       if (regnum == -1 || regnum == SPARC_SP_REGNUM
 210           || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM))
 211         {
 212           ULONGEST sp;
 213
 214           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
 215
 216           /* Deep down, sparc_collect_rwindow writes memory, so needs the global
 217              thread context to be set.  */
 218           scoped_restore restore_inferior_ptid
 219             = make_scoped_restore (&inferior_ptid, ptid);
 220
 221           sparc_collect_rwindow (regcache, sp, regnum);
 222         }
 223
 224       if (regnum != -1)
 225         return;
 226     }
 227
 228   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
 229     {
 230       fpregset_t fpregs, saved_fpregs;
 231
 232       if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1)
 233         perror_with_name (_("Couldn't get floating-point registers"));
 234
 235       memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
 236       sparc_collect_fpregset (sparc_fpregmap, regcache, regnum, &fpregs);
 237
 238       /* Writing the floating-point registers will fail on NetBSD with
 239          EINVAL if the inferior process doesn't have an FPU state
 240          (i.e. if it didn't use the FPU yet).  Therefore we don't try
 241          to write the registers if nothing changed.  */
 242       if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0)
 243         {
 244           if (gdb_ptrace (PTRACE_SETFPREGS, ptid,
 245                           (PTRACE_TYPE_ARG3) &fpregs) == -1)
 246             perror_with_name (_("Couldn't write floating-point registers"));
 247         }
 248
 249       if (regnum != -1)
 250         return;
 251     }
 252 }
 253
 254 \f
 255 /* Implement the to_xfer_partial target_ops method for
 256    TARGET_OBJECT_WCOOKIE.  Fetch StackGhost Per-Process XOR cookie.  */
 257
 258 enum target_xfer_status
 259 sparc_xfer_wcookie (enum target_object object,
 260                     const char *annex, gdb_byte *readbuf,
 261                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
 262                     ULONGEST *xfered_len)
 263 {
 264   unsigned long wcookie = 0;
 265   char *buf = (char *)&wcookie;
 266
 267   gdb_assert (object == TARGET_OBJECT_WCOOKIE);
 268   gdb_assert (readbuf && writebuf == NULL);
 269
 270   if (offset == sizeof (unsigned long))
 271     return TARGET_XFER_EOF;                     /* Signal EOF.  */
 272   if (offset > sizeof (unsigned long))
 273     return TARGET_XFER_E_IO;
 274
 275 #ifdef PT_WCOOKIE
 276   /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
 277      running on an OpenBSD release that uses StackGhost (3.1 or
 278      later).  Since release 3.6, OpenBSD uses a fully randomized
 279      cookie.  */
 280   {
 281     int pid = inferior_ptid.pid ();
 282
 283     /* Sanity check.  The proper type for a cookie is register_t, but
 284        we can't assume that this type exists on all systems supported
 285        by the code in this file.  */
 286     gdb_assert (sizeof (wcookie) == sizeof (register_t));
 287
 288     /* Fetch the cookie.  */
 289     if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
 290       {
 291         if (errno != EINVAL)
 292           perror_with_name (_("Couldn't get StackGhost cookie"));
 293
 294         /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
 295            the request wasn't implemented until after OpenBSD 3.4.  If
 296            the kernel doesn't support the PT_WCOOKIE request, assume
 297            we're running on a kernel that uses non-randomized cookies.  */
 298         wcookie = 0x3;
 299       }
 300   }
 301 #endif /* PT_WCOOKIE */
 302
 303   if (len > sizeof (unsigned long) - offset)
 304     len = sizeof (unsigned long) - offset;
 305
 306   memcpy (readbuf, buf + offset, len);
 307   *xfered_len = (ULONGEST) len;
 308   return TARGET_XFER_OK;
 309 }
 310 \f
 311
 312 INIT_GDB_FILE (sparc_nat)
 313 {
 314   /* Default to using SunOS 4 register sets.  */
 315   if (sparc_gregmap == NULL)
 316     sparc_gregmap = &sparc32_sunos4_gregmap;
 317   if (sparc_fpregmap == NULL)
 318     sparc_fpregmap = &sparc32_sunos4_fpregmap;
 319   if (sparc_supply_gregset == NULL)
 320     sparc_supply_gregset = sparc32_supply_gregset;
 321   if (sparc_collect_gregset == NULL)
 322     sparc_collect_gregset = sparc32_collect_gregset;
 323   if (sparc_supply_fpregset == NULL)
 324     sparc_supply_fpregset = sparc32_supply_fpregset;
 325   if (sparc_collect_fpregset == NULL)
 326     sparc_collect_fpregset = sparc32_collect_fpregset;
 327   if (sparc_gregset_supplies_p == NULL)
 328     sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
 329   if (sparc_fpregset_supplies_p == NULL)
 330     sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
 331 }