gdb/sparc-nat.c

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