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 = get_regcache_arch (regcache);
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 = get_regcache_arch (regcache);
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++;
640 struct record_full_message_args {
641 struct regcache *regcache;
642 enum gdb_signal signal;
646 record_full_message_wrapper (void *args)
648 struct record_full_message_args *record_full_args
649 = (struct record_full_message_args *) args;
651 return record_full_message (record_full_args->regcache,
652 record_full_args->signal);
656 record_full_message_wrapper_safe (struct regcache *regcache,
657 enum gdb_signal signal)
659 struct record_full_message_args args;
661 args.regcache = regcache;
662 args.signal = signal;
664 return catch_errors (record_full_message_wrapper, &args, "",
668 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
669 doesn't need record. */
671 static int record_full_gdb_operation_disable = 0;
674 record_full_gdb_operation_disable_set (void)
676 struct cleanup *old_cleanups = NULL;
679 make_cleanup_restore_integer (&record_full_gdb_operation_disable);
680 record_full_gdb_operation_disable = 1;
685 /* Flag set to TRUE for target_stopped_by_watchpoint. */
686 static enum target_stop_reason record_full_stop_reason
687 = TARGET_STOPPED_BY_NO_REASON;
689 /* Execute one instruction from the record log. Each instruction in
690 the log will be represented by an arbitrary sequence of register
691 entries and memory entries, followed by an 'end' entry. */
694 record_full_exec_insn (struct regcache *regcache,
695 struct gdbarch *gdbarch,
696 struct record_full_entry *entry)
700 case record_full_reg: /* reg */
702 gdb::byte_vector reg (entry->u.reg.len);
704 if (record_debug > 1)
705 fprintf_unfiltered (gdb_stdlog,
706 "Process record: record_full_reg %s to "
707 "inferior num = %d.\n",
708 host_address_to_string (entry),
711 regcache_cooked_read (regcache, entry->u.reg.num, reg.data ());
712 regcache_cooked_write (regcache, entry->u.reg.num,
713 record_full_get_loc (entry));
714 memcpy (record_full_get_loc (entry), reg.data (), entry->u.reg.len);
718 case record_full_mem: /* mem */
720 /* Nothing to do if the entry is flagged not_accessible. */
721 if (!entry->u.mem.mem_entry_not_accessible)
723 gdb_byte *mem = (gdb_byte *) xmalloc (entry->u.mem.len);
724 struct cleanup *cleanup = make_cleanup (xfree, mem);
726 if (record_debug > 1)
727 fprintf_unfiltered (gdb_stdlog,
728 "Process record: record_full_mem %s to "
729 "inferior addr = %s len = %d.\n",
730 host_address_to_string (entry),
731 paddress (gdbarch, entry->u.mem.addr),
734 if (record_read_memory (gdbarch,
735 entry->u.mem.addr, mem, entry->u.mem.len))
736 entry->u.mem.mem_entry_not_accessible = 1;
739 if (target_write_memory (entry->u.mem.addr,
740 record_full_get_loc (entry),
743 entry->u.mem.mem_entry_not_accessible = 1;
745 warning (_("Process record: error writing memory at "
746 "addr = %s len = %d."),
747 paddress (gdbarch, entry->u.mem.addr),
752 memcpy (record_full_get_loc (entry), mem,
755 /* We've changed memory --- check if a hardware
756 watchpoint should trap. Note that this
757 presently assumes the target beneath supports
758 continuable watchpoints. On non-continuable
759 watchpoints target, we'll want to check this
760 _before_ actually doing the memory change, and
761 not doing the change at all if the watchpoint
763 if (hardware_watchpoint_inserted_in_range
764 (get_regcache_aspace (regcache),
765 entry->u.mem.addr, entry->u.mem.len))
766 record_full_stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
770 do_cleanups (cleanup);
777 static void record_full_restore (void);
779 /* Asynchronous signal handle registered as event loop source for when
780 we have pending events ready to be passed to the core. */
782 static struct async_event_handler *record_full_async_inferior_event_token;
785 record_full_async_inferior_event_handler (gdb_client_data data)
787 inferior_event_handler (INF_REG_EVENT, NULL);
790 /* Open the process record target. */
793 record_full_core_open_1 (const char *name, int from_tty)
795 struct regcache *regcache = get_current_regcache ();
796 int regnum = gdbarch_num_regs (get_regcache_arch (regcache));
799 /* Get record_full_core_regbuf. */
800 target_fetch_registers (regcache, -1);
801 record_full_core_regbuf = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE * regnum);
802 for (i = 0; i < regnum; i ++)
803 regcache_raw_collect (regcache, i,
804 record_full_core_regbuf + MAX_REGISTER_SIZE * i);
806 /* Get record_full_core_start and record_full_core_end. */
807 if (build_section_table (core_bfd, &record_full_core_start,
808 &record_full_core_end))
810 xfree (record_full_core_regbuf);
811 record_full_core_regbuf = NULL;
812 error (_("\"%s\": Can't find sections: %s"),
813 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
816 push_target (&record_full_core_ops);
817 record_full_restore ();
820 /* "to_open" target method for 'live' processes. */
823 record_full_open_1 (const char *name, int from_tty)
826 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open_1\n");
829 if (!target_has_execution)
830 error (_("Process record: the program is not being run."));
832 error (_("Process record target can't debug inferior in non-stop mode "
835 if (!gdbarch_process_record_p (target_gdbarch ()))
836 error (_("Process record: the current architecture doesn't support "
837 "record function."));
839 push_target (&record_full_ops);
842 static void record_full_init_record_breakpoints (void);
844 /* "to_open" target method. Open the process record target. */
847 record_full_open (const char *name, int from_tty)
849 struct target_ops *t;
852 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
857 record_full_insn_num = 0;
858 record_full_insn_count = 0;
859 record_full_list = &record_full_first;
860 record_full_list->next = NULL;
863 record_full_core_open_1 (name, from_tty);
865 record_full_open_1 (name, from_tty);
867 /* Register extra event sources in the event loop. */
868 record_full_async_inferior_event_token
869 = create_async_event_handler (record_full_async_inferior_event_handler,
872 record_full_init_record_breakpoints ();
874 observer_notify_record_changed (current_inferior (), 1, "full", NULL);
877 /* "to_close" target method. Close the process record target. */
880 record_full_close (struct target_ops *self)
882 struct record_full_core_buf_entry *entry;
885 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_close\n");
887 record_full_list_release (record_full_list);
889 /* Release record_full_core_regbuf. */
890 if (record_full_core_regbuf)
892 xfree (record_full_core_regbuf);
893 record_full_core_regbuf = NULL;
896 /* Release record_full_core_buf_list. */
897 if (record_full_core_buf_list)
899 for (entry = record_full_core_buf_list->prev; entry;
902 xfree (record_full_core_buf_list);
903 record_full_core_buf_list = entry;
905 record_full_core_buf_list = NULL;
908 if (record_full_async_inferior_event_token)
909 delete_async_event_handler (&record_full_async_inferior_event_token);
912 /* "to_async" target method. */
915 record_full_async (struct target_ops *ops, int enable)
918 mark_async_event_handler (record_full_async_inferior_event_token);
920 clear_async_event_handler (record_full_async_inferior_event_token);
922 ops->beneath->to_async (ops->beneath, enable);
925 static int record_full_resume_step = 0;
927 /* True if we've been resumed, and so each record_full_wait call should
928 advance execution. If this is false, record_full_wait will return a
929 TARGET_WAITKIND_IGNORE. */
930 static int record_full_resumed = 0;
932 /* The execution direction of the last resume we got. This is
933 necessary for async mode. Vis (order is not strictly accurate):
935 1. user has the global execution direction set to forward
936 2. user does a reverse-step command
937 3. record_full_resume is called with global execution direction
938 temporarily switched to reverse
939 4. GDB's execution direction is reverted back to forward
940 5. target record notifies event loop there's an event to handle
941 6. infrun asks the target which direction was it going, and switches
942 the global execution direction accordingly (to reverse)
943 7. infrun polls an event out of the record target, and handles it
944 8. GDB goes back to the event loop, and goto #4.
946 static enum exec_direction_kind record_full_execution_dir = EXEC_FORWARD;
948 /* "to_resume" target method. Resume the process record target. */
951 record_full_resume (struct target_ops *ops, ptid_t ptid, int step,
952 enum gdb_signal signal)
954 record_full_resume_step = step;
955 record_full_resumed = 1;
956 record_full_execution_dir = execution_direction;
958 if (!RECORD_FULL_IS_REPLAY)
960 struct gdbarch *gdbarch = target_thread_architecture (ptid);
962 record_full_message (get_current_regcache (), signal);
966 /* This is not hard single step. */
967 if (!gdbarch_software_single_step_p (gdbarch))
969 /* This is a normal continue. */
974 /* This arch supports soft single step. */
975 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
977 /* This is a soft single step. */
978 record_full_resume_step = 1;
981 step = !insert_single_step_breakpoints (gdbarch);
985 /* Make sure the target beneath reports all signals. */
986 target_pass_signals (0, NULL);
988 ops->beneath->to_resume (ops->beneath, ptid, step, signal);
991 /* We are about to start executing the inferior (or simulate it),
992 let's register it with the event loop. */
993 if (target_can_async_p ())
997 /* "to_commit_resume" method for process record target. */
1000 record_full_commit_resume (struct target_ops *ops)
1002 if (!RECORD_FULL_IS_REPLAY)
1003 ops->beneath->to_commit_resume (ops->beneath);
1006 static int record_full_get_sig = 0;
1008 /* SIGINT signal handler, registered by "to_wait" method. */
1011 record_full_sig_handler (int signo)
1014 fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
1016 /* It will break the running inferior in replay mode. */
1017 record_full_resume_step = 1;
1019 /* It will let record_full_wait set inferior status to get the signal
1021 record_full_get_sig = 1;
1025 record_full_wait_cleanups (void *ignore)
1027 if (execution_direction == EXEC_REVERSE)
1029 if (record_full_list->next)
1030 record_full_list = record_full_list->next;
1033 record_full_list = record_full_list->prev;
1036 /* "to_wait" target method for process record target.
1038 In record mode, the target is always run in singlestep mode
1039 (even when gdb says to continue). The to_wait method intercepts
1040 the stop events and determines which ones are to be passed on to
1041 gdb. Most stop events are just singlestep events that gdb is not
1042 to know about, so the to_wait method just records them and keeps
1045 In replay mode, this function emulates the recorded execution log,
1046 one instruction at a time (forward or backward), and determines
1050 record_full_wait_1 (struct target_ops *ops,
1051 ptid_t ptid, struct target_waitstatus *status,
1054 struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
1057 fprintf_unfiltered (gdb_stdlog,
1058 "Process record: record_full_wait "
1059 "record_full_resume_step = %d, "
1060 "record_full_resumed = %d, direction=%s\n",
1061 record_full_resume_step, record_full_resumed,
1062 record_full_execution_dir == EXEC_FORWARD
1063 ? "forward" : "reverse");
1065 if (!record_full_resumed)
1067 gdb_assert ((options & TARGET_WNOHANG) != 0);
1069 /* No interesting event. */
1070 status->kind = TARGET_WAITKIND_IGNORE;
1071 return minus_one_ptid;
1074 record_full_get_sig = 0;
1075 signal (SIGINT, record_full_sig_handler);
1077 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1079 if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
1081 if (record_full_resume_step)
1083 /* This is a single step. */
1084 return ops->beneath->to_wait (ops->beneath, ptid, status, options);
1088 /* This is not a single step. */
1091 struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);
1095 struct thread_info *tp;
1097 ret = ops->beneath->to_wait (ops->beneath, ptid, status, options);
1098 if (status->kind == TARGET_WAITKIND_IGNORE)
1101 fprintf_unfiltered (gdb_stdlog,
1102 "Process record: record_full_wait "
1103 "target beneath not done yet\n");
1107 ALL_NON_EXITED_THREADS (tp)
1108 delete_single_step_breakpoints (tp);
1110 if (record_full_resume_step)
1113 /* Is this a SIGTRAP? */
1114 if (status->kind == TARGET_WAITKIND_STOPPED
1115 && status->value.sig == GDB_SIGNAL_TRAP)
1117 struct regcache *regcache;
1118 struct address_space *aspace;
1119 enum target_stop_reason *stop_reason_p
1120 = &record_full_stop_reason;
1122 /* Yes -- this is likely our single-step finishing,
1123 but check if there's any reason the core would be
1124 interested in the event. */
1126 registers_changed ();
1127 regcache = get_current_regcache ();
1128 tmp_pc = regcache_read_pc (regcache);
1129 aspace = get_regcache_aspace (regcache);
1131 if (target_stopped_by_watchpoint ())
1133 /* Always interested in watchpoints. */
1135 else if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1138 /* There is a breakpoint here. Let the core
1143 /* This is a single-step trap. Record the
1144 insn and issue another step.
1145 FIXME: this part can be a random SIGTRAP too.
1146 But GDB cannot handle it. */
1149 if (!record_full_message_wrapper_safe (regcache,
1152 status->kind = TARGET_WAITKIND_STOPPED;
1153 status->value.sig = GDB_SIGNAL_0;
1157 if (gdbarch_software_single_step_p (gdbarch))
1159 /* Try to insert the software single step breakpoint.
1160 If insert success, set step to 0. */
1161 set_executing (inferior_ptid, 0);
1162 reinit_frame_cache ();
1164 step = !insert_single_step_breakpoints (gdbarch);
1166 set_executing (inferior_ptid, 1);
1170 fprintf_unfiltered (gdb_stdlog,
1171 "Process record: record_full_wait "
1172 "issuing one more step in the "
1173 "target beneath\n");
1174 ops->beneath->to_resume (ops->beneath, ptid, step,
1176 ops->beneath->to_commit_resume (ops->beneath);
1181 /* The inferior is broken by a breakpoint or a signal. */
1190 struct regcache *regcache = get_current_regcache ();
1191 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1192 struct address_space *aspace = get_regcache_aspace (regcache);
1193 int continue_flag = 1;
1194 int first_record_full_end = 1;
1195 struct cleanup *old_cleanups
1196 = make_cleanup (record_full_wait_cleanups, 0);
1199 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1200 status->kind = TARGET_WAITKIND_STOPPED;
1202 /* Check breakpoint when forward execute. */
1203 if (execution_direction == EXEC_FORWARD)
1205 tmp_pc = regcache_read_pc (regcache);
1206 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1207 &record_full_stop_reason))
1210 fprintf_unfiltered (gdb_stdlog,
1211 "Process record: break at %s.\n",
1212 paddress (gdbarch, tmp_pc));
1217 /* If GDB is in terminal_inferior mode, it will not get the signal.
1218 And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1219 mode, because inferior will not executed.
1220 Then set it to terminal_ours to make GDB get the signal. */
1221 target_terminal::ours ();
1223 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1225 if (execution_direction == EXEC_FORWARD && record_full_list->next)
1226 record_full_list = record_full_list->next;
1228 /* Loop over the record_full_list, looking for the next place to
1232 /* Check for beginning and end of log. */
1233 if (execution_direction == EXEC_REVERSE
1234 && record_full_list == &record_full_first)
1236 /* Hit beginning of record log in reverse. */
1237 status->kind = TARGET_WAITKIND_NO_HISTORY;
1240 if (execution_direction != EXEC_REVERSE && !record_full_list->next)
1242 /* Hit end of record log going forward. */
1243 status->kind = TARGET_WAITKIND_NO_HISTORY;
1247 record_full_exec_insn (regcache, gdbarch, record_full_list);
1249 if (record_full_list->type == record_full_end)
1251 if (record_debug > 1)
1252 fprintf_unfiltered (gdb_stdlog,
1253 "Process record: record_full_end %s to "
1255 host_address_to_string (record_full_list));
1257 if (first_record_full_end && execution_direction == EXEC_REVERSE)
1259 /* When reverse excute, the first record_full_end is the
1260 part of current instruction. */
1261 first_record_full_end = 0;
1265 /* In EXEC_REVERSE mode, this is the record_full_end of prev
1267 In EXEC_FORWARD mode, this is the record_full_end of
1268 current instruction. */
1270 if (record_full_resume_step)
1272 if (record_debug > 1)
1273 fprintf_unfiltered (gdb_stdlog,
1274 "Process record: step.\n");
1278 /* check breakpoint */
1279 tmp_pc = regcache_read_pc (regcache);
1280 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1281 &record_full_stop_reason))
1284 fprintf_unfiltered (gdb_stdlog,
1285 "Process record: break "
1287 paddress (gdbarch, tmp_pc));
1292 if (record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
1295 fprintf_unfiltered (gdb_stdlog,
1296 "Process record: hit hw "
1300 /* Check target signal */
1301 if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1302 /* FIXME: better way to check */
1309 if (execution_direction == EXEC_REVERSE)
1311 if (record_full_list->prev)
1312 record_full_list = record_full_list->prev;
1316 if (record_full_list->next)
1317 record_full_list = record_full_list->next;
1321 while (continue_flag);
1324 if (record_full_get_sig)
1325 status->value.sig = GDB_SIGNAL_INT;
1326 else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1327 /* FIXME: better way to check */
1328 status->value.sig = record_full_list->u.end.sigval;
1330 status->value.sig = GDB_SIGNAL_TRAP;
1332 discard_cleanups (old_cleanups);
1335 signal (SIGINT, handle_sigint);
1337 do_cleanups (set_cleanups);
1338 return inferior_ptid;
1342 record_full_wait (struct target_ops *ops,
1343 ptid_t ptid, struct target_waitstatus *status,
1348 return_ptid = record_full_wait_1 (ops, ptid, status, options);
1349 if (status->kind != TARGET_WAITKIND_IGNORE)
1351 /* We're reporting a stop. Make sure any spurious
1352 target_wait(WNOHANG) doesn't advance the target until the
1353 core wants us resumed again. */
1354 record_full_resumed = 0;
1360 record_full_stopped_by_watchpoint (struct target_ops *ops)
1362 if (RECORD_FULL_IS_REPLAY)
1363 return record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
1365 return ops->beneath->to_stopped_by_watchpoint (ops->beneath);
1369 record_full_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
1371 if (RECORD_FULL_IS_REPLAY)
1374 return ops->beneath->to_stopped_data_address (ops->beneath, addr_p);
1377 /* The to_stopped_by_sw_breakpoint method of target record-full. */
1380 record_full_stopped_by_sw_breakpoint (struct target_ops *ops)
1382 return record_full_stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
1385 /* The to_supports_stopped_by_sw_breakpoint method of target
1389 record_full_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
1394 /* The to_stopped_by_hw_breakpoint method of target record-full. */
1397 record_full_stopped_by_hw_breakpoint (struct target_ops *ops)
1399 return record_full_stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
1402 /* The to_supports_stopped_by_sw_breakpoint method of target
1406 record_full_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
1411 /* Record registers change (by user or by GDB) to list as an instruction. */
1414 record_full_registers_change (struct regcache *regcache, int regnum)
1416 /* Check record_full_insn_num. */
1417 record_full_check_insn_num ();
1419 record_full_arch_list_head = NULL;
1420 record_full_arch_list_tail = NULL;
1426 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
1428 if (record_full_arch_list_add_reg (regcache, i))
1430 record_full_list_release (record_full_arch_list_tail);
1431 error (_("Process record: failed to record execution log."));
1437 if (record_full_arch_list_add_reg (regcache, regnum))
1439 record_full_list_release (record_full_arch_list_tail);
1440 error (_("Process record: failed to record execution log."));
1443 if (record_full_arch_list_add_end ())
1445 record_full_list_release (record_full_arch_list_tail);
1446 error (_("Process record: failed to record execution log."));
1448 record_full_list->next = record_full_arch_list_head;
1449 record_full_arch_list_head->prev = record_full_list;
1450 record_full_list = record_full_arch_list_tail;
1452 if (record_full_insn_num == record_full_insn_max_num)
1453 record_full_list_release_first ();
1455 record_full_insn_num++;
1458 /* "to_store_registers" method for process record target. */
1461 record_full_store_registers (struct target_ops *ops,
1462 struct regcache *regcache,
1465 if (!record_full_gdb_operation_disable)
1467 if (RECORD_FULL_IS_REPLAY)
1471 /* Let user choose if he wants to write register or not. */
1474 query (_("Because GDB is in replay mode, changing the "
1475 "value of a register will make the execution "
1476 "log unusable from this point onward. "
1477 "Change all registers?"));
1480 query (_("Because GDB is in replay mode, changing the value "
1481 "of a register will make the execution log unusable "
1482 "from this point onward. Change register %s?"),
1483 gdbarch_register_name (get_regcache_arch (regcache),
1488 /* Invalidate the value of regcache that was set in function
1489 "regcache_raw_write". */
1495 i < gdbarch_num_regs (get_regcache_arch (regcache));
1497 regcache_invalidate (regcache, i);
1500 regcache_invalidate (regcache, regno);
1502 error (_("Process record canceled the operation."));
1505 /* Destroy the record from here forward. */
1506 record_full_list_release_following (record_full_list);
1509 record_full_registers_change (regcache, regno);
1511 ops->beneath->to_store_registers (ops->beneath, regcache, regno);
1514 /* "to_xfer_partial" method. Behavior is conditional on
1515 RECORD_FULL_IS_REPLAY.
1516 In replay mode, we cannot write memory unles we are willing to
1517 invalidate the record/replay log from this point forward. */
1519 static enum target_xfer_status
1520 record_full_xfer_partial (struct target_ops *ops, enum target_object object,
1521 const char *annex, gdb_byte *readbuf,
1522 const gdb_byte *writebuf, ULONGEST offset,
1523 ULONGEST len, ULONGEST *xfered_len)
1525 if (!record_full_gdb_operation_disable
1526 && (object == TARGET_OBJECT_MEMORY
1527 || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
1529 if (RECORD_FULL_IS_REPLAY)
1531 /* Let user choose if he wants to write memory or not. */
1532 if (!query (_("Because GDB is in replay mode, writing to memory "
1533 "will make the execution log unusable from this "
1534 "point onward. Write memory at address %s?"),
1535 paddress (target_gdbarch (), offset)))
1536 error (_("Process record canceled the operation."));
1538 /* Destroy the record from here forward. */
1539 record_full_list_release_following (record_full_list);
1542 /* Check record_full_insn_num */
1543 record_full_check_insn_num ();
1545 /* Record registers change to list as an instruction. */
1546 record_full_arch_list_head = NULL;
1547 record_full_arch_list_tail = NULL;
1548 if (record_full_arch_list_add_mem (offset, len))
1550 record_full_list_release (record_full_arch_list_tail);
1552 fprintf_unfiltered (gdb_stdlog,
1553 "Process record: failed to record "
1555 return TARGET_XFER_E_IO;
1557 if (record_full_arch_list_add_end ())
1559 record_full_list_release (record_full_arch_list_tail);
1561 fprintf_unfiltered (gdb_stdlog,
1562 "Process record: failed to record "
1564 return TARGET_XFER_E_IO;
1566 record_full_list->next = record_full_arch_list_head;
1567 record_full_arch_list_head->prev = record_full_list;
1568 record_full_list = record_full_arch_list_tail;
1570 if (record_full_insn_num == record_full_insn_max_num)
1571 record_full_list_release_first ();
1573 record_full_insn_num++;
1576 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1577 readbuf, writebuf, offset,
1581 /* This structure represents a breakpoint inserted while the record
1582 target is active. We use this to know when to install/remove
1583 breakpoints in/from the target beneath. For example, a breakpoint
1584 may be inserted while recording, but removed when not replaying nor
1585 recording. In that case, the breakpoint had not been inserted on
1586 the target beneath, so we should not try to remove it there. */
1588 struct record_full_breakpoint
1590 /* The address and address space the breakpoint was set at. */
1591 struct address_space *address_space;
1594 /* True when the breakpoint has been also installed in the target
1595 beneath. This will be false for breakpoints set during replay or
1597 int in_target_beneath;
1600 typedef struct record_full_breakpoint *record_full_breakpoint_p;
1601 DEF_VEC_P(record_full_breakpoint_p);
1603 /* The list of breakpoints inserted while the record target is
1605 VEC(record_full_breakpoint_p) *record_full_breakpoints = NULL;
1608 record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
1610 if (loc->loc_type != bp_loc_software_breakpoint)
1615 struct record_full_breakpoint *bp = XNEW (struct record_full_breakpoint);
1617 bp->addr = loc->target_info.placed_address;
1618 bp->address_space = loc->target_info.placed_address_space;
1620 bp->in_target_beneath = 1;
1622 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1626 /* Sync existing breakpoints to record_full_breakpoints. */
1629 record_full_init_record_breakpoints (void)
1631 VEC_free (record_full_breakpoint_p, record_full_breakpoints);
1633 iterate_over_bp_locations (record_full_sync_record_breakpoints);
1636 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1637 insert or remove breakpoints in the real target when replaying, nor
1641 record_full_insert_breakpoint (struct target_ops *ops,
1642 struct gdbarch *gdbarch,
1643 struct bp_target_info *bp_tgt)
1645 struct record_full_breakpoint *bp;
1646 int in_target_beneath = 0;
1649 if (!RECORD_FULL_IS_REPLAY)
1651 /* When recording, we currently always single-step, so we don't
1652 really need to install regular breakpoints in the inferior.
1653 However, we do have to insert software single-step
1654 breakpoints, in case the target can't hardware step. To keep
1655 things simple, we always insert. */
1656 struct cleanup *old_cleanups;
1659 old_cleanups = record_full_gdb_operation_disable_set ();
1660 ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
1661 do_cleanups (old_cleanups);
1666 in_target_beneath = 1;
1669 /* Use the existing entries if found in order to avoid duplication
1670 in record_full_breakpoints. */
1673 VEC_iterate (record_full_breakpoint_p,
1674 record_full_breakpoints, ix, bp);
1677 if (bp->addr == bp_tgt->placed_address
1678 && bp->address_space == bp_tgt->placed_address_space)
1680 gdb_assert (bp->in_target_beneath == in_target_beneath);
1685 bp = XNEW (struct record_full_breakpoint);
1686 bp->addr = bp_tgt->placed_address;
1687 bp->address_space = bp_tgt->placed_address_space;
1688 bp->in_target_beneath = in_target_beneath;
1689 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1693 /* "to_remove_breakpoint" method for process record target. */
1696 record_full_remove_breakpoint (struct target_ops *ops,
1697 struct gdbarch *gdbarch,
1698 struct bp_target_info *bp_tgt,
1699 enum remove_bp_reason reason)
1701 struct record_full_breakpoint *bp;
1705 VEC_iterate (record_full_breakpoint_p,
1706 record_full_breakpoints, ix, bp);
1709 if (bp->addr == bp_tgt->placed_address
1710 && bp->address_space == bp_tgt->placed_address_space)
1712 if (bp->in_target_beneath)
1714 struct cleanup *old_cleanups;
1717 old_cleanups = record_full_gdb_operation_disable_set ();
1718 ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch,
1720 do_cleanups (old_cleanups);
1726 if (reason == REMOVE_BREAKPOINT)
1728 VEC_unordered_remove (record_full_breakpoint_p,
1729 record_full_breakpoints, ix);
1735 gdb_assert_not_reached ("removing unknown breakpoint");
1738 /* "to_can_execute_reverse" method for process record target. */
1741 record_full_can_execute_reverse (struct target_ops *self)
1746 /* "to_get_bookmark" method for process record and prec over core. */
1749 record_full_get_bookmark (struct target_ops *self, const char *args,
1754 /* Return stringified form of instruction count. */
1755 if (record_full_list && record_full_list->type == record_full_end)
1756 ret = xstrdup (pulongest (record_full_list->u.end.insn_num));
1761 fprintf_unfiltered (gdb_stdlog,
1762 "record_full_get_bookmark returns %s\n", ret);
1764 fprintf_unfiltered (gdb_stdlog,
1765 "record_full_get_bookmark returns NULL\n");
1767 return (gdb_byte *) ret;
1770 /* "to_goto_bookmark" method for process record and prec over core. */
1773 record_full_goto_bookmark (struct target_ops *self,
1774 const gdb_byte *raw_bookmark, int from_tty)
1776 const char *bookmark = (const char *) raw_bookmark;
1777 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1780 fprintf_unfiltered (gdb_stdlog,
1781 "record_full_goto_bookmark receives %s\n", bookmark);
1783 if (bookmark[0] == '\'' || bookmark[0] == '\"')
1787 if (bookmark[strlen (bookmark) - 1] != bookmark[0])
1788 error (_("Unbalanced quotes: %s"), bookmark);
1791 copy = savestring (bookmark + 1, strlen (bookmark) - 2);
1792 make_cleanup (xfree, copy);
1796 record_goto (bookmark);
1798 do_cleanups (cleanup);
1801 static enum exec_direction_kind
1802 record_full_execution_direction (struct target_ops *self)
1804 return record_full_execution_dir;
1807 /* The to_record_method method of target record-full. */
1810 record_full_record_method (struct target_ops *self, ptid_t ptid)
1812 return RECORD_METHOD_FULL;
1816 record_full_info (struct target_ops *self)
1818 struct record_full_entry *p;
1820 if (RECORD_FULL_IS_REPLAY)
1821 printf_filtered (_("Replay mode:\n"));
1823 printf_filtered (_("Record mode:\n"));
1825 /* Find entry for first actual instruction in the log. */
1826 for (p = record_full_first.next;
1827 p != NULL && p->type != record_full_end;
1831 /* Do we have a log at all? */
1832 if (p != NULL && p->type == record_full_end)
1834 /* Display instruction number for first instruction in the log. */
1835 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1836 pulongest (p->u.end.insn_num));
1838 /* If in replay mode, display where we are in the log. */
1839 if (RECORD_FULL_IS_REPLAY)
1840 printf_filtered (_("Current instruction number is %s.\n"),
1841 pulongest (record_full_list->u.end.insn_num));
1843 /* Display instruction number for last instruction in the log. */
1844 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1845 pulongest (record_full_insn_count));
1847 /* Display log count. */
1848 printf_filtered (_("Log contains %u instructions.\n"),
1849 record_full_insn_num);
1852 printf_filtered (_("No instructions have been logged.\n"));
1854 /* Display max log size. */
1855 printf_filtered (_("Max logged instructions is %u.\n"),
1856 record_full_insn_max_num);
1859 /* The "to_record_delete" target method. */
1862 record_full_delete (struct target_ops *self)
1864 record_full_list_release_following (record_full_list);
1867 /* The "to_record_is_replaying" target method. */
1870 record_full_is_replaying (struct target_ops *self, ptid_t ptid)
1872 return RECORD_FULL_IS_REPLAY;
1875 /* The "to_record_will_replay" target method. */
1878 record_full_will_replay (struct target_ops *self, ptid_t ptid, int dir)
1880 /* We can currently only record when executing forwards. Should we be able
1881 to record when executing backwards on targets that support reverse
1882 execution, this needs to be changed. */
1884 return RECORD_FULL_IS_REPLAY || dir == EXEC_REVERSE;
1887 /* Go to a specific entry. */
1890 record_full_goto_entry (struct record_full_entry *p)
1893 error (_("Target insn not found."));
1894 else if (p == record_full_list)
1895 error (_("Already at target insn."));
1896 else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
1898 printf_filtered (_("Go forward to insn number %s\n"),
1899 pulongest (p->u.end.insn_num));
1900 record_full_goto_insn (p, EXEC_FORWARD);
1904 printf_filtered (_("Go backward to insn number %s\n"),
1905 pulongest (p->u.end.insn_num));
1906 record_full_goto_insn (p, EXEC_REVERSE);
1909 registers_changed ();
1910 reinit_frame_cache ();
1911 stop_pc = regcache_read_pc (get_current_regcache ());
1912 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1915 /* The "to_goto_record_begin" target method. */
1918 record_full_goto_begin (struct target_ops *self)
1920 struct record_full_entry *p = NULL;
1922 for (p = &record_full_first; p != NULL; p = p->next)
1923 if (p->type == record_full_end)
1926 record_full_goto_entry (p);
1929 /* The "to_goto_record_end" target method. */
1932 record_full_goto_end (struct target_ops *self)
1934 struct record_full_entry *p = NULL;
1936 for (p = record_full_list; p->next != NULL; p = p->next)
1938 for (; p!= NULL; p = p->prev)
1939 if (p->type == record_full_end)
1942 record_full_goto_entry (p);
1945 /* The "to_goto_record" target method. */
1948 record_full_goto (struct target_ops *self, ULONGEST target_insn)
1950 struct record_full_entry *p = NULL;
1952 for (p = &record_full_first; p != NULL; p = p->next)
1953 if (p->type == record_full_end && p->u.end.insn_num == target_insn)
1956 record_full_goto_entry (p);
1959 /* The "to_record_stop_replaying" target method. */
1962 record_full_stop_replaying (struct target_ops *self)
1964 record_full_goto_end (self);
1968 init_record_full_ops (void)
1970 record_full_ops.to_shortname = "record-full";
1971 record_full_ops.to_longname = "Process record and replay target";
1972 record_full_ops.to_doc =
1973 "Log program while executing and replay execution from log.";
1974 record_full_ops.to_open = record_full_open;
1975 record_full_ops.to_close = record_full_close;
1976 record_full_ops.to_async = record_full_async;
1977 record_full_ops.to_resume = record_full_resume;
1978 record_full_ops.to_commit_resume = record_full_commit_resume;
1979 record_full_ops.to_wait = record_full_wait;
1980 record_full_ops.to_disconnect = record_disconnect;
1981 record_full_ops.to_detach = record_detach;
1982 record_full_ops.to_mourn_inferior = record_mourn_inferior;
1983 record_full_ops.to_kill = record_kill;
1984 record_full_ops.to_store_registers = record_full_store_registers;
1985 record_full_ops.to_xfer_partial = record_full_xfer_partial;
1986 record_full_ops.to_insert_breakpoint = record_full_insert_breakpoint;
1987 record_full_ops.to_remove_breakpoint = record_full_remove_breakpoint;
1988 record_full_ops.to_stopped_by_watchpoint = record_full_stopped_by_watchpoint;
1989 record_full_ops.to_stopped_data_address = record_full_stopped_data_address;
1990 record_full_ops.to_stopped_by_sw_breakpoint
1991 = record_full_stopped_by_sw_breakpoint;
1992 record_full_ops.to_supports_stopped_by_sw_breakpoint
1993 = record_full_supports_stopped_by_sw_breakpoint;
1994 record_full_ops.to_stopped_by_hw_breakpoint
1995 = record_full_stopped_by_hw_breakpoint;
1996 record_full_ops.to_supports_stopped_by_hw_breakpoint
1997 = record_full_supports_stopped_by_hw_breakpoint;
1998 record_full_ops.to_can_execute_reverse = record_full_can_execute_reverse;
1999 record_full_ops.to_stratum = record_stratum;
2000 /* Add bookmark target methods. */
2001 record_full_ops.to_get_bookmark = record_full_get_bookmark;
2002 record_full_ops.to_goto_bookmark = record_full_goto_bookmark;
2003 record_full_ops.to_execution_direction = record_full_execution_direction;
2004 record_full_ops.to_record_method = record_full_record_method;
2005 record_full_ops.to_info_record = record_full_info;
2006 record_full_ops.to_save_record = record_full_save;
2007 record_full_ops.to_delete_record = record_full_delete;
2008 record_full_ops.to_record_is_replaying = record_full_is_replaying;
2009 record_full_ops.to_record_will_replay = record_full_will_replay;
2010 record_full_ops.to_record_stop_replaying = record_full_stop_replaying;
2011 record_full_ops.to_goto_record_begin = record_full_goto_begin;
2012 record_full_ops.to_goto_record_end = record_full_goto_end;
2013 record_full_ops.to_goto_record = record_full_goto;
2014 record_full_ops.to_magic = OPS_MAGIC;
2017 /* "to_resume" method for prec over corefile. */
2020 record_full_core_resume (struct target_ops *ops, ptid_t ptid, int step,
2021 enum gdb_signal signal)
2023 record_full_resume_step = step;
2024 record_full_resumed = 1;
2025 record_full_execution_dir = execution_direction;
2027 /* We are about to start executing the inferior (or simulate it),
2028 let's register it with the event loop. */
2029 if (target_can_async_p ())
2033 /* "to_kill" method for prec over corefile. */
2036 record_full_core_kill (struct target_ops *ops)
2039 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
2041 unpush_target (&record_full_core_ops);
2044 /* "to_fetch_registers" method for prec over corefile. */
2047 record_full_core_fetch_registers (struct target_ops *ops,
2048 struct regcache *regcache,
2053 int num = gdbarch_num_regs (get_regcache_arch (regcache));
2056 for (i = 0; i < num; i ++)
2057 regcache_raw_supply (regcache, i,
2058 record_full_core_regbuf + MAX_REGISTER_SIZE * i);
2061 regcache_raw_supply (regcache, regno,
2062 record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2065 /* "to_prepare_to_store" method for prec over corefile. */
2068 record_full_core_prepare_to_store (struct target_ops *self,
2069 struct regcache *regcache)
2073 /* "to_store_registers" method for prec over corefile. */
2076 record_full_core_store_registers (struct target_ops *ops,
2077 struct regcache *regcache,
2080 if (record_full_gdb_operation_disable)
2081 regcache_raw_collect (regcache, regno,
2082 record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2084 error (_("You can't do that without a process to debug."));
2087 /* "to_xfer_partial" method for prec over corefile. */
2089 static enum target_xfer_status
2090 record_full_core_xfer_partial (struct target_ops *ops,
2091 enum target_object object,
2092 const char *annex, gdb_byte *readbuf,
2093 const gdb_byte *writebuf, ULONGEST offset,
2094 ULONGEST len, ULONGEST *xfered_len)
2096 if (object == TARGET_OBJECT_MEMORY)
2098 if (record_full_gdb_operation_disable || !writebuf)
2100 struct target_section *p;
2102 for (p = record_full_core_start; p < record_full_core_end; p++)
2104 if (offset >= p->addr)
2106 struct record_full_core_buf_entry *entry;
2107 ULONGEST sec_offset;
2109 if (offset >= p->endaddr)
2112 if (offset + len > p->endaddr)
2113 len = p->endaddr - offset;
2115 sec_offset = offset - p->addr;
2117 /* Read readbuf or write writebuf p, offset, len. */
2119 if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
2120 || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
2123 memset (readbuf, 0, len);
2126 return TARGET_XFER_OK;
2128 /* Get record_full_core_buf_entry. */
2129 for (entry = record_full_core_buf_list; entry;
2130 entry = entry->prev)
2137 /* Add a new entry. */
2138 entry = XNEW (struct record_full_core_buf_entry);
2140 if (!bfd_malloc_and_get_section
2141 (p->the_bfd_section->owner,
2146 return TARGET_XFER_EOF;
2148 entry->prev = record_full_core_buf_list;
2149 record_full_core_buf_list = entry;
2152 memcpy (entry->buf + sec_offset, writebuf,
2158 return ops->beneath->to_xfer_partial (ops->beneath,
2164 memcpy (readbuf, entry->buf + sec_offset,
2169 return TARGET_XFER_OK;
2173 return TARGET_XFER_E_IO;
2176 error (_("You can't do that without a process to debug."));
2179 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2180 readbuf, writebuf, offset, len,
2184 /* "to_insert_breakpoint" method for prec over corefile. */
2187 record_full_core_insert_breakpoint (struct target_ops *ops,
2188 struct gdbarch *gdbarch,
2189 struct bp_target_info *bp_tgt)
2194 /* "to_remove_breakpoint" method for prec over corefile. */
2197 record_full_core_remove_breakpoint (struct target_ops *ops,
2198 struct gdbarch *gdbarch,
2199 struct bp_target_info *bp_tgt,
2200 enum remove_bp_reason reason)
2205 /* "to_has_execution" method for prec over corefile. */
2208 record_full_core_has_execution (struct target_ops *ops, ptid_t the_ptid)
2214 init_record_full_core_ops (void)
2216 record_full_core_ops.to_shortname = "record-core";
2217 record_full_core_ops.to_longname = "Process record and replay target";
2218 record_full_core_ops.to_doc =
2219 "Log program while executing and replay execution from log.";
2220 record_full_core_ops.to_open = record_full_open;
2221 record_full_core_ops.to_close = record_full_close;
2222 record_full_core_ops.to_async = record_full_async;
2223 record_full_core_ops.to_resume = record_full_core_resume;
2224 record_full_core_ops.to_wait = record_full_wait;
2225 record_full_core_ops.to_kill = record_full_core_kill;
2226 record_full_core_ops.to_fetch_registers = record_full_core_fetch_registers;
2227 record_full_core_ops.to_prepare_to_store = record_full_core_prepare_to_store;
2228 record_full_core_ops.to_store_registers = record_full_core_store_registers;
2229 record_full_core_ops.to_xfer_partial = record_full_core_xfer_partial;
2230 record_full_core_ops.to_insert_breakpoint
2231 = record_full_core_insert_breakpoint;
2232 record_full_core_ops.to_remove_breakpoint
2233 = record_full_core_remove_breakpoint;
2234 record_full_core_ops.to_stopped_by_watchpoint
2235 = record_full_stopped_by_watchpoint;
2236 record_full_core_ops.to_stopped_data_address
2237 = record_full_stopped_data_address;
2238 record_full_core_ops.to_stopped_by_sw_breakpoint
2239 = record_full_stopped_by_sw_breakpoint;
2240 record_full_core_ops.to_supports_stopped_by_sw_breakpoint
2241 = record_full_supports_stopped_by_sw_breakpoint;
2242 record_full_core_ops.to_stopped_by_hw_breakpoint
2243 = record_full_stopped_by_hw_breakpoint;
2244 record_full_core_ops.to_supports_stopped_by_hw_breakpoint
2245 = record_full_supports_stopped_by_hw_breakpoint;
2246 record_full_core_ops.to_can_execute_reverse
2247 = record_full_can_execute_reverse;
2248 record_full_core_ops.to_has_execution = record_full_core_has_execution;
2249 record_full_core_ops.to_stratum = record_stratum;
2250 /* Add bookmark target methods. */
2251 record_full_core_ops.to_get_bookmark = record_full_get_bookmark;
2252 record_full_core_ops.to_goto_bookmark = record_full_goto_bookmark;
2253 record_full_core_ops.to_execution_direction
2254 = record_full_execution_direction;
2255 record_full_core_ops.to_record_method = record_full_record_method;
2256 record_full_core_ops.to_info_record = record_full_info;
2257 record_full_core_ops.to_delete_record = record_full_delete;
2258 record_full_core_ops.to_record_is_replaying = record_full_is_replaying;
2259 record_full_core_ops.to_record_will_replay = record_full_will_replay;
2260 record_full_core_ops.to_goto_record_begin = record_full_goto_begin;
2261 record_full_core_ops.to_goto_record_end = record_full_goto_end;
2262 record_full_core_ops.to_goto_record = record_full_goto;
2263 record_full_core_ops.to_magic = OPS_MAGIC;
2266 /* Record log save-file format
2267 Version 1 (never released)
2270 4 bytes: magic number htonl(0x20090829).
2271 NOTE: be sure to change whenever this file format changes!
2275 1 byte: record type (record_full_end, see enum record_full_type).
2277 1 byte: record type (record_full_reg, see enum record_full_type).
2278 8 bytes: register id (network byte order).
2279 MAX_REGISTER_SIZE bytes: register value.
2281 1 byte: record type (record_full_mem, see enum record_full_type).
2282 8 bytes: memory length (network byte order).
2283 8 bytes: memory address (network byte order).
2284 n bytes: memory value (n == memory length).
2287 4 bytes: magic number netorder32(0x20091016).
2288 NOTE: be sure to change whenever this file format changes!
2292 1 byte: record type (record_full_end, see enum record_full_type).
2294 4 bytes: instruction count
2296 1 byte: record type (record_full_reg, see enum record_full_type).
2297 4 bytes: register id (network byte order).
2298 n bytes: register value (n == actual register size).
2299 (eg. 4 bytes for x86 general registers).
2301 1 byte: record type (record_full_mem, see enum record_full_type).
2302 4 bytes: memory length (network byte order).
2303 8 bytes: memory address (network byte order).
2304 n bytes: memory value (n == memory length).
2308 /* bfdcore_read -- read bytes from a core file section. */
2311 bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2313 int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2318 error (_("Failed to read %d bytes from core file %s ('%s')."),
2319 len, bfd_get_filename (obfd),
2320 bfd_errmsg (bfd_get_error ()));
2323 static inline uint64_t
2324 netorder64 (uint64_t input)
2328 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2329 BFD_ENDIAN_BIG, input);
2333 static inline uint32_t
2334 netorder32 (uint32_t input)
2338 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2339 BFD_ENDIAN_BIG, input);
2343 /* Restore the execution log from a core_bfd file. */
2345 record_full_restore (void)
2348 struct cleanup *old_cleanups;
2349 struct record_full_entry *rec;
2353 struct regcache *regcache;
2355 /* We restore the execution log from the open core bfd,
2357 if (core_bfd == NULL)
2360 /* "record_full_restore" can only be called when record list is empty. */
2361 gdb_assert (record_full_first.next == NULL);
2364 fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
2366 /* Now need to find our special note section. */
2367 osec = bfd_get_section_by_name (core_bfd, "null0");
2369 fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
2370 osec ? "succeeded" : "failed");
2373 osec_size = bfd_section_size (core_bfd, osec);
2375 fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
2377 /* Check the magic code. */
2378 bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
2379 if (magic != RECORD_FULL_FILE_MAGIC)
2380 error (_("Version mis-match or file format error in core file %s."),
2381 bfd_get_filename (core_bfd));
2383 fprintf_unfiltered (gdb_stdlog,
2384 " Reading 4-byte magic cookie "
2385 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2386 phex_nz (netorder32 (magic), 4));
2388 /* Restore the entries in recfd into record_full_arch_list_head and
2389 record_full_arch_list_tail. */
2390 record_full_arch_list_head = NULL;
2391 record_full_arch_list_tail = NULL;
2392 record_full_insn_num = 0;
2393 old_cleanups = make_cleanup (record_full_arch_list_cleanups, 0);
2394 regcache = get_current_regcache ();
2399 uint32_t regnum, len, signal, count;
2402 /* We are finished when offset reaches osec_size. */
2403 if (bfd_offset >= osec_size)
2405 bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);
2409 case record_full_reg: /* reg */
2410 /* Get register number to regnum. */
2411 bfdcore_read (core_bfd, osec, ®num,
2412 sizeof (regnum), &bfd_offset);
2413 regnum = netorder32 (regnum);
2415 rec = record_full_reg_alloc (regcache, regnum);
2418 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2419 rec->u.reg.len, &bfd_offset);
2422 fprintf_unfiltered (gdb_stdlog,
2423 " Reading register %d (1 "
2424 "plus %lu plus %d bytes)\n",
2426 (unsigned long) sizeof (regnum),
2430 case record_full_mem: /* mem */
2432 bfdcore_read (core_bfd, osec, &len,
2433 sizeof (len), &bfd_offset);
2434 len = netorder32 (len);
2437 bfdcore_read (core_bfd, osec, &addr,
2438 sizeof (addr), &bfd_offset);
2439 addr = netorder64 (addr);
2441 rec = record_full_mem_alloc (addr, len);
2444 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2445 rec->u.mem.len, &bfd_offset);
2448 fprintf_unfiltered (gdb_stdlog,
2449 " Reading memory %s (1 plus "
2450 "%lu plus %lu plus %d bytes)\n",
2451 paddress (get_current_arch (),
2453 (unsigned long) sizeof (addr),
2454 (unsigned long) sizeof (len),
2458 case record_full_end: /* end */
2459 rec = record_full_end_alloc ();
2460 record_full_insn_num ++;
2462 /* Get signal value. */
2463 bfdcore_read (core_bfd, osec, &signal,
2464 sizeof (signal), &bfd_offset);
2465 signal = netorder32 (signal);
2466 rec->u.end.sigval = (enum gdb_signal) signal;
2468 /* Get insn count. */
2469 bfdcore_read (core_bfd, osec, &count,
2470 sizeof (count), &bfd_offset);
2471 count = netorder32 (count);
2472 rec->u.end.insn_num = count;
2473 record_full_insn_count = count + 1;
2475 fprintf_unfiltered (gdb_stdlog,
2476 " Reading record_full_end (1 + "
2477 "%lu + %lu bytes), offset == %s\n",
2478 (unsigned long) sizeof (signal),
2479 (unsigned long) sizeof (count),
2480 paddress (get_current_arch (),
2485 error (_("Bad entry type in core file %s."),
2486 bfd_get_filename (core_bfd));
2490 /* Add rec to record arch list. */
2491 record_full_arch_list_add (rec);
2494 discard_cleanups (old_cleanups);
2496 /* Add record_full_arch_list_head to the end of record list. */
2497 record_full_first.next = record_full_arch_list_head;
2498 record_full_arch_list_head->prev = &record_full_first;
2499 record_full_arch_list_tail->next = NULL;
2500 record_full_list = &record_full_first;
2502 /* Update record_full_insn_max_num. */
2503 if (record_full_insn_num > record_full_insn_max_num)
2505 record_full_insn_max_num = record_full_insn_num;
2506 warning (_("Auto increase record/replay buffer limit to %u."),
2507 record_full_insn_max_num);
2511 printf_filtered (_("Restored records from core file %s.\n"),
2512 bfd_get_filename (core_bfd));
2514 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2517 /* bfdcore_write -- write bytes into a core file section. */
2520 bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2522 int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2527 error (_("Failed to write %d bytes to core file %s ('%s')."),
2528 len, bfd_get_filename (obfd),
2529 bfd_errmsg (bfd_get_error ()));
2532 /* Restore the execution log from a file. We use a modified elf
2533 corefile format, with an extra section for our data. */
2536 cmd_record_full_restore (char *args, int from_tty)
2538 core_file_command (args, from_tty);
2539 record_full_open (args, from_tty);
2542 /* Save the execution log to a file. We use a modified elf corefile
2543 format, with an extra section for our data. */
2546 record_full_save (struct target_ops *self, const char *recfilename)
2548 struct record_full_entry *cur_record_full_list;
2550 struct regcache *regcache;
2551 struct gdbarch *gdbarch;
2552 struct cleanup *set_cleanups;
2554 asection *osec = NULL;
2557 /* Open the save file. */
2559 fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
2562 /* Open the output file. */
2563 gdb_bfd_ref_ptr obfd (create_gcore_bfd (recfilename));
2565 /* Arrange to remove the output file on failure. */
2566 gdb::unlinker unlink_file (recfilename);
2568 /* Save the current record entry to "cur_record_full_list". */
2569 cur_record_full_list = record_full_list;
2571 /* Get the values of regcache and gdbarch. */
2572 regcache = get_current_regcache ();
2573 gdbarch = get_regcache_arch (regcache);
2575 /* Disable the GDB operation record. */
2576 set_cleanups = record_full_gdb_operation_disable_set ();
2578 /* Reverse execute to the begin of record list. */
2581 /* Check for beginning and end of log. */
2582 if (record_full_list == &record_full_first)
2585 record_full_exec_insn (regcache, gdbarch, record_full_list);
2587 if (record_full_list->prev)
2588 record_full_list = record_full_list->prev;
2591 /* Compute the size needed for the extra bfd section. */
2592 save_size = 4; /* magic cookie */
2593 for (record_full_list = record_full_first.next; record_full_list;
2594 record_full_list = record_full_list->next)
2595 switch (record_full_list->type)
2597 case record_full_end:
2598 save_size += 1 + 4 + 4;
2600 case record_full_reg:
2601 save_size += 1 + 4 + record_full_list->u.reg.len;
2603 case record_full_mem:
2604 save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
2608 /* Make the new bfd section. */
2609 osec = bfd_make_section_anyway_with_flags (obfd.get (), "precord",
2613 error (_("Failed to create 'precord' section for corefile %s: %s"),
2615 bfd_errmsg (bfd_get_error ()));
2616 bfd_set_section_size (obfd.get (), osec, save_size);
2617 bfd_set_section_vma (obfd.get (), osec, 0);
2618 bfd_set_section_alignment (obfd.get (), osec, 0);
2619 bfd_section_lma (obfd.get (), osec) = 0;
2621 /* Save corefile state. */
2622 write_gcore_file (obfd.get ());
2624 /* Write out the record log. */
2625 /* Write the magic code. */
2626 magic = RECORD_FULL_FILE_MAGIC;
2628 fprintf_unfiltered (gdb_stdlog,
2629 " Writing 4-byte magic cookie "
2630 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2631 phex_nz (magic, 4));
2632 bfdcore_write (obfd.get (), osec, &magic, sizeof (magic), &bfd_offset);
2634 /* Save the entries to recfd and forward execute to the end of
2636 record_full_list = &record_full_first;
2640 if (record_full_list != &record_full_first)
2643 uint32_t regnum, len, signal, count;
2646 type = record_full_list->type;
2647 bfdcore_write (obfd.get (), osec, &type, sizeof (type), &bfd_offset);
2649 switch (record_full_list->type)
2651 case record_full_reg: /* reg */
2653 fprintf_unfiltered (gdb_stdlog,
2654 " Writing register %d (1 "
2655 "plus %lu plus %d bytes)\n",
2656 record_full_list->u.reg.num,
2657 (unsigned long) sizeof (regnum),
2658 record_full_list->u.reg.len);
2661 regnum = netorder32 (record_full_list->u.reg.num);
2662 bfdcore_write (obfd.get (), osec, ®num,
2663 sizeof (regnum), &bfd_offset);
2666 bfdcore_write (obfd.get (), osec,
2667 record_full_get_loc (record_full_list),
2668 record_full_list->u.reg.len, &bfd_offset);
2671 case record_full_mem: /* mem */
2673 fprintf_unfiltered (gdb_stdlog,
2674 " Writing memory %s (1 plus "
2675 "%lu plus %lu plus %d bytes)\n",
2677 record_full_list->u.mem.addr),
2678 (unsigned long) sizeof (addr),
2679 (unsigned long) sizeof (len),
2680 record_full_list->u.mem.len);
2683 len = netorder32 (record_full_list->u.mem.len);
2684 bfdcore_write (obfd.get (), osec, &len, sizeof (len),
2687 /* Write memaddr. */
2688 addr = netorder64 (record_full_list->u.mem.addr);
2689 bfdcore_write (obfd.get (), osec, &addr,
2690 sizeof (addr), &bfd_offset);
2693 bfdcore_write (obfd.get (), osec,
2694 record_full_get_loc (record_full_list),
2695 record_full_list->u.mem.len, &bfd_offset);
2698 case record_full_end:
2700 fprintf_unfiltered (gdb_stdlog,
2701 " Writing record_full_end (1 + "
2702 "%lu + %lu bytes)\n",
2703 (unsigned long) sizeof (signal),
2704 (unsigned long) sizeof (count));
2705 /* Write signal value. */
2706 signal = netorder32 (record_full_list->u.end.sigval);
2707 bfdcore_write (obfd.get (), osec, &signal,
2708 sizeof (signal), &bfd_offset);
2710 /* Write insn count. */
2711 count = netorder32 (record_full_list->u.end.insn_num);
2712 bfdcore_write (obfd.get (), osec, &count,
2713 sizeof (count), &bfd_offset);
2718 /* Execute entry. */
2719 record_full_exec_insn (regcache, gdbarch, record_full_list);
2721 if (record_full_list->next)
2722 record_full_list = record_full_list->next;
2727 /* Reverse execute to cur_record_full_list. */
2730 /* Check for beginning and end of log. */
2731 if (record_full_list == cur_record_full_list)
2734 record_full_exec_insn (regcache, gdbarch, record_full_list);
2736 if (record_full_list->prev)
2737 record_full_list = record_full_list->prev;
2740 do_cleanups (set_cleanups);
2741 unlink_file.keep ();
2744 printf_filtered (_("Saved core file %s with execution log.\n"),
2748 /* record_full_goto_insn -- rewind the record log (forward or backward,
2749 depending on DIR) to the given entry, changing the program state
2753 record_full_goto_insn (struct record_full_entry *entry,
2754 enum exec_direction_kind dir)
2756 struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
2757 struct regcache *regcache = get_current_regcache ();
2758 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2760 /* Assume everything is valid: we will hit the entry,
2761 and we will not hit the end of the recording. */
2763 if (dir == EXEC_FORWARD)
2764 record_full_list = record_full_list->next;
2768 record_full_exec_insn (regcache, gdbarch, record_full_list);
2769 if (dir == EXEC_REVERSE)
2770 record_full_list = record_full_list->prev;
2772 record_full_list = record_full_list->next;
2773 } while (record_full_list != entry);
2774 do_cleanups (set_cleanups);
2777 /* Alias for "target record-full". */
2780 cmd_record_full_start (char *args, int from_tty)
2782 execute_command ((char *) "target record-full", from_tty);
2786 set_record_full_insn_max_num (char *args, int from_tty,
2787 struct cmd_list_element *c)
2789 if (record_full_insn_num > record_full_insn_max_num)
2791 /* Count down record_full_insn_num while releasing records from list. */
2792 while (record_full_insn_num > record_full_insn_max_num)
2794 record_full_list_release_first ();
2795 record_full_insn_num--;
2800 /* The "set record full" command. */
2803 set_record_full_command (char *args, int from_tty)
2805 printf_unfiltered (_("\"set record full\" must be followed "
2806 "by an apporpriate subcommand.\n"));
2807 help_list (set_record_full_cmdlist, "set record full ", all_commands,
2811 /* The "show record full" command. */
2814 show_record_full_command (char *args, int from_tty)
2816 cmd_show_list (show_record_full_cmdlist, from_tty, "");
2820 _initialize_record_full (void)
2822 struct cmd_list_element *c;
2824 /* Init record_full_first. */
2825 record_full_first.prev = NULL;
2826 record_full_first.next = NULL;
2827 record_full_first.type = record_full_end;
2829 init_record_full_ops ();
2830 add_target (&record_full_ops);
2831 add_deprecated_target_alias (&record_full_ops, "record");
2832 init_record_full_core_ops ();
2833 add_target (&record_full_core_ops);
2835 add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
2836 _("Start full execution recording."), &record_full_cmdlist,
2837 "record full ", 0, &record_cmdlist);
2839 c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
2840 _("Restore the execution log from a file.\n\
2841 Argument is filename. File must be created with 'record save'."),
2842 &record_full_cmdlist);
2843 set_cmd_completer (c, filename_completer);
2845 /* Deprecate the old version without "full" prefix. */
2846 c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
2848 set_cmd_completer (c, filename_completer);
2849 deprecate_cmd (c, "record full restore");
2851 add_prefix_cmd ("full", class_support, set_record_full_command,
2852 _("Set record options"), &set_record_full_cmdlist,
2853 "set record full ", 0, &set_record_cmdlist);
2855 add_prefix_cmd ("full", class_support, show_record_full_command,
2856 _("Show record options"), &show_record_full_cmdlist,
2857 "show record full ", 0, &show_record_cmdlist);
2859 /* Record instructions number limit command. */
2860 add_setshow_boolean_cmd ("stop-at-limit", no_class,
2861 &record_full_stop_at_limit, _("\
2862 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2863 Show whether record/replay stops when record/replay buffer becomes full."),
2864 _("Default is ON.\n\
2865 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2866 When OFF, if the record/replay buffer becomes full,\n\
2867 delete the oldest recorded instruction to make room for each new one."),
2869 &set_record_full_cmdlist, &show_record_full_cmdlist);
2871 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2872 &set_record_cmdlist);
2873 deprecate_cmd (c, "set record full stop-at-limit");
2875 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2876 &show_record_cmdlist);
2877 deprecate_cmd (c, "show record full stop-at-limit");
2879 add_setshow_uinteger_cmd ("insn-number-max", no_class,
2880 &record_full_insn_max_num,
2881 _("Set record/replay buffer limit."),
2882 _("Show record/replay buffer limit."), _("\
2883 Set the maximum number of instructions to be stored in the\n\
2884 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2885 limit. Default is 200000."),
2886 set_record_full_insn_max_num,
2887 NULL, &set_record_full_cmdlist,
2888 &show_record_full_cmdlist);
2890 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2891 &set_record_cmdlist);
2892 deprecate_cmd (c, "set record full insn-number-max");
2894 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2895 &show_record_cmdlist);
2896 deprecate_cmd (c, "show record full insn-number-max");
2898 add_setshow_boolean_cmd ("memory-query", no_class,
2899 &record_full_memory_query, _("\
2900 Set whether query if PREC cannot record memory change of next instruction."),
2902 Show whether query if PREC cannot record memory change of next instruction."),
2905 When ON, query if PREC cannot record memory change of next instruction."),
2907 &set_record_full_cmdlist,
2908 &show_record_full_cmdlist);
2910 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2911 &set_record_cmdlist);
2912 deprecate_cmd (c, "set record full memory-query");
2914 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2915 &show_record_cmdlist);
2916 deprecate_cmd (c, "show record full memory-query");