GDB 7.6.50

gdb/sparc-nat.c

 /* Native-dependent code for SPARC.
 
-   Copyright (C) 2003-2005, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2003-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "inferior.h"
 #include "regcache.h"
 #include "target.h"
 
 #include "gdb_assert.h"
 #include <signal.h>
-#include "gdb_string.h"
+#include <string.h>
 #include <sys/ptrace.h>
 #include "gdb_wait.h"
 #ifdef HAVE_MACHINE_REG_H
 #include <machine/reg.h>
 #endif
 
 #include "sparc-tdep.h"
 #include "sparc-nat.h"
 #include "inf-ptrace.h"
 
@@ skipping 37 matching lines @@
 #ifndef PTRACE_GETFPREGS
 #define PTRACE_GETFPREGS PT_GETFPREGS
 #endif
 
 #ifndef PTRACE_SETFPREGS
 #define PTRACE_SETFPREGS PT_SETFPREGS
 #endif
 
 /* Register set description.  */
 const struct sparc_gregset *sparc_gregset;
+const struct sparc_fpregset *sparc_fpregset;
 void (*sparc_supply_gregset) (const struct sparc_gregset *,
                               struct regcache *, int , const void *);
 void (*sparc_collect_gregset) (const struct sparc_gregset *,
                                const struct regcache *, int, void *);
-void (*sparc_supply_fpregset) (struct regcache *, int , const void *);
-void (*sparc_collect_fpregset) (const struct regcache *, int , void *);
+void (*sparc_supply_fpregset) (const struct sparc_fpregset *,
+                               struct regcache *, int , const void *);
+void (*sparc_collect_fpregset) (const struct sparc_fpregset *,
+                                const struct regcache *, int , void *);
 int (*sparc_gregset_supplies_p) (struct gdbarch *, int);
 int (*sparc_fpregset_supplies_p) (struct gdbarch *, int);
 
 /* Determine whether `gregset_t' contains register REGNUM.  */
 
 int
 sparc32_gregset_supplies_p (struct gdbarch *gdbarch, int regnum)
 {
   /* Integer registers.  */
   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM)
@@ skipping 44 matching lines @@
      fine when given an 1:1 LWP:thread model (such as found on
      GNU/Linux) but will, likely, have problems when used on an N:1
      (userland threads) or N:M (userland multiple LWP) model.  In the
      case of the latter two, the LWP's registers do not necessarily
      belong to the selected thread (the LWP could be in the middle of
      executing the thread switch code).
 
      These functions should instead be paramaterized with an explicit
      object (struct regcache, struct thread_info?) into which the LWPs
      registers can be written.  */
-  pid = TIDGET (inferior_ptid);
+  pid = ptid_get_lwp (inferior_ptid);
   if (pid == 0)
-    pid = PIDGET (inferior_ptid);
+    pid = ptid_get_pid (inferior_ptid);
 
   if (regnum == SPARC_G0_REGNUM)
     {
       gdb_byte zero[8] = { 0 };
 
       regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
       return;
     }
 
   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
     {
       gregset_t regs;
 
       if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       sparc_supply_gregset (sparc_gregset, regcache, -1, &regs);
       if (regnum != -1)
         return;
     }
 
   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
     {
       fpregset_t fpregs;
 
       if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
         perror_with_name (_("Couldn't get floating point status"));
 
-      sparc_supply_fpregset (regcache, -1, &fpregs);
+      sparc_supply_fpregset (sparc_fpregset, regcache, -1, &fpregs);
     }
 }
 
 void
 sparc_store_inferior_registers (struct target_ops *ops,
                                 struct regcache *regcache, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   int pid;
 
   /* NOTE: cagney/2002-12-02: See comment in fetch_inferior_registers
      about threaded assumptions.  */
-  pid = TIDGET (inferior_ptid);
+  pid = ptid_get_lwp (inferior_ptid);
   if (pid == 0)
-    pid = PIDGET (inferior_ptid);
+    pid = ptid_get_pid (inferior_ptid);
 
   if (regnum == -1 || sparc_gregset_supplies_p (gdbarch, regnum))
     {
       gregset_t regs;
 
       if (ptrace (PTRACE_GETREGS, pid, (PTRACE_TYPE_ARG3) &regs, 0) == -1)
         perror_with_name (_("Couldn't get registers"));
 
       sparc_collect_gregset (sparc_gregset, regcache, regnum, &regs);
 
@@ skipping 15 matching lines @@
     }
 
   if (regnum == -1 || sparc_fpregset_supplies_p (gdbarch, regnum))
     {
       fpregset_t fpregs, saved_fpregs;
 
       if (ptrace (PTRACE_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
         perror_with_name (_("Couldn't get floating-point registers"));
 
       memcpy (&saved_fpregs, &fpregs, sizeof (fpregs));
-      sparc_collect_fpregset (regcache, regnum, &fpregs);
+      sparc_collect_fpregset (sparc_fpregset, regcache, regnum, &fpregs);
 
       /* Writing the floating-point registers will fail on NetBSD with
          EINVAL if the inferior process doesn't have an FPU state
          (i.e. if it didn't use the FPU yet).  Therefore we don't try
          to write the registers if nothing changed.  */
       if (memcmp (&saved_fpregs, &fpregs, sizeof (fpregs)) != 0)
         {
           if (ptrace (PTRACE_SETFPREGS, pid,
                       (PTRACE_TYPE_ARG3) &fpregs, 0) == -1)
             perror_with_name (_("Couldn't write floating-point registers"));
@@ skipping 21 matching lines @@
 
   if (offset == sizeof (unsigned long))
     return 0;                   /* Signal EOF.  */
   if (offset > sizeof (unsigned long))
     return -1;
 
 #ifdef PT_WCOOKIE
   /* If PT_WCOOKIE is defined (by <sys/ptrace.h>), assume we're
      running on an OpenBSD release that uses StackGhost (3.1 or
      later).  Since release 3.6, OpenBSD uses a fully randomized