Merge GDB 7.5.1

gdb/remote.c

 /* Remote target communications for serial-line targets in custom GDB protocol
 
    Copyright (C) 1988-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.
@@ skipping 47 matching lines @@
 #include "remote-fileio.h"
 #include "gdb/fileio.h"
 #include "gdb_stat.h"
 #include "xml-support.h"
 
 #include "memory-map.h"
 
 #include "tracepoint.h"
 #include "ax.h"
 #include "ax-gdb.h"
+#include "agent.h"
 
 /* Temp hacks for tracepoint encoding migration.  */
 static char *target_buf;
 static long target_buf_size;
-/*static*/ void
-encode_actions (struct breakpoint *t, struct bp_location *tloc,
-                char ***tdp_actions, char ***stepping_actions);
 
 /* The size to align memory write packets, when practical.  The protocol
    does not guarantee any alignment, and gdb will generate short
    writes and unaligned writes, but even as a best-effort attempt this
    can improve bulk transfers.  For instance, if a write is misaligned
    relative to the target's data bus, the stub may need to make an extra
    round trip fetching data from the target.  This doesn't make a
    huge difference, but it's easy to do, so we try to be helpful.
 
    The alignment chosen is arbitrary; usually data bus width is
@@ skipping 150 matching lines @@
 
 static void remote_async_inferior_event_handler (gdb_client_data);
 static void remote_async_get_pending_events_handler (gdb_client_data);
 
 static void remote_terminal_ours (void);
 
 static int remote_read_description_p (struct target_ops *target);
 
 static void remote_console_output (char *msg);
 
+static int remote_supports_cond_breakpoints (void);
+
+static int remote_can_run_breakpoint_commands (void);
+
 /* The non-stop remote protocol provisions for one pending stop reply.
    This is where we keep it until it is acknowledged.  */
 
 static struct stop_reply *pending_stop_reply = NULL;
 
 /* For "remote".  */
 
 static struct cmd_list_element *remote_cmdlist;
 
 /* For "set remote" and "show remote".  */
@@ skipping 57 matching lines @@
 
   /* True if the stub reports support for non-stop mode.  */
   int non_stop_aware;
 
   /* True if the stub reports support for vCont;t.  */
   int support_vCont_t;
 
   /* True if the stub reports support for conditional tracepoints.  */
   int cond_tracepoints;
 
+  /* True if the stub reports support for target-side breakpoint
+     conditions.  */
+  int cond_breakpoints;
+
+  /* True if the stub reports support for target-side breakpoint
+     commands.  */
+  int breakpoint_commands;
+
   /* True if the stub reports support for fast tracepoints.  */
   int fast_tracepoints;
 
   /* True if the stub reports support for static tracepoints.  */
   int static_tracepoints;
 
   /* True if the stub reports support for installing tracepoint while
      tracing.  */
   int install_in_trace;
 
@@ skipping 24 matching lines @@
 free_private_thread_info (struct private_thread_info *info)
 {
   xfree (info->extra);
   xfree (info);
 }
 
 /* Returns true if the multi-process extensions are in effect.  */
 static int
 remote_multi_process_p (struct remote_state *rs)
 {
-  return rs->extended && rs->multi_process_aware;
+  return rs->multi_process_aware;
 }
 
 /* This data could be associated with a target, but we do not always
    have access to the current target when we need it, so for now it is
    static.  This will be fine for as long as only one target is in use
    at a time.  */
 static struct remote_state remote_state;
 
 static struct remote_state *
 get_remote_state_raw (void)
@@ skipping 95 matching lines @@
           org_to = to;
 
           TRY_CATCH (ex, RETURN_MASK_ALL)
             {
               gdbarch_relocate_instruction (target_gdbarch, &to, from);
             }
           if (ex.reason >= 0)
             {
               adjusted_size = to - org_to;
 
-              sprintf (buf, "qRelocInsn:%x", adjusted_size);
+              xsnprintf (buf, *sizeof_buf, "qRelocInsn:%x", adjusted_size);
               putpkt (buf);
             }
           else if (ex.reason < 0 && ex.error == MEMORY_ERROR)
             {
               /* Propagate memory errors silently back to the target.
                  The stub may have limited the range of addresses we
                  can write to, for example.  */
               putpkt ("E01");
             }
           else
@@ skipping 246 matching lines @@
 
 /* Allow the user to specify what sequence to send to the remote
    when he requests a program interruption: Although ^C is usually
    what remote systems expect (this is the default, here), it is
    sometimes preferable to send a break.  On other systems such
    as the Linux kernel, a break followed by g, which is Magic SysRq g
    is required in order to interrupt the execution.  */
 const char interrupt_sequence_control_c[] = "Ctrl-C";
 const char interrupt_sequence_break[] = "BREAK";
 const char interrupt_sequence_break_g[] = "BREAK-g";
-static const char *interrupt_sequence_modes[] =
+static const char *const interrupt_sequence_modes[] =
   {
     interrupt_sequence_control_c,
     interrupt_sequence_break,
     interrupt_sequence_break_g,
     NULL
   };
 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
 
 static void
 show_interrupt_sequence (struct ui_file *file, int from_tty,
@@ skipping 472 matching lines @@
   PACKET_vCont = 0,
   PACKET_X,
   PACKET_qSymbol,
   PACKET_P,
   PACKET_p,
   PACKET_Z0,
   PACKET_Z1,
   PACKET_Z2,
   PACKET_Z3,
   PACKET_Z4,