[committed]: [PATCH] breakpoint always inserted in record target

Yao Qi yao@codesourcery.com
Tue Apr 24 15:00:00 GMT 2012


On 04/24/2012 09:13 PM, Pedro Alves wrote:
> 
> It's not clear to me that something _is_ indeed needed.  If it is, best
> would be a PR.  If not needed, then it's better not to add this comment
> in the first place, as these tend to remain in the sources forever, misleading.
> IOW, please drop the comment.
> 

Comment is removed.  I'll file some PR if I can expose them from
 existing test cases in gdb.reverse/

>> > +  if (is_tracepoint (loc->owner) || is_catchpoint (loc->owner)
>> > +      || is_watchpoint (loc->owner))
>> > +      return;
> 
> This function should only concert itself about what it knows to handle, instead
> of skip what it doesn't know about.  We don't want to need to add handling for
> other types here if/when they're added to breakpoint.c in the future.
> 
> But also, it's really the location's type that matters, not the breakpoint's.
> target_insert_breakpoint concerns itself with software breakpoints, so this
> would be better:
> 
>   if (loc->loc_type != bp_loc_software_breakpoint)
>     return;
> 

Okay, done.

> Okay with these changes.
> 

This is what I committed.
http://sourceware.org/ml/gdb-cvs/2012-04/msg00191.html

-- 
Yao (齐尧) 

2012-04-24  Yao Qi  <yao@codesourcery.com>

	Revert this patch to allow breakpoint always-inserted
	in record target.
	2011-12-05  Pedro Alves  <pedro@codesourcery.com>
        * breakpoint.c: Include record.h.
        (breakpoints_always_inserted_mode): Return false when the record
        target is in use.

	* breakpoint.c (iterate_over_bp_locations): New.
	* breakpoint.h: Declare.
	New typedef walk_bp_location_callback.
	* record.c (record_open): Call record_init_record_breakpoints.
	(record_sync_record_breakpoints): New.
	(record_init_record_breakpoints): New.
	* NEWS: Mention supporting breakpoint always-inserted mode in
	record target.
---
 gdb/NEWS         |    3 +++
 gdb/breakpoint.c |   19 +++++++++++++++----
 gdb/breakpoint.h |    4 ++++
 gdb/record.c     |   33 +++++++++++++++++++++++++++++++++
 4 files changed, 55 insertions(+), 4 deletions(-)

diff --git a/gdb/NEWS b/gdb/NEWS
index 72b4d90..72ce6b8 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -82,6 +82,9 @@
 
 * Ada support for GDB/MI Variable Objects has been added.
 
+* GDB can now support 'breakpoint always-inserted mode' in 'record'
+  target.
+
 * New commands
 
   ** "catch load" and "catch unload" can be used to stop when a shared
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index ceca221..4204e36 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -64,7 +64,6 @@
 #include "continuations.h"
 #include "stack.h"
 #include "skip.h"
-#include "record.h"
 #include "gdb_regex.h"
 #include "ax-gdb.h"
 
@@ -404,9 +403,8 @@ show_always_inserted_mode (struct ui_file *file, int from_tty,
 int
 breakpoints_always_inserted_mode (void)
 {
-  return ((always_inserted_mode == always_inserted_on
-	   || (always_inserted_mode == always_inserted_auto && non_stop))
-	  && !RECORD_IS_USED);
+  return (always_inserted_mode == always_inserted_on
+	  || (always_inserted_mode == always_inserted_auto && non_stop));
 }
 
 static const char condition_evaluation_both[] = "host or target";
@@ -2425,6 +2423,19 @@ insert_breakpoints (void)
     insert_breakpoint_locations ();
 }
 
+/* Invoke CALLBACK for each of bp_location.  */
+
+void
+iterate_over_bp_locations (walk_bp_location_callback callback)
+{
+  struct bp_location *loc, **loc_tmp;
+
+  ALL_BP_LOCATIONS (loc, loc_tmp)
+    {
+      callback (loc, NULL);
+    }
+}
+
 /* This is used when we need to synch breakpoint conditions between GDB and the
    target.  It is the case with deleting and disabling of breakpoints when using
    always-inserted mode.  */
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index e676659..75b62d2 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -1131,6 +1131,10 @@ extern void delete_breakpoint (struct breakpoint *);
 
 extern void breakpoint_auto_delete (bpstat);
 
+typedef void (*walk_bp_location_callback) (struct bp_location *, void *);
+
+extern void iterate_over_bp_locations (walk_bp_location_callback);
+
 /* Return the chain of command lines to execute when this breakpoint
    is hit.  */
 extern struct command_line *breakpoint_commands (struct breakpoint *b);
diff --git a/gdb/record.c b/gdb/record.c
index 9b7ee2f..7db1527 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -896,6 +896,8 @@ record_open_1 (char *name, int from_tty)
   push_target (&record_ops);
 }
 
+static void record_init_record_breakpoints (void);
+
 /* "to_open" target method.  Open the process record target.  */
 
 static void
@@ -993,6 +995,8 @@ record_open (char *name, int from_tty)
   record_async_inferior_event_token
     = create_async_event_handler (record_async_inferior_event_handler,
 				  NULL);
+
+  record_init_record_breakpoints ();
 }
 
 /* "to_close" target method.  Close the process record target.  */
@@ -1744,6 +1748,35 @@ DEF_VEC_P(record_breakpoint_p);
    active.  */
 VEC(record_breakpoint_p) *record_breakpoints = NULL;
 
+static void
+record_sync_record_breakpoints (struct bp_location *loc, void *data)
+{
+  if (loc->loc_type != bp_loc_software_breakpoint)
+      return;
+
+  if (loc->inserted)
+    {
+      struct record_breakpoint *bp = XNEW (struct record_breakpoint);
+
+      bp->addr = loc->target_info.placed_address;
+      bp->address_space = loc->target_info.placed_address_space;
+
+      bp->in_target_beneath = 1;
+
+      VEC_safe_push (record_breakpoint_p, record_breakpoints, bp);
+    }
+}
+
+/* Sync existing breakpoints to record_breakpoints.  */
+
+static void
+record_init_record_breakpoints (void)
+{
+  VEC_free (record_breakpoint_p, record_breakpoints);
+
+  iterate_over_bp_locations (record_sync_record_breakpoints);
+}
+
 /* Behavior is conditional on RECORD_IS_REPLAY.  We will not actually
    insert or remove breakpoints in the real target when replaying, nor
    when recording.  */
-- 
1.7.0.4



More information about the Gdb-patches mailing list