1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2023 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 "gdbsupport/event-loop.h"
37 #include "observable.h"
39 #include "gdbsupport/gdb_unlinker.h"
40 #include "gdbsupport/byte-vector.h"
41 #include "async-event.h"
46 /* This module implements "target record-full", also known as "process
47 record and replay". This target sits on top of a "normal" target
48 (a target that "has execution"), and provides a record and replay
49 functionality, including reverse debugging.
51 Target record has two modes: recording, and replaying.
53 In record mode, we intercept the resume and wait methods.
54 Whenever gdb resumes the target, we run the target in single step
55 mode, and we build up an execution log in which, for each executed
56 instruction, we record all changes in memory and register state.
57 This is invisible to the user, to whom it just looks like an
58 ordinary debugging session (except for performance degradation).
60 In replay mode, instead of actually letting the inferior run as a
61 process, we simulate its execution by playing back the recorded
62 execution log. For each instruction in the log, we simulate the
63 instruction's side effects by duplicating the changes that it would
64 have made on memory and registers. */
66 #define DEFAULT_RECORD_FULL_INSN_MAX_NUM 200000
68 #define RECORD_FULL_IS_REPLAY \
69 (record_full_list->next || ::execution_direction == EXEC_REVERSE)
71 #define RECORD_FULL_FILE_MAGIC netorder32(0x20091016)
73 /* These are the core structs of the process record functionality.
75 A record_full_entry is a record of the value change of a register
76 ("record_full_reg") or a part of memory ("record_full_mem"). And each
77 instruction must have a struct record_full_entry ("record_full_end")
78 that indicates that this is the last struct record_full_entry of this
81 Each struct record_full_entry is linked to "record_full_list" by "prev"
82 and "next" pointers. */
84 struct record_full_mem_entry
88 /* Set this flag if target memory for this entry
89 can no longer be accessed. */
90 int mem_entry_not_accessible
;
94 gdb_byte buf
[sizeof (gdb_byte
*)];
98 struct record_full_reg_entry
105 gdb_byte buf
[2 * sizeof (gdb_byte
*)];
109 struct record_full_end_entry
111 enum gdb_signal sigval
;
115 enum record_full_type
122 /* This is the data structure that makes up the execution log.
124 The execution log consists of a single linked list of entries
125 of type "struct record_full_entry". It is doubly linked so that it
126 can be traversed in either direction.
128 The start of the list is anchored by a struct called
129 "record_full_first". The pointer "record_full_list" either points
130 to the last entry that was added to the list (in record mode), or to
131 the next entry in the list that will be executed (in replay mode).
133 Each list element (struct record_full_entry), in addition to next
134 and prev pointers, consists of a union of three entry types: mem,
135 reg, and end. A field called "type" determines which entry type is
136 represented by a given list element.
138 Each instruction that is added to the execution log is represented
139 by a variable number of list elements ('entries'). The instruction
140 will have one "reg" entry for each register that is changed by
141 executing the instruction (including the PC in every case). It
142 will also have one "mem" entry for each memory change. Finally,
143 each instruction will have an "end" entry that separates it from
144 the changes associated with the next instruction. */
146 struct record_full_entry
148 struct record_full_entry
*prev
;
149 struct record_full_entry
*next
;
150 enum record_full_type type
;
154 struct record_full_reg_entry reg
;
156 struct record_full_mem_entry mem
;
158 struct record_full_end_entry end
;
162 /* If true, query if PREC cannot record memory
163 change of next instruction. */
164 bool record_full_memory_query
= false;
166 struct record_full_core_buf_entry
168 struct record_full_core_buf_entry
*prev
;
169 struct target_section
*p
;
173 /* Record buf with core target. */
174 static detached_regcache
*record_full_core_regbuf
= NULL
;
175 static target_section_table record_full_core_sections
;
176 static struct record_full_core_buf_entry
*record_full_core_buf_list
= NULL
;
178 /* The following variables are used for managing the linked list that
179 represents the execution log.
181 record_full_first is the anchor that holds down the beginning of
184 record_full_list serves two functions:
185 1) In record mode, it anchors the end of the list.
186 2) In replay mode, it traverses the list and points to
187 the next instruction that must be emulated.
189 record_full_arch_list_head and record_full_arch_list_tail are used
190 to manage a separate list, which is used to build up the change
191 elements of the currently executing instruction during record mode.
192 When this instruction has been completely annotated in the "arch
193 list", it will be appended to the main execution log. */
195 static struct record_full_entry record_full_first
;
196 static struct record_full_entry
*record_full_list
= &record_full_first
;
197 static struct record_full_entry
*record_full_arch_list_head
= NULL
;
198 static struct record_full_entry
*record_full_arch_list_tail
= NULL
;
200 /* true ask user. false auto delete the last struct record_full_entry. */
201 static bool record_full_stop_at_limit
= true;
202 /* Maximum allowed number of insns in execution log. */
203 static unsigned int record_full_insn_max_num
204 = DEFAULT_RECORD_FULL_INSN_MAX_NUM
;
205 /* Actual count of insns presently in execution log. */
206 static unsigned int record_full_insn_num
= 0;
207 /* Count of insns logged so far (may be larger
208 than count of insns presently in execution log). */
209 static ULONGEST record_full_insn_count
;
211 static const char record_longname
[]
212 = N_("Process record and replay target");
213 static const char record_doc
[]
214 = N_("Log program while executing and replay execution from log.");
216 /* Base class implementing functionality common to both the
217 "record-full" and "record-core" targets. */
219 class record_full_base_target
: public target_ops
222 const target_info
&info () const override
= 0;
224 strata
stratum () const override
{ return record_stratum
; }
226 void close () override
;
227 void async (bool) override
;
228 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
229 bool stopped_by_watchpoint () override
;
230 bool stopped_data_address (CORE_ADDR
*) override
;
232 bool stopped_by_sw_breakpoint () override
;
233 bool supports_stopped_by_sw_breakpoint () override
;
235 bool stopped_by_hw_breakpoint () override
;
236 bool supports_stopped_by_hw_breakpoint () override
;
238 bool can_execute_reverse () override
;
240 /* Add bookmark target methods. */
241 gdb_byte
*get_bookmark (const char *, int) override
;
242 void goto_bookmark (const gdb_byte
*, int) override
;
243 enum exec_direction_kind
execution_direction () override
;
244 enum record_method
record_method (ptid_t ptid
) override
;
245 void info_record () override
;
246 void save_record (const char *filename
) override
;
247 bool supports_delete_record () override
;
248 void delete_record () override
;
249 bool record_is_replaying (ptid_t ptid
) override
;
250 bool record_will_replay (ptid_t ptid
, int dir
) override
;
251 void record_stop_replaying () override
;
252 void goto_record_begin () override
;
253 void goto_record_end () override
;
254 void goto_record (ULONGEST insn
) override
;
257 /* The "record-full" target. */
259 static const target_info record_full_target_info
= {
265 class record_full_target final
: public record_full_base_target
268 const target_info
&info () const override
269 { return record_full_target_info
; }
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 (inferior
*inf
) 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 gdb_printf (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 gdb_printf (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 gdb_printf (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 gdb_printf (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
);
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 gdb_printf (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 gdb_printf (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
);
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 record_full_core_sections
= build_section_table (core_bfd
);
928 current_inferior ()->push_target (&record_full_core_ops
);
929 record_full_restore ();
932 /* Open the process record target for 'live' processes. */
935 record_full_open_1 (const char *name
, int from_tty
)
938 gdb_printf (gdb_stdlog
, "Process record: record_full_open_1\n");
941 if (!target_has_execution ())
942 error (_("Process record: the program is not being run."));
944 error (_("Process record target can't debug inferior in non-stop mode "
947 if (!gdbarch_process_record_p (target_gdbarch ()))
948 error (_("Process record: the current architecture doesn't support "
949 "record function."));
951 current_inferior ()->push_target (&record_full_ops
);
954 static void record_full_init_record_breakpoints (void);
956 /* Open the process record target. */
959 record_full_open (const char *name
, int from_tty
)
962 gdb_printf (gdb_stdlog
, "Process record: record_full_open\n");
967 record_full_insn_num
= 0;
968 record_full_insn_count
= 0;
969 record_full_list
= &record_full_first
;
970 record_full_list
->next
= NULL
;
973 record_full_core_open_1 (name
, from_tty
);
975 record_full_open_1 (name
, from_tty
);
977 /* Register extra event sources in the event loop. */
978 record_full_async_inferior_event_token
979 = create_async_event_handler (record_full_async_inferior_event_handler
,
980 NULL
, "record-full");
982 record_full_init_record_breakpoints ();
984 gdb::observers::record_changed
.notify (current_inferior (), 1, "full", NULL
);
987 /* "close" target method. Close the process record target. */
990 record_full_base_target::close ()
992 struct record_full_core_buf_entry
*entry
;
995 gdb_printf (gdb_stdlog
, "Process record: record_full_close\n");
997 record_full_list_release (record_full_list
);
999 /* Release record_full_core_regbuf. */
1000 if (record_full_core_regbuf
)
1002 delete record_full_core_regbuf
;
1003 record_full_core_regbuf
= NULL
;
1006 /* Release record_full_core_buf_list. */
1007 while (record_full_core_buf_list
)
1009 entry
= record_full_core_buf_list
;
1010 record_full_core_buf_list
= record_full_core_buf_list
->prev
;
1014 if (record_full_async_inferior_event_token
)
1015 delete_async_event_handler (&record_full_async_inferior_event_token
);
1018 /* "async" target method. */
1021 record_full_base_target::async (bool enable
)
1024 mark_async_event_handler (record_full_async_inferior_event_token
);
1026 clear_async_event_handler (record_full_async_inferior_event_token
);
1028 beneath ()->async (enable
);
1031 /* The PTID and STEP arguments last passed to
1032 record_full_target::resume. */
1033 static ptid_t record_full_resume_ptid
= null_ptid
;
1034 static int record_full_resume_step
= 0;
1036 /* True if we've been resumed, and so each record_full_wait call should
1037 advance execution. If this is false, record_full_wait will return a
1038 TARGET_WAITKIND_IGNORE. */
1039 static int record_full_resumed
= 0;
1041 /* The execution direction of the last resume we got. This is
1042 necessary for async mode. Vis (order is not strictly accurate):
1044 1. user has the global execution direction set to forward
1045 2. user does a reverse-step command
1046 3. record_full_resume is called with global execution direction
1047 temporarily switched to reverse
1048 4. GDB's execution direction is reverted back to forward
1049 5. target record notifies event loop there's an event to handle
1050 6. infrun asks the target which direction was it going, and switches
1051 the global execution direction accordingly (to reverse)
1052 7. infrun polls an event out of the record target, and handles it
1053 8. GDB goes back to the event loop, and goto #4.
1055 static enum exec_direction_kind record_full_execution_dir
= EXEC_FORWARD
;
1057 /* "resume" target method. Resume the process record target. */
1060 record_full_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
1062 record_full_resume_ptid
= inferior_ptid
;
1063 record_full_resume_step
= step
;
1064 record_full_resumed
= 1;
1065 record_full_execution_dir
= ::execution_direction
;
1067 if (!RECORD_FULL_IS_REPLAY
)
1069 struct gdbarch
*gdbarch
= target_thread_architecture (ptid
);
1071 record_full_message (get_current_regcache (), signal
);
1075 /* This is not hard single step. */
1076 if (!gdbarch_software_single_step_p (gdbarch
))
1078 /* This is a normal continue. */
1083 /* This arch supports soft single step. */
1084 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
1086 /* This is a soft single step. */
1087 record_full_resume_step
= 1;
1090 step
= !insert_single_step_breakpoints (gdbarch
);
1094 /* Make sure the target beneath reports all signals. */
1095 target_pass_signals ({});
1097 this->beneath ()->resume (ptid
, step
, signal
);
1101 static int record_full_get_sig
= 0;
1103 /* SIGINT signal handler, registered by "wait" method. */
1106 record_full_sig_handler (int signo
)
1109 gdb_printf (gdb_stdlog
, "Process record: get a signal\n");
1111 /* It will break the running inferior in replay mode. */
1112 record_full_resume_step
= 1;
1114 /* It will let record_full_wait set inferior status to get the signal
1116 record_full_get_sig
= 1;
1119 /* "wait" target method for process record target.
1121 In record mode, the target is always run in singlestep mode
1122 (even when gdb says to continue). The wait method intercepts
1123 the stop events and determines which ones are to be passed on to
1124 gdb. Most stop events are just singlestep events that gdb is not
1125 to know about, so the wait method just records them and keeps
1128 In replay mode, this function emulates the recorded execution log,
1129 one instruction at a time (forward or backward), and determines
1133 record_full_wait_1 (struct target_ops
*ops
,
1134 ptid_t ptid
, struct target_waitstatus
*status
,
1135 target_wait_flags options
)
1137 scoped_restore restore_operation_disable
1138 = record_full_gdb_operation_disable_set ();
1141 gdb_printf (gdb_stdlog
,
1142 "Process record: record_full_wait "
1143 "record_full_resume_step = %d, "
1144 "record_full_resumed = %d, direction=%s\n",
1145 record_full_resume_step
, record_full_resumed
,
1146 record_full_execution_dir
== EXEC_FORWARD
1147 ? "forward" : "reverse");
1149 if (!record_full_resumed
)
1151 gdb_assert ((options
& TARGET_WNOHANG
) != 0);
1153 /* No interesting event. */
1154 status
->set_ignore ();
1155 return minus_one_ptid
;
1158 record_full_get_sig
= 0;
1159 signal (SIGINT
, record_full_sig_handler
);
1161 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1163 if (!RECORD_FULL_IS_REPLAY
&& ops
!= &record_full_core_ops
)
1165 if (record_full_resume_step
)
1167 /* This is a single step. */
1168 return ops
->beneath ()->wait (ptid
, status
, options
);
1172 /* This is not a single step. */
1175 struct gdbarch
*gdbarch
1176 = target_thread_architecture (record_full_resume_ptid
);
1180 ret
= ops
->beneath ()->wait (ptid
, status
, options
);
1181 if (status
->kind () == TARGET_WAITKIND_IGNORE
)
1184 gdb_printf (gdb_stdlog
,
1185 "Process record: record_full_wait "
1186 "target beneath not done yet\n");
1190 for (thread_info
*tp
: all_non_exited_threads ())
1191 delete_single_step_breakpoints (tp
);
1193 if (record_full_resume_step
)
1196 /* Is this a SIGTRAP? */
1197 if (status
->kind () == TARGET_WAITKIND_STOPPED
1198 && status
->sig () == GDB_SIGNAL_TRAP
)
1200 struct regcache
*regcache
;
1201 enum target_stop_reason
*stop_reason_p
1202 = &record_full_stop_reason
;
1204 /* Yes -- this is likely our single-step finishing,
1205 but check if there's any reason the core would be
1206 interested in the event. */
1208 registers_changed ();
1209 switch_to_thread (current_inferior ()->process_target (),
1211 regcache
= get_current_regcache ();
1212 tmp_pc
= regcache_read_pc (regcache
);
1213 const struct address_space
*aspace
= regcache
->aspace ();
1215 if (target_stopped_by_watchpoint ())
1217 /* Always interested in watchpoints. */
1219 else if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1222 /* There is a breakpoint here. Let the core
1227 /* This is a single-step trap. Record the
1228 insn and issue another step.
1229 FIXME: this part can be a random SIGTRAP too.
1230 But GDB cannot handle it. */
1233 if (!record_full_message_wrapper_safe (regcache
,
1236 status
->set_stopped (GDB_SIGNAL_0
);
1240 process_stratum_target
*proc_target
1241 = current_inferior ()->process_target ();
1243 if (gdbarch_software_single_step_p (gdbarch
))
1245 /* Try to insert the software single step breakpoint.
1246 If insert success, set step to 0. */
1247 set_executing (proc_target
, inferior_ptid
, false);
1250 set_executing (proc_target
, inferior_ptid
, true);
1253 reinit_frame_cache ();
1254 step
= !insert_single_step_breakpoints (gdbarch
);
1258 gdb_printf (gdb_stdlog
,
1259 "Process record: record_full_wait "
1260 "issuing one more step in the "
1261 "target beneath\n");
1262 ops
->beneath ()->resume (ptid
, step
, GDB_SIGNAL_0
);
1263 proc_target
->commit_resumed_state
= true;
1264 proc_target
->commit_resumed ();
1265 proc_target
->commit_resumed_state
= false;
1270 /* The inferior is broken by a breakpoint or a signal. */
1279 switch_to_thread (current_inferior ()->process_target (),
1280 record_full_resume_ptid
);
1281 struct regcache
*regcache
= get_current_regcache ();
1282 struct gdbarch
*gdbarch
= regcache
->arch ();
1283 const struct address_space
*aspace
= regcache
->aspace ();
1284 int continue_flag
= 1;
1285 int first_record_full_end
= 1;
1291 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1292 status
->set_stopped (GDB_SIGNAL_0
);
1294 /* Check breakpoint when forward execute. */
1295 if (execution_direction
== EXEC_FORWARD
)
1297 tmp_pc
= regcache_read_pc (regcache
);
1298 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1299 &record_full_stop_reason
))
1302 gdb_printf (gdb_stdlog
,
1303 "Process record: break at %s.\n",
1304 paddress (gdbarch
, tmp_pc
));
1309 /* If GDB is in terminal_inferior mode, it will not get the
1310 signal. And in GDB replay mode, GDB doesn't need to be
1311 in terminal_inferior mode, because inferior will not
1312 executed. Then set it to terminal_ours to make GDB get
1314 target_terminal::ours ();
1316 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1318 if (execution_direction
== EXEC_FORWARD
&& record_full_list
->next
)
1319 record_full_list
= record_full_list
->next
;
1321 /* Loop over the record_full_list, looking for the next place to
1325 /* Check for beginning and end of log. */
1326 if (execution_direction
== EXEC_REVERSE
1327 && record_full_list
== &record_full_first
)
1329 /* Hit beginning of record log in reverse. */
1330 status
->set_no_history ();
1333 if (execution_direction
!= EXEC_REVERSE
1334 && !record_full_list
->next
)
1336 /* Hit end of record log going forward. */
1337 status
->set_no_history ();
1341 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
1343 if (record_full_list
->type
== record_full_end
)
1345 if (record_debug
> 1)
1348 "Process record: record_full_end %s to "
1350 host_address_to_string (record_full_list
));
1352 if (first_record_full_end
1353 && execution_direction
== EXEC_REVERSE
)
1355 /* When reverse execute, the first
1356 record_full_end is the part of current
1358 first_record_full_end
= 0;
1362 /* In EXEC_REVERSE mode, this is the
1363 record_full_end of prev instruction. In
1364 EXEC_FORWARD mode, this is the
1365 record_full_end of current instruction. */
1367 if (record_full_resume_step
)
1369 if (record_debug
> 1)
1370 gdb_printf (gdb_stdlog
,
1371 "Process record: step.\n");
1375 /* check breakpoint */
1376 tmp_pc
= regcache_read_pc (regcache
);
1377 if (record_check_stopped_by_breakpoint
1378 (aspace
, tmp_pc
, &record_full_stop_reason
))
1381 gdb_printf (gdb_stdlog
,
1382 "Process record: break "
1384 paddress (gdbarch
, tmp_pc
));
1389 if (record_full_stop_reason
1390 == TARGET_STOPPED_BY_WATCHPOINT
)
1393 gdb_printf (gdb_stdlog
,
1394 "Process record: hit hw "
1398 /* Check target signal */
1399 if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1400 /* FIXME: better way to check */
1407 if (execution_direction
== EXEC_REVERSE
)
1409 if (record_full_list
->prev
)
1410 record_full_list
= record_full_list
->prev
;
1414 if (record_full_list
->next
)
1415 record_full_list
= record_full_list
->next
;
1419 while (continue_flag
);
1422 if (status
->kind () == TARGET_WAITKIND_STOPPED
)
1424 if (record_full_get_sig
)
1425 status
->set_stopped (GDB_SIGNAL_INT
);
1426 else if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1427 /* FIXME: better way to check */
1428 status
->set_stopped (record_full_list
->u
.end
.sigval
);
1430 status
->set_stopped (GDB_SIGNAL_TRAP
);
1433 catch (const gdb_exception
&ex
)
1435 if (execution_direction
== EXEC_REVERSE
)
1437 if (record_full_list
->next
)
1438 record_full_list
= record_full_list
->next
;
1441 record_full_list
= record_full_list
->prev
;
1447 signal (SIGINT
, handle_sigint
);
1449 return inferior_ptid
;
1453 record_full_base_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1454 target_wait_flags options
)
1458 clear_async_event_handler (record_full_async_inferior_event_token
);
1460 return_ptid
= record_full_wait_1 (this, ptid
, status
, options
);
1461 if (status
->kind () != TARGET_WAITKIND_IGNORE
)
1463 /* We're reporting a stop. Make sure any spurious
1464 target_wait(WNOHANG) doesn't advance the target until the
1465 core wants us resumed again. */
1466 record_full_resumed
= 0;
1472 record_full_base_target::stopped_by_watchpoint ()
1474 if (RECORD_FULL_IS_REPLAY
)
1475 return record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
1477 return beneath ()->stopped_by_watchpoint ();
1481 record_full_base_target::stopped_data_address (CORE_ADDR
*addr_p
)
1483 if (RECORD_FULL_IS_REPLAY
)
1486 return this->beneath ()->stopped_data_address (addr_p
);
1489 /* The stopped_by_sw_breakpoint method of target record-full. */
1492 record_full_base_target::stopped_by_sw_breakpoint ()
1494 return record_full_stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
1497 /* The supports_stopped_by_sw_breakpoint method of target
1501 record_full_base_target::supports_stopped_by_sw_breakpoint ()
1506 /* The stopped_by_hw_breakpoint method of target record-full. */
1509 record_full_base_target::stopped_by_hw_breakpoint ()
1511 return record_full_stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
1514 /* The supports_stopped_by_sw_breakpoint method of target
1518 record_full_base_target::supports_stopped_by_hw_breakpoint ()
1523 /* Record registers change (by user or by GDB) to list as an instruction. */
1526 record_full_registers_change (struct regcache
*regcache
, int regnum
)
1528 /* Check record_full_insn_num. */
1529 record_full_check_insn_num ();
1531 record_full_arch_list_head
= NULL
;
1532 record_full_arch_list_tail
= NULL
;
1538 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
1540 if (record_full_arch_list_add_reg (regcache
, i
))
1542 record_full_list_release (record_full_arch_list_tail
);
1543 error (_("Process record: failed to record execution log."));
1549 if (record_full_arch_list_add_reg (regcache
, regnum
))
1551 record_full_list_release (record_full_arch_list_tail
);
1552 error (_("Process record: failed to record execution log."));
1555 if (record_full_arch_list_add_end ())
1557 record_full_list_release (record_full_arch_list_tail
);
1558 error (_("Process record: failed to record execution log."));
1560 record_full_list
->next
= record_full_arch_list_head
;
1561 record_full_arch_list_head
->prev
= record_full_list
;
1562 record_full_list
= record_full_arch_list_tail
;
1564 if (record_full_insn_num
== record_full_insn_max_num
)
1565 record_full_list_release_first ();
1567 record_full_insn_num
++;
1570 /* "store_registers" method for process record target. */
1573 record_full_target::store_registers (struct regcache
*regcache
, int regno
)
1575 if (!record_full_gdb_operation_disable
)
1577 if (RECORD_FULL_IS_REPLAY
)
1581 /* Let user choose if he wants to write register or not. */
1584 query (_("Because GDB is in replay mode, changing the "
1585 "value of a register will make the execution "
1586 "log unusable from this point onward. "
1587 "Change all registers?"));
1590 query (_("Because GDB is in replay mode, changing the value "
1591 "of a register will make the execution log unusable "
1592 "from this point onward. Change register %s?"),
1593 gdbarch_register_name (regcache
->arch (),
1598 /* Invalidate the value of regcache that was set in function
1599 "regcache_raw_write". */
1605 i
< gdbarch_num_regs (regcache
->arch ());
1607 regcache
->invalidate (i
);
1610 regcache
->invalidate (regno
);
1612 error (_("Process record canceled the operation."));
1615 /* Destroy the record from here forward. */
1616 record_full_list_release_following (record_full_list
);
1619 record_full_registers_change (regcache
, regno
);
1621 this->beneath ()->store_registers (regcache
, regno
);
1624 /* "xfer_partial" method. Behavior is conditional on
1625 RECORD_FULL_IS_REPLAY.
1626 In replay mode, we cannot write memory unles we are willing to
1627 invalidate the record/replay log from this point forward. */
1629 enum target_xfer_status
1630 record_full_target::xfer_partial (enum target_object object
,
1631 const char *annex
, gdb_byte
*readbuf
,
1632 const gdb_byte
*writebuf
, ULONGEST offset
,
1633 ULONGEST len
, ULONGEST
*xfered_len
)
1635 if (!record_full_gdb_operation_disable
1636 && (object
== TARGET_OBJECT_MEMORY
1637 || object
== TARGET_OBJECT_RAW_MEMORY
) && writebuf
)
1639 if (RECORD_FULL_IS_REPLAY
)
1641 /* Let user choose if he wants to write memory or not. */
1642 if (!query (_("Because GDB is in replay mode, writing to memory "
1643 "will make the execution log unusable from this "
1644 "point onward. Write memory at address %s?"),
1645 paddress (target_gdbarch (), offset
)))
1646 error (_("Process record canceled the operation."));
1648 /* Destroy the record from here forward. */
1649 record_full_list_release_following (record_full_list
);
1652 /* Check record_full_insn_num */
1653 record_full_check_insn_num ();
1655 /* Record registers change to list as an instruction. */
1656 record_full_arch_list_head
= NULL
;
1657 record_full_arch_list_tail
= NULL
;
1658 if (record_full_arch_list_add_mem (offset
, len
))
1660 record_full_list_release (record_full_arch_list_tail
);
1662 gdb_printf (gdb_stdlog
,
1663 "Process record: failed to record "
1665 return TARGET_XFER_E_IO
;
1667 if (record_full_arch_list_add_end ())
1669 record_full_list_release (record_full_arch_list_tail
);
1671 gdb_printf (gdb_stdlog
,
1672 "Process record: failed to record "
1674 return TARGET_XFER_E_IO
;
1676 record_full_list
->next
= record_full_arch_list_head
;
1677 record_full_arch_list_head
->prev
= record_full_list
;
1678 record_full_list
= record_full_arch_list_tail
;
1680 if (record_full_insn_num
== record_full_insn_max_num
)
1681 record_full_list_release_first ();
1683 record_full_insn_num
++;
1686 return this->beneath ()->xfer_partial (object
, annex
, readbuf
, writebuf
,
1687 offset
, len
, xfered_len
);
1690 /* This structure represents a breakpoint inserted while the record
1691 target is active. We use this to know when to install/remove
1692 breakpoints in/from the target beneath. For example, a breakpoint
1693 may be inserted while recording, but removed when not replaying nor
1694 recording. In that case, the breakpoint had not been inserted on
1695 the target beneath, so we should not try to remove it there. */
1697 struct record_full_breakpoint
1699 record_full_breakpoint (struct address_space
*address_space_
,
1701 bool in_target_beneath_
)
1702 : address_space (address_space_
),
1704 in_target_beneath (in_target_beneath_
)
1708 /* The address and address space the breakpoint was set at. */
1709 struct address_space
*address_space
;
1712 /* True when the breakpoint has been also installed in the target
1713 beneath. This will be false for breakpoints set during replay or
1715 bool in_target_beneath
;
1718 /* The list of breakpoints inserted while the record target is
1720 static std::vector
<record_full_breakpoint
> record_full_breakpoints
;
1722 /* Sync existing breakpoints to record_full_breakpoints. */
1725 record_full_init_record_breakpoints (void)
1727 record_full_breakpoints
.clear ();
1729 for (bp_location
*loc
: all_bp_locations ())
1731 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
, 1);
1741 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1742 insert or remove breakpoints in the real target when replaying, nor
1746 record_full_target::insert_breakpoint (struct gdbarch
*gdbarch
,
1747 struct bp_target_info
*bp_tgt
)
1749 bool in_target_beneath
= false;
1751 if (!RECORD_FULL_IS_REPLAY
)
1753 /* When recording, we currently always single-step, so we don't
1754 really need to install regular breakpoints in the inferior.
1755 However, we do have to insert software single-step
1756 breakpoints, in case the target can't hardware step. To keep
1757 things simple, we always insert. */
1759 scoped_restore restore_operation_disable
1760 = record_full_gdb_operation_disable_set ();
1762 int ret
= this->beneath ()->insert_breakpoint (gdbarch
, bp_tgt
);
1766 in_target_beneath
= true;
1769 /* Use the existing entries if found in order to avoid duplication
1770 in record_full_breakpoints. */
1772 for (const record_full_breakpoint
&bp
: record_full_breakpoints
)
1774 if (bp
.addr
== bp_tgt
->placed_address
1775 && bp
.address_space
== bp_tgt
->placed_address_space
)
1777 gdb_assert (bp
.in_target_beneath
== in_target_beneath
);
1782 record_full_breakpoints
.emplace_back (bp_tgt
->placed_address_space
,
1783 bp_tgt
->placed_address
,
1788 /* "remove_breakpoint" method for process record target. */
1791 record_full_target::remove_breakpoint (struct gdbarch
*gdbarch
,
1792 struct bp_target_info
*bp_tgt
,
1793 enum remove_bp_reason reason
)
1795 for (auto iter
= record_full_breakpoints
.begin ();
1796 iter
!= record_full_breakpoints
.end ();
1799 struct record_full_breakpoint
&bp
= *iter
;
1801 if (bp
.addr
== bp_tgt
->placed_address
1802 && bp
.address_space
== bp_tgt
->placed_address_space
)
1804 if (bp
.in_target_beneath
)
1806 scoped_restore restore_operation_disable
1807 = record_full_gdb_operation_disable_set ();
1809 int ret
= this->beneath ()->remove_breakpoint (gdbarch
, bp_tgt
,
1815 if (reason
== REMOVE_BREAKPOINT
)
1816 unordered_remove (record_full_breakpoints
, iter
);
1821 gdb_assert_not_reached ("removing unknown breakpoint");
1824 /* "can_execute_reverse" method for process record target. */
1827 record_full_base_target::can_execute_reverse ()
1832 /* "get_bookmark" method for process record and prec over core. */
1835 record_full_base_target::get_bookmark (const char *args
, int from_tty
)
1839 /* Return stringified form of instruction count. */
1840 if (record_full_list
&& record_full_list
->type
== record_full_end
)
1841 ret
= xstrdup (pulongest (record_full_list
->u
.end
.insn_num
));
1846 gdb_printf (gdb_stdlog
,
1847 "record_full_get_bookmark returns %s\n", ret
);
1849 gdb_printf (gdb_stdlog
,
1850 "record_full_get_bookmark returns NULL\n");
1852 return (gdb_byte
*) ret
;
1855 /* "goto_bookmark" method for process record and prec over core. */
1858 record_full_base_target::goto_bookmark (const gdb_byte
*raw_bookmark
,
1861 const char *bookmark
= (const char *) raw_bookmark
;
1864 gdb_printf (gdb_stdlog
,
1865 "record_full_goto_bookmark receives %s\n", bookmark
);
1867 std::string name_holder
;
1868 if (bookmark
[0] == '\'' || bookmark
[0] == '\"')
1870 if (bookmark
[strlen (bookmark
) - 1] != bookmark
[0])
1871 error (_("Unbalanced quotes: %s"), bookmark
);
1873 name_holder
= std::string (bookmark
+ 1, strlen (bookmark
) - 2);
1874 bookmark
= name_holder
.c_str ();
1877 record_goto (bookmark
);
1880 enum exec_direction_kind
1881 record_full_base_target::execution_direction ()
1883 return record_full_execution_dir
;
1886 /* The record_method method of target record-full. */
1889 record_full_base_target::record_method (ptid_t ptid
)
1891 return RECORD_METHOD_FULL
;
1895 record_full_base_target::info_record ()
1897 struct record_full_entry
*p
;
1899 if (RECORD_FULL_IS_REPLAY
)
1900 gdb_printf (_("Replay mode:\n"));
1902 gdb_printf (_("Record mode:\n"));
1904 /* Find entry for first actual instruction in the log. */
1905 for (p
= record_full_first
.next
;
1906 p
!= NULL
&& p
->type
!= record_full_end
;
1910 /* Do we have a log at all? */
1911 if (p
!= NULL
&& p
->type
== record_full_end
)
1913 /* Display instruction number for first instruction in the log. */
1914 gdb_printf (_("Lowest recorded instruction number is %s.\n"),
1915 pulongest (p
->u
.end
.insn_num
));
1917 /* If in replay mode, display where we are in the log. */
1918 if (RECORD_FULL_IS_REPLAY
)
1919 gdb_printf (_("Current instruction number is %s.\n"),
1920 pulongest (record_full_list
->u
.end
.insn_num
));
1922 /* Display instruction number for last instruction in the log. */
1923 gdb_printf (_("Highest recorded instruction number is %s.\n"),
1924 pulongest (record_full_insn_count
));
1926 /* Display log count. */
1927 gdb_printf (_("Log contains %u instructions.\n"),
1928 record_full_insn_num
);
1931 gdb_printf (_("No instructions have been logged.\n"));
1933 /* Display max log size. */
1934 gdb_printf (_("Max logged instructions is %u.\n"),
1935 record_full_insn_max_num
);
1939 record_full_base_target::supports_delete_record ()
1944 /* The "delete_record" target method. */
1947 record_full_base_target::delete_record ()
1949 record_full_list_release_following (record_full_list
);
1952 /* The "record_is_replaying" target method. */
1955 record_full_base_target::record_is_replaying (ptid_t ptid
)
1957 return RECORD_FULL_IS_REPLAY
;
1960 /* The "record_will_replay" target method. */
1963 record_full_base_target::record_will_replay (ptid_t ptid
, int dir
)
1965 /* We can currently only record when executing forwards. Should we be able
1966 to record when executing backwards on targets that support reverse
1967 execution, this needs to be changed. */
1969 return RECORD_FULL_IS_REPLAY
|| dir
== EXEC_REVERSE
;
1972 /* Go to a specific entry. */
1975 record_full_goto_entry (struct record_full_entry
*p
)
1978 error (_("Target insn not found."));
1979 else if (p
== record_full_list
)
1980 error (_("Already at target insn."));
1981 else if (p
->u
.end
.insn_num
> record_full_list
->u
.end
.insn_num
)
1983 gdb_printf (_("Go forward to insn number %s\n"),
1984 pulongest (p
->u
.end
.insn_num
));
1985 record_full_goto_insn (p
, EXEC_FORWARD
);
1989 gdb_printf (_("Go backward to insn number %s\n"),
1990 pulongest (p
->u
.end
.insn_num
));
1991 record_full_goto_insn (p
, EXEC_REVERSE
);
1994 registers_changed ();
1995 reinit_frame_cache ();
1996 inferior_thread ()->set_stop_pc (regcache_read_pc (get_current_regcache ()));
1997 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2000 /* The "goto_record_begin" target method. */
2003 record_full_base_target::goto_record_begin ()
2005 struct record_full_entry
*p
= NULL
;
2007 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
2008 if (p
->type
== record_full_end
)
2011 record_full_goto_entry (p
);
2014 /* The "goto_record_end" target method. */
2017 record_full_base_target::goto_record_end ()
2019 struct record_full_entry
*p
= NULL
;
2021 for (p
= record_full_list
; p
->next
!= NULL
; p
= p
->next
)
2023 for (; p
!= NULL
; p
= p
->prev
)
2024 if (p
->type
== record_full_end
)
2027 record_full_goto_entry (p
);
2030 /* The "goto_record" target method. */
2033 record_full_base_target::goto_record (ULONGEST target_insn
)
2035 struct record_full_entry
*p
= NULL
;
2037 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
2038 if (p
->type
== record_full_end
&& p
->u
.end
.insn_num
== target_insn
)
2041 record_full_goto_entry (p
);
2044 /* The "record_stop_replaying" target method. */
2047 record_full_base_target::record_stop_replaying ()
2052 /* "resume" method for prec over corefile. */
2055 record_full_core_target::resume (ptid_t ptid
, int step
,
2056 enum gdb_signal signal
)
2058 record_full_resume_step
= step
;
2059 record_full_resumed
= 1;
2060 record_full_execution_dir
= ::execution_direction
;
2063 /* "kill" method for prec over corefile. */
2066 record_full_core_target::kill ()
2069 gdb_printf (gdb_stdlog
, "Process record: record_full_core_kill\n");
2071 current_inferior ()->unpush_target (this);
2074 /* "fetch_registers" method for prec over corefile. */
2077 record_full_core_target::fetch_registers (struct regcache
*regcache
,
2082 int num
= gdbarch_num_regs (regcache
->arch ());
2085 for (i
= 0; i
< num
; i
++)
2086 regcache
->raw_supply (i
, *record_full_core_regbuf
);
2089 regcache
->raw_supply (regno
, *record_full_core_regbuf
);
2092 /* "prepare_to_store" method for prec over corefile. */
2095 record_full_core_target::prepare_to_store (struct regcache
*regcache
)
2099 /* "store_registers" method for prec over corefile. */
2102 record_full_core_target::store_registers (struct regcache
*regcache
,
2105 if (record_full_gdb_operation_disable
)
2106 record_full_core_regbuf
->raw_supply (regno
, *regcache
);
2108 error (_("You can't do that without a process to debug."));
2111 /* "xfer_partial" method for prec over corefile. */
2113 enum target_xfer_status
2114 record_full_core_target::xfer_partial (enum target_object object
,
2115 const char *annex
, gdb_byte
*readbuf
,
2116 const gdb_byte
*writebuf
, ULONGEST offset
,
2117 ULONGEST len
, ULONGEST
*xfered_len
)
2119 if (object
== TARGET_OBJECT_MEMORY
)
2121 if (record_full_gdb_operation_disable
|| !writebuf
)
2123 for (target_section
&p
: record_full_core_sections
)
2125 if (offset
>= p
.addr
)
2127 struct record_full_core_buf_entry
*entry
;
2128 ULONGEST sec_offset
;
2130 if (offset
>= p
.endaddr
)
2133 if (offset
+ len
> p
.endaddr
)
2134 len
= p
.endaddr
- offset
;
2136 sec_offset
= offset
- p
.addr
;
2138 /* Read readbuf or write writebuf p, offset, len. */
2140 if (p
.the_bfd_section
->flags
& SEC_CONSTRUCTOR
2141 || (p
.the_bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2144 memset (readbuf
, 0, len
);
2147 return TARGET_XFER_OK
;
2149 /* Get record_full_core_buf_entry. */
2150 for (entry
= record_full_core_buf_list
; entry
;
2151 entry
= entry
->prev
)
2158 /* Add a new entry. */
2159 entry
= XNEW (struct record_full_core_buf_entry
);
2161 if (!bfd_malloc_and_get_section
2162 (p
.the_bfd_section
->owner
,
2167 return TARGET_XFER_EOF
;
2169 entry
->prev
= record_full_core_buf_list
;
2170 record_full_core_buf_list
= entry
;
2173 memcpy (entry
->buf
+ sec_offset
, writebuf
,
2179 return this->beneath ()->xfer_partial (object
, annex
,
2184 memcpy (readbuf
, entry
->buf
+ sec_offset
,
2189 return TARGET_XFER_OK
;
2193 return TARGET_XFER_E_IO
;
2196 error (_("You can't do that without a process to debug."));
2199 return this->beneath ()->xfer_partial (object
, annex
,
2200 readbuf
, writebuf
, offset
, len
,
2204 /* "insert_breakpoint" method for prec over corefile. */
2207 record_full_core_target::insert_breakpoint (struct gdbarch
*gdbarch
,
2208 struct bp_target_info
*bp_tgt
)
2213 /* "remove_breakpoint" method for prec over corefile. */
2216 record_full_core_target::remove_breakpoint (struct gdbarch
*gdbarch
,
2217 struct bp_target_info
*bp_tgt
,
2218 enum remove_bp_reason reason
)
2223 /* "has_execution" method for prec over corefile. */
2226 record_full_core_target::has_execution (inferior
*inf
)
2231 /* Record log save-file format
2232 Version 1 (never released)
2235 4 bytes: magic number htonl(0x20090829).
2236 NOTE: be sure to change whenever this file format changes!
2240 1 byte: record type (record_full_end, see enum record_full_type).
2242 1 byte: record type (record_full_reg, see enum record_full_type).
2243 8 bytes: register id (network byte order).
2244 MAX_REGISTER_SIZE bytes: register value.
2246 1 byte: record type (record_full_mem, see enum record_full_type).
2247 8 bytes: memory length (network byte order).
2248 8 bytes: memory address (network byte order).
2249 n bytes: memory value (n == memory length).
2252 4 bytes: magic number netorder32(0x20091016).
2253 NOTE: be sure to change whenever this file format changes!
2257 1 byte: record type (record_full_end, see enum record_full_type).
2259 4 bytes: instruction count
2261 1 byte: record type (record_full_reg, see enum record_full_type).
2262 4 bytes: register id (network byte order).
2263 n bytes: register value (n == actual register size).
2264 (eg. 4 bytes for x86 general registers).
2266 1 byte: record type (record_full_mem, see enum record_full_type).
2267 4 bytes: memory length (network byte order).
2268 8 bytes: memory address (network byte order).
2269 n bytes: memory value (n == memory length).
2273 /* bfdcore_read -- read bytes from a core file section. */
2276 bfdcore_read (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2278 int ret
= bfd_get_section_contents (obfd
, osec
, buf
, *offset
, len
);
2283 error (_("Failed to read %d bytes from core file %s ('%s')."),
2284 len
, bfd_get_filename (obfd
),
2285 bfd_errmsg (bfd_get_error ()));
2288 static inline uint64_t
2289 netorder64 (uint64_t input
)
2293 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2294 BFD_ENDIAN_BIG
, input
);
2298 static inline uint32_t
2299 netorder32 (uint32_t input
)
2303 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2304 BFD_ENDIAN_BIG
, input
);
2308 /* Restore the execution log from a core_bfd file. */
2310 record_full_restore (void)
2313 struct record_full_entry
*rec
;
2317 struct regcache
*regcache
;
2319 /* We restore the execution log from the open core bfd,
2321 if (core_bfd
== NULL
)
2324 /* "record_full_restore" can only be called when record list is empty. */
2325 gdb_assert (record_full_first
.next
== NULL
);
2328 gdb_printf (gdb_stdlog
, "Restoring recording from core file.\n");
2330 /* Now need to find our special note section. */
2331 osec
= bfd_get_section_by_name (core_bfd
, "null0");
2333 gdb_printf (gdb_stdlog
, "Find precord section %s.\n",
2334 osec
? "succeeded" : "failed");
2337 osec_size
= bfd_section_size (osec
);
2339 gdb_printf (gdb_stdlog
, "%s", bfd_section_name (osec
));
2341 /* Check the magic code. */
2342 bfdcore_read (core_bfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2343 if (magic
!= RECORD_FULL_FILE_MAGIC
)
2344 error (_("Version mis-match or file format error in core file %s."),
2345 bfd_get_filename (core_bfd
));
2347 gdb_printf (gdb_stdlog
,
2348 " Reading 4-byte magic cookie "
2349 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2350 phex_nz (netorder32 (magic
), 4));
2352 /* Restore the entries in recfd into record_full_arch_list_head and
2353 record_full_arch_list_tail. */
2354 record_full_arch_list_head
= NULL
;
2355 record_full_arch_list_tail
= NULL
;
2356 record_full_insn_num
= 0;
2360 regcache
= get_current_regcache ();
2365 uint32_t regnum
, len
, signal
, count
;
2368 /* We are finished when offset reaches osec_size. */
2369 if (bfd_offset
>= osec_size
)
2371 bfdcore_read (core_bfd
, osec
, &rectype
, sizeof (rectype
), &bfd_offset
);
2375 case record_full_reg
: /* reg */
2376 /* Get register number to regnum. */
2377 bfdcore_read (core_bfd
, osec
, ®num
,
2378 sizeof (regnum
), &bfd_offset
);
2379 regnum
= netorder32 (regnum
);
2381 rec
= record_full_reg_alloc (regcache
, regnum
);
2384 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2385 rec
->u
.reg
.len
, &bfd_offset
);
2388 gdb_printf (gdb_stdlog
,
2389 " Reading register %d (1 "
2390 "plus %lu plus %d bytes)\n",
2392 (unsigned long) sizeof (regnum
),
2396 case record_full_mem
: /* mem */
2398 bfdcore_read (core_bfd
, osec
, &len
,
2399 sizeof (len
), &bfd_offset
);
2400 len
= netorder32 (len
);
2403 bfdcore_read (core_bfd
, osec
, &addr
,
2404 sizeof (addr
), &bfd_offset
);
2405 addr
= netorder64 (addr
);
2407 rec
= record_full_mem_alloc (addr
, len
);
2410 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2411 rec
->u
.mem
.len
, &bfd_offset
);
2414 gdb_printf (gdb_stdlog
,
2415 " Reading memory %s (1 plus "
2416 "%lu plus %lu plus %d bytes)\n",
2417 paddress (get_current_arch (),
2419 (unsigned long) sizeof (addr
),
2420 (unsigned long) sizeof (len
),
2424 case record_full_end
: /* end */
2425 rec
= record_full_end_alloc ();
2426 record_full_insn_num
++;
2428 /* Get signal value. */
2429 bfdcore_read (core_bfd
, osec
, &signal
,
2430 sizeof (signal
), &bfd_offset
);
2431 signal
= netorder32 (signal
);
2432 rec
->u
.end
.sigval
= (enum gdb_signal
) signal
;
2434 /* Get insn count. */
2435 bfdcore_read (core_bfd
, osec
, &count
,
2436 sizeof (count
), &bfd_offset
);
2437 count
= netorder32 (count
);
2438 rec
->u
.end
.insn_num
= count
;
2439 record_full_insn_count
= count
+ 1;
2441 gdb_printf (gdb_stdlog
,
2442 " Reading record_full_end (1 + "
2443 "%lu + %lu bytes), offset == %s\n",
2444 (unsigned long) sizeof (signal
),
2445 (unsigned long) sizeof (count
),
2446 paddress (get_current_arch (),
2451 error (_("Bad entry type in core file %s."),
2452 bfd_get_filename (core_bfd
));
2456 /* Add rec to record arch list. */
2457 record_full_arch_list_add (rec
);
2460 catch (const gdb_exception
&ex
)
2462 record_full_list_release (record_full_arch_list_tail
);
2466 /* Add record_full_arch_list_head to the end of record list. */
2467 record_full_first
.next
= record_full_arch_list_head
;
2468 record_full_arch_list_head
->prev
= &record_full_first
;
2469 record_full_arch_list_tail
->next
= NULL
;
2470 record_full_list
= &record_full_first
;
2472 /* Update record_full_insn_max_num. */
2473 if (record_full_insn_num
> record_full_insn_max_num
)
2475 record_full_insn_max_num
= record_full_insn_num
;
2476 warning (_("Auto increase record/replay buffer limit to %u."),
2477 record_full_insn_max_num
);
2481 gdb_printf (_("Restored records from core file %s.\n"),
2482 bfd_get_filename (core_bfd
));
2484 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2487 /* bfdcore_write -- write bytes into a core file section. */
2490 bfdcore_write (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2492 int ret
= bfd_set_section_contents (obfd
, osec
, buf
, *offset
, len
);
2497 error (_("Failed to write %d bytes to core file %s ('%s')."),
2498 len
, bfd_get_filename (obfd
),
2499 bfd_errmsg (bfd_get_error ()));
2502 /* Restore the execution log from a file. We use a modified elf
2503 corefile format, with an extra section for our data. */
2506 cmd_record_full_restore (const char *args
, int from_tty
)
2508 core_file_command (args
, from_tty
);
2509 record_full_open (args
, from_tty
);
2512 /* Save the execution log to a file. We use a modified elf corefile
2513 format, with an extra section for our data. */
2516 record_full_base_target::save_record (const char *recfilename
)
2518 struct record_full_entry
*cur_record_full_list
;
2520 struct regcache
*regcache
;
2521 struct gdbarch
*gdbarch
;
2523 asection
*osec
= NULL
;
2526 /* Open the save file. */
2528 gdb_printf (gdb_stdlog
, "Saving execution log to core file '%s'\n",
2531 /* Open the output file. */
2532 gdb_bfd_ref_ptr
obfd (create_gcore_bfd (recfilename
));
2534 /* Arrange to remove the output file on failure. */
2535 gdb::unlinker
unlink_file (recfilename
);
2537 /* Save the current record entry to "cur_record_full_list". */
2538 cur_record_full_list
= record_full_list
;
2540 /* Get the values of regcache and gdbarch. */
2541 regcache
= get_current_regcache ();
2542 gdbarch
= regcache
->arch ();
2544 /* Disable the GDB operation record. */
2545 scoped_restore restore_operation_disable
2546 = record_full_gdb_operation_disable_set ();
2548 /* Reverse execute to the begin of record list. */
2551 /* Check for beginning and end of log. */
2552 if (record_full_list
== &record_full_first
)
2555 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2557 if (record_full_list
->prev
)
2558 record_full_list
= record_full_list
->prev
;
2561 /* Compute the size needed for the extra bfd section. */
2562 save_size
= 4; /* magic cookie */
2563 for (record_full_list
= record_full_first
.next
; record_full_list
;
2564 record_full_list
= record_full_list
->next
)
2565 switch (record_full_list
->type
)
2567 case record_full_end
:
2568 save_size
+= 1 + 4 + 4;
2570 case record_full_reg
:
2571 save_size
+= 1 + 4 + record_full_list
->u
.reg
.len
;
2573 case record_full_mem
:
2574 save_size
+= 1 + 4 + 8 + record_full_list
->u
.mem
.len
;
2578 /* Make the new bfd section. */
2579 osec
= bfd_make_section_anyway_with_flags (obfd
.get (), "precord",
2583 error (_("Failed to create 'precord' section for corefile %s: %s"),
2585 bfd_errmsg (bfd_get_error ()));
2586 bfd_set_section_size (osec
, save_size
);
2587 bfd_set_section_vma (osec
, 0);
2588 bfd_set_section_alignment (osec
, 0);
2590 /* Save corefile state. */
2591 write_gcore_file (obfd
.get ());
2593 /* Write out the record log. */
2594 /* Write the magic code. */
2595 magic
= RECORD_FULL_FILE_MAGIC
;
2597 gdb_printf (gdb_stdlog
,
2598 " Writing 4-byte magic cookie "
2599 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2600 phex_nz (magic
, 4));
2601 bfdcore_write (obfd
.get (), osec
, &magic
, sizeof (magic
), &bfd_offset
);
2603 /* Save the entries to recfd and forward execute to the end of
2605 record_full_list
= &record_full_first
;
2609 if (record_full_list
!= &record_full_first
)
2612 uint32_t regnum
, len
, signal
, count
;
2615 type
= record_full_list
->type
;
2616 bfdcore_write (obfd
.get (), osec
, &type
, sizeof (type
), &bfd_offset
);
2618 switch (record_full_list
->type
)
2620 case record_full_reg
: /* reg */
2622 gdb_printf (gdb_stdlog
,
2623 " Writing register %d (1 "
2624 "plus %lu plus %d bytes)\n",
2625 record_full_list
->u
.reg
.num
,
2626 (unsigned long) sizeof (regnum
),
2627 record_full_list
->u
.reg
.len
);
2630 regnum
= netorder32 (record_full_list
->u
.reg
.num
);
2631 bfdcore_write (obfd
.get (), osec
, ®num
,
2632 sizeof (regnum
), &bfd_offset
);
2635 bfdcore_write (obfd
.get (), osec
,
2636 record_full_get_loc (record_full_list
),
2637 record_full_list
->u
.reg
.len
, &bfd_offset
);
2640 case record_full_mem
: /* mem */
2642 gdb_printf (gdb_stdlog
,
2643 " Writing memory %s (1 plus "
2644 "%lu plus %lu plus %d bytes)\n",
2646 record_full_list
->u
.mem
.addr
),
2647 (unsigned long) sizeof (addr
),
2648 (unsigned long) sizeof (len
),
2649 record_full_list
->u
.mem
.len
);
2652 len
= netorder32 (record_full_list
->u
.mem
.len
);
2653 bfdcore_write (obfd
.get (), osec
, &len
, sizeof (len
),
2656 /* Write memaddr. */
2657 addr
= netorder64 (record_full_list
->u
.mem
.addr
);
2658 bfdcore_write (obfd
.get (), osec
, &addr
,
2659 sizeof (addr
), &bfd_offset
);
2662 bfdcore_write (obfd
.get (), osec
,
2663 record_full_get_loc (record_full_list
),
2664 record_full_list
->u
.mem
.len
, &bfd_offset
);
2667 case record_full_end
:
2669 gdb_printf (gdb_stdlog
,
2670 " Writing record_full_end (1 + "
2671 "%lu + %lu bytes)\n",
2672 (unsigned long) sizeof (signal
),
2673 (unsigned long) sizeof (count
));
2674 /* Write signal value. */
2675 signal
= netorder32 (record_full_list
->u
.end
.sigval
);
2676 bfdcore_write (obfd
.get (), osec
, &signal
,
2677 sizeof (signal
), &bfd_offset
);
2679 /* Write insn count. */
2680 count
= netorder32 (record_full_list
->u
.end
.insn_num
);
2681 bfdcore_write (obfd
.get (), osec
, &count
,
2682 sizeof (count
), &bfd_offset
);
2687 /* Execute entry. */
2688 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2690 if (record_full_list
->next
)
2691 record_full_list
= record_full_list
->next
;
2696 /* Reverse execute to cur_record_full_list. */
2699 /* Check for beginning and end of log. */
2700 if (record_full_list
== cur_record_full_list
)
2703 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2705 if (record_full_list
->prev
)
2706 record_full_list
= record_full_list
->prev
;
2709 unlink_file
.keep ();
2712 gdb_printf (_("Saved core file %s with execution log.\n"),
2716 /* record_full_goto_insn -- rewind the record log (forward or backward,
2717 depending on DIR) to the given entry, changing the program state
2721 record_full_goto_insn (struct record_full_entry
*entry
,
2722 enum exec_direction_kind dir
)
2724 scoped_restore restore_operation_disable
2725 = record_full_gdb_operation_disable_set ();
2726 struct regcache
*regcache
= get_current_regcache ();
2727 struct gdbarch
*gdbarch
= regcache
->arch ();
2729 /* Assume everything is valid: we will hit the entry,
2730 and we will not hit the end of the recording. */
2732 if (dir
== EXEC_FORWARD
)
2733 record_full_list
= record_full_list
->next
;
2737 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2738 if (dir
== EXEC_REVERSE
)
2739 record_full_list
= record_full_list
->prev
;
2741 record_full_list
= record_full_list
->next
;
2742 } while (record_full_list
!= entry
);
2745 /* Alias for "target record-full". */
2748 cmd_record_full_start (const char *args
, int from_tty
)
2750 execute_command ("target record-full", from_tty
);
2754 set_record_full_insn_max_num (const char *args
, int from_tty
,
2755 struct cmd_list_element
*c
)
2757 if (record_full_insn_num
> record_full_insn_max_num
)
2759 /* Count down record_full_insn_num while releasing records from list. */
2760 while (record_full_insn_num
> record_full_insn_max_num
)
2762 record_full_list_release_first ();
2763 record_full_insn_num
--;
2768 /* Implement the 'maintenance print record-instruction' command. */
2771 maintenance_print_record_instruction (const char *args
, int from_tty
)
2773 struct record_full_entry
*to_print
= record_full_list
;
2775 if (args
!= nullptr)
2777 int offset
= value_as_long (parse_and_eval (args
));
2780 /* Move forward OFFSET instructions. We know we found the
2781 end of an instruction when to_print->type is record_full_end. */
2782 while (to_print
->next
!= nullptr && offset
> 0)
2784 to_print
= to_print
->next
;
2785 if (to_print
->type
== record_full_end
)
2789 error (_("Not enough recorded history"));
2793 while (to_print
->prev
!= nullptr && offset
< 0)
2795 to_print
= to_print
->prev
;
2796 if (to_print
->type
== record_full_end
)
2800 error (_("Not enough recorded history"));
2803 gdb_assert (to_print
!= nullptr);
2805 /* Go back to the start of the instruction. */
2806 while (to_print
->prev
!= nullptr && to_print
->prev
->type
!= record_full_end
)
2807 to_print
= to_print
->prev
;
2809 /* if we're in the first record, there are no actual instructions
2810 recorded. Warn the user and leave. */
2811 if (to_print
== &record_full_first
)
2812 error (_("Not enough recorded history"));
2814 while (to_print
->type
!= record_full_end
)
2816 switch (to_print
->type
)
2818 case record_full_reg
:
2820 type
*regtype
= gdbarch_register_type (target_gdbarch (),
2821 to_print
->u
.reg
.num
);
2823 = value_from_contents (regtype
,
2824 record_full_get_loc (to_print
));
2825 gdb_printf ("Register %s changed: ",
2826 gdbarch_register_name (target_gdbarch (),
2827 to_print
->u
.reg
.num
));
2828 struct value_print_options opts
;
2829 get_user_print_options (&opts
);
2831 value_print (val
, gdb_stdout
, &opts
);
2835 case record_full_mem
:
2837 gdb_byte
*b
= record_full_get_loc (to_print
);
2838 gdb_printf ("%d bytes of memory at address %s changed from:",
2839 to_print
->u
.mem
.len
,
2840 print_core_address (target_gdbarch (),
2841 to_print
->u
.mem
.addr
));
2842 for (int i
= 0; i
< to_print
->u
.mem
.len
; i
++)
2843 gdb_printf (" %02x", b
[i
]);
2848 to_print
= to_print
->next
;
2852 void _initialize_record_full ();
2854 _initialize_record_full ()
2856 struct cmd_list_element
*c
;
2858 /* Init record_full_first. */
2859 record_full_first
.prev
= NULL
;
2860 record_full_first
.next
= NULL
;
2861 record_full_first
.type
= record_full_end
;
2863 add_target (record_full_target_info
, record_full_open
);
2864 add_deprecated_target_alias (record_full_target_info
, "record");
2865 add_target (record_full_core_target_info
, record_full_open
);
2867 add_prefix_cmd ("full", class_obscure
, cmd_record_full_start
,
2868 _("Start full execution recording."), &record_full_cmdlist
,
2869 0, &record_cmdlist
);
2871 cmd_list_element
*record_full_restore_cmd
2872 = add_cmd ("restore", class_obscure
, cmd_record_full_restore
,
2873 _("Restore the execution log from a file.\n\
2874 Argument is filename. File must be created with 'record save'."),
2875 &record_full_cmdlist
);
2876 set_cmd_completer (record_full_restore_cmd
, filename_completer
);
2878 /* Deprecate the old version without "full" prefix. */
2879 c
= add_alias_cmd ("restore", record_full_restore_cmd
, class_obscure
, 1,
2881 set_cmd_completer (c
, filename_completer
);
2882 deprecate_cmd (c
, "record full restore");
2884 add_setshow_prefix_cmd ("full", class_support
,
2885 _("Set record options."),
2886 _("Show record options."),
2887 &set_record_full_cmdlist
,
2888 &show_record_full_cmdlist
,
2889 &set_record_cmdlist
,
2890 &show_record_cmdlist
);
2892 /* Record instructions number limit command. */
2893 set_show_commands set_record_full_stop_at_limit_cmds
2894 = add_setshow_boolean_cmd ("stop-at-limit", no_class
,
2895 &record_full_stop_at_limit
, _("\
2896 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2897 Show whether record/replay stops when record/replay buffer becomes full."),
2898 _("Default is ON.\n\
2899 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2900 When OFF, if the record/replay buffer becomes full,\n\
2901 delete the oldest recorded instruction to make room for each new one."),
2903 &set_record_full_cmdlist
,
2904 &show_record_full_cmdlist
);
2906 c
= add_alias_cmd ("stop-at-limit",
2907 set_record_full_stop_at_limit_cmds
.set
, no_class
, 1,
2908 &set_record_cmdlist
);
2909 deprecate_cmd (c
, "set record full stop-at-limit");
2911 c
= add_alias_cmd ("stop-at-limit",
2912 set_record_full_stop_at_limit_cmds
.show
, no_class
, 1,
2913 &show_record_cmdlist
);
2914 deprecate_cmd (c
, "show record full stop-at-limit");
2916 set_show_commands record_full_insn_number_max_cmds
2917 = add_setshow_uinteger_cmd ("insn-number-max", no_class
,
2918 &record_full_insn_max_num
,
2919 _("Set record/replay buffer limit."),
2920 _("Show record/replay buffer limit."), _("\
2921 Set the maximum number of instructions to be stored in the\n\
2922 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2923 limit. Default is 200000."),
2924 set_record_full_insn_max_num
,
2925 NULL
, &set_record_full_cmdlist
,
2926 &show_record_full_cmdlist
);
2928 c
= add_alias_cmd ("insn-number-max", record_full_insn_number_max_cmds
.set
,
2929 no_class
, 1, &set_record_cmdlist
);
2930 deprecate_cmd (c
, "set record full insn-number-max");
2932 c
= add_alias_cmd ("insn-number-max", record_full_insn_number_max_cmds
.show
,
2933 no_class
, 1, &show_record_cmdlist
);
2934 deprecate_cmd (c
, "show record full insn-number-max");
2936 set_show_commands record_full_memory_query_cmds
2937 = add_setshow_boolean_cmd ("memory-query", no_class
,
2938 &record_full_memory_query
, _("\
2939 Set whether query if PREC cannot record memory change of next instruction."),
2941 Show whether query if PREC cannot record memory change of next instruction."),
2944 When ON, query if PREC cannot record memory change of next instruction."),
2946 &set_record_full_cmdlist
,
2947 &show_record_full_cmdlist
);
2949 c
= add_alias_cmd ("memory-query", record_full_memory_query_cmds
.set
,
2950 no_class
, 1, &set_record_cmdlist
);
2951 deprecate_cmd (c
, "set record full memory-query");
2953 c
= add_alias_cmd ("memory-query", record_full_memory_query_cmds
.show
,
2954 no_class
, 1,&show_record_cmdlist
);
2955 deprecate_cmd (c
, "show record full memory-query");
2957 add_cmd ("record-instruction", class_maintenance
,
2958 maintenance_print_record_instruction
,
2960 Print a recorded instruction.\n\
2961 If no argument is provided, print the last instruction recorded.\n\
2962 If a negative argument is given, prints how the nth previous \
2963 instruction will be undone.\n\
2964 If a positive argument is given, prints \
2965 how the nth following instruction will be redone."), &maintenanceprintlist
);