1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2018 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"
24 #include "event-top.h"
25 #include "completer.h"
26 #include "arch-utils.h"
30 #include "record-full.h"
33 #include "event-loop.h"
36 #include "observable.h"
38 #include "common/gdb_unlinker.h"
39 #include "common/byte-vector.h"
43 /* This module implements "target record-full", also known as "process
44 record and replay". This target sits on top of a "normal" target
45 (a target that "has execution"), and provides a record and replay
46 functionality, including reverse debugging.
48 Target record has two modes: recording, and replaying.
50 In record mode, we intercept the resume and wait methods.
51 Whenever gdb resumes the target, we run the target in single step
52 mode, and we build up an execution log in which, for each executed
53 instruction, we record all changes in memory and register state.
54 This is invisible to the user, to whom it just looks like an
55 ordinary debugging session (except for performance degredation).
57 In replay mode, instead of actually letting the inferior run as a
58 process, we simulate its execution by playing back the recorded
59 execution log. For each instruction in the log, we simulate the
60 instruction's side effects by duplicating the changes that it would
61 have made on memory and registers. */
63 #define DEFAULT_RECORD_FULL_INSN_MAX_NUM 200000
65 #define RECORD_FULL_IS_REPLAY \
66 (record_full_list->next || ::execution_direction == EXEC_REVERSE)
68 #define RECORD_FULL_FILE_MAGIC netorder32(0x20091016)
70 /* These are the core structs of the process record functionality.
72 A record_full_entry is a record of the value change of a register
73 ("record_full_reg") or a part of memory ("record_full_mem"). And each
74 instruction must have a struct record_full_entry ("record_full_end")
75 that indicates that this is the last struct record_full_entry of this
78 Each struct record_full_entry is linked to "record_full_list" by "prev"
79 and "next" pointers. */
81 struct record_full_mem_entry
85 /* Set this flag if target memory for this entry
86 can no longer be accessed. */
87 int mem_entry_not_accessible
;
91 gdb_byte buf
[sizeof (gdb_byte
*)];
95 struct record_full_reg_entry
102 gdb_byte buf
[2 * sizeof (gdb_byte
*)];
106 struct record_full_end_entry
108 enum gdb_signal sigval
;
112 enum record_full_type
119 /* This is the data structure that makes up the execution log.
121 The execution log consists of a single linked list of entries
122 of type "struct record_full_entry". It is doubly linked so that it
123 can be traversed in either direction.
125 The start of the list is anchored by a struct called
126 "record_full_first". The pointer "record_full_list" either points
127 to the last entry that was added to the list (in record mode), or to
128 the next entry in the list that will be executed (in replay mode).
130 Each list element (struct record_full_entry), in addition to next
131 and prev pointers, consists of a union of three entry types: mem,
132 reg, and end. A field called "type" determines which entry type is
133 represented by a given list element.
135 Each instruction that is added to the execution log is represented
136 by a variable number of list elements ('entries'). The instruction
137 will have one "reg" entry for each register that is changed by
138 executing the instruction (including the PC in every case). It
139 will also have one "mem" entry for each memory change. Finally,
140 each instruction will have an "end" entry that separates it from
141 the changes associated with the next instruction. */
143 struct record_full_entry
145 struct record_full_entry
*prev
;
146 struct record_full_entry
*next
;
147 enum record_full_type type
;
151 struct record_full_reg_entry reg
;
153 struct record_full_mem_entry mem
;
155 struct record_full_end_entry end
;
159 /* If true, query if PREC cannot record memory
160 change of next instruction. */
161 int record_full_memory_query
= 0;
163 struct record_full_core_buf_entry
165 struct record_full_core_buf_entry
*prev
;
166 struct target_section
*p
;
170 /* Record buf with core target. */
171 static detached_regcache
*record_full_core_regbuf
= NULL
;
172 static struct target_section
*record_full_core_start
;
173 static struct target_section
*record_full_core_end
;
174 static struct record_full_core_buf_entry
*record_full_core_buf_list
= NULL
;
176 /* The following variables are used for managing the linked list that
177 represents the execution log.
179 record_full_first is the anchor that holds down the beginning of
182 record_full_list serves two functions:
183 1) In record mode, it anchors the end of the list.
184 2) In replay mode, it traverses the list and points to
185 the next instruction that must be emulated.
187 record_full_arch_list_head and record_full_arch_list_tail are used
188 to manage a separate list, which is used to build up the change
189 elements of the currently executing instruction during record mode.
190 When this instruction has been completely annotated in the "arch
191 list", it will be appended to the main execution log. */
193 static struct record_full_entry record_full_first
;
194 static struct record_full_entry
*record_full_list
= &record_full_first
;
195 static struct record_full_entry
*record_full_arch_list_head
= NULL
;
196 static struct record_full_entry
*record_full_arch_list_tail
= NULL
;
198 /* 1 ask user. 0 auto delete the last struct record_full_entry. */
199 static int record_full_stop_at_limit
= 1;
200 /* Maximum allowed number of insns in execution log. */
201 static unsigned int record_full_insn_max_num
202 = DEFAULT_RECORD_FULL_INSN_MAX_NUM
;
203 /* Actual count of insns presently in execution log. */
204 static unsigned int record_full_insn_num
= 0;
205 /* Count of insns logged so far (may be larger
206 than count of insns presently in execution log). */
207 static ULONGEST record_full_insn_count
;
209 static const char record_longname
[]
210 = N_("Process record and replay target");
211 static const char record_doc
[]
212 = N_("Log program while executing and replay execution from log.");
214 /* Base class implementing functionality common to both the
215 "record-full" and "record-core" targets. */
217 class record_full_base_target
: public target_ops
220 record_full_base_target ()
221 { to_stratum
= record_stratum
; }
223 const target_info
&info () const override
= 0;
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;
700 record_full_arch_list_cleanups (void *ignore
)
702 record_full_list_release (record_full_arch_list_tail
);
705 /* Before inferior step (when GDB record the running message, inferior
706 only can step), GDB will call this function to record the values to
707 record_full_list. This function will call gdbarch_process_record to
708 record the running message of inferior and set them to
709 record_full_arch_list, and add it to record_full_list. */
712 record_full_message (struct regcache
*regcache
, enum gdb_signal signal
)
715 struct gdbarch
*gdbarch
= regcache
->arch ();
716 struct cleanup
*old_cleanups
717 = make_cleanup (record_full_arch_list_cleanups
, 0);
719 record_full_arch_list_head
= NULL
;
720 record_full_arch_list_tail
= NULL
;
722 /* Check record_full_insn_num. */
723 record_full_check_insn_num ();
725 /* If gdb sends a signal value to target_resume,
726 save it in the 'end' field of the previous instruction.
728 Maybe process record should record what really happened,
729 rather than what gdb pretends has happened.
731 So if Linux delivered the signal to the child process during
732 the record mode, we will record it and deliver it again in
735 If user says "ignore this signal" during the record mode, then
736 it will be ignored again during the replay mode (no matter if
737 the user says something different, like "deliver this signal"
738 during the replay mode).
740 User should understand that nothing he does during the replay
741 mode will change the behavior of the child. If he tries,
742 then that is a user error.
744 But we should still deliver the signal to gdb during the replay,
745 if we delivered it during the recording. Therefore we should
746 record the signal during record_full_wait, not
747 record_full_resume. */
748 if (record_full_list
!= &record_full_first
) /* FIXME better way to check */
750 gdb_assert (record_full_list
->type
== record_full_end
);
751 record_full_list
->u
.end
.sigval
= signal
;
754 if (signal
== GDB_SIGNAL_0
755 || !gdbarch_process_record_signal_p (gdbarch
))
756 ret
= gdbarch_process_record (gdbarch
,
758 regcache_read_pc (regcache
));
760 ret
= gdbarch_process_record_signal (gdbarch
,
765 error (_("Process record: inferior program stopped."));
767 error (_("Process record: failed to record execution log."));
769 discard_cleanups (old_cleanups
);
771 record_full_list
->next
= record_full_arch_list_head
;
772 record_full_arch_list_head
->prev
= record_full_list
;
773 record_full_list
= record_full_arch_list_tail
;
775 if (record_full_insn_num
== record_full_insn_max_num
)
776 record_full_list_release_first ();
778 record_full_insn_num
++;
782 record_full_message_wrapper_safe (struct regcache
*regcache
,
783 enum gdb_signal signal
)
787 record_full_message (regcache
, signal
);
789 CATCH (ex
, RETURN_MASK_ALL
)
791 exception_print (gdb_stderr
, ex
);
799 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
800 doesn't need record. */
802 static int record_full_gdb_operation_disable
= 0;
804 scoped_restore_tmpl
<int>
805 record_full_gdb_operation_disable_set (void)
807 return make_scoped_restore (&record_full_gdb_operation_disable
, 1);
810 /* Flag set to TRUE for target_stopped_by_watchpoint. */
811 static enum target_stop_reason record_full_stop_reason
812 = TARGET_STOPPED_BY_NO_REASON
;
814 /* Execute one instruction from the record log. Each instruction in
815 the log will be represented by an arbitrary sequence of register
816 entries and memory entries, followed by an 'end' entry. */
819 record_full_exec_insn (struct regcache
*regcache
,
820 struct gdbarch
*gdbarch
,
821 struct record_full_entry
*entry
)
825 case record_full_reg
: /* reg */
827 gdb::byte_vector
reg (entry
->u
.reg
.len
);
829 if (record_debug
> 1)
830 fprintf_unfiltered (gdb_stdlog
,
831 "Process record: record_full_reg %s to "
832 "inferior num = %d.\n",
833 host_address_to_string (entry
),
836 regcache
->cooked_read (entry
->u
.reg
.num
, reg
.data ());
837 regcache
->cooked_write (entry
->u
.reg
.num
, record_full_get_loc (entry
));
838 memcpy (record_full_get_loc (entry
), reg
.data (), entry
->u
.reg
.len
);
842 case record_full_mem
: /* mem */
844 /* Nothing to do if the entry is flagged not_accessible. */
845 if (!entry
->u
.mem
.mem_entry_not_accessible
)
847 gdb::byte_vector
mem (entry
->u
.mem
.len
);
849 if (record_debug
> 1)
850 fprintf_unfiltered (gdb_stdlog
,
851 "Process record: record_full_mem %s to "
852 "inferior addr = %s len = %d.\n",
853 host_address_to_string (entry
),
854 paddress (gdbarch
, entry
->u
.mem
.addr
),
857 if (record_read_memory (gdbarch
,
858 entry
->u
.mem
.addr
, mem
.data (),
860 entry
->u
.mem
.mem_entry_not_accessible
= 1;
863 if (target_write_memory (entry
->u
.mem
.addr
,
864 record_full_get_loc (entry
),
867 entry
->u
.mem
.mem_entry_not_accessible
= 1;
869 warning (_("Process record: error writing memory at "
870 "addr = %s len = %d."),
871 paddress (gdbarch
, entry
->u
.mem
.addr
),
876 memcpy (record_full_get_loc (entry
), mem
.data (),
879 /* We've changed memory --- check if a hardware
880 watchpoint should trap. Note that this
881 presently assumes the target beneath supports
882 continuable watchpoints. On non-continuable
883 watchpoints target, we'll want to check this
884 _before_ actually doing the memory change, and
885 not doing the change at all if the watchpoint
887 if (hardware_watchpoint_inserted_in_range
888 (regcache
->aspace (),
889 entry
->u
.mem
.addr
, entry
->u
.mem
.len
))
890 record_full_stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
899 static void record_full_restore (void);
901 /* Asynchronous signal handle registered as event loop source for when
902 we have pending events ready to be passed to the core. */
904 static struct async_event_handler
*record_full_async_inferior_event_token
;
907 record_full_async_inferior_event_handler (gdb_client_data data
)
909 inferior_event_handler (INF_REG_EVENT
, NULL
);
912 /* Open the process record target for 'core' files. */
915 record_full_core_open_1 (const char *name
, int from_tty
)
917 struct regcache
*regcache
= get_current_regcache ();
918 int regnum
= gdbarch_num_regs (regcache
->arch ());
921 /* Get record_full_core_regbuf. */
922 target_fetch_registers (regcache
, -1);
923 record_full_core_regbuf
= new detached_regcache (regcache
->arch (), false);
925 for (i
= 0; i
< regnum
; i
++)
926 record_full_core_regbuf
->raw_supply (i
, *regcache
);
928 /* Get record_full_core_start and record_full_core_end. */
929 if (build_section_table (core_bfd
, &record_full_core_start
,
930 &record_full_core_end
))
932 delete record_full_core_regbuf
;
933 record_full_core_regbuf
= NULL
;
934 error (_("\"%s\": Can't find sections: %s"),
935 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
938 push_target (&record_full_core_ops
);
939 record_full_restore ();
942 /* Open the process record target for 'live' processes. */
945 record_full_open_1 (const char *name
, int from_tty
)
948 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open_1\n");
951 if (!target_has_execution
)
952 error (_("Process record: the program is not being run."));
954 error (_("Process record target can't debug inferior in non-stop mode "
957 if (!gdbarch_process_record_p (target_gdbarch ()))
958 error (_("Process record: the current architecture doesn't support "
959 "record function."));
961 push_target (&record_full_ops
);
964 static void record_full_init_record_breakpoints (void);
966 /* Open the process record target. */
969 record_full_open (const char *name
, int from_tty
)
972 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
977 record_full_insn_num
= 0;
978 record_full_insn_count
= 0;
979 record_full_list
= &record_full_first
;
980 record_full_list
->next
= NULL
;
983 record_full_core_open_1 (name
, from_tty
);
985 record_full_open_1 (name
, from_tty
);
987 /* Register extra event sources in the event loop. */
988 record_full_async_inferior_event_token
989 = create_async_event_handler (record_full_async_inferior_event_handler
,
992 record_full_init_record_breakpoints ();
994 gdb::observers::record_changed
.notify (current_inferior (), 1, "full", NULL
);
997 /* "close" target method. Close the process record target. */
1000 record_full_base_target::close ()
1002 struct record_full_core_buf_entry
*entry
;
1005 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_close\n");
1007 record_full_list_release (record_full_list
);
1009 /* Release record_full_core_regbuf. */
1010 if (record_full_core_regbuf
)
1012 delete record_full_core_regbuf
;
1013 record_full_core_regbuf
= NULL
;
1016 /* Release record_full_core_buf_list. */
1017 if (record_full_core_buf_list
)
1019 for (entry
= record_full_core_buf_list
->prev
; entry
;
1020 entry
= entry
->prev
)
1022 xfree (record_full_core_buf_list
);
1023 record_full_core_buf_list
= entry
;
1025 record_full_core_buf_list
= NULL
;
1028 if (record_full_async_inferior_event_token
)
1029 delete_async_event_handler (&record_full_async_inferior_event_token
);
1032 /* "async" target method. */
1035 record_full_base_target::async (int enable
)
1038 mark_async_event_handler (record_full_async_inferior_event_token
);
1040 clear_async_event_handler (record_full_async_inferior_event_token
);
1042 beneath ()->async (enable
);
1045 static int record_full_resume_step
= 0;
1047 /* True if we've been resumed, and so each record_full_wait call should
1048 advance execution. If this is false, record_full_wait will return a
1049 TARGET_WAITKIND_IGNORE. */
1050 static int record_full_resumed
= 0;
1052 /* The execution direction of the last resume we got. This is
1053 necessary for async mode. Vis (order is not strictly accurate):
1055 1. user has the global execution direction set to forward
1056 2. user does a reverse-step command
1057 3. record_full_resume is called with global execution direction
1058 temporarily switched to reverse
1059 4. GDB's execution direction is reverted back to forward
1060 5. target record notifies event loop there's an event to handle
1061 6. infrun asks the target which direction was it going, and switches
1062 the global execution direction accordingly (to reverse)
1063 7. infrun polls an event out of the record target, and handles it
1064 8. GDB goes back to the event loop, and goto #4.
1066 static enum exec_direction_kind record_full_execution_dir
= EXEC_FORWARD
;
1068 /* "resume" target method. Resume the process record target. */
1071 record_full_target::resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
1073 record_full_resume_step
= step
;
1074 record_full_resumed
= 1;
1075 record_full_execution_dir
= ::execution_direction
;
1077 if (!RECORD_FULL_IS_REPLAY
)
1079 struct gdbarch
*gdbarch
= target_thread_architecture (ptid
);
1081 record_full_message (get_current_regcache (), signal
);
1085 /* This is not hard single step. */
1086 if (!gdbarch_software_single_step_p (gdbarch
))
1088 /* This is a normal continue. */
1093 /* This arch supports soft single step. */
1094 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
1096 /* This is a soft single step. */
1097 record_full_resume_step
= 1;
1100 step
= !insert_single_step_breakpoints (gdbarch
);
1104 /* Make sure the target beneath reports all signals. */
1105 target_pass_signals (0, NULL
);
1107 this->beneath ()->resume (ptid
, step
, signal
);
1110 /* We are about to start executing the inferior (or simulate it),
1111 let's register it with the event loop. */
1112 if (target_can_async_p ())
1116 /* "commit_resume" method for process record target. */
1119 record_full_target::commit_resume ()
1121 if (!RECORD_FULL_IS_REPLAY
)
1122 beneath ()->commit_resume ();
1125 static int record_full_get_sig
= 0;
1127 /* SIGINT signal handler, registered by "wait" method. */
1130 record_full_sig_handler (int signo
)
1133 fprintf_unfiltered (gdb_stdlog
, "Process record: get a signal\n");
1135 /* It will break the running inferior in replay mode. */
1136 record_full_resume_step
= 1;
1138 /* It will let record_full_wait set inferior status to get the signal
1140 record_full_get_sig
= 1;
1144 record_full_wait_cleanups (void *ignore
)
1146 if (execution_direction
== EXEC_REVERSE
)
1148 if (record_full_list
->next
)
1149 record_full_list
= record_full_list
->next
;
1152 record_full_list
= record_full_list
->prev
;
1155 /* "wait" target method for process record target.
1157 In record mode, the target is always run in singlestep mode
1158 (even when gdb says to continue). The wait method intercepts
1159 the stop events and determines which ones are to be passed on to
1160 gdb. Most stop events are just singlestep events that gdb is not
1161 to know about, so the wait method just records them and keeps
1164 In replay mode, this function emulates the recorded execution log,
1165 one instruction at a time (forward or backward), and determines
1169 record_full_wait_1 (struct target_ops
*ops
,
1170 ptid_t ptid
, struct target_waitstatus
*status
,
1173 scoped_restore restore_operation_disable
1174 = record_full_gdb_operation_disable_set ();
1177 fprintf_unfiltered (gdb_stdlog
,
1178 "Process record: record_full_wait "
1179 "record_full_resume_step = %d, "
1180 "record_full_resumed = %d, direction=%s\n",
1181 record_full_resume_step
, record_full_resumed
,
1182 record_full_execution_dir
== EXEC_FORWARD
1183 ? "forward" : "reverse");
1185 if (!record_full_resumed
)
1187 gdb_assert ((options
& TARGET_WNOHANG
) != 0);
1189 /* No interesting event. */
1190 status
->kind
= TARGET_WAITKIND_IGNORE
;
1191 return minus_one_ptid
;
1194 record_full_get_sig
= 0;
1195 signal (SIGINT
, record_full_sig_handler
);
1197 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1199 if (!RECORD_FULL_IS_REPLAY
&& ops
!= &record_full_core_ops
)
1201 if (record_full_resume_step
)
1203 /* This is a single step. */
1204 return ops
->beneath ()->wait (ptid
, status
, options
);
1208 /* This is not a single step. */
1211 struct gdbarch
*gdbarch
= target_thread_architecture (inferior_ptid
);
1215 struct thread_info
*tp
;
1217 ret
= ops
->beneath ()->wait (ptid
, status
, options
);
1218 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
1221 fprintf_unfiltered (gdb_stdlog
,
1222 "Process record: record_full_wait "
1223 "target beneath not done yet\n");
1227 ALL_NON_EXITED_THREADS (tp
)
1228 delete_single_step_breakpoints (tp
);
1230 if (record_full_resume_step
)
1233 /* Is this a SIGTRAP? */
1234 if (status
->kind
== TARGET_WAITKIND_STOPPED
1235 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1237 struct regcache
*regcache
;
1238 enum target_stop_reason
*stop_reason_p
1239 = &record_full_stop_reason
;
1241 /* Yes -- this is likely our single-step finishing,
1242 but check if there's any reason the core would be
1243 interested in the event. */
1245 registers_changed ();
1246 regcache
= get_current_regcache ();
1247 tmp_pc
= regcache_read_pc (regcache
);
1248 const struct address_space
*aspace
= regcache
->aspace ();
1250 if (target_stopped_by_watchpoint ())
1252 /* Always interested in watchpoints. */
1254 else if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1257 /* There is a breakpoint here. Let the core
1262 /* This is a single-step trap. Record the
1263 insn and issue another step.
1264 FIXME: this part can be a random SIGTRAP too.
1265 But GDB cannot handle it. */
1268 if (!record_full_message_wrapper_safe (regcache
,
1271 status
->kind
= TARGET_WAITKIND_STOPPED
;
1272 status
->value
.sig
= GDB_SIGNAL_0
;
1276 if (gdbarch_software_single_step_p (gdbarch
))
1278 /* Try to insert the software single step breakpoint.
1279 If insert success, set step to 0. */
1280 set_executing (inferior_ptid
, 0);
1281 reinit_frame_cache ();
1283 step
= !insert_single_step_breakpoints (gdbarch
);
1285 set_executing (inferior_ptid
, 1);
1289 fprintf_unfiltered (gdb_stdlog
,
1290 "Process record: record_full_wait "
1291 "issuing one more step in the "
1292 "target beneath\n");
1293 ops
->beneath ()->resume (ptid
, step
, GDB_SIGNAL_0
);
1294 ops
->beneath ()->commit_resume ();
1299 /* The inferior is broken by a breakpoint or a signal. */
1308 struct regcache
*regcache
= get_current_regcache ();
1309 struct gdbarch
*gdbarch
= regcache
->arch ();
1310 const struct address_space
*aspace
= regcache
->aspace ();
1311 int continue_flag
= 1;
1312 int first_record_full_end
= 1;
1313 struct cleanup
*old_cleanups
1314 = make_cleanup (record_full_wait_cleanups
, 0);
1317 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1318 status
->kind
= TARGET_WAITKIND_STOPPED
;
1320 /* Check breakpoint when forward execute. */
1321 if (execution_direction
== EXEC_FORWARD
)
1323 tmp_pc
= regcache_read_pc (regcache
);
1324 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1325 &record_full_stop_reason
))
1328 fprintf_unfiltered (gdb_stdlog
,
1329 "Process record: break at %s.\n",
1330 paddress (gdbarch
, tmp_pc
));
1335 /* If GDB is in terminal_inferior mode, it will not get the signal.
1336 And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1337 mode, because inferior will not executed.
1338 Then set it to terminal_ours to make GDB get the signal. */
1339 target_terminal::ours ();
1341 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1343 if (execution_direction
== EXEC_FORWARD
&& record_full_list
->next
)
1344 record_full_list
= record_full_list
->next
;
1346 /* Loop over the record_full_list, looking for the next place to
1350 /* Check for beginning and end of log. */
1351 if (execution_direction
== EXEC_REVERSE
1352 && record_full_list
== &record_full_first
)
1354 /* Hit beginning of record log in reverse. */
1355 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1358 if (execution_direction
!= EXEC_REVERSE
&& !record_full_list
->next
)
1360 /* Hit end of record log going forward. */
1361 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1365 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
1367 if (record_full_list
->type
== record_full_end
)
1369 if (record_debug
> 1)
1370 fprintf_unfiltered (gdb_stdlog
,
1371 "Process record: record_full_end %s to "
1373 host_address_to_string (record_full_list
));
1375 if (first_record_full_end
&& execution_direction
== EXEC_REVERSE
)
1377 /* When reverse excute, the first record_full_end is the
1378 part of current instruction. */
1379 first_record_full_end
= 0;
1383 /* In EXEC_REVERSE mode, this is the record_full_end of prev
1385 In EXEC_FORWARD mode, this is the record_full_end of
1386 current instruction. */
1388 if (record_full_resume_step
)
1390 if (record_debug
> 1)
1391 fprintf_unfiltered (gdb_stdlog
,
1392 "Process record: step.\n");
1396 /* check breakpoint */
1397 tmp_pc
= regcache_read_pc (regcache
);
1398 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1399 &record_full_stop_reason
))
1402 fprintf_unfiltered (gdb_stdlog
,
1403 "Process record: break "
1405 paddress (gdbarch
, tmp_pc
));
1410 if (record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
1413 fprintf_unfiltered (gdb_stdlog
,
1414 "Process record: hit hw "
1418 /* Check target signal */
1419 if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1420 /* FIXME: better way to check */
1427 if (execution_direction
== EXEC_REVERSE
)
1429 if (record_full_list
->prev
)
1430 record_full_list
= record_full_list
->prev
;
1434 if (record_full_list
->next
)
1435 record_full_list
= record_full_list
->next
;
1439 while (continue_flag
);
1442 if (record_full_get_sig
)
1443 status
->value
.sig
= GDB_SIGNAL_INT
;
1444 else if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1445 /* FIXME: better way to check */
1446 status
->value
.sig
= record_full_list
->u
.end
.sigval
;
1448 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1450 discard_cleanups (old_cleanups
);
1453 signal (SIGINT
, handle_sigint
);
1455 return inferior_ptid
;
1459 record_full_base_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1464 return_ptid
= record_full_wait_1 (this, ptid
, status
, options
);
1465 if (status
->kind
!= TARGET_WAITKIND_IGNORE
)
1467 /* We're reporting a stop. Make sure any spurious
1468 target_wait(WNOHANG) doesn't advance the target until the
1469 core wants us resumed again. */
1470 record_full_resumed
= 0;
1476 record_full_base_target::stopped_by_watchpoint ()
1478 if (RECORD_FULL_IS_REPLAY
)
1479 return record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
1481 return beneath ()->stopped_by_watchpoint ();
1485 record_full_base_target::stopped_data_address (CORE_ADDR
*addr_p
)
1487 if (RECORD_FULL_IS_REPLAY
)
1490 return this->beneath ()->stopped_data_address (addr_p
);
1493 /* The stopped_by_sw_breakpoint method of target record-full. */
1496 record_full_base_target::stopped_by_sw_breakpoint ()
1498 return record_full_stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
1501 /* The supports_stopped_by_sw_breakpoint method of target
1505 record_full_base_target::supports_stopped_by_sw_breakpoint ()
1510 /* The stopped_by_hw_breakpoint method of target record-full. */
1513 record_full_base_target::stopped_by_hw_breakpoint ()
1515 return record_full_stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
1518 /* The supports_stopped_by_sw_breakpoint method of target
1522 record_full_base_target::supports_stopped_by_hw_breakpoint ()
1527 /* Record registers change (by user or by GDB) to list as an instruction. */
1530 record_full_registers_change (struct regcache
*regcache
, int regnum
)
1532 /* Check record_full_insn_num. */
1533 record_full_check_insn_num ();
1535 record_full_arch_list_head
= NULL
;
1536 record_full_arch_list_tail
= NULL
;
1542 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
1544 if (record_full_arch_list_add_reg (regcache
, i
))
1546 record_full_list_release (record_full_arch_list_tail
);
1547 error (_("Process record: failed to record execution log."));
1553 if (record_full_arch_list_add_reg (regcache
, regnum
))
1555 record_full_list_release (record_full_arch_list_tail
);
1556 error (_("Process record: failed to record execution log."));
1559 if (record_full_arch_list_add_end ())
1561 record_full_list_release (record_full_arch_list_tail
);
1562 error (_("Process record: failed to record execution log."));
1564 record_full_list
->next
= record_full_arch_list_head
;
1565 record_full_arch_list_head
->prev
= record_full_list
;
1566 record_full_list
= record_full_arch_list_tail
;
1568 if (record_full_insn_num
== record_full_insn_max_num
)
1569 record_full_list_release_first ();
1571 record_full_insn_num
++;
1574 /* "store_registers" method for process record target. */
1577 record_full_target::store_registers (struct regcache
*regcache
, int regno
)
1579 if (!record_full_gdb_operation_disable
)
1581 if (RECORD_FULL_IS_REPLAY
)
1585 /* Let user choose if he wants to write register or not. */
1588 query (_("Because GDB is in replay mode, changing the "
1589 "value of a register will make the execution "
1590 "log unusable from this point onward. "
1591 "Change all registers?"));
1594 query (_("Because GDB is in replay mode, changing the value "
1595 "of a register will make the execution log unusable "
1596 "from this point onward. Change register %s?"),
1597 gdbarch_register_name (regcache
->arch (),
1602 /* Invalidate the value of regcache that was set in function
1603 "regcache_raw_write". */
1609 i
< gdbarch_num_regs (regcache
->arch ());
1611 regcache
->invalidate (i
);
1614 regcache
->invalidate (regno
);
1616 error (_("Process record canceled the operation."));
1619 /* Destroy the record from here forward. */
1620 record_full_list_release_following (record_full_list
);
1623 record_full_registers_change (regcache
, regno
);
1625 this->beneath ()->store_registers (regcache
, regno
);
1628 /* "xfer_partial" method. Behavior is conditional on
1629 RECORD_FULL_IS_REPLAY.
1630 In replay mode, we cannot write memory unles we are willing to
1631 invalidate the record/replay log from this point forward. */
1633 enum target_xfer_status
1634 record_full_target::xfer_partial (enum target_object object
,
1635 const char *annex
, gdb_byte
*readbuf
,
1636 const gdb_byte
*writebuf
, ULONGEST offset
,
1637 ULONGEST len
, ULONGEST
*xfered_len
)
1639 if (!record_full_gdb_operation_disable
1640 && (object
== TARGET_OBJECT_MEMORY
1641 || object
== TARGET_OBJECT_RAW_MEMORY
) && writebuf
)
1643 if (RECORD_FULL_IS_REPLAY
)
1645 /* Let user choose if he wants to write memory or not. */
1646 if (!query (_("Because GDB is in replay mode, writing to memory "
1647 "will make the execution log unusable from this "
1648 "point onward. Write memory at address %s?"),
1649 paddress (target_gdbarch (), offset
)))
1650 error (_("Process record canceled the operation."));
1652 /* Destroy the record from here forward. */
1653 record_full_list_release_following (record_full_list
);
1656 /* Check record_full_insn_num */
1657 record_full_check_insn_num ();
1659 /* Record registers change to list as an instruction. */
1660 record_full_arch_list_head
= NULL
;
1661 record_full_arch_list_tail
= NULL
;
1662 if (record_full_arch_list_add_mem (offset
, len
))
1664 record_full_list_release (record_full_arch_list_tail
);
1666 fprintf_unfiltered (gdb_stdlog
,
1667 "Process record: failed to record "
1669 return TARGET_XFER_E_IO
;
1671 if (record_full_arch_list_add_end ())
1673 record_full_list_release (record_full_arch_list_tail
);
1675 fprintf_unfiltered (gdb_stdlog
,
1676 "Process record: failed to record "
1678 return TARGET_XFER_E_IO
;
1680 record_full_list
->next
= record_full_arch_list_head
;
1681 record_full_arch_list_head
->prev
= record_full_list
;
1682 record_full_list
= record_full_arch_list_tail
;
1684 if (record_full_insn_num
== record_full_insn_max_num
)
1685 record_full_list_release_first ();
1687 record_full_insn_num
++;
1690 return this->beneath ()->xfer_partial (object
, annex
, readbuf
, writebuf
,
1691 offset
, len
, xfered_len
);
1694 /* This structure represents a breakpoint inserted while the record
1695 target is active. We use this to know when to install/remove
1696 breakpoints in/from the target beneath. For example, a breakpoint
1697 may be inserted while recording, but removed when not replaying nor
1698 recording. In that case, the breakpoint had not been inserted on
1699 the target beneath, so we should not try to remove it there. */
1701 struct record_full_breakpoint
1703 /* The address and address space the breakpoint was set at. */
1704 struct address_space
*address_space
;
1707 /* True when the breakpoint has been also installed in the target
1708 beneath. This will be false for breakpoints set during replay or
1710 int in_target_beneath
;
1713 typedef struct record_full_breakpoint
*record_full_breakpoint_p
;
1714 DEF_VEC_P(record_full_breakpoint_p
);
1716 /* The list of breakpoints inserted while the record target is
1718 VEC(record_full_breakpoint_p
) *record_full_breakpoints
= NULL
;
1721 record_full_sync_record_breakpoints (struct bp_location
*loc
, void *data
)
1723 if (loc
->loc_type
!= bp_loc_software_breakpoint
)
1728 struct record_full_breakpoint
*bp
= XNEW (struct record_full_breakpoint
);
1730 bp
->addr
= loc
->target_info
.placed_address
;
1731 bp
->address_space
= loc
->target_info
.placed_address_space
;
1733 bp
->in_target_beneath
= 1;
1735 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1739 /* Sync existing breakpoints to record_full_breakpoints. */
1742 record_full_init_record_breakpoints (void)
1744 VEC_free (record_full_breakpoint_p
, record_full_breakpoints
);
1746 iterate_over_bp_locations (record_full_sync_record_breakpoints
);
1749 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1750 insert or remove breakpoints in the real target when replaying, nor
1754 record_full_target::insert_breakpoint (struct gdbarch
*gdbarch
,
1755 struct bp_target_info
*bp_tgt
)
1757 struct record_full_breakpoint
*bp
;
1758 int in_target_beneath
= 0;
1761 if (!RECORD_FULL_IS_REPLAY
)
1763 /* When recording, we currently always single-step, so we don't
1764 really need to install regular breakpoints in the inferior.
1765 However, we do have to insert software single-step
1766 breakpoints, in case the target can't hardware step. To keep
1767 things simple, we always insert. */
1769 scoped_restore restore_operation_disable
1770 = record_full_gdb_operation_disable_set ();
1772 int ret
= this->beneath ()->insert_breakpoint (gdbarch
, bp_tgt
);
1776 in_target_beneath
= 1;
1779 /* Use the existing entries if found in order to avoid duplication
1780 in record_full_breakpoints. */
1783 VEC_iterate (record_full_breakpoint_p
,
1784 record_full_breakpoints
, ix
, bp
);
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 bp
= XNEW (struct record_full_breakpoint
);
1796 bp
->addr
= bp_tgt
->placed_address
;
1797 bp
->address_space
= bp_tgt
->placed_address_space
;
1798 bp
->in_target_beneath
= in_target_beneath
;
1799 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1803 /* "remove_breakpoint" method for process record target. */
1806 record_full_target::remove_breakpoint (struct gdbarch
*gdbarch
,
1807 struct bp_target_info
*bp_tgt
,
1808 enum remove_bp_reason reason
)
1810 struct record_full_breakpoint
*bp
;
1814 VEC_iterate (record_full_breakpoint_p
,
1815 record_full_breakpoints
, ix
, bp
);
1818 if (bp
->addr
== bp_tgt
->placed_address
1819 && bp
->address_space
== bp_tgt
->placed_address_space
)
1821 if (bp
->in_target_beneath
)
1823 scoped_restore restore_operation_disable
1824 = record_full_gdb_operation_disable_set ();
1826 int ret
= this->beneath ()->remove_breakpoint (gdbarch
, bp_tgt
,
1832 if (reason
== REMOVE_BREAKPOINT
)
1834 VEC_unordered_remove (record_full_breakpoint_p
,
1835 record_full_breakpoints
, ix
);
1841 gdb_assert_not_reached ("removing unknown breakpoint");
1844 /* "can_execute_reverse" method for process record target. */
1847 record_full_base_target::can_execute_reverse ()
1852 /* "get_bookmark" method for process record and prec over core. */
1855 record_full_base_target::get_bookmark (const char *args
, int from_tty
)
1859 /* Return stringified form of instruction count. */
1860 if (record_full_list
&& record_full_list
->type
== record_full_end
)
1861 ret
= xstrdup (pulongest (record_full_list
->u
.end
.insn_num
));
1866 fprintf_unfiltered (gdb_stdlog
,
1867 "record_full_get_bookmark returns %s\n", ret
);
1869 fprintf_unfiltered (gdb_stdlog
,
1870 "record_full_get_bookmark returns NULL\n");
1872 return (gdb_byte
*) ret
;
1875 /* "goto_bookmark" method for process record and prec over core. */
1878 record_full_base_target::goto_bookmark (const gdb_byte
*raw_bookmark
,
1881 const char *bookmark
= (const char *) raw_bookmark
;
1884 fprintf_unfiltered (gdb_stdlog
,
1885 "record_full_goto_bookmark receives %s\n", bookmark
);
1887 std::string name_holder
;
1888 if (bookmark
[0] == '\'' || bookmark
[0] == '\"')
1890 if (bookmark
[strlen (bookmark
) - 1] != bookmark
[0])
1891 error (_("Unbalanced quotes: %s"), bookmark
);
1893 name_holder
= std::string (bookmark
+ 1, strlen (bookmark
) - 2);
1894 bookmark
= name_holder
.c_str ();
1897 record_goto (bookmark
);
1900 enum exec_direction_kind
1901 record_full_base_target::execution_direction ()
1903 return record_full_execution_dir
;
1906 /* The record_method method of target record-full. */
1909 record_full_base_target::record_method (ptid_t ptid
)
1911 return RECORD_METHOD_FULL
;
1915 record_full_base_target::info_record ()
1917 struct record_full_entry
*p
;
1919 if (RECORD_FULL_IS_REPLAY
)
1920 printf_filtered (_("Replay mode:\n"));
1922 printf_filtered (_("Record mode:\n"));
1924 /* Find entry for first actual instruction in the log. */
1925 for (p
= record_full_first
.next
;
1926 p
!= NULL
&& p
->type
!= record_full_end
;
1930 /* Do we have a log at all? */
1931 if (p
!= NULL
&& p
->type
== record_full_end
)
1933 /* Display instruction number for first instruction in the log. */
1934 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1935 pulongest (p
->u
.end
.insn_num
));
1937 /* If in replay mode, display where we are in the log. */
1938 if (RECORD_FULL_IS_REPLAY
)
1939 printf_filtered (_("Current instruction number is %s.\n"),
1940 pulongest (record_full_list
->u
.end
.insn_num
));
1942 /* Display instruction number for last instruction in the log. */
1943 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1944 pulongest (record_full_insn_count
));
1946 /* Display log count. */
1947 printf_filtered (_("Log contains %u instructions.\n"),
1948 record_full_insn_num
);
1951 printf_filtered (_("No instructions have been logged.\n"));
1953 /* Display max log size. */
1954 printf_filtered (_("Max logged instructions is %u.\n"),
1955 record_full_insn_max_num
);
1959 record_full_base_target::supports_delete_record ()
1964 /* The "delete_record" target method. */
1967 record_full_base_target::delete_record ()
1969 record_full_list_release_following (record_full_list
);
1972 /* The "record_is_replaying" target method. */
1975 record_full_base_target::record_is_replaying (ptid_t ptid
)
1977 return RECORD_FULL_IS_REPLAY
;
1980 /* The "record_will_replay" target method. */
1983 record_full_base_target::record_will_replay (ptid_t ptid
, int dir
)
1985 /* We can currently only record when executing forwards. Should we be able
1986 to record when executing backwards on targets that support reverse
1987 execution, this needs to be changed. */
1989 return RECORD_FULL_IS_REPLAY
|| dir
== EXEC_REVERSE
;
1992 /* Go to a specific entry. */
1995 record_full_goto_entry (struct record_full_entry
*p
)
1998 error (_("Target insn not found."));
1999 else if (p
== record_full_list
)
2000 error (_("Already at target insn."));
2001 else if (p
->u
.end
.insn_num
> record_full_list
->u
.end
.insn_num
)
2003 printf_filtered (_("Go forward to insn number %s\n"),
2004 pulongest (p
->u
.end
.insn_num
));
2005 record_full_goto_insn (p
, EXEC_FORWARD
);
2009 printf_filtered (_("Go backward to insn number %s\n"),
2010 pulongest (p
->u
.end
.insn_num
));
2011 record_full_goto_insn (p
, EXEC_REVERSE
);
2014 registers_changed ();
2015 reinit_frame_cache ();
2016 stop_pc
= regcache_read_pc (get_current_regcache ());
2017 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2020 /* The "goto_record_begin" target method. */
2023 record_full_base_target::goto_record_begin ()
2025 struct record_full_entry
*p
= NULL
;
2027 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
2028 if (p
->type
== record_full_end
)
2031 record_full_goto_entry (p
);
2034 /* The "goto_record_end" target method. */
2037 record_full_base_target::goto_record_end ()
2039 struct record_full_entry
*p
= NULL
;
2041 for (p
= record_full_list
; p
->next
!= NULL
; p
= p
->next
)
2043 for (; p
!= NULL
; p
= p
->prev
)
2044 if (p
->type
== record_full_end
)
2047 record_full_goto_entry (p
);
2050 /* The "goto_record" target method. */
2053 record_full_base_target::goto_record (ULONGEST target_insn
)
2055 struct record_full_entry
*p
= NULL
;
2057 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
2058 if (p
->type
== record_full_end
&& p
->u
.end
.insn_num
== target_insn
)
2061 record_full_goto_entry (p
);
2064 /* The "record_stop_replaying" target method. */
2067 record_full_base_target::record_stop_replaying ()
2072 /* "resume" method for prec over corefile. */
2075 record_full_core_target::resume (ptid_t ptid
, int step
,
2076 enum gdb_signal signal
)
2078 record_full_resume_step
= step
;
2079 record_full_resumed
= 1;
2080 record_full_execution_dir
= ::execution_direction
;
2082 /* We are about to start executing the inferior (or simulate it),
2083 let's register it with the event loop. */
2084 if (target_can_async_p ())
2088 /* "kill" method for prec over corefile. */
2091 record_full_core_target::kill ()
2094 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_core_kill\n");
2096 unpush_target (this);
2099 /* "fetch_registers" method for prec over corefile. */
2102 record_full_core_target::fetch_registers (struct regcache
*regcache
,
2107 int num
= gdbarch_num_regs (regcache
->arch ());
2110 for (i
= 0; i
< num
; i
++)
2111 regcache
->raw_supply (i
, *record_full_core_regbuf
);
2114 regcache
->raw_supply (regno
, *record_full_core_regbuf
);
2117 /* "prepare_to_store" method for prec over corefile. */
2120 record_full_core_target::prepare_to_store (struct regcache
*regcache
)
2124 /* "store_registers" method for prec over corefile. */
2127 record_full_core_target::store_registers (struct regcache
*regcache
,
2130 if (record_full_gdb_operation_disable
)
2131 record_full_core_regbuf
->raw_supply (regno
, *regcache
);
2133 error (_("You can't do that without a process to debug."));
2136 /* "xfer_partial" method for prec over corefile. */
2138 enum target_xfer_status
2139 record_full_core_target::xfer_partial (enum target_object object
,
2140 const char *annex
, gdb_byte
*readbuf
,
2141 const gdb_byte
*writebuf
, ULONGEST offset
,
2142 ULONGEST len
, ULONGEST
*xfered_len
)
2144 if (object
== TARGET_OBJECT_MEMORY
)
2146 if (record_full_gdb_operation_disable
|| !writebuf
)
2148 struct target_section
*p
;
2150 for (p
= record_full_core_start
; p
< record_full_core_end
; p
++)
2152 if (offset
>= p
->addr
)
2154 struct record_full_core_buf_entry
*entry
;
2155 ULONGEST sec_offset
;
2157 if (offset
>= p
->endaddr
)
2160 if (offset
+ len
> p
->endaddr
)
2161 len
= p
->endaddr
- offset
;
2163 sec_offset
= offset
- p
->addr
;
2165 /* Read readbuf or write writebuf p, offset, len. */
2167 if (p
->the_bfd_section
->flags
& SEC_CONSTRUCTOR
2168 || (p
->the_bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2171 memset (readbuf
, 0, len
);
2174 return TARGET_XFER_OK
;
2176 /* Get record_full_core_buf_entry. */
2177 for (entry
= record_full_core_buf_list
; entry
;
2178 entry
= entry
->prev
)
2185 /* Add a new entry. */
2186 entry
= XNEW (struct record_full_core_buf_entry
);
2188 if (!bfd_malloc_and_get_section
2189 (p
->the_bfd_section
->owner
,
2194 return TARGET_XFER_EOF
;
2196 entry
->prev
= record_full_core_buf_list
;
2197 record_full_core_buf_list
= entry
;
2200 memcpy (entry
->buf
+ sec_offset
, writebuf
,
2206 return this->beneath ()->xfer_partial (object
, annex
,
2211 memcpy (readbuf
, entry
->buf
+ sec_offset
,
2216 return TARGET_XFER_OK
;
2220 return TARGET_XFER_E_IO
;
2223 error (_("You can't do that without a process to debug."));
2226 return this->beneath ()->xfer_partial (object
, annex
,
2227 readbuf
, writebuf
, offset
, len
,
2231 /* "insert_breakpoint" method for prec over corefile. */
2234 record_full_core_target::insert_breakpoint (struct gdbarch
*gdbarch
,
2235 struct bp_target_info
*bp_tgt
)
2240 /* "remove_breakpoint" method for prec over corefile. */
2243 record_full_core_target::remove_breakpoint (struct gdbarch
*gdbarch
,
2244 struct bp_target_info
*bp_tgt
,
2245 enum remove_bp_reason reason
)
2250 /* "has_execution" method for prec over corefile. */
2253 record_full_core_target::has_execution (ptid_t the_ptid
)
2258 /* Record log save-file format
2259 Version 1 (never released)
2262 4 bytes: magic number htonl(0x20090829).
2263 NOTE: be sure to change whenever this file format changes!
2267 1 byte: record type (record_full_end, see enum record_full_type).
2269 1 byte: record type (record_full_reg, see enum record_full_type).
2270 8 bytes: register id (network byte order).
2271 MAX_REGISTER_SIZE bytes: register value.
2273 1 byte: record type (record_full_mem, see enum record_full_type).
2274 8 bytes: memory length (network byte order).
2275 8 bytes: memory address (network byte order).
2276 n bytes: memory value (n == memory length).
2279 4 bytes: magic number netorder32(0x20091016).
2280 NOTE: be sure to change whenever this file format changes!
2284 1 byte: record type (record_full_end, see enum record_full_type).
2286 4 bytes: instruction count
2288 1 byte: record type (record_full_reg, see enum record_full_type).
2289 4 bytes: register id (network byte order).
2290 n bytes: register value (n == actual register size).
2291 (eg. 4 bytes for x86 general registers).
2293 1 byte: record type (record_full_mem, see enum record_full_type).
2294 4 bytes: memory length (network byte order).
2295 8 bytes: memory address (network byte order).
2296 n bytes: memory value (n == memory length).
2300 /* bfdcore_read -- read bytes from a core file section. */
2303 bfdcore_read (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2305 int ret
= bfd_get_section_contents (obfd
, osec
, buf
, *offset
, len
);
2310 error (_("Failed to read %d bytes from core file %s ('%s')."),
2311 len
, bfd_get_filename (obfd
),
2312 bfd_errmsg (bfd_get_error ()));
2315 static inline uint64_t
2316 netorder64 (uint64_t input
)
2320 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2321 BFD_ENDIAN_BIG
, input
);
2325 static inline uint32_t
2326 netorder32 (uint32_t input
)
2330 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2331 BFD_ENDIAN_BIG
, input
);
2335 /* Restore the execution log from a core_bfd file. */
2337 record_full_restore (void)
2340 struct cleanup
*old_cleanups
;
2341 struct record_full_entry
*rec
;
2345 struct regcache
*regcache
;
2347 /* We restore the execution log from the open core bfd,
2349 if (core_bfd
== NULL
)
2352 /* "record_full_restore" can only be called when record list is empty. */
2353 gdb_assert (record_full_first
.next
== NULL
);
2356 fprintf_unfiltered (gdb_stdlog
, "Restoring recording from core file.\n");
2358 /* Now need to find our special note section. */
2359 osec
= bfd_get_section_by_name (core_bfd
, "null0");
2361 fprintf_unfiltered (gdb_stdlog
, "Find precord section %s.\n",
2362 osec
? "succeeded" : "failed");
2365 osec_size
= bfd_section_size (core_bfd
, osec
);
2367 fprintf_unfiltered (gdb_stdlog
, "%s", bfd_section_name (core_bfd
, osec
));
2369 /* Check the magic code. */
2370 bfdcore_read (core_bfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2371 if (magic
!= RECORD_FULL_FILE_MAGIC
)
2372 error (_("Version mis-match or file format error in core file %s."),
2373 bfd_get_filename (core_bfd
));
2375 fprintf_unfiltered (gdb_stdlog
,
2376 " Reading 4-byte magic cookie "
2377 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2378 phex_nz (netorder32 (magic
), 4));
2380 /* Restore the entries in recfd into record_full_arch_list_head and
2381 record_full_arch_list_tail. */
2382 record_full_arch_list_head
= NULL
;
2383 record_full_arch_list_tail
= NULL
;
2384 record_full_insn_num
= 0;
2385 old_cleanups
= make_cleanup (record_full_arch_list_cleanups
, 0);
2386 regcache
= get_current_regcache ();
2391 uint32_t regnum
, len
, signal
, count
;
2394 /* We are finished when offset reaches osec_size. */
2395 if (bfd_offset
>= osec_size
)
2397 bfdcore_read (core_bfd
, osec
, &rectype
, sizeof (rectype
), &bfd_offset
);
2401 case record_full_reg
: /* reg */
2402 /* Get register number to regnum. */
2403 bfdcore_read (core_bfd
, osec
, ®num
,
2404 sizeof (regnum
), &bfd_offset
);
2405 regnum
= netorder32 (regnum
);
2407 rec
= record_full_reg_alloc (regcache
, regnum
);
2410 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2411 rec
->u
.reg
.len
, &bfd_offset
);
2414 fprintf_unfiltered (gdb_stdlog
,
2415 " Reading register %d (1 "
2416 "plus %lu plus %d bytes)\n",
2418 (unsigned long) sizeof (regnum
),
2422 case record_full_mem
: /* mem */
2424 bfdcore_read (core_bfd
, osec
, &len
,
2425 sizeof (len
), &bfd_offset
);
2426 len
= netorder32 (len
);
2429 bfdcore_read (core_bfd
, osec
, &addr
,
2430 sizeof (addr
), &bfd_offset
);
2431 addr
= netorder64 (addr
);
2433 rec
= record_full_mem_alloc (addr
, len
);
2436 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2437 rec
->u
.mem
.len
, &bfd_offset
);
2440 fprintf_unfiltered (gdb_stdlog
,
2441 " Reading memory %s (1 plus "
2442 "%lu plus %lu plus %d bytes)\n",
2443 paddress (get_current_arch (),
2445 (unsigned long) sizeof (addr
),
2446 (unsigned long) sizeof (len
),
2450 case record_full_end
: /* end */
2451 rec
= record_full_end_alloc ();
2452 record_full_insn_num
++;
2454 /* Get signal value. */
2455 bfdcore_read (core_bfd
, osec
, &signal
,
2456 sizeof (signal
), &bfd_offset
);
2457 signal
= netorder32 (signal
);
2458 rec
->u
.end
.sigval
= (enum gdb_signal
) signal
;
2460 /* Get insn count. */
2461 bfdcore_read (core_bfd
, osec
, &count
,
2462 sizeof (count
), &bfd_offset
);
2463 count
= netorder32 (count
);
2464 rec
->u
.end
.insn_num
= count
;
2465 record_full_insn_count
= count
+ 1;
2467 fprintf_unfiltered (gdb_stdlog
,
2468 " Reading record_full_end (1 + "
2469 "%lu + %lu bytes), offset == %s\n",
2470 (unsigned long) sizeof (signal
),
2471 (unsigned long) sizeof (count
),
2472 paddress (get_current_arch (),
2477 error (_("Bad entry type in core file %s."),
2478 bfd_get_filename (core_bfd
));
2482 /* Add rec to record arch list. */
2483 record_full_arch_list_add (rec
);
2486 discard_cleanups (old_cleanups
);
2488 /* Add record_full_arch_list_head to the end of record list. */
2489 record_full_first
.next
= record_full_arch_list_head
;
2490 record_full_arch_list_head
->prev
= &record_full_first
;
2491 record_full_arch_list_tail
->next
= NULL
;
2492 record_full_list
= &record_full_first
;
2494 /* Update record_full_insn_max_num. */
2495 if (record_full_insn_num
> record_full_insn_max_num
)
2497 record_full_insn_max_num
= record_full_insn_num
;
2498 warning (_("Auto increase record/replay buffer limit to %u."),
2499 record_full_insn_max_num
);
2503 printf_filtered (_("Restored records from core file %s.\n"),
2504 bfd_get_filename (core_bfd
));
2506 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2509 /* bfdcore_write -- write bytes into a core file section. */
2512 bfdcore_write (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2514 int ret
= bfd_set_section_contents (obfd
, osec
, buf
, *offset
, len
);
2519 error (_("Failed to write %d bytes to core file %s ('%s')."),
2520 len
, bfd_get_filename (obfd
),
2521 bfd_errmsg (bfd_get_error ()));
2524 /* Restore the execution log from a file. We use a modified elf
2525 corefile format, with an extra section for our data. */
2528 cmd_record_full_restore (const char *args
, int from_tty
)
2530 core_file_command (args
, from_tty
);
2531 record_full_open (args
, from_tty
);
2534 /* Save the execution log to a file. We use a modified elf corefile
2535 format, with an extra section for our data. */
2538 record_full_base_target::save_record (const char *recfilename
)
2540 struct record_full_entry
*cur_record_full_list
;
2542 struct regcache
*regcache
;
2543 struct gdbarch
*gdbarch
;
2545 asection
*osec
= NULL
;
2548 /* Open the save file. */
2550 fprintf_unfiltered (gdb_stdlog
, "Saving execution log to core file '%s'\n",
2553 /* Open the output file. */
2554 gdb_bfd_ref_ptr
obfd (create_gcore_bfd (recfilename
));
2556 /* Arrange to remove the output file on failure. */
2557 gdb::unlinker
unlink_file (recfilename
);
2559 /* Save the current record entry to "cur_record_full_list". */
2560 cur_record_full_list
= record_full_list
;
2562 /* Get the values of regcache and gdbarch. */
2563 regcache
= get_current_regcache ();
2564 gdbarch
= regcache
->arch ();
2566 /* Disable the GDB operation record. */
2567 scoped_restore restore_operation_disable
2568 = record_full_gdb_operation_disable_set ();
2570 /* Reverse execute to the begin of record list. */
2573 /* Check for beginning and end of log. */
2574 if (record_full_list
== &record_full_first
)
2577 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2579 if (record_full_list
->prev
)
2580 record_full_list
= record_full_list
->prev
;
2583 /* Compute the size needed for the extra bfd section. */
2584 save_size
= 4; /* magic cookie */
2585 for (record_full_list
= record_full_first
.next
; record_full_list
;
2586 record_full_list
= record_full_list
->next
)
2587 switch (record_full_list
->type
)
2589 case record_full_end
:
2590 save_size
+= 1 + 4 + 4;
2592 case record_full_reg
:
2593 save_size
+= 1 + 4 + record_full_list
->u
.reg
.len
;
2595 case record_full_mem
:
2596 save_size
+= 1 + 4 + 8 + record_full_list
->u
.mem
.len
;
2600 /* Make the new bfd section. */
2601 osec
= bfd_make_section_anyway_with_flags (obfd
.get (), "precord",
2605 error (_("Failed to create 'precord' section for corefile %s: %s"),
2607 bfd_errmsg (bfd_get_error ()));
2608 bfd_set_section_size (obfd
.get (), osec
, save_size
);
2609 bfd_set_section_vma (obfd
.get (), osec
, 0);
2610 bfd_set_section_alignment (obfd
.get (), osec
, 0);
2611 bfd_section_lma (obfd
.get (), osec
) = 0;
2613 /* Save corefile state. */
2614 write_gcore_file (obfd
.get ());
2616 /* Write out the record log. */
2617 /* Write the magic code. */
2618 magic
= RECORD_FULL_FILE_MAGIC
;
2620 fprintf_unfiltered (gdb_stdlog
,
2621 " Writing 4-byte magic cookie "
2622 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2623 phex_nz (magic
, 4));
2624 bfdcore_write (obfd
.get (), osec
, &magic
, sizeof (magic
), &bfd_offset
);
2626 /* Save the entries to recfd and forward execute to the end of
2628 record_full_list
= &record_full_first
;
2632 if (record_full_list
!= &record_full_first
)
2635 uint32_t regnum
, len
, signal
, count
;
2638 type
= record_full_list
->type
;
2639 bfdcore_write (obfd
.get (), osec
, &type
, sizeof (type
), &bfd_offset
);
2641 switch (record_full_list
->type
)
2643 case record_full_reg
: /* reg */
2645 fprintf_unfiltered (gdb_stdlog
,
2646 " Writing register %d (1 "
2647 "plus %lu plus %d bytes)\n",
2648 record_full_list
->u
.reg
.num
,
2649 (unsigned long) sizeof (regnum
),
2650 record_full_list
->u
.reg
.len
);
2653 regnum
= netorder32 (record_full_list
->u
.reg
.num
);
2654 bfdcore_write (obfd
.get (), osec
, ®num
,
2655 sizeof (regnum
), &bfd_offset
);
2658 bfdcore_write (obfd
.get (), osec
,
2659 record_full_get_loc (record_full_list
),
2660 record_full_list
->u
.reg
.len
, &bfd_offset
);
2663 case record_full_mem
: /* mem */
2665 fprintf_unfiltered (gdb_stdlog
,
2666 " Writing memory %s (1 plus "
2667 "%lu plus %lu plus %d bytes)\n",
2669 record_full_list
->u
.mem
.addr
),
2670 (unsigned long) sizeof (addr
),
2671 (unsigned long) sizeof (len
),
2672 record_full_list
->u
.mem
.len
);
2675 len
= netorder32 (record_full_list
->u
.mem
.len
);
2676 bfdcore_write (obfd
.get (), osec
, &len
, sizeof (len
),
2679 /* Write memaddr. */
2680 addr
= netorder64 (record_full_list
->u
.mem
.addr
);
2681 bfdcore_write (obfd
.get (), osec
, &addr
,
2682 sizeof (addr
), &bfd_offset
);
2685 bfdcore_write (obfd
.get (), osec
,
2686 record_full_get_loc (record_full_list
),
2687 record_full_list
->u
.mem
.len
, &bfd_offset
);
2690 case record_full_end
:
2692 fprintf_unfiltered (gdb_stdlog
,
2693 " Writing record_full_end (1 + "
2694 "%lu + %lu bytes)\n",
2695 (unsigned long) sizeof (signal
),
2696 (unsigned long) sizeof (count
));
2697 /* Write signal value. */
2698 signal
= netorder32 (record_full_list
->u
.end
.sigval
);
2699 bfdcore_write (obfd
.get (), osec
, &signal
,
2700 sizeof (signal
), &bfd_offset
);
2702 /* Write insn count. */
2703 count
= netorder32 (record_full_list
->u
.end
.insn_num
);
2704 bfdcore_write (obfd
.get (), osec
, &count
,
2705 sizeof (count
), &bfd_offset
);
2710 /* Execute entry. */
2711 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2713 if (record_full_list
->next
)
2714 record_full_list
= record_full_list
->next
;
2719 /* Reverse execute to cur_record_full_list. */
2722 /* Check for beginning and end of log. */
2723 if (record_full_list
== cur_record_full_list
)
2726 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2728 if (record_full_list
->prev
)
2729 record_full_list
= record_full_list
->prev
;
2732 unlink_file
.keep ();
2735 printf_filtered (_("Saved core file %s with execution log.\n"),
2739 /* record_full_goto_insn -- rewind the record log (forward or backward,
2740 depending on DIR) to the given entry, changing the program state
2744 record_full_goto_insn (struct record_full_entry
*entry
,
2745 enum exec_direction_kind dir
)
2747 scoped_restore restore_operation_disable
2748 = record_full_gdb_operation_disable_set ();
2749 struct regcache
*regcache
= get_current_regcache ();
2750 struct gdbarch
*gdbarch
= regcache
->arch ();
2752 /* Assume everything is valid: we will hit the entry,
2753 and we will not hit the end of the recording. */
2755 if (dir
== EXEC_FORWARD
)
2756 record_full_list
= record_full_list
->next
;
2760 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2761 if (dir
== EXEC_REVERSE
)
2762 record_full_list
= record_full_list
->prev
;
2764 record_full_list
= record_full_list
->next
;
2765 } while (record_full_list
!= entry
);
2768 /* Alias for "target record-full". */
2771 cmd_record_full_start (const char *args
, int from_tty
)
2773 execute_command ("target record-full", from_tty
);
2777 set_record_full_insn_max_num (const char *args
, int from_tty
,
2778 struct cmd_list_element
*c
)
2780 if (record_full_insn_num
> record_full_insn_max_num
)
2782 /* Count down record_full_insn_num while releasing records from list. */
2783 while (record_full_insn_num
> record_full_insn_max_num
)
2785 record_full_list_release_first ();
2786 record_full_insn_num
--;
2791 /* The "set record full" command. */
2794 set_record_full_command (const char *args
, int from_tty
)
2796 printf_unfiltered (_("\"set record full\" must be followed "
2797 "by an appropriate subcommand.\n"));
2798 help_list (set_record_full_cmdlist
, "set record full ", all_commands
,
2802 /* The "show record full" command. */
2805 show_record_full_command (const char *args
, int from_tty
)
2807 cmd_show_list (show_record_full_cmdlist
, from_tty
, "");
2811 _initialize_record_full (void)
2813 struct cmd_list_element
*c
;
2815 /* Init record_full_first. */
2816 record_full_first
.prev
= NULL
;
2817 record_full_first
.next
= NULL
;
2818 record_full_first
.type
= record_full_end
;
2820 add_target (record_full_target_info
, record_full_open
);
2821 add_deprecated_target_alias (record_full_target_info
, "record");
2822 add_target (record_full_core_target_info
, record_full_open
);
2824 add_prefix_cmd ("full", class_obscure
, cmd_record_full_start
,
2825 _("Start full execution recording."), &record_full_cmdlist
,
2826 "record full ", 0, &record_cmdlist
);
2828 c
= add_cmd ("restore", class_obscure
, cmd_record_full_restore
,
2829 _("Restore the execution log from a file.\n\
2830 Argument is filename. File must be created with 'record save'."),
2831 &record_full_cmdlist
);
2832 set_cmd_completer (c
, filename_completer
);
2834 /* Deprecate the old version without "full" prefix. */
2835 c
= add_alias_cmd ("restore", "full restore", class_obscure
, 1,
2837 set_cmd_completer (c
, filename_completer
);
2838 deprecate_cmd (c
, "record full restore");
2840 add_prefix_cmd ("full", class_support
, set_record_full_command
,
2841 _("Set record options"), &set_record_full_cmdlist
,
2842 "set record full ", 0, &set_record_cmdlist
);
2844 add_prefix_cmd ("full", class_support
, show_record_full_command
,
2845 _("Show record options"), &show_record_full_cmdlist
,
2846 "show record full ", 0, &show_record_cmdlist
);
2848 /* Record instructions number limit command. */
2849 add_setshow_boolean_cmd ("stop-at-limit", no_class
,
2850 &record_full_stop_at_limit
, _("\
2851 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2852 Show whether record/replay stops when record/replay buffer becomes full."),
2853 _("Default is ON.\n\
2854 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2855 When OFF, if the record/replay buffer becomes full,\n\
2856 delete the oldest recorded instruction to make room for each new one."),
2858 &set_record_full_cmdlist
, &show_record_full_cmdlist
);
2860 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2861 &set_record_cmdlist
);
2862 deprecate_cmd (c
, "set record full stop-at-limit");
2864 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2865 &show_record_cmdlist
);
2866 deprecate_cmd (c
, "show record full stop-at-limit");
2868 add_setshow_uinteger_cmd ("insn-number-max", no_class
,
2869 &record_full_insn_max_num
,
2870 _("Set record/replay buffer limit."),
2871 _("Show record/replay buffer limit."), _("\
2872 Set the maximum number of instructions to be stored in the\n\
2873 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2874 limit. Default is 200000."),
2875 set_record_full_insn_max_num
,
2876 NULL
, &set_record_full_cmdlist
,
2877 &show_record_full_cmdlist
);
2879 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2880 &set_record_cmdlist
);
2881 deprecate_cmd (c
, "set record full insn-number-max");
2883 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2884 &show_record_cmdlist
);
2885 deprecate_cmd (c
, "show record full insn-number-max");
2887 add_setshow_boolean_cmd ("memory-query", no_class
,
2888 &record_full_memory_query
, _("\
2889 Set whether query if PREC cannot record memory change of next instruction."),
2891 Show whether query if PREC cannot record memory change of next instruction."),
2894 When ON, query if PREC cannot record memory change of next instruction."),
2896 &set_record_full_cmdlist
,
2897 &show_record_full_cmdlist
);
2899 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2900 &set_record_cmdlist
);
2901 deprecate_cmd (c
, "set record full memory-query");
2903 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2904 &show_record_cmdlist
);
2905 deprecate_cmd (c
, "show record full memory-query");