[rfc 0/8] refactor record

[rfc 0/8] refactor record

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Hi Jan,

Here's an updated version of the record.c refactoring incorporating your
comments and adding two new commands I plan to implement for record-btrace.

The series will not apply to the current master since i'm not resending some
already approved patches.

I tried pushing the entire series into archer but I seem to lack permissions.

I ran the gdb.reverse suite without regressions on 64bit IA gnu/linux.


Markus Metzger (8):
  record: make it build again
  record-full.c: rename record_ in record_full_.
  record-full.h: rename record_ into record_full_
  record: default target methods.
  record: add "record disassemble" command
  record disas: omit function names by default
  record: add "record backtrace" command
  record: add "record list" command

 gdb/Makefile.in        |    5 +-
 gdb/amd64-linux-tdep.c |   53 +-
 gdb/arm-tdep.c         |   12 +-
 gdb/i386-linux-tdep.c  |   30 +-
 gdb/i386-tdep.c        |  465 +++++++-------
 gdb/infrun.c           |    3 +-
 gdb/linux-record.c     |  544 ++++++++-------
 gdb/moxie-tdep.c       |   85 ++--
 gdb/record-full.c      | 1775 ++++++++++++++++++++++++++++--------------------
 gdb/record-full.h      |   10 +-
 gdb/record.c           |  696 ++++++++++++++-----
 gdb/record.h           |   30 +
 gdb/target.c           |  231 +++++++
 gdb/target.h           |   81 +++
 14 files changed, 2505 insertions(+), 1515 deletions(-)

[rfc 4/8] record: default target methods.

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Provide default target methods for record targets that are likely to be shared
between different record targets.

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

	* record.h (record_disconnect): New.
	(record_detach): New.
	(record_mourn_inferior): New.
	(record_kill): New.
	* record-full.c (record_disconnect, record_detach,
	record_mourn_inferior, record_kill): Move to...
	* record.c: ...here.
	(DEBUG): New.
	(record_unpush): New.
	(cmd_record_stop): Use record_unpush.
	(record_disconnect, record_detach, record_mourn_inferior,
	record_kill): Use record_unpush and DEBUG.


---
 gdb/record-full.c |   58 +++---------------------------------------
 gdb/record.c      |   72 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 gdb/record.h      |   12 +++++++++
 3 files changed, 84 insertions(+), 58 deletions(-)

diff --git a/gdb/record-full.c b/gdb/record-full.c
index 351b1e8..e5f7c62 100644
--- a/gdb/record-full.c
+++ b/gdb/record-full.c
@@ -1526,56 +1526,6 @@ record_full_stopped_by_watchpoint (void)
     return record_full_beneath_to_stopped_by_watchpoint ();
 }
 
-/* "to_disconnect" method for process record target.  */
-
-static void
-record_full_disconnect (struct target_ops *target, char *args, int from_tty)
-{
-  if (record_debug)
-    fprintf_unfiltered (gdb_stdlog,
-			"Process record: record_full_disconnect\n");
-
-  unpush_target (&record_full_ops);
-  target_disconnect (args, from_tty);
-}
-
-/* "to_detach" method for process record target.  */
-
-static void
-record_full_detach (struct target_ops *ops, char *args, int from_tty)
-{
-  if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_detach\n");
-
-  unpush_target (&record_full_ops);
-  target_detach (args, from_tty);
-}
-
-/* "to_mourn_inferior" method for process record target.  */
-
-static void
-record_full_mourn_inferior (struct target_ops *ops)
-{
-  if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: "
-			            "record_full_mourn_inferior\n");
-
-  unpush_target (&record_full_ops);
-  target_mourn_inferior ();
-}
-
-/* Close process record target before killing the inferior process.  */
-
-static void
-record_full_kill (struct target_ops *ops)
-{
-  if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_kill\n");
-
-  unpush_target (&record_full_ops);
-  target_kill ();
-}
-
 static int
 record_full_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
 {
@@ -2120,10 +2070,10 @@ init_record_full_ops (void)
   record_full_ops.to_close = record_full_close;
   record_full_ops.to_resume = record_full_resume;
   record_full_ops.to_wait = record_full_wait;
-  record_full_ops.to_disconnect = record_full_disconnect;
-  record_full_ops.to_detach = record_full_detach;
-  record_full_ops.to_mourn_inferior = record_full_mourn_inferior;
-  record_full_ops.to_kill = record_full_kill;
+  record_full_ops.to_disconnect = record_disconnect;
+  record_full_ops.to_detach = record_detach;
+  record_full_ops.to_mourn_inferior = record_mourn_inferior;
+  record_full_ops.to_kill = record_kill;
   record_full_ops.to_create_inferior = find_default_create_inferior;
   record_full_ops.to_store_registers = record_full_store_registers;
   record_full_ops.to_xfer_partial = record_full_xfer_partial;
diff --git a/gdb/record.c b/gdb/record.c
index 8b44717..abd8216 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -33,6 +33,10 @@ struct cmd_list_element *set_record_cmdlist = NULL;
 struct cmd_list_element *show_record_cmdlist = NULL;
 struct cmd_list_element *info_record_cmdlist = NULL;
 
+#define DEBUG(msg, args...)						\
+  if (record_debug)							\
+    fprintf_unfiltered (gdb_stdlog, "record: " msg "\n", ##args)
+
 /* Find the record target in the target stack.  */
 
 static struct target_ops *
@@ -71,13 +75,73 @@ record_read_memory (struct gdbarch *gdbarch,
 {
   int ret = target_read_memory (memaddr, myaddr, len);
 
-  if (ret && record_debug)
-    printf_unfiltered (_("Process record: error reading memory "
-			 "at addr %s len = %ld.\n"),
-		       paddress (gdbarch, memaddr), (long) len);
+  if (ret != 0)
+    DEBUG ("error reading memory at addr %s len = %ld.\n",
+	   paddress (gdbarch, memaddr), (long) len);
+
   return ret;
 }
 
+/* Unpush the record target.  */
+
+static void
+record_unpush (void)
+{
+  struct target_ops *t;
+
+  t = find_record_target ();
+  if (t == NULL)
+    internal_error (__FILE__, __LINE__, _("Couldn't find record target."));
+
+  DEBUG ("unpush %s", t->to_shortname);
+
+  unpush_target (t);
+}
+
+/* See record.h.  */
+
+void
+record_disconnect (struct target_ops *target, char *args, int from_tty)
+{
+  DEBUG ("disconnect");
+
+  record_unpush ();
+  target_disconnect (args, from_tty);
+}
+
+/* See record.h.  */
+
+void
+record_detach (struct target_ops *ops, char *args, int from_tty)
+{
+  DEBUG ("detach");
+
+  record_unpush ();
+  target_detach (args, from_tty);
+}
+
+/* See record.h.  */
+
+void
+record_mourn_inferior (struct target_ops *ops)
+{
+  DEBUG ("mourn_inferior");
+
+  record_unpush ();
+  target_mourn_inferior ();
+}
+
+/* See record.h.  */
+
+void
+record_kill (struct target_ops *ops)
+{
+  DEBUG ("kill");
+
+  record_unpush ();
+  target_kill ();
+}
+
 /* Implement "show record debug" command.  */
 
 static void
diff --git a/gdb/record.h b/gdb/record.h
index b428eaf..04d6b4a 100644
--- a/gdb/record.h
+++ b/gdb/record.h
@@ -41,4 +41,16 @@ extern int record_read_memory (struct gdbarch *gdbarch,
 /* The "record goto" command.  */
 extern void cmd_record_goto (char *arg, int from_tty);
 
+/* The default "to_disconnect" target method for record targets.  */
+extern void record_disconnect (struct target_ops *, char *, int);
+
+/* The default "to_detach" target method for record targets.  */
+extern void record_detach (struct target_ops *, char *, int);
+
+/* The default "to_mourn_inferior" target method for record targets.  */
+extern void record_mourn_inferior (struct target_ops *);
+
+/* The default "to_kill" target method for record targets.  */
+extern void record_kill (struct target_ops *);
+
 #endif /* _RECORD_H_ */
-- 
1.7.1

[rfc 5/8] record: add "record disassemble" command

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Add a command to provide a disassembly of the execution trace log.

Approved by Jan Kratochvil.

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

	* target.h (target_ops): Add to_disas_record and
	to_disas_record_range fields.
	(target_disas_record): New.
	(target_disas_record_range): New.
	* target.c (target_disas_record): New.
	(target_disas_record_range): New.
	* record.c: Include cli/cli-utils.h, disasm.h, ctype.h.
	(record_disas_size): New.
	(get_insn_number): New.
	(get_disas_modifiers): New.
	(cmd_record_disas): New.
	(_initialize_record): Add "set/show record disas-size" command.
	Add "record disassemble" command.


---
 gdb/record.c |  150 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 gdb/target.c |   34 +++++++++++++
 gdb/target.h |   12 +++++
 3 files changed, 196 insertions(+), 0 deletions(-)

diff --git a/gdb/record.c b/gdb/record.c
index abd8216..4f848ce 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -24,10 +24,17 @@
 #include "observer.h"
 #include "inferior.h"
 #include "common/common-utils.h"
+#include "cli/cli-utils.h"
+#include "disasm.h"
+
+#include <ctype.h>
 
 /* This is the debug switch for process record.  */
 unsigned int record_debug = 0;
 
+/* The number of instructions to disassemble in "record disas".  */
+static unsigned int record_disas_size = 10;
+
 struct cmd_list_element *record_cmdlist = NULL;
 struct cmd_list_element *set_record_cmdlist = NULL;
 struct cmd_list_element *show_record_cmdlist = NULL;
@@ -289,6 +296,127 @@ cmd_record_goto (char *arg, int from_tty)
     }
 }
 
+/* Read an instruction number from an argument string.  */
+
+static ULONGEST
+get_insn_number (char **arg)
+{
+  ULONGEST number;
+  const char *begin, *end, *pos;
+
+  begin = *arg;
+  pos = skip_spaces_const (begin);
+
+  if (!isdigit (*pos))
+    error (_("Expected positive number, got: %s."), pos);
+
+  number = strtoulst (pos, &end, 10);
+
+  *arg += (end - begin);
+
+  return number;
+}
+
+/* Read disassembly modifiers from an argument string.  */
+
+static int
+get_disas_modifiers (char **arg)
+{
+  int modifiers;
+  char *args;
+
+  modifiers = 0;
+  args = *arg;
+
+  if (args == NULL)
+    return 0;
+
+  while (*args == '/')
+    {
+      ++args;
+
+      if (*args == '\0')
+	error (_("Missing modifier."));
+
+      for (; *args; ++args)
+	{
+	  if (isspace (*args))
+	    break;
+
+	  if (*args == '/')
+	    continue;
+
+	  switch (*args)
+	    {
+	    case 'm':
+	      modifiers |= DISASSEMBLY_SOURCE;
+	      modifiers |= DISASSEMBLY_FILENAME;
+	      break;
+	    case 'r':
+	      modifiers |= DISASSEMBLY_RAW_INSN;
+	      break;
+	    default:
+	      error (_("Invalid modifier: %c."), *args);
+	    }
+	}
+
+      args = skip_spaces (args);
+    }
+
+  /* Update the argument string.  */
+  *arg = args;
+
+  return modifiers;
+}
+
+/* The "record disassemble" command.  */
+
+static void
+cmd_record_disas (char *arg, int from_tty)
+{
+  int flags;
+
+  require_record_target ();
+
+  flags = get_disas_modifiers (&arg);
+
+  if (arg == NULL || *arg == 0 || strcmp (arg, "+") == 0)
+    target_disas_record ((int) record_disas_size, flags);
+  else if (strcmp (arg, "-") == 0)
+    target_disas_record (- (int) record_disas_size, flags);
+  else
+    {
+      ULONGEST begin, end;
+
+      begin = get_insn_number (&arg);
+
+      if (*arg == ',')
+	{
+	  ++arg;
+	  end = get_insn_number (&arg);
+	}
+      else
+	{
+	  ULONGEST before;
+
+	  /* If the execution log does not start at zero, we might not
+	     disassemble the entire record_disas_size instructions.  */
+
+	  before = record_disas_size / 2;
+	  if (begin < before)
+	    before = begin;
+
+	  begin -= before;
+	  end = begin + record_disas_size;
+	}
+
+      if (*arg != 0)
+	error (_("Junk after argument: %s."), arg);
+
+      target_disas_record_range (begin, end, flags);
+    }
+}
+
 /* Provide a prototype to silence -Wmissing-prototypes.  */
 extern initialize_file_ftype _initialize_record;
 
@@ -305,6 +433,12 @@ _initialize_record (void)
 			     NULL, show_record_debug, &setdebuglist,
 			     &showdebuglist);
 
+  add_setshow_uinteger_cmd ("disas-size", no_class, &record_disas_size, _("\
+Set number of instructions to print in \"record disassemble\"."), _("\
+Show number of instructions to print in \"record disassemble\"."),
+			    NULL, NULL, NULL, &set_record_cmdlist,
+			    &show_record_cmdlist);
+
   c = add_prefix_cmd ("record", class_obscure, cmd_record_start,
 		      _("Start recording."),
 		      &record_cmdlist, "record ", 0, &cmdlist);
@@ -346,4 +480,20 @@ Default filename is 'gdb_record.<process_id>'."),
 Restore the program to its state at instruction number N.\n\
 Argument is instruction number, as shown by 'info record'."),
 	   &record_cmdlist);
+
+  add_cmd ("disassemble", class_obscure, cmd_record_disas, _("\
+Disassemble a section of the execution log.\n\
+With a /m modifier, source lines are included (if available).\n\
+With a /r modifier, raw instructions in hex are included.\n\
+With no argument, disassembles ten more instructions after or around the \
+previous disassembly.\n\
+\"disassemble -\" disassembles ten instructions before a previous ten-line \
+disassembly.\n\
+One argument specifies an instruction, and ten instructions are disassembled \
+around that instruction.\n\
+Two arguments with comma between specify starting and ending instructions to \
+disassemble.\n\
+The number of instructions to disassemble can be defined with \"set record \
+disas-size\"."),
+           &record_cmdlist);
 }
diff --git a/gdb/target.c b/gdb/target.c
index 868ff63..3a03f69 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -4360,6 +4360,40 @@ target_goto_record (ULONGEST insn)
   tcomplain ();
 }
 
+/* See target.h.  */
+
+void
+target_disas_record (int size, int flags)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_disas_record != NULL)
+      {
+	t->to_disas_record (size, flags);
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+void
+target_disas_record_range (ULONGEST begin, ULONGEST end, int flags)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_disas_record_range != NULL)
+      {
+	t->to_disas_record_range (begin, end, flags);
+	return;
+      }
+
+  tcomplain ();
+}
+
 static void
 debug_to_prepare_to_store (struct regcache *regcache)
 {
diff --git a/gdb/target.h b/gdb/target.h
index d416193..4100bb9 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -897,6 +897,12 @@ struct target_ops
     /* Go to a specific location in the recorded execution trace.  */
     void (*to_goto_record) (ULONGEST insn);
 
+    /* Disassemble the recorded execution trace.  */
+    void (*to_disas_record) (int size, int flags);
+
+    /* Disassemble a section of the recorded execution trace.  */
+    void (*to_disas_record_range) (ULONGEST begin, ULONGEST end, int flags);
+
     int to_magic;
     /* Need sub-structure for target machine related rather than comm related?
      */
@@ -1983,4 +1989,10 @@ extern void target_goto_record_end (void);
 /* See to_goto_record in struct target_ops.  */
 extern void target_goto_record (ULONGEST insn);
 
+/* See to_disas_record.  */
+extern void target_disas_record (int size, int flags);
+
+/* See to_disas_record_range.  */
+extern void target_disas_record_range (ULONGEST begin, ULONGEST end, int flags);
+
 #endif /* !defined (TARGET_H) */
-- 
1.7.1

[rfc 8/8] record: add "record list" command

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Add a "record list" command to print a source listing of the recorded execution
log.

The command supports iterating over the execution log similar to the "list"
command.

This is useful for getting a quick overview of the recorded execution trace
without having to reverse-step.

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

	* target.c (target_list_record, target_list_record_range): New.
	* target.h (target_ops) <to_list_record,
	to_list_record_range>: New fields.
	(target_disas_record, target_disas_record_range): New declaration.
	* record.c (get_list_modifiers, cmd_record_list): New.
	(record_list_size): New.
	(_initialize_record): Add the "record list" command.
	Add "set/show record list-size" commands.


---
 gdb/record.c |   92 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 gdb/target.c |   34 +++++++++++++++++++++
 gdb/target.h |   12 +++++++
 3 files changed, 138 insertions(+), 0 deletions(-)

diff --git a/gdb/record.c b/gdb/record.c
index 925e4c1..16cf48a 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -38,6 +38,9 @@ static unsigned int record_disas_size = 10;
 /* The number of functions to print in "record backtrace".  */
 static unsigned int record_backtrace_size = 10;
 
+/* The number of source lines to print in "record list".  */
+static unsigned int record_list_size = 10;
+
 struct cmd_list_element *record_cmdlist = NULL;
 struct cmd_list_element *set_record_cmdlist = NULL;
 struct cmd_list_element *show_record_cmdlist = NULL;
@@ -512,6 +515,75 @@ cmd_record_backtrace (char *arg, int from_tty)
     }
 }
 
+/* Read "record list" modifiers from an argument string.  */
+
+static int
+get_list_modifiers (char **arg)
+{
+  int modifiers;
+  char *args;
+
+  modifiers = 0;
+  args = *arg;
+
+  if (args == NULL)
+    return 0;
+
+  while (*args == '/')
+    {
+      ++args;
+
+      if (*args == '\0')
+	error (_("Missing modifier."));
+
+      for (; *args; ++args)
+	{
+	  if (isspace (*args))
+	    break;
+
+	  if (*args == '/')
+	    continue;
+
+	  switch (*args)
+	    {
+	    default:
+	      error (_("Invalid modifier: %c."), *args);
+	    }
+	}
+
+      args = skip_spaces (args);
+    }
+
+  /* Update the argument string.  */
+  *arg = args;
+
+  return modifiers;
+}
+
+/* The "record list" command.  */
+
+static void
+cmd_record_list (char *arg, int from_tty)
+{
+  int flags;
+
+  require_record_target ();
+
+  flags = get_list_modifiers (&arg);
+
+  if (arg == NULL || *arg == 0 || strcmp (arg, "+") == 0)
+    target_list_record ((int) record_list_size, flags);
+  else if (strcmp (arg, "-") == 0)
+    target_list_record (- (int) record_list_size, flags);
+  else
+    {
+      ULONGEST begin, end;
+
+      get_insn_range (&arg, record_list_size, &begin, &end);
+      target_list_record_range (begin, end, flags);
+    }
+}
+
 /* Provide a prototype to silence -Wmissing-prototypes.  */
 extern initialize_file_ftype _initialize_record;
 
@@ -541,6 +613,13 @@ Show number of functions to print in \"record backtrace\"."),
 			    NULL, NULL, NULL, &set_record_cmdlist,
 			    &show_record_cmdlist);
 
+  add_setshow_uinteger_cmd ("list-size", no_class,
+			    &record_list_size, _("\
+Set number of source lines to print in \"record list\"."), _("\
+Show number of source lines to print in \"record list\"."),
+			    NULL, NULL, NULL, &set_record_cmdlist,
+			    &show_record_cmdlist);
+
   c = add_prefix_cmd ("record", class_obscure, cmd_record_start,
 		      _("Start recording."),
 		      &record_cmdlist, "record ", 0, &cmdlist);
@@ -614,4 +693,17 @@ The number of functions to print can be defined with \"set record \
 backtrace-size\"."),
            &record_cmdlist);
   add_alias_cmd ("bt", "backtrace", class_obscure, 1, &record_cmdlist);
+
+  add_cmd ("list", class_obscure, cmd_record_list, _("\
+Print a list of recorded source lines.\n\
+With no argument, prints ten more source lines after or around the previous \
+ten-line list.\n\
+\"list -\" prints ten source lines before a previous ten-line list.\n\
+One argument specifies an instruction, and a ten source lines list is \
+printed starting at that instruction.\n\
+Two arguments with comma between specify starting and ending instructions. \
+Prints all source lines in this range.\n\
+The number of source lines to print can be defined with \"set record \
+list-size\"."),
+           &record_cmdlist);
 }
diff --git a/gdb/target.c b/gdb/target.c
index 940e6b8..0c0e8ae 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -4428,6 +4428,40 @@ target_backtrace_record_range (ULONGEST begin, ULONGEST end, int flags)
   tcomplain ();
 }
 
+/* See target.h.  */
+
+void
+target_list_record (int size, int flags)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_list_record != NULL)
+      {
+	t->to_list_record (size, flags);
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+void
+target_list_record_range (ULONGEST begin, ULONGEST end, int flags)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_list_record_range != NULL)
+      {
+	t->to_list_record_range (begin, end, flags);
+	return;
+      }
+
+  tcomplain ();
+}
+
 static void
 debug_to_prepare_to_store (struct regcache *regcache)
 {
diff --git a/gdb/target.h b/gdb/target.h
index b670660..0ebb402 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -909,6 +909,12 @@ struct target_ops
     /* Print a function trace of an execution trace section.  */
     void (*to_backtrace_record_range) (ULONGEST begin, ULONGEST end, int flags);
 
+    /* Print a source listing for the recorded execution trace.  */
+    void (*to_list_record) (int size, int flags);
+
+    /* Print a source listing for an execution trace section.  */
+    void (*to_list_record_range) (ULONGEST begin, ULONGEST end, int flags);
+
     int to_magic;
     /* Need sub-structure for target machine related rather than comm related?
      */
@@ -2008,4 +2014,10 @@ extern void target_backtrace_record (int size, int flags);
 extern void target_backtrace_record_range (ULONGEST begin, ULONGEST end,
 					   int flags);
 
+/* See to_list_record.  */
+extern void target_list_record (int size, int flags);
+
+/* See to_list_record_range.  */
+extern void target_list_record_range (ULONGEST begin, ULONGEST end, int flags);
+
 #endif /* !defined (TARGET_H) */
-- 
1.7.1

[rfc 7/8] record: add "record backtrace" command

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Add a "record backtrace" command to print a backtrace of recorded functions.

The command supports iterating over the execution log similar to the "list"
command.

This command provides a quick high-level overview over the recorded execution
log without having to reverse-step.

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

	* target.c (target_backtrace_record): New.
	(target_backtrace_record_range): New.
	* target.h (target_ops) <to_backtrace_record,
	to_backtrace_record_range>: New fields.
	(target_disas_record, target_disas_record_range): New declaration.
	* record.c (get_insn_range, get_backtrace_modifiers,
	cmd_record_backtrace, record_backtrace_size): New.
	(_initialize_record): Add the "record backtrace" command.
	Add an alias "record bt" to it. Add "set/show record
	backtrace-size" commands.
	* record.h (record_print_flag): New.


---
 gdb/record.c |  145 ++++++++++++++++++++++++++++++++++++++++++++++++++-------
 gdb/record.h |    7 +++
 gdb/target.c |   34 ++++++++++++++
 gdb/target.h |   13 +++++
 4 files changed, 181 insertions(+), 18 deletions(-)

diff --git a/gdb/record.c b/gdb/record.c
index 3ac4765..925e4c1 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -35,6 +35,9 @@ unsigned int record_debug = 0;
 /* The number of instructions to disassemble in "record disas".  */
 static unsigned int record_disas_size = 10;
 
+/* The number of functions to print in "record backtrace".  */
+static unsigned int record_backtrace_size = 10;
+
 struct cmd_list_element *record_cmdlist = NULL;
 struct cmd_list_element *set_record_cmdlist = NULL;
 struct cmd_list_element *show_record_cmdlist = NULL;
@@ -317,6 +320,42 @@ get_insn_number (char **arg)
   return number;
 }
 
+/* Read an instruction range from an argument string.  */
+
+static void
+get_insn_range (char **arg, unsigned int context,
+		ULONGEST *pbegin, ULONGEST *pend)
+{
+  ULONGEST begin, end;
+
+  begin = get_insn_number (arg);
+
+  if (**arg == ',')
+    {
+      *arg += 1;
+      end = get_insn_number (arg);
+    }
+  else
+    {
+      ULONGEST before;
+
+      /* If the execution log does not start at zero, we might not
+	 cover the entire context.  */
+      before = context / 2;
+      if (begin < before)
+	before = begin;
+
+      begin -= before;
+      end = begin + context;
+    }
+
+  if (**arg != 0)
+    error (_("Junk after argument: %s."), *arg);
+
+  *pbegin = begin;
+  *pend = end;
+}
+
 /* Read disassembly modifiers from an argument string.  */
 
 static int
@@ -396,32 +435,80 @@ cmd_record_disas (char *arg, int from_tty)
     {
       ULONGEST begin, end;
 
-      begin = get_insn_number (&arg);
+      get_insn_range (&arg, record_disas_size, &begin, &end);
+      target_disas_record_range (begin, end, flags);
+    }
+}
+
+/* Read backtrace modifiers from an argument string.  */
+
+static int
+get_backtrace_modifiers (char **arg)
+{
+  int modifiers;
+  char *args;
+
+  modifiers = 0;
+  args = *arg;
+
+  if (args == NULL)
+    return modifiers;
+
+  while (*args == '/')
+    {
+      ++args;
 
-      if (*arg == ',')
+      if (*args == '\0')
+	error (_("Missing modifier."));
+
+      for (; *args; ++args)
 	{
-	  ++arg;
-	  end = get_insn_number (&arg);
+	  if (isspace (*args))
+	    break;
+
+	  if (*args == '/')
+	    continue;
+
+	  switch (*args)
+	    {
+	    case 'l':
+	      modifiers |= record_print_src_line;
+	      break;
+	    default:
+	      error (_("Invalid modifier: %c."), *args);
+	    }
 	}
-      else
-	{
-	  ULONGEST before;
 
-	  /* If the execution log does not start at zero, we might not
-	     disassemble the entire record_disas_size instructions.  */
+      args = skip_spaces (args);
+    }
 
-	  before = record_disas_size / 2;
-	  if (begin < before)
-	    before = begin;
+  /* Update the argument string.  */
+  *arg = args;
 
-	  begin -= before;
-	  end = begin + record_disas_size;
-	}
+  return modifiers;
+}
 
-      if (*arg != 0)
-	error (_("Junk after argument: %s."), arg);
+/* The "record backtrace" command.  */
 
-      target_disas_record_range (begin, end, flags);
+static void
+cmd_record_backtrace (char *arg, int from_tty)
+{
+  int flags;
+
+  require_record_target ();
+
+  flags = get_backtrace_modifiers (&arg);
+
+  if (arg == NULL || *arg == 0 || strcmp (arg, "+") == 0)
+    target_backtrace_record ((int) record_backtrace_size, flags);
+  else if (strcmp (arg, "-") == 0)
+    target_backtrace_record (- (int) record_backtrace_size, flags);
+  else
+    {
+      ULONGEST begin, end;
+
+      get_insn_range (&arg, record_backtrace_size, &begin, &end);
+      target_backtrace_record_range (begin, end, flags);
     }
 }
 
@@ -447,6 +534,13 @@ Show number of instructions to print in \"record disassemble\"."),
 			    NULL, NULL, NULL, &set_record_cmdlist,
 			    &show_record_cmdlist);
 
+  add_setshow_uinteger_cmd ("backtrace-size", no_class,
+			    &record_backtrace_size, _("\
+Set number of function to print in \"record backtrace\"."), _("\
+Show number of functions to print in \"record backtrace\"."),
+			    NULL, NULL, NULL, &set_record_cmdlist,
+			    &show_record_cmdlist);
+
   c = add_prefix_cmd ("record", class_obscure, cmd_record_start,
 		      _("Start recording."),
 		      &record_cmdlist, "record ", 0, &cmdlist);
@@ -505,4 +599,19 @@ disassemble.\n\
 The number of instructions to disassemble can be defined with \"set record \
 disas-size\"."),
            &record_cmdlist);
+
+  add_cmd ("backtrace", class_obscure, cmd_record_backtrace, _("\
+Print a backtrace of recorded functions.\n\
+With a /l modifier, the source file and line number is included.\n\
+With no argument, prints ten more functions after or around the previous \
+backtrace.\n\
+\"backtrace -\" prints ten functions before a previous ten-line backtrace.\n\
+One argument specifies an instruction, and a ten function backtrace is \
+printed starting at that instruction.\n\
+Two arguments with comma between specify starting and ending instructions. \
+Prints all functions in this range.\n\
+The number of functions to print can be defined with \"set record \
+backtrace-size\"."),
+           &record_cmdlist);
+  add_alias_cmd ("bt", "backtrace", class_obscure, 1, &record_cmdlist);
 }
diff --git a/gdb/record.h b/gdb/record.h
index 04d6b4a..e9d4bcd 100644
--- a/gdb/record.h
+++ b/gdb/record.h
@@ -32,6 +32,13 @@ extern struct cmd_list_element *set_record_cmdlist;
 extern struct cmd_list_element *show_record_cmdlist;
 extern struct cmd_list_element *info_record_cmdlist;
 
+/* A list of flags specifying what record target methods should print.  */
+enum record_print_flag
+  {
+    /* Print the source file and line (if applicable).  */
+    record_print_src_line = (1 << 0)
+  };
+
 /* Wrapper for target_read_memory that prints a debug message if
    reading memory fails.  */
 extern int record_read_memory (struct gdbarch *gdbarch,
diff --git a/gdb/target.c b/gdb/target.c
index 3a03f69..940e6b8 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -4394,6 +4394,40 @@ target_disas_record_range (ULONGEST begin, ULONGEST end, int flags)
   tcomplain ();
 }
 
+/* See target.h.  */
+
+void
+target_backtrace_record (int size, int flags)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_backtrace_record != NULL)
+      {
+	t->to_backtrace_record (size, flags);
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+void
+target_backtrace_record_range (ULONGEST begin, ULONGEST end, int flags)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_backtrace_record_range != NULL)
+      {
+	t->to_backtrace_record_range (begin, end, flags);
+	return;
+      }
+
+  tcomplain ();
+}
+
 static void
 debug_to_prepare_to_store (struct regcache *regcache)
 {
diff --git a/gdb/target.h b/gdb/target.h
index 4100bb9..b670660 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -903,6 +903,12 @@ struct target_ops
     /* Disassemble a section of the recorded execution trace.  */
     void (*to_disas_record_range) (ULONGEST begin, ULONGEST end, int flags);
 
+    /* Print a function trace of the recorded execution trace.  */
+    void (*to_backtrace_record) (int size, int flags);
+
+    /* Print a function trace of an execution trace section.  */
+    void (*to_backtrace_record_range) (ULONGEST begin, ULONGEST end, int flags);
+
     int to_magic;
     /* Need sub-structure for target machine related rather than comm related?
      */
@@ -1995,4 +2001,11 @@ extern void target_disas_record (int size, int flags);
 /* See to_disas_record_range.  */
 extern void target_disas_record_range (ULONGEST begin, ULONGEST end, int flags);
 
+/* See to_backtrace_record.  */
+extern void target_backtrace_record (int size, int flags);
+
+/* See to_backtrace_record_range.  */
+extern void target_backtrace_record_range (ULONGEST begin, ULONGEST end,
+					   int flags);
+
 #endif /* !defined (TARGET_H) */
-- 
1.7.1

[rfc 6/8] record disas: omit function names by default

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Omit function names in the disassembly of the "record disassemble" command
unless the "/f" modifier is specified.

This helps align the disassembly output across functions.  The branch
destination is already obvious from the instruction order.

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

	* record.c (get_disas_modifiers): Set DISASSEMBLY_OMIT_FNAME
	unless /f is given.
	(_initialize_record): Update the "record disassemble" help text.


---
 gdb/record.c |   11 ++++++++++-
 1 files changed, 10 insertions(+), 1 deletions(-)

diff --git a/gdb/record.c b/gdb/record.c
index 4f848ce..3ac4765 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -328,8 +328,13 @@ get_disas_modifiers (char **arg)
   modifiers = 0;
   args = *arg;
 
+  /* By default, we omit the function name to keep the disassembly better
+     aligned.  The branch destination is obvious from the instruction order
+     in the disassembly.  */
+  modifiers |= DISASSEMBLY_OMIT_FNAME;
+
   if (args == NULL)
-    return 0;
+    return modifiers;
 
   while (*args == '/')
     {
@@ -355,6 +360,9 @@ get_disas_modifiers (char **arg)
 	    case 'r':
 	      modifiers |= DISASSEMBLY_RAW_INSN;
 	      break;
+	    case 'f':
+	      modifiers &= ~DISASSEMBLY_OMIT_FNAME;
+	      break;
 	    default:
 	      error (_("Invalid modifier: %c."), *args);
 	    }
@@ -485,6 +493,7 @@ Argument is instruction number, as shown by 'info record'."),
 Disassemble a section of the execution log.\n\
 With a /m modifier, source lines are included (if available).\n\
 With a /r modifier, raw instructions in hex are included.\n\
+With a /f modifier, function names are included.\n\
 With no argument, disassembles ten more instructions after or around the \
 previous disassembly.\n\
 \"disassemble -\" disassembles ten instructions before a previous ten-line \
-- 
1.7.1

Re: [rfc 6/8] record disas: omit function names by default

[Jan Kratochvil]

On Thu, 14 Feb 2013 17:29:10 +0100, markus.t.metzger@intel.com wrote:
> Omit function names in the disassembly of the "record disassemble" command
> unless the "/f" modifier is specified.
> 
> This helps align the disassembly output across functions.  The branch
> destination is already obvious from the instruction order.

FYI from the user point of view I find the output more readable with /f.
But I do not have practical experience with it, I am fine with it as you wrote
it if you think so.


Just now when playing with the branch the commands record disassemble vs. list
vs. backtrace should have some better short description in the help text.
Particularly record backtrace I had some difficult to understand first.

record disassemble:
Print disassembled instructions as stored in the execution log.

record backtrace:
Print function names from which instruction in the execution log ran.

recost list:
<it is currently not implemented in archer-mmetzger-btrace and I did not dig
out the former patches>


This is just a suggestion, maybe Eli could also suggest some better
formulation.


Thanks,
Jan

Re: [rfc 6/8] record disas: omit function names by default

[Eli Zaretskii]

> Date: Fri, 15 Feb 2013 17:10:49 +0100
> From: Jan Kratochvil <jan.kratochvil@redhat.com>
> Cc: gdb-patches@sourceware.org, markus.t.metzger@gmail.com
> 
> record disassemble:
> Print disassembled instructions as stored in the execution log.

Sounds good.

> record backtrace:
> Print function names from which instruction in the execution log ran.

Isn't that just a backtrace?  If so, I suggest

  Print a backtrace starting at the function to which the instruction
  in the log belongs.

Re: [rfc 6/8] record disas: omit function names by default

[Jan Kratochvil]

On Fri, 15 Feb 2013 19:20:45 +0100, Eli Zaretskii wrote:
> > record backtrace:
> > Print function names from which instruction in the execution log ran.
> 
> Isn't that just a backtrace?  If so, I suggest
> 
>   Print a backtrace starting at the function to which the instruction
>   in the log belongs.

That's the problem, the name "backtrace" itself is already a bit confusing.

It is a "backtrace" into history, not into upper frames.
	(gdb) record backtrace 
	_IO_vsnprintf
	_IO_vfprintf_internal
	strchrnul
	_IO_vfprintf_internal
	__GI__IO_default_xsputn
You can see _IO_vfprintf_internal called strchrnul which then returned back to
_IO_vfprintf_internal.  This is not a real "backtrace".

I was already considering renaming the command as the term is a bit overloaded
in the debugger context.

Maybe "record list-functions"?  It is also very similar to the "record list"
command there which lists lines:
      (gdb) btrace list 24-34
      24     in stdio_file_flush () at ../../../git/gdb/ui-file.c:525-529
      25     in ui_file_data () at ../../../git/gdb/ui-file.c:175-180
      26     in stdio_file_flush () at ../../../git/gdb/ui-file.c:522-523
      27     in gdb_flush () at ../../../git/gdb/ui-file.c:185

While I understand "record list" was trying to match the existing "list"
command I do not find it too intuitive, so maybe "record list-lines"?


Thanks,
Jan

Re: [rfc 6/8] record disas: omit function names by default

[Eli Zaretskii]

> Date: Fri, 15 Feb 2013 19:32:56 +0100
> From: Jan Kratochvil <jan.kratochvil@redhat.com>
> Cc: markus.t.metzger@intel.com, gdb-patches@sourceware.org,
>         markus.t.metzger@gmail.com
> 
> It is a "backtrace" into history, not into upper frames.
> 	(gdb) record backtrace 
> 	_IO_vsnprintf
> 	_IO_vfprintf_internal
> 	strchrnul
> 	_IO_vfprintf_internal
> 	__GI__IO_default_xsputn
> You can see _IO_vfprintf_internal called strchrnul which then returned back to
> _IO_vfprintf_internal.  This is not a real "backtrace".
> 
> I was already considering renaming the command as the term is a bit overloaded
> in the debugger context.
> 
> Maybe "record list-functions"?

How about "record trace-functions"?

Re: [rfc 6/8] record disas: omit function names by default

[Jan Kratochvil]

On Fri, 15 Feb 2013 20:05:38 +0100, Eli Zaretskii wrote:
> > It is a "backtrace" into history, not into upper frames.
> > 	(gdb) record backtrace 
> > 	_IO_vsnprintf
> > 	_IO_vfprintf_internal
> > 	strchrnul
> > 	_IO_vfprintf_internal
> > 	__GI__IO_default_xsputn
> > You can see _IO_vfprintf_internal called strchrnul which then returned back to
> > _IO_vfprintf_internal.  This is not a real "backtrace".
> > 
> > I was already considering renaming the command as the term is a bit overloaded
> > in the debugger context.
> > 
> > Maybe "record list-functions"?
> 
> How about "record trace-functions"?

"trace-functions" is fine with me; we'll see what Markus says.


Thanks,
Jan

RE: [rfc 6/8] record disas: omit function names by default

[Metzger, Markus T]

> -----Original Message-----
> From: Jan Kratochvil [mailto:jan.kratochvil@redhat.com]
> Sent: Friday, February 15, 2013 8:10 PM

> On Fri, 15 Feb 2013 20:05:38 +0100, Eli Zaretskii wrote:
> > > It is a "backtrace" into history, not into upper frames.
> > > 	(gdb) record backtrace
> > > 	_IO_vsnprintf
> > > 	_IO_vfprintf_internal
> > > 	strchrnul
> > > 	_IO_vfprintf_internal
> > > 	__GI__IO_default_xsputn
> > > You can see _IO_vfprintf_internal called strchrnul which then returned back to
> > > _IO_vfprintf_internal.  This is not a real "backtrace".
> > >
> > > I was already considering renaming the command as the term is a bit overloaded
> > > in the debugger context.
> > >
> > > Maybe "record list-functions"?
> >
> > How about "record trace-functions"?
> 
> "trace-functions" is fine with me; we'll see what Markus says.

I don't insist on the names I gave those commands, but I'd rather we had a single
word for each command. 

Consider the existing "list" and "backtrace" commands. With the same arguments,
they should be renamed into "list-source-lines" and "list-call-frames";-)
The problem with such command names is that they are awful to type and
abbreviations will be quite cryptic, e.g. "lsl" or "lcf".

Jan described it nicely above: "it's a 'backtrace' into history, not into upper frames".
The term 'backtrace' suggests it's backwards and about functions. Being a "record"
sub-command suggests it's working on the execution log.

The idea of those three new commands is to provide a quick overview of the
execution history at different levels of granularity. Each of those commands
allows iteration similar to the "list" command. The different levels of granularity
are:
  record disassemble ......... instructions
  record list ....................... source lines
  record backtrace ............. functions

I picked those terms for the record sub-commands that are associated with the
respective level of granularity, already.

It takes some practice to read the output of the above commands. Once you got
the hang of it, though, they give a very nice and compact overview of the recorded
control flow. The "record list" command will be the most difficult to make sense of
in the beginning.

The "btrace list" command that Jan mentioned works on blocks, i.e. sequentially
executed code between two branches. This would be between "record list" and
"record backtrace". I have not added a similar command to "record".

Regards,
Markus.
Intel GmbH
Dornacher Strasse 1
85622 Feldkirchen/Muenchen, Deutschland
Sitz der Gesellschaft: Feldkirchen bei Muenchen
Geschaeftsfuehrer: Christian Lamprechter, Hannes Schwaderer, Douglas Lusk
Registergericht: Muenchen HRB 47456
Ust.-IdNr./VAT Registration No.: DE129385895
Citibank Frankfurt a.M. (BLZ 502 109 00) 600119052

Re: [rfc 6/8] record disas: omit function names by default

[Jan Kratochvil]

On Mon, 18 Feb 2013 10:42:44 +0100, Metzger, Markus T wrote:
> I don't insist on the names I gave those commands, but I'd rather we had a single
> word for each command. 

Due to <tab> completion and GDB abbreviations I do not think a single word is
required, as discussed occasionally in other cases on gdb-patches.


> Consider the existing "list" and "backtrace" commands. With the same arguments,
> they should be renamed into "list-source-lines" and "list-call-frames";-)

I see the problem in that these names already have some established meaning
now while you overload these names for a different functionality in btrace.


> Jan described it nicely above: "it's a 'backtrace' into history, not into upper frames".
> The term 'backtrace' suggests it's backwards and about functions. Being a "record"
> sub-command suggests it's working on the execution log.

I got used to it now but for new users it is not obvious enough.

"backtrace" is very fundamental commands of GDB with well known semantics.

Is that "record trace-functions" OK for you?


> The "btrace list" command that Jan mentioned works on blocks, i.e. sequentially
> executed code between two branches. This would be between "record list" and
> "record backtrace". I have not added a similar command to "record".

Is this the intended final state or do you still plan updating
archer-mmetzger-btrace?  I would find the "btrace ..." commands more suitable
to be placed under "record btrace ...", so that one has all the available
"record btrace ..." commands at one place with "record btrace <tab><tab>".

There can be "btrace ..." ones as aliases to them (although I do not think it
is needed, user can create an alias using the 'alias' command easily if
needed).


Thanks,
Jan

RE: [rfc 6/8] record disas: omit function names by default

[Metzger, Markus T]

> -----Original Message-----
> From: gdb-patches-owner@sourceware.org [mailto:gdb-patches-owner@sourceware.org] On Behalf Of Jan Kratochvil
> Sent: Monday, February 18, 2013 2:03 PM

> On Mon, 18 Feb 2013 10:42:44 +0100, Metzger, Markus T wrote:
> > I don't insist on the names I gave those commands, but I'd rather we had a single
> > word for each command.
> 
> Due to <tab> completion and GDB abbreviations I do not think a single word is
> required, as discussed occasionally in other cases on gdb-patches.
>
> > Consider the existing "list" and "backtrace" commands. With the same arguments,
> > they should be renamed into "list-source-lines" and "list-call-frames";-)
> 
> I see the problem in that these names already have some established meaning
> now while you overload these names for a different functionality in btrace.

That's the point I was trying to make with the table in my previous email. I'd rather say
I took those commands and applied them to a recorded execution history.


> > Jan described it nicely above: "it's a 'backtrace' into history, not into upper frames".
> > The term 'backtrace' suggests it's backwards and about functions. Being a "record"
> > sub-command suggests it's working on the execution log.
> 
> I got used to it now but for new users it is not obvious enough.

How long did it take you?


> "backtrace" is very fundamental commands of GDB with well known semantics.
> 
> Is that "record trace-functions" OK for you?

"record trace-functions" sounds like it would enable tracing functions.

If it has to be some two-word combination, I'd rather go with "record list-", i.e.
"record list-functions", "record list-lines", and, for the sake of consistency,
"record list-instructions".

Or are you OK with "record disassemble" and "record list" and just objecting
to "record backtrace"?


> > The "btrace list" command that Jan mentioned works on blocks, i.e. sequentially
> > executed code between two branches. This would be between "record list" and
> > "record backtrace". I have not added a similar command to "record".
> 
> Is this the intended final state or do you still plan updating
> archer-mmetzger-btrace?  I would find the "btrace ..." commands more suitable
> to be placed under "record btrace ...", so that one has all the available
> "record btrace ..." commands at one place with "record btrace <tab><tab>".
> 
> There can be "btrace ..." ones as aliases to them (although I do not think it
> is needed, user can create an alias using the 'alias' command easily if
> needed).

I intend to remove the "btrace" command and all its sub-commands. I just kept them
so people can compare them with the new "record" commands.

Regarding "brace list" I do not plan to add a corresponding "record" command.

Regards,
Markus.
Intel GmbH
Dornacher Strasse 1
85622 Feldkirchen/Muenchen, Deutschland
Sitz der Gesellschaft: Feldkirchen bei Muenchen
Geschaeftsfuehrer: Christian Lamprechter, Hannes Schwaderer, Douglas Lusk
Registergericht: Muenchen HRB 47456
Ust.-IdNr./VAT Registration No.: DE129385895
Citibank Frankfurt a.M. (BLZ 502 109 00) 600119052

Re: [rfc 6/8] record disas: omit function names by default

[Jan Kratochvil]

On Mon, 18 Feb 2013 14:29:48 +0100, Metzger, Markus T wrote:
> How long did it take you?

Longer than a newbie give up on trying to understand it. :-)


> "record trace-functions" sounds like it would enable tracing functions.

I agree.


> If it has to be some two-word combination, I'd rather go with "record list-", i.e.
> "record list-functions", "record list-lines", and, for the sake of consistency,
> "record list-instructions".

Yes.  In fact "record disassemble" (or "btrace disassemble") also do not seem
so obvious to me.


> Or are you OK with "record disassemble" and "record list" and just objecting
> to "record backtrace"?

I primarily object "record backtrace", but those two are also not obvious IMO.


> I intend to remove the "btrace" command and all its sub-commands. I just kept them
> so people can compare them with the new "record" commands.
> 
> Regarding "brace list" I do not plan to add a corresponding "record" command.

What should do the current "record list" hook other than what "btrace list" did?

Current to_list_record and to_list_record_range are always left NULL in
archer-mmetzger-btrace so there isn't what to compare yet:)
(gdb) record list 
You can't do that when your target is `record-btrace'


Thanks,
Jan

RE: [rfc 6/8] record disas: omit function names by default

[Metzger, Markus T]

> -----Original Message-----
> From: Jan Kratochvil [mailto:jan.kratochvil@redhat.com]
> Sent: Monday, February 18, 2013 3:13 PM


> > I intend to remove the "btrace" command and all its sub-commands. I just kept them
> > so people can compare them with the new "record" commands.
> >
> > Regarding "brace list" I do not plan to add a corresponding "record" command.
> 
> What should do the current "record list" hook other than what "btrace list" did?
> 
> Current to_list_record and to_list_record_range are always left NULL in
> archer-mmetzger-btrace so there isn't what to compare yet:)
> (gdb) record list
> You can't do that when your target is `record-btrace'

It should print 10 source lines around the current position and allow you to
iterate over the execution log on source level.

It should essentially produce the same output as repeating "reverse step"
10 times and discarding everything except for the current source position
echoed when the "reverse step" command completes.

A rough first algorithm would be:

for (;insn in bounds; ++/--insn) {
  sal = lookup source and line at insn
  if (sal == last_sal)
    continue;
  last_sal = sal;
  print source and line
  if (++printed >= record_list_size)
    break;
}

This does not consider multi-line expressions or non-code source lines. For heavily
optimized code or for code that frequently splits expressions over multiple lines,
this may be less helpful - at least in the above version. It also omits comments,
which some might consider a drawback, as well.


This goes beyond what "btrace" did and has the potential for lots of discussions -
especially when considering optimized code.
It might be better if we postponed it in favor of reverse-stepping, but I wanted it
to be considered when we're discussing the new "record" commands to avoid that
we call what I called "record backtrace" "record list" and thus don't have an appropriate
name left for such a source listing command.

Regards,
Markus.
Intel GmbH
Dornacher Strasse 1
85622 Feldkirchen/Muenchen, Deutschland
Sitz der Gesellschaft: Feldkirchen bei Muenchen
Geschaeftsfuehrer: Christian Lamprechter, Hannes Schwaderer, Douglas Lusk
Registergericht: Muenchen HRB 47456
Ust.-IdNr./VAT Registration No.: DE129385895
Citibank Frankfurt a.M. (BLZ 502 109 00) 600119052

Re: [rfc 6/8] record disas: omit function names by default

[Jan Kratochvil]

On Mon, 18 Feb 2013 15:50:50 +0100, Metzger, Markus T wrote:
> This goes beyond what "btrace" did and has the potential for lots of discussions -
> especially when considering optimized code.

GDB currently has many issues with optimized code where it could behave better
(even for watchpoints etc.).  It is enough when the feature is useful
for "-O0 -g" code.


> It might be better if we postponed it in favor of reverse-stepping,

OK, fine with that, so that neither "btrace list" nor "record list" will
exist, in the favor of "reverse-step".


> but I wanted it
> to be considered when we're discussing the new "record" commands to avoid that
> we call what I called "record backtrace" "record list" and thus don't have an appropriate
> name left for such a source listing command.

OK.


I still find "record list-functions" and "record list-instructions" more clear
than "record backtrace" and "record disassemble".  Particularly as there is
the "list" word.

Sorry for "bikeshedding" it, additionally so late, I do not want to keep this
discussion longer anymore.


Thanks,
Jan

RE: [rfc 6/8] record disas: omit function names by default

[Metzger, Markus T]

> -----Original Message-----
> From: Jan Kratochvil [mailto:jan.kratochvil@redhat.com]
> Sent: Monday, February 18, 2013 4:14 PM


> On Mon, 18 Feb 2013 15:50:50 +0100, Metzger, Markus T wrote:
> > This goes beyond what "btrace" did and has the potential for lots of discussions -
> > especially when considering optimized code.
> 
> GDB currently has many issues with optimized code where it could behave better
> (even for watchpoints etc.).  It is enough when the feature is useful
> for "-O0 -g" code.
> 
> > It might be better if we postponed it in favor of reverse-stepping,
> 
> OK, fine with that, so that neither "btrace list" nor "record list" will
> exist, in the favor of "reverse-step".

OK, so I keep it on my todo-list but postpone it.


Let's try to close on the command names. Here's what the commands are
supposed to do:

> The idea of those three new commands is to provide a quick overview of the
> execution history at different levels of granularity. Each of those commands
> allows iteration similar to the "list" command. The different levels of granularity
> are:

... instructions (disassembly), source lines, and functions

I'm listing the proposals that were made in this thread. In the end, it's your call
since I need you to approve the patch series. I also trust that you have a better
understanding of GDB's command language than I do.

Markus:
> >   record disassemble ......... instructions
> >   record list ....................... source lines
> >   record backtrace ............. functions

Jan:
> I still find "record list-functions" and "record list-instructions" more clear
> than "record backtrace" and "record disassemble".  Particularly as there is
> the "list" word.
> 
> Sorry for "bikeshedding" it, additionally so late, I do not want to keep this
> discussion longer anymore.

Eli:
> > Maybe "record list-functions"?
> 
> How about "record trace-functions"?

Eli:
>    record instruction-history
>    record source-lines-history
>    record function-call-history

Tom:
> Jan> Maybe "record list-functions"?
> 
> "record history" or "record function-history"?

Thanks,
Markus.
Intel GmbH
Dornacher Strasse 1
85622 Feldkirchen/Muenchen, Deutschland
Sitz der Gesellschaft: Feldkirchen bei Muenchen
Geschaeftsfuehrer: Christian Lamprechter, Hannes Schwaderer, Douglas Lusk
Registergericht: Muenchen HRB 47456
Ust.-IdNr./VAT Registration No.: DE129385895
Citibank Frankfurt a.M. (BLZ 502 109 00) 600119052

[RFC on command names] Re: [rfc 6/8] record disas: omit function names by default

[Jan Kratochvil]

Hi Markus,

thanks for summarizing it.  As everyone has his different naming opinion
choosing the IMO most clear naming by Eli (unless more opinions appear today).

> Eli:
> >    record instruction-history
> >    record source-lines-history
> >    record function-call-history


Thanks,
Jan


On Tue, 19 Feb 2013 09:34:02 +0100, Metzger, Markus T wrote:
> Markus:
> > >   record disassemble ......... instructions
> > >   record list ....................... source lines
> > >   record backtrace ............. functions
> 
> Jan:
> > I still find "record list-functions" and "record list-instructions" more clear
> > than "record backtrace" and "record disassemble".  Particularly as there is
> > the "list" word.
> > 
> > Sorry for "bikeshedding" it, additionally so late, I do not want to keep this
> > discussion longer anymore.
> 
> Eli:
> > > Maybe "record list-functions"?
> > 
> > How about "record trace-functions"?
> 
> Eli:
> >    record instruction-history
> >    record source-lines-history
> >    record function-call-history
> 
> Tom:
> > Jan> Maybe "record list-functions"?
> > 
> > "record history" or "record function-history"?

Re: [rfc 6/8] record disas: omit function names by default

[Eli Zaretskii]

> From: "Metzger, Markus T" <markus.t.metzger@intel.com>
> CC: "gdb-patches@sourceware.org" <gdb-patches@sourceware.org>,
> 	"markus.t.metzger@gmail.com" <markus.t.metzger@gmail.com>
> Date: Mon, 18 Feb 2013 09:42:44 +0000
> Accept-Language: en-US
> 
> Jan described it nicely above: "it's a 'backtrace' into history, not into upper frames".

So it isn't a backtrace in the sense that we use this term in GDB (or
any other debugger).

>   record disassemble ......... instructions
>   record list ....................... source lines
>   record backtrace ............. functions

Then why not

   record instruction-history
   record source-lines-history
   record function-call-history

?

Re: [rfc 6/8] record disas: omit function names by default

[Tom Tromey]

Jan> Maybe "record list-functions"?

"record history" or "record function-history"?

Tom

[rfc 3/8] record-full.h: rename record_ into record_full_

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Rename record_ prefixes in record-full.h into record_full_.

I ran the gdb.reverse suite on 64bit IA gnu/linux - no regressions.

The changelog for this renaming will be huge. Is there a way to abbreviate or
auto-generate it?

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

---
 gdb/amd64-linux-tdep.c |   51 +++---
 gdb/arm-tdep.c         |   11 +-
 gdb/i386-linux-tdep.c  |   28 ++--
 gdb/i386-tdep.c        |  464 +++++++++++++++++++++---------------------
 gdb/infrun.c           |    2 +-
 gdb/linux-record.c     |  543 +++++++++++++++++++++++++-----------------------
 gdb/moxie-tdep.c       |   84 ++++----
 gdb/record-full.c      |   32 ++--
 gdb/record-full.h      |   10 +-
 9 files changed, 629 insertions(+), 596 deletions(-)

diff --git a/gdb/amd64-linux-tdep.c b/gdb/amd64-linux-tdep.c
index 4f383db..d07f948 100644
--- a/gdb/amd64-linux-tdep.c
+++ b/gdb/amd64-linux-tdep.c
@@ -313,39 +313,39 @@ amd64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 static int
 amd64_all_but_ip_registers_record (struct regcache *regcache)
 {
-  if (record_arch_list_add_reg (regcache, AMD64_RAX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RAX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_RCX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RCX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_RDX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RDX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_RBX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RBX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_RSP_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RSP_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_RBP_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RBP_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_RSI_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RSI_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_RDI_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RDI_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R8_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R8_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R9_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R9_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R10_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R10_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R11_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R11_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R12_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R12_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R13_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R13_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R14_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R14_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R15_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R15_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_EFLAGS_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_EFLAGS_REGNUM))
     return -1;
 
   return 0;
@@ -1164,7 +1164,7 @@ amd64_canonicalize_syscall (enum amd64_syscall syscall_number)
 
 /* Parse the arguments of current system call instruction and record
    the values of the registers and memory that will be changed into
-   "record_arch_list".  This instruction is "syscall".
+   "record_full_arch_list".  This instruction is "syscall".
 
    Return -1 if something wrong.  */
 
@@ -1203,8 +1203,9 @@ amd64_linux_syscall_record (struct regcache *regcache)
 	    regcache_raw_read_unsigned (regcache,
 					amd64_linux_record_tdep.arg2,
 					&addr);
-	    if (record_arch_list_add_mem (addr,
-					  amd64_linux_record_tdep.size_ulong))
+	    if (record_full_arch_list_add_mem
+		(addr,
+		 amd64_linux_record_tdep.size_ulong))
 	      return -1;
 	  }
 	goto record_regs;
@@ -1231,9 +1232,9 @@ amd64_linux_syscall_record (struct regcache *regcache)
 
  record_regs:
   /* Record the return value of the system call.  */
-  if (record_arch_list_add_reg (regcache, AMD64_RCX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RCX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, AMD64_R11_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_R11_REGNUM))
     return -1;
 
   return 0;
@@ -1253,7 +1254,7 @@ amd64_linux_record_signal (struct gdbarch *gdbarch,
   if (amd64_all_but_ip_registers_record (regcache))
     return -1;
 
-  if (record_arch_list_add_reg (regcache, AMD64_RIP_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, AMD64_RIP_REGNUM))
     return -1;
 
   /* Record the change in the stack.  */
@@ -1267,12 +1268,12 @@ amd64_linux_record_signal (struct gdbarch *gdbarch,
   /* This is for frame_size.
      sp -= sizeof (struct rt_sigframe);  */
   rsp -= AMD64_LINUX_frame_size;
-  if (record_arch_list_add_mem (rsp, AMD64_LINUX_redzone
+  if (record_full_arch_list_add_mem (rsp, AMD64_LINUX_redzone
                                      + AMD64_LINUX_xstate
                                      + AMD64_LINUX_frame_size))
     return -1;
 
-  if (record_arch_list_add_end ())
+  if (record_full_arch_list_add_end ())
     return -1;
 
   return 0;
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index abe895c..4dbaec7 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -12601,13 +12601,14 @@ arm_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
   if (0 == ret)
     {
       /* Record registers.  */
-      record_arch_list_add_reg (arm_record.regcache, ARM_PC_REGNUM);
+      record_full_arch_list_add_reg (arm_record.regcache, ARM_PC_REGNUM);
       if (arm_record.arm_regs)
         {
           for (no_of_rec = 0; no_of_rec < arm_record.reg_rec_count; no_of_rec++)
             {
-              if (record_arch_list_add_reg (arm_record.regcache , 
-                                            arm_record.arm_regs[no_of_rec]))
+              if (record_full_arch_list_add_reg
+		  (arm_record.regcache ,
+		   arm_record.arm_regs[no_of_rec]))
               ret = -1;
             }
         }
@@ -12616,14 +12617,14 @@ arm_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
         {
           for (no_of_rec = 0; no_of_rec < arm_record.mem_rec_count; no_of_rec++)
             {
-              if (record_arch_list_add_mem 
+              if (record_full_arch_list_add_mem
                   ((CORE_ADDR)arm_record.arm_mems[no_of_rec].addr,
                   arm_record.arm_mems[no_of_rec].len))
                 ret = -1;
             }
         }
 
-      if (record_arch_list_add_end ())
+      if (record_full_arch_list_add_end ())
         ret = -1;
     }
 
diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c
index f96fc81..fc9de62 100644
--- a/gdb/i386-linux-tdep.c
+++ b/gdb/i386-linux-tdep.c
@@ -370,23 +370,23 @@ i386_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 static int
 i386_all_but_ip_registers_record (struct regcache *regcache)
 {
-  if (record_arch_list_add_reg (regcache, I386_EAX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_ECX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_ECX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_EDX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EDX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_EBX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EBX_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_ESP_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_ESP_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_EBP_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EBP_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_ESI_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_ESI_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_EDI_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EDI_REGNUM))
     return -1;
-  if (record_arch_list_add_reg (regcache, I386_EFLAGS_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EFLAGS_REGNUM))
     return -1;
 
   return 0;
@@ -450,7 +450,7 @@ i386_linux_intx80_sysenter_syscall_record (struct regcache *regcache)
     return ret;
 
   /* Record the return value of the system call.  */
-  if (record_arch_list_add_reg (regcache, I386_EAX_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM))
     return -1;
 
   return 0;
@@ -469,7 +469,7 @@ i386_linux_record_signal (struct gdbarch *gdbarch,
   if (i386_all_but_ip_registers_record (regcache))
     return -1;
 
-  if (record_arch_list_add_reg (regcache, I386_EIP_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, I386_EIP_REGNUM))
     return -1;
 
   /* Record the change in the stack.  */
@@ -480,11 +480,11 @@ i386_linux_record_signal (struct gdbarch *gdbarch,
   /* This is for frame_size.
      sp -= sizeof (struct rt_sigframe);  */
   esp -= I386_LINUX_frame_size;
-  if (record_arch_list_add_mem (esp,
-                                I386_LINUX_xstate + I386_LINUX_frame_size))
+  if (record_full_arch_list_add_mem (esp,
+				     I386_LINUX_xstate + I386_LINUX_frame_size))
     return -1;
 
-  if (record_arch_list_add_end ())
+  if (record_full_arch_list_add_end ())
     return -1;
 
   return 0;
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index a36a83d..7a87c42 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -4205,7 +4205,7 @@ i386_record_lea_modrm (struct i386_record_s *irp)
 
   if (irp->override >= 0)
     {
-      if (record_memory_query)
+      if (record_full_memory_query)
         {
 	  int q;
 
@@ -4226,7 +4226,7 @@ Do you want to stop the program?"),
   if (i386_record_lea_modrm_addr (irp, &addr))
     return -1;
 
-  if (record_arch_list_add_mem (addr, 1 << irp->ot))
+  if (record_full_arch_list_add_mem (addr, 1 << irp->ot))
     return -1;
 
   return 0;
@@ -4240,13 +4240,13 @@ i386_record_push (struct i386_record_s *irp, int size)
 {
   ULONGEST addr;
 
-  if (record_arch_list_add_reg (irp->regcache,
-				irp->regmap[X86_RECORD_RESP_REGNUM]))
+  if (record_full_arch_list_add_reg (irp->regcache,
+				     irp->regmap[X86_RECORD_RESP_REGNUM]))
     return -1;
   regcache_raw_read_unsigned (irp->regcache,
 			      irp->regmap[X86_RECORD_RESP_REGNUM],
 			      &addr);
-  if (record_arch_list_add_mem ((CORE_ADDR) addr - size, size))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) addr - size, size))
     return -1;
 
   return 0;
@@ -4278,7 +4278,7 @@ static int i386_record_floats (struct gdbarch *gdbarch,
     {
       for (i = I387_ST0_REGNUM (tdep); i <= I387_ST0_REGNUM (tdep) + 7; i++)
         {
-          if (record_arch_list_add_reg (ir->regcache, i))
+          if (record_full_arch_list_add_reg (ir->regcache, i))
             return -1;
         }
     }
@@ -4286,7 +4286,7 @@ static int i386_record_floats (struct gdbarch *gdbarch,
     {
       for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
 	      {
-	      if (record_arch_list_add_reg (ir->regcache, i))
+	      if (record_full_arch_list_add_reg (ir->regcache, i))
 	        return -1;
 	      }
     }
@@ -4294,14 +4294,14 @@ static int i386_record_floats (struct gdbarch *gdbarch,
     {
       for (i = I387_ST0_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
       {
-        if (record_arch_list_add_reg (ir->regcache, i))
+        if (record_full_arch_list_add_reg (ir->regcache, i))
           return -1;
       }
     }
   else if ((iregnum >= I387_ST0_REGNUM (tdep)) &&
            (iregnum <= I387_FOP_REGNUM (tdep)))
     {
-      if (record_arch_list_add_reg (ir->regcache,iregnum))
+      if (record_full_arch_list_add_reg (ir->regcache,iregnum))
         return -1;
     }
   else
@@ -4313,7 +4313,7 @@ static int i386_record_floats (struct gdbarch *gdbarch,
     {
     for (i = I387_FCTRL_REGNUM (tdep); i <= I387_FOP_REGNUM (tdep); i++)
       {
-      if (record_arch_list_add_reg (ir->regcache, i))
+      if (record_full_arch_list_add_reg (ir->regcache, i))
         return -1;
       }
     }
@@ -4324,8 +4324,8 @@ static int i386_record_floats (struct gdbarch *gdbarch,
    registers and memory that will be changed by the current
    instruction.  Returns -1 if something goes wrong, 0 otherwise.  */
 
-#define I386_RECORD_ARCH_LIST_ADD_REG(regnum) \
-    record_arch_list_add_reg (ir.regcache, ir.regmap[(regnum)])
+#define I386_RECORD_FULL_ARCH_LIST_ADD_REG(regnum) \
+    record_full_arch_list_add_reg (ir.regcache, ir.regmap[(regnum)])
 
 int
 i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
@@ -4530,7 +4530,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
                   ir.rm |= ir.rex_b;
 		  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 		    ir.rm &= 0x3;
-		  I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+		  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
 		}
 	      break;
 	    case 1:    /* OP Gv, Ev */
@@ -4539,14 +4539,14 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
               ir.reg |= rex_r;
 	      if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 		ir.reg &= 0x3;
-	      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+	      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
 	      break;
 	    case 2:    /* OP A, Iv */
-	      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+	      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
 	      break;
 	    }
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x80:    /* GRP1 */
@@ -4573,9 +4573,9 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 		return -1;
 	    }
 	  else
-	    I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+	    I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x40:      /* inc */
@@ -4596,8 +4596,8 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
     case 0x4e:
     case 0x4f:
 
-      I386_RECORD_ARCH_LIST_ADD_REG (opcode & 7);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (opcode & 7);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xf6:    /* GRP3 */
@@ -4615,7 +4615,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       switch (ir.reg)
 	{
 	case 0:    /* test */
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 2:    /* not */
 	case 3:    /* neg */
@@ -4629,19 +4629,19 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
               ir.rm |= ir.rex_b;
 	      if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 		ir.rm &= 0x3;
-	      I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+	      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
 	    }
 	  if (ir.reg == 3)  /* neg */
-	    I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	    I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 4:    /* mul  */
 	case 5:    /* imul */
 	case 6:    /* div  */
 	case 7:    /* idiv */
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
 	  if (ir.ot != OT_BYTE)
-	    I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	    I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	default:
 	  ir.addr -= 2;
@@ -4679,26 +4679,26 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	      ir.rm |= ir.rex_b;
 	      if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 		ir.rm &= 0x3;
-	      I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+	      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
 	    }
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 2:    /* call */
           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
             ir.dflag = 2;
 	  if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
 	    return -1;
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 3:    /* lcall */
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
 	  if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
 	    return -1;
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 4:    /* jmp  */
 	case 5:    /* ljmp */
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 6:    /* push */
           if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
@@ -4718,16 +4718,16 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
     case 0x85:
     case 0xa8:
     case 0xa9:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x98:    /* CWDE/CBW */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
       break;
 
     case 0x99:    /* CDQ/CWD */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
       break;
 
     case 0x0faf:  /* imul */
@@ -4743,8 +4743,8 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       ir.reg |= rex_r;
       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	ir.reg &= 0x3;
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fc0:  /* xadd */
@@ -4760,10 +4760,10 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	{
 	  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	    ir.reg &= 0x3;
-	  I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
 	  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	    ir.rm &= 0x3;
-	  I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
 	}
       else
 	{
@@ -4771,9 +4771,9 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    return -1;
 	  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	    ir.reg &= 0x3;
-	  I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fb0:  /* cmpxchg */
@@ -4787,18 +4787,18 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       if (ir.mod == 3)
 	{
           ir.reg |= rex_r;
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
 	  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	    ir.reg &= 0x3;
-	  I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
 	}
       else
 	{
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
 	  if (i386_record_lea_modrm (&ir))
 	    return -1;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fc7:    /* cmpxchg8b */
@@ -4810,11 +4810,11 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  opcode = opcode << 8 | ir.modrm;
 	  goto no_support;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
       if (i386_record_lea_modrm (&ir))
 	return -1;
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x50:    /* push */
@@ -4875,8 +4875,8 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
     case 0x5d:
     case 0x5e:
     case 0x5f:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
       break;
 
     case 0x61:    /* popa */
@@ -4888,7 +4888,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       for (regnum = X86_RECORD_REAX_REGNUM; 
 	   regnum <= X86_RECORD_REDI_REGNUM;
 	   regnum++)
-	I386_RECORD_ARCH_LIST_ADD_REG (regnum);
+	I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
       break;
 
     case 0x8f:    /* pop */
@@ -4899,18 +4899,18 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       if (i386_record_modrm (&ir))
 	return -1;
       if (ir.mod == 3)
-	I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+	I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
       else
 	{
           ir.popl_esp_hack = 1 << ir.ot;
 	  if (i386_record_lea_modrm (&ir))
 	    return -1;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
       break;
 
     case 0xc8:    /* enter */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
         ir.dflag = 2;
       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
@@ -4918,8 +4918,8 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       break;
 
     case 0xc9:    /* leave */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
       break;
 
     case 0x07:    /* pop es */
@@ -4928,9 +4928,9 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  ir.addr -= 1;
 	  goto no_support;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_ES_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_ES_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x17:    /* pop ss */
@@ -4939,9 +4939,9 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  ir.addr -= 1;
 	  goto no_support;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_SS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_SS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x1f:    /* pop ds */
@@ -4950,21 +4950,21 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  ir.addr -= 1;
 	  goto no_support;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_DS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_DS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fa1:    /* pop fs */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_FS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_FS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fa9:    /* pop gs */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x88:    /* mov */
@@ -4992,7 +4992,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    ir.rm |= ir.rex_b;
 	  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	    ir.rm &= 0x3;
-	  I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
 	}
       break;
 
@@ -5007,7 +5007,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       ir.reg |= rex_r;
       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	ir.reg &= 0x3;
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
       break;
 
     case 0x8c:    /* mov seg */
@@ -5021,7 +5021,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	}
 
       if (ir.mod == 3)
-	I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+	I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
       else
 	{
 	  ir.ot = OT_WORD;
@@ -5056,8 +5056,8 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  goto no_support;
 	  break;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (regnum);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fb6:    /* movzbS */
@@ -5066,7 +5066,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
     case 0x0fbf:    /* movswS */
       if (i386_record_modrm (&ir))
 	return -1;
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
       break;
 
     case 0x8d:      /* lea */
@@ -5082,21 +5082,21 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
       ir.reg |= rex_r;
       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	ir.reg &= 0x3;
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
       break;
 
     case 0xa0:    /* mov EAX */
     case 0xa1:
 
     case 0xd7:    /* xlat */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
       break;
 
     case 0xa2:    /* mov EAX */
     case 0xa3:
       if (ir.override >= 0)
         {
-          if (record_memory_query)
+          if (record_full_memory_query)
             {
 	      int q;
 
@@ -5138,7 +5138,7 @@ Do you want to stop the program?"),
 	      ir.addr += 2;
               addr = extract_unsigned_integer (buf, 2, byte_order);
 	    }
-	  if (record_arch_list_add_mem (addr, 1 << ir.ot))
+	  if (record_full_arch_list_add_mem (addr, 1 << ir.ot))
 	    return -1;
         }
       break;
@@ -5151,7 +5151,7 @@ Do you want to stop the program?"),
     case 0xb5:
     case 0xb6:
     case 0xb7:
-      I386_RECORD_ARCH_LIST_ADD_REG ((ir.regmap[X86_RECORD_R8_REGNUM])
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG ((ir.regmap[X86_RECORD_R8_REGNUM])
                                         ? ((opcode & 0x7) | ir.rex_b)
 					: ((opcode & 0x7) & 0x3));
       break;
@@ -5164,7 +5164,7 @@ Do you want to stop the program?"),
     case 0xbd:
     case 0xbe:
     case 0xbf:
-      I386_RECORD_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 0x7) | ir.rex_b);
       break;
 
     case 0x91:    /* xchg R, EAX */
@@ -5174,8 +5174,8 @@ Do you want to stop the program?"),
     case 0x95:
     case 0x96:
     case 0x97:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (opcode & 0x7);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (opcode & 0x7);
       break;
 
     case 0x86:    /* xchg Ev, Gv */
@@ -5191,7 +5191,7 @@ Do you want to stop the program?"),
 	  ir.rm |= ir.rex_b;
 	  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	    ir.rm &= 0x3;
-	  I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
 	}
       else
 	{
@@ -5201,7 +5201,7 @@ Do you want to stop the program?"),
       ir.reg |= rex_r;
       if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	ir.reg &= 0x3;
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
       break;
 
     case 0xc4:    /* les Gv */
@@ -5244,9 +5244,9 @@ Do you want to stop the program?"),
 	  regnum = X86_RECORD_GS_REGNUM;
 	  break;
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (regnum);
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (regnum);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xc0:    /* shifts */
@@ -5271,9 +5271,9 @@ Do you want to stop the program?"),
 	  ir.rm |= ir.rex_b;
 	  if (ir.ot == OT_BYTE && !ir.regmap[X86_RECORD_R8_REGNUM])
 	    ir.rm &= 0x3;
-	  I386_RECORD_ARCH_LIST_ADD_REG (ir.rm);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm);
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fa4:
@@ -5284,7 +5284,7 @@ Do you want to stop the program?"),
 	return -1;
       if (ir.mod == 3)
 	{
-	  if (record_arch_list_add_reg (ir.regcache, ir.rm))
+	  if (record_full_arch_list_add_reg (ir.regcache, ir.rm))
 	    return -1;
 	}
       else
@@ -5387,17 +5387,17 @@ Do you want to stop the program?"),
 		  switch (ir.reg >> 4)
 		    {
 		    case 0:
-		      if (record_arch_list_add_mem (addr64, 4))
+		      if (record_full_arch_list_add_mem (addr64, 4))
 			return -1;
 		      break;
 		    case 2:
-		      if (record_arch_list_add_mem (addr64, 8))
+		      if (record_full_arch_list_add_mem (addr64, 8))
 			return -1;
 		      break;
 		    case 3:
 		      break;
 		    default:
-		      if (record_arch_list_add_mem (addr64, 2))
+		      if (record_full_arch_list_add_mem (addr64, 2))
 			return -1;
 		      break;
 		    }
@@ -5406,7 +5406,7 @@ Do you want to stop the program?"),
 		  switch (ir.reg >> 4)
 		    {
 		    case 0:
-		      if (record_arch_list_add_mem (addr64, 4))
+		      if (record_full_arch_list_add_mem (addr64, 4))
 			return -1;
 		      if (3 == (ir.reg & 7))
 			{
@@ -5417,7 +5417,7 @@ Do you want to stop the program?"),
 			}
 		      break;
 		    case 1:
-		      if (record_arch_list_add_mem (addr64, 4))
+		      if (record_full_arch_list_add_mem (addr64, 4))
 			return -1;
 		      if ((3 == (ir.reg & 7))
 			  || (5 == (ir.reg & 7))
@@ -5430,7 +5430,7 @@ Do you want to stop the program?"),
 			}
 		      break;
 		    case 2:
-		      if (record_arch_list_add_mem (addr64, 8))
+		      if (record_full_arch_list_add_mem (addr64, 8))
 			return -1;
 		      if (3 == (ir.reg & 7))
 			{
@@ -5450,7 +5450,7 @@ Do you want to stop the program?"),
 			}
 		      /* Fall through */
 		    default:
-		      if (record_arch_list_add_mem (addr64, 2))
+		      if (record_full_arch_list_add_mem (addr64, 2))
 			return -1;
 		      break;
 		    }
@@ -5477,18 +5477,18 @@ Do you want to stop the program?"),
 	    case 0x0e:
 	      if (ir.dflag)
 		{
-		  if (record_arch_list_add_mem (addr64, 28))
+		  if (record_full_arch_list_add_mem (addr64, 28))
 		    return -1;
 		}
 	      else
 		{
-		  if (record_arch_list_add_mem (addr64, 14))
+		  if (record_full_arch_list_add_mem (addr64, 14))
 		    return -1;
 		}
 	      break;
 	    case 0x0f:
 	    case 0x2f:
-	      if (record_arch_list_add_mem (addr64, 2))
+	      if (record_full_arch_list_add_mem (addr64, 2))
 		return -1;
               /* Insn fstp, fbstp.  */
               if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
@@ -5496,23 +5496,23 @@ Do you want to stop the program?"),
 	      break;
 	    case 0x1f:
 	    case 0x3e:
-	      if (record_arch_list_add_mem (addr64, 10))
+	      if (record_full_arch_list_add_mem (addr64, 10))
 		return -1;
 	      break;
 	    case 0x2e:
 	      if (ir.dflag)
 		{
-		  if (record_arch_list_add_mem (addr64, 28))
+		  if (record_full_arch_list_add_mem (addr64, 28))
 		    return -1;
 		  addr64 += 28;
 		}
 	      else
 		{
-		  if (record_arch_list_add_mem (addr64, 14))
+		  if (record_full_arch_list_add_mem (addr64, 14))
 		    return -1;
 		  addr64 += 14;
 		}
-	      if (record_arch_list_add_mem (addr64, 80))
+	      if (record_full_arch_list_add_mem (addr64, 80))
 		return -1;
 	      /* Insn fsave.  */
 	      if (i386_record_floats (gdbarch, &ir,
@@ -5520,7 +5520,7 @@ Do you want to stop the program?"),
 		return -1;
 	      break;
 	    case 0x3f:
-	      if (record_arch_list_add_mem (addr64, 8))
+	      if (record_full_arch_list_add_mem (addr64, 8))
 		return -1;
 	      /* Insn fistp.  */
 	      if (i386_record_floats (gdbarch, &ir, I386_SAVE_FPU_REGS))
@@ -5726,7 +5726,7 @@ Do you want to stop the program?"),
             case 0xdf:
               if (0xe0 == ir.modrm)
                 {
-		  if (record_arch_list_add_reg (ir.regcache, I386_EAX_REGNUM))
+		  if (record_full_arch_list_add_reg (ir.regcache, I386_EAX_REGNUM))
 		    return -1;
                 }
               else if ((0x0f == ir.modrm >> 4) || (0x0e == ir.modrm >> 4))
@@ -5769,7 +5769,7 @@ Do you want to stop the program?"),
           if (ir.aflag && (es != ds))
             {
               /* addr += ((uint32_t) read_register (I386_ES_REGNUM)) << 4; */
-              if (record_memory_query)
+              if (record_full_memory_query)
                 {
 	          int q;
 
@@ -5786,59 +5786,59 @@ Do you want to stop the program?"),
             }
           else
             {
-              if (record_arch_list_add_mem (addr, 1 << ir.ot))
+              if (record_full_arch_list_add_mem (addr, 1 << ir.ot))
                 return -1;
             }
 
           if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
-            I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
           if (opcode == 0xa4 || opcode == 0xa5)
-            I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
-          I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
-          I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	}
       break;
 
     case 0xa6:    /* cmpsS */
     case 0xa7:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
-        I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xac:    /* lodsS */
     case 0xad:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
-        I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xae:    /* scasS */
     case 0xaf:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
-        I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x6e:    /* outsS */
     case 0x6f:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
       if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
-        I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xe4:    /* port I/O */
     case 0xe5:
     case 0xec:
     case 0xed:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
       break;
 
     case 0xe6:
@@ -5850,16 +5850,16 @@ Do you want to stop the program?"),
       /* control */
     case 0xc2:    /* ret im */
     case 0xc3:    /* ret */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xca:    /* lret im */
     case 0xcb:    /* lret */
     case 0xcf:    /* iret */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xe8:    /* call im */
@@ -5875,7 +5875,7 @@ Do you want to stop the program?"),
           ir.addr -= 1;
           goto no_support;
         }
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_CS_REGNUM);
       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
         return -1;
       break;
@@ -5933,12 +5933,12 @@ Do you want to stop the program?"),
     case 0x0f9d:
     case 0x0f9e:
     case 0x0f9f:
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       ir.ot = OT_BYTE;
       if (i386_record_modrm (&ir))
 	return -1;
       if (ir.mod == 3)
-        I386_RECORD_ARCH_LIST_ADD_REG (ir.rex_b ? (ir.rm | ir.rex_b)
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rex_b ? (ir.rm | ir.rex_b)
 	                                        : (ir.rm & 0x3));
       else
 	{
@@ -5968,12 +5968,12 @@ Do you want to stop the program?"),
       ir.reg |= rex_r;
       if (ir.dflag == OT_BYTE)
 	ir.reg &= 0x3;
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
       break;
 
       /* flags */
     case 0x9c:    /* pushf */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       if (ir.regmap[X86_RECORD_R8_REGNUM] && ir.dflag)
         ir.dflag = 2;
       if (i386_record_push (&ir, 1 << (ir.dflag + 1)))
@@ -5981,8 +5981,8 @@ Do you want to stop the program?"),
       break;
 
     case 0x9d:    /* popf */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x9e:    /* sahf */
@@ -5997,7 +5997,7 @@ Do you want to stop the program?"),
     case 0xf9:    /* stc */
     case 0xfc:    /* cld */
     case 0xfd:    /* std */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x9f:    /* lahf */
@@ -6006,8 +6006,8 @@ Do you want to stop the program?"),
           ir.addr -= 1;
           goto no_support;
         }
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
       break;
 
       /* bit operations */
@@ -6024,18 +6024,18 @@ Do you want to stop the program?"),
       if (ir.reg != 4)
 	{
           if (ir.mod == 3)
-            I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
 	  else
 	    {
 	      if (i386_record_lea_modrm (&ir))
 		return -1;
 	    }
 	}
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fa3:    /* bt Gv, Ev */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fab:    /* bts */
@@ -6045,7 +6045,7 @@ Do you want to stop the program?"),
       if (i386_record_modrm (&ir))
         return -1;
       if (ir.mod == 3)
-        I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
       else
         {
           uint64_t addr64;
@@ -6066,18 +6066,18 @@ Do you want to stop the program?"),
               addr64 += ((int64_t) addr >> 6) << 6;
               break;
             }
-          if (record_arch_list_add_mem (addr64, 1 << ir.ot))
+          if (record_full_arch_list_add_mem (addr64, 1 << ir.ot))
             return -1;
           if (i386_record_lea_modrm (&ir))
             return -1;
         }
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0fbc:    /* bsf */
     case 0x0fbd:    /* bsr */
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
       /* bcd */
@@ -6092,8 +6092,8 @@ Do you want to stop the program?"),
           ir.addr -= 1;
           goto no_support;
         }
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
       /* misc */
@@ -6171,7 +6171,7 @@ Do you want to stop the program?"),
     case 0x0fcd:
     case 0x0fce:
     case 0x0fcf:
-      I386_RECORD_ARCH_LIST_ADD_REG ((opcode & 7) | ir.rex_b);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG ((opcode & 7) | ir.rex_b);
       break;
 
     case 0xd6:    /* salc */
@@ -6180,16 +6180,16 @@ Do you want to stop the program?"),
           ir.addr -= 1;
           goto no_support;
         }
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0xe0:    /* loopnz */
     case 0xe1:    /* loopz */
     case 0xe2:    /* loop */
     case 0xe3:    /* jecxz */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0f30:    /* wrmsr */
@@ -6207,8 +6207,8 @@ Do you want to stop the program?"),
       break;
 
     case 0x0f31:    /* rdtsc */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
       break;
 
     case 0x0f34:    /* sysenter */
@@ -6263,10 +6263,10 @@ Do you want to stop the program?"),
       break;
 
     case 0x0fa2:    /* cpuid */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
       break;
 
     case 0xf4:    /* hlt */
@@ -6284,7 +6284,7 @@ Do you want to stop the program?"),
 	case 0:  /* sldt */
 	case 1:  /* str  */
 	  if (ir.mod == 3)
-            I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
 	  else
 	    {
 	      ir.ot = OT_WORD;
@@ -6297,7 +6297,7 @@ Do you want to stop the program?"),
 	  break;
 	case 4:  /* verr */
 	case 5:  /* verw */
-          I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	default:
 	  ir.addr -= 3;
@@ -6324,7 +6324,7 @@ Do you want to stop the program?"),
 	      }
 	    if (ir.override >= 0)
 	      {
-                if (record_memory_query)
+                if (record_full_memory_query)
                   {
 	            int q;
 
@@ -6343,17 +6343,17 @@ Do you want to stop the program?"),
 	      {
 		if (i386_record_lea_modrm_addr (&ir, &addr64))
 		  return -1;
-		if (record_arch_list_add_mem (addr64, 2))
+		if (record_full_arch_list_add_mem (addr64, 2))
 		  return -1;
 		addr64 += 2;
                 if (ir.regmap[X86_RECORD_R8_REGNUM])
                   {
-                    if (record_arch_list_add_mem (addr64, 8))
+                    if (record_full_arch_list_add_mem (addr64, 8))
 		      return -1;
                   }
                 else
                   {
-                    if (record_arch_list_add_mem (addr64, 4))
+                    if (record_full_arch_list_add_mem (addr64, 4))
 		      return -1;
                   }
 	      }
@@ -6367,7 +6367,7 @@ Do you want to stop the program?"),
 		case 0:  /* monitor */
 		  break;
 		case 1:  /* mwait */
-		  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+		  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 		  break;
 		default:
 		  ir.addr -= 3;
@@ -6381,7 +6381,7 @@ Do you want to stop the program?"),
 	      /* sidt */
 	      if (ir.override >= 0)
 		{
-                  if (record_memory_query)
+                  if (record_full_memory_query)
                     {
 	              int q;
 
@@ -6402,17 +6402,17 @@ Do you want to stop the program?"),
 
 		  if (i386_record_lea_modrm_addr (&ir, &addr64))
 		    return -1;
-		  if (record_arch_list_add_mem (addr64, 2))
+		  if (record_full_arch_list_add_mem (addr64, 2))
 		    return -1;
 		  addr64 += 2;
                   if (ir.regmap[X86_RECORD_R8_REGNUM])
                     {
-                      if (record_arch_list_add_mem (addr64, 8))
+                      if (record_full_arch_list_add_mem (addr64, 8))
 		        return -1;
                     }
                   else
                     {
-                      if (record_arch_list_add_mem (addr64, 4))
+                      if (record_full_arch_list_add_mem (addr64, 4))
 		        return -1;
                     }
 		}
@@ -6424,8 +6424,8 @@ Do you want to stop the program?"),
 	      /* xgetbv */
 	      if (ir.rm == 0)
 		{
-		  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-		  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
+		  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+		  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
 		  break;
 		}
 	      /* xsetbv */
@@ -6443,7 +6443,7 @@ Do you want to stop the program?"),
 	case 4:  /* smsw */
 	  if (ir.mod == 3)
 	    {
-	      if (record_arch_list_add_reg (ir.regcache, ir.rm | ir.rex_b))
+	      if (record_full_arch_list_add_reg (ir.regcache, ir.rm | ir.rex_b))
 		return -1;
 	    }
 	  else
@@ -6452,16 +6452,16 @@ Do you want to stop the program?"),
 	      if (i386_record_lea_modrm (&ir))
 		return -1;
 	    }
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 6:  /* lmsw */
-	  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	case 7:  /* invlpg */
 	  if (ir.mod == 3)
 	    {
 	      if (ir.rm == 0 && ir.regmap[X86_RECORD_R8_REGNUM])
-	        I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
+	        I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_GS_REGNUM);
 	      else
 	        {
 	          ir.addr -= 3;
@@ -6470,7 +6470,7 @@ Do you want to stop the program?"),
 	        }
 	    }
 	  else
-	    I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	    I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  break;
 	default:
 	  ir.addr -= 3;
@@ -6489,7 +6489,7 @@ Do you want to stop the program?"),
 	return -1;
       if (ir.mod == 3 || ir.regmap[X86_RECORD_R8_REGNUM])
         {
-          I386_RECORD_ARCH_LIST_ADD_REG (ir.regmap[X86_RECORD_R8_REGNUM]
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.regmap[X86_RECORD_R8_REGNUM]
 	                                   ? (ir.reg | rex_r) : ir.rm);
         }
       else
@@ -6499,15 +6499,15 @@ Do you want to stop the program?"),
             return -1;
         }
       if (!ir.regmap[X86_RECORD_R8_REGNUM])
-        I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0f02:    /* lar */
     case 0x0f03:    /* lsl */
       if (i386_record_modrm (&ir))
 	return -1;
-      I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     case 0x0f18:
@@ -6549,9 +6549,9 @@ Do you want to stop the program?"),
 	case 4:
 	case 8:
 	  if (opcode & 2)
-	    I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+	    I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	  else
-            I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
 	  break;
 	default:
 	  ir.addr -= 3;
@@ -6573,13 +6573,13 @@ Do you want to stop the program?"),
 	  goto no_support;
 	}
       if (opcode & 2)
-        I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       else
-	I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+	I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
       break;
 
     case 0x0f06:    /* clts */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
       break;
 
     /* MMX 3DNow! SSE SSE2 SSE3 SSSE3 SSE4 */
@@ -6591,7 +6591,7 @@ Do you want to stop the program?"),
     case 0x0f77:    /* emms */
       if (i386_fpc_regnum_p (gdbarch, I387_FTAG_REGNUM(tdep)))
         goto no_support;
-      record_arch_list_add_reg (ir.regcache, I387_FTAG_REGNUM(tdep));
+      record_full_arch_list_add_reg (ir.regcache, I387_FTAG_REGNUM(tdep));
       break;
 
     case 0x0f0f:    /* 3DNow! data */
@@ -6628,7 +6628,7 @@ Do you want to stop the program?"),
         case 0xbf:    /* 3DNow! pavgusb */
           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.reg))
             goto no_support_3dnow_data;
-          record_arch_list_add_reg (ir.regcache, ir.reg);
+          record_full_arch_list_add_reg (ir.regcache, ir.reg);
           break;
 
         default:
@@ -6640,15 +6640,15 @@ no_support_3dnow_data:
       break;
 
     case 0x0faa:    /* rsm */
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
-      I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RECX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBX_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REBP_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_RESI_REGNUM);
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDI_REGNUM);
       break;
 
     case 0x0fae:
@@ -6660,10 +6660,10 @@ no_support_3dnow_data:
           {
             uint64_t tmpu64;
 
-            I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 	    if (i386_record_lea_modrm_addr (&ir, &tmpu64))
 	      return -1;
-            if (record_arch_list_add_mem (tmpu64, 512))
+            if (record_full_arch_list_add_mem (tmpu64, 512))
               return -1;
           }
           break;
@@ -6672,33 +6672,33 @@ no_support_3dnow_data:
           {
             int i;
 
-            I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
 
             for (i = I387_MM0_REGNUM (tdep);
                  i386_mmx_regnum_p (gdbarch, i); i++)
-              record_arch_list_add_reg (ir.regcache, i);
+              record_full_arch_list_add_reg (ir.regcache, i);
 
             for (i = I387_XMM0_REGNUM (tdep);
                  i386_xmm_regnum_p (gdbarch, i); i++)
-              record_arch_list_add_reg (ir.regcache, i);
+              record_full_arch_list_add_reg (ir.regcache, i);
 
             if (i386_mxcsr_regnum_p (gdbarch, I387_MXCSR_REGNUM(tdep)))
-              record_arch_list_add_reg (ir.regcache, I387_MXCSR_REGNUM(tdep));
+              record_full_arch_list_add_reg (ir.regcache, I387_MXCSR_REGNUM(tdep));
 
             for (i = I387_ST0_REGNUM (tdep);
                  i386_fp_regnum_p (gdbarch, i); i++)
-              record_arch_list_add_reg (ir.regcache, i);
+              record_full_arch_list_add_reg (ir.regcache, i);
 
             for (i = I387_FCTRL_REGNUM (tdep);
                  i386_fpc_regnum_p (gdbarch, i); i++)
-              record_arch_list_add_reg (ir.regcache, i);
+              record_full_arch_list_add_reg (ir.regcache, i);
           }
           break;
 
         case 2:    /* ldmxcsr */
           if (!i386_mxcsr_regnum_p (gdbarch, I387_MXCSR_REGNUM(tdep)))
             goto no_support;
-          record_arch_list_add_reg (ir.regcache, I387_MXCSR_REGNUM(tdep));
+          record_full_arch_list_add_reg (ir.regcache, I387_MXCSR_REGNUM(tdep));
           break;
 
         case 3:    /* stmxcsr */
@@ -7076,10 +7076,10 @@ reswitch_prefix_add:
           ir.reg |= rex_r;
           if (!i386_xmm_regnum_p (gdbarch, I387_XMM0_REGNUM (tdep) + ir.reg))
             goto no_support;
-          record_arch_list_add_reg (ir.regcache,
+          record_full_arch_list_add_reg (ir.regcache,
                                     I387_XMM0_REGNUM (tdep) + ir.reg);
           if ((opcode & 0xfffffffc) == 0x660f3a60)
-            I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
           break;
 
         case 0x0f11:        /* movups */
@@ -7109,7 +7109,7 @@ reswitch_prefix_add:
               if (!i386_xmm_regnum_p (gdbarch,
 				      I387_XMM0_REGNUM (tdep) + ir.rm))
                 goto no_support;
-              record_arch_list_add_reg (ir.regcache,
+              record_full_arch_list_add_reg (ir.regcache,
                                         I387_XMM0_REGNUM (tdep) + ir.rm);
             }
           else
@@ -7163,7 +7163,7 @@ reswitch_prefix_add:
         case 0x660fc5:      /* pextrw */
         case 0x0fd7:        /* pmovmskb */
         case 0x660fd7:      /* pmovmskb */
-          I386_RECORD_ARCH_LIST_ADD_REG (ir.reg | rex_r);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg | rex_r);
           break;
 
         case 0x0f3800:    /* pshufb */
@@ -7264,7 +7264,7 @@ reswitch_prefix_add:
 	    return -1;
           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.reg))
             goto no_support;
-          record_arch_list_add_reg (ir.regcache,
+          record_full_arch_list_add_reg (ir.regcache,
                                     I387_MM0_REGNUM (tdep) + ir.reg);
           break;
 
@@ -7275,7 +7275,7 @@ reswitch_prefix_add:
 	    return -1;
           if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.rm))
             goto no_support;
-          record_arch_list_add_reg (ir.regcache,
+          record_full_arch_list_add_reg (ir.regcache,
                                     I387_MM0_REGNUM (tdep) + ir.rm);
           break;
 
@@ -7287,7 +7287,7 @@ reswitch_prefix_add:
           ir.rm |= ir.rex_b;
           if (!i386_xmm_regnum_p (gdbarch, I387_XMM0_REGNUM (tdep) + ir.rm))
             goto no_support;
-          record_arch_list_add_reg (ir.regcache,
+          record_full_arch_list_add_reg (ir.regcache,
                                     I387_XMM0_REGNUM (tdep) + ir.rm);
           break;
 
@@ -7296,7 +7296,7 @@ reswitch_prefix_add:
           if (i386_record_modrm (&ir))
 	    return -1;
           if (ir.mod == 3)
-            I386_RECORD_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
+            I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rm | ir.rex_b);
           else
             {
               if (ir.dflag == 2)
@@ -7315,7 +7315,7 @@ reswitch_prefix_add:
             {
               if (!i386_mmx_regnum_p (gdbarch, I387_MM0_REGNUM (tdep) + ir.rm))
                 goto no_support;
-              record_arch_list_add_reg (ir.regcache,
+              record_full_arch_list_add_reg (ir.regcache,
                                         I387_MM0_REGNUM (tdep) + ir.rm);
             }
           else
@@ -7329,8 +7329,8 @@ reswitch_prefix_add:
         case 0xf30fb8:    /* popcnt */
           if (i386_record_modrm (&ir))
 	    return -1;
-          I386_RECORD_ARCH_LIST_ADD_REG (ir.reg);
-          I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.reg);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
           break;
 
         case 0x660fd6:    /* movq */
@@ -7342,7 +7342,7 @@ reswitch_prefix_add:
               if (!i386_xmm_regnum_p (gdbarch,
 				      I387_XMM0_REGNUM (tdep) + ir.rm))
                 goto no_support;
-              record_arch_list_add_reg (ir.regcache,
+              record_full_arch_list_add_reg (ir.regcache,
                                         I387_XMM0_REGNUM (tdep) + ir.rm);
             }
           else
@@ -7358,14 +7358,14 @@ reswitch_prefix_add:
         case 0x660f2e:      /* ucomisd */
         case 0x0f2f:        /* comiss */
         case 0x660f2f:      /* comisd */
-          I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM);
           break;
 
         case 0x0ff7:    /* maskmovq */
           regcache_raw_read_unsigned (ir.regcache,
                                       ir.regmap[X86_RECORD_REDI_REGNUM],
                                       &addr);
-          if (record_arch_list_add_mem (addr, 64))
+          if (record_full_arch_list_add_mem (addr, 64))
             return -1;
           break;
 
@@ -7373,7 +7373,7 @@ reswitch_prefix_add:
           regcache_raw_read_unsigned (ir.regcache,
                                       ir.regmap[X86_RECORD_REDI_REGNUM],
                                       &addr);
-          if (record_arch_list_add_mem (addr, 128))
+          if (record_full_arch_list_add_mem (addr, 128))
             return -1;
           break;
 
@@ -7389,8 +7389,8 @@ reswitch_prefix_add:
     }
 
   /* In the future, maybe still need to deal with need_dasm.  */
-  I386_RECORD_ARCH_LIST_ADD_REG (X86_RECORD_REIP_REGNUM);
-  if (record_arch_list_add_end ())
+  I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REIP_REGNUM);
+  if (record_full_arch_list_add_end ())
     return -1;
 
   return 0;
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 1e2addc..92874e2 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -3011,7 +3011,7 @@ adjust_pc_after_break (struct execution_control_state *ecs)
       struct cleanup *old_cleanups = NULL;
 
       if (RECORD_IS_USED)
-	old_cleanups = record_gdb_operation_disable_set ();
+	old_cleanups = record_full_gdb_operation_disable_set ();
 
       /* When using hardware single-step, a SIGTRAP is reported for both
 	 a completed single-step and a software breakpoint.  Need to
diff --git a/gdb/linux-record.c b/gdb/linux-record.c
index b8c7a4e..ef32229 100644
--- a/gdb/linux-record.c
+++ b/gdb/linux-record.c
@@ -100,7 +100,7 @@ record_linux_sockaddr (struct regcache *regcache,
 
   a = alloca (tdep->size_int);
 
-  if (record_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) len, tdep->size_int))
     return -1;
 
   /* Get the addrlen.  */
@@ -118,7 +118,7 @@ record_linux_sockaddr (struct regcache *regcache,
   if (addrlen <= 0 || addrlen > tdep->size_sockaddr)
     addrlen = tdep->size_sockaddr;
 
-  if (record_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) addr, addrlen))
     return -1;
 
   return 0;
@@ -137,7 +137,7 @@ record_linux_msghdr (struct regcache *regcache,
   if (!addr)
     return 0;
 
-  if (record_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) addr, tdep->size_msghdr))
     return -1;
 
   a = alloca (tdep->size_msghdr);
@@ -156,10 +156,11 @@ record_linux_msghdr (struct regcache *regcache,
   /* msg_name msg_namelen */
   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
   a += tdep->size_pointer;
-  if (record_arch_list_add_mem ((CORE_ADDR) addr,
-                                (int) extract_unsigned_integer (a,
-				                                tdep->size_int,
-				                                byte_order)))
+  if (record_full_arch_list_add_mem
+      ((CORE_ADDR) addr,
+       (int) extract_unsigned_integer (a,
+				       tdep->size_int,
+				       byte_order)))
     return -1;
   a += tdep->size_int;
 
@@ -193,7 +194,7 @@ record_linux_msghdr (struct regcache *regcache,
           tmpint = (int) extract_unsigned_integer (iov + tdep->size_pointer,
                                                    tdep->size_size_t,
                                                    byte_order);
-          if (record_arch_list_add_mem (tmpaddr, tmpint))
+          if (record_full_arch_list_add_mem (tmpaddr, tmpint))
             return -1;
           addr += tdep->size_iovec;
         }
@@ -204,7 +205,7 @@ record_linux_msghdr (struct regcache *regcache,
   addr = extract_unsigned_integer (a, tdep->size_pointer, byte_order);
   a += tdep->size_pointer;
   tmpint = (int) extract_unsigned_integer (a, tdep->size_size_t, byte_order);
-  if (record_arch_list_add_mem ((CORE_ADDR) addr, tmpint))
+  if (record_full_arch_list_add_mem ((CORE_ADDR) addr, tmpint))
     return -1;
 
   return 0;
@@ -261,7 +262,7 @@ record_linux_system_call (enum gdb_syscall syscall,
 
         regcache_raw_read_unsigned (regcache, tdep->arg2, &addr);
         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
-        if (record_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
+        if (record_full_arch_list_add_mem ((CORE_ADDR) addr, (int) count))
           return -1;
       }
       break;
@@ -286,8 +287,8 @@ record_linux_system_call (enum gdb_syscall syscall,
     case gdb_sys_fstat:
     case gdb_sys_lstat:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size__old_kernel_stat))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size__old_kernel_stat))
         return -1;
       break;
 
@@ -308,7 +309,7 @@ record_linux_system_call (enum gdb_syscall syscall,
         {
           regcache_raw_read_unsigned (regcache, tdep->arg4,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
             return -1;
         }
       break;
@@ -332,7 +333,8 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_times:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_tms))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_tms))
         return -1;
       break;
 
@@ -404,8 +406,8 @@ record_linux_system_call (enum gdb_syscall syscall,
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_termios))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_termios))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCGPGRP
@@ -413,8 +415,8 @@ record_linux_system_call (enum gdb_syscall syscall,
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_pid_t))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_pid_t))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCOUTQ
@@ -428,16 +430,16 @@ record_linux_system_call (enum gdb_syscall syscall,
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_int))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_int))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCGWINSZ)
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_winsize))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_winsize))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCLINUX)
@@ -445,47 +447,47 @@ record_linux_system_call (enum gdb_syscall syscall,
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
 	  /* This syscall affects a char-size memory.  */
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 1))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCGSERIAL)
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_serial_struct))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_serial_struct))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TCGETS2)
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_termios2))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_termios2))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_FIOQSIZE)
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_loff_t))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_loff_t))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCGICOUNT)
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_serial_icounter_struct))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_serial_icounter_struct))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCGHAYESESP)
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_hayes_esp_config))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_hayes_esp_config))
             return -1;
         }
       else if (tmpulongest == tdep->ioctl_TIOCSERGSTRUCT)
@@ -511,8 +513,8 @@ record_linux_system_call (enum gdb_syscall syscall,
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_flock))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_flock))
             return -1;
         }
       break;
@@ -524,8 +526,8 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_olduname:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_oldold_utsname))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_oldold_utsname))
         return -1;
       break;
 
@@ -535,8 +537,8 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_ustat:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_ustat))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_ustat))
         return -1;
       break;
 
@@ -548,8 +550,8 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_sigaction:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_sigaction))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_sigaction))
         return -1;
       break;
 
@@ -562,8 +564,8 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_sigpending:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_sigset_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_sigset_t))
         return -1;
       break;
 
@@ -573,26 +575,26 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_old_getrlimit:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rlimit))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_rlimit))
         return -1;
       break;
 
     case gdb_sys_getrusage:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rusage))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_rusage))
         return -1;
       break;
 
     case gdb_sys_gettimeofday:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timeval))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timeval))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timezone))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timezone))
         return -1;
       break;
 
@@ -601,15 +603,15 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_sys_getgroups16:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_gid_t))
         return -1;
       break;
 
     case gdb_sys_setgroups16:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_gid_t))
         return -1;
       break;
 
@@ -639,13 +641,13 @@ record_linux_system_call (enum gdb_syscall syscall,
                                       (unsigned long) sizeof (sel));
                 return -1;
               }
-            if (record_arch_list_add_mem (sel.inp, tdep->size_fd_set))
+            if (record_full_arch_list_add_mem (sel.inp, tdep->size_fd_set))
               return -1;
-            if (record_arch_list_add_mem (sel.outp, tdep->size_fd_set))
+            if (record_full_arch_list_add_mem (sel.outp, tdep->size_fd_set))
               return -1;
-            if (record_arch_list_add_mem (sel.exp, tdep->size_fd_set))
+            if (record_full_arch_list_add_mem (sel.exp, tdep->size_fd_set))
               return -1;
-            if (record_arch_list_add_mem (sel.tvp, tdep->size_timeval))
+            if (record_full_arch_list_add_mem (sel.tvp, tdep->size_timeval))
               return -1;
           }
       }
@@ -661,7 +663,7 @@ record_linux_system_call (enum gdb_syscall syscall,
         regcache_raw_read_unsigned (regcache, tdep->arg2,
                                     &tmpulongest);
         regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
-        if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
+        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
           return -1;
       }
       break;
@@ -686,8 +688,8 @@ record_linux_system_call (enum gdb_syscall syscall,
 
     case gdb_old_readdir:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_dirent))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_dirent))
         return -1;
       break;
 
@@ -701,7 +703,7 @@ record_linux_system_call (enum gdb_syscall syscall,
         regcache_raw_read_unsigned (regcache, tdep->arg1,
                                     &tmpulongest);
         regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
-        if (record_memory_query)
+        if (record_full_memory_query)
           {
 	    int q;
 
@@ -731,8 +733,8 @@ Do you want to stop the program?"),
     case gdb_sys_statfs:
     case gdb_sys_fstatfs:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_statfs))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_statfs))
         return -1;
       break;
 
@@ -779,7 +781,8 @@ Do you want to stop the program?"),
 
         regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
         regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
-        if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
+        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					   (int) size))
           return -1;
       }
       break;
@@ -792,7 +795,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_socketpair:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       break;
 
@@ -818,10 +822,10 @@ Do you want to stop the program?"),
           regcache_raw_read_unsigned (regcache, tdep->arg4, &optvalp);
           tmpint = (int) extract_signed_integer (optlenp, tdep->size_int,
                                                  byte_order);
-          if (record_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) optvalp, tmpint))
             return -1;
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_int))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_int))
             return -1;
         }
       break;
@@ -892,7 +896,7 @@ Do you want to stop the program?"),
                 tmpaddr
                   = (CORE_ADDR) extract_unsigned_integer (a, tdep->size_ulong,
                                                           byte_order);
-                if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
+                if (record_full_arch_list_add_mem (tmpaddr, tdep->size_int))
                   return -1;
               }
           }
@@ -953,8 +957,8 @@ Do you want to stop the program?"),
                   a += tdep->size_ulong;
                   tmpint = (int) extract_unsigned_integer (a, tdep->size_ulong,
                                                            byte_order);
-                  if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                                tmpint))
+                  if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+						     tmpint))
                     return -1;
                 }
             }
@@ -1008,14 +1012,15 @@ Do you want to stop the program?"),
                     tmpint = (int) extract_unsigned_integer (av,
                                                              tdep->size_int,
                                                              byte_order);
-                    if (record_arch_list_add_mem (tmpaddr, tmpint))
+                    if (record_full_arch_list_add_mem (tmpaddr, tmpint))
                       return -1;
                     a += tdep->size_ulong;
                     tmpaddr
                       = (CORE_ADDR) extract_unsigned_integer (a,
                                                               tdep->size_ulong,
                                                               byte_order);
-                    if (record_arch_list_add_mem (tmpaddr, tdep->size_int))
+                    if (record_full_arch_list_add_mem (tmpaddr,
+						       tdep->size_int))
                       return -1;
                   }
               }
@@ -1064,15 +1069,15 @@ Do you want to stop the program?"),
 
     case gdb_sys_setitimer:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerval))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_itimerval))
         return -1;
       break;
 
     case gdb_sys_getitimer:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerval))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_itimerval))
         return -1;
       break;
 
@@ -1081,14 +1086,15 @@ Do you want to stop the program?"),
     case gdb_sys_newfstat:
     case gdb_sys_newfstatat:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_stat))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_stat))
         return -1;
       break;
 
     case gdb_sys_uname:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_utsname))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_utsname))
         return -1;
       break;
 
@@ -1100,12 +1106,12 @@ Do you want to stop the program?"),
 
     case gdb_sys_wait4:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rusage))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_rusage))
         return -1;
       break;
 
@@ -1114,8 +1120,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_sysinfo:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_sysinfo))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_sysinfo))
         return -1;
       break;
 
@@ -1131,15 +1137,15 @@ Do you want to stop the program?"),
 
     case gdb_sys_shmat:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_ulong))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_ulong))
         return -1;
       break;
 
     case gdb_sys_shmctl:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_shmid_ds))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_shmid_ds))
         return -1;
       break;
 
@@ -1153,15 +1159,15 @@ Do you want to stop the program?"),
         regcache_raw_read_signed (regcache, tdep->arg3, &tmpulongest);
         regcache_raw_read_unsigned (regcache, tdep->arg2, &msgp);
         tmpint = (int) tmpulongest + tdep->size_long;
-        if (record_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
+        if (record_full_arch_list_add_mem ((CORE_ADDR) msgp, tmpint))
           return -1;
       }
       break;
 
     case gdb_sys_msgctl:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_msqid_ds))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_msqid_ds))
         return -1;
       break;
 
@@ -1187,29 +1193,29 @@ Do you want to stop the program?"),
             regcache_raw_read_signed (regcache, tdep->arg3, &second);
             regcache_raw_read_unsigned (regcache, tdep->arg5, &ptr);
             tmpint = (int) second + tdep->size_long;
-            if (record_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
+            if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, tmpint))
               return -1;
           }
           break;
         case RECORD_MSGCTL:
           regcache_raw_read_unsigned (regcache, tdep->arg5,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_msqid_ds))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_msqid_ds))
             return -1;
           break;
         case RECORD_SHMAT:
           regcache_raw_read_unsigned (regcache, tdep->arg4,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_ulong))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_ulong))
             return -1;
           break;
         case RECORD_SHMCTL:
           regcache_raw_read_unsigned (regcache, tdep->arg5,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_shmid_ds))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_shmid_ds))
             return -1;
           break;
         default:
@@ -1229,8 +1235,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_newuname:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_new_utsname))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_new_utsname))
         return -1;
       break;
 
@@ -1242,14 +1248,15 @@ Do you want to stop the program?"),
 
           regcache_raw_read_unsigned (regcache, tdep->arg2, &ptr);
           regcache_raw_read_unsigned (regcache, tdep->arg3, &bytecount);
-          if (record_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) ptr, (int) bytecount))
             return -1;
         }
       break;
 
     case gdb_sys_adjtimex:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_timex))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timex))
         return -1;
       break;
 
@@ -1258,8 +1265,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_sigprocmask:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_sigset_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_sigset_t))
         return -1;
       break;
 
@@ -1277,29 +1284,29 @@ Do you want to stop the program?"),
           regcache_raw_read_unsigned (regcache, tdep->arg4,
                                       &tmpulongest);
           /* __u32 */
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 4))
             return -1;
           break;
         case RECORD_Q_GETINFO:
           regcache_raw_read_unsigned (regcache, tdep->arg4,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_mem_dqinfo))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_mem_dqinfo))
             return -1;
           break;
         case RECORD_Q_GETQUOTA:
           regcache_raw_read_unsigned (regcache, tdep->arg4,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_if_dqblk))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_if_dqblk))
             return -1;
           break;
         case RECORD_Q_XGETQSTAT:
         case RECORD_Q_XGETQUOTA:
           regcache_raw_read_unsigned (regcache, tdep->arg4,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_fs_quota_stat))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_fs_quota_stat))
             return -1;
           break;
         }
@@ -1317,7 +1324,7 @@ Do you want to stop the program?"),
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
 	  /*XXX the size of memory is not very clear.  */
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, 10))
             return -1;
         }
       break;
@@ -1330,8 +1337,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_llseek:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_loff_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_loff_t))
         return -1;
       break;
 
@@ -1342,28 +1349,28 @@ Do you want to stop the program?"),
         regcache_raw_read_unsigned (regcache, tdep->arg2,
                                     &tmpulongest);
         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
-        if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                      tdep->size_dirent * count))
+        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					   tdep->size_dirent * count))
           return -1;
       }
       break;
 
     case gdb_sys_select:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_fd_set))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_fd_set))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_fd_set))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timeval))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timeval))
         return -1;
       break;
 
@@ -1402,7 +1409,7 @@ Do you want to stop the program?"),
                   = (int) extract_unsigned_integer (iov + tdep->size_pointer,
                                                     tdep->size_size_t,
                                                     byte_order);
-                if (record_arch_list_add_mem (tmpaddr, tmpint))
+                if (record_full_arch_list_add_mem (tmpaddr, tmpint))
                   return -1;
                 vec += tdep->size_iovec;
               }
@@ -1423,7 +1430,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_sched_getparam:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       break;
 
@@ -1437,8 +1445,8 @@ Do you want to stop the program?"),
     case gdb_sys_sched_rr_get_interval:
     case gdb_sys_nanosleep:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timespec))
         return -1;
       break;
 
@@ -1448,16 +1456,16 @@ Do you want to stop the program?"),
 
     case gdb_sys_getresuid16:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_uid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_uid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_uid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_uid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_uid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_uid_t))
         return -1;
       break;
 
@@ -1472,8 +1480,8 @@ Do you want to stop the program?"),
           ULONGEST nfds;
 
           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_pollfd * nfds))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_pollfd * nfds))
             return -1;
         }
       break;
@@ -1490,7 +1498,7 @@ Do you want to stop the program?"),
             rsize = tdep->size_knfsd_fh;
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, rsize))
             return -1;
         }
       break;
@@ -1500,16 +1508,16 @@ Do you want to stop the program?"),
 
     case gdb_sys_getresgid16:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_gid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_gid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_old_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_old_gid_t))
         return -1;
       break;
 
@@ -1520,15 +1528,15 @@ Do you want to stop the program?"),
         case 2:
           regcache_raw_read_unsigned (regcache, tdep->arg2,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_int))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_int))
             return -1;
           break;
         case 16:
           regcache_raw_read_unsigned (regcache, tdep->arg2,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_TASK_COMM_LEN))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_TASK_COMM_LEN))
             return -1;
           break;
         }
@@ -1539,15 +1547,15 @@ Do you want to stop the program?"),
 
     case gdb_sys_rt_sigaction:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_sigaction))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_sigaction))
         return -1;
       break;
 
     case gdb_sys_rt_sigprocmask:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_sigset_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_sigset_t))
         return -1;
       break;
 
@@ -1558,16 +1566,16 @@ Do you want to stop the program?"),
           ULONGEST sigsetsize;
 
           regcache_raw_read_unsigned (regcache, tdep->arg2,&sigsetsize);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        (int) sigsetsize))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) sigsetsize))
             return -1;
         }
       break;
 
     case gdb_sys_rt_sigtimedwait:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_siginfo_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_siginfo_t))
         return -1;
       break;
 
@@ -1582,7 +1590,8 @@ Do you want to stop the program?"),
           ULONGEST count;
 
           regcache_raw_read_unsigned (regcache, tdep->arg3,&count);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) count))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) count))
             return -1;
         }
       break;
@@ -1598,15 +1607,16 @@ Do you want to stop the program?"),
           ULONGEST size;
 
           regcache_raw_read_unsigned (regcache, tdep->arg2, &size);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) size))
             return -1;
         }
       break;
 
     case gdb_sys_capget:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_cap_user_data_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_cap_user_data_t))
         return -1;
       break;
 
@@ -1615,15 +1625,15 @@ Do you want to stop the program?"),
 
     case gdb_sys_sigaltstack:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_stack_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_stack_t))
         return -1;
       break;
 
     case gdb_sys_sendfile:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_off_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_off_t))
         return -1;
       break;
 
@@ -1634,8 +1644,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_getrlimit:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rlimit))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_rlimit))
         return -1;
       break;
 
@@ -1650,8 +1660,8 @@ Do you want to stop the program?"),
     case gdb_sys_lstat64:
     case gdb_sys_fstat64:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_stat64))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_stat64))
         return -1;
       break;
 
@@ -1673,7 +1683,7 @@ Do you want to stop the program?"),
           regcache_raw_read_unsigned (regcache, tdep->arg1,
                                       &gidsetsize);
           tmpint = tdep->size_gid_t * (int) gidsetsize;
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
             return -1;
         }
       break;
@@ -1685,13 +1695,16 @@ Do you want to stop the program?"),
 
     case gdb_sys_getresuid:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_uid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_uid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_uid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_uid_t))
         return -1;
       break;
 
@@ -1700,13 +1713,16 @@ Do you want to stop the program?"),
 
     case gdb_sys_getresgid:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_gid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_gid_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_gid_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_gid_t))
         return -1;
       break;
 
@@ -1720,8 +1736,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_mincore:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_PAGE_SIZE))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_PAGE_SIZE))
         return -1;
       break;
 
@@ -1735,8 +1751,8 @@ Do you want to stop the program?"),
         regcache_raw_read_unsigned (regcache, tdep->arg2,
                                     &tmpulongest);
         regcache_raw_read_unsigned (regcache, tdep->arg3, &count);
-        if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                      tdep->size_dirent64 * count))
+        if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					   tdep->size_dirent64 * count))
           return -1;
       }
       break;
@@ -1747,8 +1763,8 @@ Do you want to stop the program?"),
         {
           regcache_raw_read_unsigned (regcache, tdep->arg3,
                                       &tmpulongest);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_flock64))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_flock64))
             return -1;
         }
       else if (tmpulongest != tdep->fcntl_F_SETLK64
@@ -1776,7 +1792,8 @@ Do you want to stop the program?"),
           ULONGEST size;
 
           regcache_raw_read_unsigned (regcache, tdep->arg4, &size);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) size))
             return -1;
         }
       break;
@@ -1790,7 +1807,8 @@ Do you want to stop the program?"),
           ULONGEST size;
 
           regcache_raw_read_unsigned (regcache, tdep->arg3, &size);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) size))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) size))
             return -1;
         }
       break;
@@ -1803,8 +1821,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_sendfile64:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_loff_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_loff_t))
         return -1;
       break;
 
@@ -1819,27 +1837,30 @@ Do you want to stop the program?"),
           ULONGEST len;
 
           regcache_raw_read_unsigned (regcache, tdep->arg2, &len);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) len))
             return -1;
         }
       break;
 
     case gdb_sys_set_thread_area:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       break;
 
     case gdb_sys_get_thread_area:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_user_desc))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_user_desc))
         return -1;
       break;
 
     case gdb_sys_io_setup:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_long))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_long))
         return -1;
       break;
 
@@ -1853,8 +1874,8 @@ Do you want to stop the program?"),
           ULONGEST nr;
 
           regcache_raw_read_unsigned (regcache, tdep->arg3, &nr);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        nr * tdep->size_io_event))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     nr * tdep->size_io_event))
             return -1;
         }
       break;
@@ -1885,7 +1906,7 @@ Do you want to stop the program?"),
                 = (CORE_ADDR) extract_unsigned_integer (iocbp,
                                                         tdep->size_pointer,
                                                         byte_order);
-              if (record_arch_list_add_mem (tmpaddr, tdep->size_iocb))
+              if (record_full_arch_list_add_mem (tmpaddr, tdep->size_iocb))
                 return -1;
               iocbp += tdep->size_pointer;
             }
@@ -1894,8 +1915,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_io_cancel:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_io_event))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_io_event))
         return -1;
       break;
 
@@ -1924,7 +1945,8 @@ Do you want to stop the program?"),
           ULONGEST len;
 
           regcache_raw_read_unsigned (regcache, tdep->arg3, &len);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) len))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) len))
             return -1;
         }
       break;
@@ -1940,8 +1962,9 @@ Do you want to stop the program?"),
           ULONGEST maxevents;
 
           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        maxevents * tdep->size_epoll_event))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     maxevents *
+					     tdep->size_epoll_event))
             return -1;
         }
       break;
@@ -1952,21 +1975,22 @@ Do you want to stop the program?"),
 
     case gdb_sys_timer_create:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       break;
 
     case gdb_sys_timer_settime:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerspec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_itimerspec))
         return -1;
       break;
 
     case gdb_sys_timer_gettime:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_itimerspec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_itimerspec))
         return -1;
       break;
 
@@ -1977,30 +2001,30 @@ Do you want to stop the program?"),
 
     case gdb_sys_clock_gettime:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timespec))
         return -1;
       break;
 
     case gdb_sys_clock_getres:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timespec))
         return -1;
       break;
 
     case gdb_sys_clock_nanosleep:
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timespec))
         return -1;
       break;
 
     case gdb_sys_statfs64:
     case gdb_sys_fstatfs64:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_statfs64))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_statfs64))
         return -1;
       break;
 
@@ -2013,7 +2037,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_get_mempolicy:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
       if (tmpulongest)
@@ -2021,8 +2046,8 @@ Do you want to stop the program?"),
           ULONGEST maxnode;
 
           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxnode);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        maxnode * tdep->size_long))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     maxnode * tdep->size_long))
             return -1;
         }
       break;
@@ -2040,12 +2065,13 @@ Do you want to stop the program?"),
           ULONGEST msg_len;
 
           regcache_raw_read_unsigned (regcache, tdep->arg3, &msg_len);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        (int) msg_len))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) msg_len))
             return -1;
         }
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       break;
 
@@ -2054,8 +2080,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_mq_getsetattr:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_mq_attr))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_mq_attr))
         return -1;
       break;
 
@@ -2064,12 +2090,12 @@ Do you want to stop the program?"),
 
     case gdb_sys_waitid:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_siginfo))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_siginfo))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_rusage))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_rusage))
         return -1;
       break;
 
@@ -2089,8 +2115,8 @@ Do you want to stop the program?"),
               ULONGEST buflen;
 
               regcache_raw_read_unsigned (regcache, tdep->arg4, &buflen);
-              if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                            (int) buflen))
+              if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+						 (int) buflen))
                 return -1;
             }
         }
@@ -2111,8 +2137,8 @@ Do you want to stop the program?"),
 
     case gdb_sys_fstatat64:
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_stat64))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_stat64))
         return -1;
       break;
 
@@ -2129,7 +2155,8 @@ Do you want to stop the program?"),
           ULONGEST bufsiz;
 
           regcache_raw_read_unsigned (regcache, tdep->arg4, &bufsiz);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, (int) bufsiz))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     (int) bufsiz))
             return -1;
         }
       break;
@@ -2140,20 +2167,20 @@ Do you want to stop the program?"),
 
     case gdb_sys_pselect6:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_fd_set))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_fd_set))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_fd_set))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_fd_set))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg5, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timespec))
         return -1;
       break;
 
@@ -2164,13 +2191,13 @@ Do you want to stop the program?"),
           ULONGEST nfds;
 
           regcache_raw_read_unsigned (regcache, tdep->arg2, &nfds);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        tdep->size_pollfd * nfds))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     tdep->size_pollfd * nfds))
             return -1;
         }
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_timespec))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_timespec))
         return -1;
       break;
 
@@ -2180,21 +2207,23 @@ Do you want to stop the program?"),
 
     case gdb_sys_get_robust_list:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       break;
 
     case gdb_sys_splice:
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_loff_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_loff_t))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg4, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_loff_t))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_loff_t))
         return -1;
       break;
 
@@ -2210,22 +2239,24 @@ Do you want to stop the program?"),
           ULONGEST nr_pages;
 
           regcache_raw_read_unsigned (regcache, tdep->arg2, &nr_pages);
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                        nr_pages * tdep->size_int))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					     nr_pages * tdep->size_int))
             return -1;
         }
       break;
 
     case gdb_sys_getcpu:
       regcache_raw_read_unsigned (regcache, tdep->arg1, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg2, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tdep->size_int))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_int))
         return -1;
       regcache_raw_read_unsigned (regcache, tdep->arg3, &tmpulongest);
-      if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest,
-                                    tdep->size_ulong * 2))
+      if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest,
+					 tdep->size_ulong * 2))
         return -1;
       break;
 
@@ -2237,7 +2268,7 @@ Do you want to stop the program?"),
 
           regcache_raw_read_unsigned (regcache, tdep->arg3, &maxevents);
           tmpint = (int) maxevents * tdep->size_epoll_event;
-          if (record_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
+          if (record_full_arch_list_add_mem ((CORE_ADDR) tmpulongest, tmpint))
             return -1;
         }
       break;
diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c
index fc0f85c..1676a9b 100644
--- a/gdb/moxie-tdep.c
+++ b/gdb/moxie-tdep.c
@@ -573,7 +573,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    case 0x02: /* gsr */
 	      {
 		int reg = (inst >> 8) & 0xf;
-		if (record_arch_list_add_reg (regcache, reg))
+		if (record_full_arch_list_add_reg (regcache, reg))
 		  return -1;
 	      }
 	      break;
@@ -603,7 +603,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	case 0x02: /* mov (register-to-register) */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -613,25 +613,25 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 			       MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
-	    if (record_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
-		|| (record_arch_list_add_reg (regcache, 
-					      MOXIE_SP_REGNUM))
-		|| record_arch_list_add_mem (tmpu32 - 12, 12))
+	    if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
+		|| (record_full_arch_list_add_reg (regcache,
+						   MOXIE_SP_REGNUM))
+		|| record_full_arch_list_add_mem (tmpu32 - 12, 12))
 	      return -1;
 	  }
 	  break;
 	case 0x04: /* ret */
 	  {
-	    if (record_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
-		|| (record_arch_list_add_reg (regcache, 
-					      MOXIE_SP_REGNUM)))
+	    if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
+		|| (record_full_arch_list_add_reg (regcache,
+						   MOXIE_SP_REGNUM)))
 	      return -1;
 	  }
 	  break;
 	case 0x05: /* add.l */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -641,8 +641,8 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
-	    if (record_arch_list_add_reg (regcache, reg)
-		|| record_arch_list_add_mem (tmpu32 - 4, 4))
+	    if (record_full_arch_list_add_reg (regcache, reg)
+		|| record_full_arch_list_add_mem (tmpu32 - 4, 4))
 	      return -1;
 	  }
 	  break;
@@ -650,15 +650,15 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  {
 	    int a = (inst >> 4) & 0xf;
 	    int b = inst & 0xf;
-	    if (record_arch_list_add_reg (regcache, a)
-		|| record_arch_list_add_reg (regcache, b))
+	    if (record_full_arch_list_add_reg (regcache, a)
+		|| record_full_arch_list_add_reg (regcache, b))
 	      return -1;
 	  }
 	  break;
 	case 0x08: /* lda.l */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -666,14 +666,14 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  {
 	    tmpu32 = (uint32_t) moxie_process_readu (addr+2, buf, 
 						     4, byte_order);
-	    if (record_arch_list_add_mem (tmpu32, 4))
+	    if (record_full_arch_list_add_mem (tmpu32, 4))
 	      return -1;
 	  }
 	  break;
 	case 0x0a: /* ld.l (register indirect) */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -683,14 +683,14 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
-	    if (record_arch_list_add_mem (tmpu32, 4))
+	    if (record_full_arch_list_add_mem (tmpu32, 4))
 	      return -1;
 	  }
 	  break;
 	case 0x0c: /* ldo.l */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -703,13 +703,13 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
 	    tmpu32 += offset;
-	    if (record_arch_list_add_mem (tmpu32, 4))
+	    if (record_full_arch_list_add_mem (tmpu32, 4))
 	      return -1;
 	  }
 	  break;
 	case 0x0e: /* cmp */
 	  {
-	    if (record_arch_list_add_reg (regcache, MOXIE_CC_REGNUM))
+	    if (record_full_arch_list_add_reg (regcache, MOXIE_CC_REGNUM))
 	      return -1;
 	  }
 	  break;
@@ -733,10 +733,10 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 			       MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
-	    if (record_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
-		|| (record_arch_list_add_reg (regcache, 
-					      MOXIE_SP_REGNUM))
-		|| record_arch_list_add_mem (tmpu32 - 12, 12))
+	    if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
+		|| (record_full_arch_list_add_reg (regcache,
+						   MOXIE_SP_REGNUM))
+		|| record_full_arch_list_add_mem (tmpu32 - 12, 12))
 	      return -1;
 	  }
 	  break;
@@ -750,7 +750,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	case 0x1d: /* lda.b */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -760,7 +760,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
-	    if (record_arch_list_add_mem (tmpu32, 1))
+	    if (record_full_arch_list_add_mem (tmpu32, 1))
 	      return -1;
 	  }
 	  break;
@@ -768,7 +768,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  {
 	    tmpu32 = moxie_process_readu (addr+2, (char *) buf, 
 					  4, byte_order);
-	    if (record_arch_list_add_mem (tmpu32, 1))
+	    if (record_full_arch_list_add_mem (tmpu32, 1))
 	      return -1;
 	  }
 	  break;
@@ -777,7 +777,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	case 0x22: /* lda.s */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -787,7 +787,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
-	    if (record_arch_list_add_mem (tmpu32, 2))
+	    if (record_full_arch_list_add_mem (tmpu32, 2))
 	      return -1;
 	  }
 	  break;
@@ -795,7 +795,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	  {
 	    tmpu32 = moxie_process_readu (addr+2, (char *) buf, 
 					  4, byte_order);
-	    if (record_arch_list_add_mem (tmpu32, 2))
+	    if (record_full_arch_list_add_mem (tmpu32, 2))
 	      return -1;
 	  }
 	  break;
@@ -816,7 +816,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	case 0x2f: /* mul.l */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -837,7 +837,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 		break;
 	      case 0x2: /* SYS_open */
 		{
-		  if (record_arch_list_add_reg (regcache, RET1_REGNUM))
+		  if (record_full_arch_list_add_reg (regcache, RET1_REGNUM))
 		    return -1;
 		}
 		break;
@@ -858,13 +858,13 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 		  length = moxie_process_readu (tmpu32+20, (char *) buf, 
 						4, byte_order);
 
-		  if (record_arch_list_add_mem (ptr, length))
+		  if (record_full_arch_list_add_mem (ptr, length))
 		    return -1;
 		}
 		break;
 	      case 0x5: /* SYS_write */
 		{
-		  if (record_arch_list_add_reg (regcache, RET1_REGNUM))
+		  if (record_full_arch_list_add_reg (regcache, RET1_REGNUM))
 		    return -1;
 		}
 		break;
@@ -879,7 +879,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	case 0x34: /* umod.l */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -889,7 +889,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	case 0x36: /* ldo.b */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -902,14 +902,14 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
 	    tmpu32 += offset;
-	    if (record_arch_list_add_mem (tmpu32, 1))
+	    if (record_full_arch_list_add_mem (tmpu32, 1))
 	      return -1;
 	  }
 	  break;
 	case 0x38: /* ldo.s */
 	  {
 	    int reg = (inst >> 4) & 0xf;
-	    if (record_arch_list_add_reg (regcache, reg))
+	    if (record_full_arch_list_add_reg (regcache, reg))
 	      return -1;
 	  }
 	  break;
@@ -922,7 +922,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	    tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32, 
 					       4, byte_order);
 	    tmpu32 += offset;
-	    if (record_arch_list_add_mem (tmpu32, 2))
+	    if (record_full_arch_list_add_mem (tmpu32, 2))
 	      return -1;
 	  }
 	  break;
@@ -932,9 +932,9 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
 	}
     }
 
-  if (record_arch_list_add_reg (regcache, MOXIE_PC_REGNUM))
+  if (record_full_arch_list_add_reg (regcache, MOXIE_PC_REGNUM))
     return -1;
-  if (record_arch_list_add_end ())
+  if (record_full_arch_list_add_end ())
     return -1;
   return 0;
 }
diff --git a/gdb/record-full.c b/gdb/record-full.c
index 54a6b71..351b1e8 100644
--- a/gdb/record-full.c
+++ b/gdb/record-full.c
@@ -156,7 +156,7 @@ struct record_full_entry
 
 /* If true, query if PREC cannot record memory
    change of next instruction.  */
-int record_memory_query = 0;
+int record_full_memory_query = 0;
 
 struct record_full_core_buf_entry
 {
@@ -486,7 +486,7 @@ record_full_get_loc (struct record_full_entry *rec)
 /* Record the value of a register NUM to record_full_arch_list.  */
 
 int
-record_arch_list_add_reg (struct regcache *regcache, int regnum)
+record_full_arch_list_add_reg (struct regcache *regcache, int regnum)
 {
   struct record_full_entry *rec;
 
@@ -509,7 +509,7 @@ record_arch_list_add_reg (struct regcache *regcache, int regnum)
    length is LEN to record_full_arch_list.  */
 
 int
-record_arch_list_add_mem (CORE_ADDR addr, int len)
+record_full_arch_list_add_mem (CORE_ADDR addr, int len)
 {
   struct record_full_entry *rec;
 
@@ -540,7 +540,7 @@ record_arch_list_add_mem (CORE_ADDR addr, int len)
    record_full_arch_list.  */
 
 int
-record_arch_list_add_end (void)
+record_full_arch_list_add_end (void)
 {
   struct record_full_entry *rec;
 
@@ -704,7 +704,7 @@ record_full_message_wrapper_safe (struct regcache *regcache,
 static int record_full_gdb_operation_disable = 0;
 
 struct cleanup *
-record_gdb_operation_disable_set (void)
+record_full_gdb_operation_disable_set (void)
 {
   struct cleanup *old_cleanups = NULL;
 
@@ -1192,7 +1192,7 @@ record_full_wait_1 (struct target_ops *ops,
 		    ptid_t ptid, struct target_waitstatus *status,
 		    int options)
 {
-  struct cleanup *set_cleanups = record_gdb_operation_disable_set ();
+  struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
 
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog,
@@ -1602,7 +1602,7 @@ record_full_registers_change (struct regcache *regcache, int regnum)
 
       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 	{
-	  if (record_arch_list_add_reg (regcache, i))
+	  if (record_full_arch_list_add_reg (regcache, i))
 	    {
 	      record_full_list_release (record_full_arch_list_tail);
 	      error (_("Process record: failed to record execution log."));
@@ -1611,13 +1611,13 @@ record_full_registers_change (struct regcache *regcache, int regnum)
     }
   else
     {
-      if (record_arch_list_add_reg (regcache, regnum))
+      if (record_full_arch_list_add_reg (regcache, regnum))
 	{
 	  record_full_list_release (record_full_arch_list_tail);
 	  error (_("Process record: failed to record execution log."));
 	}
     }
-  if (record_arch_list_add_end ())
+  if (record_full_arch_list_add_end ())
     {
       record_full_list_release (record_full_arch_list_tail);
       error (_("Process record: failed to record execution log."));
@@ -1724,7 +1724,7 @@ record_full_xfer_partial (struct target_ops *ops, enum target_object object,
       /* Record registers change to list as an instruction.  */
       record_full_arch_list_head = NULL;
       record_full_arch_list_tail = NULL;
-      if (record_arch_list_add_mem (offset, len))
+      if (record_full_arch_list_add_mem (offset, len))
 	{
 	  record_full_list_release (record_full_arch_list_tail);
 	  if (record_debug)
@@ -1733,7 +1733,7 @@ record_full_xfer_partial (struct target_ops *ops, enum target_object object,
 				"execution log.");
 	  return -1;
 	}
-      if (record_arch_list_add_end ())
+      if (record_full_arch_list_add_end ())
 	{
 	  record_full_list_release (record_full_arch_list_tail);
 	  if (record_debug)
@@ -1834,7 +1834,7 @@ record_full_insert_breakpoint (struct gdbarch *gdbarch,
       struct cleanup *old_cleanups;
       int ret;
 
-      old_cleanups = record_gdb_operation_disable_set ();
+      old_cleanups = record_full_gdb_operation_disable_set ();
       ret = record_full_beneath_to_insert_breakpoint (gdbarch, bp_tgt);
       do_cleanups (old_cleanups);
 
@@ -1874,7 +1874,7 @@ record_full_remove_breakpoint (struct gdbarch *gdbarch,
 	      struct cleanup *old_cleanups;
 	      int ret;
 
-	      old_cleanups = record_gdb_operation_disable_set ();
+	      old_cleanups = record_full_gdb_operation_disable_set ();
 	      ret = record_full_beneath_to_remove_breakpoint (gdbarch, bp_tgt);
 	      do_cleanups (old_cleanups);
 
@@ -2720,7 +2720,7 @@ record_full_save (char *recfilename)
   gdbarch = get_regcache_arch (regcache);
 
   /* Disable the GDB operation record.  */
-  set_cleanups = record_gdb_operation_disable_set ();
+  set_cleanups = record_full_gdb_operation_disable_set ();
 
   /* Reverse execute to the begin of record list.  */
   while (1)
@@ -2900,7 +2900,7 @@ static void
 record_full_goto_insn (struct record_full_entry *entry,
 		       enum exec_direction_kind dir)
 {
-  struct cleanup *set_cleanups = record_gdb_operation_disable_set ();
+  struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
   struct regcache *regcache = get_current_regcache ();
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
@@ -3046,7 +3046,7 @@ record/replay buffer.  Zero means unlimited.  Default is 200000."),
   deprecate_cmd (c, "show record full insn-number-max");
 
   add_setshow_boolean_cmd ("memory-query", no_class,
-			   &record_memory_query, _("\
+			   &record_full_memory_query, _("\
 Set whether query if PREC cannot record memory change of next instruction."),
                            _("\
 Show whether query if PREC cannot record memory change of next instruction."),
diff --git a/gdb/record-full.h b/gdb/record-full.h
index 46da3a2..b5d5b31 100644
--- a/gdb/record-full.h
+++ b/gdb/record-full.h
@@ -20,11 +20,11 @@
 #ifndef RECORD_FULL_H
 #define RECORD_FULL_H
 
-extern int record_memory_query;
+extern int record_full_memory_query;
 
-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);
+extern int record_full_arch_list_add_reg (struct regcache *regcache, int num);
+extern int record_full_arch_list_add_mem (CORE_ADDR addr, int len);
+extern int record_full_arch_list_add_end (void);
+extern struct cleanup *record_full_gdb_operation_disable_set (void);
 
 #endif /* RECORD_FULL_H */
-- 
1.7.1

[rfc 2/8] record-full.c: rename record_ in record_full_.

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Rename record_ prefixes in record-full.c into record_full_.

I ran the gdb.reverse suite on 64bit IA gnu/linux - no regressions.

The changelog for this renaming will be huge. Is there a way to abbreviate or
auto-generate it?

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

---
 gdb/record-full.c | 1556 +++++++++++++++++++++++++++--------------------------
 1 files changed, 802 insertions(+), 754 deletions(-)

diff --git a/gdb/record-full.c b/gdb/record-full.c
index 1cbd724..54a6b71 100644
--- a/gdb/record-full.c
+++ b/gdb/record-full.c
@@ -58,25 +58,25 @@
    instruction's side effects by duplicating the changes that it would
    have made on memory and registers.  */
 
-#define DEFAULT_RECORD_INSN_MAX_NUM	200000
+#define DEFAULT_RECORD_FULL_INSN_MAX_NUM	200000
 
-#define RECORD_IS_REPLAY \
-     (record_list->next || execution_direction == EXEC_REVERSE)
+#define RECORD_FULL_IS_REPLAY \
+     (record_full_list->next || execution_direction == EXEC_REVERSE)
 
-#define RECORD_FILE_MAGIC	netorder32(0x20091016)
+#define RECORD_FULL_FILE_MAGIC	netorder32(0x20091016)
 
 /* These are the core structs of the process record functionality.
 
-   A 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 have a struct record_entry ("record_end") that
-   indicates that this is the last struct record_entry of this
+   A record_full_entry is a record of the value change of a register
+   ("record_full_reg") or a part of memory ("record_full_mem").  And each
+   instruction must have a struct record_full_entry ("record_full_end")
+   that indicates that this is the last struct record_full_entry of this
    instruction.
 
-   Each struct record_entry is linked to "record_list" by "prev" and
-   "next" pointers.  */
+   Each struct record_full_entry is linked to "record_full_list" by "prev"
+   and "next" pointers.  */
 
-struct record_mem_entry
+struct record_full_mem_entry
 {
   CORE_ADDR addr;
   int len;
@@ -90,7 +90,7 @@ struct record_mem_entry
   } u;
 };
 
-struct record_reg_entry
+struct record_full_reg_entry
 {
   unsigned short num;
   unsigned short len;
@@ -101,33 +101,33 @@ struct record_reg_entry
   } u;
 };
 
-struct record_end_entry
+struct record_full_end_entry
 {
   enum gdb_signal sigval;
   ULONGEST insn_num;
 };
 
-enum record_type
+enum record_full_type
 {
-  record_end = 0,
-  record_reg,
-  record_mem
+  record_full_end = 0,
+  record_full_reg,
+  record_full_mem
 };
 
 /* This is the data structure that makes up the execution log.
 
    The execution log consists of a single linked list of entries
-   of type "struct record_entry".  It is doubly linked so that it
+   of type "struct record_full_entry".  It is doubly linked so that it
    can be traversed in either direction.
 
    The start of the list is anchored by a struct called
-   "record_first".  The pointer "record_list" either points to the
-   last entry that was added to the list (in record mode), or to the
-   next entry in the list that will be executed (in replay mode).
+   "record_full_first".  The pointer "record_full_list" either points
+   to the last entry that was added to the list (in record mode), or to
+   the next entry in the list that will be executed (in replay mode).
 
-   Each list element (struct record_entry), in addition to next and
-   prev pointers, consists of a union of three entry types: mem, reg,
-   and end.  A field called "type" determines which entry type is
+   Each list element (struct record_full_entry), in addition to next
+   and prev pointers, consists of a union of three entry types: mem,
+   reg, and end.  A field called "type" determines which entry type is
    represented by a given list element.
 
    Each instruction that is added to the execution log is represented
@@ -138,19 +138,19 @@ enum record_type
    each instruction will have an "end" entry that separates it from
    the changes associated with the next instruction.  */
 
-struct record_entry
+struct record_full_entry
 {
-  struct record_entry *prev;
-  struct record_entry *next;
-  enum record_type type;
+  struct record_full_entry *prev;
+  struct record_full_entry *next;
+  enum record_full_type type;
   union
   {
     /* reg */
-    struct record_reg_entry reg;
+    struct record_full_reg_entry reg;
     /* mem */
-    struct record_mem_entry mem;
+    struct record_full_mem_entry mem;
     /* end */
-    struct record_end_entry end;
+    struct record_full_end_entry end;
   } u;
 };
 
@@ -158,53 +158,55 @@ struct record_entry
    change of next instruction.  */
 int record_memory_query = 0;
 
-struct record_core_buf_entry
+struct record_full_core_buf_entry
 {
-  struct record_core_buf_entry *prev;
+  struct record_full_core_buf_entry *prev;
   struct target_section *p;
   bfd_byte *buf;
 };
 
 /* Record buf with core target.  */
-static gdb_byte *record_core_regbuf = NULL;
-static struct target_section *record_core_start;
-static struct target_section *record_core_end;
-static struct record_core_buf_entry *record_core_buf_list = NULL;
+static gdb_byte *record_full_core_regbuf = NULL;
+static struct target_section *record_full_core_start;
+static struct target_section *record_full_core_end;
+static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
 
 /* The following variables are used for managing the linked list that
    represents the execution log.
 
-   record_first is the anchor that holds down the beginning of the list.
+   record_full_first is the anchor that holds down the beginning of
+   the list.
 
-   record_list serves two functions:
+   record_full_list serves two functions:
      1) In record mode, it anchors the end of the list.
      2) In replay mode, it traverses the list and points to
         the next instruction that must be emulated.
 
-   record_arch_list_head and record_arch_list_tail are used to manage
-   a separate list, which is used to build up the change elements of
-   the currently executing instruction during record mode.  When this
-   instruction has been completely annotated in the "arch list", it 
-   will be appended to the main execution log.  */
+   record_full_arch_list_head and record_full_arch_list_tail are used
+   to manage a separate list, which is used to build up the change
+   elements of the currently executing instruction during record mode.
+   When this instruction has been completely annotated in the "arch
+   list", it will be appended to the main 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;
+static struct record_full_entry record_full_first;
+static struct record_full_entry *record_full_list = &record_full_first;
+static struct record_full_entry *record_full_arch_list_head = NULL;
+static struct record_full_entry *record_full_arch_list_tail = NULL;
 
-/* 1 ask user. 0 auto delete the last struct record_entry.  */
-static int record_stop_at_limit = 1;
+/* 1 ask user. 0 auto delete the last struct record_full_entry.  */
+static int record_full_stop_at_limit = 1;
 /* Maximum allowed number of insns in execution log.  */
-static unsigned int record_insn_max_num = DEFAULT_RECORD_INSN_MAX_NUM;
+static unsigned int record_full_insn_max_num
+	= DEFAULT_RECORD_FULL_INSN_MAX_NUM;
 /* Actual count of insns presently in execution log.  */
-static int record_insn_num = 0;
+static int record_full_insn_num = 0;
 /* Count of insns logged so far (may be larger
    than count of insns presently in execution log).  */
-static ULONGEST record_insn_count;
+static ULONGEST record_full_insn_count;
 
 /* The target_ops of process record.  */
-static struct target_ops record_ops;
-static struct target_ops record_core_ops;
+static struct target_ops record_full_ops;
+static struct target_ops record_full_core_ops;
 
 /* Command lists for "set/show record full".  */
 static struct cmd_list_element *set_record_full_cmdlist;
@@ -214,51 +216,57 @@ static struct cmd_list_element *show_record_full_cmdlist;
 static struct cmd_list_element *record_full_cmdlist;
 
 /* 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 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,
-						  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 gdbarch *,
-						   struct bp_target_info *);
-static int (*record_beneath_to_remove_breakpoint) (struct gdbarch *,
-						   struct bp_target_info *);
-static int (*record_beneath_to_stopped_by_watchpoint) (void);
-static int (*record_beneath_to_stopped_data_address) (struct target_ops *,
-						      CORE_ADDR *);
-static void (*record_beneath_to_async) (void (*) (enum inferior_event_type, void *), void *);
-
-static void record_goto_insn (struct record_entry *entry,
-			      enum exec_direction_kind dir);
-static void record_save (char *recfilename);
-
-/* Alloc and free functions for record_reg, record_mem, and record_end 
-   entries.  */
-
-/* Alloc a record_reg record entry.  */
-
-static inline struct record_entry *
-record_reg_alloc (struct regcache *regcache, int regnum)
-{
-  struct record_entry *rec;
+static struct target_ops *record_full_beneath_to_resume_ops;
+static void (*record_full_beneath_to_resume) (struct target_ops *, ptid_t, int,
+					      enum gdb_signal);
+static struct target_ops *record_full_beneath_to_wait_ops;
+static ptid_t (*record_full_beneath_to_wait) (struct target_ops *, ptid_t,
+					      struct target_waitstatus *,
+					      int);
+static struct target_ops *record_full_beneath_to_store_registers_ops;
+static void (*record_full_beneath_to_store_registers) (struct target_ops *,
+						       struct regcache *,
+						       int regno);
+static struct target_ops *record_full_beneath_to_xfer_partial_ops;
+static LONGEST
+(*record_full_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_full_beneath_to_insert_breakpoint) (struct gdbarch *,
+					     struct bp_target_info *);
+static int
+(*record_full_beneath_to_remove_breakpoint) (struct gdbarch *,
+					     struct bp_target_info *);
+static int (*record_full_beneath_to_stopped_by_watchpoint) (void);
+static int (*record_full_beneath_to_stopped_data_address) (struct target_ops *,
+							   CORE_ADDR *);
+static void
+(*record_full_beneath_to_async) (void (*) (enum inferior_event_type, void *),
+				 void *);
+
+static void record_full_goto_insn (struct record_full_entry *entry,
+				   enum exec_direction_kind dir);
+static void record_full_save (char *recfilename);
+
+/* Alloc and free functions for record_full_reg, record_full_mem, and
+   record_full_end entries.  */
+
+/* Alloc a record_full_reg record entry.  */
+
+static inline struct record_full_entry *
+record_full_reg_alloc (struct regcache *regcache, int regnum)
+{
+  struct record_full_entry *rec;
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
-  rec = (struct record_entry *) xcalloc (1, sizeof (struct record_entry));
-  rec->type = record_reg;
+  rec = (struct record_full_entry *)
+    xcalloc (1, sizeof (struct record_full_entry));
+  rec->type = record_full_reg;
   rec->u.reg.num = regnum;
   rec->u.reg.len = register_size (gdbarch, regnum);
   if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
@@ -267,26 +275,27 @@ record_reg_alloc (struct regcache *regcache, int regnum)
   return rec;
 }
 
-/* Free a record_reg record entry.  */
+/* Free a record_full_reg record entry.  */
 
 static inline void
-record_reg_release (struct record_entry *rec)
+record_full_reg_release (struct record_full_entry *rec)
 {
-  gdb_assert (rec->type == record_reg);
+  gdb_assert (rec->type == record_full_reg);
   if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
     xfree (rec->u.reg.u.ptr);
   xfree (rec);
 }
 
-/* Alloc a record_mem record entry.  */
+/* Alloc a record_full_mem record entry.  */
 
-static inline struct record_entry *
-record_mem_alloc (CORE_ADDR addr, int len)
+static inline struct record_full_entry *
+record_full_mem_alloc (CORE_ADDR addr, int len)
 {
-  struct record_entry *rec;
+  struct record_full_entry *rec;
 
-  rec = (struct record_entry *) xcalloc (1, sizeof (struct record_entry));
-  rec->type = record_mem;
+  rec = (struct record_full_entry *)
+    xcalloc (1, sizeof (struct record_full_entry));
+  rec->type = record_full_mem;
   rec->u.mem.addr = addr;
   rec->u.mem.len = len;
   if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
@@ -295,34 +304,35 @@ record_mem_alloc (CORE_ADDR addr, int len)
   return rec;
 }
 
-/* Free a record_mem record entry.  */
+/* Free a record_full_mem record entry.  */
 
 static inline void
-record_mem_release (struct record_entry *rec)
+record_full_mem_release (struct record_full_entry *rec)
 {
-  gdb_assert (rec->type == record_mem);
+  gdb_assert (rec->type == record_full_mem);
   if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
     xfree (rec->u.mem.u.ptr);
   xfree (rec);
 }
 
-/* Alloc a record_end record entry.  */
+/* Alloc a record_full_end record entry.  */
 
-static inline struct record_entry *
-record_end_alloc (void)
+static inline struct record_full_entry *
+record_full_end_alloc (void)
 {
-  struct record_entry *rec;
+  struct record_full_entry *rec;
 
-  rec = (struct record_entry *) xcalloc (1, sizeof (struct record_entry));
-  rec->type = record_end;
+  rec = (struct record_full_entry *)
+    xcalloc (1, sizeof (struct record_full_entry));
+  rec->type = record_full_end;
 
   return rec;
 }
 
-/* Free a record_end record entry.  */
+/* Free a record_full_end record entry.  */
 
 static inline void
-record_end_release (struct record_entry *rec)
+record_full_end_release (struct record_full_entry *rec)
 {
   xfree (rec);
 }
@@ -330,20 +340,20 @@ record_end_release (struct record_entry *rec)
 /* Free one record entry, any type.
    Return entry->type, in case caller wants to know.  */
 
-static inline enum record_type
-record_entry_release (struct record_entry *rec)
+static inline enum record_full_type
+record_full_entry_release (struct record_full_entry *rec)
 {
-  enum record_type type = rec->type;
+  enum record_full_type type = rec->type;
 
   switch (type) {
-  case record_reg:
-    record_reg_release (rec);
+  case record_full_reg:
+    record_full_reg_release (rec);
     break;
-  case record_mem:
-    record_mem_release (rec);
+  case record_full_mem:
+    record_full_mem_release (rec);
     break;
-  case record_end:
-    record_end_release (rec);
+  case record_full_end:
+    record_full_end_release (rec);
     break;
   }
   return type;
@@ -352,7 +362,7 @@ record_entry_release (struct record_entry *rec)
 /* Free all record entries in list pointed to by REC.  */
 
 static void
-record_list_release (struct record_entry *rec)
+record_full_list_release (struct record_full_entry *rec)
 {
   if (!rec)
     return;
@@ -363,33 +373,33 @@ record_list_release (struct record_entry *rec)
   while (rec->prev)
     {
       rec = rec->prev;
-      record_entry_release (rec->next);
+      record_full_entry_release (rec->next);
     }
 
-  if (rec == &record_first)
+  if (rec == &record_full_first)
     {
-      record_insn_num = 0;
-      record_first.next = NULL;
+      record_full_insn_num = 0;
+      record_full_first.next = NULL;
     }
   else
-    record_entry_release (rec);
+    record_full_entry_release (rec);
 }
 
 /* Free all record entries forward of the given list position.  */
 
 static void
-record_list_release_following (struct record_entry *rec)
+record_full_list_release_following (struct record_full_entry *rec)
 {
-  struct record_entry *tmp = rec->next;
+  struct record_full_entry *tmp = rec->next;
 
   rec->next = NULL;
   while (tmp)
     {
       rec = tmp->next;
-      if (record_entry_release (tmp) == record_end)
+      if (record_full_entry_release (tmp) == record_full_end)
 	{
-	  record_insn_num--;
-	  record_insn_count--;
+	  record_full_insn_num--;
+	  record_full_insn_count--;
 	}
       tmp = rec;
     }
@@ -398,87 +408,87 @@ record_list_release_following (struct record_entry *rec)
 /* Delete the first instruction from the beginning of the log, to make
    room for adding a new instruction at the end of the log.
 
-   Note -- this function does not modify record_insn_num.  */
+   Note -- this function does not modify record_full_insn_num.  */
 
 static void
-record_list_release_first (void)
+record_full_list_release_first (void)
 {
-  struct record_entry *tmp;
+  struct record_full_entry *tmp;
 
-  if (!record_first.next)
+  if (!record_full_first.next)
     return;
 
-  /* Loop until a record_end.  */
+  /* Loop until a record_full_end.  */
   while (1)
     {
-      /* Cut record_first.next out of the linked list.  */
-      tmp = record_first.next;
-      record_first.next = tmp->next;
-      tmp->next->prev = &record_first;
+      /* Cut record_full_first.next out of the linked list.  */
+      tmp = record_full_first.next;
+      record_full_first.next = tmp->next;
+      tmp->next->prev = &record_full_first;
 
       /* tmp is now isolated, and can be deleted.  */
-      if (record_entry_release (tmp) == record_end)
-	break;	/* End loop at first record_end.  */
+      if (record_full_entry_release (tmp) == record_full_end)
+	break;	/* End loop at first record_full_end.  */
 
-      if (!record_first.next)
+      if (!record_full_first.next)
 	{
-	  gdb_assert (record_insn_num == 1);
+	  gdb_assert (record_full_insn_num == 1);
 	  break;	/* End loop when list is empty.  */
 	}
     }
 }
 
-/* Add a struct record_entry to record_arch_list.  */
+/* Add a struct record_full_entry to record_full_arch_list.  */
 
 static void
-record_arch_list_add (struct record_entry *rec)
+record_full_arch_list_add (struct record_full_entry *rec)
 {
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog,
-			"Process record: record_arch_list_add %s.\n",
+			"Process record: record_full_arch_list_add %s.\n",
 			host_address_to_string (rec));
 
-  if (record_arch_list_tail)
+  if (record_full_arch_list_tail)
     {
-      record_arch_list_tail->next = rec;
-      rec->prev = record_arch_list_tail;
-      record_arch_list_tail = rec;
+      record_full_arch_list_tail->next = rec;
+      rec->prev = record_full_arch_list_tail;
+      record_full_arch_list_tail = rec;
     }
   else
     {
-      record_arch_list_head = rec;
-      record_arch_list_tail = rec;
+      record_full_arch_list_head = rec;
+      record_full_arch_list_tail = rec;
     }
 }
 
 /* Return the value storage location of a record entry.  */
 static inline gdb_byte *
-record_get_loc (struct record_entry *rec)
+record_full_get_loc (struct record_full_entry *rec)
 {
   switch (rec->type) {
-  case record_mem:
+  case record_full_mem:
     if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
       return rec->u.mem.u.ptr;
     else
       return rec->u.mem.u.buf;
-  case record_reg:
+  case record_full_reg:
     if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
       return rec->u.reg.u.ptr;
     else
       return rec->u.reg.u.buf;
-  case record_end:
+  case record_full_end:
   default:
-    gdb_assert_not_reached ("unexpected record_entry type");
+    gdb_assert_not_reached ("unexpected record_full_entry type");
     return NULL;
   }
 }
 
-/* Record the value of a register NUM to record_arch_list.  */
+/* Record the value of a register NUM to record_full_arch_list.  */
 
 int
 record_arch_list_add_reg (struct regcache *regcache, int regnum)
 {
-  struct record_entry *rec;
+  struct record_full_entry *rec;
 
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog,
@@ -486,22 +496,22 @@ record_arch_list_add_reg (struct regcache *regcache, int regnum)
 			"record list.\n",
 			regnum);
 
-  rec = record_reg_alloc (regcache, regnum);
+  rec = record_full_reg_alloc (regcache, regnum);
 
-  regcache_raw_read (regcache, regnum, record_get_loc (rec));
+  regcache_raw_read (regcache, regnum, record_full_get_loc (rec));
 
-  record_arch_list_add (rec);
+  record_full_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.  */
+   length is LEN to record_full_arch_list.  */
 
 int
 record_arch_list_add_mem (CORE_ADDR addr, int len)
 {
-  struct record_entry *rec;
+  struct record_full_entry *rec;
 
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog,
@@ -512,49 +522,51 @@ record_arch_list_add_mem (CORE_ADDR addr, int len)
   if (!addr)	/* FIXME: Why?  Some arch must permit it...  */
     return 0;
 
-  rec = record_mem_alloc (addr, len);
+  rec = record_full_mem_alloc (addr, len);
 
-  if (record_read_memory (target_gdbarch (), addr, record_get_loc (rec), len))
+  if (record_read_memory (target_gdbarch (), addr,
+			  record_full_get_loc (rec), len))
     {
-      record_mem_release (rec);
+      record_full_mem_release (rec);
       return -1;
     }
 
-  record_arch_list_add (rec);
+  record_full_arch_list_add (rec);
 
   return 0;
 }
 
-/* Add a record_end type struct record_entry to record_arch_list.  */
+/* Add a record_full_end type struct record_full_entry to
+   record_full_arch_list.  */
 
 int
 record_arch_list_add_end (void)
 {
-  struct record_entry *rec;
+  struct record_full_entry *rec;
 
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog,
 			"Process record: add end to arch list.\n");
 
-  rec = record_end_alloc ();
+  rec = record_full_end_alloc ();
   rec->u.end.sigval = GDB_SIGNAL_0;
-  rec->u.end.insn_num = ++record_insn_count;
+  rec->u.end.insn_num = ++record_full_insn_count;
 
-  record_arch_list_add (rec);
+  record_full_arch_list_add (rec);
 
   return 0;
 }
 
 static void
-record_check_insn_num (int set_terminal)
+record_full_check_insn_num (int set_terminal)
 {
-  if (record_insn_max_num)
+  if (record_full_insn_max_num)
     {
-      gdb_assert (record_insn_num <= record_insn_max_num);
-      if (record_insn_num == record_insn_max_num)
+      gdb_assert (record_full_insn_num <= record_full_insn_max_num);
+      if (record_full_insn_num == record_full_insn_max_num)
 	{
 	  /* Ask user what to do.  */
-	  if (record_stop_at_limit)
+	  if (record_full_stop_at_limit)
 	    {
 	      int q;
 
@@ -566,7 +578,7 @@ record_check_insn_num (int set_terminal)
 	      if (set_terminal)
 		target_terminal_inferior ();
 	      if (q)
-		record_stop_at_limit = 0;
+		record_full_stop_at_limit = 0;
 	      else
 		error (_("Process record: stopped by user."));
 	    }
@@ -575,29 +587,30 @@ record_check_insn_num (int set_terminal)
 }
 
 static void
-record_arch_list_cleanups (void *ignore)
+record_full_arch_list_cleanups (void *ignore)
 {
-  record_list_release (record_arch_list_tail);
+  record_full_list_release (record_full_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_full_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.  */
+   record_full_arch_list, and add it to record_full_list.  */
 
 static int
-record_message (struct regcache *regcache, enum gdb_signal signal)
+record_full_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);
+  struct cleanup *old_cleanups
+    = make_cleanup (record_full_arch_list_cleanups, 0);
 
-  record_arch_list_head = NULL;
-  record_arch_list_tail = NULL;
+  record_full_arch_list_head = NULL;
+  record_full_arch_list_tail = NULL;
 
-  /* Check record_insn_num.  */
-  record_check_insn_num (1);
+  /* Check record_full_insn_num.  */
+  record_full_check_insn_num (1);
 
   /* If gdb sends a signal value to target_resume,
      save it in the 'end' field of the previous instruction.
@@ -620,11 +633,12 @@ record_message (struct regcache *regcache, enum gdb_signal signal)
 
      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 */
+     record the signal during record_full_wait, not
+     record_full_resume.  */
+  if (record_full_list != &record_full_first)  /* FIXME better way to check */
     {
-      gdb_assert (record_list->type == record_end);
-      record_list->u.end.sigval = signal;
+      gdb_assert (record_full_list->type == record_full_end);
+      record_full_list->u.end.sigval = signal;
     }
 
   if (signal == GDB_SIGNAL_0
@@ -644,47 +658,50 @@ record_message (struct regcache *regcache, enum gdb_signal signal)
 
   discard_cleanups (old_cleanups);
 
-  record_list->next = record_arch_list_head;
-  record_arch_list_head->prev = record_list;
-  record_list = record_arch_list_tail;
+  record_full_list->next = record_full_arch_list_head;
+  record_full_arch_list_head->prev = record_full_list;
+  record_full_list = record_full_arch_list_tail;
 
-  if (record_insn_num == record_insn_max_num && record_insn_max_num)
-    record_list_release_first ();
+  if (record_full_insn_num == record_full_insn_max_num &&
+      record_full_insn_max_num)
+    record_full_list_release_first ();
   else
-    record_insn_num++;
+    record_full_insn_num++;
 
   return 1;
 }
 
-struct record_message_args {
+struct record_full_message_args {
   struct regcache *regcache;
   enum gdb_signal signal;
 };
 
 static int
-record_message_wrapper (void *args)
+record_full_message_wrapper (void *args)
 {
-  struct record_message_args *record_args = args;
+  struct record_full_message_args *record_full_args = args;
 
-  return record_message (record_args->regcache, record_args->signal);
+  return record_full_message (record_full_args->regcache,
+			      record_full_args->signal);
 }
 
 static int
-record_message_wrapper_safe (struct regcache *regcache,
-                             enum gdb_signal signal)
+record_full_message_wrapper_safe (struct regcache *regcache,
+				  enum gdb_signal signal)
 {
-  struct record_message_args args;
+  struct record_full_message_args args;
 
   args.regcache = regcache;
   args.signal = signal;
 
-  return catch_errors (record_message_wrapper, &args, NULL, RETURN_MASK_ALL);
+  return catch_errors (record_full_message_wrapper, &args, NULL,
+		       RETURN_MASK_ALL);
 }
 
-/* Set to 1 if record_store_registers and record_xfer_partial
+/* Set to 1 if record_full_store_registers and record_full_xfer_partial
    doesn't need record.  */
 
-static int record_gdb_operation_disable = 0;
+static int record_full_gdb_operation_disable = 0;
 
 struct cleanup *
 record_gdb_operation_disable_set (void)
@@ -692,44 +709,45 @@ 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;
+    make_cleanup_restore_integer (&record_full_gdb_operation_disable);
+  record_full_gdb_operation_disable = 1;
 
   return old_cleanups;
 }
 
 /* Flag set to TRUE for target_stopped_by_watchpoint.  */
-static int record_hw_watchpoint = 0;
+static int record_full_hw_watchpoint = 0;
 
 /* Execute one instruction from the record log.  Each instruction in
    the log will be represented by an arbitrary sequence of register
    entries and memory entries, followed by an 'end' entry.  */
 
 static inline void
-record_exec_insn (struct regcache *regcache, struct gdbarch *gdbarch,
-		  struct record_entry *entry)
+record_full_exec_insn (struct regcache *regcache,
+		       struct gdbarch *gdbarch,
+		       struct record_full_entry *entry)
 {
   switch (entry->type)
     {
-    case record_reg: /* reg */
+    case record_full_reg: /* reg */
       {
         gdb_byte reg[MAX_REGISTER_SIZE];
 
         if (record_debug > 1)
           fprintf_unfiltered (gdb_stdlog,
-                              "Process record: record_reg %s to "
+                              "Process record: record_full_reg %s to "
                               "inferior num = %d.\n",
                               host_address_to_string (entry),
                               entry->u.reg.num);
 
         regcache_cooked_read (regcache, entry->u.reg.num, reg);
         regcache_cooked_write (regcache, entry->u.reg.num, 
-			       record_get_loc (entry));
-        memcpy (record_get_loc (entry), reg, entry->u.reg.len);
+			       record_full_get_loc (entry));
+        memcpy (record_full_get_loc (entry), reg, entry->u.reg.len);
       }
       break;
 
-    case record_mem: /* mem */
+    case record_full_mem: /* mem */
       {
 	/* Nothing to do if the entry is flagged not_accessible.  */
         if (!entry->u.mem.mem_entry_not_accessible)
@@ -738,7 +756,7 @@ record_exec_insn (struct regcache *regcache, struct gdbarch *gdbarch,
 
             if (record_debug > 1)
               fprintf_unfiltered (gdb_stdlog,
-                                  "Process record: record_mem %s to "
+                                  "Process record: record_full_mem %s to "
                                   "inferior addr = %s len = %d.\n",
                                   host_address_to_string (entry),
                                   paddress (gdbarch, entry->u.mem.addr),
@@ -750,7 +768,7 @@ record_exec_insn (struct regcache *regcache, struct gdbarch *gdbarch,
             else
               {
                 if (target_write_memory (entry->u.mem.addr, 
-					 record_get_loc (entry),
+					 record_full_get_loc (entry),
 					 entry->u.mem.len))
                   {
                     entry->u.mem.mem_entry_not_accessible = 1;
@@ -762,7 +780,8 @@ record_exec_insn (struct regcache *regcache, struct gdbarch *gdbarch,
                   }
                 else
 		  {
-		    memcpy (record_get_loc (entry), mem, entry->u.mem.len);
+		    memcpy (record_full_get_loc (entry), mem,
+			    entry->u.mem.len);
 
 		    /* We've changed memory --- check if a hardware
 		       watchpoint should trap.  Note that this
@@ -775,7 +794,7 @@ record_exec_insn (struct regcache *regcache, struct gdbarch *gdbarch,
 		    if (hardware_watchpoint_inserted_in_range
 			(get_regcache_aspace (regcache),
 			 entry->u.mem.addr, entry->u.mem.len))
-		      record_hw_watchpoint = 1;
+		      record_full_hw_watchpoint = 1;
 		  }
               }
           }
@@ -812,15 +831,15 @@ static int (*tmp_to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
 static int (*tmp_to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
 static void (*tmp_to_async) (void (*) (enum inferior_event_type, void *), void *);
 
-static void record_restore (void);
+static void record_full_restore (void);
 
 /* Asynchronous signal handle registered as event loop source for when
    we have pending events ready to be passed to the core.  */
 
-static struct async_event_handler *record_async_inferior_event_token;
+static struct async_event_handler *record_full_async_inferior_event_token;
 
 static void
-record_async_inferior_event_handler (gdb_client_data data)
+record_full_async_inferior_event_handler (gdb_client_data data)
 {
   inferior_event_handler (INF_REG_EVENT, NULL);
 }
@@ -828,39 +847,40 @@ record_async_inferior_event_handler (gdb_client_data data)
 /* Open the process record target.  */
 
 static void
-record_core_open_1 (char *name, int from_tty)
+record_full_core_open_1 (char *name, int from_tty)
 {
   struct regcache *regcache = get_current_regcache ();
   int regnum = gdbarch_num_regs (get_regcache_arch (regcache));
   int i;
 
-  /* Get record_core_regbuf.  */
+  /* Get record_full_core_regbuf.  */
   target_fetch_registers (regcache, -1);
-  record_core_regbuf = xmalloc (MAX_REGISTER_SIZE * regnum);
+  record_full_core_regbuf = xmalloc (MAX_REGISTER_SIZE * regnum);
   for (i = 0; i < regnum; i ++)
     regcache_raw_collect (regcache, i,
-			  record_core_regbuf + MAX_REGISTER_SIZE * i);
+			  record_full_core_regbuf + MAX_REGISTER_SIZE * i);
 
-  /* Get record_core_start and record_core_end.  */
-  if (build_section_table (core_bfd, &record_core_start, &record_core_end))
+  /* Get record_full_core_start and record_full_core_end.  */
+  if (build_section_table (core_bfd, &record_full_core_start,
+			   &record_full_core_end))
     {
-      xfree (record_core_regbuf);
-      record_core_regbuf = NULL;
+      xfree (record_full_core_regbuf);
+      record_full_core_regbuf = NULL;
       error (_("\"%s\": Can't find sections: %s"),
 	     bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
     }
 
-  push_target (&record_core_ops);
-  record_restore ();
+  push_target (&record_full_core_ops);
+  record_full_restore ();
 }
 
 /* "to_open" target method for 'live' processes.  */
 
 static void
-record_open_1 (char *name, int from_tty)
+record_full_open_1 (char *name, int from_tty)
 {
   if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n");
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
 
   /* check exec */
   if (!target_has_execution)
@@ -893,20 +913,20 @@ record_open_1 (char *name, int from_tty)
     error (_("Could not find 'to_stopped_data_address' "
 	     "method on the target stack."));
 
-  push_target (&record_ops);
+  push_target (&record_full_ops);
 }
 
-static void record_init_record_breakpoints (void);
+static void record_full_init_record_breakpoints (void);
 
 /* "to_open" target method.  Open the process record target.  */
 
 static void
-record_open (char *name, int from_tty)
+record_full_open (char *name, int from_tty)
 {
   struct target_ops *t;
 
   if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n");
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
 
   /* Check if record target is already running.  */
   if (current_target.to_stratum == record_stratum)
@@ -966,37 +986,37 @@ record_open (char *name, int from_tty)
     error (_("Could not find 'to_xfer_partial' method on the target stack."));
 
   /* Reset */
-  record_insn_num = 0;
-  record_insn_count = 0;
-  record_list = &record_first;
-  record_list->next = NULL;
+  record_full_insn_num = 0;
+  record_full_insn_count = 0;
+  record_full_list = &record_full_first;
+  record_full_list->next = NULL;
 
   /* Set the tmp beneath pointers to beneath pointers.  */
-  record_beneath_to_resume_ops = tmp_to_resume_ops;
-  record_beneath_to_resume = tmp_to_resume;
-  record_beneath_to_wait_ops = tmp_to_wait_ops;
-  record_beneath_to_wait = tmp_to_wait;
-  record_beneath_to_store_registers_ops = tmp_to_store_registers_ops;
-  record_beneath_to_store_registers = tmp_to_store_registers;
-  record_beneath_to_xfer_partial_ops = tmp_to_xfer_partial_ops;
-  record_beneath_to_xfer_partial = tmp_to_xfer_partial;
-  record_beneath_to_insert_breakpoint = tmp_to_insert_breakpoint;
-  record_beneath_to_remove_breakpoint = tmp_to_remove_breakpoint;
-  record_beneath_to_stopped_by_watchpoint = tmp_to_stopped_by_watchpoint;
-  record_beneath_to_stopped_data_address = tmp_to_stopped_data_address;
-  record_beneath_to_async = tmp_to_async;
+  record_full_beneath_to_resume_ops = tmp_to_resume_ops;
+  record_full_beneath_to_resume = tmp_to_resume;
+  record_full_beneath_to_wait_ops = tmp_to_wait_ops;
+  record_full_beneath_to_wait = tmp_to_wait;
+  record_full_beneath_to_store_registers_ops = tmp_to_store_registers_ops;
+  record_full_beneath_to_store_registers = tmp_to_store_registers;
+  record_full_beneath_to_xfer_partial_ops = tmp_to_xfer_partial_ops;
+  record_full_beneath_to_xfer_partial = tmp_to_xfer_partial;
+  record_full_beneath_to_insert_breakpoint = tmp_to_insert_breakpoint;
+  record_full_beneath_to_remove_breakpoint = tmp_to_remove_breakpoint;
+  record_full_beneath_to_stopped_by_watchpoint = tmp_to_stopped_by_watchpoint;
+  record_full_beneath_to_stopped_data_address = tmp_to_stopped_data_address;
+  record_full_beneath_to_async = tmp_to_async;
 
   if (core_bfd)
-    record_core_open_1 (name, from_tty);
+    record_full_core_open_1 (name, from_tty);
   else
-    record_open_1 (name, from_tty);
+    record_full_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,
+  record_full_async_inferior_event_token
+    = create_async_event_handler (record_full_async_inferior_event_handler,
 				  NULL);
 
-  record_init_record_breakpoints ();
+  record_full_init_record_breakpoints ();
 
   observer_notify_record_changed (current_inferior (),  1);
 }
@@ -1004,50 +1024,51 @@ record_open (char *name, int from_tty)
 /* "to_close" target method.  Close the process record target.  */
 
 static void
-record_close (int quitting)
+record_full_close (int quitting)
 {
-  struct record_core_buf_entry *entry;
+  struct record_full_core_buf_entry *entry;
 
   if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n");
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_close\n");
 
-  record_list_release (record_list);
+  record_full_list_release (record_full_list);
 
-  /* Release record_core_regbuf.  */
-  if (record_core_regbuf)
+  /* Release record_full_core_regbuf.  */
+  if (record_full_core_regbuf)
     {
-      xfree (record_core_regbuf);
-      record_core_regbuf = NULL;
+      xfree (record_full_core_regbuf);
+      record_full_core_regbuf = NULL;
     }
 
-  /* Release record_core_buf_list.  */
-  if (record_core_buf_list)
+  /* Release record_full_core_buf_list.  */
+  if (record_full_core_buf_list)
     {
-      for (entry = record_core_buf_list->prev; entry; entry = entry->prev)
+      for (entry = record_full_core_buf_list->prev; entry;
+	   entry = entry->prev)
 	{
-	  xfree (record_core_buf_list);
-	  record_core_buf_list = entry;
+	  xfree (record_full_core_buf_list);
+	  record_full_core_buf_list = entry;
 	}
-      record_core_buf_list = NULL;
+      record_full_core_buf_list = NULL;
     }
 
-  if (record_async_inferior_event_token)
-    delete_async_event_handler (&record_async_inferior_event_token);
+  if (record_full_async_inferior_event_token)
+    delete_async_event_handler (&record_full_async_inferior_event_token);
 }
 
-static int record_resume_step = 0;
+static int record_full_resume_step = 0;
 
-/* True if we've been resumed, and so each record_wait call should
-   advance execution.  If this is false, record_wait will return a
+/* True if we've been resumed, and so each record_full_wait call should
+   advance execution.  If this is false, record_full_wait will return a
    TARGET_WAITKIND_IGNORE.  */
-static int record_resumed = 0;
+static int record_full_resumed = 0;
 
 /* The execution direction of the last resume we got.  This is
    necessary for async mode.  Vis (order is not strictly accurate):
 
    1. user has the global execution direction set to forward
    2. user does a reverse-step command
-   3. record_resume is called with global execution direction
+   3. record_full_resume is called with global execution direction
       temporarily switched to reverse
    4. GDB's execution direction is reverted back to forward
    5. target record notifies event loop there's an event to handle
@@ -1056,23 +1077,23 @@ static int record_resumed = 0;
    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;
+static enum exec_direction_kind record_full_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 gdb_signal signal)
+record_full_resume (struct target_ops *ops, ptid_t ptid, int step,
+		    enum gdb_signal signal)
 {
-  record_resume_step = step;
-  record_resumed = 1;
-  record_execution_dir = execution_direction;
+  record_full_resume_step = step;
+  record_full_resumed = 1;
+  record_full_execution_dir = execution_direction;
 
-  if (!RECORD_IS_REPLAY)
+  if (!RECORD_FULL_IS_REPLAY)
     {
       struct gdbarch *gdbarch = target_thread_architecture (ptid);
 
-      record_message (get_current_regcache (), signal);
+      record_full_message (get_current_regcache (), signal);
 
       if (!step)
         {
@@ -1088,7 +1109,7 @@ record_resume (struct target_ops *ops, ptid_t ptid, int step,
               if (single_step_breakpoints_inserted ())
                 {
                   /* This is a soft single step.  */
-                  record_resume_step = 1;
+                  record_full_resume_step = 1;
                 }
               else
                 {
@@ -1108,8 +1129,8 @@ record_resume (struct target_ops *ops, ptid_t ptid, int step,
       /* Make sure the target beneath reports all signals.  */
       target_pass_signals (0, NULL);
 
-      record_beneath_to_resume (record_beneath_to_resume_ops,
-                                ptid, step, signal);
+      record_full_beneath_to_resume (record_full_beneath_to_resume_ops,
+				     ptid, step, signal);
     }
 
   /* We are about to start executing the inferior (or simulate it),
@@ -1118,39 +1139,39 @@ record_resume (struct target_ops *ops, ptid_t ptid, int step,
     {
       target_async (inferior_event_handler, 0);
       /* Notify the event loop there's an event to wait for.  We do
-	 most of the work in record_wait.  */
-      mark_async_event_handler (record_async_inferior_event_token);
+	 most of the work in record_full_wait.  */
+      mark_async_event_handler (record_full_async_inferior_event_token);
     }
 }
 
-static int record_get_sig = 0;
+static int record_full_get_sig = 0;
 
 /* SIGINT signal handler, registered by "to_wait" method.  */
 
 static void
-record_sig_handler (int signo)
+record_full_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;
+  record_full_resume_step = 1;
 
-  /* It will let record_wait set inferior status to get the signal
+  /* It will let record_full_wait set inferior status to get the signal
      SIGINT.  */
-  record_get_sig = 1;
+  record_full_get_sig = 1;
 }
 
 static void
-record_wait_cleanups (void *ignore)
+record_full_wait_cleanups (void *ignore)
 {
   if (execution_direction == EXEC_REVERSE)
     {
-      if (record_list->next)
-	record_list = record_list->next;
+      if (record_full_list->next)
+	record_full_list = record_full_list->next;
     }
   else
-    record_list = record_list->prev;
+    record_full_list = record_full_list->prev;
 }
 
 /* "to_wait" target method for process record target.
@@ -1167,20 +1188,22 @@ record_wait_cleanups (void *ignore)
    where to stop.  */
 
 static ptid_t
-record_wait_1 (struct target_ops *ops,
-	       ptid_t ptid, struct target_waitstatus *status,
-	       int options)
+record_full_wait_1 (struct target_ops *ops,
+		    ptid_t ptid, struct target_waitstatus *status,
+		    int options)
 {
   struct cleanup *set_cleanups = record_gdb_operation_disable_set ();
 
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog,
-			"Process record: record_wait "
-			"record_resume_step = %d, record_resumed = %d, direction=%s\n",
-			record_resume_step, record_resumed,
-			record_execution_dir == EXEC_FORWARD ? "forward" : "reverse");
-
-  if (!record_resumed)
+			"Process record: record_full_wait "
+			"record_full_resume_step = %d, "
+			"record_full_resumed = %d, direction=%s\n",
+			record_full_resume_step, record_full_resumed,
+			record_full_execution_dir == EXEC_FORWARD
+			? "forward" : "reverse");
+
+  if (!record_full_resumed)
     {
       gdb_assert ((options & TARGET_WNOHANG) != 0);
 
@@ -1189,16 +1212,16 @@ record_wait_1 (struct target_ops *ops,
       return minus_one_ptid;
     }
 
-  record_get_sig = 0;
-  signal (SIGINT, record_sig_handler);
+  record_full_get_sig = 0;
+  signal (SIGINT, record_full_sig_handler);
 
-  if (!RECORD_IS_REPLAY && ops != &record_core_ops)
+  if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
     {
-      if (record_resume_step)
+      if (record_full_resume_step)
 	{
 	  /* This is a single step.  */
-	  return record_beneath_to_wait (record_beneath_to_wait_ops,
-					 ptid, status, options);
+	  return record_full_beneath_to_wait (record_full_beneath_to_wait_ops,
+					      ptid, status, options);
 	}
       else
 	{
@@ -1209,13 +1232,13 @@ record_wait_1 (struct target_ops *ops,
 
 	  while (1)
 	    {
-	      ret = record_beneath_to_wait (record_beneath_to_wait_ops,
-					    ptid, status, options);
+	      ret = record_full_beneath_to_wait
+		(record_full_beneath_to_wait_ops, ptid, status, options);
 	      if (status->kind == TARGET_WAITKIND_IGNORE)
 		{
 		  if (record_debug)
 		    fprintf_unfiltered (gdb_stdlog,
-					"Process record: record_wait "
+					"Process record: record_full_wait "
 					"target beneath not done yet\n");
 		  return ret;
 		}
@@ -1223,7 +1246,7 @@ record_wait_1 (struct target_ops *ops,
               if (single_step_breakpoints_inserted ())
                 remove_single_step_breakpoints ();
 
-	      if (record_resume_step)
+	      if (record_full_resume_step)
 		return ret;
 
 	      /* Is this a SIGTRAP?  */
@@ -1269,8 +1292,8 @@ record_wait_1 (struct target_ops *ops,
                          But GDB cannot handle it.  */
                       int step = 1;
 
-		      if (!record_message_wrapper_safe (regcache,
-                                                        GDB_SIGNAL_0))
+		      if (!record_full_message_wrapper_safe (regcache,
+							     GDB_SIGNAL_0))
   			{
                            status->kind = TARGET_WAITKIND_STOPPED;
                            status->value.sig = GDB_SIGNAL_0;
@@ -1291,11 +1314,12 @@ record_wait_1 (struct target_ops *ops,
 
 		      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,
-						GDB_SIGNAL_0);
+					    "Process record: record_full_wait "
+					    "issuing one more step in the "
+					    "target beneath\n");
+		      record_full_beneath_to_resume
+			(record_full_beneath_to_resume_ops, ptid, step,
+			 GDB_SIGNAL_0);
 		      continue;
 		    }
 		}
@@ -1313,11 +1337,12 @@ record_wait_1 (struct target_ops *ops,
       struct gdbarch *gdbarch = get_regcache_arch (regcache);
       struct address_space *aspace = get_regcache_aspace (regcache);
       int continue_flag = 1;
-      int first_record_end = 1;
-      struct cleanup *old_cleanups = make_cleanup (record_wait_cleanups, 0);
+      int first_record_full_end = 1;
+      struct cleanup *old_cleanups
+	= make_cleanup (record_full_wait_cleanups, 0);
       CORE_ADDR tmp_pc;
 
-      record_hw_watchpoint = 0;
+      record_full_hw_watchpoint = 0;
       status->kind = TARGET_WAITKIND_STOPPED;
 
       /* Check breakpoint when forward execute.  */
@@ -1334,7 +1359,7 @@ record_wait_1 (struct target_ops *ops,
 				    paddress (gdbarch, tmp_pc));
 
 	      if (decr_pc_after_break
-		  && !record_resume_step
+		  && !record_full_resume_step
 		  && software_breakpoint_inserted_here_p (aspace, tmp_pc))
 		regcache_write_pc (regcache,
 				   tmp_pc + decr_pc_after_break);
@@ -1348,54 +1373,54 @@ record_wait_1 (struct target_ops *ops,
          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
+      /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
          instruction.  */
-      if (execution_direction == EXEC_FORWARD && record_list->next)
-	record_list = record_list->next;
+      if (execution_direction == EXEC_FORWARD && record_full_list->next)
+	record_full_list = record_full_list->next;
 
-      /* Loop over the record_list, looking for the next place to
+      /* Loop over the record_full_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)
+	      && record_full_list == &record_full_first)
 	    {
 	      /* Hit beginning of record log in reverse.  */
 	      status->kind = TARGET_WAITKIND_NO_HISTORY;
 	      break;
 	    }
-	  if (execution_direction != EXEC_REVERSE && !record_list->next)
+	  if (execution_direction != EXEC_REVERSE && !record_full_list->next)
 	    {
 	      /* Hit end of record log going forward.  */
 	      status->kind = TARGET_WAITKIND_NO_HISTORY;
 	      break;
 	    }
 
-          record_exec_insn (regcache, gdbarch, record_list);
+          record_full_exec_insn (regcache, gdbarch, record_full_list);
 
-	  if (record_list->type == record_end)
+	  if (record_full_list->type == record_full_end)
 	    {
 	      if (record_debug > 1)
 		fprintf_unfiltered (gdb_stdlog,
-				    "Process record: record_end %s to "
+				    "Process record: record_full_end %s to "
 				    "inferior.\n",
-				    host_address_to_string (record_list));
+				    host_address_to_string (record_full_list));
 
-	      if (first_record_end && execution_direction == EXEC_REVERSE)
+	      if (first_record_full_end && execution_direction == EXEC_REVERSE)
 		{
-		  /* When reverse excute, the first record_end is the part of
-		     current instruction.  */
-		  first_record_end = 0;
+		  /* When reverse excute, the first record_full_end is the
+		     part of current instruction.  */
+		  first_record_full_end = 0;
 		}
 	      else
 		{
-		  /* In EXEC_REVERSE mode, this is the record_end of prev
+		  /* In EXEC_REVERSE mode, this is the record_full_end of prev
 		     instruction.
-		     In EXEC_FORWARD mode, this is the record_end of current
-		     instruction.  */
+		     In EXEC_FORWARD mode, this is the record_full_end of
+		     current instruction.  */
 		  /* step */
-		  if (record_resume_step)
+		  if (record_full_resume_step)
 		    {
 		      if (record_debug > 1)
 			fprintf_unfiltered (gdb_stdlog,
@@ -1417,7 +1442,7 @@ record_wait_1 (struct target_ops *ops,
 					    paddress (gdbarch, tmp_pc));
 		      if (decr_pc_after_break
 			  && execution_direction == EXEC_FORWARD
-			  && !record_resume_step
+			  && !record_full_resume_step
 			  && software_breakpoint_inserted_here_p (aspace,
 								  tmp_pc))
 			regcache_write_pc (regcache,
@@ -1425,7 +1450,7 @@ record_wait_1 (struct target_ops *ops,
 		      continue_flag = 0;
 		    }
 
-		  if (record_hw_watchpoint)
+		  if (record_full_hw_watchpoint)
 		    {
 		      if (record_debug)
 			fprintf_unfiltered (gdb_stdlog,
@@ -1434,7 +1459,7 @@ record_wait_1 (struct target_ops *ops,
 		      continue_flag = 0;
 		    }
 		  /* Check target signal */
-		  if (record_list->u.end.sigval != GDB_SIGNAL_0)
+		  if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
 		    /* FIXME: better way to check */
 		    continue_flag = 0;
 		}
@@ -1444,24 +1469,24 @@ record_wait_1 (struct target_ops *ops,
 	    {
 	      if (execution_direction == EXEC_REVERSE)
 		{
-		  if (record_list->prev)
-		    record_list = record_list->prev;
+		  if (record_full_list->prev)
+		    record_full_list = record_full_list->prev;
 		}
 	      else
 		{
-		  if (record_list->next)
-		    record_list = record_list->next;
+		  if (record_full_list->next)
+		    record_full_list = record_full_list->next;
 		}
 	    }
 	}
       while (continue_flag);
 
 replay_out:
-      if (record_get_sig)
+      if (record_full_get_sig)
 	status->value.sig = GDB_SIGNAL_INT;
-      else if (record_list->u.end.sigval != GDB_SIGNAL_0)
+      else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
 	/* FIXME: better way to check */
-	status->value.sig = record_list->u.end.sigval;
+	status->value.sig = record_full_list->u.end.sigval;
       else
 	status->value.sig = GDB_SIGNAL_TRAP;
 
@@ -1475,100 +1500,101 @@ replay_out:
 }
 
 static ptid_t
-record_wait (struct target_ops *ops,
-	     ptid_t ptid, struct target_waitstatus *status,
-	     int options)
+record_full_wait (struct target_ops *ops,
+		  ptid_t ptid, struct target_waitstatus *status,
+		  int options)
 {
   ptid_t return_ptid;
 
-  return_ptid = record_wait_1 (ops, ptid, status, options);
+  return_ptid = record_full_wait_1 (ops, ptid, status, options);
   if (status->kind != TARGET_WAITKIND_IGNORE)
     {
       /* We're reporting a stop.  Make sure any spurious
 	 target_wait(WNOHANG) doesn't advance the target until the
 	 core wants us resumed again.  */
-      record_resumed = 0;
+      record_full_resumed = 0;
     }
   return return_ptid;
 }
 
 static int
-record_stopped_by_watchpoint (void)
+record_full_stopped_by_watchpoint (void)
 {
-  if (RECORD_IS_REPLAY)
-    return record_hw_watchpoint;
+  if (RECORD_FULL_IS_REPLAY)
+    return record_full_hw_watchpoint;
   else
-    return record_beneath_to_stopped_by_watchpoint ();
+    return record_full_beneath_to_stopped_by_watchpoint ();
 }
 
 /* "to_disconnect" method for process record target.  */
 
 static void
-record_disconnect (struct target_ops *target, char *args, int from_tty)
+record_full_disconnect (struct target_ops *target, char *args, int from_tty)
 {
   if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_disconnect\n");
+    fprintf_unfiltered (gdb_stdlog,
+			"Process record: record_full_disconnect\n");
 
-  unpush_target (&record_ops);
+  unpush_target (&record_full_ops);
   target_disconnect (args, from_tty);
 }
 
 /* "to_detach" method for process record target.  */
 
 static void
-record_detach (struct target_ops *ops, char *args, int from_tty)
+record_full_detach (struct target_ops *ops, char *args, int from_tty)
 {
   if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_detach\n");
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_detach\n");
 
-  unpush_target (&record_ops);
+  unpush_target (&record_full_ops);
   target_detach (args, from_tty);
 }
 
 /* "to_mourn_inferior" method for process record target.  */
 
 static void
-record_mourn_inferior (struct target_ops *ops)
+record_full_mourn_inferior (struct target_ops *ops)
 {
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog, "Process record: "
-			            "record_mourn_inferior\n");
+			            "record_full_mourn_inferior\n");
 
-  unpush_target (&record_ops);
+  unpush_target (&record_full_ops);
   target_mourn_inferior ();
 }
 
 /* Close process record target before killing the inferior process.  */
 
 static void
-record_kill (struct target_ops *ops)
+record_full_kill (struct target_ops *ops)
 {
   if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n");
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_kill\n");
 
-  unpush_target (&record_ops);
+  unpush_target (&record_full_ops);
   target_kill ();
 }
 
 static int
-record_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
+record_full_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
 {
-  if (RECORD_IS_REPLAY)
+  if (RECORD_FULL_IS_REPLAY)
     return 0;
   else
-    return record_beneath_to_stopped_data_address (ops, addr_p);
+    return record_full_beneath_to_stopped_data_address (ops, addr_p);
 }
 
 /* Record registers change (by user or by GDB) to list as an instruction.  */
 
 static void
-record_registers_change (struct regcache *regcache, int regnum)
+record_full_registers_change (struct regcache *regcache, int regnum)
 {
-  /* Check record_insn_num.  */
-  record_check_insn_num (0);
+  /* Check record_full_insn_num.  */
+  record_full_check_insn_num (0);
 
-  record_arch_list_head = NULL;
-  record_arch_list_tail = NULL;
+  record_full_arch_list_head = NULL;
+  record_full_arch_list_tail = NULL;
 
   if (regnum < 0)
     {
@@ -1578,7 +1604,7 @@ record_registers_change (struct regcache *regcache, int regnum)
 	{
 	  if (record_arch_list_add_reg (regcache, i))
 	    {
-	      record_list_release (record_arch_list_tail);
+	      record_full_list_release (record_full_arch_list_tail);
 	      error (_("Process record: failed to record execution log."));
 	    }
 	}
@@ -1587,34 +1613,36 @@ record_registers_change (struct regcache *regcache, int regnum)
     {
       if (record_arch_list_add_reg (regcache, regnum))
 	{
-	  record_list_release (record_arch_list_tail);
+	  record_full_list_release (record_full_arch_list_tail);
 	  error (_("Process record: failed to record execution log."));
 	}
     }
   if (record_arch_list_add_end ())
     {
-      record_list_release (record_arch_list_tail);
+      record_full_list_release (record_full_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;
+  record_full_list->next = record_full_arch_list_head;
+  record_full_arch_list_head->prev = record_full_list;
+  record_full_list = record_full_arch_list_tail;
 
-  if (record_insn_num == record_insn_max_num && record_insn_max_num)
-    record_list_release_first ();
+  if (record_full_insn_num == record_full_insn_max_num &&
+      record_full_insn_max_num)
+    record_full_list_release_first ();
   else
-    record_insn_num++;
+    record_full_insn_num++;
 }
 
 /* "to_store_registers" method for process record target.  */
 
 static void
-record_store_registers (struct target_ops *ops, struct regcache *regcache,
-                        int regno)
+record_full_store_registers (struct target_ops *ops,
+			     struct regcache *regcache,
+			     int regno)
 {
-  if (!record_gdb_operation_disable)
+  if (!record_full_gdb_operation_disable)
     {
-      if (RECORD_IS_REPLAY)
+      if (RECORD_FULL_IS_REPLAY)
 	{
 	  int n;
 
@@ -1653,29 +1681,31 @@ record_store_registers (struct target_ops *ops, struct regcache *regcache,
 	    }
 
 	  /* Destroy the record from here forward.  */
-	  record_list_release_following (record_list);
+	  record_full_list_release_following (record_full_list);
 	}
 
-      record_registers_change (regcache, regno);
+      record_full_registers_change (regcache, regno);
     }
-  record_beneath_to_store_registers (record_beneath_to_store_registers_ops,
-                                     regcache, regno);
+  record_full_beneath_to_store_registers
+    (record_full_beneath_to_store_registers_ops, regcache, regno);
 }
 
-/* "to_xfer_partial" method.  Behavior is conditional on RECORD_IS_REPLAY.
+/* "to_xfer_partial" method.  Behavior is conditional on
+   RECORD_FULL_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)
+record_full_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
+  if (!record_full_gdb_operation_disable
       && (object == TARGET_OBJECT_MEMORY
 	  || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
     {
-      if (RECORD_IS_REPLAY)
+      if (RECORD_FULL_IS_REPLAY)
 	{
 	  /* Let user choose if he wants to write memory or not.  */
 	  if (!query (_("Because GDB is in replay mode, writing to memory "
@@ -1685,18 +1715,18 @@ record_xfer_partial (struct target_ops *ops, enum target_object object,
 	    error (_("Process record canceled the operation."));
 
 	  /* Destroy the record from here forward.  */
-	  record_list_release_following (record_list);
+	  record_full_list_release_following (record_full_list);
 	}
 
-      /* Check record_insn_num */
-      record_check_insn_num (0);
+      /* Check record_full_insn_num */
+      record_full_check_insn_num (0);
 
       /* Record registers change to list as an instruction.  */
-      record_arch_list_head = NULL;
-      record_arch_list_tail = NULL;
+      record_full_arch_list_head = NULL;
+      record_full_arch_list_tail = NULL;
       if (record_arch_list_add_mem (offset, len))
 	{
-	  record_list_release (record_arch_list_tail);
+	  record_full_list_release (record_full_arch_list_tail);
 	  if (record_debug)
 	    fprintf_unfiltered (gdb_stdlog,
 				"Process record: failed to record "
@@ -1705,26 +1735,27 @@ record_xfer_partial (struct target_ops *ops, enum target_object object,
 	}
       if (record_arch_list_add_end ())
 	{
-	  record_list_release (record_arch_list_tail);
+	  record_full_list_release (record_full_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;
+      record_full_list->next = record_full_arch_list_head;
+      record_full_arch_list_head->prev = record_full_list;
+      record_full_list = record_full_arch_list_tail;
 
-      if (record_insn_num == record_insn_max_num && record_insn_max_num)
-	record_list_release_first ();
+      if (record_full_insn_num == record_full_insn_max_num &&
+	  record_full_insn_max_num)
+	record_full_list_release_first ();
       else
-	record_insn_num++;
+	record_full_insn_num++;
     }
 
-  return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_ops,
-                                         object, annex, readbuf, writebuf,
-                                         offset, len);
+  return record_full_beneath_to_xfer_partial
+    (record_full_beneath_to_xfer_partial_ops, object, annex,
+     readbuf, writebuf, offset, len);
 }
 
 /* This structure represents a breakpoint inserted while the record
@@ -1734,7 +1765,7 @@ record_xfer_partial (struct target_ops *ops, enum target_object object,
    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
+struct record_full_breakpoint
 {
   /* The address and address space the breakpoint was set at.  */
   struct address_space *address_space;
@@ -1746,54 +1777,54 @@ struct record_breakpoint
   int in_target_beneath;
 };
 
-typedef struct record_breakpoint *record_breakpoint_p;
-DEF_VEC_P(record_breakpoint_p);
+typedef struct record_full_breakpoint *record_full_breakpoint_p;
+DEF_VEC_P(record_full_breakpoint_p);
 
 /* The list of breakpoints inserted while the record target is
    active.  */
-VEC(record_breakpoint_p) *record_breakpoints = NULL;
+VEC(record_full_breakpoint_p) *record_full_breakpoints = NULL;
 
 static void
-record_sync_record_breakpoints (struct bp_location *loc, void *data)
+record_full_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);
+      struct record_full_breakpoint *bp = XNEW (struct record_full_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);
+      VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
     }
 }
 
-/* Sync existing breakpoints to record_breakpoints.  */
+/* Sync existing breakpoints to record_full_breakpoints.  */
 
 static void
-record_init_record_breakpoints (void)
+record_full_init_record_breakpoints (void)
 {
-  VEC_free (record_breakpoint_p, record_breakpoints);
+  VEC_free (record_full_breakpoint_p, record_full_breakpoints);
 
-  iterate_over_bp_locations (record_sync_record_breakpoints);
+  iterate_over_bp_locations (record_full_sync_record_breakpoints);
 }
 
-/* Behavior is conditional on RECORD_IS_REPLAY.  We will not actually
+/* Behavior is conditional on RECORD_FULL_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)
+record_full_insert_breakpoint (struct gdbarch *gdbarch,
+			       struct bp_target_info *bp_tgt)
 {
-  struct record_breakpoint *bp;
+  struct record_full_breakpoint *bp;
   int in_target_beneath = 0;
 
-  if (!RECORD_IS_REPLAY)
+  if (!RECORD_FULL_IS_REPLAY)
     {
       /* When recording, we currently always single-step, so we don't
 	 really need to install regular breakpoints in the inferior.
@@ -1804,7 +1835,7 @@ record_insert_breakpoint (struct gdbarch *gdbarch,
       int ret;
 
       old_cleanups = record_gdb_operation_disable_set ();
-      ret = record_beneath_to_insert_breakpoint (gdbarch, bp_tgt);
+      ret = record_full_beneath_to_insert_breakpoint (gdbarch, bp_tgt);
       do_cleanups (old_cleanups);
 
       if (ret != 0)
@@ -1813,25 +1844,26 @@ record_insert_breakpoint (struct gdbarch *gdbarch,
       in_target_beneath = 1;
     }
 
-  bp = XNEW (struct record_breakpoint);
+  bp = XNEW (struct record_full_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);
+  VEC_safe_push (record_full_breakpoint_p, record_full_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)
+record_full_remove_breakpoint (struct gdbarch *gdbarch,
+			       struct bp_target_info *bp_tgt)
 {
-  struct record_breakpoint *bp;
+  struct record_full_breakpoint *bp;
   int ix;
 
   for (ix = 0;
-       VEC_iterate (record_breakpoint_p, record_breakpoints, ix, bp);
+       VEC_iterate (record_full_breakpoint_p,
+		    record_full_breakpoints, ix, bp);
        ++ix)
     {
       if (bp->addr == bp_tgt->placed_address
@@ -1843,14 +1875,15 @@ record_remove_breakpoint (struct gdbarch *gdbarch,
 	      int ret;
 
 	      old_cleanups = record_gdb_operation_disable_set ();
-	      ret = record_beneath_to_remove_breakpoint (gdbarch, bp_tgt);
+	      ret = record_full_beneath_to_remove_breakpoint (gdbarch, bp_tgt);
 	      do_cleanups (old_cleanups);
 
 	      if (ret != 0)
 		return ret;
 	    }
 
-	  VEC_unordered_remove (record_breakpoint_p, record_breakpoints, ix);
+	  VEC_unordered_remove (record_full_breakpoint_p,
+				record_full_breakpoints, ix);
 	  return 0;
 	}
     }
@@ -1861,7 +1894,7 @@ record_remove_breakpoint (struct gdbarch *gdbarch,
 /* "to_can_execute_reverse" method for process record target.  */
 
 static int
-record_can_execute_reverse (void)
+record_full_can_execute_reverse (void)
 {
   return 1;
 }
@@ -1869,22 +1902,22 @@ record_can_execute_reverse (void)
 /* "to_get_bookmark" method for process record and prec over core.  */
 
 static gdb_byte *
-record_get_bookmark (char *args, int from_tty)
+record_full_get_bookmark (char *args, int from_tty)
 {
   gdb_byte *ret = NULL;
 
   /* Return stringified form of instruction count.  */
-  if (record_list && record_list->type == record_end)
-    ret = xstrdup (pulongest (record_list->u.end.insn_num));
+  if (record_full_list && record_full_list->type == record_full_end)
+    ret = xstrdup (pulongest (record_full_list->u.end.insn_num));
 
   if (record_debug)
     {
       if (ret)
 	fprintf_unfiltered (gdb_stdlog,
-			    "record_get_bookmark returns %s\n", ret);
+			    "record_full_get_bookmark returns %s\n", ret);
       else
 	fprintf_unfiltered (gdb_stdlog,
-			    "record_get_bookmark returns NULL\n");
+			    "record_full_get_bookmark returns NULL\n");
     }
   return ret;
 }
@@ -1892,11 +1925,11 @@ record_get_bookmark (char *args, int from_tty)
 /* "to_goto_bookmark" method for process record and prec over core.  */
 
 static void
-record_goto_bookmark (gdb_byte *bookmark, int from_tty)
+record_full_goto_bookmark (gdb_byte *bookmark, int from_tty)
 {
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog,
-			"record_goto_bookmark receives %s\n", bookmark);
+			"record_full_goto_bookmark receives %s\n", bookmark);
 
   if (bookmark[0] == '\'' || bookmark[0] == '\"')
     {
@@ -1907,7 +1940,7 @@ record_goto_bookmark (gdb_byte *bookmark, int from_tty)
       bookmark[strlen (bookmark) - 1] = '\0';
       /* Strip leading quote.  */
       bookmark++;
-      /* Pass along to cmd_record_goto.  */
+      /* Pass along to cmd_record_full_goto.  */
     }
 
   cmd_record_goto ((char *) bookmark, from_tty);
@@ -1915,116 +1948,116 @@ record_goto_bookmark (gdb_byte *bookmark, int from_tty)
 }
 
 static void
-record_async (void (*callback) (enum inferior_event_type event_type,
-				void *context), void *context)
+record_full_async (void (*callback) (enum inferior_event_type event_type,
+				     void *context), void *context)
 {
   /* If we're on top of a line target (e.g., linux-nat, remote), then
      set it to async mode as well.  Will be NULL if we're sitting on
      top of the core target, for "record restore".  */
-  if (record_beneath_to_async != NULL)
-    record_beneath_to_async (callback, context);
+  if (record_full_beneath_to_async != NULL)
+    record_full_beneath_to_async (callback, context);
 }
 
 static int
-record_can_async_p (void)
+record_full_can_async_p (void)
 {
   /* We only enable async when the user specifically asks for it.  */
   return target_async_permitted;
 }
 
 static int
-record_is_async_p (void)
+record_full_is_async_p (void)
 {
   /* We only enable async when the user specifically asks for it.  */
   return target_async_permitted;
 }
 
 static enum exec_direction_kind
-record_execution_direction (void)
+record_full_execution_direction (void)
 {
-  return record_execution_dir;
+  return record_full_execution_dir;
 }
 
 static void
-record_info (void)
+record_full_info (void)
 {
-  struct record_entry *p;
+  struct record_full_entry *p;
 
-  if (RECORD_IS_REPLAY)
+  if (RECORD_FULL_IS_REPLAY)
     printf_filtered (_("Replay mode:\n"));
   else
     printf_filtered (_("Record mode:\n"));
 
   /* Find entry for first actual instruction in the log.  */
-  for (p = record_first.next;
-       p != NULL && p->type != record_end;
+  for (p = record_full_first.next;
+       p != NULL && p->type != record_full_end;
        p = p->next)
     ;
 
   /* Do we have a log at all?  */
-  if (p != NULL && p->type == record_end)
+  if (p != NULL && p->type == record_full_end)
     {
       /* Display instruction number for first instruction in the log.  */
       printf_filtered (_("Lowest recorded instruction number is %s.\n"),
 		       pulongest (p->u.end.insn_num));
 
       /* If in replay mode, display where we are in the log.  */
-      if (RECORD_IS_REPLAY)
+      if (RECORD_FULL_IS_REPLAY)
 	printf_filtered (_("Current instruction number is %s.\n"),
-			 pulongest (record_list->u.end.insn_num));
+			 pulongest (record_full_list->u.end.insn_num));
 
       /* Display instruction number for last instruction in the log.  */
       printf_filtered (_("Highest recorded instruction number is %s.\n"),
-		       pulongest (record_insn_count));
+		       pulongest (record_full_insn_count));
 
       /* Display log count.  */
       printf_filtered (_("Log contains %d instructions.\n"),
-		       record_insn_num);
+		       record_full_insn_num);
     }
   else
     printf_filtered (_("No instructions have been logged.\n"));
 
   /* Display max log size.  */
   printf_filtered (_("Max logged instructions is %d.\n"),
-		   record_insn_max_num);
+		   record_full_insn_max_num);
 }
 
 /* The "to_record_delete" target method.  */
 
 static void
-record_delete (void)
+record_full_delete (void)
 {
-  record_list_release_following (record_list);
+  record_full_list_release_following (record_full_list);
 }
 
 /* The "to_record_is_replaying" target method.  */
 
 static int
-record_is_replaying (void)
+record_full_is_replaying (void)
 {
-  return RECORD_IS_REPLAY;
+  return RECORD_FULL_IS_REPLAY;
 }
 
 /* Go to a specific entry.  */
 
 static void
-record_goto_entry (struct record_entry *p)
+record_full_goto_entry (struct record_full_entry *p)
 {
   if (p == NULL)
     error (_("Target insn not found."));
-  else if (p == record_list)
+  else if (p == record_full_list)
     error (_("Already at target insn."));
-  else if (p->u.end.insn_num > record_list->u.end.insn_num)
+  else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
     {
       printf_filtered (_("Go forward to insn number %s\n"),
 		       pulongest (p->u.end.insn_num));
-      record_goto_insn (p, EXEC_FORWARD);
+      record_full_goto_insn (p, EXEC_FORWARD);
     }
   else
     {
       printf_filtered (_("Go backward to insn number %s\n"),
 		       pulongest (p->u.end.insn_num));
-      record_goto_insn (p, EXEC_REVERSE);
+      record_full_goto_insn (p, EXEC_REVERSE);
     }
 
   registers_changed ();
@@ -2035,97 +2068,97 @@ record_goto_entry (struct record_entry *p)
 /* The "to_goto_record_begin" target method.  */
 
 static void
-record_goto_begin (void)
+record_full_goto_begin (void)
 {
-  struct record_entry *p = NULL;
+  struct record_full_entry *p = NULL;
 
-  for (p = &record_first; p != NULL; p = p->next)
-    if (p->type == record_end)
+  for (p = &record_full_first; p != NULL; p = p->next)
+    if (p->type == record_full_end)
       break;
 
-  record_goto_entry (p);
+  record_full_goto_entry (p);
 }
 
 /* The "to_goto_record_end" target method.  */
 
 static void
-record_goto_end (void)
+record_full_goto_end (void)
 {
-  struct record_entry *p = NULL;
+  struct record_full_entry *p = NULL;
 
-  for (p = record_list; p->next != NULL; p = p->next)
+  for (p = record_full_list; p->next != NULL; p = p->next)
     ;
   for (; p!= NULL; p = p->prev)
-    if (p->type == record_end)
+    if (p->type == record_full_end)
       break;
 
-  record_goto_entry (p);
+  record_full_goto_entry (p);
 }
 
 /* The "to_goto_record" target method.  */
 
 static void
-record_goto (ULONGEST target_insn)
+record_full_goto (ULONGEST target_insn)
 {
-  struct record_entry *p = NULL;
+  struct record_full_entry *p = NULL;
 
-  for (p = &record_first; p != NULL; p = p->next)
-    if (p->type == record_end && p->u.end.insn_num == target_insn)
+  for (p = &record_full_first; p != NULL; p = p->next)
+    if (p->type == record_full_end && p->u.end.insn_num == target_insn)
       break;
 
-  record_goto_entry (p);
+  record_full_goto_entry (p);
 }
 
 static void
-init_record_ops (void)
+init_record_full_ops (void)
 {
-  record_ops.to_shortname = "record-full";
-  record_ops.to_longname = "Process record and replay target";
-  record_ops.to_doc =
+  record_full_ops.to_shortname = "record-full";
+  record_full_ops.to_longname = "Process record and replay target";
+  record_full_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_stopped_by_watchpoint = record_stopped_by_watchpoint;
-  record_ops.to_stopped_data_address = record_stopped_data_address;
-  record_ops.to_can_execute_reverse = record_can_execute_reverse;
-  record_ops.to_stratum = record_stratum;
+  record_full_ops.to_open = record_full_open;
+  record_full_ops.to_close = record_full_close;
+  record_full_ops.to_resume = record_full_resume;
+  record_full_ops.to_wait = record_full_wait;
+  record_full_ops.to_disconnect = record_full_disconnect;
+  record_full_ops.to_detach = record_full_detach;
+  record_full_ops.to_mourn_inferior = record_full_mourn_inferior;
+  record_full_ops.to_kill = record_full_kill;
+  record_full_ops.to_create_inferior = find_default_create_inferior;
+  record_full_ops.to_store_registers = record_full_store_registers;
+  record_full_ops.to_xfer_partial = record_full_xfer_partial;
+  record_full_ops.to_insert_breakpoint = record_full_insert_breakpoint;
+  record_full_ops.to_remove_breakpoint = record_full_remove_breakpoint;
+  record_full_ops.to_stopped_by_watchpoint = record_full_stopped_by_watchpoint;
+  record_full_ops.to_stopped_data_address = record_full_stopped_data_address;
+  record_full_ops.to_can_execute_reverse = record_full_can_execute_reverse;
+  record_full_ops.to_stratum = record_stratum;
   /* Add bookmark target methods.  */
-  record_ops.to_get_bookmark = record_get_bookmark;
-  record_ops.to_goto_bookmark = record_goto_bookmark;
-  record_ops.to_async = record_async;
-  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_info_record = record_info;
-  record_ops.to_save_record = record_save;
-  record_ops.to_delete_record = record_delete;
-  record_ops.to_record_is_replaying = record_is_replaying;
-  record_ops.to_goto_record_begin = record_goto_begin;
-  record_ops.to_goto_record_end = record_goto_end;
-  record_ops.to_goto_record = record_goto;
-  record_ops.to_magic = OPS_MAGIC;
+  record_full_ops.to_get_bookmark = record_full_get_bookmark;
+  record_full_ops.to_goto_bookmark = record_full_goto_bookmark;
+  record_full_ops.to_async = record_full_async;
+  record_full_ops.to_can_async_p = record_full_can_async_p;
+  record_full_ops.to_is_async_p = record_full_is_async_p;
+  record_full_ops.to_execution_direction = record_full_execution_direction;
+  record_full_ops.to_info_record = record_full_info;
+  record_full_ops.to_save_record = record_full_save;
+  record_full_ops.to_delete_record = record_full_delete;
+  record_full_ops.to_record_is_replaying = record_full_is_replaying;
+  record_full_ops.to_goto_record_begin = record_full_goto_begin;
+  record_full_ops.to_goto_record_end = record_full_goto_end;
+  record_full_ops.to_goto_record = record_full_goto;
+  record_full_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 gdb_signal signal)
+record_full_core_resume (struct target_ops *ops, ptid_t ptid, int step,
+			 enum gdb_signal signal)
 {
-  record_resume_step = step;
-  record_resumed = 1;
-  record_execution_dir = execution_direction;
+  record_full_resume_step = step;
+  record_full_resumed = 1;
+  record_full_execution_dir = execution_direction;
 
   /* We are about to start executing the inferior (or simulate it),
      let's register it with the event loop.  */
@@ -2134,27 +2167,27 @@ record_core_resume (struct target_ops *ops, ptid_t ptid, int step,
       target_async (inferior_event_handler, 0);
 
       /* Notify the event loop there's an event to wait for.  */
-      mark_async_event_handler (record_async_inferior_event_token);
+      mark_async_event_handler (record_full_async_inferior_event_token);
     }
 }
 
 /* "to_kill" method for prec over corefile.  */
 
 static void
-record_core_kill (struct target_ops *ops)
+record_full_core_kill (struct target_ops *ops)
 {
   if (record_debug)
-    fprintf_unfiltered (gdb_stdlog, "Process record: record_core_kill\n");
+    fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
 
-  unpush_target (&record_core_ops);
+  unpush_target (&record_full_core_ops);
 }
 
 /* "to_fetch_registers" method for prec over corefile.  */
 
 static void
-record_core_fetch_registers (struct target_ops *ops,
-                             struct regcache *regcache,
-                             int regno)
+record_full_core_fetch_registers (struct target_ops *ops,
+				  struct regcache *regcache,
+				  int regno)
 {
   if (regno < 0)
     {
@@ -2163,30 +2196,30 @@ record_core_fetch_registers (struct target_ops *ops,
 
       for (i = 0; i < num; i ++)
         regcache_raw_supply (regcache, i,
-                             record_core_regbuf + MAX_REGISTER_SIZE * i);
+                             record_full_core_regbuf + MAX_REGISTER_SIZE * i);
     }
   else
     regcache_raw_supply (regcache, regno,
-                         record_core_regbuf + MAX_REGISTER_SIZE * regno);
+                         record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
 }
 
 /* "to_prepare_to_store" method for prec over corefile.  */
 
 static void
-record_core_prepare_to_store (struct regcache *regcache)
+record_full_core_prepare_to_store (struct regcache *regcache)
 {
 }
 
 /* "to_store_registers" method for prec over corefile.  */
 
 static void
-record_core_store_registers (struct target_ops *ops,
+record_full_core_store_registers (struct target_ops *ops,
                              struct regcache *regcache,
                              int regno)
 {
-  if (record_gdb_operation_disable)
+  if (record_full_gdb_operation_disable)
     regcache_raw_collect (regcache, regno,
-                          record_core_regbuf + MAX_REGISTER_SIZE * regno);
+                          record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
   else
     error (_("You can't do that without a process to debug."));
 }
@@ -2194,22 +2227,23 @@ record_core_store_registers (struct target_ops *ops,
 /* "to_xfer_partial" method for prec over corefile.  */
 
 static LONGEST
-record_core_xfer_partial (struct target_ops *ops, enum target_object object,
-		          const char *annex, gdb_byte *readbuf,
-		          const gdb_byte *writebuf, ULONGEST offset,
-                          LONGEST len)
+record_full_core_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 (object == TARGET_OBJECT_MEMORY)
     {
-      if (record_gdb_operation_disable || !writebuf)
+      if (record_full_gdb_operation_disable || !writebuf)
 	{
 	  struct target_section *p;
 
-	  for (p = record_core_start; p < record_core_end; p++)
+	  for (p = record_full_core_start; p < record_full_core_end; p++)
 	    {
 	      if (offset >= p->addr)
 		{
-		  struct record_core_buf_entry *entry;
+		  struct record_full_core_buf_entry *entry;
 		  ULONGEST sec_offset;
 
 		  if (offset >= p->endaddr)
@@ -2229,8 +2263,8 @@ record_core_xfer_partial (struct target_ops *ops, enum target_object object,
 			memset (readbuf, 0, len);
 		      return len;
 		    }
-		  /* Get record_core_buf_entry.  */
-		  for (entry = record_core_buf_list; entry;
+		  /* Get record_full_core_buf_entry.  */
+		  for (entry = record_full_core_buf_list; entry;
 		       entry = entry->prev)
 		    if (entry->p == p)
 		      break;
@@ -2239,8 +2273,9 @@ record_core_xfer_partial (struct target_ops *ops, enum target_object object,
 		      if (!entry)
 			{
 			  /* Add a new entry.  */
-			  entry = (struct record_core_buf_entry *)
-			    xmalloc (sizeof (struct record_core_buf_entry));
+			  entry = (struct record_full_core_buf_entry *)
+			    xmalloc
+			    (sizeof (struct record_full_core_buf_entry));
 			  entry->p = p;
 			  if (!bfd_malloc_and_get_section (p->bfd,
 							   p->the_bfd_section,
@@ -2249,8 +2284,8 @@ record_core_xfer_partial (struct target_ops *ops, enum target_object object,
 			      xfree (entry);
 			      return 0;
 			    }
-			  entry->prev = record_core_buf_list;
-			  record_core_buf_list = entry;
+			  entry->prev = record_full_core_buf_list;
+			  record_full_core_buf_list = entry;
 			}
 
 		      memcpy (entry->buf + sec_offset, writebuf,
@@ -2259,8 +2294,8 @@ record_core_xfer_partial (struct target_ops *ops, enum target_object object,
 		  else
 		    {
 		      if (!entry)
-			return record_beneath_to_xfer_partial
-			  (record_beneath_to_xfer_partial_ops,
+			return record_full_beneath_to_xfer_partial
+			  (record_full_beneath_to_xfer_partial_ops,
 			   object, annex, readbuf, writebuf,
 			   offset, len);
 
@@ -2278,16 +2313,16 @@ record_core_xfer_partial (struct target_ops *ops, enum target_object object,
 	error (_("You can't do that without a process to debug."));
     }
 
-  return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_ops,
-                                         object, annex, readbuf, writebuf,
-                                         offset, len);
+  return record_full_beneath_to_xfer_partial
+    (record_full_beneath_to_xfer_partial_ops, object, annex,
+     readbuf, writebuf, offset, len);
 }
 
 /* "to_insert_breakpoint" method for prec over corefile.  */
 
 static int
-record_core_insert_breakpoint (struct gdbarch *gdbarch,
-			       struct bp_target_info *bp_tgt)
+record_full_core_insert_breakpoint (struct gdbarch *gdbarch,
+				    struct bp_target_info *bp_tgt)
 {
   return 0;
 }
@@ -2295,8 +2330,8 @@ record_core_insert_breakpoint (struct gdbarch *gdbarch,
 /* "to_remove_breakpoint" method for prec over corefile.  */
 
 static int
-record_core_remove_breakpoint (struct gdbarch *gdbarch,
-			       struct bp_target_info *bp_tgt)
+record_full_core_remove_breakpoint (struct gdbarch *gdbarch,
+				    struct bp_target_info *bp_tgt)
 {
   return 0;
 }
@@ -2304,48 +2339,54 @@ record_core_remove_breakpoint (struct gdbarch *gdbarch,
 /* "to_has_execution" method for prec over corefile.  */
 
 static int
-record_core_has_execution (struct target_ops *ops, ptid_t the_ptid)
+record_full_core_has_execution (struct target_ops *ops, ptid_t the_ptid)
 {
   return 1;
 }
 
 static void
-init_record_core_ops (void)
+init_record_full_core_ops (void)
 {
-  record_core_ops.to_shortname = "record-core";
-  record_core_ops.to_longname = "Process record and replay target";
-  record_core_ops.to_doc =
+  record_full_core_ops.to_shortname = "record-core";
+  record_full_core_ops.to_longname = "Process record and replay target";
+  record_full_core_ops.to_doc =
     "Log program while executing and replay execution from log.";
-  record_core_ops.to_open = record_open;
-  record_core_ops.to_close = record_close;
-  record_core_ops.to_resume = record_core_resume;
-  record_core_ops.to_wait = record_wait;
-  record_core_ops.to_kill = record_core_kill;
-  record_core_ops.to_fetch_registers = record_core_fetch_registers;
-  record_core_ops.to_prepare_to_store = record_core_prepare_to_store;
-  record_core_ops.to_store_registers = record_core_store_registers;
-  record_core_ops.to_xfer_partial = record_core_xfer_partial;
-  record_core_ops.to_insert_breakpoint = record_core_insert_breakpoint;
-  record_core_ops.to_remove_breakpoint = record_core_remove_breakpoint;
-  record_core_ops.to_stopped_by_watchpoint = record_stopped_by_watchpoint;
-  record_core_ops.to_stopped_data_address = record_stopped_data_address;
-  record_core_ops.to_can_execute_reverse = record_can_execute_reverse;
-  record_core_ops.to_has_execution = record_core_has_execution;
-  record_core_ops.to_stratum = record_stratum;
+  record_full_core_ops.to_open = record_full_open;
+  record_full_core_ops.to_close = record_full_close;
+  record_full_core_ops.to_resume = record_full_core_resume;
+  record_full_core_ops.to_wait = record_full_wait;
+  record_full_core_ops.to_kill = record_full_core_kill;
+  record_full_core_ops.to_fetch_registers = record_full_core_fetch_registers;
+  record_full_core_ops.to_prepare_to_store = record_full_core_prepare_to_store;
+  record_full_core_ops.to_store_registers = record_full_core_store_registers;
+  record_full_core_ops.to_xfer_partial = record_full_core_xfer_partial;
+  record_full_core_ops.to_insert_breakpoint
+    = record_full_core_insert_breakpoint;
+  record_full_core_ops.to_remove_breakpoint
+    = record_full_core_remove_breakpoint;
+  record_full_core_ops.to_stopped_by_watchpoint
+    = record_full_stopped_by_watchpoint;
+  record_full_core_ops.to_stopped_data_address
+    = record_full_stopped_data_address;
+  record_full_core_ops.to_can_execute_reverse
+    = record_full_can_execute_reverse;
+  record_full_core_ops.to_has_execution = record_full_core_has_execution;
+  record_full_core_ops.to_stratum = record_stratum;
   /* Add bookmark target methods.  */
-  record_core_ops.to_get_bookmark = record_get_bookmark;
-  record_core_ops.to_goto_bookmark = record_goto_bookmark;
-  record_core_ops.to_async = record_async;
-  record_core_ops.to_can_async_p = record_can_async_p;
-  record_core_ops.to_is_async_p = record_is_async_p;
-  record_core_ops.to_execution_direction = record_execution_direction;
-  record_core_ops.to_info_record = record_info;
-  record_core_ops.to_delete_record = record_delete;
-  record_core_ops.to_record_is_replaying = record_is_replaying;
-  record_core_ops.to_goto_record_begin = record_goto_begin;
-  record_core_ops.to_goto_record_end = record_goto_end;
-  record_core_ops.to_goto_record = record_goto;
-  record_core_ops.to_magic = OPS_MAGIC;
+  record_full_core_ops.to_get_bookmark = record_full_get_bookmark;
+  record_full_core_ops.to_goto_bookmark = record_full_goto_bookmark;
+  record_full_core_ops.to_async = record_full_async;
+  record_full_core_ops.to_can_async_p = record_full_can_async_p;
+  record_full_core_ops.to_is_async_p = record_full_is_async_p;
+  record_full_core_ops.to_execution_direction
+    = record_full_execution_direction;
+  record_full_core_ops.to_info_record = record_full_info;
+  record_full_core_ops.to_delete_record = record_full_delete;
+  record_full_core_ops.to_record_is_replaying = record_full_is_replaying;
+  record_full_core_ops.to_goto_record_begin = record_full_goto_begin;
+  record_full_core_ops.to_goto_record_end = record_full_goto_end;
+  record_full_core_ops.to_goto_record = record_full_goto;
+  record_full_core_ops.to_magic = OPS_MAGIC;
 }
 
 /* Record log save-file format
@@ -2356,14 +2397,14 @@ init_record_core_ops (void)
        NOTE: be sure to change whenever this file format changes!
 
    Records:
-     record_end:
-       1 byte:  record type (record_end, see enum record_type).
-     record_reg:
-       1 byte:  record type (record_reg, see enum record_type).
+     record_full_end:
+       1 byte:  record type (record_full_end, see enum record_full_type).
+     record_full_reg:
+       1 byte:  record type (record_full_reg, see enum record_full_type).
        8 bytes: register id (network byte order).
        MAX_REGISTER_SIZE bytes: register value.
-     record_mem:
-       1 byte:  record type (record_mem, see enum record_type).
+     record_full_mem:
+       1 byte:  record type (record_full_mem, see enum record_full_type).
        8 bytes: memory length (network byte order).
        8 bytes: memory address (network byte order).
        n bytes: memory value (n == memory length).
@@ -2373,17 +2414,17 @@ init_record_core_ops (void)
        NOTE: be sure to change whenever this file format changes!
 
    Records:
-     record_end:
-       1 byte:  record type (record_end, see enum record_type).
+     record_full_end:
+       1 byte:  record type (record_full_end, see enum record_full_type).
        4 bytes: signal
        4 bytes: instruction count
-     record_reg:
-       1 byte:  record type (record_reg, see enum record_type).
+     record_full_reg:
+       1 byte:  record type (record_full_reg, see enum record_full_type).
        4 bytes: register id (network byte order).
        n bytes: register value (n == actual register size).
                 (eg. 4 bytes for x86 general registers).
-     record_mem:
-       1 byte:  record type (record_mem, see enum record_type).
+     record_full_mem:
+       1 byte:  record type (record_full_mem, see enum record_full_type).
        4 bytes: memory length (network byte order).
        8 bytes: memory address (network byte order).
        n bytes: memory value (n == memory length).
@@ -2437,11 +2478,11 @@ netorder16 (uint16_t input)
 
 /* Restore the execution log from a core_bfd file.  */
 static void
-record_restore (void)
+record_full_restore (void)
 {
   uint32_t magic;
   struct cleanup *old_cleanups;
-  struct record_entry *rec;
+  struct record_full_entry *rec;
   asection *osec;
   uint32_t osec_size;
   int bfd_offset = 0;
@@ -2452,8 +2493,8 @@ record_restore (void)
   if (core_bfd == NULL)
     return;
 
-  /* "record_restore" can only be called when record list is empty.  */
-  gdb_assert (record_first.next == NULL);
+  /* "record_full_restore" can only be called when record list is empty.  */
+  gdb_assert (record_full_first.next == NULL);
  
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
@@ -2471,21 +2512,21 @@ record_restore (void)
 
   /* Check the magic code.  */
   bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
-  if (magic != RECORD_FILE_MAGIC)
+  if (magic != RECORD_FULL_FILE_MAGIC)
     error (_("Version mis-match or file format error in core file %s."),
 	   bfd_get_filename (core_bfd));
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog,
 			"  Reading 4-byte magic cookie "
-			"RECORD_FILE_MAGIC (0x%s)\n",
+			"RECORD_FULL_FILE_MAGIC (0x%s)\n",
 			phex_nz (netorder32 (magic), 4));
 
-  /* Restore the entries in recfd into record_arch_list_head and
-     record_arch_list_tail.  */
-  record_arch_list_head = NULL;
-  record_arch_list_tail = NULL;
-  record_insn_num = 0;
-  old_cleanups = make_cleanup (record_arch_list_cleanups, 0);
+  /* Restore the entries in recfd into record_full_arch_list_head and
+     record_full_arch_list_tail.  */
+  record_full_arch_list_head = NULL;
+  record_full_arch_list_tail = NULL;
+  record_full_insn_num = 0;
+  old_cleanups = make_cleanup (record_full_arch_list_cleanups, 0);
   regcache = get_current_regcache ();
 
   while (1)
@@ -2501,16 +2542,16 @@ record_restore (void)
 
       switch (rectype)
         {
-        case record_reg: /* reg */
+        case record_full_reg: /* reg */
           /* Get register number to regnum.  */
           bfdcore_read (core_bfd, osec, &regnum,
 			sizeof (regnum), &bfd_offset);
 	  regnum = netorder32 (regnum);
 
-          rec = record_reg_alloc (regcache, regnum);
+          rec = record_full_reg_alloc (regcache, regnum);
 
           /* Get val.  */
-          bfdcore_read (core_bfd, osec, record_get_loc (rec),
+          bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
 			rec->u.reg.len, &bfd_offset);
 
 	  if (record_debug)
@@ -2522,7 +2563,7 @@ record_restore (void)
 				rec->u.reg.len);
           break;
 
-        case record_mem: /* mem */
+        case record_full_mem: /* mem */
           /* Get len.  */
           bfdcore_read (core_bfd, osec, &len, 
 			sizeof (len), &bfd_offset);
@@ -2533,10 +2574,10 @@ record_restore (void)
 			sizeof (addr), &bfd_offset);
 	  addr = netorder64 (addr);
 
-          rec = record_mem_alloc (addr, len);
+          rec = record_full_mem_alloc (addr, len);
 
           /* Get val.  */
-          bfdcore_read (core_bfd, osec, record_get_loc (rec),
+          bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
 			rec->u.mem.len, &bfd_offset);
 
 	  if (record_debug)
@@ -2550,9 +2591,9 @@ record_restore (void)
 				rec->u.mem.len);
           break;
 
-        case record_end: /* end */
-          rec = record_end_alloc ();
-          record_insn_num ++;
+        case record_full_end: /* end */
+          rec = record_full_end_alloc ();
+          record_full_insn_num ++;
 
 	  /* Get signal value.  */
 	  bfdcore_read (core_bfd, osec, &signal, 
@@ -2565,10 +2606,10 @@ record_restore (void)
 			sizeof (count), &bfd_offset);
 	  count = netorder32 (count);
 	  rec->u.end.insn_num = count;
-	  record_insn_count = count + 1;
+	  record_full_insn_count = count + 1;
 	  if (record_debug)
 	    fprintf_unfiltered (gdb_stdlog,
-				"  Reading record_end (1 + "
+				"  Reading record_full_end (1 + "
 				"%lu + %lu bytes), offset == %s\n",
 				(unsigned long) sizeof (signal),
 				(unsigned long) sizeof (count),
@@ -2583,23 +2624,23 @@ record_restore (void)
         }
 
       /* Add rec to record arch list.  */
-      record_arch_list_add (rec);
+      record_full_arch_list_add (rec);
     }
 
   discard_cleanups (old_cleanups);
 
-  /* Add record_arch_list_head to the end of record list.  */
-  record_first.next = record_arch_list_head;
-  record_arch_list_head->prev = &record_first;
-  record_arch_list_tail->next = NULL;
-  record_list = &record_first;
+  /* Add record_full_arch_list_head to the end of record list.  */
+  record_full_first.next = record_full_arch_list_head;
+  record_full_arch_list_head->prev = &record_full_first;
+  record_full_arch_list_tail->next = NULL;
+  record_full_list = &record_full_first;
 
-  /* Update record_insn_max_num.  */
-  if (record_insn_num > record_insn_max_num)
+  /* Update record_full_insn_max_num.  */
+  if (record_full_insn_num > record_full_insn_max_num)
     {
-      record_insn_max_num = record_insn_num;
+      record_full_insn_max_num = record_full_insn_num;
       warning (_("Auto increase record/replay buffer limit to %d."),
-               record_insn_max_num);
+               record_full_insn_max_num);
     }
 
   /* Succeeded.  */
@@ -2628,14 +2669,14 @@ bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
    corefile format, with an extra section for our data.  */
 
 static void
-cmd_record_restore (char *args, int from_tty)
+cmd_record_full_restore (char *args, int from_tty)
 {
   core_file_command (args, from_tty);
-  record_open (args, from_tty);
+  record_full_open (args, from_tty);
 }
 
 static void
-record_save_cleanups (void *data)
+record_full_save_cleanups (void *data)
 {
   bfd *obfd = data;
   char *pathname = xstrdup (bfd_get_filename (obfd));
@@ -2649,9 +2690,9 @@ record_save_cleanups (void *data)
    format, with an extra section for our data.  */
 
 static void
-record_save (char *recfilename)
+record_full_save (char *recfilename)
 {
-  struct record_entry *cur_record_list;
+  struct record_full_entry *cur_record_full_list;
   uint32_t magic;
   struct regcache *regcache;
   struct gdbarch *gdbarch;
@@ -2669,10 +2710,10 @@ record_save (char *recfilename)
 
   /* Open the output file.  */
   obfd = create_gcore_bfd (recfilename);
-  old_cleanups = make_cleanup (record_save_cleanups, obfd);
+  old_cleanups = make_cleanup (record_full_save_cleanups, obfd);
 
-  /* Save the current record entry to "cur_record_list".  */
-  cur_record_list = record_list;
+  /* Save the current record entry to "cur_record_full_list".  */
+  cur_record_full_list = record_full_list;
 
   /* Get the values of regcache and gdbarch.  */
   regcache = get_current_regcache ();
@@ -2685,29 +2726,29 @@ record_save (char *recfilename)
   while (1)
     {
       /* Check for beginning and end of log.  */
-      if (record_list == &record_first)
+      if (record_full_list == &record_full_first)
         break;
 
-      record_exec_insn (regcache, gdbarch, record_list);
+      record_full_exec_insn (regcache, gdbarch, record_full_list);
 
-      if (record_list->prev)
-        record_list = record_list->prev;
+      if (record_full_list->prev)
+        record_full_list = record_full_list->prev;
     }
 
   /* Compute the size needed for the extra bfd section.  */
   save_size = 4;	/* magic cookie */
-  for (record_list = record_first.next; record_list;
-       record_list = record_list->next)
-    switch (record_list->type)
+  for (record_full_list = record_full_first.next; record_full_list;
+       record_full_list = record_full_list->next)
+    switch (record_full_list->type)
       {
-      case record_end:
+      case record_full_end:
 	save_size += 1 + 4 + 4;
 	break;
-      case record_reg:
-	save_size += 1 + 4 + record_list->u.reg.len;
+      case record_full_reg:
+	save_size += 1 + 4 + record_full_list->u.reg.len;
 	break;
-      case record_mem:
-	save_size += 1 + 4 + 8 + record_list->u.mem.len;
+      case record_full_mem:
+	save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
 	break;
       }
 
@@ -2729,89 +2770,91 @@ record_save (char *recfilename)
 
   /* Write out the record log.  */
   /* Write the magic code.  */
-  magic = RECORD_FILE_MAGIC;
+  magic = RECORD_FULL_FILE_MAGIC;
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog,
 			"  Writing 4-byte magic cookie "
-			"RECORD_FILE_MAGIC (0x%s)\n",
+			"RECORD_FULL_FILE_MAGIC (0x%s)\n",
 		      phex_nz (magic, 4));
   bfdcore_write (obfd, osec, &magic, sizeof (magic), &bfd_offset);
 
   /* Save the entries to recfd and forward execute to the end of
      record list.  */
-  record_list = &record_first;
+  record_full_list = &record_full_first;
   while (1)
     {
       /* Save entry.  */
-      if (record_list != &record_first)
+      if (record_full_list != &record_full_first)
         {
 	  uint8_t type;
 	  uint32_t regnum, len, signal, count;
           uint64_t addr;
 
-	  type = record_list->type;
+	  type = record_full_list->type;
           bfdcore_write (obfd, osec, &type, sizeof (type), &bfd_offset);
 
-          switch (record_list->type)
+          switch (record_full_list->type)
             {
-            case record_reg: /* reg */
+            case record_full_reg: /* reg */
 	      if (record_debug)
 		fprintf_unfiltered (gdb_stdlog,
 				    "  Writing register %d (1 "
 				    "plus %lu plus %d bytes)\n",
-				    record_list->u.reg.num,
+				    record_full_list->u.reg.num,
 				    (unsigned long) sizeof (regnum),
-				    record_list->u.reg.len);
+				    record_full_list->u.reg.len);
 
               /* Write regnum.  */
-              regnum = netorder32 (record_list->u.reg.num);
+              regnum = netorder32 (record_full_list->u.reg.num);
               bfdcore_write (obfd, osec, &regnum,
 			     sizeof (regnum), &bfd_offset);
 
               /* Write regval.  */
-              bfdcore_write (obfd, osec, record_get_loc (record_list),
-			     record_list->u.reg.len, &bfd_offset);
+              bfdcore_write (obfd, osec,
+			     record_full_get_loc (record_full_list),
+			     record_full_list->u.reg.len, &bfd_offset);
               break;
 
-            case record_mem: /* mem */
+            case record_full_mem: /* mem */
 	      if (record_debug)
 		fprintf_unfiltered (gdb_stdlog,
 				    "  Writing memory %s (1 plus "
 				    "%lu plus %lu plus %d bytes)\n",
 				    paddress (gdbarch,
-					      record_list->u.mem.addr),
+					      record_full_list->u.mem.addr),
 				    (unsigned long) sizeof (addr),
 				    (unsigned long) sizeof (len),
-				    record_list->u.mem.len);
+				    record_full_list->u.mem.len);
 
 	      /* Write memlen.  */
-	      len = netorder32 (record_list->u.mem.len);
+	      len = netorder32 (record_full_list->u.mem.len);
 	      bfdcore_write (obfd, osec, &len, sizeof (len), &bfd_offset);
 
 	      /* Write memaddr.  */
-	      addr = netorder64 (record_list->u.mem.addr);
+	      addr = netorder64 (record_full_list->u.mem.addr);
 	      bfdcore_write (obfd, osec, &addr, 
 			     sizeof (addr), &bfd_offset);
 
 	      /* Write memval.  */
-	      bfdcore_write (obfd, osec, record_get_loc (record_list),
-			     record_list->u.mem.len, &bfd_offset);
+	      bfdcore_write (obfd, osec,
+			     record_full_get_loc (record_full_list),
+			     record_full_list->u.mem.len, &bfd_offset);
               break;
 
-              case record_end:
+              case record_full_end:
 		if (record_debug)
 		  fprintf_unfiltered (gdb_stdlog,
-				      "  Writing record_end (1 + "
+				      "  Writing record_full_end (1 + "
 				      "%lu + %lu bytes)\n", 
 				      (unsigned long) sizeof (signal),
 				      (unsigned long) sizeof (count));
 		/* Write signal value.  */
-		signal = netorder32 (record_list->u.end.sigval);
+		signal = netorder32 (record_full_list->u.end.sigval);
 		bfdcore_write (obfd, osec, &signal,
 			       sizeof (signal), &bfd_offset);
 
 		/* Write insn count.  */
-		count = netorder32 (record_list->u.end.insn_num);
+		count = netorder32 (record_full_list->u.end.insn_num);
 		bfdcore_write (obfd, osec, &count,
 			       sizeof (count), &bfd_offset);
                 break;
@@ -2819,25 +2862,25 @@ record_save (char *recfilename)
         }
 
       /* Execute entry.  */
-      record_exec_insn (regcache, gdbarch, record_list);
+      record_full_exec_insn (regcache, gdbarch, record_full_list);
 
-      if (record_list->next)
-        record_list = record_list->next;
+      if (record_full_list->next)
+        record_full_list = record_full_list->next;
       else
         break;
     }
 
-  /* Reverse execute to cur_record_list.  */
+  /* Reverse execute to cur_record_full_list.  */
   while (1)
     {
       /* Check for beginning and end of log.  */
-      if (record_list == cur_record_list)
+      if (record_full_list == cur_record_full_list)
         break;
 
-      record_exec_insn (regcache, gdbarch, record_list);
+      record_full_exec_insn (regcache, gdbarch, record_full_list);
 
-      if (record_list->prev)
-        record_list = record_list->prev;
+      if (record_full_list->prev)
+        record_full_list = record_full_list->prev;
     }
 
   do_cleanups (set_cleanups);
@@ -2849,13 +2892,13 @@ record_save (char *recfilename)
 		   recfilename);
 }
 
-/* record_goto_insn -- rewind the record log (forward or backward,
+/* record_full_goto_insn -- rewind the record log (forward or backward,
    depending on DIR) to the given entry, changing the program state
    correspondingly.  */
 
 static void
-record_goto_insn (struct record_entry *entry,
-		  enum exec_direction_kind dir)
+record_full_goto_insn (struct record_full_entry *entry,
+		       enum exec_direction_kind dir)
 {
   struct cleanup *set_cleanups = record_gdb_operation_disable_set ();
   struct regcache *regcache = get_current_regcache ();
@@ -2865,37 +2908,39 @@ record_goto_insn (struct record_entry *entry,
      and we will not hit the end of the recording.  */
 
   if (dir == EXEC_FORWARD)
-    record_list = record_list->next;
+    record_full_list = record_full_list->next;
 
   do
     {
-      record_exec_insn (regcache, gdbarch, record_list);
+      record_full_exec_insn (regcache, gdbarch, record_full_list);
       if (dir == EXEC_REVERSE)
-	record_list = record_list->prev;
+	record_full_list = record_full_list->prev;
       else
-	record_list = record_list->next;
-    } while (record_list != entry);
+	record_full_list = record_full_list->next;
+    } while (record_full_list != entry);
   do_cleanups (set_cleanups);
 }
 
 /* Alias for "target record-full".  */
 
 static void
-cmd_record_start (char *args, int from_tty)
+cmd_record_full_start (char *args, int from_tty)
 {
   execute_command ("target record-full", from_tty);
 }
 
 static void
-set_record_insn_max_num (char *args, int from_tty, struct cmd_list_element *c)
+set_record_full_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)
+  if (record_full_insn_num > record_full_insn_max_num &&
+      record_full_insn_max_num)
     {
-      /* Count down record_insn_num while releasing records from list.  */
-      while (record_insn_num > record_insn_max_num)
+      /* Count down record_full_insn_num while releasing records from list.  */
+      while (record_full_insn_num > record_full_insn_max_num)
        {
-         record_list_release_first ();
-         record_insn_num--;
+         record_full_list_release_first ();
+         record_full_insn_num--;
        }
     }
 }
@@ -2927,22 +2972,22 @@ _initialize_record_full (void)
 {
   struct cmd_list_element *c;
 
-  /* Init record_first.  */
-  record_first.prev = NULL;
-  record_first.next = NULL;
-  record_first.type = record_end;
+  /* Init record_full_first.  */
+  record_full_first.prev = NULL;
+  record_full_first.next = NULL;
+  record_full_first.type = record_full_end;
 
-  init_record_ops ();
-  add_target (&record_ops);
-  add_deprecated_target_alias (&record_ops, "record");
-  init_record_core_ops ();
-  add_target (&record_core_ops);
+  init_record_full_ops ();
+  add_target (&record_full_ops);
+  add_deprecated_target_alias (&record_full_ops, "record");
+  init_record_full_core_ops ();
+  add_target (&record_full_core_ops);
 
-  add_prefix_cmd ("full", class_obscure, cmd_record_start,
+  add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
 		  _("Start full execution recording."), &record_full_cmdlist,
 		  "record full ", 0, &record_cmdlist);
 
-  c = add_cmd ("restore", class_obscure, cmd_record_restore,
+  c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
 	       _("Restore the execution log from a file.\n\
 Argument is filename.  File must be created with 'record save'."),
 	       &record_full_cmdlist);
@@ -2964,7 +3009,7 @@ Argument is filename.  File must be created with 'record save'."),
 
   /* Record instructions number limit command.  */
   add_setshow_boolean_cmd ("stop-at-limit", no_class,
-			   &record_stop_at_limit, _("\
+			   &record_full_stop_at_limit, _("\
 Set whether record/replay stops when record/replay buffer becomes full."), _("\
 Show whether record/replay stops when record/replay buffer becomes full."),
 			   _("Default is ON.\n\
@@ -2982,12 +3027,13 @@ delete the oldest recorded instruction to make room for each new one."),
 		     &show_record_cmdlist);
   deprecate_cmd (c, "show record full stop-at-limit");
 
-  add_setshow_uinteger_cmd ("insn-number-max", no_class, &record_insn_max_num,
+  add_setshow_uinteger_cmd ("insn-number-max", no_class,
+			    &record_full_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 is 200000."),
-			    set_record_insn_max_num,
+			    set_record_full_insn_max_num,
 			    NULL, &set_record_full_cmdlist,
 			    &show_record_full_cmdlist);
 
@@ -2999,7 +3045,8 @@ record/replay buffer.  Zero means unlimited.  Default is 200000."),
 		     &show_record_cmdlist);
   deprecate_cmd (c, "show record full insn-number-max");
 
-  add_setshow_boolean_cmd ("memory-query", no_class, &record_memory_query, _("\
+  add_setshow_boolean_cmd ("memory-query", no_class,
+			   &record_memory_query, _("\
 Set whether query if PREC cannot record memory change of next instruction."),
                            _("\
 Show whether query if PREC cannot record memory change of next instruction."),
@@ -3007,7 +3054,8 @@ 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_full_cmdlist, &show_record_full_cmdlist);
+			   &set_record_full_cmdlist,
+			   &show_record_full_cmdlist);
 
   c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
 		     &set_record_cmdlist);
-- 
1.7.1

Re: [rfc 2/8] record-full.c: rename record_ in record_full_.

[Jan Kratochvil]

On Thu, 14 Feb 2013 17:29:06 +0100, markus.t.metzger@intel.com wrote:
> The changelog for this renaming will be huge. Is there a way to abbreviate or
> auto-generate it?

There is a script by Daniel Jacobowitz:
	http://sourceware.org/ml/gdb-patches/2006-10/msg00085.html

But as you may find out it does not work too well.

I have tried right now some tiny fixes to it which I consider for many years
already but I apparently do not have experience with this change yet:

--- bin/fsfchangelog-orig	2013-02-15 09:42:14.836287199 +0100
+++ bin/fsfchangelog	2013-02-15 09:42:17.706281390 +0100
@@ -61,9 +61,9 @@ while (<DFILE>) {
     # The first two patterns work with context diff files (diff -c). The
     # third pattern works with unified diff files (diff -u).
 
-    my $linestart = "[-a-zA-Z0-9_.]+";
+    my $linestart = "[-a-zA-Z0-9_.]+(?: [-a-zA-Z0-9_.]+)*";
     if (/^\*\*\*\*\*\** ($linestart)/
-        || /^[\-\+\!] ($linestart)[ \t]*\(.*/
+        || /^[\-\+\!] ?($linestart)[ \t]*\(.*/
 	|| /^@@ .* @@ ($linestart)/)
       {
 	$fn = $1;

Although IMO automating it too much is not good as the goal is to
unconditionally self-review the patch, not to write the ChangeLog entry.


Thanks,
Jan

[rfc 1/8] record: make it build again

[markus.t.metzger]

From: Markus Metzger <markus.t.metzger@intel.com>

Complete the split of record into record.c and record-full.c

I ran the gdb.reverse suite on 64bit IA gnu/linux - no regressions.

2013-02-14 Markus Metzger <markus.t.metzger@intel.com>

	* target.h (target_ops): Add new fields to_info_record,
	to_save_record, to_delete_record, to_record_is_replaying,
	to_goto_record_begin, to_goto_record_end, to_goto_record.
	(target_info_record): New.
	(target_save_record): New.
	(target_supports_delete_record): New.
	(target_delete_record): New.
	(target_record_is_replaying): New.
	(target_goto_record_begin): New.
	(target_goto_record_end): New.
	(target_goto_record): New.
	* target.c (target_info_record): New.
	(target_save_record): New.
	(target_supports_delete_record): New.
	(target_delete_record): New.
	(target_record_is_replaying): New.
	(target_goto_record_begin): New.
	(target_goto_record_end): New.
	(target_goto_record): New.
	* record.h: Declare struct cmd_list_element.
	(record_cmdlist): New declaration.
	(set_record_cmdlist): New declaration.
	(show_record_cmdlist): New declaration.
	(info_record_cmdlist): New declaration.
	(cmd_record_goto): New declaration.
	* record.c: Remove unnecessary includes.
	Include inferior.h.
	(cmd_record_goto): Remove declaration.
	(record_cmdlist): Now extern. Initialize.
	(set_record_cmdlist): Now extern. Initialize.
	(show_record_cmdlist): Now extern. Initialize.
	(info_record_cmdlist): Now extern. Initialize.
	(find_record_target): New.
	(require_record_target): New.
	(cmd_record_start): Update.
	(cmd_record_delete): Remove target-specific code.
	Call target_delete_record.
	(cmd_record_stop): Unpush any record target.
	(set_record_insn_max_num): Move to record-full.c
	(set_record_command): Add comment.
	(show_record_command): Add comment.
	(info_record_command): Update comment.
	Remove target-specific code.
	Call the record target's to_info_record.
	(cmd_record_start): New.
	(cmd_record_goto): Now extern.
	Remove target-specific code.
	Call target_goto_begin,  target_goto_end, or target_goto.
	(_initialize_record): Move record target ops initialization to
	record-full.c.
	Change "record" command help text.
	Move "record restore", "record set", and "record show" commands to
	record-full.c.
	* Makefile.in (SFILES): Add record-full.c.
	(HFILES_NO_SRCDIR): Add record-full.h.
	(COMMON_OBS): Add record-full.o.
	* amd64-linux-tdep.c: Include record-full.h instead of record.h.
	* arm-tdep.c: Include record-full.h.
	* i386-linux-tdep.c: Include record-full.h instead of record.h.
	* i386-tdep.c: Include record-full.h.
	* infrun.c: Include record-full.h.
	* linux-record.c: Include record-full.h.
	* moxie-tdep.c: Include record-full.h.
	* record-full.c: Include record-full.h.
	Change module comment.
	(set_record_full_cmdlist): New.
	(show_record_full_cmdlist): New.
	(record_full_cmdlist): New.
	(record_goto_insn): New declaration.
	(record_save): New declaration.
	(record_check_insn_num): Change query string.
	(record_info): New.
	(record_delete): New.
	(record_is_replaying): New.
	(record_goto_entry): New.
	(record_goto_begin): New.
	(record_goto_end): New.
	(record_goto): New.
	(init_record_ops): Update.
	(init_record_core_ops): Update.
	(cmd_record_save): Rename to record_save. Remove target and arg checks.
	(cmd_record_start): New.
	(set_record_insn_max_num): Moved from record.c
	(set_record_full_command): New.
	(show_record_full_command): New.
	(_initialize_record_full): New.


---
 gdb/Makefile.in        |    5 +-
 gdb/amd64-linux-tdep.c |    2 +-
 gdb/arm-tdep.c         |    1 +
 gdb/i386-linux-tdep.c  |    2 +-
 gdb/i386-tdep.c        |    1 +
 gdb/infrun.c           |    1 +
 gdb/linux-record.c     |    1 +
 gdb/moxie-tdep.c       |    1 +
 gdb/record-full.c      |  319 +++++++++++++++++++++++++++++++++++++++++++++---
 gdb/record.c           |  288 +++++++++++++++-----------------------------
 gdb/record.h           |   11 ++
 gdb/target.c           |  129 +++++++++++++++++++
 gdb/target.h           |   44 +++++++
 13 files changed, 591 insertions(+), 214 deletions(-)

diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index e11e3d1..a36d576 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -753,7 +753,7 @@ 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 common/vec.c \
 	xml-tdesc.c xml-support.c \
 	inferior.c gdb_usleep.c \
-	record.c gcore.c \
+	record.c record-full.c gcore.c \
 	jit.c \
 	xml-syscall.c \
 	annotate.c common/signals.c copying.c dfp.c gdb.c inf-child.c \
@@ -829,6 +829,7 @@ dicos-tdep.h filesystem.h gcore.h gdb_wchar.h hppabsd-tdep.h \
 i386-darwin-tdep.h i386-nat.h linux-record.h moxie-tdep.h \
 osdata.h procfs.h python/py-event.h python/py-events.h python/py-stopevent.h \
 python/python-internal.h python/python.h ravenscar-thread.h record.h \
+record-full.h \
 solib-darwin.h solib-ia64-hpux.h solib-spu.h windows-nat.h xcoffread.h \
 gnulib/import/extra/snippet/arg-nonnull.h gnulib/import/extra/snippet/c++defs.h \
 gnulib/import/extra/snippet/warn-on-use.h \
@@ -926,7 +927,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \
 	prologue-value.o memory-map.o memrange.o \
 	xml-support.o xml-syscall.o xml-utils.o \
 	target-descriptions.o target-memory.o xml-tdesc.o xml-builtin.o \
-	inferior.o osdata.o gdb_usleep.o record.o gcore.o \
+	inferior.o osdata.o gdb_usleep.o record.o record-full.o gcore.o \
 	gdb_vecs.o jit.o progspace.o skip.o probe.o \
 	common-utils.o buffer.o ptid.o gdb-dlfcn.o common-agent.o \
 	format.o registry.o btrace.o
diff --git a/gdb/amd64-linux-tdep.c b/gdb/amd64-linux-tdep.c
index e262c19..4f383db 100644
--- a/gdb/amd64-linux-tdep.c
+++ b/gdb/amd64-linux-tdep.c
@@ -48,7 +48,7 @@
 /* The syscall's XML filename for i386.  */
 #define XML_SYSCALL_FILENAME_AMD64 "syscalls/amd64-linux.xml"
 
-#include "record.h"
+#include "record-full.h"
 #include "linux-record.h"
 
 /* Supported register note sections.  */
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index ead09d7..abe895c 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -56,6 +56,7 @@
 #include "vec.h"
 
 #include "record.h"
+#include "record-full.h"
 
 #include "features/arm-with-m.c"
 #include "features/arm-with-m-fpa-layout.c"
diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c
index 15a1247..f96fc81 100644
--- a/gdb/i386-linux-tdep.c
+++ b/gdb/i386-linux-tdep.c
@@ -44,7 +44,7 @@
 /* The syscall's XML filename for i386.  */
 #define XML_SYSCALL_FILENAME_I386 "syscalls/i386-linux.xml"
 
-#include "record.h"
+#include "record-full.h"
 #include "linux-record.h"
 #include <stdint.h>
 
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index 637c44d..a36a83d 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -52,6 +52,7 @@
 #include "i386-xstate.h"
 
 #include "record.h"
+#include "record-full.h"
 #include <stdint.h>
 
 #include "features/i386/i386.c"
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 1cf30fe..1e2addc 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -49,6 +49,7 @@
 #include "mi/mi-common.h"
 #include "event-top.h"
 #include "record.h"
+#include "record-full.h"
 #include "inline-frame.h"
 #include "jit.h"
 #include "tracepoint.h"
diff --git a/gdb/linux-record.c b/gdb/linux-record.c
index 5a9ec99..b8c7a4e 100644
--- a/gdb/linux-record.c
+++ b/gdb/linux-record.c
@@ -22,6 +22,7 @@
 #include "gdbtypes.h"
 #include "regcache.h"
 #include "record.h"
+#include "record-full.h"
 #include "linux-record.h"
 
 /* These macros are the values of the first argument of system call
diff --git a/gdb/moxie-tdep.c b/gdb/moxie-tdep.c
index 4b250f8..fc0f85c 100644
--- a/gdb/moxie-tdep.c
+++ b/gdb/moxie-tdep.c
@@ -37,6 +37,7 @@
 #include "trad-frame.h"
 #include "dis-asm.h"
 #include "record.h"
+#include "record-full.h"
 
 #include "gdb_assert.h"
 
diff --git a/gdb/record-full.c b/gdb/record-full.c
index ff22b95..1cbd724 100644
--- a/gdb/record-full.c
+++ b/gdb/record-full.c
@@ -28,6 +28,7 @@
 #include "gdbcore.h"
 #include "exec.h"
 #include "record.h"
+#include "record-full.h"
 #include "elf-bfd.h"
 #include "gcore.h"
 #include "event-loop.h"
@@ -37,7 +38,7 @@
 
 #include <signal.h>
 
-/* This module implements "target record", also known as "process
+/* This module implements "target record-full", also known as "process
    record and replay".  This target sits on top of a "normal" target
    (a target that "has execution"), and provides a record and replay
    functionality, including reverse debugging.
@@ -205,6 +206,13 @@ static ULONGEST record_insn_count;
 static struct target_ops record_ops;
 static struct target_ops record_core_ops;
 
+/* Command lists for "set/show record full".  */
+static struct cmd_list_element *set_record_full_cmdlist;
+static struct cmd_list_element *show_record_full_cmdlist;
+
+/* Command list for "record full".  */
+static struct cmd_list_element *record_full_cmdlist;
+
 /* 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,
@@ -234,6 +242,10 @@ static int (*record_beneath_to_stopped_data_address) (struct target_ops *,
 						      CORE_ADDR *);
 static void (*record_beneath_to_async) (void (*) (enum inferior_event_type, void *), void *);
 
+static void record_goto_insn (struct record_entry *entry,
+			      enum exec_direction_kind dir);
+static void record_save (char *recfilename);
+
 /* Alloc and free functions for record_reg, record_mem, and record_end 
    entries.  */
 
@@ -550,7 +562,7 @@ record_check_insn_num (int 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)?"));
+			    "full (record full stop-at-limit)?"));
 	      if (set_terminal)
 		target_terminal_inferior ();
 	      if (q)
@@ -1934,9 +1946,140 @@ record_execution_direction (void)
 }
 
 static void
+record_info (void)
+{
+  struct record_entry *p;
+
+  if (RECORD_IS_REPLAY)
+    printf_filtered (_("Replay mode:\n"));
+  else
+    printf_filtered (_("Record mode:\n"));
+
+  /* Find entry for first actual instruction in the log.  */
+  for (p = record_first.next;
+       p != NULL && p->type != record_end;
+       p = p->next)
+    ;
+
+  /* Do we have a log at all?  */
+  if (p != NULL && p->type == record_end)
+    {
+      /* Display instruction number for first instruction in the log.  */
+      printf_filtered (_("Lowest recorded instruction number is %s.\n"),
+		       pulongest (p->u.end.insn_num));
+
+      /* If in replay mode, display where we are in the log.  */
+      if (RECORD_IS_REPLAY)
+	printf_filtered (_("Current instruction number is %s.\n"),
+			 pulongest (record_list->u.end.insn_num));
+
+      /* Display instruction number for last instruction in the log.  */
+      printf_filtered (_("Highest recorded instruction number is %s.\n"),
+		       pulongest (record_insn_count));
+
+      /* Display log count.  */
+      printf_filtered (_("Log contains %d instructions.\n"),
+		       record_insn_num);
+    }
+  else
+    printf_filtered (_("No instructions have been logged.\n"));
+
+  /* Display max log size.  */
+  printf_filtered (_("Max logged instructions is %d.\n"),
+		   record_insn_max_num);
+}
+
+/* The "to_record_delete" target method.  */
+
+static void
+record_delete (void)
+{
+  record_list_release_following (record_list);
+}
+
+/* The "to_record_is_replaying" target method.  */
+
+static int
+record_is_replaying (void)
+{
+  return RECORD_IS_REPLAY;
+}
+
+/* Go to a specific entry.  */
+
+static void
+record_goto_entry (struct record_entry *p)
+{
+  if (p == NULL)
+    error (_("Target insn not found."));
+  else if (p == record_list)
+    error (_("Already at target insn."));
+  else if (p->u.end.insn_num > record_list->u.end.insn_num)
+    {
+      printf_filtered (_("Go forward to insn number %s\n"),
+		       pulongest (p->u.end.insn_num));
+      record_goto_insn (p, EXEC_FORWARD);
+    }
+  else
+    {
+      printf_filtered (_("Go backward to insn number %s\n"),
+		       pulongest (p->u.end.insn_num));
+      record_goto_insn (p, EXEC_REVERSE);
+    }
+
+  registers_changed ();
+  reinit_frame_cache ();
+  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
+}
+
+/* The "to_goto_record_begin" target method.  */
+
+static void
+record_goto_begin (void)
+{
+  struct record_entry *p = NULL;
+
+  for (p = &record_first; p != NULL; p = p->next)
+    if (p->type == record_end)
+      break;
+
+  record_goto_entry (p);
+}
+
+/* The "to_goto_record_end" target method.  */
+
+static void
+record_goto_end (void)
+{
+  struct record_entry *p = NULL;
+
+  for (p = record_list; p->next != NULL; p = p->next)
+    ;
+  for (; p!= NULL; p = p->prev)
+    if (p->type == record_end)
+      break;
+
+  record_goto_entry (p);
+}
+
+/* The "to_goto_record" target method.  */
+
+static void
+record_goto (ULONGEST target_insn)
+{
+  struct record_entry *p = NULL;
+
+  for (p = &record_first; p != NULL; p = p->next)
+    if (p->type == record_end && p->u.end.insn_num == target_insn)
+      break;
+
+  record_goto_entry (p);
+}
+
+static void
 init_record_ops (void)
 {
-  record_ops.to_shortname = "record";
+  record_ops.to_shortname = "record-full";
   record_ops.to_longname = "Process record and replay target";
   record_ops.to_doc =
     "Log program while executing and replay execution from log.";
@@ -1964,6 +2107,13 @@ init_record_ops (void)
   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_info_record = record_info;
+  record_ops.to_save_record = record_save;
+  record_ops.to_delete_record = record_delete;
+  record_ops.to_record_is_replaying = record_is_replaying;
+  record_ops.to_goto_record_begin = record_goto_begin;
+  record_ops.to_goto_record_end = record_goto_end;
+  record_ops.to_goto_record = record_goto;
   record_ops.to_magic = OPS_MAGIC;
 }
 
@@ -2189,6 +2339,12 @@ init_record_core_ops (void)
   record_core_ops.to_can_async_p = record_can_async_p;
   record_core_ops.to_is_async_p = record_is_async_p;
   record_core_ops.to_execution_direction = record_execution_direction;
+  record_core_ops.to_info_record = record_info;
+  record_core_ops.to_delete_record = record_delete;
+  record_core_ops.to_record_is_replaying = record_is_replaying;
+  record_core_ops.to_goto_record_begin = record_goto_begin;
+  record_core_ops.to_goto_record_end = record_goto_end;
+  record_core_ops.to_goto_record = record_goto;
   record_core_ops.to_magic = OPS_MAGIC;
 }
 
@@ -2493,9 +2649,8 @@ record_save_cleanups (void *data)
    format, with an extra section for our data.  */
 
 static void
-cmd_record_save (char *args, int from_tty)
+record_save (char *recfilename)
 {
-  char *recfilename, recfilename_buffer[40];
   struct record_entry *cur_record_list;
   uint32_t magic;
   struct regcache *regcache;
@@ -2507,20 +2662,6 @@ cmd_record_save (char *args, int from_tty)
   asection *osec = NULL;
   int bfd_offset = 0;
 
-  if (strcmp (current_target.to_shortname, "record") != 0)
-    error (_("This command can only be used with target 'record'.\n"
-	     "Use 'target record' first.\n"));
-
-  if (args && *args)
-    recfilename = args;
-  else
-    {
-      /* Default recfile name is "gdb_record.PID".  */
-      snprintf (recfilename_buffer, sizeof (recfilename_buffer),
-                "gdb_record.%d", PIDGET (inferior_ptid));
-      recfilename = recfilename_buffer;
-    }
-
   /* Open the save file.  */
   if (record_debug)
     fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
@@ -2736,3 +2877,143 @@ record_goto_insn (struct record_entry *entry,
     } while (record_list != entry);
   do_cleanups (set_cleanups);
 }
+
+/* Alias for "target record-full".  */
+
+static void
+cmd_record_start (char *args, int from_tty)
+{
+  execute_command ("target record-full", from_tty);
+}
+
+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)
+    {
+      /* Count down record_insn_num while releasing records from list.  */
+      while (record_insn_num > record_insn_max_num)
+       {
+         record_list_release_first ();
+         record_insn_num--;
+       }
+    }
+}
+
+/* The "set record full" command.  */
+
+static void
+set_record_full_command (char *args, int from_tty)
+{
+  printf_unfiltered (_("\"set record full\" must be followed "
+		       "by an apporpriate subcommand.\n"));
+  help_list (set_record_full_cmdlist, "set record full ", all_commands,
+	     gdb_stdout);
+}
+
+/* The "show record full" command.  */
+
+static void
+show_record_full_command (char *args, int from_tty)
+{
+  cmd_show_list (show_record_full_cmdlist, from_tty, "");
+}
+
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern initialize_file_ftype _initialize_record_full;
+
+void
+_initialize_record_full (void)
+{
+  struct cmd_list_element *c;
+
+  /* Init record_first.  */
+  record_first.prev = NULL;
+  record_first.next = NULL;
+  record_first.type = record_end;
+
+  init_record_ops ();
+  add_target (&record_ops);
+  add_deprecated_target_alias (&record_ops, "record");
+  init_record_core_ops ();
+  add_target (&record_core_ops);
+
+  add_prefix_cmd ("full", class_obscure, cmd_record_start,
+		  _("Start full execution recording."), &record_full_cmdlist,
+		  "record full ", 0, &record_cmdlist);
+
+  c = add_cmd ("restore", class_obscure, cmd_record_restore,
+	       _("Restore the execution log from a file.\n\
+Argument is filename.  File must be created with 'record save'."),
+	       &record_full_cmdlist);
+  set_cmd_completer (c, filename_completer);
+
+  /* Deprecate the old version without "full" prefix.  */
+  c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
+		     &record_cmdlist);
+  set_cmd_completer (c, filename_completer);
+  deprecate_cmd (c, "record full restore");
+
+  add_prefix_cmd ("full", class_support, set_record_full_command,
+		  _("Set record options"), &set_record_full_cmdlist,
+		  "set record full ", 0, &set_record_cmdlist);
+
+  add_prefix_cmd ("full", class_support, show_record_full_command,
+		  _("Show record options"), &show_record_full_cmdlist,
+		  "show record full ", 0, &show_record_cmdlist);
+
+  /* Record instructions number limit command.  */
+  add_setshow_boolean_cmd ("stop-at-limit", no_class,
+			   &record_stop_at_limit, _("\
+Set whether record/replay stops when record/replay buffer becomes full."), _("\
+Show whether record/replay stops when record/replay buffer becomes full."),
+			   _("Default is ON.\n\
+When ON, if the record/replay buffer becomes full, ask user what to do.\n\
+When OFF, if the record/replay buffer becomes full,\n\
+delete the oldest recorded instruction to make room for each new one."),
+			   NULL, NULL,
+			   &set_record_full_cmdlist, &show_record_full_cmdlist);
+
+  c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
+		     &set_record_cmdlist);
+  deprecate_cmd (c, "set record full stop-at-limit");
+
+  c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
+		     &show_record_cmdlist);
+  deprecate_cmd (c, "show record full stop-at-limit");
+
+  add_setshow_uinteger_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 is 200000."),
+			    set_record_insn_max_num,
+			    NULL, &set_record_full_cmdlist,
+			    &show_record_full_cmdlist);
+
+  c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
+		     &set_record_cmdlist);
+  deprecate_cmd (c, "set record full insn-number-max");
+
+  c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
+		     &show_record_cmdlist);
+  deprecate_cmd (c, "show record full insn-number-max");
+
+  add_setshow_boolean_cmd ("memory-query", no_class, &record_memory_query, _("\
+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_full_cmdlist, &show_record_full_cmdlist);
+
+  c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
+		     &set_record_cmdlist);
+  deprecate_cmd (c, "set record full memory-query");
+
+  c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
+		     &show_record_cmdlist);
+  deprecate_cmd (c, "show record full memory-query");
+}
diff --git a/gdb/record.c b/gdb/record.c
index c06bcae..8b44717 100644
--- a/gdb/record.c
+++ b/gdb/record.c
@@ -19,29 +19,48 @@
 
 #include "defs.h"
 #include "gdbcmd.h"
-#include "regcache.h"
-#include "gdbthread.h"
-#include "event-top.h"
-#include "exceptions.h"
 #include "completer.h"
-#include "arch-utils.h"
-#include "gdbcore.h"
-#include "exec.h"
 #include "record.h"
-#include "elf-bfd.h"
-#include "gcore.h"
-#include "event-loop.h"
-#include "inf-loop.h"
-#include "gdb_bfd.h"
 #include "observer.h"
-
-#include <signal.h>
+#include "inferior.h"
+#include "common/common-utils.h"
 
 /* This is the debug switch for process record.  */
 unsigned int record_debug = 0;
 
-/* The implementation of the command "record goto".  */
-static void cmd_record_goto (char *, int);
+struct cmd_list_element *record_cmdlist = NULL;
+struct cmd_list_element *set_record_cmdlist = NULL;
+struct cmd_list_element *show_record_cmdlist = NULL;
+struct cmd_list_element *info_record_cmdlist = NULL;
+
+/* Find the record target in the target stack.  */
+
+static struct target_ops *
+find_record_target (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_stratum == record_stratum)
+      return t;
+
+  return NULL;
+}
+
+/* Check that recording is active.  Throw an error, if it isn't.  */
+
+static struct target_ops *
+require_record_target (void)
+{
+  struct target_ops *t;
+
+  t = find_record_target ();
+  if (t == NULL)
+    error (_("No record target is currently active.\n"
+	     "Use one of the \"target record-<tab><tab>\" commands first."));
+
+  return t;
+}
 
 /* See record.h.  */
 
@@ -74,7 +93,7 @@ show_record_debug (struct ui_file *file, int from_tty,
 static void
 cmd_record_start (char *args, int from_tty)
 {
-  execute_command ("target record", from_tty);
+  execute_command ("target record-full", from_tty);
 }
 
 /* Truncate the record log from the present point
@@ -83,21 +102,25 @@ cmd_record_start (char *args, int from_tty)
 static void
 cmd_record_delete (char *args, int from_tty)
 {
-  if (current_target.to_stratum == record_stratum)
+  require_record_target ();
+
+  if (!target_record_is_replaying ())
     {
-      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_following (record_list);
-	}
-      else
-	  printf_unfiltered (_("Already at end of record list.\n"));
+      printf_unfiltered (_("Already at end of record list.\n"));
+      return;
+    }
 
+  if (!target_supports_delete_record ())
+    {
+      printf_unfiltered (_("The current record target does not support "
+			   "this operation.\n"));
+      return;
     }
-  else
-    printf_unfiltered (_("Process record is not started.\n"));
+
+  if (!from_tty || query (_("Delete the log from this point forward "
+			    "and begin to record the running message "
+			    "at current PC?")))
+    target_delete_record ();
 }
 
 /* Implement the "stoprecord" or "record stop" command.  */
@@ -105,36 +128,18 @@ cmd_record_delete (char *args, int from_tty)
 static void
 cmd_record_stop (char *args, int from_tty)
 {
-  if (current_target.to_stratum == record_stratum)
-    {
-      unpush_target (&record_ops);
-      printf_unfiltered (_("Process record is stopped and all execution "
-                           "logs are deleted.\n"));
+  struct target_ops *t;
 
-      observer_notify_record_changed (current_inferior (), 0);
-    }
-  else
-    printf_unfiltered (_("Process record is not started.\n"));
-}
+  t = require_record_target ();
+  unpush_target (t);
 
-/* Set upper limit of record log size.  */
+  printf_unfiltered (_("Process record is stopped and all execution "
+		       "logs are deleted.\n"));
 
-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)
-    {
-      /* Count down record_insn_num while releasing records from list.  */
-      while (record_insn_num > record_insn_max_num)
-	{
-	  record_list_release_first ();
-	  record_insn_num--;
-	}
-    }
+  observer_notify_record_changed (current_inferior (), 0);
 }
 
-static struct cmd_list_element *record_cmdlist, *set_record_cmdlist,
-			       *show_record_cmdlist, *info_record_cmdlist;
+/* The "set record" command.  */
 
 static void
 set_record_command (char *args, int from_tty)
@@ -144,65 +149,53 @@ set_record_command (char *args, int from_tty)
   help_list (set_record_cmdlist, "set record ", all_commands, gdb_stdout);
 }
 
+/* The "show record" command.  */
+
 static void
 show_record_command (char *args, int from_tty)
 {
   cmd_show_list (show_record_cmdlist, from_tty, "");
 }
 
-/* Display some statistics about the execution log.  */
+/* The "info record" command.  */
 
 static void
 info_record_command (char *args, int from_tty)
 {
-  struct record_entry *p;
+  struct target_ops *t;
 
-  if (current_target.to_stratum == record_stratum)
+  t = find_record_target ();
+  if (t == NULL)
     {
-      if (RECORD_IS_REPLAY)
-	printf_filtered (_("Replay mode:\n"));
-      else
-	printf_filtered (_("Record mode:\n"));
-
-      /* Find entry for first actual instruction in the log.  */
-      for (p = record_first.next;
-	   p != NULL && p->type != record_end;
-	   p = p->next)
-	;
-
-      /* Do we have a log at all?  */
-      if (p != NULL && p->type == record_end)
-	{
-	  /* Display instruction number for first instruction in the log.  */
-	  printf_filtered (_("Lowest recorded instruction number is %s.\n"),
-			   pulongest (p->u.end.insn_num));
-
-	  /* If in replay mode, display where we are in the log.  */
-	  if (RECORD_IS_REPLAY)
-	    printf_filtered (_("Current instruction number is %s.\n"),
-			     pulongest (record_list->u.end.insn_num));
-
-	  /* Display instruction number for last instruction in the log.  */
-	  printf_filtered (_("Highest recorded instruction number is %s.\n"), 
-			   pulongest (record_insn_count));
-
-	  /* Display log count.  */
-	  printf_filtered (_("Log contains %d instructions.\n"), 
-			   record_insn_num);
-	}
-      else
-	{
-	  printf_filtered (_("No instructions have been logged.\n"));
-	}
+      printf_filtered (_("No record target is currently active.\n"));
+      return;
     }
+
+  printf_filtered (_("Active record target: %s\n"), t->to_shortname);
+  if (t->to_info_record != NULL)
+    t->to_info_record ();
+}
+
+/* The "record save" command.  */
+
+static void
+cmd_record_save (char *args, int from_tty)
+{
+  char *recfilename, recfilename_buffer[40];
+
+  require_record_target ();
+
+  if (args != NULL && *args != 0)
+    recfilename = args;
   else
     {
-      printf_filtered (_("target record is not active.\n"));
+      /* Default recfile name is "gdb_record.PID".  */
+      xsnprintf (recfilename_buffer, sizeof (recfilename_buffer),
+                "gdb_record.%d", PIDGET (inferior_ptid));
+      recfilename = recfilename_buffer;
     }
 
-  /* Display max log size.  */
-  printf_filtered (_("Max logged instructions is %d.\n"),
-		   record_insn_max_num);
+  target_save_record (recfilename);
 }
 
 /* "record goto" command.  Argument is an instruction number,
@@ -210,65 +203,26 @@ info_record_command (char *args, int from_tty)
 
    Rewinds the recording (forward or backward) to the given instruction.  */
 
-static void
+void
 cmd_record_goto (char *arg, int from_tty)
 {
-  struct record_entry *p = NULL;
-  ULONGEST target_insn = 0;
+  require_record_target ();
 
   if (arg == NULL || *arg == '\0')
     error (_("Command requires an argument (insn number to go to)."));
 
   if (strncmp (arg, "start", strlen ("start")) == 0
       || strncmp (arg, "begin", strlen ("begin")) == 0)
-    {
-      /* Special case.  Find first insn.  */
-      for (p = &record_first; p != NULL; p = p->next)
-	if (p->type == record_end)
-	  break;
-      if (p)
-	target_insn = p->u.end.insn_num;
-    }
+    target_goto_record_begin ();
   else if (strncmp (arg, "end", strlen ("end")) == 0)
-    {
-      /* Special case.  Find last insn.  */
-      for (p = record_list; p->next != NULL; p = p->next)
-	;
-      for (; p!= NULL; p = p->prev)
-	if (p->type == record_end)
-	  break;
-      if (p)
-	target_insn = p->u.end.insn_num;
-    }
+    target_goto_record_end ();
   else
     {
-      /* General case.  Find designated insn.  */
-      target_insn = parse_and_eval_long (arg);
+      ULONGEST insn;
 
-      for (p = &record_first; p != NULL; p = p->next)
-	if (p->type == record_end && p->u.end.insn_num == target_insn)
-	  break;
+      insn = parse_and_eval_long (arg);
+      target_goto_record (insn);
     }
-
-  if (p == NULL)
-    error (_("Target insn '%s' not found."), arg);
-  else if (p == record_list)
-    error (_("Already at insn '%s'."), arg);
-  else if (p->u.end.insn_num > record_list->u.end.insn_num)
-    {
-      printf_filtered (_("Go forward to insn number %s\n"),
-		       pulongest (target_insn));
-      record_goto_insn (p, EXEC_FORWARD);
-    }
-  else
-    {
-      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.  */
@@ -279,16 +233,6 @@ _initialize_record (void)
 {
   struct cmd_list_element *c;
 
-  /* Init record_first.  */
-  record_first.prev = NULL;
-  record_first.next = NULL;
-  record_first.type = record_end;
-
-  init_record_ops ();
-  add_target (&record_ops);
-  init_record_core_ops ();
-  add_target (&record_core_ops);
-
   add_setshow_zuinteger_cmd ("record", no_class, &record_debug,
 			     _("Set debugging of record/replay feature."),
 			     _("Show debugging of record/replay feature."),
@@ -298,7 +242,7 @@ _initialize_record (void)
 			     &showdebuglist);
 
   c = add_prefix_cmd ("record", class_obscure, cmd_record_start,
-		      _("Abbreviated form of \"target record\" command."),
+		      _("Start recording."),
 		      &record_cmdlist, "record ", 0, &cmdlist);
   set_cmd_completer (c, filename_completer);
 
@@ -323,12 +267,6 @@ Default filename is 'gdb_record.<process_id>'."),
 	       &record_cmdlist);
   set_cmd_completer (c, filename_completer);
 
-  c = add_cmd ("restore", class_obscure, cmd_record_restore,
-	       _("Restore the execution log from a file.\n\
-Argument is filename.  File must be created with 'record save'."),
-	       &record_cmdlist);
-  set_cmd_completer (c, filename_completer);
-
   add_cmd ("delete", class_obscure, cmd_record_delete,
 	   _("Delete the rest of execution log and start recording it anew."),
            &record_cmdlist);
@@ -340,40 +278,8 @@ Argument is filename.  File must be created with 'record save'."),
            &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 stops when record/replay buffer becomes full."), _("\
-Show whether record/replay stops when record/replay buffer becomes full."),
-			   _("Default is ON.\n\
-When ON, if the record/replay buffer becomes full, ask user what to do.\n\
-When OFF, if the record/replay buffer becomes full,\n\
-delete the oldest recorded instruction to make room for each new one."),
-			   NULL, NULL,
-			   &set_record_cmdlist, &show_record_cmdlist);
-  add_setshow_uinteger_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 is 200000."),
-			    set_record_insn_max_num,
-			    NULL, &set_record_cmdlist, &show_record_cmdlist);
-
   add_cmd ("goto", class_obscure, cmd_record_goto, _("\
 Restore the program to its state at instruction number N.\n\
 Argument is instruction number, as shown by 'info record'."),
 	   &record_cmdlist);
-
-  add_setshow_boolean_cmd ("memory-query", no_class,
-			   &record_memory_query, _("\
-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);
-
 }
diff --git a/gdb/record.h b/gdb/record.h
index 88e59e2..b428eaf 100644
--- a/gdb/record.h
+++ b/gdb/record.h
@@ -20,14 +20,25 @@
 #ifndef _RECORD_H_
 #define _RECORD_H_
 
+struct cmd_list_element;
+
 #define RECORD_IS_USED	(current_target.to_stratum == record_stratum)
 
 extern unsigned int record_debug;
 
+/* Allow record targets to add their own sub-commands.  */
+extern struct cmd_list_element *record_cmdlist;
+extern struct cmd_list_element *set_record_cmdlist;
+extern struct cmd_list_element *show_record_cmdlist;
+extern struct cmd_list_element *info_record_cmdlist;
+
 /* Wrapper for target_read_memory that prints a debug message if
    reading memory fails.  */
 extern int record_read_memory (struct gdbarch *gdbarch,
 			       CORE_ADDR memaddr, gdb_byte *myaddr,
 			       ssize_t len);
 
+/* The "record goto" command.  */
+extern void cmd_record_goto (char *arg, int from_tty);
+
 #endif /* _RECORD_H_ */
diff --git a/gdb/target.c b/gdb/target.c
index 3e4ba83..868ff63 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -4230,6 +4230,135 @@ target_read_btrace (struct btrace_target_info *btinfo)
   return NULL;
 }
 
+/* See target.h.  */
+
+void
+target_info_record (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_info_record != NULL)
+      {
+	t->to_info_record ();
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+void
+target_save_record (char *filename)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_save_record != NULL)
+      {
+	t->to_save_record (filename);
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+int
+target_supports_delete_record (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_delete_record != NULL)
+      return 1;
+
+  return 0;
+}
+
+/* See target.h.  */
+
+void
+target_delete_record (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_delete_record != NULL)
+      {
+	t->to_delete_record ();
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+int
+target_record_is_replaying (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_record_is_replaying != NULL)
+	return t->to_record_is_replaying ();
+
+  return 0;
+}
+
+/* See target.h.  */
+
+void
+target_goto_record_begin (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_goto_record_begin != NULL)
+      {
+	t->to_goto_record_begin ();
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+void
+target_goto_record_end (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_goto_record_end != NULL)
+      {
+	t->to_goto_record_end ();
+	return;
+      }
+
+  tcomplain ();
+}
+
+/* See target.h.  */
+
+void
+target_goto_record (ULONGEST insn)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_goto_record != NULL)
+      {
+	t->to_goto_record (insn);
+	return;
+      }
+
+  tcomplain ();
+}
 
 static void
 debug_to_prepare_to_store (struct regcache *regcache)
diff --git a/gdb/target.h b/gdb/target.h
index 1d73336..d416193 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -876,6 +876,27 @@ struct target_ops
     /* Read branch trace data.  */
     VEC (btrace_block_s) *(*to_read_btrace) (struct btrace_target_info *);
 
+    /* Print information about the recording.  */
+    void (*to_info_record) (void);
+
+    /* Save the recorded execution trace into a file.  */
+    void (*to_save_record) (char *filename);
+
+    /* Delete the recorded execution trace from the current position onwards.  */
+    void (*to_delete_record) (void);
+
+    /* Query if the record target is currently replaying.  */
+    int (*to_record_is_replaying) (void);
+
+    /* Go to the begin of the execution trace.  */
+    void (*to_goto_record_begin) (void);
+
+    /* Go to the end of the execution trace.  */
+    void (*to_goto_record_end) (void);
+
+    /* Go to a specific location in the recorded execution trace.  */
+    void (*to_goto_record) (ULONGEST insn);
+
     int to_magic;
     /* Need sub-structure for target machine related rather than comm related?
      */
@@ -1938,5 +1959,28 @@ extern int target_btrace_has_changed (struct btrace_target_info *btinfo);
    Returns a vector of branch trace blocks with the latest entry at index 0.  */
 extern VEC (btrace_block_s) *target_read_btrace (struct btrace_target_info *);
 
+/* See to_info_record in struct target_ops.  */
+extern void target_info_record (void);
+
+/* See to_save_record in struct target_ops.  */
+extern void target_save_record (char *filename);
+
+/* Query if the target supports deleting the execution log.  */
+extern int target_supports_delete_record (void);
+
+/* See to_delete_record in struct target_ops.  */
+extern void target_delete_record (void);
+
+/* See to_record_is_replaying in struct target_ops.  */
+extern int target_record_is_replaying (void);
+
+/* See to_goto_record_begin in struct target_ops.  */
+extern void target_goto_record_begin (void);
+
+/* See to_goto_record_end in struct target_ops.  */
+extern void target_goto_record_end (void);
+
+/* See to_goto_record in struct target_ops.  */
+extern void target_goto_record (ULONGEST insn);
 
 #endif /* !defined (TARGET_H) */
-- 
1.7.1

RE: [rfc 0/8] refactor record

[Metzger, Markus T]

> -----Original Message-----
> From: Metzger, Markus T
> Sent: Thursday, February 14, 2013 5:29 PM

> Here's an updated version of the record.c refactoring incorporating your
> comments and adding two new commands I plan to implement for record-btrace.
> 
> The series will not apply to the current master since i'm not resending some
> already approved patches.
> 
> I tried pushing the entire series into archer but I seem to lack permissions.

I pushed the entire btrace series plus a first draft a record-btrace target into
archer-mmetzger-btrace.

The record-btrace target implements the "record disassemble" and
"record backtrace" commands that had been added by this rfc patch series.

I will rebase the archer branch when there is a new version available.

Regards,
Markus.

Intel GmbH
Dornacher Strasse 1
85622 Feldkirchen/Muenchen, Deutschland
Sitz der Gesellschaft: Feldkirchen bei Muenchen
Geschaeftsfuehrer: Christian Lamprechter, Hannes Schwaderer, Douglas Lusk
Registergericht: Muenchen HRB 47456
Ust.-IdNr./VAT Registration No.: DE129385895
Citibank Frankfurt a.M. (BLZ 502 109 00) 600119052

Re: [rfc 0/8] refactor record

[Jan Kratochvil]

On Thu, 14 Feb 2013 17:29:04 +0100, markus.t.metzger@intel.com wrote:
> Markus Metzger (8):
>   record: make it build again
>   record-full.c: rename record_ in record_full_.
>   record-full.h: rename record_ into record_full_
>   record: default target methods.
>   record: add "record disassemble" command
>   record disas: omit function names by default
>   record: add "record backtrace" command
>   record: add "record list" command

OK for this series, I haven't found there anything.


Just it needs some rebase of the btrace backend which IIUC you are working on.

The renaming can be vary brief, like:

	(record_insn_num): Rename to ...
	(record_full_insn_num): ... here.  All users updated.


Thanks,
Jan