1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdbthread.h"
24 #include "event-top.h"
25 #include "completer.h"
26 #include "arch-utils.h"
30 #include "record-full.h"
33 #include "event-loop.h"
41 /* This module implements "target record-full", also known as "process
42 record and replay". This target sits on top of a "normal" target
43 (a target that "has execution"), and provides a record and replay
44 functionality, including reverse debugging.
46 Target record has two modes: recording, and replaying.
48 In record mode, we intercept the to_resume and to_wait methods.
49 Whenever gdb resumes the target, we run the target in single step
50 mode, and we build up an execution log in which, for each executed
51 instruction, we record all changes in memory and register state.
52 This is invisible to the user, to whom it just looks like an
53 ordinary debugging session (except for performance degredation).
55 In replay mode, instead of actually letting the inferior run as a
56 process, we simulate its execution by playing back the recorded
57 execution log. For each instruction in the log, we simulate the
58 instruction's side effects by duplicating the changes that it would
59 have made on memory and registers. */
61 #define DEFAULT_RECORD_FULL_INSN_MAX_NUM 200000
63 #define RECORD_FULL_IS_REPLAY \
64 (record_full_list->next || execution_direction == EXEC_REVERSE)
66 #define RECORD_FULL_FILE_MAGIC netorder32(0x20091016)
68 /* These are the core structs of the process record functionality.
70 A record_full_entry is a record of the value change of a register
71 ("record_full_reg") or a part of memory ("record_full_mem"). And each
72 instruction must have a struct record_full_entry ("record_full_end")
73 that indicates that this is the last struct record_full_entry of this
76 Each struct record_full_entry is linked to "record_full_list" by "prev"
77 and "next" pointers. */
79 struct record_full_mem_entry
83 /* Set this flag if target memory for this entry
84 can no longer be accessed. */
85 int mem_entry_not_accessible;
89 gdb_byte buf[sizeof (gdb_byte *)];
93 struct record_full_reg_entry
100 gdb_byte buf[2 * sizeof (gdb_byte *)];
104 struct record_full_end_entry
106 enum gdb_signal sigval;
110 enum record_full_type
117 /* This is the data structure that makes up the execution log.
119 The execution log consists of a single linked list of entries
120 of type "struct record_full_entry". It is doubly linked so that it
121 can be traversed in either direction.
123 The start of the list is anchored by a struct called
124 "record_full_first". The pointer "record_full_list" either points
125 to the last entry that was added to the list (in record mode), or to
126 the next entry in the list that will be executed (in replay mode).
128 Each list element (struct record_full_entry), in addition to next
129 and prev pointers, consists of a union of three entry types: mem,
130 reg, and end. A field called "type" determines which entry type is
131 represented by a given list element.
133 Each instruction that is added to the execution log is represented
134 by a variable number of list elements ('entries'). The instruction
135 will have one "reg" entry for each register that is changed by
136 executing the instruction (including the PC in every case). It
137 will also have one "mem" entry for each memory change. Finally,
138 each instruction will have an "end" entry that separates it from
139 the changes associated with the next instruction. */
141 struct record_full_entry
143 struct record_full_entry *prev;
144 struct record_full_entry *next;
145 enum record_full_type type;
149 struct record_full_reg_entry reg;
151 struct record_full_mem_entry mem;
153 struct record_full_end_entry end;
157 /* If true, query if PREC cannot record memory
158 change of next instruction. */
159 int record_full_memory_query = 0;
161 struct record_full_core_buf_entry
163 struct record_full_core_buf_entry *prev;
164 struct target_section *p;
168 /* Record buf with core target. */
169 static gdb_byte *record_full_core_regbuf = NULL;
170 static struct target_section *record_full_core_start;
171 static struct target_section *record_full_core_end;
172 static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
174 /* The following variables are used for managing the linked list that
175 represents the execution log.
177 record_full_first is the anchor that holds down the beginning of
180 record_full_list serves two functions:
181 1) In record mode, it anchors the end of the list.
182 2) In replay mode, it traverses the list and points to
183 the next instruction that must be emulated.
185 record_full_arch_list_head and record_full_arch_list_tail are used
186 to manage a separate list, which is used to build up the change
187 elements of the currently executing instruction during record mode.
188 When this instruction has been completely annotated in the "arch
189 list", it will be appended to the main execution log. */
191 static struct record_full_entry record_full_first;
192 static struct record_full_entry *record_full_list = &record_full_first;
193 static struct record_full_entry *record_full_arch_list_head = NULL;
194 static struct record_full_entry *record_full_arch_list_tail = NULL;
196 /* 1 ask user. 0 auto delete the last struct record_full_entry. */
197 static int record_full_stop_at_limit = 1;
198 /* Maximum allowed number of insns in execution log. */
199 static unsigned int record_full_insn_max_num
200 = DEFAULT_RECORD_FULL_INSN_MAX_NUM;
201 /* Actual count of insns presently in execution log. */
202 static unsigned int record_full_insn_num = 0;
203 /* Count of insns logged so far (may be larger
204 than count of insns presently in execution log). */
205 static ULONGEST record_full_insn_count;
207 /* The target_ops of process record. */
208 static struct target_ops record_full_ops;
209 static struct target_ops record_full_core_ops;
211 /* See record-full.h. */
214 record_full_is_used (void)
216 struct target_ops *t;
218 t = find_record_target ();
219 return (t == &record_full_ops
220 || t == &record_full_core_ops);
224 /* Command lists for "set/show record full". */
225 static struct cmd_list_element *set_record_full_cmdlist;
226 static struct cmd_list_element *show_record_full_cmdlist;
228 /* Command list for "record full". */
229 static struct cmd_list_element *record_full_cmdlist;
231 static void record_full_goto_insn (struct record_full_entry *entry,
232 enum exec_direction_kind dir);
233 static void record_full_save (struct target_ops *self,
234 const char *recfilename);
236 /* Alloc and free functions for record_full_reg, record_full_mem, and
237 record_full_end entries. */
239 /* Alloc a record_full_reg record entry. */
241 static inline struct record_full_entry *
242 record_full_reg_alloc (struct regcache *regcache, int regnum)
244 struct record_full_entry *rec;
245 struct gdbarch *gdbarch = get_regcache_arch (regcache);
247 rec = XCNEW (struct record_full_entry);
248 rec->type = record_full_reg;
249 rec->u.reg.num = regnum;
250 rec->u.reg.len = register_size (gdbarch, regnum);
251 if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
252 rec->u.reg.u.ptr = (gdb_byte *) xmalloc (rec->u.reg.len);
257 /* Free a record_full_reg record entry. */
260 record_full_reg_release (struct record_full_entry *rec)
262 gdb_assert (rec->type == record_full_reg);
263 if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
264 xfree (rec->u.reg.u.ptr);
268 /* Alloc a record_full_mem record entry. */
270 static inline struct record_full_entry *
271 record_full_mem_alloc (CORE_ADDR addr, int len)
273 struct record_full_entry *rec;
275 rec = XCNEW (struct record_full_entry);
276 rec->type = record_full_mem;
277 rec->u.mem.addr = addr;
278 rec->u.mem.len = len;
279 if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
280 rec->u.mem.u.ptr = (gdb_byte *) xmalloc (len);
285 /* Free a record_full_mem record entry. */
288 record_full_mem_release (struct record_full_entry *rec)
290 gdb_assert (rec->type == record_full_mem);
291 if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
292 xfree (rec->u.mem.u.ptr);
296 /* Alloc a record_full_end record entry. */
298 static inline struct record_full_entry *
299 record_full_end_alloc (void)
301 struct record_full_entry *rec;
303 rec = XCNEW (struct record_full_entry);
304 rec->type = record_full_end;
309 /* Free a record_full_end record entry. */
312 record_full_end_release (struct record_full_entry *rec)
317 /* Free one record entry, any type.
318 Return entry->type, in case caller wants to know. */
320 static inline enum record_full_type
321 record_full_entry_release (struct record_full_entry *rec)
323 enum record_full_type type = rec->type;
326 case record_full_reg:
327 record_full_reg_release (rec);
329 case record_full_mem:
330 record_full_mem_release (rec);
332 case record_full_end:
333 record_full_end_release (rec);
339 /* Free all record entries in list pointed to by REC. */
342 record_full_list_release (struct record_full_entry *rec)
353 record_full_entry_release (rec->next);
356 if (rec == &record_full_first)
358 record_full_insn_num = 0;
359 record_full_first.next = NULL;
362 record_full_entry_release (rec);
365 /* Free all record entries forward of the given list position. */
368 record_full_list_release_following (struct record_full_entry *rec)
370 struct record_full_entry *tmp = rec->next;
376 if (record_full_entry_release (tmp) == record_full_end)
378 record_full_insn_num--;
379 record_full_insn_count--;
385 /* Delete the first instruction from the beginning of the log, to make
386 room for adding a new instruction at the end of the log.
388 Note -- this function does not modify record_full_insn_num. */
391 record_full_list_release_first (void)
393 struct record_full_entry *tmp;
395 if (!record_full_first.next)
398 /* Loop until a record_full_end. */
401 /* Cut record_full_first.next out of the linked list. */
402 tmp = record_full_first.next;
403 record_full_first.next = tmp->next;
404 tmp->next->prev = &record_full_first;
406 /* tmp is now isolated, and can be deleted. */
407 if (record_full_entry_release (tmp) == record_full_end)
408 break; /* End loop at first record_full_end. */
410 if (!record_full_first.next)
412 gdb_assert (record_full_insn_num == 1);
413 break; /* End loop when list is empty. */
418 /* Add a struct record_full_entry to record_full_arch_list. */
421 record_full_arch_list_add (struct record_full_entry *rec)
423 if (record_debug > 1)
424 fprintf_unfiltered (gdb_stdlog,
425 "Process record: record_full_arch_list_add %s.\n",
426 host_address_to_string (rec));
428 if (record_full_arch_list_tail)
430 record_full_arch_list_tail->next = rec;
431 rec->prev = record_full_arch_list_tail;
432 record_full_arch_list_tail = rec;
436 record_full_arch_list_head = rec;
437 record_full_arch_list_tail = rec;
441 /* Return the value storage location of a record entry. */
442 static inline gdb_byte *
443 record_full_get_loc (struct record_full_entry *rec)
446 case record_full_mem:
447 if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
448 return rec->u.mem.u.ptr;
450 return rec->u.mem.u.buf;
451 case record_full_reg:
452 if (rec->u.reg.len > sizeof (rec->u.reg.u.buf))
453 return rec->u.reg.u.ptr;
455 return rec->u.reg.u.buf;
456 case record_full_end:
458 gdb_assert_not_reached ("unexpected record_full_entry type");
463 /* Record the value of a register NUM to record_full_arch_list. */
466 record_full_arch_list_add_reg (struct regcache *regcache, int regnum)
468 struct record_full_entry *rec;
470 if (record_debug > 1)
471 fprintf_unfiltered (gdb_stdlog,
472 "Process record: add register num = %d to "
476 rec = record_full_reg_alloc (regcache, regnum);
478 regcache_raw_read (regcache, regnum, record_full_get_loc (rec));
480 record_full_arch_list_add (rec);
485 /* Record the value of a region of memory whose address is ADDR and
486 length is LEN to record_full_arch_list. */
489 record_full_arch_list_add_mem (CORE_ADDR addr, int len)
491 struct record_full_entry *rec;
493 if (record_debug > 1)
494 fprintf_unfiltered (gdb_stdlog,
495 "Process record: add mem addr = %s len = %d to "
497 paddress (target_gdbarch (), addr), len);
499 if (!addr) /* FIXME: Why? Some arch must permit it... */
502 rec = record_full_mem_alloc (addr, len);
504 if (record_read_memory (target_gdbarch (), addr,
505 record_full_get_loc (rec), len))
507 record_full_mem_release (rec);
511 record_full_arch_list_add (rec);
516 /* Add a record_full_end type struct record_full_entry to
517 record_full_arch_list. */
520 record_full_arch_list_add_end (void)
522 struct record_full_entry *rec;
524 if (record_debug > 1)
525 fprintf_unfiltered (gdb_stdlog,
526 "Process record: add end to arch list.\n");
528 rec = record_full_end_alloc ();
529 rec->u.end.sigval = GDB_SIGNAL_0;
530 rec->u.end.insn_num = ++record_full_insn_count;
532 record_full_arch_list_add (rec);
538 record_full_check_insn_num (void)
540 if (record_full_insn_num == record_full_insn_max_num)
542 /* Ask user what to do. */
543 if (record_full_stop_at_limit)
545 if (!yquery (_("Do you want to auto delete previous execution "
546 "log entries when record/replay buffer becomes "
547 "full (record full stop-at-limit)?")))
548 error (_("Process record: stopped by user."));
549 record_full_stop_at_limit = 0;
555 record_full_arch_list_cleanups (void *ignore)
557 record_full_list_release (record_full_arch_list_tail);
560 /* Before inferior step (when GDB record the running message, inferior
561 only can step), GDB will call this function to record the values to
562 record_full_list. This function will call gdbarch_process_record to
563 record the running message of inferior and set them to
564 record_full_arch_list, and add it to record_full_list. */
567 record_full_message (struct regcache *regcache, enum gdb_signal signal)
570 struct gdbarch *gdbarch = get_regcache_arch (regcache);
571 struct cleanup *old_cleanups
572 = make_cleanup (record_full_arch_list_cleanups, 0);
574 record_full_arch_list_head = NULL;
575 record_full_arch_list_tail = NULL;
577 /* Check record_full_insn_num. */
578 record_full_check_insn_num ();
580 /* If gdb sends a signal value to target_resume,
581 save it in the 'end' field of the previous instruction.
583 Maybe process record should record what really happened,
584 rather than what gdb pretends has happened.
586 So if Linux delivered the signal to the child process during
587 the record mode, we will record it and deliver it again in
590 If user says "ignore this signal" during the record mode, then
591 it will be ignored again during the replay mode (no matter if
592 the user says something different, like "deliver this signal"
593 during the replay mode).
595 User should understand that nothing he does during the replay
596 mode will change the behavior of the child. If he tries,
597 then that is a user error.
599 But we should still deliver the signal to gdb during the replay,
600 if we delivered it during the recording. Therefore we should
601 record the signal during record_full_wait, not
602 record_full_resume. */
603 if (record_full_list != &record_full_first) /* FIXME better way to check */
605 gdb_assert (record_full_list->type == record_full_end);
606 record_full_list->u.end.sigval = signal;
609 if (signal == GDB_SIGNAL_0
610 || !gdbarch_process_record_signal_p (gdbarch))
611 ret = gdbarch_process_record (gdbarch,
613 regcache_read_pc (regcache));
615 ret = gdbarch_process_record_signal (gdbarch,
620 error (_("Process record: inferior program stopped."));
622 error (_("Process record: failed to record execution log."));
624 discard_cleanups (old_cleanups);
626 record_full_list->next = record_full_arch_list_head;
627 record_full_arch_list_head->prev = record_full_list;
628 record_full_list = record_full_arch_list_tail;
630 if (record_full_insn_num == record_full_insn_max_num)
631 record_full_list_release_first ();
633 record_full_insn_num++;
638 struct record_full_message_args {
639 struct regcache *regcache;
640 enum gdb_signal signal;
644 record_full_message_wrapper (void *args)
646 struct record_full_message_args *record_full_args
647 = (struct record_full_message_args *) args;
649 return record_full_message (record_full_args->regcache,
650 record_full_args->signal);
654 record_full_message_wrapper_safe (struct regcache *regcache,
655 enum gdb_signal signal)
657 struct record_full_message_args args;
659 args.regcache = regcache;
660 args.signal = signal;
662 return catch_errors (record_full_message_wrapper, &args, "",
666 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
667 doesn't need record. */
669 static int record_full_gdb_operation_disable = 0;
672 record_full_gdb_operation_disable_set (void)
674 struct cleanup *old_cleanups = NULL;
677 make_cleanup_restore_integer (&record_full_gdb_operation_disable);
678 record_full_gdb_operation_disable = 1;
683 /* Flag set to TRUE for target_stopped_by_watchpoint. */
684 static enum target_stop_reason record_full_stop_reason
685 = TARGET_STOPPED_BY_NO_REASON;
687 /* Execute one instruction from the record log. Each instruction in
688 the log will be represented by an arbitrary sequence of register
689 entries and memory entries, followed by an 'end' entry. */
692 record_full_exec_insn (struct regcache *regcache,
693 struct gdbarch *gdbarch,
694 struct record_full_entry *entry)
698 case record_full_reg: /* reg */
700 gdb_byte reg[MAX_REGISTER_SIZE];
702 if (record_debug > 1)
703 fprintf_unfiltered (gdb_stdlog,
704 "Process record: record_full_reg %s to "
705 "inferior num = %d.\n",
706 host_address_to_string (entry),
709 regcache_cooked_read (regcache, entry->u.reg.num, reg);
710 regcache_cooked_write (regcache, entry->u.reg.num,
711 record_full_get_loc (entry));
712 memcpy (record_full_get_loc (entry), reg, entry->u.reg.len);
716 case record_full_mem: /* mem */
718 /* Nothing to do if the entry is flagged not_accessible. */
719 if (!entry->u.mem.mem_entry_not_accessible)
721 gdb_byte *mem = (gdb_byte *) xmalloc (entry->u.mem.len);
722 struct cleanup *cleanup = make_cleanup (xfree, mem);
724 if (record_debug > 1)
725 fprintf_unfiltered (gdb_stdlog,
726 "Process record: record_full_mem %s to "
727 "inferior addr = %s len = %d.\n",
728 host_address_to_string (entry),
729 paddress (gdbarch, entry->u.mem.addr),
732 if (record_read_memory (gdbarch,
733 entry->u.mem.addr, mem, entry->u.mem.len))
734 entry->u.mem.mem_entry_not_accessible = 1;
737 if (target_write_memory (entry->u.mem.addr,
738 record_full_get_loc (entry),
741 entry->u.mem.mem_entry_not_accessible = 1;
743 warning (_("Process record: error writing memory at "
744 "addr = %s len = %d."),
745 paddress (gdbarch, entry->u.mem.addr),
750 memcpy (record_full_get_loc (entry), mem,
753 /* We've changed memory --- check if a hardware
754 watchpoint should trap. Note that this
755 presently assumes the target beneath supports
756 continuable watchpoints. On non-continuable
757 watchpoints target, we'll want to check this
758 _before_ actually doing the memory change, and
759 not doing the change at all if the watchpoint
761 if (hardware_watchpoint_inserted_in_range
762 (get_regcache_aspace (regcache),
763 entry->u.mem.addr, entry->u.mem.len))
764 record_full_stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
768 do_cleanups (cleanup);
775 static void record_full_restore (void);
777 /* Asynchronous signal handle registered as event loop source for when
778 we have pending events ready to be passed to the core. */
780 static struct async_event_handler *record_full_async_inferior_event_token;
783 record_full_async_inferior_event_handler (gdb_client_data data)
785 inferior_event_handler (INF_REG_EVENT, NULL);
788 /* Open the process record target. */
791 record_full_core_open_1 (const char *name, int from_tty)
793 struct regcache *regcache = get_current_regcache ();
794 int regnum = gdbarch_num_regs (get_regcache_arch (regcache));
797 /* Get record_full_core_regbuf. */
798 target_fetch_registers (regcache, -1);
799 record_full_core_regbuf = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE * regnum);
800 for (i = 0; i < regnum; i ++)
801 regcache_raw_collect (regcache, i,
802 record_full_core_regbuf + MAX_REGISTER_SIZE * i);
804 /* Get record_full_core_start and record_full_core_end. */
805 if (build_section_table (core_bfd, &record_full_core_start,
806 &record_full_core_end))
808 xfree (record_full_core_regbuf);
809 record_full_core_regbuf = NULL;
810 error (_("\"%s\": Can't find sections: %s"),
811 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
814 push_target (&record_full_core_ops);
815 record_full_restore ();
818 /* "to_open" target method for 'live' processes. */
821 record_full_open_1 (const char *name, int from_tty)
824 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
827 if (!target_has_execution)
828 error (_("Process record: the program is not being run."));
830 error (_("Process record target can't debug inferior in non-stop mode "
833 if (!gdbarch_process_record_p (target_gdbarch ()))
834 error (_("Process record: the current architecture doesn't support "
835 "record function."));
837 push_target (&record_full_ops);
840 static void record_full_init_record_breakpoints (void);
842 /* "to_open" target method. Open the process record target. */
845 record_full_open (const char *name, int from_tty)
847 struct target_ops *t;
850 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
855 record_full_insn_num = 0;
856 record_full_insn_count = 0;
857 record_full_list = &record_full_first;
858 record_full_list->next = NULL;
861 record_full_core_open_1 (name, from_tty);
863 record_full_open_1 (name, from_tty);
865 /* Register extra event sources in the event loop. */
866 record_full_async_inferior_event_token
867 = create_async_event_handler (record_full_async_inferior_event_handler,
870 record_full_init_record_breakpoints ();
872 observer_notify_record_changed (current_inferior (), 1, "full", NULL);
875 /* "to_close" target method. Close the process record target. */
878 record_full_close (struct target_ops *self)
880 struct record_full_core_buf_entry *entry;
883 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_close\n");
885 record_full_list_release (record_full_list);
887 /* Release record_full_core_regbuf. */
888 if (record_full_core_regbuf)
890 xfree (record_full_core_regbuf);
891 record_full_core_regbuf = NULL;
894 /* Release record_full_core_buf_list. */
895 if (record_full_core_buf_list)
897 for (entry = record_full_core_buf_list->prev; entry;
900 xfree (record_full_core_buf_list);
901 record_full_core_buf_list = entry;
903 record_full_core_buf_list = NULL;
906 if (record_full_async_inferior_event_token)
907 delete_async_event_handler (&record_full_async_inferior_event_token);
910 /* "to_async" target method. */
913 record_full_async (struct target_ops *ops, int enable)
916 mark_async_event_handler (record_full_async_inferior_event_token);
918 clear_async_event_handler (record_full_async_inferior_event_token);
920 ops->beneath->to_async (ops->beneath, enable);
923 static int record_full_resume_step = 0;
925 /* True if we've been resumed, and so each record_full_wait call should
926 advance execution. If this is false, record_full_wait will return a
927 TARGET_WAITKIND_IGNORE. */
928 static int record_full_resumed = 0;
930 /* The execution direction of the last resume we got. This is
931 necessary for async mode. Vis (order is not strictly accurate):
933 1. user has the global execution direction set to forward
934 2. user does a reverse-step command
935 3. record_full_resume is called with global execution direction
936 temporarily switched to reverse
937 4. GDB's execution direction is reverted back to forward
938 5. target record notifies event loop there's an event to handle
939 6. infrun asks the target which direction was it going, and switches
940 the global execution direction accordingly (to reverse)
941 7. infrun polls an event out of the record target, and handles it
942 8. GDB goes back to the event loop, and goto #4.
944 static enum exec_direction_kind record_full_execution_dir = EXEC_FORWARD;
946 /* "to_resume" target method. Resume the process record target. */
949 record_full_resume (struct target_ops *ops, ptid_t ptid, int step,
950 enum gdb_signal signal)
952 record_full_resume_step = step;
953 record_full_resumed = 1;
954 record_full_execution_dir = execution_direction;
956 if (!RECORD_FULL_IS_REPLAY)
958 struct gdbarch *gdbarch = target_thread_architecture (ptid);
960 record_full_message (get_current_regcache (), signal);
964 /* This is not hard single step. */
965 if (!gdbarch_software_single_step_p (gdbarch))
967 /* This is a normal continue. */
972 /* This arch support soft sigle step. */
973 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
975 /* This is a soft single step. */
976 record_full_resume_step = 1;
980 /* This is a continue.
981 Try to insert a soft single step breakpoint. */
982 if (!gdbarch_software_single_step (gdbarch,
983 get_current_frame ()))
985 /* This system don't want use soft single step.
986 Use hard sigle step. */
993 /* Make sure the target beneath reports all signals. */
994 target_pass_signals (0, NULL);
996 ops->beneath->to_resume (ops->beneath, ptid, step, signal);
999 /* We are about to start executing the inferior (or simulate it),
1000 let's register it with the event loop. */
1001 if (target_can_async_p ())
1005 /* "to_commit_resume" method for process record target. */
1008 record_full_commit_resume (struct target_ops *ops)
1010 if (!RECORD_FULL_IS_REPLAY)
1011 ops->beneath->to_commit_resume (ops->beneath);
1014 static int record_full_get_sig = 0;
1016 /* SIGINT signal handler, registered by "to_wait" method. */
1019 record_full_sig_handler (int signo)
1022 fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
1024 /* It will break the running inferior in replay mode. */
1025 record_full_resume_step = 1;
1027 /* It will let record_full_wait set inferior status to get the signal
1029 record_full_get_sig = 1;
1033 record_full_wait_cleanups (void *ignore)
1035 if (execution_direction == EXEC_REVERSE)
1037 if (record_full_list->next)
1038 record_full_list = record_full_list->next;
1041 record_full_list = record_full_list->prev;
1044 /* "to_wait" target method for process record target.
1046 In record mode, the target is always run in singlestep mode
1047 (even when gdb says to continue). The to_wait method intercepts
1048 the stop events and determines which ones are to be passed on to
1049 gdb. Most stop events are just singlestep events that gdb is not
1050 to know about, so the to_wait method just records them and keeps
1053 In replay mode, this function emulates the recorded execution log,
1054 one instruction at a time (forward or backward), and determines
1058 record_full_wait_1 (struct target_ops *ops,
1059 ptid_t ptid, struct target_waitstatus *status,
1062 struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
1065 fprintf_unfiltered (gdb_stdlog,
1066 "Process record: record_full_wait "
1067 "record_full_resume_step = %d, "
1068 "record_full_resumed = %d, direction=%s\n",
1069 record_full_resume_step, record_full_resumed,
1070 record_full_execution_dir == EXEC_FORWARD
1071 ? "forward" : "reverse");
1073 if (!record_full_resumed)
1075 gdb_assert ((options & TARGET_WNOHANG) != 0);
1077 /* No interesting event. */
1078 status->kind = TARGET_WAITKIND_IGNORE;
1079 return minus_one_ptid;
1082 record_full_get_sig = 0;
1083 signal (SIGINT, record_full_sig_handler);
1085 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1087 if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
1089 if (record_full_resume_step)
1091 /* This is a single step. */
1092 return ops->beneath->to_wait (ops->beneath, ptid, status, options);
1096 /* This is not a single step. */
1099 struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);
1103 struct thread_info *tp;
1105 ret = ops->beneath->to_wait (ops->beneath, ptid, status, options);
1106 if (status->kind == TARGET_WAITKIND_IGNORE)
1109 fprintf_unfiltered (gdb_stdlog,
1110 "Process record: record_full_wait "
1111 "target beneath not done yet\n");
1115 ALL_NON_EXITED_THREADS (tp)
1116 delete_single_step_breakpoints (tp);
1118 if (record_full_resume_step)
1121 /* Is this a SIGTRAP? */
1122 if (status->kind == TARGET_WAITKIND_STOPPED
1123 && status->value.sig == GDB_SIGNAL_TRAP)
1125 struct regcache *regcache;
1126 struct address_space *aspace;
1127 enum target_stop_reason *stop_reason_p
1128 = &record_full_stop_reason;
1130 /* Yes -- this is likely our single-step finishing,
1131 but check if there's any reason the core would be
1132 interested in the event. */
1134 registers_changed ();
1135 regcache = get_current_regcache ();
1136 tmp_pc = regcache_read_pc (regcache);
1137 aspace = get_regcache_aspace (regcache);
1139 if (target_stopped_by_watchpoint ())
1141 /* Always interested in watchpoints. */
1143 else if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1146 /* There is a breakpoint here. Let the core
1151 /* This is a single-step trap. Record the
1152 insn and issue another step.
1153 FIXME: this part can be a random SIGTRAP too.
1154 But GDB cannot handle it. */
1157 if (!record_full_message_wrapper_safe (regcache,
1160 status->kind = TARGET_WAITKIND_STOPPED;
1161 status->value.sig = GDB_SIGNAL_0;
1165 if (gdbarch_software_single_step_p (gdbarch))
1167 /* Try to insert the software single step breakpoint.
1168 If insert success, set step to 0. */
1169 set_executing (inferior_ptid, 0);
1170 reinit_frame_cache ();
1171 if (gdbarch_software_single_step (gdbarch,
1172 get_current_frame ()))
1174 set_executing (inferior_ptid, 1);
1178 fprintf_unfiltered (gdb_stdlog,
1179 "Process record: record_full_wait "
1180 "issuing one more step in the "
1181 "target beneath\n");
1182 ops->beneath->to_resume (ops->beneath, ptid, step,
1184 ops->beneath->to_commit_resume (ops->beneath);
1189 /* The inferior is broken by a breakpoint or a signal. */
1198 struct regcache *regcache = get_current_regcache ();
1199 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1200 struct address_space *aspace = get_regcache_aspace (regcache);
1201 int continue_flag = 1;
1202 int first_record_full_end = 1;
1203 struct cleanup *old_cleanups
1204 = make_cleanup (record_full_wait_cleanups, 0);
1207 record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1208 status->kind = TARGET_WAITKIND_STOPPED;
1210 /* Check breakpoint when forward execute. */
1211 if (execution_direction == EXEC_FORWARD)
1213 tmp_pc = regcache_read_pc (regcache);
1214 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1215 &record_full_stop_reason))
1218 fprintf_unfiltered (gdb_stdlog,
1219 "Process record: break at %s.\n",
1220 paddress (gdbarch, tmp_pc));
1225 /* If GDB is in terminal_inferior mode, it will not get the signal.
1226 And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1227 mode, because inferior will not executed.
1228 Then set it to terminal_ours to make GDB get the signal. */
1229 target_terminal_ours ();
1231 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1233 if (execution_direction == EXEC_FORWARD && record_full_list->next)
1234 record_full_list = record_full_list->next;
1236 /* Loop over the record_full_list, looking for the next place to
1240 /* Check for beginning and end of log. */
1241 if (execution_direction == EXEC_REVERSE
1242 && record_full_list == &record_full_first)
1244 /* Hit beginning of record log in reverse. */
1245 status->kind = TARGET_WAITKIND_NO_HISTORY;
1248 if (execution_direction != EXEC_REVERSE && !record_full_list->next)
1250 /* Hit end of record log going forward. */
1251 status->kind = TARGET_WAITKIND_NO_HISTORY;
1255 record_full_exec_insn (regcache, gdbarch, record_full_list);
1257 if (record_full_list->type == record_full_end)
1259 if (record_debug > 1)
1260 fprintf_unfiltered (gdb_stdlog,
1261 "Process record: record_full_end %s to "
1263 host_address_to_string (record_full_list));
1265 if (first_record_full_end && execution_direction == EXEC_REVERSE)
1267 /* When reverse excute, the first record_full_end is the
1268 part of current instruction. */
1269 first_record_full_end = 0;
1273 /* In EXEC_REVERSE mode, this is the record_full_end of prev
1275 In EXEC_FORWARD mode, this is the record_full_end of
1276 current instruction. */
1278 if (record_full_resume_step)
1280 if (record_debug > 1)
1281 fprintf_unfiltered (gdb_stdlog,
1282 "Process record: step.\n");
1286 /* check breakpoint */
1287 tmp_pc = regcache_read_pc (regcache);
1288 if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1289 &record_full_stop_reason))
1292 fprintf_unfiltered (gdb_stdlog,
1293 "Process record: break "
1295 paddress (gdbarch, tmp_pc));
1300 if (record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
1303 fprintf_unfiltered (gdb_stdlog,
1304 "Process record: hit hw "
1308 /* Check target signal */
1309 if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1310 /* FIXME: better way to check */
1317 if (execution_direction == EXEC_REVERSE)
1319 if (record_full_list->prev)
1320 record_full_list = record_full_list->prev;
1324 if (record_full_list->next)
1325 record_full_list = record_full_list->next;
1329 while (continue_flag);
1332 if (record_full_get_sig)
1333 status->value.sig = GDB_SIGNAL_INT;
1334 else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1335 /* FIXME: better way to check */
1336 status->value.sig = record_full_list->u.end.sigval;
1338 status->value.sig = GDB_SIGNAL_TRAP;
1340 discard_cleanups (old_cleanups);
1343 signal (SIGINT, handle_sigint);
1345 do_cleanups (set_cleanups);
1346 return inferior_ptid;
1350 record_full_wait (struct target_ops *ops,
1351 ptid_t ptid, struct target_waitstatus *status,
1356 return_ptid = record_full_wait_1 (ops, ptid, status, options);
1357 if (status->kind != TARGET_WAITKIND_IGNORE)
1359 /* We're reporting a stop. Make sure any spurious
1360 target_wait(WNOHANG) doesn't advance the target until the
1361 core wants us resumed again. */
1362 record_full_resumed = 0;
1368 record_full_stopped_by_watchpoint (struct target_ops *ops)
1370 if (RECORD_FULL_IS_REPLAY)
1371 return record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
1373 return ops->beneath->to_stopped_by_watchpoint (ops->beneath);
1377 record_full_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
1379 if (RECORD_FULL_IS_REPLAY)
1382 return ops->beneath->to_stopped_data_address (ops->beneath, addr_p);
1385 /* The to_stopped_by_sw_breakpoint method of target record-full. */
1388 record_full_stopped_by_sw_breakpoint (struct target_ops *ops)
1390 return record_full_stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
1393 /* The to_supports_stopped_by_sw_breakpoint method of target
1397 record_full_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
1402 /* The to_stopped_by_hw_breakpoint method of target record-full. */
1405 record_full_stopped_by_hw_breakpoint (struct target_ops *ops)
1407 return record_full_stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
1410 /* The to_supports_stopped_by_sw_breakpoint method of target
1414 record_full_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
1419 /* Record registers change (by user or by GDB) to list as an instruction. */
1422 record_full_registers_change (struct regcache *regcache, int regnum)
1424 /* Check record_full_insn_num. */
1425 record_full_check_insn_num ();
1427 record_full_arch_list_head = NULL;
1428 record_full_arch_list_tail = NULL;
1434 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
1436 if (record_full_arch_list_add_reg (regcache, i))
1438 record_full_list_release (record_full_arch_list_tail);
1439 error (_("Process record: failed to record execution log."));
1445 if (record_full_arch_list_add_reg (regcache, regnum))
1447 record_full_list_release (record_full_arch_list_tail);
1448 error (_("Process record: failed to record execution log."));
1451 if (record_full_arch_list_add_end ())
1453 record_full_list_release (record_full_arch_list_tail);
1454 error (_("Process record: failed to record execution log."));
1456 record_full_list->next = record_full_arch_list_head;
1457 record_full_arch_list_head->prev = record_full_list;
1458 record_full_list = record_full_arch_list_tail;
1460 if (record_full_insn_num == record_full_insn_max_num)
1461 record_full_list_release_first ();
1463 record_full_insn_num++;
1466 /* "to_store_registers" method for process record target. */
1469 record_full_store_registers (struct target_ops *ops,
1470 struct regcache *regcache,
1473 if (!record_full_gdb_operation_disable)
1475 if (RECORD_FULL_IS_REPLAY)
1479 /* Let user choose if he wants to write register or not. */
1482 query (_("Because GDB is in replay mode, changing the "
1483 "value of a register will make the execution "
1484 "log unusable from this point onward. "
1485 "Change all registers?"));
1488 query (_("Because GDB is in replay mode, changing the value "
1489 "of a register will make the execution log unusable "
1490 "from this point onward. Change register %s?"),
1491 gdbarch_register_name (get_regcache_arch (regcache),
1496 /* Invalidate the value of regcache that was set in function
1497 "regcache_raw_write". */
1503 i < gdbarch_num_regs (get_regcache_arch (regcache));
1505 regcache_invalidate (regcache, i);
1508 regcache_invalidate (regcache, regno);
1510 error (_("Process record canceled the operation."));
1513 /* Destroy the record from here forward. */
1514 record_full_list_release_following (record_full_list);
1517 record_full_registers_change (regcache, regno);
1519 ops->beneath->to_store_registers (ops->beneath, regcache, regno);
1522 /* "to_xfer_partial" method. Behavior is conditional on
1523 RECORD_FULL_IS_REPLAY.
1524 In replay mode, we cannot write memory unles we are willing to
1525 invalidate the record/replay log from this point forward. */
1527 static enum target_xfer_status
1528 record_full_xfer_partial (struct target_ops *ops, enum target_object object,
1529 const char *annex, gdb_byte *readbuf,
1530 const gdb_byte *writebuf, ULONGEST offset,
1531 ULONGEST len, ULONGEST *xfered_len)
1533 if (!record_full_gdb_operation_disable
1534 && (object == TARGET_OBJECT_MEMORY
1535 || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
1537 if (RECORD_FULL_IS_REPLAY)
1539 /* Let user choose if he wants to write memory or not. */
1540 if (!query (_("Because GDB is in replay mode, writing to memory "
1541 "will make the execution log unusable from this "
1542 "point onward. Write memory at address %s?"),
1543 paddress (target_gdbarch (), offset)))
1544 error (_("Process record canceled the operation."));
1546 /* Destroy the record from here forward. */
1547 record_full_list_release_following (record_full_list);
1550 /* Check record_full_insn_num */
1551 record_full_check_insn_num ();
1553 /* Record registers change to list as an instruction. */
1554 record_full_arch_list_head = NULL;
1555 record_full_arch_list_tail = NULL;
1556 if (record_full_arch_list_add_mem (offset, len))
1558 record_full_list_release (record_full_arch_list_tail);
1560 fprintf_unfiltered (gdb_stdlog,
1561 "Process record: failed to record "
1563 return TARGET_XFER_E_IO;
1565 if (record_full_arch_list_add_end ())
1567 record_full_list_release (record_full_arch_list_tail);
1569 fprintf_unfiltered (gdb_stdlog,
1570 "Process record: failed to record "
1572 return TARGET_XFER_E_IO;
1574 record_full_list->next = record_full_arch_list_head;
1575 record_full_arch_list_head->prev = record_full_list;
1576 record_full_list = record_full_arch_list_tail;
1578 if (record_full_insn_num == record_full_insn_max_num)
1579 record_full_list_release_first ();
1581 record_full_insn_num++;
1584 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1585 readbuf, writebuf, offset,
1589 /* This structure represents a breakpoint inserted while the record
1590 target is active. We use this to know when to install/remove
1591 breakpoints in/from the target beneath. For example, a breakpoint
1592 may be inserted while recording, but removed when not replaying nor
1593 recording. In that case, the breakpoint had not been inserted on
1594 the target beneath, so we should not try to remove it there. */
1596 struct record_full_breakpoint
1598 /* The address and address space the breakpoint was set at. */
1599 struct address_space *address_space;
1602 /* True when the breakpoint has been also installed in the target
1603 beneath. This will be false for breakpoints set during replay or
1605 int in_target_beneath;
1608 typedef struct record_full_breakpoint *record_full_breakpoint_p;
1609 DEF_VEC_P(record_full_breakpoint_p);
1611 /* The list of breakpoints inserted while the record target is
1613 VEC(record_full_breakpoint_p) *record_full_breakpoints = NULL;
1616 record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
1618 if (loc->loc_type != bp_loc_software_breakpoint)
1623 struct record_full_breakpoint *bp = XNEW (struct record_full_breakpoint);
1625 bp->addr = loc->target_info.placed_address;
1626 bp->address_space = loc->target_info.placed_address_space;
1628 bp->in_target_beneath = 1;
1630 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1634 /* Sync existing breakpoints to record_full_breakpoints. */
1637 record_full_init_record_breakpoints (void)
1639 VEC_free (record_full_breakpoint_p, record_full_breakpoints);
1641 iterate_over_bp_locations (record_full_sync_record_breakpoints);
1644 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1645 insert or remove breakpoints in the real target when replaying, nor
1649 record_full_insert_breakpoint (struct target_ops *ops,
1650 struct gdbarch *gdbarch,
1651 struct bp_target_info *bp_tgt)
1653 struct record_full_breakpoint *bp;
1654 int in_target_beneath = 0;
1657 if (!RECORD_FULL_IS_REPLAY)
1659 /* When recording, we currently always single-step, so we don't
1660 really need to install regular breakpoints in the inferior.
1661 However, we do have to insert software single-step
1662 breakpoints, in case the target can't hardware step. To keep
1663 things simple, we always insert. */
1664 struct cleanup *old_cleanups;
1667 old_cleanups = record_full_gdb_operation_disable_set ();
1668 ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
1669 do_cleanups (old_cleanups);
1674 in_target_beneath = 1;
1678 CORE_ADDR addr = bp_tgt->reqstd_address;
1681 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
1683 bp_tgt->placed_address = addr;
1684 bp_tgt->placed_size = bplen;
1687 /* Use the existing entries if found in order to avoid duplication
1688 in record_full_breakpoints. */
1691 VEC_iterate (record_full_breakpoint_p,
1692 record_full_breakpoints, ix, bp);
1695 if (bp->addr == bp_tgt->placed_address
1696 && bp->address_space == bp_tgt->placed_address_space)
1698 gdb_assert (bp->in_target_beneath == in_target_beneath);
1703 bp = XNEW (struct record_full_breakpoint);
1704 bp->addr = bp_tgt->placed_address;
1705 bp->address_space = bp_tgt->placed_address_space;
1706 bp->in_target_beneath = in_target_beneath;
1707 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1711 /* "to_remove_breakpoint" method for process record target. */
1714 record_full_remove_breakpoint (struct target_ops *ops,
1715 struct gdbarch *gdbarch,
1716 struct bp_target_info *bp_tgt,
1717 enum remove_bp_reason reason)
1719 struct record_full_breakpoint *bp;
1723 VEC_iterate (record_full_breakpoint_p,
1724 record_full_breakpoints, ix, bp);
1727 if (bp->addr == bp_tgt->placed_address
1728 && bp->address_space == bp_tgt->placed_address_space)
1730 if (bp->in_target_beneath)
1732 struct cleanup *old_cleanups;
1735 old_cleanups = record_full_gdb_operation_disable_set ();
1736 ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch,
1738 do_cleanups (old_cleanups);
1744 if (reason == REMOVE_BREAKPOINT)
1746 VEC_unordered_remove (record_full_breakpoint_p,
1747 record_full_breakpoints, ix);
1753 gdb_assert_not_reached ("removing unknown breakpoint");
1756 /* "to_can_execute_reverse" method for process record target. */
1759 record_full_can_execute_reverse (struct target_ops *self)
1764 /* "to_get_bookmark" method for process record and prec over core. */
1767 record_full_get_bookmark (struct target_ops *self, const char *args,
1772 /* Return stringified form of instruction count. */
1773 if (record_full_list && record_full_list->type == record_full_end)
1774 ret = xstrdup (pulongest (record_full_list->u.end.insn_num));
1779 fprintf_unfiltered (gdb_stdlog,
1780 "record_full_get_bookmark returns %s\n", ret);
1782 fprintf_unfiltered (gdb_stdlog,
1783 "record_full_get_bookmark returns NULL\n");
1785 return (gdb_byte *) ret;
1788 /* "to_goto_bookmark" method for process record and prec over core. */
1791 record_full_goto_bookmark (struct target_ops *self,
1792 const gdb_byte *raw_bookmark, int from_tty)
1794 const char *bookmark = (const char *) raw_bookmark;
1795 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1798 fprintf_unfiltered (gdb_stdlog,
1799 "record_full_goto_bookmark receives %s\n", bookmark);
1801 if (bookmark[0] == '\'' || bookmark[0] == '\"')
1805 if (bookmark[strlen (bookmark) - 1] != bookmark[0])
1806 error (_("Unbalanced quotes: %s"), bookmark);
1809 copy = savestring (bookmark + 1, strlen (bookmark) - 2);
1810 make_cleanup (xfree, copy);
1814 record_goto (bookmark);
1816 do_cleanups (cleanup);
1819 static enum exec_direction_kind
1820 record_full_execution_direction (struct target_ops *self)
1822 return record_full_execution_dir;
1826 record_full_info (struct target_ops *self)
1828 struct record_full_entry *p;
1830 if (RECORD_FULL_IS_REPLAY)
1831 printf_filtered (_("Replay mode:\n"));
1833 printf_filtered (_("Record mode:\n"));
1835 /* Find entry for first actual instruction in the log. */
1836 for (p = record_full_first.next;
1837 p != NULL && p->type != record_full_end;
1841 /* Do we have a log at all? */
1842 if (p != NULL && p->type == record_full_end)
1844 /* Display instruction number for first instruction in the log. */
1845 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1846 pulongest (p->u.end.insn_num));
1848 /* If in replay mode, display where we are in the log. */
1849 if (RECORD_FULL_IS_REPLAY)
1850 printf_filtered (_("Current instruction number is %s.\n"),
1851 pulongest (record_full_list->u.end.insn_num));
1853 /* Display instruction number for last instruction in the log. */
1854 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1855 pulongest (record_full_insn_count));
1857 /* Display log count. */
1858 printf_filtered (_("Log contains %u instructions.\n"),
1859 record_full_insn_num);
1862 printf_filtered (_("No instructions have been logged.\n"));
1864 /* Display max log size. */
1865 printf_filtered (_("Max logged instructions is %u.\n"),
1866 record_full_insn_max_num);
1869 /* The "to_record_delete" target method. */
1872 record_full_delete (struct target_ops *self)
1874 record_full_list_release_following (record_full_list);
1877 /* The "to_record_is_replaying" target method. */
1880 record_full_is_replaying (struct target_ops *self, ptid_t ptid)
1882 return RECORD_FULL_IS_REPLAY;
1885 /* The "to_record_will_replay" target method. */
1888 record_full_will_replay (struct target_ops *self, ptid_t ptid, int dir)
1890 /* We can currently only record when executing forwards. Should we be able
1891 to record when executing backwards on targets that support reverse
1892 execution, this needs to be changed. */
1894 return RECORD_FULL_IS_REPLAY || dir == EXEC_REVERSE;
1897 /* Go to a specific entry. */
1900 record_full_goto_entry (struct record_full_entry *p)
1903 error (_("Target insn not found."));
1904 else if (p == record_full_list)
1905 error (_("Already at target insn."));
1906 else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
1908 printf_filtered (_("Go forward to insn number %s\n"),
1909 pulongest (p->u.end.insn_num));
1910 record_full_goto_insn (p, EXEC_FORWARD);
1914 printf_filtered (_("Go backward to insn number %s\n"),
1915 pulongest (p->u.end.insn_num));
1916 record_full_goto_insn (p, EXEC_REVERSE);
1919 registers_changed ();
1920 reinit_frame_cache ();
1921 stop_pc = regcache_read_pc (get_current_regcache ());
1922 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1925 /* The "to_goto_record_begin" target method. */
1928 record_full_goto_begin (struct target_ops *self)
1930 struct record_full_entry *p = NULL;
1932 for (p = &record_full_first; p != NULL; p = p->next)
1933 if (p->type == record_full_end)
1936 record_full_goto_entry (p);
1939 /* The "to_goto_record_end" target method. */
1942 record_full_goto_end (struct target_ops *self)
1944 struct record_full_entry *p = NULL;
1946 for (p = record_full_list; p->next != NULL; p = p->next)
1948 for (; p!= NULL; p = p->prev)
1949 if (p->type == record_full_end)
1952 record_full_goto_entry (p);
1955 /* The "to_goto_record" target method. */
1958 record_full_goto (struct target_ops *self, ULONGEST target_insn)
1960 struct record_full_entry *p = NULL;
1962 for (p = &record_full_first; p != NULL; p = p->next)
1963 if (p->type == record_full_end && p->u.end.insn_num == target_insn)
1966 record_full_goto_entry (p);
1969 /* The "to_record_stop_replaying" target method. */
1972 record_full_stop_replaying (struct target_ops *self)
1974 record_full_goto_end (self);
1978 init_record_full_ops (void)
1980 record_full_ops.to_shortname = "record-full";
1981 record_full_ops.to_longname = "Process record and replay target";
1982 record_full_ops.to_doc =
1983 "Log program while executing and replay execution from log.";
1984 record_full_ops.to_open = record_full_open;
1985 record_full_ops.to_close = record_full_close;
1986 record_full_ops.to_async = record_full_async;
1987 record_full_ops.to_resume = record_full_resume;
1988 record_full_ops.to_commit_resume = record_full_commit_resume;
1989 record_full_ops.to_wait = record_full_wait;
1990 record_full_ops.to_disconnect = record_disconnect;
1991 record_full_ops.to_detach = record_detach;
1992 record_full_ops.to_mourn_inferior = record_mourn_inferior;
1993 record_full_ops.to_kill = record_kill;
1994 record_full_ops.to_store_registers = record_full_store_registers;
1995 record_full_ops.to_xfer_partial = record_full_xfer_partial;
1996 record_full_ops.to_insert_breakpoint = record_full_insert_breakpoint;
1997 record_full_ops.to_remove_breakpoint = record_full_remove_breakpoint;
1998 record_full_ops.to_stopped_by_watchpoint = record_full_stopped_by_watchpoint;
1999 record_full_ops.to_stopped_data_address = record_full_stopped_data_address;
2000 record_full_ops.to_stopped_by_sw_breakpoint
2001 = record_full_stopped_by_sw_breakpoint;
2002 record_full_ops.to_supports_stopped_by_sw_breakpoint
2003 = record_full_supports_stopped_by_sw_breakpoint;
2004 record_full_ops.to_stopped_by_hw_breakpoint
2005 = record_full_stopped_by_hw_breakpoint;
2006 record_full_ops.to_supports_stopped_by_hw_breakpoint
2007 = record_full_supports_stopped_by_hw_breakpoint;
2008 record_full_ops.to_can_execute_reverse = record_full_can_execute_reverse;
2009 record_full_ops.to_stratum = record_stratum;
2010 /* Add bookmark target methods. */
2011 record_full_ops.to_get_bookmark = record_full_get_bookmark;
2012 record_full_ops.to_goto_bookmark = record_full_goto_bookmark;
2013 record_full_ops.to_execution_direction = record_full_execution_direction;
2014 record_full_ops.to_info_record = record_full_info;
2015 record_full_ops.to_save_record = record_full_save;
2016 record_full_ops.to_delete_record = record_full_delete;
2017 record_full_ops.to_record_is_replaying = record_full_is_replaying;
2018 record_full_ops.to_record_will_replay = record_full_will_replay;
2019 record_full_ops.to_record_stop_replaying = record_full_stop_replaying;
2020 record_full_ops.to_goto_record_begin = record_full_goto_begin;
2021 record_full_ops.to_goto_record_end = record_full_goto_end;
2022 record_full_ops.to_goto_record = record_full_goto;
2023 record_full_ops.to_magic = OPS_MAGIC;
2026 /* "to_resume" method for prec over corefile. */
2029 record_full_core_resume (struct target_ops *ops, ptid_t ptid, int step,
2030 enum gdb_signal signal)
2032 record_full_resume_step = step;
2033 record_full_resumed = 1;
2034 record_full_execution_dir = execution_direction;
2036 /* We are about to start executing the inferior (or simulate it),
2037 let's register it with the event loop. */
2038 if (target_can_async_p ())
2042 /* "to_kill" method for prec over corefile. */
2045 record_full_core_kill (struct target_ops *ops)
2048 fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
2050 unpush_target (&record_full_core_ops);
2053 /* "to_fetch_registers" method for prec over corefile. */
2056 record_full_core_fetch_registers (struct target_ops *ops,
2057 struct regcache *regcache,
2062 int num = gdbarch_num_regs (get_regcache_arch (regcache));
2065 for (i = 0; i < num; i ++)
2066 regcache_raw_supply (regcache, i,
2067 record_full_core_regbuf + MAX_REGISTER_SIZE * i);
2070 regcache_raw_supply (regcache, regno,
2071 record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2074 /* "to_prepare_to_store" method for prec over corefile. */
2077 record_full_core_prepare_to_store (struct target_ops *self,
2078 struct regcache *regcache)
2082 /* "to_store_registers" method for prec over corefile. */
2085 record_full_core_store_registers (struct target_ops *ops,
2086 struct regcache *regcache,
2089 if (record_full_gdb_operation_disable)
2090 regcache_raw_collect (regcache, regno,
2091 record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2093 error (_("You can't do that without a process to debug."));
2096 /* "to_xfer_partial" method for prec over corefile. */
2098 static enum target_xfer_status
2099 record_full_core_xfer_partial (struct target_ops *ops,
2100 enum target_object object,
2101 const char *annex, gdb_byte *readbuf,
2102 const gdb_byte *writebuf, ULONGEST offset,
2103 ULONGEST len, ULONGEST *xfered_len)
2105 if (object == TARGET_OBJECT_MEMORY)
2107 if (record_full_gdb_operation_disable || !writebuf)
2109 struct target_section *p;
2111 for (p = record_full_core_start; p < record_full_core_end; p++)
2113 if (offset >= p->addr)
2115 struct record_full_core_buf_entry *entry;
2116 ULONGEST sec_offset;
2118 if (offset >= p->endaddr)
2121 if (offset + len > p->endaddr)
2122 len = p->endaddr - offset;
2124 sec_offset = offset - p->addr;
2126 /* Read readbuf or write writebuf p, offset, len. */
2128 if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
2129 || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
2132 memset (readbuf, 0, len);
2135 return TARGET_XFER_OK;
2137 /* Get record_full_core_buf_entry. */
2138 for (entry = record_full_core_buf_list; entry;
2139 entry = entry->prev)
2146 /* Add a new entry. */
2147 entry = XNEW (struct record_full_core_buf_entry);
2149 if (!bfd_malloc_and_get_section
2150 (p->the_bfd_section->owner,
2155 return TARGET_XFER_EOF;
2157 entry->prev = record_full_core_buf_list;
2158 record_full_core_buf_list = entry;
2161 memcpy (entry->buf + sec_offset, writebuf,
2167 return ops->beneath->to_xfer_partial (ops->beneath,
2173 memcpy (readbuf, entry->buf + sec_offset,
2178 return TARGET_XFER_OK;
2182 return TARGET_XFER_E_IO;
2185 error (_("You can't do that without a process to debug."));
2188 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2189 readbuf, writebuf, offset, len,
2193 /* "to_insert_breakpoint" method for prec over corefile. */
2196 record_full_core_insert_breakpoint (struct target_ops *ops,
2197 struct gdbarch *gdbarch,
2198 struct bp_target_info *bp_tgt)
2203 /* "to_remove_breakpoint" method for prec over corefile. */
2206 record_full_core_remove_breakpoint (struct target_ops *ops,
2207 struct gdbarch *gdbarch,
2208 struct bp_target_info *bp_tgt,
2209 enum remove_bp_reason reason)
2214 /* "to_has_execution" method for prec over corefile. */
2217 record_full_core_has_execution (struct target_ops *ops, ptid_t the_ptid)
2223 init_record_full_core_ops (void)
2225 record_full_core_ops.to_shortname = "record-core";
2226 record_full_core_ops.to_longname = "Process record and replay target";
2227 record_full_core_ops.to_doc =
2228 "Log program while executing and replay execution from log.";
2229 record_full_core_ops.to_open = record_full_open;
2230 record_full_core_ops.to_close = record_full_close;
2231 record_full_core_ops.to_async = record_full_async;
2232 record_full_core_ops.to_resume = record_full_core_resume;
2233 record_full_core_ops.to_wait = record_full_wait;
2234 record_full_core_ops.to_kill = record_full_core_kill;
2235 record_full_core_ops.to_fetch_registers = record_full_core_fetch_registers;
2236 record_full_core_ops.to_prepare_to_store = record_full_core_prepare_to_store;
2237 record_full_core_ops.to_store_registers = record_full_core_store_registers;
2238 record_full_core_ops.to_xfer_partial = record_full_core_xfer_partial;
2239 record_full_core_ops.to_insert_breakpoint
2240 = record_full_core_insert_breakpoint;
2241 record_full_core_ops.to_remove_breakpoint
2242 = record_full_core_remove_breakpoint;
2243 record_full_core_ops.to_stopped_by_watchpoint
2244 = record_full_stopped_by_watchpoint;
2245 record_full_core_ops.to_stopped_data_address
2246 = record_full_stopped_data_address;
2247 record_full_core_ops.to_stopped_by_sw_breakpoint
2248 = record_full_stopped_by_sw_breakpoint;
2249 record_full_core_ops.to_supports_stopped_by_sw_breakpoint
2250 = record_full_supports_stopped_by_sw_breakpoint;
2251 record_full_core_ops.to_stopped_by_hw_breakpoint
2252 = record_full_stopped_by_hw_breakpoint;
2253 record_full_core_ops.to_supports_stopped_by_hw_breakpoint
2254 = record_full_supports_stopped_by_hw_breakpoint;
2255 record_full_core_ops.to_can_execute_reverse
2256 = record_full_can_execute_reverse;
2257 record_full_core_ops.to_has_execution = record_full_core_has_execution;
2258 record_full_core_ops.to_stratum = record_stratum;
2259 /* Add bookmark target methods. */
2260 record_full_core_ops.to_get_bookmark = record_full_get_bookmark;
2261 record_full_core_ops.to_goto_bookmark = record_full_goto_bookmark;
2262 record_full_core_ops.to_execution_direction
2263 = record_full_execution_direction;
2264 record_full_core_ops.to_info_record = record_full_info;
2265 record_full_core_ops.to_delete_record = record_full_delete;
2266 record_full_core_ops.to_record_is_replaying = record_full_is_replaying;
2267 record_full_core_ops.to_record_will_replay = record_full_will_replay;
2268 record_full_core_ops.to_goto_record_begin = record_full_goto_begin;
2269 record_full_core_ops.to_goto_record_end = record_full_goto_end;
2270 record_full_core_ops.to_goto_record = record_full_goto;
2271 record_full_core_ops.to_magic = OPS_MAGIC;
2274 /* Record log save-file format
2275 Version 1 (never released)
2278 4 bytes: magic number htonl(0x20090829).
2279 NOTE: be sure to change whenever this file format changes!
2283 1 byte: record type (record_full_end, see enum record_full_type).
2285 1 byte: record type (record_full_reg, see enum record_full_type).
2286 8 bytes: register id (network byte order).
2287 MAX_REGISTER_SIZE bytes: register value.
2289 1 byte: record type (record_full_mem, see enum record_full_type).
2290 8 bytes: memory length (network byte order).
2291 8 bytes: memory address (network byte order).
2292 n bytes: memory value (n == memory length).
2295 4 bytes: magic number netorder32(0x20091016).
2296 NOTE: be sure to change whenever this file format changes!
2300 1 byte: record type (record_full_end, see enum record_full_type).
2302 4 bytes: instruction count
2304 1 byte: record type (record_full_reg, see enum record_full_type).
2305 4 bytes: register id (network byte order).
2306 n bytes: register value (n == actual register size).
2307 (eg. 4 bytes for x86 general registers).
2309 1 byte: record type (record_full_mem, see enum record_full_type).
2310 4 bytes: memory length (network byte order).
2311 8 bytes: memory address (network byte order).
2312 n bytes: memory value (n == memory length).
2316 /* bfdcore_read -- read bytes from a core file section. */
2319 bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2321 int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2326 error (_("Failed to read %d bytes from core file %s ('%s')."),
2327 len, bfd_get_filename (obfd),
2328 bfd_errmsg (bfd_get_error ()));
2331 static inline uint64_t
2332 netorder64 (uint64_t input)
2336 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2337 BFD_ENDIAN_BIG, input);
2341 static inline uint32_t
2342 netorder32 (uint32_t input)
2346 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2347 BFD_ENDIAN_BIG, input);
2351 static inline uint16_t
2352 netorder16 (uint16_t input)
2356 store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2357 BFD_ENDIAN_BIG, input);
2361 /* Restore the execution log from a core_bfd file. */
2363 record_full_restore (void)
2366 struct cleanup *old_cleanups;
2367 struct record_full_entry *rec;
2371 struct regcache *regcache;
2373 /* We restore the execution log from the open core bfd,
2375 if (core_bfd == NULL)
2378 /* "record_full_restore" can only be called when record list is empty. */
2379 gdb_assert (record_full_first.next == NULL);
2382 fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
2384 /* Now need to find our special note section. */
2385 osec = bfd_get_section_by_name (core_bfd, "null0");
2387 fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
2388 osec ? "succeeded" : "failed");
2391 osec_size = bfd_section_size (core_bfd, osec);
2393 fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
2395 /* Check the magic code. */
2396 bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
2397 if (magic != RECORD_FULL_FILE_MAGIC)
2398 error (_("Version mis-match or file format error in core file %s."),
2399 bfd_get_filename (core_bfd));
2401 fprintf_unfiltered (gdb_stdlog,
2402 " Reading 4-byte magic cookie "
2403 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2404 phex_nz (netorder32 (magic), 4));
2406 /* Restore the entries in recfd into record_full_arch_list_head and
2407 record_full_arch_list_tail. */
2408 record_full_arch_list_head = NULL;
2409 record_full_arch_list_tail = NULL;
2410 record_full_insn_num = 0;
2411 old_cleanups = make_cleanup (record_full_arch_list_cleanups, 0);
2412 regcache = get_current_regcache ();
2417 uint32_t regnum, len, signal, count;
2420 /* We are finished when offset reaches osec_size. */
2421 if (bfd_offset >= osec_size)
2423 bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);
2427 case record_full_reg: /* reg */
2428 /* Get register number to regnum. */
2429 bfdcore_read (core_bfd, osec, ®num,
2430 sizeof (regnum), &bfd_offset);
2431 regnum = netorder32 (regnum);
2433 rec = record_full_reg_alloc (regcache, regnum);
2436 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2437 rec->u.reg.len, &bfd_offset);
2440 fprintf_unfiltered (gdb_stdlog,
2441 " Reading register %d (1 "
2442 "plus %lu plus %d bytes)\n",
2444 (unsigned long) sizeof (regnum),
2448 case record_full_mem: /* mem */
2450 bfdcore_read (core_bfd, osec, &len,
2451 sizeof (len), &bfd_offset);
2452 len = netorder32 (len);
2455 bfdcore_read (core_bfd, osec, &addr,
2456 sizeof (addr), &bfd_offset);
2457 addr = netorder64 (addr);
2459 rec = record_full_mem_alloc (addr, len);
2462 bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2463 rec->u.mem.len, &bfd_offset);
2466 fprintf_unfiltered (gdb_stdlog,
2467 " Reading memory %s (1 plus "
2468 "%lu plus %lu plus %d bytes)\n",
2469 paddress (get_current_arch (),
2471 (unsigned long) sizeof (addr),
2472 (unsigned long) sizeof (len),
2476 case record_full_end: /* end */
2477 rec = record_full_end_alloc ();
2478 record_full_insn_num ++;
2480 /* Get signal value. */
2481 bfdcore_read (core_bfd, osec, &signal,
2482 sizeof (signal), &bfd_offset);
2483 signal = netorder32 (signal);
2484 rec->u.end.sigval = (enum gdb_signal) signal;
2486 /* Get insn count. */
2487 bfdcore_read (core_bfd, osec, &count,
2488 sizeof (count), &bfd_offset);
2489 count = netorder32 (count);
2490 rec->u.end.insn_num = count;
2491 record_full_insn_count = count + 1;
2493 fprintf_unfiltered (gdb_stdlog,
2494 " Reading record_full_end (1 + "
2495 "%lu + %lu bytes), offset == %s\n",
2496 (unsigned long) sizeof (signal),
2497 (unsigned long) sizeof (count),
2498 paddress (get_current_arch (),
2503 error (_("Bad entry type in core file %s."),
2504 bfd_get_filename (core_bfd));
2508 /* Add rec to record arch list. */
2509 record_full_arch_list_add (rec);
2512 discard_cleanups (old_cleanups);
2514 /* Add record_full_arch_list_head to the end of record list. */
2515 record_full_first.next = record_full_arch_list_head;
2516 record_full_arch_list_head->prev = &record_full_first;
2517 record_full_arch_list_tail->next = NULL;
2518 record_full_list = &record_full_first;
2520 /* Update record_full_insn_max_num. */
2521 if (record_full_insn_num > record_full_insn_max_num)
2523 record_full_insn_max_num = record_full_insn_num;
2524 warning (_("Auto increase record/replay buffer limit to %u."),
2525 record_full_insn_max_num);
2529 printf_filtered (_("Restored records from core file %s.\n"),
2530 bfd_get_filename (core_bfd));
2532 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2535 /* bfdcore_write -- write bytes into a core file section. */
2538 bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2540 int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2545 error (_("Failed to write %d bytes to core file %s ('%s')."),
2546 len, bfd_get_filename (obfd),
2547 bfd_errmsg (bfd_get_error ()));
2550 /* Restore the execution log from a file. We use a modified elf
2551 corefile format, with an extra section for our data. */
2554 cmd_record_full_restore (char *args, int from_tty)
2556 core_file_command (args, from_tty);
2557 record_full_open (args, from_tty);
2561 record_full_save_cleanups (void *data)
2563 bfd *obfd = (bfd *) data;
2564 char *pathname = xstrdup (bfd_get_filename (obfd));
2566 gdb_bfd_unref (obfd);
2571 /* Save the execution log to a file. We use a modified elf corefile
2572 format, with an extra section for our data. */
2575 record_full_save (struct target_ops *self, const char *recfilename)
2577 struct record_full_entry *cur_record_full_list;
2579 struct regcache *regcache;
2580 struct gdbarch *gdbarch;
2581 struct cleanup *old_cleanups;
2582 struct cleanup *set_cleanups;
2585 asection *osec = NULL;
2588 /* Open the save file. */
2590 fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
2593 /* Open the output file. */
2594 obfd = create_gcore_bfd (recfilename);
2595 old_cleanups = make_cleanup (record_full_save_cleanups, obfd);
2597 /* Save the current record entry to "cur_record_full_list". */
2598 cur_record_full_list = record_full_list;
2600 /* Get the values of regcache and gdbarch. */
2601 regcache = get_current_regcache ();
2602 gdbarch = get_regcache_arch (regcache);
2604 /* Disable the GDB operation record. */
2605 set_cleanups = record_full_gdb_operation_disable_set ();
2607 /* Reverse execute to the begin of record list. */
2610 /* Check for beginning and end of log. */
2611 if (record_full_list == &record_full_first)
2614 record_full_exec_insn (regcache, gdbarch, record_full_list);
2616 if (record_full_list->prev)
2617 record_full_list = record_full_list->prev;
2620 /* Compute the size needed for the extra bfd section. */
2621 save_size = 4; /* magic cookie */
2622 for (record_full_list = record_full_first.next; record_full_list;
2623 record_full_list = record_full_list->next)
2624 switch (record_full_list->type)
2626 case record_full_end:
2627 save_size += 1 + 4 + 4;
2629 case record_full_reg:
2630 save_size += 1 + 4 + record_full_list->u.reg.len;
2632 case record_full_mem:
2633 save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
2637 /* Make the new bfd section. */
2638 osec = bfd_make_section_anyway_with_flags (obfd, "precord",
2642 error (_("Failed to create 'precord' section for corefile %s: %s"),
2644 bfd_errmsg (bfd_get_error ()));
2645 bfd_set_section_size (obfd, osec, save_size);
2646 bfd_set_section_vma (obfd, osec, 0);
2647 bfd_set_section_alignment (obfd, osec, 0);
2648 bfd_section_lma (obfd, osec) = 0;
2650 /* Save corefile state. */
2651 write_gcore_file (obfd);
2653 /* Write out the record log. */
2654 /* Write the magic code. */
2655 magic = RECORD_FULL_FILE_MAGIC;
2657 fprintf_unfiltered (gdb_stdlog,
2658 " Writing 4-byte magic cookie "
2659 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2660 phex_nz (magic, 4));
2661 bfdcore_write (obfd, osec, &magic, sizeof (magic), &bfd_offset);
2663 /* Save the entries to recfd and forward execute to the end of
2665 record_full_list = &record_full_first;
2669 if (record_full_list != &record_full_first)
2672 uint32_t regnum, len, signal, count;
2675 type = record_full_list->type;
2676 bfdcore_write (obfd, osec, &type, sizeof (type), &bfd_offset);
2678 switch (record_full_list->type)
2680 case record_full_reg: /* reg */
2682 fprintf_unfiltered (gdb_stdlog,
2683 " Writing register %d (1 "
2684 "plus %lu plus %d bytes)\n",
2685 record_full_list->u.reg.num,
2686 (unsigned long) sizeof (regnum),
2687 record_full_list->u.reg.len);
2690 regnum = netorder32 (record_full_list->u.reg.num);
2691 bfdcore_write (obfd, osec, ®num,
2692 sizeof (regnum), &bfd_offset);
2695 bfdcore_write (obfd, osec,
2696 record_full_get_loc (record_full_list),
2697 record_full_list->u.reg.len, &bfd_offset);
2700 case record_full_mem: /* mem */
2702 fprintf_unfiltered (gdb_stdlog,
2703 " Writing memory %s (1 plus "
2704 "%lu plus %lu plus %d bytes)\n",
2706 record_full_list->u.mem.addr),
2707 (unsigned long) sizeof (addr),
2708 (unsigned long) sizeof (len),
2709 record_full_list->u.mem.len);
2712 len = netorder32 (record_full_list->u.mem.len);
2713 bfdcore_write (obfd, osec, &len, sizeof (len), &bfd_offset);
2715 /* Write memaddr. */
2716 addr = netorder64 (record_full_list->u.mem.addr);
2717 bfdcore_write (obfd, osec, &addr,
2718 sizeof (addr), &bfd_offset);
2721 bfdcore_write (obfd, osec,
2722 record_full_get_loc (record_full_list),
2723 record_full_list->u.mem.len, &bfd_offset);
2726 case record_full_end:
2728 fprintf_unfiltered (gdb_stdlog,
2729 " Writing record_full_end (1 + "
2730 "%lu + %lu bytes)\n",
2731 (unsigned long) sizeof (signal),
2732 (unsigned long) sizeof (count));
2733 /* Write signal value. */
2734 signal = netorder32 (record_full_list->u.end.sigval);
2735 bfdcore_write (obfd, osec, &signal,
2736 sizeof (signal), &bfd_offset);
2738 /* Write insn count. */
2739 count = netorder32 (record_full_list->u.end.insn_num);
2740 bfdcore_write (obfd, osec, &count,
2741 sizeof (count), &bfd_offset);
2746 /* Execute entry. */
2747 record_full_exec_insn (regcache, gdbarch, record_full_list);
2749 if (record_full_list->next)
2750 record_full_list = record_full_list->next;
2755 /* Reverse execute to cur_record_full_list. */
2758 /* Check for beginning and end of log. */
2759 if (record_full_list == cur_record_full_list)
2762 record_full_exec_insn (regcache, gdbarch, record_full_list);
2764 if (record_full_list->prev)
2765 record_full_list = record_full_list->prev;
2768 do_cleanups (set_cleanups);
2769 gdb_bfd_unref (obfd);
2770 discard_cleanups (old_cleanups);
2773 printf_filtered (_("Saved core file %s with execution log.\n"),
2777 /* record_full_goto_insn -- rewind the record log (forward or backward,
2778 depending on DIR) to the given entry, changing the program state
2782 record_full_goto_insn (struct record_full_entry *entry,
2783 enum exec_direction_kind dir)
2785 struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
2786 struct regcache *regcache = get_current_regcache ();
2787 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2789 /* Assume everything is valid: we will hit the entry,
2790 and we will not hit the end of the recording. */
2792 if (dir == EXEC_FORWARD)
2793 record_full_list = record_full_list->next;
2797 record_full_exec_insn (regcache, gdbarch, record_full_list);
2798 if (dir == EXEC_REVERSE)
2799 record_full_list = record_full_list->prev;
2801 record_full_list = record_full_list->next;
2802 } while (record_full_list != entry);
2803 do_cleanups (set_cleanups);
2806 /* Alias for "target record-full". */
2809 cmd_record_full_start (char *args, int from_tty)
2811 execute_command ("target record-full", from_tty);
2815 set_record_full_insn_max_num (char *args, int from_tty,
2816 struct cmd_list_element *c)
2818 if (record_full_insn_num > record_full_insn_max_num)
2820 /* Count down record_full_insn_num while releasing records from list. */
2821 while (record_full_insn_num > record_full_insn_max_num)
2823 record_full_list_release_first ();
2824 record_full_insn_num--;
2829 /* The "set record full" command. */
2832 set_record_full_command (char *args, int from_tty)
2834 printf_unfiltered (_("\"set record full\" must be followed "
2835 "by an apporpriate subcommand.\n"));
2836 help_list (set_record_full_cmdlist, "set record full ", all_commands,
2840 /* The "show record full" command. */
2843 show_record_full_command (char *args, int from_tty)
2845 cmd_show_list (show_record_full_cmdlist, from_tty, "");
2848 /* Provide a prototype to silence -Wmissing-prototypes. */
2849 extern initialize_file_ftype _initialize_record_full;
2852 _initialize_record_full (void)
2854 struct cmd_list_element *c;
2856 /* Init record_full_first. */
2857 record_full_first.prev = NULL;
2858 record_full_first.next = NULL;
2859 record_full_first.type = record_full_end;
2861 init_record_full_ops ();
2862 add_target (&record_full_ops);
2863 add_deprecated_target_alias (&record_full_ops, "record");
2864 init_record_full_core_ops ();
2865 add_target (&record_full_core_ops);
2867 add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
2868 _("Start full execution recording."), &record_full_cmdlist,
2869 "record full ", 0, &record_cmdlist);
2871 c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
2872 _("Restore the execution log from a file.\n\
2873 Argument is filename. File must be created with 'record save'."),
2874 &record_full_cmdlist);
2875 set_cmd_completer (c, filename_completer);
2877 /* Deprecate the old version without "full" prefix. */
2878 c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
2880 set_cmd_completer (c, filename_completer);
2881 deprecate_cmd (c, "record full restore");
2883 add_prefix_cmd ("full", class_support, set_record_full_command,
2884 _("Set record options"), &set_record_full_cmdlist,
2885 "set record full ", 0, &set_record_cmdlist);
2887 add_prefix_cmd ("full", class_support, show_record_full_command,
2888 _("Show record options"), &show_record_full_cmdlist,
2889 "show record full ", 0, &show_record_cmdlist);
2891 /* Record instructions number limit command. */
2892 add_setshow_boolean_cmd ("stop-at-limit", no_class,
2893 &record_full_stop_at_limit, _("\
2894 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2895 Show whether record/replay stops when record/replay buffer becomes full."),
2896 _("Default is ON.\n\
2897 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2898 When OFF, if the record/replay buffer becomes full,\n\
2899 delete the oldest recorded instruction to make room for each new one."),
2901 &set_record_full_cmdlist, &show_record_full_cmdlist);
2903 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2904 &set_record_cmdlist);
2905 deprecate_cmd (c, "set record full stop-at-limit");
2907 c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2908 &show_record_cmdlist);
2909 deprecate_cmd (c, "show record full stop-at-limit");
2911 add_setshow_uinteger_cmd ("insn-number-max", no_class,
2912 &record_full_insn_max_num,
2913 _("Set record/replay buffer limit."),
2914 _("Show record/replay buffer limit."), _("\
2915 Set the maximum number of instructions to be stored in the\n\
2916 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2917 limit. Default is 200000."),
2918 set_record_full_insn_max_num,
2919 NULL, &set_record_full_cmdlist,
2920 &show_record_full_cmdlist);
2922 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2923 &set_record_cmdlist);
2924 deprecate_cmd (c, "set record full insn-number-max");
2926 c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2927 &show_record_cmdlist);
2928 deprecate_cmd (c, "show record full insn-number-max");
2930 add_setshow_boolean_cmd ("memory-query", no_class,
2931 &record_full_memory_query, _("\
2932 Set whether query if PREC cannot record memory change of next instruction."),
2934 Show whether query if PREC cannot record memory change of next instruction."),
2937 When ON, query if PREC cannot record memory change of next instruction."),
2939 &set_record_full_cmdlist,
2940 &show_record_full_cmdlist);
2942 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2943 &set_record_cmdlist);
2944 deprecate_cmd (c, "set record full memory-query");
2946 c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2947 &show_record_cmdlist);
2948 deprecate_cmd (c, "show record full memory-query");