* amd64-windows-nat.c, amd64-windows-tdep.c: New files.

[deliverable/binutils-gdb.git] / gdb / inf-ptrace.c

diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c
index 07ebb9d41205dc93ed5441e0d02338e6704beafc..538816dcd592f5a5ec4ea02d2b9517fba37863bb 100644 (file)
--- a/gdb/inf-ptrace.c
+++ b/gdb/inf-ptrace.c
@@ -1,14 +1,14 @@
 /* Low-level child interface to ptrace.
 
 /* Low-level child interface to ptrace.
 

-   Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
-   1998, 1999, 2000, 2001, 2002, 2004, 2005
+   Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
+   1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009

    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
    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 2 of the License, or
+   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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -17,16 +17,13 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "command.h"
 #include "inferior.h"
 #include "inflow.h"
 #include "gdbcore.h"
 
 #include "defs.h"
 #include "command.h"
 #include "inferior.h"
 #include "inflow.h"
 #include "gdbcore.h"

-#include "observer.h"

 #include "regcache.h"
 
 #include "gdb_assert.h"
 #include "regcache.h"
 
 #include "gdb_assert.h"


@@ -36,9 +33,8 @@
 #include <signal.h>
 
 #include "inf-child.h"
 #include <signal.h>
 
 #include "inf-child.h"

+#include "gdbthread.h"

 
 

-/* HACK: Save the ptrace ops returned by inf_ptrace_target.  */
-static struct target_ops *ptrace_ops_hack;

 \f
 
 #ifdef PT_GET_PROCESS_STATE
 \f
 
 #ifdef PT_GET_PROCESS_STATE


@@ -48,6 +44,7 @@ inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
 {
   pid_t pid, fpid;
   ptrace_state_t pe;
 {
   pid_t pid, fpid;
   ptrace_state_t pe;

+  struct thread_info *last_tp = NULL;

 
   /* FIXME: kettenis/20050720: This stuff should really be passed as
      an argument by our caller.  */
 
   /* FIXME: kettenis/20050720: This stuff should really be passed as
      an argument by our caller.  */


@@ -59,6 +56,7 @@ inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
     gdb_assert (status.kind == TARGET_WAITKIND_FORKED);
 
     pid = ptid_get_pid (ptid);
     gdb_assert (status.kind == TARGET_WAITKIND_FORKED);
 
     pid = ptid_get_pid (ptid);

+    last_tp = find_thread_pid (ptid);

   }
 
   if (ptrace (PT_GET_PROCESS_STATE, pid,
   }
 
   if (ptrace (PT_GET_PROCESS_STATE, pid,


@@ -70,14 +68,42 @@ inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
 
   if (follow_child)
     {
 
   if (follow_child)
     {

-      inferior_ptid = pid_to_ptid (fpid);
-      detach_breakpoints (pid);
+      /* Copy user stepping state to the new inferior thread.  */
+      struct breakpoint *step_resume_breakpoint = last_tp->step_resume_breakpoint;
+      CORE_ADDR step_range_start = last_tp->step_range_start;
+      CORE_ADDR step_range_end = last_tp->step_range_end;
+      struct frame_id step_frame_id = last_tp->step_frame_id;

 
 

-      /* Reset breakpoints in the child as appropriate.  */
-      follow_inferior_reset_breakpoints ();
+      struct thread_info *tp;
+
+      /* Otherwise, deleting the parent would get rid of this
+        breakpoint.  */
+      last_tp->step_resume_breakpoint = NULL;
+
+      /* Before detaching from the parent, remove all breakpoints from
+        it.  */
+      detach_breakpoints (pid);

 
       if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
        perror_with_name (("ptrace"));
 
       if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
        perror_with_name (("ptrace"));

+
+      /* Switch inferior_ptid out of the parent's way.  */
+      inferior_ptid = pid_to_ptid (fpid);
+
+      /* Delete the parent.  */
+      detach_inferior (pid);
+
+      /* Add the child.  */
+      add_inferior (fpid);
+      tp = add_thread_silent (inferior_ptid);
+
+      tp->step_resume_breakpoint = step_resume_breakpoint;
+      tp->step_range_start = step_range_start;
+      tp->step_range_end = step_range_end;
+      tp->step_frame_id = step_frame_id;
+
+      /* Reset breakpoints in the child as appropriate.  */
+      follow_inferior_reset_breakpoints ();

     }
   else
     {
     }
   else
     {


@@ -86,6 +112,7 @@ inf_ptrace_follow_fork (struct target_ops *ops, int follow_child)
 
       if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
        perror_with_name (("ptrace"));
 
       if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1)
        perror_with_name (("ptrace"));

+      detach_inferior (pid);

     }
 
   return 0;
     }
 
   return 0;


@@ -103,12 +130,22 @@ inf_ptrace_me (void)
   ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
 }
 
   ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0);
 }
 

-/* Start tracing PID.  */
+/* Start a new inferior Unix child process.  EXEC_FILE is the file to
+   run, ALLARGS is a string containing the arguments to the program.
+   ENV is the environment vector to pass.  If FROM_TTY is non-zero, be
+   chatty about it.  */

 
 static void
 
 static void

-inf_ptrace_him (int pid)
+inf_ptrace_create_inferior (struct target_ops *ops,
+                           char *exec_file, char *allargs, char **env,
+                           int from_tty)

 {
 {

-  push_target (ptrace_ops_hack);
+  int pid;
+
+  pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
+                      NULL, NULL);
+
+  push_target (ops);

 
   /* On some targets, there must be some explicit synchronization
      between the parent and child processes after the debugger
 
   /* On some targets, there must be some explicit synchronization
      between the parent and child processes after the debugger


@@ -127,25 +164,6 @@ inf_ptrace_him (int pid)
   target_post_startup_inferior (pid_to_ptid (pid));
 }
 
   target_post_startup_inferior (pid_to_ptid (pid));
 }
 

-/* Start a new inferior Unix child process.  EXEC_FILE is the file to
-   run, ALLARGS is a string containing the arguments to the program.
-   ENV is the environment vector to pass.  If FROM_TTY is non-zero, be
-   chatty about it.  */
-
-static void
-inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env,
-                           int from_tty)
-{
-  fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him,
-                NULL, NULL);
-
-  /* We are at the first instruction we care about.  */
-  observer_notify_inferior_created (&current_target, from_tty);
-
-  /* Pedal to the metal...  */
-  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
-}
-

 #ifdef PT_GET_PROCESS_STATE
 
 static void
 #ifdef PT_GET_PROCESS_STATE
 
 static void


@@ -166,17 +184,17 @@ inf_ptrace_post_startup_inferior (ptid_t pid)
 /* Clean up a rotting corpse of an inferior after it died.  */
 
 static void
 /* Clean up a rotting corpse of an inferior after it died.  */
 
 static void

-inf_ptrace_mourn_inferior (void)
+inf_ptrace_mourn_inferior (struct target_ops *ops)

 {
   int status;
 
   /* Wait just one more time to collect the inferior's exit status.
 {
   int status;
 
   /* Wait just one more time to collect the inferior's exit status.

-     Don not check whether this succeeds though, since we may be
+     Do not check whether this succeeds though, since we may be

      dealing with a process that we attached to.  Such a process will
      dealing with a process that we attached to.  Such a process will

-     only report its exit status to its origional parent.  */
+     only report its exit status to its original parent.  */

   waitpid (ptid_get_pid (inferior_ptid), &status, 0);
 
   waitpid (ptid_get_pid (inferior_ptid), &status, 0);
 

-  unpush_target (ptrace_ops_hack);
+  unpush_target (ops);

   generic_mourn_inferior ();
 }
 
   generic_mourn_inferior ();
 }
 


@@ -184,11 +202,12 @@ inf_ptrace_mourn_inferior (void)
    be chatty about it.  */
 
 static void
    be chatty about it.  */
 
 static void

-inf_ptrace_attach (char *args, int from_tty)
+inf_ptrace_attach (struct target_ops *ops, char *args, int from_tty)

 {
   char *exec_file;
   pid_t pid;
   char *dummy;
 {
   char *exec_file;
   pid_t pid;
   char *dummy;

+  struct inferior *inf;

 
   if (!args)
     error_no_arg (_("process-id to attach"));
 
   if (!args)
     error_no_arg (_("process-id to attach"));


@@ -221,17 +240,20 @@ inf_ptrace_attach (char *args, int from_tty)
   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
   if (errno != 0)
     perror_with_name (("ptrace"));
   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
   if (errno != 0)
     perror_with_name (("ptrace"));

-  attach_flag = 1;

 #else
   error (_("This system does not support attaching to a process"));
 #endif
 
   inferior_ptid = pid_to_ptid (pid);
 #else
   error (_("This system does not support attaching to a process"));
 #endif
 
   inferior_ptid = pid_to_ptid (pid);

-  push_target (ptrace_ops_hack);

 
 

-  /* Do this first, before anything has had a chance to query the
-     inferior's symbol table or similar.  */
-  observer_notify_inferior_created (&current_target, from_tty);
+  inf = add_inferior (pid);
+  inf->attach_flag = 1;
+
+  /* Always add a main thread.  If some target extends the ptrace
+     target, it should decorate the ptid later with more info.  */
+  add_thread_silent (inferior_ptid);
+
+  push_target(ops);

 }
 
 #ifdef PT_GET_PROCESS_STATE
 }
 
 #ifdef PT_GET_PROCESS_STATE


@@ -252,10 +274,10 @@ inf_ptrace_post_attach (int pid)
 #endif
 
 /* Detach from the inferior, optionally passing it the signal
 #endif
 
 /* Detach from the inferior, optionally passing it the signal

-   specified ARGS.  If FROM_TTY is non-zero, be chatty about it.  */
+   specified by ARGS.  If FROM_TTY is non-zero, be chatty about it.  */

 
 static void
 
 static void

-inf_ptrace_detach (char *args, int from_tty)
+inf_ptrace_detach (struct target_ops *ops, char *args, int from_tty)

 {
   pid_t pid = ptid_get_pid (inferior_ptid);
   int sig = 0;
 {
   pid_t pid = ptid_get_pid (inferior_ptid);
   int sig = 0;


@@ -274,20 +296,22 @@ inf_ptrace_detach (char *args, int from_tty)
 
 #ifdef PT_DETACH
   /* We'd better not have left any breakpoints in the program or it'll
 
 #ifdef PT_DETACH
   /* We'd better not have left any breakpoints in the program or it'll

-     die when it hits one.  Alsno note that this may only work if we
+     die when it hits one.  Also note that this may only work if we

      previously attached to the inferior.  It *might* work if we
      started the process ourselves.  */
   errno = 0;
   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
   if (errno != 0)
     perror_with_name (("ptrace"));
      previously attached to the inferior.  It *might* work if we
      started the process ourselves.  */
   errno = 0;
   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig);
   if (errno != 0)
     perror_with_name (("ptrace"));

-  attach_flag = 0;

 #else
   error (_("This system does not support detaching from a process"));
 #endif
 
   inferior_ptid = null_ptid;
 #else
   error (_("This system does not support detaching from a process"));
 #endif
 
   inferior_ptid = null_ptid;

-  unpush_target (ptrace_ops_hack);
+  detach_inferior (pid);
+
+  if (!have_inferiors ())
+    unpush_target (ops);

 }
 
 /* Kill the inferior.  */
 }
 
 /* Kill the inferior.  */


@@ -310,7 +334,7 @@ inf_ptrace_kill (void)
 /* Stop the inferior.  */
 
 static void
 /* Stop the inferior.  */
 
 static void

-inf_ptrace_stop (void)
+inf_ptrace_stop (ptid_t ptid)

 {
   /* Send a SIGINT to the process group.  This acts just like the user
      typed a ^C on the controlling terminal.  Note that using a
 {
   /* Send a SIGINT to the process group.  This acts just like the user
      typed a ^C on the controlling terminal.  Note that using a


@@ -367,7 +391,6 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   do
     {
       set_sigint_trap ();
   do
     {
       set_sigint_trap ();

-      set_sigio_trap ();

 
       do
        {
 
       do
        {


@@ -376,7 +399,6 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
        }
       while (pid == -1 && errno == EINTR);
 
        }
       while (pid == -1 && errno == EINTR);
 

-      clear_sigio_trap ();

       clear_sigint_trap ();
 
       if (pid == -1)
       clear_sigint_trap ();
 
       if (pid == -1)


@@ -388,7 +410,7 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
          /* Claim it exited with unknown signal.  */
          ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
          ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
          /* Claim it exited with unknown signal.  */
          ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
          ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;

-         return minus_one_ptid;
+         return inferior_ptid;

        }
 
       /* Ignore terminated detached child processes.  */
        }
 
       /* Ignore terminated detached child processes.  */


@@ -411,7 +433,7 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
        {
        case PTRACE_FORK:
          ourstatus->kind = TARGET_WAITKIND_FORKED;
        {
        case PTRACE_FORK:
          ourstatus->kind = TARGET_WAITKIND_FORKED;

-         ourstatus->value.related_pid = pe.pe_other_pid;
+         ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);

 
          /* Make sure the other end of the fork is stopped too.  */
          fpid = waitpid (pe.pe_other_pid, &status, 0);
 
          /* Make sure the other end of the fork is stopped too.  */
          fpid = waitpid (pe.pe_other_pid, &status, 0);


@@ -426,7 +448,7 @@ inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
          gdb_assert (pe.pe_other_pid == pid);
          if (fpid == ptid_get_pid (inferior_ptid))
            {
          gdb_assert (pe.pe_other_pid == pid);
          if (fpid == ptid_get_pid (inferior_ptid))
            {

-             ourstatus->value.related_pid = pe.pe_other_pid;
+             ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);

              return pid_to_ptid (fpid);
            }
 
              return pid_to_ptid (fpid);
            }
 


@@ -462,8 +484,12 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
        struct ptrace_io_desc piod;
 
        /* NOTE: We assume that there are no distinct address spaces
        struct ptrace_io_desc piod;
 
        /* NOTE: We assume that there are no distinct address spaces

-          for instruction and data.  */
-       piod.piod_op = writebuf ? PIOD_WRITE_D : PIOD_READ_D;
+          for instruction and data.  However, on OpenBSD 3.9 and
+          later, PIOD_WRITE_D doesn't allow changing memory that's
+          mapped read-only.  Since most code segments will be
+          read-only, using PIOD_WRITE_D will prevent us from
+          inserting breakpoints, so we use PIOD_WRITE_I instead.  */
+       piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;

        piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
        piod.piod_offs = (void *) (long) offset;
        piod.piod_len = len;
        piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
        piod.piod_offs = (void *) (long) offset;
        piod.piod_len = len;


@@ -511,7 +537,8 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
                    < rounded_offset + sizeof (PTRACE_TYPE_RET)))
              /* Need part of initial word -- fetch it.  */
              buffer.word = ptrace (PT_READ_I, pid,
                    < rounded_offset + sizeof (PTRACE_TYPE_RET)))
              /* Need part of initial word -- fetch it.  */
              buffer.word = ptrace (PT_READ_I, pid,

-                                   (PTRACE_TYPE_ARG3)(long)rounded_offset, 0);
+                                   (PTRACE_TYPE_ARG3)(uintptr_t)
+                                   rounded_offset, 0);

 
            /* Copy data to be written over corresponding part of
               buffer.  */
 
            /* Copy data to be written over corresponding part of
               buffer.  */


@@ -520,14 +547,16 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
 
            errno = 0;
            ptrace (PT_WRITE_D, pid,
 
            errno = 0;
            ptrace (PT_WRITE_D, pid,

-                   (PTRACE_TYPE_ARG3)(long)rounded_offset, buffer.word);
+                   (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
+                   buffer.word);

            if (errno)
              {
                /* Using the appropriate one (I or D) is necessary for
                   Gould NP1, at least.  */
                errno = 0;
                ptrace (PT_WRITE_I, pid,
            if (errno)
              {
                /* Using the appropriate one (I or D) is necessary for
                   Gould NP1, at least.  */
                errno = 0;
                ptrace (PT_WRITE_I, pid,

-                       (PTRACE_TYPE_ARG3)(long)rounded_offset, buffer.word);
+                       (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
+                       buffer.word);

                if (errno)
                  return 0;
              }
                if (errno)
                  return 0;
              }


@@ -537,7 +566,8 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object,
          {
            errno = 0;
            buffer.word = ptrace (PT_READ_I, pid,
          {
            errno = 0;
            buffer.word = ptrace (PT_READ_I, pid,

-                                 (PTRACE_TYPE_ARG3)(long)rounded_offset, 0);
+                                 (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset,
+                                 0);

            if (errno)
              return 0;
            /* Copy appropriate bytes out of the buffer.  */
            if (errno)
              return 0;
            /* Copy appropriate bytes out of the buffer.  */


@@ -576,8 +606,10 @@ inf_ptrace_thread_alive (ptid_t ptid)
 static void
 inf_ptrace_files_info (struct target_ops *ignore)
 {
 static void
 inf_ptrace_files_info (struct target_ops *ignore)
 {

+  struct inferior *inf = current_inferior ();
+

   printf_filtered (_("\tUsing the running image of %s %s.\n"),
   printf_filtered (_("\tUsing the running image of %s %s.\n"),

-                  attach_flag ? "attached" : "child",
+                  inf->attach_flag ? "attached" : "child",

                   target_pid_to_str (inferior_ptid));
 }
 
                   target_pid_to_str (inferior_ptid));
 }
 


@@ -607,97 +639,111 @@ inf_ptrace_target (void)
   t->to_stop = inf_ptrace_stop;
   t->to_xfer_partial = inf_ptrace_xfer_partial;
 
   t->to_stop = inf_ptrace_stop;
   t->to_xfer_partial = inf_ptrace_xfer_partial;
 

-  ptrace_ops_hack = t;

   return t;
 }
 \f
 
 /* Pointer to a function that returns the offset within the user area
    where a particular register is stored.  */
   return t;
 }
 \f
 
 /* Pointer to a function that returns the offset within the user area
    where a particular register is stored.  */

-static CORE_ADDR (*inf_ptrace_register_u_offset)(int);
+static CORE_ADDR (*inf_ptrace_register_u_offset)(struct gdbarch *, int, int);

 
 /* Fetch register REGNUM from the inferior.  */
 
 static void
 
 /* Fetch register REGNUM from the inferior.  */
 
 static void

-inf_ptrace_fetch_register (int regnum)
+inf_ptrace_fetch_register (struct regcache *regcache, int regnum)

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   CORE_ADDR addr;
   size_t size;
   PTRACE_TYPE_RET *buf;
   int pid, i;
 
   CORE_ADDR addr;
   size_t size;
   PTRACE_TYPE_RET *buf;
   int pid, i;
 

+  /* This isn't really an address, but ptrace thinks of it as one.  */
+  addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0);
+  if (addr == (CORE_ADDR)-1
+      || gdbarch_cannot_fetch_register (gdbarch, regnum))
+    {
+      regcache_raw_supply (regcache, regnum, NULL);
+      return;
+    }
+

   /* Cater for systems like GNU/Linux, that implement threads as
   /* Cater for systems like GNU/Linux, that implement threads as

-     seperate processes.  */
+     separate processes.  */

   pid = ptid_get_lwp (inferior_ptid);
   if (pid == 0)
     pid = ptid_get_pid (inferior_ptid);
 
   pid = ptid_get_lwp (inferior_ptid);
   if (pid == 0)
     pid = ptid_get_pid (inferior_ptid);
 

-  /* This isn't really an address, but ptrace thinks of it as one.  */
-  addr = inf_ptrace_register_u_offset (regnum);
-  size = register_size (current_gdbarch, regnum);
-
+  size = register_size (gdbarch, regnum);

   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
   buf = alloca (size);
 
   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
   buf = alloca (size);
 

-  /* Read the register contents from the inferior a chuck at the time.  */
+  /* Read the register contents from the inferior a chunk at a time.  */

   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
     {
       errno = 0;
   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
     {
       errno = 0;

-      buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)addr, 0);
+      buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0);

       if (errno != 0)
        error (_("Couldn't read register %s (#%d): %s."),
       if (errno != 0)
        error (_("Couldn't read register %s (#%d): %s."),

-              REGISTER_NAME (regnum), regnum, safe_strerror (errno));
+              gdbarch_register_name (gdbarch, regnum),
+              regnum, safe_strerror (errno));

 
       addr += sizeof (PTRACE_TYPE_RET);
     }
 
       addr += sizeof (PTRACE_TYPE_RET);
     }

-  regcache_raw_supply (current_regcache, regnum, buf);
+  regcache_raw_supply (regcache, regnum, buf);

 }
 
 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
    for all registers.  */
 
 static void
 }
 
 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
    for all registers.  */
 
 static void

-inf_ptrace_fetch_registers (int regnum)
+inf_ptrace_fetch_registers (struct regcache *regcache, int regnum)

 {
   if (regnum == -1)
 {
   if (regnum == -1)

-    for (regnum = 0; regnum < NUM_REGS; regnum++)
-      inf_ptrace_fetch_register (regnum);
+    for (regnum = 0;
+        regnum < gdbarch_num_regs (get_regcache_arch (regcache));
+        regnum++)
+      inf_ptrace_fetch_register (regcache, regnum);

   else
   else

-    inf_ptrace_fetch_register (regnum);
+    inf_ptrace_fetch_register (regcache, regnum);

 }
 
 /* Store register REGNUM into the inferior.  */
 
 static void
 }
 
 /* Store register REGNUM into the inferior.  */
 
 static void

-inf_ptrace_store_register (int regnum)
+inf_ptrace_store_register (const struct regcache *regcache, int regnum)

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   CORE_ADDR addr;
   size_t size;
   PTRACE_TYPE_RET *buf;
   int pid, i;
 
   CORE_ADDR addr;
   size_t size;
   PTRACE_TYPE_RET *buf;
   int pid, i;
 

+  /* This isn't really an address, but ptrace thinks of it as one.  */
+  addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1);
+  if (addr == (CORE_ADDR)-1 
+      || gdbarch_cannot_store_register (gdbarch, regnum))
+    return;
+

   /* Cater for systems like GNU/Linux, that implement threads as
   /* Cater for systems like GNU/Linux, that implement threads as

-     seperate processes.  */
+     separate processes.  */

   pid = ptid_get_lwp (inferior_ptid);
   if (pid == 0)
     pid = ptid_get_pid (inferior_ptid);
 
   pid = ptid_get_lwp (inferior_ptid);
   if (pid == 0)
     pid = ptid_get_pid (inferior_ptid);
 

-  /* This isn't really an address, but ptrace thinks of it as one.  */
-  addr = inf_ptrace_register_u_offset (regnum);
-  size = register_size (current_gdbarch, regnum);
-
+  size = register_size (gdbarch, regnum);

   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
   buf = alloca (size);
 
   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
   buf = alloca (size);
 

-  /* Write the register contents into the inferior a chunk at the time.  */
-  regcache_raw_collect (current_regcache, regnum, buf);
+  /* Write the register contents into the inferior a chunk at a time.  */
+  regcache_raw_collect (regcache, regnum, buf);

   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
     {
       errno = 0;
   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
     {
       errno = 0;

-      ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)addr, buf[i]);
+      ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]);

       if (errno != 0)
        error (_("Couldn't write register %s (#%d): %s."),
       if (errno != 0)
        error (_("Couldn't write register %s (#%d): %s."),

-              REGISTER_NAME (regnum), regnum, safe_strerror (errno));
+              gdbarch_register_name (gdbarch, regnum),
+              regnum, safe_strerror (errno));

 
       addr += sizeof (PTRACE_TYPE_RET);
     }
 
       addr += sizeof (PTRACE_TYPE_RET);
     }


@@ -707,13 +753,15 @@ inf_ptrace_store_register (int regnum)
    this for all registers.  */
 
 void
    this for all registers.  */
 
 void

-inf_ptrace_store_registers (int regnum)
+inf_ptrace_store_registers (struct regcache *regcache, int regnum)

 {
   if (regnum == -1)
 {
   if (regnum == -1)

-    for (regnum = 0; regnum < NUM_REGS; regnum++)
-      inf_ptrace_store_register (regnum);
+    for (regnum = 0;
+        regnum < gdbarch_num_regs (get_regcache_arch (regcache));
+        regnum++)
+      inf_ptrace_store_register (regcache, regnum);

   else
   else

-    inf_ptrace_store_register (regnum);
+    inf_ptrace_store_register (regcache, regnum);

 }
 
 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be
 }
 
 /* Create a "traditional" ptrace target.  REGISTER_U_OFFSET should be


@@ -721,7 +769,8 @@ inf_ptrace_store_registers (int regnum)
    particular register is stored.  */
 
 struct target_ops *
    particular register is stored.  */
 
 struct target_ops *

-inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)(int))
+inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)
+                                       (struct gdbarch *, int, int))

 {
   struct target_ops *t = inf_ptrace_target();
 
 {
   struct target_ops *t = inf_ptrace_target();