Merge GDB 7.5.1

gdb/gdbserver/server.c

 /* Main code for remote server for GDB.
    Copyright (C) 1989, 1993-1995, 1997-2000, 2002-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 "gdbthread.h"
+#include "agent.h"
 
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #if HAVE_SIGNAL_H
 #include <signal.h>
 #endif
 #if HAVE_SYS_WAIT_H
 #include <sys/wait.h>
 #endif
 
+/* The thread set with an `Hc' packet.  `Hc' is deprecated in favor of
+   `vCont'.  Note the multi-process extensions made `vCont' a
+   requirement, so `Hc pPID.TID' is pretty much undefined.  So
+   CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
+   resuming all threads of the process (again, `Hc' isn't used for
+   multi-process), or a specific thread ptid_t.
+
+   We also set this when handling a single-thread `vCont' resume, as
+   some places in the backends check it to know when (and for which
+   thread) single-thread scheduler-locking is in effect.  */
 ptid_t cont_thread;
+
+/* The thread set with an `Hg' packet.  */
 ptid_t general_thread;
 
 int server_waiting;
 
 static int extended_protocol;
 static int response_needed;
 static int exit_requested;
 
 /* --once: Exit after the first connection has closed.  */
 int run_once;
 
 int multi_process;
 int non_stop;
 
 /* Whether we should attempt to disable the operating system's address
    space randomization feature before starting an inferior.  */
 int disable_randomization = 1;
 
 static char **program_argv, **wrapper_argv;
 
 /* Enable miscellaneous debugging output.  The name is historical - it
    was originally used to debug LinuxThreads support.  */
 int debug_threads;
 
 /* Enable debugging of h/w breakpoint/watchpoint support.  */
 int debug_hw_points;
 
-int pass_signals[TARGET_SIGNAL_LAST];
+int pass_signals[GDB_SIGNAL_LAST];
+int program_signals[GDB_SIGNAL_LAST];
+int program_signals_p;
 
 jmp_buf toplevel;
 
 const char *gdbserver_xmltarget;
 
 /* The PID of the originally created or attached inferior.  Used to
    send signals to the process when GDB sends us an asynchronous interrupt
    (user hitting Control-C in the client), and to wait for the child to exit
    when no longer debugging it.  */
 
@@ skipping 181 matching lines @@
       for (i = 0; new_argv[i]; ++i)
         fprintf (stderr, "new_argv[%d] = \"%s\"\n", i, new_argv[i]);
       fflush (stderr);
     }
 
 #ifdef SIGTTOU
   signal (SIGTTOU, SIG_DFL);
   signal (SIGTTIN, SIG_DFL);
 #endif
 
+  /* Clear this so the backend doesn't get confused, thinking
+     CONT_THREAD died, and it needs to resume all threads.  */
+  cont_thread = null_ptid;
+
   signal_pid = create_inferior (new_argv[0], new_argv);
 
   /* FIXME: we don't actually know at this point that the create
      actually succeeded.  We won't know that until we wait.  */
   fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
            signal_pid);
   fflush (stderr);
 
 #ifdef SIGTTOU
   signal (SIGTTOU, SIG_IGN);
   signal (SIGTTIN, SIG_IGN);
   terminal_fd = fileno (stderr);
   old_foreground_pgrp = tcgetpgrp (terminal_fd);
   tcsetpgrp (terminal_fd, signal_pid);
   atexit (restore_old_foreground_pgrp);
 #endif
 
   if (wrapper_argv != NULL)
     {
       struct thread_resume resume_info;
 
       resume_info.thread = pid_to_ptid (signal_pid);
       resume_info.kind = resume_continue;
       resume_info.sig = 0;
 
-      mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
+      last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
 
       if (last_status.kind != TARGET_WAITKIND_STOPPED)
         return signal_pid;
 
       do
         {
           (*the_target->resume) (&resume_info, 1);
 
-          mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
+          last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
           if (last_status.kind != TARGET_WAITKIND_STOPPED)
             return signal_pid;
 
           current_inferior->last_resume_kind = resume_stop;
           current_inferior->last_status = last_status;
         }
-      while (last_status.value.sig != TARGET_SIGNAL_TRAP);
+      while (last_status.value.sig != GDB_SIGNAL_TRAP);
 
-      current_inferior->last_resume_kind = resume_stop;
-      current_inferior->last_status = last_status;
       return signal_pid;
     }
 
   /* Wait till we are at 1st instruction in program, return new pid
      (assuming success).  */
   last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
 
   if (last_status.kind != TARGET_WAITKIND_EXITED
       && last_status.kind != TARGET_WAITKIND_SIGNALLED)
     {
@@ skipping 14 matching lines @@
     return -1;
 
   fprintf (stderr, "Attached; pid = %d\n", pid);
   fflush (stderr);
 
   /* FIXME - It may be that we should get the SIGNAL_PID from the
      attach function, so that it can be the main thread instead of
      whichever we were told to attach to.  */
   signal_pid = pid;
 
+  /* Clear this so the backend doesn't get confused, thinking
+     CONT_THREAD died, and it needs to resume all threads.  */
+  cont_thread = null_ptid;
+
   if (!non_stop)
     {
       last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
 
       /* GDB knows to ignore the first SIGSTOP after attaching to a running
          process using the "attach" command, but this is different; it's
          just using "target remote".  Pretend it's just starting up.  */
       if (last_status.kind == TARGET_WAITKIND_STOPPED
-          && last_status.value.sig == TARGET_SIGNAL_STOP)
-        last_status.value.sig = TARGET_SIGNAL_TRAP;
+          && last_status.value.sig == GDB_SIGNAL_STOP)
+        last_status.value.sig = GDB_SIGNAL_TRAP;
 
       current_inferior->last_resume_kind = resume_stop;
       current_inferior->last_status = last_status;
     }
 
   return 0;
 }
 
 extern int remote_debug;
 
@@ skipping 59 matching lines @@
                                PBUFSIZ - 2) + 1;
 }
 
 /* Handle all of the extended 'Q' packets.  */
 
 static void
 handle_general_set (char *own_buf)
 {
   if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
     {
-      int numsigs = (int) TARGET_SIGNAL_LAST, i;
+      int numsigs = (int) GDB_SIGNAL_LAST, i;
       const char *p = own_buf + strlen ("QPassSignals:");
       CORE_ADDR cursig;
 
       p = decode_address_to_semicolon (&cursig, p);
       for (i = 0; i < numsigs; i++)
         {
           if (i == cursig)
             {
               pass_signals[i] = 1;
               if (*p == '\0')
                 /* Keep looping, to clear the remaining signals.  */
                 cursig = -1;
               else
                 p = decode_address_to_semicolon (&cursig, p);
             }
           else
             pass_signals[i] = 0;
         }
       strcpy (own_buf, "OK");
       return;
     }
 
+  if (strncmp ("QProgramSignals:", own_buf, strlen ("QProgramSignals:")) == 0)
+    {
+      int numsigs = (int) GDB_SIGNAL_LAST, i;
+      const char *p = own_buf + strlen ("QProgramSignals:");
+      CORE_ADDR cursig;
+
+      program_signals_p = 1;
+
+      p = decode_address_to_semicolon (&cursig, p);
+      for (i = 0; i < numsigs; i++)
+        {
+          if (i == cursig)
+            {
+              program_signals[i] = 1;
+              if (*p == '\0')
+                /* Keep looping, to clear the remaining signals.  */
+                cursig = -1;
+              else
+                p = decode_address_to_semicolon (&cursig, p);
+            }
+          else
+            program_signals[i] = 0;
+        }
+      strcpy (own_buf, "OK");
+      return;
+    }
+
   if (strcmp (own_buf, "QStartNoAckMode") == 0)
     {
       if (remote_debug)
         {
           fprintf (stderr, "[noack mode enabled]\n");
           fflush (stderr);
         }
 
       noack_mode = 1;
       write_ok (own_buf);
@@ skipping 55 matching lines @@
         }
 
       write_ok (own_buf);
       return;
     }
 
   if (target_supports_tracepoints ()
       && handle_tracepoint_general_set (own_buf))
     return;
 
+  if (strncmp ("QAgent:", own_buf, strlen ("QAgent:")) == 0)
+    {
+      char *mode = own_buf + strlen ("QAgent:");
+      int req = 0;
+
+      if (strcmp (mode, "0") == 0)
+        req = 0;
+      else if (strcmp (mode, "1") == 0)
+        req = 1;
+      else
+        {
+          /* We don't know what this value is, so complain to GDB.  */
+          sprintf (own_buf, "E.Unknown QAgent value");
+          return;
+        }
+
+      /* Update the flag.  */
+      use_agent = req;
+      if (remote_debug)
+        fprintf (stderr, "[%s agent]\n", req ? "Enable" : "Disable");
+      write_ok (own_buf);
+      return;
+    }
+
   /* Otherwise we didn't know what packet it was.  Say we didn't
      understand it.  */
   own_buf[0] = 0;
 }
 
 static const char *
 get_features_xml (const char *annex)
 {
   /* gdbserver_xmltarget defines what to return when looking
      for the "target.xml" file.  Its contents can either be
@@ skipping 262 matching lines @@
 #define require_running(BUF)                    \
   if (!target_running ())                       \
     {                                           \
       write_enn (BUF);                          \
       return;                                   \
     }
 
 /* Handle monitor commands not handled by target-specific handlers.  */
 
 static void
-handle_monitor_command (char *mon)
+handle_monitor_command (char *mon, char *own_buf)
 {
   if (strcmp (mon, "set debug 1") == 0)
     {
       debug_threads = 1;
       monitor_output ("Debug output enabled.\n");
     }
   else if (strcmp (mon, "set debug 0") == 0)
     {
       debug_threads = 0;
       monitor_output ("Debug output disabled.\n");
@@ skipping 113 matching lines @@
   unsigned int total_len;
   char *document, *p;
   struct inferior_list_entry *dll_ptr;
 
   if (writebuf != NULL)
     return -2;
 
   if (annex[0] != '\0' || !target_running ())
     return -1;
 
-  /* Do not confuse this packet with qXfer:libraries-svr4:read.  */
-  if (the_target->qxfer_libraries_svr4 != NULL)
-    return 0;
-
   /* Over-estimate the necessary memory.  Assume that every character
      in the library name must be escaped.  */
   total_len = 64;
   for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
     total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
 
   document = malloc (total_len);
   if (document == NULL)
     return -1;
 
@@ skipping 126 matching lines @@
 handle_qxfer_threads_proper (struct buffer *buffer)
 {
   struct inferior_list_entry *thread;
 
   buffer_grow_str (buffer, "<threads>\n");
 
   for (thread = all_threads.head; thread; thread = thread->next)
     {
       ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread);
       char ptid_s[100];
-      int core = -1;
+      int core = target_core_of_thread (ptid);
       char core_s[21];
 
       write_ptid (ptid_s, ptid);
 
-      if (the_target->core_of_thread)
-        core = (*the_target->core_of_thread) (ptid);
-
       if (core != -1)
         {
           sprintf (core_s, "%d", core);
           buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
                              ptid_s, core_s);
         }
       else
         {
           buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
                              ptid_s);
@@ skipping 436 matching lines @@
                 }
               else
                 target_process_qsupported (p);
 
               free (p);
             }
 
           free (qsupported);
         }
 
-      sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
+      sprintf (own_buf,
+               "PacketSize=%x;QPassSignals+;QProgramSignals+",
+               PBUFSIZ - 1);
 
       if (the_target->qxfer_libraries_svr4 != NULL)
         strcat (own_buf, ";qXfer:libraries-svr4:read+");
       else
         {
           /* We do not have any hook to indicate whether the non-SVR4 target
              backend supports qXfer:libraries:read, so always report it.  */
           strcat (own_buf, ";qXfer:libraries:read+");
         }
 
@@ skipping 41 matching lines @@
           if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
             strcat (own_buf, ";FastTracepoints+");
           strcat (own_buf, ";StaticTracepoints+");
           strcat (own_buf, ";InstallInTrace+");
           strcat (own_buf, ";qXfer:statictrace:read+");
           strcat (own_buf, ";qXfer:traceframe-info:read+");
           strcat (own_buf, ";EnableDisableTracepoints+");
           strcat (own_buf, ";tracenz+");
         }
 
+      /* Support target-side breakpoint conditions and commands.  */
+      strcat (own_buf, ";ConditionalBreakpoints+");
+      strcat (own_buf, ";BreakpointCommands+");
+
+      if (target_supports_agent ())
+        strcat (own_buf, ";QAgent+");
+
       return;
     }
 
   /* Thread-local storage support.  */
   if (the_target->get_tls_address != NULL
       && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
     {
       char *p = own_buf + 12;
       CORE_ADDR parts[2], address = 0;
       int i, err;
@@ skipping 96 matching lines @@
           free (mon);
           return;
         }
       mon[len / 2] = '\0';
 
       write_ok (own_buf);
 
       if (the_target->handle_monitor_command == NULL
           || (*the_target->handle_monitor_command) (mon) == 0)
         /* Default processing.  */
-        handle_monitor_command (mon);
+        handle_monitor_command (mon, own_buf);
 
       free (mon);
       return;
     }
 
   if (strncmp ("qSearch:memory:", own_buf,
                sizeof ("qSearch:memory:") - 1) == 0)
     {
       require_running (own_buf);
       handle_search_memory (own_buf, packet_len);
@@ skipping 105 matching lines @@
         goto err;
 
       if (p[0] == 'S' || p[0] == 'C')
         {
           int sig;
           sig = strtol (p + 1, &q, 16);
           if (p == q)
             goto err;
           p = q;
 
-          if (!target_signal_to_host_p (sig))
+          if (!gdb_signal_to_host_p (sig))
             goto err;
-          resume_info[i].sig = target_signal_to_host (sig);
+          resume_info[i].sig = gdb_signal_to_host (sig);
         }
       else
         {
           resume_info[i].sig = 0;
           p = p + 1;
         }
 
       if (p[0] == 0)
         {
           resume_info[i].thread = minus_one_ptid;
@@ skipping 14 matching lines @@
 
           resume_info[i].thread = ptid;
 
           i++;
         }
     }
 
   if (i < n)
     resume_info[i] = default_action;
 
-  /* Still used in occasional places in the backend.  */
+  /* `cont_thread' is still used in occasional places in the backend,
+     to implement single-thread scheduler-locking.  Doesn't make sense
+     to set it if we see a stop request, or a wildcard action (one
+     with '-1' (all threads), or 'pPID.-1' (all threads of PID)).  */
   if (n == 1
-      && !ptid_equal (resume_info[0].thread, minus_one_ptid)
+      && !(ptid_equal (resume_info[0].thread, minus_one_ptid)
+           || ptid_get_lwp (resume_info[0].thread) == -1)
       && resume_info[0].kind != resume_stop)
     cont_thread = resume_info[0].thread;
   else
     cont_thread = minus_one_ptid;
   set_desired_inferior (0);
 
   if (!non_stop)
     enable_async_io ();
 
   (*the_target->resume) (resume_info, n);
@@ skipping 159 matching lines @@
 {
   int pid;
   char *p = &own_buf[6];
   if (multi_process)
     pid = strtol (p, NULL, 16);
   else
     pid = signal_pid;
   if (pid != 0 && kill_inferior (pid) == 0)
     {
       last_status.kind = TARGET_WAITKIND_SIGNALLED;
-      last_status.value.sig = TARGET_SIGNAL_KILL;
+      last_status.value.sig = GDB_SIGNAL_KILL;
       last_ptid = pid_to_ptid (pid);
       discard_queued_stop_replies (pid);
       write_ok (own_buf);
       return 1;
     }
   else
     {
       write_enn (own_buf);
       return 0;
     }
@@ skipping 41 matching lines @@
           return;
         }
     }
 
   if (strncmp (own_buf, "vFile:", 6) == 0
       && handle_vFile (own_buf, packet_len, new_packet_len))
     return;
 
   if (strncmp (own_buf, "vAttach;", 8) == 0)
     {
-      if (!multi_process && target_running ())
+      if ((!extended_protocol || !multi_process) && target_running ())
         {
           fprintf (stderr, "Already debugging a process\n");
           write_enn (own_buf);
           return;
         }
       handle_v_attach (own_buf);
       return;
     }
 
   if (strncmp (own_buf, "vRun;", 5) == 0)
     {
-      if (!multi_process && target_running ())
+      if ((!extended_protocol || !multi_process) && target_running ())
         {
           fprintf (stderr, "Already debugging a process\n");
           write_enn (own_buf);
           return;
         }
       handle_v_run (own_buf);
       return;
     }
 
   if (strncmp (own_buf, "vKill;", 6) == 0)
@@ skipping 128 matching lines @@
 {
   struct thread_info *thread = (struct thread_info *) entry;
 
   thread->last_resume_kind = resume_stop;
 
   if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
     {
       /* Most threads are stopped implicitly (all-stop); tag that with
          signal 0.  */
       thread->last_status.kind = TARGET_WAITKIND_STOPPED;
-      thread->last_status.value.sig = TARGET_SIGNAL_0;
+      thread->last_status.value.sig = GDB_SIGNAL_0;
     }
 }
 
 /* Set all threads' states as "want-stopped".  */
 
 static void
 gdb_wants_all_threads_stopped (void)
 {
   for_each_inferior (&all_threads, gdb_wants_thread_stopped);
 }
@@ skipping 34 matching lines @@
     {
       pause_all (0);
       stabilize_threads ();
       gdb_wants_all_threads_stopped ();
 
       if (all_threads.head)
         {
           struct target_waitstatus status;
 
           status.kind = TARGET_WAITKIND_STOPPED;
-          status.value.sig = TARGET_SIGNAL_TRAP;
+          status.value.sig = GDB_SIGNAL_TRAP;
           prepare_resume_reply (own_buf,
                                 all_threads.head->id, &status);
         }
       else
         strcpy (own_buf, "W00");
     }
 }
 
 static void
 gdbserver_version (void)
@@ skipping 147 matching lines @@
   for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
 }
 
 int
 main (int argc, char *argv[])
 {
   int bad_attach;
   int pid;
   char *arg_end, *port;
   char **next_arg = &argv[1];
-  int multi_mode = 0;
-  int attach = 0;
+  volatile int multi_mode = 0;
+  volatile int attach = 0;
   int was_running;
 
   while (*next_arg != NULL && **next_arg == '-')
     {
       if (strcmp (*next_arg, "--version") == 0)
         {
           gdbserver_version ();
           exit (0);
         }
       else if (strcmp (*next_arg, "--help") == 0)
@@ skipping 59 matching lines @@
                 }
               else
                 {
                   fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
                            tok);
                   gdbserver_show_disableable (stderr);
                   exit (1);
                 }
             }
         }
+      else if (strcmp (*next_arg, "-") == 0)
+        {
+          /* "-" specifies a stdio connection and is a form of port
+             specification.  */
+          *next_arg = STDIO_CONNECTION_NAME;
+          break;
+        }
       else if (strcmp (*next_arg, "--disable-randomization") == 0)
         disable_randomization = 1;
       else if (strcmp (*next_arg, "--no-disable-randomization") == 0)
         disable_randomization = 0;
       else if (strcmp (*next_arg, "--once") == 0)
         run_once = 1;
       else
         {
           fprintf (stderr, "Unknown argument: %s\n", *next_arg);
           exit (1);
@@ skipping 10 matching lines @@
     }
 
   port = *next_arg;
   next_arg++;
   if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
     {
       gdbserver_usage (stderr);
       exit (1);
     }
 
+  /* We need to know whether the remote connection is stdio before
+     starting the inferior.  Inferiors created in this scenario have
+     stdin,stdout redirected.  So do this here before we call
+     start_inferior.  */
+  remote_prepare (port);
+
   bad_attach = 0;
   pid = 0;
 
   /* --attach used to come after PORT, so allow it there for
        compatibility.  */
   if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
     {
       attach = 1;
       next_arg++;
     }
@@ skipping 51 matching lines @@
       last_ptid = minus_one_ptid;
     }
 
   /* Don't report shared library events on the initial connection,
      even if some libraries are preloaded.  Avoids the "stopped by
      shared library event" notice on gdb side.  */
   dlls_changed = 0;
 
   if (setjmp (toplevel))
     {
-      detach_or_kill_for_exit ();
+      /* If something fails and longjmps while detaching or killing
+         inferiors, we'd end up here again, stuck in an infinite loop
+         trap.  Be sure that if that happens, we exit immediately
+         instead.  */
+      if (setjmp (toplevel) == 0)
+        detach_or_kill_for_exit ();
+      else
+        fprintf (stderr, "Detach or kill failed.  Exiting\n");
       exit (1);
     }
 
   if (last_status.kind == TARGET_WAITKIND_EXITED
       || last_status.kind == TARGET_WAITKIND_SIGNALLED)
     was_running = 0;
   else
     was_running = 1;
 
   if (!was_running && !multi_mode)
     {
       fprintf (stderr, "No program to debug.  GDBserver exiting.\n");
       exit (1);
     }
 
-  remote_prepare (port);
-
   while (1)
     {
       noack_mode = 0;
       multi_process = 0;
       /* Be sure we're out of tfind mode.  */
       current_traceframe = -1;
 
       remote_open (port);
 
       if (setjmp (toplevel) != 0)
@@ skipping 10 matching lines @@
          removed from the event loop.  */
       start_event_loop ();
 
       /* If an exit was requested (using the "monitor exit" command),
          terminate now.  The only other way to get here is for
          getpkt to fail; close the connection and reopen it at the
          top of the loop.  */
 
       if (exit_requested || run_once)
         {
-          detach_or_kill_for_exit ();
-          exit (0);
+          /* If something fails and longjmps while detaching or
+             killing inferiors, we'd end up here again, stuck in an
+             infinite loop trap.  Be sure that if that happens, we
+             exit immediately instead.  */
+          if (setjmp (toplevel) == 0)
+            {
+              detach_or_kill_for_exit ();
+              exit (0);
+            }
+          else
+            {
+              fprintf (stderr, "Detach or kill failed.  Exiting\n");
+              exit (1);
+            }
         }
 
       fprintf (stderr,
                "Remote side has terminated connection.  "
                "GDBserver will reopen the connection.\n");
 
       if (tracing)
         {
           if (disconnected_tracing)
             {
@@ skipping 15 matching lines @@
           else
             {
               fprintf (stderr,
                        "Disconnected tracing disabled; stopping trace run.\n");
               stop_tracing ();
             }
         }
     }
 }
 
+/* Process options coming from Z packets for *point at address
+   POINT_ADDR.  PACKET is the packet buffer.  *PACKET is updated
+   to point to the first char after the last processed option.  */
+
+static void
+process_point_options (CORE_ADDR point_addr, char **packet)
+{
+  char *dataptr = *packet;
+  int persist;
+
+  /* Check if data has the correct format.  */
+  if (*dataptr != ';')
+    return;
+
+  dataptr++;
+
+  while (*dataptr)
+    {
+      if (*dataptr == ';')
+        ++dataptr;
+
+      if (*dataptr == 'X')
+        {
+          /* Conditional expression.  */
+          fprintf (stderr, "Found breakpoint condition.\n");
+          add_breakpoint_condition (point_addr, &dataptr);
+        }
+      else if (strncmp (dataptr, "cmds:", strlen ("cmds:")) == 0)
+        {
+          dataptr += strlen ("cmds:");
+          if (debug_threads)
+            fprintf (stderr, "Found breakpoint commands %s.\n", dataptr);
+          persist = (*dataptr == '1');
+          dataptr += 2;
+          add_breakpoint_commands (point_addr, &dataptr, persist);
+        }
+      else
+        {
+          /* Unrecognized token, just skip it.  */
+          fprintf (stderr, "Unknown token %c, ignoring.\n",
+                   *dataptr);
+        }
+
+      /* Skip tokens until we find one that we recognize.  */
+      while (*dataptr && *dataptr != 'X' && *dataptr != ';')
+        dataptr++;
+    }
+  *packet = dataptr;
+}
+
 /* Event loop callback that handles a serial event.  The first byte in
    the serial buffer gets us here.  We expect characters to arrive at
    a brisk pace, so we read the rest of the packet with a blocking
    getpkt call.  */
 
 static int
 process_serial_event (void)
 {
   char ch;
   int i = 0;
@@ skipping 40 matching lines @@
 
       if (multi_process)
         {
           i++; /* skip ';' */
           pid = strtol (&own_buf[i], NULL, 16);
         }
       else
         pid =
           ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id);
 
-      if (tracing && disconnected_tracing)
+      if ((tracing && disconnected_tracing) || any_persistent_commands ())
         {
           struct thread_resume resume_info;
           struct process_info *process = find_process_pid (pid);
 
           if (process == NULL)
             {
               write_enn (own_buf);
               break;
             }
 
-          fprintf (stderr,
-                   "Disconnected tracing in effect, "
-                   "leaving gdbserver attached to the process\n");
+          if (tracing && disconnected_tracing)
+            fprintf (stderr,
+                     "Disconnected tracing in effect, "
+                     "leaving gdbserver attached to the process\n");
+
+          if (any_persistent_commands ())
+            fprintf (stderr,
+                     "Persistent commands are present, "
+                     "leaving gdbserver attached to the process\n");
 
           /* Make sure we're in non-stop/async mode, so we we can both
              wait for an async socket accept, and handle async target
              events simultaneously.  There's also no point either in
              having the target stop all threads, when we're going to
              pass signals down without informing GDB.  */
           if (!non_stop)
             {
               if (debug_threads)
                 fprintf (stderr, "Forcing non-stop mode\n");
@@ skipping 180 matching lines @@
       if (decode_X_packet (&own_buf[1], packet_len - 1,
                            &mem_addr, &len, &mem_buf) < 0
           || gdb_write_memory (mem_addr, mem_buf, len) != 0)
         write_enn (own_buf);
       else
         write_ok (own_buf);
       break;
     case 'C':
       require_running (own_buf);
       convert_ascii_to_int (own_buf + 1, &sig, 1);
-      if (target_signal_to_host_p (sig))
-        signal = target_signal_to_host (sig);
+      if (gdb_signal_to_host_p (sig))
+        signal = gdb_signal_to_host (sig);
       else
         signal = 0;
       myresume (own_buf, 0, signal);
       break;
     case 'S':
       require_running (own_buf);
       convert_ascii_to_int (own_buf + 1, &sig, 1);
-      if (target_signal_to_host_p (sig))
-        signal = target_signal_to_host (sig);
+      if (gdb_signal_to_host_p (sig))
+        signal = gdb_signal_to_host (sig);
       else
         signal = 0;
       myresume (own_buf, 1, signal);
       break;
     case 'c':
       require_running (own_buf);
       signal = 0;
       myresume (own_buf, 0, signal);
       break;
     case 's':
@@ skipping 17 matching lines @@
         res = 1;
         switch (type)
           {
           case '0': /* software-breakpoint */
           case '1': /* hardware-breakpoint */
           case '2': /* write watchpoint */
           case '3': /* read watchpoint */
           case '4': /* access watchpoint */
             require_running (own_buf);
             if (insert && the_target->insert_point != NULL)
-              res = (*the_target->insert_point) (type, addr, len);
+              {
+                /* Insert the breakpoint.  If it is already inserted, nothing
+                   will take place.  */
+                res = (*the_target->insert_point) (type, addr, len);
+
+                /* GDB may have sent us a list of *point parameters to be
+                   evaluated on the target's side.  Read such list here.  If we
+                   already have a list of parameters, GDB is telling us to drop
+                   that list and use this one instead.  */
+                if (!res && (type == '0' || type == '1'))
+                  {
+                    /* Remove previous conditions.  */
+                    clear_gdb_breakpoint_conditions (addr);
+                    process_point_options (addr, &dataptr);
+                  }
+              }
             else if (!insert && the_target->remove_point != NULL)
               res = (*the_target->remove_point) (type, addr, len);
             break;
           default:
             break;
           }
 
         if (res == 0)
           write_ok (own_buf);
         else if (res == 1)
@@ skipping 11 matching lines @@
         return 0;
 
       fprintf (stderr, "Killing all inferiors\n");
       for_each_inferior (&all_processes, kill_inferior_callback);
 
       /* When using the extended protocol, we wait with no program
          running.  The traditional protocol will exit instead.  */
       if (extended_protocol)
         {
           last_status.kind = TARGET_WAITKIND_EXITED;
-          last_status.value.sig = TARGET_SIGNAL_KILL;
+          last_status.value.sig = GDB_SIGNAL_KILL;
           return 0;
         }
       else
         exit (0);
 
     case 'T':
       {
         ptid_t gdb_id, thread_id;
 
         require_running (own_buf);
@@ skipping 23 matching lines @@
             for_each_inferior (&all_processes,
                                kill_inferior_callback);
           fprintf (stderr, "GDBserver restarting\n");
 
           /* Wait till we are at 1st instruction in prog.  */
           if (program_argv != NULL)
             start_inferior (program_argv);
           else
             {
               last_status.kind = TARGET_WAITKIND_EXITED;
-              last_status.value.sig = TARGET_SIGNAL_KILL;
+              last_status.value.sig = GDB_SIGNAL_KILL;
             }
           return 0;
         }
       else
         {
           /* It is a request we don't understand.  Respond with an
              empty packet so that gdb knows that we don't support this
              request.  */
           own_buf[0] = '\0';
           break;
@@ skipping 103 matching lines @@
               struct thread_resume resume_info;
 
               if (debug_threads)
                 fprintf (stderr,
                          "GDB not connected; forwarding event %d for [%s]\n",
                          (int) last_status.kind,
                          target_pid_to_str (last_ptid));
 
               resume_info.thread = last_ptid;
               resume_info.kind = resume_continue;
-              resume_info.sig = target_signal_to_host (last_status.value.sig);
+              resume_info.sig = gdb_signal_to_host (last_status.value.sig);
               (*the_target->resume) (&resume_info, 1);
             }
           else if (debug_threads)
             fprintf (stderr, "GDB not connected; ignoring event %d for [%s]\n",
                      (int) last_status.kind,
                      target_pid_to_str (last_ptid));
         }
       else
         {
           /* Something interesting.  Tell GDB about it.  */
           push_event (last_ptid, &last_status);
         }
     }
 
   /* Be sure to not change the selected inferior behind GDB's back.
      Important in the non-stop mode asynchronous protocol.  */
   set_desired_inferior (1);
 
   return 0;
 }