Process record and replay target.
authorHui Zhu <teawater@gmail.com>
Thu, 30 Apr 2009 02:58:37 +0000 (02:58 +0000)
committerHui Zhu <teawater@gmail.com>
Thu, 30 Apr 2009 02:58:37 +0000 (02:58 +0000)
* Makefile.in (SFILES): Add record.c.
(COMMON_OBS): Add record.o.
* record.c, record.h: New file.

gdb/ChangeLog
gdb/Makefile.in
gdb/record.c [new file with mode: 0644]
gdb/record.h [new file with mode: 0644]

index 07d3eed..f10703b 100644 (file)
@@ -1,6 +1,15 @@
 2009-04-30  Hui Zhu  <teawater@gmail.com>
             Michael Snyder  <msnyder@vmware.com>
 
+       Process record and replay target.
+
+       * Makefile.in (SFILES): Add record.c.
+       (COMMON_OBS): Add record.o.
+       * record.c, record.h: New file.
+
+2009-04-30  Hui Zhu  <teawater@gmail.com>
+            Michael Snyder  <msnyder@vmware.com>
+
        * target.h (strata): New stratum "record_stratum".
 
 2009-04-30  Hui Zhu  <teawater@gmail.com>
index 35c3813..fbdc217 100644 (file)
@@ -664,7 +664,8 @@ SFILES = ada-exp.y ada-lang.c ada-typeprint.c ada-valprint.c ada-tasks.c \
        valarith.c valops.c valprint.c value.c varobj.c vec.c \
        wrapper.c \
        xml-tdesc.c xml-support.c \
-       inferior.c gdb_usleep.c
+       inferior.c gdb_usleep.c \
+       record.c
 
 LINTFILES = $(SFILES) $(YYFILES) $(CONFIG_SRCS) init.c
 
@@ -816,7 +817,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \
        solib.o solib-null.o \
        prologue-value.o memory-map.o xml-support.o \
        target-descriptions.o target-memory.o xml-tdesc.o xml-builtin.o \
-       inferior.o osdata.o gdb_usleep.o
+       inferior.o osdata.o gdb_usleep.o record.o
 
 TSOBS = inflow.o
 
diff --git a/gdb/record.c b/gdb/record.c
new file mode 100644 (file)
index 0000000..498e6fc
--- /dev/null
@@ -0,0 +1,1289 @@
+/* Process record and replay target for GDB, the GNU debugger.
+
+   Copyright (C) 2008, 2009 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 "defs.h"
+#include "gdbcmd.h"
+#include "regcache.h"
+#include "gdbthread.h"
+#include "event-top.h"
+#include "exceptions.h"
+#include "record.h"
+
+#include <signal.h>
+
+#define DEFAULT_RECORD_INSN_MAX_NUM    200000
+
+#define RECORD_IS_REPLAY \
+     (record_list->next || execution_direction == EXEC_REVERSE)
+
+/* These are the core struct of record function.
+
+   An record_entry is a record of the value change of a register
+   ("record_reg") or a part of memory ("record_mem").  And each
+   instruction must has a struct record_entry ("record_end") that points out this
+   is the last struct record_entry of this instruction.
+
+   Each struct record_entry is linked to "record_list" by "prev" and "next". */
+
+struct record_reg_entry
+{
+  int num;
+  gdb_byte *val;
+};
+
+struct record_mem_entry
+{
+  CORE_ADDR addr;
+  int len;
+  gdb_byte *val;
+};
+
+enum record_type
+{
+  record_end = 0,
+  record_reg,
+  record_mem
+};
+
+struct record_entry
+{
+  struct record_entry *prev;
+  struct record_entry *next;
+  enum record_type type;
+  union
+  {
+    /* reg */
+    struct record_reg_entry reg;
+    /* mem */
+    struct record_mem_entry mem;
+  } u;
+};
+
+/* This is the debug switch for process record.  */
+int record_debug = 0;
+
+/* These list is for execution log.  */
+static struct record_entry record_first;
+static struct record_entry *record_list = &record_first;
+static struct record_entry *record_arch_list_head = NULL;
+static struct record_entry *record_arch_list_tail = NULL;
+
+/* 1 ask user. 0 auto delete the last struct record_entry.  */
+static int record_stop_at_limit = 1;
+static int record_insn_max_num = DEFAULT_RECORD_INSN_MAX_NUM;
+static int record_insn_num = 0;
+
+/* The target_ops of process record.  */
+static struct target_ops record_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);
+static struct target_ops *record_beneath_to_wait_ops;
+static ptid_t (*record_beneath_to_wait) (struct target_ops *, ptid_t,
+                                        struct target_waitstatus *);
+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,
+                                                 enum target_object object,
+                                                 const char *annex,
+                                                 gdb_byte *readbuf,
+                                                 const gdb_byte *writebuf,
+                                                 ULONGEST offset,
+                                                 LONGEST len);
+static int (*record_beneath_to_insert_breakpoint) (struct bp_target_info *);
+static int (*record_beneath_to_remove_breakpoint) (struct bp_target_info *);
+
+static void
+record_list_release (struct record_entry *rec)
+{
+  struct record_entry *tmp;
+
+  if (!rec)
+    return;
+
+  while (rec->next)
+    {
+      rec = rec->next;
+    }
+
+  while (rec->prev)
+    {
+      tmp = rec;
+      rec = rec->prev;
+      if (tmp->type == record_reg)
+       xfree (tmp->u.reg.val);
+      else if (tmp->type == record_mem)
+       xfree (tmp->u.mem.val);
+      xfree (tmp);
+    }
+
+  if (rec != &record_first)
+    xfree (rec);
+}
+
+static void
+record_list_release_next (void)
+{
+  struct record_entry *rec = record_list;
+  struct record_entry *tmp = rec->next;
+  rec->next = NULL;
+  while (tmp)
+    {
+      rec = tmp->next;
+      if (tmp->type == record_reg)
+       record_insn_num--;
+      else if (tmp->type == record_reg)
+       xfree (tmp->u.reg.val);
+      else if (tmp->type == record_mem)
+       xfree (tmp->u.mem.val);
+      xfree (tmp);
+      tmp = rec;
+    }
+}
+
+static void
+record_list_release_first (void)
+{
+  struct record_entry *tmp = NULL;
+  enum record_type type;
+
+  if (!record_first.next)
+    return;
+
+  while (1)
+    {
+      type = record_first.next->type;
+
+      if (type == record_reg)
+       xfree (record_first.next->u.reg.val);
+      else if (type == record_mem)
+       xfree (record_first.next->u.mem.val);
+      tmp = record_first.next;
+      record_first.next = tmp->next;
+      xfree (tmp);
+
+      if (!record_first.next)
+       {
+         gdb_assert (record_insn_num == 1);
+         break;
+       }
+
+      record_first.next->prev = &record_first;
+
+      if (type == record_end)
+       break;
+    }
+
+  record_insn_num--;
+}
+
+/* Add a struct record_entry to record_arch_list.  */
+
+static void
+record_arch_list_add (struct record_entry *rec)
+{
+  if (record_debug > 1)
+    fprintf_unfiltered (gdb_stdlog,
+                       "Process record: record_arch_list_add %s.\n",
+                       host_address_to_string (rec));
+
+  if (record_arch_list_tail)
+    {
+      record_arch_list_tail->next = rec;
+      rec->prev = record_arch_list_tail;
+      record_arch_list_tail = rec;
+    }
+  else
+    {
+      record_arch_list_head = rec;
+      record_arch_list_tail = rec;
+    }
+}
+
+/* Record the value of a register NUM to record_arch_list.  */
+
+int
+record_arch_list_add_reg (struct regcache *regcache, int num)
+{
+  struct record_entry *rec;
+
+  if (record_debug > 1)
+    fprintf_unfiltered (gdb_stdlog,
+                       "Process record: add register num = %d to "
+                       "record list.\n",
+                       num);
+
+  rec = (struct record_entry *) xmalloc (sizeof (struct record_entry));
+  rec->u.reg.val = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE);
+  rec->prev = NULL;
+  rec->next = NULL;
+  rec->type = record_reg;
+  rec->u.reg.num = num;
+
+  regcache_raw_read (regcache, num, rec->u.reg.val);
+
+  record_arch_list_add (rec);
+
+  return 0;
+}
+
+/* Record the value of a region of memory whose address is ADDR and
+   length is LEN to record_arch_list.  */
+
+int
+record_arch_list_add_mem (CORE_ADDR addr, int len)
+{
+  struct record_entry *rec;
+
+  if (record_debug > 1)
+    fprintf_unfiltered (gdb_stdlog,
+                       "Process record: add mem addr = 0x%s len = %d to "
+                       "record list.\n",
+                       paddr_nz (addr), len);
+
+  if (!addr)
+    return 0;
+
+  rec = (struct record_entry *) xmalloc (sizeof (struct record_entry));
+  rec->u.mem.val = (gdb_byte *) xmalloc (len);
+  rec->prev = NULL;
+  rec->next = NULL;
+  rec->type = record_mem;
+  rec->u.mem.addr = addr;
+  rec->u.mem.len = len;
+
+  if (target_read_memory (addr, rec->u.mem.val, len))
+    {
+      if (record_debug)
+       fprintf_unfiltered (gdb_stdlog,
+                           "Process record: error reading memory at "
+                           "addr = 0x%s len = %d.\n",
+                           paddr_nz (addr), len);
+      xfree (rec->u.mem.val);
+      xfree (rec);
+      return -1;
+    }
+
+  record_arch_list_add (rec);
+
+  return 0;
+}
+
+/* Add a record_end type struct record_entry to record_arch_list.  */
+
+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 = (struct record_entry *) xmalloc (sizeof (struct record_entry));
+  rec->prev = NULL;
+  rec->next = NULL;
+  rec->type = record_end;
+
+  record_arch_list_add (rec);
+
+  return 0;
+}
+
+static void
+record_check_insn_num (int set_terminal)
+{
+  if (record_insn_max_num)
+    {
+      gdb_assert (record_insn_num <= record_insn_max_num);
+      if (record_insn_num == record_insn_max_num)
+       {
+         /* Ask user what to do.  */
+         if (record_stop_at_limit)
+           {
+             int q;
+             if (set_terminal)
+               target_terminal_ours ();
+             q = yquery (_("Do you want to auto delete previous execution "
+                           "log entries when record/replay buffer becomes "
+                           "full (record stop-at-limit)?"));
+             if (set_terminal)
+               target_terminal_inferior ();
+             if (q)
+               record_stop_at_limit = 0;
+             else
+               error (_("Process record: inferior program stopped."));
+           }
+       }
+    }
+}
+
+/* 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 void
+record_message_cleanups (void *ignore)
+{
+  record_list_release (record_arch_list_tail);
+}
+
+static int
+record_message (void *args)
+{
+  int ret;
+  struct regcache *regcache = args;
+  struct cleanup *old_cleanups = make_cleanup (record_message_cleanups, 0);
+
+  record_arch_list_head = NULL;
+  record_arch_list_tail = NULL;
+
+  /* Check record_insn_num.  */
+  record_check_insn_num (1);
+
+  ret = gdbarch_process_record (get_regcache_arch (regcache),
+                               regcache,
+                               regcache_read_pc (regcache));
+  if (ret > 0)
+    error (_("Process record: inferior program stopped."));
+  if (ret < 0)
+    error (_("Process record: failed to record execution log."));
+
+  discard_cleanups (old_cleanups);
+
+  record_list->next = record_arch_list_head;
+  record_arch_list_head->prev = record_list;
+  record_list = record_arch_list_tail;
+
+  if (record_insn_num == record_insn_max_num && record_insn_max_num)
+    record_list_release_first ();
+  else
+    record_insn_num++;
+
+  return 1;
+}
+
+static int
+do_record_message (struct regcache *regcache)
+{
+  return catch_errors (record_message, regcache, NULL, RETURN_MASK_ALL);
+}
+
+/* Set to 1 if record_store_registers and record_xfer_partial
+   doesn't need record.  */
+
+static int record_gdb_operation_disable = 0;
+
+struct cleanup *
+record_gdb_operation_disable_set (void)
+{
+  struct cleanup *old_cleanups = NULL;
+
+  old_cleanups =
+    make_cleanup_restore_integer (&record_gdb_operation_disable);
+  record_gdb_operation_disable = 1;
+
+  return old_cleanups;
+}
+
+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");
+
+  /* check exec */
+  if (!target_has_execution)
+    error (_("Process record: the program is not being run."));
+  if (non_stop)
+    error (_("Process record target can't debug inferior in non-stop mode "
+            "(non-stop)."));
+  if (target_async_permitted)
+    error (_("Process record target can't debug inferior in asynchronous "
+            "mode (target-async)."));
+
+  if (!gdbarch_process_record_p (current_gdbarch))
+    error (_("Process record: the current architecture doesn't support "
+            "record function."));
+
+  /* Check if record target is already running.  */
+  if (current_target.to_stratum == record_stratum)
+    {
+      if (!nquery
+         (_("Process record target already running, do you want to delete "
+            "the old record log?")))
+       return;
+    }
+
+  /*Reset the beneath function pointers.  */
+  record_beneath_to_resume = NULL;
+  record_beneath_to_wait = NULL;
+  record_beneath_to_store_registers = NULL;
+  record_beneath_to_xfer_partial = NULL;
+  record_beneath_to_insert_breakpoint = NULL;
+  record_beneath_to_remove_breakpoint = NULL;
+
+  /* Set the beneath function pointers.  */
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    {
+      if (!record_beneath_to_resume)
+        {
+         record_beneath_to_resume = t->to_resume;
+         record_beneath_to_resume_ops = t;
+        }
+      if (!record_beneath_to_wait)
+        {
+         record_beneath_to_wait = t->to_wait;
+         record_beneath_to_wait_ops = t;
+        }
+      if (!record_beneath_to_store_registers)
+        {
+         record_beneath_to_store_registers = t->to_store_registers;
+         record_beneath_to_store_registers_ops = t;
+        }
+      if (!record_beneath_to_xfer_partial)
+        {
+         record_beneath_to_xfer_partial = t->to_xfer_partial;
+         record_beneath_to_xfer_partial_ops = t;
+        }
+      if (!record_beneath_to_insert_breakpoint)
+       record_beneath_to_insert_breakpoint = t->to_insert_breakpoint;
+      if (!record_beneath_to_remove_breakpoint)
+       record_beneath_to_remove_breakpoint = t->to_remove_breakpoint;
+    }
+  if (!record_beneath_to_resume)
+    error (_("Process record can't get to_resume."));
+  if (!record_beneath_to_wait)
+    error (_("Process record can't get to_wait."));
+  if (!record_beneath_to_store_registers)
+    error (_("Process record can't get to_store_registers."));
+  if (!record_beneath_to_xfer_partial)
+    error (_("Process record can't get to_xfer_partial."));
+  if (!record_beneath_to_insert_breakpoint)
+    error (_("Process record can't get to_insert_breakpoint."));
+  if (!record_beneath_to_remove_breakpoint)
+    error (_("Process record can't get to_remove_breakpoint."));
+
+  push_target (&record_ops);
+
+  /* Reset */
+  record_insn_num = 0;
+  record_list = &record_first;
+  record_list->next = NULL;
+}
+
+static void
+record_close (int quitting)
+{
+  if (record_debug)
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n");
+
+  record_list_release (record_list);
+}
+
+static int record_resume_step = 0;
+static enum target_signal record_resume_siggnal;
+static int record_resume_error;
+
+static void
+record_resume (struct target_ops *ops, ptid_t ptid, int step,
+               enum target_signal siggnal)
+{
+  record_resume_step = step;
+  record_resume_siggnal = siggnal;
+
+  if (!RECORD_IS_REPLAY)
+    {
+      if (do_record_message (get_current_regcache ()))
+        {
+          record_resume_error = 0;
+        }
+      else
+        {
+          record_resume_error = 1;
+          return;
+        }
+      record_beneath_to_resume (record_beneath_to_resume_ops, ptid, 1,
+                                siggnal);
+    }
+}
+
+static int record_get_sig = 0;
+
+static void
+record_sig_handler (int signo)
+{
+  if (record_debug)
+    fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
+
+  /* It will break the running inferior in replay mode.  */
+  record_resume_step = 1;
+
+  /* It will let record_wait set inferior status to get the signal
+     SIGINT.  */
+  record_get_sig = 1;
+}
+
+static void
+record_wait_cleanups (void *ignore)
+{
+  if (execution_direction == EXEC_REVERSE)
+    {
+      if (record_list->next)
+       record_list = record_list->next;
+    }
+  else
+    record_list = record_list->prev;
+}
+
+/* In replay mode, this function examines the recorded log and
+   determines where to stop.  */
+
+static ptid_t
+record_wait (struct target_ops *ops,
+              ptid_t ptid, struct target_waitstatus *status)
+{
+  struct cleanup *set_cleanups = record_gdb_operation_disable_set ();
+
+  if (record_debug)
+    fprintf_unfiltered (gdb_stdlog,
+                       "Process record: record_wait "
+                       "record_resume_step = %d\n",
+                       record_resume_step);
+
+  if (!RECORD_IS_REPLAY)
+    {
+      if (record_resume_error)
+       {
+         /* If record_resume get error, return directly.  */
+         status->kind = TARGET_WAITKIND_STOPPED;
+         status->value.sig = TARGET_SIGNAL_ABRT;
+         return inferior_ptid;
+       }
+
+      if (record_resume_step)
+       {
+         /* This is a single step.  */
+         return record_beneath_to_wait (record_beneath_to_wait_ops,
+                                                      ptid, status);
+       }
+      else
+       {
+         /* This is not a single step.  */
+         ptid_t ret;
+         CORE_ADDR tmp_pc;
+
+         while (1)
+           {
+             ret = record_beneath_to_wait (record_beneath_to_wait_ops,
+                                           ptid, status);
+
+             if (status->kind == TARGET_WAITKIND_STOPPED
+                 && status->value.sig == TARGET_SIGNAL_TRAP)
+               {
+                 /* Check if there is a breakpoint.  */
+                 registers_changed ();
+                 tmp_pc = read_pc ();
+                 if (breakpoint_inserted_here_p (tmp_pc))
+                   {
+                     /* There is a breakpoint.  */
+                     CORE_ADDR decr_pc_after_break =
+                       gdbarch_decr_pc_after_break
+                       (get_regcache_arch (get_current_regcache ()));
+                     if (decr_pc_after_break)
+                       {
+                         regcache_write_pc (get_thread_regcache (ret),
+                                            tmp_pc + decr_pc_after_break);
+                       }
+                   }
+                 else
+                   {
+                     /* There is not a breakpoint.  */
+                     if (!do_record_message (get_current_regcache ()))
+                       {
+                          break;
+                       }
+                     record_beneath_to_resume (record_beneath_to_resume_ops,
+                                               ptid, 1,
+                                               record_resume_siggnal);
+                     continue;
+                   }
+               }
+
+             /* The inferior is broken by a breakpoint or a signal.  */
+             break;
+           }
+
+         return ret;
+       }
+    }
+  else
+    {
+      struct regcache *regcache = get_current_regcache ();
+      int continue_flag = 1;
+      int first_record_end = 1;
+      struct cleanup *old_cleanups = make_cleanup (record_wait_cleanups, 0);
+      CORE_ADDR tmp_pc;
+
+      status->kind = TARGET_WAITKIND_STOPPED;
+
+      /* Check breakpoint when forward execute.  */
+      if (execution_direction == EXEC_FORWARD)
+       {
+         tmp_pc = regcache_read_pc (regcache);
+         if (breakpoint_inserted_here_p (tmp_pc))
+           {
+             if (record_debug)
+               fprintf_unfiltered (gdb_stdlog,
+                                   "Process record: break at 0x%s.\n",
+                                   paddr_nz (tmp_pc));
+             if (gdbarch_decr_pc_after_break (get_regcache_arch (regcache))
+                 && !record_resume_step)
+               regcache_write_pc (regcache,
+                                  tmp_pc +
+                                  gdbarch_decr_pc_after_break
+                                  (get_regcache_arch (regcache)));
+             goto replay_out;
+           }
+       }
+
+      record_get_sig = 0;
+      signal (SIGINT, record_sig_handler);
+      /* If GDB is in terminal_inferior mode, it will not get the signal.
+         And in GDB replay mode, GDB doesn't need to be in terminal_inferior
+         mode, because inferior will not executed.
+         Then set it to terminal_ours to make GDB get the signal.  */
+      target_terminal_ours ();
+
+      /* In EXEC_FORWARD mode, record_list points to the tail of prev
+         instruction.  */
+      if (execution_direction == EXEC_FORWARD && record_list->next)
+       record_list = record_list->next;
+
+      /* Loop over the record_list, looking for the next place to
+        stop.  */
+      do
+       {
+         /* Check for beginning and end of log.  */
+         if (execution_direction == EXEC_REVERSE
+             && record_list == &record_first)
+           {
+             /* Hit beginning of record log in reverse.  */
+             status->kind = TARGET_WAITKIND_NO_HISTORY;
+             break;
+           }
+         if (execution_direction != EXEC_REVERSE && !record_list->next)
+           {
+             /* Hit end of record log going forward.  */
+             status->kind = TARGET_WAITKIND_NO_HISTORY;
+             break;
+           }
+
+         /* Set ptid, register and memory according to record_list.  */
+         if (record_list->type == record_reg)
+           {
+             /* reg */
+             gdb_byte reg[MAX_REGISTER_SIZE];
+             if (record_debug > 1)
+               fprintf_unfiltered (gdb_stdlog,
+                                   "Process record: record_reg %s to "
+                                   "inferior num = %d.\n",
+                                   host_address_to_string (record_list),
+                                   record_list->u.reg.num);
+             regcache_cooked_read (regcache, record_list->u.reg.num, reg);
+             regcache_cooked_write (regcache, record_list->u.reg.num,
+                                    record_list->u.reg.val);
+             memcpy (record_list->u.reg.val, reg, MAX_REGISTER_SIZE);
+           }
+         else if (record_list->type == record_mem)
+           {
+             /* mem */
+             gdb_byte *mem = alloca (record_list->u.mem.len);
+             if (record_debug > 1)
+               fprintf_unfiltered (gdb_stdlog,
+                                   "Process record: record_mem %s to "
+                                   "inferior addr = 0x%s len = %d.\n",
+                                   host_address_to_string (record_list),
+                                   paddr_nz (record_list->u.mem.addr),
+                                   record_list->u.mem.len);
+
+             if (target_read_memory
+                 (record_list->u.mem.addr, mem, record_list->u.mem.len))
+               error (_("Process record: error reading memory at "
+                        "addr = 0x%s len = %d."),
+                      paddr_nz (record_list->u.mem.addr),
+                      record_list->u.mem.len);
+
+             if (target_write_memory
+                 (record_list->u.mem.addr, record_list->u.mem.val,
+                  record_list->u.mem.len))
+               error (_
+                      ("Process record: error writing memory at "
+                       "addr = 0x%s len = %d."),
+                      paddr_nz (record_list->u.mem.addr),
+                      record_list->u.mem.len);
+
+             memcpy (record_list->u.mem.val, mem, record_list->u.mem.len);
+           }
+         else
+           {
+             if (record_debug > 1)
+               fprintf_unfiltered (gdb_stdlog,
+                                   "Process record: record_end %s to "
+                                   "inferior.\n",
+                                   host_address_to_string (record_list));
+
+             if (first_record_end && execution_direction == EXEC_REVERSE)
+               {
+                 /* When reverse excute, the first record_end is the part of
+                    current instruction.  */
+                 first_record_end = 0;
+               }
+             else
+               {
+                 /* In EXEC_REVERSE mode, this is the record_end of prev
+                    instruction.
+                    In EXEC_FORWARD mode, this is the record_end of current
+                    instruction.  */
+                 /* step */
+                 if (record_resume_step)
+                   {
+                     if (record_debug > 1)
+                       fprintf_unfiltered (gdb_stdlog,
+                                           "Process record: step.\n");
+                     continue_flag = 0;
+                   }
+
+                 /* check breakpoint */
+                 tmp_pc = regcache_read_pc (regcache);
+                 if (breakpoint_inserted_here_p (tmp_pc))
+                   {
+                     if (record_debug)
+                       fprintf_unfiltered (gdb_stdlog,
+                                           "Process record: break "
+                                           "at 0x%s.\n",
+                                           paddr_nz (tmp_pc));
+                     if (gdbarch_decr_pc_after_break (get_regcache_arch (regcache))
+                         && execution_direction == EXEC_FORWARD
+                         && !record_resume_step)
+                       regcache_write_pc (regcache,
+                                          tmp_pc +
+                                          gdbarch_decr_pc_after_break
+                                          (get_regcache_arch (regcache)));
+                     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);
+
+      signal (SIGINT, handle_sigint);
+
+replay_out:
+      if (record_get_sig)
+       status->value.sig = TARGET_SIGNAL_INT;
+      else
+       status->value.sig = TARGET_SIGNAL_TRAP;
+
+      discard_cleanups (old_cleanups);
+    }
+
+  do_cleanups (set_cleanups);
+  return inferior_ptid;
+}
+
+static void
+record_disconnect (struct target_ops *target, char *args, int from_tty)
+{
+  if (record_debug)
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_disconnect\n");
+
+  unpush_target (&record_ops);
+  target_disconnect (args, from_tty);
+}
+
+static void
+record_detach (struct target_ops *ops, char *args, int from_tty)
+{
+  if (record_debug)
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_detach\n");
+
+  unpush_target (&record_ops);
+  target_detach (args, from_tty);
+}
+
+static void
+record_mourn_inferior (struct target_ops *ops)
+{
+  if (record_debug)
+    fprintf_unfiltered (gdb_stdlog, "Process record: "
+                                   "record_mourn_inferior\n");
+
+  unpush_target (&record_ops);
+  target_mourn_inferior ();
+}
+
+/* Close process record target before killing the inferior process.  */
+
+static void
+record_kill (struct target_ops *ops)
+{
+  if (record_debug)
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n");
+
+  unpush_target (&record_ops);
+  target_kill ();
+}
+
+/* Record registers change (by user or by GDB) to list as an instruction.  */
+
+static void
+record_registers_change (struct regcache *regcache, int regnum)
+{
+  /* Check record_insn_num.  */
+  record_check_insn_num (0);
+
+  record_arch_list_head = NULL;
+  record_arch_list_tail = NULL;
+
+  if (regnum < 0)
+    {
+      int i;
+      for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
+       {
+         if (record_arch_list_add_reg (regcache, i))
+           {
+             record_list_release (record_arch_list_tail);
+             error (_("Process record: failed to record execution log."));
+           }
+       }
+    }
+  else
+    {
+      if (record_arch_list_add_reg (regcache, regnum))
+       {
+         record_list_release (record_arch_list_tail);
+         error (_("Process record: failed to record execution log."));
+       }
+    }
+  if (record_arch_list_add_end ())
+    {
+      record_list_release (record_arch_list_tail);
+      error (_("Process record: failed to record execution log."));
+    }
+  record_list->next = record_arch_list_head;
+  record_arch_list_head->prev = record_list;
+  record_list = record_arch_list_tail;
+
+  if (record_insn_num == record_insn_max_num && record_insn_max_num)
+    record_list_release_first ();
+  else
+    record_insn_num++;
+}
+
+static void
+record_store_registers (struct target_ops *ops, struct regcache *regcache,
+                        int regno)
+{
+  if (!record_gdb_operation_disable)
+    {
+      if (RECORD_IS_REPLAY)
+       {
+         int n;
+         struct cleanup *old_cleanups;
+
+         /* Let user choose if he wants to write register or not.  */
+         if (regno < 0)
+           n =
+             nquery (_("Because GDB is in replay mode, changing the "
+                       "value of a register will make the execution "
+                       "log unusable from this point onward.  "
+                       "Change all registers?"));
+         else
+           n =
+             nquery (_("Because GDB is in replay mode, changing the value "
+                       "of a register will make the execution log unusable "
+                       "from this point onward.  Change register %s?"),
+                     gdbarch_register_name (get_regcache_arch (regcache),
+                                              regno));
+
+         if (!n)
+           {
+             /* Invalidate the value of regcache that was set in function
+                "regcache_raw_write".  */
+             if (regno < 0)
+               {
+                 int i;
+                 for (i = 0;
+                      i < gdbarch_num_regs (get_regcache_arch (regcache));
+                      i++)
+                   regcache_invalidate (regcache, i);
+               }
+             else
+               regcache_invalidate (regcache, regno);
+
+             error (_("Process record canceled the operation."));
+           }
+
+         /* Destroy the record from here forward.  */
+         record_list_release_next ();
+       }
+
+      record_registers_change (regcache, regno);
+    }
+  record_beneath_to_store_registers (record_beneath_to_store_registers_ops,
+                                     regcache, regno);
+}
+
+/* Behavior is conditional on RECORD_IS_REPLAY.
+   In replay mode, we cannot write memory unles we are willing to
+   invalidate the record/replay log from this point forward.  */
+
+static LONGEST
+record_xfer_partial (struct target_ops *ops, enum target_object object,
+                    const char *annex, gdb_byte *readbuf,
+                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+{
+  if (!record_gdb_operation_disable
+      && (object == TARGET_OBJECT_MEMORY
+         || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
+    {
+      if (RECORD_IS_REPLAY)
+       {
+         /* Let user choose if he wants to write memory or not.  */
+         if (!nquery (_("Because GDB is in replay mode, writing to memory "
+                        "will make the execution log unusable from this "
+                        "point onward.  Write memory at address 0x%s?"),
+                      paddr_nz (offset)))
+           return -1;
+
+         /* Destroy the record from here forward.  */
+         record_list_release_next ();
+       }
+
+      /* Check record_insn_num */
+      record_check_insn_num (0);
+
+      /* Record registers change to list as an instruction.  */
+      record_arch_list_head = NULL;
+      record_arch_list_tail = NULL;
+      if (record_arch_list_add_mem (offset, len))
+       {
+         record_list_release (record_arch_list_tail);
+         if (record_debug)
+           fprintf_unfiltered (gdb_stdlog,
+                               _("Process record: failed to record "
+                                 "execution log."));
+         return -1;
+       }
+      if (record_arch_list_add_end ())
+       {
+         record_list_release (record_arch_list_tail);
+         if (record_debug)
+           fprintf_unfiltered (gdb_stdlog,
+                               _("Process record: failed to record "
+                                 "execution log."));
+         return -1;
+       }
+      record_list->next = record_arch_list_head;
+      record_arch_list_head->prev = record_list;
+      record_list = record_arch_list_tail;
+
+      if (record_insn_num == record_insn_max_num && record_insn_max_num)
+       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.  */
+
+static int
+record_insert_breakpoint (struct bp_target_info *bp_tgt)
+{
+  if (!RECORD_IS_REPLAY)
+    {
+      struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
+      int ret = record_beneath_to_insert_breakpoint (bp_tgt);
+
+      do_cleanups (old_cleanups);
+
+      return ret;
+    }
+
+  return 0;
+}
+
+static int
+record_remove_breakpoint (struct bp_target_info *bp_tgt)
+{
+  if (!RECORD_IS_REPLAY)
+    {
+      struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
+      int ret = record_beneath_to_remove_breakpoint (bp_tgt);
+
+      do_cleanups (old_cleanups);
+
+      return ret;
+    }
+
+  return 0;
+}
+
+static int
+record_can_execute_reverse (void)
+{
+  return 1;
+}
+
+static void
+init_record_ops (void)
+{
+  record_ops.to_shortname = "record";
+  record_ops.to_longname = "Process record and replay target";
+  record_ops.to_doc =
+    "Log program while executing and replay execution from log.";
+  record_ops.to_open = record_open;
+  record_ops.to_close = record_close;
+  record_ops.to_resume = record_resume;
+  record_ops.to_wait = record_wait;
+  record_ops.to_disconnect = record_disconnect;
+  record_ops.to_detach = record_detach;
+  record_ops.to_mourn_inferior = record_mourn_inferior;
+  record_ops.to_kill = record_kill;
+  record_ops.to_create_inferior = find_default_create_inferior;
+  record_ops.to_store_registers = record_store_registers;
+  record_ops.to_xfer_partial = record_xfer_partial;
+  record_ops.to_insert_breakpoint = record_insert_breakpoint;
+  record_ops.to_remove_breakpoint = record_remove_breakpoint;
+  record_ops.to_can_execute_reverse = record_can_execute_reverse;
+  record_ops.to_stratum = record_stratum;
+  record_ops.to_magic = OPS_MAGIC;
+}
+
+static void
+show_record_debug (struct ui_file *file, int from_tty,
+                  struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file, _("Debugging of process record target is %s.\n"),
+                   value);
+}
+
+/* Alias for "target record".  */
+
+static void
+cmd_record_start (char *args, int from_tty)
+{
+  execute_command ("target record", from_tty);
+}
+
+/* Truncate the record log from the present point
+   of replay until the end.  */
+
+static void
+cmd_record_delete (char *args, int from_tty)
+{
+  if (current_target.to_stratum == record_stratum)
+    {
+      if (RECORD_IS_REPLAY)
+       {
+         if (!from_tty || query (_("Delete the log from this point forward "
+                                   "and begin to record the running message "
+                                   "at current PC?")))
+           record_list_release_next ();
+       }
+      else
+         printf_unfiltered (_("Already at end of record list.\n"));
+
+    }
+  else
+    printf_unfiltered (_("Process record is not started.\n"));
+}
+
+/* Implement the "stoprecord" command.  */
+
+static void
+cmd_record_stop (char *args, int from_tty)
+{
+  if (current_target.to_stratum == record_stratum)
+    {
+      if (!record_list || !from_tty || query (_("Delete recorded log and "
+                                               "stop recording?")))
+       unpush_target (&record_ops);
+    }
+  else
+    printf_unfiltered (_("Process record is not started.\n"));
+}
+
+/* Set upper limit of record log size.  */
+
+static void
+set_record_insn_max_num (char *args, int from_tty, struct cmd_list_element *c)
+{
+  if (record_insn_num > record_insn_max_num && record_insn_max_num)
+    {
+      printf_unfiltered (_("Record instructions number is bigger than "
+                          "record instructions max number.  Auto delete "
+                          "the first ones?\n"));
+
+      while (record_insn_num > record_insn_max_num)
+       record_list_release_first ();
+    }
+}
+
+/* Print the current index into the record log (number of insns recorded
+   so far).  */
+
+static void
+show_record_insn_number (char *ignore, int from_tty)
+{
+  printf_unfiltered (_("Record instruction number is %d.\n"),
+                    record_insn_num);
+}
+
+static struct cmd_list_element *record_cmdlist, *set_record_cmdlist,
+                              *show_record_cmdlist, *info_record_cmdlist;
+
+static void
+set_record_command (char *args, int from_tty)
+{
+  printf_unfiltered (_("\
+\"set record\" must be followed by an apporpriate subcommand.\n"));
+  help_list (set_record_cmdlist, "set record ", all_commands, gdb_stdout);
+}
+
+static void
+show_record_command (char *args, int from_tty)
+{
+  cmd_show_list (show_record_cmdlist, from_tty, "");
+}
+
+static void
+info_record_command (char *args, int from_tty)
+{
+  cmd_show_list (info_record_cmdlist, from_tty, "");
+}
+
+void
+_initialize_record (void)
+{
+  /* Init record_first.  */
+  record_first.prev = NULL;
+  record_first.next = NULL;
+  record_first.type = record_end;
+
+  init_record_ops ();
+  add_target (&record_ops);
+
+  add_setshow_zinteger_cmd ("record", no_class, &record_debug,
+                           _("Set debugging of record/replay feature."),
+                           _("Show debugging of record/replay feature."),
+                           _("When enabled, debugging output for "
+                             "record/replay feature is displayed."),
+                           NULL, show_record_debug, &setdebuglist,
+                           &showdebuglist);
+
+  add_prefix_cmd ("record", class_obscure, cmd_record_start,
+                 _("Abbreviated form of \"target record\" command."),
+                 &record_cmdlist, "record ", 0, &cmdlist);
+  add_com_alias ("rec", "record", class_obscure, 1);
+  add_prefix_cmd ("record", class_support, set_record_command,
+                 _("Set record options"), &set_record_cmdlist,
+                 "set record ", 0, &setlist);
+  add_alias_cmd ("rec", "record", class_obscure, 1, &setlist);
+  add_prefix_cmd ("record", class_support, show_record_command,
+                 _("Show record options"), &show_record_cmdlist,
+                 "show record ", 0, &showlist);
+  add_alias_cmd ("rec", "record", class_obscure, 1, &showlist);
+  add_prefix_cmd ("record", class_support, info_record_command,
+                 _("Info record options"), &info_record_cmdlist,
+                 "info record ", 0, &infolist);
+  add_alias_cmd ("rec", "record", class_obscure, 1, &infolist);
+
+
+  add_cmd ("delete", class_obscure, cmd_record_delete,
+          _("Delete the rest of execution log and start recording it anew."),
+           &record_cmdlist);
+  add_alias_cmd ("d", "delete", class_obscure, 1, &record_cmdlist);
+  add_alias_cmd ("del", "delete", class_obscure, 1, &record_cmdlist);
+
+  add_cmd ("stop", class_obscure, cmd_record_stop,
+          _("Stop the record/replay target."),
+           &record_cmdlist);
+  add_alias_cmd ("s", "stop", class_obscure, 1, &record_cmdlist);
+
+  /* Record instructions number limit command.  */
+  add_setshow_boolean_cmd ("stop-at-limit", no_class,
+                           &record_stop_at_limit,
+                           _("Set whether record/replay stop when "
+                             "record/replay buffer becomes full."),
+                           _("Show whether record/replay stop when "
+                             "record/replay buffer becomes full."),
+                           _("Enable is default value.\n"
+                             "When enabled, if the record/replay buffer "
+                             "becomes full,\n"
+                              "ask user what to do.\n"
+                              "When disabled, if the record/replay buffer "
+                             "becomes full,\n"
+                              "delete it and start new recording."),
+                           NULL, NULL,
+                            &set_record_cmdlist, &show_record_cmdlist);
+  add_setshow_zinteger_cmd ("insn-number-max", no_class,
+                           &record_insn_max_num,
+                           _("Set record/replay buffer limit."),
+                           _("Show record/replay buffer limit."),
+                           _("Set the maximum number of instructions to be "
+                              "stored in the\n"
+                              "record/replay buffer.  "
+                              "Zero means unlimited (default 200000)."),
+                           set_record_insn_max_num,
+                           NULL, &set_record_cmdlist, &show_record_cmdlist);
+  add_cmd ("insn-number", class_obscure, show_record_insn_number,
+           _("Show the current number of instructions in the "
+             "record/replay buffer."), &info_record_cmdlist);
+}
diff --git a/gdb/record.h b/gdb/record.h
new file mode 100644 (file)
index 0000000..d4049ea
--- /dev/null
@@ -0,0 +1,32 @@
+/* Process record and replay target for GDB, the GNU debugger.
+
+   Copyright (C) 2008, 2009 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/>.  */
+
+#ifndef _RECORD_H_
+#define _RECORD_H_
+
+#define RECORD_IS_USED (current_target.to_stratum == record_stratum)
+
+extern int record_debug;
+
+extern int record_arch_list_add_reg (struct regcache *regcache, int num);
+extern int record_arch_list_add_mem (CORE_ADDR addr, int len);
+extern int record_arch_list_add_end (void);
+extern struct cleanup *record_gdb_operation_disable_set (void);
+
+#endif /* _RECORD_H_ */