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 = xcalloc (1, sizeof (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 = xcalloc (1, sizeof (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 = xcalloc (1, sizeof (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,
918 void (*callback) (enum inferior_event_type event_type,
922 if (callback != NULL)
923 mark_async_event_handler (record_full_async_inferior_event_token);
925 clear_async_event_handler (record_full_async_inferior_event_token);
927 ops->beneath->to_async (ops->beneath, callback, context);
930 static int record_full_resume_step = 0;
932 /* True if we've been resumed, and so each record_full_wait call should
933 advance execution. If this is false, record_full_wait will return a
934 TARGET_WAITKIND_IGNORE. */
935 static int record_full_resumed = 0;
937 /* The execution direction of the last resume we got. This is
938 necessary for async mode. Vis (order is not strictly accurate):
940 1. user has the global execution direction set to forward
941 2. user does a reverse-step command
942 3. record_full_resume is called with global execution direction
943 temporarily switched to reverse
944 4. GDB's execution direction is reverted back to forward
945 5. target record notifies event loop there's an event to handle
946 6. infrun asks the target which direction was it going, and switches
947 the global execution direction accordingly (to reverse)
948 7. infrun polls an event out of the record target, and handles it
949 8. GDB goes back to the event loop, and goto #4.
951 static enum exec_direction_kind record_full_execution_dir = EXEC_FORWARD;
953 /* "to_resume" target method. Resume the process record target. */
956 record_full_resume (struct target_ops *ops, ptid_t ptid, int step,
957 enum gdb_signal signal)
959 record_full_resume_step = step;
960 record_full_resumed = 1;
961 record_full_execution_dir = execution_direction;
963 if (!RECORD_FULL_IS_REPLAY)
965 struct gdbarch *gdbarch = target_thread_architecture (ptid);
967 record_full_message (get_current_regcache (), signal);
971 /* This is not hard single step. */
972 if (!gdbarch_software_single_step_p (gdbarch))
974 /* This is a normal continue. */
979 /* This arch support soft sigle step. */
980 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
982 /* This is a soft single step. */
983 record_full_resume_step = 1;
987 /* This is a continue.
988 Try to insert a soft single step breakpoint. */
989 if (!gdbarch_software_single_step (gdbarch,
990 get_current_frame ()))
992 /* This system don't want use soft single step.
993 Use hard sigle step. */
1000 /* Make sure the target beneath reports all signals. */
1001 target_pass_signals (0, NULL);
1003 ops->beneath->to_resume (ops->beneath, ptid, step, signal);
1006 /* We are about to start executing the inferior (or simulate it),
1007 let's register it with the event loop. */
1008 if (target_can_async_p ())
1009 target_async (inferior_event_handler, 0);
1012 static int record_full_get_sig = 0;
1014 /* SIGINT signal handler, registered by "to_wait" method. */
1017 record_full_sig_handler (int signo)
1020 fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
1022 /* It will break the running inferior in replay mode. */
1023 record_full_resume_step = 1;
1025 /* It will let record_full_wait set inferior status to get the signal
1027 record_full_get_sig = 1;
1031 record_full_wait_cleanups (void *ignore)
1033 if (execution_direction == EXEC_REVERSE)
1035 if (record_full_list->next)
1036 record_full_list = record_full_list->next;
1039 record_full_list = record_full_list->prev;
1042 /* "to_wait" target method for process record target.
1044 In record mode, the target is always run in singlestep mode
1045 (even when gdb says to continue). The to_wait method intercepts
1046 the stop events and determines which ones are to be passed on to
1047 gdb. Most stop events are just singlestep events that gdb is not
1048 to know about, so the to_wait method just records them and keeps
1051 In replay mode, this function emulates the recorded execution log,
1052 one instruction at a time (forward or backward), and determines
1056 record_full_wait_1 (struct target_ops *ops,
1057 ptid_t ptid, struct target_waitstatus *status,
1060 struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
1063 fprintf_unfiltered (gdb_stdlog,
1064 "Process record: record_full_wait "
1065 "record_full_resume_step = %d, "
1066 "record_full_resumed = %d, direction=%s\n",
1067 record_full_resume_step, record_full_resumed,
1068 record_full_execution_dir == EXEC_FORWARD
1069 ? "forward" : "reverse");
1071 if (!record_full_resumed)
1073 gdb_assert ((options & TARGET_WNOHANG) != 0);
1075 /* No interesting event. */
1076 status->kind = TARGET_WAITKIND_IGNORE;
1077 return minus_one_ptid;
1080 record_full_get_sig = 0;
1081 signal (SIGINT, record_full_sig_handler);
1083 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1085 if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
1087 if (record_full_resume_step)
1089 /* This is a single step. */
1090 return ops->beneath->to_wait (ops->beneath, ptid, status, options);
1094 /* This is not a single step. */
1097 struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);
1101 struct thread_info *tp;
1103 ret = ops->beneath->to_wait (ops->beneath, ptid, status, options);
1104 if (status->kind == TARGET_WAITKIND_IGNORE)
1107 fprintf_unfiltered (gdb_stdlog,
1108 "Process record: record_full_wait "
1109 "target beneath not done yet\n");
1113 ALL_NON_EXITED_THREADS (tp)
1114 delete_single_step_breakpoints (tp);
1116 if (record_full_resume_step)
1119 /* Is this a SIGTRAP? */
1120 if (status->kind == TARGET_WAITKIND_STOPPED
1121 && status->value.sig == GDB_SIGNAL_TRAP)
1123 struct regcache *regcache;
1124 struct address_space *aspace;
1125 enum target_stop_reason *stop_reason_p
1126 = &record_full_stop_reason;
1128 /* Yes -- this is likely our single-step finishing,
1129 but check if there's any reason the core would be
1130 interested in the event. */
1132 registers_changed ();
1133 regcache = get_current_regcache ();
1134 tmp_pc = regcache_read_pc (regcache);
1135 aspace = get_regcache_aspace (regcache);
1137 if (target_stopped_by_watchpoint ())
1139 /* Always interested in watchpoints. */
1141 else if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1144 /* There is a breakpoint here. Let the core
1149 /* This is a single-step trap. Record the
1150 insn and issue another step.
1151 FIXME: this part can be a random SIGTRAP too.
1152 But GDB cannot handle it. */
1155 if (!record_full_message_wrapper_safe (regcache,
1158 status->kind = TARGET_WAITKIND_STOPPED;
1159 status->value.sig = GDB_SIGNAL_0;
1163 if (gdbarch_software_single_step_p (gdbarch))
1165 /* Try to insert the software single step breakpoint.
1166 If insert success, set step to 0. */
1167 set_executing (inferior_ptid, 0);
1168 reinit_frame_cache ();
1169 if (gdbarch_software_single_step (gdbarch,
1170 get_current_frame ()))
1172 set_executing (inferior_ptid, 1);
1176 fprintf_unfiltered (gdb_stdlog,
1177 "Process record: record_full_wait "
1178 "issuing one more step in the "
1179 "target beneath\n");
1180 ops->beneath->to_resume (ops->beneath, ptid, step,
1186 /* The inferior is broken by a breakpoint or a signal. */
1195 struct regcache *regcache = get_current_regcache ();
1196 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1197 struct address_space *aspace = get_regcache_aspace (regcache);
1198 int continue_flag = 1;
1199 int first_record_full_end = 1;
1200 struct cleanup *old_cleanups
1201 = make_cleanup (record_full_wait_cleanups, 0);
1204 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1205 status->kind = TARGET_WAITKIND_STOPPED;
1207 /* Check breakpoint when forward execute. */
1208 if (execution_direction == EXEC_FORWARD)
1210 tmp_pc = regcache_read_pc (regcache);
1211 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1212 &record_full_stop_reason))
1215 fprintf_unfiltered (gdb_stdlog,
1216 "Process record: break at %s.\n",
1217 paddress (gdbarch, tmp_pc));
1222 /* If GDB is in terminal_inferior mode, it will not get the signal.
1223 And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1224 mode, because inferior will not executed.
1225 Then set it to terminal_ours to make GDB get the signal. */
1226 target_terminal_ours ();
1228 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1230 if (execution_direction == EXEC_FORWARD && record_full_list->next)
1231 record_full_list = record_full_list->next;
1233 /* Loop over the record_full_list, looking for the next place to
1237 /* Check for beginning and end of log. */
1238 if (execution_direction == EXEC_REVERSE
1239 && record_full_list == &record_full_first)
1241 /* Hit beginning of record log in reverse. */
1242 status->kind = TARGET_WAITKIND_NO_HISTORY;
1245 if (execution_direction != EXEC_REVERSE && !record_full_list->next)
1247 /* Hit end of record log going forward. */
1248 status->kind = TARGET_WAITKIND_NO_HISTORY;
1252 record_full_exec_insn (regcache, gdbarch, record_full_list);
1254 if (record_full_list->type == record_full_end)
1256 if (record_debug > 1)
1257 fprintf_unfiltered (gdb_stdlog,
1258 "Process record: record_full_end %s to "
1260 host_address_to_string (record_full_list));
1262 if (first_record_full_end && execution_direction == EXEC_REVERSE)
1264 /* When reverse excute, the first record_full_end is the
1265 part of current instruction. */
1266 first_record_full_end = 0;
1270 /* In EXEC_REVERSE mode, this is the record_full_end of prev
1272 In EXEC_FORWARD mode, this is the record_full_end of
1273 current instruction. */
1275 if (record_full_resume_step)
1277 if (record_debug > 1)
1278 fprintf_unfiltered (gdb_stdlog,
1279 "Process record: step.\n");
1283 /* check breakpoint */
1284 tmp_pc = regcache_read_pc (regcache);
1285 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1286 &record_full_stop_reason))
1289 fprintf_unfiltered (gdb_stdlog,
1290 "Process record: break "
1292 paddress (gdbarch, tmp_pc));
1297 if (record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
1300 fprintf_unfiltered (gdb_stdlog,
1301 "Process record: hit hw "
1305 /* Check target signal */
1306 if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1307 /* FIXME: better way to check */
1314 if (execution_direction == EXEC_REVERSE)
1316 if (record_full_list->prev)
1317 record_full_list = record_full_list->prev;
1321 if (record_full_list->next)
1322 record_full_list = record_full_list->next;
1326 while (continue_flag);
1329 if (record_full_get_sig)
1330 status->value.sig = GDB_SIGNAL_INT;
1331 else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1332 /* FIXME: better way to check */
1333 status->value.sig = record_full_list->u.end.sigval;
1335 status->value.sig = GDB_SIGNAL_TRAP;
1337 discard_cleanups (old_cleanups);
1340 signal (SIGINT, handle_sigint);
1342 do_cleanups (set_cleanups);
1343 return inferior_ptid;
1347 record_full_wait (struct target_ops *ops,
1348 ptid_t ptid, struct target_waitstatus *status,
1353 return_ptid = record_full_wait_1 (ops, ptid, status, options);
1354 if (status->kind != TARGET_WAITKIND_IGNORE)
1356 /* We're reporting a stop. Make sure any spurious
1357 target_wait(WNOHANG) doesn't advance the target until the
1358 core wants us resumed again. */
1359 record_full_resumed = 0;
1365 record_full_stopped_by_watchpoint (struct target_ops *ops)
1367 if (RECORD_FULL_IS_REPLAY)
1368 return record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
1370 return ops->beneath->to_stopped_by_watchpoint (ops->beneath);
1374 record_full_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
1376 if (RECORD_FULL_IS_REPLAY)
1379 return ops->beneath->to_stopped_data_address (ops->beneath, addr_p);
1382 /* The to_stopped_by_sw_breakpoint method of target record-full. */
1385 record_full_stopped_by_sw_breakpoint (struct target_ops *ops)
1387 return record_full_stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
1390 /* The to_supports_stopped_by_sw_breakpoint method of target
1394 record_full_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
1399 /* The to_stopped_by_hw_breakpoint method of target record-full. */
1402 record_full_stopped_by_hw_breakpoint (struct target_ops *ops)
1404 return record_full_stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
1407 /* The to_supports_stopped_by_sw_breakpoint method of target
1411 record_full_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
1416 /* Record registers change (by user or by GDB) to list as an instruction. */
1419 record_full_registers_change (struct regcache *regcache, int regnum)
1421 /* Check record_full_insn_num. */
1422 record_full_check_insn_num (0);
1424 record_full_arch_list_head = NULL;
1425 record_full_arch_list_tail = NULL;
1431 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
1433 if (record_full_arch_list_add_reg (regcache, i))
1435 record_full_list_release (record_full_arch_list_tail);
1436 error (_("Process record: failed to record execution log."));
1442 if (record_full_arch_list_add_reg (regcache, regnum))
1444 record_full_list_release (record_full_arch_list_tail);
1445 error (_("Process record: failed to record execution log."));
1448 if (record_full_arch_list_add_end ())
1450 record_full_list_release (record_full_arch_list_tail);
1451 error (_("Process record: failed to record execution log."));
1453 record_full_list->next = record_full_arch_list_head;
1454 record_full_arch_list_head->prev = record_full_list;
1455 record_full_list = record_full_arch_list_tail;
1457 if (record_full_insn_num == record_full_insn_max_num)
1458 record_full_list_release_first ();
1460 record_full_insn_num++;
1463 /* "to_store_registers" method for process record target. */
1466 record_full_store_registers (struct target_ops *ops,
1467 struct regcache *regcache,
1470 if (!record_full_gdb_operation_disable)
1472 if (RECORD_FULL_IS_REPLAY)
1476 /* Let user choose if he wants to write register or not. */
1479 query (_("Because GDB is in replay mode, changing the "
1480 "value of a register will make the execution "
1481 "log unusable from this point onward. "
1482 "Change all registers?"));
1485 query (_("Because GDB is in replay mode, changing the value "
1486 "of a register will make the execution log unusable "
1487 "from this point onward. Change register %s?"),
1488 gdbarch_register_name (get_regcache_arch (regcache),
1493 /* Invalidate the value of regcache that was set in function
1494 "regcache_raw_write". */
1500 i < gdbarch_num_regs (get_regcache_arch (regcache));
1502 regcache_invalidate (regcache, i);
1505 regcache_invalidate (regcache, regno);
1507 error (_("Process record canceled the operation."));
1510 /* Destroy the record from here forward. */
1511 record_full_list_release_following (record_full_list);
1514 record_full_registers_change (regcache, regno);
1516 ops->beneath->to_store_registers (ops->beneath, regcache, regno);
1519 /* "to_xfer_partial" method. Behavior is conditional on
1520 RECORD_FULL_IS_REPLAY.
1521 In replay mode, we cannot write memory unles we are willing to
1522 invalidate the record/replay log from this point forward. */
1524 static enum target_xfer_status
1525 record_full_xfer_partial (struct target_ops *ops, enum target_object object,
1526 const char *annex, gdb_byte *readbuf,
1527 const gdb_byte *writebuf, ULONGEST offset,
1528 ULONGEST len, ULONGEST *xfered_len)
1530 if (!record_full_gdb_operation_disable
1531 && (object == TARGET_OBJECT_MEMORY
1532 || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
1534 if (RECORD_FULL_IS_REPLAY)
1536 /* Let user choose if he wants to write memory or not. */
1537 if (!query (_("Because GDB is in replay mode, writing to memory "
1538 "will make the execution log unusable from this "
1539 "point onward. Write memory at address %s?"),
1540 paddress (target_gdbarch (), offset)))
1541 error (_("Process record canceled the operation."));
1543 /* Destroy the record from here forward. */
1544 record_full_list_release_following (record_full_list);
1547 /* Check record_full_insn_num */
1548 record_full_check_insn_num (0);
1550 /* Record registers change to list as an instruction. */
1551 record_full_arch_list_head = NULL;
1552 record_full_arch_list_tail = NULL;
1553 if (record_full_arch_list_add_mem (offset, len))
1555 record_full_list_release (record_full_arch_list_tail);
1557 fprintf_unfiltered (gdb_stdlog,
1558 "Process record: failed to record "
1560 return TARGET_XFER_E_IO;
1562 if (record_full_arch_list_add_end ())
1564 record_full_list_release (record_full_arch_list_tail);
1566 fprintf_unfiltered (gdb_stdlog,
1567 "Process record: failed to record "
1569 return TARGET_XFER_E_IO;
1571 record_full_list->next = record_full_arch_list_head;
1572 record_full_arch_list_head->prev = record_full_list;
1573 record_full_list = record_full_arch_list_tail;
1575 if (record_full_insn_num == record_full_insn_max_num)
1576 record_full_list_release_first ();
1578 record_full_insn_num++;
1581 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1582 readbuf, writebuf, offset,
1586 /* This structure represents a breakpoint inserted while the record
1587 target is active. We use this to know when to install/remove
1588 breakpoints in/from the target beneath. For example, a breakpoint
1589 may be inserted while recording, but removed when not replaying nor
1590 recording. In that case, the breakpoint had not been inserted on
1591 the target beneath, so we should not try to remove it there. */
1593 struct record_full_breakpoint
1595 /* The address and address space the breakpoint was set at. */
1596 struct address_space *address_space;
1599 /* True when the breakpoint has been also installed in the target
1600 beneath. This will be false for breakpoints set during replay or
1602 int in_target_beneath;
1605 typedef struct record_full_breakpoint *record_full_breakpoint_p;
1606 DEF_VEC_P(record_full_breakpoint_p);
1608 /* The list of breakpoints inserted while the record target is
1610 VEC(record_full_breakpoint_p) *record_full_breakpoints = NULL;
1613 record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
1615 if (loc->loc_type != bp_loc_software_breakpoint)
1620 struct record_full_breakpoint *bp = XNEW (struct record_full_breakpoint);
1622 bp->addr = loc->target_info.placed_address;
1623 bp->address_space = loc->target_info.placed_address_space;
1625 bp->in_target_beneath = 1;
1627 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1631 /* Sync existing breakpoints to record_full_breakpoints. */
1634 record_full_init_record_breakpoints (void)
1636 VEC_free (record_full_breakpoint_p, record_full_breakpoints);
1638 iterate_over_bp_locations (record_full_sync_record_breakpoints);
1641 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1642 insert or remove breakpoints in the real target when replaying, nor
1646 record_full_insert_breakpoint (struct target_ops *ops,
1647 struct gdbarch *gdbarch,
1648 struct bp_target_info *bp_tgt)
1650 struct record_full_breakpoint *bp;
1651 int in_target_beneath = 0;
1653 if (!RECORD_FULL_IS_REPLAY)
1655 /* When recording, we currently always single-step, so we don't
1656 really need to install regular breakpoints in the inferior.
1657 However, we do have to insert software single-step
1658 breakpoints, in case the target can't hardware step. To keep
1659 things single, we always insert. */
1660 struct cleanup *old_cleanups;
1663 old_cleanups = record_full_gdb_operation_disable_set ();
1664 ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
1665 do_cleanups (old_cleanups);
1670 in_target_beneath = 1;
1673 bp = XNEW (struct record_full_breakpoint);
1674 bp->addr = bp_tgt->placed_address;
1675 bp->address_space = bp_tgt->placed_address_space;
1676 bp->in_target_beneath = in_target_beneath;
1677 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1681 /* "to_remove_breakpoint" method for process record target. */
1684 record_full_remove_breakpoint (struct target_ops *ops,
1685 struct gdbarch *gdbarch,
1686 struct bp_target_info *bp_tgt)
1688 struct record_full_breakpoint *bp;
1692 VEC_iterate (record_full_breakpoint_p,
1693 record_full_breakpoints, ix, bp);
1696 if (bp->addr == bp_tgt->placed_address
1697 && bp->address_space == bp_tgt->placed_address_space)
1699 if (bp->in_target_beneath)
1701 struct cleanup *old_cleanups;
1704 old_cleanups = record_full_gdb_operation_disable_set ();
1705 ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch,
1707 do_cleanups (old_cleanups);
1713 VEC_unordered_remove (record_full_breakpoint_p,
1714 record_full_breakpoints, ix);
1719 gdb_assert_not_reached ("removing unknown breakpoint");
1722 /* "to_can_execute_reverse" method for process record target. */
1725 record_full_can_execute_reverse (struct target_ops *self)
1730 /* "to_get_bookmark" method for process record and prec over core. */
1733 record_full_get_bookmark (struct target_ops *self, const char *args,
1738 /* Return stringified form of instruction count. */
1739 if (record_full_list && record_full_list->type == record_full_end)
1740 ret = xstrdup (pulongest (record_full_list->u.end.insn_num));
1745 fprintf_unfiltered (gdb_stdlog,
1746 "record_full_get_bookmark returns %s\n", ret);
1748 fprintf_unfiltered (gdb_stdlog,
1749 "record_full_get_bookmark returns NULL\n");
1751 return (gdb_byte *) ret;
1754 /* "to_goto_bookmark" method for process record and prec over core. */
1757 record_full_goto_bookmark (struct target_ops *self,
1758 const gdb_byte *raw_bookmark, int from_tty)
1760 const char *bookmark = (const char *) raw_bookmark;
1761 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1764 fprintf_unfiltered (gdb_stdlog,
1765 "record_full_goto_bookmark receives %s\n", bookmark);
1767 if (bookmark[0] == '\'' || bookmark[0] == '\"')
1771 if (bookmark[strlen (bookmark) - 1] != bookmark[0])
1772 error (_("Unbalanced quotes: %s"), bookmark);
1775 copy = savestring (bookmark + 1, strlen (bookmark) - 2);
1776 make_cleanup (xfree, copy);
1780 record_goto (bookmark);
1782 do_cleanups (cleanup);
1785 static enum exec_direction_kind
1786 record_full_execution_direction (struct target_ops *self)
1788 return record_full_execution_dir;
1792 record_full_info (struct target_ops *self)
1794 struct record_full_entry *p;
1796 if (RECORD_FULL_IS_REPLAY)
1797 printf_filtered (_("Replay mode:\n"));
1799 printf_filtered (_("Record mode:\n"));
1801 /* Find entry for first actual instruction in the log. */
1802 for (p = record_full_first.next;
1803 p != NULL && p->type != record_full_end;
1807 /* Do we have a log at all? */
1808 if (p != NULL && p->type == record_full_end)
1810 /* Display instruction number for first instruction in the log. */
1811 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1812 pulongest (p->u.end.insn_num));
1814 /* If in replay mode, display where we are in the log. */
1815 if (RECORD_FULL_IS_REPLAY)
1816 printf_filtered (_("Current instruction number is %s.\n"),
1817 pulongest (record_full_list->u.end.insn_num));
1819 /* Display instruction number for last instruction in the log. */
1820 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1821 pulongest (record_full_insn_count));
1823 /* Display log count. */
1824 printf_filtered (_("Log contains %u instructions.\n"),
1825 record_full_insn_num);
1828 printf_filtered (_("No instructions have been logged.\n"));
1830 /* Display max log size. */
1831 printf_filtered (_("Max logged instructions is %u.\n"),
1832 record_full_insn_max_num);
1835 /* The "to_record_delete" target method. */
1838 record_full_delete (struct target_ops *self)
1840 record_full_list_release_following (record_full_list);
1843 /* The "to_record_is_replaying" target method. */
1846 record_full_is_replaying (struct target_ops *self)
1848 return RECORD_FULL_IS_REPLAY;
1851 /* Go to a specific entry. */
1854 record_full_goto_entry (struct record_full_entry *p)
1857 error (_("Target insn not found."));
1858 else if (p == record_full_list)
1859 error (_("Already at target insn."));
1860 else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
1862 printf_filtered (_("Go forward to insn number %s\n"),
1863 pulongest (p->u.end.insn_num));
1864 record_full_goto_insn (p, EXEC_FORWARD);
1868 printf_filtered (_("Go backward to insn number %s\n"),
1869 pulongest (p->u.end.insn_num));
1870 record_full_goto_insn (p, EXEC_REVERSE);
1873 registers_changed ();
1874 reinit_frame_cache ();
1875 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1878 /* The "to_goto_record_begin" target method. */
1881 record_full_goto_begin (struct target_ops *self)
1883 struct record_full_entry *p = NULL;
1885 for (p = &record_full_first; p != NULL; p = p->next)
1886 if (p->type == record_full_end)
1889 record_full_goto_entry (p);
1892 /* The "to_goto_record_end" target method. */
1895 record_full_goto_end (struct target_ops *self)
1897 struct record_full_entry *p = NULL;
1899 for (p = record_full_list; p->next != NULL; p = p->next)
1901 for (; p!= NULL; p = p->prev)
1902 if (p->type == record_full_end)
1905 record_full_goto_entry (p);
1908 /* The "to_goto_record" target method. */
1911 record_full_goto (struct target_ops *self, ULONGEST target_insn)
1913 struct record_full_entry *p = NULL;
1915 for (p = &record_full_first; p != NULL; p = p->next)
1916 if (p->type == record_full_end && p->u.end.insn_num == target_insn)
1919 record_full_goto_entry (p);
1923 init_record_full_ops (void)
1925 record_full_ops.to_shortname = "record-full";
1926 record_full_ops.to_longname = "Process record and replay target";
1927 record_full_ops.to_doc =
1928 "Log program while executing and replay execution from log.";
1929 record_full_ops.to_open = record_full_open;
1930 record_full_ops.to_close = record_full_close;
1931 record_full_ops.to_async = record_full_async;
1932 record_full_ops.to_resume = record_full_resume;
1933 record_full_ops.to_wait = record_full_wait;
1934 record_full_ops.to_disconnect = record_disconnect;
1935 record_full_ops.to_detach = record_detach;
1936 record_full_ops.to_mourn_inferior = record_mourn_inferior;
1937 record_full_ops.to_kill = record_kill;
1938 record_full_ops.to_store_registers = record_full_store_registers;
1939 record_full_ops.to_xfer_partial = record_full_xfer_partial;
1940 record_full_ops.to_insert_breakpoint = record_full_insert_breakpoint;
1941 record_full_ops.to_remove_breakpoint = record_full_remove_breakpoint;
1942 record_full_ops.to_stopped_by_watchpoint = record_full_stopped_by_watchpoint;
1943 record_full_ops.to_stopped_data_address = record_full_stopped_data_address;
1944 record_full_ops.to_stopped_by_sw_breakpoint
1945 = record_full_stopped_by_sw_breakpoint;
1946 record_full_ops.to_supports_stopped_by_sw_breakpoint
1947 = record_full_supports_stopped_by_sw_breakpoint;
1948 record_full_ops.to_stopped_by_hw_breakpoint
1949 = record_full_stopped_by_hw_breakpoint;
1950 record_full_ops.to_supports_stopped_by_hw_breakpoint
1951 = record_full_supports_stopped_by_hw_breakpoint;
1952 record_full_ops.to_can_execute_reverse = record_full_can_execute_reverse;
1953 record_full_ops.to_stratum = record_stratum;
1954 /* Add bookmark target methods. */
1955 record_full_ops.to_get_bookmark = record_full_get_bookmark;
1956 record_full_ops.to_goto_bookmark = record_full_goto_bookmark;
1957 record_full_ops.to_execution_direction = record_full_execution_direction;
1958 record_full_ops.to_info_record = record_full_info;
1959 record_full_ops.to_save_record = record_full_save;
1960 record_full_ops.to_delete_record = record_full_delete;
1961 record_full_ops.to_record_is_replaying = record_full_is_replaying;
1962 record_full_ops.to_goto_record_begin = record_full_goto_begin;
1963 record_full_ops.to_goto_record_end = record_full_goto_end;
1964 record_full_ops.to_goto_record = record_full_goto;
1965 record_full_ops.to_magic = OPS_MAGIC;
1968 /* "to_resume" method for prec over corefile. */
1971 record_full_core_resume (struct target_ops *ops, ptid_t ptid, int step,
1972 enum gdb_signal signal)
1974 record_full_resume_step = step;
1975 record_full_resumed = 1;
1976 record_full_execution_dir = execution_direction;
1978 /* We are about to start executing the inferior (or simulate it),
1979 let's register it with the event loop. */
1980 if (target_can_async_p ())
1981 target_async (inferior_event_handler, 0);
1984 /* "to_kill" method for prec over corefile. */
1987 record_full_core_kill (struct target_ops *ops)
1990 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
1992 unpush_target (&record_full_core_ops);
1995 /* "to_fetch_registers" method for prec over corefile. */
1998 record_full_core_fetch_registers (struct target_ops *ops,
1999 struct regcache *regcache,
2004 int num = gdbarch_num_regs (get_regcache_arch (regcache));
2007 for (i = 0; i < num; i ++)
2008 regcache_raw_supply (regcache, i,
2009 record_full_core_regbuf + MAX_REGISTER_SIZE * i);
2012 regcache_raw_supply (regcache, regno,
2013 record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2016 /* "to_prepare_to_store" method for prec over corefile. */
2019 record_full_core_prepare_to_store (struct target_ops *self,
2020 struct regcache *regcache)
2024 /* "to_store_registers" method for prec over corefile. */
2027 record_full_core_store_registers (struct target_ops *ops,
2028 struct regcache *regcache,
2031 if (record_full_gdb_operation_disable)
2032 regcache_raw_collect (regcache, regno,
2033 record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2035 error (_("You can't do that without a process to debug."));
2038 /* "to_xfer_partial" method for prec over corefile. */
2040 static enum target_xfer_status
2041 record_full_core_xfer_partial (struct target_ops *ops,
2042 enum target_object object,
2043 const char *annex, gdb_byte *readbuf,
2044 const gdb_byte *writebuf, ULONGEST offset,
2045 ULONGEST len, ULONGEST *xfered_len)
2047 if (object == TARGET_OBJECT_MEMORY)
2049 if (record_full_gdb_operation_disable || !writebuf)
2051 struct target_section *p;
2053 for (p = record_full_core_start; p < record_full_core_end; p++)
2055 if (offset >= p->addr)
2057 struct record_full_core_buf_entry *entry;
2058 ULONGEST sec_offset;
2060 if (offset >= p->endaddr)
2063 if (offset + len > p->endaddr)
2064 len = p->endaddr - offset;
2066 sec_offset = offset - p->addr;
2068 /* Read readbuf or write writebuf p, offset, len. */
2070 if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
2071 || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
2074 memset (readbuf, 0, len);
2077 return TARGET_XFER_OK;
2079 /* Get record_full_core_buf_entry. */
2080 for (entry = record_full_core_buf_list; entry;
2081 entry = entry->prev)
2088 /* Add a new entry. */
2089 entry = (struct record_full_core_buf_entry *)
2091 (sizeof (struct record_full_core_buf_entry));
2093 if (!bfd_malloc_and_get_section
2094 (p->the_bfd_section->owner,
2099 return TARGET_XFER_EOF;
2101 entry->prev = record_full_core_buf_list;
2102 record_full_core_buf_list = entry;
2105 memcpy (entry->buf + sec_offset, writebuf,
2111 return ops->beneath->to_xfer_partial (ops->beneath,
2117 memcpy (readbuf, entry->buf + sec_offset,
2122 return TARGET_XFER_OK;
2126 return TARGET_XFER_E_IO;
2129 error (_("You can't do that without a process to debug."));
2132 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2133 readbuf, writebuf, offset, len,
2137 /* "to_insert_breakpoint" method for prec over corefile. */
2140 record_full_core_insert_breakpoint (struct target_ops *ops,
2141 struct gdbarch *gdbarch,
2142 struct bp_target_info *bp_tgt)
2147 /* "to_remove_breakpoint" method for prec over corefile. */
2150 record_full_core_remove_breakpoint (struct target_ops *ops,
2151 struct gdbarch *gdbarch,
2152 struct bp_target_info *bp_tgt)
2157 /* "to_has_execution" method for prec over corefile. */
2160 record_full_core_has_execution (struct target_ops *ops, ptid_t the_ptid)
2166 init_record_full_core_ops (void)
2168 record_full_core_ops.to_shortname = "record-core";
2169 record_full_core_ops.to_longname = "Process record and replay target";
2170 record_full_core_ops.to_doc =
2171 "Log program while executing and replay execution from log.";
2172 record_full_core_ops.to_open = record_full_open;
2173 record_full_core_ops.to_close = record_full_close;
2174 record_full_core_ops.to_async = record_full_async;
2175 record_full_core_ops.to_resume = record_full_core_resume;
2176 record_full_core_ops.to_wait = record_full_wait;
2177 record_full_core_ops.to_kill = record_full_core_kill;
2178 record_full_core_ops.to_fetch_registers = record_full_core_fetch_registers;
2179 record_full_core_ops.to_prepare_to_store = record_full_core_prepare_to_store;
2180 record_full_core_ops.to_store_registers = record_full_core_store_registers;
2181 record_full_core_ops.to_xfer_partial = record_full_core_xfer_partial;
2182 record_full_core_ops.to_insert_breakpoint
2183 = record_full_core_insert_breakpoint;
2184 record_full_core_ops.to_remove_breakpoint
2185 = record_full_core_remove_breakpoint;
2186 record_full_core_ops.to_stopped_by_watchpoint
2187 = record_full_stopped_by_watchpoint;
2188 record_full_core_ops.to_stopped_data_address
2189 = record_full_stopped_data_address;
2190 record_full_core_ops.to_stopped_by_sw_breakpoint
2191 = record_full_stopped_by_sw_breakpoint;
2192 record_full_core_ops.to_supports_stopped_by_sw_breakpoint
2193 = record_full_supports_stopped_by_sw_breakpoint;
2194 record_full_core_ops.to_stopped_by_hw_breakpoint
2195 = record_full_stopped_by_hw_breakpoint;
2196 record_full_core_ops.to_supports_stopped_by_hw_breakpoint
2197 = record_full_supports_stopped_by_hw_breakpoint;
2198 record_full_core_ops.to_can_execute_reverse
2199 = record_full_can_execute_reverse;
2200 record_full_core_ops.to_has_execution = record_full_core_has_execution;
2201 record_full_core_ops.to_stratum = record_stratum;
2202 /* Add bookmark target methods. */
2203 record_full_core_ops.to_get_bookmark = record_full_get_bookmark;
2204 record_full_core_ops.to_goto_bookmark = record_full_goto_bookmark;
2205 record_full_core_ops.to_execution_direction
2206 = record_full_execution_direction;
2207 record_full_core_ops.to_info_record = record_full_info;
2208 record_full_core_ops.to_delete_record = record_full_delete;
2209 record_full_core_ops.to_record_is_replaying = record_full_is_replaying;
2210 record_full_core_ops.to_goto_record_begin = record_full_goto_begin;
2211 record_full_core_ops.to_goto_record_end = record_full_goto_end;
2212 record_full_core_ops.to_goto_record = record_full_goto;
2213 record_full_core_ops.to_magic = OPS_MAGIC;
2216 /* Record log save-file format
2217 Version 1 (never released)
2220 4 bytes: magic number htonl(0x20090829).
2221 NOTE: be sure to change whenever this file format changes!
2225 1 byte: record type (record_full_end, see enum record_full_type).
2227 1 byte: record type (record_full_reg, see enum record_full_type).
2228 8 bytes: register id (network byte order).
2229 MAX_REGISTER_SIZE bytes: register value.
2231 1 byte: record type (record_full_mem, see enum record_full_type).
2232 8 bytes: memory length (network byte order).
2233 8 bytes: memory address (network byte order).
2234 n bytes: memory value (n == memory length).
2237 4 bytes: magic number netorder32(0x20091016).
2238 NOTE: be sure to change whenever this file format changes!
2242 1 byte: record type (record_full_end, see enum record_full_type).
2244 4 bytes: instruction count
2246 1 byte: record type (record_full_reg, see enum record_full_type).
2247 4 bytes: register id (network byte order).
2248 n bytes: register value (n == actual register size).
2249 (eg. 4 bytes for x86 general registers).
2251 1 byte: record type (record_full_mem, see enum record_full_type).
2252 4 bytes: memory length (network byte order).
2253 8 bytes: memory address (network byte order).
2254 n bytes: memory value (n == memory length).
2258 /* bfdcore_read -- read bytes from a core file section. */
2261 bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2263 int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2268 error (_("Failed to read %d bytes from core file %s ('%s')."),
2269 len, bfd_get_filename (obfd),
2270 bfd_errmsg (bfd_get_error ()));
2273 static inline uint64_t
2274 netorder64 (uint64_t input)
2278 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2279 BFD_ENDIAN_BIG, input);
2283 static inline uint32_t
2284 netorder32 (uint32_t input)
2288 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2289 BFD_ENDIAN_BIG, input);
2293 static inline uint16_t
2294 netorder16 (uint16_t input)
2298 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2299 BFD_ENDIAN_BIG, input);
2303 /* Restore the execution log from a core_bfd file. */
2305 record_full_restore (void)
2308 struct cleanup *old_cleanups;
2309 struct record_full_entry *rec;
2313 struct regcache *regcache;
2315 /* We restore the execution log from the open core bfd,
2317 if (core_bfd == NULL)
2320 /* "record_full_restore" can only be called when record list is empty. */
2321 gdb_assert (record_full_first.next == NULL);
2324 fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
2326 /* Now need to find our special note section. */
2327 osec = bfd_get_section_by_name (core_bfd, "null0");
2329 fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
2330 osec ? "succeeded" : "failed");
2333 osec_size = bfd_section_size (core_bfd, osec);
2335 fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
2337 /* Check the magic code. */
2338 bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
2339 if (magic != RECORD_FULL_FILE_MAGIC)
2340 error (_("Version mis-match or file format error in core file %s."),
2341 bfd_get_filename (core_bfd));
2343 fprintf_unfiltered (gdb_stdlog,
2344 " Reading 4-byte magic cookie "
2345 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2346 phex_nz (netorder32 (magic), 4));
2348 /* Restore the entries in recfd into record_full_arch_list_head and
2349 record_full_arch_list_tail. */
2350 record_full_arch_list_head = NULL;
2351 record_full_arch_list_tail = NULL;
2352 record_full_insn_num = 0;
2353 old_cleanups = make_cleanup (record_full_arch_list_cleanups, 0);
2354 regcache = get_current_regcache ();
2359 uint32_t regnum, len, signal, count;
2362 /* We are finished when offset reaches osec_size. */
2363 if (bfd_offset >= osec_size)
2365 bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);
2369 case record_full_reg: /* reg */
2370 /* Get register number to regnum. */
2371 bfdcore_read (core_bfd, osec, ®num,
2372 sizeof (regnum), &bfd_offset);
2373 regnum = netorder32 (regnum);
2375 rec = record_full_reg_alloc (regcache, regnum);
2378 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2379 rec->u.reg.len, &bfd_offset);
2382 fprintf_unfiltered (gdb_stdlog,
2383 " Reading register %d (1 "
2384 "plus %lu plus %d bytes)\n",
2386 (unsigned long) sizeof (regnum),
2390 case record_full_mem: /* mem */
2392 bfdcore_read (core_bfd, osec, &len,
2393 sizeof (len), &bfd_offset);
2394 len = netorder32 (len);
2397 bfdcore_read (core_bfd, osec, &addr,
2398 sizeof (addr), &bfd_offset);
2399 addr = netorder64 (addr);
2401 rec = record_full_mem_alloc (addr, len);
2404 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2405 rec->u.mem.len, &bfd_offset);
2408 fprintf_unfiltered (gdb_stdlog,
2409 " Reading memory %s (1 plus "
2410 "%lu plus %lu plus %d bytes)\n",
2411 paddress (get_current_arch (),
2413 (unsigned long) sizeof (addr),
2414 (unsigned long) sizeof (len),
2418 case record_full_end: /* end */
2419 rec = record_full_end_alloc ();
2420 record_full_insn_num ++;
2422 /* Get signal value. */
2423 bfdcore_read (core_bfd, osec, &signal,
2424 sizeof (signal), &bfd_offset);
2425 signal = netorder32 (signal);
2426 rec->u.end.sigval = signal;
2428 /* Get insn count. */
2429 bfdcore_read (core_bfd, osec, &count,
2430 sizeof (count), &bfd_offset);
2431 count = netorder32 (count);
2432 rec->u.end.insn_num = count;
2433 record_full_insn_count = count + 1;
2435 fprintf_unfiltered (gdb_stdlog,
2436 " Reading record_full_end (1 + "
2437 "%lu + %lu bytes), offset == %s\n",
2438 (unsigned long) sizeof (signal),
2439 (unsigned long) sizeof (count),
2440 paddress (get_current_arch (),
2445 error (_("Bad entry type in core file %s."),
2446 bfd_get_filename (core_bfd));
2450 /* Add rec to record arch list. */
2451 record_full_arch_list_add (rec);
2454 discard_cleanups (old_cleanups);
2456 /* Add record_full_arch_list_head to the end of record list. */
2457 record_full_first.next = record_full_arch_list_head;
2458 record_full_arch_list_head->prev = &record_full_first;
2459 record_full_arch_list_tail->next = NULL;
2460 record_full_list = &record_full_first;
2462 /* Update record_full_insn_max_num. */
2463 if (record_full_insn_num > record_full_insn_max_num)
2465 record_full_insn_max_num = record_full_insn_num;
2466 warning (_("Auto increase record/replay buffer limit to %u."),
2467 record_full_insn_max_num);
2471 printf_filtered (_("Restored records from core file %s.\n"),
2472 bfd_get_filename (core_bfd));
2474 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2477 /* bfdcore_write -- write bytes into a core file section. */
2480 bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2482 int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2487 error (_("Failed to write %d bytes to core file %s ('%s')."),
2488 len, bfd_get_filename (obfd),
2489 bfd_errmsg (bfd_get_error ()));
2492 /* Restore the execution log from a file. We use a modified elf
2493 corefile format, with an extra section for our data. */
2496 cmd_record_full_restore (char *args, int from_tty)
2498 core_file_command (args, from_tty);
2499 record_full_open (args, from_tty);
2503 record_full_save_cleanups (void *data)
2506 char *pathname = xstrdup (bfd_get_filename (obfd));
2508 gdb_bfd_unref (obfd);
2513 /* Save the execution log to a file. We use a modified elf corefile
2514 format, with an extra section for our data. */
2517 record_full_save (struct target_ops *self, const char *recfilename)
2519 struct record_full_entry *cur_record_full_list;
2521 struct regcache *regcache;
2522 struct gdbarch *gdbarch;
2523 struct cleanup *old_cleanups;
2524 struct cleanup *set_cleanups;
2527 asection *osec = NULL;
2530 /* Open the save file. */
2532 fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
2535 /* Open the output file. */
2536 obfd = create_gcore_bfd (recfilename);
2537 old_cleanups = make_cleanup (record_full_save_cleanups, obfd);
2539 /* Save the current record entry to "cur_record_full_list". */
2540 cur_record_full_list = record_full_list;
2542 /* Get the values of regcache and gdbarch. */
2543 regcache = get_current_regcache ();
2544 gdbarch = get_regcache_arch (regcache);
2546 /* Disable the GDB operation record. */
2547 set_cleanups = record_full_gdb_operation_disable_set ();
2549 /* Reverse execute to the begin of record list. */
2552 /* Check for beginning and end of log. */
2553 if (record_full_list == &record_full_first)
2556 record_full_exec_insn (regcache, gdbarch, record_full_list);
2558 if (record_full_list->prev)
2559 record_full_list = record_full_list->prev;
2562 /* Compute the size needed for the extra bfd section. */
2563 save_size = 4; /* magic cookie */
2564 for (record_full_list = record_full_first.next; record_full_list;
2565 record_full_list = record_full_list->next)
2566 switch (record_full_list->type)
2568 case record_full_end:
2569 save_size += 1 + 4 + 4;
2571 case record_full_reg:
2572 save_size += 1 + 4 + record_full_list->u.reg.len;
2574 case record_full_mem:
2575 save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
2579 /* Make the new bfd section. */
2580 osec = bfd_make_section_anyway_with_flags (obfd, "precord",
2584 error (_("Failed to create 'precord' section for corefile %s: %s"),
2586 bfd_errmsg (bfd_get_error ()));
2587 bfd_set_section_size (obfd, osec, save_size);
2588 bfd_set_section_vma (obfd, osec, 0);
2589 bfd_set_section_alignment (obfd, osec, 0);
2590 bfd_section_lma (obfd, osec) = 0;
2592 /* Save corefile state. */
2593 write_gcore_file (obfd);
2595 /* Write out the record log. */
2596 /* Write the magic code. */
2597 magic = RECORD_FULL_FILE_MAGIC;
2599 fprintf_unfiltered (gdb_stdlog,
2600 " Writing 4-byte magic cookie "
2601 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2602 phex_nz (magic, 4));
2603 bfdcore_write (obfd, osec, &magic, sizeof (magic), &bfd_offset);
2605 /* Save the entries to recfd and forward execute to the end of
2607 record_full_list = &record_full_first;
2611 if (record_full_list != &record_full_first)
2614 uint32_t regnum, len, signal, count;
2617 type = record_full_list->type;
2618 bfdcore_write (obfd, osec, &type, sizeof (type), &bfd_offset);
2620 switch (record_full_list->type)
2622 case record_full_reg: /* reg */
2624 fprintf_unfiltered (gdb_stdlog,
2625 " Writing register %d (1 "
2626 "plus %lu plus %d bytes)\n",
2627 record_full_list->u.reg.num,
2628 (unsigned long) sizeof (regnum),
2629 record_full_list->u.reg.len);
2632 regnum = netorder32 (record_full_list->u.reg.num);
2633 bfdcore_write (obfd, osec, ®num,
2634 sizeof (regnum), &bfd_offset);
2637 bfdcore_write (obfd, osec,
2638 record_full_get_loc (record_full_list),
2639 record_full_list->u.reg.len, &bfd_offset);
2642 case record_full_mem: /* mem */
2644 fprintf_unfiltered (gdb_stdlog,
2645 " Writing memory %s (1 plus "
2646 "%lu plus %lu plus %d bytes)\n",
2648 record_full_list->u.mem.addr),
2649 (unsigned long) sizeof (addr),
2650 (unsigned long) sizeof (len),
2651 record_full_list->u.mem.len);
2654 len = netorder32 (record_full_list->u.mem.len);
2655 bfdcore_write (obfd, osec, &len, sizeof (len), &bfd_offset);
2657 /* Write memaddr. */
2658 addr = netorder64 (record_full_list->u.mem.addr);
2659 bfdcore_write (obfd, osec, &addr,
2660 sizeof (addr), &bfd_offset);
2663 bfdcore_write (obfd, osec,
2664 record_full_get_loc (record_full_list),
2665 record_full_list->u.mem.len, &bfd_offset);
2668 case record_full_end:
2670 fprintf_unfiltered (gdb_stdlog,
2671 " Writing record_full_end (1 + "
2672 "%lu + %lu bytes)\n",
2673 (unsigned long) sizeof (signal),
2674 (unsigned long) sizeof (count));
2675 /* Write signal value. */
2676 signal = netorder32 (record_full_list->u.end.sigval);
2677 bfdcore_write (obfd, osec, &signal,
2678 sizeof (signal), &bfd_offset);
2680 /* Write insn count. */
2681 count = netorder32 (record_full_list->u.end.insn_num);
2682 bfdcore_write (obfd, osec, &count,
2683 sizeof (count), &bfd_offset);
2688 /* Execute entry. */
2689 record_full_exec_insn (regcache, gdbarch, record_full_list);
2691 if (record_full_list->next)
2692 record_full_list = record_full_list->next;
2697 /* Reverse execute to cur_record_full_list. */
2700 /* Check for beginning and end of log. */
2701 if (record_full_list == cur_record_full_list)
2704 record_full_exec_insn (regcache, gdbarch, record_full_list);
2706 if (record_full_list->prev)
2707 record_full_list = record_full_list->prev;
2710 do_cleanups (set_cleanups);
2711 gdb_bfd_unref (obfd);
2712 discard_cleanups (old_cleanups);
2715 printf_filtered (_("Saved core file %s with execution log.\n"),
2719 /* record_full_goto_insn -- rewind the record log (forward or backward,
2720 depending on DIR) to the given entry, changing the program state
2724 record_full_goto_insn (struct record_full_entry *entry,
2725 enum exec_direction_kind dir)
2727 struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
2728 struct regcache *regcache = get_current_regcache ();
2729 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2731 /* Assume everything is valid: we will hit the entry,
2732 and we will not hit the end of the recording. */
2734 if (dir == EXEC_FORWARD)
2735 record_full_list = record_full_list->next;
2739 record_full_exec_insn (regcache, gdbarch, record_full_list);
2740 if (dir == EXEC_REVERSE)
2741 record_full_list = record_full_list->prev;
2743 record_full_list = record_full_list->next;
2744 } while (record_full_list != entry);
2745 do_cleanups (set_cleanups);
2748 /* Alias for "target record-full". */
2751 cmd_record_full_start (char *args, int from_tty)
2753 execute_command ("target record-full", from_tty);
2757 set_record_full_insn_max_num (char *args, int from_tty,
2758 struct cmd_list_element *c)
2760 if (record_full_insn_num > record_full_insn_max_num)
2762 /* Count down record_full_insn_num while releasing records from list. */
2763 while (record_full_insn_num > record_full_insn_max_num)
2765 record_full_list_release_first ();
2766 record_full_insn_num--;
2771 /* The "set record full" command. */
2774 set_record_full_command (char *args, int from_tty)
2776 printf_unfiltered (_("\"set record full\" must be followed "
2777 "by an apporpriate subcommand.\n"));
2778 help_list (set_record_full_cmdlist, "set record full ", all_commands,
2782 /* The "show record full" command. */
2785 show_record_full_command (char *args, int from_tty)
2787 cmd_show_list (show_record_full_cmdlist, from_tty, "");
2790 /* Provide a prototype to silence -Wmissing-prototypes. */
2791 extern initialize_file_ftype _initialize_record_full;
2794 _initialize_record_full (void)
2796 struct cmd_list_element *c;
2798 /* Init record_full_first. */
2799 record_full_first.prev = NULL;
2800 record_full_first.next = NULL;
2801 record_full_first.type = record_full_end;
2803 init_record_full_ops ();
2804 add_target (&record_full_ops);
2805 add_deprecated_target_alias (&record_full_ops, "record");
2806 init_record_full_core_ops ();
2807 add_target (&record_full_core_ops);
2809 add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
2810 _("Start full execution recording."), &record_full_cmdlist,
2811 "record full ", 0, &record_cmdlist);
2813 c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
2814 _("Restore the execution log from a file.\n\
2815 Argument is filename. File must be created with 'record save'."),
2816 &record_full_cmdlist);
2817 set_cmd_completer (c, filename_completer);
2819 /* Deprecate the old version without "full" prefix. */
2820 c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
2822 set_cmd_completer (c, filename_completer);
2823 deprecate_cmd (c, "record full restore");
2825 add_prefix_cmd ("full", class_support, set_record_full_command,
2826 _("Set record options"), &set_record_full_cmdlist,
2827 "set record full ", 0, &set_record_cmdlist);
2829 add_prefix_cmd ("full", class_support, show_record_full_command,
2830 _("Show record options"), &show_record_full_cmdlist,
2831 "show record full ", 0, &show_record_cmdlist);
2833 /* Record instructions number limit command. */
2834 add_setshow_boolean_cmd ("stop-at-limit", no_class,
2835 &record_full_stop_at_limit, _("\
2836 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2837 Show whether record/replay stops when record/replay buffer becomes full."),
2838 _("Default is ON.\n\
2839 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2840 When OFF, if the record/replay buffer becomes full,\n\
2841 delete the oldest recorded instruction to make room for each new one."),
2843 &set_record_full_cmdlist, &show_record_full_cmdlist);
2845 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2846 &set_record_cmdlist);
2847 deprecate_cmd (c, "set record full stop-at-limit");
2849 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2850 &show_record_cmdlist);
2851 deprecate_cmd (c, "show record full stop-at-limit");
2853 add_setshow_uinteger_cmd ("insn-number-max", no_class,
2854 &record_full_insn_max_num,
2855 _("Set record/replay buffer limit."),
2856 _("Show record/replay buffer limit."), _("\
2857 Set the maximum number of instructions to be stored in the\n\
2858 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2859 limit. Default is 200000."),
2860 set_record_full_insn_max_num,
2861 NULL, &set_record_full_cmdlist,
2862 &show_record_full_cmdlist);
2864 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2865 &set_record_cmdlist);
2866 deprecate_cmd (c, "set record full insn-number-max");
2868 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2869 &show_record_cmdlist);
2870 deprecate_cmd (c, "show record full insn-number-max");
2872 add_setshow_boolean_cmd ("memory-query", no_class,
2873 &record_full_memory_query, _("\
2874 Set whether query if PREC cannot record memory change of next instruction."),
2876 Show whether query if PREC cannot record memory change of next instruction."),
2879 When ON, query if PREC cannot record memory change of next instruction."),
2881 &set_record_full_cmdlist,
2882 &show_record_full_cmdlist);
2884 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2885 &set_record_cmdlist);
2886 deprecate_cmd (c, "set record full memory-query");
2888 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2889 &show_record_cmdlist);
2890 deprecate_cmd (c, "show record full memory-query");