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 (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
655 = (struct record_full_message_args
*) args
;
657 return record_full_message (record_full_args
->regcache
,
658 record_full_args
->signal
);
662 record_full_message_wrapper_safe (struct regcache
*regcache
,
663 enum gdb_signal signal
)
665 struct record_full_message_args args
;
667 args
.regcache
= regcache
;
668 args
.signal
= signal
;
670 return catch_errors (record_full_message_wrapper
, &args
, "",
674 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
675 doesn't need record. */
677 static int record_full_gdb_operation_disable
= 0;
680 record_full_gdb_operation_disable_set (void)
682 struct cleanup
*old_cleanups
= NULL
;
685 make_cleanup_restore_integer (&record_full_gdb_operation_disable
);
686 record_full_gdb_operation_disable
= 1;
691 /* Flag set to TRUE for target_stopped_by_watchpoint. */
692 static enum target_stop_reason record_full_stop_reason
693 = TARGET_STOPPED_BY_NO_REASON
;
695 /* Execute one instruction from the record log. Each instruction in
696 the log will be represented by an arbitrary sequence of register
697 entries and memory entries, followed by an 'end' entry. */
700 record_full_exec_insn (struct regcache
*regcache
,
701 struct gdbarch
*gdbarch
,
702 struct record_full_entry
*entry
)
706 case record_full_reg
: /* reg */
708 gdb_byte reg
[MAX_REGISTER_SIZE
];
710 if (record_debug
> 1)
711 fprintf_unfiltered (gdb_stdlog
,
712 "Process record: record_full_reg %s to "
713 "inferior num = %d.\n",
714 host_address_to_string (entry
),
717 regcache_cooked_read (regcache
, entry
->u
.reg
.num
, reg
);
718 regcache_cooked_write (regcache
, entry
->u
.reg
.num
,
719 record_full_get_loc (entry
));
720 memcpy (record_full_get_loc (entry
), reg
, entry
->u
.reg
.len
);
724 case record_full_mem
: /* mem */
726 /* Nothing to do if the entry is flagged not_accessible. */
727 if (!entry
->u
.mem
.mem_entry_not_accessible
)
729 gdb_byte
*mem
= (gdb_byte
*) xmalloc (entry
->u
.mem
.len
);
730 struct cleanup
*cleanup
= make_cleanup (xfree
, mem
);
732 if (record_debug
> 1)
733 fprintf_unfiltered (gdb_stdlog
,
734 "Process record: record_full_mem %s to "
735 "inferior addr = %s len = %d.\n",
736 host_address_to_string (entry
),
737 paddress (gdbarch
, entry
->u
.mem
.addr
),
740 if (record_read_memory (gdbarch
,
741 entry
->u
.mem
.addr
, mem
, entry
->u
.mem
.len
))
742 entry
->u
.mem
.mem_entry_not_accessible
= 1;
745 if (target_write_memory (entry
->u
.mem
.addr
,
746 record_full_get_loc (entry
),
749 entry
->u
.mem
.mem_entry_not_accessible
= 1;
751 warning (_("Process record: error writing memory at "
752 "addr = %s len = %d."),
753 paddress (gdbarch
, entry
->u
.mem
.addr
),
758 memcpy (record_full_get_loc (entry
), mem
,
761 /* We've changed memory --- check if a hardware
762 watchpoint should trap. Note that this
763 presently assumes the target beneath supports
764 continuable watchpoints. On non-continuable
765 watchpoints target, we'll want to check this
766 _before_ actually doing the memory change, and
767 not doing the change at all if the watchpoint
769 if (hardware_watchpoint_inserted_in_range
770 (get_regcache_aspace (regcache
),
771 entry
->u
.mem
.addr
, entry
->u
.mem
.len
))
772 record_full_stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
776 do_cleanups (cleanup
);
783 static void record_full_restore (void);
785 /* Asynchronous signal handle registered as event loop source for when
786 we have pending events ready to be passed to the core. */
788 static struct async_event_handler
*record_full_async_inferior_event_token
;
791 record_full_async_inferior_event_handler (gdb_client_data data
)
793 inferior_event_handler (INF_REG_EVENT
, NULL
);
796 /* Open the process record target. */
799 record_full_core_open_1 (const char *name
, int from_tty
)
801 struct regcache
*regcache
= get_current_regcache ();
802 int regnum
= gdbarch_num_regs (get_regcache_arch (regcache
));
805 /* Get record_full_core_regbuf. */
806 target_fetch_registers (regcache
, -1);
807 record_full_core_regbuf
= (gdb_byte
*) xmalloc (MAX_REGISTER_SIZE
* regnum
);
808 for (i
= 0; i
< regnum
; i
++)
809 regcache_raw_collect (regcache
, i
,
810 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
812 /* Get record_full_core_start and record_full_core_end. */
813 if (build_section_table (core_bfd
, &record_full_core_start
,
814 &record_full_core_end
))
816 xfree (record_full_core_regbuf
);
817 record_full_core_regbuf
= NULL
;
818 error (_("\"%s\": Can't find sections: %s"),
819 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
822 push_target (&record_full_core_ops
);
823 record_full_restore ();
826 /* "to_open" target method for 'live' processes. */
829 record_full_open_1 (const char *name
, int from_tty
)
832 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
835 if (!target_has_execution
)
836 error (_("Process record: the program is not being run."));
838 error (_("Process record target can't debug inferior in non-stop mode "
841 if (!gdbarch_process_record_p (target_gdbarch ()))
842 error (_("Process record: the current architecture doesn't support "
843 "record function."));
845 push_target (&record_full_ops
);
848 static void record_full_init_record_breakpoints (void);
850 /* "to_open" target method. Open the process record target. */
853 record_full_open (const char *name
, int from_tty
)
855 struct target_ops
*t
;
858 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_open\n");
863 record_full_insn_num
= 0;
864 record_full_insn_count
= 0;
865 record_full_list
= &record_full_first
;
866 record_full_list
->next
= NULL
;
869 record_full_core_open_1 (name
, from_tty
);
871 record_full_open_1 (name
, from_tty
);
873 /* Register extra event sources in the event loop. */
874 record_full_async_inferior_event_token
875 = create_async_event_handler (record_full_async_inferior_event_handler
,
878 record_full_init_record_breakpoints ();
880 observer_notify_record_changed (current_inferior (), 1);
883 /* "to_close" target method. Close the process record target. */
886 record_full_close (struct target_ops
*self
)
888 struct record_full_core_buf_entry
*entry
;
891 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_close\n");
893 record_full_list_release (record_full_list
);
895 /* Release record_full_core_regbuf. */
896 if (record_full_core_regbuf
)
898 xfree (record_full_core_regbuf
);
899 record_full_core_regbuf
= NULL
;
902 /* Release record_full_core_buf_list. */
903 if (record_full_core_buf_list
)
905 for (entry
= record_full_core_buf_list
->prev
; entry
;
908 xfree (record_full_core_buf_list
);
909 record_full_core_buf_list
= entry
;
911 record_full_core_buf_list
= NULL
;
914 if (record_full_async_inferior_event_token
)
915 delete_async_event_handler (&record_full_async_inferior_event_token
);
918 /* "to_async" target method. */
921 record_full_async (struct target_ops
*ops
, int enable
)
924 mark_async_event_handler (record_full_async_inferior_event_token
);
926 clear_async_event_handler (record_full_async_inferior_event_token
);
928 ops
->beneath
->to_async (ops
->beneath
, enable
);
931 static int record_full_resume_step
= 0;
933 /* True if we've been resumed, and so each record_full_wait call should
934 advance execution. If this is false, record_full_wait will return a
935 TARGET_WAITKIND_IGNORE. */
936 static int record_full_resumed
= 0;
938 /* The execution direction of the last resume we got. This is
939 necessary for async mode. Vis (order is not strictly accurate):
941 1. user has the global execution direction set to forward
942 2. user does a reverse-step command
943 3. record_full_resume is called with global execution direction
944 temporarily switched to reverse
945 4. GDB's execution direction is reverted back to forward
946 5. target record notifies event loop there's an event to handle
947 6. infrun asks the target which direction was it going, and switches
948 the global execution direction accordingly (to reverse)
949 7. infrun polls an event out of the record target, and handles it
950 8. GDB goes back to the event loop, and goto #4.
952 static enum exec_direction_kind record_full_execution_dir
= EXEC_FORWARD
;
954 /* "to_resume" target method. Resume the process record target. */
957 record_full_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
958 enum gdb_signal signal
)
960 record_full_resume_step
= step
;
961 record_full_resumed
= 1;
962 record_full_execution_dir
= execution_direction
;
964 if (!RECORD_FULL_IS_REPLAY
)
966 struct gdbarch
*gdbarch
= target_thread_architecture (ptid
);
968 record_full_message (get_current_regcache (), signal
);
972 /* This is not hard single step. */
973 if (!gdbarch_software_single_step_p (gdbarch
))
975 /* This is a normal continue. */
980 /* This arch support soft sigle step. */
981 if (thread_has_single_step_breakpoints_set (inferior_thread ()))
983 /* This is a soft single step. */
984 record_full_resume_step
= 1;
988 /* This is a continue.
989 Try to insert a soft single step breakpoint. */
990 if (!gdbarch_software_single_step (gdbarch
,
991 get_current_frame ()))
993 /* This system don't want use soft single step.
994 Use hard sigle step. */
1001 /* Make sure the target beneath reports all signals. */
1002 target_pass_signals (0, NULL
);
1004 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
, signal
);
1007 /* We are about to start executing the inferior (or simulate it),
1008 let's register it with the event loop. */
1009 if (target_can_async_p ())
1013 static int record_full_get_sig
= 0;
1015 /* SIGINT signal handler, registered by "to_wait" method. */
1018 record_full_sig_handler (int signo
)
1021 fprintf_unfiltered (gdb_stdlog
, "Process record: get a signal\n");
1023 /* It will break the running inferior in replay mode. */
1024 record_full_resume_step
= 1;
1026 /* It will let record_full_wait set inferior status to get the signal
1028 record_full_get_sig
= 1;
1032 record_full_wait_cleanups (void *ignore
)
1034 if (execution_direction
== EXEC_REVERSE
)
1036 if (record_full_list
->next
)
1037 record_full_list
= record_full_list
->next
;
1040 record_full_list
= record_full_list
->prev
;
1043 /* "to_wait" target method for process record target.
1045 In record mode, the target is always run in singlestep mode
1046 (even when gdb says to continue). The to_wait method intercepts
1047 the stop events and determines which ones are to be passed on to
1048 gdb. Most stop events are just singlestep events that gdb is not
1049 to know about, so the to_wait method just records them and keeps
1052 In replay mode, this function emulates the recorded execution log,
1053 one instruction at a time (forward or backward), and determines
1057 record_full_wait_1 (struct target_ops
*ops
,
1058 ptid_t ptid
, struct target_waitstatus
*status
,
1061 struct cleanup
*set_cleanups
= record_full_gdb_operation_disable_set ();
1064 fprintf_unfiltered (gdb_stdlog
,
1065 "Process record: record_full_wait "
1066 "record_full_resume_step = %d, "
1067 "record_full_resumed = %d, direction=%s\n",
1068 record_full_resume_step
, record_full_resumed
,
1069 record_full_execution_dir
== EXEC_FORWARD
1070 ? "forward" : "reverse");
1072 if (!record_full_resumed
)
1074 gdb_assert ((options
& TARGET_WNOHANG
) != 0);
1076 /* No interesting event. */
1077 status
->kind
= TARGET_WAITKIND_IGNORE
;
1078 return minus_one_ptid
;
1081 record_full_get_sig
= 0;
1082 signal (SIGINT
, record_full_sig_handler
);
1084 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1086 if (!RECORD_FULL_IS_REPLAY
&& ops
!= &record_full_core_ops
)
1088 if (record_full_resume_step
)
1090 /* This is a single step. */
1091 return ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1095 /* This is not a single step. */
1098 struct gdbarch
*gdbarch
= target_thread_architecture (inferior_ptid
);
1102 struct thread_info
*tp
;
1104 ret
= ops
->beneath
->to_wait (ops
->beneath
, ptid
, status
, options
);
1105 if (status
->kind
== TARGET_WAITKIND_IGNORE
)
1108 fprintf_unfiltered (gdb_stdlog
,
1109 "Process record: record_full_wait "
1110 "target beneath not done yet\n");
1114 ALL_NON_EXITED_THREADS (tp
)
1115 delete_single_step_breakpoints (tp
);
1117 if (record_full_resume_step
)
1120 /* Is this a SIGTRAP? */
1121 if (status
->kind
== TARGET_WAITKIND_STOPPED
1122 && status
->value
.sig
== GDB_SIGNAL_TRAP
)
1124 struct regcache
*regcache
;
1125 struct address_space
*aspace
;
1126 enum target_stop_reason
*stop_reason_p
1127 = &record_full_stop_reason
;
1129 /* Yes -- this is likely our single-step finishing,
1130 but check if there's any reason the core would be
1131 interested in the event. */
1133 registers_changed ();
1134 regcache
= get_current_regcache ();
1135 tmp_pc
= regcache_read_pc (regcache
);
1136 aspace
= get_regcache_aspace (regcache
);
1138 if (target_stopped_by_watchpoint ())
1140 /* Always interested in watchpoints. */
1142 else if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1145 /* There is a breakpoint here. Let the core
1150 /* This is a single-step trap. Record the
1151 insn and issue another step.
1152 FIXME: this part can be a random SIGTRAP too.
1153 But GDB cannot handle it. */
1156 if (!record_full_message_wrapper_safe (regcache
,
1159 status
->kind
= TARGET_WAITKIND_STOPPED
;
1160 status
->value
.sig
= GDB_SIGNAL_0
;
1164 if (gdbarch_software_single_step_p (gdbarch
))
1166 /* Try to insert the software single step breakpoint.
1167 If insert success, set step to 0. */
1168 set_executing (inferior_ptid
, 0);
1169 reinit_frame_cache ();
1170 if (gdbarch_software_single_step (gdbarch
,
1171 get_current_frame ()))
1173 set_executing (inferior_ptid
, 1);
1177 fprintf_unfiltered (gdb_stdlog
,
1178 "Process record: record_full_wait "
1179 "issuing one more step in the "
1180 "target beneath\n");
1181 ops
->beneath
->to_resume (ops
->beneath
, ptid
, step
,
1187 /* The inferior is broken by a breakpoint or a signal. */
1196 struct regcache
*regcache
= get_current_regcache ();
1197 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1198 struct address_space
*aspace
= get_regcache_aspace (regcache
);
1199 int continue_flag
= 1;
1200 int first_record_full_end
= 1;
1201 struct cleanup
*old_cleanups
1202 = make_cleanup (record_full_wait_cleanups
, 0);
1205 record_full_stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1206 status
->kind
= TARGET_WAITKIND_STOPPED
;
1208 /* Check breakpoint when forward execute. */
1209 if (execution_direction
== EXEC_FORWARD
)
1211 tmp_pc
= regcache_read_pc (regcache
);
1212 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1213 &record_full_stop_reason
))
1216 fprintf_unfiltered (gdb_stdlog
,
1217 "Process record: break at %s.\n",
1218 paddress (gdbarch
, tmp_pc
));
1223 /* If GDB is in terminal_inferior mode, it will not get the signal.
1224 And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1225 mode, because inferior will not executed.
1226 Then set it to terminal_ours to make GDB get the signal. */
1227 target_terminal_ours ();
1229 /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1231 if (execution_direction
== EXEC_FORWARD
&& record_full_list
->next
)
1232 record_full_list
= record_full_list
->next
;
1234 /* Loop over the record_full_list, looking for the next place to
1238 /* Check for beginning and end of log. */
1239 if (execution_direction
== EXEC_REVERSE
1240 && record_full_list
== &record_full_first
)
1242 /* Hit beginning of record log in reverse. */
1243 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1246 if (execution_direction
!= EXEC_REVERSE
&& !record_full_list
->next
)
1248 /* Hit end of record log going forward. */
1249 status
->kind
= TARGET_WAITKIND_NO_HISTORY
;
1253 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
1255 if (record_full_list
->type
== record_full_end
)
1257 if (record_debug
> 1)
1258 fprintf_unfiltered (gdb_stdlog
,
1259 "Process record: record_full_end %s to "
1261 host_address_to_string (record_full_list
));
1263 if (first_record_full_end
&& execution_direction
== EXEC_REVERSE
)
1265 /* When reverse excute, the first record_full_end is the
1266 part of current instruction. */
1267 first_record_full_end
= 0;
1271 /* In EXEC_REVERSE mode, this is the record_full_end of prev
1273 In EXEC_FORWARD mode, this is the record_full_end of
1274 current instruction. */
1276 if (record_full_resume_step
)
1278 if (record_debug
> 1)
1279 fprintf_unfiltered (gdb_stdlog
,
1280 "Process record: step.\n");
1284 /* check breakpoint */
1285 tmp_pc
= regcache_read_pc (regcache
);
1286 if (record_check_stopped_by_breakpoint (aspace
, tmp_pc
,
1287 &record_full_stop_reason
))
1290 fprintf_unfiltered (gdb_stdlog
,
1291 "Process record: break "
1293 paddress (gdbarch
, tmp_pc
));
1298 if (record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
1301 fprintf_unfiltered (gdb_stdlog
,
1302 "Process record: hit hw "
1306 /* Check target signal */
1307 if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1308 /* FIXME: better way to check */
1315 if (execution_direction
== EXEC_REVERSE
)
1317 if (record_full_list
->prev
)
1318 record_full_list
= record_full_list
->prev
;
1322 if (record_full_list
->next
)
1323 record_full_list
= record_full_list
->next
;
1327 while (continue_flag
);
1330 if (record_full_get_sig
)
1331 status
->value
.sig
= GDB_SIGNAL_INT
;
1332 else if (record_full_list
->u
.end
.sigval
!= GDB_SIGNAL_0
)
1333 /* FIXME: better way to check */
1334 status
->value
.sig
= record_full_list
->u
.end
.sigval
;
1336 status
->value
.sig
= GDB_SIGNAL_TRAP
;
1338 discard_cleanups (old_cleanups
);
1341 signal (SIGINT
, handle_sigint
);
1343 do_cleanups (set_cleanups
);
1344 return inferior_ptid
;
1348 record_full_wait (struct target_ops
*ops
,
1349 ptid_t ptid
, struct target_waitstatus
*status
,
1354 return_ptid
= record_full_wait_1 (ops
, ptid
, status
, options
);
1355 if (status
->kind
!= TARGET_WAITKIND_IGNORE
)
1357 /* We're reporting a stop. Make sure any spurious
1358 target_wait(WNOHANG) doesn't advance the target until the
1359 core wants us resumed again. */
1360 record_full_resumed
= 0;
1366 record_full_stopped_by_watchpoint (struct target_ops
*ops
)
1368 if (RECORD_FULL_IS_REPLAY
)
1369 return record_full_stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
;
1371 return ops
->beneath
->to_stopped_by_watchpoint (ops
->beneath
);
1375 record_full_stopped_data_address (struct target_ops
*ops
, CORE_ADDR
*addr_p
)
1377 if (RECORD_FULL_IS_REPLAY
)
1380 return ops
->beneath
->to_stopped_data_address (ops
->beneath
, addr_p
);
1383 /* The to_stopped_by_sw_breakpoint method of target record-full. */
1386 record_full_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1388 return record_full_stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
;
1391 /* The to_supports_stopped_by_sw_breakpoint method of target
1395 record_full_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
1400 /* The to_stopped_by_hw_breakpoint method of target record-full. */
1403 record_full_stopped_by_hw_breakpoint (struct target_ops
*ops
)
1405 return record_full_stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
;
1408 /* The to_supports_stopped_by_sw_breakpoint method of target
1412 record_full_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
1417 /* Record registers change (by user or by GDB) to list as an instruction. */
1420 record_full_registers_change (struct regcache
*regcache
, int regnum
)
1422 /* Check record_full_insn_num. */
1423 record_full_check_insn_num (0);
1425 record_full_arch_list_head
= NULL
;
1426 record_full_arch_list_tail
= NULL
;
1432 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
1434 if (record_full_arch_list_add_reg (regcache
, i
))
1436 record_full_list_release (record_full_arch_list_tail
);
1437 error (_("Process record: failed to record execution log."));
1443 if (record_full_arch_list_add_reg (regcache
, regnum
))
1445 record_full_list_release (record_full_arch_list_tail
);
1446 error (_("Process record: failed to record execution log."));
1449 if (record_full_arch_list_add_end ())
1451 record_full_list_release (record_full_arch_list_tail
);
1452 error (_("Process record: failed to record execution log."));
1454 record_full_list
->next
= record_full_arch_list_head
;
1455 record_full_arch_list_head
->prev
= record_full_list
;
1456 record_full_list
= record_full_arch_list_tail
;
1458 if (record_full_insn_num
== record_full_insn_max_num
)
1459 record_full_list_release_first ();
1461 record_full_insn_num
++;
1464 /* "to_store_registers" method for process record target. */
1467 record_full_store_registers (struct target_ops
*ops
,
1468 struct regcache
*regcache
,
1471 if (!record_full_gdb_operation_disable
)
1473 if (RECORD_FULL_IS_REPLAY
)
1477 /* Let user choose if he wants to write register or not. */
1480 query (_("Because GDB is in replay mode, changing the "
1481 "value of a register will make the execution "
1482 "log unusable from this point onward. "
1483 "Change all registers?"));
1486 query (_("Because GDB is in replay mode, changing the value "
1487 "of a register will make the execution log unusable "
1488 "from this point onward. Change register %s?"),
1489 gdbarch_register_name (get_regcache_arch (regcache
),
1494 /* Invalidate the value of regcache that was set in function
1495 "regcache_raw_write". */
1501 i
< gdbarch_num_regs (get_regcache_arch (regcache
));
1503 regcache_invalidate (regcache
, i
);
1506 regcache_invalidate (regcache
, regno
);
1508 error (_("Process record canceled the operation."));
1511 /* Destroy the record from here forward. */
1512 record_full_list_release_following (record_full_list
);
1515 record_full_registers_change (regcache
, regno
);
1517 ops
->beneath
->to_store_registers (ops
->beneath
, regcache
, regno
);
1520 /* "to_xfer_partial" method. Behavior is conditional on
1521 RECORD_FULL_IS_REPLAY.
1522 In replay mode, we cannot write memory unles we are willing to
1523 invalidate the record/replay log from this point forward. */
1525 static enum target_xfer_status
1526 record_full_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1527 const char *annex
, gdb_byte
*readbuf
,
1528 const gdb_byte
*writebuf
, ULONGEST offset
,
1529 ULONGEST len
, ULONGEST
*xfered_len
)
1531 if (!record_full_gdb_operation_disable
1532 && (object
== TARGET_OBJECT_MEMORY
1533 || object
== TARGET_OBJECT_RAW_MEMORY
) && writebuf
)
1535 if (RECORD_FULL_IS_REPLAY
)
1537 /* Let user choose if he wants to write memory or not. */
1538 if (!query (_("Because GDB is in replay mode, writing to memory "
1539 "will make the execution log unusable from this "
1540 "point onward. Write memory at address %s?"),
1541 paddress (target_gdbarch (), offset
)))
1542 error (_("Process record canceled the operation."));
1544 /* Destroy the record from here forward. */
1545 record_full_list_release_following (record_full_list
);
1548 /* Check record_full_insn_num */
1549 record_full_check_insn_num (0);
1551 /* Record registers change to list as an instruction. */
1552 record_full_arch_list_head
= NULL
;
1553 record_full_arch_list_tail
= NULL
;
1554 if (record_full_arch_list_add_mem (offset
, len
))
1556 record_full_list_release (record_full_arch_list_tail
);
1558 fprintf_unfiltered (gdb_stdlog
,
1559 "Process record: failed to record "
1561 return TARGET_XFER_E_IO
;
1563 if (record_full_arch_list_add_end ())
1565 record_full_list_release (record_full_arch_list_tail
);
1567 fprintf_unfiltered (gdb_stdlog
,
1568 "Process record: failed to record "
1570 return TARGET_XFER_E_IO
;
1572 record_full_list
->next
= record_full_arch_list_head
;
1573 record_full_arch_list_head
->prev
= record_full_list
;
1574 record_full_list
= record_full_arch_list_tail
;
1576 if (record_full_insn_num
== record_full_insn_max_num
)
1577 record_full_list_release_first ();
1579 record_full_insn_num
++;
1582 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1583 readbuf
, writebuf
, offset
,
1587 /* This structure represents a breakpoint inserted while the record
1588 target is active. We use this to know when to install/remove
1589 breakpoints in/from the target beneath. For example, a breakpoint
1590 may be inserted while recording, but removed when not replaying nor
1591 recording. In that case, the breakpoint had not been inserted on
1592 the target beneath, so we should not try to remove it there. */
1594 struct record_full_breakpoint
1596 /* The address and address space the breakpoint was set at. */
1597 struct address_space
*address_space
;
1600 /* True when the breakpoint has been also installed in the target
1601 beneath. This will be false for breakpoints set during replay or
1603 int in_target_beneath
;
1606 typedef struct record_full_breakpoint
*record_full_breakpoint_p
;
1607 DEF_VEC_P(record_full_breakpoint_p
);
1609 /* The list of breakpoints inserted while the record target is
1611 VEC(record_full_breakpoint_p
) *record_full_breakpoints
= NULL
;
1614 record_full_sync_record_breakpoints (struct bp_location
*loc
, void *data
)
1616 if (loc
->loc_type
!= bp_loc_software_breakpoint
)
1621 struct record_full_breakpoint
*bp
= XNEW (struct record_full_breakpoint
);
1623 bp
->addr
= loc
->target_info
.placed_address
;
1624 bp
->address_space
= loc
->target_info
.placed_address_space
;
1626 bp
->in_target_beneath
= 1;
1628 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1632 /* Sync existing breakpoints to record_full_breakpoints. */
1635 record_full_init_record_breakpoints (void)
1637 VEC_free (record_full_breakpoint_p
, record_full_breakpoints
);
1639 iterate_over_bp_locations (record_full_sync_record_breakpoints
);
1642 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1643 insert or remove breakpoints in the real target when replaying, nor
1647 record_full_insert_breakpoint (struct target_ops
*ops
,
1648 struct gdbarch
*gdbarch
,
1649 struct bp_target_info
*bp_tgt
)
1651 struct record_full_breakpoint
*bp
;
1652 int in_target_beneath
= 0;
1654 if (!RECORD_FULL_IS_REPLAY
)
1656 /* When recording, we currently always single-step, so we don't
1657 really need to install regular breakpoints in the inferior.
1658 However, we do have to insert software single-step
1659 breakpoints, in case the target can't hardware step. To keep
1660 things single, we always insert. */
1661 struct cleanup
*old_cleanups
;
1664 old_cleanups
= record_full_gdb_operation_disable_set ();
1665 ret
= ops
->beneath
->to_insert_breakpoint (ops
->beneath
, gdbarch
, bp_tgt
);
1666 do_cleanups (old_cleanups
);
1671 in_target_beneath
= 1;
1675 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
1678 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
1680 bp_tgt
->placed_address
= addr
;
1681 bp_tgt
->placed_size
= bplen
;
1684 bp
= XNEW (struct record_full_breakpoint
);
1685 bp
->addr
= bp_tgt
->placed_address
;
1686 bp
->address_space
= bp_tgt
->placed_address_space
;
1687 bp
->in_target_beneath
= in_target_beneath
;
1688 VEC_safe_push (record_full_breakpoint_p
, record_full_breakpoints
, bp
);
1692 /* "to_remove_breakpoint" method for process record target. */
1695 record_full_remove_breakpoint (struct target_ops
*ops
,
1696 struct gdbarch
*gdbarch
,
1697 struct bp_target_info
*bp_tgt
)
1699 struct record_full_breakpoint
*bp
;
1703 VEC_iterate (record_full_breakpoint_p
,
1704 record_full_breakpoints
, ix
, bp
);
1707 if (bp
->addr
== bp_tgt
->placed_address
1708 && bp
->address_space
== bp_tgt
->placed_address_space
)
1710 if (bp
->in_target_beneath
)
1712 struct cleanup
*old_cleanups
;
1715 old_cleanups
= record_full_gdb_operation_disable_set ();
1716 ret
= ops
->beneath
->to_remove_breakpoint (ops
->beneath
, gdbarch
,
1718 do_cleanups (old_cleanups
);
1724 VEC_unordered_remove (record_full_breakpoint_p
,
1725 record_full_breakpoints
, ix
);
1730 gdb_assert_not_reached ("removing unknown breakpoint");
1733 /* "to_can_execute_reverse" method for process record target. */
1736 record_full_can_execute_reverse (struct target_ops
*self
)
1741 /* "to_get_bookmark" method for process record and prec over core. */
1744 record_full_get_bookmark (struct target_ops
*self
, const char *args
,
1749 /* Return stringified form of instruction count. */
1750 if (record_full_list
&& record_full_list
->type
== record_full_end
)
1751 ret
= xstrdup (pulongest (record_full_list
->u
.end
.insn_num
));
1756 fprintf_unfiltered (gdb_stdlog
,
1757 "record_full_get_bookmark returns %s\n", ret
);
1759 fprintf_unfiltered (gdb_stdlog
,
1760 "record_full_get_bookmark returns NULL\n");
1762 return (gdb_byte
*) ret
;
1765 /* "to_goto_bookmark" method for process record and prec over core. */
1768 record_full_goto_bookmark (struct target_ops
*self
,
1769 const gdb_byte
*raw_bookmark
, int from_tty
)
1771 const char *bookmark
= (const char *) raw_bookmark
;
1772 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1775 fprintf_unfiltered (gdb_stdlog
,
1776 "record_full_goto_bookmark receives %s\n", bookmark
);
1778 if (bookmark
[0] == '\'' || bookmark
[0] == '\"')
1782 if (bookmark
[strlen (bookmark
) - 1] != bookmark
[0])
1783 error (_("Unbalanced quotes: %s"), bookmark
);
1786 copy
= savestring (bookmark
+ 1, strlen (bookmark
) - 2);
1787 make_cleanup (xfree
, copy
);
1791 record_goto (bookmark
);
1793 do_cleanups (cleanup
);
1796 static enum exec_direction_kind
1797 record_full_execution_direction (struct target_ops
*self
)
1799 return record_full_execution_dir
;
1803 record_full_info (struct target_ops
*self
)
1805 struct record_full_entry
*p
;
1807 if (RECORD_FULL_IS_REPLAY
)
1808 printf_filtered (_("Replay mode:\n"));
1810 printf_filtered (_("Record mode:\n"));
1812 /* Find entry for first actual instruction in the log. */
1813 for (p
= record_full_first
.next
;
1814 p
!= NULL
&& p
->type
!= record_full_end
;
1818 /* Do we have a log at all? */
1819 if (p
!= NULL
&& p
->type
== record_full_end
)
1821 /* Display instruction number for first instruction in the log. */
1822 printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1823 pulongest (p
->u
.end
.insn_num
));
1825 /* If in replay mode, display where we are in the log. */
1826 if (RECORD_FULL_IS_REPLAY
)
1827 printf_filtered (_("Current instruction number is %s.\n"),
1828 pulongest (record_full_list
->u
.end
.insn_num
));
1830 /* Display instruction number for last instruction in the log. */
1831 printf_filtered (_("Highest recorded instruction number is %s.\n"),
1832 pulongest (record_full_insn_count
));
1834 /* Display log count. */
1835 printf_filtered (_("Log contains %u instructions.\n"),
1836 record_full_insn_num
);
1839 printf_filtered (_("No instructions have been logged.\n"));
1841 /* Display max log size. */
1842 printf_filtered (_("Max logged instructions is %u.\n"),
1843 record_full_insn_max_num
);
1846 /* The "to_record_delete" target method. */
1849 record_full_delete (struct target_ops
*self
)
1851 record_full_list_release_following (record_full_list
);
1854 /* The "to_record_is_replaying" target method. */
1857 record_full_is_replaying (struct target_ops
*self
, ptid_t ptid
)
1859 return RECORD_FULL_IS_REPLAY
;
1862 /* The "to_record_will_replay" target method. */
1865 record_full_will_replay (struct target_ops
*self
, ptid_t ptid
, int dir
)
1867 /* We can currently only record when executing forwards. Should we be able
1868 to record when executing backwards on targets that support reverse
1869 execution, this needs to be changed. */
1871 return RECORD_FULL_IS_REPLAY
|| dir
== EXEC_REVERSE
;
1874 /* Go to a specific entry. */
1877 record_full_goto_entry (struct record_full_entry
*p
)
1880 error (_("Target insn not found."));
1881 else if (p
== record_full_list
)
1882 error (_("Already at target insn."));
1883 else if (p
->u
.end
.insn_num
> record_full_list
->u
.end
.insn_num
)
1885 printf_filtered (_("Go forward to insn number %s\n"),
1886 pulongest (p
->u
.end
.insn_num
));
1887 record_full_goto_insn (p
, EXEC_FORWARD
);
1891 printf_filtered (_("Go backward to insn number %s\n"),
1892 pulongest (p
->u
.end
.insn_num
));
1893 record_full_goto_insn (p
, EXEC_REVERSE
);
1896 registers_changed ();
1897 reinit_frame_cache ();
1898 stop_pc
= regcache_read_pc (get_current_regcache ());
1899 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1902 /* The "to_goto_record_begin" target method. */
1905 record_full_goto_begin (struct target_ops
*self
)
1907 struct record_full_entry
*p
= NULL
;
1909 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1910 if (p
->type
== record_full_end
)
1913 record_full_goto_entry (p
);
1916 /* The "to_goto_record_end" target method. */
1919 record_full_goto_end (struct target_ops
*self
)
1921 struct record_full_entry
*p
= NULL
;
1923 for (p
= record_full_list
; p
->next
!= NULL
; p
= p
->next
)
1925 for (; p
!= NULL
; p
= p
->prev
)
1926 if (p
->type
== record_full_end
)
1929 record_full_goto_entry (p
);
1932 /* The "to_goto_record" target method. */
1935 record_full_goto (struct target_ops
*self
, ULONGEST target_insn
)
1937 struct record_full_entry
*p
= NULL
;
1939 for (p
= &record_full_first
; p
!= NULL
; p
= p
->next
)
1940 if (p
->type
== record_full_end
&& p
->u
.end
.insn_num
== target_insn
)
1943 record_full_goto_entry (p
);
1946 /* The "to_record_stop_replaying" target method. */
1949 record_full_stop_replaying (struct target_ops
*self
)
1951 record_full_goto_end (self
);
1955 init_record_full_ops (void)
1957 record_full_ops
.to_shortname
= "record-full";
1958 record_full_ops
.to_longname
= "Process record and replay target";
1959 record_full_ops
.to_doc
=
1960 "Log program while executing and replay execution from log.";
1961 record_full_ops
.to_open
= record_full_open
;
1962 record_full_ops
.to_close
= record_full_close
;
1963 record_full_ops
.to_async
= record_full_async
;
1964 record_full_ops
.to_resume
= record_full_resume
;
1965 record_full_ops
.to_wait
= record_full_wait
;
1966 record_full_ops
.to_disconnect
= record_disconnect
;
1967 record_full_ops
.to_detach
= record_detach
;
1968 record_full_ops
.to_mourn_inferior
= record_mourn_inferior
;
1969 record_full_ops
.to_kill
= record_kill
;
1970 record_full_ops
.to_store_registers
= record_full_store_registers
;
1971 record_full_ops
.to_xfer_partial
= record_full_xfer_partial
;
1972 record_full_ops
.to_insert_breakpoint
= record_full_insert_breakpoint
;
1973 record_full_ops
.to_remove_breakpoint
= record_full_remove_breakpoint
;
1974 record_full_ops
.to_stopped_by_watchpoint
= record_full_stopped_by_watchpoint
;
1975 record_full_ops
.to_stopped_data_address
= record_full_stopped_data_address
;
1976 record_full_ops
.to_stopped_by_sw_breakpoint
1977 = record_full_stopped_by_sw_breakpoint
;
1978 record_full_ops
.to_supports_stopped_by_sw_breakpoint
1979 = record_full_supports_stopped_by_sw_breakpoint
;
1980 record_full_ops
.to_stopped_by_hw_breakpoint
1981 = record_full_stopped_by_hw_breakpoint
;
1982 record_full_ops
.to_supports_stopped_by_hw_breakpoint
1983 = record_full_supports_stopped_by_hw_breakpoint
;
1984 record_full_ops
.to_can_execute_reverse
= record_full_can_execute_reverse
;
1985 record_full_ops
.to_stratum
= record_stratum
;
1986 /* Add bookmark target methods. */
1987 record_full_ops
.to_get_bookmark
= record_full_get_bookmark
;
1988 record_full_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
1989 record_full_ops
.to_execution_direction
= record_full_execution_direction
;
1990 record_full_ops
.to_info_record
= record_full_info
;
1991 record_full_ops
.to_save_record
= record_full_save
;
1992 record_full_ops
.to_delete_record
= record_full_delete
;
1993 record_full_ops
.to_record_is_replaying
= record_full_is_replaying
;
1994 record_full_ops
.to_record_will_replay
= record_full_will_replay
;
1995 record_full_ops
.to_record_stop_replaying
= record_full_stop_replaying
;
1996 record_full_ops
.to_goto_record_begin
= record_full_goto_begin
;
1997 record_full_ops
.to_goto_record_end
= record_full_goto_end
;
1998 record_full_ops
.to_goto_record
= record_full_goto
;
1999 record_full_ops
.to_magic
= OPS_MAGIC
;
2002 /* "to_resume" method for prec over corefile. */
2005 record_full_core_resume (struct target_ops
*ops
, ptid_t ptid
, int step
,
2006 enum gdb_signal signal
)
2008 record_full_resume_step
= step
;
2009 record_full_resumed
= 1;
2010 record_full_execution_dir
= execution_direction
;
2012 /* We are about to start executing the inferior (or simulate it),
2013 let's register it with the event loop. */
2014 if (target_can_async_p ())
2018 /* "to_kill" method for prec over corefile. */
2021 record_full_core_kill (struct target_ops
*ops
)
2024 fprintf_unfiltered (gdb_stdlog
, "Process record: record_full_core_kill\n");
2026 unpush_target (&record_full_core_ops
);
2029 /* "to_fetch_registers" method for prec over corefile. */
2032 record_full_core_fetch_registers (struct target_ops
*ops
,
2033 struct regcache
*regcache
,
2038 int num
= gdbarch_num_regs (get_regcache_arch (regcache
));
2041 for (i
= 0; i
< num
; i
++)
2042 regcache_raw_supply (regcache
, i
,
2043 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* i
);
2046 regcache_raw_supply (regcache
, regno
,
2047 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
2050 /* "to_prepare_to_store" method for prec over corefile. */
2053 record_full_core_prepare_to_store (struct target_ops
*self
,
2054 struct regcache
*regcache
)
2058 /* "to_store_registers" method for prec over corefile. */
2061 record_full_core_store_registers (struct target_ops
*ops
,
2062 struct regcache
*regcache
,
2065 if (record_full_gdb_operation_disable
)
2066 regcache_raw_collect (regcache
, regno
,
2067 record_full_core_regbuf
+ MAX_REGISTER_SIZE
* regno
);
2069 error (_("You can't do that without a process to debug."));
2072 /* "to_xfer_partial" method for prec over corefile. */
2074 static enum target_xfer_status
2075 record_full_core_xfer_partial (struct target_ops
*ops
,
2076 enum target_object object
,
2077 const char *annex
, gdb_byte
*readbuf
,
2078 const gdb_byte
*writebuf
, ULONGEST offset
,
2079 ULONGEST len
, ULONGEST
*xfered_len
)
2081 if (object
== TARGET_OBJECT_MEMORY
)
2083 if (record_full_gdb_operation_disable
|| !writebuf
)
2085 struct target_section
*p
;
2087 for (p
= record_full_core_start
; p
< record_full_core_end
; p
++)
2089 if (offset
>= p
->addr
)
2091 struct record_full_core_buf_entry
*entry
;
2092 ULONGEST sec_offset
;
2094 if (offset
>= p
->endaddr
)
2097 if (offset
+ len
> p
->endaddr
)
2098 len
= p
->endaddr
- offset
;
2100 sec_offset
= offset
- p
->addr
;
2102 /* Read readbuf or write writebuf p, offset, len. */
2104 if (p
->the_bfd_section
->flags
& SEC_CONSTRUCTOR
2105 || (p
->the_bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0)
2108 memset (readbuf
, 0, len
);
2111 return TARGET_XFER_OK
;
2113 /* Get record_full_core_buf_entry. */
2114 for (entry
= record_full_core_buf_list
; entry
;
2115 entry
= entry
->prev
)
2122 /* Add a new entry. */
2123 entry
= XNEW (struct record_full_core_buf_entry
);
2125 if (!bfd_malloc_and_get_section
2126 (p
->the_bfd_section
->owner
,
2131 return TARGET_XFER_EOF
;
2133 entry
->prev
= record_full_core_buf_list
;
2134 record_full_core_buf_list
= entry
;
2137 memcpy (entry
->buf
+ sec_offset
, writebuf
,
2143 return ops
->beneath
->to_xfer_partial (ops
->beneath
,
2149 memcpy (readbuf
, entry
->buf
+ sec_offset
,
2154 return TARGET_XFER_OK
;
2158 return TARGET_XFER_E_IO
;
2161 error (_("You can't do that without a process to debug."));
2164 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2165 readbuf
, writebuf
, offset
, len
,
2169 /* "to_insert_breakpoint" method for prec over corefile. */
2172 record_full_core_insert_breakpoint (struct target_ops
*ops
,
2173 struct gdbarch
*gdbarch
,
2174 struct bp_target_info
*bp_tgt
)
2179 /* "to_remove_breakpoint" method for prec over corefile. */
2182 record_full_core_remove_breakpoint (struct target_ops
*ops
,
2183 struct gdbarch
*gdbarch
,
2184 struct bp_target_info
*bp_tgt
)
2189 /* "to_has_execution" method for prec over corefile. */
2192 record_full_core_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
2198 init_record_full_core_ops (void)
2200 record_full_core_ops
.to_shortname
= "record-core";
2201 record_full_core_ops
.to_longname
= "Process record and replay target";
2202 record_full_core_ops
.to_doc
=
2203 "Log program while executing and replay execution from log.";
2204 record_full_core_ops
.to_open
= record_full_open
;
2205 record_full_core_ops
.to_close
= record_full_close
;
2206 record_full_core_ops
.to_async
= record_full_async
;
2207 record_full_core_ops
.to_resume
= record_full_core_resume
;
2208 record_full_core_ops
.to_wait
= record_full_wait
;
2209 record_full_core_ops
.to_kill
= record_full_core_kill
;
2210 record_full_core_ops
.to_fetch_registers
= record_full_core_fetch_registers
;
2211 record_full_core_ops
.to_prepare_to_store
= record_full_core_prepare_to_store
;
2212 record_full_core_ops
.to_store_registers
= record_full_core_store_registers
;
2213 record_full_core_ops
.to_xfer_partial
= record_full_core_xfer_partial
;
2214 record_full_core_ops
.to_insert_breakpoint
2215 = record_full_core_insert_breakpoint
;
2216 record_full_core_ops
.to_remove_breakpoint
2217 = record_full_core_remove_breakpoint
;
2218 record_full_core_ops
.to_stopped_by_watchpoint
2219 = record_full_stopped_by_watchpoint
;
2220 record_full_core_ops
.to_stopped_data_address
2221 = record_full_stopped_data_address
;
2222 record_full_core_ops
.to_stopped_by_sw_breakpoint
2223 = record_full_stopped_by_sw_breakpoint
;
2224 record_full_core_ops
.to_supports_stopped_by_sw_breakpoint
2225 = record_full_supports_stopped_by_sw_breakpoint
;
2226 record_full_core_ops
.to_stopped_by_hw_breakpoint
2227 = record_full_stopped_by_hw_breakpoint
;
2228 record_full_core_ops
.to_supports_stopped_by_hw_breakpoint
2229 = record_full_supports_stopped_by_hw_breakpoint
;
2230 record_full_core_ops
.to_can_execute_reverse
2231 = record_full_can_execute_reverse
;
2232 record_full_core_ops
.to_has_execution
= record_full_core_has_execution
;
2233 record_full_core_ops
.to_stratum
= record_stratum
;
2234 /* Add bookmark target methods. */
2235 record_full_core_ops
.to_get_bookmark
= record_full_get_bookmark
;
2236 record_full_core_ops
.to_goto_bookmark
= record_full_goto_bookmark
;
2237 record_full_core_ops
.to_execution_direction
2238 = record_full_execution_direction
;
2239 record_full_core_ops
.to_info_record
= record_full_info
;
2240 record_full_core_ops
.to_delete_record
= record_full_delete
;
2241 record_full_core_ops
.to_record_is_replaying
= record_full_is_replaying
;
2242 record_full_core_ops
.to_record_will_replay
= record_full_will_replay
;
2243 record_full_core_ops
.to_goto_record_begin
= record_full_goto_begin
;
2244 record_full_core_ops
.to_goto_record_end
= record_full_goto_end
;
2245 record_full_core_ops
.to_goto_record
= record_full_goto
;
2246 record_full_core_ops
.to_magic
= OPS_MAGIC
;
2249 /* Record log save-file format
2250 Version 1 (never released)
2253 4 bytes: magic number htonl(0x20090829).
2254 NOTE: be sure to change whenever this file format changes!
2258 1 byte: record type (record_full_end, see enum record_full_type).
2260 1 byte: record type (record_full_reg, see enum record_full_type).
2261 8 bytes: register id (network byte order).
2262 MAX_REGISTER_SIZE bytes: register value.
2264 1 byte: record type (record_full_mem, see enum record_full_type).
2265 8 bytes: memory length (network byte order).
2266 8 bytes: memory address (network byte order).
2267 n bytes: memory value (n == memory length).
2270 4 bytes: magic number netorder32(0x20091016).
2271 NOTE: be sure to change whenever this file format changes!
2275 1 byte: record type (record_full_end, see enum record_full_type).
2277 4 bytes: instruction count
2279 1 byte: record type (record_full_reg, see enum record_full_type).
2280 4 bytes: register id (network byte order).
2281 n bytes: register value (n == actual register size).
2282 (eg. 4 bytes for x86 general registers).
2284 1 byte: record type (record_full_mem, see enum record_full_type).
2285 4 bytes: memory length (network byte order).
2286 8 bytes: memory address (network byte order).
2287 n bytes: memory value (n == memory length).
2291 /* bfdcore_read -- read bytes from a core file section. */
2294 bfdcore_read (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2296 int ret
= bfd_get_section_contents (obfd
, osec
, buf
, *offset
, len
);
2301 error (_("Failed to read %d bytes from core file %s ('%s')."),
2302 len
, bfd_get_filename (obfd
),
2303 bfd_errmsg (bfd_get_error ()));
2306 static inline uint64_t
2307 netorder64 (uint64_t input
)
2311 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2312 BFD_ENDIAN_BIG
, input
);
2316 static inline uint32_t
2317 netorder32 (uint32_t input
)
2321 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2322 BFD_ENDIAN_BIG
, input
);
2326 static inline uint16_t
2327 netorder16 (uint16_t input
)
2331 store_unsigned_integer ((gdb_byte
*) &ret
, sizeof (ret
),
2332 BFD_ENDIAN_BIG
, input
);
2336 /* Restore the execution log from a core_bfd file. */
2338 record_full_restore (void)
2341 struct cleanup
*old_cleanups
;
2342 struct record_full_entry
*rec
;
2346 struct regcache
*regcache
;
2348 /* We restore the execution log from the open core bfd,
2350 if (core_bfd
== NULL
)
2353 /* "record_full_restore" can only be called when record list is empty. */
2354 gdb_assert (record_full_first
.next
== NULL
);
2357 fprintf_unfiltered (gdb_stdlog
, "Restoring recording from core file.\n");
2359 /* Now need to find our special note section. */
2360 osec
= bfd_get_section_by_name (core_bfd
, "null0");
2362 fprintf_unfiltered (gdb_stdlog
, "Find precord section %s.\n",
2363 osec
? "succeeded" : "failed");
2366 osec_size
= bfd_section_size (core_bfd
, osec
);
2368 fprintf_unfiltered (gdb_stdlog
, "%s", bfd_section_name (core_bfd
, osec
));
2370 /* Check the magic code. */
2371 bfdcore_read (core_bfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2372 if (magic
!= RECORD_FULL_FILE_MAGIC
)
2373 error (_("Version mis-match or file format error in core file %s."),
2374 bfd_get_filename (core_bfd
));
2376 fprintf_unfiltered (gdb_stdlog
,
2377 " Reading 4-byte magic cookie "
2378 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2379 phex_nz (netorder32 (magic
), 4));
2381 /* Restore the entries in recfd into record_full_arch_list_head and
2382 record_full_arch_list_tail. */
2383 record_full_arch_list_head
= NULL
;
2384 record_full_arch_list_tail
= NULL
;
2385 record_full_insn_num
= 0;
2386 old_cleanups
= make_cleanup (record_full_arch_list_cleanups
, 0);
2387 regcache
= get_current_regcache ();
2392 uint32_t regnum
, len
, signal
, count
;
2395 /* We are finished when offset reaches osec_size. */
2396 if (bfd_offset
>= osec_size
)
2398 bfdcore_read (core_bfd
, osec
, &rectype
, sizeof (rectype
), &bfd_offset
);
2402 case record_full_reg
: /* reg */
2403 /* Get register number to regnum. */
2404 bfdcore_read (core_bfd
, osec
, ®num
,
2405 sizeof (regnum
), &bfd_offset
);
2406 regnum
= netorder32 (regnum
);
2408 rec
= record_full_reg_alloc (regcache
, regnum
);
2411 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2412 rec
->u
.reg
.len
, &bfd_offset
);
2415 fprintf_unfiltered (gdb_stdlog
,
2416 " Reading register %d (1 "
2417 "plus %lu plus %d bytes)\n",
2419 (unsigned long) sizeof (regnum
),
2423 case record_full_mem
: /* mem */
2425 bfdcore_read (core_bfd
, osec
, &len
,
2426 sizeof (len
), &bfd_offset
);
2427 len
= netorder32 (len
);
2430 bfdcore_read (core_bfd
, osec
, &addr
,
2431 sizeof (addr
), &bfd_offset
);
2432 addr
= netorder64 (addr
);
2434 rec
= record_full_mem_alloc (addr
, len
);
2437 bfdcore_read (core_bfd
, osec
, record_full_get_loc (rec
),
2438 rec
->u
.mem
.len
, &bfd_offset
);
2441 fprintf_unfiltered (gdb_stdlog
,
2442 " Reading memory %s (1 plus "
2443 "%lu plus %lu plus %d bytes)\n",
2444 paddress (get_current_arch (),
2446 (unsigned long) sizeof (addr
),
2447 (unsigned long) sizeof (len
),
2451 case record_full_end
: /* end */
2452 rec
= record_full_end_alloc ();
2453 record_full_insn_num
++;
2455 /* Get signal value. */
2456 bfdcore_read (core_bfd
, osec
, &signal
,
2457 sizeof (signal
), &bfd_offset
);
2458 signal
= netorder32 (signal
);
2459 rec
->u
.end
.sigval
= (enum gdb_signal
) signal
;
2461 /* Get insn count. */
2462 bfdcore_read (core_bfd
, osec
, &count
,
2463 sizeof (count
), &bfd_offset
);
2464 count
= netorder32 (count
);
2465 rec
->u
.end
.insn_num
= count
;
2466 record_full_insn_count
= count
+ 1;
2468 fprintf_unfiltered (gdb_stdlog
,
2469 " Reading record_full_end (1 + "
2470 "%lu + %lu bytes), offset == %s\n",
2471 (unsigned long) sizeof (signal
),
2472 (unsigned long) sizeof (count
),
2473 paddress (get_current_arch (),
2478 error (_("Bad entry type in core file %s."),
2479 bfd_get_filename (core_bfd
));
2483 /* Add rec to record arch list. */
2484 record_full_arch_list_add (rec
);
2487 discard_cleanups (old_cleanups
);
2489 /* Add record_full_arch_list_head to the end of record list. */
2490 record_full_first
.next
= record_full_arch_list_head
;
2491 record_full_arch_list_head
->prev
= &record_full_first
;
2492 record_full_arch_list_tail
->next
= NULL
;
2493 record_full_list
= &record_full_first
;
2495 /* Update record_full_insn_max_num. */
2496 if (record_full_insn_num
> record_full_insn_max_num
)
2498 record_full_insn_max_num
= record_full_insn_num
;
2499 warning (_("Auto increase record/replay buffer limit to %u."),
2500 record_full_insn_max_num
);
2504 printf_filtered (_("Restored records from core file %s.\n"),
2505 bfd_get_filename (core_bfd
));
2507 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2510 /* bfdcore_write -- write bytes into a core file section. */
2513 bfdcore_write (bfd
*obfd
, asection
*osec
, void *buf
, int len
, int *offset
)
2515 int ret
= bfd_set_section_contents (obfd
, osec
, buf
, *offset
, len
);
2520 error (_("Failed to write %d bytes to core file %s ('%s')."),
2521 len
, bfd_get_filename (obfd
),
2522 bfd_errmsg (bfd_get_error ()));
2525 /* Restore the execution log from a file. We use a modified elf
2526 corefile format, with an extra section for our data. */
2529 cmd_record_full_restore (char *args
, int from_tty
)
2531 core_file_command (args
, from_tty
);
2532 record_full_open (args
, from_tty
);
2536 record_full_save_cleanups (void *data
)
2538 bfd
*obfd
= (bfd
*) data
;
2539 char *pathname
= xstrdup (bfd_get_filename (obfd
));
2541 gdb_bfd_unref (obfd
);
2546 /* Save the execution log to a file. We use a modified elf corefile
2547 format, with an extra section for our data. */
2550 record_full_save (struct target_ops
*self
, const char *recfilename
)
2552 struct record_full_entry
*cur_record_full_list
;
2554 struct regcache
*regcache
;
2555 struct gdbarch
*gdbarch
;
2556 struct cleanup
*old_cleanups
;
2557 struct cleanup
*set_cleanups
;
2560 asection
*osec
= NULL
;
2563 /* Open the save file. */
2565 fprintf_unfiltered (gdb_stdlog
, "Saving execution log to core file '%s'\n",
2568 /* Open the output file. */
2569 obfd
= create_gcore_bfd (recfilename
);
2570 old_cleanups
= make_cleanup (record_full_save_cleanups
, obfd
);
2572 /* Save the current record entry to "cur_record_full_list". */
2573 cur_record_full_list
= record_full_list
;
2575 /* Get the values of regcache and gdbarch. */
2576 regcache
= get_current_regcache ();
2577 gdbarch
= get_regcache_arch (regcache
);
2579 /* Disable the GDB operation record. */
2580 set_cleanups
= record_full_gdb_operation_disable_set ();
2582 /* Reverse execute to the begin of record list. */
2585 /* Check for beginning and end of log. */
2586 if (record_full_list
== &record_full_first
)
2589 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2591 if (record_full_list
->prev
)
2592 record_full_list
= record_full_list
->prev
;
2595 /* Compute the size needed for the extra bfd section. */
2596 save_size
= 4; /* magic cookie */
2597 for (record_full_list
= record_full_first
.next
; record_full_list
;
2598 record_full_list
= record_full_list
->next
)
2599 switch (record_full_list
->type
)
2601 case record_full_end
:
2602 save_size
+= 1 + 4 + 4;
2604 case record_full_reg
:
2605 save_size
+= 1 + 4 + record_full_list
->u
.reg
.len
;
2607 case record_full_mem
:
2608 save_size
+= 1 + 4 + 8 + record_full_list
->u
.mem
.len
;
2612 /* Make the new bfd section. */
2613 osec
= bfd_make_section_anyway_with_flags (obfd
, "precord",
2617 error (_("Failed to create 'precord' section for corefile %s: %s"),
2619 bfd_errmsg (bfd_get_error ()));
2620 bfd_set_section_size (obfd
, osec
, save_size
);
2621 bfd_set_section_vma (obfd
, osec
, 0);
2622 bfd_set_section_alignment (obfd
, osec
, 0);
2623 bfd_section_lma (obfd
, osec
) = 0;
2625 /* Save corefile state. */
2626 write_gcore_file (obfd
);
2628 /* Write out the record log. */
2629 /* Write the magic code. */
2630 magic
= RECORD_FULL_FILE_MAGIC
;
2632 fprintf_unfiltered (gdb_stdlog
,
2633 " Writing 4-byte magic cookie "
2634 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2635 phex_nz (magic
, 4));
2636 bfdcore_write (obfd
, osec
, &magic
, sizeof (magic
), &bfd_offset
);
2638 /* Save the entries to recfd and forward execute to the end of
2640 record_full_list
= &record_full_first
;
2644 if (record_full_list
!= &record_full_first
)
2647 uint32_t regnum
, len
, signal
, count
;
2650 type
= record_full_list
->type
;
2651 bfdcore_write (obfd
, osec
, &type
, sizeof (type
), &bfd_offset
);
2653 switch (record_full_list
->type
)
2655 case record_full_reg
: /* reg */
2657 fprintf_unfiltered (gdb_stdlog
,
2658 " Writing register %d (1 "
2659 "plus %lu plus %d bytes)\n",
2660 record_full_list
->u
.reg
.num
,
2661 (unsigned long) sizeof (regnum
),
2662 record_full_list
->u
.reg
.len
);
2665 regnum
= netorder32 (record_full_list
->u
.reg
.num
);
2666 bfdcore_write (obfd
, osec
, ®num
,
2667 sizeof (regnum
), &bfd_offset
);
2670 bfdcore_write (obfd
, osec
,
2671 record_full_get_loc (record_full_list
),
2672 record_full_list
->u
.reg
.len
, &bfd_offset
);
2675 case record_full_mem
: /* mem */
2677 fprintf_unfiltered (gdb_stdlog
,
2678 " Writing memory %s (1 plus "
2679 "%lu plus %lu plus %d bytes)\n",
2681 record_full_list
->u
.mem
.addr
),
2682 (unsigned long) sizeof (addr
),
2683 (unsigned long) sizeof (len
),
2684 record_full_list
->u
.mem
.len
);
2687 len
= netorder32 (record_full_list
->u
.mem
.len
);
2688 bfdcore_write (obfd
, osec
, &len
, sizeof (len
), &bfd_offset
);
2690 /* Write memaddr. */
2691 addr
= netorder64 (record_full_list
->u
.mem
.addr
);
2692 bfdcore_write (obfd
, osec
, &addr
,
2693 sizeof (addr
), &bfd_offset
);
2696 bfdcore_write (obfd
, osec
,
2697 record_full_get_loc (record_full_list
),
2698 record_full_list
->u
.mem
.len
, &bfd_offset
);
2701 case record_full_end
:
2703 fprintf_unfiltered (gdb_stdlog
,
2704 " Writing record_full_end (1 + "
2705 "%lu + %lu bytes)\n",
2706 (unsigned long) sizeof (signal
),
2707 (unsigned long) sizeof (count
));
2708 /* Write signal value. */
2709 signal
= netorder32 (record_full_list
->u
.end
.sigval
);
2710 bfdcore_write (obfd
, osec
, &signal
,
2711 sizeof (signal
), &bfd_offset
);
2713 /* Write insn count. */
2714 count
= netorder32 (record_full_list
->u
.end
.insn_num
);
2715 bfdcore_write (obfd
, osec
, &count
,
2716 sizeof (count
), &bfd_offset
);
2721 /* Execute entry. */
2722 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2724 if (record_full_list
->next
)
2725 record_full_list
= record_full_list
->next
;
2730 /* Reverse execute to cur_record_full_list. */
2733 /* Check for beginning and end of log. */
2734 if (record_full_list
== cur_record_full_list
)
2737 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2739 if (record_full_list
->prev
)
2740 record_full_list
= record_full_list
->prev
;
2743 do_cleanups (set_cleanups
);
2744 gdb_bfd_unref (obfd
);
2745 discard_cleanups (old_cleanups
);
2748 printf_filtered (_("Saved core file %s with execution log.\n"),
2752 /* record_full_goto_insn -- rewind the record log (forward or backward,
2753 depending on DIR) to the given entry, changing the program state
2757 record_full_goto_insn (struct record_full_entry
*entry
,
2758 enum exec_direction_kind dir
)
2760 struct cleanup
*set_cleanups
= record_full_gdb_operation_disable_set ();
2761 struct regcache
*regcache
= get_current_regcache ();
2762 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2764 /* Assume everything is valid: we will hit the entry,
2765 and we will not hit the end of the recording. */
2767 if (dir
== EXEC_FORWARD
)
2768 record_full_list
= record_full_list
->next
;
2772 record_full_exec_insn (regcache
, gdbarch
, record_full_list
);
2773 if (dir
== EXEC_REVERSE
)
2774 record_full_list
= record_full_list
->prev
;
2776 record_full_list
= record_full_list
->next
;
2777 } while (record_full_list
!= entry
);
2778 do_cleanups (set_cleanups
);
2781 /* Alias for "target record-full". */
2784 cmd_record_full_start (char *args
, int from_tty
)
2786 execute_command ("target record-full", from_tty
);
2790 set_record_full_insn_max_num (char *args
, int from_tty
,
2791 struct cmd_list_element
*c
)
2793 if (record_full_insn_num
> record_full_insn_max_num
)
2795 /* Count down record_full_insn_num while releasing records from list. */
2796 while (record_full_insn_num
> record_full_insn_max_num
)
2798 record_full_list_release_first ();
2799 record_full_insn_num
--;
2804 /* The "set record full" command. */
2807 set_record_full_command (char *args
, int from_tty
)
2809 printf_unfiltered (_("\"set record full\" must be followed "
2810 "by an apporpriate subcommand.\n"));
2811 help_list (set_record_full_cmdlist
, "set record full ", all_commands
,
2815 /* The "show record full" command. */
2818 show_record_full_command (char *args
, int from_tty
)
2820 cmd_show_list (show_record_full_cmdlist
, from_tty
, "");
2823 /* Provide a prototype to silence -Wmissing-prototypes. */
2824 extern initialize_file_ftype _initialize_record_full
;
2827 _initialize_record_full (void)
2829 struct cmd_list_element
*c
;
2831 /* Init record_full_first. */
2832 record_full_first
.prev
= NULL
;
2833 record_full_first
.next
= NULL
;
2834 record_full_first
.type
= record_full_end
;
2836 init_record_full_ops ();
2837 add_target (&record_full_ops
);
2838 add_deprecated_target_alias (&record_full_ops
, "record");
2839 init_record_full_core_ops ();
2840 add_target (&record_full_core_ops
);
2842 add_prefix_cmd ("full", class_obscure
, cmd_record_full_start
,
2843 _("Start full execution recording."), &record_full_cmdlist
,
2844 "record full ", 0, &record_cmdlist
);
2846 c
= add_cmd ("restore", class_obscure
, cmd_record_full_restore
,
2847 _("Restore the execution log from a file.\n\
2848 Argument is filename. File must be created with 'record save'."),
2849 &record_full_cmdlist
);
2850 set_cmd_completer (c
, filename_completer
);
2852 /* Deprecate the old version without "full" prefix. */
2853 c
= add_alias_cmd ("restore", "full restore", class_obscure
, 1,
2855 set_cmd_completer (c
, filename_completer
);
2856 deprecate_cmd (c
, "record full restore");
2858 add_prefix_cmd ("full", class_support
, set_record_full_command
,
2859 _("Set record options"), &set_record_full_cmdlist
,
2860 "set record full ", 0, &set_record_cmdlist
);
2862 add_prefix_cmd ("full", class_support
, show_record_full_command
,
2863 _("Show record options"), &show_record_full_cmdlist
,
2864 "show record full ", 0, &show_record_cmdlist
);
2866 /* Record instructions number limit command. */
2867 add_setshow_boolean_cmd ("stop-at-limit", no_class
,
2868 &record_full_stop_at_limit
, _("\
2869 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2870 Show whether record/replay stops when record/replay buffer becomes full."),
2871 _("Default is ON.\n\
2872 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2873 When OFF, if the record/replay buffer becomes full,\n\
2874 delete the oldest recorded instruction to make room for each new one."),
2876 &set_record_full_cmdlist
, &show_record_full_cmdlist
);
2878 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2879 &set_record_cmdlist
);
2880 deprecate_cmd (c
, "set record full stop-at-limit");
2882 c
= add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class
, 1,
2883 &show_record_cmdlist
);
2884 deprecate_cmd (c
, "show record full stop-at-limit");
2886 add_setshow_uinteger_cmd ("insn-number-max", no_class
,
2887 &record_full_insn_max_num
,
2888 _("Set record/replay buffer limit."),
2889 _("Show record/replay buffer limit."), _("\
2890 Set the maximum number of instructions to be stored in the\n\
2891 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2892 limit. Default is 200000."),
2893 set_record_full_insn_max_num
,
2894 NULL
, &set_record_full_cmdlist
,
2895 &show_record_full_cmdlist
);
2897 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2898 &set_record_cmdlist
);
2899 deprecate_cmd (c
, "set record full insn-number-max");
2901 c
= add_alias_cmd ("insn-number-max", "full insn-number-max", no_class
, 1,
2902 &show_record_cmdlist
);
2903 deprecate_cmd (c
, "show record full insn-number-max");
2905 add_setshow_boolean_cmd ("memory-query", no_class
,
2906 &record_full_memory_query
, _("\
2907 Set whether query if PREC cannot record memory change of next instruction."),
2909 Show whether query if PREC cannot record memory change of next instruction."),
2912 When ON, query if PREC cannot record memory change of next instruction."),
2914 &set_record_full_cmdlist
,
2915 &show_record_full_cmdlist
);
2917 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2918 &set_record_cmdlist
);
2919 deprecate_cmd (c
, "set record full memory-query");
2921 c
= add_alias_cmd ("memory-query", "full memory-query", no_class
, 1,
2922 &show_record_cmdlist
);
2923 deprecate_cmd (c
, "show record full memory-query");