Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / i386-tdep.c
index 549297e..61ccc3e 100644 (file)
@@ -1,6 +1,6 @@
 /* Intel 386 target-dependent stuff.
 
-   Copyright (C) 1988-2012 Free Software Foundation, Inc.
+   Copyright (C) 1988-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -52,6 +52,7 @@
 #include "i386-xstate.h"
 
 #include "record.h"
+#include "record-full.h"
 #include <stdint.h>
 
 #include "features/i386/i386.c"
 #include "ax.h"
 #include "ax-gdb.h"
 
+#include "stap-probe.h"
+#include "user-regs.h"
+#include "cli/cli-utils.h"
+#include "expression.h"
+#include "parser-defs.h"
+#include <ctype.h>
+
 /* Register names.  */
 
 static const char *i386_register_names[] =
@@ -376,7 +384,7 @@ i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg)
    its legitimate values.  */
 static const char att_flavor[] = "att";
 static const char intel_flavor[] = "intel";
-static const char *valid_flavors[] =
+static const char *const valid_flavors[] =
 {
   att_flavor,
   intel_flavor,
@@ -521,7 +529,12 @@ i386_call_p (const gdb_byte *insn)
 static int
 i386_syscall_p (const gdb_byte *insn, int *lengthp)
 {
-  if (insn[0] == 0xcd)
+  /* Is it 'int $0x80'?  */
+  if ((insn[0] == 0xcd && insn[1] == 0x80)
+      /* Or is it 'sysenter'?  */
+      || (insn[0] == 0x0f && insn[1] == 0x34)
+      /* Or is it 'syscall'?  */
+      || (insn[0] == 0x0f && insn[1] == 0x05))
     {
       *lengthp = 2;
       return 1;
@@ -738,7 +751,7 @@ i386_relocate_instruction (struct gdbarch *gdbarch,
       /* Where "ret" in the original code will return to.  */
       ret_addr = oldloc + insn_length;
       push_buf[0] = 0x68; /* pushq $...  */
-      memcpy (&push_buf[1], &ret_addr, 4);
+      store_unsigned_integer (&push_buf[1], 4, byte_order, ret_addr);
       /* Push the push.  */
       append_insns (to, 5, push_buf);
 
@@ -1185,7 +1198,6 @@ i386_match_insn_block (CORE_ADDR pc, struct i386_insn *insn_patterns)
 {
   CORE_ADDR current_pc;
   int ix, i;
-  gdb_byte op;
   struct i386_insn *insn;
 
   insn = i386_match_insn (pc, insn_patterns);
@@ -1377,18 +1389,40 @@ i386_analyze_frame_setup (struct gdbarch *gdbarch,
       if (target_read_memory (pc + skip, &op, 1))
        return pc + skip;
 
-      /* Check for `movl %esp, %ebp' -- can be written in two ways.  */
+      /* The i386 prologue looks like
+
+        push   %ebp
+        mov    %esp,%ebp
+        sub    $0x10,%esp
+
+        and a different prologue can be generated for atom.
+
+        push   %ebp
+        lea    (%esp),%ebp
+        lea    -0x10(%esp),%esp
+
+        We handle both of them here.  */
+
       switch (op)
        {
+         /* Check for `movl %esp, %ebp' -- can be written in two ways.  */
        case 0x8b:
          if (read_memory_unsigned_integer (pc + skip + 1, 1, byte_order)
              != 0xec)
            return pc;
+         pc += (skip + 2);
          break;
        case 0x89:
          if (read_memory_unsigned_integer (pc + skip + 1, 1, byte_order)
              != 0xe5)
            return pc;
+         pc += (skip + 2);
+         break;
+       case 0x8d: /* Check for 'lea (%ebp), %ebp'.  */
+         if (read_memory_unsigned_integer (pc + skip + 1, 2, byte_order)
+             != 0x242c)
+           return pc;
+         pc += (skip + 3);
          break;
        default:
          return pc;
@@ -1399,7 +1433,6 @@ i386_analyze_frame_setup (struct gdbarch *gdbarch,
         necessary.  We also now commit to skipping the special
         instructions mentioned before.  */
       cache->locals = 0;
-      pc += (skip + 2);
 
       /* If that's all, return now.  */
       if (limit <= pc)
@@ -1408,6 +1441,8 @@ i386_analyze_frame_setup (struct gdbarch *gdbarch,
       /* Check for stack adjustment 
 
            subl $XXX, %esp
+        or
+           lea -XXX(%esp),%esp
 
         NOTE: You can't subtract a 16-bit immediate from a 32-bit
         reg, so we don't have to worry about a data16 prefix.  */
@@ -1436,9 +1471,18 @@ i386_analyze_frame_setup (struct gdbarch *gdbarch,
          cache->locals = read_memory_integer (pc + 2, 4, byte_order);
          return pc + 6;
        }
+      else if (op == 0x8d)
+       {
+         /* The ModR/M byte is 0x64.  */
+         if (read_memory_unsigned_integer (pc + 1, 1, byte_order) != 0x64)
+           return pc;
+         /* 'lea' with 8-bit displacement.  */
+         cache->locals = -1 * read_memory_integer (pc + 3, 1, byte_order);
+         return pc + 4;
+       }
       else
        {
-         /* Some instruction other than `subl'.  */
+         /* Some instruction other than `subl' nor 'lea'.  */
          return pc;
        }
     }
@@ -1539,7 +1583,23 @@ i386_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
   CORE_ADDR pc;
   gdb_byte op;
   int i;
+  CORE_ADDR func_addr;
 
+  if (find_pc_partial_function (start_pc, NULL, &func_addr, NULL))
+    {
+      CORE_ADDR post_prologue_pc
+       = skip_prologue_using_sal (gdbarch, func_addr);
+      struct symtab *s = find_pc_symtab (func_addr);
+
+      /* Clang always emits a line note before the prologue and another
+        one after.  We trust clang to emit usable line notes.  */
+      if (post_prologue_pc
+         && (s != NULL
+             && s->producer != NULL
+             && strncmp (s->producer, "clang ", sizeof ("clang ") - 1) == 0))
+        return max (start_pc, post_prologue_pc);
+    }
   cache.locals = -1;
   pc = i386_analyze_prologue (gdbarch, start_pc, 0xffffffff, &cache);
   if (cache.locals < 0)
@@ -1740,7 +1800,8 @@ i386_frame_cache_1 (struct frame_info *this_frame,
       /* Saved stack pointer has been saved (but the SAVED_SP_REG
         register may be unavailable).  */
       if (cache->saved_sp == 0
-         && frame_register_read (this_frame, cache->saved_sp_reg, buf))
+         && deprecated_frame_register_read (this_frame,
+                                            cache->saved_sp_reg, buf))
        cache->saved_sp = extract_unsigned_integer (buf, 4, byte_order);
     }
   /* Now that we have the base address for the stack frame we can
@@ -2036,7 +2097,7 @@ static int
 i386_in_stack_tramp_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   gdb_byte insn;
-  char *name;
+  const char *name;
 
   /* A stack trampoline is detected if no name is associated
     to the current pc and if it points inside a trampoline
@@ -2321,6 +2382,22 @@ i386_16_byte_align_p (struct type *type)
   return 0;
 }
 
+/* Implementation for set_gdbarch_push_dummy_code.  */
+
+static CORE_ADDR
+i386_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr,
+                     struct value **args, int nargs, struct type *value_type,
+                     CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
+                     struct regcache *regcache)
+{
+  /* Use 0xcc breakpoint - 1 byte.  */
+  *bp_addr = sp - 1;
+  *real_pc = funaddr;
+
+  /* Keep the stack aligned.  */
+  return sp - 16;
+}
+
 static CORE_ADDR
 i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
@@ -2340,7 +2417,6 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   for (write_pass = 0; write_pass < 2; write_pass++)
     {
       int args_space_used = 0;
-      int have_16_byte_aligned_arg = 0;
 
       if (struct_return)
        {
@@ -2378,19 +2454,20 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
          else
            {
              if (i386_16_byte_align_p (value_enclosing_type (args[i])))
-               {
-                 args_space = align_up (args_space, 16);
-                 have_16_byte_aligned_arg = 1;
-               }
+               args_space = align_up (args_space, 16);
              args_space += align_up (len, 4);
            }
        }
 
       if (!write_pass)
        {
-         if (have_16_byte_aligned_arg)
-           args_space = align_up (args_space, 16);
          sp -= args_space;
+
+         /* The original System V ABI only requires word alignment,
+            but modern incarnations need 16-byte alignment in order
+            to support SSE.  Since wasting a few bytes here isn't
+            harmful we unconditionally enforce 16-byte alignment.  */
+         sp &= ~0xf;
        }
     }
 
@@ -2545,7 +2622,7 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
 static const char default_struct_convention[] = "default";
 static const char pcc_struct_convention[] = "pcc";
 static const char reg_struct_convention[] = "reg";
-static const char *valid_conventions[] =
+static const char *const valid_conventions[] =
 {
   default_struct_convention,
   pcc_struct_convention,
@@ -2593,7 +2670,7 @@ i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
    from WRITEBUF into REGCACHE.  */
 
 static enum return_value_convention
-i386_return_value (struct gdbarch *gdbarch, struct type *func_type,
+i386_return_value (struct gdbarch *gdbarch, struct value *function,
                   struct type *type, struct regcache *regcache,
                   gdb_byte *readbuf, const gdb_byte *writebuf)
 {
@@ -2603,6 +2680,9 @@ i386_return_value (struct gdbarch *gdbarch, struct type *func_type,
        || code == TYPE_CODE_UNION
        || code == TYPE_CODE_ARRAY)
        && !i386_reg_struct_return_p (gdbarch, type))
+      /* Complex double and long double uses the struct return covention.  */
+      || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 16)
+      || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 24)
       /* 128-bit decimal float uses the struct return convention.  */
       || (code == TYPE_CODE_DECFLOAT && TYPE_LENGTH (type) == 16))
     {
@@ -2644,7 +2724,7 @@ i386_return_value (struct gdbarch *gdbarch, struct type *func_type,
   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
     {
       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
-      return i386_return_value (gdbarch, func_type, type, regcache,
+      return i386_return_value (gdbarch, function, type, regcache,
                                readbuf, writebuf);
     }
 
@@ -2769,7 +2849,7 @@ i386_mmx_type (struct gdbarch *gdbarch)
 /* Return the GDB type object for the "standard" data type of data in
    register REGNUM.  */
 
-static struct type *
+struct type *
 i386_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
 {
   if (i386_mmx_regnum_p (gdbarch, regnum))
@@ -3273,7 +3353,7 @@ i386_pe_skip_trampoline_code (struct frame_info *frame,
        read_memory_unsigned_integer (pc + 2, 4, byte_order);
       struct minimal_symbol *indsym =
        indirect ? lookup_minimal_symbol_by_pc (indirect) : 0;
-      char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : 0;
+      const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : 0;
 
       if (symname)
        {
@@ -3294,7 +3374,7 @@ int
 i386_sigtramp_p (struct frame_info *this_frame)
 {
   CORE_ADDR pc = get_frame_pc (this_frame);
-  char *name;
+  const char *name;
 
   find_pc_partial_function (pc, &name, NULL, NULL);
   return (name && strcmp ("_sigtramp", name) == 0);
@@ -3332,13 +3412,11 @@ static int
 i386_svr4_sigtramp_p (struct frame_info *this_frame)
 {
   CORE_ADDR pc = get_frame_pc (this_frame);
-  char *name;
+  const char *name;
 
-  /* UnixWare uses _sigacthandler.  The origin of the other symbols is
-     currently unknown.  */
+  /* The origin of these symbols is currently unknown.  */
   find_pc_partial_function (pc, &name, NULL, NULL);
   return (name && (strcmp ("_sigreturn", name) == 0
-                  || strcmp ("_sigacthandler", name) == 0
                   || strcmp ("sigvechandler", name) == 0));
 }
 
@@ -3358,6 +3436,323 @@ i386_svr4_sigcontext_addr (struct frame_info *this_frame)
 
   return read_memory_unsigned_integer (sp + 8, 4, byte_order);
 }
+
+\f
+
+/* Implementation of `gdbarch_stap_is_single_operand', as defined in
+   gdbarch.h.  */
+
+int
+i386_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
+{
+  return (*s == '$' /* Literal number.  */
+         || (isdigit (*s) && s[1] == '(' && s[2] == '%') /* Displacement.  */
+         || (*s == '(' && s[1] == '%') /* Register indirection.  */
+         || (*s == '%' && isalpha (s[1]))); /* Register access.  */
+}
+
+/* Implementation of `gdbarch_stap_parse_special_token', as defined in
+   gdbarch.h.  */
+
+int
+i386_stap_parse_special_token (struct gdbarch *gdbarch,
+                              struct stap_parse_info *p)
+{
+  /* In order to parse special tokens, we use a state-machine that go
+     through every known token and try to get a match.  */
+  enum
+    {
+      TRIPLET,
+      THREE_ARG_DISPLACEMENT,
+      DONE
+    } current_state;
+
+  current_state = TRIPLET;
+
+  /* The special tokens to be parsed here are:
+
+     - `register base + (register index * size) + offset', as represented
+     in `(%rcx,%rax,8)', or `[OFFSET](BASE_REG,INDEX_REG[,SIZE])'.
+
+     - Operands of the form `-8+3+1(%rbp)', which must be interpreted as
+     `*(-8 + 3 - 1 + (void *) $eax)'.  */
+
+  while (current_state != DONE)
+    {
+      const char *s = p->arg;
+
+      switch (current_state)
+       {
+       case TRIPLET:
+           {
+             if (isdigit (*s) || *s == '-' || *s == '+')
+               {
+                 int got_minus[3];
+                 int i;
+                 long displacements[3];
+                 const char *start;
+                 char *regname;
+                 int len;
+                 struct stoken str;
+
+                 got_minus[0] = 0;
+                 if (*s == '+')
+                   ++s;
+                 else if (*s == '-')
+                   {
+                     ++s;
+                     got_minus[0] = 1;
+                   }
+
+                 displacements[0] = strtol (s, (char **) &s, 10);
+
+                 if (*s != '+' && *s != '-')
+                   {
+                     /* We are not dealing with a triplet.  */
+                     break;
+                   }
+
+                 got_minus[1] = 0;
+                 if (*s == '+')
+                   ++s;
+                 else
+                   {
+                     ++s;
+                     got_minus[1] = 1;
+                   }
+
+                 displacements[1] = strtol (s, (char **) &s, 10);
+
+                 if (*s != '+' && *s != '-')
+                   {
+                     /* We are not dealing with a triplet.  */
+                     break;
+                   }
+
+                 got_minus[2] = 0;
+                 if (*s == '+')
+                   ++s;
+                 else
+                   {
+                     ++s;
+                     got_minus[2] = 1;
+                   }
+
+                 displacements[2] = strtol (s, (char **) &s, 10);
+
+                 if (*s != '(' || s[1] != '%')
+                   break;
+
+                 s += 2;
+                 start = s;
+
+                 while (isalnum (*s))
+                   ++s;
+
+                 if (*s++ != ')')
+                   break;
+
+                 len = s - start;
+                 regname = alloca (len + 1);
+
+                 strncpy (regname, start, len);
+                 regname[len] = '\0';
+
+                 if (user_reg_map_name_to_regnum (gdbarch,
+                                                  regname, len) == -1)
+                   error (_("Invalid register name `%s' "
+                            "on expression `%s'."),
+                          regname, p->saved_arg);
+
+                 for (i = 0; i < 3; i++)
+                   {
+                     write_exp_elt_opcode (OP_LONG);
+                     write_exp_elt_type
+                       (builtin_type (gdbarch)->builtin_long);
+                     write_exp_elt_longcst (displacements[i]);
+                     write_exp_elt_opcode (OP_LONG);
+                     if (got_minus[i])
+                       write_exp_elt_opcode (UNOP_NEG);
+                   }
+
+                 write_exp_elt_opcode (OP_REGISTER);
+                 str.ptr = regname;
+                 str.length = len;
+                 write_exp_string (str);
+                 write_exp_elt_opcode (OP_REGISTER);
+
+                 write_exp_elt_opcode (UNOP_CAST);
+                 write_exp_elt_type (builtin_type (gdbarch)->builtin_data_ptr);
+                 write_exp_elt_opcode (UNOP_CAST);
+
+                 write_exp_elt_opcode (BINOP_ADD);
+                 write_exp_elt_opcode (BINOP_ADD);
+                 write_exp_elt_opcode (BINOP_ADD);
+
+                 write_exp_elt_opcode (UNOP_CAST);
+                 write_exp_elt_type (lookup_pointer_type (p->arg_type));
+                 write_exp_elt_opcode (UNOP_CAST);
+
+                 write_exp_elt_opcode (UNOP_IND);
+
+                 p->arg = s;
+
+                 return 1;
+               }
+             break;
+           }
+       case THREE_ARG_DISPLACEMENT:
+           {
+             if (isdigit (*s) || *s == '(' || *s == '-' || *s == '+')
+               {
+                 int offset_minus = 0;
+                 long offset = 0;
+                 int size_minus = 0;
+                 long size = 0;
+                 const char *start;
+                 char *base;
+                 int len_base;
+                 char *index;
+                 int len_index;
+                 struct stoken base_token, index_token;
+
+                 if (*s == '+')
+                   ++s;
+                 else if (*s == '-')
+                   {
+                     ++s;
+                     offset_minus = 1;
+                   }
+
+                 if (offset_minus && !isdigit (*s))
+                   break;
+
+                 if (isdigit (*s))
+                   offset = strtol (s, (char **) &s, 10);
+
+                 if (*s != '(' || s[1] != '%')
+                   break;
+
+                 s += 2;
+                 start = s;
+
+                 while (isalnum (*s))
+                   ++s;
+
+                 if (*s != ',' || s[1] != '%')
+                   break;
+
+                 len_base = s - start;
+                 base = alloca (len_base + 1);
+                 strncpy (base, start, len_base);
+                 base[len_base] = '\0';
+
+                 if (user_reg_map_name_to_regnum (gdbarch,
+                                                  base, len_base) == -1)
+                   error (_("Invalid register name `%s' "
+                            "on expression `%s'."),
+                          base, p->saved_arg);
+
+                 s += 2;
+                 start = s;
+
+                 while (isalnum (*s))
+                   ++s;
+
+                 len_index = s - start;
+                 index = alloca (len_index + 1);
+                 strncpy (index, start, len_index);
+                 index[len_index] = '\0';
+
+                 if (user_reg_map_name_to_regnum (gdbarch,
+                                                  index, len_index) == -1)
+                   error (_("Invalid register name `%s' "
+                            "on expression `%s'."),
+                          index, p->saved_arg);
+
+                 if (*s != ',' && *s != ')')
+                   break;
+
+                 if (*s == ',')
+                   {
+                     ++s;
+                     if (*s == '+')
+                       ++s;
+                     else if (*s == '-')
+                       {
+                         ++s;
+                         size_minus = 1;
+                       }
+
+                     size = strtol (s, (char **) &s, 10);
+
+                     if (*s != ')')
+                       break;
+                   }
+
+                 ++s;
+
+                 if (offset)
+                   {
+                     write_exp_elt_opcode (OP_LONG);
+                     write_exp_elt_type
+                       (builtin_type (gdbarch)->builtin_long);
+                     write_exp_elt_longcst (offset);
+                     write_exp_elt_opcode (OP_LONG);
+                     if (offset_minus)
+                       write_exp_elt_opcode (UNOP_NEG);
+                   }
+
+                 write_exp_elt_opcode (OP_REGISTER);
+                 base_token.ptr = base;
+                 base_token.length = len_base;
+                 write_exp_string (base_token);
+                 write_exp_elt_opcode (OP_REGISTER);
+
+                 if (offset)
+                   write_exp_elt_opcode (BINOP_ADD);
+
+                 write_exp_elt_opcode (OP_REGISTER);
+                 index_token.ptr = index;
+                 index_token.length = len_index;
+                 write_exp_string (index_token);
+                 write_exp_elt_opcode (OP_REGISTER);
+
+                 if (size)
+                   {
+                     write_exp_elt_opcode (OP_LONG);
+                     write_exp_elt_type
+                       (builtin_type (gdbarch)->builtin_long);
+                     write_exp_elt_longcst (size);
+                     write_exp_elt_opcode (OP_LONG);
+                     if (size_minus)
+                       write_exp_elt_opcode (UNOP_NEG);
+                     write_exp_elt_opcode (BINOP_MUL);
+                   }
+
+                 write_exp_elt_opcode (BINOP_ADD);
+
+                 write_exp_elt_opcode (UNOP_CAST);
+                 write_exp_elt_type (lookup_pointer_type (p->arg_type));
+                 write_exp_elt_opcode (UNOP_CAST);
+
+                 write_exp_elt_opcode (UNOP_IND);
+
+                 p->arg = s;
+
+                 return 1;
+               }
+             break;
+           }
+       }
+
+      /* Advancing to the next state.  */
+      ++current_state;
+    }
+
+  return 0;
+}
+
 \f
 
 /* Generic ELF.  */
@@ -3367,6 +3762,16 @@ i386_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 {
   /* We typically use stabs-in-ELF with the SVR4 register numbering.  */
   set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum);
+
+  /* Registering SystemTap handlers.  */
+  set_gdbarch_stap_integer_prefix (gdbarch, "$");
+  set_gdbarch_stap_register_prefix (gdbarch, "%");
+  set_gdbarch_stap_register_indirection_prefix (gdbarch, "(");
+  set_gdbarch_stap_register_indirection_suffix (gdbarch, ")");
+  set_gdbarch_stap_is_single_operand (gdbarch,
+                                     i386_stap_is_single_operand);
+  set_gdbarch_stap_parse_special_token (gdbarch,
+                                       i386_stap_parse_special_token);
 }
 
 /* System V Release 4 (SVR4).  */
@@ -3515,7 +3920,7 @@ i386_fetch_pointer_argument (struct frame_info *frame, int argi,
 {
   struct gdbarch *gdbarch = get_frame_arch (frame);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  CORE_ADDR sp = get_frame_register_unsigned  (frame, I386_ESP_REGNUM);
+  CORE_ADDR sp = get_frame_register_unsigned (frame, I386_ESP_REGNUM);
   return read_memory_unsigned_integer (sp + (4 * (argi + 1)), 4, byte_order);
 }
 
@@ -3579,22 +3984,17 @@ struct i386_record_s
   const int *regmap;
 };
 
-/* Parse "modrm" part in current memory address that irp->addr point to
-   Return -1 if something wrong.  */
+/* Parse the "modrm" part of the memory address irp->addr points at.
+   Returns -1 if something goes wrong, 0 otherwise.  */
 
 static int
 i386_record_modrm (struct i386_record_s *irp)
 {
   struct gdbarch *gdbarch = irp->gdbarch;
 
-  if (target_read_memory (irp->addr, &irp->modrm, 1))
-    {
-      if (record_debug)
-       printf_unfiltered (_("Process record: error reading memory at "
-                            "addr %s len = 1.\n"),
-                          paddress (gdbarch, irp->addr));
-      return -1;
-    }
+  if (record_read_memory (gdbarch, irp->addr, &irp->modrm, 1))
+    return -1;
+
   irp->addr++;
   irp->mod = (irp->modrm >> 6) & 3;
   irp->reg = (irp->modrm >> 3) & 7;
@@ -3603,9 +4003,8 @@ i386_record_modrm (struct i386_record_s *irp)
   return 0;
 }
 
-/* Get the memory address that current instruction  write to and set it to
-   the argument "addr".
-   Return -1 if something wrong.  */
+/* Extract the memory address that the current instruction writes to,
+   and return it in *ADDR.  Return -1 if something goes wrong.  */
 
 static int
 i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
@@ -3628,14 +4027,8 @@ i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
       if (base == 4)
        {
          havesib = 1;
-         if (target_read_memory (irp->addr, &byte, 1))
-           {
-             if (record_debug)
-               printf_unfiltered (_("Process record: error reading memory "
-                                    "at addr %s len = 1.\n"),
-                                  paddress (gdbarch, irp->addr));
-             return -1;
-           }
+         if (record_read_memory (gdbarch, irp->addr, &byte, 1))
+           return -1;
          irp->addr++;
          scale = (byte >> 6) & 3;
          index = ((byte >> 3) & 7) | irp->rex_x;
@@ -3649,14 +4042,8 @@ i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
          if ((base & 7) == 5)
            {
              base = 0xff;
-             if (target_read_memory (irp->addr, buf, 4))
-               {
-                 if (record_debug)
-                   printf_unfiltered (_("Process record: error reading "
-                                        "memory at addr %s len = 4.\n"),
-                                      paddress (gdbarch, irp->addr));
-                 return -1;
-               }
+             if (record_read_memory (gdbarch, irp->addr, buf, 4))
+               return -1;
              irp->addr += 4;
              *addr = extract_signed_integer (buf, 4, byte_order);
              if (irp->regmap[X86_RECORD_R8_REGNUM] && !havesib)
@@ -3664,26 +4051,14 @@ i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
            }
          break;
        case 1:
-         if (target_read_memory (irp->addr, buf, 1))
-           {
-             if (record_debug)
-               printf_unfiltered (_("Process record: error reading memory "
-                                    "at addr %s len = 1.\n"),
-                                  paddress (gdbarch, irp->addr));
-             return -1;
-           }
+         if (record_read_memory (gdbarch, irp->addr, buf, 1))
+           return -1;
          irp->addr++;
          *addr = (int8_t) buf[0];
          break;
        case 2:
-         if (target_read_memory (irp->addr, buf, 4))
-           {
-             if (record_debug)
-               printf_unfiltered (_("Process record: error reading memory "
-                                    "at addr %s len = 4.\n"),
-                                  paddress (gdbarch, irp->addr));
-             return -1;
-           }
+         if (record_read_memory (gdbarch, irp->addr, buf, 4))
+           return -1;
          *addr = extract_signed_integer (buf, 4, byte_order);
          irp->addr += 4;
          break;
@@ -3722,14 +4097,8 @@ i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
        case 0:
          if (irp->rm == 6)
            {
-             if (target_read_memory (irp->addr, buf, 2))
-               {
-                 if (record_debug)
-                   printf_unfiltered (_("Process record: error reading "
-                                        "memory at addr %s len = 2.\n"),
-                                      paddress (gdbarch, irp->addr));
-                 return -1;
-               }
+             if (record_read_memory (gdbarch, irp->addr, buf, 2))
+               return -1;
              irp->addr += 2;
              *addr = extract_signed_integer (buf, 2, byte_order);
              irp->rm = 0;
@@ -3737,26 +4106,14 @@ i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
            }
          break;
        case 1:
-         if (target_read_memory (irp->addr, buf, 1))
-           {
-             if (record_debug)
-               printf_unfiltered (_("Process record: error reading memory "
-                                    "at addr %s len = 1.\n"),
-                                  paddress (gdbarch, irp->addr));
-             return -1;
-           }
+         if (record_read_memory (gdbarch, irp->addr, buf, 1))
+           return -1;
          irp->addr++;
          *addr = (int8_t) buf[0];
          break;
        case 2:
-         if (target_read_memory (irp->addr, buf, 2))
-           {
-             if (record_debug)
-               printf_unfiltered (_("Process record: error reading memory "
-                                    "at addr %s len = 2.\n"),
-                                  paddress (gdbarch, irp->addr));
-             return -1;
-           }
+         if (record_read_memory (gdbarch, irp->addr, buf, 2))
+           return -1;
          irp->addr += 2;
          *addr = extract_signed_integer (buf, 2, byte_order);
          break;
@@ -3836,9 +4193,9 @@ i386_record_lea_modrm_addr (struct i386_record_s *irp, uint64_t *addr)
   return 0;
 }
 
-/* Record the value of the memory that willbe changed in current instruction
-   to "record_arch_list".
-   Return -1 if something wrong.  */
+/* Record the address and contents of the memory that will be changed
+   by the current instruction.  Return -1 if something goes wrong, 0
+   otherwise.  */
 
 static int
 i386_record_lea_modrm (struct i386_record_s *irp)
@@ -3848,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;
 
@@ -3869,27 +4226,27 @@ 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;
 }
 
-/* Record the push operation to "record_arch_list".
-   Return -1 if something wrong.  */
+/* Record the effects of a push operation.  Return -1 if something
+   goes wrong, 0 otherwise.  */
 
 static int
 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;
@@ -3901,9 +4258,9 @@ i386_record_push (struct i386_record_s *irp, int size)
 #define I386_SAVE_FPU_ENV               0xfffe
 #define I386_SAVE_FPU_ENV_REG_STACK     0xffff
 
-/* Record the value of floating point registers which will be changed
-   by the current instruction to "record_arch_list".  Return -1 if
-   something is wrong.  */
+/* Record the values of the floating point registers which will be
+   changed by the current instruction.  Returns -1 if something is
+   wrong, 0 otherwise.  */
 
 static int i386_record_floats (struct gdbarch *gdbarch,
                                struct i386_record_s *ir,
@@ -3921,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;
         }
     }
@@ -3929,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;
              }
     }
@@ -3937,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
@@ -3956,19 +4313,19 @@ 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;
       }
     }
   return 0;
 }
 
-/* Parse the current instruction and record the values of the registers and
-   memory that will be changed in current instruction to "record_arch_list".
-   Return -1 if something wrong.  */
+/* Parse the current instruction, and record the values of the
+   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,
@@ -3978,12 +4335,11 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
   int prefixes = 0;
   int regnum = 0;
   uint32_t opcode;
-  uint8_t  opcode8;
+  uint8_t opcode8;
   ULONGEST addr;
   gdb_byte buf[MAX_REGISTER_SIZE];
   struct i386_record_s ir;
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  int rex = 0;
   uint8_t rex_w = -1;
   uint8_t rex_r = 0;
 
@@ -4006,14 +4362,8 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
   /* prefixes */
   while (1)
     {
-      if (target_read_memory (ir.addr, &opcode8, 1))
-       {
-         if (record_debug)
-           printf_unfiltered (_("Process record: error reading memory at "
-                                "addr %s len = 1.\n"),
-                              paddress (gdbarch, ir.addr));
-         return -1;
-       }
+      if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
+       return -1;
       ir.addr++;
       switch (opcode8) /* Instruction prefixes */
        {
@@ -4069,7 +4419,6 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
           if (ir.regmap[X86_RECORD_R8_REGNUM]) /* 64 bit target */
             {
                /* REX */
-               rex = 1;
                rex_w = (opcode8 >> 3) & 1;
                rex_r = (opcode8 & 0x4) << 1;
                ir.rex_x = (opcode8 & 0x2) << 2;
@@ -4104,14 +4453,8 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
   switch (opcode)
     {
     case 0x0f:
-      if (target_read_memory (ir.addr, &opcode8, 1))
-       {
-         if (record_debug)
-           printf_unfiltered (_("Process record: error reading memory at "
-                                "addr %s len = 1.\n"),
-                              paddress (gdbarch, ir.addr));
-         return -1;
-       }
+      if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
+       return -1;
       ir.addr++;
       opcode = (uint32_t) opcode8 | 0x0f00;
       goto reswitch;
@@ -4187,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 */
@@ -4196,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 */
@@ -4230,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 */
@@ -4253,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 */
@@ -4272,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 */
@@ -4286,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;
@@ -4336,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)
@@ -4375,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 */
@@ -4400,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 */
@@ -4417,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
        {
@@ -4428,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 */
@@ -4444,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 */
@@ -4467,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 */
@@ -4532,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 */
@@ -4545,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 */
@@ -4556,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)))
@@ -4575,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 */
@@ -4585,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 */
@@ -4596,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 */
@@ -4607,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 */
@@ -4649,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;
 
@@ -4664,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 */
@@ -4678,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;
@@ -4713,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 */
@@ -4723,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 */
@@ -4739,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;
 
@@ -4776,44 +5119,26 @@ Do you want to stop the program?"),
            ir.ot = ir.dflag + OT_WORD;
          if (ir.aflag == 2)
            {
-              if (target_read_memory (ir.addr, buf, 8))
-               {
-                 if (record_debug)
-                   printf_unfiltered (_("Process record: error reading "
-                                        "memory at addr 0x%s len = 8.\n"),
-                                      paddress (gdbarch, ir.addr));
-                 return -1;
-               }
+              if (record_read_memory (gdbarch, ir.addr, buf, 8))
+               return -1;
              ir.addr += 8;
              addr = extract_unsigned_integer (buf, 8, byte_order);
            }
           else if (ir.aflag)
            {
-              if (target_read_memory (ir.addr, buf, 4))
-               {
-                 if (record_debug)
-                   printf_unfiltered (_("Process record: error reading "
-                                        "memory at addr 0x%s len = 4.\n"),
-                                      paddress (gdbarch, ir.addr));
-                 return -1;
-               }
+              if (record_read_memory (gdbarch, ir.addr, buf, 4))
+               return -1;
              ir.addr += 4;
               addr = extract_unsigned_integer (buf, 4, byte_order);
            }
           else
            {
-              if (target_read_memory (ir.addr, buf, 2))
-               {
-                 if (record_debug)
-                   printf_unfiltered (_("Process record: error reading "
-                                        "memory at addr 0x%s len = 2.\n"),
-                                      paddress (gdbarch, ir.addr));
-                 return -1;
-               }
+              if (record_read_memory (gdbarch, ir.addr, buf, 2))
+               return -1;
              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;
@@ -4826,9 +5151,9 @@ 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])
-                                        ? ((opcode & 0x7) | ir.rex_b)
-                                       : ((opcode & 0x7) & 0x3));
+      I386_RECORD_FULL_ARCH_LIST_ADD_REG ((ir.regmap[X86_RECORD_R8_REGNUM])
+                                         ? ((opcode & 0x7) | ir.rex_b)
+                                         : ((opcode & 0x7) & 0x3));
       break;
 
     case 0xb8:    /* mov R, Iv */
@@ -4839,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 */
@@ -4849,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 */
@@ -4866,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
        {
@@ -4876,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 */
@@ -4919,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 */
@@ -4946,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:
@@ -4959,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
@@ -5062,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;
                    }
@@ -5081,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))
                        {
@@ -5092,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))
@@ -5105,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))
                        {
@@ -5125,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;
                    }
@@ -5152,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))
@@ -5171,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,
@@ -5195,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))
@@ -5401,7 +5726,8 @@ 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))
@@ -5444,7 +5770,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;
 
@@ -5461,59 +5787,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:
@@ -5525,16 +5851,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 */
@@ -5550,7 +5876,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;
@@ -5608,13 +5934,13 @@ 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)
-                                               : (ir.rm & 0x3));
+        I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rex_b ? (ir.rm | ir.rex_b)
+                                           : (ir.rm & 0x3));
       else
        {
          if (i386_record_lea_modrm (&ir))
@@ -5643,12 +5969,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)))
@@ -5656,8 +5982,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 */
@@ -5672,7 +5998,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 */
@@ -5681,8 +6007,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 */
@@ -5699,18 +6025,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 */
@@ -5720,7 +6046,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;
@@ -5741,18 +6067,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 */
@@ -5767,8 +6093,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 */
@@ -5781,14 +6107,8 @@ Do you want to stop the program?"),
       break;
 
     case 0x9b:    /* fwait */
-      if (target_read_memory (ir.addr, &opcode8, 1))
-        {
-          if (record_debug)
-            printf_unfiltered (_("Process record: error reading memory at "
-                                "addr 0x%s len = 1.\n"),
-                              paddress (gdbarch, ir.addr));
-          return -1;
-        }
+      if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
+       return -1;
       opcode = (uint32_t) opcode8;
       ir.addr++;
       goto reswitch;
@@ -5807,14 +6127,8 @@ Do you want to stop the program?"),
       {
        int ret;
        uint8_t interrupt;
-       if (target_read_memory (ir.addr, &interrupt, 1))
-         {
-           if (record_debug)
-             printf_unfiltered (_("Process record: error reading memory "
-                                  "at addr %s len = 1.\n"),
-                                paddress (gdbarch, ir.addr));
-           return -1;
-         }
+       if (record_read_memory (gdbarch, ir.addr, &interrupt, 1))
+         return -1;
        ir.addr++;
        if (interrupt != 0x80
            || tdep->i386_intx80_record == NULL)
@@ -5858,7 +6172,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 */
@@ -5867,16 +6181,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 */
@@ -5894,8 +6208,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 */
@@ -5950,10 +6264,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 */
@@ -5971,7 +6285,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;
@@ -5984,7 +6298,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;
@@ -6011,7 +6325,7 @@ Do you want to stop the program?"),
              }
            if (ir.override >= 0)
              {
-                if (record_memory_query)
+                if (record_full_memory_query)
                   {
                    int q;
 
@@ -6030,17 +6344,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;
                   }
              }
@@ -6054,7 +6368,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;
@@ -6068,7 +6382,7 @@ Do you want to stop the program?"),
              /* sidt */
              if (ir.override >= 0)
                {
-                  if (record_memory_query)
+                  if (record_full_memory_query)
                     {
                      int q;
 
@@ -6089,17 +6403,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;
                     }
                }
@@ -6111,8 +6425,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 */
@@ -6130,7 +6444,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
@@ -6139,16 +6453,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;
@@ -6157,7 +6471,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;
@@ -6176,8 +6490,8 @@ 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]
-                                          ? (ir.reg | rex_r) : ir.rm);
+          I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.regmap[X86_RECORD_R8_REGNUM]
+                                             ? (ir.reg | rex_r) : ir.rm);
         }
       else
         {
@@ -6186,15 +6500,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:
@@ -6236,9 +6550,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;
@@ -6260,13 +6574,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 */
@@ -6278,19 +6592,14 @@ 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 */
       if (i386_record_modrm (&ir))
        return -1;
-      if (target_read_memory (ir.addr, &opcode8, 1))
-        {
-         printf_unfiltered (_("Process record: error reading memory at "
-                              "addr %s len = 1.\n"),
-                            paddress (gdbarch, ir.addr));
-          return -1;
-        }
+      if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
+       return -1;
       ir.addr++;
       switch (opcode8)
         {
@@ -6320,7 +6629,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:
@@ -6332,15 +6641,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:
@@ -6352,10 +6661,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;
@@ -6364,33 +6673,34 @@ 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 */
@@ -6557,13 +6867,8 @@ reswitch_prefix_add:
         case 0xf20f38:
         case 0x0f3a:
         case 0x660f3a:
-          if (target_read_memory (ir.addr, &opcode8, 1))
-            {
-             printf_unfiltered (_("Process record: error reading memory at "
-                                  "addr %s len = 1.\n"),
-                                paddress (gdbarch, ir.addr));
-              return -1;
-            }
+          if (record_read_memory (gdbarch, ir.addr, &opcode8, 1))
+           return -1;
           ir.addr++;
           opcode = (uint32_t) opcode8 | opcode << 8;
           goto reswitch_prefix_add;
@@ -6773,10 +7078,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,
-                                    I387_XMM0_REGNUM (tdep) + ir.reg);
+          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 */
@@ -6806,8 +7111,8 @@ 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,
-                                        I387_XMM0_REGNUM (tdep) + ir.rm);
+              record_full_arch_list_add_reg (ir.regcache,
+                                            I387_XMM0_REGNUM (tdep) + ir.rm);
             }
           else
             {
@@ -6860,7 +7165,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 */
@@ -6961,8 +7266,8 @@ 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,
-                                    I387_MM0_REGNUM (tdep) + ir.reg);
+          record_full_arch_list_add_reg (ir.regcache,
+                                        I387_MM0_REGNUM (tdep) + ir.reg);
           break;
 
         case 0x0f71:    /* psllw */
@@ -6972,8 +7277,8 @@ 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,
-                                    I387_MM0_REGNUM (tdep) + ir.rm);
+          record_full_arch_list_add_reg (ir.regcache,
+                                        I387_MM0_REGNUM (tdep) + ir.rm);
           break;
 
         case 0x660f71:    /* psllw */
@@ -6984,8 +7289,8 @@ 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,
-                                    I387_XMM0_REGNUM (tdep) + ir.rm);
+          record_full_arch_list_add_reg (ir.regcache,
+                                        I387_XMM0_REGNUM (tdep) + ir.rm);
           break;
 
         case 0x0f7e:      /* movd */
@@ -6993,7 +7298,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)
@@ -7012,8 +7317,8 @@ 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,
-                                        I387_MM0_REGNUM (tdep) + ir.rm);
+              record_full_arch_list_add_reg (ir.regcache,
+                                            I387_MM0_REGNUM (tdep) + ir.rm);
             }
           else
             {
@@ -7026,8 +7331,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 */
@@ -7039,8 +7344,8 @@ 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,
-                                        I387_XMM0_REGNUM (tdep) + ir.rm);
+              record_full_arch_list_add_reg (ir.regcache,
+                                            I387_XMM0_REGNUM (tdep) + ir.rm);
             }
           else
             {
@@ -7055,14 +7360,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;
 
@@ -7070,7 +7375,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;
 
@@ -7086,8 +7391,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;
@@ -7367,6 +7672,8 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_get_longjmp_target (gdbarch, i386_get_longjmp_target);
 
   /* Call dummy code.  */
+  set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
+  set_gdbarch_push_dummy_code (gdbarch, i386_push_dummy_code);
   set_gdbarch_push_dummy_call (gdbarch, i386_push_dummy_call);
   set_gdbarch_frame_align (gdbarch, i386_frame_align);