gdb/sparc-nat.c

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