1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2017 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"
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 to_resume and to_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 gdb_byte
*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 /* The target_ops of process record. */
210 static struct target_ops record_full_ops
;
211 static struct target_ops record_full_core_ops
;
213 /* See record-full.h. */
216 record_full_is_used (void)
218 struct target_ops
*t
;
220 t
= find_record_target ();
221 return (t
== &record_full_ops
222 || t
== &record_full_core_ops
);
226 /* Command lists for "set/show record full". */
227 static struct cmd_list_element
*set_record_full_cmdlist
;
228 static struct cmd_list_element
*show_record_full_cmdlist
;
230 /* Command list for "record full". */
231 static struct cmd_list_element
*record_full_cmdlist
;
233 static void record_full_goto_insn (struct record_full_entry
*entry
,
234 enum exec_direction_kind dir
);
235 static void record_full_save (struct target_ops
*self
,
236 const char *recfilename
);
238 /* Alloc and free functions for record_full_reg, record_full_mem, and
239 record_full_end entries. */
241 /* Alloc a record_full_reg record entry. */
243 static inline struct record_full_entry
*
244 record_full_reg_alloc (struct regcache
*regcache
, int regnum
)
246 struct record_full_entry
*rec
;
247 struct gdbarch
*gdbarch
= regcache
->arch ();
249 rec
= XCNEW (struct record_full_entry
);
250 rec
->type
= record_full_reg
;
251 rec
->u
.reg
.num
= regnum
;
252 rec
->u
.reg
.len
= register_size (gdbarch
, regnum
);
253 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
254 rec
->u
.reg
.u
.ptr
= (gdb_byte
*) xmalloc (rec
->u
.reg
.len
);
259 /* Free a record_full_reg record entry. */
262 record_full_reg_release (struct record_full_entry
*rec
)
264 gdb_assert (rec
->type
== record_full_reg
);
265 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
266 xfree (rec
->u
.reg
.u
.ptr
);
270 /* Alloc a record_full_mem record entry. */
272 static inline struct record_full_entry
*
273 record_full_mem_alloc (CORE_ADDR addr
, int len
)
275 struct record_full_entry
*rec
;
277 rec
= XCNEW (struct record_full_entry
);
278 rec
->type
= record_full_mem
;
279 rec
->u
.mem
.addr
= addr
;
280 rec
->u
.mem
.len
= len
;
281 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
282 rec
->u
.mem
.u
.ptr
= (gdb_byte
*) xmalloc (len
);
287 /* Free a record_full_mem record entry. */
290 record_full_mem_release (struct record_full_entry
*rec
)
292 gdb_assert (rec
->type
== record_full_mem
);
293 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
294 xfree (rec
->u
.mem
.u
.ptr
);
298 /* Alloc a record_full_end record entry. */
300 static inline struct record_full_entry
*
301 record_full_end_alloc (void)
303 struct record_full_entry
*rec
;
305 rec
= XCNEW (struct record_full_entry
);
306 rec
->type
= record_full_end
;
311 /* Free a record_full_end record entry. */
314 record_full_end_release (struct record_full_entry
*rec
)
319 /* Free one record entry, any type.
320 Return entry->type, in case caller wants to know. */
322 static inline enum record_full_type
323 record_full_entry_release (struct record_full_entry
*rec
)
325 enum record_full_type type
= rec
->type
;
328 case record_full_reg
:
329 record_full_reg_release (rec
);
331 case record_full_mem
:
332 record_full_mem_release (rec
);
334 case record_full_end
:
335 record_full_end_release (rec
);
341 /* Free all record entries in list pointed to by REC. */
344 record_full_list_release (struct record_full_entry
*rec
)
355 record_full_entry_release (rec
->next
);
358 if (rec
== &record_full_first
)
360 record_full_insn_num
= 0;
361 record_full_first
.next
= NULL
;
364 record_full_entry_release (rec
);
367 /* Free all record entries forward of the given list position. */
370 record_full_list_release_following (struct record_full_entry
*rec
)
372 struct record_full_entry
*tmp
= rec
->next
;
378 if (record_full_entry_release (tmp
) == record_full_end
)
380 record_full_insn_num
--;
381 record_full_insn_count
--;
387 /* Delete the first instruction from the beginning of the log, to make
388 room for adding a new instruction at the end of the log.
390 Note -- this function does not modify record_full_insn_num. */
393 record_full_list_release_first (void)
395 struct record_full_entry
*tmp
;
397 if (!record_full_first
.next
)
400 /* Loop until a record_full_end. */
403 /* Cut record_full_first.next out of the linked list. */
404 tmp
= record_full_first
.next
;
405 record_full_first
.next
= tmp
->next
;
406 tmp
->next
->prev
= &record_full_first
;
408 /* tmp is now isolated, and can be deleted. */
409 if (record_full_entry_release (tmp
) == record_full_end
)
410 break; /* End loop at first record_full_end. */
412 if (!record_full_first
.next
)
414 gdb_assert (record_full_insn_num
== 1);
415 break; /* End loop when list is empty. */
420 /* Add a struct record_full_entry to record_full_arch_list. */
423 record_full_arch_list_add (struct record_full_entry
*rec
)
425 if (record_debug
> 1)
426 fprintf_unfiltered (gdb_stdlog
,
427 "Process record: record_full_arch_list_add %s.\n",
428 host_address_to_string (rec
));
430 if (record_full_arch_list_tail
)
432 record_full_arch_list_tail
->next
= rec
;
433 rec
->prev
= record_full_arch_list_tail
;
434 record_full_arch_list_tail
= rec
;
438 record_full_arch_list_head
= rec
;
439 record_full_arch_list_tail
= rec
;
443 /* Return the value storage location of a record entry. */
444 static inline gdb_byte
*
445 record_full_get_loc (struct record_full_entry
*rec
)
448 case record_full_mem
:
449 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
450 return rec
->u
.mem
.u
.ptr
;
452 return rec
->u
.mem
.u
.buf
;
453 case record_full_reg
:
454 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
455 return rec
->u
.reg
.u
.ptr
;
457 return rec
->u
.reg
.u
.buf
;
458 case record_full_end
:
460 gdb_assert_not_reached ("unexpected record_full_entry type");
465 /* Record the value of a register NUM to record_full_arch_list. */
468 record_full_arch_list_add_reg (struct regcache
*regcache
, int regnum
)
470 struct record_full_entry
*rec
;
472 if (record_debug
> 1)
473 fprintf_unfiltered (gdb_stdlog
,
474 "Process record: add register num = %d to "
478 rec
= record_full_reg_alloc (regcache
, regnum
);
480 regcache_raw_read (regcache
, regnum
, record_full_get_loc (rec
));
482 record_full_arch_list_add (rec
);
487 /* Record the value of a region of memory whose address is ADDR and
488 length is LEN to record_full_arch_list. */
491 record_full_arch_list_add_mem (CORE_ADDR addr
, int len
)
493 struct record_full_entry
*rec
;
495 if (record_debug
> 1)
496 fprintf_unfiltered (gdb_stdlog
,
497 "Process record: add mem addr = %s len = %d to "
499 paddress (target_gdbarch (), addr
), len
);
501 if (!addr
) /* FIXME: Why? Some arch must permit it... */
504 rec
= record_full_mem_alloc (addr
, len
);
506 if (record_read_memory (target_gdbarch (), addr
,
507 record_full_get_loc (rec
), len
))
509 record_full_mem_release (rec
);
513 record_full_arch_list_add (rec
);
518 /* Add a record_full_end type struct record_full_entry to
519 record_full_arch_list. */
522 record_full_arch_list_add_end (void)
524 struct record_full_entry
*rec
;
526 if (record_debug
> 1)
527 fprintf_unfiltered (gdb_stdlog
,
528 "Process record: add end to arch list.\n");
530 rec
= record_full_end_alloc ();
531 rec
->u
.end
.sigval
= GDB_SIGNAL_0
;
532 rec
->u
.end
.insn_num
= ++record_full_insn_count
;
534 record_full_arch_list_add (rec
);
540 record_full_check_insn_num (void)
542 if (record_full_insn_num
== record_full_insn_max_num
)
544 /* Ask user what to do. */
545 if (record_full_stop_at_limit
)
547 if (!yquery (_("Do you want to auto delete previous execution "
548 "log entries when record/replay buffer becomes "
549 "full (record full stop-at-limit)?")))
550 error (_("Process record: stopped by user."));
551 record_full_stop_at_limit
= 0;
557 record_full_arch_list_cleanups (void *ignore
)
559 record_full_list_release (record_full_arch_list_tail
);
562 /* Before inferior step (when GDB record the running message, inferior
563 only can step), GDB will call this function to record the values to
564 record_full_list. This function will call gdbarch_process_record to
565 record the running message of inferior and set them to
566 record_full_arch_list, and add it to record_full_list. */
569 record_full_message (struct regcache
*regcache
, enum gdb_signal signal
)
572 struct gdbarch
*gdbarch
= regcache
->arch ();
573 struct cleanup
*old_cleanups
574 = make_cleanup (record_full_arch_list_cleanups
, 0);
576 record_full_arch_list_head
= NULL
;
577 record_full_arch_list_tail
= NULL
;
579 /* Check record_full_insn_num. */
580 record_full_check_insn_num ();
582 /* If gdb sends a signal value to target_resume,
583 save it in the 'end' field of the previous instruction.
585 Maybe process record should record what really happened,
586 rather than what gdb pretends has happened.
588 So if Linux delivered the signal to the child process during
589 the record mode, we will record it and deliver it again in
592 If user says "ignore this signal" during the record mode, then
593 it will be ignored again during the replay mode (no matter if
594 the user says something different, like "deliver this signal"
595 during the replay mode).
597 User should understand that nothing he does during the replay
598 mode will change the behavior of the child. If he tries,
599 then that is a user error.
601 But we should still deliver the signal to gdb during the replay,
602 if we delivered it during the recording. Therefore we should
603 record the signal during record_full_wait, not
604 record_full_resume. */
605 if (record_full_list
!= &record_full_first
) /* FIXME better way to check */
607 gdb_assert (record_full_list
->type
== record_full_end
);
608 record_full_list
->u
.end
.sigval
= signal
;
611 if (signal
== GDB_SIGNAL_0
612 || !gdbarch_process_record_signal_p (gdbarch
))
613 ret
= gdbarch_process_record (gdbarch
,
615 regcache_read_pc (regcache
));
617 ret
= gdbarch_process_record_signal (gdbarch
,
622 error (_("Process record: inferior program stopped."));
624 error (_("Process record: failed to record execution log."));
626 discard_cleanups (old_cleanups
);
628 record_full_list
->next
= record_full_arch_list_head
;
629 record_full_arch_list_head
->prev
= record_full_list
;
630 record_full_list
= record_full_arch_list_tail
;
632 if (record_full_insn_num
== record_full_insn_max_num
)
633 record_full_list_release_first ();
635 record_full_insn_num
++;
639 record_full_message_wrapper_safe (struct regcache
*regcache
,
640 enum gdb_signal signal
)
644 record_full_message (regcache
, signal
);
646 CATCH (ex
, RETURN_MASK_ALL
)
648 exception_print (gdb_stderr
, ex
);
656 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
657 doesn't need record. */
659 static int record_full_gdb_operation_disable
= 0;
661 scoped_restore_tmpl
<int>
662 record_full_gdb_operation_disable_set (void)
664 return make_scoped_restore (&record_full_gdb_operation_disable
, 1);
667 /* Flag set to TRUE for target_stopped_by_watchpoint. */
668 static enum target_stop_reason record_full_stop_reason
669 = TARGET_STOPPED_BY_NO_REASON
;
671 /* Execute one instruction from the record log. Each instruction in
672 the log will be represented by an arbitrary sequence of register
673 entries and memory entries, followed by an 'end' entry. */
676 record_full_exec_insn (struct regcache
*regcache
,
677 struct gdbarch
*gdbarch
,
678 struct record_full_entry
*entry
)
682 case record_full_reg
: /* reg */
684 gdb::byte_vector
reg (entry
->u
.reg
.len
);
686 if (record_debug
> 1)
687 fprintf_unfiltered (gdb_stdlog
,
688 "Process record: record_full_reg %s to "
689 "inferior num = %d.\n",
690 host_address_to_string (entry
),
693 regcache_cooked_read (regcache
, entry
->u
.reg
.num
, reg
.data ());
694 regcache_cooked_write (regcache
, entry
->u
.reg
.num
,
695 record_full_get_loc (entry
));
696 memcpy (record_full_get_loc (entry
), reg
.data (), entry
->u
.reg
.len
);
700 case record_full_mem
: /* mem */
702 /* Nothing to do if the entry is flagged not_accessible. */
703 if (!entry
->u
.mem
.mem_entry_not_accessible
)
705 gdb_byte
*mem
= (gdb_byte
*) xmalloc (entry
->u
.mem
.len
);
706 struct cleanup
*cleanup
= make_cleanup (xfree
, mem
);
708 if (record_debug
> 1)
709 fprintf_unfiltered (gdb_stdlog
,
710 "Process record: record_full_mem %s to "
711 "inferior addr = %s len = %d.\n",
712 host_address_to_string (entry
),
713 paddress (gdbarch
, entry
->u
.mem
.addr
),
716 if (record_read_memory (gdbarch
,
717 entry
->u
.mem
.addr
, mem
, entry
->u
.mem
.len
))
718 entry
->u
.mem
.mem_entry_not_accessible
= 1;
721 if (target_write_memory (entry
->u
.mem
.addr
,
722 record_full_get_loc (entry
),
725 entry
->u
.mem
.mem_entry_not_accessible
= 1;
727 warning (_("Process record: error writing memory at "
728 "addr = %s len = %d."),
729 paddress (gdbarch
, entry
->u
.mem
.addr
),
734 memcpy (record_full_get_loc (entry
), mem
,
737 /* We've changed memory --- check if a hardware
738 watchpoint should trap. Note that this
739 presently assumes the target beneath supports
740 continuable watchpoints. On non-continuable
741 watchpoints target, we'll want to check this
742 _before_ actually doing the memory change, and
743 not doing the change at all if the watchpoint
745 if (hardware_watchpoint_inserted_in_range
746 (regcache
->aspace (),
747 entry
->u
.mem
.addr
, entry
->u
.mem
.len
))
748 record_full_stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
752 do_cleanups (cleanup
);
759 static void record_full_restore (void);
761 /* Asynchronous signal handle registered as event loop source for when
762 we have pending events ready to be passed to the core. */
764 static struct async_event_handler
*record_full_async_inferior_event_token
;
767 record_full_async_inferior_event_handler (gdb_client_data data
)
769 inferior_event_handler (INF_REG_EVENT
, NULL
);
772 /* Open the process record target. */
775 record_full_core_open_1 (const char *name
, int from_tty
)
777 struct regcache
*regcache
= get_current_regcache ();
778 int regnum
= gdbarch_num_regs (regcache
->arch ());
781 /* Get record_full_core_regbuf. */
782 target_fetch_registers (regcache
, -1);
783 record_full_core_regbuf
= (gdb_byte
*) xmalloc (MAX_REGISTER_SIZE
* regnum
);
784 for (i
= 0; i
< regnum
; i
++)
785 regcache_raw_collect (regcache
, i
,
786 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
788 /* Get record_full_core_start and record_full_core_end. */
789 if (build_section_table (core_bfd
, &record_full_core_start
,
790 &record_full_core_end
))
792 xfree (record_full_core_regbuf
);
793 record_full_core_regbuf
= NULL
;
794 error (_("\"%s\": Can't find sections: %s"),
795 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
798 push_target (&record_full_core_ops
);
799 record_full_restore ();
802 /* "to_open" target method for 'live' processes. */
805 record_full_open_1 (const char *name
, int from_tty
)
808 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open_1\n");
811 if (!target_has_execution
)
812 error (_("Process record: the program is not being run."));
814 error (_("Process record target can't debug inferior in non-stop mode "
817 if (!gdbarch_process_record_p (target_gdbarch ()))
818 error (_("Process record: the current architecture doesn't support "
819 "record function."));
821 push_target (&record_full_ops
);
824 static void record_full_init_record_breakpoints (void);
826 /* "to_open" target method. Open the process record target. */
829 record_full_open (const char *name
, int from_tty
)
831 struct target_ops
*t
;
834 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
839 record_full_insn_num
= 0;
840 record_full_insn_count
= 0;
841 record_full_list
= &record_full_first
;
842 record_full_list
->next
= NULL
;
845 record_full_core_open_1 (name
, from_tty
);
847 record_full_open_1 (name
, from_tty
);
849 /* Register extra event sources in the event loop. */
850 record_full_async_inferior_event_token
851 = create_async_event_handler (record_full_async_inferior_event_handler
,
854 record_full_init_record_breakpoints ();
856 observer_notify_record_changed (current_inferior (), 1, "full", NULL
);
859 /* "to_close" target method. Close the process record target. */
862 record_full_close (struct target_ops
*self
)
864 struct record_full_core_buf_entry
*entry
;
867 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_close\n");
869 record_full_list_release (record_full_list
);
871 /* Release record_full_core_regbuf. */
872 if (record_full_core_regbuf
)
874 xfree (record_full_core_regbuf
);
875 record_full_core_regbuf
= NULL
;
878 /* Release record_full_core_buf_list. */
879 if (record_full_core_buf_list
)
881 for (entry
= record_full_core_buf_list
->prev
; entry
;
884 xfree (record_full_core_buf_list
);
885 record_full_core_buf_list
= entry
;
887 record_full_core_buf_list
= NULL
;
890 if (record_full_async_inferior_event_token
)
891 delete_async_event_handler (&record_full_async_inferior_event_token
);
894 /* "to_async" target method. */
897 record_full_async (struct target_ops
*ops
, int enable
)
900 mark_async_event_handler (record_full_async_inferior_event_token
);
902 clear_async_event_handler (record_full_async_inferior_event_token
);
904 ops
->beneath
->to_async (ops
->beneath
, enable
);
907 static int record_full_resume_step
= 0;
909 /* True if we've been resumed, and so each record_full_wait call should
910 advance execution. If this is false, record_full_wait will return a
911 TARGET_WAITKIND_IGNORE. */
912 static int record_full_resumed
= 0;
914 /* The execution direction of the last resume we got. This is
915 necessary for async mode. Vis (order is not strictly accurate):
917 1. user has the global execution direction set to forward
918 2. user does a reverse-step command
919 3. record_full_resume is called with global execution direction
920 temporarily switched to reverse
921 4. GDB's execution direction is reverted back to forward
922 5. target record notifies event loop there's an event to handle
923 6. infrun asks the target which direction was it going, and switches
924 the global execution direction accordingly (to reverse)
925 7. infrun polls an event out of the record target, and handles it
926 8. GDB goes back to the event loop, and goto #4.
928 static enum exec_direction_kind record_full_execution_dir
= EXEC_FORWARD
;
930 /* "to_resume" target method. Resume the process record target. */
933 record_full_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
934 enum gdb_signal signal
)
936 record_full_resume_step
= step
;
937 record_full_resumed
= 1;
938 record_full_execution_dir
= execution_direction
;
940 if (!RECORD_FULL_IS_REPLAY
)
942 struct gdbarch
*gdbarch
= target_thread_architecture (ptid
);
944 record_full_message (get_current_regcache (), signal
);
948 /* This is not hard single step. */
949 if (!gdbarch_software_single_step_p (gdbarch
))
951 /* This is a normal continue. */
956 /* This arch supports soft single step. */
957 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
959 /* This is a soft single step. */
960 record_full_resume_step
= 1;
963 step
= !insert_single_step_breakpoints (gdbarch
);
967 /* Make sure the target beneath reports all signals. */
968 target_pass_signals (0, NULL
);
970 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
, signal
);
973 /* We are about to start executing the inferior (or simulate it),
974 let's register it with the event loop. */
975 if (target_can_async_p ())
979 /* "to_commit_resume" method for process record target. */
982 record_full_commit_resume (struct target_ops
*ops
)
984 if (!RECORD_FULL_IS_REPLAY
)
985 ops
->beneath
->to_commit_resume (ops
->beneath
);
988 static int record_full_get_sig
= 0;
990 /* SIGINT signal handler, registered by "to_wait" method. */
993 record_full_sig_handler (int signo
)
996 fprintf_unfiltered (gdb_stdlog
, "Process record: get a signal\n");
998 /* It will break the running inferior in replay mode. */
999 record_full_resume_step
= 1;
1001 /* It will let record_full_wait set inferior status to get the signal
1003 record_full_get_sig
= 1;
1007 record_full_wait_cleanups (void *ignore
)
1009 if (execution_direction
== EXEC_REVERSE
)
1011 if (record_full_list
->next
)
1012 record_full_list
= record_full_list
->next
;
1015 record_full_list
= record_full_list
->prev
;
1018 /* "to_wait" target method for process record target.
1020 In record mode, the target is always run in singlestep mode
1021 (even when gdb says to continue). The to_wait method intercepts
1022 the stop events and determines which ones are to be passed on to
1023 gdb. Most stop events are just singlestep events that gdb is not
1024 to know about, so the to_wait method just records them and keeps
1027 In replay mode, this function emulates the recorded execution log,
1028 one instruction at a time (forward or backward), and determines
1032 record_full_wait_1 (struct target_ops
*ops
,
1033 ptid_t ptid
, struct target_waitstatus
*status
,
1036 scoped_restore restore_operation_disable
1037 = record_full_gdb_operation_disable_set ();
1040 fprintf_unfiltered (gdb_stdlog
,
1041 "Process record: record_full_wait "
1042 "record_full_resume_step = %d, "
1043 "record_full_resumed = %d, direction=%s\n",
1044 record_full_resume_step
, record_full_resumed
,
1045 record_full_execution_dir
== EXEC_FORWARD
1046 ? "forward" : "reverse");
1048 if (!record_full_resumed
)
1050 gdb_assert ((options
& TARGET_WNOHANG
) != 0);
1052 /* No interesting event. */
1053 status
->kind
= TARGET_WAITKIND_IGNORE
;
1054 return minus_one_ptid
;
1057 record_full_get_sig
= 0;
1058 signal (SIGINT
, record_full_sig_handler
);
1060 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1062 if (!RECORD_FULL_IS_REPLAY
&& ops
!= &record_full_core_ops
)
1064 if (record_full_resume_step
)
1066 /* This is a single step. */
1067 return ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1071 /* This is not a single step. */
1074 struct gdbarch
*gdbarch
= target_thread_architecture (inferior_ptid
);
1078 struct thread_info
*tp
;
1080 ret
= ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1081 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
1084 fprintf_unfiltered (gdb_stdlog
,
1085 "Process record: record_full_wait "
1086 "target beneath not done yet\n");
1090 ALL_NON_EXITED_THREADS (tp
)
1091 delete_single_step_breakpoints (tp
);
1093 if (record_full_resume_step
)
1096 /* Is this a SIGTRAP? */
1097 if (status
->kind
== TARGET_WAITKIND_STOPPED
1098 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1100 struct regcache
*regcache
;
1101 enum target_stop_reason
*stop_reason_p
1102 = &record_full_stop_reason
;
1104 /* Yes -- this is likely our single-step finishing,
1105 but check if there's any reason the core would be
1106 interested in the event. */
1108 registers_changed ();
1109 regcache
= get_current_regcache ();
1110 tmp_pc
= regcache_read_pc (regcache
);
1111 const struct address_space
*aspace
= regcache
->aspace ();
1113 if (target_stopped_by_watchpoint ())
1115 /* Always interested in watchpoints. */
1117 else if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1120 /* There is a breakpoint here. Let the core
1125 /* This is a single-step trap. Record the
1126 insn and issue another step.
1127 FIXME: this part can be a random SIGTRAP too.
1128 But GDB cannot handle it. */
1131 if (!record_full_message_wrapper_safe (regcache
,
1134 status
->kind
= TARGET_WAITKIND_STOPPED
;
1135 status
->value
.sig
= GDB_SIGNAL_0
;
1139 if (gdbarch_software_single_step_p (gdbarch
))
1141 /* Try to insert the software single step breakpoint.
1142 If insert success, set step to 0. */
1143 set_executing (inferior_ptid
, 0);
1144 reinit_frame_cache ();
1146 step
= !insert_single_step_breakpoints (gdbarch
);
1148 set_executing (inferior_ptid
, 1);
1152 fprintf_unfiltered (gdb_stdlog
,
1153 "Process record: record_full_wait "
1154 "issuing one more step in the "
1155 "target beneath\n");
1156 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
,
1158 ops
->beneath
->to_commit_resume (ops
->beneath
);
1163 /* The inferior is broken by a breakpoint or a signal. */
1172 struct regcache
*regcache
= get_current_regcache ();
1173 struct gdbarch
*gdbarch
= regcache
->arch ();
1174 const struct address_space
*aspace
= regcache
->aspace ();
1175 int continue_flag
= 1;
1176 int first_record_full_end
= 1;
1177 struct cleanup
*old_cleanups
1178 = make_cleanup (record_full_wait_cleanups
, 0);
1181 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1182 status
->kind
= TARGET_WAITKIND_STOPPED
;
1184 /* Check breakpoint when forward execute. */
1185 if (execution_direction
== EXEC_FORWARD
)
1187 tmp_pc
= regcache_read_pc (regcache
);
1188 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1189 &record_full_stop_reason
))
1192 fprintf_unfiltered (gdb_stdlog
,
1193 "Process record: break at %s.\n",
1194 paddress (gdbarch
, tmp_pc
));
1199 /* If GDB is in terminal_inferior mode, it will not get the signal.
1200 And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1201 mode, because inferior will not executed.
1202 Then set it to terminal_ours to make GDB get the signal. */
1203 target_terminal::ours ();
1205 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1207 if (execution_direction
== EXEC_FORWARD
&& record_full_list
->next
)
1208 record_full_list
= record_full_list
->next
;
1210 /* Loop over the record_full_list, looking for the next place to
1214 /* Check for beginning and end of log. */
1215 if (execution_direction
== EXEC_REVERSE
1216 && record_full_list
== &record_full_first
)
1218 /* Hit beginning of record log in reverse. */
1219 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1222 if (execution_direction
!= EXEC_REVERSE
&& !record_full_list
->next
)
1224 /* Hit end of record log going forward. */
1225 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1229 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
1231 if (record_full_list
->type
== record_full_end
)
1233 if (record_debug
> 1)
1234 fprintf_unfiltered (gdb_stdlog
,
1235 "Process record: record_full_end %s to "
1237 host_address_to_string (record_full_list
));
1239 if (first_record_full_end
&& execution_direction
== EXEC_REVERSE
)
1241 /* When reverse excute, the first record_full_end is the
1242 part of current instruction. */
1243 first_record_full_end
= 0;
1247 /* In EXEC_REVERSE mode, this is the record_full_end of prev
1249 In EXEC_FORWARD mode, this is the record_full_end of
1250 current instruction. */
1252 if (record_full_resume_step
)
1254 if (record_debug
> 1)
1255 fprintf_unfiltered (gdb_stdlog
,
1256 "Process record: step.\n");
1260 /* check breakpoint */
1261 tmp_pc
= regcache_read_pc (regcache
);
1262 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1263 &record_full_stop_reason
))
1266 fprintf_unfiltered (gdb_stdlog
,
1267 "Process record: break "
1269 paddress (gdbarch
, tmp_pc
));
1274 if (record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
1277 fprintf_unfiltered (gdb_stdlog
,
1278 "Process record: hit hw "
1282 /* Check target signal */
1283 if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1284 /* FIXME: better way to check */
1291 if (execution_direction
== EXEC_REVERSE
)
1293 if (record_full_list
->prev
)
1294 record_full_list
= record_full_list
->prev
;
1298 if (record_full_list
->next
)
1299 record_full_list
= record_full_list
->next
;
1303 while (continue_flag
);
1306 if (record_full_get_sig
)
1307 status
->value
.sig
= GDB_SIGNAL_INT
;
1308 else if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1309 /* FIXME: better way to check */
1310 status
->value
.sig
= record_full_list
->u
.end
.sigval
;
1312 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1314 discard_cleanups (old_cleanups
);
1317 signal (SIGINT
, handle_sigint
);
1319 return inferior_ptid
;
1323 record_full_wait (struct target_ops
*ops
,
1324 ptid_t ptid
, struct target_waitstatus
*status
,
1329 return_ptid
= record_full_wait_1 (ops
, ptid
, status
, options
);
1330 if (status
->kind
!= TARGET_WAITKIND_IGNORE
)
1332 /* We're reporting a stop. Make sure any spurious
1333 target_wait(WNOHANG) doesn't advance the target until the
1334 core wants us resumed again. */
1335 record_full_resumed
= 0;
1341 record_full_stopped_by_watchpoint (struct target_ops
*ops
)
1343 if (RECORD_FULL_IS_REPLAY
)
1344 return record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
1346 return ops
->beneath
->to_stopped_by_watchpoint (ops
->beneath
);
1350 record_full_stopped_data_address (struct target_ops
*ops
, CORE_ADDR
*addr_p
)
1352 if (RECORD_FULL_IS_REPLAY
)
1355 return ops
->beneath
->to_stopped_data_address (ops
->beneath
, addr_p
);
1358 /* The to_stopped_by_sw_breakpoint method of target record-full. */
1361 record_full_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1363 return record_full_stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
1366 /* The to_supports_stopped_by_sw_breakpoint method of target
1370 record_full_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1375 /* The to_stopped_by_hw_breakpoint method of target record-full. */
1378 record_full_stopped_by_hw_breakpoint (struct target_ops
*ops
)
1380 return record_full_stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
1383 /* The to_supports_stopped_by_sw_breakpoint method of target
1387 record_full_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
1392 /* Record registers change (by user or by GDB) to list as an instruction. */
1395 record_full_registers_change (struct regcache
*regcache
, int regnum
)
1397 /* Check record_full_insn_num. */
1398 record_full_check_insn_num ();
1400 record_full_arch_list_head
= NULL
;
1401 record_full_arch_list_tail
= NULL
;
1407 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
1409 if (record_full_arch_list_add_reg (regcache
, i
))
1411 record_full_list_release (record_full_arch_list_tail
);
1412 error (_("Process record: failed to record execution log."));
1418 if (record_full_arch_list_add_reg (regcache
, regnum
))
1420 record_full_list_release (record_full_arch_list_tail
);
1421 error (_("Process record: failed to record execution log."));
1424 if (record_full_arch_list_add_end ())
1426 record_full_list_release (record_full_arch_list_tail
);
1427 error (_("Process record: failed to record execution log."));
1429 record_full_list
->next
= record_full_arch_list_head
;
1430 record_full_arch_list_head
->prev
= record_full_list
;
1431 record_full_list
= record_full_arch_list_tail
;
1433 if (record_full_insn_num
== record_full_insn_max_num
)
1434 record_full_list_release_first ();
1436 record_full_insn_num
++;
1439 /* "to_store_registers" method for process record target. */
1442 record_full_store_registers (struct target_ops
*ops
,
1443 struct regcache
*regcache
,
1446 if (!record_full_gdb_operation_disable
)
1448 if (RECORD_FULL_IS_REPLAY
)
1452 /* Let user choose if he wants to write register or not. */
1455 query (_("Because GDB is in replay mode, changing the "
1456 "value of a register will make the execution "
1457 "log unusable from this point onward. "
1458 "Change all registers?"));
1461 query (_("Because GDB is in replay mode, changing the value "
1462 "of a register will make the execution log unusable "
1463 "from this point onward. Change register %s?"),
1464 gdbarch_register_name (regcache
->arch (),
1469 /* Invalidate the value of regcache that was set in function
1470 "regcache_raw_write". */
1476 i
< gdbarch_num_regs (regcache
->arch ());
1478 regcache_invalidate (regcache
, i
);
1481 regcache_invalidate (regcache
, regno
);
1483 error (_("Process record canceled the operation."));
1486 /* Destroy the record from here forward. */
1487 record_full_list_release_following (record_full_list
);
1490 record_full_registers_change (regcache
, regno
);
1492 ops
->beneath
->to_store_registers (ops
->beneath
, regcache
, regno
);
1495 /* "to_xfer_partial" method. Behavior is conditional on
1496 RECORD_FULL_IS_REPLAY.
1497 In replay mode, we cannot write memory unles we are willing to
1498 invalidate the record/replay log from this point forward. */
1500 static enum target_xfer_status
1501 record_full_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1502 const char *annex
, gdb_byte
*readbuf
,
1503 const gdb_byte
*writebuf
, ULONGEST offset
,
1504 ULONGEST len
, ULONGEST
*xfered_len
)
1506 if (!record_full_gdb_operation_disable
1507 && (object
== TARGET_OBJECT_MEMORY
1508 || object
== TARGET_OBJECT_RAW_MEMORY
) && writebuf
)
1510 if (RECORD_FULL_IS_REPLAY
)
1512 /* Let user choose if he wants to write memory or not. */
1513 if (!query (_("Because GDB is in replay mode, writing to memory "
1514 "will make the execution log unusable from this "
1515 "point onward. Write memory at address %s?"),
1516 paddress (target_gdbarch (), offset
)))
1517 error (_("Process record canceled the operation."));
1519 /* Destroy the record from here forward. */
1520 record_full_list_release_following (record_full_list
);
1523 /* Check record_full_insn_num */
1524 record_full_check_insn_num ();
1526 /* Record registers change to list as an instruction. */
1527 record_full_arch_list_head
= NULL
;
1528 record_full_arch_list_tail
= NULL
;
1529 if (record_full_arch_list_add_mem (offset
, len
))
1531 record_full_list_release (record_full_arch_list_tail
);
1533 fprintf_unfiltered (gdb_stdlog
,
1534 "Process record: failed to record "
1536 return TARGET_XFER_E_IO
;
1538 if (record_full_arch_list_add_end ())
1540 record_full_list_release (record_full_arch_list_tail
);
1542 fprintf_unfiltered (gdb_stdlog
,
1543 "Process record: failed to record "
1545 return TARGET_XFER_E_IO
;
1547 record_full_list
->next
= record_full_arch_list_head
;
1548 record_full_arch_list_head
->prev
= record_full_list
;
1549 record_full_list
= record_full_arch_list_tail
;
1551 if (record_full_insn_num
== record_full_insn_max_num
)
1552 record_full_list_release_first ();
1554 record_full_insn_num
++;
1557 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1558 readbuf
, writebuf
, offset
,
1562 /* This structure represents a breakpoint inserted while the record
1563 target is active. We use this to know when to install/remove
1564 breakpoints in/from the target beneath. For example, a breakpoint
1565 may be inserted while recording, but removed when not replaying nor
1566 recording. In that case, the breakpoint had not been inserted on
1567 the target beneath, so we should not try to remove it there. */
1569 struct record_full_breakpoint
1571 /* The address and address space the breakpoint was set at. */
1572 struct address_space
*address_space
;
1575 /* True when the breakpoint has been also installed in the target
1576 beneath. This will be false for breakpoints set during replay or
1578 int in_target_beneath
;
1581 typedef struct record_full_breakpoint
*record_full_breakpoint_p
;
1582 DEF_VEC_P(record_full_breakpoint_p
);
1584 /* The list of breakpoints inserted while the record target is
1586 VEC(record_full_breakpoint_p
) *record_full_breakpoints
= NULL
;
1589 record_full_sync_record_breakpoints (struct bp_location
*loc
, void *data
)
1591 if (loc
->loc_type
!= bp_loc_software_breakpoint
)
1596 struct record_full_breakpoint
*bp
= XNEW (struct record_full_breakpoint
);
1598 bp
->addr
= loc
->target_info
.placed_address
;
1599 bp
->address_space
= loc
->target_info
.placed_address_space
;
1601 bp
->in_target_beneath
= 1;
1603 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1607 /* Sync existing breakpoints to record_full_breakpoints. */
1610 record_full_init_record_breakpoints (void)
1612 VEC_free (record_full_breakpoint_p
, record_full_breakpoints
);
1614 iterate_over_bp_locations (record_full_sync_record_breakpoints
);
1617 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1618 insert or remove breakpoints in the real target when replaying, nor
1622 record_full_insert_breakpoint (struct target_ops
*ops
,
1623 struct gdbarch
*gdbarch
,
1624 struct bp_target_info
*bp_tgt
)
1626 struct record_full_breakpoint
*bp
;
1627 int in_target_beneath
= 0;
1630 if (!RECORD_FULL_IS_REPLAY
)
1632 /* When recording, we currently always single-step, so we don't
1633 really need to install regular breakpoints in the inferior.
1634 However, we do have to insert software single-step
1635 breakpoints, in case the target can't hardware step. To keep
1636 things simple, we always insert. */
1639 scoped_restore restore_operation_disable
1640 = record_full_gdb_operation_disable_set ();
1641 ret
= ops
->beneath
->to_insert_breakpoint (ops
->beneath
, gdbarch
, bp_tgt
);
1646 in_target_beneath
= 1;
1649 /* Use the existing entries if found in order to avoid duplication
1650 in record_full_breakpoints. */
1653 VEC_iterate (record_full_breakpoint_p
,
1654 record_full_breakpoints
, ix
, bp
);
1657 if (bp
->addr
== bp_tgt
->placed_address
1658 && bp
->address_space
== bp_tgt
->placed_address_space
)
1660 gdb_assert (bp
->in_target_beneath
== in_target_beneath
);
1665 bp
= XNEW (struct record_full_breakpoint
);
1666 bp
->addr
= bp_tgt
->placed_address
;
1667 bp
->address_space
= bp_tgt
->placed_address_space
;
1668 bp
->in_target_beneath
= in_target_beneath
;
1669 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1673 /* "to_remove_breakpoint" method for process record target. */
1676 record_full_remove_breakpoint (struct target_ops
*ops
,
1677 struct gdbarch
*gdbarch
,
1678 struct bp_target_info
*bp_tgt
,
1679 enum remove_bp_reason reason
)
1681 struct record_full_breakpoint
*bp
;
1685 VEC_iterate (record_full_breakpoint_p
,
1686 record_full_breakpoints
, ix
, bp
);
1689 if (bp
->addr
== bp_tgt
->placed_address
1690 && bp
->address_space
== bp_tgt
->placed_address_space
)
1692 if (bp
->in_target_beneath
)
1696 scoped_restore restore_operation_disable
1697 = record_full_gdb_operation_disable_set ();
1698 ret
= ops
->beneath
->to_remove_breakpoint (ops
->beneath
, gdbarch
,
1704 if (reason
== REMOVE_BREAKPOINT
)
1706 VEC_unordered_remove (record_full_breakpoint_p
,
1707 record_full_breakpoints
, ix
);
1713 gdb_assert_not_reached ("removing unknown breakpoint");
1716 /* "to_can_execute_reverse" method for process record target. */
1719 record_full_can_execute_reverse (struct target_ops
*self
)
1724 /* "to_get_bookmark" method for process record and prec over core. */
1727 record_full_get_bookmark (struct target_ops
*self
, const char *args
,
1732 /* Return stringified form of instruction count. */
1733 if (record_full_list
&& record_full_list
->type
== record_full_end
)
1734 ret
= xstrdup (pulongest (record_full_list
->u
.end
.insn_num
));
1739 fprintf_unfiltered (gdb_stdlog
,
1740 "record_full_get_bookmark returns %s\n", ret
);
1742 fprintf_unfiltered (gdb_stdlog
,
1743 "record_full_get_bookmark returns NULL\n");
1745 return (gdb_byte
*) ret
;
1748 /* "to_goto_bookmark" method for process record and prec over core. */
1751 record_full_goto_bookmark (struct target_ops
*self
,
1752 const gdb_byte
*raw_bookmark
, int from_tty
)
1754 const char *bookmark
= (const char *) raw_bookmark
;
1755 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1758 fprintf_unfiltered (gdb_stdlog
,
1759 "record_full_goto_bookmark receives %s\n", bookmark
);
1761 if (bookmark
[0] == '\'' || bookmark
[0] == '\"')
1765 if (bookmark
[strlen (bookmark
) - 1] != bookmark
[0])
1766 error (_("Unbalanced quotes: %s"), bookmark
);
1769 copy
= savestring (bookmark
+ 1, strlen (bookmark
) - 2);
1770 make_cleanup (xfree
, copy
);
1774 record_goto (bookmark
);
1776 do_cleanups (cleanup
);
1779 static enum exec_direction_kind
1780 record_full_execution_direction (struct target_ops
*self
)
1782 return record_full_execution_dir
;
1785 /* The to_record_method method of target record-full. */
1788 record_full_record_method (struct target_ops
*self
, ptid_t ptid
)
1790 return RECORD_METHOD_FULL
;
1794 record_full_info (struct target_ops
*self
)
1796 struct record_full_entry
*p
;
1798 if (RECORD_FULL_IS_REPLAY
)
1799 printf_filtered (_("Replay mode:\n"));
1801 printf_filtered (_("Record mode:\n"));
1803 /* Find entry for first actual instruction in the log. */
1804 for (p
= record_full_first
.next
;
1805 p
!= NULL
&& p
->type
!= record_full_end
;
1809 /* Do we have a log at all? */
1810 if (p
!= NULL
&& p
->type
== record_full_end
)
1812 /* Display instruction number for first instruction in the log. */
1813 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1814 pulongest (p
->u
.end
.insn_num
));
1816 /* If in replay mode, display where we are in the log. */
1817 if (RECORD_FULL_IS_REPLAY
)
1818 printf_filtered (_("Current instruction number is %s.\n"),
1819 pulongest (record_full_list
->u
.end
.insn_num
));
1821 /* Display instruction number for last instruction in the log. */
1822 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1823 pulongest (record_full_insn_count
));
1825 /* Display log count. */
1826 printf_filtered (_("Log contains %u instructions.\n"),
1827 record_full_insn_num
);
1830 printf_filtered (_("No instructions have been logged.\n"));
1832 /* Display max log size. */
1833 printf_filtered (_("Max logged instructions is %u.\n"),
1834 record_full_insn_max_num
);
1837 /* The "to_record_delete" target method. */
1840 record_full_delete (struct target_ops
*self
)
1842 record_full_list_release_following (record_full_list
);
1845 /* The "to_record_is_replaying" target method. */
1848 record_full_is_replaying (struct target_ops
*self
, ptid_t ptid
)
1850 return RECORD_FULL_IS_REPLAY
;
1853 /* The "to_record_will_replay" target method. */
1856 record_full_will_replay (struct target_ops
*self
, ptid_t ptid
, int dir
)
1858 /* We can currently only record when executing forwards. Should we be able
1859 to record when executing backwards on targets that support reverse
1860 execution, this needs to be changed. */
1862 return RECORD_FULL_IS_REPLAY
|| dir
== EXEC_REVERSE
;
1865 /* Go to a specific entry. */
1868 record_full_goto_entry (struct record_full_entry
*p
)
1871 error (_("Target insn not found."));
1872 else if (p
== record_full_list
)
1873 error (_("Already at target insn."));
1874 else if (p
->u
.end
.insn_num
> record_full_list
->u
.end
.insn_num
)
1876 printf_filtered (_("Go forward to insn number %s\n"),
1877 pulongest (p
->u
.end
.insn_num
));
1878 record_full_goto_insn (p
, EXEC_FORWARD
);
1882 printf_filtered (_("Go backward to insn number %s\n"),
1883 pulongest (p
->u
.end
.insn_num
));
1884 record_full_goto_insn (p
, EXEC_REVERSE
);
1887 registers_changed ();
1888 reinit_frame_cache ();
1889 stop_pc
= regcache_read_pc (get_current_regcache ());
1890 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1893 /* The "to_goto_record_begin" target method. */
1896 record_full_goto_begin (struct target_ops
*self
)
1898 struct record_full_entry
*p
= NULL
;
1900 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1901 if (p
->type
== record_full_end
)
1904 record_full_goto_entry (p
);
1907 /* The "to_goto_record_end" target method. */
1910 record_full_goto_end (struct target_ops
*self
)
1912 struct record_full_entry
*p
= NULL
;
1914 for (p
= record_full_list
; p
->next
!= NULL
; p
= p
->next
)
1916 for (; p
!= NULL
; p
= p
->prev
)
1917 if (p
->type
== record_full_end
)
1920 record_full_goto_entry (p
);
1923 /* The "to_goto_record" target method. */
1926 record_full_goto (struct target_ops
*self
, ULONGEST target_insn
)
1928 struct record_full_entry
*p
= NULL
;
1930 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1931 if (p
->type
== record_full_end
&& p
->u
.end
.insn_num
== target_insn
)
1934 record_full_goto_entry (p
);
1937 /* The "to_record_stop_replaying" target method. */
1940 record_full_stop_replaying (struct target_ops
*self
)
1942 record_full_goto_end (self
);
1946 init_record_full_ops (void)
1948 record_full_ops
.to_shortname
= "record-full";
1949 record_full_ops
.to_longname
= "Process record and replay target";
1950 record_full_ops
.to_doc
=
1951 "Log program while executing and replay execution from log.";
1952 record_full_ops
.to_open
= record_full_open
;
1953 record_full_ops
.to_close
= record_full_close
;
1954 record_full_ops
.to_async
= record_full_async
;
1955 record_full_ops
.to_resume
= record_full_resume
;
1956 record_full_ops
.to_commit_resume
= record_full_commit_resume
;
1957 record_full_ops
.to_wait
= record_full_wait
;
1958 record_full_ops
.to_disconnect
= record_disconnect
;
1959 record_full_ops
.to_detach
= record_detach
;
1960 record_full_ops
.to_mourn_inferior
= record_mourn_inferior
;
1961 record_full_ops
.to_kill
= record_kill
;
1962 record_full_ops
.to_store_registers
= record_full_store_registers
;
1963 record_full_ops
.to_xfer_partial
= record_full_xfer_partial
;
1964 record_full_ops
.to_insert_breakpoint
= record_full_insert_breakpoint
;
1965 record_full_ops
.to_remove_breakpoint
= record_full_remove_breakpoint
;
1966 record_full_ops
.to_stopped_by_watchpoint
= record_full_stopped_by_watchpoint
;
1967 record_full_ops
.to_stopped_data_address
= record_full_stopped_data_address
;
1968 record_full_ops
.to_stopped_by_sw_breakpoint
1969 = record_full_stopped_by_sw_breakpoint
;
1970 record_full_ops
.to_supports_stopped_by_sw_breakpoint
1971 = record_full_supports_stopped_by_sw_breakpoint
;
1972 record_full_ops
.to_stopped_by_hw_breakpoint
1973 = record_full_stopped_by_hw_breakpoint
;
1974 record_full_ops
.to_supports_stopped_by_hw_breakpoint
1975 = record_full_supports_stopped_by_hw_breakpoint
;
1976 record_full_ops
.to_can_execute_reverse
= record_full_can_execute_reverse
;
1977 record_full_ops
.to_stratum
= record_stratum
;
1978 /* Add bookmark target methods. */
1979 record_full_ops
.to_get_bookmark
= record_full_get_bookmark
;
1980 record_full_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
1981 record_full_ops
.to_execution_direction
= record_full_execution_direction
;
1982 record_full_ops
.to_record_method
= record_full_record_method
;
1983 record_full_ops
.to_info_record
= record_full_info
;
1984 record_full_ops
.to_save_record
= record_full_save
;
1985 record_full_ops
.to_delete_record
= record_full_delete
;
1986 record_full_ops
.to_record_is_replaying
= record_full_is_replaying
;
1987 record_full_ops
.to_record_will_replay
= record_full_will_replay
;
1988 record_full_ops
.to_record_stop_replaying
= record_full_stop_replaying
;
1989 record_full_ops
.to_goto_record_begin
= record_full_goto_begin
;
1990 record_full_ops
.to_goto_record_end
= record_full_goto_end
;
1991 record_full_ops
.to_goto_record
= record_full_goto
;
1992 record_full_ops
.to_magic
= OPS_MAGIC
;
1995 /* "to_resume" method for prec over corefile. */
1998 record_full_core_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
1999 enum gdb_signal signal
)
2001 record_full_resume_step
= step
;
2002 record_full_resumed
= 1;
2003 record_full_execution_dir
= execution_direction
;
2005 /* We are about to start executing the inferior (or simulate it),
2006 let's register it with the event loop. */
2007 if (target_can_async_p ())
2011 /* "to_kill" method for prec over corefile. */
2014 record_full_core_kill (struct target_ops
*ops
)
2017 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_core_kill\n");
2019 unpush_target (&record_full_core_ops
);
2022 /* "to_fetch_registers" method for prec over corefile. */
2025 record_full_core_fetch_registers (struct target_ops
*ops
,
2026 struct regcache
*regcache
,
2031 int num
= gdbarch_num_regs (regcache
->arch ());
2034 for (i
= 0; i
< num
; i
++)
2035 regcache_raw_supply (regcache
, i
,
2036 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
2039 regcache_raw_supply (regcache
, regno
,
2040 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
2043 /* "to_prepare_to_store" method for prec over corefile. */
2046 record_full_core_prepare_to_store (struct target_ops
*self
,
2047 struct regcache
*regcache
)
2051 /* "to_store_registers" method for prec over corefile. */
2054 record_full_core_store_registers (struct target_ops
*ops
,
2055 struct regcache
*regcache
,
2058 if (record_full_gdb_operation_disable
)
2059 regcache_raw_collect (regcache
, regno
,
2060 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
2062 error (_("You can't do that without a process to debug."));
2065 /* "to_xfer_partial" method for prec over corefile. */
2067 static enum target_xfer_status
2068 record_full_core_xfer_partial (struct target_ops
*ops
,
2069 enum target_object object
,
2070 const char *annex
, gdb_byte
*readbuf
,
2071 const gdb_byte
*writebuf
, ULONGEST offset
,
2072 ULONGEST len
, ULONGEST
*xfered_len
)
2074 if (object
== TARGET_OBJECT_MEMORY
)
2076 if (record_full_gdb_operation_disable
|| !writebuf
)
2078 struct target_section
*p
;
2080 for (p
= record_full_core_start
; p
< record_full_core_end
; p
++)
2082 if (offset
>= p
->addr
)
2084 struct record_full_core_buf_entry
*entry
;
2085 ULONGEST sec_offset
;
2087 if (offset
>= p
->endaddr
)
2090 if (offset
+ len
> p
->endaddr
)
2091 len
= p
->endaddr
- offset
;
2093 sec_offset
= offset
- p
->addr
;
2095 /* Read readbuf or write writebuf p, offset, len. */
2097 if (p
->the_bfd_section
->flags
& SEC_CONSTRUCTOR
2098 || (p
->the_bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2101 memset (readbuf
, 0, len
);
2104 return TARGET_XFER_OK
;
2106 /* Get record_full_core_buf_entry. */
2107 for (entry
= record_full_core_buf_list
; entry
;
2108 entry
= entry
->prev
)
2115 /* Add a new entry. */
2116 entry
= XNEW (struct record_full_core_buf_entry
);
2118 if (!bfd_malloc_and_get_section
2119 (p
->the_bfd_section
->owner
,
2124 return TARGET_XFER_EOF
;
2126 entry
->prev
= record_full_core_buf_list
;
2127 record_full_core_buf_list
= entry
;
2130 memcpy (entry
->buf
+ sec_offset
, writebuf
,
2136 return ops
->beneath
->to_xfer_partial (ops
->beneath
,
2142 memcpy (readbuf
, entry
->buf
+ sec_offset
,
2147 return TARGET_XFER_OK
;
2151 return TARGET_XFER_E_IO
;
2154 error (_("You can't do that without a process to debug."));
2157 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2158 readbuf
, writebuf
, offset
, len
,
2162 /* "to_insert_breakpoint" method for prec over corefile. */
2165 record_full_core_insert_breakpoint (struct target_ops
*ops
,
2166 struct gdbarch
*gdbarch
,
2167 struct bp_target_info
*bp_tgt
)
2172 /* "to_remove_breakpoint" method for prec over corefile. */
2175 record_full_core_remove_breakpoint (struct target_ops
*ops
,
2176 struct gdbarch
*gdbarch
,
2177 struct bp_target_info
*bp_tgt
,
2178 enum remove_bp_reason reason
)
2183 /* "to_has_execution" method for prec over corefile. */
2186 record_full_core_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
2192 init_record_full_core_ops (void)
2194 record_full_core_ops
.to_shortname
= "record-core";
2195 record_full_core_ops
.to_longname
= "Process record and replay target";
2196 record_full_core_ops
.to_doc
=
2197 "Log program while executing and replay execution from log.";
2198 record_full_core_ops
.to_open
= record_full_open
;
2199 record_full_core_ops
.to_close
= record_full_close
;
2200 record_full_core_ops
.to_async
= record_full_async
;
2201 record_full_core_ops
.to_resume
= record_full_core_resume
;
2202 record_full_core_ops
.to_wait
= record_full_wait
;
2203 record_full_core_ops
.to_kill
= record_full_core_kill
;
2204 record_full_core_ops
.to_fetch_registers
= record_full_core_fetch_registers
;
2205 record_full_core_ops
.to_prepare_to_store
= record_full_core_prepare_to_store
;
2206 record_full_core_ops
.to_store_registers
= record_full_core_store_registers
;
2207 record_full_core_ops
.to_xfer_partial
= record_full_core_xfer_partial
;
2208 record_full_core_ops
.to_insert_breakpoint
2209 = record_full_core_insert_breakpoint
;
2210 record_full_core_ops
.to_remove_breakpoint
2211 = record_full_core_remove_breakpoint
;
2212 record_full_core_ops
.to_stopped_by_watchpoint
2213 = record_full_stopped_by_watchpoint
;
2214 record_full_core_ops
.to_stopped_data_address
2215 = record_full_stopped_data_address
;
2216 record_full_core_ops
.to_stopped_by_sw_breakpoint
2217 = record_full_stopped_by_sw_breakpoint
;
2218 record_full_core_ops
.to_supports_stopped_by_sw_breakpoint
2219 = record_full_supports_stopped_by_sw_breakpoint
;
2220 record_full_core_ops
.to_stopped_by_hw_breakpoint
2221 = record_full_stopped_by_hw_breakpoint
;
2222 record_full_core_ops
.to_supports_stopped_by_hw_breakpoint
2223 = record_full_supports_stopped_by_hw_breakpoint
;
2224 record_full_core_ops
.to_can_execute_reverse
2225 = record_full_can_execute_reverse
;
2226 record_full_core_ops
.to_has_execution
= record_full_core_has_execution
;
2227 record_full_core_ops
.to_stratum
= record_stratum
;
2228 /* Add bookmark target methods. */
2229 record_full_core_ops
.to_get_bookmark
= record_full_get_bookmark
;
2230 record_full_core_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
2231 record_full_core_ops
.to_execution_direction
2232 = record_full_execution_direction
;
2233 record_full_core_ops
.to_record_method
= record_full_record_method
;
2234 record_full_core_ops
.to_info_record
= record_full_info
;
2235 record_full_core_ops
.to_delete_record
= record_full_delete
;
2236 record_full_core_ops
.to_record_is_replaying
= record_full_is_replaying
;
2237 record_full_core_ops
.to_record_will_replay
= record_full_will_replay
;
2238 record_full_core_ops
.to_goto_record_begin
= record_full_goto_begin
;
2239 record_full_core_ops
.to_goto_record_end
= record_full_goto_end
;
2240 record_full_core_ops
.to_goto_record
= record_full_goto
;
2241 record_full_core_ops
.to_magic
= OPS_MAGIC
;
2244 /* Record log save-file format
2245 Version 1 (never released)
2248 4 bytes: magic number htonl(0x20090829).
2249 NOTE: be sure to change whenever this file format changes!
2253 1 byte: record type (record_full_end, see enum record_full_type).
2255 1 byte: record type (record_full_reg, see enum record_full_type).
2256 8 bytes: register id (network byte order).
2257 MAX_REGISTER_SIZE bytes: register value.
2259 1 byte: record type (record_full_mem, see enum record_full_type).
2260 8 bytes: memory length (network byte order).
2261 8 bytes: memory address (network byte order).
2262 n bytes: memory value (n == memory length).
2265 4 bytes: magic number netorder32(0x20091016).
2266 NOTE: be sure to change whenever this file format changes!
2270 1 byte: record type (record_full_end, see enum record_full_type).
2272 4 bytes: instruction count
2274 1 byte: record type (record_full_reg, see enum record_full_type).
2275 4 bytes: register id (network byte order).
2276 n bytes: register value (n == actual register size).
2277 (eg. 4 bytes for x86 general registers).
2279 1 byte: record type (record_full_mem, see enum record_full_type).
2280 4 bytes: memory length (network byte order).
2281 8 bytes: memory address (network byte order).
2282 n bytes: memory value (n == memory length).
2286 /* bfdcore_read -- read bytes from a core file section. */
2289 bfdcore_read (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2291 int ret
= bfd_get_section_contents (obfd
, osec
, buf
, *offset
, len
);
2296 error (_("Failed to read %d bytes from core file %s ('%s')."),
2297 len
, bfd_get_filename (obfd
),
2298 bfd_errmsg (bfd_get_error ()));
2301 static inline uint64_t
2302 netorder64 (uint64_t input
)
2306 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2307 BFD_ENDIAN_BIG
, input
);
2311 static inline uint32_t
2312 netorder32 (uint32_t input
)
2316 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2317 BFD_ENDIAN_BIG
, input
);
2321 /* Restore the execution log from a core_bfd file. */
2323 record_full_restore (void)
2326 struct cleanup
*old_cleanups
;
2327 struct record_full_entry
*rec
;
2331 struct regcache
*regcache
;
2333 /* We restore the execution log from the open core bfd,
2335 if (core_bfd
== NULL
)
2338 /* "record_full_restore" can only be called when record list is empty. */
2339 gdb_assert (record_full_first
.next
== NULL
);
2342 fprintf_unfiltered (gdb_stdlog
, "Restoring recording from core file.\n");
2344 /* Now need to find our special note section. */
2345 osec
= bfd_get_section_by_name (core_bfd
, "null0");
2347 fprintf_unfiltered (gdb_stdlog
, "Find precord section %s.\n",
2348 osec
? "succeeded" : "failed");
2351 osec_size
= bfd_section_size (core_bfd
, osec
);
2353 fprintf_unfiltered (gdb_stdlog
, "%s", bfd_section_name (core_bfd
, osec
));
2355 /* Check the magic code. */
2356 bfdcore_read (core_bfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2357 if (magic
!= RECORD_FULL_FILE_MAGIC
)
2358 error (_("Version mis-match or file format error in core file %s."),
2359 bfd_get_filename (core_bfd
));
2361 fprintf_unfiltered (gdb_stdlog
,
2362 " Reading 4-byte magic cookie "
2363 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2364 phex_nz (netorder32 (magic
), 4));
2366 /* Restore the entries in recfd into record_full_arch_list_head and
2367 record_full_arch_list_tail. */
2368 record_full_arch_list_head
= NULL
;
2369 record_full_arch_list_tail
= NULL
;
2370 record_full_insn_num
= 0;
2371 old_cleanups
= make_cleanup (record_full_arch_list_cleanups
, 0);
2372 regcache
= get_current_regcache ();
2377 uint32_t regnum
, len
, signal
, count
;
2380 /* We are finished when offset reaches osec_size. */
2381 if (bfd_offset
>= osec_size
)
2383 bfdcore_read (core_bfd
, osec
, &rectype
, sizeof (rectype
), &bfd_offset
);
2387 case record_full_reg
: /* reg */
2388 /* Get register number to regnum. */
2389 bfdcore_read (core_bfd
, osec
, ®num
,
2390 sizeof (regnum
), &bfd_offset
);
2391 regnum
= netorder32 (regnum
);
2393 rec
= record_full_reg_alloc (regcache
, regnum
);
2396 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2397 rec
->u
.reg
.len
, &bfd_offset
);
2400 fprintf_unfiltered (gdb_stdlog
,
2401 " Reading register %d (1 "
2402 "plus %lu plus %d bytes)\n",
2404 (unsigned long) sizeof (regnum
),
2408 case record_full_mem
: /* mem */
2410 bfdcore_read (core_bfd
, osec
, &len
,
2411 sizeof (len
), &bfd_offset
);
2412 len
= netorder32 (len
);
2415 bfdcore_read (core_bfd
, osec
, &addr
,
2416 sizeof (addr
), &bfd_offset
);
2417 addr
= netorder64 (addr
);
2419 rec
= record_full_mem_alloc (addr
, len
);
2422 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2423 rec
->u
.mem
.len
, &bfd_offset
);
2426 fprintf_unfiltered (gdb_stdlog
,
2427 " Reading memory %s (1 plus "
2428 "%lu plus %lu plus %d bytes)\n",
2429 paddress (get_current_arch (),
2431 (unsigned long) sizeof (addr
),
2432 (unsigned long) sizeof (len
),
2436 case record_full_end
: /* end */
2437 rec
= record_full_end_alloc ();
2438 record_full_insn_num
++;
2440 /* Get signal value. */
2441 bfdcore_read (core_bfd
, osec
, &signal
,
2442 sizeof (signal
), &bfd_offset
);
2443 signal
= netorder32 (signal
);
2444 rec
->u
.end
.sigval
= (enum gdb_signal
) signal
;
2446 /* Get insn count. */
2447 bfdcore_read (core_bfd
, osec
, &count
,
2448 sizeof (count
), &bfd_offset
);
2449 count
= netorder32 (count
);
2450 rec
->u
.end
.insn_num
= count
;
2451 record_full_insn_count
= count
+ 1;
2453 fprintf_unfiltered (gdb_stdlog
,
2454 " Reading record_full_end (1 + "
2455 "%lu + %lu bytes), offset == %s\n",
2456 (unsigned long) sizeof (signal
),
2457 (unsigned long) sizeof (count
),
2458 paddress (get_current_arch (),
2463 error (_("Bad entry type in core file %s."),
2464 bfd_get_filename (core_bfd
));
2468 /* Add rec to record arch list. */
2469 record_full_arch_list_add (rec
);
2472 discard_cleanups (old_cleanups
);
2474 /* Add record_full_arch_list_head to the end of record list. */
2475 record_full_first
.next
= record_full_arch_list_head
;
2476 record_full_arch_list_head
->prev
= &record_full_first
;
2477 record_full_arch_list_tail
->next
= NULL
;
2478 record_full_list
= &record_full_first
;
2480 /* Update record_full_insn_max_num. */
2481 if (record_full_insn_num
> record_full_insn_max_num
)
2483 record_full_insn_max_num
= record_full_insn_num
;
2484 warning (_("Auto increase record/replay buffer limit to %u."),
2485 record_full_insn_max_num
);
2489 printf_filtered (_("Restored records from core file %s.\n"),
2490 bfd_get_filename (core_bfd
));
2492 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2495 /* bfdcore_write -- write bytes into a core file section. */
2498 bfdcore_write (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2500 int ret
= bfd_set_section_contents (obfd
, osec
, buf
, *offset
, len
);
2505 error (_("Failed to write %d bytes to core file %s ('%s')."),
2506 len
, bfd_get_filename (obfd
),
2507 bfd_errmsg (bfd_get_error ()));
2510 /* Restore the execution log from a file. We use a modified elf
2511 corefile format, with an extra section for our data. */
2514 cmd_record_full_restore (const char *args
, int from_tty
)
2516 core_file_command (args
, from_tty
);
2517 record_full_open (args
, from_tty
);
2520 /* Save the execution log to a file. We use a modified elf corefile
2521 format, with an extra section for our data. */
2524 record_full_save (struct target_ops
*self
, const char *recfilename
)
2526 struct record_full_entry
*cur_record_full_list
;
2528 struct regcache
*regcache
;
2529 struct gdbarch
*gdbarch
;
2531 asection
*osec
= NULL
;
2534 /* Open the save file. */
2536 fprintf_unfiltered (gdb_stdlog
, "Saving execution log to core file '%s'\n",
2539 /* Open the output file. */
2540 gdb_bfd_ref_ptr
obfd (create_gcore_bfd (recfilename
));
2542 /* Arrange to remove the output file on failure. */
2543 gdb::unlinker
unlink_file (recfilename
);
2545 /* Save the current record entry to "cur_record_full_list". */
2546 cur_record_full_list
= record_full_list
;
2548 /* Get the values of regcache and gdbarch. */
2549 regcache
= get_current_regcache ();
2550 gdbarch
= regcache
->arch ();
2552 /* Disable the GDB operation record. */
2553 scoped_restore restore_operation_disable
2554 = record_full_gdb_operation_disable_set ();
2556 /* Reverse execute to the begin of record list. */
2559 /* Check for beginning and end of log. */
2560 if (record_full_list
== &record_full_first
)
2563 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2565 if (record_full_list
->prev
)
2566 record_full_list
= record_full_list
->prev
;
2569 /* Compute the size needed for the extra bfd section. */
2570 save_size
= 4; /* magic cookie */
2571 for (record_full_list
= record_full_first
.next
; record_full_list
;
2572 record_full_list
= record_full_list
->next
)
2573 switch (record_full_list
->type
)
2575 case record_full_end
:
2576 save_size
+= 1 + 4 + 4;
2578 case record_full_reg
:
2579 save_size
+= 1 + 4 + record_full_list
->u
.reg
.len
;
2581 case record_full_mem
:
2582 save_size
+= 1 + 4 + 8 + record_full_list
->u
.mem
.len
;
2586 /* Make the new bfd section. */
2587 osec
= bfd_make_section_anyway_with_flags (obfd
.get (), "precord",
2591 error (_("Failed to create 'precord' section for corefile %s: %s"),
2593 bfd_errmsg (bfd_get_error ()));
2594 bfd_set_section_size (obfd
.get (), osec
, save_size
);
2595 bfd_set_section_vma (obfd
.get (), osec
, 0);
2596 bfd_set_section_alignment (obfd
.get (), osec
, 0);
2597 bfd_section_lma (obfd
.get (), osec
) = 0;
2599 /* Save corefile state. */
2600 write_gcore_file (obfd
.get ());
2602 /* Write out the record log. */
2603 /* Write the magic code. */
2604 magic
= RECORD_FULL_FILE_MAGIC
;
2606 fprintf_unfiltered (gdb_stdlog
,
2607 " Writing 4-byte magic cookie "
2608 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2609 phex_nz (magic
, 4));
2610 bfdcore_write (obfd
.get (), osec
, &magic
, sizeof (magic
), &bfd_offset
);
2612 /* Save the entries to recfd and forward execute to the end of
2614 record_full_list
= &record_full_first
;
2618 if (record_full_list
!= &record_full_first
)
2621 uint32_t regnum
, len
, signal
, count
;
2624 type
= record_full_list
->type
;
2625 bfdcore_write (obfd
.get (), osec
, &type
, sizeof (type
), &bfd_offset
);
2627 switch (record_full_list
->type
)
2629 case record_full_reg
: /* reg */
2631 fprintf_unfiltered (gdb_stdlog
,
2632 " Writing register %d (1 "
2633 "plus %lu plus %d bytes)\n",
2634 record_full_list
->u
.reg
.num
,
2635 (unsigned long) sizeof (regnum
),
2636 record_full_list
->u
.reg
.len
);
2639 regnum
= netorder32 (record_full_list
->u
.reg
.num
);
2640 bfdcore_write (obfd
.get (), osec
, ®num
,
2641 sizeof (regnum
), &bfd_offset
);
2644 bfdcore_write (obfd
.get (), osec
,
2645 record_full_get_loc (record_full_list
),
2646 record_full_list
->u
.reg
.len
, &bfd_offset
);
2649 case record_full_mem
: /* mem */
2651 fprintf_unfiltered (gdb_stdlog
,
2652 " Writing memory %s (1 plus "
2653 "%lu plus %lu plus %d bytes)\n",
2655 record_full_list
->u
.mem
.addr
),
2656 (unsigned long) sizeof (addr
),
2657 (unsigned long) sizeof (len
),
2658 record_full_list
->u
.mem
.len
);
2661 len
= netorder32 (record_full_list
->u
.mem
.len
);
2662 bfdcore_write (obfd
.get (), osec
, &len
, sizeof (len
),
2665 /* Write memaddr. */
2666 addr
= netorder64 (record_full_list
->u
.mem
.addr
);
2667 bfdcore_write (obfd
.get (), osec
, &addr
,
2668 sizeof (addr
), &bfd_offset
);
2671 bfdcore_write (obfd
.get (), osec
,
2672 record_full_get_loc (record_full_list
),
2673 record_full_list
->u
.mem
.len
, &bfd_offset
);
2676 case record_full_end
:
2678 fprintf_unfiltered (gdb_stdlog
,
2679 " Writing record_full_end (1 + "
2680 "%lu + %lu bytes)\n",
2681 (unsigned long) sizeof (signal
),
2682 (unsigned long) sizeof (count
));
2683 /* Write signal value. */
2684 signal
= netorder32 (record_full_list
->u
.end
.sigval
);
2685 bfdcore_write (obfd
.get (), osec
, &signal
,
2686 sizeof (signal
), &bfd_offset
);
2688 /* Write insn count. */
2689 count
= netorder32 (record_full_list
->u
.end
.insn_num
);
2690 bfdcore_write (obfd
.get (), osec
, &count
,
2691 sizeof (count
), &bfd_offset
);
2696 /* Execute entry. */
2697 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2699 if (record_full_list
->next
)
2700 record_full_list
= record_full_list
->next
;
2705 /* Reverse execute to cur_record_full_list. */
2708 /* Check for beginning and end of log. */
2709 if (record_full_list
== cur_record_full_list
)
2712 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2714 if (record_full_list
->prev
)
2715 record_full_list
= record_full_list
->prev
;
2718 unlink_file
.keep ();
2721 printf_filtered (_("Saved core file %s with execution log.\n"),
2725 /* record_full_goto_insn -- rewind the record log (forward or backward,
2726 depending on DIR) to the given entry, changing the program state
2730 record_full_goto_insn (struct record_full_entry
*entry
,
2731 enum exec_direction_kind dir
)
2733 scoped_restore restore_operation_disable
2734 = record_full_gdb_operation_disable_set ();
2735 struct regcache
*regcache
= get_current_regcache ();
2736 struct gdbarch
*gdbarch
= regcache
->arch ();
2738 /* Assume everything is valid: we will hit the entry,
2739 and we will not hit the end of the recording. */
2741 if (dir
== EXEC_FORWARD
)
2742 record_full_list
= record_full_list
->next
;
2746 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2747 if (dir
== EXEC_REVERSE
)
2748 record_full_list
= record_full_list
->prev
;
2750 record_full_list
= record_full_list
->next
;
2751 } while (record_full_list
!= entry
);
2754 /* Alias for "target record-full". */
2757 cmd_record_full_start (const char *args
, int from_tty
)
2759 execute_command ("target record-full", from_tty
);
2763 set_record_full_insn_max_num (const char *args
, int from_tty
,
2764 struct cmd_list_element
*c
)
2766 if (record_full_insn_num
> record_full_insn_max_num
)
2768 /* Count down record_full_insn_num while releasing records from list. */
2769 while (record_full_insn_num
> record_full_insn_max_num
)
2771 record_full_list_release_first ();
2772 record_full_insn_num
--;
2777 /* The "set record full" command. */
2780 set_record_full_command (const char *args
, int from_tty
)
2782 printf_unfiltered (_("\"set record full\" must be followed "
2783 "by an appropriate subcommand.\n"));
2784 help_list (set_record_full_cmdlist
, "set record full ", all_commands
,
2788 /* The "show record full" command. */
2791 show_record_full_command (const char *args
, int from_tty
)
2793 cmd_show_list (show_record_full_cmdlist
, from_tty
, "");
2797 _initialize_record_full (void)
2799 struct cmd_list_element
*c
;
2801 /* Init record_full_first. */
2802 record_full_first
.prev
= NULL
;
2803 record_full_first
.next
= NULL
;
2804 record_full_first
.type
= record_full_end
;
2806 init_record_full_ops ();
2807 add_target (&record_full_ops
);
2808 add_deprecated_target_alias (&record_full_ops
, "record");
2809 init_record_full_core_ops ();
2810 add_target (&record_full_core_ops
);
2812 add_prefix_cmd ("full", class_obscure
, cmd_record_full_start
,
2813 _("Start full execution recording."), &record_full_cmdlist
,
2814 "record full ", 0, &record_cmdlist
);
2816 c
= add_cmd ("restore", class_obscure
, cmd_record_full_restore
,
2817 _("Restore the execution log from a file.\n\
2818 Argument is filename. File must be created with 'record save'."),
2819 &record_full_cmdlist
);
2820 set_cmd_completer (c
, filename_completer
);
2822 /* Deprecate the old version without "full" prefix. */
2823 c
= add_alias_cmd ("restore", "full restore", class_obscure
, 1,
2825 set_cmd_completer (c
, filename_completer
);
2826 deprecate_cmd (c
, "record full restore");
2828 add_prefix_cmd ("full", class_support
, set_record_full_command
,
2829 _("Set record options"), &set_record_full_cmdlist
,
2830 "set record full ", 0, &set_record_cmdlist
);
2832 add_prefix_cmd ("full", class_support
, show_record_full_command
,
2833 _("Show record options"), &show_record_full_cmdlist
,
2834 "show record full ", 0, &show_record_cmdlist
);
2836 /* Record instructions number limit command. */
2837 add_setshow_boolean_cmd ("stop-at-limit", no_class
,
2838 &record_full_stop_at_limit
, _("\
2839 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2840 Show whether record/replay stops when record/replay buffer becomes full."),
2841 _("Default is ON.\n\
2842 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2843 When OFF, if the record/replay buffer becomes full,\n\
2844 delete the oldest recorded instruction to make room for each new one."),
2846 &set_record_full_cmdlist
, &show_record_full_cmdlist
);
2848 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2849 &set_record_cmdlist
);
2850 deprecate_cmd (c
, "set record full stop-at-limit");
2852 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2853 &show_record_cmdlist
);
2854 deprecate_cmd (c
, "show record full stop-at-limit");
2856 add_setshow_uinteger_cmd ("insn-number-max", no_class
,
2857 &record_full_insn_max_num
,
2858 _("Set record/replay buffer limit."),
2859 _("Show record/replay buffer limit."), _("\
2860 Set the maximum number of instructions to be stored in the\n\
2861 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2862 limit. Default is 200000."),
2863 set_record_full_insn_max_num
,
2864 NULL
, &set_record_full_cmdlist
,
2865 &show_record_full_cmdlist
);
2867 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2868 &set_record_cmdlist
);
2869 deprecate_cmd (c
, "set record full insn-number-max");
2871 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2872 &show_record_cmdlist
);
2873 deprecate_cmd (c
, "show record full insn-number-max");
2875 add_setshow_boolean_cmd ("memory-query", no_class
,
2876 &record_full_memory_query
, _("\
2877 Set whether query if PREC cannot record memory change of next instruction."),
2879 Show whether query if PREC cannot record memory change of next instruction."),
2882 When ON, query if PREC cannot record memory change of next instruction."),
2884 &set_record_full_cmdlist
,
2885 &show_record_full_cmdlist
);
2887 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2888 &set_record_cmdlist
);
2889 deprecate_cmd (c
, "set record full memory-query");
2891 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2892 &show_record_cmdlist
);
2893 deprecate_cmd (c
, "show record full memory-query");