gdb/sparc-nat.c

   1 /* Native-dependent code for SPARC.
   2
   3    Copyright (C) 2003-2014 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 "gdb_assert.h"
  26 #include <signal.h>
  27 #include <string.h>
  28 #include <sys/ptrace.h>
  29 #include "gdb_wait.h"
  30 #ifdef HAVE_MACHINE_REG_H
  31 #include <machine/reg.h>
  32 #endif
  33
  34 #include "sparc-tdep.h"
  35 #include "sparc-nat.h"
  36 #include "inf-ptrace.h"
  37
  38 /* With some trickery we can use the code in this file for most (if
  39    not all) ptrace(2) based SPARC systems, which includes SunOS 4,
  40    GNU/Linux and the various SPARC BSD's.
  41
  42    First, we need a data structure for use with ptrace(2).  SunOS has
  43    `struct regs' and `struct fp_status' in <machine/reg.h>.  BSD's
  44    have `struct reg' and `struct fpreg' in <machine/reg.h>.  GNU/Linux
  45    has the same structures as SunOS 4, but they're in <asm/reg.h>,
  46    which is a kernel header.  As a general rule we avoid including
  47    GNU/Linux kernel headers.  Fortunately GNU/Linux has a `gregset_t'
  48    and a `fpregset_t' that are equivalent to `struct regs' and `struct
  49    fp_status' in <sys/ucontext.h>, which is automatically included by
  50    <signal.h>.  Settling on using the `gregset_t' and `fpregset_t'
  51    typedefs, providing them for the other systems, therefore solves
  52    the puzzle.  */
  53
  54 #ifdef HAVE_MACHINE_REG_H
  55 #ifdef HAVE_STRUCT_REG
  56 typedef struct reg gregset_t;
  57 typedef struct fpreg fpregset_t;
  58 #else
  59 typedef struct regs gregset_t;
  60 typedef struct fp_status fpregset_t;
  61 #endif
  62 #endif
  63
  64 /* Second, we need to remap the BSD ptrace(2) requests to their SunOS
  65    equivalents.  GNU/Linux already follows SunOS here.  */
  66
  67 #ifndef PTRACE_GETREGS
  68 #define PTRACE_GETREGS PT_GETREGS
  69 #endif
  70
  71 #ifndef PTRACE_SETREGS
  72 #define PTRACE_SETREGS PT_SETREGS
  73 #endif
  74
  75 #ifndef PTRACE_GETFPREGS
  76 #define PTRACE_GETFPREGS PT_GETFPREGS
  77 #endif
  78
  79 #ifndef PTRACE_SETFPREGS
  80 #define PTRACE_SETFPREGS PT_SETFPREGS
  81 #endif
  82
  83 /* Register set description.  */
  84 const struct sparc_gregset *sparc_gregset;
  85 const struct sparc_fpregset *sparc_fpregset;
  86 void (*sparc_supply_gregset) (const struct sparc_gregset *,
  87                               struct regcache *, int , const void *);
  88 void (*sparc_collect_gregset) (const struct sparc_gregset *,
  89                                const struct regcache *, int, void *);
  90 void (*sparc_supply_fpregset) (const struct sparc_fpregset *,
  91                                struct regcache *, int , const void *);
  92 void (*sparc_collect_fpregset) (const struct sparc_fpregset *,
  93                                 const struct regcache *, int , void *);
  94 int (*sparc_gregset_supplies_p) (struct gdbarch *, int);
  95 int (*sparc_fpregset_supplies_p) (struct gdbarch *, int);
  96
  97 /* Determine whether `gregset_t' contains register REGNUM.  */
  98
  99 int
 100 sparc32_gregset_supplies_p (struct gdbarch *gdbarch, int regnum)
 101 {
 102   /* Integer registers.  */
 103   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM)
 104       || (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
 105       || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM)
 106       || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM))
 107     return 1;
 108
 109   /* Control registers.  */
 110   if (regnum == SPARC32_PC_REGNUM
 111       || regnum == SPARC32_NPC_REGNUM
 112       || regnum == SPARC32_PSR_REGNUM
 113       || regnum == SPARC32_Y_REGNUM)
 114     return 1;
 115
 116   return 0;
 117 }
 118
 119 /* Determine whether `fpregset_t' contains register REGNUM.  */
 120
 121 int
 122 sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, int regnum)
 123 {
 124   /* Floating-point registers.  */
 125   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
 126     return 1;
 127
 128   /* Control registers.  */
 129   if (regnum == SPARC32_FSR_REGNUM)
 130     return 1;
 131
 132   return 0;
 133 }
 134
 135 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 136    for all registers (including the floating-point registers).  */
 137
 138 void
 139 sparc_fetch_inferior_registers (struct target_ops *ops,
 140                                 struct regcache *regcache, int regnum)
 141 {
 142   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 143   int pid;
 144
 145   /* NOTE: cagney/2002-12-03: This code assumes that the currently
 146      selected light weight processes' registers can be written
 147      directly into the selected thread's register cache.  This works
 148      fine when given an 1:1 LWP:thread model (such as found on
 149      GNU/Linux) but will, likely, have problems when used on an N:1
 150      (userland threads) or N:M (userland multiple LWP) model.  In the
 151      case of the latter two, the LWP's registers do not necessarily
 152      belong to the selected thread (the LWP could be in the middle of
 153      executing the thread switch code).
 154
 155      These functions should instead be paramaterized with an explicit
 156      object (struct regcache, struct thread_info?) into which the LWPs
 157      registers can be written.  */
 158   pid = ptid_get_lwp (inferior_ptid);
 159   if (pid == 0)
 160     pid = ptid_get_pid (inferior_ptid);
 161
 162   if (regnum == SPARC_G0_REGNUM)
 163     {
 164       gdb_byte zero[8] = { 0 };
 165
 166       regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
 167       return;
 168     }
 169
 170   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 171     {
 172       gregset_t regs;
 173
 174       if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 175         perror_with_name (_("Couldn't get registers"));
 176
 177       sparc_supply_gregset (sparc_gregset, 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 (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 187         perror_with_name (_("Couldn't get floating point status"));
 188
 189       sparc_supply_fpregset (sparc_fpregset, regcache, -1, &fpregs);
 190     }
 191 }
 192
 193 void
 194 sparc_store_inferior_registers (struct target_ops *ops,
 195                                 struct regcache *regcache, int regnum)
 196 {
 197   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 198   int pid;
 199
 200   /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers
 201      about threaded assumptions.  */
 202   pid = ptid_get_lwp (inferior_ptid);
 203   if (pid == 0)
 204     pid = ptid_get_pid (inferior_ptid);
 205
 206   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 207     {
 208       gregset_t regs;
 209
 210       if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 211         perror_with_name (_("Couldn't get registers"));
 212
 213       sparc_collect_gregset (sparc_gregset, regcache, regnum, &regs);
 214
 215       if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 216         perror_with_name (_("Couldn't write registers"));
 217
 218       /* Deal with the stack regs.  */
 219       if (regnum == -1 || regnum == SPARC_SP_REGNUM
 220           || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM))
 221         {
 222           ULONGEST sp;
 223
 224           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
 225           sparc_collect_rwindow (regcache, sp, regnum);
 226         }
 227
 228       if (regnum != -1)
 229         return;
 230     }
 231
 232   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
 233     {
 234       fpregset_t fpregs, saved_fpregs;
 235
 236       if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 237         perror_with_name (_("Couldn't get floating-point registers"));
 238
 239       memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
 240       sparc_collect_fpregset (sparc_fpregset, regcache, regnum, &fpregs);
 241
 242       /* Writing the floating-point registers will fail on NetBSD with
 243          EINVAL if the inferior process doesn't have an FPU state
 244          (i.e. if it didn't use the FPU yet).  Therefore we don't try
 245          to write the registers if nothing changed.  */
 246       if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0)
 247         {
 248           if (ptrace (PTRACE_SETFPREGS, pid,
 249                       (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 250             perror_with_name (_("Couldn't write floating-point registers"));
 251         }
 252
 253       if (regnum != -1)
 254         return;
 255     }
 256 }
 257
 258 \f
 259 /* Fetch StackGhost Per-Process XOR cookie.  */
 260
 261 static enum target_xfer_status
 262 sparc_xfer_wcookie (struct target_ops *ops, enum target_object object,
 263                     const char *annex, gdb_byte *readbuf,
 264                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
 265                     ULONGEST *xfered_len)
 266 {
 267   unsigned long wcookie = 0;
 268   char *buf = (char *)&wcookie;
 269
 270   gdb_assert (object == TARGET_OBJECT_WCOOKIE);
 271   gdb_assert (readbuf && writebuf == NULL);
 272
 273   if (offset == sizeof (unsigned long))
 274     return TARGET_XFER_EOF;                     /* Signal EOF.  */
 275   if (offset > sizeof (unsigned long))
 276     return TARGET_XFER_E_IO;
 277
 278 #ifdef PT_WCOOKIE
 279   /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
 280      running on an OpenBSD release that uses StackGhost (3.1 or
 281      later).  Since release 3.6, OpenBSD uses a fully randomized
 282      cookie.  */
 283   {
 284     int pid;
 285
 286     pid = ptid_get_lwp (inferior_ptid);
 287     if (pid == 0)
 288       pid = ptid_get_pid (inferior_ptid);
 289
 290     /* Sanity check.  The proper type for a cookie is register_t, but
 291        we can't assume that this type exists on all systems supported
 292        by the code in this file.  */
 293     gdb_assert (sizeof (wcookie) == sizeof (register_t));
 294
 295     /* Fetch the cookie.  */
 296     if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
 297       {
 298         if (errno != EINVAL)
 299           perror_with_name (_("Couldn't get StackGhost cookie"));
 300
 301         /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
 302            the request wasn't implemented until after OpenBSD 3.4.  If
 303            the kernel doesn't support the PT_WCOOKIE request, assume
 304            we're running on a kernel that uses non-randomized cookies.  */
 305         wcookie = 0x3;
 306       }
 307   }
 308 #endif /* PT_WCOOKIE */
 309
 310   if (len > sizeof (unsigned long) - offset)
 311     len = sizeof (unsigned long) - offset;
 312
 313   memcpy (readbuf, buf + offset, len);
 314   *xfered_len = (ULONGEST) len;
 315   return TARGET_XFER_OK;
 316 }
 317
 318 target_xfer_partial_ftype *inf_ptrace_xfer_partial;
 319
 320 static enum target_xfer_status
 321 sparc_xfer_partial (struct target_ops *ops, enum target_object object,
 322                     const char *annex, gdb_byte *readbuf,
 323                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
 324                     ULONGEST *xfered_len)
 325 {
 326   if (object == TARGET_OBJECT_WCOOKIE)
 327     return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf,
 328                                offset, len, xfered_len);
 329
 330   return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf,
 331                                   offset, len, xfered_len);
 332 }
 333 \f
 334 /* Create a prototype generic SPARC target.  The client can override
 335    it with local methods.  */
 336
 337 struct target_ops *
 338 sparc_target (void)
 339 {
 340   struct target_ops *t;
 341
 342   t = inf_ptrace_target ();
 343   t->to_fetch_registers = sparc_fetch_inferior_registers;
 344   t->to_store_registers = sparc_store_inferior_registers;
 345   inf_ptrace_xfer_partial = t->to_xfer_partial;
 346   t->to_xfer_partial = sparc_xfer_partial;
 347   return t;
 348 }
 349
 350 \f
 351 /* Provide a prototype to silence -Wmissing-prototypes.  */
 352 void _initialize_sparc_nat (void);
 353
 354 void
 355 _initialize_sparc_nat (void)
 356 {
 357   /* Deafult to using SunOS 4 register sets.  */
 358   if (sparc_gregset == NULL)
 359     sparc_gregset = &sparc32_sunos4_gregset;
 360   if (sparc_fpregset == NULL)
 361     sparc_fpregset = &sparc32_sunos4_fpregset;
 362   if (sparc_supply_gregset == NULL)
 363     sparc_supply_gregset = sparc32_supply_gregset;
 364   if (sparc_collect_gregset == NULL)
 365     sparc_collect_gregset = sparc32_collect_gregset;
 366   if (sparc_supply_fpregset == NULL)
 367     sparc_supply_fpregset = sparc32_supply_fpregset;
 368   if (sparc_collect_fpregset == NULL)
 369     sparc_collect_fpregset = sparc32_collect_fpregset;
 370   if (sparc_gregset_supplies_p == NULL)
 371     sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
 372   if (sparc_fpregset_supplies_p == NULL)
 373     sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
 374 }