1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2019 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/>. */
23 #include "gdbthread.h"
25 #include "event-top.h"
26 #include "completer.h"
27 #include "arch-utils.h"
31 #include "record-full.h"
34 #include "event-loop.h"
37 #include "observable.h"
39 #include "common/gdb_unlinker.h"
40 #include "common/byte-vector.h"
44 /* This module implements "target record-full", also known as "process
45 record and replay". This target sits on top of a "normal" target
46 (a target that "has execution"), and provides a record and replay
47 functionality, including reverse debugging.
49 Target record has two modes: recording, and replaying.
51 In record mode, we intercept the resume and wait methods.
52 Whenever gdb resumes the target, we run the target in single step
53 mode, and we build up an execution log in which, for each executed
54 instruction, we record all changes in memory and register state.
55 This is invisible to the user, to whom it just looks like an
56 ordinary debugging session (except for performance degredation).
58 In replay mode, instead of actually letting the inferior run as a
59 process, we simulate its execution by playing back the recorded
60 execution log. For each instruction in the log, we simulate the
61 instruction's side effects by duplicating the changes that it would
62 have made on memory and registers. */
64 #define DEFAULT_RECORD_FULL_INSN_MAX_NUM 200000
66 #define RECORD_FULL_IS_REPLAY \
67 (record_full_list->next || ::execution_direction == EXEC_REVERSE)
69 #define RECORD_FULL_FILE_MAGIC netorder32(0x20091016)
71 /* These are the core structs of the process record functionality.
73 A record_full_entry is a record of the value change of a register
74 ("record_full_reg") or a part of memory ("record_full_mem"). And each
75 instruction must have a struct record_full_entry ("record_full_end")
76 that indicates that this is the last struct record_full_entry of this
79 Each struct record_full_entry is linked to "record_full_list" by "prev"
80 and "next" pointers. */
82 struct record_full_mem_entry
86 /* Set this flag if target memory for this entry
87 can no longer be accessed. */
88 int mem_entry_not_accessible;
92 gdb_byte buf[sizeof (gdb_byte *)];
96 struct record_full_reg_entry
103 gdb_byte buf[2 * sizeof (gdb_byte *)];
107 struct record_full_end_entry
109 enum gdb_signal sigval;
113 enum record_full_type
120 /* This is the data structure that makes up the execution log.
122 The execution log consists of a single linked list of entries
123 of type "struct record_full_entry". It is doubly linked so that it
124 can be traversed in either direction.
126 The start of the list is anchored by a struct called
127 "record_full_first". The pointer "record_full_list" either points
128 to the last entry that was added to the list (in record mode), or to
129 the next entry in the list that will be executed (in replay mode).
131 Each list element (struct record_full_entry), in addition to next
132 and prev pointers, consists of a union of three entry types: mem,
133 reg, and end. A field called "type" determines which entry type is
134 represented by a given list element.
136 Each instruction that is added to the execution log is represented
137 by a variable number of list elements ('entries'). The instruction
138 will have one "reg" entry for each register that is changed by
139 executing the instruction (including the PC in every case). It
140 will also have one "mem" entry for each memory change. Finally,
141 each instruction will have an "end" entry that separates it from
142 the changes associated with the next instruction. */
144 struct record_full_entry
146 struct record_full_entry *prev;
147 struct record_full_entry *next;
148 enum record_full_type type;
152 struct record_full_reg_entry reg;
154 struct record_full_mem_entry mem;
156 struct record_full_end_entry end;
160 /* If true, query if PREC cannot record memory
161 change of next instruction. */
162 int record_full_memory_query = 0;
164 struct record_full_core_buf_entry
166 struct record_full_core_buf_entry *prev;
167 struct target_section *p;
171 /* Record buf with core target. */
172 static detached_regcache *record_full_core_regbuf = NULL;
173 static struct target_section *record_full_core_start;
174 static struct target_section *record_full_core_end;
175 static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
177 /* The following variables are used for managing the linked list that
178 represents the execution log.
180 record_full_first is the anchor that holds down the beginning of
183 record_full_list serves two functions:
184 1) In record mode, it anchors the end of the list.
185 2) In replay mode, it traverses the list and points to
186 the next instruction that must be emulated.
188 record_full_arch_list_head and record_full_arch_list_tail are used
189 to manage a separate list, which is used to build up the change
190 elements of the currently executing instruction during record mode.
191 When this instruction has been completely annotated in the "arch
192 list", it will be appended to the main execution log. */
194 static struct record_full_entry record_full_first;
195 static struct record_full_entry *record_full_list = &record_full_first;
196 static struct record_full_entry *record_full_arch_list_head = NULL;
197 static struct record_full_entry *record_full_arch_list_tail = NULL;
199 /* 1 ask user. 0 auto delete the last struct record_full_entry. */
200 static int record_full_stop_at_limit = 1;
201 /* Maximum allowed number of insns in execution log. */
202 static unsigned int record_full_insn_max_num
203 = DEFAULT_RECORD_FULL_INSN_MAX_NUM;
204 /* Actual count of insns presently in execution log. */
205 static unsigned int record_full_insn_num = 0;
206 /* Count of insns logged so far (may be larger
207 than count of insns presently in execution log). */
208 static ULONGEST record_full_insn_count;
210 static const char record_longname[]
211 = N_("Process record and replay target");
212 static const char record_doc[]
213 = N_("Log program while executing and replay execution from log.");
215 /* Base class implementing functionality common to both the
216 "record-full" and "record-core" targets. */
218 class record_full_base_target : public target_ops
221 const target_info &info () const override = 0;
223 strata stratum () const override { return record_stratum; }
225 void close () override;
226 void async (int) override;
227 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
228 bool stopped_by_watchpoint () override;
229 bool stopped_data_address (CORE_ADDR *) override;
231 bool stopped_by_sw_breakpoint () override;
232 bool supports_stopped_by_sw_breakpoint () override;
234 bool stopped_by_hw_breakpoint () override;
235 bool supports_stopped_by_hw_breakpoint () override;
237 bool can_execute_reverse () override;
239 /* Add bookmark target methods. */
240 gdb_byte *get_bookmark (const char *, int) override;
241 void goto_bookmark (const gdb_byte *, int) override;
242 enum exec_direction_kind execution_direction () override;
243 enum record_method record_method (ptid_t ptid) override;
244 void info_record () override;
245 void save_record (const char *filename) override;
246 bool supports_delete_record () override;
247 void delete_record () override;
248 bool record_is_replaying (ptid_t ptid) override;
249 bool record_will_replay (ptid_t ptid, int dir) override;
250 void record_stop_replaying () override;
251 void goto_record_begin () override;
252 void goto_record_end () override;
253 void goto_record (ULONGEST insn) override;
256 /* The "record-full" target. */
258 static const target_info record_full_target_info = {
264 class record_full_target final : public record_full_base_target
267 const target_info &info () const override
268 { return record_full_target_info; }
270 void commit_resume () override;
271 void resume (ptid_t, int, enum gdb_signal) override;
272 void disconnect (const char *, int) override;
273 void detach (inferior *, int) override;
274 void mourn_inferior () override;
275 void kill () override;
276 void store_registers (struct regcache *, int) override;
277 enum target_xfer_status xfer_partial (enum target_object object,
280 const gdb_byte *writebuf,
281 ULONGEST offset, ULONGEST len,
282 ULONGEST *xfered_len) override;
283 int insert_breakpoint (struct gdbarch *,
284 struct bp_target_info *) override;
285 int remove_breakpoint (struct gdbarch *,
286 struct bp_target_info *,
287 enum remove_bp_reason) override;
290 /* The "record-core" target. */
292 static const target_info record_full_core_target_info = {
298 class record_full_core_target final : public record_full_base_target
301 const target_info &info () const override
302 { return record_full_core_target_info; }
304 void resume (ptid_t, int, enum gdb_signal) override;
305 void disconnect (const char *, int) override;
306 void kill () override;
307 void fetch_registers (struct regcache *regcache, int regno) override;
308 void prepare_to_store (struct regcache *regcache) override;
309 void store_registers (struct regcache *, int) override;
310 enum target_xfer_status xfer_partial (enum target_object object,
313 const gdb_byte *writebuf,
314 ULONGEST offset, ULONGEST len,
315 ULONGEST *xfered_len) override;
316 int insert_breakpoint (struct gdbarch *,
317 struct bp_target_info *) override;
318 int remove_breakpoint (struct gdbarch *,
319 struct bp_target_info *,
320 enum remove_bp_reason) override;
322 bool has_execution (ptid_t) override;
325 static record_full_target record_full_ops;
326 static record_full_core_target record_full_core_ops;
329 record_full_target::detach (inferior *inf, int from_tty)
331 record_detach (this, inf, from_tty);
335 record_full_target::disconnect (const char *args, int from_tty)
337 record_disconnect (this, args, from_tty);
341 record_full_core_target::disconnect (const char *args, int from_tty)
343 record_disconnect (this, args, from_tty);
347 record_full_target::mourn_inferior ()
349 record_mourn_inferior (this);
353 record_full_target::kill ()
358 /* See record-full.h. */
361 record_full_is_used (void)
363 struct target_ops *t;
365 t = find_record_target ();
366 return (t == &record_full_ops
367 || t == &record_full_core_ops);
371 /* Command lists for "set/show record full". */
372 static struct cmd_list_element *set_record_full_cmdlist;
373 static struct cmd_list_element *show_record_full_cmdlist;
375 /* Command list for "record full". */
376 static struct cmd_list_element *record_full_cmdlist;
378 static void record_full_goto_insn (struct record_full_entry *entry,
379 enum exec_direction_kind dir);
381 /* Alloc and free functions for record_full_reg, record_full_mem, and
382 record_full_end entries. */
384 /* Alloc a record_full_reg record entry. */
386 static inline struct record_full_entry *
387 record_full_reg_alloc (struct regcache *regcache, int regnum)
389 struct record_full_entry *rec;
390 struct gdbarch *gdbarch = regcache->arch ();
392 rec = XCNEW (struct record_full_entry);
393 rec->type = record_full_reg;
394 rec->u.reg.num = regnum;
395 rec->u.reg.len = register_size (gdbarch, regnum);
396 if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
397 rec->u.reg.u.ptr = (gdb_byte *) xmalloc (rec->u.reg.len);
402 /* Free a record_full_reg record entry. */
405 record_full_reg_release (struct record_full_entry *rec)
407 gdb_assert (rec->type == record_full_reg);
408 if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
409 xfree (rec->u.reg.u.ptr);
413 /* Alloc a record_full_mem record entry. */
415 static inline struct record_full_entry *
416 record_full_mem_alloc (CORE_ADDR addr, int len)
418 struct record_full_entry *rec;
420 rec = XCNEW (struct record_full_entry);
421 rec->type = record_full_mem;
422 rec->u.mem.addr = addr;
423 rec->u.mem.len = len;
424 if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
425 rec->u.mem.u.ptr = (gdb_byte *) xmalloc (len);
430 /* Free a record_full_mem record entry. */
433 record_full_mem_release (struct record_full_entry *rec)
435 gdb_assert (rec->type == record_full_mem);
436 if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
437 xfree (rec->u.mem.u.ptr);
441 /* Alloc a record_full_end record entry. */
443 static inline struct record_full_entry *
444 record_full_end_alloc (void)
446 struct record_full_entry *rec;
448 rec = XCNEW (struct record_full_entry);
449 rec->type = record_full_end;
454 /* Free a record_full_end record entry. */
457 record_full_end_release (struct record_full_entry *rec)
462 /* Free one record entry, any type.
463 Return entry->type, in case caller wants to know. */
465 static inline enum record_full_type
466 record_full_entry_release (struct record_full_entry *rec)
468 enum record_full_type type = rec->type;
471 case record_full_reg:
472 record_full_reg_release (rec);
474 case record_full_mem:
475 record_full_mem_release (rec);
477 case record_full_end:
478 record_full_end_release (rec);
484 /* Free all record entries in list pointed to by REC. */
487 record_full_list_release (struct record_full_entry *rec)
498 record_full_entry_release (rec->next);
501 if (rec == &record_full_first)
503 record_full_insn_num = 0;
504 record_full_first.next = NULL;
507 record_full_entry_release (rec);
510 /* Free all record entries forward of the given list position. */
513 record_full_list_release_following (struct record_full_entry *rec)
515 struct record_full_entry *tmp = rec->next;
521 if (record_full_entry_release (tmp) == record_full_end)
523 record_full_insn_num--;
524 record_full_insn_count--;
530 /* Delete the first instruction from the beginning of the log, to make
531 room for adding a new instruction at the end of the log.
533 Note -- this function does not modify record_full_insn_num. */
536 record_full_list_release_first (void)
538 struct record_full_entry *tmp;
540 if (!record_full_first.next)
543 /* Loop until a record_full_end. */
546 /* Cut record_full_first.next out of the linked list. */
547 tmp = record_full_first.next;
548 record_full_first.next = tmp->next;
549 tmp->next->prev = &record_full_first;
551 /* tmp is now isolated, and can be deleted. */
552 if (record_full_entry_release (tmp) == record_full_end)
553 break; /* End loop at first record_full_end. */
555 if (!record_full_first.next)
557 gdb_assert (record_full_insn_num == 1);
558 break; /* End loop when list is empty. */
563 /* Add a struct record_full_entry to record_full_arch_list. */
566 record_full_arch_list_add (struct record_full_entry *rec)
568 if (record_debug > 1)
569 fprintf_unfiltered (gdb_stdlog,
570 "Process record: record_full_arch_list_add %s.\n",
571 host_address_to_string (rec));
573 if (record_full_arch_list_tail)
575 record_full_arch_list_tail->next = rec;
576 rec->prev = record_full_arch_list_tail;
577 record_full_arch_list_tail = rec;
581 record_full_arch_list_head = rec;
582 record_full_arch_list_tail = rec;
586 /* Return the value storage location of a record entry. */
587 static inline gdb_byte *
588 record_full_get_loc (struct record_full_entry *rec)
591 case record_full_mem:
592 if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
593 return rec->u.mem.u.ptr;
595 return rec->u.mem.u.buf;
596 case record_full_reg:
597 if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
598 return rec->u.reg.u.ptr;
600 return rec->u.reg.u.buf;
601 case record_full_end:
603 gdb_assert_not_reached ("unexpected record_full_entry type");
608 /* Record the value of a register NUM to record_full_arch_list. */
611 record_full_arch_list_add_reg (struct regcache *regcache, int regnum)
613 struct record_full_entry *rec;
615 if (record_debug > 1)
616 fprintf_unfiltered (gdb_stdlog,
617 "Process record: add register num = %d to "
621 rec = record_full_reg_alloc (regcache, regnum);
623 regcache->raw_read (regnum, record_full_get_loc (rec));
625 record_full_arch_list_add (rec);
630 /* Record the value of a region of memory whose address is ADDR and
631 length is LEN to record_full_arch_list. */
634 record_full_arch_list_add_mem (CORE_ADDR addr, int len)
636 struct record_full_entry *rec;
638 if (record_debug > 1)
639 fprintf_unfiltered (gdb_stdlog,
640 "Process record: add mem addr = %s len = %d to "
642 paddress (target_gdbarch (), addr), len);
644 if (!addr) /* FIXME: Why? Some arch must permit it... */
647 rec = record_full_mem_alloc (addr, len);
649 if (record_read_memory (target_gdbarch (), addr,
650 record_full_get_loc (rec), len))
652 record_full_mem_release (rec);
656 record_full_arch_list_add (rec);
661 /* Add a record_full_end type struct record_full_entry to
662 record_full_arch_list. */
665 record_full_arch_list_add_end (void)
667 struct record_full_entry *rec;
669 if (record_debug > 1)
670 fprintf_unfiltered (gdb_stdlog,
671 "Process record: add end to arch list.\n");
673 rec = record_full_end_alloc ();
674 rec->u.end.sigval = GDB_SIGNAL_0;
675 rec->u.end.insn_num = ++record_full_insn_count;
677 record_full_arch_list_add (rec);
683 record_full_check_insn_num (void)
685 if (record_full_insn_num == record_full_insn_max_num)
687 /* Ask user what to do. */
688 if (record_full_stop_at_limit)
690 if (!yquery (_("Do you want to auto delete previous execution "
691 "log entries when record/replay buffer becomes "
692 "full (record full stop-at-limit)?")))
693 error (_("Process record: stopped by user."));
694 record_full_stop_at_limit = 0;
699 /* Before inferior step (when GDB record the running message, inferior
700 only can step), GDB will call this function to record the values to
701 record_full_list. This function will call gdbarch_process_record to
702 record the running message of inferior and set them to
703 record_full_arch_list, and add it to record_full_list. */
706 record_full_message (struct regcache *regcache, enum gdb_signal signal)
709 struct gdbarch *gdbarch = regcache->arch ();
713 record_full_arch_list_head = NULL;
714 record_full_arch_list_tail = NULL;
716 /* Check record_full_insn_num. */
717 record_full_check_insn_num ();
719 /* If gdb sends a signal value to target_resume,
720 save it in the 'end' field of the previous instruction.
722 Maybe process record should record what really happened,
723 rather than what gdb pretends has happened.
725 So if Linux delivered the signal to the child process during
726 the record mode, we will record it and deliver it again in
729 If user says "ignore this signal" during the record mode, then
730 it will be ignored again during the replay mode (no matter if
731 the user says something different, like "deliver this signal"
732 during the replay mode).
734 User should understand that nothing he does during the replay
735 mode will change the behavior of the child. If he tries,
736 then that is a user error.
738 But we should still deliver the signal to gdb during the replay,
739 if we delivered it during the recording. Therefore we should
740 record the signal during record_full_wait, not
741 record_full_resume. */
742 if (record_full_list != &record_full_first) /* FIXME better way
745 gdb_assert (record_full_list->type == record_full_end);
746 record_full_list->u.end.sigval = signal;
749 if (signal == GDB_SIGNAL_0
750 || !gdbarch_process_record_signal_p (gdbarch))
751 ret = gdbarch_process_record (gdbarch,
753 regcache_read_pc (regcache));
755 ret = gdbarch_process_record_signal (gdbarch,
760 error (_("Process record: inferior program stopped."));
762 error (_("Process record: failed to record execution log."));
764 catch (const gdb_exception &ex)
766 record_full_list_release (record_full_arch_list_tail);
767 throw_exception (ex);
770 record_full_list->next = record_full_arch_list_head;
771 record_full_arch_list_head->prev = record_full_list;
772 record_full_list = record_full_arch_list_tail;
774 if (record_full_insn_num == record_full_insn_max_num)
775 record_full_list_release_first ();
777 record_full_insn_num++;
781 record_full_message_wrapper_safe (struct regcache *regcache,
782 enum gdb_signal signal)
786 record_full_message (regcache, signal);
788 catch (const gdb_exception &ex)
790 exception_print (gdb_stderr, ex);
797 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
798 doesn't need record. */
800 static int record_full_gdb_operation_disable = 0;
802 scoped_restore_tmpl<int>
803 record_full_gdb_operation_disable_set (void)
805 return make_scoped_restore (&record_full_gdb_operation_disable, 1);
808 /* Flag set to TRUE for target_stopped_by_watchpoint. */
809 static enum target_stop_reason record_full_stop_reason
810 = TARGET_STOPPED_BY_NO_REASON;
812 /* Execute one instruction from the record log. Each instruction in
813 the log will be represented by an arbitrary sequence of register
814 entries and memory entries, followed by an 'end' entry. */
817 record_full_exec_insn (struct regcache *regcache,
818 struct gdbarch *gdbarch,
819 struct record_full_entry *entry)
823 case record_full_reg: /* reg */
825 gdb::byte_vector reg (entry->u.reg.len);
827 if (record_debug > 1)
828 fprintf_unfiltered (gdb_stdlog,
829 "Process record: record_full_reg %s to "
830 "inferior num = %d.\n",
831 host_address_to_string (entry),
834 regcache->cooked_read (entry->u.reg.num, reg.data ());
835 regcache->cooked_write (entry->u.reg.num, record_full_get_loc (entry));
836 memcpy (record_full_get_loc (entry), reg.data (), entry->u.reg.len);
840 case record_full_mem: /* mem */
842 /* Nothing to do if the entry is flagged not_accessible. */
843 if (!entry->u.mem.mem_entry_not_accessible)
845 gdb::byte_vector mem (entry->u.mem.len);
847 if (record_debug > 1)
848 fprintf_unfiltered (gdb_stdlog,
849 "Process record: record_full_mem %s to "
850 "inferior addr = %s len = %d.\n",
851 host_address_to_string (entry),
852 paddress (gdbarch, entry->u.mem.addr),
855 if (record_read_memory (gdbarch,
856 entry->u.mem.addr, mem.data (),
858 entry->u.mem.mem_entry_not_accessible = 1;
861 if (target_write_memory (entry->u.mem.addr,
862 record_full_get_loc (entry),
865 entry->u.mem.mem_entry_not_accessible = 1;
867 warning (_("Process record: error writing memory at "
868 "addr = %s len = %d."),
869 paddress (gdbarch, entry->u.mem.addr),
874 memcpy (record_full_get_loc (entry), mem.data (),
877 /* We've changed memory --- check if a hardware
878 watchpoint should trap. Note that this
879 presently assumes the target beneath supports
880 continuable watchpoints. On non-continuable
881 watchpoints target, we'll want to check this
882 _before_ actually doing the memory change, and
883 not doing the change at all if the watchpoint
885 if (hardware_watchpoint_inserted_in_range
886 (regcache->aspace (),
887 entry->u.mem.addr, entry->u.mem.len))
888 record_full_stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
897 static void record_full_restore (void);
899 /* Asynchronous signal handle registered as event loop source for when
900 we have pending events ready to be passed to the core. */
902 static struct async_event_handler *record_full_async_inferior_event_token;
905 record_full_async_inferior_event_handler (gdb_client_data data)
907 inferior_event_handler (INF_REG_EVENT, NULL);
910 /* Open the process record target for 'core' files. */
913 record_full_core_open_1 (const char *name, int from_tty)
915 struct regcache *regcache = get_current_regcache ();
916 int regnum = gdbarch_num_regs (regcache->arch ());
919 /* Get record_full_core_regbuf. */
920 target_fetch_registers (regcache, -1);
921 record_full_core_regbuf = new detached_regcache (regcache->arch (), false);
923 for (i = 0; i < regnum; i ++)
924 record_full_core_regbuf->raw_supply (i, *regcache);
926 /* Get record_full_core_start and record_full_core_end. */
927 if (build_section_table (core_bfd, &record_full_core_start,
928 &record_full_core_end))
930 delete record_full_core_regbuf;
931 record_full_core_regbuf = NULL;
932 error (_("\"%s\": Can't find sections: %s"),
933 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
936 push_target (&record_full_core_ops);
937 record_full_restore ();
940 /* Open the process record target for 'live' processes. */
943 record_full_open_1 (const char *name, int from_tty)
946 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open_1\n");
949 if (!target_has_execution)
950 error (_("Process record: the program is not being run."));
952 error (_("Process record target can't debug inferior in non-stop mode "
955 if (!gdbarch_process_record_p (target_gdbarch ()))
956 error (_("Process record: the current architecture doesn't support "
957 "record function."));
959 push_target (&record_full_ops);
962 static void record_full_init_record_breakpoints (void);
964 /* Open the process record target. */
967 record_full_open (const char *name, int from_tty)
970 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
975 record_full_insn_num = 0;
976 record_full_insn_count = 0;
977 record_full_list = &record_full_first;
978 record_full_list->next = NULL;
981 record_full_core_open_1 (name, from_tty);
983 record_full_open_1 (name, from_tty);
985 /* Register extra event sources in the event loop. */
986 record_full_async_inferior_event_token
987 = create_async_event_handler (record_full_async_inferior_event_handler,
990 record_full_init_record_breakpoints ();
992 gdb::observers::record_changed.notify (current_inferior (), 1, "full", NULL);
995 /* "close" target method. Close the process record target. */
998 record_full_base_target::close ()
1000 struct record_full_core_buf_entry *entry;
1003 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_close\n");
1005 record_full_list_release (record_full_list);
1007 /* Release record_full_core_regbuf. */
1008 if (record_full_core_regbuf)
1010 delete record_full_core_regbuf;
1011 record_full_core_regbuf = NULL;
1014 /* Release record_full_core_buf_list. */
1015 while (record_full_core_buf_list)
1017 entry = record_full_core_buf_list;
1018 record_full_core_buf_list = record_full_core_buf_list->prev;
1022 if (record_full_async_inferior_event_token)
1023 delete_async_event_handler (&record_full_async_inferior_event_token);
1026 /* "async" target method. */
1029 record_full_base_target::async (int enable)
1032 mark_async_event_handler (record_full_async_inferior_event_token);
1034 clear_async_event_handler (record_full_async_inferior_event_token);
1036 beneath ()->async (enable);
1039 static int record_full_resume_step = 0;
1041 /* True if we've been resumed, and so each record_full_wait call should
1042 advance execution. If this is false, record_full_wait will return a
1043 TARGET_WAITKIND_IGNORE. */
1044 static int record_full_resumed = 0;
1046 /* The execution direction of the last resume we got. This is
1047 necessary for async mode. Vis (order is not strictly accurate):
1049 1. user has the global execution direction set to forward
1050 2. user does a reverse-step command
1051 3. record_full_resume is called with global execution direction
1052 temporarily switched to reverse
1053 4. GDB's execution direction is reverted back to forward
1054 5. target record notifies event loop there's an event to handle
1055 6. infrun asks the target which direction was it going, and switches
1056 the global execution direction accordingly (to reverse)
1057 7. infrun polls an event out of the record target, and handles it
1058 8. GDB goes back to the event loop, and goto #4.
1060 static enum exec_direction_kind record_full_execution_dir = EXEC_FORWARD;
1062 /* "resume" target method. Resume the process record target. */
1065 record_full_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
1067 record_full_resume_step = step;
1068 record_full_resumed = 1;
1069 record_full_execution_dir = ::execution_direction;
1071 if (!RECORD_FULL_IS_REPLAY)
1073 struct gdbarch *gdbarch = target_thread_architecture (ptid);
1075 record_full_message (get_current_regcache (), signal);
1079 /* This is not hard single step. */
1080 if (!gdbarch_software_single_step_p (gdbarch))
1082 /* This is a normal continue. */
1087 /* This arch supports soft single step. */
1088 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
1090 /* This is a soft single step. */
1091 record_full_resume_step = 1;
1094 step = !insert_single_step_breakpoints (gdbarch);
1098 /* Make sure the target beneath reports all signals. */
1099 target_pass_signals ({});
1101 this->beneath ()->resume (ptid, step, signal);
1104 /* We are about to start executing the inferior (or simulate it),
1105 let's register it with the event loop. */
1106 if (target_can_async_p ())
1110 /* "commit_resume" method for process record target. */
1113 record_full_target::commit_resume ()
1115 if (!RECORD_FULL_IS_REPLAY)
1116 beneath ()->commit_resume ();
1119 static int record_full_get_sig = 0;
1121 /* SIGINT signal handler, registered by "wait" method. */
1124 record_full_sig_handler (int signo)
1127 fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
1129 /* It will break the running inferior in replay mode. */
1130 record_full_resume_step = 1;
1132 /* It will let record_full_wait set inferior status to get the signal
1134 record_full_get_sig = 1;
1137 /* "wait" target method for process record target.
1139 In record mode, the target is always run in singlestep mode
1140 (even when gdb says to continue). The wait method intercepts
1141 the stop events and determines which ones are to be passed on to
1142 gdb. Most stop events are just singlestep events that gdb is not
1143 to know about, so the wait method just records them and keeps
1146 In replay mode, this function emulates the recorded execution log,
1147 one instruction at a time (forward or backward), and determines
1151 record_full_wait_1 (struct target_ops *ops,
1152 ptid_t ptid, struct target_waitstatus *status,
1155 scoped_restore restore_operation_disable
1156 = record_full_gdb_operation_disable_set ();
1159 fprintf_unfiltered (gdb_stdlog,
1160 "Process record: record_full_wait "
1161 "record_full_resume_step = %d, "
1162 "record_full_resumed = %d, direction=%s\n",
1163 record_full_resume_step, record_full_resumed,
1164 record_full_execution_dir == EXEC_FORWARD
1165 ? "forward" : "reverse");
1167 if (!record_full_resumed)
1169 gdb_assert ((options & TARGET_WNOHANG) != 0);
1171 /* No interesting event. */
1172 status->kind = TARGET_WAITKIND_IGNORE;
1173 return minus_one_ptid;
1176 record_full_get_sig = 0;
1177 signal (SIGINT, record_full_sig_handler);
1179 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1181 if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
1183 if (record_full_resume_step)
1185 /* This is a single step. */
1186 return ops->beneath ()->wait (ptid, status, options);
1190 /* This is not a single step. */
1193 struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);
1197 ret = ops->beneath ()->wait (ptid, status, options);
1198 if (status->kind == TARGET_WAITKIND_IGNORE)
1201 fprintf_unfiltered (gdb_stdlog,
1202 "Process record: record_full_wait "
1203 "target beneath not done yet\n");
1207 for (thread_info *tp : all_non_exited_threads ())
1208 delete_single_step_breakpoints (tp);
1210 if (record_full_resume_step)
1213 /* Is this a SIGTRAP? */
1214 if (status->kind == TARGET_WAITKIND_STOPPED
1215 && status->value.sig == GDB_SIGNAL_TRAP)
1217 struct regcache *regcache;
1218 enum target_stop_reason *stop_reason_p
1219 = &record_full_stop_reason;
1221 /* Yes -- this is likely our single-step finishing,
1222 but check if there's any reason the core would be
1223 interested in the event. */
1225 registers_changed ();
1226 regcache = get_current_regcache ();
1227 tmp_pc = regcache_read_pc (regcache);
1228 const struct address_space *aspace = regcache->aspace ();
1230 if (target_stopped_by_watchpoint ())
1232 /* Always interested in watchpoints. */
1234 else if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1237 /* There is a breakpoint here. Let the core
1242 /* This is a single-step trap. Record the
1243 insn and issue another step.
1244 FIXME: this part can be a random SIGTRAP too.
1245 But GDB cannot handle it. */
1248 if (!record_full_message_wrapper_safe (regcache,
1251 status->kind = TARGET_WAITKIND_STOPPED;
1252 status->value.sig = GDB_SIGNAL_0;
1256 if (gdbarch_software_single_step_p (gdbarch))
1258 /* Try to insert the software single step breakpoint.
1259 If insert success, set step to 0. */
1260 set_executing (inferior_ptid, 0);
1261 reinit_frame_cache ();
1263 step = !insert_single_step_breakpoints (gdbarch);
1265 set_executing (inferior_ptid, 1);
1269 fprintf_unfiltered (gdb_stdlog,
1270 "Process record: record_full_wait "
1271 "issuing one more step in the "
1272 "target beneath\n");
1273 ops->beneath ()->resume (ptid, step, GDB_SIGNAL_0);
1274 ops->beneath ()->commit_resume ();
1279 /* The inferior is broken by a breakpoint or a signal. */
1288 struct regcache *regcache = get_current_regcache ();
1289 struct gdbarch *gdbarch = regcache->arch ();
1290 const struct address_space *aspace = regcache->aspace ();
1291 int continue_flag = 1;
1292 int first_record_full_end = 1;
1298 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1299 status->kind = TARGET_WAITKIND_STOPPED;
1301 /* Check breakpoint when forward execute. */
1302 if (execution_direction == EXEC_FORWARD)
1304 tmp_pc = regcache_read_pc (regcache);
1305 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1306 &record_full_stop_reason))
1309 fprintf_unfiltered (gdb_stdlog,
1310 "Process record: break at %s.\n",
1311 paddress (gdbarch, tmp_pc));
1316 /* If GDB is in terminal_inferior mode, it will not get the
1317 signal. And in GDB replay mode, GDB doesn't need to be
1318 in terminal_inferior mode, because inferior will not
1319 executed. Then set it to terminal_ours to make GDB get
1321 target_terminal::ours ();
1323 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1325 if (execution_direction == EXEC_FORWARD && record_full_list->next)
1326 record_full_list = record_full_list->next;
1328 /* Loop over the record_full_list, looking for the next place to
1332 /* Check for beginning and end of log. */
1333 if (execution_direction == EXEC_REVERSE
1334 && record_full_list == &record_full_first)
1336 /* Hit beginning of record log in reverse. */
1337 status->kind = TARGET_WAITKIND_NO_HISTORY;
1340 if (execution_direction != EXEC_REVERSE
1341 && !record_full_list->next)
1343 /* Hit end of record log going forward. */
1344 status->kind = TARGET_WAITKIND_NO_HISTORY;
1348 record_full_exec_insn (regcache, gdbarch, record_full_list);
1350 if (record_full_list->type == record_full_end)
1352 if (record_debug > 1)
1355 "Process record: record_full_end %s to "
1357 host_address_to_string (record_full_list));
1359 if (first_record_full_end
1360 && execution_direction == EXEC_REVERSE)
1362 /* When reverse excute, the first
1363 record_full_end is the part of current
1365 first_record_full_end = 0;
1369 /* In EXEC_REVERSE mode, this is the
1370 record_full_end of prev instruction. In
1371 EXEC_FORWARD mode, this is the
1372 record_full_end of current instruction. */
1374 if (record_full_resume_step)
1376 if (record_debug > 1)
1377 fprintf_unfiltered (gdb_stdlog,
1378 "Process record: step.\n");
1382 /* check breakpoint */
1383 tmp_pc = regcache_read_pc (regcache);
1384 if (record_check_stopped_by_breakpoint
1385 (aspace, tmp_pc, &record_full_stop_reason))
1388 fprintf_unfiltered (gdb_stdlog,
1389 "Process record: break "
1391 paddress (gdbarch, tmp_pc));
1396 if (record_full_stop_reason
1397 == TARGET_STOPPED_BY_WATCHPOINT)
1400 fprintf_unfiltered (gdb_stdlog,
1401 "Process record: hit hw "
1405 /* Check target signal */
1406 if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1407 /* FIXME: better way to check */
1414 if (execution_direction == EXEC_REVERSE)
1416 if (record_full_list->prev)
1417 record_full_list = record_full_list->prev;
1421 if (record_full_list->next)
1422 record_full_list = record_full_list->next;
1426 while (continue_flag);
1429 if (record_full_get_sig)
1430 status->value.sig = GDB_SIGNAL_INT;
1431 else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1432 /* FIXME: better way to check */
1433 status->value.sig = record_full_list->u.end.sigval;
1435 status->value.sig = GDB_SIGNAL_TRAP;
1437 catch (const gdb_exception &ex)
1439 if (execution_direction == EXEC_REVERSE)
1441 if (record_full_list->next)
1442 record_full_list = record_full_list->next;
1445 record_full_list = record_full_list->prev;
1447 throw_exception (ex);
1451 signal (SIGINT, handle_sigint);
1453 return inferior_ptid;
1457 record_full_base_target::wait (ptid_t ptid, struct target_waitstatus *status,
1462 return_ptid = record_full_wait_1 (this, ptid, status, options);
1463 if (status->kind != TARGET_WAITKIND_IGNORE)
1465 /* We're reporting a stop. Make sure any spurious
1466 target_wait(WNOHANG) doesn't advance the target until the
1467 core wants us resumed again. */
1468 record_full_resumed = 0;
1474 record_full_base_target::stopped_by_watchpoint ()
1476 if (RECORD_FULL_IS_REPLAY)
1477 return record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
1479 return beneath ()->stopped_by_watchpoint ();
1483 record_full_base_target::stopped_data_address (CORE_ADDR *addr_p)
1485 if (RECORD_FULL_IS_REPLAY)
1488 return this->beneath ()->stopped_data_address (addr_p);
1491 /* The stopped_by_sw_breakpoint method of target record-full. */
1494 record_full_base_target::stopped_by_sw_breakpoint ()
1496 return record_full_stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
1499 /* The supports_stopped_by_sw_breakpoint method of target
1503 record_full_base_target::supports_stopped_by_sw_breakpoint ()
1508 /* The stopped_by_hw_breakpoint method of target record-full. */
1511 record_full_base_target::stopped_by_hw_breakpoint ()
1513 return record_full_stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
1516 /* The supports_stopped_by_sw_breakpoint method of target
1520 record_full_base_target::supports_stopped_by_hw_breakpoint ()
1525 /* Record registers change (by user or by GDB) to list as an instruction. */
1528 record_full_registers_change (struct regcache *regcache, int regnum)
1530 /* Check record_full_insn_num. */
1531 record_full_check_insn_num ();
1533 record_full_arch_list_head = NULL;
1534 record_full_arch_list_tail = NULL;
1540 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
1542 if (record_full_arch_list_add_reg (regcache, i))
1544 record_full_list_release (record_full_arch_list_tail);
1545 error (_("Process record: failed to record execution log."));
1551 if (record_full_arch_list_add_reg (regcache, regnum))
1553 record_full_list_release (record_full_arch_list_tail);
1554 error (_("Process record: failed to record execution log."));
1557 if (record_full_arch_list_add_end ())
1559 record_full_list_release (record_full_arch_list_tail);
1560 error (_("Process record: failed to record execution log."));
1562 record_full_list->next = record_full_arch_list_head;
1563 record_full_arch_list_head->prev = record_full_list;
1564 record_full_list = record_full_arch_list_tail;
1566 if (record_full_insn_num == record_full_insn_max_num)
1567 record_full_list_release_first ();
1569 record_full_insn_num++;
1572 /* "store_registers" method for process record target. */
1575 record_full_target::store_registers (struct regcache *regcache, int regno)
1577 if (!record_full_gdb_operation_disable)
1579 if (RECORD_FULL_IS_REPLAY)
1583 /* Let user choose if he wants to write register or not. */
1586 query (_("Because GDB is in replay mode, changing the "
1587 "value of a register will make the execution "
1588 "log unusable from this point onward. "
1589 "Change all registers?"));
1592 query (_("Because GDB is in replay mode, changing the value "
1593 "of a register will make the execution log unusable "
1594 "from this point onward. Change register %s?"),
1595 gdbarch_register_name (regcache->arch (),
1600 /* Invalidate the value of regcache that was set in function
1601 "regcache_raw_write". */
1607 i < gdbarch_num_regs (regcache->arch ());
1609 regcache->invalidate (i);
1612 regcache->invalidate (regno);
1614 error (_("Process record canceled the operation."));
1617 /* Destroy the record from here forward. */
1618 record_full_list_release_following (record_full_list);
1621 record_full_registers_change (regcache, regno);
1623 this->beneath ()->store_registers (regcache, regno);
1626 /* "xfer_partial" method. Behavior is conditional on
1627 RECORD_FULL_IS_REPLAY.
1628 In replay mode, we cannot write memory unles we are willing to
1629 invalidate the record/replay log from this point forward. */
1631 enum target_xfer_status
1632 record_full_target::xfer_partial (enum target_object object,
1633 const char *annex, gdb_byte *readbuf,
1634 const gdb_byte *writebuf, ULONGEST offset,
1635 ULONGEST len, ULONGEST *xfered_len)
1637 if (!record_full_gdb_operation_disable
1638 && (object == TARGET_OBJECT_MEMORY
1639 || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
1641 if (RECORD_FULL_IS_REPLAY)
1643 /* Let user choose if he wants to write memory or not. */
1644 if (!query (_("Because GDB is in replay mode, writing to memory "
1645 "will make the execution log unusable from this "
1646 "point onward. Write memory at address %s?"),
1647 paddress (target_gdbarch (), offset)))
1648 error (_("Process record canceled the operation."));
1650 /* Destroy the record from here forward. */
1651 record_full_list_release_following (record_full_list);
1654 /* Check record_full_insn_num */
1655 record_full_check_insn_num ();
1657 /* Record registers change to list as an instruction. */
1658 record_full_arch_list_head = NULL;
1659 record_full_arch_list_tail = NULL;
1660 if (record_full_arch_list_add_mem (offset, len))
1662 record_full_list_release (record_full_arch_list_tail);
1664 fprintf_unfiltered (gdb_stdlog,
1665 "Process record: failed to record "
1667 return TARGET_XFER_E_IO;
1669 if (record_full_arch_list_add_end ())
1671 record_full_list_release (record_full_arch_list_tail);
1673 fprintf_unfiltered (gdb_stdlog,
1674 "Process record: failed to record "
1676 return TARGET_XFER_E_IO;
1678 record_full_list->next = record_full_arch_list_head;
1679 record_full_arch_list_head->prev = record_full_list;
1680 record_full_list = record_full_arch_list_tail;
1682 if (record_full_insn_num == record_full_insn_max_num)
1683 record_full_list_release_first ();
1685 record_full_insn_num++;
1688 return this->beneath ()->xfer_partial (object, annex, readbuf, writebuf,
1689 offset, len, xfered_len);
1692 /* This structure represents a breakpoint inserted while the record
1693 target is active. We use this to know when to install/remove
1694 breakpoints in/from the target beneath. For example, a breakpoint
1695 may be inserted while recording, but removed when not replaying nor
1696 recording. In that case, the breakpoint had not been inserted on
1697 the target beneath, so we should not try to remove it there. */
1699 struct record_full_breakpoint
1701 record_full_breakpoint (struct address_space *address_space_,
1703 bool in_target_beneath_)
1704 : address_space (address_space_),
1706 in_target_beneath (in_target_beneath_)
1710 /* The address and address space the breakpoint was set at. */
1711 struct address_space *address_space;
1714 /* True when the breakpoint has been also installed in the target
1715 beneath. This will be false for breakpoints set during replay or
1717 bool in_target_beneath;
1720 /* The list of breakpoints inserted while the record target is
1722 static std::vector<record_full_breakpoint> record_full_breakpoints;
1725 record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
1727 if (loc->loc_type != bp_loc_software_breakpoint)
1732 record_full_breakpoints.emplace_back
1733 (loc->target_info.placed_address_space,
1734 loc->target_info.placed_address,
1739 /* Sync existing breakpoints to record_full_breakpoints. */
1742 record_full_init_record_breakpoints (void)
1744 record_full_breakpoints.clear ();
1746 iterate_over_bp_locations (record_full_sync_record_breakpoints);
1749 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1750 insert or remove breakpoints in the real target when replaying, nor
1754 record_full_target::insert_breakpoint (struct gdbarch *gdbarch,
1755 struct bp_target_info *bp_tgt)
1757 bool in_target_beneath = false;
1759 if (!RECORD_FULL_IS_REPLAY)
1761 /* When recording, we currently always single-step, so we don't
1762 really need to install regular breakpoints in the inferior.
1763 However, we do have to insert software single-step
1764 breakpoints, in case the target can't hardware step. To keep
1765 things simple, we always insert. */
1767 scoped_restore restore_operation_disable
1768 = record_full_gdb_operation_disable_set ();
1770 int ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt);
1774 in_target_beneath = true;
1777 /* Use the existing entries if found in order to avoid duplication
1778 in record_full_breakpoints. */
1780 for (const record_full_breakpoint &bp : record_full_breakpoints)
1782 if (bp.addr == bp_tgt->placed_address
1783 && bp.address_space == bp_tgt->placed_address_space)
1785 gdb_assert (bp.in_target_beneath == in_target_beneath);
1790 record_full_breakpoints.emplace_back (bp_tgt->placed_address_space,
1791 bp_tgt->placed_address,
1796 /* "remove_breakpoint" method for process record target. */
1799 record_full_target::remove_breakpoint (struct gdbarch *gdbarch,
1800 struct bp_target_info *bp_tgt,
1801 enum remove_bp_reason reason)
1803 for (auto iter = record_full_breakpoints.begin ();
1804 iter != record_full_breakpoints.end ();
1807 struct record_full_breakpoint &bp = *iter;
1809 if (bp.addr == bp_tgt->placed_address
1810 && bp.address_space == bp_tgt->placed_address_space)
1812 if (bp.in_target_beneath)
1814 scoped_restore restore_operation_disable
1815 = record_full_gdb_operation_disable_set ();
1817 int ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt,
1823 if (reason == REMOVE_BREAKPOINT)
1824 unordered_remove (record_full_breakpoints, iter);
1829 gdb_assert_not_reached ("removing unknown breakpoint");
1832 /* "can_execute_reverse" method for process record target. */
1835 record_full_base_target::can_execute_reverse ()
1840 /* "get_bookmark" method for process record and prec over core. */
1843 record_full_base_target::get_bookmark (const char *args, int from_tty)
1847 /* Return stringified form of instruction count. */
1848 if (record_full_list && record_full_list->type == record_full_end)
1849 ret = xstrdup (pulongest (record_full_list->u.end.insn_num));
1854 fprintf_unfiltered (gdb_stdlog,
1855 "record_full_get_bookmark returns %s\n", ret);
1857 fprintf_unfiltered (gdb_stdlog,
1858 "record_full_get_bookmark returns NULL\n");
1860 return (gdb_byte *) ret;
1863 /* "goto_bookmark" method for process record and prec over core. */
1866 record_full_base_target::goto_bookmark (const gdb_byte *raw_bookmark,
1869 const char *bookmark = (const char *) raw_bookmark;
1872 fprintf_unfiltered (gdb_stdlog,
1873 "record_full_goto_bookmark receives %s\n", bookmark);
1875 std::string name_holder;
1876 if (bookmark[0] == '\'' || bookmark[0] == '\"')
1878 if (bookmark[strlen (bookmark) - 1] != bookmark[0])
1879 error (_("Unbalanced quotes: %s"), bookmark);
1881 name_holder = std::string (bookmark + 1, strlen (bookmark) - 2);
1882 bookmark = name_holder.c_str ();
1885 record_goto (bookmark);
1888 enum exec_direction_kind
1889 record_full_base_target::execution_direction ()
1891 return record_full_execution_dir;
1894 /* The record_method method of target record-full. */
1897 record_full_base_target::record_method (ptid_t ptid)
1899 return RECORD_METHOD_FULL;
1903 record_full_base_target::info_record ()
1905 struct record_full_entry *p;
1907 if (RECORD_FULL_IS_REPLAY)
1908 printf_filtered (_("Replay mode:\n"));
1910 printf_filtered (_("Record mode:\n"));
1912 /* Find entry for first actual instruction in the log. */
1913 for (p = record_full_first.next;
1914 p != NULL && p->type != record_full_end;
1918 /* Do we have a log at all? */
1919 if (p != NULL && p->type == record_full_end)
1921 /* Display instruction number for first instruction in the log. */
1922 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1923 pulongest (p->u.end.insn_num));
1925 /* If in replay mode, display where we are in the log. */
1926 if (RECORD_FULL_IS_REPLAY)
1927 printf_filtered (_("Current instruction number is %s.\n"),
1928 pulongest (record_full_list->u.end.insn_num));
1930 /* Display instruction number for last instruction in the log. */
1931 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1932 pulongest (record_full_insn_count));
1934 /* Display log count. */
1935 printf_filtered (_("Log contains %u instructions.\n"),
1936 record_full_insn_num);
1939 printf_filtered (_("No instructions have been logged.\n"));
1941 /* Display max log size. */
1942 printf_filtered (_("Max logged instructions is %u.\n"),
1943 record_full_insn_max_num);
1947 record_full_base_target::supports_delete_record ()
1952 /* The "delete_record" target method. */
1955 record_full_base_target::delete_record ()
1957 record_full_list_release_following (record_full_list);
1960 /* The "record_is_replaying" target method. */
1963 record_full_base_target::record_is_replaying (ptid_t ptid)
1965 return RECORD_FULL_IS_REPLAY;
1968 /* The "record_will_replay" target method. */
1971 record_full_base_target::record_will_replay (ptid_t ptid, int dir)
1973 /* We can currently only record when executing forwards. Should we be able
1974 to record when executing backwards on targets that support reverse
1975 execution, this needs to be changed. */
1977 return RECORD_FULL_IS_REPLAY || dir == EXEC_REVERSE;
1980 /* Go to a specific entry. */
1983 record_full_goto_entry (struct record_full_entry *p)
1986 error (_("Target insn not found."));
1987 else if (p == record_full_list)
1988 error (_("Already at target insn."));
1989 else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
1991 printf_filtered (_("Go forward to insn number %s\n"),
1992 pulongest (p->u.end.insn_num));
1993 record_full_goto_insn (p, EXEC_FORWARD);
1997 printf_filtered (_("Go backward to insn number %s\n"),
1998 pulongest (p->u.end.insn_num));
1999 record_full_goto_insn (p, EXEC_REVERSE);
2002 registers_changed ();
2003 reinit_frame_cache ();
2004 inferior_thread ()->suspend.stop_pc
2005 = regcache_read_pc (get_current_regcache ());
2006 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2009 /* The "goto_record_begin" target method. */
2012 record_full_base_target::goto_record_begin ()
2014 struct record_full_entry *p = NULL;
2016 for (p = &record_full_first; p != NULL; p = p->next)
2017 if (p->type == record_full_end)
2020 record_full_goto_entry (p);
2023 /* The "goto_record_end" target method. */
2026 record_full_base_target::goto_record_end ()
2028 struct record_full_entry *p = NULL;
2030 for (p = record_full_list; p->next != NULL; p = p->next)
2032 for (; p!= NULL; p = p->prev)
2033 if (p->type == record_full_end)
2036 record_full_goto_entry (p);
2039 /* The "goto_record" target method. */
2042 record_full_base_target::goto_record (ULONGEST target_insn)
2044 struct record_full_entry *p = NULL;
2046 for (p = &record_full_first; p != NULL; p = p->next)
2047 if (p->type == record_full_end && p->u.end.insn_num == target_insn)
2050 record_full_goto_entry (p);
2053 /* The "record_stop_replaying" target method. */
2056 record_full_base_target::record_stop_replaying ()
2061 /* "resume" method for prec over corefile. */
2064 record_full_core_target::resume (ptid_t ptid, int step,
2065 enum gdb_signal signal)
2067 record_full_resume_step = step;
2068 record_full_resumed = 1;
2069 record_full_execution_dir = ::execution_direction;
2071 /* We are about to start executing the inferior (or simulate it),
2072 let's register it with the event loop. */
2073 if (target_can_async_p ())
2077 /* "kill" method for prec over corefile. */
2080 record_full_core_target::kill ()
2083 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
2085 unpush_target (this);
2088 /* "fetch_registers" method for prec over corefile. */
2091 record_full_core_target::fetch_registers (struct regcache *regcache,
2096 int num = gdbarch_num_regs (regcache->arch ());
2099 for (i = 0; i < num; i ++)
2100 regcache->raw_supply (i, *record_full_core_regbuf);
2103 regcache->raw_supply (regno, *record_full_core_regbuf);
2106 /* "prepare_to_store" method for prec over corefile. */
2109 record_full_core_target::prepare_to_store (struct regcache *regcache)
2113 /* "store_registers" method for prec over corefile. */
2116 record_full_core_target::store_registers (struct regcache *regcache,
2119 if (record_full_gdb_operation_disable)
2120 record_full_core_regbuf->raw_supply (regno, *regcache);
2122 error (_("You can't do that without a process to debug."));
2125 /* "xfer_partial" method for prec over corefile. */
2127 enum target_xfer_status
2128 record_full_core_target::xfer_partial (enum target_object object,
2129 const char *annex, gdb_byte *readbuf,
2130 const gdb_byte *writebuf, ULONGEST offset,
2131 ULONGEST len, ULONGEST *xfered_len)
2133 if (object == TARGET_OBJECT_MEMORY)
2135 if (record_full_gdb_operation_disable || !writebuf)
2137 struct target_section *p;
2139 for (p = record_full_core_start; p < record_full_core_end; p++)
2141 if (offset >= p->addr)
2143 struct record_full_core_buf_entry *entry;
2144 ULONGEST sec_offset;
2146 if (offset >= p->endaddr)
2149 if (offset + len > p->endaddr)
2150 len = p->endaddr - offset;
2152 sec_offset = offset - p->addr;
2154 /* Read readbuf or write writebuf p, offset, len. */
2156 if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
2157 || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
2160 memset (readbuf, 0, len);
2163 return TARGET_XFER_OK;
2165 /* Get record_full_core_buf_entry. */
2166 for (entry = record_full_core_buf_list; entry;
2167 entry = entry->prev)
2174 /* Add a new entry. */
2175 entry = XNEW (struct record_full_core_buf_entry);
2177 if (!bfd_malloc_and_get_section
2178 (p->the_bfd_section->owner,
2183 return TARGET_XFER_EOF;
2185 entry->prev = record_full_core_buf_list;
2186 record_full_core_buf_list = entry;
2189 memcpy (entry->buf + sec_offset, writebuf,
2195 return this->beneath ()->xfer_partial (object, annex,
2200 memcpy (readbuf, entry->buf + sec_offset,
2205 return TARGET_XFER_OK;
2209 return TARGET_XFER_E_IO;
2212 error (_("You can't do that without a process to debug."));
2215 return this->beneath ()->xfer_partial (object, annex,
2216 readbuf, writebuf, offset, len,
2220 /* "insert_breakpoint" method for prec over corefile. */
2223 record_full_core_target::insert_breakpoint (struct gdbarch *gdbarch,
2224 struct bp_target_info *bp_tgt)
2229 /* "remove_breakpoint" method for prec over corefile. */
2232 record_full_core_target::remove_breakpoint (struct gdbarch *gdbarch,
2233 struct bp_target_info *bp_tgt,
2234 enum remove_bp_reason reason)
2239 /* "has_execution" method for prec over corefile. */
2242 record_full_core_target::has_execution (ptid_t the_ptid)
2247 /* Record log save-file format
2248 Version 1 (never released)
2251 4 bytes: magic number htonl(0x20090829).
2252 NOTE: be sure to change whenever this file format changes!
2256 1 byte: record type (record_full_end, see enum record_full_type).
2258 1 byte: record type (record_full_reg, see enum record_full_type).
2259 8 bytes: register id (network byte order).
2260 MAX_REGISTER_SIZE bytes: register value.
2262 1 byte: record type (record_full_mem, see enum record_full_type).
2263 8 bytes: memory length (network byte order).
2264 8 bytes: memory address (network byte order).
2265 n bytes: memory value (n == memory length).
2268 4 bytes: magic number netorder32(0x20091016).
2269 NOTE: be sure to change whenever this file format changes!
2273 1 byte: record type (record_full_end, see enum record_full_type).
2275 4 bytes: instruction count
2277 1 byte: record type (record_full_reg, see enum record_full_type).
2278 4 bytes: register id (network byte order).
2279 n bytes: register value (n == actual register size).
2280 (eg. 4 bytes for x86 general registers).
2282 1 byte: record type (record_full_mem, see enum record_full_type).
2283 4 bytes: memory length (network byte order).
2284 8 bytes: memory address (network byte order).
2285 n bytes: memory value (n == memory length).
2289 /* bfdcore_read -- read bytes from a core file section. */
2292 bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2294 int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2299 error (_("Failed to read %d bytes from core file %s ('%s')."),
2300 len, bfd_get_filename (obfd),
2301 bfd_errmsg (bfd_get_error ()));
2304 static inline uint64_t
2305 netorder64 (uint64_t input)
2309 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2310 BFD_ENDIAN_BIG, input);
2314 static inline uint32_t
2315 netorder32 (uint32_t input)
2319 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2320 BFD_ENDIAN_BIG, input);
2324 /* Restore the execution log from a core_bfd file. */
2326 record_full_restore (void)
2329 struct record_full_entry *rec;
2333 struct regcache *regcache;
2335 /* We restore the execution log from the open core bfd,
2337 if (core_bfd == NULL)
2340 /* "record_full_restore" can only be called when record list is empty. */
2341 gdb_assert (record_full_first.next == NULL);
2344 fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
2346 /* Now need to find our special note section. */
2347 osec = bfd_get_section_by_name (core_bfd, "null0");
2349 fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
2350 osec ? "succeeded" : "failed");
2353 osec_size = bfd_section_size (core_bfd, osec);
2355 fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
2357 /* Check the magic code. */
2358 bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
2359 if (magic != RECORD_FULL_FILE_MAGIC)
2360 error (_("Version mis-match or file format error in core file %s."),
2361 bfd_get_filename (core_bfd));
2363 fprintf_unfiltered (gdb_stdlog,
2364 " Reading 4-byte magic cookie "
2365 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2366 phex_nz (netorder32 (magic), 4));
2368 /* Restore the entries in recfd into record_full_arch_list_head and
2369 record_full_arch_list_tail. */
2370 record_full_arch_list_head = NULL;
2371 record_full_arch_list_tail = NULL;
2372 record_full_insn_num = 0;
2376 regcache = get_current_regcache ();
2381 uint32_t regnum, len, signal, count;
2384 /* We are finished when offset reaches osec_size. */
2385 if (bfd_offset >= osec_size)
2387 bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);
2391 case record_full_reg: /* reg */
2392 /* Get register number to regnum. */
2393 bfdcore_read (core_bfd, osec, ®num,
2394 sizeof (regnum), &bfd_offset);
2395 regnum = netorder32 (regnum);
2397 rec = record_full_reg_alloc (regcache, regnum);
2400 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2401 rec->u.reg.len, &bfd_offset);
2404 fprintf_unfiltered (gdb_stdlog,
2405 " Reading register %d (1 "
2406 "plus %lu plus %d bytes)\n",
2408 (unsigned long) sizeof (regnum),
2412 case record_full_mem: /* mem */
2414 bfdcore_read (core_bfd, osec, &len,
2415 sizeof (len), &bfd_offset);
2416 len = netorder32 (len);
2419 bfdcore_read (core_bfd, osec, &addr,
2420 sizeof (addr), &bfd_offset);
2421 addr = netorder64 (addr);
2423 rec = record_full_mem_alloc (addr, len);
2426 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2427 rec->u.mem.len, &bfd_offset);
2430 fprintf_unfiltered (gdb_stdlog,
2431 " Reading memory %s (1 plus "
2432 "%lu plus %lu plus %d bytes)\n",
2433 paddress (get_current_arch (),
2435 (unsigned long) sizeof (addr),
2436 (unsigned long) sizeof (len),
2440 case record_full_end: /* end */
2441 rec = record_full_end_alloc ();
2442 record_full_insn_num ++;
2444 /* Get signal value. */
2445 bfdcore_read (core_bfd, osec, &signal,
2446 sizeof (signal), &bfd_offset);
2447 signal = netorder32 (signal);
2448 rec->u.end.sigval = (enum gdb_signal) signal;
2450 /* Get insn count. */
2451 bfdcore_read (core_bfd, osec, &count,
2452 sizeof (count), &bfd_offset);
2453 count = netorder32 (count);
2454 rec->u.end.insn_num = count;
2455 record_full_insn_count = count + 1;
2457 fprintf_unfiltered (gdb_stdlog,
2458 " Reading record_full_end (1 + "
2459 "%lu + %lu bytes), offset == %s\n",
2460 (unsigned long) sizeof (signal),
2461 (unsigned long) sizeof (count),
2462 paddress (get_current_arch (),
2467 error (_("Bad entry type in core file %s."),
2468 bfd_get_filename (core_bfd));
2472 /* Add rec to record arch list. */
2473 record_full_arch_list_add (rec);
2476 catch (const gdb_exception &ex)
2478 record_full_list_release (record_full_arch_list_tail);
2479 throw_exception (ex);
2482 /* Add record_full_arch_list_head to the end of record list. */
2483 record_full_first.next = record_full_arch_list_head;
2484 record_full_arch_list_head->prev = &record_full_first;
2485 record_full_arch_list_tail->next = NULL;
2486 record_full_list = &record_full_first;
2488 /* Update record_full_insn_max_num. */
2489 if (record_full_insn_num > record_full_insn_max_num)
2491 record_full_insn_max_num = record_full_insn_num;
2492 warning (_("Auto increase record/replay buffer limit to %u."),
2493 record_full_insn_max_num);
2497 printf_filtered (_("Restored records from core file %s.\n"),
2498 bfd_get_filename (core_bfd));
2500 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2503 /* bfdcore_write -- write bytes into a core file section. */
2506 bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2508 int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2513 error (_("Failed to write %d bytes to core file %s ('%s')."),
2514 len, bfd_get_filename (obfd),
2515 bfd_errmsg (bfd_get_error ()));
2518 /* Restore the execution log from a file. We use a modified elf
2519 corefile format, with an extra section for our data. */
2522 cmd_record_full_restore (const char *args, int from_tty)
2524 core_file_command (args, from_tty);
2525 record_full_open (args, from_tty);
2528 /* Save the execution log to a file. We use a modified elf corefile
2529 format, with an extra section for our data. */
2532 record_full_base_target::save_record (const char *recfilename)
2534 struct record_full_entry *cur_record_full_list;
2536 struct regcache *regcache;
2537 struct gdbarch *gdbarch;
2539 asection *osec = NULL;
2542 /* Open the save file. */
2544 fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
2547 /* Open the output file. */
2548 gdb_bfd_ref_ptr obfd (create_gcore_bfd (recfilename));
2550 /* Arrange to remove the output file on failure. */
2551 gdb::unlinker unlink_file (recfilename);
2553 /* Save the current record entry to "cur_record_full_list". */
2554 cur_record_full_list = record_full_list;
2556 /* Get the values of regcache and gdbarch. */
2557 regcache = get_current_regcache ();
2558 gdbarch = regcache->arch ();
2560 /* Disable the GDB operation record. */
2561 scoped_restore restore_operation_disable
2562 = record_full_gdb_operation_disable_set ();
2564 /* Reverse execute to the begin of record list. */
2567 /* Check for beginning and end of log. */
2568 if (record_full_list == &record_full_first)
2571 record_full_exec_insn (regcache, gdbarch, record_full_list);
2573 if (record_full_list->prev)
2574 record_full_list = record_full_list->prev;
2577 /* Compute the size needed for the extra bfd section. */
2578 save_size = 4; /* magic cookie */
2579 for (record_full_list = record_full_first.next; record_full_list;
2580 record_full_list = record_full_list->next)
2581 switch (record_full_list->type)
2583 case record_full_end:
2584 save_size += 1 + 4 + 4;
2586 case record_full_reg:
2587 save_size += 1 + 4 + record_full_list->u.reg.len;
2589 case record_full_mem:
2590 save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
2594 /* Make the new bfd section. */
2595 osec = bfd_make_section_anyway_with_flags (obfd.get (), "precord",
2599 error (_("Failed to create 'precord' section for corefile %s: %s"),
2601 bfd_errmsg (bfd_get_error ()));
2602 bfd_set_section_size (obfd.get (), osec, save_size);
2603 bfd_set_section_vma (obfd.get (), osec, 0);
2604 bfd_set_section_alignment (obfd.get (), osec, 0);
2605 bfd_section_lma (obfd.get (), osec) = 0;
2607 /* Save corefile state. */
2608 write_gcore_file (obfd.get ());
2610 /* Write out the record log. */
2611 /* Write the magic code. */
2612 magic = RECORD_FULL_FILE_MAGIC;
2614 fprintf_unfiltered (gdb_stdlog,
2615 " Writing 4-byte magic cookie "
2616 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2617 phex_nz (magic, 4));
2618 bfdcore_write (obfd.get (), osec, &magic, sizeof (magic), &bfd_offset);
2620 /* Save the entries to recfd and forward execute to the end of
2622 record_full_list = &record_full_first;
2626 if (record_full_list != &record_full_first)
2629 uint32_t regnum, len, signal, count;
2632 type = record_full_list->type;
2633 bfdcore_write (obfd.get (), osec, &type, sizeof (type), &bfd_offset);
2635 switch (record_full_list->type)
2637 case record_full_reg: /* reg */
2639 fprintf_unfiltered (gdb_stdlog,
2640 " Writing register %d (1 "
2641 "plus %lu plus %d bytes)\n",
2642 record_full_list->u.reg.num,
2643 (unsigned long) sizeof (regnum),
2644 record_full_list->u.reg.len);
2647 regnum = netorder32 (record_full_list->u.reg.num);
2648 bfdcore_write (obfd.get (), osec, ®num,
2649 sizeof (regnum), &bfd_offset);
2652 bfdcore_write (obfd.get (), osec,
2653 record_full_get_loc (record_full_list),
2654 record_full_list->u.reg.len, &bfd_offset);
2657 case record_full_mem: /* mem */
2659 fprintf_unfiltered (gdb_stdlog,
2660 " Writing memory %s (1 plus "
2661 "%lu plus %lu plus %d bytes)\n",
2663 record_full_list->u.mem.addr),
2664 (unsigned long) sizeof (addr),
2665 (unsigned long) sizeof (len),
2666 record_full_list->u.mem.len);
2669 len = netorder32 (record_full_list->u.mem.len);
2670 bfdcore_write (obfd.get (), osec, &len, sizeof (len),
2673 /* Write memaddr. */
2674 addr = netorder64 (record_full_list->u.mem.addr);
2675 bfdcore_write (obfd.get (), osec, &addr,
2676 sizeof (addr), &bfd_offset);
2679 bfdcore_write (obfd.get (), osec,
2680 record_full_get_loc (record_full_list),
2681 record_full_list->u.mem.len, &bfd_offset);
2684 case record_full_end:
2686 fprintf_unfiltered (gdb_stdlog,
2687 " Writing record_full_end (1 + "
2688 "%lu + %lu bytes)\n",
2689 (unsigned long) sizeof (signal),
2690 (unsigned long) sizeof (count));
2691 /* Write signal value. */
2692 signal = netorder32 (record_full_list->u.end.sigval);
2693 bfdcore_write (obfd.get (), osec, &signal,
2694 sizeof (signal), &bfd_offset);
2696 /* Write insn count. */
2697 count = netorder32 (record_full_list->u.end.insn_num);
2698 bfdcore_write (obfd.get (), osec, &count,
2699 sizeof (count), &bfd_offset);
2704 /* Execute entry. */
2705 record_full_exec_insn (regcache, gdbarch, record_full_list);
2707 if (record_full_list->next)
2708 record_full_list = record_full_list->next;
2713 /* Reverse execute to cur_record_full_list. */
2716 /* Check for beginning and end of log. */
2717 if (record_full_list == cur_record_full_list)
2720 record_full_exec_insn (regcache, gdbarch, record_full_list);
2722 if (record_full_list->prev)
2723 record_full_list = record_full_list->prev;
2726 unlink_file.keep ();
2729 printf_filtered (_("Saved core file %s with execution log.\n"),
2733 /* record_full_goto_insn -- rewind the record log (forward or backward,
2734 depending on DIR) to the given entry, changing the program state
2738 record_full_goto_insn (struct record_full_entry *entry,
2739 enum exec_direction_kind dir)
2741 scoped_restore restore_operation_disable
2742 = record_full_gdb_operation_disable_set ();
2743 struct regcache *regcache = get_current_regcache ();
2744 struct gdbarch *gdbarch = regcache->arch ();
2746 /* Assume everything is valid: we will hit the entry,
2747 and we will not hit the end of the recording. */
2749 if (dir == EXEC_FORWARD)
2750 record_full_list = record_full_list->next;
2754 record_full_exec_insn (regcache, gdbarch, record_full_list);
2755 if (dir == EXEC_REVERSE)
2756 record_full_list = record_full_list->prev;
2758 record_full_list = record_full_list->next;
2759 } while (record_full_list != entry);
2762 /* Alias for "target record-full". */
2765 cmd_record_full_start (const char *args, int from_tty)
2767 execute_command ("target record-full", from_tty);
2771 set_record_full_insn_max_num (const char *args, int from_tty,
2772 struct cmd_list_element *c)
2774 if (record_full_insn_num > record_full_insn_max_num)
2776 /* Count down record_full_insn_num while releasing records from list. */
2777 while (record_full_insn_num > record_full_insn_max_num)
2779 record_full_list_release_first ();
2780 record_full_insn_num--;
2785 /* The "set record full" command. */
2788 set_record_full_command (const char *args, int from_tty)
2790 printf_unfiltered (_("\"set record full\" must be followed "
2791 "by an appropriate subcommand.\n"));
2792 help_list (set_record_full_cmdlist, "set record full ", all_commands,
2796 /* The "show record full" command. */
2799 show_record_full_command (const char *args, int from_tty)
2801 cmd_show_list (show_record_full_cmdlist, from_tty, "");
2805 _initialize_record_full (void)
2807 struct cmd_list_element *c;
2809 /* Init record_full_first. */
2810 record_full_first.prev = NULL;
2811 record_full_first.next = NULL;
2812 record_full_first.type = record_full_end;
2814 add_target (record_full_target_info, record_full_open);
2815 add_deprecated_target_alias (record_full_target_info, "record");
2816 add_target (record_full_core_target_info, record_full_open);
2818 add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
2819 _("Start full execution recording."), &record_full_cmdlist,
2820 "record full ", 0, &record_cmdlist);
2822 c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
2823 _("Restore the execution log from a file.\n\
2824 Argument is filename. File must be created with 'record save'."),
2825 &record_full_cmdlist);
2826 set_cmd_completer (c, filename_completer);
2828 /* Deprecate the old version without "full" prefix. */
2829 c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
2831 set_cmd_completer (c, filename_completer);
2832 deprecate_cmd (c, "record full restore");
2834 add_prefix_cmd ("full", class_support, set_record_full_command,
2835 _("Set record options"), &set_record_full_cmdlist,
2836 "set record full ", 0, &set_record_cmdlist);
2838 add_prefix_cmd ("full", class_support, show_record_full_command,
2839 _("Show record options"), &show_record_full_cmdlist,
2840 "show record full ", 0, &show_record_cmdlist);
2842 /* Record instructions number limit command. */
2843 add_setshow_boolean_cmd ("stop-at-limit", no_class,
2844 &record_full_stop_at_limit, _("\
2845 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2846 Show whether record/replay stops when record/replay buffer becomes full."),
2847 _("Default is ON.\n\
2848 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2849 When OFF, if the record/replay buffer becomes full,\n\
2850 delete the oldest recorded instruction to make room for each new one."),
2852 &set_record_full_cmdlist, &show_record_full_cmdlist);
2854 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2855 &set_record_cmdlist);
2856 deprecate_cmd (c, "set record full stop-at-limit");
2858 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2859 &show_record_cmdlist);
2860 deprecate_cmd (c, "show record full stop-at-limit");
2862 add_setshow_uinteger_cmd ("insn-number-max", no_class,
2863 &record_full_insn_max_num,
2864 _("Set record/replay buffer limit."),
2865 _("Show record/replay buffer limit."), _("\
2866 Set the maximum number of instructions to be stored in the\n\
2867 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2868 limit. Default is 200000."),
2869 set_record_full_insn_max_num,
2870 NULL, &set_record_full_cmdlist,
2871 &show_record_full_cmdlist);
2873 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2874 &set_record_cmdlist);
2875 deprecate_cmd (c, "set record full insn-number-max");
2877 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2878 &show_record_cmdlist);
2879 deprecate_cmd (c, "show record full insn-number-max");
2881 add_setshow_boolean_cmd ("memory-query", no_class,
2882 &record_full_memory_query, _("\
2883 Set whether query if PREC cannot record memory change of next instruction."),
2885 Show whether query if PREC cannot record memory change of next instruction."),
2888 When ON, query if PREC cannot record memory change of next instruction."),
2890 &set_record_full_cmdlist,
2891 &show_record_full_cmdlist);
2893 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2894 &set_record_cmdlist);
2895 deprecate_cmd (c, "set record full memory-query");
2897 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2898 &show_record_cmdlist);
2899 deprecate_cmd (c, "show record full memory-query");