gdb/sparc-nat.c

   1 /* Native-dependent code for SPARC.
   2
   3    Copyright (C) 2003-2013 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 "gdb_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 = TIDGET (inferior_ptid);
 159   if (pid == 0)
 160     pid = PIDGET (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 = TIDGET (inferior_ptid);
 203   if (pid == 0)
 204     pid = PIDGET (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 LONGEST
 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, LONGEST 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 0;                   /* Signal EOF.  */
 274   if (offset > sizeof (unsigned long))
 275     return -1;
 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;
 284
 285     pid = TIDGET (inferior_ptid);
 286     if (pid == 0)
 287       pid = PIDGET (inferior_ptid);
 288
 289     /* Sanity check.  The proper type for a cookie is register_t, but
 290        we can't assume that this type exists on all systems supported
 291        by the code in this file.  */
 292     gdb_assert (sizeof (wcookie) == sizeof (register_t));
 293
 294     /* Fetch the cookie.  */
 295     if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
 296       {
 297         if (errno != EINVAL)
 298           perror_with_name (_("Couldn't get StackGhost cookie"));
 299
 300         /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
 301            the request wasn't implemented until after OpenBSD 3.4.  If
 302            the kernel doesn't support the PT_WCOOKIE request, assume
 303            we're running on a kernel that uses non-randomized cookies.  */
 304         wcookie = 0x3;
 305       }
 306   }
 307 #endif /* PT_WCOOKIE */
 308
 309   if (len > sizeof (unsigned long) - offset)
 310     len = sizeof (unsigned long) - offset;
 311
 312   memcpy (readbuf, buf + offset, len);
 313   return len;
 314 }
 315
 316 LONGEST (*inf_ptrace_xfer_partial) (struct target_ops *, enum target_object,
 317                                     const char *, gdb_byte *, const gdb_byte *,
 318                                     ULONGEST, LONGEST);
 319
 320 static LONGEST
 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, LONGEST len)
 324 {
 325   if (object == TARGET_OBJECT_WCOOKIE)
 326     return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf,
 327                                offset, len);
 328
 329   return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf,
 330                                   offset, len);
 331 }
 332 \f
 333 /* Create a prototype generic SPARC target.  The client can override
 334    it with local methods.  */
 335
 336 struct target_ops *
 337 sparc_target (void)
 338 {
 339   struct target_ops *t;
 340
 341   t = inf_ptrace_target ();
 342   t->to_fetch_registers = sparc_fetch_inferior_registers;
 343   t->to_store_registers = sparc_store_inferior_registers;
 344   inf_ptrace_xfer_partial = t->to_xfer_partial;
 345   t->to_xfer_partial = sparc_xfer_partial;
 346   return t;
 347 }
 348
 349 \f
 350 /* Provide a prototype to silence -Wmissing-prototypes.  */
 351 void _initialize_sparc_nat (void);
 352
 353 void
 354 _initialize_sparc_nat (void)
 355 {
 356   /* Deafult to using SunOS 4 register sets.  */
 357   if (sparc_gregset == NULL)
 358     sparc_gregset = &sparc32_sunos4_gregset;
 359   if (sparc_fpregset == NULL)
 360     sparc_fpregset = &sparc32_sunos4_fpregset;
 361   if (sparc_supply_gregset == NULL)
 362     sparc_supply_gregset = sparc32_supply_gregset;
 363   if (sparc_collect_gregset == NULL)
 364     sparc_collect_gregset = sparc32_collect_gregset;
 365   if (sparc_supply_fpregset == NULL)
 366     sparc_supply_fpregset = sparc32_supply_fpregset;
 367   if (sparc_collect_fpregset == NULL)
 368     sparc_collect_fpregset = sparc32_collect_fpregset;
 369   if (sparc_gregset_supplies_p == NULL)
 370     sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
 371   if (sparc_fpregset_supplies_p == NULL)
 372     sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
 373 }