1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2020 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 "gdbsupport/gdb_unlinker.h"
40 #include "gdbsupport/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 degradation).
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 bool record_full_memory_query
= false;
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 /* true ask user. false auto delete the last struct record_full_entry. */
200 static bool record_full_stop_at_limit
= true;
201 /* Maximum allowed number of insns in execution log. */
202 static unsigned int record_full_insn_max_num
203 = DEFAULT_RECORD_FULL_INSN_MAX_NUM
;
204 /* Actual count of insns presently in execution log. */
205 static unsigned int record_full_insn_num
= 0;
206 /* Count of insns logged so far (may be larger
207 than count of insns presently in execution log). */
208 static ULONGEST record_full_insn_count
;
210 static const char record_longname
[]
211 = N_("Process record and replay target");
212 static const char record_doc
[]
213 = N_("Log program while executing and replay execution from log.");
215 /* Base class implementing functionality common to both the
216 "record-full" and "record-core" targets. */
218 class record_full_base_target
: public target_ops
221 const target_info
&info () const override
= 0;
223 strata
stratum () const override
{ return record_stratum
; }
225 void close () override
;
226 void async (int) override
;
227 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
228 bool stopped_by_watchpoint () override
;
229 bool stopped_data_address (CORE_ADDR
*) override
;
231 bool stopped_by_sw_breakpoint () override
;
232 bool supports_stopped_by_sw_breakpoint () override
;
234 bool stopped_by_hw_breakpoint () override
;
235 bool supports_stopped_by_hw_breakpoint () override
;
237 bool can_execute_reverse () override
;
239 /* Add bookmark target methods. */
240 gdb_byte
*get_bookmark (const char *, int) override
;
241 void goto_bookmark (const gdb_byte
*, int) override
;
242 enum exec_direction_kind
execution_direction () override
;
243 enum record_method
record_method (ptid_t ptid
) override
;
244 void info_record () override
;
245 void save_record (const char *filename
) override
;
246 bool supports_delete_record () override
;
247 void delete_record () override
;
248 bool record_is_replaying (ptid_t ptid
) override
;
249 bool record_will_replay (ptid_t ptid
, int dir
) override
;
250 void record_stop_replaying () override
;
251 void goto_record_begin () override
;
252 void goto_record_end () override
;
253 void goto_record (ULONGEST insn
) override
;
256 /* The "record-full" target. */
258 static const target_info record_full_target_info
= {
264 class record_full_target final
: public record_full_base_target
267 const target_info
&info () const override
268 { return record_full_target_info
; }
270 void commit_resume () override
;
271 void resume (ptid_t
, int, enum gdb_signal
) override
;
272 void disconnect (const char *, int) override
;
273 void detach (inferior
*, int) override
;
274 void mourn_inferior () override
;
275 void kill () override
;
276 void store_registers (struct regcache
*, int) override
;
277 enum target_xfer_status
xfer_partial (enum target_object object
,
280 const gdb_byte
*writebuf
,
281 ULONGEST offset
, ULONGEST len
,
282 ULONGEST
*xfered_len
) override
;
283 int insert_breakpoint (struct gdbarch
*,
284 struct bp_target_info
*) override
;
285 int remove_breakpoint (struct gdbarch
*,
286 struct bp_target_info
*,
287 enum remove_bp_reason
) override
;
290 /* The "record-core" target. */
292 static const target_info record_full_core_target_info
= {
298 class record_full_core_target final
: public record_full_base_target
301 const target_info
&info () const override
302 { return record_full_core_target_info
; }
304 void resume (ptid_t
, int, enum gdb_signal
) override
;
305 void disconnect (const char *, int) override
;
306 void kill () override
;
307 void fetch_registers (struct regcache
*regcache
, int regno
) override
;
308 void prepare_to_store (struct regcache
*regcache
) override
;
309 void store_registers (struct regcache
*, int) override
;
310 enum target_xfer_status
xfer_partial (enum target_object object
,
313 const gdb_byte
*writebuf
,
314 ULONGEST offset
, ULONGEST len
,
315 ULONGEST
*xfered_len
) override
;
316 int insert_breakpoint (struct gdbarch
*,
317 struct bp_target_info
*) override
;
318 int remove_breakpoint (struct gdbarch
*,
319 struct bp_target_info
*,
320 enum remove_bp_reason
) override
;
322 bool has_execution (ptid_t
) override
;
325 static record_full_target record_full_ops
;
326 static record_full_core_target record_full_core_ops
;
329 record_full_target::detach (inferior
*inf
, int from_tty
)
331 record_detach (this, inf
, from_tty
);
335 record_full_target::disconnect (const char *args
, int from_tty
)
337 record_disconnect (this, args
, from_tty
);
341 record_full_core_target::disconnect (const char *args
, int from_tty
)
343 record_disconnect (this, args
, from_tty
);
347 record_full_target::mourn_inferior ()
349 record_mourn_inferior (this);
353 record_full_target::kill ()
358 /* See record-full.h. */
361 record_full_is_used (void)
363 struct target_ops
*t
;
365 t
= find_record_target ();
366 return (t
== &record_full_ops
367 || t
== &record_full_core_ops
);
371 /* Command lists for "set/show record full". */
372 static struct cmd_list_element
*set_record_full_cmdlist
;
373 static struct cmd_list_element
*show_record_full_cmdlist
;
375 /* Command list for "record full". */
376 static struct cmd_list_element
*record_full_cmdlist
;
378 static void record_full_goto_insn (struct record_full_entry
*entry
,
379 enum exec_direction_kind dir
);
381 /* Alloc and free functions for record_full_reg, record_full_mem, and
382 record_full_end entries. */
384 /* Alloc a record_full_reg record entry. */
386 static inline struct record_full_entry
*
387 record_full_reg_alloc (struct regcache
*regcache
, int regnum
)
389 struct record_full_entry
*rec
;
390 struct gdbarch
*gdbarch
= regcache
->arch ();
392 rec
= XCNEW (struct record_full_entry
);
393 rec
->type
= record_full_reg
;
394 rec
->u
.reg
.num
= regnum
;
395 rec
->u
.reg
.len
= register_size (gdbarch
, regnum
);
396 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
397 rec
->u
.reg
.u
.ptr
= (gdb_byte
*) xmalloc (rec
->u
.reg
.len
);
402 /* Free a record_full_reg record entry. */
405 record_full_reg_release (struct record_full_entry
*rec
)
407 gdb_assert (rec
->type
== record_full_reg
);
408 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
409 xfree (rec
->u
.reg
.u
.ptr
);
413 /* Alloc a record_full_mem record entry. */
415 static inline struct record_full_entry
*
416 record_full_mem_alloc (CORE_ADDR addr
, int len
)
418 struct record_full_entry
*rec
;
420 rec
= XCNEW (struct record_full_entry
);
421 rec
->type
= record_full_mem
;
422 rec
->u
.mem
.addr
= addr
;
423 rec
->u
.mem
.len
= len
;
424 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
425 rec
->u
.mem
.u
.ptr
= (gdb_byte
*) xmalloc (len
);
430 /* Free a record_full_mem record entry. */
433 record_full_mem_release (struct record_full_entry
*rec
)
435 gdb_assert (rec
->type
== record_full_mem
);
436 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
437 xfree (rec
->u
.mem
.u
.ptr
);
441 /* Alloc a record_full_end record entry. */
443 static inline struct record_full_entry
*
444 record_full_end_alloc (void)
446 struct record_full_entry
*rec
;
448 rec
= XCNEW (struct record_full_entry
);
449 rec
->type
= record_full_end
;
454 /* Free a record_full_end record entry. */
457 record_full_end_release (struct record_full_entry
*rec
)
462 /* Free one record entry, any type.
463 Return entry->type, in case caller wants to know. */
465 static inline enum record_full_type
466 record_full_entry_release (struct record_full_entry
*rec
)
468 enum record_full_type type
= rec
->type
;
471 case record_full_reg
:
472 record_full_reg_release (rec
);
474 case record_full_mem
:
475 record_full_mem_release (rec
);
477 case record_full_end
:
478 record_full_end_release (rec
);
484 /* Free all record entries in list pointed to by REC. */
487 record_full_list_release (struct record_full_entry
*rec
)
498 record_full_entry_release (rec
->next
);
501 if (rec
== &record_full_first
)
503 record_full_insn_num
= 0;
504 record_full_first
.next
= NULL
;
507 record_full_entry_release (rec
);
510 /* Free all record entries forward of the given list position. */
513 record_full_list_release_following (struct record_full_entry
*rec
)
515 struct record_full_entry
*tmp
= rec
->next
;
521 if (record_full_entry_release (tmp
) == record_full_end
)
523 record_full_insn_num
--;
524 record_full_insn_count
--;
530 /* Delete the first instruction from the beginning of the log, to make
531 room for adding a new instruction at the end of the log.
533 Note -- this function does not modify record_full_insn_num. */
536 record_full_list_release_first (void)
538 struct record_full_entry
*tmp
;
540 if (!record_full_first
.next
)
543 /* Loop until a record_full_end. */
546 /* Cut record_full_first.next out of the linked list. */
547 tmp
= record_full_first
.next
;
548 record_full_first
.next
= tmp
->next
;
549 tmp
->next
->prev
= &record_full_first
;
551 /* tmp is now isolated, and can be deleted. */
552 if (record_full_entry_release (tmp
) == record_full_end
)
553 break; /* End loop at first record_full_end. */
555 if (!record_full_first
.next
)
557 gdb_assert (record_full_insn_num
== 1);
558 break; /* End loop when list is empty. */
563 /* Add a struct record_full_entry to record_full_arch_list. */
566 record_full_arch_list_add (struct record_full_entry
*rec
)
568 if (record_debug
> 1)
569 fprintf_unfiltered (gdb_stdlog
,
570 "Process record: record_full_arch_list_add %s.\n",
571 host_address_to_string (rec
));
573 if (record_full_arch_list_tail
)
575 record_full_arch_list_tail
->next
= rec
;
576 rec
->prev
= record_full_arch_list_tail
;
577 record_full_arch_list_tail
= rec
;
581 record_full_arch_list_head
= rec
;
582 record_full_arch_list_tail
= rec
;
586 /* Return the value storage location of a record entry. */
587 static inline gdb_byte
*
588 record_full_get_loc (struct record_full_entry
*rec
)
591 case record_full_mem
:
592 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
593 return rec
->u
.mem
.u
.ptr
;
595 return rec
->u
.mem
.u
.buf
;
596 case record_full_reg
:
597 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
598 return rec
->u
.reg
.u
.ptr
;
600 return rec
->u
.reg
.u
.buf
;
601 case record_full_end
:
603 gdb_assert_not_reached ("unexpected record_full_entry type");
608 /* Record the value of a register NUM to record_full_arch_list. */
611 record_full_arch_list_add_reg (struct regcache
*regcache
, int regnum
)
613 struct record_full_entry
*rec
;
615 if (record_debug
> 1)
616 fprintf_unfiltered (gdb_stdlog
,
617 "Process record: add register num = %d to "
621 rec
= record_full_reg_alloc (regcache
, regnum
);
623 regcache
->raw_read (regnum
, record_full_get_loc (rec
));
625 record_full_arch_list_add (rec
);
630 /* Record the value of a region of memory whose address is ADDR and
631 length is LEN to record_full_arch_list. */
634 record_full_arch_list_add_mem (CORE_ADDR addr
, int len
)
636 struct record_full_entry
*rec
;
638 if (record_debug
> 1)
639 fprintf_unfiltered (gdb_stdlog
,
640 "Process record: add mem addr = %s len = %d to "
642 paddress (target_gdbarch (), addr
), len
);
644 if (!addr
) /* FIXME: Why? Some arch must permit it... */
647 rec
= record_full_mem_alloc (addr
, len
);
649 if (record_read_memory (target_gdbarch (), addr
,
650 record_full_get_loc (rec
), len
))
652 record_full_mem_release (rec
);
656 record_full_arch_list_add (rec
);
661 /* Add a record_full_end type struct record_full_entry to
662 record_full_arch_list. */
665 record_full_arch_list_add_end (void)
667 struct record_full_entry
*rec
;
669 if (record_debug
> 1)
670 fprintf_unfiltered (gdb_stdlog
,
671 "Process record: add end to arch list.\n");
673 rec
= record_full_end_alloc ();
674 rec
->u
.end
.sigval
= GDB_SIGNAL_0
;
675 rec
->u
.end
.insn_num
= ++record_full_insn_count
;
677 record_full_arch_list_add (rec
);
683 record_full_check_insn_num (void)
685 if (record_full_insn_num
== record_full_insn_max_num
)
687 /* Ask user what to do. */
688 if (record_full_stop_at_limit
)
690 if (!yquery (_("Do you want to auto delete previous execution "
691 "log entries when record/replay buffer becomes "
692 "full (record full stop-at-limit)?")))
693 error (_("Process record: stopped by user."));
694 record_full_stop_at_limit
= 0;
699 /* Before inferior step (when GDB record the running message, inferior
700 only can step), GDB will call this function to record the values to
701 record_full_list. This function will call gdbarch_process_record to
702 record the running message of inferior and set them to
703 record_full_arch_list, and add it to record_full_list. */
706 record_full_message (struct regcache
*regcache
, enum gdb_signal signal
)
709 struct gdbarch
*gdbarch
= regcache
->arch ();
713 record_full_arch_list_head
= NULL
;
714 record_full_arch_list_tail
= NULL
;
716 /* Check record_full_insn_num. */
717 record_full_check_insn_num ();
719 /* If gdb sends a signal value to target_resume,
720 save it in the 'end' field of the previous instruction.
722 Maybe process record should record what really happened,
723 rather than what gdb pretends has happened.
725 So if Linux delivered the signal to the child process during
726 the record mode, we will record it and deliver it again in
729 If user says "ignore this signal" during the record mode, then
730 it will be ignored again during the replay mode (no matter if
731 the user says something different, like "deliver this signal"
732 during the replay mode).
734 User should understand that nothing he does during the replay
735 mode will change the behavior of the child. If he tries,
736 then that is a user error.
738 But we should still deliver the signal to gdb during the replay,
739 if we delivered it during the recording. Therefore we should
740 record the signal during record_full_wait, not
741 record_full_resume. */
742 if (record_full_list
!= &record_full_first
) /* FIXME better way
745 gdb_assert (record_full_list
->type
== record_full_end
);
746 record_full_list
->u
.end
.sigval
= signal
;
749 if (signal
== GDB_SIGNAL_0
750 || !gdbarch_process_record_signal_p (gdbarch
))
751 ret
= gdbarch_process_record (gdbarch
,
753 regcache_read_pc (regcache
));
755 ret
= gdbarch_process_record_signal (gdbarch
,
760 error (_("Process record: inferior program stopped."));
762 error (_("Process record: failed to record execution log."));
764 catch (const gdb_exception
&ex
)
766 record_full_list_release (record_full_arch_list_tail
);
770 record_full_list
->next
= record_full_arch_list_head
;
771 record_full_arch_list_head
->prev
= record_full_list
;
772 record_full_list
= record_full_arch_list_tail
;
774 if (record_full_insn_num
== record_full_insn_max_num
)
775 record_full_list_release_first ();
777 record_full_insn_num
++;
781 record_full_message_wrapper_safe (struct regcache
*regcache
,
782 enum gdb_signal signal
)
786 record_full_message (regcache
, signal
);
788 catch (const gdb_exception
&ex
)
790 exception_print (gdb_stderr
, ex
);
797 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
798 doesn't need record. */
800 static int record_full_gdb_operation_disable
= 0;
802 scoped_restore_tmpl
<int>
803 record_full_gdb_operation_disable_set (void)
805 return make_scoped_restore (&record_full_gdb_operation_disable
, 1);
808 /* Flag set to TRUE for target_stopped_by_watchpoint. */
809 static enum target_stop_reason record_full_stop_reason
810 = TARGET_STOPPED_BY_NO_REASON
;
812 /* Execute one instruction from the record log. Each instruction in
813 the log will be represented by an arbitrary sequence of register
814 entries and memory entries, followed by an 'end' entry. */
817 record_full_exec_insn (struct regcache
*regcache
,
818 struct gdbarch
*gdbarch
,
819 struct record_full_entry
*entry
)
823 case record_full_reg
: /* reg */
825 gdb::byte_vector
reg (entry
->u
.reg
.len
);
827 if (record_debug
> 1)
828 fprintf_unfiltered (gdb_stdlog
,
829 "Process record: record_full_reg %s to "
830 "inferior num = %d.\n",
831 host_address_to_string (entry
),
834 regcache
->cooked_read (entry
->u
.reg
.num
, reg
.data ());
835 regcache
->cooked_write (entry
->u
.reg
.num
, record_full_get_loc (entry
));
836 memcpy (record_full_get_loc (entry
), reg
.data (), entry
->u
.reg
.len
);
840 case record_full_mem
: /* mem */
842 /* Nothing to do if the entry is flagged not_accessible. */
843 if (!entry
->u
.mem
.mem_entry_not_accessible
)
845 gdb::byte_vector
mem (entry
->u
.mem
.len
);
847 if (record_debug
> 1)
848 fprintf_unfiltered (gdb_stdlog
,
849 "Process record: record_full_mem %s to "
850 "inferior addr = %s len = %d.\n",
851 host_address_to_string (entry
),
852 paddress (gdbarch
, entry
->u
.mem
.addr
),
855 if (record_read_memory (gdbarch
,
856 entry
->u
.mem
.addr
, mem
.data (),
858 entry
->u
.mem
.mem_entry_not_accessible
= 1;
861 if (target_write_memory (entry
->u
.mem
.addr
,
862 record_full_get_loc (entry
),
865 entry
->u
.mem
.mem_entry_not_accessible
= 1;
867 warning (_("Process record: error writing memory at "
868 "addr = %s len = %d."),
869 paddress (gdbarch
, entry
->u
.mem
.addr
),
874 memcpy (record_full_get_loc (entry
), mem
.data (),
877 /* We've changed memory --- check if a hardware
878 watchpoint should trap. Note that this
879 presently assumes the target beneath supports
880 continuable watchpoints. On non-continuable
881 watchpoints target, we'll want to check this
882 _before_ actually doing the memory change, and
883 not doing the change at all if the watchpoint
885 if (hardware_watchpoint_inserted_in_range
886 (regcache
->aspace (),
887 entry
->u
.mem
.addr
, entry
->u
.mem
.len
))
888 record_full_stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
897 static void record_full_restore (void);
899 /* Asynchronous signal handle registered as event loop source for when
900 we have pending events ready to be passed to the core. */
902 static struct async_event_handler
*record_full_async_inferior_event_token
;
905 record_full_async_inferior_event_handler (gdb_client_data data
)
907 inferior_event_handler (INF_REG_EVENT
, NULL
);
910 /* Open the process record target for 'core' files. */
913 record_full_core_open_1 (const char *name
, int from_tty
)
915 struct regcache
*regcache
= get_current_regcache ();
916 int regnum
= gdbarch_num_regs (regcache
->arch ());
919 /* Get record_full_core_regbuf. */
920 target_fetch_registers (regcache
, -1);
921 record_full_core_regbuf
= new detached_regcache (regcache
->arch (), false);
923 for (i
= 0; i
< regnum
; i
++)
924 record_full_core_regbuf
->raw_supply (i
, *regcache
);
926 /* Get record_full_core_start and record_full_core_end. */
927 if (build_section_table (core_bfd
, &record_full_core_start
,
928 &record_full_core_end
))
930 delete record_full_core_regbuf
;
931 record_full_core_regbuf
= NULL
;
932 error (_("\"%s\": Can't find sections: %s"),
933 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
936 push_target (&record_full_core_ops
);
937 record_full_restore ();
940 /* Open the process record target for 'live' processes. */
943 record_full_open_1 (const char *name
, int from_tty
)
946 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open_1\n");
949 if (!target_has_execution
)
950 error (_("Process record: the program is not being run."));
952 error (_("Process record target can't debug inferior in non-stop mode "
955 if (!gdbarch_process_record_p (target_gdbarch ()))
956 error (_("Process record: the current architecture doesn't support "
957 "record function."));
959 push_target (&record_full_ops
);
962 static void record_full_init_record_breakpoints (void);
964 /* Open the process record target. */
967 record_full_open (const char *name
, int from_tty
)
970 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
975 record_full_insn_num
= 0;
976 record_full_insn_count
= 0;
977 record_full_list
= &record_full_first
;
978 record_full_list
->next
= NULL
;
981 record_full_core_open_1 (name
, from_tty
);
983 record_full_open_1 (name
, from_tty
);
985 /* Register extra event sources in the event loop. */
986 record_full_async_inferior_event_token
987 = create_async_event_handler (record_full_async_inferior_event_handler
,
990 record_full_init_record_breakpoints ();
992 gdb::observers::record_changed
.notify (current_inferior (), 1, "full", NULL
);
995 /* "close" target method. Close the process record target. */
998 record_full_base_target::close ()
1000 struct record_full_core_buf_entry
*entry
;
1003 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_close\n");
1005 record_full_list_release (record_full_list
);
1007 /* Release record_full_core_regbuf. */
1008 if (record_full_core_regbuf
)
1010 delete record_full_core_regbuf
;
1011 record_full_core_regbuf
= NULL
;
1014 /* Release record_full_core_buf_list. */
1015 while (record_full_core_buf_list
)
1017 entry
= record_full_core_buf_list
;
1018 record_full_core_buf_list
= record_full_core_buf_list
->prev
;
1022 if (record_full_async_inferior_event_token
)
1023 delete_async_event_handler (&record_full_async_inferior_event_token
);
1026 /* "async" target method. */
1029 record_full_base_target::async (int enable
)
1032 mark_async_event_handler (record_full_async_inferior_event_token
);
1034 clear_async_event_handler (record_full_async_inferior_event_token
);
1036 beneath ()->async (enable
);
1039 /* The PTID and STEP arguments last passed to
1040 record_full_target::resume. */
1041 static ptid_t record_full_resume_ptid
= null_ptid
;
1042 static int record_full_resume_step
= 0;
1044 /* True if we've been resumed, and so each record_full_wait call should
1045 advance execution. If this is false, record_full_wait will return a
1046 TARGET_WAITKIND_IGNORE. */
1047 static int record_full_resumed
= 0;
1049 /* The execution direction of the last resume we got. This is
1050 necessary for async mode. Vis (order is not strictly accurate):
1052 1. user has the global execution direction set to forward
1053 2. user does a reverse-step command
1054 3. record_full_resume is called with global execution direction
1055 temporarily switched to reverse
1056 4. GDB's execution direction is reverted back to forward
1057 5. target record notifies event loop there's an event to handle
1058 6. infrun asks the target which direction was it going, and switches
1059 the global execution direction accordingly (to reverse)
1060 7. infrun polls an event out of the record target, and handles it
1061 8. GDB goes back to the event loop, and goto #4.
1063 static enum exec_direction_kind record_full_execution_dir
= EXEC_FORWARD
;
1065 /* "resume" target method. Resume the process record target. */
1068 record_full_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
1070 record_full_resume_ptid
= inferior_ptid
;
1071 record_full_resume_step
= step
;
1072 record_full_resumed
= 1;
1073 record_full_execution_dir
= ::execution_direction
;
1075 if (!RECORD_FULL_IS_REPLAY
)
1077 struct gdbarch
*gdbarch
= target_thread_architecture (ptid
);
1079 record_full_message (get_current_regcache (), signal
);
1083 /* This is not hard single step. */
1084 if (!gdbarch_software_single_step_p (gdbarch
))
1086 /* This is a normal continue. */
1091 /* This arch supports soft single step. */
1092 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
1094 /* This is a soft single step. */
1095 record_full_resume_step
= 1;
1098 step
= !insert_single_step_breakpoints (gdbarch
);
1102 /* Make sure the target beneath reports all signals. */
1103 target_pass_signals ({});
1105 this->beneath ()->resume (ptid
, step
, signal
);
1108 /* We are about to start executing the inferior (or simulate it),
1109 let's register it with the event loop. */
1110 if (target_can_async_p ())
1114 /* "commit_resume" method for process record target. */
1117 record_full_target::commit_resume ()
1119 if (!RECORD_FULL_IS_REPLAY
)
1120 beneath ()->commit_resume ();
1123 static int record_full_get_sig
= 0;
1125 /* SIGINT signal handler, registered by "wait" method. */
1128 record_full_sig_handler (int signo
)
1131 fprintf_unfiltered (gdb_stdlog
, "Process record: get a signal\n");
1133 /* It will break the running inferior in replay mode. */
1134 record_full_resume_step
= 1;
1136 /* It will let record_full_wait set inferior status to get the signal
1138 record_full_get_sig
= 1;
1141 /* "wait" target method for process record target.
1143 In record mode, the target is always run in singlestep mode
1144 (even when gdb says to continue). The wait method intercepts
1145 the stop events and determines which ones are to be passed on to
1146 gdb. Most stop events are just singlestep events that gdb is not
1147 to know about, so the wait method just records them and keeps
1150 In replay mode, this function emulates the recorded execution log,
1151 one instruction at a time (forward or backward), and determines
1155 record_full_wait_1 (struct target_ops
*ops
,
1156 ptid_t ptid
, struct target_waitstatus
*status
,
1159 scoped_restore restore_operation_disable
1160 = record_full_gdb_operation_disable_set ();
1163 fprintf_unfiltered (gdb_stdlog
,
1164 "Process record: record_full_wait "
1165 "record_full_resume_step = %d, "
1166 "record_full_resumed = %d, direction=%s\n",
1167 record_full_resume_step
, record_full_resumed
,
1168 record_full_execution_dir
== EXEC_FORWARD
1169 ? "forward" : "reverse");
1171 if (!record_full_resumed
)
1173 gdb_assert ((options
& TARGET_WNOHANG
) != 0);
1175 /* No interesting event. */
1176 status
->kind
= TARGET_WAITKIND_IGNORE
;
1177 return minus_one_ptid
;
1180 record_full_get_sig
= 0;
1181 signal (SIGINT
, record_full_sig_handler
);
1183 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1185 if (!RECORD_FULL_IS_REPLAY
&& ops
!= &record_full_core_ops
)
1187 if (record_full_resume_step
)
1189 /* This is a single step. */
1190 return ops
->beneath ()->wait (ptid
, status
, options
);
1194 /* This is not a single step. */
1197 struct gdbarch
*gdbarch
1198 = target_thread_architecture (record_full_resume_ptid
);
1202 ret
= ops
->beneath ()->wait (ptid
, status
, options
);
1203 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
1206 fprintf_unfiltered (gdb_stdlog
,
1207 "Process record: record_full_wait "
1208 "target beneath not done yet\n");
1212 for (thread_info
*tp
: all_non_exited_threads ())
1213 delete_single_step_breakpoints (tp
);
1215 if (record_full_resume_step
)
1218 /* Is this a SIGTRAP? */
1219 if (status
->kind
== TARGET_WAITKIND_STOPPED
1220 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1222 struct regcache
*regcache
;
1223 enum target_stop_reason
*stop_reason_p
1224 = &record_full_stop_reason
;
1226 /* Yes -- this is likely our single-step finishing,
1227 but check if there's any reason the core would be
1228 interested in the event. */
1230 registers_changed ();
1231 regcache
= get_current_regcache ();
1232 tmp_pc
= regcache_read_pc (regcache
);
1233 const struct address_space
*aspace
= regcache
->aspace ();
1235 if (target_stopped_by_watchpoint ())
1237 /* Always interested in watchpoints. */
1239 else if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1242 /* There is a breakpoint here. Let the core
1247 /* This is a single-step trap. Record the
1248 insn and issue another step.
1249 FIXME: this part can be a random SIGTRAP too.
1250 But GDB cannot handle it. */
1253 if (!record_full_message_wrapper_safe (regcache
,
1256 status
->kind
= TARGET_WAITKIND_STOPPED
;
1257 status
->value
.sig
= GDB_SIGNAL_0
;
1261 if (gdbarch_software_single_step_p (gdbarch
))
1263 /* Try to insert the software single step breakpoint.
1264 If insert success, set step to 0. */
1265 set_executing (inferior_ptid
, 0);
1266 reinit_frame_cache ();
1268 step
= !insert_single_step_breakpoints (gdbarch
);
1270 set_executing (inferior_ptid
, 1);
1274 fprintf_unfiltered (gdb_stdlog
,
1275 "Process record: record_full_wait "
1276 "issuing one more step in the "
1277 "target beneath\n");
1278 ops
->beneath ()->resume (ptid
, step
, GDB_SIGNAL_0
);
1279 ops
->beneath ()->commit_resume ();
1284 /* The inferior is broken by a breakpoint or a signal. */
1293 struct regcache
*regcache
= get_current_regcache ();
1294 struct gdbarch
*gdbarch
= regcache
->arch ();
1295 const struct address_space
*aspace
= regcache
->aspace ();
1296 int continue_flag
= 1;
1297 int first_record_full_end
= 1;
1303 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1304 status
->kind
= TARGET_WAITKIND_STOPPED
;
1306 /* Check breakpoint when forward execute. */
1307 if (execution_direction
== EXEC_FORWARD
)
1309 tmp_pc
= regcache_read_pc (regcache
);
1310 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1311 &record_full_stop_reason
))
1314 fprintf_unfiltered (gdb_stdlog
,
1315 "Process record: break at %s.\n",
1316 paddress (gdbarch
, tmp_pc
));
1321 /* If GDB is in terminal_inferior mode, it will not get the
1322 signal. And in GDB replay mode, GDB doesn't need to be
1323 in terminal_inferior mode, because inferior will not
1324 executed. Then set it to terminal_ours to make GDB get
1326 target_terminal::ours ();
1328 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1330 if (execution_direction
== EXEC_FORWARD
&& record_full_list
->next
)
1331 record_full_list
= record_full_list
->next
;
1333 /* Loop over the record_full_list, looking for the next place to
1337 /* Check for beginning and end of log. */
1338 if (execution_direction
== EXEC_REVERSE
1339 && record_full_list
== &record_full_first
)
1341 /* Hit beginning of record log in reverse. */
1342 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1345 if (execution_direction
!= EXEC_REVERSE
1346 && !record_full_list
->next
)
1348 /* Hit end of record log going forward. */
1349 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1353 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
1355 if (record_full_list
->type
== record_full_end
)
1357 if (record_debug
> 1)
1360 "Process record: record_full_end %s to "
1362 host_address_to_string (record_full_list
));
1364 if (first_record_full_end
1365 && execution_direction
== EXEC_REVERSE
)
1367 /* When reverse execute, the first
1368 record_full_end is the part of current
1370 first_record_full_end
= 0;
1374 /* In EXEC_REVERSE mode, this is the
1375 record_full_end of prev instruction. In
1376 EXEC_FORWARD mode, this is the
1377 record_full_end of current instruction. */
1379 if (record_full_resume_step
)
1381 if (record_debug
> 1)
1382 fprintf_unfiltered (gdb_stdlog
,
1383 "Process record: step.\n");
1387 /* check breakpoint */
1388 tmp_pc
= regcache_read_pc (regcache
);
1389 if (record_check_stopped_by_breakpoint
1390 (aspace
, tmp_pc
, &record_full_stop_reason
))
1393 fprintf_unfiltered (gdb_stdlog
,
1394 "Process record: break "
1396 paddress (gdbarch
, tmp_pc
));
1401 if (record_full_stop_reason
1402 == TARGET_STOPPED_BY_WATCHPOINT
)
1405 fprintf_unfiltered (gdb_stdlog
,
1406 "Process record: hit hw "
1410 /* Check target signal */
1411 if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1412 /* FIXME: better way to check */
1419 if (execution_direction
== EXEC_REVERSE
)
1421 if (record_full_list
->prev
)
1422 record_full_list
= record_full_list
->prev
;
1426 if (record_full_list
->next
)
1427 record_full_list
= record_full_list
->next
;
1431 while (continue_flag
);
1434 if (record_full_get_sig
)
1435 status
->value
.sig
= GDB_SIGNAL_INT
;
1436 else if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1437 /* FIXME: better way to check */
1438 status
->value
.sig
= record_full_list
->u
.end
.sigval
;
1440 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1442 catch (const gdb_exception
&ex
)
1444 if (execution_direction
== EXEC_REVERSE
)
1446 if (record_full_list
->next
)
1447 record_full_list
= record_full_list
->next
;
1450 record_full_list
= record_full_list
->prev
;
1456 signal (SIGINT
, handle_sigint
);
1458 return inferior_ptid
;
1462 record_full_base_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1467 return_ptid
= record_full_wait_1 (this, ptid
, status
, options
);
1468 if (status
->kind
!= TARGET_WAITKIND_IGNORE
)
1470 /* We're reporting a stop. Make sure any spurious
1471 target_wait(WNOHANG) doesn't advance the target until the
1472 core wants us resumed again. */
1473 record_full_resumed
= 0;
1479 record_full_base_target::stopped_by_watchpoint ()
1481 if (RECORD_FULL_IS_REPLAY
)
1482 return record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
1484 return beneath ()->stopped_by_watchpoint ();
1488 record_full_base_target::stopped_data_address (CORE_ADDR
*addr_p
)
1490 if (RECORD_FULL_IS_REPLAY
)
1493 return this->beneath ()->stopped_data_address (addr_p
);
1496 /* The stopped_by_sw_breakpoint method of target record-full. */
1499 record_full_base_target::stopped_by_sw_breakpoint ()
1501 return record_full_stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
1504 /* The supports_stopped_by_sw_breakpoint method of target
1508 record_full_base_target::supports_stopped_by_sw_breakpoint ()
1513 /* The stopped_by_hw_breakpoint method of target record-full. */
1516 record_full_base_target::stopped_by_hw_breakpoint ()
1518 return record_full_stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
1521 /* The supports_stopped_by_sw_breakpoint method of target
1525 record_full_base_target::supports_stopped_by_hw_breakpoint ()
1530 /* Record registers change (by user or by GDB) to list as an instruction. */
1533 record_full_registers_change (struct regcache
*regcache
, int regnum
)
1535 /* Check record_full_insn_num. */
1536 record_full_check_insn_num ();
1538 record_full_arch_list_head
= NULL
;
1539 record_full_arch_list_tail
= NULL
;
1545 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
1547 if (record_full_arch_list_add_reg (regcache
, i
))
1549 record_full_list_release (record_full_arch_list_tail
);
1550 error (_("Process record: failed to record execution log."));
1556 if (record_full_arch_list_add_reg (regcache
, regnum
))
1558 record_full_list_release (record_full_arch_list_tail
);
1559 error (_("Process record: failed to record execution log."));
1562 if (record_full_arch_list_add_end ())
1564 record_full_list_release (record_full_arch_list_tail
);
1565 error (_("Process record: failed to record execution log."));
1567 record_full_list
->next
= record_full_arch_list_head
;
1568 record_full_arch_list_head
->prev
= record_full_list
;
1569 record_full_list
= record_full_arch_list_tail
;
1571 if (record_full_insn_num
== record_full_insn_max_num
)
1572 record_full_list_release_first ();
1574 record_full_insn_num
++;
1577 /* "store_registers" method for process record target. */
1580 record_full_target::store_registers (struct regcache
*regcache
, int regno
)
1582 if (!record_full_gdb_operation_disable
)
1584 if (RECORD_FULL_IS_REPLAY
)
1588 /* Let user choose if he wants to write register or not. */
1591 query (_("Because GDB is in replay mode, changing the "
1592 "value of a register will make the execution "
1593 "log unusable from this point onward. "
1594 "Change all registers?"));
1597 query (_("Because GDB is in replay mode, changing the value "
1598 "of a register will make the execution log unusable "
1599 "from this point onward. Change register %s?"),
1600 gdbarch_register_name (regcache
->arch (),
1605 /* Invalidate the value of regcache that was set in function
1606 "regcache_raw_write". */
1612 i
< gdbarch_num_regs (regcache
->arch ());
1614 regcache
->invalidate (i
);
1617 regcache
->invalidate (regno
);
1619 error (_("Process record canceled the operation."));
1622 /* Destroy the record from here forward. */
1623 record_full_list_release_following (record_full_list
);
1626 record_full_registers_change (regcache
, regno
);
1628 this->beneath ()->store_registers (regcache
, regno
);
1631 /* "xfer_partial" method. Behavior is conditional on
1632 RECORD_FULL_IS_REPLAY.
1633 In replay mode, we cannot write memory unles we are willing to
1634 invalidate the record/replay log from this point forward. */
1636 enum target_xfer_status
1637 record_full_target::xfer_partial (enum target_object object
,
1638 const char *annex
, gdb_byte
*readbuf
,
1639 const gdb_byte
*writebuf
, ULONGEST offset
,
1640 ULONGEST len
, ULONGEST
*xfered_len
)
1642 if (!record_full_gdb_operation_disable
1643 && (object
== TARGET_OBJECT_MEMORY
1644 || object
== TARGET_OBJECT_RAW_MEMORY
) && writebuf
)
1646 if (RECORD_FULL_IS_REPLAY
)
1648 /* Let user choose if he wants to write memory or not. */
1649 if (!query (_("Because GDB is in replay mode, writing to memory "
1650 "will make the execution log unusable from this "
1651 "point onward. Write memory at address %s?"),
1652 paddress (target_gdbarch (), offset
)))
1653 error (_("Process record canceled the operation."));
1655 /* Destroy the record from here forward. */
1656 record_full_list_release_following (record_full_list
);
1659 /* Check record_full_insn_num */
1660 record_full_check_insn_num ();
1662 /* Record registers change to list as an instruction. */
1663 record_full_arch_list_head
= NULL
;
1664 record_full_arch_list_tail
= NULL
;
1665 if (record_full_arch_list_add_mem (offset
, len
))
1667 record_full_list_release (record_full_arch_list_tail
);
1669 fprintf_unfiltered (gdb_stdlog
,
1670 "Process record: failed to record "
1672 return TARGET_XFER_E_IO
;
1674 if (record_full_arch_list_add_end ())
1676 record_full_list_release (record_full_arch_list_tail
);
1678 fprintf_unfiltered (gdb_stdlog
,
1679 "Process record: failed to record "
1681 return TARGET_XFER_E_IO
;
1683 record_full_list
->next
= record_full_arch_list_head
;
1684 record_full_arch_list_head
->prev
= record_full_list
;
1685 record_full_list
= record_full_arch_list_tail
;
1687 if (record_full_insn_num
== record_full_insn_max_num
)
1688 record_full_list_release_first ();
1690 record_full_insn_num
++;
1693 return this->beneath ()->xfer_partial (object
, annex
, readbuf
, writebuf
,
1694 offset
, len
, xfered_len
);
1697 /* This structure represents a breakpoint inserted while the record
1698 target is active. We use this to know when to install/remove
1699 breakpoints in/from the target beneath. For example, a breakpoint
1700 may be inserted while recording, but removed when not replaying nor
1701 recording. In that case, the breakpoint had not been inserted on
1702 the target beneath, so we should not try to remove it there. */
1704 struct record_full_breakpoint
1706 record_full_breakpoint (struct address_space
*address_space_
,
1708 bool in_target_beneath_
)
1709 : address_space (address_space_
),
1711 in_target_beneath (in_target_beneath_
)
1715 /* The address and address space the breakpoint was set at. */
1716 struct address_space
*address_space
;
1719 /* True when the breakpoint has been also installed in the target
1720 beneath. This will be false for breakpoints set during replay or
1722 bool in_target_beneath
;
1725 /* The list of breakpoints inserted while the record target is
1727 static std::vector
<record_full_breakpoint
> record_full_breakpoints
;
1730 record_full_sync_record_breakpoints (struct bp_location
*loc
, void *data
)
1732 if (loc
->loc_type
!= bp_loc_software_breakpoint
)
1737 record_full_breakpoints
.emplace_back
1738 (loc
->target_info
.placed_address_space
,
1739 loc
->target_info
.placed_address
,
1744 /* Sync existing breakpoints to record_full_breakpoints. */
1747 record_full_init_record_breakpoints (void)
1749 record_full_breakpoints
.clear ();
1751 iterate_over_bp_locations (record_full_sync_record_breakpoints
);
1754 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1755 insert or remove breakpoints in the real target when replaying, nor
1759 record_full_target::insert_breakpoint (struct gdbarch
*gdbarch
,
1760 struct bp_target_info
*bp_tgt
)
1762 bool in_target_beneath
= false;
1764 if (!RECORD_FULL_IS_REPLAY
)
1766 /* When recording, we currently always single-step, so we don't
1767 really need to install regular breakpoints in the inferior.
1768 However, we do have to insert software single-step
1769 breakpoints, in case the target can't hardware step. To keep
1770 things simple, we always insert. */
1772 scoped_restore restore_operation_disable
1773 = record_full_gdb_operation_disable_set ();
1775 int ret
= this->beneath ()->insert_breakpoint (gdbarch
, bp_tgt
);
1779 in_target_beneath
= true;
1782 /* Use the existing entries if found in order to avoid duplication
1783 in record_full_breakpoints. */
1785 for (const record_full_breakpoint
&bp
: record_full_breakpoints
)
1787 if (bp
.addr
== bp_tgt
->placed_address
1788 && bp
.address_space
== bp_tgt
->placed_address_space
)
1790 gdb_assert (bp
.in_target_beneath
== in_target_beneath
);
1795 record_full_breakpoints
.emplace_back (bp_tgt
->placed_address_space
,
1796 bp_tgt
->placed_address
,
1801 /* "remove_breakpoint" method for process record target. */
1804 record_full_target::remove_breakpoint (struct gdbarch
*gdbarch
,
1805 struct bp_target_info
*bp_tgt
,
1806 enum remove_bp_reason reason
)
1808 for (auto iter
= record_full_breakpoints
.begin ();
1809 iter
!= record_full_breakpoints
.end ();
1812 struct record_full_breakpoint
&bp
= *iter
;
1814 if (bp
.addr
== bp_tgt
->placed_address
1815 && bp
.address_space
== bp_tgt
->placed_address_space
)
1817 if (bp
.in_target_beneath
)
1819 scoped_restore restore_operation_disable
1820 = record_full_gdb_operation_disable_set ();
1822 int ret
= this->beneath ()->remove_breakpoint (gdbarch
, bp_tgt
,
1828 if (reason
== REMOVE_BREAKPOINT
)
1829 unordered_remove (record_full_breakpoints
, iter
);
1834 gdb_assert_not_reached ("removing unknown breakpoint");
1837 /* "can_execute_reverse" method for process record target. */
1840 record_full_base_target::can_execute_reverse ()
1845 /* "get_bookmark" method for process record and prec over core. */
1848 record_full_base_target::get_bookmark (const char *args
, int from_tty
)
1852 /* Return stringified form of instruction count. */
1853 if (record_full_list
&& record_full_list
->type
== record_full_end
)
1854 ret
= xstrdup (pulongest (record_full_list
->u
.end
.insn_num
));
1859 fprintf_unfiltered (gdb_stdlog
,
1860 "record_full_get_bookmark returns %s\n", ret
);
1862 fprintf_unfiltered (gdb_stdlog
,
1863 "record_full_get_bookmark returns NULL\n");
1865 return (gdb_byte
*) ret
;
1868 /* "goto_bookmark" method for process record and prec over core. */
1871 record_full_base_target::goto_bookmark (const gdb_byte
*raw_bookmark
,
1874 const char *bookmark
= (const char *) raw_bookmark
;
1877 fprintf_unfiltered (gdb_stdlog
,
1878 "record_full_goto_bookmark receives %s\n", bookmark
);
1880 std::string name_holder
;
1881 if (bookmark
[0] == '\'' || bookmark
[0] == '\"')
1883 if (bookmark
[strlen (bookmark
) - 1] != bookmark
[0])
1884 error (_("Unbalanced quotes: %s"), bookmark
);
1886 name_holder
= std::string (bookmark
+ 1, strlen (bookmark
) - 2);
1887 bookmark
= name_holder
.c_str ();
1890 record_goto (bookmark
);
1893 enum exec_direction_kind
1894 record_full_base_target::execution_direction ()
1896 return record_full_execution_dir
;
1899 /* The record_method method of target record-full. */
1902 record_full_base_target::record_method (ptid_t ptid
)
1904 return RECORD_METHOD_FULL
;
1908 record_full_base_target::info_record ()
1910 struct record_full_entry
*p
;
1912 if (RECORD_FULL_IS_REPLAY
)
1913 printf_filtered (_("Replay mode:\n"));
1915 printf_filtered (_("Record mode:\n"));
1917 /* Find entry for first actual instruction in the log. */
1918 for (p
= record_full_first
.next
;
1919 p
!= NULL
&& p
->type
!= record_full_end
;
1923 /* Do we have a log at all? */
1924 if (p
!= NULL
&& p
->type
== record_full_end
)
1926 /* Display instruction number for first instruction in the log. */
1927 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1928 pulongest (p
->u
.end
.insn_num
));
1930 /* If in replay mode, display where we are in the log. */
1931 if (RECORD_FULL_IS_REPLAY
)
1932 printf_filtered (_("Current instruction number is %s.\n"),
1933 pulongest (record_full_list
->u
.end
.insn_num
));
1935 /* Display instruction number for last instruction in the log. */
1936 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1937 pulongest (record_full_insn_count
));
1939 /* Display log count. */
1940 printf_filtered (_("Log contains %u instructions.\n"),
1941 record_full_insn_num
);
1944 printf_filtered (_("No instructions have been logged.\n"));
1946 /* Display max log size. */
1947 printf_filtered (_("Max logged instructions is %u.\n"),
1948 record_full_insn_max_num
);
1952 record_full_base_target::supports_delete_record ()
1957 /* The "delete_record" target method. */
1960 record_full_base_target::delete_record ()
1962 record_full_list_release_following (record_full_list
);
1965 /* The "record_is_replaying" target method. */
1968 record_full_base_target::record_is_replaying (ptid_t ptid
)
1970 return RECORD_FULL_IS_REPLAY
;
1973 /* The "record_will_replay" target method. */
1976 record_full_base_target::record_will_replay (ptid_t ptid
, int dir
)
1978 /* We can currently only record when executing forwards. Should we be able
1979 to record when executing backwards on targets that support reverse
1980 execution, this needs to be changed. */
1982 return RECORD_FULL_IS_REPLAY
|| dir
== EXEC_REVERSE
;
1985 /* Go to a specific entry. */
1988 record_full_goto_entry (struct record_full_entry
*p
)
1991 error (_("Target insn not found."));
1992 else if (p
== record_full_list
)
1993 error (_("Already at target insn."));
1994 else if (p
->u
.end
.insn_num
> record_full_list
->u
.end
.insn_num
)
1996 printf_filtered (_("Go forward to insn number %s\n"),
1997 pulongest (p
->u
.end
.insn_num
));
1998 record_full_goto_insn (p
, EXEC_FORWARD
);
2002 printf_filtered (_("Go backward to insn number %s\n"),
2003 pulongest (p
->u
.end
.insn_num
));
2004 record_full_goto_insn (p
, EXEC_REVERSE
);
2007 registers_changed ();
2008 reinit_frame_cache ();
2009 inferior_thread ()->suspend
.stop_pc
2010 = regcache_read_pc (get_current_regcache ());
2011 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2014 /* The "goto_record_begin" target method. */
2017 record_full_base_target::goto_record_begin ()
2019 struct record_full_entry
*p
= NULL
;
2021 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
2022 if (p
->type
== record_full_end
)
2025 record_full_goto_entry (p
);
2028 /* The "goto_record_end" target method. */
2031 record_full_base_target::goto_record_end ()
2033 struct record_full_entry
*p
= NULL
;
2035 for (p
= record_full_list
; p
->next
!= NULL
; p
= p
->next
)
2037 for (; p
!= NULL
; p
= p
->prev
)
2038 if (p
->type
== record_full_end
)
2041 record_full_goto_entry (p
);
2044 /* The "goto_record" target method. */
2047 record_full_base_target::goto_record (ULONGEST target_insn
)
2049 struct record_full_entry
*p
= NULL
;
2051 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
2052 if (p
->type
== record_full_end
&& p
->u
.end
.insn_num
== target_insn
)
2055 record_full_goto_entry (p
);
2058 /* The "record_stop_replaying" target method. */
2061 record_full_base_target::record_stop_replaying ()
2066 /* "resume" method for prec over corefile. */
2069 record_full_core_target::resume (ptid_t ptid
, int step
,
2070 enum gdb_signal signal
)
2072 record_full_resume_step
= step
;
2073 record_full_resumed
= 1;
2074 record_full_execution_dir
= ::execution_direction
;
2076 /* We are about to start executing the inferior (or simulate it),
2077 let's register it with the event loop. */
2078 if (target_can_async_p ())
2082 /* "kill" method for prec over corefile. */
2085 record_full_core_target::kill ()
2088 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_core_kill\n");
2090 unpush_target (this);
2093 /* "fetch_registers" method for prec over corefile. */
2096 record_full_core_target::fetch_registers (struct regcache
*regcache
,
2101 int num
= gdbarch_num_regs (regcache
->arch ());
2104 for (i
= 0; i
< num
; i
++)
2105 regcache
->raw_supply (i
, *record_full_core_regbuf
);
2108 regcache
->raw_supply (regno
, *record_full_core_regbuf
);
2111 /* "prepare_to_store" method for prec over corefile. */
2114 record_full_core_target::prepare_to_store (struct regcache
*regcache
)
2118 /* "store_registers" method for prec over corefile. */
2121 record_full_core_target::store_registers (struct regcache
*regcache
,
2124 if (record_full_gdb_operation_disable
)
2125 record_full_core_regbuf
->raw_supply (regno
, *regcache
);
2127 error (_("You can't do that without a process to debug."));
2130 /* "xfer_partial" method for prec over corefile. */
2132 enum target_xfer_status
2133 record_full_core_target::xfer_partial (enum target_object object
,
2134 const char *annex
, gdb_byte
*readbuf
,
2135 const gdb_byte
*writebuf
, ULONGEST offset
,
2136 ULONGEST len
, ULONGEST
*xfered_len
)
2138 if (object
== TARGET_OBJECT_MEMORY
)
2140 if (record_full_gdb_operation_disable
|| !writebuf
)
2142 struct target_section
*p
;
2144 for (p
= record_full_core_start
; p
< record_full_core_end
; p
++)
2146 if (offset
>= p
->addr
)
2148 struct record_full_core_buf_entry
*entry
;
2149 ULONGEST sec_offset
;
2151 if (offset
>= p
->endaddr
)
2154 if (offset
+ len
> p
->endaddr
)
2155 len
= p
->endaddr
- offset
;
2157 sec_offset
= offset
- p
->addr
;
2159 /* Read readbuf or write writebuf p, offset, len. */
2161 if (p
->the_bfd_section
->flags
& SEC_CONSTRUCTOR
2162 || (p
->the_bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2165 memset (readbuf
, 0, len
);
2168 return TARGET_XFER_OK
;
2170 /* Get record_full_core_buf_entry. */
2171 for (entry
= record_full_core_buf_list
; entry
;
2172 entry
= entry
->prev
)
2179 /* Add a new entry. */
2180 entry
= XNEW (struct record_full_core_buf_entry
);
2182 if (!bfd_malloc_and_get_section
2183 (p
->the_bfd_section
->owner
,
2188 return TARGET_XFER_EOF
;
2190 entry
->prev
= record_full_core_buf_list
;
2191 record_full_core_buf_list
= entry
;
2194 memcpy (entry
->buf
+ sec_offset
, writebuf
,
2200 return this->beneath ()->xfer_partial (object
, annex
,
2205 memcpy (readbuf
, entry
->buf
+ sec_offset
,
2210 return TARGET_XFER_OK
;
2214 return TARGET_XFER_E_IO
;
2217 error (_("You can't do that without a process to debug."));
2220 return this->beneath ()->xfer_partial (object
, annex
,
2221 readbuf
, writebuf
, offset
, len
,
2225 /* "insert_breakpoint" method for prec over corefile. */
2228 record_full_core_target::insert_breakpoint (struct gdbarch
*gdbarch
,
2229 struct bp_target_info
*bp_tgt
)
2234 /* "remove_breakpoint" method for prec over corefile. */
2237 record_full_core_target::remove_breakpoint (struct gdbarch
*gdbarch
,
2238 struct bp_target_info
*bp_tgt
,
2239 enum remove_bp_reason reason
)
2244 /* "has_execution" method for prec over corefile. */
2247 record_full_core_target::has_execution (ptid_t the_ptid
)
2252 /* Record log save-file format
2253 Version 1 (never released)
2256 4 bytes: magic number htonl(0x20090829).
2257 NOTE: be sure to change whenever this file format changes!
2261 1 byte: record type (record_full_end, see enum record_full_type).
2263 1 byte: record type (record_full_reg, see enum record_full_type).
2264 8 bytes: register id (network byte order).
2265 MAX_REGISTER_SIZE bytes: register value.
2267 1 byte: record type (record_full_mem, see enum record_full_type).
2268 8 bytes: memory length (network byte order).
2269 8 bytes: memory address (network byte order).
2270 n bytes: memory value (n == memory length).
2273 4 bytes: magic number netorder32(0x20091016).
2274 NOTE: be sure to change whenever this file format changes!
2278 1 byte: record type (record_full_end, see enum record_full_type).
2280 4 bytes: instruction count
2282 1 byte: record type (record_full_reg, see enum record_full_type).
2283 4 bytes: register id (network byte order).
2284 n bytes: register value (n == actual register size).
2285 (eg. 4 bytes for x86 general registers).
2287 1 byte: record type (record_full_mem, see enum record_full_type).
2288 4 bytes: memory length (network byte order).
2289 8 bytes: memory address (network byte order).
2290 n bytes: memory value (n == memory length).
2294 /* bfdcore_read -- read bytes from a core file section. */
2297 bfdcore_read (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2299 int ret
= bfd_get_section_contents (obfd
, osec
, buf
, *offset
, len
);
2304 error (_("Failed to read %d bytes from core file %s ('%s')."),
2305 len
, bfd_get_filename (obfd
),
2306 bfd_errmsg (bfd_get_error ()));
2309 static inline uint64_t
2310 netorder64 (uint64_t input
)
2314 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2315 BFD_ENDIAN_BIG
, input
);
2319 static inline uint32_t
2320 netorder32 (uint32_t input
)
2324 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2325 BFD_ENDIAN_BIG
, input
);
2329 /* Restore the execution log from a core_bfd file. */
2331 record_full_restore (void)
2334 struct record_full_entry
*rec
;
2338 struct regcache
*regcache
;
2340 /* We restore the execution log from the open core bfd,
2342 if (core_bfd
== NULL
)
2345 /* "record_full_restore" can only be called when record list is empty. */
2346 gdb_assert (record_full_first
.next
== NULL
);
2349 fprintf_unfiltered (gdb_stdlog
, "Restoring recording from core file.\n");
2351 /* Now need to find our special note section. */
2352 osec
= bfd_get_section_by_name (core_bfd
, "null0");
2354 fprintf_unfiltered (gdb_stdlog
, "Find precord section %s.\n",
2355 osec
? "succeeded" : "failed");
2358 osec_size
= bfd_section_size (osec
);
2360 fprintf_unfiltered (gdb_stdlog
, "%s", bfd_section_name (osec
));
2362 /* Check the magic code. */
2363 bfdcore_read (core_bfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2364 if (magic
!= RECORD_FULL_FILE_MAGIC
)
2365 error (_("Version mis-match or file format error in core file %s."),
2366 bfd_get_filename (core_bfd
));
2368 fprintf_unfiltered (gdb_stdlog
,
2369 " Reading 4-byte magic cookie "
2370 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2371 phex_nz (netorder32 (magic
), 4));
2373 /* Restore the entries in recfd into record_full_arch_list_head and
2374 record_full_arch_list_tail. */
2375 record_full_arch_list_head
= NULL
;
2376 record_full_arch_list_tail
= NULL
;
2377 record_full_insn_num
= 0;
2381 regcache
= get_current_regcache ();
2386 uint32_t regnum
, len
, signal
, count
;
2389 /* We are finished when offset reaches osec_size. */
2390 if (bfd_offset
>= osec_size
)
2392 bfdcore_read (core_bfd
, osec
, &rectype
, sizeof (rectype
), &bfd_offset
);
2396 case record_full_reg
: /* reg */
2397 /* Get register number to regnum. */
2398 bfdcore_read (core_bfd
, osec
, ®num
,
2399 sizeof (regnum
), &bfd_offset
);
2400 regnum
= netorder32 (regnum
);
2402 rec
= record_full_reg_alloc (regcache
, regnum
);
2405 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2406 rec
->u
.reg
.len
, &bfd_offset
);
2409 fprintf_unfiltered (gdb_stdlog
,
2410 " Reading register %d (1 "
2411 "plus %lu plus %d bytes)\n",
2413 (unsigned long) sizeof (regnum
),
2417 case record_full_mem
: /* mem */
2419 bfdcore_read (core_bfd
, osec
, &len
,
2420 sizeof (len
), &bfd_offset
);
2421 len
= netorder32 (len
);
2424 bfdcore_read (core_bfd
, osec
, &addr
,
2425 sizeof (addr
), &bfd_offset
);
2426 addr
= netorder64 (addr
);
2428 rec
= record_full_mem_alloc (addr
, len
);
2431 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2432 rec
->u
.mem
.len
, &bfd_offset
);
2435 fprintf_unfiltered (gdb_stdlog
,
2436 " Reading memory %s (1 plus "
2437 "%lu plus %lu plus %d bytes)\n",
2438 paddress (get_current_arch (),
2440 (unsigned long) sizeof (addr
),
2441 (unsigned long) sizeof (len
),
2445 case record_full_end
: /* end */
2446 rec
= record_full_end_alloc ();
2447 record_full_insn_num
++;
2449 /* Get signal value. */
2450 bfdcore_read (core_bfd
, osec
, &signal
,
2451 sizeof (signal
), &bfd_offset
);
2452 signal
= netorder32 (signal
);
2453 rec
->u
.end
.sigval
= (enum gdb_signal
) signal
;
2455 /* Get insn count. */
2456 bfdcore_read (core_bfd
, osec
, &count
,
2457 sizeof (count
), &bfd_offset
);
2458 count
= netorder32 (count
);
2459 rec
->u
.end
.insn_num
= count
;
2460 record_full_insn_count
= count
+ 1;
2462 fprintf_unfiltered (gdb_stdlog
,
2463 " Reading record_full_end (1 + "
2464 "%lu + %lu bytes), offset == %s\n",
2465 (unsigned long) sizeof (signal
),
2466 (unsigned long) sizeof (count
),
2467 paddress (get_current_arch (),
2472 error (_("Bad entry type in core file %s."),
2473 bfd_get_filename (core_bfd
));
2477 /* Add rec to record arch list. */
2478 record_full_arch_list_add (rec
);
2481 catch (const gdb_exception
&ex
)
2483 record_full_list_release (record_full_arch_list_tail
);
2487 /* Add record_full_arch_list_head to the end of record list. */
2488 record_full_first
.next
= record_full_arch_list_head
;
2489 record_full_arch_list_head
->prev
= &record_full_first
;
2490 record_full_arch_list_tail
->next
= NULL
;
2491 record_full_list
= &record_full_first
;
2493 /* Update record_full_insn_max_num. */
2494 if (record_full_insn_num
> record_full_insn_max_num
)
2496 record_full_insn_max_num
= record_full_insn_num
;
2497 warning (_("Auto increase record/replay buffer limit to %u."),
2498 record_full_insn_max_num
);
2502 printf_filtered (_("Restored records from core file %s.\n"),
2503 bfd_get_filename (core_bfd
));
2505 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2508 /* bfdcore_write -- write bytes into a core file section. */
2511 bfdcore_write (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2513 int ret
= bfd_set_section_contents (obfd
, osec
, buf
, *offset
, len
);
2518 error (_("Failed to write %d bytes to core file %s ('%s')."),
2519 len
, bfd_get_filename (obfd
),
2520 bfd_errmsg (bfd_get_error ()));
2523 /* Restore the execution log from a file. We use a modified elf
2524 corefile format, with an extra section for our data. */
2527 cmd_record_full_restore (const char *args
, int from_tty
)
2529 core_file_command (args
, from_tty
);
2530 record_full_open (args
, from_tty
);
2533 /* Save the execution log to a file. We use a modified elf corefile
2534 format, with an extra section for our data. */
2537 record_full_base_target::save_record (const char *recfilename
)
2539 struct record_full_entry
*cur_record_full_list
;
2541 struct regcache
*regcache
;
2542 struct gdbarch
*gdbarch
;
2544 asection
*osec
= NULL
;
2547 /* Open the save file. */
2549 fprintf_unfiltered (gdb_stdlog
, "Saving execution log to core file '%s'\n",
2552 /* Open the output file. */
2553 gdb_bfd_ref_ptr
obfd (create_gcore_bfd (recfilename
));
2555 /* Arrange to remove the output file on failure. */
2556 gdb::unlinker
unlink_file (recfilename
);
2558 /* Save the current record entry to "cur_record_full_list". */
2559 cur_record_full_list
= record_full_list
;
2561 /* Get the values of regcache and gdbarch. */
2562 regcache
= get_current_regcache ();
2563 gdbarch
= regcache
->arch ();
2565 /* Disable the GDB operation record. */
2566 scoped_restore restore_operation_disable
2567 = record_full_gdb_operation_disable_set ();
2569 /* Reverse execute to the begin of record list. */
2572 /* Check for beginning and end of log. */
2573 if (record_full_list
== &record_full_first
)
2576 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2578 if (record_full_list
->prev
)
2579 record_full_list
= record_full_list
->prev
;
2582 /* Compute the size needed for the extra bfd section. */
2583 save_size
= 4; /* magic cookie */
2584 for (record_full_list
= record_full_first
.next
; record_full_list
;
2585 record_full_list
= record_full_list
->next
)
2586 switch (record_full_list
->type
)
2588 case record_full_end
:
2589 save_size
+= 1 + 4 + 4;
2591 case record_full_reg
:
2592 save_size
+= 1 + 4 + record_full_list
->u
.reg
.len
;
2594 case record_full_mem
:
2595 save_size
+= 1 + 4 + 8 + record_full_list
->u
.mem
.len
;
2599 /* Make the new bfd section. */
2600 osec
= bfd_make_section_anyway_with_flags (obfd
.get (), "precord",
2604 error (_("Failed to create 'precord' section for corefile %s: %s"),
2606 bfd_errmsg (bfd_get_error ()));
2607 bfd_set_section_size (osec
, save_size
);
2608 bfd_set_section_vma (osec
, 0);
2609 bfd_set_section_alignment (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");