GDB 7.6.50

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.
+   Copyright (C) 1995-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "server.h"
 #include "linux-low.h"
 #include "linux-osdata.h"
 #include "agent.h"
 
-#include <sys/wait.h>
+#include "nat/linux-nat.h"
+#include "nat/linux-waitpid.h"
+#include "gdb_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>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/syscall.h>
 #include <sched.h>
 #include <ctype.h>
 #include <pwd.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <sys/stat.h>
 #include <sys/vfs.h>
 #include <sys/uio.h>
+#include "filestuff.h"
+#include "tracepoint.h"
+#include "hostio.h"
 #ifndef ELFMAG0
 /* Don't include <linux/elf.h> here.  If it got included by gdb_proc_service.h
    then ELFMAG0 will have been defined.  If it didn't get included by
    gdb_proc_service.h then including it will likely introduce a duplicate
    definition of elf_fpregset_t.  */
 #include <elf.h>
 #endif
 
 #ifndef SPUFS_MAGIC
 #define SPUFS_MAGIC 0x23c9b64e
@@ skipping 13 matching lines @@
 #ifndef W_STOPCODE
 #define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
 #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
+/* Some targets did not define these ptrace constants from the start,
+   so gdbserver defines them locally here.  In the future, these may
+   be removed after they are added to asm/ptrace.h.  */
+#if !(defined(PT_TEXT_ADDR) \
+      || defined(PT_DATA_ADDR) \
+      || defined(PT_TEXT_END_ADDR))
+#if defined(__mcoldfire__)
+/* These are still undefined in 3.10 kernels.  */
+#define PT_TEXT_ADDR 49*4
+#define PT_DATA_ADDR 50*4
+#define PT_TEXT_END_ADDR  51*4
+/* BFIN already defines these since at least 2.6.32 kernels.  */
+#elif defined(BFIN)
+#define PT_TEXT_ADDR 220
+#define PT_TEXT_END_ADDR 224
+#define PT_DATA_ADDR 228
+/* These are still undefined in 3.10 kernels.  */
+#elif defined(__TMS320C6X__)
+#define PT_TEXT_ADDR     (0x10000*4)
+#define PT_DATA_ADDR     (0x10004*4)
+#define PT_TEXT_END_ADDR (0x10008*4)
 #endif
 #endif
 
+#ifdef HAVE_LINUX_BTRACE
+# include "linux-btrace.h"
+#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
@@ skipping 92 matching lines @@
 /* 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
-   to call the low target's arch_setup callback.  Doing this only on
-   the first inferior avoids reinializing the architecture on every
-   inferior, and avoids messing with the register caches of the
-   already running inferiors.  NOTE: this assumes all inferiors under
-   control of gdbserver have the same architecture.  */
-static int new_inferior;
-
 static void linux_resume_one_lwp (struct lwp_info *lwp,
                                   int step, int signal, siginfo_t *info);
 static void linux_resume (struct thread_resume *resume_info, size_t n);
 static void stop_all_lwps (int suspend, struct lwp_info *except);
 static void unstop_all_lwps (int unsuspend, struct lwp_info *except);
 static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
 static void *add_lwp (ptid_t ptid);
 static int linux_stopped_by_watchpoint (void);
 static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
 static void proceed_all_lwps (void);
 static int finish_step_over (struct lwp_info *lwp);
 static CORE_ADDR get_stop_pc (struct lwp_info *lwp);
 static int kill_lwp (unsigned long lwpid, int signo);
-static void linux_enable_event_reporting (int pid);
 
 /* True if the low target can hardware single-step.  Such targets
    don't need a BREAKPOINT_REINSERT_ADDR callback.  */
 
 static int
 can_hardware_single_step (void)
 {
   return (the_low_target.breakpoint_reinsert_addr == NULL);
 }
 
 /* True if the low target supports memory breakpoints.  If so, we'll
    have a GET_PC implementation.  */
 
 static int
 supports_breakpoints (void)
 {
   return (the_low_target.get_pc != NULL);
 }
 
 /* Returns true if this target can support fast tracepoints.  This
    does not mean that the in-process agent has been loaded in the
    inferior.  */
 
 static int
 supports_fast_tracepoints (void)
 {
   return the_low_target.install_fast_tracepoint_jump_pad != NULL;
 }
 
+/* True if LWP is stopped in its stepping range.  */
+
+static int
+lwp_in_step_range (struct lwp_info *lwp)
+{
+  CORE_ADDR pc = lwp->stop_pc;
+
+  return (pc >= lwp->step_range_start && pc < lwp->step_range_end);
+}
+
 struct pending_signals
 {
   int signal;
   siginfo_t info;
   struct pending_signals *prev;
 };
 
-#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);
 
@@ skipping 38 matching lines @@
 
   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];
+  char file[PATH_MAX];
 
   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);
 }
 
 /* Add a process to the common process list, and set its private
    data.  */
 
 static struct process_info *
 linux_add_process (int pid, int attached)
 {
   struct process_info *proc;
 
-  /* Is this the first process?  If so, then set the arch.  */
-  if (all_processes.head == NULL)
-    new_inferior = 1;
-
   proc = add_process (pid, attached);
   proc->private = xcalloc (1, sizeof (*proc->private));
 
+  /* Set the arch when the first LWP stops.  */
+  proc->private->new_inferior = 1;
+
   if (the_low_target.new_process != NULL)
     proc->private->arch_private = the_low_target.new_process ();
 
   return proc;
 }
 
-/* Wrapper function for waitpid which handles EINTR, and emulates
-   __WALL for systems where that is not available.  */
-
-static int
-my_waitpid (int pid, int *status, int flags)
-{
-  int ret, out_errno;
-
-  if (debug_threads)
-    fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
-
-  if (flags & __WALL)
-    {
-      sigset_t block_mask, org_mask, wake_mask;
-      int wnohang;
-
-      wnohang = (flags & WNOHANG) != 0;
-      flags &= ~(__WALL | __WCLONE);
-      flags |= WNOHANG;
-
-      /* Block all signals while here.  This avoids knowing about
-         LinuxThread's signals.  */
-      sigfillset (&block_mask);
-      sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
-
-      /* ... except during the sigsuspend below.  */
-      sigemptyset (&wake_mask);
-
-      while (1)
-        {
-          /* Since all signals are blocked, there's no need to check
-             for EINTR here.  */
-          ret = waitpid (pid, status, flags);
-          out_errno = errno;
-
-          if (ret == -1 && out_errno != ECHILD)
-            break;
-          else if (ret > 0)
-            break;
-
-          if (flags & __WCLONE)
-            {
-              /* We've tried both flavors now.  If WNOHANG is set,
-                 there's nothing else to do, just bail out.  */
-              if (wnohang)
-                break;
-
-              if (debug_threads)
-                fprintf (stderr, "blocking\n");
-
-              /* Block waiting for signals.  */
-              sigsuspend (&wake_mask);
-            }
-
-          flags ^= __WCLONE;
-        }
-
-      sigprocmask (SIG_SETMASK, &org_mask, NULL);
-    }
-  else
-    {
-      do
-        ret = waitpid (pid, status, flags);
-      while (ret == -1 && errno == EINTR);
-      out_errno = errno;
-    }
-
-  if (debug_threads)
-    fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
-             pid, flags, status ? *status : -1, ret);
-
-  errno = out_errno;
-  return ret;
-}
-
 /* Handle a GNU/Linux extended wait response.  If we see a clone
    event, we need to add the new LWP to our list (and not report the
    trap to higher layers).  */
 
 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;
 
-      ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), 0, &new_pid);
+      ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), (PTRACE_TYPE_ARG3) 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, &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;
 
@@ skipping 156 matching lines @@
 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
   pid = vfork ();
 #else
   pid = fork ();
 #endif
   if (pid < 0)
     perror_with_name ("fork");
 
   if (pid == 0)
     {
-      ptrace (PTRACE_TRACEME, 0, 0, 0);
+      close_most_fds ();
+      ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 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.  */;
+            {
+              /* 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)
+  if (ptrace (PTRACE_ATTACH, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 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;
@@ skipping 45 matching lines @@
          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);
+      ptrace (PTRACE_CONT, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 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
@@ skipping 170 matching lines @@
 
   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);
+  ptrace (PTRACE_KILL, pid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 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.  */
 
@@ skipping 184 matching lines @@
       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;
     }
 
   /* Flush any pending changes to the process's registers.  */
-  regcache_invalidate_one ((struct inferior_list_entry *)
-                           get_lwp_thread (lwp));
+  regcache_invalidate_thread (get_lwp_thread (lwp));
 
   /* Pass on any pending signal for this thread.  */
   sig = get_detach_signal (thread);
 
   /* Finally, let it resume.  */
   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)
+  if (ptrace (PTRACE_DETACH, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+              (PTRACE_TYPE_ARG4) (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)
@@ skipping 178 matching lines @@
       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.
-     This needs to happen after we have attached to the inferior
-     and it is stopped for the first time, but before we access
-     any inferior registers.  */
-  if (new_inferior)
+  if (WIFSTOPPED (*wstatp))
     {
-      the_low_target.arch_setup ();
-#ifdef HAVE_LINUX_REGSETS
-      memset (disabled_regsets, 0, num_regsets);
-#endif
-      new_inferior = 0;
+      struct process_info *proc;
+
+      /* Architecture-specific setup after inferior is running.  This
+         needs to happen after we have attached to the inferior and it
+         is stopped for the first time, but before we access any
+         inferior registers.  */
+      proc = find_process_pid (pid_of (child));
+      if (proc->private->new_inferior)
+        {
+          struct thread_info *saved_inferior;
+
+          saved_inferior = current_inferior;
+          current_inferior = get_lwp_thread (child);
+
+          the_low_target.arch_setup ();
+
+          current_inferior = saved_inferior;
+
+          proc->private->new_inferior = 0;
+        }
     }
 
   /* Fetch the possibly triggered data watchpoint info and store it in
      CHILD.
 
      On some archs, like x86, that use debug registers to set
      watchpoints, it's possible that the way to know which watched
      address trapped, is to check the register that is used to select
      which address to watch.  Problem is, between setting the
      watchpoint and reading back which data address trapped, the user
@@ skipping 200 matching lines @@
               siginfo_t info;
               struct regcache *regcache;
 
               /* The si_addr on a few signals references the address
                  of the faulting instruction.  Adjust that as
                  well.  */
               if ((WSTOPSIG (*wstat) == SIGILL
                    || WSTOPSIG (*wstat) == SIGFPE
                    || WSTOPSIG (*wstat) == SIGBUS
                    || WSTOPSIG (*wstat) == SIGSEGV)
-                  && ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &info) == 0
+                  && ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp),
+                             (PTRACE_TYPE_ARG3) 0, &info) == 0
                   /* Final check just to make sure we don't clobber
                      the siginfo of non-kernel-sent signals.  */
                   && (uintptr_t) info.si_addr == lwp->stop_pc)
                 {
                   info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
-                  ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &info);
+                  ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp),
+                          (PTRACE_TYPE_ARG3) 0, &info);
                 }
 
               regcache = get_thread_regcache (get_lwp_thread (lwp), 1);
               (*the_low_target.set_pc) (regcache, status.tpoint_addr);
               lwp->stop_pc = status.tpoint_addr;
 
               /* Cancel any fast tracepoint lock this thread was
                  holding.  */
               force_unlock_trace_buffer ();
             }
@@ skipping 74 matching lines @@
                          lwpid_of (lwp));
               return;
             }
         }
     }
 
   p_sig = xmalloc (sizeof (*p_sig));
   p_sig->prev = lwp->pending_signals_to_report;
   p_sig->signal = WSTOPSIG (*wstat);
   memset (&p_sig->info, 0, sizeof (siginfo_t));
-  ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
+  ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+          &p_sig->info);
 
   lwp->pending_signals_to_report = p_sig;
 }
 
 /* Dequeue one signal from the "signals to report later when out of
    the jump pad" list.  */
 
 static int
 dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
 {
   if (lwp->pending_signals_to_report != NULL)
     {
       struct pending_signals **p_sig;
 
       p_sig = &lwp->pending_signals_to_report;
       while ((*p_sig)->prev != NULL)
         p_sig = &(*p_sig)->prev;
 
       *wstat = W_STOPCODE ((*p_sig)->signal);
       if ((*p_sig)->info.si_signo != 0)
-        ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
+        ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+                &(*p_sig)->info);
       free (*p_sig);
       *p_sig = NULL;
 
       if (debug_threads)
         fprintf (stderr, "Reporting deferred signal %d for LWP %ld.\n",
                  WSTOPSIG (*wstat), lwpid_of (lwp));
 
       if (debug_threads)
         {
           struct pending_signals *sig;
@@ skipping 557 matching lines @@
 {
   int w;
   struct lwp_info *event_child;
   int options;
   int pid;
   int step_over_finished;
   int bp_explains_trap;
   int maybe_internal_trap;
   int report_to_gdb;
   int trace_event;
+  int in_step_range;
 
   /* Translate generic target options into linux options.  */
   options = __WALL;
   if (target_options & TARGET_WNOHANG)
     options |= WNOHANG;
 
 retry:
   bp_explains_trap = 0;
   trace_event = 0;
+  in_step_range = 0;
   ourstatus->kind = TARGET_WAITKIND_IGNORE;
 
   /* If we were only supposed to resume one thread, only wait for
      that thread - if it's still alive.  If it died, however - which
      can happen if we're coming from the thread death case below -
      then we need to make sure we restart the other threads.  We could
      pick a thread at random or restart all; restarting all is less
      arbitrary.  */
   if (!non_stop
       && !ptid_equal (cont_thread, null_ptid)
@@ skipping 263 matching lines @@
           (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)
+      if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child),
+                  (PTRACE_TYPE_ARG3) 0, &info) == 0)
         info_p = &info;
       else
         info_p = NULL;
       linux_resume_one_lwp (event_child, event_child->stepping,
                             WSTOPSIG (w), info_p);
       goto retry;
     }
 
-  /* If GDB wanted this thread to single step, we always want to
-     report the SIGTRAP, and let GDB handle it.  Watchpoints should
-     always be reported.  So should signals we can't explain.  A
-     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.  */
+  /* Note that all addresses are always "out of the step range" when
+     there's no range to begin with.  */
+  in_step_range = lwp_in_step_range (event_child);
+
+  /* If GDB wanted this thread to single step, and the thread is out
+     of the step range, we always want to report the SIGTRAP, and let
+     GDB handle it.  Watchpoints should always be reported.  So should
+     signals we can't explain.  A 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
+                   || (current_inferior->last_resume_kind == resume_step
+                       && !in_step_range)
                    || event_child->stopped_by_watchpoint
-                   || (!step_over_finished
+                   || (!step_over_finished && !in_step_range
                        && !bp_explains_trap && !trace_event)
                    || (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");
           if (step_over_finished)
             fprintf (stderr, "Step-over finished.\n");
           if (trace_event)
             fprintf (stderr, "Tracepoint event.\n");
+          if (lwp_in_step_range (event_child))
+            fprintf (stderr, "Range stepping pc 0x%s [0x%s, 0x%s).\n",
+                     paddress (event_child->stop_pc),
+                     paddress (event_child->step_range_start),
+                     paddress (event_child->step_range_end));
         }
 
       /* We're not reporting this breakpoint to GDB, so apply the
          decr_pc_after_break adjustment to the inferior's regcache
          ourselves.  */
 
       if (the_low_target.set_pc != NULL)
         {
           struct regcache *regcache
             = get_thread_regcache (get_lwp_thread (event_child), 1);
@@ skipping 11 matching lines @@
       if (step_over_finished)
         unsuspend_all_lwps (event_child);
 
       proceed_all_lwps ();
       goto retry;
     }
 
   if (debug_threads)
     {
       if (current_inferior->last_resume_kind == resume_step)
-        fprintf (stderr, "GDB wanted to single-step, reporting event.\n");
+        {
+          if (event_child->step_range_start == event_child->step_range_end)
+            fprintf (stderr, "GDB wanted to single-step, reporting event.\n");
+          else if (!lwp_in_step_range (event_child))
+            fprintf (stderr, "Out of step range, reporting event.\n");
+        }
       if (event_child->stopped_by_watchpoint)
         fprintf (stderr, "Stopped by watchpoint.\n");
       if (gdb_breakpoint_here (event_child->stop_pc))
         fprintf (stderr, "Stopped by GDB breakpoint.\n");
       if (debug_threads)
         fprintf (stderr, "Hit a non-gdbserver trap event.\n");
     }
 
   /* Alright, we're going to report a stop.  */
 
@@ skipping 502 matching lines @@
      Making this stack would also shrink the window in which breakpoints are
      uninserted (see comment in linux_wait_for_lwp) but not enough for
      complete correctness, so it won't solve that problem.  It may be
      worthwhile just to solve this one, however.  */
   if (lwp->bp_reinsert != 0)
     {
       if (debug_threads)
         fprintf (stderr, "  pending reinsert at 0x%s\n",
                  paddress (lwp->bp_reinsert));
 
-      if (lwp->bp_reinsert != 0 && can_hardware_single_step ())
+      if (can_hardware_single_step ())
         {
           if (fast_tp_collecting == 0)
             {
               if (step == 0)
                 fprintf (stderr, "BAD - reinserting but not stepping.\n");
               if (lwp->suspended)
                 fprintf (stderr, "BAD - reinserting and suspended(%d).\n",
                          lwp->suspended);
             }
 
@@ skipping 64 matching lines @@
       && fast_tp_collecting == 0)
     {
       struct pending_signals **p_sig;
 
       p_sig = &lwp->pending_signals;
       while ((*p_sig)->prev != NULL)
         p_sig = &(*p_sig)->prev;
 
       signal = (*p_sig)->signal;
       if ((*p_sig)->info.si_signo != 0)
-        ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), 0, &(*p_sig)->info);
+        ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+                &(*p_sig)->info);
 
       free (*p_sig);
       *p_sig = NULL;
     }
 
   if (the_low_target.prepare_to_resume != NULL)
     the_low_target.prepare_to_resume (lwp);
 
-  regcache_invalidate_one ((struct inferior_list_entry *)
-                           get_lwp_thread (lwp));
+  regcache_invalidate_thread (get_lwp_thread (lwp));
   errno = 0;
   lwp->stopped = 0;
   lwp->stopped_by_watchpoint = 0;
   lwp->stepping = step;
-  ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), 0,
+  ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp),
+          (PTRACE_TYPE_ARG3) 0,
           /* Coerce to a uintptr_t first to avoid potential gcc warning
              of coercing an 8 byte integer to a 4 byte pointer.  */
-          (PTRACE_ARG4_TYPE) (uintptr_t) signal);
+          (PTRACE_TYPE_ARG4) (uintptr_t) signal);
 
   current_inferior = saved_inferior;
   if (errno)
     {
       /* ESRCH from ptrace either means that the thread was already
          running (an error) or that it is gone (a race condition).  If
          it's gone, we will get a notification the next time we wait,
          so we can ignore the error.  We could differentiate these
          two, but it's tricky without waiting; the thread still exists
          as a zombie, so sending it signal 0 would succeed.  So just
          ignore ESRCH.  */
       if (errno == ESRCH)
         return;
 
       perror_with_name ("ptrace");
     }
 }
 
 struct thread_resume_array
 {
   struct thread_resume *resume;
   size_t n;
 };
 
-/* This function is called once per thread.  We look up the thread
-   in RESUME_PTR, and mark the thread with a pointer to the appropriate
-   resume request.
+/* This function is called once per thread via find_inferior.
+   ARG is a pointer to a thread_resume_array struct.
+   We look up the thread specified by ENTRY in ARG, and mark the thread
+   with a pointer to the appropriate resume request.
 
    This algorithm is O(threads * resume elements), but resume elements
    is small (and will remain small at least until GDB supports thread
    suspension).  */
+
 static int
 linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
 {
   struct lwp_info *lwp;
   struct thread_info *thread;
   int ndx;
   struct thread_resume_array *r;
 
   thread = (struct thread_info *) entry;
   lwp = get_thread_lwp (thread);
@@ skipping 19 matching lines @@
                          ? "stopped"
                          : "stopping",
                          lwpid_of (lwp));
 
               continue;
             }
 
           lwp->resume = &r->resume[ndx];
           thread->last_resume_kind = lwp->resume->kind;
 
+          lwp->step_range_start = lwp->resume->step_range_start;
+          lwp->step_range_end = lwp->resume->step_range_end;
+
           /* If we had a deferred signal to report, dequeue one now.
              This can happen if LWP gets more than one signal while
              trying to get out of a jump pad.  */
           if (lwp->stopped
               && !lwp->status_pending_p
               && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
             {
               lwp->status_pending_p = 1;
 
               if (debug_threads)
                 fprintf (stderr,
                          "Dequeueing deferred signal %d for LWP %ld, "
                          "leaving status pending.\n",
                          WSTOPSIG (lwp->status_pending), lwpid_of (lwp));
             }
 
           return 0;
         }
     }
 
   /* No resume action for this thread.  */
   lwp->resume = NULL;
 
   return 0;
 }
 
+/* find_inferior callback for linux_resume.
+   Set *FLAG_P if this lwp has an interesting status pending.  */
 
-/* Set *FLAG_P if this lwp has an interesting status pending.  */
 static int
 resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
 {
   struct lwp_info *lwp = (struct lwp_info *) entry;
 
   /* LWPs which will not be resumed are not interesting, because
      we might not wait for them next time through linux_wait.  */
   if (lwp->resume == NULL)
     return 0;
 
@@ skipping 346 matching lines @@
           p_sig->prev = lwp->pending_signals;
           p_sig->signal = lwp->resume->sig;
           memset (&p_sig->info, 0, sizeof (siginfo_t));
 
           /* If this is the same signal we were previously stopped by,
              make sure to queue its siginfo.  We can ignore the return
              value of ptrace; if it fails, we'll skip
              PTRACE_SETSIGINFO.  */
           if (WIFSTOPPED (lwp->last_status)
               && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
-            ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &p_sig->info);
+            ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0,
+                    &p_sig->info);
 
           lwp->pending_signals = p_sig;
         }
     }
 
   thread->last_status.kind = TARGET_WAITKIND_IGNORE;
   lwp->resume = NULL;
   return 0;
 }
 
@@ skipping 209 matching lines @@
     find_inferior (&all_lwps, unsuspend_and_proceed_one_lwp, except);
   else
     find_inferior (&all_lwps, proceed_one_lwp, except);
 }
 
 
 #ifdef HAVE_LINUX_REGSETS
 
 #define use_linux_regsets 1
 
+/* Returns true if REGSET has been disabled.  */
+
 static int
-regsets_fetch_inferior_registers (struct regcache *regcache)
+regset_disabled (struct regsets_info *info, struct regset_info *regset)
+{
+  return (info->disabled_regsets != NULL
+          && info->disabled_regsets[regset - info->regsets]);
+}
+
+/* Disable REGSET.  */
+
+static void
+disable_regset (struct regsets_info *info, struct regset_info *regset)
+{
+  int dr_offset;
+
+  dr_offset = regset - info->regsets;
+  if (info->disabled_regsets == NULL)
+    info->disabled_regsets = xcalloc (1, info->num_regsets);
+  info->disabled_regsets[dr_offset] = 1;
+}
+
+static int
+regsets_fetch_inferior_registers (struct regsets_info *regsets_info,
+                                  struct regcache *regcache)
 {
   struct regset_info *regset;
   int saw_general_regs = 0;
   int pid;
   struct iovec iov;
 
-  regset = target_regsets;
+  regset = regsets_info->regsets;
 
   pid = lwpid_of (get_thread_lwp (current_inferior));
   while (regset->size >= 0)
     {
       void *buf, *data;
       int nt_type, res;
 
-      if (regset->size == 0 || disabled_regsets[regset - target_regsets])
+      if (regset->size == 0 || regset_disabled (regsets_info, regset))
         {
           regset ++;
           continue;
         }
 
       buf = xmalloc (regset->size);
 
       nt_type = regset->nt_type;
       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,
-                    (PTRACE_ARG3_TYPE) (long) nt_type, data);
+                    (PTRACE_TYPE_ARG3) (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;
+                 this process mode.  */
+              disable_regset (regsets_info, regset);
               free (buf);
               continue;
             }
           else
             {
               char s[256];
               sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
                        pid);
               perror (s);
             }
         }
       else if (regset->type == GENERAL_REGS)
         saw_general_regs = 1;
       regset->store_function (regcache, buf);
       regset ++;
       free (buf);
     }
   if (saw_general_regs)
     return 0;
   else
     return 1;
 }
 
 static int
-regsets_store_inferior_registers (struct regcache *regcache)
+regsets_store_inferior_registers (struct regsets_info *regsets_info,
+                                  struct regcache *regcache)
 {
   struct regset_info *regset;
   int saw_general_regs = 0;
   int pid;
   struct iovec iov;
 
-  regset = target_regsets;
+  regset = regsets_info->regsets;
 
   pid = lwpid_of (get_thread_lwp (current_inferior));
   while (regset->size >= 0)
     {
       void *buf, *data;
       int nt_type, res;
 
-      if (regset->size == 0 || disabled_regsets[regset - target_regsets])
+      if (regset->size == 0 || regset_disabled (regsets_info, regset))
         {
           regset ++;
           continue;
         }
 
       buf = xmalloc (regset->size);
 
       /* First fill the buffer with the current register set contents,
          in case there are any items in the kernel's regset that are
          not in gdbserver's regcache.  */
 
       nt_type = regset->nt_type;
       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,
-                    (PTRACE_ARG3_TYPE) (long) nt_type, data);
+                    (PTRACE_TYPE_ARG3) (long) nt_type, data);
 #else
       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,
-                        (PTRACE_ARG3_TYPE) (long) nt_type, data);
+                        (PTRACE_TYPE_ARG3) (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
-                 this process.  */
-              disabled_regsets[regset - target_regsets] = 1;
+                 this process mode.  */
+              disable_regset (regsets_info, regset);
               free (buf);
               continue;
             }
           else if (errno == ESRCH)
             {
               /* 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.  */
               free (buf);
@@ skipping 11 matching lines @@
     }
   if (saw_general_regs)
     return 0;
   else
     return 1;
 }
 
 #else /* !HAVE_LINUX_REGSETS */
 
 #define use_linux_regsets 0
-#define regsets_fetch_inferior_registers(regcache) 1
-#define regsets_store_inferior_registers(regcache) 1
+#define regsets_fetch_inferior_registers(regsets_info, regcache) 1
+#define regsets_store_inferior_registers(regsets_info, 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)
+linux_register_in_regsets (const struct regs_info *regs_info, 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));
+          && (regs_info->regset_bitmap == NULL
+              || (regs_info->regset_bitmap[index] & mask) != 0));
 }
 
 #ifdef HAVE_LINUX_USRREGS
 
 int
-register_addr (int regnum)
+register_addr (const struct usrregs_info *usrregs, int regnum)
 {
   int addr;
 
-  if (regnum < 0 || regnum >= the_low_target.num_regs)
+  if (regnum < 0 || regnum >= usrregs->num_regs)
     error ("Invalid register number %d.", regnum);
 
-  addr = the_low_target.regmap[regnum];
+  addr = usrregs->regmap[regnum];
 
   return addr;
 }
 
 /* Fetch one register.  */
 static void
-fetch_register (struct regcache *regcache, int regno)
+fetch_register (const struct usrregs_info *usrregs,
+                struct regcache *regcache, int regno)
 {
   CORE_ADDR regaddr;
   int i, size;
   char *buf;
   int pid;
 
-  if (regno >= the_low_target.num_regs)
+  if (regno >= usrregs->num_regs)
     return;
   if ((*the_low_target.cannot_fetch_register) (regno))
     return;
 
-  regaddr = register_addr (regno);
+  regaddr = register_addr (usrregs, regno);
   if (regaddr == -1)
     return;
 
-  size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
+  size = ((register_size (regcache->tdesc, 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);
+                (PTRACE_TYPE_ARG3) (uintptr_t) regaddr, (PTRACE_TYPE_ARG4) 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)
+store_register (const struct usrregs_info *usrregs,
+                struct regcache *regcache, int regno)
 {
   CORE_ADDR regaddr;
   int i, size;
   char *buf;
   int pid;
 
-  if (regno >= the_low_target.num_regs)
+  if (regno >= usrregs->num_regs)
     return;
   if ((*the_low_target.cannot_store_register) (regno))
     return;
 
-  regaddr = register_addr (regno);
+  regaddr = register_addr (usrregs, regno);
   if (regaddr == -1)
     return;
 
-  size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
+  size = ((register_size (regcache->tdesc, 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));
+              (PTRACE_TYPE_ARG3) (uintptr_t) regaddr,
+              (PTRACE_TYPE_ARG4) *(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)
+usr_fetch_inferior_registers (const struct regs_info *regs_info,
+                              struct regcache *regcache, int regno, int all)
 {
+  struct usrregs_info *usr = regs_info->usrregs;
+
   if (regno == -1)
     {
-      for (regno = 0; regno < the_low_target.num_regs; regno++)
-        if (all || !linux_register_in_regsets (regno))
-          fetch_register (regcache, regno);
+      for (regno = 0; regno < usr->num_regs; regno++)
+        if (all || !linux_register_in_regsets (regs_info, regno))
+          fetch_register (usr, regcache, regno);
     }
   else
-    fetch_register (regcache, regno);
+    fetch_register (usr, 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)
+usr_store_inferior_registers (const struct regs_info *regs_info,
+                              struct regcache *regcache, int regno, int all)
 {
+  struct usrregs_info *usr = regs_info->usrregs;
+
   if (regno == -1)
     {
-      for (regno = 0; regno < the_low_target.num_regs; regno++)
-        if (all || !linux_register_in_regsets (regno))
-          store_register (regcache, regno);
+      for (regno = 0; regno < usr->num_regs; regno++)
+        if (all || !linux_register_in_regsets (regs_info, regno))
+          store_register (usr, regcache, regno);
     }
   else
-    store_register (regcache, regno);
+    store_register (usr, 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)
+#define usr_fetch_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
+#define usr_store_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
 
 #endif
 
 
 void
 linux_fetch_registers (struct regcache *regcache, int regno)
 {
   int use_regsets;
   int all = 0;
+  const struct regs_info *regs_info = (*the_low_target.regs_info) ();
 
   if (regno == -1)
     {
-      if (the_low_target.fetch_register != NULL)
-        for (regno = 0; regno < the_low_target.num_regs; regno++)
+      if (the_low_target.fetch_register != NULL
+          && regs_info->usrregs != NULL)
+        for (regno = 0; regno < regs_info->usrregs->num_regs; regno++)
           (*the_low_target.fetch_register) (regcache, regno);
 
-      all = regsets_fetch_inferior_registers (regcache);
-      usr_fetch_inferior_registers (regcache, -1, all);
+      all = regsets_fetch_inferior_registers (regs_info->regsets_info, regcache);
+      if (regs_info->usrregs != NULL)
+        usr_fetch_inferior_registers (regs_info, 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);
+      use_regsets = linux_register_in_regsets (regs_info, regno);
       if (use_regsets)
-        all = regsets_fetch_inferior_registers (regcache);
-      if (!use_regsets || all)
-        usr_fetch_inferior_registers (regcache, regno, 1);
+        all = regsets_fetch_inferior_registers (regs_info->regsets_info,
+                                                regcache);
+      if ((!use_regsets || all) && regs_info->usrregs != NULL)
+        usr_fetch_inferior_registers (regs_info, regcache, regno, 1);
     }
 }
 
 void
 linux_store_registers (struct regcache *regcache, int regno)
 {
   int use_regsets;
   int all = 0;
+  const struct regs_info *regs_info = (*the_low_target.regs_info) ();
 
   if (regno == -1)
     {
-      all = regsets_store_inferior_registers (regcache);
-      usr_store_inferior_registers (regcache, regno, all);
+      all = regsets_store_inferior_registers (regs_info->regsets_info,
+                                              regcache);
+      if (regs_info->usrregs != NULL)
+        usr_store_inferior_registers (regs_info, regcache, regno, all);
     }
   else
     {
-      use_regsets = linux_register_in_regsets (regno);
+      use_regsets = linux_register_in_regsets (regs_info, regno);
       if (use_regsets)
-        all = regsets_store_inferior_registers (regcache);
-      if (!use_regsets || all)
-        usr_store_inferior_registers (regcache, regno, 1);
+        all = regsets_store_inferior_registers (regs_info->regsets_info,
+                                                regcache);
+      if ((!use_regsets || all) && regs_info->usrregs != NULL)
+        usr_store_inferior_registers (regs_info, 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)
 {
@@ skipping 52 matching lines @@
   /* 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))
     {
       /* 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);
+                          (PTRACE_TYPE_ARG3) (uintptr_t) addr,
+                          (PTRACE_TYPE_ARG4) 0);
       if (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);
     }
 
   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.  */
+   returns the value of errno.  Always succeeds if LEN is zero.  */
 
 static int
 linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 {
   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 pid = lwpid_of (get_thread_lwp (current_inferior));
 
+  if (len == 0)
+    {
+      /* Zero length write always succeeds.  */
+      return 0;
+    }
+
   if (debug_threads)
     {
       /* Dump up to four bytes.  */
       unsigned int val = * (unsigned int *) myaddr;
       if (len == 1)
         val = val & 0xff;
       else if (len == 2)
         val = val & 0xffff;
       else if (len == 3)
         val = val & 0xffffff;
       fprintf (stderr, "Writing %0*x to 0x%08lx\n", 2 * ((len < 4) ? len : 4),
                val, (long)memaddr);
     }
 
   /* Fill start and end extra bytes of buffer with existing memory data.  */
 
   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[0] = ptrace (PTRACE_PEEKTEXT, pid,
-                      (PTRACE_ARG3_TYPE) (uintptr_t) addr, 0);
+                      (PTRACE_TYPE_ARG3) (uintptr_t) addr,
+                      (PTRACE_TYPE_ARG4) 0);
   if (errno)
     return errno;
 
   if (count > 1)
     {
       errno = 0;
       buffer[count - 1]
         = ptrace (PTRACE_PEEKTEXT, 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) (addr + (count - 1)
+                  (PTRACE_TYPE_ARG3) (uintptr_t) (addr + (count - 1)
                                                   * sizeof (PTRACE_XFER_TYPE)),
-                  0);
+                  (PTRACE_TYPE_ARG4) 0);
       if (errno)
         return errno;
     }
 
   /* Copy data to be written over corresponding part of buffer.  */
 
   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
           myaddr, len);
 
   /* Write the entire buffer.  */
 
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;
       ptrace (PTRACE_POKETEXT, 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) addr,
-              (PTRACE_ARG4_TYPE) buffer[i]);
+              (PTRACE_TYPE_ARG3) (uintptr_t) addr,
+              (PTRACE_TYPE_ARG4) buffer[i]);
       if (errno)
         return errno;
     }
 
   return 0;
 }
 
-/* Non-zero if the kernel supports PTRACE_O_TRACEFORK.  */
-static int linux_supports_tracefork_flag;
-
-static void
-linux_enable_event_reporting (int pid)
-{
-  if (!linux_supports_tracefork_flag)
-    return;
-
-  ptrace (PTRACE_SETOPTIONS, pid, 0, (PTRACE_ARG4_TYPE) PTRACE_O_TRACECLONE);
-}
-
-/* Helper functions for linux_test_for_tracefork, called via clone ().  */
-
-static int
-linux_tracefork_grandchild (void *arg)
-{
-  _exit (0);
-}
-
-#define STACK_SIZE 4096
-
-static int
-linux_tracefork_child (void *arg)
-{
-  ptrace (PTRACE_TRACEME, 0, 0, 0);
-  kill (getpid (), SIGSTOP);
-
-#if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
-
-  if (fork () == 0)
-    linux_tracefork_grandchild (NULL);
-
-#else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
-
-#ifdef __ia64__
-  __clone2 (linux_tracefork_grandchild, arg, STACK_SIZE,
-            CLONE_VM | SIGCHLD, NULL);
-#else
-  clone (linux_tracefork_grandchild, (char *) arg + STACK_SIZE,
-         CLONE_VM | SIGCHLD, NULL);
-#endif
-
-#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
-
-  _exit (0);
-}
-
-/* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.  Make
-   sure that we can enable the option, and that it had the desired
-   effect.  */
-
-static void
-linux_test_for_tracefork (void)
-{
-  int child_pid, ret, status;
-  long second_pid;
-#if defined(__UCLIBC__) && defined(HAS_NOMMU)
-  char *stack = xmalloc (STACK_SIZE * 4);
-#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
-
-  linux_supports_tracefork_flag = 0;
-
-#if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
-
-  child_pid = fork ();
-  if (child_pid == 0)
-    linux_tracefork_child (NULL);
-
-#else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
-
-  /* Use CLONE_VM instead of fork, to support uClinux (no MMU).  */
-#ifdef __ia64__
-  child_pid = __clone2 (linux_tracefork_child, stack, STACK_SIZE,
-                        CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
-#else /* !__ia64__ */
-  child_pid = clone (linux_tracefork_child, stack + STACK_SIZE,
-                     CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
-#endif /* !__ia64__ */
-
-#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
-
-  if (child_pid == -1)
-    perror_with_name ("clone");
-
-  ret = my_waitpid (child_pid, &status, 0);
-  if (ret == -1)
-    perror_with_name ("waitpid");
-  else if (ret != child_pid)
-    error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
-  if (! WIFSTOPPED (status))
-    error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
-
-  ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
-                (PTRACE_ARG4_TYPE) PTRACE_O_TRACEFORK);
-  if (ret != 0)
-    {
-      ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
-      if (ret != 0)
-        {
-          warning ("linux_test_for_tracefork: failed to kill child");
-          return;
-        }
-
-      ret = my_waitpid (child_pid, &status, 0);
-      if (ret != child_pid)
-        warning ("linux_test_for_tracefork: failed to wait for killed child");
-      else if (!WIFSIGNALED (status))
-        warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
-                 "killed child", status);
-
-      return;
-    }
-
-  ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
-  if (ret != 0)
-    warning ("linux_test_for_tracefork: failed to resume child");
-
-  ret = my_waitpid (child_pid, &status, 0);
-
-  if (ret == child_pid && WIFSTOPPED (status)
-      && status >> 16 == PTRACE_EVENT_FORK)
-    {
-      second_pid = 0;
-      ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
-      if (ret == 0 && second_pid != 0)
-        {
-          int second_status;
-
-          linux_supports_tracefork_flag = 1;
-          my_waitpid (second_pid, &second_status, 0);
-          ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
-          if (ret != 0)
-            warning ("linux_test_for_tracefork: failed to kill second child");
-          my_waitpid (second_pid, &status, 0);
-        }
-    }
-  else
-    warning ("linux_test_for_tracefork: unexpected result from waitpid "
-             "(%d, status 0x%x)", ret, status);
-
-  do
-    {
-      ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
-      if (ret != 0)
-        warning ("linux_test_for_tracefork: failed to kill child");
-      my_waitpid (child_pid, &status, 0);
-    }
-  while (WIFSTOPPED (status));
-
-#if defined(__UCLIBC__) && defined(HAS_NOMMU)
-  free (stack);
-#endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
-}
-
-
 static void
 linux_look_up_symbols (void)
 {
 #ifdef USE_THREAD_DB
   struct process_info *proc = current_process ();
 
   if (proc->private->thread_db != NULL)
     return;
 
-  /* If the kernel supports tracing forks then it also supports tracing
-     clones, and then we don't need to use the magic thread event breakpoint
-     to learn about threads.  */
-  thread_db_init (!linux_supports_tracefork_flag);
+  /* If the kernel supports tracing clones, then we don't need to
+     use the magic thread event breakpoint to learn about
+     threads.  */
+  thread_db_init (!linux_supports_traceclone ());
 #endif
 }
 
 static void
 linux_request_interrupt (void)
 {
   extern unsigned long signal_pid;
 
   if (!ptid_equal (cont_thread, null_ptid)
       && !ptid_equal (cont_thread, minus_one_ptid))
@@ skipping 69 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
+#if defined(__UCLIBC__) && defined(HAS_NOMMU)         \
+    && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
+    && defined(PT_TEXT_END_ADDR)
+
+/* This is only used for targets that define PT_TEXT_ADDR,
+   PT_DATA_ADDR and PT_TEXT_END_ADDR.  If those are not defined, supposedly
+   the target has different ways of acquiring this information, like
+   loadmaps.  */
 
 /* 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));
 
   errno = 0;
 
-  text = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_ADDR, 0);
-  text_end = ptrace (PTRACE_PEEKUSER, pid, (long)PT_TEXT_END_ADDR, 0);
-  data = ptrace (PTRACE_PEEKUSER, pid, (long)PT_DATA_ADDR, 0);
+  text = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_ADDR,
+                 (PTRACE_TYPE_ARG4) 0);
+  text_end = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_END_ADDR,
+                     (PTRACE_TYPE_ARG4) 0);
+  data = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_DATA_ADDR,
+                 (PTRACE_TYPE_ARG4) 0);
 
   if (errno == 0)
     {
       /* Both text and data offsets produced at compile-time (and so
          used by gdb) are relative to the beginning of the program,
          with the data segment immediately following the text segment.
          However, the actual runtime layout in memory may put the data
          somewhere else, so when we send gdb a data base-address, we
          use the real data base address and subtract the compile-time
          data base-address from it (which is just the length of the
          text segment).  BSS immediately follows data in both
          cases.  */
       *text_p = text;
       *data_p = data - (text_end - text);
 
       return 1;
     }
-#endif
  return 0;
 }
 #endif
 
 static int
 linux_qxfer_osdata (const char *annex,
                     unsigned char *readbuf, unsigned const char *writebuf,
                     CORE_ADDR offset, int len)
 {
   return linux_common_xfer_osdata (annex, readbuf, offset, len);
@@ skipping 35 matching lines @@
   pid = lwpid_of (get_thread_lwp (current_inferior));
 
   if (debug_threads)
     fprintf (stderr, "%s siginfo for lwp %d.\n",
              readbuf != NULL ? "Reading" : "Writing",
              pid);
 
   if (offset >= sizeof (siginfo))
     return -1;
 
-  if (ptrace (PTRACE_GETSIGINFO, pid, 0, &siginfo) != 0)
+  if (ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
     return -1;
 
   /* When GDBSERVER is built as a 64-bit application, ptrace writes into
      SIGINFO an object with 64-bit layout.  Since debugging a 32-bit
      inferior with a 64-bit GDBSERVER should look the same as debugging it
      with a 32-bit GDBSERVER, we need to convert it.  */
   siginfo_fixup (&siginfo, inf_siginfo, 0);
 
   if (offset + len > sizeof (siginfo))
     len = sizeof (siginfo) - offset;
 
   if (readbuf != NULL)
     memcpy (readbuf, inf_siginfo + offset, len);
   else
     {
       memcpy (inf_siginfo + offset, writebuf, len);
 
       /* Convert back to ptrace layout before flushing it out.  */
       siginfo_fixup (&siginfo, inf_siginfo, 1);
 
-      if (ptrace (PTRACE_SETSIGINFO, pid, 0, &siginfo) != 0)
+      if (ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
         return -1;
     }
 
   return len;
 }
 
 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
    so we notice when children change state; as the handler for the
    sigsuspend in my_waitpid.  */
 
@@ skipping 97 matching lines @@
   return 0;
 #endif
 }
 
 static int
 linux_supports_agent (void)
 {
   return 1;
 }
 
+static int
+linux_supports_range_stepping (void)
+{
+  if (*the_low_target.supports_range_stepping == NULL)
+    return 0;
+
+  return (*the_low_target.supports_range_stepping) ();
+}
+
 /* 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 574 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;
+  int ptr_size;
+  CORE_ADDR lm_addr = 0, lm_prev = 0;
+  int allocated = 1024;
+  char *p;
+  CORE_ADDR l_name, l_addr, l_ld, l_next, l_prev;
+  int header_done = 0;
 
   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, &machine);
   lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
+  ptr_size = is_elf64 ? 8 : 4;
 
-  if (priv->r_debug == 0)
-    priv->r_debug = get_r_debug (pid, is_elf64);
+  while (annex[0] != '\0')
+    {
+      const char *sep;
+      CORE_ADDR *addrp;
+      int len;
 
-  /* 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;
+      sep = strchr (annex, '=');
+      if (sep == NULL)
+        break;
 
-  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;
-
-      document = xmalloc (allocated);
-      strcpy (document, "<library-list-svr4 version=\"1.0\"");
-      p = document + strlen (document);
-
-      r_version = 0;
-      if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
-                             (unsigned char *) &r_version,
-                             sizeof (r_version)) != 0
-          || r_version != 1)
+      len = sep - annex;
+      if (len == 5 && strncmp (annex, "start", 5) == 0)
+        addrp = &lm_addr;
+      else if (len == 4 && strncmp (annex, "prev", 4) == 0)
+        addrp = &lm_prev;
+      else
         {
-          warning ("unexpected r_debug version %d", r_version);
-          goto done;
+          annex = strchr (sep, ';');
+          if (annex == NULL)
+            break;
+          annex++;
+          continue;
         }
 
-      if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
-                        &lm_addr, ptr_size) != 0)
+      annex = decode_address_to_semicolon (addrp, sep + 1);
+    }
+
+  if (lm_addr == 0)
+    {
+      int r_version = 0;
+
+      if (priv->r_debug == 0)
+        priv->r_debug = get_r_debug (pid, is_elf64);
+
+      /* 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)
         {
-          warning ("unable to read r_map from 0x%lx",
-                   (long) priv->r_debug + lmo->r_map_offset);
-          goto done;
+          if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
+                                 (unsigned char *) &r_version,
+                                 sizeof (r_version)) != 0
+              || r_version != 1)
+            {
+              warning ("unexpected r_debug version %d", r_version);
+            }
+          else if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
+                                 &lm_addr, ptr_size) != 0)
+            {
+              warning ("unable to read r_map from 0x%lx",
+                       (long) priv->r_debug + lmo->r_map_offset);
+            }
+        }
+    }
+
+  document = xmalloc (allocated);
+  strcpy (document, "<library-list-svr4 version=\"1.0\"");
+  p = document + strlen (document);
+
+  while (lm_addr
+         && read_one_ptr (lm_addr + lmo->l_name_offset,
+                          &l_name, ptr_size) == 0
+         && read_one_ptr (lm_addr + lmo->l_addr_offset,
+                          &l_addr, ptr_size) == 0
+         && read_one_ptr (lm_addr + lmo->l_ld_offset,
+                          &l_ld, ptr_size) == 0
+         && read_one_ptr (lm_addr + lmo->l_prev_offset,
+                          &l_prev, ptr_size) == 0
+         && read_one_ptr (lm_addr + lmo->l_next_offset,
+                          &l_next, ptr_size) == 0)
+    {
+      unsigned char libname[PATH_MAX];
+
+      if (lm_prev != l_prev)
+        {
+          warning ("Corrupted shared library list: 0x%lx != 0x%lx",
+                   (long) lm_prev, (long) l_prev);
+          break;
         }
 
-      lm_prev = 0;
-      while (read_one_ptr (lm_addr + lmo->l_name_offset,
-                           &l_name, ptr_size) == 0
-             && read_one_ptr (lm_addr + lmo->l_addr_offset,
-                              &l_addr, ptr_size) == 0
-             && read_one_ptr (lm_addr + lmo->l_ld_offset,
-                              &l_ld, ptr_size) == 0
-             && read_one_ptr (lm_addr + lmo->l_prev_offset,
-                              &l_prev, ptr_size) == 0
-             && read_one_ptr (lm_addr + lmo->l_next_offset,
-                              &l_next, ptr_size) == 0)
+      /* Ignore the first entry even if it has valid name as the first entry
+         corresponds to the main executable.  The first entry should not be
+         skipped if the dynamic loader was loaded late by a static executable
+         (see solib-svr4.c parameter ignore_first).  But in such case the main
+         executable does not have PT_DYNAMIC present and this function already
+         exited above due to failed get_r_debug.  */
+      if (lm_prev == 0)
         {
-          unsigned char libname[PATH_MAX];
-
-          if (lm_prev != l_prev)
-            {
-              warning ("Corrupted shared library list: 0x%lx != 0x%lx",
-                       (long) lm_prev, (long) l_prev);
-              break;
-            }
-
+          sprintf (p, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
+          p = p + strlen (p);
+        }
+      else
+        {
           /* Not checking for error because reading may stop before
              we've got PATH_MAX worth of characters.  */
           libname[0] = '\0';
           linux_read_memory (l_name, libname, sizeof (libname) - 1);
           libname[sizeof (libname) - 1] = '\0';
           if (libname[0] != '\0')
             {
               /* 6x the size for xml_escape_text below.  */
               size_t len = 6 * strlen ((char *) libname);
               char *name;
@@ skipping 10 matching lines @@
                   /* Expand to guarantee sufficient storage.  */
                   uintptr_t document_len = p - document;
 
                   document = xrealloc (document, 2 * allocated);
                   allocated *= 2;
                   p = document + document_len;
                 }
 
               name = xml_escape_text ((char *) libname);
               p += sprintf (p, "<library name=\"%s\" lm=\"0x%lx\" "
-                               "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
+                            "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
                             name, (unsigned long) lm_addr,
                             (unsigned long) l_addr, (unsigned long) l_ld);
               free (name);
             }
-          else if (lm_prev == 0)
-            {
-              sprintf (p, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
-              p = p + strlen (p);
-            }
+        }
 
-          if (l_next == 0)
-            break;
+      lm_prev = lm_addr;
+      lm_addr = l_next;
+    }
 
-          lm_prev = lm_addr;
-          lm_addr = l_next;
-        }
-    done:
-      if (!header_done)
-        {
-          /* Empty list; terminate `<library-list-svr4'.  */
-          strcpy (p, "/>");
-        }
-      else
-        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;
 
   memcpy (readbuf, document + offset, len);
   xfree (document);
 
   return len;
 }
 
+#ifdef HAVE_LINUX_BTRACE
+
+/* Enable branch tracing.  */
+
+static struct btrace_target_info *
+linux_low_enable_btrace (ptid_t ptid)
+{
+  struct btrace_target_info *tinfo;
+
+  tinfo = linux_enable_btrace (ptid);
+
+  if (tinfo != NULL)
+    {
+      struct thread_info *thread = find_thread_ptid (ptid);
+      struct regcache *regcache = get_thread_regcache (thread, 0);
+
+      tinfo->ptr_bits = register_size (regcache->tdesc, 0) * 8;
+    }
+
+  return tinfo;
+}
+
+/* Read branch trace data as btrace xml document.  */
+
+static void
+linux_low_read_btrace (struct btrace_target_info *tinfo, struct buffer *buffer,
+                       int type)
+{
+  VEC (btrace_block_s) *btrace;
+  struct btrace_block *block;
+  int i;
+
+  btrace = linux_read_btrace (tinfo, type);
+
+  buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
+  buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
+
+  for (i = 0; VEC_iterate (btrace_block_s, btrace, i, block); i++)
+    buffer_xml_printf (buffer, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
+                       paddress (block->begin), paddress (block->end));
+
+  buffer_grow_str (buffer, "</btrace>\n");
+
+  VEC_free (btrace_block_s, btrace);
+}
+#endif /* HAVE_LINUX_BTRACE */
+
 static struct target_ops linux_target_ops = {
   linux_create_inferior,
   linux_attach,
   linux_kill,
   linux_detach,
   linux_mourn,
   linux_join,
   linux_thread_alive,
   linux_resume,
   linux_wait,
   linux_fetch_registers,
   linux_store_registers,
   linux_prepare_to_access_memory,
   linux_done_accessing_memory,
   linux_read_memory,
   linux_write_memory,
   linux_look_up_symbols,
   linux_request_interrupt,
   linux_read_auxv,
   linux_insert_point,
   linux_remove_point,
   linux_stopped_by_watchpoint,
   linux_stopped_data_address,
-#if defined(__UCLIBC__) && defined(HAS_NOMMU)
+#if defined(__UCLIBC__) && defined(HAS_NOMMU)         \
+    && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
+    && defined(PT_TEXT_END_ADDR)
   linux_read_offsets,
 #else
   NULL,
 #endif
 #ifdef USE_THREAD_DB
   thread_db_get_tls_address,
 #else
   NULL,
 #endif
   linux_qxfer_spu,
@@ skipping 20 matching lines @@
   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,
+#ifdef HAVE_LINUX_BTRACE
+  linux_supports_btrace,
+  linux_low_enable_btrace,
+  linux_disable_btrace,
+  linux_low_read_btrace,
+#else
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+#endif
+  linux_supports_range_stepping,
 };
 
 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
 }
 
+#ifdef HAVE_LINUX_REGSETS
+void
+initialize_regsets_info (struct regsets_info *info)
+{
+  for (info->num_regsets = 0;
+       info->regsets[info->num_regsets].size >= 0;
+       info->num_regsets++)
+    ;
+}
+#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);
+
+  initialize_low_arch ();
 }