gdb/sparc-nat.c

   1 /* Native-dependent code for SPARC.
   2
   3    Copyright (C) 2003-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 "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       gdb_byte zero[8] = { 0 };
 158
 159       regcache->raw_supply (SPARC_G0_REGNUM, &zero);
 160       return;
 161     }
 162
 163   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 164     {
 165       gregset_t regs;
 166
 167       if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs) == -1)
 168         perror_with_name (_("Couldn't get registers"));
 169
 170       /* Deep down, sparc_supply_rwindow reads memory, so needs the global
 171          thread context to be set.  */
 172       scoped_restore restore_inferior_ptid
 173         = make_scoped_restore (&inferior_ptid, ptid);
 174
 175       sparc_supply_gregset (sparc_gregmap, regcache, -1, &regs);
 176       if (regnum != -1)
 177         return;
 178     }
 179
 180   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
 181     {
 182       fpregset_t fpregs;
 183
 184       if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1)
 185         perror_with_name (_("Couldn't get floating point status"));
 186
 187       sparc_supply_fpregset (sparc_fpregmap, regcache, -1, &fpregs);
 188     }
 189 }
 190
 191 void
 192 sparc_store_inferior_registers (process_stratum_target *proc_target,
 193                                 regcache *regcache, int regnum)
 194 {
 195   struct gdbarch *gdbarch = regcache->arch ();
 196   ptid_t ptid = regcache->ptid ();
 197
 198   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 199     {
 200       gregset_t regs;
 201
 202       if (gdb_ptrace (PTRACE_GETREGS, ptid, (PTRACE_TYPE_ARG3) &regs) == -1)
 203         perror_with_name (_("Couldn't get registers"));
 204
 205       sparc_collect_gregset (sparc_gregmap, regcache, regnum, &regs);
 206
 207       if (gdb_ptrace (PTRACE_SETREGS, ptid, (PTRACE_TYPE_ARG3) &regs) == -1)
 208         perror_with_name (_("Couldn't write registers"));
 209
 210       /* Deal with the stack regs.  */
 211       if (regnum == -1 || regnum == SPARC_SP_REGNUM
 212           || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM))
 213         {
 214           ULONGEST sp;
 215
 216           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
 217
 218           /* Deep down, sparc_collect_rwindow writes memory, so needs the global
 219              thread context to be set.  */
 220           scoped_restore restore_inferior_ptid
 221             = make_scoped_restore (&inferior_ptid, ptid);
 222
 223           sparc_collect_rwindow (regcache, sp, regnum);
 224         }
 225
 226       if (regnum != -1)
 227         return;
 228     }
 229
 230   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
 231     {
 232       fpregset_t fpregs, saved_fpregs;
 233
 234       if (gdb_ptrace (PTRACE_GETFPREGS, ptid, (PTRACE_TYPE_ARG3) &fpregs) == -1)
 235         perror_with_name (_("Couldn't get floating-point registers"));
 236
 237       memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
 238       sparc_collect_fpregset (sparc_fpregmap, regcache, regnum, &fpregs);
 239
 240       /* Writing the floating-point registers will fail on NetBSD with
 241          EINVAL if the inferior process doesn't have an FPU state
 242          (i.e. if it didn't use the FPU yet).  Therefore we don't try
 243          to write the registers if nothing changed.  */
 244       if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0)
 245         {
 246           if (gdb_ptrace (PTRACE_SETFPREGS, ptid,
 247                           (PTRACE_TYPE_ARG3) &fpregs) == -1)
 248             perror_with_name (_("Couldn't write floating-point registers"));
 249         }
 250
 251       if (regnum != -1)
 252         return;
 253     }
 254 }
 255
 256 \f
 257 /* Implement the to_xfer_partial target_ops method for
 258    TARGET_OBJECT_WCOOKIE.  Fetch StackGhost Per-Process XOR cookie.  */
 259
 260 enum target_xfer_status
 261 sparc_xfer_wcookie (enum target_object object,
 262                     const char *annex, gdb_byte *readbuf,
 263                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
 264                     ULONGEST *xfered_len)
 265 {
 266   unsigned long wcookie = 0;
 267   char *buf = (char *)&wcookie;
 268
 269   gdb_assert (object == TARGET_OBJECT_WCOOKIE);
 270   gdb_assert (readbuf && writebuf == NULL);
 271
 272   if (offset == sizeof (unsigned long))
 273     return TARGET_XFER_EOF;                     /* Signal EOF.  */
 274   if (offset > sizeof (unsigned long))
 275     return TARGET_XFER_E_IO;
 276
 277 #ifdef PT_WCOOKIE
 278   /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
 279      running on an OpenBSD release that uses StackGhost (3.1 or
 280      later).  Since release 3.6, OpenBSD uses a fully randomized
 281      cookie.  */
 282   {
 283     int pid = inferior_ptid.pid ();
 284
 285     /* Sanity check.  The proper type for a cookie is register_t, but
 286        we can't assume that this type exists on all systems supported
 287        by the code in this file.  */
 288     gdb_assert (sizeof (wcookie) == sizeof (register_t));
 289
 290     /* Fetch the cookie.  */
 291     if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
 292       {
 293         if (errno != EINVAL)
 294           perror_with_name (_("Couldn't get StackGhost cookie"));
 295
 296         /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
 297            the request wasn't implemented until after OpenBSD 3.4.  If
 298            the kernel doesn't support the PT_WCOOKIE request, assume
 299            we're running on a kernel that uses non-randomized cookies.  */
 300         wcookie = 0x3;
 301       }
 302   }
 303 #endif /* PT_WCOOKIE */
 304
 305   if (len > sizeof (unsigned long) - offset)
 306     len = sizeof (unsigned long) - offset;
 307
 308   memcpy (readbuf, buf + offset, len);
 309   *xfered_len = (ULONGEST) len;
 310   return TARGET_XFER_OK;
 311 }
 312 \f
 313
 314 void _initialize_sparc_nat ();
 315 void
 316 _initialize_sparc_nat ()
 317 {
 318   /* Default to using SunOS 4 register sets.  */
 319   if (sparc_gregmap == NULL)
 320     sparc_gregmap = &sparc32_sunos4_gregmap;
 321   if (sparc_fpregmap == NULL)
 322     sparc_fpregmap = &sparc32_sunos4_fpregmap;
 323   if (sparc_supply_gregset == NULL)
 324     sparc_supply_gregset = sparc32_supply_gregset;
 325   if (sparc_collect_gregset == NULL)
 326     sparc_collect_gregset = sparc32_collect_gregset;
 327   if (sparc_supply_fpregset == NULL)
 328     sparc_supply_fpregset = sparc32_supply_fpregset;
 329   if (sparc_collect_fpregset == NULL)
 330     sparc_collect_fpregset = sparc32_collect_fpregset;
 331   if (sparc_gregset_supplies_p == NULL)
 332     sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
 333   if (sparc_fpregset_supplies_p == NULL)
 334     sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
 335 }