1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2015 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"
41 /* This module implements "target record-full", also known as "process
42 record and replay". This target sits on top of a "normal" target
43 (a target that "has execution"), and provides a record and replay
44 functionality, including reverse debugging.
46 Target record has two modes: recording, and replaying.
48 In record mode, we intercept the to_resume and to_wait methods.
49 Whenever gdb resumes the target, we run the target in single step
50 mode, and we build up an execution log in which, for each executed
51 instruction, we record all changes in memory and register state.
52 This is invisible to the user, to whom it just looks like an
53 ordinary debugging session (except for performance degredation).
55 In replay mode, instead of actually letting the inferior run as a
56 process, we simulate its execution by playing back the recorded
57 execution log. For each instruction in the log, we simulate the
58 instruction's side effects by duplicating the changes that it would
59 have made on memory and registers. */
61 #define DEFAULT_RECORD_FULL_INSN_MAX_NUM 200000
63 #define RECORD_FULL_IS_REPLAY \
64 (record_full_list->next || execution_direction == EXEC_REVERSE)
66 #define RECORD_FULL_FILE_MAGIC netorder32(0x20091016)
68 /* These are the core structs of the process record functionality.
70 A record_full_entry is a record of the value change of a register
71 ("record_full_reg") or a part of memory ("record_full_mem"). And each
72 instruction must have a struct record_full_entry ("record_full_end")
73 that indicates that this is the last struct record_full_entry of this
76 Each struct record_full_entry is linked to "record_full_list" by "prev"
77 and "next" pointers. */
79 struct record_full_mem_entry
83 /* Set this flag if target memory for this entry
84 can no longer be accessed. */
85 int mem_entry_not_accessible
;
89 gdb_byte buf
[sizeof (gdb_byte
*)];
93 struct record_full_reg_entry
100 gdb_byte buf
[2 * sizeof (gdb_byte
*)];
104 struct record_full_end_entry
106 enum gdb_signal sigval
;
110 enum record_full_type
117 /* This is the data structure that makes up the execution log.
119 The execution log consists of a single linked list of entries
120 of type "struct record_full_entry". It is doubly linked so that it
121 can be traversed in either direction.
123 The start of the list is anchored by a struct called
124 "record_full_first". The pointer "record_full_list" either points
125 to the last entry that was added to the list (in record mode), or to
126 the next entry in the list that will be executed (in replay mode).
128 Each list element (struct record_full_entry), in addition to next
129 and prev pointers, consists of a union of three entry types: mem,
130 reg, and end. A field called "type" determines which entry type is
131 represented by a given list element.
133 Each instruction that is added to the execution log is represented
134 by a variable number of list elements ('entries'). The instruction
135 will have one "reg" entry for each register that is changed by
136 executing the instruction (including the PC in every case). It
137 will also have one "mem" entry for each memory change. Finally,
138 each instruction will have an "end" entry that separates it from
139 the changes associated with the next instruction. */
141 struct record_full_entry
143 struct record_full_entry
*prev
;
144 struct record_full_entry
*next
;
145 enum record_full_type type
;
149 struct record_full_reg_entry reg
;
151 struct record_full_mem_entry mem
;
153 struct record_full_end_entry end
;
157 /* If true, query if PREC cannot record memory
158 change of next instruction. */
159 int record_full_memory_query
= 0;
161 struct record_full_core_buf_entry
163 struct record_full_core_buf_entry
*prev
;
164 struct target_section
*p
;
168 /* Record buf with core target. */
169 static gdb_byte
*record_full_core_regbuf
= NULL
;
170 static struct target_section
*record_full_core_start
;
171 static struct target_section
*record_full_core_end
;
172 static struct record_full_core_buf_entry
*record_full_core_buf_list
= NULL
;
174 /* The following variables are used for managing the linked list that
175 represents the execution log.
177 record_full_first is the anchor that holds down the beginning of
180 record_full_list serves two functions:
181 1) In record mode, it anchors the end of the list.
182 2) In replay mode, it traverses the list and points to
183 the next instruction that must be emulated.
185 record_full_arch_list_head and record_full_arch_list_tail are used
186 to manage a separate list, which is used to build up the change
187 elements of the currently executing instruction during record mode.
188 When this instruction has been completely annotated in the "arch
189 list", it will be appended to the main execution log. */
191 static struct record_full_entry record_full_first
;
192 static struct record_full_entry
*record_full_list
= &record_full_first
;
193 static struct record_full_entry
*record_full_arch_list_head
= NULL
;
194 static struct record_full_entry
*record_full_arch_list_tail
= NULL
;
196 /* 1 ask user. 0 auto delete the last struct record_full_entry. */
197 static int record_full_stop_at_limit
= 1;
198 /* Maximum allowed number of insns in execution log. */
199 static unsigned int record_full_insn_max_num
200 = DEFAULT_RECORD_FULL_INSN_MAX_NUM
;
201 /* Actual count of insns presently in execution log. */
202 static unsigned int record_full_insn_num
= 0;
203 /* Count of insns logged so far (may be larger
204 than count of insns presently in execution log). */
205 static ULONGEST record_full_insn_count
;
207 /* The target_ops of process record. */
208 static struct target_ops record_full_ops
;
209 static struct target_ops record_full_core_ops
;
211 /* See record-full.h. */
214 record_full_is_used (void)
216 struct target_ops
*t
;
218 t
= find_record_target ();
219 return (t
== &record_full_ops
220 || t
== &record_full_core_ops
);
224 /* Command lists for "set/show record full". */
225 static struct cmd_list_element
*set_record_full_cmdlist
;
226 static struct cmd_list_element
*show_record_full_cmdlist
;
228 /* Command list for "record full". */
229 static struct cmd_list_element
*record_full_cmdlist
;
231 static void record_full_goto_insn (struct record_full_entry
*entry
,
232 enum exec_direction_kind dir
);
233 static void record_full_save (struct target_ops
*self
,
234 const char *recfilename
);
236 /* Alloc and free functions for record_full_reg, record_full_mem, and
237 record_full_end entries. */
239 /* Alloc a record_full_reg record entry. */
241 static inline struct record_full_entry
*
242 record_full_reg_alloc (struct regcache
*regcache
, int regnum
)
244 struct record_full_entry
*rec
;
245 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
247 rec
= XCNEW (struct record_full_entry
);
248 rec
->type
= record_full_reg
;
249 rec
->u
.reg
.num
= regnum
;
250 rec
->u
.reg
.len
= register_size (gdbarch
, regnum
);
251 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
252 rec
->u
.reg
.u
.ptr
= (gdb_byte
*) xmalloc (rec
->u
.reg
.len
);
257 /* Free a record_full_reg record entry. */
260 record_full_reg_release (struct record_full_entry
*rec
)
262 gdb_assert (rec
->type
== record_full_reg
);
263 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
264 xfree (rec
->u
.reg
.u
.ptr
);
268 /* Alloc a record_full_mem record entry. */
270 static inline struct record_full_entry
*
271 record_full_mem_alloc (CORE_ADDR addr
, int len
)
273 struct record_full_entry
*rec
;
275 rec
= XCNEW (struct record_full_entry
);
276 rec
->type
= record_full_mem
;
277 rec
->u
.mem
.addr
= addr
;
278 rec
->u
.mem
.len
= len
;
279 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
280 rec
->u
.mem
.u
.ptr
= (gdb_byte
*) xmalloc (len
);
285 /* Free a record_full_mem record entry. */
288 record_full_mem_release (struct record_full_entry
*rec
)
290 gdb_assert (rec
->type
== record_full_mem
);
291 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
292 xfree (rec
->u
.mem
.u
.ptr
);
296 /* Alloc a record_full_end record entry. */
298 static inline struct record_full_entry
*
299 record_full_end_alloc (void)
301 struct record_full_entry
*rec
;
303 rec
= XCNEW (struct record_full_entry
);
304 rec
->type
= record_full_end
;
309 /* Free a record_full_end record entry. */
312 record_full_end_release (struct record_full_entry
*rec
)
317 /* Free one record entry, any type.
318 Return entry->type, in case caller wants to know. */
320 static inline enum record_full_type
321 record_full_entry_release (struct record_full_entry
*rec
)
323 enum record_full_type type
= rec
->type
;
326 case record_full_reg
:
327 record_full_reg_release (rec
);
329 case record_full_mem
:
330 record_full_mem_release (rec
);
332 case record_full_end
:
333 record_full_end_release (rec
);
339 /* Free all record entries in list pointed to by REC. */
342 record_full_list_release (struct record_full_entry
*rec
)
353 record_full_entry_release (rec
->next
);
356 if (rec
== &record_full_first
)
358 record_full_insn_num
= 0;
359 record_full_first
.next
= NULL
;
362 record_full_entry_release (rec
);
365 /* Free all record entries forward of the given list position. */
368 record_full_list_release_following (struct record_full_entry
*rec
)
370 struct record_full_entry
*tmp
= rec
->next
;
376 if (record_full_entry_release (tmp
) == record_full_end
)
378 record_full_insn_num
--;
379 record_full_insn_count
--;
385 /* Delete the first instruction from the beginning of the log, to make
386 room for adding a new instruction at the end of the log.
388 Note -- this function does not modify record_full_insn_num. */
391 record_full_list_release_first (void)
393 struct record_full_entry
*tmp
;
395 if (!record_full_first
.next
)
398 /* Loop until a record_full_end. */
401 /* Cut record_full_first.next out of the linked list. */
402 tmp
= record_full_first
.next
;
403 record_full_first
.next
= tmp
->next
;
404 tmp
->next
->prev
= &record_full_first
;
406 /* tmp is now isolated, and can be deleted. */
407 if (record_full_entry_release (tmp
) == record_full_end
)
408 break; /* End loop at first record_full_end. */
410 if (!record_full_first
.next
)
412 gdb_assert (record_full_insn_num
== 1);
413 break; /* End loop when list is empty. */
418 /* Add a struct record_full_entry to record_full_arch_list. */
421 record_full_arch_list_add (struct record_full_entry
*rec
)
423 if (record_debug
> 1)
424 fprintf_unfiltered (gdb_stdlog
,
425 "Process record: record_full_arch_list_add %s.\n",
426 host_address_to_string (rec
));
428 if (record_full_arch_list_tail
)
430 record_full_arch_list_tail
->next
= rec
;
431 rec
->prev
= record_full_arch_list_tail
;
432 record_full_arch_list_tail
= rec
;
436 record_full_arch_list_head
= rec
;
437 record_full_arch_list_tail
= rec
;
441 /* Return the value storage location of a record entry. */
442 static inline gdb_byte
*
443 record_full_get_loc (struct record_full_entry
*rec
)
446 case record_full_mem
:
447 if (rec
->u
.mem
.len
> sizeof (rec
->u
.mem
.u
.buf
))
448 return rec
->u
.mem
.u
.ptr
;
450 return rec
->u
.mem
.u
.buf
;
451 case record_full_reg
:
452 if (rec
->u
.reg
.len
> sizeof (rec
->u
.reg
.u
.buf
))
453 return rec
->u
.reg
.u
.ptr
;
455 return rec
->u
.reg
.u
.buf
;
456 case record_full_end
:
458 gdb_assert_not_reached ("unexpected record_full_entry type");
463 /* Record the value of a register NUM to record_full_arch_list. */
466 record_full_arch_list_add_reg (struct regcache
*regcache
, int regnum
)
468 struct record_full_entry
*rec
;
470 if (record_debug
> 1)
471 fprintf_unfiltered (gdb_stdlog
,
472 "Process record: add register num = %d to "
476 rec
= record_full_reg_alloc (regcache
, regnum
);
478 regcache_raw_read (regcache
, regnum
, record_full_get_loc (rec
));
480 record_full_arch_list_add (rec
);
485 /* Record the value of a region of memory whose address is ADDR and
486 length is LEN to record_full_arch_list. */
489 record_full_arch_list_add_mem (CORE_ADDR addr
, int len
)
491 struct record_full_entry
*rec
;
493 if (record_debug
> 1)
494 fprintf_unfiltered (gdb_stdlog
,
495 "Process record: add mem addr = %s len = %d to "
497 paddress (target_gdbarch (), addr
), len
);
499 if (!addr
) /* FIXME: Why? Some arch must permit it... */
502 rec
= record_full_mem_alloc (addr
, len
);
504 if (record_read_memory (target_gdbarch (), addr
,
505 record_full_get_loc (rec
), len
))
507 record_full_mem_release (rec
);
511 record_full_arch_list_add (rec
);
516 /* Add a record_full_end type struct record_full_entry to
517 record_full_arch_list. */
520 record_full_arch_list_add_end (void)
522 struct record_full_entry
*rec
;
524 if (record_debug
> 1)
525 fprintf_unfiltered (gdb_stdlog
,
526 "Process record: add end to arch list.\n");
528 rec
= record_full_end_alloc ();
529 rec
->u
.end
.sigval
= GDB_SIGNAL_0
;
530 rec
->u
.end
.insn_num
= ++record_full_insn_count
;
532 record_full_arch_list_add (rec
);
538 record_full_check_insn_num (int set_terminal
)
540 if (record_full_insn_num
== record_full_insn_max_num
)
542 /* Ask user what to do. */
543 if (record_full_stop_at_limit
)
548 target_terminal_ours ();
549 q
= yquery (_("Do you want to auto delete previous execution "
550 "log entries when record/replay buffer becomes "
551 "full (record full stop-at-limit)?"));
553 target_terminal_inferior ();
555 record_full_stop_at_limit
= 0;
557 error (_("Process record: stopped by user."));
563 record_full_arch_list_cleanups (void *ignore
)
565 record_full_list_release (record_full_arch_list_tail
);
568 /* Before inferior step (when GDB record the running message, inferior
569 only can step), GDB will call this function to record the values to
570 record_full_list. This function will call gdbarch_process_record to
571 record the running message of inferior and set them to
572 record_full_arch_list, and add it to record_full_list. */
575 record_full_message (struct regcache
*regcache
, enum gdb_signal signal
)
578 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
579 struct cleanup
*old_cleanups
580 = make_cleanup (record_full_arch_list_cleanups
, 0);
582 record_full_arch_list_head
= NULL
;
583 record_full_arch_list_tail
= NULL
;
585 /* Check record_full_insn_num. */
586 record_full_check_insn_num (1);
588 /* If gdb sends a signal value to target_resume,
589 save it in the 'end' field of the previous instruction.
591 Maybe process record should record what really happened,
592 rather than what gdb pretends has happened.
594 So if Linux delivered the signal to the child process during
595 the record mode, we will record it and deliver it again in
598 If user says "ignore this signal" during the record mode, then
599 it will be ignored again during the replay mode (no matter if
600 the user says something different, like "deliver this signal"
601 during the replay mode).
603 User should understand that nothing he does during the replay
604 mode will change the behavior of the child. If he tries,
605 then that is a user error.
607 But we should still deliver the signal to gdb during the replay,
608 if we delivered it during the recording. Therefore we should
609 record the signal during record_full_wait, not
610 record_full_resume. */
611 if (record_full_list
!= &record_full_first
) /* FIXME better way to check */
613 gdb_assert (record_full_list
->type
== record_full_end
);
614 record_full_list
->u
.end
.sigval
= signal
;
617 if (signal
== GDB_SIGNAL_0
618 || !gdbarch_process_record_signal_p (gdbarch
))
619 ret
= gdbarch_process_record (gdbarch
,
621 regcache_read_pc (regcache
));
623 ret
= gdbarch_process_record_signal (gdbarch
,
628 error (_("Process record: inferior program stopped."));
630 error (_("Process record: failed to record execution log."));
632 discard_cleanups (old_cleanups
);
634 record_full_list
->next
= record_full_arch_list_head
;
635 record_full_arch_list_head
->prev
= record_full_list
;
636 record_full_list
= record_full_arch_list_tail
;
638 if (record_full_insn_num
== record_full_insn_max_num
)
639 record_full_list_release_first ();
641 record_full_insn_num
++;
646 struct record_full_message_args
{
647 struct regcache
*regcache
;
648 enum gdb_signal signal
;
652 record_full_message_wrapper (void *args
)
654 struct record_full_message_args
*record_full_args
= args
;
656 return record_full_message (record_full_args
->regcache
,
657 record_full_args
->signal
);
661 record_full_message_wrapper_safe (struct regcache
*regcache
,
662 enum gdb_signal signal
)
664 struct record_full_message_args args
;
666 args
.regcache
= regcache
;
667 args
.signal
= signal
;
669 return catch_errors (record_full_message_wrapper
, &args
, NULL
,
673 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
674 doesn't need record. */
676 static int record_full_gdb_operation_disable
= 0;
679 record_full_gdb_operation_disable_set (void)
681 struct cleanup
*old_cleanups
= NULL
;
684 make_cleanup_restore_integer (&record_full_gdb_operation_disable
);
685 record_full_gdb_operation_disable
= 1;
690 /* Flag set to TRUE for target_stopped_by_watchpoint. */
691 static enum target_stop_reason record_full_stop_reason
692 = TARGET_STOPPED_BY_NO_REASON
;
694 /* Execute one instruction from the record log. Each instruction in
695 the log will be represented by an arbitrary sequence of register
696 entries and memory entries, followed by an 'end' entry. */
699 record_full_exec_insn (struct regcache
*regcache
,
700 struct gdbarch
*gdbarch
,
701 struct record_full_entry
*entry
)
705 case record_full_reg
: /* reg */
707 gdb_byte reg
[MAX_REGISTER_SIZE
];
709 if (record_debug
> 1)
710 fprintf_unfiltered (gdb_stdlog
,
711 "Process record: record_full_reg %s to "
712 "inferior num = %d.\n",
713 host_address_to_string (entry
),
716 regcache_cooked_read (regcache
, entry
->u
.reg
.num
, reg
);
717 regcache_cooked_write (regcache
, entry
->u
.reg
.num
,
718 record_full_get_loc (entry
));
719 memcpy (record_full_get_loc (entry
), reg
, entry
->u
.reg
.len
);
723 case record_full_mem
: /* mem */
725 /* Nothing to do if the entry is flagged not_accessible. */
726 if (!entry
->u
.mem
.mem_entry_not_accessible
)
728 gdb_byte
*mem
= alloca (entry
->u
.mem
.len
);
730 if (record_debug
> 1)
731 fprintf_unfiltered (gdb_stdlog
,
732 "Process record: record_full_mem %s to "
733 "inferior addr = %s len = %d.\n",
734 host_address_to_string (entry
),
735 paddress (gdbarch
, entry
->u
.mem
.addr
),
738 if (record_read_memory (gdbarch
,
739 entry
->u
.mem
.addr
, mem
, entry
->u
.mem
.len
))
740 entry
->u
.mem
.mem_entry_not_accessible
= 1;
743 if (target_write_memory (entry
->u
.mem
.addr
,
744 record_full_get_loc (entry
),
747 entry
->u
.mem
.mem_entry_not_accessible
= 1;
749 warning (_("Process record: error writing memory at "
750 "addr = %s len = %d."),
751 paddress (gdbarch
, entry
->u
.mem
.addr
),
756 memcpy (record_full_get_loc (entry
), mem
,
759 /* We've changed memory --- check if a hardware
760 watchpoint should trap. Note that this
761 presently assumes the target beneath supports
762 continuable watchpoints. On non-continuable
763 watchpoints target, we'll want to check this
764 _before_ actually doing the memory change, and
765 not doing the change at all if the watchpoint
767 if (hardware_watchpoint_inserted_in_range
768 (get_regcache_aspace (regcache
),
769 entry
->u
.mem
.addr
, entry
->u
.mem
.len
))
770 record_full_stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
779 static void record_full_restore (void);
781 /* Asynchronous signal handle registered as event loop source for when
782 we have pending events ready to be passed to the core. */
784 static struct async_event_handler
*record_full_async_inferior_event_token
;
787 record_full_async_inferior_event_handler (gdb_client_data data
)
789 inferior_event_handler (INF_REG_EVENT
, NULL
);
792 /* Open the process record target. */
795 record_full_core_open_1 (const char *name
, int from_tty
)
797 struct regcache
*regcache
= get_current_regcache ();
798 int regnum
= gdbarch_num_regs (get_regcache_arch (regcache
));
801 /* Get record_full_core_regbuf. */
802 target_fetch_registers (regcache
, -1);
803 record_full_core_regbuf
= xmalloc (MAX_REGISTER_SIZE
* regnum
);
804 for (i
= 0; i
< regnum
; i
++)
805 regcache_raw_collect (regcache
, i
,
806 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
808 /* Get record_full_core_start and record_full_core_end. */
809 if (build_section_table (core_bfd
, &record_full_core_start
,
810 &record_full_core_end
))
812 xfree (record_full_core_regbuf
);
813 record_full_core_regbuf
= NULL
;
814 error (_("\"%s\": Can't find sections: %s"),
815 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
818 push_target (&record_full_core_ops
);
819 record_full_restore ();
822 /* "to_open" target method for 'live' processes. */
825 record_full_open_1 (const char *name
, int from_tty
)
828 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
831 if (!target_has_execution
)
832 error (_("Process record: the program is not being run."));
834 error (_("Process record target can't debug inferior in non-stop mode "
837 if (!gdbarch_process_record_p (target_gdbarch ()))
838 error (_("Process record: the current architecture doesn't support "
839 "record function."));
841 push_target (&record_full_ops
);
844 static void record_full_init_record_breakpoints (void);
846 /* "to_open" target method. Open the process record target. */
849 record_full_open (const char *name
, int from_tty
)
851 struct target_ops
*t
;
854 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
859 record_full_insn_num
= 0;
860 record_full_insn_count
= 0;
861 record_full_list
= &record_full_first
;
862 record_full_list
->next
= NULL
;
865 record_full_core_open_1 (name
, from_tty
);
867 record_full_open_1 (name
, from_tty
);
869 /* Register extra event sources in the event loop. */
870 record_full_async_inferior_event_token
871 = create_async_event_handler (record_full_async_inferior_event_handler
,
874 record_full_init_record_breakpoints ();
876 observer_notify_record_changed (current_inferior (), 1);
879 /* "to_close" target method. Close the process record target. */
882 record_full_close (struct target_ops
*self
)
884 struct record_full_core_buf_entry
*entry
;
887 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_close\n");
889 record_full_list_release (record_full_list
);
891 /* Release record_full_core_regbuf. */
892 if (record_full_core_regbuf
)
894 xfree (record_full_core_regbuf
);
895 record_full_core_regbuf
= NULL
;
898 /* Release record_full_core_buf_list. */
899 if (record_full_core_buf_list
)
901 for (entry
= record_full_core_buf_list
->prev
; entry
;
904 xfree (record_full_core_buf_list
);
905 record_full_core_buf_list
= entry
;
907 record_full_core_buf_list
= NULL
;
910 if (record_full_async_inferior_event_token
)
911 delete_async_event_handler (&record_full_async_inferior_event_token
);
914 /* "to_async" target method. */
917 record_full_async (struct target_ops
*ops
, int enable
)
920 mark_async_event_handler (record_full_async_inferior_event_token
);
922 clear_async_event_handler (record_full_async_inferior_event_token
);
924 ops
->beneath
->to_async (ops
->beneath
, enable
);
927 static int record_full_resume_step
= 0;
929 /* True if we've been resumed, and so each record_full_wait call should
930 advance execution. If this is false, record_full_wait will return a
931 TARGET_WAITKIND_IGNORE. */
932 static int record_full_resumed
= 0;
934 /* The execution direction of the last resume we got. This is
935 necessary for async mode. Vis (order is not strictly accurate):
937 1. user has the global execution direction set to forward
938 2. user does a reverse-step command
939 3. record_full_resume is called with global execution direction
940 temporarily switched to reverse
941 4. GDB's execution direction is reverted back to forward
942 5. target record notifies event loop there's an event to handle
943 6. infrun asks the target which direction was it going, and switches
944 the global execution direction accordingly (to reverse)
945 7. infrun polls an event out of the record target, and handles it
946 8. GDB goes back to the event loop, and goto #4.
948 static enum exec_direction_kind record_full_execution_dir
= EXEC_FORWARD
;
950 /* "to_resume" target method. Resume the process record target. */
953 record_full_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
954 enum gdb_signal signal
)
956 record_full_resume_step
= step
;
957 record_full_resumed
= 1;
958 record_full_execution_dir
= execution_direction
;
960 if (!RECORD_FULL_IS_REPLAY
)
962 struct gdbarch
*gdbarch
= target_thread_architecture (ptid
);
964 record_full_message (get_current_regcache (), signal
);
968 /* This is not hard single step. */
969 if (!gdbarch_software_single_step_p (gdbarch
))
971 /* This is a normal continue. */
976 /* This arch support soft sigle step. */
977 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
979 /* This is a soft single step. */
980 record_full_resume_step
= 1;
984 /* This is a continue.
985 Try to insert a soft single step breakpoint. */
986 if (!gdbarch_software_single_step (gdbarch
,
987 get_current_frame ()))
989 /* This system don't want use soft single step.
990 Use hard sigle step. */
997 /* Make sure the target beneath reports all signals. */
998 target_pass_signals (0, NULL
);
1000 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
, signal
);
1003 /* We are about to start executing the inferior (or simulate it),
1004 let's register it with the event loop. */
1005 if (target_can_async_p ())
1009 static int record_full_get_sig
= 0;
1011 /* SIGINT signal handler, registered by "to_wait" method. */
1014 record_full_sig_handler (int signo
)
1017 fprintf_unfiltered (gdb_stdlog
, "Process record: get a signal\n");
1019 /* It will break the running inferior in replay mode. */
1020 record_full_resume_step
= 1;
1022 /* It will let record_full_wait set inferior status to get the signal
1024 record_full_get_sig
= 1;
1028 record_full_wait_cleanups (void *ignore
)
1030 if (execution_direction
== EXEC_REVERSE
)
1032 if (record_full_list
->next
)
1033 record_full_list
= record_full_list
->next
;
1036 record_full_list
= record_full_list
->prev
;
1039 /* "to_wait" target method for process record target.
1041 In record mode, the target is always run in singlestep mode
1042 (even when gdb says to continue). The to_wait method intercepts
1043 the stop events and determines which ones are to be passed on to
1044 gdb. Most stop events are just singlestep events that gdb is not
1045 to know about, so the to_wait method just records them and keeps
1048 In replay mode, this function emulates the recorded execution log,
1049 one instruction at a time (forward or backward), and determines
1053 record_full_wait_1 (struct target_ops
*ops
,
1054 ptid_t ptid
, struct target_waitstatus
*status
,
1057 struct cleanup
*set_cleanups
= record_full_gdb_operation_disable_set ();
1060 fprintf_unfiltered (gdb_stdlog
,
1061 "Process record: record_full_wait "
1062 "record_full_resume_step = %d, "
1063 "record_full_resumed = %d, direction=%s\n",
1064 record_full_resume_step
, record_full_resumed
,
1065 record_full_execution_dir
== EXEC_FORWARD
1066 ? "forward" : "reverse");
1068 if (!record_full_resumed
)
1070 gdb_assert ((options
& TARGET_WNOHANG
) != 0);
1072 /* No interesting event. */
1073 status
->kind
= TARGET_WAITKIND_IGNORE
;
1074 return minus_one_ptid
;
1077 record_full_get_sig
= 0;
1078 signal (SIGINT
, record_full_sig_handler
);
1080 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1082 if (!RECORD_FULL_IS_REPLAY
&& ops
!= &record_full_core_ops
)
1084 if (record_full_resume_step
)
1086 /* This is a single step. */
1087 return ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1091 /* This is not a single step. */
1094 struct gdbarch
*gdbarch
= target_thread_architecture (inferior_ptid
);
1098 struct thread_info
*tp
;
1100 ret
= ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1101 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
1104 fprintf_unfiltered (gdb_stdlog
,
1105 "Process record: record_full_wait "
1106 "target beneath not done yet\n");
1110 ALL_NON_EXITED_THREADS (tp
)
1111 delete_single_step_breakpoints (tp
);
1113 if (record_full_resume_step
)
1116 /* Is this a SIGTRAP? */
1117 if (status
->kind
== TARGET_WAITKIND_STOPPED
1118 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1120 struct regcache
*regcache
;
1121 struct address_space
*aspace
;
1122 enum target_stop_reason
*stop_reason_p
1123 = &record_full_stop_reason
;
1125 /* Yes -- this is likely our single-step finishing,
1126 but check if there's any reason the core would be
1127 interested in the event. */
1129 registers_changed ();
1130 regcache
= get_current_regcache ();
1131 tmp_pc
= regcache_read_pc (regcache
);
1132 aspace
= get_regcache_aspace (regcache
);
1134 if (target_stopped_by_watchpoint ())
1136 /* Always interested in watchpoints. */
1138 else if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1141 /* There is a breakpoint here. Let the core
1146 /* This is a single-step trap. Record the
1147 insn and issue another step.
1148 FIXME: this part can be a random SIGTRAP too.
1149 But GDB cannot handle it. */
1152 if (!record_full_message_wrapper_safe (regcache
,
1155 status
->kind
= TARGET_WAITKIND_STOPPED
;
1156 status
->value
.sig
= GDB_SIGNAL_0
;
1160 if (gdbarch_software_single_step_p (gdbarch
))
1162 /* Try to insert the software single step breakpoint.
1163 If insert success, set step to 0. */
1164 set_executing (inferior_ptid
, 0);
1165 reinit_frame_cache ();
1166 if (gdbarch_software_single_step (gdbarch
,
1167 get_current_frame ()))
1169 set_executing (inferior_ptid
, 1);
1173 fprintf_unfiltered (gdb_stdlog
,
1174 "Process record: record_full_wait "
1175 "issuing one more step in the "
1176 "target beneath\n");
1177 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
,
1183 /* The inferior is broken by a breakpoint or a signal. */
1192 struct regcache
*regcache
= get_current_regcache ();
1193 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1194 struct address_space
*aspace
= get_regcache_aspace (regcache
);
1195 int continue_flag
= 1;
1196 int first_record_full_end
= 1;
1197 struct cleanup
*old_cleanups
1198 = make_cleanup (record_full_wait_cleanups
, 0);
1201 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1202 status
->kind
= TARGET_WAITKIND_STOPPED
;
1204 /* Check breakpoint when forward execute. */
1205 if (execution_direction
== EXEC_FORWARD
)
1207 tmp_pc
= regcache_read_pc (regcache
);
1208 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1209 &record_full_stop_reason
))
1212 fprintf_unfiltered (gdb_stdlog
,
1213 "Process record: break at %s.\n",
1214 paddress (gdbarch
, tmp_pc
));
1219 /* If GDB is in terminal_inferior mode, it will not get the signal.
1220 And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1221 mode, because inferior will not executed.
1222 Then set it to terminal_ours to make GDB get the signal. */
1223 target_terminal_ours ();
1225 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1227 if (execution_direction
== EXEC_FORWARD
&& record_full_list
->next
)
1228 record_full_list
= record_full_list
->next
;
1230 /* Loop over the record_full_list, looking for the next place to
1234 /* Check for beginning and end of log. */
1235 if (execution_direction
== EXEC_REVERSE
1236 && record_full_list
== &record_full_first
)
1238 /* Hit beginning of record log in reverse. */
1239 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1242 if (execution_direction
!= EXEC_REVERSE
&& !record_full_list
->next
)
1244 /* Hit end of record log going forward. */
1245 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1249 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
1251 if (record_full_list
->type
== record_full_end
)
1253 if (record_debug
> 1)
1254 fprintf_unfiltered (gdb_stdlog
,
1255 "Process record: record_full_end %s to "
1257 host_address_to_string (record_full_list
));
1259 if (first_record_full_end
&& execution_direction
== EXEC_REVERSE
)
1261 /* When reverse excute, the first record_full_end is the
1262 part of current instruction. */
1263 first_record_full_end
= 0;
1267 /* In EXEC_REVERSE mode, this is the record_full_end of prev
1269 In EXEC_FORWARD mode, this is the record_full_end of
1270 current instruction. */
1272 if (record_full_resume_step
)
1274 if (record_debug
> 1)
1275 fprintf_unfiltered (gdb_stdlog
,
1276 "Process record: step.\n");
1280 /* check breakpoint */
1281 tmp_pc
= regcache_read_pc (regcache
);
1282 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1283 &record_full_stop_reason
))
1286 fprintf_unfiltered (gdb_stdlog
,
1287 "Process record: break "
1289 paddress (gdbarch
, tmp_pc
));
1294 if (record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
1297 fprintf_unfiltered (gdb_stdlog
,
1298 "Process record: hit hw "
1302 /* Check target signal */
1303 if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1304 /* FIXME: better way to check */
1311 if (execution_direction
== EXEC_REVERSE
)
1313 if (record_full_list
->prev
)
1314 record_full_list
= record_full_list
->prev
;
1318 if (record_full_list
->next
)
1319 record_full_list
= record_full_list
->next
;
1323 while (continue_flag
);
1326 if (record_full_get_sig
)
1327 status
->value
.sig
= GDB_SIGNAL_INT
;
1328 else if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1329 /* FIXME: better way to check */
1330 status
->value
.sig
= record_full_list
->u
.end
.sigval
;
1332 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1334 discard_cleanups (old_cleanups
);
1337 signal (SIGINT
, handle_sigint
);
1339 do_cleanups (set_cleanups
);
1340 return inferior_ptid
;
1344 record_full_wait (struct target_ops
*ops
,
1345 ptid_t ptid
, struct target_waitstatus
*status
,
1350 return_ptid
= record_full_wait_1 (ops
, ptid
, status
, options
);
1351 if (status
->kind
!= TARGET_WAITKIND_IGNORE
)
1353 /* We're reporting a stop. Make sure any spurious
1354 target_wait(WNOHANG) doesn't advance the target until the
1355 core wants us resumed again. */
1356 record_full_resumed
= 0;
1362 record_full_stopped_by_watchpoint (struct target_ops
*ops
)
1364 if (RECORD_FULL_IS_REPLAY
)
1365 return record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
1367 return ops
->beneath
->to_stopped_by_watchpoint (ops
->beneath
);
1371 record_full_stopped_data_address (struct target_ops
*ops
, CORE_ADDR
*addr_p
)
1373 if (RECORD_FULL_IS_REPLAY
)
1376 return ops
->beneath
->to_stopped_data_address (ops
->beneath
, addr_p
);
1379 /* The to_stopped_by_sw_breakpoint method of target record-full. */
1382 record_full_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1384 return record_full_stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
1387 /* The to_supports_stopped_by_sw_breakpoint method of target
1391 record_full_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1396 /* The to_stopped_by_hw_breakpoint method of target record-full. */
1399 record_full_stopped_by_hw_breakpoint (struct target_ops
*ops
)
1401 return record_full_stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
1404 /* The to_supports_stopped_by_sw_breakpoint method of target
1408 record_full_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
1413 /* Record registers change (by user or by GDB) to list as an instruction. */
1416 record_full_registers_change (struct regcache
*regcache
, int regnum
)
1418 /* Check record_full_insn_num. */
1419 record_full_check_insn_num (0);
1421 record_full_arch_list_head
= NULL
;
1422 record_full_arch_list_tail
= NULL
;
1428 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
1430 if (record_full_arch_list_add_reg (regcache
, i
))
1432 record_full_list_release (record_full_arch_list_tail
);
1433 error (_("Process record: failed to record execution log."));
1439 if (record_full_arch_list_add_reg (regcache
, regnum
))
1441 record_full_list_release (record_full_arch_list_tail
);
1442 error (_("Process record: failed to record execution log."));
1445 if (record_full_arch_list_add_end ())
1447 record_full_list_release (record_full_arch_list_tail
);
1448 error (_("Process record: failed to record execution log."));
1450 record_full_list
->next
= record_full_arch_list_head
;
1451 record_full_arch_list_head
->prev
= record_full_list
;
1452 record_full_list
= record_full_arch_list_tail
;
1454 if (record_full_insn_num
== record_full_insn_max_num
)
1455 record_full_list_release_first ();
1457 record_full_insn_num
++;
1460 /* "to_store_registers" method for process record target. */
1463 record_full_store_registers (struct target_ops
*ops
,
1464 struct regcache
*regcache
,
1467 if (!record_full_gdb_operation_disable
)
1469 if (RECORD_FULL_IS_REPLAY
)
1473 /* Let user choose if he wants to write register or not. */
1476 query (_("Because GDB is in replay mode, changing the "
1477 "value of a register will make the execution "
1478 "log unusable from this point onward. "
1479 "Change all registers?"));
1482 query (_("Because GDB is in replay mode, changing the value "
1483 "of a register will make the execution log unusable "
1484 "from this point onward. Change register %s?"),
1485 gdbarch_register_name (get_regcache_arch (regcache
),
1490 /* Invalidate the value of regcache that was set in function
1491 "regcache_raw_write". */
1497 i
< gdbarch_num_regs (get_regcache_arch (regcache
));
1499 regcache_invalidate (regcache
, i
);
1502 regcache_invalidate (regcache
, regno
);
1504 error (_("Process record canceled the operation."));
1507 /* Destroy the record from here forward. */
1508 record_full_list_release_following (record_full_list
);
1511 record_full_registers_change (regcache
, regno
);
1513 ops
->beneath
->to_store_registers (ops
->beneath
, regcache
, regno
);
1516 /* "to_xfer_partial" method. Behavior is conditional on
1517 RECORD_FULL_IS_REPLAY.
1518 In replay mode, we cannot write memory unles we are willing to
1519 invalidate the record/replay log from this point forward. */
1521 static enum target_xfer_status
1522 record_full_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1523 const char *annex
, gdb_byte
*readbuf
,
1524 const gdb_byte
*writebuf
, ULONGEST offset
,
1525 ULONGEST len
, ULONGEST
*xfered_len
)
1527 if (!record_full_gdb_operation_disable
1528 && (object
== TARGET_OBJECT_MEMORY
1529 || object
== TARGET_OBJECT_RAW_MEMORY
) && writebuf
)
1531 if (RECORD_FULL_IS_REPLAY
)
1533 /* Let user choose if he wants to write memory or not. */
1534 if (!query (_("Because GDB is in replay mode, writing to memory "
1535 "will make the execution log unusable from this "
1536 "point onward. Write memory at address %s?"),
1537 paddress (target_gdbarch (), offset
)))
1538 error (_("Process record canceled the operation."));
1540 /* Destroy the record from here forward. */
1541 record_full_list_release_following (record_full_list
);
1544 /* Check record_full_insn_num */
1545 record_full_check_insn_num (0);
1547 /* Record registers change to list as an instruction. */
1548 record_full_arch_list_head
= NULL
;
1549 record_full_arch_list_tail
= NULL
;
1550 if (record_full_arch_list_add_mem (offset
, len
))
1552 record_full_list_release (record_full_arch_list_tail
);
1554 fprintf_unfiltered (gdb_stdlog
,
1555 "Process record: failed to record "
1557 return TARGET_XFER_E_IO
;
1559 if (record_full_arch_list_add_end ())
1561 record_full_list_release (record_full_arch_list_tail
);
1563 fprintf_unfiltered (gdb_stdlog
,
1564 "Process record: failed to record "
1566 return TARGET_XFER_E_IO
;
1568 record_full_list
->next
= record_full_arch_list_head
;
1569 record_full_arch_list_head
->prev
= record_full_list
;
1570 record_full_list
= record_full_arch_list_tail
;
1572 if (record_full_insn_num
== record_full_insn_max_num
)
1573 record_full_list_release_first ();
1575 record_full_insn_num
++;
1578 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1579 readbuf
, writebuf
, offset
,
1583 /* This structure represents a breakpoint inserted while the record
1584 target is active. We use this to know when to install/remove
1585 breakpoints in/from the target beneath. For example, a breakpoint
1586 may be inserted while recording, but removed when not replaying nor
1587 recording. In that case, the breakpoint had not been inserted on
1588 the target beneath, so we should not try to remove it there. */
1590 struct record_full_breakpoint
1592 /* The address and address space the breakpoint was set at. */
1593 struct address_space
*address_space
;
1596 /* True when the breakpoint has been also installed in the target
1597 beneath. This will be false for breakpoints set during replay or
1599 int in_target_beneath
;
1602 typedef struct record_full_breakpoint
*record_full_breakpoint_p
;
1603 DEF_VEC_P(record_full_breakpoint_p
);
1605 /* The list of breakpoints inserted while the record target is
1607 VEC(record_full_breakpoint_p
) *record_full_breakpoints
= NULL
;
1610 record_full_sync_record_breakpoints (struct bp_location
*loc
, void *data
)
1612 if (loc
->loc_type
!= bp_loc_software_breakpoint
)
1617 struct record_full_breakpoint
*bp
= XNEW (struct record_full_breakpoint
);
1619 bp
->addr
= loc
->target_info
.placed_address
;
1620 bp
->address_space
= loc
->target_info
.placed_address_space
;
1622 bp
->in_target_beneath
= 1;
1624 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1628 /* Sync existing breakpoints to record_full_breakpoints. */
1631 record_full_init_record_breakpoints (void)
1633 VEC_free (record_full_breakpoint_p
, record_full_breakpoints
);
1635 iterate_over_bp_locations (record_full_sync_record_breakpoints
);
1638 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1639 insert or remove breakpoints in the real target when replaying, nor
1643 record_full_insert_breakpoint (struct target_ops
*ops
,
1644 struct gdbarch
*gdbarch
,
1645 struct bp_target_info
*bp_tgt
)
1647 struct record_full_breakpoint
*bp
;
1648 int in_target_beneath
= 0;
1650 if (!RECORD_FULL_IS_REPLAY
)
1652 /* When recording, we currently always single-step, so we don't
1653 really need to install regular breakpoints in the inferior.
1654 However, we do have to insert software single-step
1655 breakpoints, in case the target can't hardware step. To keep
1656 things single, we always insert. */
1657 struct cleanup
*old_cleanups
;
1660 old_cleanups
= record_full_gdb_operation_disable_set ();
1661 ret
= ops
->beneath
->to_insert_breakpoint (ops
->beneath
, gdbarch
, bp_tgt
);
1662 do_cleanups (old_cleanups
);
1667 in_target_beneath
= 1;
1670 bp
= XNEW (struct record_full_breakpoint
);
1671 bp
->addr
= bp_tgt
->placed_address
;
1672 bp
->address_space
= bp_tgt
->placed_address_space
;
1673 bp
->in_target_beneath
= in_target_beneath
;
1674 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1678 /* "to_remove_breakpoint" method for process record target. */
1681 record_full_remove_breakpoint (struct target_ops
*ops
,
1682 struct gdbarch
*gdbarch
,
1683 struct bp_target_info
*bp_tgt
)
1685 struct record_full_breakpoint
*bp
;
1689 VEC_iterate (record_full_breakpoint_p
,
1690 record_full_breakpoints
, ix
, bp
);
1693 if (bp
->addr
== bp_tgt
->placed_address
1694 && bp
->address_space
== bp_tgt
->placed_address_space
)
1696 if (bp
->in_target_beneath
)
1698 struct cleanup
*old_cleanups
;
1701 old_cleanups
= record_full_gdb_operation_disable_set ();
1702 ret
= ops
->beneath
->to_remove_breakpoint (ops
->beneath
, gdbarch
,
1704 do_cleanups (old_cleanups
);
1710 VEC_unordered_remove (record_full_breakpoint_p
,
1711 record_full_breakpoints
, ix
);
1716 gdb_assert_not_reached ("removing unknown breakpoint");
1719 /* "to_can_execute_reverse" method for process record target. */
1722 record_full_can_execute_reverse (struct target_ops
*self
)
1727 /* "to_get_bookmark" method for process record and prec over core. */
1730 record_full_get_bookmark (struct target_ops
*self
, const char *args
,
1735 /* Return stringified form of instruction count. */
1736 if (record_full_list
&& record_full_list
->type
== record_full_end
)
1737 ret
= xstrdup (pulongest (record_full_list
->u
.end
.insn_num
));
1742 fprintf_unfiltered (gdb_stdlog
,
1743 "record_full_get_bookmark returns %s\n", ret
);
1745 fprintf_unfiltered (gdb_stdlog
,
1746 "record_full_get_bookmark returns NULL\n");
1748 return (gdb_byte
*) ret
;
1751 /* "to_goto_bookmark" method for process record and prec over core. */
1754 record_full_goto_bookmark (struct target_ops
*self
,
1755 const gdb_byte
*raw_bookmark
, int from_tty
)
1757 const char *bookmark
= (const char *) raw_bookmark
;
1758 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1761 fprintf_unfiltered (gdb_stdlog
,
1762 "record_full_goto_bookmark receives %s\n", bookmark
);
1764 if (bookmark
[0] == '\'' || bookmark
[0] == '\"')
1768 if (bookmark
[strlen (bookmark
) - 1] != bookmark
[0])
1769 error (_("Unbalanced quotes: %s"), bookmark
);
1772 copy
= savestring (bookmark
+ 1, strlen (bookmark
) - 2);
1773 make_cleanup (xfree
, copy
);
1777 record_goto (bookmark
);
1779 do_cleanups (cleanup
);
1782 static enum exec_direction_kind
1783 record_full_execution_direction (struct target_ops
*self
)
1785 return record_full_execution_dir
;
1789 record_full_info (struct target_ops
*self
)
1791 struct record_full_entry
*p
;
1793 if (RECORD_FULL_IS_REPLAY
)
1794 printf_filtered (_("Replay mode:\n"));
1796 printf_filtered (_("Record mode:\n"));
1798 /* Find entry for first actual instruction in the log. */
1799 for (p
= record_full_first
.next
;
1800 p
!= NULL
&& p
->type
!= record_full_end
;
1804 /* Do we have a log at all? */
1805 if (p
!= NULL
&& p
->type
== record_full_end
)
1807 /* Display instruction number for first instruction in the log. */
1808 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1809 pulongest (p
->u
.end
.insn_num
));
1811 /* If in replay mode, display where we are in the log. */
1812 if (RECORD_FULL_IS_REPLAY
)
1813 printf_filtered (_("Current instruction number is %s.\n"),
1814 pulongest (record_full_list
->u
.end
.insn_num
));
1816 /* Display instruction number for last instruction in the log. */
1817 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1818 pulongest (record_full_insn_count
));
1820 /* Display log count. */
1821 printf_filtered (_("Log contains %u instructions.\n"),
1822 record_full_insn_num
);
1825 printf_filtered (_("No instructions have been logged.\n"));
1827 /* Display max log size. */
1828 printf_filtered (_("Max logged instructions is %u.\n"),
1829 record_full_insn_max_num
);
1832 /* The "to_record_delete" target method. */
1835 record_full_delete (struct target_ops
*self
)
1837 record_full_list_release_following (record_full_list
);
1840 /* The "to_record_is_replaying" target method. */
1843 record_full_is_replaying (struct target_ops
*self
, ptid_t ptid
)
1845 return RECORD_FULL_IS_REPLAY
;
1848 /* Go to a specific entry. */
1851 record_full_goto_entry (struct record_full_entry
*p
)
1854 error (_("Target insn not found."));
1855 else if (p
== record_full_list
)
1856 error (_("Already at target insn."));
1857 else if (p
->u
.end
.insn_num
> record_full_list
->u
.end
.insn_num
)
1859 printf_filtered (_("Go forward to insn number %s\n"),
1860 pulongest (p
->u
.end
.insn_num
));
1861 record_full_goto_insn (p
, EXEC_FORWARD
);
1865 printf_filtered (_("Go backward to insn number %s\n"),
1866 pulongest (p
->u
.end
.insn_num
));
1867 record_full_goto_insn (p
, EXEC_REVERSE
);
1870 registers_changed ();
1871 reinit_frame_cache ();
1872 stop_pc
= regcache_read_pc (get_current_regcache ());
1873 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1876 /* The "to_goto_record_begin" target method. */
1879 record_full_goto_begin (struct target_ops
*self
)
1881 struct record_full_entry
*p
= NULL
;
1883 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1884 if (p
->type
== record_full_end
)
1887 record_full_goto_entry (p
);
1890 /* The "to_goto_record_end" target method. */
1893 record_full_goto_end (struct target_ops
*self
)
1895 struct record_full_entry
*p
= NULL
;
1897 for (p
= record_full_list
; p
->next
!= NULL
; p
= p
->next
)
1899 for (; p
!= NULL
; p
= p
->prev
)
1900 if (p
->type
== record_full_end
)
1903 record_full_goto_entry (p
);
1906 /* The "to_goto_record" target method. */
1909 record_full_goto (struct target_ops
*self
, ULONGEST target_insn
)
1911 struct record_full_entry
*p
= NULL
;
1913 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1914 if (p
->type
== record_full_end
&& p
->u
.end
.insn_num
== target_insn
)
1917 record_full_goto_entry (p
);
1920 /* The "to_record_stop_replaying" target method. */
1923 record_full_stop_replaying (struct target_ops
*self
)
1925 record_full_goto_end (self
);
1929 init_record_full_ops (void)
1931 record_full_ops
.to_shortname
= "record-full";
1932 record_full_ops
.to_longname
= "Process record and replay target";
1933 record_full_ops
.to_doc
=
1934 "Log program while executing and replay execution from log.";
1935 record_full_ops
.to_open
= record_full_open
;
1936 record_full_ops
.to_close
= record_full_close
;
1937 record_full_ops
.to_async
= record_full_async
;
1938 record_full_ops
.to_resume
= record_full_resume
;
1939 record_full_ops
.to_wait
= record_full_wait
;
1940 record_full_ops
.to_disconnect
= record_disconnect
;
1941 record_full_ops
.to_detach
= record_detach
;
1942 record_full_ops
.to_mourn_inferior
= record_mourn_inferior
;
1943 record_full_ops
.to_kill
= record_kill
;
1944 record_full_ops
.to_store_registers
= record_full_store_registers
;
1945 record_full_ops
.to_xfer_partial
= record_full_xfer_partial
;
1946 record_full_ops
.to_insert_breakpoint
= record_full_insert_breakpoint
;
1947 record_full_ops
.to_remove_breakpoint
= record_full_remove_breakpoint
;
1948 record_full_ops
.to_stopped_by_watchpoint
= record_full_stopped_by_watchpoint
;
1949 record_full_ops
.to_stopped_data_address
= record_full_stopped_data_address
;
1950 record_full_ops
.to_stopped_by_sw_breakpoint
1951 = record_full_stopped_by_sw_breakpoint
;
1952 record_full_ops
.to_supports_stopped_by_sw_breakpoint
1953 = record_full_supports_stopped_by_sw_breakpoint
;
1954 record_full_ops
.to_stopped_by_hw_breakpoint
1955 = record_full_stopped_by_hw_breakpoint
;
1956 record_full_ops
.to_supports_stopped_by_hw_breakpoint
1957 = record_full_supports_stopped_by_hw_breakpoint
;
1958 record_full_ops
.to_can_execute_reverse
= record_full_can_execute_reverse
;
1959 record_full_ops
.to_stratum
= record_stratum
;
1960 /* Add bookmark target methods. */
1961 record_full_ops
.to_get_bookmark
= record_full_get_bookmark
;
1962 record_full_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
1963 record_full_ops
.to_execution_direction
= record_full_execution_direction
;
1964 record_full_ops
.to_info_record
= record_full_info
;
1965 record_full_ops
.to_save_record
= record_full_save
;
1966 record_full_ops
.to_delete_record
= record_full_delete
;
1967 record_full_ops
.to_record_is_replaying
= record_full_is_replaying
;
1968 record_full_ops
.to_record_stop_replaying
= record_full_stop_replaying
;
1969 record_full_ops
.to_goto_record_begin
= record_full_goto_begin
;
1970 record_full_ops
.to_goto_record_end
= record_full_goto_end
;
1971 record_full_ops
.to_goto_record
= record_full_goto
;
1972 record_full_ops
.to_magic
= OPS_MAGIC
;
1975 /* "to_resume" method for prec over corefile. */
1978 record_full_core_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
1979 enum gdb_signal signal
)
1981 record_full_resume_step
= step
;
1982 record_full_resumed
= 1;
1983 record_full_execution_dir
= execution_direction
;
1985 /* We are about to start executing the inferior (or simulate it),
1986 let's register it with the event loop. */
1987 if (target_can_async_p ())
1991 /* "to_kill" method for prec over corefile. */
1994 record_full_core_kill (struct target_ops
*ops
)
1997 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_core_kill\n");
1999 unpush_target (&record_full_core_ops
);
2002 /* "to_fetch_registers" method for prec over corefile. */
2005 record_full_core_fetch_registers (struct target_ops
*ops
,
2006 struct regcache
*regcache
,
2011 int num
= gdbarch_num_regs (get_regcache_arch (regcache
));
2014 for (i
= 0; i
< num
; i
++)
2015 regcache_raw_supply (regcache
, i
,
2016 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
2019 regcache_raw_supply (regcache
, regno
,
2020 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
2023 /* "to_prepare_to_store" method for prec over corefile. */
2026 record_full_core_prepare_to_store (struct target_ops
*self
,
2027 struct regcache
*regcache
)
2031 /* "to_store_registers" method for prec over corefile. */
2034 record_full_core_store_registers (struct target_ops
*ops
,
2035 struct regcache
*regcache
,
2038 if (record_full_gdb_operation_disable
)
2039 regcache_raw_collect (regcache
, regno
,
2040 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
2042 error (_("You can't do that without a process to debug."));
2045 /* "to_xfer_partial" method for prec over corefile. */
2047 static enum target_xfer_status
2048 record_full_core_xfer_partial (struct target_ops
*ops
,
2049 enum target_object object
,
2050 const char *annex
, gdb_byte
*readbuf
,
2051 const gdb_byte
*writebuf
, ULONGEST offset
,
2052 ULONGEST len
, ULONGEST
*xfered_len
)
2054 if (object
== TARGET_OBJECT_MEMORY
)
2056 if (record_full_gdb_operation_disable
|| !writebuf
)
2058 struct target_section
*p
;
2060 for (p
= record_full_core_start
; p
< record_full_core_end
; p
++)
2062 if (offset
>= p
->addr
)
2064 struct record_full_core_buf_entry
*entry
;
2065 ULONGEST sec_offset
;
2067 if (offset
>= p
->endaddr
)
2070 if (offset
+ len
> p
->endaddr
)
2071 len
= p
->endaddr
- offset
;
2073 sec_offset
= offset
- p
->addr
;
2075 /* Read readbuf or write writebuf p, offset, len. */
2077 if (p
->the_bfd_section
->flags
& SEC_CONSTRUCTOR
2078 || (p
->the_bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2081 memset (readbuf
, 0, len
);
2084 return TARGET_XFER_OK
;
2086 /* Get record_full_core_buf_entry. */
2087 for (entry
= record_full_core_buf_list
; entry
;
2088 entry
= entry
->prev
)
2095 /* Add a new entry. */
2096 entry
= XNEW (struct record_full_core_buf_entry
);
2098 if (!bfd_malloc_and_get_section
2099 (p
->the_bfd_section
->owner
,
2104 return TARGET_XFER_EOF
;
2106 entry
->prev
= record_full_core_buf_list
;
2107 record_full_core_buf_list
= entry
;
2110 memcpy (entry
->buf
+ sec_offset
, writebuf
,
2116 return ops
->beneath
->to_xfer_partial (ops
->beneath
,
2122 memcpy (readbuf
, entry
->buf
+ sec_offset
,
2127 return TARGET_XFER_OK
;
2131 return TARGET_XFER_E_IO
;
2134 error (_("You can't do that without a process to debug."));
2137 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2138 readbuf
, writebuf
, offset
, len
,
2142 /* "to_insert_breakpoint" method for prec over corefile. */
2145 record_full_core_insert_breakpoint (struct target_ops
*ops
,
2146 struct gdbarch
*gdbarch
,
2147 struct bp_target_info
*bp_tgt
)
2152 /* "to_remove_breakpoint" method for prec over corefile. */
2155 record_full_core_remove_breakpoint (struct target_ops
*ops
,
2156 struct gdbarch
*gdbarch
,
2157 struct bp_target_info
*bp_tgt
)
2162 /* "to_has_execution" method for prec over corefile. */
2165 record_full_core_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
2171 init_record_full_core_ops (void)
2173 record_full_core_ops
.to_shortname
= "record-core";
2174 record_full_core_ops
.to_longname
= "Process record and replay target";
2175 record_full_core_ops
.to_doc
=
2176 "Log program while executing and replay execution from log.";
2177 record_full_core_ops
.to_open
= record_full_open
;
2178 record_full_core_ops
.to_close
= record_full_close
;
2179 record_full_core_ops
.to_async
= record_full_async
;
2180 record_full_core_ops
.to_resume
= record_full_core_resume
;
2181 record_full_core_ops
.to_wait
= record_full_wait
;
2182 record_full_core_ops
.to_kill
= record_full_core_kill
;
2183 record_full_core_ops
.to_fetch_registers
= record_full_core_fetch_registers
;
2184 record_full_core_ops
.to_prepare_to_store
= record_full_core_prepare_to_store
;
2185 record_full_core_ops
.to_store_registers
= record_full_core_store_registers
;
2186 record_full_core_ops
.to_xfer_partial
= record_full_core_xfer_partial
;
2187 record_full_core_ops
.to_insert_breakpoint
2188 = record_full_core_insert_breakpoint
;
2189 record_full_core_ops
.to_remove_breakpoint
2190 = record_full_core_remove_breakpoint
;
2191 record_full_core_ops
.to_stopped_by_watchpoint
2192 = record_full_stopped_by_watchpoint
;
2193 record_full_core_ops
.to_stopped_data_address
2194 = record_full_stopped_data_address
;
2195 record_full_core_ops
.to_stopped_by_sw_breakpoint
2196 = record_full_stopped_by_sw_breakpoint
;
2197 record_full_core_ops
.to_supports_stopped_by_sw_breakpoint
2198 = record_full_supports_stopped_by_sw_breakpoint
;
2199 record_full_core_ops
.to_stopped_by_hw_breakpoint
2200 = record_full_stopped_by_hw_breakpoint
;
2201 record_full_core_ops
.to_supports_stopped_by_hw_breakpoint
2202 = record_full_supports_stopped_by_hw_breakpoint
;
2203 record_full_core_ops
.to_can_execute_reverse
2204 = record_full_can_execute_reverse
;
2205 record_full_core_ops
.to_has_execution
= record_full_core_has_execution
;
2206 record_full_core_ops
.to_stratum
= record_stratum
;
2207 /* Add bookmark target methods. */
2208 record_full_core_ops
.to_get_bookmark
= record_full_get_bookmark
;
2209 record_full_core_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
2210 record_full_core_ops
.to_execution_direction
2211 = record_full_execution_direction
;
2212 record_full_core_ops
.to_info_record
= record_full_info
;
2213 record_full_core_ops
.to_delete_record
= record_full_delete
;
2214 record_full_core_ops
.to_record_is_replaying
= record_full_is_replaying
;
2215 record_full_core_ops
.to_goto_record_begin
= record_full_goto_begin
;
2216 record_full_core_ops
.to_goto_record_end
= record_full_goto_end
;
2217 record_full_core_ops
.to_goto_record
= record_full_goto
;
2218 record_full_core_ops
.to_magic
= OPS_MAGIC
;
2221 /* Record log save-file format
2222 Version 1 (never released)
2225 4 bytes: magic number htonl(0x20090829).
2226 NOTE: be sure to change whenever this file format changes!
2230 1 byte: record type (record_full_end, see enum record_full_type).
2232 1 byte: record type (record_full_reg, see enum record_full_type).
2233 8 bytes: register id (network byte order).
2234 MAX_REGISTER_SIZE bytes: register value.
2236 1 byte: record type (record_full_mem, see enum record_full_type).
2237 8 bytes: memory length (network byte order).
2238 8 bytes: memory address (network byte order).
2239 n bytes: memory value (n == memory length).
2242 4 bytes: magic number netorder32(0x20091016).
2243 NOTE: be sure to change whenever this file format changes!
2247 1 byte: record type (record_full_end, see enum record_full_type).
2249 4 bytes: instruction count
2251 1 byte: record type (record_full_reg, see enum record_full_type).
2252 4 bytes: register id (network byte order).
2253 n bytes: register value (n == actual register size).
2254 (eg. 4 bytes for x86 general registers).
2256 1 byte: record type (record_full_mem, see enum record_full_type).
2257 4 bytes: memory length (network byte order).
2258 8 bytes: memory address (network byte order).
2259 n bytes: memory value (n == memory length).
2263 /* bfdcore_read -- read bytes from a core file section. */
2266 bfdcore_read (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2268 int ret
= bfd_get_section_contents (obfd
, osec
, buf
, *offset
, len
);
2273 error (_("Failed to read %d bytes from core file %s ('%s')."),
2274 len
, bfd_get_filename (obfd
),
2275 bfd_errmsg (bfd_get_error ()));
2278 static inline uint64_t
2279 netorder64 (uint64_t input
)
2283 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2284 BFD_ENDIAN_BIG
, input
);
2288 static inline uint32_t
2289 netorder32 (uint32_t input
)
2293 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2294 BFD_ENDIAN_BIG
, input
);
2298 static inline uint16_t
2299 netorder16 (uint16_t input
)
2303 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2304 BFD_ENDIAN_BIG
, input
);
2308 /* Restore the execution log from a core_bfd file. */
2310 record_full_restore (void)
2313 struct cleanup
*old_cleanups
;
2314 struct record_full_entry
*rec
;
2318 struct regcache
*regcache
;
2320 /* We restore the execution log from the open core bfd,
2322 if (core_bfd
== NULL
)
2325 /* "record_full_restore" can only be called when record list is empty. */
2326 gdb_assert (record_full_first
.next
== NULL
);
2329 fprintf_unfiltered (gdb_stdlog
, "Restoring recording from core file.\n");
2331 /* Now need to find our special note section. */
2332 osec
= bfd_get_section_by_name (core_bfd
, "null0");
2334 fprintf_unfiltered (gdb_stdlog
, "Find precord section %s.\n",
2335 osec
? "succeeded" : "failed");
2338 osec_size
= bfd_section_size (core_bfd
, osec
);
2340 fprintf_unfiltered (gdb_stdlog
, "%s", bfd_section_name (core_bfd
, osec
));
2342 /* Check the magic code. */
2343 bfdcore_read (core_bfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2344 if (magic
!= RECORD_FULL_FILE_MAGIC
)
2345 error (_("Version mis-match or file format error in core file %s."),
2346 bfd_get_filename (core_bfd
));
2348 fprintf_unfiltered (gdb_stdlog
,
2349 " Reading 4-byte magic cookie "
2350 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2351 phex_nz (netorder32 (magic
), 4));
2353 /* Restore the entries in recfd into record_full_arch_list_head and
2354 record_full_arch_list_tail. */
2355 record_full_arch_list_head
= NULL
;
2356 record_full_arch_list_tail
= NULL
;
2357 record_full_insn_num
= 0;
2358 old_cleanups
= make_cleanup (record_full_arch_list_cleanups
, 0);
2359 regcache
= get_current_regcache ();
2364 uint32_t regnum
, len
, signal
, count
;
2367 /* We are finished when offset reaches osec_size. */
2368 if (bfd_offset
>= osec_size
)
2370 bfdcore_read (core_bfd
, osec
, &rectype
, sizeof (rectype
), &bfd_offset
);
2374 case record_full_reg
: /* reg */
2375 /* Get register number to regnum. */
2376 bfdcore_read (core_bfd
, osec
, ®num
,
2377 sizeof (regnum
), &bfd_offset
);
2378 regnum
= netorder32 (regnum
);
2380 rec
= record_full_reg_alloc (regcache
, regnum
);
2383 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2384 rec
->u
.reg
.len
, &bfd_offset
);
2387 fprintf_unfiltered (gdb_stdlog
,
2388 " Reading register %d (1 "
2389 "plus %lu plus %d bytes)\n",
2391 (unsigned long) sizeof (regnum
),
2395 case record_full_mem
: /* mem */
2397 bfdcore_read (core_bfd
, osec
, &len
,
2398 sizeof (len
), &bfd_offset
);
2399 len
= netorder32 (len
);
2402 bfdcore_read (core_bfd
, osec
, &addr
,
2403 sizeof (addr
), &bfd_offset
);
2404 addr
= netorder64 (addr
);
2406 rec
= record_full_mem_alloc (addr
, len
);
2409 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2410 rec
->u
.mem
.len
, &bfd_offset
);
2413 fprintf_unfiltered (gdb_stdlog
,
2414 " Reading memory %s (1 plus "
2415 "%lu plus %lu plus %d bytes)\n",
2416 paddress (get_current_arch (),
2418 (unsigned long) sizeof (addr
),
2419 (unsigned long) sizeof (len
),
2423 case record_full_end
: /* end */
2424 rec
= record_full_end_alloc ();
2425 record_full_insn_num
++;
2427 /* Get signal value. */
2428 bfdcore_read (core_bfd
, osec
, &signal
,
2429 sizeof (signal
), &bfd_offset
);
2430 signal
= netorder32 (signal
);
2431 rec
->u
.end
.sigval
= (enum gdb_signal
) signal
;
2433 /* Get insn count. */
2434 bfdcore_read (core_bfd
, osec
, &count
,
2435 sizeof (count
), &bfd_offset
);
2436 count
= netorder32 (count
);
2437 rec
->u
.end
.insn_num
= count
;
2438 record_full_insn_count
= count
+ 1;
2440 fprintf_unfiltered (gdb_stdlog
,
2441 " Reading record_full_end (1 + "
2442 "%lu + %lu bytes), offset == %s\n",
2443 (unsigned long) sizeof (signal
),
2444 (unsigned long) sizeof (count
),
2445 paddress (get_current_arch (),
2450 error (_("Bad entry type in core file %s."),
2451 bfd_get_filename (core_bfd
));
2455 /* Add rec to record arch list. */
2456 record_full_arch_list_add (rec
);
2459 discard_cleanups (old_cleanups
);
2461 /* Add record_full_arch_list_head to the end of record list. */
2462 record_full_first
.next
= record_full_arch_list_head
;
2463 record_full_arch_list_head
->prev
= &record_full_first
;
2464 record_full_arch_list_tail
->next
= NULL
;
2465 record_full_list
= &record_full_first
;
2467 /* Update record_full_insn_max_num. */
2468 if (record_full_insn_num
> record_full_insn_max_num
)
2470 record_full_insn_max_num
= record_full_insn_num
;
2471 warning (_("Auto increase record/replay buffer limit to %u."),
2472 record_full_insn_max_num
);
2476 printf_filtered (_("Restored records from core file %s.\n"),
2477 bfd_get_filename (core_bfd
));
2479 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2482 /* bfdcore_write -- write bytes into a core file section. */
2485 bfdcore_write (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2487 int ret
= bfd_set_section_contents (obfd
, osec
, buf
, *offset
, len
);
2492 error (_("Failed to write %d bytes to core file %s ('%s')."),
2493 len
, bfd_get_filename (obfd
),
2494 bfd_errmsg (bfd_get_error ()));
2497 /* Restore the execution log from a file. We use a modified elf
2498 corefile format, with an extra section for our data. */
2501 cmd_record_full_restore (char *args
, int from_tty
)
2503 core_file_command (args
, from_tty
);
2504 record_full_open (args
, from_tty
);
2508 record_full_save_cleanups (void *data
)
2511 char *pathname
= xstrdup (bfd_get_filename (obfd
));
2513 gdb_bfd_unref (obfd
);
2518 /* Save the execution log to a file. We use a modified elf corefile
2519 format, with an extra section for our data. */
2522 record_full_save (struct target_ops
*self
, const char *recfilename
)
2524 struct record_full_entry
*cur_record_full_list
;
2526 struct regcache
*regcache
;
2527 struct gdbarch
*gdbarch
;
2528 struct cleanup
*old_cleanups
;
2529 struct cleanup
*set_cleanups
;
2532 asection
*osec
= NULL
;
2535 /* Open the save file. */
2537 fprintf_unfiltered (gdb_stdlog
, "Saving execution log to core file '%s'\n",
2540 /* Open the output file. */
2541 obfd
= create_gcore_bfd (recfilename
);
2542 old_cleanups
= make_cleanup (record_full_save_cleanups
, obfd
);
2544 /* Save the current record entry to "cur_record_full_list". */
2545 cur_record_full_list
= record_full_list
;
2547 /* Get the values of regcache and gdbarch. */
2548 regcache
= get_current_regcache ();
2549 gdbarch
= get_regcache_arch (regcache
);
2551 /* Disable the GDB operation record. */
2552 set_cleanups
= record_full_gdb_operation_disable_set ();
2554 /* Reverse execute to the begin of record list. */
2557 /* Check for beginning and end of log. */
2558 if (record_full_list
== &record_full_first
)
2561 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2563 if (record_full_list
->prev
)
2564 record_full_list
= record_full_list
->prev
;
2567 /* Compute the size needed for the extra bfd section. */
2568 save_size
= 4; /* magic cookie */
2569 for (record_full_list
= record_full_first
.next
; record_full_list
;
2570 record_full_list
= record_full_list
->next
)
2571 switch (record_full_list
->type
)
2573 case record_full_end
:
2574 save_size
+= 1 + 4 + 4;
2576 case record_full_reg
:
2577 save_size
+= 1 + 4 + record_full_list
->u
.reg
.len
;
2579 case record_full_mem
:
2580 save_size
+= 1 + 4 + 8 + record_full_list
->u
.mem
.len
;
2584 /* Make the new bfd section. */
2585 osec
= bfd_make_section_anyway_with_flags (obfd
, "precord",
2589 error (_("Failed to create 'precord' section for corefile %s: %s"),
2591 bfd_errmsg (bfd_get_error ()));
2592 bfd_set_section_size (obfd
, osec
, save_size
);
2593 bfd_set_section_vma (obfd
, osec
, 0);
2594 bfd_set_section_alignment (obfd
, osec
, 0);
2595 bfd_section_lma (obfd
, osec
) = 0;
2597 /* Save corefile state. */
2598 write_gcore_file (obfd
);
2600 /* Write out the record log. */
2601 /* Write the magic code. */
2602 magic
= RECORD_FULL_FILE_MAGIC
;
2604 fprintf_unfiltered (gdb_stdlog
,
2605 " Writing 4-byte magic cookie "
2606 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2607 phex_nz (magic
, 4));
2608 bfdcore_write (obfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2610 /* Save the entries to recfd and forward execute to the end of
2612 record_full_list
= &record_full_first
;
2616 if (record_full_list
!= &record_full_first
)
2619 uint32_t regnum
, len
, signal
, count
;
2622 type
= record_full_list
->type
;
2623 bfdcore_write (obfd
, osec
, &type
, sizeof (type
), &bfd_offset
);
2625 switch (record_full_list
->type
)
2627 case record_full_reg
: /* reg */
2629 fprintf_unfiltered (gdb_stdlog
,
2630 " Writing register %d (1 "
2631 "plus %lu plus %d bytes)\n",
2632 record_full_list
->u
.reg
.num
,
2633 (unsigned long) sizeof (regnum
),
2634 record_full_list
->u
.reg
.len
);
2637 regnum
= netorder32 (record_full_list
->u
.reg
.num
);
2638 bfdcore_write (obfd
, osec
, ®num
,
2639 sizeof (regnum
), &bfd_offset
);
2642 bfdcore_write (obfd
, osec
,
2643 record_full_get_loc (record_full_list
),
2644 record_full_list
->u
.reg
.len
, &bfd_offset
);
2647 case record_full_mem
: /* mem */
2649 fprintf_unfiltered (gdb_stdlog
,
2650 " Writing memory %s (1 plus "
2651 "%lu plus %lu plus %d bytes)\n",
2653 record_full_list
->u
.mem
.addr
),
2654 (unsigned long) sizeof (addr
),
2655 (unsigned long) sizeof (len
),
2656 record_full_list
->u
.mem
.len
);
2659 len
= netorder32 (record_full_list
->u
.mem
.len
);
2660 bfdcore_write (obfd
, osec
, &len
, sizeof (len
), &bfd_offset
);
2662 /* Write memaddr. */
2663 addr
= netorder64 (record_full_list
->u
.mem
.addr
);
2664 bfdcore_write (obfd
, osec
, &addr
,
2665 sizeof (addr
), &bfd_offset
);
2668 bfdcore_write (obfd
, osec
,
2669 record_full_get_loc (record_full_list
),
2670 record_full_list
->u
.mem
.len
, &bfd_offset
);
2673 case record_full_end
:
2675 fprintf_unfiltered (gdb_stdlog
,
2676 " Writing record_full_end (1 + "
2677 "%lu + %lu bytes)\n",
2678 (unsigned long) sizeof (signal
),
2679 (unsigned long) sizeof (count
));
2680 /* Write signal value. */
2681 signal
= netorder32 (record_full_list
->u
.end
.sigval
);
2682 bfdcore_write (obfd
, osec
, &signal
,
2683 sizeof (signal
), &bfd_offset
);
2685 /* Write insn count. */
2686 count
= netorder32 (record_full_list
->u
.end
.insn_num
);
2687 bfdcore_write (obfd
, osec
, &count
,
2688 sizeof (count
), &bfd_offset
);
2693 /* Execute entry. */
2694 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2696 if (record_full_list
->next
)
2697 record_full_list
= record_full_list
->next
;
2702 /* Reverse execute to cur_record_full_list. */
2705 /* Check for beginning and end of log. */
2706 if (record_full_list
== cur_record_full_list
)
2709 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2711 if (record_full_list
->prev
)
2712 record_full_list
= record_full_list
->prev
;
2715 do_cleanups (set_cleanups
);
2716 gdb_bfd_unref (obfd
);
2717 discard_cleanups (old_cleanups
);
2720 printf_filtered (_("Saved core file %s with execution log.\n"),
2724 /* record_full_goto_insn -- rewind the record log (forward or backward,
2725 depending on DIR) to the given entry, changing the program state
2729 record_full_goto_insn (struct record_full_entry
*entry
,
2730 enum exec_direction_kind dir
)
2732 struct cleanup
*set_cleanups
= record_full_gdb_operation_disable_set ();
2733 struct regcache
*regcache
= get_current_regcache ();
2734 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2736 /* Assume everything is valid: we will hit the entry,
2737 and we will not hit the end of the recording. */
2739 if (dir
== EXEC_FORWARD
)
2740 record_full_list
= record_full_list
->next
;
2744 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2745 if (dir
== EXEC_REVERSE
)
2746 record_full_list
= record_full_list
->prev
;
2748 record_full_list
= record_full_list
->next
;
2749 } while (record_full_list
!= entry
);
2750 do_cleanups (set_cleanups
);
2753 /* Alias for "target record-full". */
2756 cmd_record_full_start (char *args
, int from_tty
)
2758 execute_command ("target record-full", from_tty
);
2762 set_record_full_insn_max_num (char *args
, int from_tty
,
2763 struct cmd_list_element
*c
)
2765 if (record_full_insn_num
> record_full_insn_max_num
)
2767 /* Count down record_full_insn_num while releasing records from list. */
2768 while (record_full_insn_num
> record_full_insn_max_num
)
2770 record_full_list_release_first ();
2771 record_full_insn_num
--;
2776 /* The "set record full" command. */
2779 set_record_full_command (char *args
, int from_tty
)
2781 printf_unfiltered (_("\"set record full\" must be followed "
2782 "by an apporpriate subcommand.\n"));
2783 help_list (set_record_full_cmdlist
, "set record full ", all_commands
,
2787 /* The "show record full" command. */
2790 show_record_full_command (char *args
, int from_tty
)
2792 cmd_show_list (show_record_full_cmdlist
, from_tty
, "");
2795 /* Provide a prototype to silence -Wmissing-prototypes. */
2796 extern initialize_file_ftype _initialize_record_full
;
2799 _initialize_record_full (void)
2801 struct cmd_list_element
*c
;
2803 /* Init record_full_first. */
2804 record_full_first
.prev
= NULL
;
2805 record_full_first
.next
= NULL
;
2806 record_full_first
.type
= record_full_end
;
2808 init_record_full_ops ();
2809 add_target (&record_full_ops
);
2810 add_deprecated_target_alias (&record_full_ops
, "record");
2811 init_record_full_core_ops ();
2812 add_target (&record_full_core_ops
);
2814 add_prefix_cmd ("full", class_obscure
, cmd_record_full_start
,
2815 _("Start full execution recording."), &record_full_cmdlist
,
2816 "record full ", 0, &record_cmdlist
);
2818 c
= add_cmd ("restore", class_obscure
, cmd_record_full_restore
,
2819 _("Restore the execution log from a file.\n\
2820 Argument is filename. File must be created with 'record save'."),
2821 &record_full_cmdlist
);
2822 set_cmd_completer (c
, filename_completer
);
2824 /* Deprecate the old version without "full" prefix. */
2825 c
= add_alias_cmd ("restore", "full restore", class_obscure
, 1,
2827 set_cmd_completer (c
, filename_completer
);
2828 deprecate_cmd (c
, "record full restore");
2830 add_prefix_cmd ("full", class_support
, set_record_full_command
,
2831 _("Set record options"), &set_record_full_cmdlist
,
2832 "set record full ", 0, &set_record_cmdlist
);
2834 add_prefix_cmd ("full", class_support
, show_record_full_command
,
2835 _("Show record options"), &show_record_full_cmdlist
,
2836 "show record full ", 0, &show_record_cmdlist
);
2838 /* Record instructions number limit command. */
2839 add_setshow_boolean_cmd ("stop-at-limit", no_class
,
2840 &record_full_stop_at_limit
, _("\
2841 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2842 Show whether record/replay stops when record/replay buffer becomes full."),
2843 _("Default is ON.\n\
2844 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2845 When OFF, if the record/replay buffer becomes full,\n\
2846 delete the oldest recorded instruction to make room for each new one."),
2848 &set_record_full_cmdlist
, &show_record_full_cmdlist
);
2850 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2851 &set_record_cmdlist
);
2852 deprecate_cmd (c
, "set record full stop-at-limit");
2854 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2855 &show_record_cmdlist
);
2856 deprecate_cmd (c
, "show record full stop-at-limit");
2858 add_setshow_uinteger_cmd ("insn-number-max", no_class
,
2859 &record_full_insn_max_num
,
2860 _("Set record/replay buffer limit."),
2861 _("Show record/replay buffer limit."), _("\
2862 Set the maximum number of instructions to be stored in the\n\
2863 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2864 limit. Default is 200000."),
2865 set_record_full_insn_max_num
,
2866 NULL
, &set_record_full_cmdlist
,
2867 &show_record_full_cmdlist
);
2869 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2870 &set_record_cmdlist
);
2871 deprecate_cmd (c
, "set record full insn-number-max");
2873 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2874 &show_record_cmdlist
);
2875 deprecate_cmd (c
, "show record full insn-number-max");
2877 add_setshow_boolean_cmd ("memory-query", no_class
,
2878 &record_full_memory_query
, _("\
2879 Set whether query if PREC cannot record memory change of next instruction."),
2881 Show whether query if PREC cannot record memory change of next instruction."),
2884 When ON, query if PREC cannot record memory change of next instruction."),
2886 &set_record_full_cmdlist
,
2887 &show_record_full_cmdlist
);
2889 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2890 &set_record_cmdlist
);
2891 deprecate_cmd (c
, "set record full memory-query");
2893 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2894 &show_record_cmdlist
);
2895 deprecate_cmd (c
, "show record full memory-query");