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 (ex, RETURN_MASK_ALL)
766 record_full_list_release (record_full_arch_list_tail);
767 throw_exception (ex);
771 record_full_list->next = record_full_arch_list_head;
772 record_full_arch_list_head->prev = record_full_list;
773 record_full_list = record_full_arch_list_tail;
775 if (record_full_insn_num == record_full_insn_max_num)
776 record_full_list_release_first ();
778 record_full_insn_num++;
782 record_full_message_wrapper_safe (struct regcache *regcache,
783 enum gdb_signal signal)
787 record_full_message (regcache, signal);
789 CATCH (ex, RETURN_MASK_ALL)
791 exception_print (gdb_stderr, ex);
799 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
800 doesn't need record. */
802 static int record_full_gdb_operation_disable = 0;
804 scoped_restore_tmpl<int>
805 record_full_gdb_operation_disable_set (void)
807 return make_scoped_restore (&record_full_gdb_operation_disable, 1);
810 /* Flag set to TRUE for target_stopped_by_watchpoint. */
811 static enum target_stop_reason record_full_stop_reason
812 = TARGET_STOPPED_BY_NO_REASON;
814 /* Execute one instruction from the record log. Each instruction in
815 the log will be represented by an arbitrary sequence of register
816 entries and memory entries, followed by an 'end' entry. */
819 record_full_exec_insn (struct regcache *regcache,
820 struct gdbarch *gdbarch,
821 struct record_full_entry *entry)
825 case record_full_reg: /* reg */
827 gdb::byte_vector reg (entry->u.reg.len);
829 if (record_debug > 1)
830 fprintf_unfiltered (gdb_stdlog,
831 "Process record: record_full_reg %s to "
832 "inferior num = %d.\n",
833 host_address_to_string (entry),
836 regcache->cooked_read (entry->u.reg.num, reg.data ());
837 regcache->cooked_write (entry->u.reg.num, record_full_get_loc (entry));
838 memcpy (record_full_get_loc (entry), reg.data (), entry->u.reg.len);
842 case record_full_mem: /* mem */
844 /* Nothing to do if the entry is flagged not_accessible. */
845 if (!entry->u.mem.mem_entry_not_accessible)
847 gdb::byte_vector mem (entry->u.mem.len);
849 if (record_debug > 1)
850 fprintf_unfiltered (gdb_stdlog,
851 "Process record: record_full_mem %s to "
852 "inferior addr = %s len = %d.\n",
853 host_address_to_string (entry),
854 paddress (gdbarch, entry->u.mem.addr),
857 if (record_read_memory (gdbarch,
858 entry->u.mem.addr, mem.data (),
860 entry->u.mem.mem_entry_not_accessible = 1;
863 if (target_write_memory (entry->u.mem.addr,
864 record_full_get_loc (entry),
867 entry->u.mem.mem_entry_not_accessible = 1;
869 warning (_("Process record: error writing memory at "
870 "addr = %s len = %d."),
871 paddress (gdbarch, entry->u.mem.addr),
876 memcpy (record_full_get_loc (entry), mem.data (),
879 /* We've changed memory --- check if a hardware
880 watchpoint should trap. Note that this
881 presently assumes the target beneath supports
882 continuable watchpoints. On non-continuable
883 watchpoints target, we'll want to check this
884 _before_ actually doing the memory change, and
885 not doing the change at all if the watchpoint
887 if (hardware_watchpoint_inserted_in_range
888 (regcache->aspace (),
889 entry->u.mem.addr, entry->u.mem.len))
890 record_full_stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
899 static void record_full_restore (void);
901 /* Asynchronous signal handle registered as event loop source for when
902 we have pending events ready to be passed to the core. */
904 static struct async_event_handler *record_full_async_inferior_event_token;
907 record_full_async_inferior_event_handler (gdb_client_data data)
909 inferior_event_handler (INF_REG_EVENT, NULL);
912 /* Open the process record target for 'core' files. */
915 record_full_core_open_1 (const char *name, int from_tty)
917 struct regcache *regcache = get_current_regcache ();
918 int regnum = gdbarch_num_regs (regcache->arch ());
921 /* Get record_full_core_regbuf. */
922 target_fetch_registers (regcache, -1);
923 record_full_core_regbuf = new detached_regcache (regcache->arch (), false);
925 for (i = 0; i < regnum; i ++)
926 record_full_core_regbuf->raw_supply (i, *regcache);
928 /* Get record_full_core_start and record_full_core_end. */
929 if (build_section_table (core_bfd, &record_full_core_start,
930 &record_full_core_end))
932 delete record_full_core_regbuf;
933 record_full_core_regbuf = NULL;
934 error (_("\"%s\": Can't find sections: %s"),
935 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
938 push_target (&record_full_core_ops);
939 record_full_restore ();
942 /* Open the process record target for 'live' processes. */
945 record_full_open_1 (const char *name, int from_tty)
948 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open_1\n");
951 if (!target_has_execution)
952 error (_("Process record: the program is not being run."));
954 error (_("Process record target can't debug inferior in non-stop mode "
957 if (!gdbarch_process_record_p (target_gdbarch ()))
958 error (_("Process record: the current architecture doesn't support "
959 "record function."));
961 push_target (&record_full_ops);
964 static void record_full_init_record_breakpoints (void);
966 /* Open the process record target. */
969 record_full_open (const char *name, int from_tty)
972 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
977 record_full_insn_num = 0;
978 record_full_insn_count = 0;
979 record_full_list = &record_full_first;
980 record_full_list->next = NULL;
983 record_full_core_open_1 (name, from_tty);
985 record_full_open_1 (name, from_tty);
987 /* Register extra event sources in the event loop. */
988 record_full_async_inferior_event_token
989 = create_async_event_handler (record_full_async_inferior_event_handler,
992 record_full_init_record_breakpoints ();
994 gdb::observers::record_changed.notify (current_inferior (), 1, "full", NULL);
997 /* "close" target method. Close the process record target. */
1000 record_full_base_target::close ()
1002 struct record_full_core_buf_entry *entry;
1005 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_close\n");
1007 record_full_list_release (record_full_list);
1009 /* Release record_full_core_regbuf. */
1010 if (record_full_core_regbuf)
1012 delete record_full_core_regbuf;
1013 record_full_core_regbuf = NULL;
1016 /* Release record_full_core_buf_list. */
1017 while (record_full_core_buf_list)
1019 entry = record_full_core_buf_list;
1020 record_full_core_buf_list = record_full_core_buf_list->prev;
1024 if (record_full_async_inferior_event_token)
1025 delete_async_event_handler (&record_full_async_inferior_event_token);
1028 /* "async" target method. */
1031 record_full_base_target::async (int enable)
1034 mark_async_event_handler (record_full_async_inferior_event_token);
1036 clear_async_event_handler (record_full_async_inferior_event_token);
1038 beneath ()->async (enable);
1041 static int record_full_resume_step = 0;
1043 /* True if we've been resumed, and so each record_full_wait call should
1044 advance execution. If this is false, record_full_wait will return a
1045 TARGET_WAITKIND_IGNORE. */
1046 static int record_full_resumed = 0;
1048 /* The execution direction of the last resume we got. This is
1049 necessary for async mode. Vis (order is not strictly accurate):
1051 1. user has the global execution direction set to forward
1052 2. user does a reverse-step command
1053 3. record_full_resume is called with global execution direction
1054 temporarily switched to reverse
1055 4. GDB's execution direction is reverted back to forward
1056 5. target record notifies event loop there's an event to handle
1057 6. infrun asks the target which direction was it going, and switches
1058 the global execution direction accordingly (to reverse)
1059 7. infrun polls an event out of the record target, and handles it
1060 8. GDB goes back to the event loop, and goto #4.
1062 static enum exec_direction_kind record_full_execution_dir = EXEC_FORWARD;
1064 /* "resume" target method. Resume the process record target. */
1067 record_full_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
1069 record_full_resume_step = step;
1070 record_full_resumed = 1;
1071 record_full_execution_dir = ::execution_direction;
1073 if (!RECORD_FULL_IS_REPLAY)
1075 struct gdbarch *gdbarch = target_thread_architecture (ptid);
1077 record_full_message (get_current_regcache (), signal);
1081 /* This is not hard single step. */
1082 if (!gdbarch_software_single_step_p (gdbarch))
1084 /* This is a normal continue. */
1089 /* This arch supports soft single step. */
1090 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
1092 /* This is a soft single step. */
1093 record_full_resume_step = 1;
1096 step = !insert_single_step_breakpoints (gdbarch);
1100 /* Make sure the target beneath reports all signals. */
1101 target_pass_signals (0, NULL);
1103 this->beneath ()->resume (ptid, step, signal);
1106 /* We are about to start executing the inferior (or simulate it),
1107 let's register it with the event loop. */
1108 if (target_can_async_p ())
1112 /* "commit_resume" method for process record target. */
1115 record_full_target::commit_resume ()
1117 if (!RECORD_FULL_IS_REPLAY)
1118 beneath ()->commit_resume ();
1121 static int record_full_get_sig = 0;
1123 /* SIGINT signal handler, registered by "wait" method. */
1126 record_full_sig_handler (int signo)
1129 fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
1131 /* It will break the running inferior in replay mode. */
1132 record_full_resume_step = 1;
1134 /* It will let record_full_wait set inferior status to get the signal
1136 record_full_get_sig = 1;
1139 /* "wait" target method for process record target.
1141 In record mode, the target is always run in singlestep mode
1142 (even when gdb says to continue). The wait method intercepts
1143 the stop events and determines which ones are to be passed on to
1144 gdb. Most stop events are just singlestep events that gdb is not
1145 to know about, so the wait method just records them and keeps
1148 In replay mode, this function emulates the recorded execution log,
1149 one instruction at a time (forward or backward), and determines
1153 record_full_wait_1 (struct target_ops *ops,
1154 ptid_t ptid, struct target_waitstatus *status,
1157 scoped_restore restore_operation_disable
1158 = record_full_gdb_operation_disable_set ();
1161 fprintf_unfiltered (gdb_stdlog,
1162 "Process record: record_full_wait "
1163 "record_full_resume_step = %d, "
1164 "record_full_resumed = %d, direction=%s\n",
1165 record_full_resume_step, record_full_resumed,
1166 record_full_execution_dir == EXEC_FORWARD
1167 ? "forward" : "reverse");
1169 if (!record_full_resumed)
1171 gdb_assert ((options & TARGET_WNOHANG) != 0);
1173 /* No interesting event. */
1174 status->kind = TARGET_WAITKIND_IGNORE;
1175 return minus_one_ptid;
1178 record_full_get_sig = 0;
1179 signal (SIGINT, record_full_sig_handler);
1181 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1183 if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
1185 if (record_full_resume_step)
1187 /* This is a single step. */
1188 return ops->beneath ()->wait (ptid, status, options);
1192 /* This is not a single step. */
1195 struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);
1199 ret = ops->beneath ()->wait (ptid, status, options);
1200 if (status->kind == TARGET_WAITKIND_IGNORE)
1203 fprintf_unfiltered (gdb_stdlog,
1204 "Process record: record_full_wait "
1205 "target beneath not done yet\n");
1209 for (thread_info *tp : all_non_exited_threads ())
1210 delete_single_step_breakpoints (tp);
1212 if (record_full_resume_step)
1215 /* Is this a SIGTRAP? */
1216 if (status->kind == TARGET_WAITKIND_STOPPED
1217 && status->value.sig == GDB_SIGNAL_TRAP)
1219 struct regcache *regcache;
1220 enum target_stop_reason *stop_reason_p
1221 = &record_full_stop_reason;
1223 /* Yes -- this is likely our single-step finishing,
1224 but check if there's any reason the core would be
1225 interested in the event. */
1227 registers_changed ();
1228 regcache = get_current_regcache ();
1229 tmp_pc = regcache_read_pc (regcache);
1230 const struct address_space *aspace = regcache->aspace ();
1232 if (target_stopped_by_watchpoint ())
1234 /* Always interested in watchpoints. */
1236 else if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1239 /* There is a breakpoint here. Let the core
1244 /* This is a single-step trap. Record the
1245 insn and issue another step.
1246 FIXME: this part can be a random SIGTRAP too.
1247 But GDB cannot handle it. */
1250 if (!record_full_message_wrapper_safe (regcache,
1253 status->kind = TARGET_WAITKIND_STOPPED;
1254 status->value.sig = GDB_SIGNAL_0;
1258 if (gdbarch_software_single_step_p (gdbarch))
1260 /* Try to insert the software single step breakpoint.
1261 If insert success, set step to 0. */
1262 set_executing (inferior_ptid, 0);
1263 reinit_frame_cache ();
1265 step = !insert_single_step_breakpoints (gdbarch);
1267 set_executing (inferior_ptid, 1);
1271 fprintf_unfiltered (gdb_stdlog,
1272 "Process record: record_full_wait "
1273 "issuing one more step in the "
1274 "target beneath\n");
1275 ops->beneath ()->resume (ptid, step, GDB_SIGNAL_0);
1276 ops->beneath ()->commit_resume ();
1281 /* The inferior is broken by a breakpoint or a signal. */
1290 struct regcache *regcache = get_current_regcache ();
1291 struct gdbarch *gdbarch = regcache->arch ();
1292 const struct address_space *aspace = regcache->aspace ();
1293 int continue_flag = 1;
1294 int first_record_full_end = 1;
1300 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1301 status->kind = TARGET_WAITKIND_STOPPED;
1303 /* Check breakpoint when forward execute. */
1304 if (execution_direction == EXEC_FORWARD)
1306 tmp_pc = regcache_read_pc (regcache);
1307 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1308 &record_full_stop_reason))
1311 fprintf_unfiltered (gdb_stdlog,
1312 "Process record: break at %s.\n",
1313 paddress (gdbarch, tmp_pc));
1318 /* If GDB is in terminal_inferior mode, it will not get the
1319 signal. And in GDB replay mode, GDB doesn't need to be
1320 in terminal_inferior mode, because inferior will not
1321 executed. Then set it to terminal_ours to make GDB get
1323 target_terminal::ours ();
1325 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1327 if (execution_direction == EXEC_FORWARD && record_full_list->next)
1328 record_full_list = record_full_list->next;
1330 /* Loop over the record_full_list, looking for the next place to
1334 /* Check for beginning and end of log. */
1335 if (execution_direction == EXEC_REVERSE
1336 && record_full_list == &record_full_first)
1338 /* Hit beginning of record log in reverse. */
1339 status->kind = TARGET_WAITKIND_NO_HISTORY;
1342 if (execution_direction != EXEC_REVERSE
1343 && !record_full_list->next)
1345 /* Hit end of record log going forward. */
1346 status->kind = TARGET_WAITKIND_NO_HISTORY;
1350 record_full_exec_insn (regcache, gdbarch, record_full_list);
1352 if (record_full_list->type == record_full_end)
1354 if (record_debug > 1)
1357 "Process record: record_full_end %s to "
1359 host_address_to_string (record_full_list));
1361 if (first_record_full_end
1362 && execution_direction == EXEC_REVERSE)
1364 /* When reverse excute, the first
1365 record_full_end is the part of current
1367 first_record_full_end = 0;
1371 /* In EXEC_REVERSE mode, this is the
1372 record_full_end of prev instruction. In
1373 EXEC_FORWARD mode, this is the
1374 record_full_end of current instruction. */
1376 if (record_full_resume_step)
1378 if (record_debug > 1)
1379 fprintf_unfiltered (gdb_stdlog,
1380 "Process record: step.\n");
1384 /* check breakpoint */
1385 tmp_pc = regcache_read_pc (regcache);
1386 if (record_check_stopped_by_breakpoint
1387 (aspace, tmp_pc, &record_full_stop_reason))
1390 fprintf_unfiltered (gdb_stdlog,
1391 "Process record: break "
1393 paddress (gdbarch, tmp_pc));
1398 if (record_full_stop_reason
1399 == TARGET_STOPPED_BY_WATCHPOINT)
1402 fprintf_unfiltered (gdb_stdlog,
1403 "Process record: hit hw "
1407 /* Check target signal */
1408 if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1409 /* FIXME: better way to check */
1416 if (execution_direction == EXEC_REVERSE)
1418 if (record_full_list->prev)
1419 record_full_list = record_full_list->prev;
1423 if (record_full_list->next)
1424 record_full_list = record_full_list->next;
1428 while (continue_flag);
1431 if (record_full_get_sig)
1432 status->value.sig = GDB_SIGNAL_INT;
1433 else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1434 /* FIXME: better way to check */
1435 status->value.sig = record_full_list->u.end.sigval;
1437 status->value.sig = GDB_SIGNAL_TRAP;
1439 CATCH (ex, RETURN_MASK_ALL)
1441 if (execution_direction == EXEC_REVERSE)
1443 if (record_full_list->next)
1444 record_full_list = record_full_list->next;
1447 record_full_list = record_full_list->prev;
1449 throw_exception (ex);
1454 signal (SIGINT, handle_sigint);
1456 return inferior_ptid;
1460 record_full_base_target::wait (ptid_t ptid, struct target_waitstatus *status,
1465 return_ptid = record_full_wait_1 (this, ptid, status, options);
1466 if (status->kind != TARGET_WAITKIND_IGNORE)
1468 /* We're reporting a stop. Make sure any spurious
1469 target_wait(WNOHANG) doesn't advance the target until the
1470 core wants us resumed again. */
1471 record_full_resumed = 0;
1477 record_full_base_target::stopped_by_watchpoint ()
1479 if (RECORD_FULL_IS_REPLAY)
1480 return record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
1482 return beneath ()->stopped_by_watchpoint ();
1486 record_full_base_target::stopped_data_address (CORE_ADDR *addr_p)
1488 if (RECORD_FULL_IS_REPLAY)
1491 return this->beneath ()->stopped_data_address (addr_p);
1494 /* The stopped_by_sw_breakpoint method of target record-full. */
1497 record_full_base_target::stopped_by_sw_breakpoint ()
1499 return record_full_stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
1502 /* The supports_stopped_by_sw_breakpoint method of target
1506 record_full_base_target::supports_stopped_by_sw_breakpoint ()
1511 /* The stopped_by_hw_breakpoint method of target record-full. */
1514 record_full_base_target::stopped_by_hw_breakpoint ()
1516 return record_full_stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
1519 /* The supports_stopped_by_sw_breakpoint method of target
1523 record_full_base_target::supports_stopped_by_hw_breakpoint ()
1528 /* Record registers change (by user or by GDB) to list as an instruction. */
1531 record_full_registers_change (struct regcache *regcache, int regnum)
1533 /* Check record_full_insn_num. */
1534 record_full_check_insn_num ();
1536 record_full_arch_list_head = NULL;
1537 record_full_arch_list_tail = NULL;
1543 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
1545 if (record_full_arch_list_add_reg (regcache, i))
1547 record_full_list_release (record_full_arch_list_tail);
1548 error (_("Process record: failed to record execution log."));
1554 if (record_full_arch_list_add_reg (regcache, regnum))
1556 record_full_list_release (record_full_arch_list_tail);
1557 error (_("Process record: failed to record execution log."));
1560 if (record_full_arch_list_add_end ())
1562 record_full_list_release (record_full_arch_list_tail);
1563 error (_("Process record: failed to record execution log."));
1565 record_full_list->next = record_full_arch_list_head;
1566 record_full_arch_list_head->prev = record_full_list;
1567 record_full_list = record_full_arch_list_tail;
1569 if (record_full_insn_num == record_full_insn_max_num)
1570 record_full_list_release_first ();
1572 record_full_insn_num++;
1575 /* "store_registers" method for process record target. */
1578 record_full_target::store_registers (struct regcache *regcache, int regno)
1580 if (!record_full_gdb_operation_disable)
1582 if (RECORD_FULL_IS_REPLAY)
1586 /* Let user choose if he wants to write register or not. */
1589 query (_("Because GDB is in replay mode, changing the "
1590 "value of a register will make the execution "
1591 "log unusable from this point onward. "
1592 "Change all registers?"));
1595 query (_("Because GDB is in replay mode, changing the value "
1596 "of a register will make the execution log unusable "
1597 "from this point onward. Change register %s?"),
1598 gdbarch_register_name (regcache->arch (),
1603 /* Invalidate the value of regcache that was set in function
1604 "regcache_raw_write". */
1610 i < gdbarch_num_regs (regcache->arch ());
1612 regcache->invalidate (i);
1615 regcache->invalidate (regno);
1617 error (_("Process record canceled the operation."));
1620 /* Destroy the record from here forward. */
1621 record_full_list_release_following (record_full_list);
1624 record_full_registers_change (regcache, regno);
1626 this->beneath ()->store_registers (regcache, regno);
1629 /* "xfer_partial" method. Behavior is conditional on
1630 RECORD_FULL_IS_REPLAY.
1631 In replay mode, we cannot write memory unles we are willing to
1632 invalidate the record/replay log from this point forward. */
1634 enum target_xfer_status
1635 record_full_target::xfer_partial (enum target_object object,
1636 const char *annex, gdb_byte *readbuf,
1637 const gdb_byte *writebuf, ULONGEST offset,
1638 ULONGEST len, ULONGEST *xfered_len)
1640 if (!record_full_gdb_operation_disable
1641 && (object == TARGET_OBJECT_MEMORY
1642 || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
1644 if (RECORD_FULL_IS_REPLAY)
1646 /* Let user choose if he wants to write memory or not. */
1647 if (!query (_("Because GDB is in replay mode, writing to memory "
1648 "will make the execution log unusable from this "
1649 "point onward. Write memory at address %s?"),
1650 paddress (target_gdbarch (), offset)))
1651 error (_("Process record canceled the operation."));
1653 /* Destroy the record from here forward. */
1654 record_full_list_release_following (record_full_list);
1657 /* Check record_full_insn_num */
1658 record_full_check_insn_num ();
1660 /* Record registers change to list as an instruction. */
1661 record_full_arch_list_head = NULL;
1662 record_full_arch_list_tail = NULL;
1663 if (record_full_arch_list_add_mem (offset, len))
1665 record_full_list_release (record_full_arch_list_tail);
1667 fprintf_unfiltered (gdb_stdlog,
1668 "Process record: failed to record "
1670 return TARGET_XFER_E_IO;
1672 if (record_full_arch_list_add_end ())
1674 record_full_list_release (record_full_arch_list_tail);
1676 fprintf_unfiltered (gdb_stdlog,
1677 "Process record: failed to record "
1679 return TARGET_XFER_E_IO;
1681 record_full_list->next = record_full_arch_list_head;
1682 record_full_arch_list_head->prev = record_full_list;
1683 record_full_list = record_full_arch_list_tail;
1685 if (record_full_insn_num == record_full_insn_max_num)
1686 record_full_list_release_first ();
1688 record_full_insn_num++;
1691 return this->beneath ()->xfer_partial (object, annex, readbuf, writebuf,
1692 offset, len, xfered_len);
1695 /* This structure represents a breakpoint inserted while the record
1696 target is active. We use this to know when to install/remove
1697 breakpoints in/from the target beneath. For example, a breakpoint
1698 may be inserted while recording, but removed when not replaying nor
1699 recording. In that case, the breakpoint had not been inserted on
1700 the target beneath, so we should not try to remove it there. */
1702 struct record_full_breakpoint
1704 record_full_breakpoint (struct address_space *address_space_,
1706 bool in_target_beneath_)
1707 : address_space (address_space_),
1709 in_target_beneath (in_target_beneath_)
1713 /* The address and address space the breakpoint was set at. */
1714 struct address_space *address_space;
1717 /* True when the breakpoint has been also installed in the target
1718 beneath. This will be false for breakpoints set during replay or
1720 bool in_target_beneath;
1723 /* The list of breakpoints inserted while the record target is
1725 static std::vector<record_full_breakpoint> record_full_breakpoints;
1728 record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
1730 if (loc->loc_type != bp_loc_software_breakpoint)
1735 record_full_breakpoints.emplace_back
1736 (loc->target_info.placed_address_space,
1737 loc->target_info.placed_address,
1742 /* Sync existing breakpoints to record_full_breakpoints. */
1745 record_full_init_record_breakpoints (void)
1747 record_full_breakpoints.clear ();
1749 iterate_over_bp_locations (record_full_sync_record_breakpoints);
1752 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1753 insert or remove breakpoints in the real target when replaying, nor
1757 record_full_target::insert_breakpoint (struct gdbarch *gdbarch,
1758 struct bp_target_info *bp_tgt)
1760 bool in_target_beneath = false;
1762 if (!RECORD_FULL_IS_REPLAY)
1764 /* When recording, we currently always single-step, so we don't
1765 really need to install regular breakpoints in the inferior.
1766 However, we do have to insert software single-step
1767 breakpoints, in case the target can't hardware step. To keep
1768 things simple, we always insert. */
1770 scoped_restore restore_operation_disable
1771 = record_full_gdb_operation_disable_set ();
1773 int ret = this->beneath ()->insert_breakpoint (gdbarch, bp_tgt);
1777 in_target_beneath = true;
1780 /* Use the existing entries if found in order to avoid duplication
1781 in record_full_breakpoints. */
1783 for (const record_full_breakpoint &bp : record_full_breakpoints)
1785 if (bp.addr == bp_tgt->placed_address
1786 && bp.address_space == bp_tgt->placed_address_space)
1788 gdb_assert (bp.in_target_beneath == in_target_beneath);
1793 record_full_breakpoints.emplace_back (bp_tgt->placed_address_space,
1794 bp_tgt->placed_address,
1799 /* "remove_breakpoint" method for process record target. */
1802 record_full_target::remove_breakpoint (struct gdbarch *gdbarch,
1803 struct bp_target_info *bp_tgt,
1804 enum remove_bp_reason reason)
1806 for (auto iter = record_full_breakpoints.begin ();
1807 iter != record_full_breakpoints.end ();
1810 struct record_full_breakpoint &bp = *iter;
1812 if (bp.addr == bp_tgt->placed_address
1813 && bp.address_space == bp_tgt->placed_address_space)
1815 if (bp.in_target_beneath)
1817 scoped_restore restore_operation_disable
1818 = record_full_gdb_operation_disable_set ();
1820 int ret = this->beneath ()->remove_breakpoint (gdbarch, bp_tgt,
1826 if (reason == REMOVE_BREAKPOINT)
1827 unordered_remove (record_full_breakpoints, iter);
1832 gdb_assert_not_reached ("removing unknown breakpoint");
1835 /* "can_execute_reverse" method for process record target. */
1838 record_full_base_target::can_execute_reverse ()
1843 /* "get_bookmark" method for process record and prec over core. */
1846 record_full_base_target::get_bookmark (const char *args, int from_tty)
1850 /* Return stringified form of instruction count. */
1851 if (record_full_list && record_full_list->type == record_full_end)
1852 ret = xstrdup (pulongest (record_full_list->u.end.insn_num));
1857 fprintf_unfiltered (gdb_stdlog,
1858 "record_full_get_bookmark returns %s\n", ret);
1860 fprintf_unfiltered (gdb_stdlog,
1861 "record_full_get_bookmark returns NULL\n");
1863 return (gdb_byte *) ret;
1866 /* "goto_bookmark" method for process record and prec over core. */
1869 record_full_base_target::goto_bookmark (const gdb_byte *raw_bookmark,
1872 const char *bookmark = (const char *) raw_bookmark;
1875 fprintf_unfiltered (gdb_stdlog,
1876 "record_full_goto_bookmark receives %s\n", bookmark);
1878 std::string name_holder;
1879 if (bookmark[0] == '\'' || bookmark[0] == '\"')
1881 if (bookmark[strlen (bookmark) - 1] != bookmark[0])
1882 error (_("Unbalanced quotes: %s"), bookmark);
1884 name_holder = std::string (bookmark + 1, strlen (bookmark) - 2);
1885 bookmark = name_holder.c_str ();
1888 record_goto (bookmark);
1891 enum exec_direction_kind
1892 record_full_base_target::execution_direction ()
1894 return record_full_execution_dir;
1897 /* The record_method method of target record-full. */
1900 record_full_base_target::record_method (ptid_t ptid)
1902 return RECORD_METHOD_FULL;
1906 record_full_base_target::info_record ()
1908 struct record_full_entry *p;
1910 if (RECORD_FULL_IS_REPLAY)
1911 printf_filtered (_("Replay mode:\n"));
1913 printf_filtered (_("Record mode:\n"));
1915 /* Find entry for first actual instruction in the log. */
1916 for (p = record_full_first.next;
1917 p != NULL && p->type != record_full_end;
1921 /* Do we have a log at all? */
1922 if (p != NULL && p->type == record_full_end)
1924 /* Display instruction number for first instruction in the log. */
1925 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1926 pulongest (p->u.end.insn_num));
1928 /* If in replay mode, display where we are in the log. */
1929 if (RECORD_FULL_IS_REPLAY)
1930 printf_filtered (_("Current instruction number is %s.\n"),
1931 pulongest (record_full_list->u.end.insn_num));
1933 /* Display instruction number for last instruction in the log. */
1934 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1935 pulongest (record_full_insn_count));
1937 /* Display log count. */
1938 printf_filtered (_("Log contains %u instructions.\n"),
1939 record_full_insn_num);
1942 printf_filtered (_("No instructions have been logged.\n"));
1944 /* Display max log size. */
1945 printf_filtered (_("Max logged instructions is %u.\n"),
1946 record_full_insn_max_num);
1950 record_full_base_target::supports_delete_record ()
1955 /* The "delete_record" target method. */
1958 record_full_base_target::delete_record ()
1960 record_full_list_release_following (record_full_list);
1963 /* The "record_is_replaying" target method. */
1966 record_full_base_target::record_is_replaying (ptid_t ptid)
1968 return RECORD_FULL_IS_REPLAY;
1971 /* The "record_will_replay" target method. */
1974 record_full_base_target::record_will_replay (ptid_t ptid, int dir)
1976 /* We can currently only record when executing forwards. Should we be able
1977 to record when executing backwards on targets that support reverse
1978 execution, this needs to be changed. */
1980 return RECORD_FULL_IS_REPLAY || dir == EXEC_REVERSE;
1983 /* Go to a specific entry. */
1986 record_full_goto_entry (struct record_full_entry *p)
1989 error (_("Target insn not found."));
1990 else if (p == record_full_list)
1991 error (_("Already at target insn."));
1992 else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
1994 printf_filtered (_("Go forward to insn number %s\n"),
1995 pulongest (p->u.end.insn_num));
1996 record_full_goto_insn (p, EXEC_FORWARD);
2000 printf_filtered (_("Go backward to insn number %s\n"),
2001 pulongest (p->u.end.insn_num));
2002 record_full_goto_insn (p, EXEC_REVERSE);
2005 registers_changed ();
2006 reinit_frame_cache ();
2007 inferior_thread ()->suspend.stop_pc
2008 = regcache_read_pc (get_current_regcache ());
2009 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2012 /* The "goto_record_begin" target method. */
2015 record_full_base_target::goto_record_begin ()
2017 struct record_full_entry *p = NULL;
2019 for (p = &record_full_first; p != NULL; p = p->next)
2020 if (p->type == record_full_end)
2023 record_full_goto_entry (p);
2026 /* The "goto_record_end" target method. */
2029 record_full_base_target::goto_record_end ()
2031 struct record_full_entry *p = NULL;
2033 for (p = record_full_list; p->next != NULL; p = p->next)
2035 for (; p!= NULL; p = p->prev)
2036 if (p->type == record_full_end)
2039 record_full_goto_entry (p);
2042 /* The "goto_record" target method. */
2045 record_full_base_target::goto_record (ULONGEST target_insn)
2047 struct record_full_entry *p = NULL;
2049 for (p = &record_full_first; p != NULL; p = p->next)
2050 if (p->type == record_full_end && p->u.end.insn_num == target_insn)
2053 record_full_goto_entry (p);
2056 /* The "record_stop_replaying" target method. */
2059 record_full_base_target::record_stop_replaying ()
2064 /* "resume" method for prec over corefile. */
2067 record_full_core_target::resume (ptid_t ptid, int step,
2068 enum gdb_signal signal)
2070 record_full_resume_step = step;
2071 record_full_resumed = 1;
2072 record_full_execution_dir = ::execution_direction;
2074 /* We are about to start executing the inferior (or simulate it),
2075 let's register it with the event loop. */
2076 if (target_can_async_p ())
2080 /* "kill" method for prec over corefile. */
2083 record_full_core_target::kill ()
2086 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
2088 unpush_target (this);
2091 /* "fetch_registers" method for prec over corefile. */
2094 record_full_core_target::fetch_registers (struct regcache *regcache,
2099 int num = gdbarch_num_regs (regcache->arch ());
2102 for (i = 0; i < num; i ++)
2103 regcache->raw_supply (i, *record_full_core_regbuf);
2106 regcache->raw_supply (regno, *record_full_core_regbuf);
2109 /* "prepare_to_store" method for prec over corefile. */
2112 record_full_core_target::prepare_to_store (struct regcache *regcache)
2116 /* "store_registers" method for prec over corefile. */
2119 record_full_core_target::store_registers (struct regcache *regcache,
2122 if (record_full_gdb_operation_disable)
2123 record_full_core_regbuf->raw_supply (regno, *regcache);
2125 error (_("You can't do that without a process to debug."));
2128 /* "xfer_partial" method for prec over corefile. */
2130 enum target_xfer_status
2131 record_full_core_target::xfer_partial (enum target_object object,
2132 const char *annex, gdb_byte *readbuf,
2133 const gdb_byte *writebuf, ULONGEST offset,
2134 ULONGEST len, ULONGEST *xfered_len)
2136 if (object == TARGET_OBJECT_MEMORY)
2138 if (record_full_gdb_operation_disable || !writebuf)
2140 struct target_section *p;
2142 for (p = record_full_core_start; p < record_full_core_end; p++)
2144 if (offset >= p->addr)
2146 struct record_full_core_buf_entry *entry;
2147 ULONGEST sec_offset;
2149 if (offset >= p->endaddr)
2152 if (offset + len > p->endaddr)
2153 len = p->endaddr - offset;
2155 sec_offset = offset - p->addr;
2157 /* Read readbuf or write writebuf p, offset, len. */
2159 if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
2160 || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
2163 memset (readbuf, 0, len);
2166 return TARGET_XFER_OK;
2168 /* Get record_full_core_buf_entry. */
2169 for (entry = record_full_core_buf_list; entry;
2170 entry = entry->prev)
2177 /* Add a new entry. */
2178 entry = XNEW (struct record_full_core_buf_entry);
2180 if (!bfd_malloc_and_get_section
2181 (p->the_bfd_section->owner,
2186 return TARGET_XFER_EOF;
2188 entry->prev = record_full_core_buf_list;
2189 record_full_core_buf_list = entry;
2192 memcpy (entry->buf + sec_offset, writebuf,
2198 return this->beneath ()->xfer_partial (object, annex,
2203 memcpy (readbuf, entry->buf + sec_offset,
2208 return TARGET_XFER_OK;
2212 return TARGET_XFER_E_IO;
2215 error (_("You can't do that without a process to debug."));
2218 return this->beneath ()->xfer_partial (object, annex,
2219 readbuf, writebuf, offset, len,
2223 /* "insert_breakpoint" method for prec over corefile. */
2226 record_full_core_target::insert_breakpoint (struct gdbarch *gdbarch,
2227 struct bp_target_info *bp_tgt)
2232 /* "remove_breakpoint" method for prec over corefile. */
2235 record_full_core_target::remove_breakpoint (struct gdbarch *gdbarch,
2236 struct bp_target_info *bp_tgt,
2237 enum remove_bp_reason reason)
2242 /* "has_execution" method for prec over corefile. */
2245 record_full_core_target::has_execution (ptid_t the_ptid)
2250 /* Record log save-file format
2251 Version 1 (never released)
2254 4 bytes: magic number htonl(0x20090829).
2255 NOTE: be sure to change whenever this file format changes!
2259 1 byte: record type (record_full_end, see enum record_full_type).
2261 1 byte: record type (record_full_reg, see enum record_full_type).
2262 8 bytes: register id (network byte order).
2263 MAX_REGISTER_SIZE bytes: register value.
2265 1 byte: record type (record_full_mem, see enum record_full_type).
2266 8 bytes: memory length (network byte order).
2267 8 bytes: memory address (network byte order).
2268 n bytes: memory value (n == memory length).
2271 4 bytes: magic number netorder32(0x20091016).
2272 NOTE: be sure to change whenever this file format changes!
2276 1 byte: record type (record_full_end, see enum record_full_type).
2278 4 bytes: instruction count
2280 1 byte: record type (record_full_reg, see enum record_full_type).
2281 4 bytes: register id (network byte order).
2282 n bytes: register value (n == actual register size).
2283 (eg. 4 bytes for x86 general registers).
2285 1 byte: record type (record_full_mem, see enum record_full_type).
2286 4 bytes: memory length (network byte order).
2287 8 bytes: memory address (network byte order).
2288 n bytes: memory value (n == memory length).
2292 /* bfdcore_read -- read bytes from a core file section. */
2295 bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2297 int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2302 error (_("Failed to read %d bytes from core file %s ('%s')."),
2303 len, bfd_get_filename (obfd),
2304 bfd_errmsg (bfd_get_error ()));
2307 static inline uint64_t
2308 netorder64 (uint64_t input)
2312 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2313 BFD_ENDIAN_BIG, input);
2317 static inline uint32_t
2318 netorder32 (uint32_t input)
2322 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2323 BFD_ENDIAN_BIG, input);
2327 /* Restore the execution log from a core_bfd file. */
2329 record_full_restore (void)
2332 struct record_full_entry *rec;
2336 struct regcache *regcache;
2338 /* We restore the execution log from the open core bfd,
2340 if (core_bfd == NULL)
2343 /* "record_full_restore" can only be called when record list is empty. */
2344 gdb_assert (record_full_first.next == NULL);
2347 fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
2349 /* Now need to find our special note section. */
2350 osec = bfd_get_section_by_name (core_bfd, "null0");
2352 fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
2353 osec ? "succeeded" : "failed");
2356 osec_size = bfd_section_size (core_bfd, osec);
2358 fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
2360 /* Check the magic code. */
2361 bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
2362 if (magic != RECORD_FULL_FILE_MAGIC)
2363 error (_("Version mis-match or file format error in core file %s."),
2364 bfd_get_filename (core_bfd));
2366 fprintf_unfiltered (gdb_stdlog,
2367 " Reading 4-byte magic cookie "
2368 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2369 phex_nz (netorder32 (magic), 4));
2371 /* Restore the entries in recfd into record_full_arch_list_head and
2372 record_full_arch_list_tail. */
2373 record_full_arch_list_head = NULL;
2374 record_full_arch_list_tail = NULL;
2375 record_full_insn_num = 0;
2379 regcache = get_current_regcache ();
2384 uint32_t regnum, len, signal, count;
2387 /* We are finished when offset reaches osec_size. */
2388 if (bfd_offset >= osec_size)
2390 bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);
2394 case record_full_reg: /* reg */
2395 /* Get register number to regnum. */
2396 bfdcore_read (core_bfd, osec, ®num,
2397 sizeof (regnum), &bfd_offset);
2398 regnum = netorder32 (regnum);
2400 rec = record_full_reg_alloc (regcache, regnum);
2403 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2404 rec->u.reg.len, &bfd_offset);
2407 fprintf_unfiltered (gdb_stdlog,
2408 " Reading register %d (1 "
2409 "plus %lu plus %d bytes)\n",
2411 (unsigned long) sizeof (regnum),
2415 case record_full_mem: /* mem */
2417 bfdcore_read (core_bfd, osec, &len,
2418 sizeof (len), &bfd_offset);
2419 len = netorder32 (len);
2422 bfdcore_read (core_bfd, osec, &addr,
2423 sizeof (addr), &bfd_offset);
2424 addr = netorder64 (addr);
2426 rec = record_full_mem_alloc (addr, len);
2429 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2430 rec->u.mem.len, &bfd_offset);
2433 fprintf_unfiltered (gdb_stdlog,
2434 " Reading memory %s (1 plus "
2435 "%lu plus %lu plus %d bytes)\n",
2436 paddress (get_current_arch (),
2438 (unsigned long) sizeof (addr),
2439 (unsigned long) sizeof (len),
2443 case record_full_end: /* end */
2444 rec = record_full_end_alloc ();
2445 record_full_insn_num ++;
2447 /* Get signal value. */
2448 bfdcore_read (core_bfd, osec, &signal,
2449 sizeof (signal), &bfd_offset);
2450 signal = netorder32 (signal);
2451 rec->u.end.sigval = (enum gdb_signal) signal;
2453 /* Get insn count. */
2454 bfdcore_read (core_bfd, osec, &count,
2455 sizeof (count), &bfd_offset);
2456 count = netorder32 (count);
2457 rec->u.end.insn_num = count;
2458 record_full_insn_count = count + 1;
2460 fprintf_unfiltered (gdb_stdlog,
2461 " Reading record_full_end (1 + "
2462 "%lu + %lu bytes), offset == %s\n",
2463 (unsigned long) sizeof (signal),
2464 (unsigned long) sizeof (count),
2465 paddress (get_current_arch (),
2470 error (_("Bad entry type in core file %s."),
2471 bfd_get_filename (core_bfd));
2475 /* Add rec to record arch list. */
2476 record_full_arch_list_add (rec);
2479 CATCH (ex, RETURN_MASK_ALL)
2481 record_full_list_release (record_full_arch_list_tail);
2482 throw_exception (ex);
2486 /* Add record_full_arch_list_head to the end of record list. */
2487 record_full_first.next = record_full_arch_list_head;
2488 record_full_arch_list_head->prev = &record_full_first;
2489 record_full_arch_list_tail->next = NULL;
2490 record_full_list = &record_full_first;
2492 /* Update record_full_insn_max_num. */
2493 if (record_full_insn_num > record_full_insn_max_num)
2495 record_full_insn_max_num = record_full_insn_num;
2496 warning (_("Auto increase record/replay buffer limit to %u."),
2497 record_full_insn_max_num);
2501 printf_filtered (_("Restored records from core file %s.\n"),
2502 bfd_get_filename (core_bfd));
2504 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2507 /* bfdcore_write -- write bytes into a core file section. */
2510 bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2512 int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2517 error (_("Failed to write %d bytes to core file %s ('%s')."),
2518 len, bfd_get_filename (obfd),
2519 bfd_errmsg (bfd_get_error ()));
2522 /* Restore the execution log from a file. We use a modified elf
2523 corefile format, with an extra section for our data. */
2526 cmd_record_full_restore (const char *args, int from_tty)
2528 core_file_command (args, from_tty);
2529 record_full_open (args, from_tty);
2532 /* Save the execution log to a file. We use a modified elf corefile
2533 format, with an extra section for our data. */
2536 record_full_base_target::save_record (const char *recfilename)
2538 struct record_full_entry *cur_record_full_list;
2540 struct regcache *regcache;
2541 struct gdbarch *gdbarch;
2543 asection *osec = NULL;
2546 /* Open the save file. */
2548 fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
2551 /* Open the output file. */
2552 gdb_bfd_ref_ptr obfd (create_gcore_bfd (recfilename));
2554 /* Arrange to remove the output file on failure. */
2555 gdb::unlinker unlink_file (recfilename);
2557 /* Save the current record entry to "cur_record_full_list". */
2558 cur_record_full_list = record_full_list;
2560 /* Get the values of regcache and gdbarch. */
2561 regcache = get_current_regcache ();
2562 gdbarch = regcache->arch ();
2564 /* Disable the GDB operation record. */
2565 scoped_restore restore_operation_disable
2566 = record_full_gdb_operation_disable_set ();
2568 /* Reverse execute to the begin of record list. */
2571 /* Check for beginning and end of log. */
2572 if (record_full_list == &record_full_first)
2575 record_full_exec_insn (regcache, gdbarch, record_full_list);
2577 if (record_full_list->prev)
2578 record_full_list = record_full_list->prev;
2581 /* Compute the size needed for the extra bfd section. */
2582 save_size = 4; /* magic cookie */
2583 for (record_full_list = record_full_first.next; record_full_list;
2584 record_full_list = record_full_list->next)
2585 switch (record_full_list->type)
2587 case record_full_end:
2588 save_size += 1 + 4 + 4;
2590 case record_full_reg:
2591 save_size += 1 + 4 + record_full_list->u.reg.len;
2593 case record_full_mem:
2594 save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
2598 /* Make the new bfd section. */
2599 osec = bfd_make_section_anyway_with_flags (obfd.get (), "precord",
2603 error (_("Failed to create 'precord' section for corefile %s: %s"),
2605 bfd_errmsg (bfd_get_error ()));
2606 bfd_set_section_size (obfd.get (), osec, save_size);
2607 bfd_set_section_vma (obfd.get (), osec, 0);
2608 bfd_set_section_alignment (obfd.get (), osec, 0);
2609 bfd_section_lma (obfd.get (), osec) = 0;
2611 /* Save corefile state. */
2612 write_gcore_file (obfd.get ());
2614 /* Write out the record log. */
2615 /* Write the magic code. */
2616 magic = RECORD_FULL_FILE_MAGIC;
2618 fprintf_unfiltered (gdb_stdlog,
2619 " Writing 4-byte magic cookie "
2620 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2621 phex_nz (magic, 4));
2622 bfdcore_write (obfd.get (), osec, &magic, sizeof (magic), &bfd_offset);
2624 /* Save the entries to recfd and forward execute to the end of
2626 record_full_list = &record_full_first;
2630 if (record_full_list != &record_full_first)
2633 uint32_t regnum, len, signal, count;
2636 type = record_full_list->type;
2637 bfdcore_write (obfd.get (), osec, &type, sizeof (type), &bfd_offset);
2639 switch (record_full_list->type)
2641 case record_full_reg: /* reg */
2643 fprintf_unfiltered (gdb_stdlog,
2644 " Writing register %d (1 "
2645 "plus %lu plus %d bytes)\n",
2646 record_full_list->u.reg.num,
2647 (unsigned long) sizeof (regnum),
2648 record_full_list->u.reg.len);
2651 regnum = netorder32 (record_full_list->u.reg.num);
2652 bfdcore_write (obfd.get (), osec, ®num,
2653 sizeof (regnum), &bfd_offset);
2656 bfdcore_write (obfd.get (), osec,
2657 record_full_get_loc (record_full_list),
2658 record_full_list->u.reg.len, &bfd_offset);
2661 case record_full_mem: /* mem */
2663 fprintf_unfiltered (gdb_stdlog,
2664 " Writing memory %s (1 plus "
2665 "%lu plus %lu plus %d bytes)\n",
2667 record_full_list->u.mem.addr),
2668 (unsigned long) sizeof (addr),
2669 (unsigned long) sizeof (len),
2670 record_full_list->u.mem.len);
2673 len = netorder32 (record_full_list->u.mem.len);
2674 bfdcore_write (obfd.get (), osec, &len, sizeof (len),
2677 /* Write memaddr. */
2678 addr = netorder64 (record_full_list->u.mem.addr);
2679 bfdcore_write (obfd.get (), osec, &addr,
2680 sizeof (addr), &bfd_offset);
2683 bfdcore_write (obfd.get (), osec,
2684 record_full_get_loc (record_full_list),
2685 record_full_list->u.mem.len, &bfd_offset);
2688 case record_full_end:
2690 fprintf_unfiltered (gdb_stdlog,
2691 " Writing record_full_end (1 + "
2692 "%lu + %lu bytes)\n",
2693 (unsigned long) sizeof (signal),
2694 (unsigned long) sizeof (count));
2695 /* Write signal value. */
2696 signal = netorder32 (record_full_list->u.end.sigval);
2697 bfdcore_write (obfd.get (), osec, &signal,
2698 sizeof (signal), &bfd_offset);
2700 /* Write insn count. */
2701 count = netorder32 (record_full_list->u.end.insn_num);
2702 bfdcore_write (obfd.get (), osec, &count,
2703 sizeof (count), &bfd_offset);
2708 /* Execute entry. */
2709 record_full_exec_insn (regcache, gdbarch, record_full_list);
2711 if (record_full_list->next)
2712 record_full_list = record_full_list->next;
2717 /* Reverse execute to cur_record_full_list. */
2720 /* Check for beginning and end of log. */
2721 if (record_full_list == cur_record_full_list)
2724 record_full_exec_insn (regcache, gdbarch, record_full_list);
2726 if (record_full_list->prev)
2727 record_full_list = record_full_list->prev;
2730 unlink_file.keep ();
2733 printf_filtered (_("Saved core file %s with execution log.\n"),
2737 /* record_full_goto_insn -- rewind the record log (forward or backward,
2738 depending on DIR) to the given entry, changing the program state
2742 record_full_goto_insn (struct record_full_entry *entry,
2743 enum exec_direction_kind dir)
2745 scoped_restore restore_operation_disable
2746 = record_full_gdb_operation_disable_set ();
2747 struct regcache *regcache = get_current_regcache ();
2748 struct gdbarch *gdbarch = regcache->arch ();
2750 /* Assume everything is valid: we will hit the entry,
2751 and we will not hit the end of the recording. */
2753 if (dir == EXEC_FORWARD)
2754 record_full_list = record_full_list->next;
2758 record_full_exec_insn (regcache, gdbarch, record_full_list);
2759 if (dir == EXEC_REVERSE)
2760 record_full_list = record_full_list->prev;
2762 record_full_list = record_full_list->next;
2763 } while (record_full_list != entry);
2766 /* Alias for "target record-full". */
2769 cmd_record_full_start (const char *args, int from_tty)
2771 execute_command ("target record-full", from_tty);
2775 set_record_full_insn_max_num (const char *args, int from_tty,
2776 struct cmd_list_element *c)
2778 if (record_full_insn_num > record_full_insn_max_num)
2780 /* Count down record_full_insn_num while releasing records from list. */
2781 while (record_full_insn_num > record_full_insn_max_num)
2783 record_full_list_release_first ();
2784 record_full_insn_num--;
2789 /* The "set record full" command. */
2792 set_record_full_command (const char *args, int from_tty)
2794 printf_unfiltered (_("\"set record full\" must be followed "
2795 "by an appropriate subcommand.\n"));
2796 help_list (set_record_full_cmdlist, "set record full ", all_commands,
2800 /* The "show record full" command. */
2803 show_record_full_command (const char *args, int from_tty)
2805 cmd_show_list (show_record_full_cmdlist, from_tty, "");
2809 _initialize_record_full (void)
2811 struct cmd_list_element *c;
2813 /* Init record_full_first. */
2814 record_full_first.prev = NULL;
2815 record_full_first.next = NULL;
2816 record_full_first.type = record_full_end;
2818 add_target (record_full_target_info, record_full_open);
2819 add_deprecated_target_alias (record_full_target_info, "record");
2820 add_target (record_full_core_target_info, record_full_open);
2822 add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
2823 _("Start full execution recording."), &record_full_cmdlist,
2824 "record full ", 0, &record_cmdlist);
2826 c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
2827 _("Restore the execution log from a file.\n\
2828 Argument is filename. File must be created with 'record save'."),
2829 &record_full_cmdlist);
2830 set_cmd_completer (c, filename_completer);
2832 /* Deprecate the old version without "full" prefix. */
2833 c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
2835 set_cmd_completer (c, filename_completer);
2836 deprecate_cmd (c, "record full restore");
2838 add_prefix_cmd ("full", class_support, set_record_full_command,
2839 _("Set record options"), &set_record_full_cmdlist,
2840 "set record full ", 0, &set_record_cmdlist);
2842 add_prefix_cmd ("full", class_support, show_record_full_command,
2843 _("Show record options"), &show_record_full_cmdlist,
2844 "show record full ", 0, &show_record_cmdlist);
2846 /* Record instructions number limit command. */
2847 add_setshow_boolean_cmd ("stop-at-limit", no_class,
2848 &record_full_stop_at_limit, _("\
2849 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2850 Show whether record/replay stops when record/replay buffer becomes full."),
2851 _("Default is ON.\n\
2852 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2853 When OFF, if the record/replay buffer becomes full,\n\
2854 delete the oldest recorded instruction to make room for each new one."),
2856 &set_record_full_cmdlist, &show_record_full_cmdlist);
2858 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2859 &set_record_cmdlist);
2860 deprecate_cmd (c, "set record full stop-at-limit");
2862 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2863 &show_record_cmdlist);
2864 deprecate_cmd (c, "show record full stop-at-limit");
2866 add_setshow_uinteger_cmd ("insn-number-max", no_class,
2867 &record_full_insn_max_num,
2868 _("Set record/replay buffer limit."),
2869 _("Show record/replay buffer limit."), _("\
2870 Set the maximum number of instructions to be stored in the\n\
2871 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2872 limit. Default is 200000."),
2873 set_record_full_insn_max_num,
2874 NULL, &set_record_full_cmdlist,
2875 &show_record_full_cmdlist);
2877 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2878 &set_record_cmdlist);
2879 deprecate_cmd (c, "set record full insn-number-max");
2881 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2882 &show_record_cmdlist);
2883 deprecate_cmd (c, "show record full insn-number-max");
2885 add_setshow_boolean_cmd ("memory-query", no_class,
2886 &record_full_memory_query, _("\
2887 Set whether query if PREC cannot record memory change of next instruction."),
2889 Show whether query if PREC cannot record memory change of next instruction."),
2892 When ON, query if PREC cannot record memory change of next instruction."),
2894 &set_record_full_cmdlist,
2895 &show_record_full_cmdlist);
2897 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2898 &set_record_cmdlist);
2899 deprecate_cmd (c, "set record full memory-query");
2901 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2902 &show_record_cmdlist);
2903 deprecate_cmd (c, "show record full memory-query");