Merge GDB 7.5.1

gdb/gdbserver/linux-low.c

 /* Low level interface to ptrace, for the remote server for GDB.
    Copyright (C) 1995-1996, 1998-2012 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 "server.h"
 #include "linux-low.h"
 #include "linux-osdata.h"
+#include "agent.h"
 
 #include <sys/wait.h>
 #include <stdio.h>
 #include <sys/param.h>
 #include <sys/ptrace.h>
 #include "linux-ptrace.h"
 #include "linux-procfs.h"
 #include <signal.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
@@ skipping 38 matching lines @@
 #endif
 
 /* This is the kernel's hard limit.  Not to be confused with
    SIGRTMIN.  */
 #ifndef __SIGRTMIN
 #define __SIGRTMIN 32
 #endif
 
 #ifdef __UCLIBC__
 #if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
+/* PTRACE_TEXT_ADDR and friends.  */
+#include <asm/ptrace.h>
 #define HAS_NOMMU
 #endif
 #endif
 
+#ifndef HAVE_ELF32_AUXV_T
+/* Copied from glibc's elf.h.  */
+typedef struct
+{
+  uint32_t a_type;              /* Entry type */
+  union
+    {
+      uint32_t a_val;           /* Integer value */
+      /* We use to have pointer elements added here.  We cannot do that,
+         though, since it does not work when using 32-bit definitions
+         on 64-bit platforms and vice versa.  */
+    } a_un;
+} Elf32_auxv_t;
+#endif
+
+#ifndef HAVE_ELF64_AUXV_T
+/* Copied from glibc's elf.h.  */
+typedef struct
+{
+  uint64_t a_type;              /* Entry type */
+  union
+    {
+      uint64_t a_val;           /* Integer value */
+      /* We use to have pointer elements added here.  We cannot do that,
+         though, since it does not work when using 32-bit definitions
+         on 64-bit platforms and vice versa.  */
+    } a_un;
+} Elf64_auxv_t;
+#endif
+
 /* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
    representation of the thread ID.
 
    ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
    the same as the LWP ID.
 
    ``all_processes'' is keyed by the "overall process ID", which
    GNU/Linux calls tgid, "thread group ID".  */
 
 struct inferior_list all_lwps;
 
-/* A list of all unknown processes which receive stop signals.  Some other
-   process will presumably claim each of these as forked children
-   momentarily.  */
+/* A list of all unknown processes which receive stop signals.  Some
+   other process will presumably claim each of these as forked
+   children momentarily.  */
 
-struct inferior_list stopped_pids;
+struct simple_pid_list
+{
+  /* The process ID.  */
+  int pid;
 
-/* FIXME this is a bit of a hack, and could be removed.  */
-int stopping_threads;
+  /* The status as reported by waitpid.  */
+  int status;
+
+  /* Next in chain.  */
+  struct simple_pid_list *next;
+};
+struct simple_pid_list *stopped_pids;
+
+/* Trivial list manipulation functions to keep track of a list of new
+   stopped processes.  */
+
+static void
+add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
+{
+  struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
+
+  new_pid->pid = pid;
+  new_pid->status = status;
+  new_pid->next = *listp;
+  *listp = new_pid;
+}
+
+static int
+pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
+{
+  struct simple_pid_list **p;
+
+  for (p = listp; *p != NULL; p = &(*p)->next)
+    if ((*p)->pid == pid)
+      {
+        struct simple_pid_list *next = (*p)->next;
+
+        *statusp = (*p)->status;
+        xfree (*p);
+        *p = next;
+        return 1;
+      }
+  return 0;
+}
+
+enum stopping_threads_kind
+  {
+    /* Not stopping threads presently.  */
+    NOT_STOPPING_THREADS,
+
+    /* Stopping threads.  */
+    STOPPING_THREADS,
+
+    /* Stopping and suspending threads.  */
+    STOPPING_AND_SUSPENDING_THREADS
+  };
+
+/* This is set while stop_all_lwps is in effect.  */
+enum stopping_threads_kind stopping_threads = NOT_STOPPING_THREADS;
 
 /* FIXME make into a target method?  */
 int using_threads = 1;
 
 /* True if we're presently stabilizing threads (moving them out of
    jump pads).  */
 static int stabilizing_threads;
 
 /* This flag is true iff we've just created or attached to our first
    inferior but it has not stopped yet.  As soon as it does, we need
@@ skipping 47 matching lines @@
   return the_low_target.install_fast_tracepoint_jump_pad != NULL;
 }
 
 struct pending_signals
 {
   int signal;
   siginfo_t info;
   struct pending_signals *prev;
 };
 
-#define PTRACE_ARG3_TYPE void *
-#define PTRACE_ARG4_TYPE void *
-#define PTRACE_XFER_TYPE long
-
 #ifdef HAVE_LINUX_REGSETS
 static char *disabled_regsets;
 static int num_regsets;
 #endif
 
 /* The read/write ends of the pipe registered as waitable file in the
    event loop.  */
 static int linux_event_pipe[2] = { -1, -1 };
 
 /* True if we're currently in async mode.  */
 #define target_is_async_p() (linux_event_pipe[0] != -1)
 
 static void send_sigstop (struct lwp_info *lwp);
 static void wait_for_sigstop (struct inferior_list_entry *entry);
 
-/* Accepts an integer PID; Returns a string representing a file that
-   can be opened to get info for the child process.
-   Space for the result is malloc'd, caller must free.  */
-
-char *
-linux_child_pid_to_exec_file (int pid)
-{
-  char *name1, *name2;
-
-  name1 = xmalloc (MAXPATHLEN);
-  name2 = xmalloc (MAXPATHLEN);
-  memset (name2, 0, MAXPATHLEN);
-
-  sprintf (name1, "/proc/%d/exe", pid);
-  if (readlink (name1, name2, MAXPATHLEN) > 0)
-    {
-      free (name1);
-      return name2;
-    }
-  else
-    {
-      free (name2);
-      return name1;
-    }
-}
-
 /* Return non-zero if HEADER is a 64-bit ELF file.  */
 
 static int
-elf_64_header_p (const Elf64_Ehdr *header)
+elf_64_header_p (const Elf64_Ehdr *header, unsigned int *machine)
 {
-  return (header->e_ident[EI_MAG0] == ELFMAG0
-          && header->e_ident[EI_MAG1] == ELFMAG1
-          && header->e_ident[EI_MAG2] == ELFMAG2
-          && header->e_ident[EI_MAG3] == ELFMAG3
-          && header->e_ident[EI_CLASS] == ELFCLASS64);
+  if (header->e_ident[EI_MAG0] == ELFMAG0
+      && header->e_ident[EI_MAG1] == ELFMAG1
+      && header->e_ident[EI_MAG2] == ELFMAG2
+      && header->e_ident[EI_MAG3] == ELFMAG3)
+    {
+      *machine = header->e_machine;
+      return header->e_ident[EI_CLASS] == ELFCLASS64;
+
+    }
+  *machine = EM_NONE;
+  return -1;
 }
 
 /* Return non-zero if FILE is a 64-bit ELF file,
    zero if the file is not a 64-bit ELF file,
    and -1 if the file is not accessible or doesn't exist.  */
 
-int
-elf_64_file_p (const char *file)
+static int
+elf_64_file_p (const char *file, unsigned int *machine)
 {
   Elf64_Ehdr header;
   int fd;
 
   fd = open (file, O_RDONLY);
   if (fd < 0)
     return -1;
 
   if (read (fd, &header, sizeof (header)) != sizeof (header))
     {
       close (fd);
       return 0;
     }
   close (fd);
 
-  return elf_64_header_p (&header);
+  return elf_64_header_p (&header, machine);
+}
+
+/* Accepts an integer PID; Returns true if the executable PID is
+   running is a 64-bit ELF file..  */
+
+int
+linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine)
+{
+  char file[MAXPATHLEN];
+
+  sprintf (file, "/proc/%d/exe", pid);
+  return elf_64_file_p (file, machine);
 }
 
 static void
 delete_lwp (struct lwp_info *lwp)
 {
   remove_thread (get_lwp_thread (lwp));
   remove_inferior (&all_lwps, &lwp->head);
   free (lwp->arch_private);
   free (lwp);
 }
@@ skipping 101 matching lines @@
 static void
 handle_extended_wait (struct lwp_info *event_child, int wstat)
 {
   int event = wstat >> 16;
   struct lwp_info *new_lwp;
 
   if (event == PTRACE_EVENT_CLONE)
     {
       ptid_t ptid;
       unsigned long new_pid;
-      int ret, status = W_STOPCODE (SIGSTOP);
+      int ret, status;
 
       ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
 
       /* If we haven't already seen the new PID stop, wait for it now.  */
-      if (! pull_pid_from_list (&stopped_pids, new_pid))
+      if (!pull_pid_from_list (&stopped_pids, new_pid, &status))
         {
           /* The new child has a pending SIGSTOP.  We can't affect it until it
              hits the SIGSTOP, but we're already attached.  */
 
           ret = my_waitpid (new_pid, &status, __WALL);
 
           if (ret == -1)
             perror_with_name ("waiting for new child");
           else if (ret != new_pid)
             warning ("wait returned unexpected PID %d", ret);
           else if (!WIFSTOPPED (status))
             warning ("wait returned unexpected status 0x%x", status);
         }
 
       linux_enable_event_reporting (new_pid);
 
       ptid = ptid_build (pid_of (event_child), new_pid, 0);
       new_lwp = (struct lwp_info *) add_lwp (ptid);
       add_thread (ptid, new_lwp);
 
       /* Either we're going to immediately resume the new thread
          or leave it stopped.  linux_resume_one_lwp is a nop if it
          thinks the thread is currently running, so set this first
          before calling linux_resume_one_lwp.  */
       new_lwp->stopped = 1;
 
+     /* If we're suspending all threads, leave this one suspended
+        too.  */
+      if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS)
+        new_lwp->suspended = 1;
+
       /* Normally we will get the pending SIGSTOP.  But in some cases
          we might get another signal delivered to the group first.
          If we do get another signal, be sure not to lose it.  */
       if (WSTOPSIG (status) == SIGSTOP)
         {
-          if (stopping_threads)
+          if (stopping_threads != NOT_STOPPING_THREADS)
             new_lwp->stop_pc = get_stop_pc (new_lwp);
           else
             linux_resume_one_lwp (new_lwp, 0, 0, NULL);
         }
       else
         {
           new_lwp->stop_expected = 1;
 
-          if (stopping_threads)
+          if (stopping_threads != NOT_STOPPING_THREADS)
             {
               new_lwp->stop_pc = get_stop_pc (new_lwp);
               new_lwp->status_pending_p = 1;
               new_lwp->status_pending = status;
             }
           else
             /* Pass the signal on.  This is what GDB does - except
                shouldn't we really report it instead?  */
             linux_resume_one_lwp (new_lwp, 0, WSTOPSIG (status), NULL);
         }
@@ skipping 134 matching lines @@
   if (pid == 0)
     {
       ptrace (PTRACE_TRACEME, 0, 0, 0);
 
 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does.  */
       signal (__SIGRTMIN + 1, SIG_DFL);
 #endif
 
       setpgid (0, 0);
 
+      /* If gdbserver is connected to gdb via stdio, redirect the inferior's
+         stdout to stderr so that inferior i/o doesn't corrupt the connection.
+         Also, redirect stdin to /dev/null.  */
+      if (remote_connection_is_stdio ())
+        {
+          close (0);
+          open ("/dev/null", O_RDONLY);
+          dup2 (2, 1);
+          if (write (2, "stdin/stdout redirected\n",
+                     sizeof ("stdin/stdout redirected\n") - 1) < 0)
+            /* Errors ignored.  */;
+        }
+
       execv (program, allargs);
       if (errno == ENOENT)
         execvp (program, allargs);
 
       fprintf (stderr, "Cannot exec %s: %s.\n", program,
                strerror (errno));
       fflush (stderr);
       _exit (0177);
     }
 
@@ skipping 21 matching lines @@
 /* Attach to an inferior process.  */
 
 static void
 linux_attach_lwp_1 (unsigned long lwpid, int initial)
 {
   ptid_t ptid;
   struct lwp_info *new_lwp;
 
   if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) != 0)
     {
+      struct buffer buffer;
+
       if (!initial)
         {
           /* If we fail to attach to an LWP, just warn.  */
           fprintf (stderr, "Cannot attach to lwp %ld: %s (%d)\n", lwpid,
                    strerror (errno), errno);
           fflush (stderr);
           return;
         }
-      else
-        /* If we fail to attach to a process, report an error.  */
-        error ("Cannot attach to lwp %ld: %s (%d)\n", lwpid,
-               strerror (errno), errno);
+
+      /* If we fail to attach to a process, report an error.  */
+      buffer_init (&buffer);
+      linux_ptrace_attach_warnings (lwpid, &buffer);
+      buffer_grow_str0 (&buffer, "");
+      error ("%sCannot attach to lwp %ld: %s (%d)", buffer_finish (&buffer),
+             lwpid, strerror (errno), errno);
     }
 
   if (initial)
     /* If lwp is the tgid, we handle adding existing threads later.
        Otherwise we just add lwp without bothering about any other
        threads.  */
     ptid = ptid_build (lwpid, lwpid, 0);
   else
     {
       /* Note that extracting the pid from the current inferior is
          safe, since we're always called in the context of the same
          process as this new thread.  */
       int pid = pid_of (get_thread_lwp (current_inferior));
       ptid = ptid_build (pid, lwpid, 0);
     }
 
   new_lwp = (struct lwp_info *) add_lwp (ptid);
   add_thread (ptid, new_lwp);
 
   /* We need to wait for SIGSTOP before being able to make the next
      ptrace call on this LWP.  */
   new_lwp->must_set_ptrace_flags = 1;
 
+  if (linux_proc_pid_is_stopped (lwpid))
+    {
+      if (debug_threads)
+        fprintf (stderr,
+                 "Attached to a stopped process\n");
+
+      /* The process is definitely stopped.  It is in a job control
+         stop, unless the kernel predates the TASK_STOPPED /
+         TASK_TRACED distinction, in which case it might be in a
+         ptrace stop.  Make sure it is in a ptrace stop; from there we
+         can kill it, signal it, et cetera.
+
+         First make sure there is a pending SIGSTOP.  Since we are
+         already attached, the process can not transition from stopped
+         to running without a PTRACE_CONT; so we know this signal will
+         go into the queue.  The SIGSTOP generated by PTRACE_ATTACH is
+         probably already in the queue (unless this kernel is old
+         enough to use TASK_STOPPED for ptrace stops); but since
+         SIGSTOP is not an RT signal, it can only be queued once.  */
+      kill_lwp (lwpid, SIGSTOP);
+
+      /* Finally, resume the stopped process.  This will deliver the
+         SIGSTOP (or a higher priority signal, just like normal
+         PTRACE_ATTACH), which we'll catch later on.  */
+      ptrace (PTRACE_CONT, lwpid, 0, 0);
+    }
+
   /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
      brings it to a halt.
 
      There are several cases to consider here:
 
      1) gdbserver has already attached to the process and is being notified
         of a new thread that is being created.
         In this case we should ignore that SIGSTOP and resume the
         process.  This is handled below by setting stop_expected = 1,
         and the fact that add_thread sets last_resume_kind ==
@@ skipping 27 matching lines @@
 
 void
 linux_attach_lwp (unsigned long lwpid)
 {
   linux_attach_lwp_1 (lwpid, 0);
 }
 
 /* Attach to PID.  If PID is the tgid, attach to it and all
    of its threads.  */
 
-int
+static int
 linux_attach (unsigned long pid)
 {
   /* Attach to PID.  We will check for other threads
      soon.  */
   linux_attach_lwp_1 (pid, 1);
   linux_add_process (pid, 1);
 
   if (!non_stop)
     {
       struct thread_info *thread;
@@ skipping 90 matching lines @@
 last_thread_of_process_p (struct thread_info *thread)
 {
   ptid_t ptid = ((struct inferior_list_entry *)thread)->id;
   int pid = ptid_get_pid (ptid);
   struct counter counter = { pid , 0 };
 
   return (find_inferior (&all_threads,
                          second_thread_of_pid_p, &counter) == NULL);
 }
 
-/* Kill the inferior lwp.  */
+/* Kill LWP.  */
+
+static void
+linux_kill_one_lwp (struct lwp_info *lwp)
+{
+  int pid = lwpid_of (lwp);
+
+  /* PTRACE_KILL is unreliable.  After stepping into a signal handler,
+     there is no signal context, and ptrace(PTRACE_KILL) (or
+     ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
+     ptrace(CONT, pid, 0,0) and just resumes the tracee.  A better
+     alternative is to kill with SIGKILL.  We only need one SIGKILL
+     per process, not one for each thread.  But since we still support
+     linuxthreads, and we also support debugging programs using raw
+     clone without CLONE_THREAD, we send one for each thread.  For
+     years, we used PTRACE_KILL only, so we're being a bit paranoid
+     about some old kernels where PTRACE_KILL might work better
+     (dubious if there are any such, but that's why it's paranoia), so
+     we try SIGKILL first, PTRACE_KILL second, and so we're fine
+     everywhere.  */
+
+  errno = 0;
+  kill (pid, SIGKILL);
+  if (debug_threads)
+    fprintf (stderr,
+             "LKL:  kill (SIGKILL) %s, 0, 0 (%s)\n",
+             target_pid_to_str (ptid_of (lwp)),
+             errno ? strerror (errno) : "OK");
+
+  errno = 0;
+  ptrace (PTRACE_KILL, pid, 0, 0);
+  if (debug_threads)
+    fprintf (stderr,
+             "LKL:  PTRACE_KILL %s, 0, 0 (%s)\n",
+             target_pid_to_str (ptid_of (lwp)),
+             errno ? strerror (errno) : "OK");
+}
+
+/* Callback for `find_inferior'.  Kills an lwp of a given process,
+   except the leader.  */
 
 static int
-linux_kill_one_lwp (struct inferior_list_entry *entry, void *args)
+kill_one_lwp_callback (struct inferior_list_entry *entry, void *args)
 {
   struct thread_info *thread = (struct thread_info *) entry;
   struct lwp_info *lwp = get_thread_lwp (thread);
   int wstat;
   int pid = * (int *) args;
 
   if (ptid_get_pid (entry->id) != pid)
     return 0;
 
   /* We avoid killing the first thread here, because of a Linux kernel (at
      least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
      the children get a chance to be reaped, it will remain a zombie
      forever.  */
 
   if (lwpid_of (lwp) == pid)
     {
       if (debug_threads)
         fprintf (stderr, "lkop: is last of process %s\n",
                  target_pid_to_str (entry->id));
       return 0;
     }
 
   do
     {
-      ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
+      linux_kill_one_lwp (lwp);
 
       /* Make sure it died.  The loop is most likely unnecessary.  */
       pid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
     } while (pid > 0 && WIFSTOPPED (wstat));
 
   return 0;
 }
 
 static int
 linux_kill (int pid)
 {
   struct process_info *process;
   struct lwp_info *lwp;
   int wstat;
   int lwpid;
 
   process = find_process_pid (pid);
   if (process == NULL)
     return -1;
 
   /* If we're killing a running inferior, make sure it is stopped
      first, as PTRACE_KILL will not work otherwise.  */
   stop_all_lwps (0, NULL);
 
-  find_inferior (&all_threads, linux_kill_one_lwp, &pid);
+  find_inferior (&all_threads, kill_one_lwp_callback , &pid);
 
   /* See the comment in linux_kill_one_lwp.  We did not kill the first
      thread in the list, so do so now.  */
   lwp = find_lwp_pid (pid_to_ptid (pid));
 
   if (lwp == NULL)
     {
       if (debug_threads)
         fprintf (stderr, "lk_1: cannot find lwp %ld, for pid: %d\n",
                  lwpid_of (lwp), pid);
     }
   else
     {
       if (debug_threads)
         fprintf (stderr, "lk_1: killing lwp %ld, for pid: %d\n",
                  lwpid_of (lwp), pid);
 
       do
         {
-          ptrace (PTRACE_KILL, lwpid_of (lwp), 0, 0);
+          linux_kill_one_lwp (lwp);
 
           /* Make sure it died.  The loop is most likely unnecessary.  */
           lwpid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
         } while (lwpid > 0 && WIFSTOPPED (wstat));
     }
 
   the_target->mourn (process);
 
   /* Since we presently can only stop all lwps of all processes, we
      need to unstop lwps of other processes.  */
   unstop_all_lwps (0, NULL);
   return 0;
 }
 
+/* Get pending signal of THREAD, for detaching purposes.  This is the
+   signal the thread last stopped for, which we need to deliver to the
+   thread when detaching, otherwise, it'd be suppressed/lost.  */
+
+static int
+get_detach_signal (struct thread_info *thread)
+{
+  enum gdb_signal signo = GDB_SIGNAL_0;
+  int status;
+  struct lwp_info *lp = get_thread_lwp (thread);
+
+  if (lp->status_pending_p)
+    status = lp->status_pending;
+  else
+    {
+      /* If the thread had been suspended by gdbserver, and it stopped
+         cleanly, then it'll have stopped with SIGSTOP.  But we don't
+         want to deliver that SIGSTOP.  */
+      if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
+          || thread->last_status.value.sig == GDB_SIGNAL_0)
+        return 0;
+
+      /* Otherwise, we may need to deliver the signal we
+         intercepted.  */
+      status = lp->last_status;
+    }
+
+  if (!WIFSTOPPED (status))
+    {
+      if (debug_threads)
+        fprintf (stderr,
+                 "GPS: lwp %s hasn't stopped: no pending signal\n",
+                 target_pid_to_str (ptid_of (lp)));
+      return 0;
+    }
+
+  /* Extended wait statuses aren't real SIGTRAPs.  */
+  if (WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
+    {
+      if (debug_threads)
+        fprintf (stderr,
+                 "GPS: lwp %s had stopped with extended "
+                 "status: no pending signal\n",
+                 target_pid_to_str (ptid_of (lp)));
+      return 0;
+    }
+
+  signo = gdb_signal_from_host (WSTOPSIG (status));
+
+  if (program_signals_p && !program_signals[signo])
+    {
+      if (debug_threads)
+        fprintf (stderr,
+                 "GPS: lwp %s had signal %s, but it is in nopass state\n",
+                 target_pid_to_str (ptid_of (lp)),
+                 gdb_signal_to_string (signo));
+      return 0;
+    }
+  else if (!program_signals_p
+           /* If we have no way to know which signals GDB does not
+              want to have passed to the program, assume
+              SIGTRAP/SIGINT, which is GDB's default.  */
+           && (signo == GDB_SIGNAL_TRAP || signo == GDB_SIGNAL_INT))
+    {
+      if (debug_threads)
+        fprintf (stderr,
+                 "GPS: lwp %s had signal %s, "
+                 "but we don't know if we should pass it.  Default to not.\n",
+                 target_pid_to_str (ptid_of (lp)),
+                 gdb_signal_to_string (signo));
+      return 0;
+    }
+  else
+    {
+      if (debug_threads)
+        fprintf (stderr,
+                 "GPS: lwp %s has pending signal %s: delivering it.\n",
+                 target_pid_to_str (ptid_of (lp)),
+                 gdb_signal_to_string (signo));
+
+      return WSTOPSIG (status);
+    }
+}
+
 static int
 linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
 {
   struct thread_info *thread = (struct thread_info *) entry;
   struct lwp_info *lwp = get_thread_lwp (thread);
   int pid = * (int *) args;
+  int sig;
 
   if (ptid_get_pid (entry->id) != pid)
     return 0;
 
-  /* If this process is stopped but is expecting a SIGSTOP, then make
-     sure we take care of that now.  This isn't absolutely guaranteed
-     to collect the SIGSTOP, but is fairly likely to.  */
+  /* If there is a pending SIGSTOP, get rid of it.  */
   if (lwp->stop_expected)
     {
-      int wstat;
-      /* Clear stop_expected, so that the SIGSTOP will be reported.  */
+      if (debug_threads)
+        fprintf (stderr,
+                 "Sending SIGCONT to %s\n",
+                 target_pid_to_str (ptid_of (lwp)));
+
+      kill_lwp (lwpid_of (lwp), SIGCONT);
       lwp->stop_expected = 0;
-      linux_resume_one_lwp (lwp, 0, 0, NULL);
-      linux_wait_for_event (lwp->head.id, &wstat, __WALL);
     }
 
   /* Flush any pending changes to the process's registers.  */
   regcache_invalidate_one ((struct inferior_list_entry *)
                            get_lwp_thread (lwp));
 
+  /* Pass on any pending signal for this thread.  */
+  sig = get_detach_signal (thread);
+
   /* Finally, let it resume.  */
-  ptrace (PTRACE_DETACH, lwpid_of (lwp), 0, 0);
+  if (the_low_target.prepare_to_resume != NULL)
+    the_low_target.prepare_to_resume (lwp);
+  if (ptrace (PTRACE_DETACH, lwpid_of (lwp), 0,
+              (PTRACE_ARG4_TYPE) (long) sig) < 0)
+    error (_("Can't detach %s: %s"),
+           target_pid_to_str (ptid_of (lwp)),
+           strerror (errno));
 
   delete_lwp (lwp);
   return 0;
 }
 
 static int
 linux_detach (int pid)
 {
   struct process_info *process;
 
@@ skipping 165 matching lines @@
     fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
 
   child = find_lwp_pid (pid_to_ptid (ret));
 
   /* If we didn't find a process, one of two things presumably happened:
      - A process we started and then detached from has exited.  Ignore it.
      - A process we are controlling has forked and the new child's stop
      was reported to us by the kernel.  Save its PID.  */
   if (child == NULL && WIFSTOPPED (*wstatp))
     {
-      add_pid_to_list (&stopped_pids, ret);
+      add_to_pid_list (&stopped_pids, ret, *wstatp);
       goto retry;
     }
   else if (child == NULL)
     goto retry;
 
   child->stopped = 1;
 
   child->last_status = *wstatp;
 
   /* Architecture-specific setup after inferior is running.
@@ skipping 156 matching lines @@
 maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
 {
   struct thread_info *saved_inferior;
 
   saved_inferior = current_inferior;
   current_inferior = get_lwp_thread (lwp);
 
   if ((wstat == NULL
        || (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
       && supports_fast_tracepoints ()
-      && in_process_agent_loaded ())
+      && agent_loaded_p ())
     {
       struct fast_tpoint_collect_status status;
       int r;
 
       if (debug_threads)
         fprintf (stderr, "\
 Checking whether LWP %ld needs to move out of the jump pad.\n",
                  lwpid_of (lwp));
 
       r = linux_fast_tracepoint_collecting (lwp, &status);
@@ skipping 253 matching lines @@
    being stepped.  */
 ptid_t step_over_bkpt;
 
 /* Wait for an event from child PID.  If PID is -1, wait for any
    child.  Store the stop status through the status pointer WSTAT.
    OPTIONS is passed to the waitpid call.  Return 0 if no child stop
    event was found and OPTIONS contains WNOHANG.  Return the PID of
    the stopped child otherwise.  */
 
 static int
-linux_wait_for_event_1 (ptid_t ptid, int *wstat, int options)
+linux_wait_for_event (ptid_t ptid, int *wstat, int options)
 {
   struct lwp_info *event_child, *requested_child;
+  ptid_t wait_ptid;
 
   event_child = NULL;
   requested_child = NULL;
 
   /* Check for a lwp with a pending status.  */
 
-  if (ptid_equal (ptid, minus_one_ptid)
-      || ptid_equal (pid_to_ptid (ptid_get_pid (ptid)), ptid))
+  if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
     {
       event_child = (struct lwp_info *)
         find_inferior (&all_lwps, status_pending_p_callback, &ptid);
       if (debug_threads && event_child)
         fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
     }
   else
     {
       requested_child = find_lwp_pid (ptid);
 
-      if (!stopping_threads
+      if (stopping_threads == NOT_STOPPING_THREADS
           && requested_child->status_pending_p
           && requested_child->collecting_fast_tracepoint)
         {
           enqueue_one_deferred_signal (requested_child,
                                        &requested_child->status_pending);
           requested_child->status_pending_p = 0;
           requested_child->status_pending = 0;
           linux_resume_one_lwp (requested_child, 0, 0, NULL);
         }
 
@@ skipping 10 matching lines @@
       if (debug_threads)
         fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
                  lwpid_of (event_child), event_child->status_pending);
       *wstat = event_child->status_pending;
       event_child->status_pending_p = 0;
       event_child->status_pending = 0;
       current_inferior = get_lwp_thread (event_child);
       return lwpid_of (event_child);
     }
 
+  if (ptid_is_pid (ptid))
+    {
+      /* A request to wait for a specific tgid.  This is not possible
+         with waitpid, so instead, we wait for any child, and leave
+         children we're not interested in right now with a pending
+         status to report later.  */
+      wait_ptid = minus_one_ptid;
+    }
+  else
+    wait_ptid = ptid;
+
   /* We only enter this loop if no process has a pending wait status.  Thus
      any action taken in response to a wait status inside this loop is
      responding as soon as we detect the status, not after any pending
      events.  */
   while (1)
     {
-      event_child = linux_wait_for_lwp (ptid, wstat, options);
+      event_child = linux_wait_for_lwp (wait_ptid, wstat, options);
 
       if ((options & WNOHANG) && event_child == NULL)
         {
           if (debug_threads)
             fprintf (stderr, "WNOHANG set, no event found\n");
           return 0;
         }
 
       if (event_child == NULL)
         error ("event from unknown child");
 
+      if (ptid_is_pid (ptid)
+          && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_child)))
+        {
+          if (! WIFSTOPPED (*wstat))
+            mark_lwp_dead (event_child, *wstat);
+          else
+            {
+              event_child->status_pending_p = 1;
+              event_child->status_pending = *wstat;
+            }
+          continue;
+        }
+
       current_inferior = get_lwp_thread (event_child);
 
       /* Check for thread exit.  */
       if (! WIFSTOPPED (*wstat))
         {
           if (debug_threads)
             fprintf (stderr, "LWP %ld exiting\n", lwpid_of (event_child));
 
           /* If the last thread is exiting, just return.  */
           if (last_thread_of_process_p (current_inferior))
@@ skipping 55 matching lines @@
           && WSTOPSIG (*wstat) == SIGSTOP
           && event_child->stop_expected)
         {
           int should_stop;
 
           if (debug_threads)
             fprintf (stderr, "Expected stop.\n");
           event_child->stop_expected = 0;
 
           should_stop = (current_inferior->last_resume_kind == resume_stop
-                         || stopping_threads);
+                         || stopping_threads != NOT_STOPPING_THREADS);
 
           if (!should_stop)
             {
               linux_resume_one_lwp (event_child,
                                     event_child->stepping, 0, NULL);
               continue;
             }
         }
 
       return lwpid_of (event_child);
     }
 
   /* NOTREACHED */
   return 0;
 }
 
-static int
-linux_wait_for_event (ptid_t ptid, int *wstat, int options)
-{
-  ptid_t wait_ptid;
-
-  if (ptid_is_pid (ptid))
-    {
-      /* A request to wait for a specific tgid.  This is not possible
-         with waitpid, so instead, we wait for any child, and leave
-         children we're not interested in right now with a pending
-         status to report later.  */
-      wait_ptid = minus_one_ptid;
-    }
-  else
-    wait_ptid = ptid;
-
-  while (1)
-    {
-      int event_pid;
-
-      event_pid = linux_wait_for_event_1 (wait_ptid, wstat, options);
-
-      if (event_pid > 0
-          && ptid_is_pid (ptid) && ptid_get_pid (ptid) != event_pid)
-        {
-          struct lwp_info *event_child
-            = find_lwp_pid (pid_to_ptid (event_pid));
-
-          if (! WIFSTOPPED (*wstat))
-            mark_lwp_dead (event_child, *wstat);
-          else
-            {
-              event_child->status_pending_p = 1;
-              event_child->status_pending = *wstat;
-            }
-        }
-      else
-        return event_pid;
-    }
-}
-
-
 /* Count the LWP's that have had events.  */
 
 static int
 count_events_callback (struct inferior_list_entry *entry, void *data)
 {
   struct lwp_info *lp = (struct lwp_info *) entry;
   struct thread_info *thread = get_lwp_thread (lp);
   int *count = data;
 
   gdb_assert (count != NULL);
@@ skipping 243 matching lines @@
          over internal breakpoints and such.  */
       linux_wait_1 (minus_one_ptid, &ourstatus, 0);
 
       if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
         {
           lwp = get_thread_lwp (current_inferior);
 
           /* Lock it.  */
           lwp->suspended++;
 
-          if (ourstatus.value.sig != TARGET_SIGNAL_0
+          if (ourstatus.value.sig != GDB_SIGNAL_0
               || current_inferior->last_resume_kind == resume_stop)
             {
-              wstat = W_STOPCODE (target_signal_to_host (ourstatus.value.sig));
+              wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.value.sig));
               enqueue_one_deferred_signal (lwp, &wstat);
             }
         }
     }
 
   find_inferior (&all_lwps, unsuspend_one_lwp, NULL);
 
   stabilizing_threads = 0;
 
   current_inferior = save_inferior;
@@ skipping 100 matching lines @@
               ourstatus->value.integer = WEXITSTATUS (w);
 
               if (debug_threads)
                 fprintf (stderr,
                          "\nChild exited with retcode = %x \n",
                          WEXITSTATUS (w));
             }
           else
             {
               ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
-              ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));
+              ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
 
               if (debug_threads)
                 fprintf (stderr,
                          "\nChild terminated with signal = %x \n",
                          WTERMSIG (w));
 
             }
 
           return ptid_of (event_child);
         }
@@ skipping 63 matching lines @@
   /* We have all the data we need.  Either report the event to GDB, or
      resume threads and keep waiting for more.  */
 
   /* If we're collecting a fast tracepoint, finish the collection and
      move out of the jump pad before delivering a signal.  See
      linux_stabilize_threads.  */
 
   if (WIFSTOPPED (w)
       && WSTOPSIG (w) != SIGTRAP
       && supports_fast_tracepoints ()
-      && in_process_agent_loaded ())
+      && agent_loaded_p ())
     {
       if (debug_threads)
         fprintf (stderr,
                  "Got signal %d for LWP %ld.  Check if we need "
                  "to defer or adjust it.\n",
                  WSTOPSIG (w), lwpid_of (event_child));
 
       /* Allow debugging the jump pad itself.  */
       if (current_inferior->last_resume_kind != resume_step
           && maybe_move_out_of_jump_pad (event_child, &w))
@@ skipping 67 matching lines @@
                 fprintf (stderr, "dequeued one signal.\n");
             }
           else
             {
               if (debug_threads)
                 fprintf (stderr, "no deferred signals.\n");
 
               if (stabilizing_threads)
                 {
                   ourstatus->kind = TARGET_WAITKIND_STOPPED;
-                  ourstatus->value.sig = TARGET_SIGNAL_0;
+                  ourstatus->value.sig = GDB_SIGNAL_0;
                   return ptid_of (event_child);
                 }
             }
         }
     }
 
   /* Check whether GDB would be interested in this event.  */
 
   /* If GDB is not interested in this signal, don't stop other
      threads, and don't report it to GDB.  Just resume the inferior
      right away.  We do this for threading-related signals as well as
      any that GDB specifically requested we ignore.  But never ignore
      SIGSTOP if we sent it ourselves, and do not ignore signals when
      stepping - they may require special handling to skip the signal
      handler.  */
   /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
      thread library?  */
   if (WIFSTOPPED (w)
       && current_inferior->last_resume_kind != resume_step
       && (
 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
           (current_process ()->private->thread_db != NULL
            && (WSTOPSIG (w) == __SIGRTMIN
                || WSTOPSIG (w) == __SIGRTMIN + 1))
           ||
 #endif
-          (pass_signals[target_signal_from_host (WSTOPSIG (w))]
+          (pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
            && !(WSTOPSIG (w) == SIGSTOP
                 && current_inferior->last_resume_kind == resume_stop))))
     {
       siginfo_t info, *info_p;
 
       if (debug_threads)
         fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
                  WSTOPSIG (w), lwpid_of (event_child));
 
       if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), 0, &info) == 0)
@@ skipping 11 matching lines @@
      SIGTRAP we can't explain could be a GDB breakpoint --- we may or
      not support Z0 breakpoints.  If we do, we're be able to handle
      GDB breakpoints on top of internal breakpoints, by handling the
      internal breakpoint and still reporting the event to GDB.  If we
      don't, we're out of luck, GDB won't see the breakpoint hit.  */
   report_to_gdb = (!maybe_internal_trap
                    || current_inferior->last_resume_kind == resume_step
                    || event_child->stopped_by_watchpoint
                    || (!step_over_finished
                        && !bp_explains_trap && !trace_event)
-                   || gdb_breakpoint_here (event_child->stop_pc));
+                   || (gdb_breakpoint_here (event_child->stop_pc)
+                       && gdb_condition_true_at_breakpoint (event_child->stop_pc)
+                       && gdb_no_commands_at_breakpoint (event_child->stop_pc)));
+
+  run_breakpoint_commands (event_child->stop_pc);
 
   /* We found no reason GDB would want us to stop.  We either hit one
      of our own breakpoints, or finished an internal step GDB
      shouldn't know about.  */
   if (!report_to_gdb)
     {
       if (debug_threads)
         {
           if (bp_explains_trap)
             fprintf (stderr, "Hit a gdbserver breakpoint.\n");
@@ skipping 62 matching lines @@
           event_child->status_pending_p = 0;
           w = event_child->status_pending;
         }
 
       /* Now that we've selected our final event LWP, cancel any
          breakpoints in other LWPs that have hit a GDB breakpoint.
          See the comment in cancel_breakpoints_callback to find out
          why.  */
       find_inferior (&all_lwps, cancel_breakpoints_callback, event_child);
 
+      /* If we were going a step-over, all other threads but the stepping one
+         had been paused in start_step_over, with their suspend counts
+         incremented.  We don't want to do a full unstop/unpause, because we're
+         in all-stop mode (so we want threads stopped), but we still need to
+         unsuspend the other threads, to decrement their `suspended' count
+         back.  */
+      if (step_over_finished)
+        unsuspend_all_lwps (event_child);
+
       /* Stabilize threads (move out of jump pads).  */
       stabilize_threads ();
     }
   else
     {
       /* If we just finished a step-over, then all threads had been
          momentarily paused.  In all-stop, that's fine, we want
          threads stopped by now anyway.  In non-stop, we need to
          re-resume threads that GDB wanted to be running.  */
       if (step_over_finished)
         unstop_all_lwps (1, event_child);
     }
 
   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 
   if (current_inferior->last_resume_kind == resume_stop
       && WSTOPSIG (w) == SIGSTOP)
     {
       /* A thread that has been requested to stop by GDB with vCont;t,
          and it stopped cleanly, so report as SIG0.  The use of
          SIGSTOP is an implementation detail.  */
-      ourstatus->value.sig = TARGET_SIGNAL_0;
+      ourstatus->value.sig = GDB_SIGNAL_0;
     }
   else if (current_inferior->last_resume_kind == resume_stop
            && WSTOPSIG (w) != SIGSTOP)
     {
       /* A thread that has been requested to stop by GDB with vCont;t,
          but, it stopped for other reasons.  */
-      ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
+      ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
     }
   else
     {
-      ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
+      ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
     }
 
   gdb_assert (ptid_equal (step_over_bkpt, null_ptid));
 
   if (debug_threads)
     fprintf (stderr, "linux_wait ret = %s, %d, %d\n",
              target_pid_to_str (ptid_of (event_child)),
              ourstatus->kind,
              ourstatus->value.sig);
 
@@ skipping 261 matching lines @@
 stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
 {
   struct lwp_info *lwp = (struct lwp_info *) entry;
   struct thread_info *thread = get_lwp_thread (lwp);
 
   gdb_assert (lwp->suspended == 0);
   gdb_assert (lwp->stopped);
 
   /* Allow debugging the jump pad, gdb_collect, etc..  */
   return (supports_fast_tracepoints ()
-          && in_process_agent_loaded ()
+          && agent_loaded_p ()
           && (gdb_breakpoint_here (lwp->stop_pc)
               || lwp->stopped_by_watchpoint
               || thread->last_resume_kind == resume_step)
           && linux_fast_tracepoint_collecting (lwp, NULL));
 }
 
 static void
 move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
 {
   struct lwp_info *lwp = (struct lwp_info *) entry;
@@ skipping 46 matching lines @@
   return 1;
 }
 
 /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
    If SUSPEND, then also increase the suspend count of every LWP,
    except EXCEPT.  */
 
 static void
 stop_all_lwps (int suspend, struct lwp_info *except)
 {
-  stopping_threads = 1;
+  /* Should not be called recursively.  */
+  gdb_assert (stopping_threads == NOT_STOPPING_THREADS);
+
+  stopping_threads = (suspend
+                      ? STOPPING_AND_SUSPENDING_THREADS
+                      : STOPPING_THREADS);
 
   if (suspend)
     find_inferior (&all_lwps, suspend_and_send_sigstop_callback, except);
   else
     find_inferior (&all_lwps, send_sigstop_callback, except);
   for_each_inferior (&all_lwps, wait_for_sigstop);
-  stopping_threads = 0;
+  stopping_threads = NOT_STOPPING_THREADS;
 }
 
 /* Resume execution of the inferior process.
    If STEP is nonzero, single-step it.
    If SIGNAL is nonzero, give it that signal.  */
 
 static void
 linux_resume_one_lwp (struct lwp_info *lwp,
                       int step, int signal, siginfo_t *info)
 {
@@ skipping 215 matching lines @@
 
   thread = (struct thread_info *) entry;
   lwp = get_thread_lwp (thread);
   r = arg;
 
   for (ndx = 0; ndx < r->n; ndx++)
     {
       ptid_t ptid = r->resume[ndx].thread;
       if (ptid_equal (ptid, minus_one_ptid)
           || ptid_equal (ptid, entry->id)
-          || (ptid_is_pid (ptid)
-              && (ptid_get_pid (ptid) == pid_of (lwp)))
-          || (ptid_get_lwp (ptid) == -1
-              && (ptid_get_pid (ptid) == pid_of (lwp))))
+          /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
+             of PID'.  */
+          || (ptid_get_pid (ptid) == pid_of (lwp)
+              && (ptid_is_pid (ptid)
+                  || ptid_get_lwp (ptid) == -1)))
         {
           if (r->resume[ndx].kind == resume_stop
               && thread->last_resume_kind == resume_stop)
             {
               if (debug_threads)
                 fprintf (stderr, "already %s LWP %ld at GDB's request\n",
                          thread->last_status.kind == TARGET_WAITKIND_STOPPED
                          ? "stopped"
                          : "stopping",
                          lwpid_of (lwp));
@@ skipping 132 matching lines @@
       return 0;
     }
 
   saved_inferior = current_inferior;
   current_inferior = thread;
 
   /* We can only step over breakpoints we know about.  */
   if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
     {
       /* Don't step over a breakpoint that GDB expects to hit
-         though.  */
-      if (gdb_breakpoint_here (pc))
+         though.  If the condition is being evaluated on the target's side
+         and it evaluate to false, step over this breakpoint as well.  */
+      if (gdb_breakpoint_here (pc)
+          && gdb_condition_true_at_breakpoint (pc)
+          && gdb_no_commands_at_breakpoint (pc))
         {
           if (debug_threads)
             fprintf (stderr,
                      "Need step over [LWP %ld]? yes, but found"
                      " GDB breakpoint at 0x%s; skipping step over\n",
                      lwpid_of (lwp), paddress (pc));
 
           current_inferior = saved_inferior;
           return 0;
         }
@@ skipping 459 matching lines @@
         fprintf (stderr,
                  "unstopping all lwps\n");
     }
 
   if (unsuspend)
     find_inferior (&all_lwps, unsuspend_and_proceed_one_lwp, except);
   else
     find_inferior (&all_lwps, proceed_one_lwp, except);
 }
 
-#ifdef HAVE_LINUX_USRREGS
-
-int
-register_addr (int regnum)
-{
-  int addr;
-
-  if (regnum < 0 || regnum >= the_low_target.num_regs)
-    error ("Invalid register number %d.", regnum);
-
-  addr = the_low_target.regmap[regnum];
-
-  return addr;
-}
-
-/* Fetch one register.  */
-static void
-fetch_register (struct regcache *regcache, int regno)
-{
-  CORE_ADDR regaddr;
-  int i, size;
-  char *buf;
-  int pid;
-
-  if (regno >= the_low_target.num_regs)
-    return;
-  if ((*the_low_target.cannot_fetch_register) (regno))
-    return;
-
-  regaddr = register_addr (regno);
-  if (regaddr == -1)
-    return;
-
-  size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
-          & -sizeof (PTRACE_XFER_TYPE));
-  buf = alloca (size);
-
-  pid = lwpid_of (get_thread_lwp (current_inferior));
-  for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
-    {
-      errno = 0;
-      *(PTRACE_XFER_TYPE *) (buf + i) =
-        ptrace (PTRACE_PEEKUSER, pid,
-                /* Coerce to a uintptr_t first to avoid potential gcc warning
-                   of coercing an 8 byte integer to a 4 byte pointer.  */
-                (PTRACE_ARG3_TYPE) (uintptr_t) regaddr, 0);
-      regaddr += sizeof (PTRACE_XFER_TYPE);
-      if (errno != 0)
-        error ("reading register %d: %s", regno, strerror (errno));
-    }
-
-  if (the_low_target.supply_ptrace_register)
-    the_low_target.supply_ptrace_register (regcache, regno, buf);
-  else
-    supply_register (regcache, regno, buf);
-}
-
-/* Store one register.  */
-static void
-store_register (struct regcache *regcache, int regno)
-{
-  CORE_ADDR regaddr;
-  int i, size;
-  char *buf;
-  int pid;
-
-  if (regno >= the_low_target.num_regs)
-    return;
-  if ((*the_low_target.cannot_store_register) (regno))
-    return;
-
-  regaddr = register_addr (regno);
-  if (regaddr == -1)
-    return;
-
-  size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
-          & -sizeof (PTRACE_XFER_TYPE));
-  buf = alloca (size);
-  memset (buf, 0, size);
-
-  if (the_low_target.collect_ptrace_register)
-    the_low_target.collect_ptrace_register (regcache, regno, buf);
-  else
-    collect_register (regcache, regno, buf);
-
-  pid = lwpid_of (get_thread_lwp (current_inferior));
-  for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
-    {
-      errno = 0;
-      ptrace (PTRACE_POKEUSER, pid,
-            /* Coerce to a uintptr_t first to avoid potential gcc warning
-               about coercing an 8 byte integer to a 4 byte pointer.  */
-              (PTRACE_ARG3_TYPE) (uintptr_t) regaddr,
-              (PTRACE_ARG4_TYPE) *(PTRACE_XFER_TYPE *) (buf + i));
-      if (errno != 0)
-        {
-          /* At this point, ESRCH should mean the process is
-             already gone, in which case we simply ignore attempts
-             to change its registers.  See also the related
-             comment in linux_resume_one_lwp.  */
-          if (errno == ESRCH)
-            return;
-
-          if ((*the_low_target.cannot_store_register) (regno) == 0)
-            error ("writing register %d: %s", regno, strerror (errno));
-        }
-      regaddr += sizeof (PTRACE_XFER_TYPE);
-    }
-}
-
-/* Fetch all registers, or just one, from the child process.  */
-static void
-usr_fetch_inferior_registers (struct regcache *regcache, int regno)
-{
-  if (regno == -1)
-    for (regno = 0; regno < the_low_target.num_regs; regno++)
-      fetch_register (regcache, regno);
-  else
-    fetch_register (regcache, regno);
-}
-
-/* Store our register values back into the inferior.
-   If REGNO is -1, do this for all registers.
-   Otherwise, REGNO specifies which register (so we can save time).  */
-static void
-usr_store_inferior_registers (struct regcache *regcache, int regno)
-{
-  if (regno == -1)
-    for (regno = 0; regno < the_low_target.num_regs; regno++)
-      store_register (regcache, regno);
-  else
-    store_register (regcache, regno);
-}
-#endif /* HAVE_LINUX_USRREGS */
-
-
 
 #ifdef HAVE_LINUX_REGSETS
 
+#define use_linux_regsets 1
+
 static int
 regsets_fetch_inferior_registers (struct regcache *regcache)
 {
   struct regset_info *regset;
   int saw_general_regs = 0;
   int pid;
   struct iovec iov;
 
   regset = target_regsets;
 
@@ skipping 15 matching lines @@
       if (nt_type)
         {
           iov.iov_base = buf;
           iov.iov_len = regset->size;
           data = (void *) &iov;
         }
       else
         data = buf;
 
 #ifndef __sparc__
-      res = ptrace (regset->get_request, pid, nt_type, data);
+      res = ptrace (regset->get_request, pid,
+                    (PTRACE_ARG3_TYPE) (long) nt_type, data);
 #else
       res = ptrace (regset->get_request, pid, data, nt_type);
 #endif
       if (res < 0)
         {
           if (errno == EIO)
             {
               /* If we get EIO on a regset, do not try it again for
                  this process.  */
               disabled_regsets[regset - target_regsets] = 1;
@@ skipping 52 matching lines @@
       if (nt_type)
         {
           iov.iov_base = buf;
           iov.iov_len = regset->size;
           data = (void *) &iov;
         }
       else
         data = buf;
 
 #ifndef __sparc__
-      res = ptrace (regset->get_request, pid, nt_type, data);
+      res = ptrace (regset->get_request, pid,
+                    (PTRACE_ARG3_TYPE) (long) nt_type, data);
 #else
-      res = ptrace (regset->get_request, pid, &iov, data);
+      res = ptrace (regset->get_request, pid, data, nt_type);
 #endif
 
       if (res == 0)
         {
           /* Then overlay our cached registers on that.  */
           regset->fill_function (regcache, buf);
 
           /* Only now do we write the register set.  */
 #ifndef __sparc__
-          res = ptrace (regset->set_request, pid, nt_type, data);
+          res = ptrace (regset->set_request, pid,
+                        (PTRACE_ARG3_TYPE) (long) nt_type, data);
 #else
           res = ptrace (regset->set_request, pid, data, nt_type);
 #endif
         }
 
       if (res < 0)
         {
           if (errno == EIO)
             {
               /* If we get EIO on a regset, do not try it again for
@@ skipping 18 matching lines @@
         }
       else if (regset->type == GENERAL_REGS)
         saw_general_regs = 1;
       regset ++;
       free (buf);
     }
   if (saw_general_regs)
     return 0;
   else
     return 1;
-  return 0;
-}
-
-#endif /* HAVE_LINUX_REGSETS */
+}
+
+#else /* !HAVE_LINUX_REGSETS */
+
+#define use_linux_regsets 0
+#define regsets_fetch_inferior_registers(regcache) 1
+#define regsets_store_inferior_registers(regcache) 1
+
+#endif
+
+/* Return 1 if register REGNO is supported by one of the regset ptrace
+   calls or 0 if it has to be transferred individually.  */
+
+static int
+linux_register_in_regsets (int regno)
+{
+  unsigned char mask = 1 << (regno % 8);
+  size_t index = regno / 8;
+
+  return (use_linux_regsets
+          && (the_low_target.regset_bitmap == NULL
+              || (the_low_target.regset_bitmap[index] & mask) != 0));
+}
+
+#ifdef HAVE_LINUX_USRREGS
+
+int
+register_addr (int regnum)
+{
+  int addr;
+
+  if (regnum < 0 || regnum >= the_low_target.num_regs)
+    error ("Invalid register number %d.", regnum);
+
+  addr = the_low_target.regmap[regnum];
+
+  return addr;
+}
+
+/* Fetch one register.  */
+static void
+fetch_register (struct regcache *regcache, int regno)
+{
+  CORE_ADDR regaddr;
+  int i, size;
+  char *buf;
+  int pid;
+
+  if (regno >= the_low_target.num_regs)
+    return;
+  if ((*the_low_target.cannot_fetch_register) (regno))
+    return;
+
+  regaddr = register_addr (regno);
+  if (regaddr == -1)
+    return;
+
+  size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
+          & -sizeof (PTRACE_XFER_TYPE));
+  buf = alloca (size);
+
+  pid = lwpid_of (get_thread_lwp (current_inferior));
+  for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
+    {
+      errno = 0;
+      *(PTRACE_XFER_TYPE *) (buf + i) =
+        ptrace (PTRACE_PEEKUSER, pid,
+                /* Coerce to a uintptr_t first to avoid potential gcc warning
+                   of coercing an 8 byte integer to a 4 byte pointer.  */
+                (PTRACE_ARG3_TYPE) (uintptr_t) regaddr, 0);
+      regaddr += sizeof (PTRACE_XFER_TYPE);
+      if (errno != 0)
+        error ("reading register %d: %s", regno, strerror (errno));
+    }
+
+  if (the_low_target.supply_ptrace_register)
+    the_low_target.supply_ptrace_register (regcache, regno, buf);
+  else
+    supply_register (regcache, regno, buf);
+}
+
+/* Store one register.  */
+static void
+store_register (struct regcache *regcache, int regno)
+{
+  CORE_ADDR regaddr;
+  int i, size;
+  char *buf;
+  int pid;
+
+  if (regno >= the_low_target.num_regs)
+    return;
+  if ((*the_low_target.cannot_store_register) (regno))
+    return;
+
+  regaddr = register_addr (regno);
+  if (regaddr == -1)
+    return;
+
+  size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
+          & -sizeof (PTRACE_XFER_TYPE));
+  buf = alloca (size);
+  memset (buf, 0, size);
+
+  if (the_low_target.collect_ptrace_register)
+    the_low_target.collect_ptrace_register (regcache, regno, buf);
+  else
+    collect_register (regcache, regno, buf);
+
+  pid = lwpid_of (get_thread_lwp (current_inferior));
+  for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
+    {
+      errno = 0;
+      ptrace (PTRACE_POKEUSER, pid,
+            /* Coerce to a uintptr_t first to avoid potential gcc warning
+               about coercing an 8 byte integer to a 4 byte pointer.  */
+              (PTRACE_ARG3_TYPE) (uintptr_t) regaddr,
+              (PTRACE_ARG4_TYPE) *(PTRACE_XFER_TYPE *) (buf + i));
+      if (errno != 0)
+        {
+          /* At this point, ESRCH should mean the process is
+             already gone, in which case we simply ignore attempts
+             to change its registers.  See also the related
+             comment in linux_resume_one_lwp.  */
+          if (errno == ESRCH)
+            return;
+
+          if ((*the_low_target.cannot_store_register) (regno) == 0)
+            error ("writing register %d: %s", regno, strerror (errno));
+        }
+      regaddr += sizeof (PTRACE_XFER_TYPE);
+    }
+}
+
+/* Fetch all registers, or just one, from the child process.
+   If REGNO is -1, do this for all registers, skipping any that are
+   assumed to have been retrieved by regsets_fetch_inferior_registers,
+   unless ALL is non-zero.
+   Otherwise, REGNO specifies which register (so we can save time).  */
+static void
+usr_fetch_inferior_registers (struct regcache *regcache, int regno, int all)
+{
+  if (regno == -1)
+    {
+      for (regno = 0; regno < the_low_target.num_regs; regno++)
+        if (all || !linux_register_in_regsets (regno))
+          fetch_register (regcache, regno);
+    }
+  else
+    fetch_register (regcache, regno);
+}
+
+/* Store our register values back into the inferior.
+   If REGNO is -1, do this for all registers, skipping any that are
+   assumed to have been saved by regsets_store_inferior_registers,
+   unless ALL is non-zero.
+   Otherwise, REGNO specifies which register (so we can save time).  */
+static void
+usr_store_inferior_registers (struct regcache *regcache, int regno, int all)
+{
+  if (regno == -1)
+    {
+      for (regno = 0; regno < the_low_target.num_regs; regno++)
+        if (all || !linux_register_in_regsets (regno))
+          store_register (regcache, regno);
+    }
+  else
+    store_register (regcache, regno);
+}
+
+#else /* !HAVE_LINUX_USRREGS */
+
+#define usr_fetch_inferior_registers(regcache, regno, all) do {} while (0)
+#define usr_store_inferior_registers(regcache, regno, all) do {} while (0)
+
+#endif
 
 
 void
 linux_fetch_registers (struct regcache *regcache, int regno)
 {
-#ifdef HAVE_LINUX_REGSETS
-  if (regsets_fetch_inferior_registers (regcache) == 0)
-    return;
-#endif
-#ifdef HAVE_LINUX_USRREGS
-  usr_fetch_inferior_registers (regcache, regno);
-#endif
+  int use_regsets;
+  int all = 0;
+
+  if (regno == -1)
+    {
+      if (the_low_target.fetch_register != NULL)
+        for (regno = 0; regno < the_low_target.num_regs; regno++)
+          (*the_low_target.fetch_register) (regcache, regno);
+
+      all = regsets_fetch_inferior_registers (regcache);
+      usr_fetch_inferior_registers (regcache, -1, all);
+    }
+  else
+    {
+      if (the_low_target.fetch_register != NULL
+          && (*the_low_target.fetch_register) (regcache, regno))
+        return;
+
+      use_regsets = linux_register_in_regsets (regno);
+      if (use_regsets)
+        all = regsets_fetch_inferior_registers (regcache);
+      if (!use_regsets || all)
+        usr_fetch_inferior_registers (regcache, regno, 1);
+    }
 }
 
 void
 linux_store_registers (struct regcache *regcache, int regno)
 {
-#ifdef HAVE_LINUX_REGSETS
-  if (regsets_store_inferior_registers (regcache) == 0)
-    return;
-#endif
-#ifdef HAVE_LINUX_USRREGS
-  usr_store_inferior_registers (regcache, regno);
-#endif
-}
-
-
+  int use_regsets;
+  int all = 0;
+
+  if (regno == -1)
+    {
+      all = regsets_store_inferior_registers (regcache);
+      usr_store_inferior_registers (regcache, regno, all);
+    }
+  else
+    {
+      use_regsets = linux_register_in_regsets (regno);
+      if (use_regsets)
+        all = regsets_store_inferior_registers (regcache);
+      if (!use_regsets || all)
+        usr_store_inferior_registers (regcache, regno, 1);
+    }
+}
+
+
 /* Copy LEN bytes from inferior's memory starting at MEMADDR
    to debugger memory starting at MYADDR.  */
 
 static int
 linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 {
+  int pid = lwpid_of (get_thread_lwp (current_inferior));
+  register PTRACE_XFER_TYPE *buffer;
+  register CORE_ADDR addr;
+  register int count;
+  char filename[64];
   register int i;
-  /* Round starting address down to longword boundary.  */
-  register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
-  /* Round ending address up; get number of longwords that makes.  */
-  register int count
-    = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
-      / sizeof (PTRACE_XFER_TYPE);
-  /* Allocate buffer of that many longwords.  */
-  register PTRACE_XFER_TYPE *buffer
-    = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
+  int ret;
   int fd;
-  char filename[64];
-  int pid = lwpid_of (get_thread_lwp (current_inferior));
 
   /* Try using /proc.  Don't bother for one word.  */
   if (len >= 3 * sizeof (long))
     {
+      int bytes;
+
       /* We could keep this file open and cache it - possibly one per
          thread.  That requires some juggling, but is even faster.  */
       sprintf (filename, "/proc/%d/mem", pid);
       fd = open (filename, O_RDONLY | O_LARGEFILE);
       if (fd == -1)
         goto no_proc;
 
       /* If pread64 is available, use it.  It's faster if the kernel
          supports it (only one syscall), and it's 64-bit safe even on
          32-bit platforms (for instance, SPARC debugging a SPARC64
          application).  */
 #ifdef HAVE_PREAD64
-      if (pread64 (fd, myaddr, len, memaddr) != len)
+      bytes = pread64 (fd, myaddr, len, memaddr);
 #else
-      if (lseek (fd, memaddr, SEEK_SET) == -1 || read (fd, myaddr, len) != len)
+      bytes = -1;
+      if (lseek (fd, memaddr, SEEK_SET) != -1)
+        bytes = read (fd, myaddr, len);
 #endif
-        {
-          close (fd);
-          goto no_proc;
-        }
 
       close (fd);
-      return 0;
+      if (bytes == len)
+        return 0;
+
+      /* Some data was read, we'll try to get the rest with ptrace.  */
+      if (bytes > 0)
+        {
+          memaddr += bytes;
+          myaddr += bytes;
+          len -= bytes;
+        }
     }
 
  no_proc:
+  /* Round starting address down to longword boundary.  */
+  addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
+  /* Round ending address up; get number of longwords that makes.  */
+  count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
+           / sizeof (PTRACE_XFER_TYPE));
+  /* Allocate buffer of that many longwords.  */
+  buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
+
   /* Read all the longwords */
+  errno = 0;
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
     {
-      errno = 0;
       /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
          about coercing an 8 byte integer to a 4 byte pointer.  */
       buffer[i] = ptrace (PTRACE_PEEKTEXT, pid,
                           (PTRACE_ARG3_TYPE) (uintptr_t) addr, 0);
       if (errno)
-        return errno;
+        break;
+    }
+  ret = errno;
+
+  /* Copy appropriate bytes out of the buffer.  */
+  if (i > 0)
+    {
+      i *= sizeof (PTRACE_XFER_TYPE);
+      i -= memaddr & (sizeof (PTRACE_XFER_TYPE) - 1);
+      memcpy (myaddr,
+              (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
+              i < len ? i : len);
     }
 
-  /* Copy appropriate bytes out of the buffer.  */
-  memcpy (myaddr,
-          (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
-          len);
-
-  return 0;
+  return ret;
 }
 
 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
    memory at MEMADDR.  On failure (cannot write to the inferior)
    returns the value of errno.  */
 
 static int
 linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 {
   register int i;
@@ skipping 322 matching lines @@
 
 static CORE_ADDR
 linux_stopped_data_address (void)
 {
   struct lwp_info *lwp = get_thread_lwp (current_inferior);
 
   return lwp->stopped_data_address;
 }
 
 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
+#if ! (defined(PT_TEXT_ADDR) \
+       || defined(PT_DATA_ADDR) \
+       || defined(PT_TEXT_END_ADDR))
 #if defined(__mcoldfire__)
 /* These should really be defined in the kernel's ptrace.h header.  */
 #define PT_TEXT_ADDR 49*4
 #define PT_DATA_ADDR 50*4
 #define PT_TEXT_END_ADDR  51*4
 #elif defined(BFIN)
 #define PT_TEXT_ADDR 220
 #define PT_TEXT_END_ADDR 224
 #define PT_DATA_ADDR 228
 #elif defined(__TMS320C6X__)
 #define PT_TEXT_ADDR     (0x10000*4)
 #define PT_DATA_ADDR     (0x10004*4)
 #define PT_TEXT_END_ADDR (0x10008*4)
 #endif
+#endif
 
 /* Under uClinux, programs are loaded at non-zero offsets, which we need
    to tell gdb about.  */
 
 static int
 linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
 {
 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
   unsigned long text, text_end, data;
   int pid = lwpid_of (get_thread_lwp (current_inferior));
@@ skipping 30 matching lines @@
                     unsigned char *readbuf, unsigned const char *writebuf,
                     CORE_ADDR offset, int len)
 {
   return linux_common_xfer_osdata (annex, readbuf, offset, len);
 }
 
 /* Convert a native/host siginfo object, into/from the siginfo in the
    layout of the inferiors' architecture.  */
 
 static void
-siginfo_fixup (struct siginfo *siginfo, void *inf_siginfo, int direction)
+siginfo_fixup (siginfo_t *siginfo, void *inf_siginfo, int direction)
 {
   int done = 0;
 
   if (the_low_target.siginfo_fixup != NULL)
     done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
 
   /* If there was no callback, or the callback didn't do anything,
      then just do a straight memcpy.  */
   if (!done)
     {
       if (direction == 1)
-        memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
+        memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
       else
-        memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
+        memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
     }
 }
 
 static int
 linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
                     unsigned const char *writebuf, CORE_ADDR offset, int len)
 {
   int pid;
-  struct siginfo siginfo;
-  char inf_siginfo[sizeof (struct siginfo)];
+  siginfo_t siginfo;
+  char inf_siginfo[sizeof (siginfo_t)];
 
   if (current_inferior == NULL)
     return -1;
 
   pid = lwpid_of (get_thread_lwp (current_inferior));
 
   if (debug_threads)
     fprintf (stderr, "%s siginfo for lwp %d.\n",
              readbuf != NULL ? "Reading" : "Writing",
              pid);
@@ skipping 127 matching lines @@
 static int
 linux_supports_disable_randomization (void)
 {
 #ifdef HAVE_PERSONALITY
   return 1;
 #else
   return 0;
 #endif
 }
 
+static int
+linux_supports_agent (void)
+{
+  return 1;
+}
+
 /* Enumerate spufs IDs for process PID.  */
 static int
 spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len)
 {
   int pos = 0;
   int written = 0;
   char path[128];
   DIR *dir;
   struct dirent *entry;
 
@@ skipping 369 matching lines @@
     else
       {
         Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
 
         if (p->p_type == PT_PHDR)
           relocation = phdr_memaddr - p->p_vaddr;
       }
 
   if (relocation == -1)
     {
-      warning ("Unexpected missing PT_PHDR");
+      /* PT_PHDR is optional, but necessary for PIE in general.  Fortunately
+         any real world executables, including PIE executables, have always
+         PT_PHDR present.  PT_PHDR is not present in some shared libraries or
+         in fpc (Free Pascal 2.4) binaries but neither of those have a need for
+         or present DT_DEBUG anyway (fpc binaries are statically linked).
+
+         Therefore if there exists DT_DEBUG there is always also PT_PHDR.
+
+         GDB could find RELOCATION also from AT_ENTRY - e_entry.  */
+
       return 0;
     }
 
   for (i = 0; i < num_phdr; i++)
     {
       if (is_elf64)
         {
           Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
 
           if (p->p_type == PT_DYNAMIC)
             return p->p_vaddr + relocation;
         }
       else
         {
           Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
 
           if (p->p_type == PT_DYNAMIC)
             return p->p_vaddr + relocation;
         }
     }
 
   return 0;
 }
 
 /* Return &_r_debug in the inferior, or -1 if not present.  Return value
-   can be 0 if the inferior does not yet have the library list initialized.  */
+   can be 0 if the inferior does not yet have the library list initialized.
+   We look for DT_MIPS_RLD_MAP first.  MIPS executables use this instead of
+   DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too.  */
 
 static CORE_ADDR
 get_r_debug (const int pid, const int is_elf64)
 {
   CORE_ADDR dynamic_memaddr;
   const int dyn_size = is_elf64 ? sizeof (Elf64_Dyn) : sizeof (Elf32_Dyn);
   unsigned char buf[sizeof (Elf64_Dyn)];  /* The larger of the two.  */
+  CORE_ADDR map = -1;
 
   dynamic_memaddr = get_dynamic (pid, is_elf64);
   if (dynamic_memaddr == 0)
-    return (CORE_ADDR) -1;
+    return map;
 
   while (linux_read_memory (dynamic_memaddr, buf, dyn_size) == 0)
     {
       if (is_elf64)
         {
           Elf64_Dyn *const dyn = (Elf64_Dyn *) buf;
+#ifdef DT_MIPS_RLD_MAP
+          union
+            {
+              Elf64_Xword map;
+              unsigned char buf[sizeof (Elf64_Xword)];
+            }
+          rld_map;
 
-          if (dyn->d_tag == DT_DEBUG)
-            return dyn->d_un.d_val;
+          if (dyn->d_tag == DT_MIPS_RLD_MAP)
+            {
+              if (linux_read_memory (dyn->d_un.d_val,
+                                     rld_map.buf, sizeof (rld_map.buf)) == 0)
+                return rld_map.map;
+              else
+                break;
+            }
+#endif  /* DT_MIPS_RLD_MAP */
+
+          if (dyn->d_tag == DT_DEBUG && map == -1)
+            map = dyn->d_un.d_val;
 
           if (dyn->d_tag == DT_NULL)
             break;
         }
       else
         {
           Elf32_Dyn *const dyn = (Elf32_Dyn *) buf;
+#ifdef DT_MIPS_RLD_MAP
+          union
+            {
+              Elf32_Word map;
+              unsigned char buf[sizeof (Elf32_Word)];
+            }
+          rld_map;
 
-          if (dyn->d_tag == DT_DEBUG)
-            return dyn->d_un.d_val;
+          if (dyn->d_tag == DT_MIPS_RLD_MAP)
+            {
+              if (linux_read_memory (dyn->d_un.d_val,
+                                     rld_map.buf, sizeof (rld_map.buf)) == 0)
+                return rld_map.map;
+              else
+                break;
+            }
+#endif  /* DT_MIPS_RLD_MAP */
+
+          if (dyn->d_tag == DT_DEBUG && map == -1)
+            map = dyn->d_un.d_val;
 
           if (dyn->d_tag == DT_NULL)
             break;
         }
 
       dynamic_memaddr += dyn_size;
     }
 
-  return (CORE_ADDR) -1;
+  return map;
 }
 
 /* Read one pointer from MEMADDR in the inferior.  */
 
 static int
 read_one_ptr (CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
 {
-  *ptr = 0;
-  return linux_read_memory (memaddr, (unsigned char *) ptr, ptr_size);
+  int ret;
+
+  /* Go through a union so this works on either big or little endian
+     hosts, when the inferior's pointer size is smaller than the size
+     of CORE_ADDR.  It is assumed the inferior's endianness is the
+     same of the superior's.  */
+  union
+  {
+    CORE_ADDR core_addr;
+    unsigned int ui;
+    unsigned char uc;
+  } addr;
+
+  ret = linux_read_memory (memaddr, &addr.uc, ptr_size);
+  if (ret == 0)
+    {
+      if (ptr_size == sizeof (CORE_ADDR))
+        *ptr = addr.core_addr;
+      else if (ptr_size == sizeof (unsigned int))
+        *ptr = addr.ui;
+      else
+        gdb_assert_not_reached ("unhandled pointer size");
+    }
+  return ret;
 }
 
 struct link_map_offsets
   {
     /* Offset and size of r_debug.r_version.  */
     int r_version_offset;
 
     /* Offset and size of r_debug.r_map.  */
     int r_map_offset;
 
     /* Offset to l_addr field in struct link_map.  */
     int l_addr_offset;
 
     /* Offset to l_name field in struct link_map.  */
     int l_name_offset;
 
     /* Offset to l_ld field in struct link_map.  */
     int l_ld_offset;
 
     /* Offset to l_next field in struct link_map.  */
     int l_next_offset;
 
     /* Offset to l_prev field in struct link_map.  */
     int l_prev_offset;
   };
 
-/* Construct qXfer:libraries:read reply.  */
+/* Construct qXfer:libraries-svr4:read reply.  */
 
 static int
 linux_qxfer_libraries_svr4 (const char *annex, unsigned char *readbuf,
                             unsigned const char *writebuf,
                             CORE_ADDR offset, int len)
 {
   char *document;
   unsigned document_len;
   struct process_info_private *const priv = current_process ()->private;
   char filename[PATH_MAX];
@@ skipping 14 matching lines @@
     {
       0,     /* r_version offset. */
       8,     /* r_debug.r_map offset.  */
       0,     /* l_addr offset in link_map.  */
       8,     /* l_name offset in link_map.  */
       16,    /* l_ld offset in link_map.  */
       24,    /* l_next offset in link_map.  */
       32     /* l_prev offset in link_map.  */
     };
   const struct link_map_offsets *lmo;
+  unsigned int machine;
 
   if (writebuf != NULL)
     return -2;
   if (readbuf == NULL)
     return -1;
 
   pid = lwpid_of (get_thread_lwp (current_inferior));
   xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
-  is_elf64 = elf_64_file_p (filename);
+  is_elf64 = elf_64_file_p (filename, &machine);
   lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
 
   if (priv->r_debug == 0)
     priv->r_debug = get_r_debug (pid, is_elf64);
 
-  if (priv->r_debug == (CORE_ADDR) -1 || priv->r_debug == 0)
+  /* We failed to find DT_DEBUG.  Such situation will not change for this
+     inferior - do not retry it.  Report it to GDB as E01, see for the reasons
+     at the GDB solib-svr4.c side.  */
+  if (priv->r_debug == (CORE_ADDR) -1)
+    return -1;
+
+  if (priv->r_debug == 0)
     {
       document = xstrdup ("<library-list-svr4 version=\"1.0\"/>\n");
     }
   else
     {
       int allocated = 1024;
       char *p;
       const int ptr_size = is_elf64 ? 8 : 4;
       CORE_ADDR lm_addr, lm_prev, l_name, l_addr, l_ld, l_next, l_prev;
       int r_version, header_done = 0;
@@ skipping 82 matching lines @@
               p = p + strlen (p);
             }
 
           if (l_next == 0)
             break;
 
           lm_prev = lm_addr;
           lm_addr = l_next;
         }
     done:
-      strcpy (p, "</library-list-svr4>");
+      if (!header_done)
+        {
+          /* Empty list; terminate `<library-list-svr4'.  */
+          strcpy (p, "/>");
+        }
+      else
+        strcpy (p, "</library-list-svr4>");
     }
 
   document_len = strlen (document);
   if (offset < document_len)
     document_len -= offset;
   else
     document_len = 0;
   if (len > document_len)
     len = document_len;
 
@@ skipping 59 matching lines @@
   NULL,
   linux_pause_all,
   linux_unpause_all,
   linux_cancel_breakpoints,
   linux_stabilize_threads,
   linux_install_fast_tracepoint_jump_pad,
   linux_emit_ops,
   linux_supports_disable_randomization,
   linux_get_min_fast_tracepoint_insn_len,
   linux_qxfer_libraries_svr4,
+  linux_supports_agent,
 };
 
 static void
 linux_init_signals ()
 {
   /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
      to find what the cancel signal actually is.  */
 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does.  */
   signal (__SIGRTMIN+1, SIG_IGN);
 #endif
 }
 
 void
 initialize_low (void)
 {
   struct sigaction sigchld_action;
   memset (&sigchld_action, 0, sizeof (sigchld_action));
   set_target_ops (&linux_target_ops);
   set_breakpoint_data (the_low_target.breakpoint,
                        the_low_target.breakpoint_len);
   linux_init_signals ();
   linux_test_for_tracefork ();
+  linux_ptrace_init_warnings ();
 #ifdef HAVE_LINUX_REGSETS
   for (num_regsets = 0; target_regsets[num_regsets].size >= 0; num_regsets++)
     ;
   disabled_regsets = xmalloc (num_regsets);
 #endif
 
   sigchld_action.sa_handler = sigchld_handler;
   sigemptyset (&sigchld_action.sa_mask);
   sigchld_action.sa_flags = SA_RESTART;
   sigaction (SIGCHLD, &sigchld_action, NULL);
 }