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_gregmap *sparc_gregmap;
  85 const struct sparc_fpregmap *sparc_fpregmap;
  86 void (*sparc_supply_gregset) (const struct sparc_gregmap *,
  87                               struct regcache *, int , const void *);
  88 void (*sparc_collect_gregset) (const struct sparc_gregmap *,
  89                                const struct regcache *, int, void *);
  90 void (*sparc_supply_fpregset) (const struct sparc_fpregmap *,
  91                                struct regcache *, int , const void *);
  92 void (*sparc_collect_fpregset) (const struct sparc_fpregmap *,
  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_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 (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_fpregmap, 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_gregmap, 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_fpregmap, 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 /* Implement the to_xfer_partial target_ops method for
 260    TARGET_OBJECT_WCOOKIE.  Fetch StackGhost Per-Process XOR cookie.  */
 261
 262 static enum target_xfer_status
 263 sparc_xfer_wcookie (struct target_ops *ops, enum target_object object,
 264                     const char *annex, gdb_byte *readbuf,
 265                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
 266                     ULONGEST *xfered_len)
 267 {
 268   unsigned long wcookie = 0;
 269   char *buf = (char *)&wcookie;
 270
 271   gdb_assert (object == TARGET_OBJECT_WCOOKIE);
 272   gdb_assert (readbuf && writebuf == NULL);
 273
 274   if (offset == sizeof (unsigned long))
 275     return TARGET_XFER_EOF;                     /* Signal EOF.  */
 276   if (offset > sizeof (unsigned long))
 277     return TARGET_XFER_E_IO;
 278
 279 #ifdef PT_WCOOKIE
 280   /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
 281      running on an OpenBSD release that uses StackGhost (3.1 or
 282      later).  Since release 3.6, OpenBSD uses a fully randomized
 283      cookie.  */
 284   {
 285     int pid = ptid_get_pid (inferior_ptid);
 286
 287     /* Sanity check.  The proper type for a cookie is register_t, but
 288        we can't assume that this type exists on all systems supported
 289        by the code in this file.  */
 290     gdb_assert (sizeof (wcookie) == sizeof (register_t));
 291
 292     /* Fetch the cookie.  */
 293     if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
 294       {
 295         if (errno != EINVAL)
 296           perror_with_name (_("Couldn't get StackGhost cookie"));
 297
 298         /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
 299            the request wasn't implemented until after OpenBSD 3.4.  If
 300            the kernel doesn't support the PT_WCOOKIE request, assume
 301            we're running on a kernel that uses non-randomized cookies.  */
 302         wcookie = 0x3;
 303       }
 304   }
 305 #endif /* PT_WCOOKIE */
 306
 307   if (len > sizeof (unsigned long) - offset)
 308     len = sizeof (unsigned long) - offset;
 309
 310   memcpy (readbuf, buf + offset, len);
 311   *xfered_len = (ULONGEST) len;
 312   return TARGET_XFER_OK;
 313 }
 314
 315 target_xfer_partial_ftype *inf_ptrace_xfer_partial;
 316
 317 static enum target_xfer_status
 318 sparc_xfer_partial (struct target_ops *ops, enum target_object object,
 319                     const char *annex, gdb_byte *readbuf,
 320                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
 321                     ULONGEST *xfered_len)
 322 {
 323   if (object == TARGET_OBJECT_WCOOKIE)
 324     return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf,
 325                                offset, len, xfered_len);
 326
 327   return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf,
 328                                   offset, len, xfered_len);
 329 }
 330 \f
 331 /* Create a prototype generic SPARC target.  The client can override
 332    it with local methods.  */
 333
 334 struct target_ops *
 335 sparc_target (void)
 336 {
 337   struct target_ops *t;
 338
 339   t = inf_ptrace_target ();
 340   t->to_fetch_registers = sparc_fetch_inferior_registers;
 341   t->to_store_registers = sparc_store_inferior_registers;
 342   inf_ptrace_xfer_partial = t->to_xfer_partial;
 343   t->to_xfer_partial = sparc_xfer_partial;
 344   return t;
 345 }
 346
 347 \f
 348 /* Provide a prototype to silence -Wmissing-prototypes.  */
 349 void _initialize_sparc_nat (void);
 350
 351 void
 352 _initialize_sparc_nat (void)
 353 {
 354   /* Deafult to using SunOS 4 register sets.  */
 355   if (sparc_gregmap == NULL)
 356     sparc_gregmap = &sparc32_sunos4_gregmap;
 357   if (sparc_fpregmap == NULL)
 358     sparc_fpregmap = &sparc32_sunos4_fpregmap;
 359   if (sparc_supply_gregset == NULL)
 360     sparc_supply_gregset = sparc32_supply_gregset;
 361   if (sparc_collect_gregset == NULL)
 362     sparc_collect_gregset = sparc32_collect_gregset;
 363   if (sparc_supply_fpregset == NULL)
 364     sparc_supply_fpregset = sparc32_supply_fpregset;
 365   if (sparc_collect_fpregset == NULL)
 366     sparc_collect_fpregset = sparc32_collect_fpregset;
 367   if (sparc_gregset_supplies_p == NULL)
 368     sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
 369   if (sparc_fpregset_supplies_p == NULL)
 370     sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
 371 }