Merge GDB 7.5.1

gdb/record.c

 /* Process record and replay target for GDB, the GNU debugger.
 
    Copyright (C) 2008-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 82 matching lines @@
   unsigned short len;
   union 
   {
     gdb_byte *ptr;
     gdb_byte buf[2 * sizeof (gdb_byte *)];
   } u;
 };
 
 struct record_end_entry
 {
-  enum target_signal sigval;
+  enum gdb_signal sigval;
   ULONGEST insn_num;
 };
 
 enum record_type
 {
   record_end = 0,
   record_reg,
   record_mem
 };
 
@@ skipping 88 matching lines @@
    than count of insns presently in execution log).  */
 static ULONGEST record_insn_count;
 
 /* The target_ops of process record.  */
 static struct target_ops record_ops;
 static struct target_ops record_core_ops;
 
 /* The beneath function pointers.  */
 static struct target_ops *record_beneath_to_resume_ops;
 static void (*record_beneath_to_resume) (struct target_ops *, ptid_t, int,
-                                         enum target_signal);
+                                         enum gdb_signal);
 static struct target_ops *record_beneath_to_wait_ops;
 static ptid_t (*record_beneath_to_wait) (struct target_ops *, ptid_t,
                                          struct target_waitstatus *,
                                          int);
 static struct target_ops *record_beneath_to_store_registers_ops;
 static void (*record_beneath_to_store_registers) (struct target_ops *,
                                                   struct regcache *,
                                                   int regno);
 static struct target_ops *record_beneath_to_xfer_partial_ops;
 static LONGEST (*record_beneath_to_xfer_partial) (struct target_ops *ops,
@@ skipping 301 matching lines @@
 int
 record_arch_list_add_end (void)
 {
   struct record_entry *rec;
 
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog,
                         "Process record: add end to arch list.\n");
 
   rec = record_end_alloc ();
-  rec->u.end.sigval = TARGET_SIGNAL_0;
+  rec->u.end.sigval = GDB_SIGNAL_0;
   rec->u.end.insn_num = ++record_insn_count;
 
   record_arch_list_add (rec);
 
   return 0;
 }
 
 static void
 record_check_insn_num (int set_terminal)
 {
@@ skipping 29 matching lines @@
   record_list_release (record_arch_list_tail);
 }
 
 /* Before inferior step (when GDB record the running message, inferior
    only can step), GDB will call this function to record the values to
    record_list.  This function will call gdbarch_process_record to
    record the running message of inferior and set them to
    record_arch_list, and add it to record_list.  */
 
 static int
-record_message (struct regcache *regcache, enum target_signal signal)
+record_message (struct regcache *regcache, enum gdb_signal signal)
 {
   int ret;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct cleanup *old_cleanups = make_cleanup (record_arch_list_cleanups, 0);
 
   record_arch_list_head = NULL;
   record_arch_list_tail = NULL;
 
   /* Check record_insn_num.  */
   record_check_insn_num (1);
@@ skipping 19 matching lines @@
 
      But we should still deliver the signal to gdb during the replay,
      if we delivered it during the recording.  Therefore we should
      record the signal during record_wait, not record_resume.  */
   if (record_list != &record_first)    /* FIXME better way to check */
     {
       gdb_assert (record_list->type == record_end);
       record_list->u.end.sigval = signal;
     }
 
-  if (signal == TARGET_SIGNAL_0
+  if (signal == GDB_SIGNAL_0
       || !gdbarch_process_record_signal_p (gdbarch))
     ret = gdbarch_process_record (gdbarch,
                                   regcache,
                                   regcache_read_pc (regcache));
   else
     ret = gdbarch_process_record_signal (gdbarch,
                                          regcache,
                                          signal);
 
   if (ret > 0)
@@ skipping 10 matching lines @@
   if (record_insn_num == record_insn_max_num && record_insn_max_num)
     record_list_release_first ();
   else
     record_insn_num++;
 
   return 1;
 }
 
 struct record_message_args {
   struct regcache *regcache;
-  enum target_signal signal;
+  enum gdb_signal signal;
 };
 
 static int
 record_message_wrapper (void *args)
 {
   struct record_message_args *record_args = args;
 
   return record_message (record_args->regcache, record_args->signal);
 }
 
 static int
 record_message_wrapper_safe (struct regcache *regcache,
-                             enum target_signal signal)
+                             enum gdb_signal signal)
 {
   struct record_message_args args;
 
   args.regcache = regcache;
   args.signal = signal;
 
   return catch_errors (record_message_wrapper, &args, NULL, RETURN_MASK_ALL);
 }
 
 /* Set to 1 if record_store_registers and record_xfer_partial
@@ skipping 100 matching lines @@
                   }
               }
           }
       }
       break;
     }
 }
 
 static struct target_ops *tmp_to_resume_ops;
 static void (*tmp_to_resume) (struct target_ops *, ptid_t, int,
-                              enum target_signal);
+                              enum gdb_signal);
 static struct target_ops *tmp_to_wait_ops;
 static ptid_t (*tmp_to_wait) (struct target_ops *, ptid_t,
                               struct target_waitstatus *,
                               int);
 static struct target_ops *tmp_to_store_registers_ops;
 static void (*tmp_to_store_registers) (struct target_ops *,
                                        struct regcache *,
                                        int regno);
 static struct target_ops *tmp_to_xfer_partial_ops;
 static LONGEST (*tmp_to_xfer_partial) (struct target_ops *ops,
@@ skipping 89 matching lines @@
   if (!tmp_to_stopped_by_watchpoint)
     error (_("Could not find 'to_stopped_by_watchpoint' "
              "method on the target stack."));
   if (!tmp_to_stopped_data_address)
     error (_("Could not find 'to_stopped_data_address' "
              "method on the target stack."));
 
   push_target (&record_ops);
 }
 
+static void record_init_record_breakpoints (void);
+
 /* "to_open" target method.  Open the process record target.  */
 
 static void
 record_open (char *name, int from_tty)
 {
   struct target_ops *t;
 
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n");
 
@@ skipping 77 matching lines @@
 
   if (core_bfd)
     record_core_open_1 (name, from_tty);
   else
     record_open_1 (name, from_tty);
 
   /* Register extra event sources in the event loop.  */
   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.  */
 
 static void
 record_close (int quitting)
 {
   struct record_core_buf_entry *entry;
 
   if (record_debug)
@@ skipping 43 matching lines @@
       the global execution direction accordingly (to reverse)
    7. infrun polls an event out of the record target, and handles it
    8. GDB goes back to the event loop, and goto #4.
 */
 static enum exec_direction_kind record_execution_dir = EXEC_FORWARD;
 
 /* "to_resume" target method.  Resume the process record target.  */
 
 static void
 record_resume (struct target_ops *ops, ptid_t ptid, int step,
-               enum target_signal signal)
+               enum gdb_signal signal)
 {
   record_resume_step = step;
   record_resumed = 1;
   record_execution_dir = execution_direction;
 
   if (!RECORD_IS_REPLAY)
     {
       struct gdbarch *gdbarch = target_thread_architecture (ptid);
 
       record_message (get_current_regcache (), signal);
@@ skipping 142 matching lines @@
                 }
 
               if (single_step_breakpoints_inserted ())
                 remove_single_step_breakpoints ();
 
               if (record_resume_step)
                 return ret;
 
               /* Is this a SIGTRAP?  */
               if (status->kind == TARGET_WAITKIND_STOPPED
-                  && status->value.sig == TARGET_SIGNAL_TRAP)
+                  && status->value.sig == GDB_SIGNAL_TRAP)
                 {
                   struct regcache *regcache;
                   struct address_space *aspace;
 
                   /* Yes -- this is likely our single-step finishing,
                      but check if there's any reason the core would be
                      interested in the event.  */
 
                   registers_changed ();
                   regcache = get_current_regcache ();
@@ skipping 21 matching lines @@
                     }
                   else
                     {
                       /* This is a single-step trap.  Record the
                          insn and issue another step.
                          FIXME: this part can be a random SIGTRAP too.
                          But GDB cannot handle it.  */
                       int step = 1;
 
                       if (!record_message_wrapper_safe (regcache,
-                                                        TARGET_SIGNAL_0))
+                                                        GDB_SIGNAL_0))
                         {
                            status->kind = TARGET_WAITKIND_STOPPED;
-                           status->value.sig = TARGET_SIGNAL_0;
+                           status->value.sig = GDB_SIGNAL_0;
                            break;
                         }
 
                       if (gdbarch_software_single_step_p (gdbarch))
                         {
                           /* Try to insert the software single step breakpoint.
                              If insert success, set step to 0.  */
                           set_executing (inferior_ptid, 0);
                           reinit_frame_cache ();
                           if (gdbarch_software_single_step (gdbarch,
                                                             get_current_frame ()))
                             step = 0;
                           set_executing (inferior_ptid, 1);
                         }
 
                       if (record_debug)
                         fprintf_unfiltered (gdb_stdlog,
                                             "Process record: record_wait "
                                             "issuing one more step in the target beneath\n");
                       record_beneath_to_resume (record_beneath_to_resume_ops,
                                                 ptid, step,
-                                                TARGET_SIGNAL_0);
+                                                GDB_SIGNAL_0);
                       continue;
                     }
                 }
 
               /* The inferior is broken by a breakpoint or a signal.  */
               break;
             }
 
           return ret;
         }
@@ skipping 118 matching lines @@
 
                   if (record_hw_watchpoint)
                     {
                       if (record_debug)
                         fprintf_unfiltered (gdb_stdlog,
                                             "Process record: hit hw "
                                             "watchpoint.\n");
                       continue_flag = 0;
                     }
                   /* Check target signal */
-                  if (record_list->u.end.sigval != TARGET_SIGNAL_0)
+                  if (record_list->u.end.sigval != GDB_SIGNAL_0)
                     /* FIXME: better way to check */
                     continue_flag = 0;
                 }
             }
 
           if (continue_flag)
             {
               if (execution_direction == EXEC_REVERSE)
                 {
                   if (record_list->prev)
                     record_list = record_list->prev;
                 }
               else
                 {
                   if (record_list->next)
                     record_list = record_list->next;
                 }
             }
         }
       while (continue_flag);
 
 replay_out:
       if (record_get_sig)
-        status->value.sig = TARGET_SIGNAL_INT;
-      else if (record_list->u.end.sigval != TARGET_SIGNAL_0)
+        status->value.sig = GDB_SIGNAL_INT;
+      else if (record_list->u.end.sigval != GDB_SIGNAL_0)
         /* FIXME: better way to check */
         status->value.sig = record_list->u.end.sigval;
       else
-        status->value.sig = TARGET_SIGNAL_TRAP;
+        status->value.sig = GDB_SIGNAL_TRAP;
 
       discard_cleanups (old_cleanups);
     }
 
   signal (SIGINT, handle_sigint);
 
   do_cleanups (set_cleanups);
   return inferior_ptid;
 }
 
@@ skipping 243 matching lines @@
         record_list_release_first ();
       else
         record_insn_num++;
     }
 
   return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_ops,
                                          object, annex, readbuf, writebuf,
                                          offset, len);
 }
 
-/* Behavior is conditional on RECORD_IS_REPLAY.
-   We will not actually insert or remove breakpoints when replaying,
-   nor when recording.  */
+/* This structure represents a breakpoint inserted while the record
+   target is active.  We use this to know when to install/remove
+   breakpoints in/from the target beneath.  For example, a breakpoint
+   may be inserted while recording, but removed when not replaying nor
+   recording.  In that case, the breakpoint had not been inserted on
+   the target beneath, so we should not try to remove it there.  */
+
+struct record_breakpoint
+{
+  /* The address and address space the breakpoint was set at.  */
+  struct address_space *address_space;
+  CORE_ADDR addr;
+
+  /* True when the breakpoint has been also installed in the target
+     beneath.  This will be false for breakpoints set during replay or
+     when recording.  */
+  int in_target_beneath;
+};
+
+typedef struct record_breakpoint *record_breakpoint_p;
+DEF_VEC_P(record_breakpoint_p);
+
+/* The list of breakpoints inserted while the record target is
+   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.  */
 
 static int
 record_insert_breakpoint (struct gdbarch *gdbarch,
                           struct bp_target_info *bp_tgt)
 {
+  struct record_breakpoint *bp;
+  int in_target_beneath = 0;
+
   if (!RECORD_IS_REPLAY)
     {
-      struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
-      int ret = record_beneath_to_insert_breakpoint (gdbarch, bp_tgt);
+      /* When recording, we currently always single-step, so we don't
+         really need to install regular breakpoints in the inferior.
+         However, we do have to insert software single-step
+         breakpoints, in case the target can't hardware step.  To keep
+         things single, we always insert.  */
+      struct cleanup *old_cleanups;
+      int ret;
 
+      old_cleanups = record_gdb_operation_disable_set ();
+      ret = record_beneath_to_insert_breakpoint (gdbarch, bp_tgt);
       do_cleanups (old_cleanups);
 
-      return ret;
+      if (ret != 0)
+        return ret;
+
+      in_target_beneath = 1;
     }
 
+  bp = XNEW (struct record_breakpoint);
+  bp->addr = bp_tgt->placed_address;
+  bp->address_space = bp_tgt->placed_address_space;
+  bp->in_target_beneath = in_target_beneath;
+  VEC_safe_push (record_breakpoint_p, record_breakpoints, bp);
   return 0;
 }
 
 /* "to_remove_breakpoint" method for process record target.  */
 
 static int
 record_remove_breakpoint (struct gdbarch *gdbarch,
                           struct bp_target_info *bp_tgt)
 {
-  if (!RECORD_IS_REPLAY)
+  struct record_breakpoint *bp;
+  int ix;
+
+  for (ix = 0;
+       VEC_iterate (record_breakpoint_p, record_breakpoints, ix, bp);
+       ++ix)
     {
-      struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
-      int ret = record_beneath_to_remove_breakpoint (gdbarch, bp_tgt);
+      if (bp->addr == bp_tgt->placed_address
+          && bp->address_space == bp_tgt->placed_address_space)
+        {
+          if (bp->in_target_beneath)
+            {
+              struct cleanup *old_cleanups;
+              int ret;
 
-      do_cleanups (old_cleanups);
+              old_cleanups = record_gdb_operation_disable_set ();
+              ret = record_beneath_to_remove_breakpoint (gdbarch, bp_tgt);
+              do_cleanups (old_cleanups);
 
-      return ret;
+              if (ret != 0)
+                return ret;
+            }
+
+          VEC_unordered_remove (record_breakpoint_p, record_breakpoints, ix);
+          return 0;
+        }
     }
 
-  return 0;
+  gdb_assert_not_reached ("removing unknown breakpoint");
 }
 
 /* "to_can_execute_reverse" method for process record target.  */
 
 static int
 record_can_execute_reverse (void)
 {
   return 1;
 }
 
@@ skipping 110 matching lines @@
   record_ops.to_can_async_p = record_can_async_p;
   record_ops.to_is_async_p = record_is_async_p;
   record_ops.to_execution_direction = record_execution_direction;
   record_ops.to_magic = OPS_MAGIC;
 }
 
 /* "to_resume" method for prec over corefile.  */
 
 static void
 record_core_resume (struct target_ops *ops, ptid_t ptid, int step,
-                    enum target_signal signal)
+                    enum gdb_signal signal)
 {
   record_resume_step = step;
   record_resumed = 1;
   record_execution_dir = execution_direction;
 
   /* We are about to start executing the inferior (or simulate it),
      let's register it with the event loop.  */
   if (target_can_async_p ())
     {
       target_async (inferior_event_handler, 0);
@@ skipping 955 matching lines @@
     {
       printf_filtered (_("Go backward to insn number %s\n"),
                        pulongest (target_insn));
       record_goto_insn (p, EXEC_REVERSE);
     }
   registers_changed ();
   reinit_frame_cache ();
   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 }
 
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern initialize_file_ftype _initialize_record;
+
 void
 _initialize_record (void)
 {
   struct cmd_list_element *c;
 
   /* Init record_first.  */
   record_first.prev = NULL;
   record_first.next = NULL;
   record_first.type = record_end;
 
@@ skipping 83 matching lines @@
 Set whether query if PREC cannot record memory change of next instruction."),
                            _("\
 Show whether query if PREC cannot record memory change of next instruction."),
                            _("\
 Default is OFF.\n\
 When ON, query if PREC cannot record memory change of next instruction."),
                            NULL, NULL,
                            &set_record_cmdlist, &show_record_cmdlist);
 
 }