Re: [rfc target-side break conditions 3/5 v2] GDB-side changes

[Luis Gustavo <luis_gustavo at mentor dot com>]

On 02/06/2012 06:26 PM, Tom Tromey wrote:
> Second, I was wondering if you have any plans to extend agent
> expressions to provide more coverage for DWARF expressions.  It would be
> somewhat interesting, I think, to get some idea of how often GCC
> generates untranslatable expressions for real code.  (Like, looking at
> all the DWARF expressions in the distro... or at least some big
> libraries.)

Nothing clearly planned for now, but it should be the natural course to 
expand it in order to handle more interesting expressions.

> Luis>  +static const char *condition_evaluation_enums[] = {
>
> After Jan's patch I think you will need another const in there.

Fixed.

> Luis>  +/* Translate a condition evaluation mode MODE into either "gdb"
> Luis>  +   or "target.  This is used mostly to translate from "auto" to the
>
> Missing quote after "target".

Fixed as well.

> Luis>  +  /* Signals that the condition has changed since the last time
> Luis>  +     we updated the global location list.  This means the condition
> Luis>  +     needs to be sent to the target again.  This is used together
> Luis>  +     with target-side breakpoint conditions.
> Luis>  +
> Luis>  +     This field has 3 special values:
> Luis>  +
> Luis>  +     0: It means there has been no condition changes.
> Luis>  +
> Luis>  +     1: It means this location had its condition modified.
> Luis>  +
> Luis>  +     2: It means we already marked all the locations that are duplicates
> Luis>  +     of this location and thus we don't need to call
> Luis>  +     force_breakpoint_reinsertion (...) for this location.  */
> Luis>  +
> Luis>  +  char condition_changed;
>
> How about an enum instead of numerical constants?

That's better. I'm using an enum now and i've updated the other usages 
of condition_changed.

Thanks for the input!

Luis
2012-02-07  Luis Machado  <lgustavo@codesourcery.com>

	* remote.c (remote_supports_cond_breakpoints): New forward
	declaration.
	(remote_add_target_side_condition): New function.
	(remote_insert_breakpoint): Add target-side breakpoint
	conditional if supported.
	(remote_insert_hw_breakpoint): Likewise.
	(init_remote_ops): Set to_supports_breakpoint_condition hook.

	* target.c (update_current_target): Inherit
	to_supports_breakpoint_conditions.
	Default to_supports_breakpoint_conditions to return_zero.

	* target.h (struct target_ops) <to_supports_breakpoint_conditions>:
	New field.
	(target_supports_breakpoint_conditions): New #define.

	* breakpoint.c (get_first_locp_gte_addr): New forward declaration.
	(condition_evaluation_auto,
	condition_evaluation_gdb, condition_evaluation_stub,
	condition_evaluation_enums, condition_evaluation_mode_1,
	condition_evaluation_mode): New	static globals.
	(translate_condition_evaluation_mode): New function.
	(breakpoint_condition_evaluation_mode): New function.
	(gdb_evaluates_breakpoint_condition_p): New function.
	(ALL_BP_LOCATIONS_AT_ADDR): New helper macro.
	(mark_breakpoint_modified): New function.
	(mark_breakpoint_location_modified): New function.
	(set_condition_evaluation_mode): New function.
	(show_condition_evaluation_mode): New function.
	(get_first_location_gte_addr): New helper function.
	(set_breakpoint_condition): Free condition bytecode if locations
	has become unconditional.  Call mark_breakpoint_modified (...).
	(condition_command): Call update_global_location_list (1) for
	breakpoints.
	(breakpoint_xfer_memory): Use is_breakpoint (...).
	(is_breakpoint): New function.
	(parse_cond_to_aexpr): New function.
	(build_target_condition_list): New function.
	(insert_bp_location): Handle target-side conditional
	breakpoints and call build_target_condition_list (...).
	(insert_breakpoint_locations): Handle target-side conditional
	breakpoints.
	(bpstat_check_breakpoint_conditions): Add comment.
	(print_breakpoint_location): Print information on where the condition
	will be evaluated.
	(init_bp_location): Call mark_breakpoint_location_modified (...) for
	breakpoint location.
	(force_breakpoint_reinsertion): New functions.
	(update_global_location_list): Handle target-side breakpoint
	conditions.
	(bp_location_dtor): Free agent expression bytecode.
	(delete_breakpoint): Rename to delete_breakpoint_1, add new update
	parameter and make it static.
	(delete_breakpoint): New function.
	(delete_breakpoint_with_update): New function.
	(do_delete_breakpoint): Call delete_breakpoint_with_update (...) for
	breakpoints.
	(delete_command): Call do_delete_breakpoint (...) instead of
	delete_breakpoint (...).
	(disable_breakpoint): Call mark_breakpoint_modified (...).
	Call update_global_location_list (...) with parameter 1 for breakpoints.
	(disable_command): Call mark_breakpoint_location_modified (...).
	Call update_global_location_list (...) with parameter 1 for breakpoints.
	(enable_breakpoint_disp): Call mark_breakpoint_modified (...).
	(enable_command): mark_breakpoint_location_modified (...).
	(_initialize_breakpoint): Update documentation and add
	condition-evaluation breakpoint subcommand.

	* breakpoint.h: Include ax.h.
	(condition_list): New data structure.
	(condition_status): New enum.
	(bp_target_info) <cond_list>: New field.
	(bp_location) <condition_changed, cond_bytecode>: New fields.
	(is_breakpoint): New prototype.

Index: gdb/gdb/remote.c
===================================================================
--- gdb.orig/gdb/remote.c	2012-02-06 22:57:38.000000000 -0200
+++ gdb/gdb/remote.c	2012-02-06 22:58:04.529895001 -0200
@@ -242,6 +242,8 @@ static int remote_read_description_p (st
 
 static void remote_console_output (char *msg);
 
+static int remote_supports_cond_breakpoints (void);
+
 /* The non-stop remote protocol provisions for one pending stop reply.
    This is where we keep it until it is acknowledged.  */
 
@@ -7720,6 +7722,47 @@ extended_remote_create_inferior (struct
 }
 
 
+/* Given a location's target info BP_TGT and the packet buffer BUF,  output
+   the list of conditions (in agent expression bytecode format), if any, the
+   target needs to evaluate.  The output is placed into the packet buffer
+   BUF.  */
+
+static int
+remote_add_target_side_condition (struct gdbarch *gdbarch,
+				  struct bp_target_info *bp_tgt, char *buf)
+{
+  struct agent_expr *aexpr = NULL;
+  int i, ix;
+  char *pkt;
+  char *buf_start = buf;
+
+  if (VEC_length (agent_expr_p, bp_tgt->conditions))
+    {
+      sprintf (buf + strlen (buf), "%s", ",conditions=");
+    }
+  else
+    return 0;
+
+  /* Send conditions to the target and free the vector.  */
+  for (ix = 0;
+       VEC_iterate (agent_expr_p, bp_tgt->conditions, ix, aexpr);
+       ix++)
+    {
+      sprintf (buf + strlen (buf), "X%x,", aexpr->len);
+      pkt = buf + strlen (buf);
+      for (i = 0; i < aexpr->len; ++i)
+	pkt = pack_hex_byte (pkt, aexpr->buf[i]);
+      *pkt++ = ';';
+      *pkt = '\0';
+    }
+
+  pkt--;
+  *pkt = '\0';
+
+  VEC_free (agent_expr_p, bp_tgt->conditions);
+  return 0;
+}
+
 /* Insert a breakpoint.  On targets that have software breakpoint
    support, we ask the remote target to do the work; on targets
    which don't, we insert a traditional memory breakpoint.  */
@@ -7739,6 +7782,7 @@ remote_insert_breakpoint (struct gdbarch
       struct remote_state *rs;
       char *p;
       int bpsize;
+      struct condition_list *cond = NULL;
 
       gdbarch_remote_breakpoint_from_pc (gdbarch, &addr, &bpsize);
 
@@ -7752,6 +7796,9 @@ remote_insert_breakpoint (struct gdbarch
       p += hexnumstr (p, addr);
       sprintf (p, ",%d", bpsize);
 
+      if (remote_supports_cond_breakpoints ())
+	remote_add_target_side_condition (gdbarch, bp_tgt, p);
+
       putpkt (rs->buf);
       getpkt (&rs->buf, &rs->buf_size, 0);
 
@@ -7977,6 +8024,9 @@ remote_insert_hw_breakpoint (struct gdba
   p += hexnumstr (p, (ULONGEST) addr);
   sprintf (p, ",%x", bp_tgt->placed_size);
 
+  if (remote_supports_cond_breakpoints ())
+    remote_add_target_side_condition (gdbarch, bp_tgt, p);
+
   putpkt (rs->buf);
   getpkt (&rs->buf, &rs->buf_size, 0);
 
@@ -10770,6 +10820,7 @@ Specify the serial device it is connecte
   remote_ops.to_fileio_readlink = remote_hostio_readlink;
   remote_ops.to_supports_enable_disable_tracepoint = remote_supports_enable_disable_tracepoint;
   remote_ops.to_supports_string_tracing = remote_supports_string_tracing;
+  remote_ops.to_supports_breakpoint_conditions = remote_supports_cond_breakpoints;
   remote_ops.to_trace_init = remote_trace_init;
   remote_ops.to_download_tracepoint = remote_download_tracepoint;
   remote_ops.to_can_download_tracepoint = remote_can_download_tracepoint;
Index: gdb/gdb/target.c
===================================================================
--- gdb.orig/gdb/target.c	2012-02-06 22:54:54.000000000 -0200
+++ gdb/gdb/target.c	2012-02-06 22:58:04.533895001 -0200
@@ -699,6 +699,7 @@ update_current_target (void)
       INHERIT (to_static_tracepoint_markers_by_strid, t);
       INHERIT (to_traceframe_info, t);
       INHERIT (to_magic, t);
+      INHERIT (to_supports_breakpoint_conditions, t);
       /* Do not inherit to_memory_map.  */
       /* Do not inherit to_flash_erase.  */
       /* Do not inherit to_flash_done.  */
@@ -925,6 +926,9 @@ update_current_target (void)
   de_fault (to_traceframe_info,
 	    (struct traceframe_info * (*) (void))
 	    tcomplain);
+  de_fault (to_supports_breakpoint_conditions,
+	    (int (*) (void))
+	    return_zero);
   de_fault (to_execution_direction, default_execution_direction);
 
 #undef de_fault
Index: gdb/gdb/target.h
===================================================================
--- gdb.orig/gdb/target.h	2012-02-06 22:54:54.000000000 -0200
+++ gdb/gdb/target.h	2012-02-06 22:58:04.533895001 -0200
@@ -662,6 +662,9 @@ struct target_ops
     /* Does this target support the tracenz bytecode for string collection?  */
     int (*to_supports_string_tracing) (void);
 
+    /* Does this target support evaluation breakpoint conditions on its end?  */
+    int (*to_supports_breakpoint_conditions) (void);
+
     /* Determine current architecture of thread PTID.
 
        The target is supposed to determine the architecture of the code where
@@ -968,6 +971,12 @@ int target_supports_disable_randomizatio
 #define target_supports_string_tracing() \
   (*current_target.to_supports_string_tracing) ()
 
+/* Returns true if this target can handle breakpoint conditions
+   on its end.  */
+
+#define target_supports_breakpoint_conditions() \
+  (*current_target.to_supports_breakpoint_conditions) ()
+
 /* Invalidate all target dcaches.  */
 extern void target_dcache_invalidate (void);
 
Index: gdb/gdb/breakpoint.c
===================================================================
--- gdb.orig/gdb/breakpoint.c	2012-02-06 22:57:25.000000000 -0200
+++ gdb/gdb/breakpoint.c	2012-02-07 00:02:02.121895001 -0200
@@ -66,6 +66,7 @@
 #include "skip.h"
 #include "record.h"
 #include "gdb_regex.h"
+#include "ax-gdb.h"
 
 /* readline include files */
 #include "readline/readline.h"
@@ -255,6 +256,8 @@ static void trace_pass_command (char *,
 
 static int is_masked_watchpoint (const struct breakpoint *b);
 
+static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
+
 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
    otherwise.  */
 
@@ -403,6 +406,62 @@ breakpoints_always_inserted_mode (void)
 	  && !RECORD_IS_USED);
 }
 
+/* Modes for breakpoint condition evaluation.  */
+static const char condition_evaluation_auto[] = "auto";
+static const char condition_evaluation_gdb[] = "gdb";
+static const char condition_evaluation_target[] = "target";
+static const char *const condition_evaluation_enums[] = {
+  condition_evaluation_auto,
+  condition_evaluation_gdb,
+  condition_evaluation_target,
+  NULL
+};
+
+/* Global that holds the current mode for breakpoint condition evaluation.  */
+static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
+
+/* Global that we use to display information to the user (gets its value from
+   condition_evaluation_mode_1.  */
+static const char *condition_evaluation_mode = condition_evaluation_auto;
+
+/* Translate a condition evaluation mode MODE into either "gdb"
+   or "target".  This is used mostly to translate from "auto" to the
+   real setting that is being used.  It returns the translated
+   evaluation mode.  */
+
+static const char *
+translate_condition_evaluation_mode (const char *mode)
+{
+  if (mode == condition_evaluation_auto)
+    {
+      if (target_supports_breakpoint_conditions ())
+	return condition_evaluation_target;
+      else
+	return condition_evaluation_gdb;
+    }
+  else
+    return mode;
+}
+
+/* Discovers what condition_evaluation_auto translates to.  */
+
+static const char *
+breakpoint_condition_evaluation_mode (void)
+{
+  return translate_condition_evaluation_mode (condition_evaluation_mode);
+}
+
+/* Return true if GDB should evaluate breakpoint conditions or false
+   otherwise.  */
+
+static int
+gdb_evaluates_breakpoint_condition_p (void)
+{
+  const char *mode = breakpoint_condition_evaluation_mode ();
+
+  return (mode == condition_evaluation_gdb);
+}
+
 void _initialize_breakpoint (void);
 
 /* Are we executing breakpoint commands?  */
@@ -434,6 +493,20 @@ int target_exact_watchpoints = 0;
 	     BP_TMP < bp_location + bp_location_count && (B = *BP_TMP);	\
 	     BP_TMP++)
 
+/* Iterates through locations with address ADDRESS for the currently selected
+   program space.  BP_LOCP_TMP points to each object.  BP_LOCP_START points
+   to where the loop should start from.
+   If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
+   appropriate location to start with.  */
+
+#define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS)	\
+	if (!BP_LOCP_START)						\
+	  BP_LOCP_START = get_first_locp_gte_addr (ADDRESS);		\
+	for (BP_LOCP_TMP = BP_LOCP_START;				\
+	     (BP_LOCP_TMP < bp_location + bp_location_count		\
+	     && (*BP_LOCP_TMP)->address == ADDRESS);			\
+	     BP_LOCP_TMP++)
+
 /* Iterator for tracepoints only.  */
 
 #define ALL_TRACEPOINTS(B)  \
@@ -617,6 +690,146 @@ get_breakpoint (int num)
 
 
 
+/* Mark locations as "conditions have changed" in case
+   the target supports evaluating conditions on
+   its side.  */
+
+static void
+mark_breakpoint_modified (struct breakpoint *b)
+{
+  struct bp_location *loc;
+
+  /* This is only meaningful if the target is
+     evaluating conditions and if the user has
+     opted for condition evaluation on the target's
+     side.  */
+  if (gdb_evaluates_breakpoint_condition_p ()
+      || !target_supports_breakpoint_conditions ())
+    return;
+
+  if (!is_breakpoint (b))
+    return;
+
+  for (loc = b->loc; loc; loc = loc->next)
+    loc->condition_changed = condition_modified;
+}
+
+/* Mark location as "conditions have changed" in case
+   the target supports evaluating conditions on
+   its side.  */
+
+static void
+mark_breakpoint_location_modified (struct bp_location *loc)
+{
+  /* This is only meaningful if the target is
+     evaluating conditions and if the user has
+     opted for condition evaluation on the target's
+     side.  */
+  if (gdb_evaluates_breakpoint_condition_p ()
+      || !target_supports_breakpoint_conditions ())
+
+    return;
+
+  if (!is_breakpoint (loc->owner))
+    return;
+
+  loc->condition_changed = condition_modified;
+}
+
+/* Sets the condition-evaluation mode using the static global
+   condition_evaluation_mode.  */
+
+static void
+set_condition_evaluation_mode (char *args, int from_tty,
+			       struct cmd_list_element *c)
+{
+  struct breakpoint *b;
+  const char *old_mode, *new_mode;
+
+  if ((condition_evaluation_mode_1 == condition_evaluation_target)
+      && !target_supports_breakpoint_conditions ())
+    {
+      condition_evaluation_mode_1 = condition_evaluation_mode;
+      warning (_("Target does not support condition evaluation.\n"
+		 "Using GDB evaluation mode instead."));
+      return;
+    }
+
+  new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
+  old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
+
+  /* Only update the mode if the user picked a different one.  */
+  if (new_mode != old_mode)
+    {
+      struct bp_location *loc, **loc_tmp;
+      /* If the user switched to a different evaluation mode, we
+	 need to synch the changes with the target as follows:
+
+	 "gdb" -> "target": Send all (valid) conditions to the target.
+	 "target" -> "gdb": Remove all the conditions from the target.
+      */
+
+      /* Flip the switch.  */
+      condition_evaluation_mode = condition_evaluation_mode_1;
+
+      if (new_mode == condition_evaluation_target)
+	{
+	  /* Mark everything modified and to synch conditions with the
+	     target.  */
+	  ALL_BP_LOCATIONS (loc, loc_tmp)
+	    mark_breakpoint_location_modified (loc);
+  	}
+      else
+	{
+	  /* Manually mark non-duplicate locations to synch conditions
+	     with the target.  We do this to remove all the conditions the
+	     target knows about.  */
+	  ALL_BP_LOCATIONS (loc, loc_tmp)
+	    if (is_breakpoint (loc->owner) && loc->inserted)
+	      loc->needs_update = 1;
+	}
+
+      /* Do the update.  */
+      update_global_location_list (1);
+    }
+
+  return;
+}
+
+/* Shows the current mode of breakpoint condition evaluation.  Explicitly shows
+   what "auto" is translating to.  */
+
+static void
+show_condition_evaluation_mode (struct ui_file *file, int from_tty,
+				struct cmd_list_element *c, const char *value)
+{
+  if (condition_evaluation_mode == condition_evaluation_auto)
+    fprintf_filtered (file,
+		      _("Breakpoint condition evaluation "
+			"mode is %s (currently %s).\n"),
+		      value,
+		      breakpoint_condition_evaluation_mode ());
+  else
+    fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
+		      value);
+}
+
+/* Helper function to skip all bp_locations with addresses
+   less than ADDRESS.  It returns the first bp_location that
+   is greater than or equal to ADDRESS.  */
+
+static struct bp_location **
+get_first_locp_gte_addr (CORE_ADDR address)
+{
+  struct bp_location **locp = bp_location;
+
+  while (locp < bp_location + bp_location_count
+	 && (*locp)->address < address)
+    locp++;
+
+  return locp;
+}
+
 void
 set_breakpoint_condition (struct breakpoint *b, char *exp,
 			  int from_tty)
@@ -639,6 +852,10 @@ set_breakpoint_condition (struct breakpo
 	{
 	  xfree (loc->cond);
 	  loc->cond = NULL;
+
+	  /* No need to free the condition agent expression
+	     bytecode (if we have one).  We will handle this
+	     when we go through update_global_location_list (...).  */
 	}
     }
 
@@ -681,6 +898,8 @@ set_breakpoint_condition (struct breakpo
 	    }
 	}
     }
+  mark_breakpoint_modified (b);
+
   breakpoints_changed ();
   observer_notify_breakpoint_modified (b);
 }
@@ -714,6 +933,10 @@ condition_command (char *arg, int from_t
 	  error (_("Cannot set a condition where a Python 'stop' "
 		   "method has been defined in the breakpoint."));
 	set_breakpoint_condition (b, p, from_tty);
+
+	if (is_breakpoint (b))
+	  update_global_location_list (1);
+
 	return;
       }
 
@@ -1213,6 +1436,16 @@ breakpoint_xfer_memory (gdb_byte *readbu
 }
 
 
+/* Return true if BPT is of any breakpoint kind, hardware or
+   software.  */
+
+int
+is_breakpoint (const struct breakpoint *bpt)
+{
+  return (bpt->type == bp_breakpoint
+	  || bpt->type == bp_hardware_breakpoint);
+}
+
 /* Return true if BPT is of any hardware watchpoint kind.  */
 
 static int
@@ -1655,6 +1888,143 @@ unduplicated_should_be_inserted (struct
   return result;
 }
 
+/* Parses a conditional described by an expression COND into an
+   agent expression bytecode suitable for evaluation
+   by the bytecode interpreter.  Return NULL if there was
+   any error during parsing.  */
+
+static struct agent_expr *
+parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
+{
+  struct agent_expr *aexpr = NULL;
+  struct cleanup *old_chain = NULL;
+  volatile struct gdb_exception ex;
+
+  if (!cond)
+    return NULL;
+
+  /* We don't want to stop processing, so catch any errors
+     that may show up.  */
+  TRY_CATCH (ex, RETURN_MASK_ERROR)
+    {
+      aexpr = gen_eval_for_expr (scope, cond);
+    }
+
+  if (ex.reason < 0)
+    {
+      /* If we got here, it means the condition could not be parse to a valid
+	 bytecode expression and thus can't be evaluated on the target's side.
+	 It's no use iterating through the conditions.  */
+      return NULL;
+    }
+
+  /* We have a valid agent expression.  */
+  return aexpr;
+}
+
+/* Based on location BL, create a list of breakpoint conditions to be
+   passed on to the target.  If we have duplicated locations with different
+   conditions, we will add such conditions to the list.  The idea is that the
+   target will evaluate the list of conditions and will only notify GDB when
+   one of them is true.  */
+
+static void
+build_target_condition_list (struct bp_location *bl)
+{
+  struct bp_location **locp = NULL, **loc2p;
+  int null_condition_or_parse_error = 0;
+  int modified = bl->needs_update;
+  struct bp_location *loc;
+
+  /* This is only meaningful if the target is
+     evaluating conditions and if the user has
+     opted for condition evaluation on the target's
+     side.  */
+  if (gdb_evaluates_breakpoint_condition_p ()
+      || !target_supports_breakpoint_conditions ())
+    return;
+
+  /* Do a first pass to check for locations with no assigned
+     conditions or conditions that fail to parse to a valid agent expression
+     bytecode.  If any of these happen, then it's no use to send conditions
+     to the target since this location will always trigger and generate a
+     response back to GDB.  */
+  ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
+    {
+      loc = (*loc2p);
+      if (is_breakpoint (loc->owner) && loc->pspace == bl->pspace)
+	{
+	  if (modified)
+	    {
+	      struct agent_expr *aexpr;
+
+	      /* Re-parse the conditions since something changed.  In that
+		 case we already freed the condition bytecodes (see
+		 force_breakpoint_reinsertion).  We just
+		 need to parse the condition to bytecodes again.  */
+	      aexpr = parse_cond_to_aexpr (bl->address, loc->cond);
+	      loc->cond_bytecode = aexpr;
+
+	      /* Check if we managed to parse the conditional expression
+		 correctly.  If not, we will not send this condition
+		 to the target.  */
+	      if (aexpr)
+		continue;
+	    }
+
+	  /* If we have a NULL bytecode expression, it means something
+	     went wrong or we have a null condition expression.  */
+	  if (!loc->cond_bytecode)
+	    {
+	      null_condition_or_parse_error = 1;
+	      break;
+	    }
+	}
+    }
+
+  /* If any of these happened, it means we will have to evaluate the conditions
+     for the location's address on gdb's side.  It is no use keeping bytecodes
+     for all the other duplicate locations, thus we free all of them here.
+
+     This is so we have a finer control over which locations' conditions are
+     being evaluated by GDB or the remote stub.  */
+  if (null_condition_or_parse_error)
+    {
+      ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
+	{
+	  loc = (*loc2p);
+	  if (is_breakpoint (loc->owner) && loc->pspace == bl->pspace)
+	    {
+	      /* Only go as far as the first NULL bytecode is
+		 located.  */
+	      if (!loc->cond_bytecode)
+		return;
+
+	      free_agent_expr (loc->cond_bytecode);
+	      loc->cond_bytecode = NULL;
+	    }
+	}
+    }
+
+  /* No NULL conditions or failed bytecode generation.  Build a condition list
+     for this location's address.  */
+  ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
+    {
+      loc = (*loc2p);
+      if (loc->cond
+	  && is_breakpoint (loc->owner)
+	  && loc->pspace == bl->pspace
+	  && loc->owner->enable_state == bp_enabled
+	  && loc->enabled)
+	/* Add the condition to the vector.  This will be used later to send the
+	   conditions to the target.  */
+	VEC_safe_push (agent_expr_p, bl->target_info.conditions,
+		       loc->cond_bytecode);
+    }
+
+  return;
+}
+
 /* Insert a low-level "breakpoint" of some type.  BL is the breakpoint
    location.  Any error messages are printed to TMP_ERROR_STREAM; and
    DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
@@ -1671,7 +2041,7 @@ insert_bp_location (struct bp_location *
 {
   int val = 0;
 
-  if (!should_be_inserted (bl) || bl->inserted)
+  if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
     return 0;
 
   /* Initialize the target-specific information.  */
@@ -1680,6 +2050,18 @@ insert_bp_location (struct bp_location *
   bl->target_info.placed_address_space = bl->pspace->aspace;
   bl->target_info.length = bl->length;
 
+  /* When working with target-side conditions, we must pass all the conditions
+     for the same breakpoint address down to the target since GDB will not
+     insert those locations.  With a list of breakpoint conditions, the target
+     can decide when to stop and notify GDB.  */
+
+  if (is_breakpoint (bl->owner))
+    {
+      build_target_condition_list (bl);
+      /* Reset the condition modification marker.  */
+      bl->needs_update = 0;
+    }
+
   if (bl->loc_type == bp_loc_software_breakpoint
       || bl->loc_type == bp_loc_hardware_breakpoint)
     {
@@ -2011,7 +2393,7 @@ insert_breakpoint_locations (void)
 
   ALL_BP_LOCATIONS (bl, blp_tmp)
     {
-      if (!should_be_inserted (bl) || bl->inserted)
+      if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
 	continue;
 
       /* There is no point inserting thread-specific breakpoints if
@@ -4089,6 +4471,10 @@ bpstat_check_breakpoint_conditions (bpst
   b = bs->breakpoint_at;
   gdb_assert (b != NULL);
 
+  /* Even if the target evaluated the condition on its end and notified GDB, we
+     need to do so again since GDB does not know if we stopped due to a
+     breakpoint or a single step breakpoint.  */
+
   if (frame_id_p (b->frame_id)
       && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
     bs->stop = 0;
@@ -4722,6 +5108,18 @@ print_breakpoint_location (struct breakp
   else
     ui_out_field_string (uiout, "pending", b->addr_string);
 
+  /* Print whether the target is doing the breakpoint's condition
+     evaluation.  If GDB is doing the evaluation, don't print anything.  */
+  if (is_breakpoint (b) && loc && loc->cond_bytecode
+      && (breakpoint_condition_evaluation_mode ()
+      != condition_evaluation_gdb))
+    {
+      ui_out_text (uiout, " (");
+      ui_out_field_string (uiout, "evaluated-by",
+			   breakpoint_condition_evaluation_mode ());
+      ui_out_text (uiout, " evaluates conditions)");
+    }
+
   do_cleanups (old_chain);
 }
 
@@ -5709,6 +6107,7 @@ init_bp_location (struct bp_location *lo
   loc->ops = ops;
   loc->owner = owner;
   loc->cond = NULL;
+  loc->cond_bytecode = NULL;
   loc->shlib_disabled = 0;
   loc->enabled = 1;
 
@@ -5736,9 +6135,11 @@ init_bp_location (struct bp_location *lo
     case bp_gnu_ifunc_resolver:
     case bp_gnu_ifunc_resolver_return:
       loc->loc_type = bp_loc_software_breakpoint;
+      mark_breakpoint_location_modified (loc);
       break;
     case bp_hardware_breakpoint:
       loc->loc_type = bp_loc_hardware_breakpoint;
+      mark_breakpoint_location_modified (loc);
       break;
     case bp_hardware_watchpoint:
     case bp_read_watchpoint:
@@ -10685,6 +11086,7 @@ swap_insertion (struct bp_location *left
 {
   const int left_inserted = left->inserted;
   const int left_duplicate = left->duplicate;
+  const int left_needs_update = left->needs_update;
   const struct bp_target_info left_target_info = left->target_info;
 
   /* Locations of tracepoints can never be duplicated.  */
@@ -10695,12 +11097,67 @@ swap_insertion (struct bp_location *left
 
   left->inserted = right->inserted;
   left->duplicate = right->duplicate;
+  left->needs_update = right->needs_update;
   left->target_info = right->target_info;
   right->inserted = left_inserted;
   right->duplicate = left_duplicate;
+  right->needs_update = left_needs_update;
   right->target_info = left_target_info;
 }
 
+/* Force the re-insertion of the locations at ADDRESS.  This is called
+   once a new/deleted/modified duplicate location is found and we are evaluating
+   conditions on the target's side.  Such conditions need to be updated on
+   the target.  */
+
+static void
+force_breakpoint_reinsertion (struct bp_location *bl)
+{
+  struct bp_location **locp = NULL, **loc2p;
+  struct bp_location *loc;
+  CORE_ADDR address = 0;
+  struct program_space *pspace = NULL;
+
+  address = bl->address;
+  pspace = bl->pspace;
+
+  /* This is only meaningful if the target is
+     evaluating conditions and if the user has
+     opted for condition evaluation on the target's
+     side.  */
+  if (gdb_evaluates_breakpoint_condition_p ()
+      && !target_supports_breakpoint_conditions ())
+    return;
+
+  /* Flag all breakpoint locations with this address and
+     the same program space as the location
+     as "its condition has changed".  We need to
+     update the conditions on the target's side.  */
+  ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
+    {
+      loc = *loc2p;
+
+      if (!is_breakpoint (loc->owner)
+	  || pspace != loc->pspace)
+	continue;
+
+      /* Flag the location appropriately.  We use a different number to
+	 let everyone know that we already updated the set of locations
+	 with addr bl->address and program space bl->pspace.  This is so
+	 we don't have to keep calling this functions just to mark locations
+	 that have already been marked.  */
+      loc->condition_changed = condition_updated;
+
+      /* Free the agent expression bytecode as well.  We will compute
+	 it later on.  */
+      if (loc->cond_bytecode)
+	{
+	  free_agent_expr (loc->cond_bytecode);
+	  loc->cond_bytecode = NULL;
+	}
+    }
+}
+
 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
    into the inferior, only remove already-inserted locations that no
    longer should be inserted.  Functions that delete a breakpoint or
@@ -10722,6 +11179,10 @@ update_global_location_list (int should_
   struct breakpoint *b;
   struct bp_location **locp, *loc;
   struct cleanup *cleanups;
+  /* Last breakpoint location address that was marked for update.  */
+  CORE_ADDR last_addr = 0;
+  /* Last breakpoint location program space that was marked for updated.  */
+  struct program_space *last_pspace = NULL;
 
   /* Used in the duplicates detection below.  When iterating over all
      bp_locations, points to the first bp_location of a given address.
@@ -10795,13 +11256,27 @@ update_global_location_list (int should_
 	    && (*loc2p)->address == old_loc->address);
 	   loc2p++)
 	{
+	  /* Check if this is a new/duplicated location or a duplicated
+	     location that had its condition modified.  If so, we want to send
+	     its condition to the target if evaluation of conditions is taking
+	     place there.  */
+
+	  if ((*loc2p)->condition_changed == condition_modified
+	      && last_addr != old_loc->address)
+	    force_breakpoint_reinsertion ((*loc2p));
+
 	  if (*loc2p == old_loc)
-	    {
-	      found_object = 1;
-	      break;
-	    }
+	    found_object = 1;
 	}
 
+      /* We have already handled this address, update it so that we don't
+	 have to go through updates again.  */
+      last_addr = old_loc->address;
+
+      /* Target-side condition evaluation: Handle deleted locations.  */
+      if (!found_object)
+	force_breakpoint_reinsertion (old_loc);
+
       /* If this location is no longer present, and inserted, look if
 	 there's maybe a new location at the same address.  If so,
 	 mark that one inserted, and don't remove this one.  This is
@@ -10821,6 +11296,10 @@ update_global_location_list (int should_
 	    }
 	  else
 	    {
+	      /* This location still exists, but it won't be kept in the
+		 target since it may have been disabled.  We proceed to
+		 remove its target-side condition.  */
+
 	      /* The location is either no longer present, or got
 		 disabled.  See if there's another location at the
 		 same address, in which case we don't need to remove
@@ -10988,7 +11467,11 @@ update_global_location_list (int should_
 		 are never duplicated.  See the comments in field `duplicate' of
 	   `	 struct bp_location'.  */
 	      || is_tracepoint (b))
-	    continue;
+	    {
+	      /* Clear the condition modification flag.  */
+	      loc->condition_changed = condition_unchanged;
+	      continue;
+	    }
 
 	  /* Permanent breakpoint should always be inserted.  */
 	  if (b->enable_state == bp_permanent && ! loc->inserted)
@@ -11011,6 +11494,13 @@ update_global_location_list (int should_
 	    {
 	      *loc_first_p = loc;
 	      loc->duplicate = 0;
+
+	      if (is_breakpoint (loc->owner) && loc->condition_changed)
+		{
+		  loc->needs_update = 1;
+		  /* Clear the condition modification flag.  */
+		  loc->condition_changed = condition_unchanged;
+		}
 	      continue;
 	    }
 
@@ -11021,6 +11511,9 @@ update_global_location_list (int should_
 	    swap_insertion (loc, *loc_first_p);
 	  loc->duplicate = 1;
 
+	  /* Clear the condition modification flag.  */
+	  loc->condition_changed = condition_unchanged;
+
 	  if ((*loc_first_p)->owner->enable_state == bp_permanent
 	      && loc->inserted
 	      && b->enable_state != bp_permanent)
@@ -11147,6 +11640,8 @@ static void
 bp_location_dtor (struct bp_location *self)
 {
   xfree (self->cond);
+  if (self->cond_bytecode)
+    free_agent_expr (self->cond_bytecode);
   xfree (self->function_name);
   xfree (self->source_file);
 }
@@ -11870,10 +12365,11 @@ strace_marker_p (struct breakpoint *b)
 }
 
 /* Delete a breakpoint and clean up all traces of it in the data
-   structures.  */
+   structures.  If UPDATE is true, proceed to update the list of
+   locations, otherwise don't update it.  */
 
-void
-delete_breakpoint (struct breakpoint *bpt)
+static void
+delete_breakpoint_1 (struct breakpoint *bpt, int update)
 {
   struct breakpoint *b;
 
@@ -11955,8 +12451,12 @@ delete_breakpoint (struct breakpoint *bp
      belong to this breakpoint.  Do this before freeing the breakpoint
      itself, since remove_breakpoint looks at location's owner.  It
      might be better design to have location completely
-     self-contained, but it's not the case now.  */
-  update_global_location_list (0);
+     self-contained, but it's not the case now.
+
+     If we have conditions being evaluated on the target, we will also
+     synchronize the list of conditions due to a deleted duplicate
+     breakpoint.  */
+  update_global_location_list (update);
 
   bpt->ops->dtor (bpt);
   /* On the chance that someone will soon try again to delete this
@@ -11965,6 +12465,24 @@ delete_breakpoint (struct breakpoint *bp
   xfree (bpt);
 }
 
+/* Delete a breakpoint but don't update the list of locations.  */
+
+void
+delete_breakpoint (struct breakpoint *bpt)
+{
+  delete_breakpoint_1 (bpt, 0);
+}
+
+/* Delete a breakpoint and update the list of locations.  We use
+   this one to synchronize the list of conditions with the target
+   in case the target is responsible for evaluating them.  */
+
+void
+delete_breakpoint_with_update (struct breakpoint *bpt)
+{
+  delete_breakpoint_1 (bpt, 1);
+}
+
 static void
 do_delete_breakpoint_cleanup (void *b)
 {
@@ -12017,7 +12535,10 @@ iterate_over_related_breakpoints (struct
 static void
 do_delete_breakpoint (struct breakpoint *b, void *ignore)
 {
-  delete_breakpoint (b);
+  if (is_breakpoint (b))
+    delete_breakpoint_with_update (b);
+  else
+    delete_breakpoint (b);
 }
 
 /* A callback for map_breakpoint_numbers that calls
@@ -12056,7 +12577,7 @@ delete_command (char *arg, int from_tty)
 	{
 	  ALL_BREAKPOINTS_SAFE (b, b_tmp)
 	    if (user_breakpoint_p (b))
-	      delete_breakpoint (b);
+	      do_delete_breakpoint (b, NULL);
 	}
     }
   else
@@ -12840,6 +13361,9 @@ disable_breakpoint (struct breakpoint *b
 
   bpt->enable_state = bp_disabled;
 
+  /* Mark breakpoint locations modified.  */
+  mark_breakpoint_modified (bpt);
+
   if (target_supports_enable_disable_tracepoint ()
       && current_trace_status ()->running && is_tracepoint (bpt))
     {
@@ -12849,7 +13373,10 @@ disable_breakpoint (struct breakpoint *b
 	target_disable_tracepoint (location);
     }
 
-  update_global_location_list (0);
+  if (is_breakpoint (bpt))
+    update_global_location_list (1);
+  else
+    update_global_location_list (0);
 
   observer_notify_breakpoint_modified (bpt);
 }
@@ -12887,13 +13414,20 @@ disable_command (char *args, int from_tt
       struct bp_location *loc = find_location_by_number (args);
       if (loc)
 	{
-	  loc->enabled = 0;
+	  if (loc->enabled)
+	    {
+	      loc->enabled = 0;
+	      mark_breakpoint_location_modified (loc);
+	    }
 	  if (target_supports_enable_disable_tracepoint ()
 	      && current_trace_status ()->running && loc->owner
 	      && is_tracepoint (loc->owner))
 	    target_disable_tracepoint (loc);
 	}
-      update_global_location_list (0);
+      if (loc && is_breakpoint (loc->owner))
+	update_global_location_list (1);
+      else
+	update_global_location_list (0);
     }
   else
     map_breakpoint_numbers (args, do_map_disable_breakpoint, NULL);
@@ -12943,6 +13477,11 @@ enable_breakpoint_disp (struct breakpoin
   if (bpt->enable_state != bp_permanent)
     bpt->enable_state = bp_enabled;
 
+  bpt->enable_state = bp_enabled;
+
+  /* Mark breakpoint locations modified.  */
+  mark_breakpoint_modified (bpt);
+
   if (target_supports_enable_disable_tracepoint ()
       && current_trace_status ()->running && is_tracepoint (bpt))
     {
@@ -13001,7 +13540,11 @@ enable_command (char *args, int from_tty
       struct bp_location *loc = find_location_by_number (args);
       if (loc)
 	{
-	  loc->enabled = 1;
+	  if (!loc->enabled)
+	    {
+	      loc->enabled = 1;
+	      mark_breakpoint_location_modified (loc);
+	    }
 	  if (target_supports_enable_disable_tracepoint ()
 	      && current_trace_status ()->running && loc->owner
 	      && is_tracepoint (loc->owner))
@@ -14405,8 +14948,9 @@ The \"Type\" column indicates one of:\n\
 \twatchpoint     - watchpoint\n\
 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
-breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate\n\
+the address and file/line number respectively.  The \"Cond Eval\" column\n\
+indicates where the breakpoint condition will be evaluated.\n\
 \n\
 Convenience variable \"$_\" and default examine address for \"x\"\n\
 are set to the address of the last breakpoint listed unless the command\n\
@@ -14422,8 +14966,9 @@ The \"Type\" column indicates one of:\n\
 \twatchpoint     - watchpoint\n\
 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
-breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate\n\
+the address and file/line number respectively.  The \"Cond Eval\" column\n\
+indicates where the breakpoint condition will be evaluated.\n\
 \n\
 Convenience variable \"$_\" and default examine address for \"x\"\n\
 are set to the address of the last breakpoint listed unless the command\n\
@@ -14441,8 +14986,9 @@ The \"Type\" column indicates one of:\n\
 \twatchpoint     - watchpoint\n\
 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
-breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate\n\
+the address and file/line number respectively.  The \"Cond Eval\" column\n\
+indicates where the breakpoint condition will be evaluated.\n\
 \n\
 Convenience variable \"$_\" and default examine address for \"x\"\n\
 are set to the address of the last breakpoint listed unless the command\n\
@@ -14461,8 +15007,9 @@ The \"Type\" column indicates one of:\n\
 \tfinish         - internal breakpoint used by the \"finish\" command\n\
 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
-breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
-address and file/line number respectively.\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate\n\
+the address and file/line number respectively.  The \"Cond Eval\" column\n\
+indicates where the breakpoint condition will be evaluated.\n\
 \n\
 Convenience variable \"$_\" and default examine address for \"x\"\n\
 are set to the address of the last breakpoint listed unless the command\n\
@@ -14739,6 +15286,23 @@ inferior in all-stop mode, gdb behaves a
 			   &breakpoint_set_cmdlist,
 			   &breakpoint_show_cmdlist);
 
+  add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
+			condition_evaluation_enums,
+			&condition_evaluation_mode_1, _("\
+Set mode of breakpoint condition evaluation."), _("\
+Show mode of breakpoint condition evaluation."), _("\
+When this is set to \"gdb\", breakpoint conditions will be\n\
+evaluated on the host's side by GDB.  When it is set to \"target\",\n\
+breakpoint conditions will be downloaded to the target (if the target\n\
+supports such feature) and conditions will be evaluated on the target's side.\n\
+If this is set to \"auto\" (default), this will be automatically set to\n\
+\"target\" if it supports condition evaluation, otherwise it will\n\
+be set to \"gdb\""),
+			   &set_condition_evaluation_mode,
+			   &show_condition_evaluation_mode,
+			   &breakpoint_set_cmdlist,
+			   &breakpoint_show_cmdlist);
+
   add_com ("break-range", class_breakpoint, break_range_command, _("\
 Set a breakpoint for an address range.\n\
 break-range START-LOCATION, END-LOCATION\n\
Index: gdb/gdb/breakpoint.h
===================================================================
--- gdb.orig/gdb/breakpoint.h	2012-02-06 22:57:02.000000000 -0200
+++ gdb/gdb/breakpoint.h	2012-02-07 00:06:40.785895001 -0200
@@ -22,6 +22,7 @@
 #include "frame.h"
 #include "value.h"
 #include "vec.h"
+#include "ax.h"
 
 struct value;
 struct block;
@@ -215,6 +216,16 @@ enum target_hw_bp_type
   };
 
 
+/* Status of breakpoint conditions used when synchronizing
+   conditions with the target.  */
+
+enum condition_status
+  {
+    condition_unchanged = 0,
+    condition_modified,
+    condition_updated
+  };
+
 /* Information used by targets to insert and remove breakpoints.  */
 
 struct bp_target_info
@@ -249,6 +260,10 @@ struct bp_target_info
      (e.g. if a remote stub handled the details).  We may still need
      the size to remove the breakpoint safely.  */
   int placed_size;
+
+  /* Vector of conditions the target should evaluate if it supports target-side
+     breakpoint conditions.  */
+  VEC(agent_expr_p) *conditions;
 };
 
 /* GDB maintains two types of information about each breakpoint (or
@@ -315,6 +330,30 @@ struct bp_location
      the owner breakpoint object.  */
   struct expression *cond;
 
+  /* Conditional expression in agent expression
+     bytecode form.  This is used for stub-side breakpoint
+     condition evaluation.  */
+  struct agent_expr *cond_bytecode;
+
+  /* Signals that the condition has changed since the last time
+     we updated the global location list.  This means the condition
+     needs to be sent to the target again.  This is used together
+     with target-side breakpoint conditions.
+
+     condition_unchanged: It means there has been no condition changes.
+
+     condition_modified: It means this location had its condition modified.
+
+     condition_updated: It means we already marked all the locations that are
+     duplicates of this location and thus we don't need to call
+     force_breakpoint_reinsertion (...) for this location.  */
+
+  enum condition_status condition_changed;
+
+  /* Signals that breakpoint conditions need to be re-synched with the
+     target.  This has no use other than target-side breakpoints.  */
+  char needs_update;
+
   /* This location's address is in an unloaded solib, and so this
      location should not be inserted.  It will be automatically
      enabled when that solib is loaded.  */
@@ -721,6 +760,10 @@ struct watchpoint
   CORE_ADDR hw_wp_mask;
 };
 
+/* Returns true if BPT is a breakpoint of any kind.  */
+
+extern int is_breakpoint (const struct breakpoint *bpt);
+
 /* Returns true if BPT is really a watchpoint.  */
 
 extern int is_watchpoint (const struct breakpoint *bpt);
Index: gdb/gdb/ax.h
===================================================================
--- gdb.orig/gdb/ax.h	2012-02-06 22:54:54.000000000 -0200
+++ gdb/gdb/ax.h	2012-02-06 22:58:04.557895001 -0200
@@ -20,6 +20,7 @@
 #define AGENTEXPR_H
 
 #include "doublest.h"		/* For DOUBLEST.  */
+#include "vec.h"
 
 /* It's sometimes useful to be able to debug programs that you can't
    really stop for more than a fraction of a second.  To this end, the
@@ -144,6 +145,12 @@ struct agent_expr
     unsigned char *reg_mask;
   };
 
+/* Pointer to an agent_expr structure.  */
+typedef struct agent_expr *agent_expr_p;
+
+/* Vector of pointers to agent expressions.  */
+DEF_VEC_P (agent_expr_p);
+
 /* The actual values of the various bytecode operations.  */
 
 enum agent_op