1 /* Process record and replay target for GDB, the GNU debugger.
3 Copyright (C) 2013-2014 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 int record_full_hw_watchpoint
= 0;
693 /* Execute one instruction from the record log. Each instruction in
694 the log will be represented by an arbitrary sequence of register
695 entries and memory entries, followed by an 'end' entry. */
698 record_full_exec_insn (struct regcache
*regcache
,
699 struct gdbarch
*gdbarch
,
700 struct record_full_entry
*entry
)
704 case record_full_reg
: /* reg */
706 gdb_byte reg
[MAX_REGISTER_SIZE
];
708 if (record_debug
> 1)
709 fprintf_unfiltered (gdb_stdlog
,
710 "Process record: record_full_reg %s to "
711 "inferior num = %d.\n",
712 host_address_to_string (entry
),
715 regcache_cooked_read (regcache
, entry
->u
.reg
.num
, reg
);
716 regcache_cooked_write (regcache
, entry
->u
.reg
.num
,
717 record_full_get_loc (entry
));
718 memcpy (record_full_get_loc (entry
), reg
, entry
->u
.reg
.len
);
722 case record_full_mem
: /* mem */
724 /* Nothing to do if the entry is flagged not_accessible. */
725 if (!entry
->u
.mem
.mem_entry_not_accessible
)
727 gdb_byte
*mem
= alloca (entry
->u
.mem
.len
);
729 if (record_debug
> 1)
730 fprintf_unfiltered (gdb_stdlog
,
731 "Process record: record_full_mem %s to "
732 "inferior addr = %s len = %d.\n",
733 host_address_to_string (entry
),
734 paddress (gdbarch
, entry
->u
.mem
.addr
),
737 if (record_read_memory (gdbarch
,
738 entry
->u
.mem
.addr
, mem
, entry
->u
.mem
.len
))
739 entry
->u
.mem
.mem_entry_not_accessible
= 1;
742 if (target_write_memory (entry
->u
.mem
.addr
,
743 record_full_get_loc (entry
),
746 entry
->u
.mem
.mem_entry_not_accessible
= 1;
748 warning (_("Process record: error writing memory at "
749 "addr = %s len = %d."),
750 paddress (gdbarch
, entry
->u
.mem
.addr
),
755 memcpy (record_full_get_loc (entry
), mem
,
758 /* We've changed memory --- check if a hardware
759 watchpoint should trap. Note that this
760 presently assumes the target beneath supports
761 continuable watchpoints. On non-continuable
762 watchpoints target, we'll want to check this
763 _before_ actually doing the memory change, and
764 not doing the change at all if the watchpoint
766 if (hardware_watchpoint_inserted_in_range
767 (get_regcache_aspace (regcache
),
768 entry
->u
.mem
.addr
, entry
->u
.mem
.len
))
769 record_full_hw_watchpoint
= 1;
778 static void record_full_restore (void);
780 /* Asynchronous signal handle registered as event loop source for when
781 we have pending events ready to be passed to the core. */
783 static struct async_event_handler
*record_full_async_inferior_event_token
;
786 record_full_async_inferior_event_handler (gdb_client_data data
)
788 inferior_event_handler (INF_REG_EVENT
, NULL
);
791 /* Open the process record target. */
794 record_full_core_open_1 (const char *name
, int from_tty
)
796 struct regcache
*regcache
= get_current_regcache ();
797 int regnum
= gdbarch_num_regs (get_regcache_arch (regcache
));
800 /* Get record_full_core_regbuf. */
801 target_fetch_registers (regcache
, -1);
802 record_full_core_regbuf
= xmalloc (MAX_REGISTER_SIZE
* regnum
);
803 for (i
= 0; i
< regnum
; i
++)
804 regcache_raw_collect (regcache
, i
,
805 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
807 /* Get record_full_core_start and record_full_core_end. */
808 if (build_section_table (core_bfd
, &record_full_core_start
,
809 &record_full_core_end
))
811 xfree (record_full_core_regbuf
);
812 record_full_core_regbuf
= NULL
;
813 error (_("\"%s\": Can't find sections: %s"),
814 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
817 push_target (&record_full_core_ops
);
818 record_full_restore ();
821 /* "to_open" target method for 'live' processes. */
824 record_full_open_1 (const char *name
, int from_tty
)
827 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
830 if (!target_has_execution
)
831 error (_("Process record: the program is not being run."));
833 error (_("Process record target can't debug inferior in non-stop mode "
836 if (!gdbarch_process_record_p (target_gdbarch ()))
837 error (_("Process record: the current architecture doesn't support "
838 "record function."));
840 push_target (&record_full_ops
);
843 static void record_full_init_record_breakpoints (void);
845 /* "to_open" target method. Open the process record target. */
848 record_full_open (const char *name
, int from_tty
)
850 struct target_ops
*t
;
853 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
858 record_full_insn_num
= 0;
859 record_full_insn_count
= 0;
860 record_full_list
= &record_full_first
;
861 record_full_list
->next
= NULL
;
864 record_full_core_open_1 (name
, from_tty
);
866 record_full_open_1 (name
, from_tty
);
868 /* Register extra event sources in the event loop. */
869 record_full_async_inferior_event_token
870 = create_async_event_handler (record_full_async_inferior_event_handler
,
873 record_full_init_record_breakpoints ();
875 observer_notify_record_changed (current_inferior (), 1);
878 /* "to_close" target method. Close the process record target. */
881 record_full_close (struct target_ops
*self
)
883 struct record_full_core_buf_entry
*entry
;
886 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_close\n");
888 record_full_list_release (record_full_list
);
890 /* Release record_full_core_regbuf. */
891 if (record_full_core_regbuf
)
893 xfree (record_full_core_regbuf
);
894 record_full_core_regbuf
= NULL
;
897 /* Release record_full_core_buf_list. */
898 if (record_full_core_buf_list
)
900 for (entry
= record_full_core_buf_list
->prev
; entry
;
903 xfree (record_full_core_buf_list
);
904 record_full_core_buf_list
= entry
;
906 record_full_core_buf_list
= NULL
;
909 if (record_full_async_inferior_event_token
)
910 delete_async_event_handler (&record_full_async_inferior_event_token
);
913 static int record_full_resume_step
= 0;
915 /* True if we've been resumed, and so each record_full_wait call should
916 advance execution. If this is false, record_full_wait will return a
917 TARGET_WAITKIND_IGNORE. */
918 static int record_full_resumed
= 0;
920 /* The execution direction of the last resume we got. This is
921 necessary for async mode. Vis (order is not strictly accurate):
923 1. user has the global execution direction set to forward
924 2. user does a reverse-step command
925 3. record_full_resume is called with global execution direction
926 temporarily switched to reverse
927 4. GDB's execution direction is reverted back to forward
928 5. target record notifies event loop there's an event to handle
929 6. infrun asks the target which direction was it going, and switches
930 the global execution direction accordingly (to reverse)
931 7. infrun polls an event out of the record target, and handles it
932 8. GDB goes back to the event loop, and goto #4.
934 static enum exec_direction_kind record_full_execution_dir
= EXEC_FORWARD
;
936 /* "to_resume" target method. Resume the process record target. */
939 record_full_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
940 enum gdb_signal signal
)
942 record_full_resume_step
= step
;
943 record_full_resumed
= 1;
944 record_full_execution_dir
= execution_direction
;
946 if (!RECORD_FULL_IS_REPLAY
)
948 struct gdbarch
*gdbarch
= target_thread_architecture (ptid
);
950 record_full_message (get_current_regcache (), signal
);
954 /* This is not hard single step. */
955 if (!gdbarch_software_single_step_p (gdbarch
))
957 /* This is a normal continue. */
962 /* This arch support soft sigle step. */
963 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
965 /* This is a soft single step. */
966 record_full_resume_step
= 1;
970 /* This is a continue.
971 Try to insert a soft single step breakpoint. */
972 if (!gdbarch_software_single_step (gdbarch
,
973 get_current_frame ()))
975 /* This system don't want use soft single step.
976 Use hard sigle step. */
983 /* Make sure the target beneath reports all signals. */
984 target_pass_signals (0, NULL
);
986 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
, signal
);
989 /* We are about to start executing the inferior (or simulate it),
990 let's register it with the event loop. */
991 if (target_can_async_p ())
993 target_async (inferior_event_handler
, 0);
994 /* Notify the event loop there's an event to wait for. We do
995 most of the work in record_full_wait. */
996 mark_async_event_handler (record_full_async_inferior_event_token
);
1000 static int record_full_get_sig
= 0;
1002 /* SIGINT signal handler, registered by "to_wait" method. */
1005 record_full_sig_handler (int signo
)
1008 fprintf_unfiltered (gdb_stdlog
, "Process record: get a signal\n");
1010 /* It will break the running inferior in replay mode. */
1011 record_full_resume_step
= 1;
1013 /* It will let record_full_wait set inferior status to get the signal
1015 record_full_get_sig
= 1;
1019 record_full_wait_cleanups (void *ignore
)
1021 if (execution_direction
== EXEC_REVERSE
)
1023 if (record_full_list
->next
)
1024 record_full_list
= record_full_list
->next
;
1027 record_full_list
= record_full_list
->prev
;
1030 /* "to_wait" target method for process record target.
1032 In record mode, the target is always run in singlestep mode
1033 (even when gdb says to continue). The to_wait method intercepts
1034 the stop events and determines which ones are to be passed on to
1035 gdb. Most stop events are just singlestep events that gdb is not
1036 to know about, so the to_wait method just records them and keeps
1039 In replay mode, this function emulates the recorded execution log,
1040 one instruction at a time (forward or backward), and determines
1044 record_full_wait_1 (struct target_ops
*ops
,
1045 ptid_t ptid
, struct target_waitstatus
*status
,
1048 struct cleanup
*set_cleanups
= record_full_gdb_operation_disable_set ();
1051 fprintf_unfiltered (gdb_stdlog
,
1052 "Process record: record_full_wait "
1053 "record_full_resume_step = %d, "
1054 "record_full_resumed = %d, direction=%s\n",
1055 record_full_resume_step
, record_full_resumed
,
1056 record_full_execution_dir
== EXEC_FORWARD
1057 ? "forward" : "reverse");
1059 if (!record_full_resumed
)
1061 gdb_assert ((options
& TARGET_WNOHANG
) != 0);
1063 /* No interesting event. */
1064 status
->kind
= TARGET_WAITKIND_IGNORE
;
1065 return minus_one_ptid
;
1068 record_full_get_sig
= 0;
1069 signal (SIGINT
, record_full_sig_handler
);
1071 if (!RECORD_FULL_IS_REPLAY
&& ops
!= &record_full_core_ops
)
1073 if (record_full_resume_step
)
1075 /* This is a single step. */
1076 return ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1080 /* This is not a single step. */
1083 struct gdbarch
*gdbarch
= target_thread_architecture (inferior_ptid
);
1087 struct thread_info
*tp
;
1089 ret
= ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1090 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
1093 fprintf_unfiltered (gdb_stdlog
,
1094 "Process record: record_full_wait "
1095 "target beneath not done yet\n");
1099 ALL_NON_EXITED_THREADS (tp
)
1100 delete_single_step_breakpoints (tp
);
1102 if (record_full_resume_step
)
1105 /* Is this a SIGTRAP? */
1106 if (status
->kind
== TARGET_WAITKIND_STOPPED
1107 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1109 struct regcache
*regcache
;
1110 struct address_space
*aspace
;
1112 /* Yes -- this is likely our single-step finishing,
1113 but check if there's any reason the core would be
1114 interested in the event. */
1116 registers_changed ();
1117 regcache
= get_current_regcache ();
1118 tmp_pc
= regcache_read_pc (regcache
);
1119 aspace
= get_regcache_aspace (regcache
);
1121 if (target_stopped_by_watchpoint ())
1123 /* Always interested in watchpoints. */
1125 else if (breakpoint_inserted_here_p (aspace
, tmp_pc
))
1127 /* There is a breakpoint here. Let the core
1129 if (software_breakpoint_inserted_here_p (aspace
, tmp_pc
))
1131 struct gdbarch
*gdbarch
1132 = get_regcache_arch (regcache
);
1133 CORE_ADDR decr_pc_after_break
1134 = target_decr_pc_after_break (gdbarch
);
1135 if (decr_pc_after_break
)
1136 regcache_write_pc (regcache
,
1137 tmp_pc
+ decr_pc_after_break
);
1142 /* This is a single-step trap. Record the
1143 insn and issue another step.
1144 FIXME: this part can be a random SIGTRAP too.
1145 But GDB cannot handle it. */
1148 if (!record_full_message_wrapper_safe (regcache
,
1151 status
->kind
= TARGET_WAITKIND_STOPPED
;
1152 status
->value
.sig
= GDB_SIGNAL_0
;
1156 if (gdbarch_software_single_step_p (gdbarch
))
1158 /* Try to insert the software single step breakpoint.
1159 If insert success, set step to 0. */
1160 set_executing (inferior_ptid
, 0);
1161 reinit_frame_cache ();
1162 if (gdbarch_software_single_step (gdbarch
,
1163 get_current_frame ()))
1165 set_executing (inferior_ptid
, 1);
1169 fprintf_unfiltered (gdb_stdlog
,
1170 "Process record: record_full_wait "
1171 "issuing one more step in the "
1172 "target beneath\n");
1173 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
,
1179 /* The inferior is broken by a breakpoint or a signal. */
1188 struct regcache
*regcache
= get_current_regcache ();
1189 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1190 struct address_space
*aspace
= get_regcache_aspace (regcache
);
1191 int continue_flag
= 1;
1192 int first_record_full_end
= 1;
1193 struct cleanup
*old_cleanups
1194 = make_cleanup (record_full_wait_cleanups
, 0);
1197 record_full_hw_watchpoint
= 0;
1198 status
->kind
= TARGET_WAITKIND_STOPPED
;
1200 /* Check breakpoint when forward execute. */
1201 if (execution_direction
== EXEC_FORWARD
)
1203 tmp_pc
= regcache_read_pc (regcache
);
1204 if (breakpoint_inserted_here_p (aspace
, tmp_pc
))
1206 int decr_pc_after_break
= target_decr_pc_after_break (gdbarch
);
1209 fprintf_unfiltered (gdb_stdlog
,
1210 "Process record: break at %s.\n",
1211 paddress (gdbarch
, tmp_pc
));
1213 if (decr_pc_after_break
1214 && !record_full_resume_step
1215 && software_breakpoint_inserted_here_p (aspace
, tmp_pc
))
1216 regcache_write_pc (regcache
,
1217 tmp_pc
+ decr_pc_after_break
);
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 (breakpoint_inserted_here_p (aspace
, tmp_pc
))
1287 int decr_pc_after_break
1288 = target_decr_pc_after_break (gdbarch
);
1291 fprintf_unfiltered (gdb_stdlog
,
1292 "Process record: break "
1294 paddress (gdbarch
, tmp_pc
));
1295 if (decr_pc_after_break
1296 && execution_direction
== EXEC_FORWARD
1297 && !record_full_resume_step
1298 && software_breakpoint_inserted_here_p (aspace
,
1300 regcache_write_pc (regcache
,
1301 tmp_pc
+ decr_pc_after_break
);
1305 if (record_full_hw_watchpoint
)
1308 fprintf_unfiltered (gdb_stdlog
,
1309 "Process record: hit hw "
1313 /* Check target signal */
1314 if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1315 /* FIXME: better way to check */
1322 if (execution_direction
== EXEC_REVERSE
)
1324 if (record_full_list
->prev
)
1325 record_full_list
= record_full_list
->prev
;
1329 if (record_full_list
->next
)
1330 record_full_list
= record_full_list
->next
;
1334 while (continue_flag
);
1337 if (record_full_get_sig
)
1338 status
->value
.sig
= GDB_SIGNAL_INT
;
1339 else if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1340 /* FIXME: better way to check */
1341 status
->value
.sig
= record_full_list
->u
.end
.sigval
;
1343 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1345 discard_cleanups (old_cleanups
);
1348 signal (SIGINT
, handle_sigint
);
1350 do_cleanups (set_cleanups
);
1351 return inferior_ptid
;
1355 record_full_wait (struct target_ops
*ops
,
1356 ptid_t ptid
, struct target_waitstatus
*status
,
1361 return_ptid
= record_full_wait_1 (ops
, ptid
, status
, options
);
1362 if (status
->kind
!= TARGET_WAITKIND_IGNORE
)
1364 /* We're reporting a stop. Make sure any spurious
1365 target_wait(WNOHANG) doesn't advance the target until the
1366 core wants us resumed again. */
1367 record_full_resumed
= 0;
1373 record_full_stopped_by_watchpoint (struct target_ops
*ops
)
1375 if (RECORD_FULL_IS_REPLAY
)
1376 return record_full_hw_watchpoint
;
1378 return ops
->beneath
->to_stopped_by_watchpoint (ops
->beneath
);
1382 record_full_stopped_data_address (struct target_ops
*ops
, CORE_ADDR
*addr_p
)
1384 if (RECORD_FULL_IS_REPLAY
)
1387 return ops
->beneath
->to_stopped_data_address (ops
->beneath
, addr_p
);
1390 /* Record registers change (by user or by GDB) to list as an instruction. */
1393 record_full_registers_change (struct regcache
*regcache
, int regnum
)
1395 /* Check record_full_insn_num. */
1396 record_full_check_insn_num (0);
1398 record_full_arch_list_head
= NULL
;
1399 record_full_arch_list_tail
= NULL
;
1405 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
1407 if (record_full_arch_list_add_reg (regcache
, i
))
1409 record_full_list_release (record_full_arch_list_tail
);
1410 error (_("Process record: failed to record execution log."));
1416 if (record_full_arch_list_add_reg (regcache
, regnum
))
1418 record_full_list_release (record_full_arch_list_tail
);
1419 error (_("Process record: failed to record execution log."));
1422 if (record_full_arch_list_add_end ())
1424 record_full_list_release (record_full_arch_list_tail
);
1425 error (_("Process record: failed to record execution log."));
1427 record_full_list
->next
= record_full_arch_list_head
;
1428 record_full_arch_list_head
->prev
= record_full_list
;
1429 record_full_list
= record_full_arch_list_tail
;
1431 if (record_full_insn_num
== record_full_insn_max_num
)
1432 record_full_list_release_first ();
1434 record_full_insn_num
++;
1437 /* "to_store_registers" method for process record target. */
1440 record_full_store_registers (struct target_ops
*ops
,
1441 struct regcache
*regcache
,
1444 if (!record_full_gdb_operation_disable
)
1446 if (RECORD_FULL_IS_REPLAY
)
1450 /* Let user choose if he wants to write register or not. */
1453 query (_("Because GDB is in replay mode, changing the "
1454 "value of a register will make the execution "
1455 "log unusable from this point onward. "
1456 "Change all registers?"));
1459 query (_("Because GDB is in replay mode, changing the value "
1460 "of a register will make the execution log unusable "
1461 "from this point onward. Change register %s?"),
1462 gdbarch_register_name (get_regcache_arch (regcache
),
1467 /* Invalidate the value of regcache that was set in function
1468 "regcache_raw_write". */
1474 i
< gdbarch_num_regs (get_regcache_arch (regcache
));
1476 regcache_invalidate (regcache
, i
);
1479 regcache_invalidate (regcache
, regno
);
1481 error (_("Process record canceled the operation."));
1484 /* Destroy the record from here forward. */
1485 record_full_list_release_following (record_full_list
);
1488 record_full_registers_change (regcache
, regno
);
1490 ops
->beneath
->to_store_registers (ops
->beneath
, regcache
, regno
);
1493 /* "to_xfer_partial" method. Behavior is conditional on
1494 RECORD_FULL_IS_REPLAY.
1495 In replay mode, we cannot write memory unles we are willing to
1496 invalidate the record/replay log from this point forward. */
1498 static enum target_xfer_status
1499 record_full_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1500 const char *annex
, gdb_byte
*readbuf
,
1501 const gdb_byte
*writebuf
, ULONGEST offset
,
1502 ULONGEST len
, ULONGEST
*xfered_len
)
1504 if (!record_full_gdb_operation_disable
1505 && (object
== TARGET_OBJECT_MEMORY
1506 || object
== TARGET_OBJECT_RAW_MEMORY
) && writebuf
)
1508 if (RECORD_FULL_IS_REPLAY
)
1510 /* Let user choose if he wants to write memory or not. */
1511 if (!query (_("Because GDB is in replay mode, writing to memory "
1512 "will make the execution log unusable from this "
1513 "point onward. Write memory at address %s?"),
1514 paddress (target_gdbarch (), offset
)))
1515 error (_("Process record canceled the operation."));
1517 /* Destroy the record from here forward. */
1518 record_full_list_release_following (record_full_list
);
1521 /* Check record_full_insn_num */
1522 record_full_check_insn_num (0);
1524 /* Record registers change to list as an instruction. */
1525 record_full_arch_list_head
= NULL
;
1526 record_full_arch_list_tail
= NULL
;
1527 if (record_full_arch_list_add_mem (offset
, len
))
1529 record_full_list_release (record_full_arch_list_tail
);
1531 fprintf_unfiltered (gdb_stdlog
,
1532 "Process record: failed to record "
1534 return TARGET_XFER_E_IO
;
1536 if (record_full_arch_list_add_end ())
1538 record_full_list_release (record_full_arch_list_tail
);
1540 fprintf_unfiltered (gdb_stdlog
,
1541 "Process record: failed to record "
1543 return TARGET_XFER_E_IO
;
1545 record_full_list
->next
= record_full_arch_list_head
;
1546 record_full_arch_list_head
->prev
= record_full_list
;
1547 record_full_list
= record_full_arch_list_tail
;
1549 if (record_full_insn_num
== record_full_insn_max_num
)
1550 record_full_list_release_first ();
1552 record_full_insn_num
++;
1555 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1556 readbuf
, writebuf
, offset
,
1560 /* This structure represents a breakpoint inserted while the record
1561 target is active. We use this to know when to install/remove
1562 breakpoints in/from the target beneath. For example, a breakpoint
1563 may be inserted while recording, but removed when not replaying nor
1564 recording. In that case, the breakpoint had not been inserted on
1565 the target beneath, so we should not try to remove it there. */
1567 struct record_full_breakpoint
1569 /* The address and address space the breakpoint was set at. */
1570 struct address_space
*address_space
;
1573 /* True when the breakpoint has been also installed in the target
1574 beneath. This will be false for breakpoints set during replay or
1576 int in_target_beneath
;
1579 typedef struct record_full_breakpoint
*record_full_breakpoint_p
;
1580 DEF_VEC_P(record_full_breakpoint_p
);
1582 /* The list of breakpoints inserted while the record target is
1584 VEC(record_full_breakpoint_p
) *record_full_breakpoints
= NULL
;
1587 record_full_sync_record_breakpoints (struct bp_location
*loc
, void *data
)
1589 if (loc
->loc_type
!= bp_loc_software_breakpoint
)
1594 struct record_full_breakpoint
*bp
= XNEW (struct record_full_breakpoint
);
1596 bp
->addr
= loc
->target_info
.placed_address
;
1597 bp
->address_space
= loc
->target_info
.placed_address_space
;
1599 bp
->in_target_beneath
= 1;
1601 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1605 /* Sync existing breakpoints to record_full_breakpoints. */
1608 record_full_init_record_breakpoints (void)
1610 VEC_free (record_full_breakpoint_p
, record_full_breakpoints
);
1612 iterate_over_bp_locations (record_full_sync_record_breakpoints
);
1615 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1616 insert or remove breakpoints in the real target when replaying, nor
1620 record_full_insert_breakpoint (struct target_ops
*ops
,
1621 struct gdbarch
*gdbarch
,
1622 struct bp_target_info
*bp_tgt
)
1624 struct record_full_breakpoint
*bp
;
1625 int in_target_beneath
= 0;
1627 if (!RECORD_FULL_IS_REPLAY
)
1629 /* When recording, we currently always single-step, so we don't
1630 really need to install regular breakpoints in the inferior.
1631 However, we do have to insert software single-step
1632 breakpoints, in case the target can't hardware step. To keep
1633 things single, we always insert. */
1634 struct cleanup
*old_cleanups
;
1637 old_cleanups
= record_full_gdb_operation_disable_set ();
1638 ret
= ops
->beneath
->to_insert_breakpoint (ops
->beneath
, gdbarch
, bp_tgt
);
1639 do_cleanups (old_cleanups
);
1644 in_target_beneath
= 1;
1647 bp
= XNEW (struct record_full_breakpoint
);
1648 bp
->addr
= bp_tgt
->placed_address
;
1649 bp
->address_space
= bp_tgt
->placed_address_space
;
1650 bp
->in_target_beneath
= in_target_beneath
;
1651 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1655 /* "to_remove_breakpoint" method for process record target. */
1658 record_full_remove_breakpoint (struct target_ops
*ops
,
1659 struct gdbarch
*gdbarch
,
1660 struct bp_target_info
*bp_tgt
)
1662 struct record_full_breakpoint
*bp
;
1666 VEC_iterate (record_full_breakpoint_p
,
1667 record_full_breakpoints
, ix
, bp
);
1670 if (bp
->addr
== bp_tgt
->placed_address
1671 && bp
->address_space
== bp_tgt
->placed_address_space
)
1673 if (bp
->in_target_beneath
)
1675 struct cleanup
*old_cleanups
;
1678 old_cleanups
= record_full_gdb_operation_disable_set ();
1679 ret
= ops
->beneath
->to_remove_breakpoint (ops
->beneath
, gdbarch
,
1681 do_cleanups (old_cleanups
);
1687 VEC_unordered_remove (record_full_breakpoint_p
,
1688 record_full_breakpoints
, ix
);
1693 gdb_assert_not_reached ("removing unknown breakpoint");
1696 /* "to_can_execute_reverse" method for process record target. */
1699 record_full_can_execute_reverse (struct target_ops
*self
)
1704 /* "to_get_bookmark" method for process record and prec over core. */
1707 record_full_get_bookmark (struct target_ops
*self
, const char *args
,
1712 /* Return stringified form of instruction count. */
1713 if (record_full_list
&& record_full_list
->type
== record_full_end
)
1714 ret
= xstrdup (pulongest (record_full_list
->u
.end
.insn_num
));
1719 fprintf_unfiltered (gdb_stdlog
,
1720 "record_full_get_bookmark returns %s\n", ret
);
1722 fprintf_unfiltered (gdb_stdlog
,
1723 "record_full_get_bookmark returns NULL\n");
1725 return (gdb_byte
*) ret
;
1728 /* "to_goto_bookmark" method for process record and prec over core. */
1731 record_full_goto_bookmark (struct target_ops
*self
,
1732 const gdb_byte
*raw_bookmark
, int from_tty
)
1734 const char *bookmark
= (const char *) raw_bookmark
;
1735 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1738 fprintf_unfiltered (gdb_stdlog
,
1739 "record_full_goto_bookmark receives %s\n", bookmark
);
1741 if (bookmark
[0] == '\'' || bookmark
[0] == '\"')
1745 if (bookmark
[strlen (bookmark
) - 1] != bookmark
[0])
1746 error (_("Unbalanced quotes: %s"), bookmark
);
1749 copy
= savestring (bookmark
+ 1, strlen (bookmark
) - 2);
1750 make_cleanup (xfree
, copy
);
1754 record_goto (bookmark
);
1756 do_cleanups (cleanup
);
1759 static enum exec_direction_kind
1760 record_full_execution_direction (struct target_ops
*self
)
1762 return record_full_execution_dir
;
1766 record_full_info (struct target_ops
*self
)
1768 struct record_full_entry
*p
;
1770 if (RECORD_FULL_IS_REPLAY
)
1771 printf_filtered (_("Replay mode:\n"));
1773 printf_filtered (_("Record mode:\n"));
1775 /* Find entry for first actual instruction in the log. */
1776 for (p
= record_full_first
.next
;
1777 p
!= NULL
&& p
->type
!= record_full_end
;
1781 /* Do we have a log at all? */
1782 if (p
!= NULL
&& p
->type
== record_full_end
)
1784 /* Display instruction number for first instruction in the log. */
1785 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1786 pulongest (p
->u
.end
.insn_num
));
1788 /* If in replay mode, display where we are in the log. */
1789 if (RECORD_FULL_IS_REPLAY
)
1790 printf_filtered (_("Current instruction number is %s.\n"),
1791 pulongest (record_full_list
->u
.end
.insn_num
));
1793 /* Display instruction number for last instruction in the log. */
1794 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1795 pulongest (record_full_insn_count
));
1797 /* Display log count. */
1798 printf_filtered (_("Log contains %u instructions.\n"),
1799 record_full_insn_num
);
1802 printf_filtered (_("No instructions have been logged.\n"));
1804 /* Display max log size. */
1805 printf_filtered (_("Max logged instructions is %u.\n"),
1806 record_full_insn_max_num
);
1809 /* The "to_record_delete" target method. */
1812 record_full_delete (struct target_ops
*self
)
1814 record_full_list_release_following (record_full_list
);
1817 /* The "to_record_is_replaying" target method. */
1820 record_full_is_replaying (struct target_ops
*self
)
1822 return RECORD_FULL_IS_REPLAY
;
1825 /* Go to a specific entry. */
1828 record_full_goto_entry (struct record_full_entry
*p
)
1831 error (_("Target insn not found."));
1832 else if (p
== record_full_list
)
1833 error (_("Already at target insn."));
1834 else if (p
->u
.end
.insn_num
> record_full_list
->u
.end
.insn_num
)
1836 printf_filtered (_("Go forward to insn number %s\n"),
1837 pulongest (p
->u
.end
.insn_num
));
1838 record_full_goto_insn (p
, EXEC_FORWARD
);
1842 printf_filtered (_("Go backward to insn number %s\n"),
1843 pulongest (p
->u
.end
.insn_num
));
1844 record_full_goto_insn (p
, EXEC_REVERSE
);
1847 registers_changed ();
1848 reinit_frame_cache ();
1849 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1852 /* The "to_goto_record_begin" target method. */
1855 record_full_goto_begin (struct target_ops
*self
)
1857 struct record_full_entry
*p
= NULL
;
1859 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1860 if (p
->type
== record_full_end
)
1863 record_full_goto_entry (p
);
1866 /* The "to_goto_record_end" target method. */
1869 record_full_goto_end (struct target_ops
*self
)
1871 struct record_full_entry
*p
= NULL
;
1873 for (p
= record_full_list
; p
->next
!= NULL
; p
= p
->next
)
1875 for (; p
!= NULL
; p
= p
->prev
)
1876 if (p
->type
== record_full_end
)
1879 record_full_goto_entry (p
);
1882 /* The "to_goto_record" target method. */
1885 record_full_goto (struct target_ops
*self
, ULONGEST target_insn
)
1887 struct record_full_entry
*p
= NULL
;
1889 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1890 if (p
->type
== record_full_end
&& p
->u
.end
.insn_num
== target_insn
)
1893 record_full_goto_entry (p
);
1897 init_record_full_ops (void)
1899 record_full_ops
.to_shortname
= "record-full";
1900 record_full_ops
.to_longname
= "Process record and replay target";
1901 record_full_ops
.to_doc
=
1902 "Log program while executing and replay execution from log.";
1903 record_full_ops
.to_open
= record_full_open
;
1904 record_full_ops
.to_close
= record_full_close
;
1905 record_full_ops
.to_resume
= record_full_resume
;
1906 record_full_ops
.to_wait
= record_full_wait
;
1907 record_full_ops
.to_disconnect
= record_disconnect
;
1908 record_full_ops
.to_detach
= record_detach
;
1909 record_full_ops
.to_mourn_inferior
= record_mourn_inferior
;
1910 record_full_ops
.to_kill
= record_kill
;
1911 record_full_ops
.to_store_registers
= record_full_store_registers
;
1912 record_full_ops
.to_xfer_partial
= record_full_xfer_partial
;
1913 record_full_ops
.to_insert_breakpoint
= record_full_insert_breakpoint
;
1914 record_full_ops
.to_remove_breakpoint
= record_full_remove_breakpoint
;
1915 record_full_ops
.to_stopped_by_watchpoint
= record_full_stopped_by_watchpoint
;
1916 record_full_ops
.to_stopped_data_address
= record_full_stopped_data_address
;
1917 record_full_ops
.to_can_execute_reverse
= record_full_can_execute_reverse
;
1918 record_full_ops
.to_stratum
= record_stratum
;
1919 /* Add bookmark target methods. */
1920 record_full_ops
.to_get_bookmark
= record_full_get_bookmark
;
1921 record_full_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
1922 record_full_ops
.to_execution_direction
= record_full_execution_direction
;
1923 record_full_ops
.to_info_record
= record_full_info
;
1924 record_full_ops
.to_save_record
= record_full_save
;
1925 record_full_ops
.to_delete_record
= record_full_delete
;
1926 record_full_ops
.to_record_is_replaying
= record_full_is_replaying
;
1927 record_full_ops
.to_goto_record_begin
= record_full_goto_begin
;
1928 record_full_ops
.to_goto_record_end
= record_full_goto_end
;
1929 record_full_ops
.to_goto_record
= record_full_goto
;
1930 record_full_ops
.to_magic
= OPS_MAGIC
;
1933 /* "to_resume" method for prec over corefile. */
1936 record_full_core_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
1937 enum gdb_signal signal
)
1939 record_full_resume_step
= step
;
1940 record_full_resumed
= 1;
1941 record_full_execution_dir
= execution_direction
;
1943 /* We are about to start executing the inferior (or simulate it),
1944 let's register it with the event loop. */
1945 if (target_can_async_p ())
1947 target_async (inferior_event_handler
, 0);
1949 /* Notify the event loop there's an event to wait for. */
1950 mark_async_event_handler (record_full_async_inferior_event_token
);
1954 /* "to_kill" method for prec over corefile. */
1957 record_full_core_kill (struct target_ops
*ops
)
1960 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_core_kill\n");
1962 unpush_target (&record_full_core_ops
);
1965 /* "to_fetch_registers" method for prec over corefile. */
1968 record_full_core_fetch_registers (struct target_ops
*ops
,
1969 struct regcache
*regcache
,
1974 int num
= gdbarch_num_regs (get_regcache_arch (regcache
));
1977 for (i
= 0; i
< num
; i
++)
1978 regcache_raw_supply (regcache
, i
,
1979 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
1982 regcache_raw_supply (regcache
, regno
,
1983 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
1986 /* "to_prepare_to_store" method for prec over corefile. */
1989 record_full_core_prepare_to_store (struct target_ops
*self
,
1990 struct regcache
*regcache
)
1994 /* "to_store_registers" method for prec over corefile. */
1997 record_full_core_store_registers (struct target_ops
*ops
,
1998 struct regcache
*regcache
,
2001 if (record_full_gdb_operation_disable
)
2002 regcache_raw_collect (regcache
, regno
,
2003 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
2005 error (_("You can't do that without a process to debug."));
2008 /* "to_xfer_partial" method for prec over corefile. */
2010 static enum target_xfer_status
2011 record_full_core_xfer_partial (struct target_ops
*ops
,
2012 enum target_object object
,
2013 const char *annex
, gdb_byte
*readbuf
,
2014 const gdb_byte
*writebuf
, ULONGEST offset
,
2015 ULONGEST len
, ULONGEST
*xfered_len
)
2017 if (object
== TARGET_OBJECT_MEMORY
)
2019 if (record_full_gdb_operation_disable
|| !writebuf
)
2021 struct target_section
*p
;
2023 for (p
= record_full_core_start
; p
< record_full_core_end
; p
++)
2025 if (offset
>= p
->addr
)
2027 struct record_full_core_buf_entry
*entry
;
2028 ULONGEST sec_offset
;
2030 if (offset
>= p
->endaddr
)
2033 if (offset
+ len
> p
->endaddr
)
2034 len
= p
->endaddr
- offset
;
2036 sec_offset
= offset
- p
->addr
;
2038 /* Read readbuf or write writebuf p, offset, len. */
2040 if (p
->the_bfd_section
->flags
& SEC_CONSTRUCTOR
2041 || (p
->the_bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2044 memset (readbuf
, 0, len
);
2047 return TARGET_XFER_OK
;
2049 /* Get record_full_core_buf_entry. */
2050 for (entry
= record_full_core_buf_list
; entry
;
2051 entry
= entry
->prev
)
2058 /* Add a new entry. */
2059 entry
= (struct record_full_core_buf_entry
*)
2061 (sizeof (struct record_full_core_buf_entry
));
2063 if (!bfd_malloc_and_get_section
2064 (p
->the_bfd_section
->owner
,
2069 return TARGET_XFER_EOF
;
2071 entry
->prev
= record_full_core_buf_list
;
2072 record_full_core_buf_list
= entry
;
2075 memcpy (entry
->buf
+ sec_offset
, writebuf
,
2081 return ops
->beneath
->to_xfer_partial (ops
->beneath
,
2087 memcpy (readbuf
, entry
->buf
+ sec_offset
,
2092 return TARGET_XFER_OK
;
2096 return TARGET_XFER_E_IO
;
2099 error (_("You can't do that without a process to debug."));
2102 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2103 readbuf
, writebuf
, offset
, len
,
2107 /* "to_insert_breakpoint" method for prec over corefile. */
2110 record_full_core_insert_breakpoint (struct target_ops
*ops
,
2111 struct gdbarch
*gdbarch
,
2112 struct bp_target_info
*bp_tgt
)
2117 /* "to_remove_breakpoint" method for prec over corefile. */
2120 record_full_core_remove_breakpoint (struct target_ops
*ops
,
2121 struct gdbarch
*gdbarch
,
2122 struct bp_target_info
*bp_tgt
)
2127 /* "to_has_execution" method for prec over corefile. */
2130 record_full_core_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
2136 init_record_full_core_ops (void)
2138 record_full_core_ops
.to_shortname
= "record-core";
2139 record_full_core_ops
.to_longname
= "Process record and replay target";
2140 record_full_core_ops
.to_doc
=
2141 "Log program while executing and replay execution from log.";
2142 record_full_core_ops
.to_open
= record_full_open
;
2143 record_full_core_ops
.to_close
= record_full_close
;
2144 record_full_core_ops
.to_resume
= record_full_core_resume
;
2145 record_full_core_ops
.to_wait
= record_full_wait
;
2146 record_full_core_ops
.to_kill
= record_full_core_kill
;
2147 record_full_core_ops
.to_fetch_registers
= record_full_core_fetch_registers
;
2148 record_full_core_ops
.to_prepare_to_store
= record_full_core_prepare_to_store
;
2149 record_full_core_ops
.to_store_registers
= record_full_core_store_registers
;
2150 record_full_core_ops
.to_xfer_partial
= record_full_core_xfer_partial
;
2151 record_full_core_ops
.to_insert_breakpoint
2152 = record_full_core_insert_breakpoint
;
2153 record_full_core_ops
.to_remove_breakpoint
2154 = record_full_core_remove_breakpoint
;
2155 record_full_core_ops
.to_stopped_by_watchpoint
2156 = record_full_stopped_by_watchpoint
;
2157 record_full_core_ops
.to_stopped_data_address
2158 = record_full_stopped_data_address
;
2159 record_full_core_ops
.to_can_execute_reverse
2160 = record_full_can_execute_reverse
;
2161 record_full_core_ops
.to_has_execution
= record_full_core_has_execution
;
2162 record_full_core_ops
.to_stratum
= record_stratum
;
2163 /* Add bookmark target methods. */
2164 record_full_core_ops
.to_get_bookmark
= record_full_get_bookmark
;
2165 record_full_core_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
2166 record_full_core_ops
.to_execution_direction
2167 = record_full_execution_direction
;
2168 record_full_core_ops
.to_info_record
= record_full_info
;
2169 record_full_core_ops
.to_delete_record
= record_full_delete
;
2170 record_full_core_ops
.to_record_is_replaying
= record_full_is_replaying
;
2171 record_full_core_ops
.to_goto_record_begin
= record_full_goto_begin
;
2172 record_full_core_ops
.to_goto_record_end
= record_full_goto_end
;
2173 record_full_core_ops
.to_goto_record
= record_full_goto
;
2174 record_full_core_ops
.to_magic
= OPS_MAGIC
;
2177 /* Record log save-file format
2178 Version 1 (never released)
2181 4 bytes: magic number htonl(0x20090829).
2182 NOTE: be sure to change whenever this file format changes!
2186 1 byte: record type (record_full_end, see enum record_full_type).
2188 1 byte: record type (record_full_reg, see enum record_full_type).
2189 8 bytes: register id (network byte order).
2190 MAX_REGISTER_SIZE bytes: register value.
2192 1 byte: record type (record_full_mem, see enum record_full_type).
2193 8 bytes: memory length (network byte order).
2194 8 bytes: memory address (network byte order).
2195 n bytes: memory value (n == memory length).
2198 4 bytes: magic number netorder32(0x20091016).
2199 NOTE: be sure to change whenever this file format changes!
2203 1 byte: record type (record_full_end, see enum record_full_type).
2205 4 bytes: instruction count
2207 1 byte: record type (record_full_reg, see enum record_full_type).
2208 4 bytes: register id (network byte order).
2209 n bytes: register value (n == actual register size).
2210 (eg. 4 bytes for x86 general registers).
2212 1 byte: record type (record_full_mem, see enum record_full_type).
2213 4 bytes: memory length (network byte order).
2214 8 bytes: memory address (network byte order).
2215 n bytes: memory value (n == memory length).
2219 /* bfdcore_read -- read bytes from a core file section. */
2222 bfdcore_read (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2224 int ret
= bfd_get_section_contents (obfd
, osec
, buf
, *offset
, len
);
2229 error (_("Failed to read %d bytes from core file %s ('%s')."),
2230 len
, bfd_get_filename (obfd
),
2231 bfd_errmsg (bfd_get_error ()));
2234 static inline uint64_t
2235 netorder64 (uint64_t input
)
2239 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2240 BFD_ENDIAN_BIG
, input
);
2244 static inline uint32_t
2245 netorder32 (uint32_t input
)
2249 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2250 BFD_ENDIAN_BIG
, input
);
2254 static inline uint16_t
2255 netorder16 (uint16_t input
)
2259 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2260 BFD_ENDIAN_BIG
, input
);
2264 /* Restore the execution log from a core_bfd file. */
2266 record_full_restore (void)
2269 struct cleanup
*old_cleanups
;
2270 struct record_full_entry
*rec
;
2274 struct regcache
*regcache
;
2276 /* We restore the execution log from the open core bfd,
2278 if (core_bfd
== NULL
)
2281 /* "record_full_restore" can only be called when record list is empty. */
2282 gdb_assert (record_full_first
.next
== NULL
);
2285 fprintf_unfiltered (gdb_stdlog
, "Restoring recording from core file.\n");
2287 /* Now need to find our special note section. */
2288 osec
= bfd_get_section_by_name (core_bfd
, "null0");
2290 fprintf_unfiltered (gdb_stdlog
, "Find precord section %s.\n",
2291 osec
? "succeeded" : "failed");
2294 osec_size
= bfd_section_size (core_bfd
, osec
);
2296 fprintf_unfiltered (gdb_stdlog
, "%s", bfd_section_name (core_bfd
, osec
));
2298 /* Check the magic code. */
2299 bfdcore_read (core_bfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2300 if (magic
!= RECORD_FULL_FILE_MAGIC
)
2301 error (_("Version mis-match or file format error in core file %s."),
2302 bfd_get_filename (core_bfd
));
2304 fprintf_unfiltered (gdb_stdlog
,
2305 " Reading 4-byte magic cookie "
2306 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2307 phex_nz (netorder32 (magic
), 4));
2309 /* Restore the entries in recfd into record_full_arch_list_head and
2310 record_full_arch_list_tail. */
2311 record_full_arch_list_head
= NULL
;
2312 record_full_arch_list_tail
= NULL
;
2313 record_full_insn_num
= 0;
2314 old_cleanups
= make_cleanup (record_full_arch_list_cleanups
, 0);
2315 regcache
= get_current_regcache ();
2320 uint32_t regnum
, len
, signal
, count
;
2323 /* We are finished when offset reaches osec_size. */
2324 if (bfd_offset
>= osec_size
)
2326 bfdcore_read (core_bfd
, osec
, &rectype
, sizeof (rectype
), &bfd_offset
);
2330 case record_full_reg
: /* reg */
2331 /* Get register number to regnum. */
2332 bfdcore_read (core_bfd
, osec
, ®num
,
2333 sizeof (regnum
), &bfd_offset
);
2334 regnum
= netorder32 (regnum
);
2336 rec
= record_full_reg_alloc (regcache
, regnum
);
2339 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2340 rec
->u
.reg
.len
, &bfd_offset
);
2343 fprintf_unfiltered (gdb_stdlog
,
2344 " Reading register %d (1 "
2345 "plus %lu plus %d bytes)\n",
2347 (unsigned long) sizeof (regnum
),
2351 case record_full_mem
: /* mem */
2353 bfdcore_read (core_bfd
, osec
, &len
,
2354 sizeof (len
), &bfd_offset
);
2355 len
= netorder32 (len
);
2358 bfdcore_read (core_bfd
, osec
, &addr
,
2359 sizeof (addr
), &bfd_offset
);
2360 addr
= netorder64 (addr
);
2362 rec
= record_full_mem_alloc (addr
, len
);
2365 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2366 rec
->u
.mem
.len
, &bfd_offset
);
2369 fprintf_unfiltered (gdb_stdlog
,
2370 " Reading memory %s (1 plus "
2371 "%lu plus %lu plus %d bytes)\n",
2372 paddress (get_current_arch (),
2374 (unsigned long) sizeof (addr
),
2375 (unsigned long) sizeof (len
),
2379 case record_full_end
: /* end */
2380 rec
= record_full_end_alloc ();
2381 record_full_insn_num
++;
2383 /* Get signal value. */
2384 bfdcore_read (core_bfd
, osec
, &signal
,
2385 sizeof (signal
), &bfd_offset
);
2386 signal
= netorder32 (signal
);
2387 rec
->u
.end
.sigval
= signal
;
2389 /* Get insn count. */
2390 bfdcore_read (core_bfd
, osec
, &count
,
2391 sizeof (count
), &bfd_offset
);
2392 count
= netorder32 (count
);
2393 rec
->u
.end
.insn_num
= count
;
2394 record_full_insn_count
= count
+ 1;
2396 fprintf_unfiltered (gdb_stdlog
,
2397 " Reading record_full_end (1 + "
2398 "%lu + %lu bytes), offset == %s\n",
2399 (unsigned long) sizeof (signal
),
2400 (unsigned long) sizeof (count
),
2401 paddress (get_current_arch (),
2406 error (_("Bad entry type in core file %s."),
2407 bfd_get_filename (core_bfd
));
2411 /* Add rec to record arch list. */
2412 record_full_arch_list_add (rec
);
2415 discard_cleanups (old_cleanups
);
2417 /* Add record_full_arch_list_head to the end of record list. */
2418 record_full_first
.next
= record_full_arch_list_head
;
2419 record_full_arch_list_head
->prev
= &record_full_first
;
2420 record_full_arch_list_tail
->next
= NULL
;
2421 record_full_list
= &record_full_first
;
2423 /* Update record_full_insn_max_num. */
2424 if (record_full_insn_num
> record_full_insn_max_num
)
2426 record_full_insn_max_num
= record_full_insn_num
;
2427 warning (_("Auto increase record/replay buffer limit to %u."),
2428 record_full_insn_max_num
);
2432 printf_filtered (_("Restored records from core file %s.\n"),
2433 bfd_get_filename (core_bfd
));
2435 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2438 /* bfdcore_write -- write bytes into a core file section. */
2441 bfdcore_write (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2443 int ret
= bfd_set_section_contents (obfd
, osec
, buf
, *offset
, len
);
2448 error (_("Failed to write %d bytes to core file %s ('%s')."),
2449 len
, bfd_get_filename (obfd
),
2450 bfd_errmsg (bfd_get_error ()));
2453 /* Restore the execution log from a file. We use a modified elf
2454 corefile format, with an extra section for our data. */
2457 cmd_record_full_restore (char *args
, int from_tty
)
2459 core_file_command (args
, from_tty
);
2460 record_full_open (args
, from_tty
);
2464 record_full_save_cleanups (void *data
)
2467 char *pathname
= xstrdup (bfd_get_filename (obfd
));
2469 gdb_bfd_unref (obfd
);
2474 /* Save the execution log to a file. We use a modified elf corefile
2475 format, with an extra section for our data. */
2478 record_full_save (struct target_ops
*self
, const char *recfilename
)
2480 struct record_full_entry
*cur_record_full_list
;
2482 struct regcache
*regcache
;
2483 struct gdbarch
*gdbarch
;
2484 struct cleanup
*old_cleanups
;
2485 struct cleanup
*set_cleanups
;
2488 asection
*osec
= NULL
;
2491 /* Open the save file. */
2493 fprintf_unfiltered (gdb_stdlog
, "Saving execution log to core file '%s'\n",
2496 /* Open the output file. */
2497 obfd
= create_gcore_bfd (recfilename
);
2498 old_cleanups
= make_cleanup (record_full_save_cleanups
, obfd
);
2500 /* Save the current record entry to "cur_record_full_list". */
2501 cur_record_full_list
= record_full_list
;
2503 /* Get the values of regcache and gdbarch. */
2504 regcache
= get_current_regcache ();
2505 gdbarch
= get_regcache_arch (regcache
);
2507 /* Disable the GDB operation record. */
2508 set_cleanups
= record_full_gdb_operation_disable_set ();
2510 /* Reverse execute to the begin of record list. */
2513 /* Check for beginning and end of log. */
2514 if (record_full_list
== &record_full_first
)
2517 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2519 if (record_full_list
->prev
)
2520 record_full_list
= record_full_list
->prev
;
2523 /* Compute the size needed for the extra bfd section. */
2524 save_size
= 4; /* magic cookie */
2525 for (record_full_list
= record_full_first
.next
; record_full_list
;
2526 record_full_list
= record_full_list
->next
)
2527 switch (record_full_list
->type
)
2529 case record_full_end
:
2530 save_size
+= 1 + 4 + 4;
2532 case record_full_reg
:
2533 save_size
+= 1 + 4 + record_full_list
->u
.reg
.len
;
2535 case record_full_mem
:
2536 save_size
+= 1 + 4 + 8 + record_full_list
->u
.mem
.len
;
2540 /* Make the new bfd section. */
2541 osec
= bfd_make_section_anyway_with_flags (obfd
, "precord",
2545 error (_("Failed to create 'precord' section for corefile %s: %s"),
2547 bfd_errmsg (bfd_get_error ()));
2548 bfd_set_section_size (obfd
, osec
, save_size
);
2549 bfd_set_section_vma (obfd
, osec
, 0);
2550 bfd_set_section_alignment (obfd
, osec
, 0);
2551 bfd_section_lma (obfd
, osec
) = 0;
2553 /* Save corefile state. */
2554 write_gcore_file (obfd
);
2556 /* Write out the record log. */
2557 /* Write the magic code. */
2558 magic
= RECORD_FULL_FILE_MAGIC
;
2560 fprintf_unfiltered (gdb_stdlog
,
2561 " Writing 4-byte magic cookie "
2562 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2563 phex_nz (magic
, 4));
2564 bfdcore_write (obfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2566 /* Save the entries to recfd and forward execute to the end of
2568 record_full_list
= &record_full_first
;
2572 if (record_full_list
!= &record_full_first
)
2575 uint32_t regnum
, len
, signal
, count
;
2578 type
= record_full_list
->type
;
2579 bfdcore_write (obfd
, osec
, &type
, sizeof (type
), &bfd_offset
);
2581 switch (record_full_list
->type
)
2583 case record_full_reg
: /* reg */
2585 fprintf_unfiltered (gdb_stdlog
,
2586 " Writing register %d (1 "
2587 "plus %lu plus %d bytes)\n",
2588 record_full_list
->u
.reg
.num
,
2589 (unsigned long) sizeof (regnum
),
2590 record_full_list
->u
.reg
.len
);
2593 regnum
= netorder32 (record_full_list
->u
.reg
.num
);
2594 bfdcore_write (obfd
, osec
, ®num
,
2595 sizeof (regnum
), &bfd_offset
);
2598 bfdcore_write (obfd
, osec
,
2599 record_full_get_loc (record_full_list
),
2600 record_full_list
->u
.reg
.len
, &bfd_offset
);
2603 case record_full_mem
: /* mem */
2605 fprintf_unfiltered (gdb_stdlog
,
2606 " Writing memory %s (1 plus "
2607 "%lu plus %lu plus %d bytes)\n",
2609 record_full_list
->u
.mem
.addr
),
2610 (unsigned long) sizeof (addr
),
2611 (unsigned long) sizeof (len
),
2612 record_full_list
->u
.mem
.len
);
2615 len
= netorder32 (record_full_list
->u
.mem
.len
);
2616 bfdcore_write (obfd
, osec
, &len
, sizeof (len
), &bfd_offset
);
2618 /* Write memaddr. */
2619 addr
= netorder64 (record_full_list
->u
.mem
.addr
);
2620 bfdcore_write (obfd
, osec
, &addr
,
2621 sizeof (addr
), &bfd_offset
);
2624 bfdcore_write (obfd
, osec
,
2625 record_full_get_loc (record_full_list
),
2626 record_full_list
->u
.mem
.len
, &bfd_offset
);
2629 case record_full_end
:
2631 fprintf_unfiltered (gdb_stdlog
,
2632 " Writing record_full_end (1 + "
2633 "%lu + %lu bytes)\n",
2634 (unsigned long) sizeof (signal
),
2635 (unsigned long) sizeof (count
));
2636 /* Write signal value. */
2637 signal
= netorder32 (record_full_list
->u
.end
.sigval
);
2638 bfdcore_write (obfd
, osec
, &signal
,
2639 sizeof (signal
), &bfd_offset
);
2641 /* Write insn count. */
2642 count
= netorder32 (record_full_list
->u
.end
.insn_num
);
2643 bfdcore_write (obfd
, osec
, &count
,
2644 sizeof (count
), &bfd_offset
);
2649 /* Execute entry. */
2650 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2652 if (record_full_list
->next
)
2653 record_full_list
= record_full_list
->next
;
2658 /* Reverse execute to cur_record_full_list. */
2661 /* Check for beginning and end of log. */
2662 if (record_full_list
== cur_record_full_list
)
2665 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2667 if (record_full_list
->prev
)
2668 record_full_list
= record_full_list
->prev
;
2671 do_cleanups (set_cleanups
);
2672 gdb_bfd_unref (obfd
);
2673 discard_cleanups (old_cleanups
);
2676 printf_filtered (_("Saved core file %s with execution log.\n"),
2680 /* record_full_goto_insn -- rewind the record log (forward or backward,
2681 depending on DIR) to the given entry, changing the program state
2685 record_full_goto_insn (struct record_full_entry
*entry
,
2686 enum exec_direction_kind dir
)
2688 struct cleanup
*set_cleanups
= record_full_gdb_operation_disable_set ();
2689 struct regcache
*regcache
= get_current_regcache ();
2690 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2692 /* Assume everything is valid: we will hit the entry,
2693 and we will not hit the end of the recording. */
2695 if (dir
== EXEC_FORWARD
)
2696 record_full_list
= record_full_list
->next
;
2700 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2701 if (dir
== EXEC_REVERSE
)
2702 record_full_list
= record_full_list
->prev
;
2704 record_full_list
= record_full_list
->next
;
2705 } while (record_full_list
!= entry
);
2706 do_cleanups (set_cleanups
);
2709 /* Alias for "target record-full". */
2712 cmd_record_full_start (char *args
, int from_tty
)
2714 execute_command ("target record-full", from_tty
);
2718 set_record_full_insn_max_num (char *args
, int from_tty
,
2719 struct cmd_list_element
*c
)
2721 if (record_full_insn_num
> record_full_insn_max_num
)
2723 /* Count down record_full_insn_num while releasing records from list. */
2724 while (record_full_insn_num
> record_full_insn_max_num
)
2726 record_full_list_release_first ();
2727 record_full_insn_num
--;
2732 /* The "set record full" command. */
2735 set_record_full_command (char *args
, int from_tty
)
2737 printf_unfiltered (_("\"set record full\" must be followed "
2738 "by an apporpriate subcommand.\n"));
2739 help_list (set_record_full_cmdlist
, "set record full ", all_commands
,
2743 /* The "show record full" command. */
2746 show_record_full_command (char *args
, int from_tty
)
2748 cmd_show_list (show_record_full_cmdlist
, from_tty
, "");
2751 /* Provide a prototype to silence -Wmissing-prototypes. */
2752 extern initialize_file_ftype _initialize_record_full
;
2755 _initialize_record_full (void)
2757 struct cmd_list_element
*c
;
2759 /* Init record_full_first. */
2760 record_full_first
.prev
= NULL
;
2761 record_full_first
.next
= NULL
;
2762 record_full_first
.type
= record_full_end
;
2764 init_record_full_ops ();
2765 add_target (&record_full_ops
);
2766 add_deprecated_target_alias (&record_full_ops
, "record");
2767 init_record_full_core_ops ();
2768 add_target (&record_full_core_ops
);
2770 add_prefix_cmd ("full", class_obscure
, cmd_record_full_start
,
2771 _("Start full execution recording."), &record_full_cmdlist
,
2772 "record full ", 0, &record_cmdlist
);
2774 c
= add_cmd ("restore", class_obscure
, cmd_record_full_restore
,
2775 _("Restore the execution log from a file.\n\
2776 Argument is filename. File must be created with 'record save'."),
2777 &record_full_cmdlist
);
2778 set_cmd_completer (c
, filename_completer
);
2780 /* Deprecate the old version without "full" prefix. */
2781 c
= add_alias_cmd ("restore", "full restore", class_obscure
, 1,
2783 set_cmd_completer (c
, filename_completer
);
2784 deprecate_cmd (c
, "record full restore");
2786 add_prefix_cmd ("full", class_support
, set_record_full_command
,
2787 _("Set record options"), &set_record_full_cmdlist
,
2788 "set record full ", 0, &set_record_cmdlist
);
2790 add_prefix_cmd ("full", class_support
, show_record_full_command
,
2791 _("Show record options"), &show_record_full_cmdlist
,
2792 "show record full ", 0, &show_record_cmdlist
);
2794 /* Record instructions number limit command. */
2795 add_setshow_boolean_cmd ("stop-at-limit", no_class
,
2796 &record_full_stop_at_limit
, _("\
2797 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2798 Show whether record/replay stops when record/replay buffer becomes full."),
2799 _("Default is ON.\n\
2800 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2801 When OFF, if the record/replay buffer becomes full,\n\
2802 delete the oldest recorded instruction to make room for each new one."),
2804 &set_record_full_cmdlist
, &show_record_full_cmdlist
);
2806 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2807 &set_record_cmdlist
);
2808 deprecate_cmd (c
, "set record full stop-at-limit");
2810 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2811 &show_record_cmdlist
);
2812 deprecate_cmd (c
, "show record full stop-at-limit");
2814 add_setshow_uinteger_cmd ("insn-number-max", no_class
,
2815 &record_full_insn_max_num
,
2816 _("Set record/replay buffer limit."),
2817 _("Show record/replay buffer limit."), _("\
2818 Set the maximum number of instructions to be stored in the\n\
2819 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2820 limit. Default is 200000."),
2821 set_record_full_insn_max_num
,
2822 NULL
, &set_record_full_cmdlist
,
2823 &show_record_full_cmdlist
);
2825 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2826 &set_record_cmdlist
);
2827 deprecate_cmd (c
, "set record full insn-number-max");
2829 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2830 &show_record_cmdlist
);
2831 deprecate_cmd (c
, "show record full insn-number-max");
2833 add_setshow_boolean_cmd ("memory-query", no_class
,
2834 &record_full_memory_query
, _("\
2835 Set whether query if PREC cannot record memory change of next instruction."),
2837 Show whether query if PREC cannot record memory change of next instruction."),
2840 When ON, query if PREC cannot record memory change of next instruction."),
2842 &set_record_full_cmdlist
,
2843 &show_record_full_cmdlist
);
2845 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2846 &set_record_cmdlist
);
2847 deprecate_cmd (c
, "set record full memory-query");
2849 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2850 &show_record_cmdlist
);
2851 deprecate_cmd (c
, "show record full memory-query");