gdb/sparc-nat.c

   1 /* Native-dependent code for SPARC.
   2
   3    Copyright (C) 2003-2005, 2007-2012 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 void (*sparc_supply_gregset) (const struct sparc_gregset *,
  86                               struct regcache *, int , const void *);
  87 void (*sparc_collect_gregset) (const struct sparc_gregset *,
  88                                const struct regcache *, int, void *);
  89 void (*sparc_supply_fpregset) (struct regcache *, int , const void *);
  90 void (*sparc_collect_fpregset) (const struct regcache *, int , void *);
  91 int (*sparc_gregset_supplies_p) (struct gdbarch *, int);
  92 int (*sparc_fpregset_supplies_p) (struct gdbarch *, int);
  93
  94 /* Determine whether `gregset_t' contains register REGNUM.  */
  95
  96 int
  97 sparc32_gregset_supplies_p (struct gdbarch *gdbarch, int regnum)
  98 {
  99   /* Integer registers.  */
 100   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM)
 101       || (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
 102       || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM)
 103       || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM))
 104     return 1;
 105
 106   /* Control registers.  */
 107   if (regnum == SPARC32_PC_REGNUM
 108       || regnum == SPARC32_NPC_REGNUM
 109       || regnum == SPARC32_PSR_REGNUM
 110       || regnum == SPARC32_Y_REGNUM)
 111     return 1;
 112
 113   return 0;
 114 }
 115
 116 /* Determine whether `fpregset_t' contains register REGNUM.  */
 117
 118 int
 119 sparc32_fpregset_supplies_p (struct gdbarch *gdbarch, int regnum)
 120 {
 121   /* Floating-point registers.  */
 122   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
 123     return 1;
 124
 125   /* Control registers.  */
 126   if (regnum == SPARC32_FSR_REGNUM)
 127     return 1;
 128
 129   return 0;
 130 }
 131
 132 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 133    for all registers (including the floating-point registers).  */
 134
 135 void
 136 sparc_fetch_inferior_registers (struct target_ops *ops,
 137                                 struct regcache *regcache, int regnum)
 138 {
 139   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 140   int pid;
 141
 142   /* NOTE: cagney/2002-12-03: This code assumes that the currently
 143      selected light weight processes' registers can be written
 144      directly into the selected thread's register cache.  This works
 145      fine when given an 1:1 LWP:thread model (such as found on
 146      GNU/Linux) but will, likely, have problems when used on an N:1
 147      (userland threads) or N:M (userland multiple LWP) model.  In the
 148      case of the latter two, the LWP's registers do not necessarily
 149      belong to the selected thread (the LWP could be in the middle of
 150      executing the thread switch code).
 151
 152      These functions should instead be paramaterized with an explicit
 153      object (struct regcache, struct thread_info?) into which the LWPs
 154      registers can be written.  */
 155   pid = TIDGET (inferior_ptid);
 156   if (pid == 0)
 157     pid = PIDGET (inferior_ptid);
 158
 159   if (regnum == SPARC_G0_REGNUM)
 160     {
 161       gdb_byte zero[8] = { 0 };
 162
 163       regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
 164       return;
 165     }
 166
 167   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 168     {
 169       gregset_t regs;
 170
 171       if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 172         perror_with_name (_("Couldn't get registers"));
 173
 174       sparc_supply_gregset (sparc_gregset, regcache, -1, &regs);
 175       if (regnum != -1)
 176         return;
 177     }
 178
 179   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
 180     {
 181       fpregset_t fpregs;
 182
 183       if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 184         perror_with_name (_("Couldn't get floating point status"));
 185
 186       sparc_supply_fpregset (regcache, -1, &fpregs);
 187     }
 188 }
 189
 190 void
 191 sparc_store_inferior_registers (struct target_ops *ops,
 192                                 struct regcache *regcache, int regnum)
 193 {
 194   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 195   int pid;
 196
 197   /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers
 198      about threaded assumptions.  */
 199   pid = TIDGET (inferior_ptid);
 200   if (pid == 0)
 201     pid = PIDGET (inferior_ptid);
 202
 203   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
 204     {
 205       gregset_t regs;
 206
 207       if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 208         perror_with_name (_("Couldn't get registers"));
 209
 210       sparc_collect_gregset (sparc_gregset, regcache, regnum, &regs);
 211
 212       if (ptrace (PTRACE_SETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
 213         perror_with_name (_("Couldn't write registers"));
 214
 215       /* Deal with the stack regs.  */
 216       if (regnum == -1 || regnum == SPARC_SP_REGNUM
 217           || (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM))
 218         {
 219           ULONGEST sp;
 220
 221           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
 222           sparc_collect_rwindow (regcache, sp, regnum);
 223         }
 224
 225       if (regnum != -1)
 226         return;
 227     }
 228
 229   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
 230     {
 231       fpregset_t fpregs, saved_fpregs;
 232
 233       if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 234         perror_with_name (_("Couldn't get floating-point registers"));
 235
 236       memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
 237       sparc_collect_fpregset (regcache, regnum, &fpregs);
 238
 239       /* Writing the floating-point registers will fail on NetBSD with
 240          EINVAL if the inferior process doesn't have an FPU state
 241          (i.e. if it didn't use the FPU yet).  Therefore we don't try
 242          to write the registers if nothing changed.  */
 243       if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0)
 244         {
 245           if (ptrace (PTRACE_SETFPREGS, pid,
 246                       (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
 247             perror_with_name (_("Couldn't write floating-point registers"));
 248         }
 249
 250       if (regnum != -1)
 251         return;
 252     }
 253 }
 254
 255 \f
 256 /* Fetch StackGhost Per-Process XOR cookie.  */
 257
 258 static LONGEST
 259 sparc_xfer_wcookie (struct target_ops *ops, enum target_object object,
 260                     const char *annex, gdb_byte *readbuf,
 261                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
 262 {
 263   unsigned long wcookie = 0;
 264   char *buf = (char *)&wcookie;
 265
 266   gdb_assert (object == TARGET_OBJECT_WCOOKIE);
 267   gdb_assert (readbuf && writebuf == NULL);
 268
 269   if (offset == sizeof (unsigned long))
 270     return 0;                   /* Signal EOF.  */
 271   if (offset > sizeof (unsigned long))
 272     return -1;
 273
 274 #ifdef PT_WCOOKIE
 275   /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
 276      running on an OpenBSD release that uses StackGhost (3.1 or
 277      later).  Since release 3.6, OpenBSD uses a fully randomized
 278      cookie.  */
 279   {
 280     int pid;
 281
 282     pid = TIDGET (inferior_ptid);
 283     if (pid == 0)
 284       pid = PIDGET (inferior_ptid);
 285
 286     /* Sanity check.  The proper type for a cookie is register_t, but
 287        we can't assume that this type exists on all systems supported
 288        by the code in this file.  */
 289     gdb_assert (sizeof (wcookie) == sizeof (register_t));
 290
 291     /* Fetch the cookie.  */
 292     if (ptrace (PT_WCOOKIE, pid, (PTRACE_TYPE_ARG3) &wcookie, 0) == -1)
 293       {
 294         if (errno != EINVAL)
 295           perror_with_name (_("Couldn't get StackGhost cookie"));
 296
 297         /* Although PT_WCOOKIE is defined on OpenBSD 3.1 and later,
 298            the request wasn't implemented until after OpenBSD 3.4.  If
 299            the kernel doesn't support the PT_WCOOKIE request, assume
 300            we're running on a kernel that uses non-randomized cookies.  */
 301         wcookie = 0x3;
 302       }
 303   }
 304 #endif /* PT_WCOOKIE */
 305
 306   if (len > sizeof (unsigned long) - offset)
 307     len = sizeof (unsigned long) - offset;
 308
 309   memcpy (readbuf, buf + offset, len);
 310   return len;
 311 }
 312
 313 LONGEST (*inf_ptrace_xfer_partial) (struct target_ops *, enum target_object,
 314                                     const char *, gdb_byte *, const gdb_byte *,
 315                                     ULONGEST, LONGEST);
 316
 317 static LONGEST
 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, LONGEST len)
 321 {
 322   if (object == TARGET_OBJECT_WCOOKIE)
 323     return sparc_xfer_wcookie (ops, object, annex, readbuf, writebuf,
 324                                offset, len);
 325
 326   return inf_ptrace_xfer_partial (ops, object, annex, readbuf, writebuf,
 327                                   offset, len);
 328 }
 329 \f
 330 /* Create a prototype generic SPARC target.  The client can override
 331    it with local methods.  */
 332
 333 struct target_ops *
 334 sparc_target (void)
 335 {
 336   struct target_ops *t;
 337
 338   t = inf_ptrace_target ();
 339   t->to_fetch_registers = sparc_fetch_inferior_registers;
 340   t->to_store_registers = sparc_store_inferior_registers;
 341   inf_ptrace_xfer_partial = t->to_xfer_partial;
 342   t->to_xfer_partial = sparc_xfer_partial;
 343   return t;
 344 }
 345
 346 \f
 347 /* Provide a prototype to silence -Wmissing-prototypes.  */
 348 void _initialize_sparc_nat (void);
 349
 350 void
 351 _initialize_sparc_nat (void)
 352 {
 353   /* Deafult to using SunOS 4 register sets.  */
 354   if (sparc_gregset == NULL)
 355     sparc_gregset = &sparc32_sunos4_gregset;
 356   if (sparc_supply_gregset == NULL)
 357     sparc_supply_gregset = sparc32_supply_gregset;
 358   if (sparc_collect_gregset == NULL)
 359     sparc_collect_gregset = sparc32_collect_gregset;
 360   if (sparc_supply_fpregset == NULL)
 361     sparc_supply_fpregset = sparc32_supply_fpregset;
 362   if (sparc_collect_fpregset == NULL)
 363     sparc_collect_fpregset = sparc32_collect_fpregset;
 364   if (sparc_gregset_supplies_p == NULL)
 365     sparc_gregset_supplies_p = sparc32_gregset_supplies_p;
 366   if (sparc_fpregset_supplies_p == NULL)
 367     sparc_fpregset_supplies_p = sparc32_fpregset_supplies_p;
 368 }