gdb/record-full.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Process record and replay target for GDB, the GNU debugger.

  3.    Copyright (C) 2013-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.

  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.

  17.    You should have received a copy of the GNU General Public License
  18.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  20. #include "defs.h"
  21. #include "gdbcmd.h"
  22. #include "regcache.h"
  23. #include "gdbthread.h"
  24. #include "event-top.h"
  25. #include "completer.h"
  26. #include "arch-utils.h"
  27. #include "gdbcore.h"
  28. #include "exec.h"
  29. #include "record.h"
  30. #include "record-full.h"
  31. #include "elf-bfd.h"
  32. #include "gcore.h"
  33. #include "event-loop.h"
  34. #include "inf-loop.h"
  35. #include "gdb_bfd.h"
  36. #include "observer.h"
  37. #include "infrun.h"

  39. #include <signal.h>

  41. /* This module implements "target record-full", also known as "process
  42.    record and replay".  This target sits on top of a "normal" target
  43.    (a target that "has execution"), and provides a record and replay
  44.    functionality, including reverse debugging.

  46.    Target record has two modes: recording, and replaying.

  48.    In record mode, we intercept the to_resume and to_wait methods.
  49.    Whenever gdb resumes the target, we run the target in single step
  50.    mode, and we build up an execution log in which, for each executed
  51.    instruction, we record all changes in memory and register state.
  52.    This is invisible to the user, to whom it just looks like an
  53.    ordinary debugging session (except for performance degredation).

  55.    In replay mode, instead of actually letting the inferior run as a
  56.    process, we simulate its execution by playing back the recorded
  57.    execution log.  For each instruction in the log, we simulate the
  58.    instruction's side effects by duplicating the changes that it would
  59.    have made on memory and registers.  */

  61. ‌#define DEFAULT_RECORD_FULL_INSN_MAX_NUM        200000

  63. ‌#define RECORD_FULL_IS_REPLAY \
  64.      (record_full_list->next || execution_direction == EXEC_REVERSE)

  66. ‌#define RECORD_FULL_FILE_MAGIC        netorder32(0x20091016)

  68. /* These are the core structs of the process record functionality.

  70.    A record_full_entry is a record of the value change of a register
  71.    ("record_full_reg") or a part of memory ("record_full_mem").  And each
  72.    instruction must have a struct record_full_entry ("record_full_end")
  73.    that indicates that this is the last struct record_full_entry of this
  74.    instruction.

  76.    Each struct record_full_entry is linked to "record_full_list" by "prev"
  77.    and "next" pointers.  */

  79. ‌struct record_full_mem_entry
  80. {
  81.   CORE_ADDR addr;
  82.   int len;
  83.   /* Set this flag if target memory for this entry
  84.      can no longer be accessed.  */
  85.   int mem_entry_not_accessible;
  86.   union
  87.   {
  88.     gdb_byte *ptr;
  89.     gdb_byte buf[sizeof (gdb_byte *)];
  90.   } u;
  91. };

  93. ‌struct record_full_reg_entry
  94. {
  95.   unsigned short num;
  96.   unsigned short len;
  97.   union
  98.   {
  99.     gdb_byte *ptr;
  100.     gdb_byte buf[2 * sizeof (gdb_byte *)];
  101.   } u;
  102. };

  104. ‌struct record_full_end_entry
  105. {
  106.   enum gdb_signal sigval;
  107.   ULONGEST insn_num;
  108. };

  110. ‌enum record_full_type
  111. {
  112.   record_full_end = 0,
  113.   record_full_reg,
  114.   record_full_mem
  115. };

  117. /* This is the data structure that makes up the execution log.

  119.    The execution log consists of a single linked list of entries
  120.    of type "struct record_full_entry".  It is doubly linked so that it
  121.    can be traversed in either direction.

  123.    The start of the list is anchored by a struct called
  124.    "record_full_first".  The pointer "record_full_list" either points
  125.    to the last entry that was added to the list (in record mode), or to
  126.    the next entry in the list that will be executed (in replay mode).

  128.    Each list element (struct record_full_entry), in addition to next
  129.    and prev pointers, consists of a union of three entry types: mem,
  130.    reg, and end.  A field called "type" determines which entry type is
  131.    represented by a given list element.

  133.    Each instruction that is added to the execution log is represented
  134.    by a variable number of list elements ('entries').  The instruction
  135.    will have one "reg" entry for each register that is changed by
  136.    executing the instruction (including the PC in every case).  It
  137.    will also have one "mem" entry for each memory change.  Finally,
  138.    each instruction will have an "end" entry that separates it from
  139.    the changes associated with the next instruction.  */

  141. ‌struct record_full_entry
  142. {
  143.   struct record_full_entry *prev;
  144.   struct record_full_entry *next;
  145.   enum record_full_type type;
  146.   union
  147.   {
  148.     /* reg */
  149.     struct record_full_reg_entry reg;
  150.     /* mem */
  151.     struct record_full_mem_entry mem;
  152.     /* end */
  153.     struct record_full_end_entry end;
  154.   } u;
  155. };

  157. /* If true, query if PREC cannot record memory
  158.    change of next instruction.  */
  159. ‌int record_full_memory_query = 0;

  161. ‌struct record_full_core_buf_entry
  162. {
  163.   struct record_full_core_buf_entry *prev;
  164.   struct target_section *p;
  165.   bfd_byte *buf;
  166. };

  168. /* Record buf with core target.  */
  169. ‌static gdb_byte *record_full_core_regbuf = NULL;
  170. ‌static struct target_section *record_full_core_start;
  171. ‌static struct target_section *record_full_core_end;
  172. ‌static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;

  174. /* The following variables are used for managing the linked list that
  175.    represents the execution log.

  177.    record_full_first is the anchor that holds down the beginning of
  178.    the list.

  180.    record_full_list serves two functions:
  181.      1) In record mode, it anchors the end of the list.
  182.      2) In replay mode, it traverses the list and points to
  183.         the next instruction that must be emulated.

  185.    record_full_arch_list_head and record_full_arch_list_tail are used
  186.    to manage a separate list, which is used to build up the change
  187.    elements of the currently executing instruction during record mode.
  188.    When this instruction has been completely annotated in the "arch
  189.    list", it will be appended to the main execution log.  */

  191. ‌static struct record_full_entry record_full_first;
  192. ‌static struct record_full_entry *record_full_list = &record_full_first;
  193. ‌static struct record_full_entry *record_full_arch_list_head = NULL;
  194. ‌static struct record_full_entry *record_full_arch_list_tail = NULL;

  196. /* 1 ask user. 0 auto delete the last struct record_full_entry.  */
  197. ‌static int record_full_stop_at_limit = 1;
  198. /* Maximum allowed number of insns in execution log.  */
  199. ‌static unsigned int record_full_insn_max_num
  200.         = DEFAULT_RECORD_FULL_INSN_MAX_NUM;
  201. /* Actual count of insns presently in execution log.  */
  202. ‌static unsigned int record_full_insn_num = 0;
  203. /* Count of insns logged so far (may be larger
  204.    than count of insns presently in execution log).  */
  205. ‌static ULONGEST record_full_insn_count;

  207. /* The target_ops of process record.  */
  208. ‌static struct target_ops record_full_ops;
  209. ‌static struct target_ops record_full_core_ops;

  211. /* See record-full.h.  */

  213. int
  214. ‌record_full_is_used (void)
  215. {
  216.   struct target_ops *t;

  218.   t = find_record_target ();
  219.   return (t == &record_full_ops
  220.           || t == &record_full_core_ops);
  221. }


  224. /* Command lists for "set/show record full".  */
  225. ‌static struct cmd_list_element *set_record_full_cmdlist;
  226. ‌static struct cmd_list_element *show_record_full_cmdlist;

  228. /* Command list for "record full".  */
  229. ‌static struct cmd_list_element *record_full_cmdlist;

  231. static void record_full_goto_insn (struct record_full_entry *entry,
  232.                                    enum exec_direction_kind dir);
  233. static void record_full_save (struct target_ops *self,
  234.                               const char *recfilename);

  236. /* Alloc and free functions for record_full_reg, record_full_mem, and
  237.    record_full_end entries.  */

  239. /* Alloc a record_full_reg record entry.  */

  241. static inline struct record_full_entry *
  242. ‌record_full_reg_alloc (struct regcache *regcache, int regnum)
  243. {
  244.   struct record_full_entry *rec;
  245.   struct gdbarch *gdbarch = get_regcache_arch (regcache);

  247.   rec = xcalloc (1, sizeof (struct record_full_entry));
  248.   rec->type = record_full_reg;
  249.   rec->u.reg.num = regnum;
  250.   rec->u.reg.len = register_size (gdbarch, regnum);
  251.   if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
  252.     rec->u.reg.u.ptr = (gdb_byte *) xmalloc (rec->u.reg.len);

  254.   return rec;
  255. }

  257. /* Free a record_full_reg record entry.  */

  259. static inline void
  260. ‌record_full_reg_release (struct record_full_entry *rec)
  261. {
  262.   gdb_assert (rec->type == record_full_reg);
  263.   if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
  264.     xfree (rec->u.reg.u.ptr);
  265.   xfree (rec);
  266. }

  268. /* Alloc a record_full_mem record entry.  */

  270. static inline struct record_full_entry *
  271. ‌record_full_mem_alloc (CORE_ADDR addr, int len)
  272. {
  273.   struct record_full_entry *rec;

  275.   rec = xcalloc (1, sizeof (struct record_full_entry));
  276.   rec->type = record_full_mem;
  277.   rec->u.mem.addr = addr;
  278.   rec->u.mem.len = len;
  279.   if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
  280.     rec->u.mem.u.ptr = (gdb_byte *) xmalloc (len);

  282.   return rec;
  283. }

  285. /* Free a record_full_mem record entry.  */

  287. static inline void
  288. ‌record_full_mem_release (struct record_full_entry *rec)
  289. {
  290.   gdb_assert (rec->type == record_full_mem);
  291.   if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
  292.     xfree (rec->u.mem.u.ptr);
  293.   xfree (rec);
  294. }

  296. /* Alloc a record_full_end record entry.  */

  298. static inline struct record_full_entry *
  299. ‌record_full_end_alloc (void)
  300. {
  301.   struct record_full_entry *rec;

  303.   rec = xcalloc (1, sizeof (struct record_full_entry));
  304.   rec->type = record_full_end;

  306.   return rec;
  307. }

  309. /* Free a record_full_end record entry.  */

  311. static inline void
  312. ‌record_full_end_release (struct record_full_entry *rec)
  313. {
  314.   xfree (rec);
  315. }

  317. /* Free one record entry, any type.
  318.    Return entry->type, in case caller wants to know.  */

  320. static inline enum record_full_type
  321. ‌record_full_entry_release (struct record_full_entry *rec)
  322. {
  323.   enum record_full_type type = rec->type;

  325.   switch (type) {
  326.   case record_full_reg:
  327.     record_full_reg_release (rec);
  328.     break;
  329.   case record_full_mem:
  330.     record_full_mem_release (rec);
  331.     break;
  332.   case record_full_end:
  333.     record_full_end_release (rec);
  334.     break;
  335.   }
  336.   return type;
  337. }

  339. /* Free all record entries in list pointed to by REC.  */

  341. static void
  342. ‌record_full_list_release (struct record_full_entry *rec)
  343. {
  344.   if (!rec)
  345.     return;

  347.   while (rec->next)
  348.     rec = rec->next;

  350.   while (rec->prev)
  351.     {
  352.       rec = rec->prev;
  353.       record_full_entry_release (rec->next);
  354.     }

  356.   if (rec == &record_full_first)
  357.     {
  358.       record_full_insn_num = 0;
  359.       record_full_first.next = NULL;
  360.     }
  361.   else
  362.     record_full_entry_release (rec);
  363. }

  365. /* Free all record entries forward of the given list position.  */

  367. static void
  368. ‌record_full_list_release_following (struct record_full_entry *rec)
  369. {
  370.   struct record_full_entry *tmp = rec->next;

  372.   rec->next = NULL;
  373.   while (tmp)
  374.     {
  375.       rec = tmp->next;
  376.       if (record_full_entry_release (tmp) == record_full_end)
  377.         {
  378.           record_full_insn_num--;
  379.           record_full_insn_count--;
  380.         }
  381.       tmp = rec;
  382.     }
  383. }

  385. /* Delete the first instruction from the beginning of the log, to make
  386.    room for adding a new instruction at the end of the log.

  388.    Note -- this function does not modify record_full_insn_num.  */

  390. static void
  391. ‌record_full_list_release_first (void)
  392. {
  393.   struct record_full_entry *tmp;

  395.   if (!record_full_first.next)
  396.     return;

  398.   /* Loop until a record_full_end.  */
  399.   while (1)
  400.     {
  401.       /* Cut record_full_first.next out of the linked list.  */
  402.       tmp = record_full_first.next;
  403.       record_full_first.next = tmp->next;
  404.       tmp->next->prev = &record_full_first;

  406.       /* tmp is now isolated, and can be deleted.  */
  407.       if (record_full_entry_release (tmp) == record_full_end)
  408.         break;        /* End loop at first record_full_end.  */

  410.       if (!record_full_first.next)
  411.         {
  412.           gdb_assert (record_full_insn_num == 1);
  413.           break;        /* End loop when list is empty.  */
  414.         }
  415.     }
  416. }

  418. /* Add a struct record_full_entry to record_full_arch_list.  */

  420. static void
  421. ‌record_full_arch_list_add (struct record_full_entry *rec)
  422. {
  423.   if (record_debug > 1)
  424.     fprintf_unfiltered (gdb_stdlog,
  425.                         "Process record: record_full_arch_list_add %s.\n",
  426.                         host_address_to_string (rec));

  428.   if (record_full_arch_list_tail)
  429.     {
  430.       record_full_arch_list_tail->next = rec;
  431.       rec->prev = record_full_arch_list_tail;
  432.       record_full_arch_list_tail = rec;
  433.     }
  434.   else
  435.     {
  436.       record_full_arch_list_head = rec;
  437.       record_full_arch_list_tail = rec;
  438.     }
  439. }

  441. /* Return the value storage location of a record entry.  */
  442. static inline gdb_byte *
  443. ‌record_full_get_loc (struct record_full_entry *rec)
  444. {
  445.   switch (rec->type) {
  446.   case record_full_mem:
  447.     if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
  448.       return rec->u.mem.u.ptr;
  449.     else
  450.       return rec->u.mem.u.buf;
  451.   case record_full_reg:
  452.     if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
  453.       return rec->u.reg.u.ptr;
  454.     else
  455.       return rec->u.reg.u.buf;
  456.   case record_full_end:
  457.   default:
  458.     gdb_assert_not_reached ("unexpected record_full_entry type");
  459.     return NULL;
  460.   }
  461. }

  463. /* Record the value of a register NUM to record_full_arch_list.  */

  465. int
  466. ‌record_full_arch_list_add_reg (struct regcache *regcache, int regnum)
  467. {
  468.   struct record_full_entry *rec;

  470.   if (record_debug > 1)
  471.     fprintf_unfiltered (gdb_stdlog,
  472.                         "Process record: add register num = %d to "
  473.                         "record list.\n",
  474.                         regnum);

  476.   rec = record_full_reg_alloc (regcache, regnum);

  478.   regcache_raw_read (regcache, regnum, record_full_get_loc (rec));

  480.   record_full_arch_list_add (rec);

  482.   return 0;
  483. }

  485. /* Record the value of a region of memory whose address is ADDR and
  486.    length is LEN to record_full_arch_list.  */

  488. int
  489. ‌record_full_arch_list_add_mem (CORE_ADDR addr, int len)
  490. {
  491.   struct record_full_entry *rec;

  493.   if (record_debug > 1)
  494.     fprintf_unfiltered (gdb_stdlog,
  495.                         "Process record: add mem addr = %s len = %d to "
  496.                         "record list.\n",
  497.                         paddress (target_gdbarch (), addr), len);

  499.   if (!addr)        /* FIXME: Why?  Some arch must permit it...  */
  500.     return 0;

  502.   rec = record_full_mem_alloc (addr, len);

  504.   if (record_read_memory (target_gdbarch (), addr,
  505.                           record_full_get_loc (rec), len))
  506.     {
  507.       record_full_mem_release (rec);
  508.       return -1;
  509.     }

  511.   record_full_arch_list_add (rec);

  513.   return 0;
  514. }

  516. /* Add a record_full_end type struct record_full_entry to
  517.    record_full_arch_list.  */

  519. int
  520. ‌record_full_arch_list_add_end (void)
  521. {
  522.   struct record_full_entry *rec;

  524.   if (record_debug > 1)
  525.     fprintf_unfiltered (gdb_stdlog,
  526.                         "Process record: add end to arch list.\n");

  528.   rec = record_full_end_alloc ();
  529.   rec->u.end.sigval = GDB_SIGNAL_0;
  530.   rec->u.end.insn_num = ++record_full_insn_count;

  532.   record_full_arch_list_add (rec);

  534.   return 0;
  535. }

  537. static void
  538. ‌record_full_check_insn_num (int set_terminal)
  539. {
  540.   if (record_full_insn_num == record_full_insn_max_num)
  541.     {
  542.       /* Ask user what to do.  */
  543.       if (record_full_stop_at_limit)
  544.         {
  545.           int q;

  547.           if (set_terminal)
  548.             target_terminal_ours ();
  549.           q = yquery (_("Do you want to auto delete previous execution "
  550.                         "log entries when record/replay buffer becomes "
  551.                         "full (record full stop-at-limit)?"));
  552.           if (set_terminal)
  553.             target_terminal_inferior ();
  554.           if (q)
  555.             record_full_stop_at_limit = 0;
  556.           else
  557.             error (_("Process record: stopped by user."));
  558.         }
  559.     }
  560. }

  562. static void
  563. ‌record_full_arch_list_cleanups (void *ignore)
  564. {
  565.   record_full_list_release (record_full_arch_list_tail);
  566. }

  568. /* Before inferior step (when GDB record the running message, inferior
  569.    only can step), GDB will call this function to record the values to
  570.    record_full_list.  This function will call gdbarch_process_record to
  571.    record the running message of inferior and set them to
  572.    record_full_arch_list, and add it to record_full_list.  */

  574. static int
  575. ‌record_full_message (struct regcache *regcache, enum gdb_signal signal)
  576. {
  577.   int ret;
  578.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  579.   struct cleanup *old_cleanups
  580.     = make_cleanup (record_full_arch_list_cleanups, 0);

  582.   record_full_arch_list_head = NULL;
  583.   record_full_arch_list_tail = NULL;

  585.   /* Check record_full_insn_num.  */
  586.   record_full_check_insn_num (1);

  588.   /* If gdb sends a signal value to target_resume,
  589.      save it in the 'end' field of the previous instruction.

  591.      Maybe process record should record what really happened,
  592.      rather than what gdb pretends has happened.

  594.      So if Linux delivered the signal to the child process during
  595.      the record mode, we will record it and deliver it again in
  596.      the replay mode.

  598.      If user says "ignore this signal" during the record mode, then
  599.      it will be ignored again during the replay mode (no matter if
  600.      the user says something different, like "deliver this signal"
  601.      during the replay mode).

  603.      User should understand that nothing he does during the replay
  604.      mode will change the behavior of the child.  If he tries,
  605.      then that is a user error.

  607.      But we should still deliver the signal to gdb during the replay,
  608.      if we delivered it during the recording.  Therefore we should
  609.      record the signal during record_full_wait, not
  610.      record_full_resume.  */
  611.   if (record_full_list != &record_full_first)  /* FIXME better way to check */
  612.     {
  613.       gdb_assert (record_full_list->type == record_full_end);
  614.       record_full_list->u.end.sigval = signal;
  615.     }

  617.   if (signal == GDB_SIGNAL_0
  618.       || !gdbarch_process_record_signal_p (gdbarch))
  619.     ret = gdbarch_process_record (gdbarch,
  620.                                   regcache,
  621.                                   regcache_read_pc (regcache));
  622.   else
  623.     ret = gdbarch_process_record_signal (gdbarch,
  624.                                          regcache,
  625.                                          signal);

  627.   if (ret > 0)
  628.     error (_("Process record: inferior program stopped."));
  629.   if (ret < 0)
  630.     error (_("Process record: failed to record execution log."));

  632.   discard_cleanups (old_cleanups);

  634.   record_full_list->next = record_full_arch_list_head;
  635.   record_full_arch_list_head->prev = record_full_list;
  636.   record_full_list = record_full_arch_list_tail;

  638.   if (record_full_insn_num == record_full_insn_max_num)
  639.     record_full_list_release_first ();
  640.   else
  641.     record_full_insn_num++;

  643.   return 1;
  644. }

  646. ‌struct record_full_message_args {
  647.   struct regcache *regcache;
  648.   enum gdb_signal signal;
  649. };

  651. static int
  652. ‌record_full_message_wrapper (void *args)
  653. {
  654.   struct record_full_message_args *record_full_args = args;

  656.   return record_full_message (record_full_args->regcache,
  657.                               record_full_args->signal);
  658. }

  660. static int
  661. ‌record_full_message_wrapper_safe (struct regcache *regcache,
  662.                                   enum gdb_signal signal)
  663. {
  664.   struct record_full_message_args args;

  666.   args.regcache = regcache;
  667.   args.signal = signal;

  669.   return catch_errors (record_full_message_wrapper, &args, NULL,
  670.                        RETURN_MASK_ALL);
  671. }

  673. /* Set to 1 if record_full_store_registers and record_full_xfer_partial
  674.    doesn't need record.  */

  676. ‌static int record_full_gdb_operation_disable = 0;

  678. struct cleanup *
  679. ‌record_full_gdb_operation_disable_set (void)
  680. {
  681.   struct cleanup *old_cleanups = NULL;

  683.   old_cleanups =
  684.     make_cleanup_restore_integer (&record_full_gdb_operation_disable);
  685.   record_full_gdb_operation_disable = 1;

  687.   return old_cleanups;
  688. }

  690. /* Flag set to TRUE for target_stopped_by_watchpoint.  */
  691. ‌static int record_full_hw_watchpoint = 0;

  693. /* Execute one instruction from the record log.  Each instruction in
  694.    the log will be represented by an arbitrary sequence of register
  695.    entries and memory entries, followed by an 'end' entry.  */

  697. static inline void
  698. ‌record_full_exec_insn (struct regcache *regcache,
  699.                        struct gdbarch *gdbarch,
  700.                        struct record_full_entry *entry)
  701. {
  702.   switch (entry->type)
  703.     {
  704.     case record_full_reg: /* reg */
  705.       {
  706.         gdb_byte reg[MAX_REGISTER_SIZE];

  708.         if (record_debug > 1)
  709.           fprintf_unfiltered (gdb_stdlog,
  710.                               "Process record: record_full_reg %s to "
  711.                               "inferior num = %d.\n",
  712.                               host_address_to_string (entry),
  713.                               entry->u.reg.num);

  715.         regcache_cooked_read (regcache, entry->u.reg.num, reg);
  716.         regcache_cooked_write (regcache, entry->u.reg.num,
  717.                                record_full_get_loc (entry));
  718.         memcpy (record_full_get_loc (entry), reg, entry->u.reg.len);
  719.       }
  720.       break;

  722.     case record_full_mem: /* mem */
  723.       {
  724.         /* Nothing to do if the entry is flagged not_accessible.  */
  725.         if (!entry->u.mem.mem_entry_not_accessible)
  726.           {
  727.             gdb_byte *mem = alloca (entry->u.mem.len);

  729.             if (record_debug > 1)
  730.               fprintf_unfiltered (gdb_stdlog,
  731.                                   "Process record: record_full_mem %s to "
  732.                                   "inferior addr = %s len = %d.\n",
  733.                                   host_address_to_string (entry),
  734.                                   paddress (gdbarch, entry->u.mem.addr),
  735.                                   entry->u.mem.len);

  737.             if (record_read_memory (gdbarch,
  738.                                     entry->u.mem.addr, mem, entry->u.mem.len))
  739.               entry->u.mem.mem_entry_not_accessible = 1;
  740.             else
  741.               {
  742.                 if (target_write_memory (entry->u.mem.addr,
  743.                                          record_full_get_loc (entry),
  744.                                          entry->u.mem.len))
  745.                   {
  746.                     entry->u.mem.mem_entry_not_accessible = 1;
  747.                     if (record_debug)
  748.                       warning (_("Process record: error writing memory at "
  749.                                  "addr = %s len = %d."),
  750.                                paddress (gdbarch, entry->u.mem.addr),
  751.                                entry->u.mem.len);
  752.                   }
  753.                 else
  754.                   {
  755.                     memcpy (record_full_get_loc (entry), mem,
  756.                             entry->u.mem.len);

  758.                     /* We've changed memory --- check if a hardware
  759.                        watchpoint should trap.  Note that this
  760.                        presently assumes the target beneath supports
  761.                        continuable watchpoints.  On non-continuable
  762.                        watchpoints target, we'll want to check this
  763.                        _before_ actually doing the memory change, and
  764.                        not doing the change at all if the watchpoint
  765.                        traps.  */
  766.                     if (hardware_watchpoint_inserted_in_range
  767.                         (get_regcache_aspace (regcache),
  768.                          entry->u.mem.addr, entry->u.mem.len))
  769.                       record_full_hw_watchpoint = 1;
  770.                   }
  771.               }
  772.           }
  773.       }
  774.       break;
  775.     }
  776. }

  778. static void record_full_restore (void);

  780. /* Asynchronous signal handle registered as event loop source for when
  781.    we have pending events ready to be passed to the core.  */

  783. ‌static struct async_event_handler *record_full_async_inferior_event_token;

  785. static void
  786. ‌record_full_async_inferior_event_handler (gdb_client_data data)
  787. {
  788.   inferior_event_handler (INF_REG_EVENT, NULL);
  789. }

  791. /* Open the process record target.  */

  793. static void
  794. ‌record_full_core_open_1 (const char *name, int from_tty)
  795. {
  796.   struct regcache *regcache = get_current_regcache ();
  797.   int regnum = gdbarch_num_regs (get_regcache_arch (regcache));
  798.   int i;

  800.   /* Get record_full_core_regbuf.  */
  801.   target_fetch_registers (regcache, -1);
  802.   record_full_core_regbuf = xmalloc (MAX_REGISTER_SIZE * regnum);
  803.   for (i = 0; i < regnum; i ++)
  804.     regcache_raw_collect (regcache, i,
  805.                           record_full_core_regbuf + MAX_REGISTER_SIZE * i);

  807.   /* Get record_full_core_start and record_full_core_end.  */
  808.   if (build_section_table (core_bfd, &record_full_core_start,
  809.                            &record_full_core_end))
  810.     {
  811.       xfree (record_full_core_regbuf);
  812.       record_full_core_regbuf = NULL;
  813.       error (_("\"%s\": Can't find sections: %s"),
  814.              bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
  815.     }

  817.   push_target (&record_full_core_ops);
  818.   record_full_restore ();
  819. }

  821. /* "to_open" target method for 'live' processes.  */

  823. static void
  824. ‌record_full_open_1 (const char *name, int from_tty)
  825. {
  826.   if (record_debug)
  827.     fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");

  829.   /* check exec */
  830.   if (!target_has_execution)
  831.     error (_("Process record: the program is not being run."));
  832.   if (non_stop)
  833.     error (_("Process record target can't debug inferior in non-stop mode "
  834.              "(non-stop)."));

  836.   if (!gdbarch_process_record_p (target_gdbarch ()))
  837.     error (_("Process record: the current architecture doesn't support "
  838.              "record function."));

  840.   push_target (&record_full_ops);
  841. }

  843. static void record_full_init_record_breakpoints (void);

  845. /* "to_open" target method.  Open the process record target.  */

  847. static void
  848. ‌record_full_open (const char *name, int from_tty)
  849. {
  850.   struct target_ops *t;

  852.   if (record_debug)
  853.     fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");

  855.   record_preopen ();

  857.   /* Reset */
  858.   record_full_insn_num = 0;
  859.   record_full_insn_count = 0;
  860.   record_full_list = &record_full_first;
  861.   record_full_list->next = NULL;

  863.   if (core_bfd)
  864.     record_full_core_open_1 (name, from_tty);
  865.   else
  866.     record_full_open_1 (name, from_tty);

  868.   /* Register extra event sources in the event loop.  */
  869.   record_full_async_inferior_event_token
  870.     = create_async_event_handler (record_full_async_inferior_event_handler,
  871.                                   NULL);

  873.   record_full_init_record_breakpoints ();

  875.   observer_notify_record_changed (current_inferior (),  1);
  876. }

  878. /* "to_close" target method.  Close the process record target.  */

  880. static void
  881. ‌record_full_close (struct target_ops *self)
  882. {
  883.   struct record_full_core_buf_entry *entry;

  885.   if (record_debug)
  886.     fprintf_unfiltered (gdb_stdlog, "Process record: record_full_close\n");

  888.   record_full_list_release (record_full_list);

  890.   /* Release record_full_core_regbuf.  */
  891.   if (record_full_core_regbuf)
  892.     {
  893.       xfree (record_full_core_regbuf);
  894.       record_full_core_regbuf = NULL;
  895.     }

  897.   /* Release record_full_core_buf_list.  */
  898.   if (record_full_core_buf_list)
  899.     {
  900.       for (entry = record_full_core_buf_list->prev; entry;
  901.            entry = entry->prev)
  902.         {
  903.           xfree (record_full_core_buf_list);
  904.           record_full_core_buf_list = entry;
  905.         }
  906.       record_full_core_buf_list = NULL;
  907.     }

  909.   if (record_full_async_inferior_event_token)
  910.     delete_async_event_handler (&record_full_async_inferior_event_token);
  911. }

  913. ‌static int record_full_resume_step = 0;

  915. /* True if we've been resumed, and so each record_full_wait call should
  916.    advance execution.  If this is false, record_full_wait will return a
  917.    TARGET_WAITKIND_IGNORE.  */
  918. ‌static int record_full_resumed = 0;

  920. /* The execution direction of the last resume we got.  This is
  921.    necessary for async mode.  Vis (order is not strictly accurate):

  923.    1. user has the global execution direction set to forward
  924.    2. user does a reverse-step command
  925.    3. record_full_resume is called with global execution direction
  926.       temporarily switched to reverse
  927.    4. GDB's execution direction is reverted back to forward
  928.    5. target record notifies event loop there's an event to handle
  929.    6. infrun asks the target which direction was it going, and switches
  930.       the global execution direction accordingly (to reverse)
  931.    7. infrun polls an event out of the record target, and handles it
  932.    8. GDB goes back to the event loop, and goto #4.
  933. */
  934. ‌static enum exec_direction_kind record_full_execution_dir = EXEC_FORWARD;

  936. /* "to_resume" target method.  Resume the process record target.  */

  938. static void
  939. ‌record_full_resume (struct target_ops *ops, ptid_t ptid, int step,
  940.                     enum gdb_signal signal)
  941. {
  942.   record_full_resume_step = step;
  943.   record_full_resumed = 1;
  944.   record_full_execution_dir = execution_direction;

  946.   if (!RECORD_FULL_IS_REPLAY)
  947.     {
  948.       struct gdbarch *gdbarch = target_thread_architecture (ptid);

  950.       record_full_message (get_current_regcache (), signal);

  952.       if (!step)
  953.         {
  954.           /* This is not hard single step.  */
  955.           if (!gdbarch_software_single_step_p (gdbarch))
  956.             {
  957.               /* This is a normal continue.  */
  958.               step = 1;
  959.             }
  960.           else
  961.             {
  962.               /* This arch support soft sigle step.  */
  963.               if (thread_has_single_step_breakpoints_set (inferior_thread ()))
  964.                 {
  965.                   /* This is a soft single step.  */
  966.                   record_full_resume_step = 1;
  967.                 }
  968.               else
  969.                 {
  970.                   /* This is a continue.
  971.                      Try to insert a soft single step breakpoint.  */
  972.                   if (!gdbarch_software_single_step (gdbarch,
  973.                                                      get_current_frame ()))
  974.                     {
  975.                       /* This system don't want use soft single step.
  976.                          Use hard sigle step.  */
  977.                       step = 1;
  978.                     }
  979.                 }
  980.             }
  981.         }

  983.       /* Make sure the target beneath reports all signals.  */
  984.       target_pass_signals (0, NULL);

  986.       ops->beneath->to_resume (ops->beneath, ptid, step, signal);
  987.     }

  989.   /* We are about to start executing the inferior (or simulate it),
  990.      let's register it with the event loop.  */
  991.   if (target_can_async_p ())
  992.     {
  993.       target_async (inferior_event_handler, 0);
  994.       /* Notify the event loop there's an event to wait for.  We do
  995.          most of the work in record_full_wait.  */
  996.       mark_async_event_handler (record_full_async_inferior_event_token);
  997.     }
  998. }

  1000. ‌static int record_full_get_sig = 0;

  1002. /* SIGINT signal handler, registered by "to_wait" method.  */

  1004. static void
  1005. ‌record_full_sig_handler (int signo)
  1006. {
  1007.   if (record_debug)
  1008.     fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");

  1010.   /* It will break the running inferior in replay mode.  */
  1011.   record_full_resume_step = 1;

  1013.   /* It will let record_full_wait set inferior status to get the signal
  1014.      SIGINT.  */
  1015.   record_full_get_sig = 1;
  1016. }

  1018. static void
  1019. ‌record_full_wait_cleanups (void *ignore)
  1020. {
  1021.   if (execution_direction == EXEC_REVERSE)
  1022.     {
  1023.       if (record_full_list->next)
  1024.         record_full_list = record_full_list->next;
  1025.     }
  1026.   else
  1027.     record_full_list = record_full_list->prev;
  1028. }

  1030. /* "to_wait" target method for process record target.

  1032.    In record mode, the target is always run in singlestep mode
  1033.    (even when gdb says to continue).  The to_wait method intercepts
  1034.    the stop events and determines which ones are to be passed on to
  1035.    gdb.  Most stop events are just singlestep events that gdb is not
  1036.    to know about, so the to_wait method just records them and keeps
  1037.    singlestepping.

  1039.    In replay mode, this function emulates the recorded execution log,
  1040.    one instruction at a time (forward or backward), and determines
  1041.    where to stop.  */

  1043. static ptid_t
  1044. ‌record_full_wait_1 (struct target_ops *ops,
  1045.                     ptid_t ptid, struct target_waitstatus *status,
  1046.                     int options)
  1047. {
  1048.   struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();

  1050.   if (record_debug)
  1051.     fprintf_unfiltered (gdb_stdlog,
  1052.                         "Process record: record_full_wait "
  1053.                         "record_full_resume_step = %d, "
  1054.                         "record_full_resumed = %d, direction=%s\n",
  1055.                         record_full_resume_step, record_full_resumed,
  1056.                         record_full_execution_dir == EXEC_FORWARD
  1057.                         ? "forward" : "reverse");

  1059.   if (!record_full_resumed)
  1060.     {
  1061.       gdb_assert ((options & TARGET_WNOHANG) != 0);

  1063.       /* No interesting event.  */
  1064.       status->kind = TARGET_WAITKIND_IGNORE;
  1065.       return minus_one_ptid;
  1066.     }

  1068.   record_full_get_sig = 0;
  1069.   signal (SIGINT, record_full_sig_handler);

  1071.   if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
  1072.     {
  1073.       if (record_full_resume_step)
  1074.         {
  1075.           /* This is a single step.  */
  1076.           return ops->beneath->to_wait (ops->beneath, ptid, status, options);
  1077.         }
  1078.       else
  1079.         {
  1080.           /* This is not a single step.  */
  1081.           ptid_t ret;
  1082.           CORE_ADDR tmp_pc;
  1083.           struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);

  1085.           while (1)
  1086.             {
  1087.               struct thread_info *tp;

  1089.               ret = ops->beneath->to_wait (ops->beneath, ptid, status, options);
  1090.               if (status->kind == TARGET_WAITKIND_IGNORE)
  1091.                 {
  1092.                   if (record_debug)
  1093.                     fprintf_unfiltered (gdb_stdlog,
  1094.                                         "Process record: record_full_wait "
  1095.                                         "target beneath not done yet\n");
  1096.                   return ret;
  1097.                 }

  1099.               ALL_NON_EXITED_THREADS (tp)
  1100.                 delete_single_step_breakpoints (tp);

  1102.               if (record_full_resume_step)
  1103.                 return ret;

  1105.               /* Is this a SIGTRAP?  */
  1106.               if (status->kind == TARGET_WAITKIND_STOPPED
  1107.                   && status->value.sig == GDB_SIGNAL_TRAP)
  1108.                 {
  1109.                   struct regcache *regcache;
  1110.                   struct address_space *aspace;

  1112.                   /* Yes -- this is likely our single-step finishing,
  1113.                      but check if there's any reason the core would be
  1114.                      interested in the event.  */

  1116.                   registers_changed ();
  1117.                   regcache = get_current_regcache ();
  1118.                   tmp_pc = regcache_read_pc (regcache);
  1119.                   aspace = get_regcache_aspace (regcache);

  1121.                   if (target_stopped_by_watchpoint ())
  1122.                     {
  1123.                       /* Always interested in watchpoints.  */
  1124.                     }
  1125.                   else if (breakpoint_inserted_here_p (aspace, tmp_pc))
  1126.                     {
  1127.                       /* There is a breakpoint here.  Let the core
  1128.                          handle it.  */
  1129.                       if (software_breakpoint_inserted_here_p (aspace, tmp_pc))
  1130.                         {
  1131.                           struct gdbarch *gdbarch
  1132.                             = get_regcache_arch (regcache);
  1133.                           CORE_ADDR decr_pc_after_break
  1134.                             = target_decr_pc_after_break (gdbarch);
  1135.                           if (decr_pc_after_break)
  1136.                             regcache_write_pc (regcache,
  1137.                                                tmp_pc + decr_pc_after_break);
  1138.                         }
  1139.                     }
  1140.                   else
  1141.                     {
  1142.                       /* This is a single-step trap.  Record the
  1143.                          insn and issue another step.
  1144.                          FIXME: this part can be a random SIGTRAP too.
  1145.                          But GDB cannot handle it.  */
  1146.                       int step = 1;

  1148.                       if (!record_full_message_wrapper_safe (regcache,
  1149.                                                              GDB_SIGNAL_0))
  1150.                           {
  1151.                            status->kind = TARGET_WAITKIND_STOPPED;
  1152.                            status->value.sig = GDB_SIGNAL_0;
  1153.                            break;
  1154.                           }

  1156.                       if (gdbarch_software_single_step_p (gdbarch))
  1157.                         {
  1158.                           /* Try to insert the software single step breakpoint.
  1159.                              If insert success, set step to 0.  */
  1160.                           set_executing (inferior_ptid, 0);
  1161.                           reinit_frame_cache ();
  1162.                           if (gdbarch_software_single_step (gdbarch,
  1163.                                                             get_current_frame ()))
  1164.                             step = 0;
  1165.                           set_executing (inferior_ptid, 1);
  1166.                         }

  1168.                       if (record_debug)
  1169.                         fprintf_unfiltered (gdb_stdlog,
  1170.                                             "Process record: record_full_wait "
  1171.                                             "issuing one more step in the "
  1172.                                             "target beneath\n");
  1173.                       ops->beneath->to_resume (ops->beneath, ptid, step,
  1174.                                                GDB_SIGNAL_0);
  1175.                       continue;
  1176.                     }
  1177.                 }

  1179.               /* The inferior is broken by a breakpoint or a signal.  */
  1180.               break;
  1181.             }

  1183.           return ret;
  1184.         }
  1185.     }
  1186.   else
  1187.     {
  1188.       struct regcache *regcache = get_current_regcache ();
  1189.       struct gdbarch *gdbarch = get_regcache_arch (regcache);
  1190.       struct address_space *aspace = get_regcache_aspace (regcache);
  1191.       int continue_flag = 1;
  1192.       int first_record_full_end = 1;
  1193.       struct cleanup *old_cleanups
  1194.         = make_cleanup (record_full_wait_cleanups, 0);
  1195.       CORE_ADDR tmp_pc;

  1197.       record_full_hw_watchpoint = 0;
  1198.       status->kind = TARGET_WAITKIND_STOPPED;

  1200.       /* Check breakpoint when forward execute.  */
  1201.       if (execution_direction == EXEC_FORWARD)
  1202.         {
  1203.           tmp_pc = regcache_read_pc (regcache);
  1204.           if (breakpoint_inserted_here_p (aspace, tmp_pc))
  1205.             {
  1206.               int decr_pc_after_break = target_decr_pc_after_break (gdbarch);

  1208.               if (record_debug)
  1209.                 fprintf_unfiltered (gdb_stdlog,
  1210.                                     "Process record: break at %s.\n",
  1211.                                     paddress (gdbarch, tmp_pc));

  1213.               if (decr_pc_after_break
  1214.                   && !record_full_resume_step
  1215.                   && software_breakpoint_inserted_here_p (aspace, tmp_pc))
  1216.                 regcache_write_pc (regcache,
  1217.                                    tmp_pc + decr_pc_after_break);
  1218.               goto replay_out;
  1219.             }
  1220.         }

  1222.       /* If GDB is in terminal_inferior mode, it will not get the signal.
  1223.          And in GDB replay mode, GDB doesn't need to be in terminal_inferior
  1224.          mode, because inferior will not executed.
  1225.          Then set it to terminal_ours to make GDB get the signal.  */
  1226.       target_terminal_ours ();

  1228.       /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
  1229.          instruction.  */
  1230.       if (execution_direction == EXEC_FORWARD && record_full_list->next)
  1231.         record_full_list = record_full_list->next;

  1233.       /* Loop over the record_full_list, looking for the next place to
  1234.          stop.  */
  1235.       do
  1236.         {
  1237.           /* Check for beginning and end of log.  */
  1238.           if (execution_direction == EXEC_REVERSE
  1239.               && record_full_list == &record_full_first)
  1240.             {
  1241.               /* Hit beginning of record log in reverse.  */
  1242.               status->kind = TARGET_WAITKIND_NO_HISTORY;
  1243.               break;
  1244.             }
  1245.           if (execution_direction != EXEC_REVERSE && !record_full_list->next)
  1246.             {
  1247.               /* Hit end of record log going forward.  */
  1248.               status->kind = TARGET_WAITKIND_NO_HISTORY;
  1249.               break;
  1250.             }

  1252.           record_full_exec_insn (regcache, gdbarch, record_full_list);

  1254.           if (record_full_list->type == record_full_end)
  1255.             {
  1256.               if (record_debug > 1)
  1257.                 fprintf_unfiltered (gdb_stdlog,
  1258.                                     "Process record: record_full_end %s to "
  1259.                                     "inferior.\n",
  1260.                                     host_address_to_string (record_full_list));

  1262.               if (first_record_full_end && execution_direction == EXEC_REVERSE)
  1263.                 {
  1264.                   /* When reverse excute, the first record_full_end is the
  1265.                      part of current instruction.  */
  1266.                   first_record_full_end = 0;
  1267.                 }
  1268.               else
  1269.                 {
  1270.                   /* In EXEC_REVERSE mode, this is the record_full_end of prev
  1271.                      instruction.
  1272.                      In EXEC_FORWARD mode, this is the record_full_end of
  1273.                      current instruction.  */
  1274.                   /* step */
  1275.                   if (record_full_resume_step)
  1276.                     {
  1277.                       if (record_debug > 1)
  1278.                         fprintf_unfiltered (gdb_stdlog,
  1279.                                             "Process record: step.\n");
  1280.                       continue_flag = 0;
  1281.                     }

  1283.                   /* check breakpoint */
  1284.                   tmp_pc = regcache_read_pc (regcache);
  1285.                   if (breakpoint_inserted_here_p (aspace, tmp_pc))
  1286.                     {
  1287.                       int decr_pc_after_break
  1288.                         = target_decr_pc_after_break (gdbarch);

  1290.                       if (record_debug)
  1291.                         fprintf_unfiltered (gdb_stdlog,
  1292.                                             "Process record: break "
  1293.                                             "at %s.\n",
  1294.                                             paddress (gdbarch, tmp_pc));
  1295.                       if (decr_pc_after_break
  1296.                           && execution_direction == EXEC_FORWARD
  1297.                           && !record_full_resume_step
  1298.                           && software_breakpoint_inserted_here_p (aspace,
  1299.                                                                   tmp_pc))
  1300.                         regcache_write_pc (regcache,
  1301.                                            tmp_pc + decr_pc_after_break);
  1302.                       continue_flag = 0;
  1303.                     }

  1305.                   if (record_full_hw_watchpoint)
  1306.                     {
  1307.                       if (record_debug)
  1308.                         fprintf_unfiltered (gdb_stdlog,
  1309.                                             "Process record: hit hw "
  1310.                                             "watchpoint.\n");
  1311.                       continue_flag = 0;
  1312.                     }
  1313.                   /* Check target signal */
  1314.                   if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
  1315.                     /* FIXME: better way to check */
  1316.                     continue_flag = 0;
  1317.                 }
  1318.             }

  1320.           if (continue_flag)
  1321.             {
  1322.               if (execution_direction == EXEC_REVERSE)
  1323.                 {
  1324.                   if (record_full_list->prev)
  1325.                     record_full_list = record_full_list->prev;
  1326.                 }
  1327.               else
  1328.                 {
  1329.                   if (record_full_list->next)
  1330.                     record_full_list = record_full_list->next;
  1331.                 }
  1332.             }
  1333.         }
  1334.       while (continue_flag);

  1336. replay_out:
  1337.       if (record_full_get_sig)
  1338.         status->value.sig = GDB_SIGNAL_INT;
  1339.       else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
  1340.         /* FIXME: better way to check */
  1341.         status->value.sig = record_full_list->u.end.sigval;
  1342.       else
  1343.         status->value.sig = GDB_SIGNAL_TRAP;

  1345.       discard_cleanups (old_cleanups);
  1346.     }

  1348.   signal (SIGINT, handle_sigint);

  1350.   do_cleanups (set_cleanups);
  1351.   return inferior_ptid;
  1352. }

  1354. static ptid_t
  1355. ‌record_full_wait (struct target_ops *ops,
  1356.                   ptid_t ptid, struct target_waitstatus *status,
  1357.                   int options)
  1358. {
  1359.   ptid_t return_ptid;

  1361.   return_ptid = record_full_wait_1 (ops, ptid, status, options);
  1362.   if (status->kind != TARGET_WAITKIND_IGNORE)
  1363.     {
  1364.       /* We're reporting a stop.  Make sure any spurious
  1365.          target_wait(WNOHANG) doesn't advance the target until the
  1366.          core wants us resumed again.  */
  1367.       record_full_resumed = 0;
  1368.     }
  1369.   return return_ptid;
  1370. }

  1372. static int
  1373. ‌record_full_stopped_by_watchpoint (struct target_ops *ops)
  1374. {
  1375.   if (RECORD_FULL_IS_REPLAY)
  1376.     return record_full_hw_watchpoint;
  1377.   else
  1378.     return ops->beneath->to_stopped_by_watchpoint (ops->beneath);
  1379. }

  1381. static int
  1382. ‌record_full_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
  1383. {
  1384.   if (RECORD_FULL_IS_REPLAY)
  1385.     return 0;
  1386.   else
  1387.     return ops->beneath->to_stopped_data_address (ops->beneath, addr_p);
  1388. }

  1390. /* Record registers change (by user or by GDB) to list as an instruction.  */

  1392. static void
  1393. ‌record_full_registers_change (struct regcache *regcache, int regnum)
  1394. {
  1395.   /* Check record_full_insn_num.  */
  1396.   record_full_check_insn_num (0);

  1398.   record_full_arch_list_head = NULL;
  1399.   record_full_arch_list_tail = NULL;

  1401.   if (regnum < 0)
  1402.     {
  1403.       int i;

  1405.       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
  1406.         {
  1407.           if (record_full_arch_list_add_reg (regcache, i))
  1408.             {
  1409.               record_full_list_release (record_full_arch_list_tail);
  1410.               error (_("Process record: failed to record execution log."));
  1411.             }
  1412.         }
  1413.     }
  1414.   else
  1415.     {
  1416.       if (record_full_arch_list_add_reg (regcache, regnum))
  1417.         {
  1418.           record_full_list_release (record_full_arch_list_tail);
  1419.           error (_("Process record: failed to record execution log."));
  1420.         }
  1421.     }
  1422.   if (record_full_arch_list_add_end ())
  1423.     {
  1424.       record_full_list_release (record_full_arch_list_tail);
  1425.       error (_("Process record: failed to record execution log."));
  1426.     }
  1427.   record_full_list->next = record_full_arch_list_head;
  1428.   record_full_arch_list_head->prev = record_full_list;
  1429.   record_full_list = record_full_arch_list_tail;

  1431.   if (record_full_insn_num == record_full_insn_max_num)
  1432.     record_full_list_release_first ();
  1433.   else
  1434.     record_full_insn_num++;
  1435. }

  1437. /* "to_store_registers" method for process record target.  */

  1439. static void
  1440. ‌record_full_store_registers (struct target_ops *ops,
  1441.                              struct regcache *regcache,
  1442.                              int regno)
  1443. {
  1444.   if (!record_full_gdb_operation_disable)
  1445.     {
  1446.       if (RECORD_FULL_IS_REPLAY)
  1447.         {
  1448.           int n;

  1450.           /* Let user choose if he wants to write register or not.  */
  1451.           if (regno < 0)
  1452.             n =
  1453.               query (_("Because GDB is in replay mode, changing the "
  1454.                        "value of a register will make the execution "
  1455.                        "log unusable from this point onward.  "
  1456.                        "Change all registers?"));
  1457.           else
  1458.             n =
  1459.               query (_("Because GDB is in replay mode, changing the value "
  1460.                        "of a register will make the execution log unusable "
  1461.                        "from this point onward.  Change register %s?"),
  1462.                       gdbarch_register_name (get_regcache_arch (regcache),
  1463.                                                regno));

  1465.           if (!n)
  1466.             {
  1467.               /* Invalidate the value of regcache that was set in function
  1468.                  "regcache_raw_write".  */
  1469.               if (regno < 0)
  1470.                 {
  1471.                   int i;

  1473.                   for (i = 0;
  1474.                        i < gdbarch_num_regs (get_regcache_arch (regcache));
  1475.                        i++)
  1476.                     regcache_invalidate (regcache, i);
  1477.                 }
  1478.               else
  1479.                 regcache_invalidate (regcache, regno);

  1481.               error (_("Process record canceled the operation."));
  1482.             }

  1484.           /* Destroy the record from here forward.  */
  1485.           record_full_list_release_following (record_full_list);
  1486.         }

  1488.       record_full_registers_change (regcache, regno);
  1489.     }
  1490.   ops->beneath->to_store_registers (ops->beneath, regcache, regno);
  1491. }

  1493. /* "to_xfer_partial" method.  Behavior is conditional on
  1494.    RECORD_FULL_IS_REPLAY.
  1495.    In replay mode, we cannot write memory unles we are willing to
  1496.    invalidate the record/replay log from this point forward.  */

  1498. static enum target_xfer_status
  1499. ‌record_full_xfer_partial (struct target_ops *ops, enum target_object object,
  1500.                           const char *annex, gdb_byte *readbuf,
  1501.                           const gdb_byte *writebuf, ULONGEST offset,
  1502.                           ULONGEST len, ULONGEST *xfered_len)
  1503. {
  1504.   if (!record_full_gdb_operation_disable
  1505.       && (object == TARGET_OBJECT_MEMORY
  1506.           || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
  1507.     {
  1508.       if (RECORD_FULL_IS_REPLAY)
  1509.         {
  1510.           /* Let user choose if he wants to write memory or not.  */
  1511.           if (!query (_("Because GDB is in replay mode, writing to memory "
  1512.                         "will make the execution log unusable from this "
  1513.                         "point onward.  Write memory at address %s?"),
  1514.                        paddress (target_gdbarch (), offset)))
  1515.             error (_("Process record canceled the operation."));

  1517.           /* Destroy the record from here forward.  */
  1518.           record_full_list_release_following (record_full_list);
  1519.         }

  1521.       /* Check record_full_insn_num */
  1522.       record_full_check_insn_num (0);

  1524.       /* Record registers change to list as an instruction.  */
  1525.       record_full_arch_list_head = NULL;
  1526.       record_full_arch_list_tail = NULL;
  1527.       if (record_full_arch_list_add_mem (offset, len))
  1528.         {
  1529.           record_full_list_release (record_full_arch_list_tail);
  1530.           if (record_debug)
  1531.             fprintf_unfiltered (gdb_stdlog,
  1532.                                 "Process record: failed to record "
  1533.                                 "execution log.");
  1534.           return TARGET_XFER_E_IO;
  1535.         }
  1536.       if (record_full_arch_list_add_end ())
  1537.         {
  1538.           record_full_list_release (record_full_arch_list_tail);
  1539.           if (record_debug)
  1540.             fprintf_unfiltered (gdb_stdlog,
  1541.                                 "Process record: failed to record "
  1542.                                 "execution log.");
  1543.           return TARGET_XFER_E_IO;
  1544.         }
  1545.       record_full_list->next = record_full_arch_list_head;
  1546.       record_full_arch_list_head->prev = record_full_list;
  1547.       record_full_list = record_full_arch_list_tail;

  1549.       if (record_full_insn_num == record_full_insn_max_num)
  1550.         record_full_list_release_first ();
  1551.       else
  1552.         record_full_insn_num++;
  1553.     }

  1555.   return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
  1556.                                         readbuf, writebuf, offset,
  1557.                                         len, xfered_len);
  1558. }

  1560. /* This structure represents a breakpoint inserted while the record
  1561.    target is active.  We use this to know when to install/remove
  1562.    breakpoints in/from the target beneath.  For example, a breakpoint
  1563.    may be inserted while recording, but removed when not replaying nor
  1564.    recording.  In that case, the breakpoint had not been inserted on
  1565.    the target beneath, so we should not try to remove it there.  */

  1567. ‌struct record_full_breakpoint
  1568. {
  1569.   /* The address and address space the breakpoint was set at.  */
  1570.   struct address_space *address_space;
  1571.   CORE_ADDR addr;

  1573.   /* True when the breakpoint has been also installed in the target
  1574.      beneath.  This will be false for breakpoints set during replay or
  1575.      when recording.  */
  1576.   int in_target_beneath;
  1577. };

  1579. ‌typedef struct record_full_breakpoint *record_full_breakpoint_p;
  1580. ‌DEF_VEC_P(record_full_breakpoint_p);

  1582. /* The list of breakpoints inserted while the record target is
  1583.    active.  */
  1584. VEC(record_full_breakpoint_p) *record_full_breakpoints = NULL;

  1586. static void
  1587. ‌record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
  1588. {
  1589.   if (loc->loc_type != bp_loc_software_breakpoint)
  1590.       return;

  1592.   if (loc->inserted)
  1593.     {
  1594.       struct record_full_breakpoint *bp = XNEW (struct record_full_breakpoint);

  1596.       bp->addr = loc->target_info.placed_address;
  1597.       bp->address_space = loc->target_info.placed_address_space;

  1599.       bp->in_target_beneath = 1;

  1601.       VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
  1602.     }
  1603. }

  1605. /* Sync existing breakpoints to record_full_breakpoints.  */

  1607. static void
  1608. ‌record_full_init_record_breakpoints (void)
  1609. {
  1610.   VEC_free (record_full_breakpoint_p, record_full_breakpoints);

  1612.   iterate_over_bp_locations (record_full_sync_record_breakpoints);
  1613. }

  1615. /* Behavior is conditional on RECORD_FULL_IS_REPLAY.  We will not actually
  1616.    insert or remove breakpoints in the real target when replaying, nor
  1617.    when recording.  */

  1619. static int
  1620. ‌record_full_insert_breakpoint (struct target_ops *ops,
  1621.                                struct gdbarch *gdbarch,
  1622.                                struct bp_target_info *bp_tgt)
  1623. {
  1624.   struct record_full_breakpoint *bp;
  1625.   int in_target_beneath = 0;

  1627.   if (!RECORD_FULL_IS_REPLAY)
  1628.     {
  1629.       /* When recording, we currently always single-step, so we don't
  1630.          really need to install regular breakpoints in the inferior.
  1631.          However, we do have to insert software single-step
  1632.          breakpoints, in case the target can't hardware step.  To keep
  1633.          things single, we always insert.  */
  1634.       struct cleanup *old_cleanups;
  1635.       int ret;

  1637.       old_cleanups = record_full_gdb_operation_disable_set ();
  1638.       ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
  1639.       do_cleanups (old_cleanups);

  1641.       if (ret != 0)
  1642.         return ret;

  1644.       in_target_beneath = 1;
  1645.     }

  1647.   bp = XNEW (struct record_full_breakpoint);
  1648.   bp->addr = bp_tgt->placed_address;
  1649.   bp->address_space = bp_tgt->placed_address_space;
  1650.   bp->in_target_beneath = in_target_beneath;
  1651.   VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
  1652.   return 0;
  1653. }

  1655. /* "to_remove_breakpoint" method for process record target.  */

  1657. static int
  1658. ‌record_full_remove_breakpoint (struct target_ops *ops,
  1659.                                struct gdbarch *gdbarch,
  1660.                                struct bp_target_info *bp_tgt)
  1661. {
  1662.   struct record_full_breakpoint *bp;
  1663.   int ix;

  1665.   for (ix = 0;
  1666.        VEC_iterate (record_full_breakpoint_p,
  1667.                     record_full_breakpoints, ix, bp);
  1668.        ++ix)
  1669.     {
  1670.       if (bp->addr == bp_tgt->placed_address
  1671.           && bp->address_space == bp_tgt->placed_address_space)
  1672.         {
  1673.           if (bp->in_target_beneath)
  1674.             {
  1675.               struct cleanup *old_cleanups;
  1676.               int ret;

  1678.               old_cleanups = record_full_gdb_operation_disable_set ();
  1679.               ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch,
  1680.                                                         bp_tgt);
  1681.               do_cleanups (old_cleanups);

  1683.               if (ret != 0)
  1684.                 return ret;
  1685.             }

  1687.           VEC_unordered_remove (record_full_breakpoint_p,
  1688.                                 record_full_breakpoints, ix);
  1689.           return 0;
  1690.         }
  1691.     }

  1693.   gdb_assert_not_reached ("removing unknown breakpoint");
  1694. }

  1696. /* "to_can_execute_reverse" method for process record target.  */

  1698. static int
  1699. ‌record_full_can_execute_reverse (struct target_ops *self)
  1700. {
  1701.   return 1;
  1702. }

  1704. /* "to_get_bookmark" method for process record and prec over core.  */

  1706. static gdb_byte *
  1707. ‌record_full_get_bookmark (struct target_ops *self, const char *args,
  1708.                           int from_tty)
  1709. {
  1710.   char *ret = NULL;

  1712.   /* Return stringified form of instruction count.  */
  1713.   if (record_full_list && record_full_list->type == record_full_end)
  1714.     ret = xstrdup (pulongest (record_full_list->u.end.insn_num));

  1716.   if (record_debug)
  1717.     {
  1718.       if (ret)
  1719.         fprintf_unfiltered (gdb_stdlog,
  1720.                             "record_full_get_bookmark returns %s\n", ret);
  1721.       else
  1722.         fprintf_unfiltered (gdb_stdlog,
  1723.                             "record_full_get_bookmark returns NULL\n");
  1724.     }
  1725.   return (gdb_byte *) ret;
  1726. }

  1728. /* "to_goto_bookmark" method for process record and prec over core.  */

  1730. static void
  1731. ‌record_full_goto_bookmark (struct target_ops *self,
  1732.                            const gdb_byte *raw_bookmark, int from_tty)
  1733. {
  1734.   const char *bookmark = (const char *) raw_bookmark;
  1735.   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);

  1737.   if (record_debug)
  1738.     fprintf_unfiltered (gdb_stdlog,
  1739.                         "record_full_goto_bookmark receives %s\n", bookmark);

  1741.   if (bookmark[0] == '\'' || bookmark[0] == '\"')
  1742.     {
  1743.       char *copy;

  1745.       if (bookmark[strlen (bookmark) - 1] != bookmark[0])
  1746.         error (_("Unbalanced quotes: %s"), bookmark);


  1749.       copy = savestring (bookmark + 1, strlen (bookmark) - 2);
  1750.       make_cleanup (xfree, copy);
  1751.       bookmark = copy;
  1752.     }

  1754.   record_goto (bookmark);

  1756.   do_cleanups (cleanup);
  1757. }

  1759. static enum exec_direction_kind
  1760. ‌record_full_execution_direction (struct target_ops *self)
  1761. {
  1762.   return record_full_execution_dir;
  1763. }

  1765. static void
  1766. ‌record_full_info (struct target_ops *self)
  1767. {
  1768.   struct record_full_entry *p;

  1770.   if (RECORD_FULL_IS_REPLAY)
  1771.     printf_filtered (_("Replay mode:\n"));
  1772.   else
  1773.     printf_filtered (_("Record mode:\n"));

  1775.   /* Find entry for first actual instruction in the log.  */
  1776.   for (p = record_full_first.next;
  1777.        p != NULL && p->type != record_full_end;
  1778.        p = p->next)
  1779.     ;

  1781.   /* Do we have a log at all?  */
  1782.   if (p != NULL && p->type == record_full_end)
  1783.     {
  1784.       /* Display instruction number for first instruction in the log.  */
  1785.       printf_filtered (_("Lowest recorded instruction number is %s.\n"),
  1786.                        pulongest (p->u.end.insn_num));

  1788.       /* If in replay mode, display where we are in the log.  */
  1789.       if (RECORD_FULL_IS_REPLAY)
  1790.         printf_filtered (_("Current instruction number is %s.\n"),
  1791.                          pulongest (record_full_list->u.end.insn_num));

  1793.       /* Display instruction number for last instruction in the log.  */
  1794.       printf_filtered (_("Highest recorded instruction number is %s.\n"),
  1795.                        pulongest (record_full_insn_count));

  1797.       /* Display log count.  */
  1798.       printf_filtered (_("Log contains %u instructions.\n"),
  1799.                        record_full_insn_num);
  1800.     }
  1801.   else
  1802.     printf_filtered (_("No instructions have been logged.\n"));

  1804.   /* Display max log size.  */
  1805.   printf_filtered (_("Max logged instructions is %u.\n"),
  1806.                    record_full_insn_max_num);
  1807. }

  1809. /* The "to_record_delete" target method.  */

  1811. static void
  1812. ‌record_full_delete (struct target_ops *self)
  1813. {
  1814.   record_full_list_release_following (record_full_list);
  1815. }

  1817. /* The "to_record_is_replaying" target method.  */

  1819. static int
  1820. ‌record_full_is_replaying (struct target_ops *self)
  1821. {
  1822.   return RECORD_FULL_IS_REPLAY;
  1823. }

  1825. /* Go to a specific entry.  */

  1827. static void
  1828. ‌record_full_goto_entry (struct record_full_entry *p)
  1829. {
  1830.   if (p == NULL)
  1831.     error (_("Target insn not found."));
  1832.   else if (p == record_full_list)
  1833.     error (_("Already at target insn."));
  1834.   else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
  1835.     {
  1836.       printf_filtered (_("Go forward to insn number %s\n"),
  1837.                        pulongest (p->u.end.insn_num));
  1838.       record_full_goto_insn (p, EXEC_FORWARD);
  1839.     }
  1840.   else
  1841.     {
  1842.       printf_filtered (_("Go backward to insn number %s\n"),
  1843.                        pulongest (p->u.end.insn_num));
  1844.       record_full_goto_insn (p, EXEC_REVERSE);
  1845.     }

  1847.   registers_changed ();
  1848.   reinit_frame_cache ();
  1849.   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
  1850. }

  1852. /* The "to_goto_record_begin" target method.  */

  1854. static void
  1855. ‌record_full_goto_begin (struct target_ops *self)
  1856. {
  1857.   struct record_full_entry *p = NULL;

  1859.   for (p = &record_full_first; p != NULL; p = p->next)
  1860.     if (p->type == record_full_end)
  1861.       break;

  1863.   record_full_goto_entry (p);
  1864. }

  1866. /* The "to_goto_record_end" target method.  */

  1868. static void
  1869. ‌record_full_goto_end (struct target_ops *self)
  1870. {
  1871.   struct record_full_entry *p = NULL;

  1873.   for (p = record_full_list; p->next != NULL; p = p->next)
  1874.     ;
  1875.   for (; p!= NULL; p = p->prev)
  1876.     if (p->type == record_full_end)
  1877.       break;

  1879.   record_full_goto_entry (p);
  1880. }

  1882. /* The "to_goto_record" target method.  */

  1884. static void
  1885. ‌record_full_goto (struct target_ops *self, ULONGEST target_insn)
  1886. {
  1887.   struct record_full_entry *p = NULL;

  1889.   for (p = &record_full_first; p != NULL; p = p->next)
  1890.     if (p->type == record_full_end && p->u.end.insn_num == target_insn)
  1891.       break;

  1893.   record_full_goto_entry (p);
  1894. }

  1896. static void
  1897. ‌init_record_full_ops (void)
  1898. {
  1899.   record_full_ops.to_shortname = "record-full";
  1900.   record_full_ops.to_longname = "Process record and replay target";
  1901.   record_full_ops.to_doc =
  1902.     "Log program while executing and replay execution from log.";
  1903.   record_full_ops.to_open = record_full_open;
  1904.   record_full_ops.to_close = record_full_close;
  1905.   record_full_ops.to_resume = record_full_resume;
  1906.   record_full_ops.to_wait = record_full_wait;
  1907.   record_full_ops.to_disconnect = record_disconnect;
  1908.   record_full_ops.to_detach = record_detach;
  1909.   record_full_ops.to_mourn_inferior = record_mourn_inferior;
  1910.   record_full_ops.to_kill = record_kill;
  1911.   record_full_ops.to_store_registers = record_full_store_registers;
  1912.   record_full_ops.to_xfer_partial = record_full_xfer_partial;
  1913.   record_full_ops.to_insert_breakpoint = record_full_insert_breakpoint;
  1914.   record_full_ops.to_remove_breakpoint = record_full_remove_breakpoint;
  1915.   record_full_ops.to_stopped_by_watchpoint = record_full_stopped_by_watchpoint;
  1916.   record_full_ops.to_stopped_data_address = record_full_stopped_data_address;
  1917.   record_full_ops.to_can_execute_reverse = record_full_can_execute_reverse;
  1918.   record_full_ops.to_stratum = record_stratum;
  1919.   /* Add bookmark target methods.  */
  1920.   record_full_ops.to_get_bookmark = record_full_get_bookmark;
  1921.   record_full_ops.to_goto_bookmark = record_full_goto_bookmark;
  1922.   record_full_ops.to_execution_direction = record_full_execution_direction;
  1923.   record_full_ops.to_info_record = record_full_info;
  1924.   record_full_ops.to_save_record = record_full_save;
  1925.   record_full_ops.to_delete_record = record_full_delete;
  1926.   record_full_ops.to_record_is_replaying = record_full_is_replaying;
  1927.   record_full_ops.to_goto_record_begin = record_full_goto_begin;
  1928.   record_full_ops.to_goto_record_end = record_full_goto_end;
  1929.   record_full_ops.to_goto_record = record_full_goto;
  1930.   record_full_ops.to_magic = OPS_MAGIC;
  1931. }

  1933. /* "to_resume" method for prec over corefile.  */

  1935. static void
  1936. ‌record_full_core_resume (struct target_ops *ops, ptid_t ptid, int step,
  1937.                          enum gdb_signal signal)
  1938. {
  1939.   record_full_resume_step = step;
  1940.   record_full_resumed = 1;
  1941.   record_full_execution_dir = execution_direction;

  1943.   /* We are about to start executing the inferior (or simulate it),
  1944.      let's register it with the event loop.  */
  1945.   if (target_can_async_p ())
  1946.     {
  1947.       target_async (inferior_event_handler, 0);

  1949.       /* Notify the event loop there's an event to wait for.  */
  1950.       mark_async_event_handler (record_full_async_inferior_event_token);
  1951.     }
  1952. }

  1954. /* "to_kill" method for prec over corefile.  */

  1956. static void
  1957. ‌record_full_core_kill (struct target_ops *ops)
  1958. {
  1959.   if (record_debug)
  1960.     fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");

  1962.   unpush_target (&record_full_core_ops);
  1963. }

  1965. /* "to_fetch_registers" method for prec over corefile.  */

  1967. static void
  1968. ‌record_full_core_fetch_registers (struct target_ops *ops,
  1969.                                   struct regcache *regcache,
  1970.                                   int regno)
  1971. {
  1972.   if (regno < 0)
  1973.     {
  1974.       int num = gdbarch_num_regs (get_regcache_arch (regcache));
  1975.       int i;

  1977.       for (i = 0; i < num; i ++)
  1978.         regcache_raw_supply (regcache, i,
  1979.                              record_full_core_regbuf + MAX_REGISTER_SIZE * i);
  1980.     }
  1981.   else
  1982.     regcache_raw_supply (regcache, regno,
  1983.                          record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
  1984. }

  1986. /* "to_prepare_to_store" method for prec over corefile.  */

  1988. static void
  1989. ‌record_full_core_prepare_to_store (struct target_ops *self,
  1990.                                    struct regcache *regcache)
  1991. {
  1992. }

  1994. /* "to_store_registers" method for prec over corefile.  */

  1996. static void
  1997. ‌record_full_core_store_registers (struct target_ops *ops,
  1998.                              struct regcache *regcache,
  1999.                              int regno)
  2000. {
  2001.   if (record_full_gdb_operation_disable)
  2002.     regcache_raw_collect (regcache, regno,
  2003.                           record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
  2004.   else
  2005.     error (_("You can't do that without a process to debug."));
  2006. }

  2008. /* "to_xfer_partial" method for prec over corefile.  */

  2010. static enum target_xfer_status
  2011. ‌record_full_core_xfer_partial (struct target_ops *ops,
  2012.                                enum target_object object,
  2013.                                const char *annex, gdb_byte *readbuf,
  2014.                                const gdb_byte *writebuf, ULONGEST offset,
  2015.                                ULONGEST len, ULONGEST *xfered_len)
  2016. {
  2017.   if (object == TARGET_OBJECT_MEMORY)
  2018.     {
  2019.       if (record_full_gdb_operation_disable || !writebuf)
  2020.         {
  2021.           struct target_section *p;

  2023.           for (p = record_full_core_start; p < record_full_core_end; p++)
  2024.             {
  2025.               if (offset >= p->addr)
  2026.                 {
  2027.                   struct record_full_core_buf_entry *entry;
  2028.                   ULONGEST sec_offset;

  2030.                   if (offset >= p->endaddr)
  2031.                     continue;

  2033.                   if (offset + len > p->endaddr)
  2034.                     len = p->endaddr - offset;

  2036.                   sec_offset = offset - p->addr;

  2038.                   /* Read readbuf or write writebuf p, offset, len.  */
  2039.                   /* Check flags.  */
  2040.                   if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
  2041.                       || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
  2042.                     {
  2043.                       if (readbuf)
  2044.                         memset (readbuf, 0, len);

  2046.                       *xfered_len = len;
  2047.                       return TARGET_XFER_OK;
  2048.                     }
  2049.                   /* Get record_full_core_buf_entry.  */
  2050.                   for (entry = record_full_core_buf_list; entry;
  2051.                        entry = entry->prev)
  2052.                     if (entry->p == p)
  2053.                       break;
  2054.                   if (writebuf)
  2055.                     {
  2056.                       if (!entry)
  2057.                         {
  2058.                           /* Add a new entry.  */
  2059.                           entry = (struct record_full_core_buf_entry *)
  2060.                             xmalloc
  2061.                             (sizeof (struct record_full_core_buf_entry));
  2062.                           entry->p = p;
  2063.                           if (!bfd_malloc_and_get_section
  2064.                                 (p->the_bfd_section->owner,
  2065.                                  p->the_bfd_section,
  2066.                                  &entry->buf))
  2067.                             {
  2068.                               xfree (entry);
  2069.                               return TARGET_XFER_EOF;
  2070.                             }
  2071.                           entry->prev = record_full_core_buf_list;
  2072.                           record_full_core_buf_list = entry;
  2073.                         }

  2075.                       memcpy (entry->buf + sec_offset, writebuf,
  2076.                               (size_t) len);
  2077.                     }
  2078.                   else
  2079.                     {
  2080.                       if (!entry)
  2081.                         return ops->beneath->to_xfer_partial (ops->beneath,
  2082.                                                               object, annex,
  2083.                                                               readbuf, writebuf,
  2084.                                                               offset, len,
  2085.                                                               xfered_len);

  2087.                       memcpy (readbuf, entry->buf + sec_offset,
  2088.                               (size_t) len);
  2089.                     }

  2091.                   *xfered_len = len;
  2092.                   return TARGET_XFER_OK;
  2093.                 }
  2094.             }

  2096.           return TARGET_XFER_E_IO;
  2097.         }
  2098.       else
  2099.         error (_("You can't do that without a process to debug."));
  2100.     }

  2102.   return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
  2103.                                         readbuf, writebuf, offset, len,
  2104.                                         xfered_len);
  2105. }

  2107. /* "to_insert_breakpoint" method for prec over corefile.  */

  2109. static int
  2110. ‌record_full_core_insert_breakpoint (struct target_ops *ops,
  2111.                                     struct gdbarch *gdbarch,
  2112.                                     struct bp_target_info *bp_tgt)
  2113. {
  2114.   return 0;
  2115. }

  2117. /* "to_remove_breakpoint" method for prec over corefile.  */

  2119. static int
  2120. ‌record_full_core_remove_breakpoint (struct target_ops *ops,
  2121.                                     struct gdbarch *gdbarch,
  2122.                                     struct bp_target_info *bp_tgt)
  2123. {
  2124.   return 0;
  2125. }

  2127. /* "to_has_execution" method for prec over corefile.  */

  2129. static int
  2130. ‌record_full_core_has_execution (struct target_ops *ops, ptid_t the_ptid)
  2131. {
  2132.   return 1;
  2133. }

  2135. static void
  2136. ‌init_record_full_core_ops (void)
  2137. {
  2138.   record_full_core_ops.to_shortname = "record-core";
  2139.   record_full_core_ops.to_longname = "Process record and replay target";
  2140.   record_full_core_ops.to_doc =
  2141.     "Log program while executing and replay execution from log.";
  2142.   record_full_core_ops.to_open = record_full_open;
  2143.   record_full_core_ops.to_close = record_full_close;
  2144.   record_full_core_ops.to_resume = record_full_core_resume;
  2145.   record_full_core_ops.to_wait = record_full_wait;
  2146.   record_full_core_ops.to_kill = record_full_core_kill;
  2147.   record_full_core_ops.to_fetch_registers = record_full_core_fetch_registers;
  2148.   record_full_core_ops.to_prepare_to_store = record_full_core_prepare_to_store;
  2149.   record_full_core_ops.to_store_registers = record_full_core_store_registers;
  2150.   record_full_core_ops.to_xfer_partial = record_full_core_xfer_partial;
  2151.   record_full_core_ops.to_insert_breakpoint
  2152.     = record_full_core_insert_breakpoint;
  2153.   record_full_core_ops.to_remove_breakpoint
  2154.     = record_full_core_remove_breakpoint;
  2155.   record_full_core_ops.to_stopped_by_watchpoint
  2156.     = record_full_stopped_by_watchpoint;
  2157.   record_full_core_ops.to_stopped_data_address
  2158.     = record_full_stopped_data_address;
  2159.   record_full_core_ops.to_can_execute_reverse
  2160.     = record_full_can_execute_reverse;
  2161.   record_full_core_ops.to_has_execution = record_full_core_has_execution;
  2162.   record_full_core_ops.to_stratum = record_stratum;
  2163.   /* Add bookmark target methods.  */
  2164.   record_full_core_ops.to_get_bookmark = record_full_get_bookmark;
  2165.   record_full_core_ops.to_goto_bookmark = record_full_goto_bookmark;
  2166.   record_full_core_ops.to_execution_direction
  2167.     = record_full_execution_direction;
  2168.   record_full_core_ops.to_info_record = record_full_info;
  2169.   record_full_core_ops.to_delete_record = record_full_delete;
  2170.   record_full_core_ops.to_record_is_replaying = record_full_is_replaying;
  2171.   record_full_core_ops.to_goto_record_begin = record_full_goto_begin;
  2172.   record_full_core_ops.to_goto_record_end = record_full_goto_end;
  2173.   record_full_core_ops.to_goto_record = record_full_goto;
  2174.   record_full_core_ops.to_magic = OPS_MAGIC;
  2175. }

  2177. /* Record log save-file format
  2178.    Version 1 (never released)

  2180.    Header:
  2181.      4 bytes: magic number htonl(0x20090829).
  2182.        NOTE: be sure to change whenever this file format changes!

  2184.    Records:
  2185.      record_full_end:
  2186.        1 byte:  record type (record_full_end, see enum record_full_type).
  2187.      record_full_reg:
  2188.        1 byte:  record type (record_full_reg, see enum record_full_type).
  2189.        8 bytes: register id (network byte order).
  2190.        MAX_REGISTER_SIZE bytes: register value.
  2191.      record_full_mem:
  2192.        1 byte:  record type (record_full_mem, see enum record_full_type).
  2193.        8 bytes: memory length (network byte order).
  2194.        8 bytes: memory address (network byte order).
  2195.        n bytes: memory value (n == memory length).

  2197.    Version 2
  2198.      4 bytes: magic number netorder32(0x20091016).
  2199.        NOTE: be sure to change whenever this file format changes!

  2201.    Records:
  2202.      record_full_end:
  2203.        1 byte:  record type (record_full_end, see enum record_full_type).
  2204.        4 bytes: signal
  2205.        4 bytes: instruction count
  2206.      record_full_reg:
  2207.        1 byte:  record type (record_full_reg, see enum record_full_type).
  2208.        4 bytes: register id (network byte order).
  2209.        n bytes: register value (n == actual register size).
  2210.                 (eg. 4 bytes for x86 general registers).
  2211.      record_full_mem:
  2212.        1 byte:  record type (record_full_mem, see enum record_full_type).
  2213.        4 bytes: memory length (network byte order).
  2214.        8 bytes: memory address (network byte order).
  2215.        n bytes: memory value (n == memory length).

  2217. */

  2219. /* bfdcore_read -- read bytes from a core file section.  */

  2221. static inline void
  2222. ‌bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
  2223. {
  2224.   int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);

  2226.   if (ret)
  2227.     *offset += len;
  2228.   else
  2229.     error (_("Failed to read %d bytes from core file %s ('%s')."),
  2230.            len, bfd_get_filename (obfd),
  2231.            bfd_errmsg (bfd_get_error ()));
  2232. }

  2234. static inline uint64_t
  2235. ‌netorder64 (uint64_t input)
  2236. {
  2237.   uint64_t ret;

  2239.   store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
  2240.                           BFD_ENDIAN_BIG, input);
  2241.   return ret;
  2242. }

  2244. static inline uint32_t
  2245. ‌netorder32 (uint32_t input)
  2246. {
  2247.   uint32_t ret;

  2249.   store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
  2250.                           BFD_ENDIAN_BIG, input);
  2251.   return ret;
  2252. }

  2254. static inline uint16_t
  2255. ‌netorder16 (uint16_t input)
  2256. {
  2257.   uint16_t ret;

  2259.   store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
  2260.                           BFD_ENDIAN_BIG, input);
  2261.   return ret;
  2262. }

  2264. /* Restore the execution log from a core_bfd file.  */
  2265. static void
  2266. ‌record_full_restore (void)
  2267. {
  2268.   uint32_t magic;
  2269.   struct cleanup *old_cleanups;
  2270.   struct record_full_entry *rec;
  2271.   asection *osec;
  2272.   uint32_t osec_size;
  2273.   int bfd_offset = 0;
  2274.   struct regcache *regcache;

  2276.   /* We restore the execution log from the open core bfd,
  2277.      if there is one.  */
  2278.   if (core_bfd == NULL)
  2279.     return;

  2281.   /* "record_full_restore" can only be called when record list is empty.  */
  2282.   gdb_assert (record_full_first.next == NULL);

  2284.   if (record_debug)
  2285.     fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");

  2287.   /* Now need to find our special note section.  */
  2288.   osec = bfd_get_section_by_name (core_bfd, "null0");
  2289.   if (record_debug)
  2290.     fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
  2291.                         osec ? "succeeded" : "failed");
  2292.   if (osec == NULL)
  2293.     return;
  2294.   osec_size = bfd_section_size (core_bfd, osec);
  2295.   if (record_debug)
  2296.     fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));

  2298.   /* Check the magic code.  */
  2299.   bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
  2300.   if (magic != RECORD_FULL_FILE_MAGIC)
  2301.     error (_("Version mis-match or file format error in core file %s."),
  2302.            bfd_get_filename (core_bfd));
  2303.   if (record_debug)
  2304.     fprintf_unfiltered (gdb_stdlog,
  2305.                         "  Reading 4-byte magic cookie "
  2306.                         "RECORD_FULL_FILE_MAGIC (0x%s)\n",
  2307.                         phex_nz (netorder32 (magic), 4));

  2309.   /* Restore the entries in recfd into record_full_arch_list_head and
  2310.      record_full_arch_list_tail.  */
  2311.   record_full_arch_list_head = NULL;
  2312.   record_full_arch_list_tail = NULL;
  2313.   record_full_insn_num = 0;
  2314.   old_cleanups = make_cleanup (record_full_arch_list_cleanups, 0);
  2315.   regcache = get_current_regcache ();

  2317.   while (1)
  2318.     {
  2319.       uint8_t rectype;
  2320.       uint32_t regnum, len, signal, count;
  2321.       uint64_t addr;

  2323.       /* We are finished when offset reaches osec_size.  */
  2324.       if (bfd_offset >= osec_size)
  2325.         break;
  2326.       bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);

  2328.       switch (rectype)
  2329.         {
  2330.         case record_full_reg: /* reg */
  2331.           /* Get register number to regnum.  */
  2332.           bfdcore_read (core_bfd, osec, &regnum,
  2333.                         sizeof (regnum), &bfd_offset);
  2334.           regnum = netorder32 (regnum);

  2336.           rec = record_full_reg_alloc (regcache, regnum);

  2338.           /* Get val.  */
  2339.           bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
  2340.                         rec->u.reg.len, &bfd_offset);

  2342.           if (record_debug)
  2343.             fprintf_unfiltered (gdb_stdlog,
  2344.                                 "  Reading register %d (1 "
  2345.                                 "plus %lu plus %d bytes)\n",
  2346.                                 rec->u.reg.num,
  2347.                                 (unsigned long) sizeof (regnum),
  2348.                                 rec->u.reg.len);
  2349.           break;

  2351.         case record_full_mem: /* mem */
  2352.           /* Get len.  */
  2353.           bfdcore_read (core_bfd, osec, &len,
  2354.                         sizeof (len), &bfd_offset);
  2355.           len = netorder32 (len);

  2357.           /* Get addr.  */
  2358.           bfdcore_read (core_bfd, osec, &addr,
  2359.                         sizeof (addr), &bfd_offset);
  2360.           addr = netorder64 (addr);

  2362.           rec = record_full_mem_alloc (addr, len);

  2364.           /* Get val.  */
  2365.           bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
  2366.                         rec->u.mem.len, &bfd_offset);

  2368.           if (record_debug)
  2369.             fprintf_unfiltered (gdb_stdlog,
  2370.                                 "  Reading memory %s (1 plus "
  2371.                                 "%lu plus %lu plus %d bytes)\n",
  2372.                                 paddress (get_current_arch (),
  2373.                                           rec->u.mem.addr),
  2374.                                 (unsigned long) sizeof (addr),
  2375.                                 (unsigned long) sizeof (len),
  2376.                                 rec->u.mem.len);
  2377.           break;

  2379.         case record_full_end: /* end */
  2380.           rec = record_full_end_alloc ();
  2381.           record_full_insn_num ++;

  2383.           /* Get signal value.  */
  2384.           bfdcore_read (core_bfd, osec, &signal,
  2385.                         sizeof (signal), &bfd_offset);
  2386.           signal = netorder32 (signal);
  2387.           rec->u.end.sigval = signal;

  2389.           /* Get insn count.  */
  2390.           bfdcore_read (core_bfd, osec, &count,
  2391.                         sizeof (count), &bfd_offset);
  2392.           count = netorder32 (count);
  2393.           rec->u.end.insn_num = count;
  2394.           record_full_insn_count = count + 1;
  2395.           if (record_debug)
  2396.             fprintf_unfiltered (gdb_stdlog,
  2397.                                 "  Reading record_full_end (1 + "
  2398.                                 "%lu + %lu bytes), offset == %s\n",
  2399.                                 (unsigned long) sizeof (signal),
  2400.                                 (unsigned long) sizeof (count),
  2401.                                 paddress (get_current_arch (),
  2402.                                           bfd_offset));
  2403.           break;

  2405.         default:
  2406.           error (_("Bad entry type in core file %s."),
  2407.                  bfd_get_filename (core_bfd));
  2408.           break;
  2409.         }

  2411.       /* Add rec to record arch list.  */
  2412.       record_full_arch_list_add (rec);
  2413.     }

  2415.   discard_cleanups (old_cleanups);

  2417.   /* Add record_full_arch_list_head to the end of record list.  */
  2418.   record_full_first.next = record_full_arch_list_head;
  2419.   record_full_arch_list_head->prev = &record_full_first;
  2420.   record_full_arch_list_tail->next = NULL;
  2421.   record_full_list = &record_full_first;

  2423.   /* Update record_full_insn_max_num.  */
  2424.   if (record_full_insn_num > record_full_insn_max_num)
  2425.     {
  2426.       record_full_insn_max_num = record_full_insn_num;
  2427.       warning (_("Auto increase record/replay buffer limit to %u."),
  2428.                record_full_insn_max_num);
  2429.     }

  2431.   /* Succeeded.  */
  2432.   printf_filtered (_("Restored records from core file %s.\n"),
  2433.                    bfd_get_filename (core_bfd));

  2435.   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
  2436. }

  2438. /* bfdcore_write -- write bytes into a core file section.  */

  2440. static inline void
  2441. ‌bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
  2442. {
  2443.   int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);

  2445.   if (ret)
  2446.     *offset += len;
  2447.   else
  2448.     error (_("Failed to write %d bytes to core file %s ('%s')."),
  2449.            len, bfd_get_filename (obfd),
  2450.            bfd_errmsg (bfd_get_error ()));
  2451. }

  2453. /* Restore the execution log from a file.  We use a modified elf
  2454.    corefile format, with an extra section for our data.  */

  2456. static void
  2457. ‌cmd_record_full_restore (char *args, int from_tty)
  2458. {
  2459.   core_file_command (args, from_tty);
  2460.   record_full_open (args, from_tty);
  2461. }

  2463. static void
  2464. ‌record_full_save_cleanups (void *data)
  2465. {
  2466.   bfd *obfd = data;
  2467.   char *pathname = xstrdup (bfd_get_filename (obfd));

  2469.   gdb_bfd_unref (obfd);
  2470.   unlink (pathname);
  2471.   xfree (pathname);
  2472. }

  2474. /* Save the execution log to a file.  We use a modified elf corefile
  2475.    format, with an extra section for our data.  */

  2477. static void
  2478. ‌record_full_save (struct target_ops *self, const char *recfilename)
  2479. {
  2480.   struct record_full_entry *cur_record_full_list;
  2481.   uint32_t magic;
  2482.   struct regcache *regcache;
  2483.   struct gdbarch *gdbarch;
  2484.   struct cleanup *old_cleanups;
  2485.   struct cleanup *set_cleanups;
  2486.   bfd *obfd;
  2487.   int save_size = 0;
  2488.   asection *osec = NULL;
  2489.   int bfd_offset = 0;

  2491.   /* Open the save file.  */
  2492.   if (record_debug)
  2493.     fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
  2494.                         recfilename);

  2496.   /* Open the output file.  */
  2497.   obfd = create_gcore_bfd (recfilename);
  2498.   old_cleanups = make_cleanup (record_full_save_cleanups, obfd);

  2500.   /* Save the current record entry to "cur_record_full_list".  */
  2501.   cur_record_full_list = record_full_list;

  2503.   /* Get the values of regcache and gdbarch.  */
  2504.   regcache = get_current_regcache ();
  2505.   gdbarch = get_regcache_arch (regcache);

  2507.   /* Disable the GDB operation record.  */
  2508.   set_cleanups = record_full_gdb_operation_disable_set ();

  2510.   /* Reverse execute to the begin of record list.  */
  2511.   while (1)
  2512.     {
  2513.       /* Check for beginning and end of log.  */
  2514.       if (record_full_list == &record_full_first)
  2515.         break;

  2517.       record_full_exec_insn (regcache, gdbarch, record_full_list);

  2519.       if (record_full_list->prev)
  2520.         record_full_list = record_full_list->prev;
  2521.     }

  2523.   /* Compute the size needed for the extra bfd section.  */
  2524.   save_size = 4;        /* magic cookie */
  2525.   for (record_full_list = record_full_first.next; record_full_list;
  2526.        record_full_list = record_full_list->next)
  2527.     switch (record_full_list->type)
  2528.       {
  2529.       case record_full_end:
  2530.         save_size += 1 + 4 + 4;
  2531.         break;
  2532.       case record_full_reg:
  2533.         save_size += 1 + 4 + record_full_list->u.reg.len;
  2534.         break;
  2535.       case record_full_mem:
  2536.         save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
  2537.         break;
  2538.       }

  2540.   /* Make the new bfd section.  */
  2541.   osec = bfd_make_section_anyway_with_flags (obfd, "precord",
  2542.                                              SEC_HAS_CONTENTS
  2543.                                              | SEC_READONLY);
  2544.   if (osec == NULL)
  2545.     error (_("Failed to create 'precord' section for corefile %s: %s"),
  2546.            recfilename,
  2547.            bfd_errmsg (bfd_get_error ()));
  2548.   bfd_set_section_size (obfd, osec, save_size);
  2549.   bfd_set_section_vma (obfd, osec, 0);
  2550.   bfd_set_section_alignment (obfd, osec, 0);
  2551.   bfd_section_lma (obfd, osec) = 0;

  2553.   /* Save corefile state.  */
  2554.   write_gcore_file (obfd);

  2556.   /* Write out the record log.  */
  2557.   /* Write the magic code.  */
  2558.   magic = RECORD_FULL_FILE_MAGIC;
  2559.   if (record_debug)
  2560.     fprintf_unfiltered (gdb_stdlog,
  2561.                         "  Writing 4-byte magic cookie "
  2562.                         "RECORD_FULL_FILE_MAGIC (0x%s)\n",
  2563.                       phex_nz (magic, 4));
  2564.   bfdcore_write (obfd, osec, &magic, sizeof (magic), &bfd_offset);

  2566.   /* Save the entries to recfd and forward execute to the end of
  2567.      record list.  */
  2568.   record_full_list = &record_full_first;
  2569.   while (1)
  2570.     {
  2571.       /* Save entry.  */
  2572.       if (record_full_list != &record_full_first)
  2573.         {
  2574.           uint8_t type;
  2575.           uint32_t regnum, len, signal, count;
  2576.           uint64_t addr;

  2578.           type = record_full_list->type;
  2579.           bfdcore_write (obfd, osec, &type, sizeof (type), &bfd_offset);

  2581.           switch (record_full_list->type)
  2582.             {
  2583.             case record_full_reg: /* reg */
  2584.               if (record_debug)
  2585.                 fprintf_unfiltered (gdb_stdlog,
  2586.                                     "  Writing register %d (1 "
  2587.                                     "plus %lu plus %d bytes)\n",
  2588.                                     record_full_list->u.reg.num,
  2589.                                     (unsigned long) sizeof (regnum),
  2590.                                     record_full_list->u.reg.len);

  2592.               /* Write regnum.  */
  2593.               regnum = netorder32 (record_full_list->u.reg.num);
  2594.               bfdcore_write (obfd, osec, &regnum,
  2595.                              sizeof (regnum), &bfd_offset);

  2597.               /* Write regval.  */
  2598.               bfdcore_write (obfd, osec,
  2599.                              record_full_get_loc (record_full_list),
  2600.                              record_full_list->u.reg.len, &bfd_offset);
  2601.               break;

  2603.             case record_full_mem: /* mem */
  2604.               if (record_debug)
  2605.                 fprintf_unfiltered (gdb_stdlog,
  2606.                                     "  Writing memory %s (1 plus "
  2607.                                     "%lu plus %lu plus %d bytes)\n",
  2608.                                     paddress (gdbarch,
  2609.                                               record_full_list->u.mem.addr),
  2610.                                     (unsigned long) sizeof (addr),
  2611.                                     (unsigned long) sizeof (len),
  2612.                                     record_full_list->u.mem.len);

  2614.               /* Write memlen.  */
  2615.               len = netorder32 (record_full_list->u.mem.len);
  2616.               bfdcore_write (obfd, osec, &len, sizeof (len), &bfd_offset);

  2618.               /* Write memaddr.  */
  2619.               addr = netorder64 (record_full_list->u.mem.addr);
  2620.               bfdcore_write (obfd, osec, &addr,
  2621.                              sizeof (addr), &bfd_offset);

  2623.               /* Write memval.  */
  2624.               bfdcore_write (obfd, osec,
  2625.                              record_full_get_loc (record_full_list),
  2626.                              record_full_list->u.mem.len, &bfd_offset);
  2627.               break;

  2629.               case record_full_end:
  2630.                 if (record_debug)
  2631.                   fprintf_unfiltered (gdb_stdlog,
  2632.                                       "  Writing record_full_end (1 + "
  2633.                                       "%lu + %lu bytes)\n",
  2634.                                       (unsigned long) sizeof (signal),
  2635.                                       (unsigned long) sizeof (count));
  2636.                 /* Write signal value.  */
  2637.                 signal = netorder32 (record_full_list->u.end.sigval);
  2638.                 bfdcore_write (obfd, osec, &signal,
  2639.                                sizeof (signal), &bfd_offset);

  2641.                 /* Write insn count.  */
  2642.                 count = netorder32 (record_full_list->u.end.insn_num);
  2643.                 bfdcore_write (obfd, osec, &count,
  2644.                                sizeof (count), &bfd_offset);
  2645.                 break;
  2646.             }
  2647.         }

  2649.       /* Execute entry.  */
  2650.       record_full_exec_insn (regcache, gdbarch, record_full_list);

  2652.       if (record_full_list->next)
  2653.         record_full_list = record_full_list->next;
  2654.       else
  2655.         break;
  2656.     }

  2658.   /* Reverse execute to cur_record_full_list.  */
  2659.   while (1)
  2660.     {
  2661.       /* Check for beginning and end of log.  */
  2662.       if (record_full_list == cur_record_full_list)
  2663.         break;

  2665.       record_full_exec_insn (regcache, gdbarch, record_full_list);

  2667.       if (record_full_list->prev)
  2668.         record_full_list = record_full_list->prev;
  2669.     }

  2671.   do_cleanups (set_cleanups);
  2672.   gdb_bfd_unref (obfd);
  2673.   discard_cleanups (old_cleanups);

  2675.   /* Succeeded.  */
  2676.   printf_filtered (_("Saved core file %s with execution log.\n"),
  2677.                    recfilename);
  2678. }

  2680. /* record_full_goto_insn -- rewind the record log (forward or backward,
  2681.    depending on DIR) to the given entry, changing the program state
  2682.    correspondingly.  */

  2684. static void
  2685. ‌record_full_goto_insn (struct record_full_entry *entry,
  2686.                        enum exec_direction_kind dir)
  2687. {
  2688.   struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
  2689.   struct regcache *regcache = get_current_regcache ();
  2690.   struct gdbarch *gdbarch = get_regcache_arch (regcache);

  2692.   /* Assume everything is valid: we will hit the entry,
  2693.      and we will not hit the end of the recording.  */

  2695.   if (dir == EXEC_FORWARD)
  2696.     record_full_list = record_full_list->next;

  2698.   do
  2699.     {
  2700.       record_full_exec_insn (regcache, gdbarch, record_full_list);
  2701.       if (dir == EXEC_REVERSE)
  2702.         record_full_list = record_full_list->prev;
  2703.       else
  2704.         record_full_list = record_full_list->next;
  2705.     } while (record_full_list != entry);
  2706.   do_cleanups (set_cleanups);
  2707. }

  2709. /* Alias for "target record-full".  */

  2711. static void
  2712. ‌cmd_record_full_start (char *args, int from_tty)
  2713. {
  2714.   execute_command ("target record-full", from_tty);
  2715. }

  2717. static void
  2718. ‌set_record_full_insn_max_num (char *args, int from_tty,
  2719.                               struct cmd_list_element *c)
  2720. {
  2721.   if (record_full_insn_num > record_full_insn_max_num)
  2722.     {
  2723.       /* Count down record_full_insn_num while releasing records from list.  */
  2724.       while (record_full_insn_num > record_full_insn_max_num)
  2725.        {
  2726.          record_full_list_release_first ();
  2727.          record_full_insn_num--;
  2728.        }
  2729.     }
  2730. }

  2732. /* The "set record full" command.  */

  2734. static void
  2735. ‌set_record_full_command (char *args, int from_tty)
  2736. {
  2737.   printf_unfiltered (_("\"set record full\" must be followed "
  2738.                        "by an apporpriate subcommand.\n"));
  2739.   help_list (set_record_full_cmdlist, "set record full ", all_commands,
  2740.              gdb_stdout);
  2741. }

  2743. /* The "show record full" command.  */

  2745. static void
  2746. ‌show_record_full_command (char *args, int from_tty)
  2747. {
  2748.   cmd_show_list (show_record_full_cmdlist, from_tty, "");
  2749. }

  2751. /* Provide a prototype to silence -Wmissing-prototypes.  */
  2752. extern initialize_file_ftype _initialize_record_full;

  2754. void
  2755. ‌_initialize_record_full (void)
  2756. {
  2757.   struct cmd_list_element *c;

  2759.   /* Init record_full_first.  */
  2760.   record_full_first.prev = NULL;
  2761.   record_full_first.next = NULL;
  2762.   record_full_first.type = record_full_end;

  2764.   init_record_full_ops ();
  2765.   add_target (&record_full_ops);
  2766.   add_deprecated_target_alias (&record_full_ops, "record");
  2767.   init_record_full_core_ops ();
  2768.   add_target (&record_full_core_ops);

  2770.   add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
  2771.                   _("Start full execution recording."), &record_full_cmdlist,
  2772.                   "record full ", 0, &record_cmdlist);

  2774.   c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
  2775.                _("Restore the execution log from a file.\n\
  2776. Argument is filename.  File must be created with 'record save'."),
  2777.                &record_full_cmdlist);
  2778.   set_cmd_completer (c, filename_completer);

  2780.   /* Deprecate the old version without "full" prefix.  */
  2781.   c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
  2782.                      &record_cmdlist);
  2783.   set_cmd_completer (c, filename_completer);
  2784.   deprecate_cmd (c, "record full restore");

  2786.   add_prefix_cmd ("full", class_support, set_record_full_command,
  2787.                   _("Set record options"), &set_record_full_cmdlist,
  2788.                   "set record full ", 0, &set_record_cmdlist);

  2790.   add_prefix_cmd ("full", class_support, show_record_full_command,
  2791.                   _("Show record options"), &show_record_full_cmdlist,
  2792.                   "show record full ", 0, &show_record_cmdlist);

  2794.   /* Record instructions number limit command.  */
  2795.   add_setshow_boolean_cmd ("stop-at-limit", no_class,
  2796.                            &record_full_stop_at_limit, _("\
  2797. Set whether record/replay stops when record/replay buffer becomes full."), _("\
  2798. Show whether record/replay stops when record/replay buffer becomes full."),
  2799.                            _("Default is ON.\n\
  2800. When ON, if the record/replay buffer becomes full, ask user what to do.\n\
  2801. When OFF, if the record/replay buffer becomes full,\n\
  2802. delete the oldest recorded instruction to make room for each new one."),
  2803.                            NULL, NULL,
  2804.                            &set_record_full_cmdlist, &show_record_full_cmdlist);

  2806.   c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
  2807.                      &set_record_cmdlist);
  2808.   deprecate_cmd (c, "set record full stop-at-limit");

  2810.   c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
  2811.                      &show_record_cmdlist);
  2812.   deprecate_cmd (c, "show record full stop-at-limit");

  2814.   add_setshow_uinteger_cmd ("insn-number-max", no_class,
  2815.                             &record_full_insn_max_num,
  2816.                             _("Set record/replay buffer limit."),
  2817.                             _("Show record/replay buffer limit."), _("\
  2818. Set the maximum number of instructions to be stored in the\n\
  2819. record/replay buffer.  A value of either \"unlimited\" or zero means no\n\
  2820. limit.  Default is 200000."),
  2821.                             set_record_full_insn_max_num,
  2822.                             NULL, &set_record_full_cmdlist,
  2823.                             &show_record_full_cmdlist);

  2825.   c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
  2826.                      &set_record_cmdlist);
  2827.   deprecate_cmd (c, "set record full insn-number-max");

  2829.   c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
  2830.                      &show_record_cmdlist);
  2831.   deprecate_cmd (c, "show record full insn-number-max");

  2833.   add_setshow_boolean_cmd ("memory-query", no_class,
  2834.                            &record_full_memory_query, _("\
  2835. Set whether query if PREC cannot record memory change of next instruction."),
  2836.                            _("\
  2837. Show whether query if PREC cannot record memory change of next instruction."),
  2838.                            _("\
  2839. Default is OFF.\n\
  2840. When ON, query if PREC cannot record memory change of next instruction."),
  2841.                            NULL, NULL,
  2842.                            &set_record_full_cmdlist,
  2843.                            &show_record_full_cmdlist);

  2845.   c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
  2846.                      &set_record_cmdlist);
  2847.   deprecate_cmd (c, "set record full memory-query");

  2849.   c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
  2850.                      &show_record_cmdlist);
  2851.   deprecate_cmd (c, "show record full memory-query");
  2852. }