GDB (xrefs)
/tmp/gdb-7.10/gdb/record-full.c
Go to the documentation of this file.
1 /* Process record and replay target for GDB, the GNU debugger.
2 
3  Copyright (C) 2013-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
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.
11 
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.
16 
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/>. */
19 
20 #include "defs.h"
21 #include "gdbcmd.h"
22 #include "regcache.h"
23 #include "gdbthread.h"
24 #include "event-top.h"
25 #include "completer.h"
26 #include "arch-utils.h"
27 #include "gdbcore.h"
28 #include "exec.h"
29 #include "record.h"
30 #include "record-full.h"
31 #include "elf-bfd.h"
32 #include "gcore.h"
33 #include "event-loop.h"
34 #include "inf-loop.h"
35 #include "gdb_bfd.h"
36 #include "observer.h"
37 #include "infrun.h"
38 
39 #include <signal.h>
40 
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.
45 
46  Target record has two modes: recording, and replaying.
47 
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).
54 
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. */
60 
61 #define DEFAULT_RECORD_FULL_INSN_MAX_NUM 200000
62 
63 #define RECORD_FULL_IS_REPLAY \
64  (record_full_list->next || execution_direction == EXEC_REVERSE)
65 
66 #define RECORD_FULL_FILE_MAGIC netorder32(0x20091016)
67 
68 /* These are the core structs of the process record functionality.
69 
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
74  instruction.
75 
76  Each struct record_full_entry is linked to "record_full_list" by "prev"
77  and "next" pointers. */
78 
80 {
82  int len;
83  /* Set this flag if target memory for this entry
84  can no longer be accessed. */
86  union
87  {
89  gdb_byte buf[sizeof (gdb_byte *)];
90  } u;
91 };
92 
94 {
95  unsigned short num;
96  unsigned short len;
97  union
98  {
100  gdb_byte buf[2 * sizeof (gdb_byte *)];
101  } u;
102 };
103 
105 {
106  enum gdb_signal sigval;
108 };
109 
111 {
115 };
116 
117 /* This is the data structure that makes up the execution log.
118 
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.
122 
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).
127 
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.
132 
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. */
140 
142 {
146  union
147  {
148  /* reg */
150  /* mem */
152  /* end */
154  } u;
155 };
156 
157 /* If true, query if PREC cannot record memory
158  change of next instruction. */
160 
162 {
164  struct target_section *p;
165  bfd_byte *buf;
166 };
167 
168 /* Record buf with core target. */
172 static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
173 
174 /* The following variables are used for managing the linked list that
175  represents the execution log.
176 
177  record_full_first is the anchor that holds down the beginning of
178  the list.
179 
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.
184 
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. */
190 
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;
195 
196 /* 1 ask user. 0 auto delete the last struct record_full_entry. */
198 /* Maximum allowed number of insns in execution log. */
199 static unsigned int 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). */
206 
207 /* The target_ops of process record. */
210 
211 /* See record-full.h. */
212 
213 int
215 {
216  struct target_ops *t;
217 
218  t = find_record_target ();
219  return (t == &record_full_ops
220  || t == &record_full_core_ops);
221 }
222 
223 
224 /* Command lists for "set/show record full". */
227 
228 /* Command list for "record full". */
230 
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);
235 
236 /* Alloc and free functions for record_full_reg, record_full_mem, and
237  record_full_end entries. */
238 
239 /* Alloc a record_full_reg record entry. */
240 
241 static inline struct record_full_entry *
243 {
244  struct record_full_entry *rec;
245  struct gdbarch *gdbarch = get_regcache_arch (regcache);
246 
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);
253 
254  return rec;
255 }
256 
257 /* Free a record_full_reg record entry. */
258 
259 static inline void
261 {
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);
265  xfree (rec);
266 }
267 
268 /* Alloc a record_full_mem record entry. */
269 
270 static inline struct record_full_entry *
272 {
273  struct record_full_entry *rec;
274 
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);
281 
282  return rec;
283 }
284 
285 /* Free a record_full_mem record entry. */
286 
287 static inline void
289 {
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);
293  xfree (rec);
294 }
295 
296 /* Alloc a record_full_end record entry. */
297 
298 static inline struct record_full_entry *
300 {
301  struct record_full_entry *rec;
302 
303  rec = xcalloc (1, sizeof (struct record_full_entry));
304  rec->type = record_full_end;
305 
306  return rec;
307 }
308 
309 /* Free a record_full_end record entry. */
310 
311 static inline void
313 {
314  xfree (rec);
315 }
316 
317 /* Free one record entry, any type.
318  Return entry->type, in case caller wants to know. */
319 
320 static inline enum record_full_type
322 {
323  enum record_full_type type = rec->type;
324 
325  switch (type) {
326  case record_full_reg:
328  break;
329  case record_full_mem:
331  break;
332  case record_full_end:
334  break;
335  }
336  return type;
337 }
338 
339 /* Free all record entries in list pointed to by REC. */
340 
341 static void
343 {
344  if (!rec)
345  return;
346 
347  while (rec->next)
348  rec = rec->next;
349 
350  while (rec->prev)
351  {
352  rec = rec->prev;
354  }
355 
356  if (rec == &record_full_first)
357  {
359  record_full_first.next = NULL;
360  }
361  else
363 }
364 
365 /* Free all record entries forward of the given list position. */
366 
367 static void
369 {
370  struct record_full_entry *tmp = rec->next;
371 
372  rec->next = NULL;
373  while (tmp)
374  {
375  rec = tmp->next;
377  {
380  }
381  tmp = rec;
382  }
383 }
384 
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.
387 
388  Note -- this function does not modify record_full_insn_num. */
389 
390 static void
392 {
393  struct record_full_entry *tmp;
394 
395  if (!record_full_first.next)
396  return;
397 
398  /* Loop until a record_full_end. */
399  while (1)
400  {
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;
405 
406  /* tmp is now isolated, and can be deleted. */
408  break; /* End loop at first record_full_end. */
409 
410  if (!record_full_first.next)
411  {
413  break; /* End loop when list is empty. */
414  }
415  }
416 }
417 
418 /* Add a struct record_full_entry to record_full_arch_list. */
419 
420 static void
422 {
423  if (record_debug > 1)
425  "Process record: record_full_arch_list_add %s.\n",
426  host_address_to_string (rec));
427 
428  if (record_full_arch_list_tail)
429  {
430  record_full_arch_list_tail->next = rec;
432  record_full_arch_list_tail = rec;
433  }
434  else
435  {
436  record_full_arch_list_head = rec;
437  record_full_arch_list_tail = rec;
438  }
439 }
440 
441 /* Return the value storage location of a record entry. */
442 static inline gdb_byte *
444 {
445  switch (rec->type) {
446  case record_full_mem:
447  if (rec->u.mem.len > sizeof (rec->u.mem.u.buf))
448  return rec->u.mem.u.ptr;
449  else
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;
454  else
455  return rec->u.reg.u.buf;
456  case record_full_end:
457  default:
458  gdb_assert_not_reached ("unexpected record_full_entry type");
459  return NULL;
460  }
461 }
462 
463 /* Record the value of a register NUM to record_full_arch_list. */
464 
465 int
467 {
468  struct record_full_entry *rec;
469 
470  if (record_debug > 1)
472  "Process record: add register num = %d to "
473  "record list.\n",
474  regnum);
475 
476  rec = record_full_reg_alloc (regcache, regnum);
477 
478  regcache_raw_read (regcache, regnum, record_full_get_loc (rec));
479 
481 
482  return 0;
483 }
484 
485 /* Record the value of a region of memory whose address is ADDR and
486  length is LEN to record_full_arch_list. */
487 
488 int
490 {
491  struct record_full_entry *rec;
492 
493  if (record_debug > 1)
495  "Process record: add mem addr = %s len = %d to "
496  "record list.\n",
497  paddress (target_gdbarch (), addr), len);
498 
499  if (!addr) /* FIXME: Why? Some arch must permit it... */
500  return 0;
501 
502  rec = record_full_mem_alloc (addr, len);
503 
504  if (record_read_memory (target_gdbarch (), addr,
505  record_full_get_loc (rec), len))
506  {
508  return -1;
509  }
510 
512 
513  return 0;
514 }
515 
516 /* Add a record_full_end type struct record_full_entry to
517  record_full_arch_list. */
518 
519 int
521 {
522  struct record_full_entry *rec;
523 
524  if (record_debug > 1)
526  "Process record: add end to arch list.\n");
527 
528  rec = record_full_end_alloc ();
529  rec->u.end.sigval = GDB_SIGNAL_0;
531 
533 
534  return 0;
535 }
536 
537 static void
538 record_full_check_insn_num (int set_terminal)
539 {
541  {
542  /* Ask user what to do. */
544  {
545  int q;
546 
547  if (set_terminal)
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)?"));
552  if (set_terminal)
554  if (q)
556  else
557  error (_("Process record: stopped by user."));
558  }
559  }
560 }
561 
562 static void
564 {
565  record_full_list_release (record_full_arch_list_tail);
566 }
567 
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. */
573 
574 static int
575 record_full_message (struct regcache *regcache, enum gdb_signal signal)
576 {
577  int ret;
578  struct gdbarch *gdbarch = get_regcache_arch (regcache);
579  struct cleanup *old_cleanups
581 
582  record_full_arch_list_head = NULL;
583  record_full_arch_list_tail = NULL;
584 
585  /* Check record_full_insn_num. */
587 
588  /* If gdb sends a signal value to target_resume,
589  save it in the 'end' field of the previous instruction.
590 
591  Maybe process record should record what really happened,
592  rather than what gdb pretends has happened.
593 
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
596  the replay mode.
597 
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).
602 
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.
606 
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 */
612  {
613  gdb_assert (record_full_list->type == record_full_end);
614  record_full_list->u.end.sigval = signal;
615  }
616 
617  if (signal == GDB_SIGNAL_0
618  || !gdbarch_process_record_signal_p (gdbarch))
619  ret = gdbarch_process_record (gdbarch,
620  regcache,
621  regcache_read_pc (regcache));
622  else
623  ret = gdbarch_process_record_signal (gdbarch,
624  regcache,
625  signal);
626 
627  if (ret > 0)
628  error (_("Process record: inferior program stopped."));
629  if (ret < 0)
630  error (_("Process record: failed to record execution log."));
631 
632  discard_cleanups (old_cleanups);
633 
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;
637 
640  else
642 
643  return 1;
644 }
645 
648  enum gdb_signal signal;
649 };
650 
651 static int
653 {
654  struct record_full_message_args *record_full_args = args;
655 
656  return record_full_message (record_full_args->regcache,
657  record_full_args->signal);
658 }
659 
660 static int
662  enum gdb_signal signal)
663 {
664  struct record_full_message_args args;
665 
666  args.regcache = regcache;
667  args.signal = signal;
668 
669  return catch_errors (record_full_message_wrapper, &args, NULL,
671 }
672 
673 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
674  doesn't need record. */
675 
677 
678 struct cleanup *
680 {
681  struct cleanup *old_cleanups = NULL;
682 
683  old_cleanups =
686 
687  return old_cleanups;
688 }
689 
690 /* Flag set to TRUE for target_stopped_by_watchpoint. */
693 
694 /* Execute one instruction from the record log. Each instruction in
695  the log will be represented by an arbitrary sequence of register
696  entries and memory entries, followed by an 'end' entry. */
697 
698 static inline void
700  struct gdbarch *gdbarch,
701  struct record_full_entry *entry)
702 {
703  switch (entry->type)
704  {
705  case record_full_reg: /* reg */
706  {
708 
709  if (record_debug > 1)
711  "Process record: record_full_reg %s to "
712  "inferior num = %d.\n",
713  host_address_to_string (entry),
714  entry->u.reg.num);
715 
716  regcache_cooked_read (regcache, entry->u.reg.num, reg);
717  regcache_cooked_write (regcache, entry->u.reg.num,
718  record_full_get_loc (entry));
719  memcpy (record_full_get_loc (entry), reg, entry->u.reg.len);
720  }
721  break;
722 
723  case record_full_mem: /* mem */
724  {
725  /* Nothing to do if the entry is flagged not_accessible. */
726  if (!entry->u.mem.mem_entry_not_accessible)
727  {
728  gdb_byte *mem = alloca (entry->u.mem.len);
729 
730  if (record_debug > 1)
732  "Process record: record_full_mem %s to "
733  "inferior addr = %s len = %d.\n",
734  host_address_to_string (entry),
735  paddress (gdbarch, entry->u.mem.addr),
736  entry->u.mem.len);
737 
738  if (record_read_memory (gdbarch,
739  entry->u.mem.addr, mem, entry->u.mem.len))
740  entry->u.mem.mem_entry_not_accessible = 1;
741  else
742  {
743  if (target_write_memory (entry->u.mem.addr,
744  record_full_get_loc (entry),
745  entry->u.mem.len))
746  {
747  entry->u.mem.mem_entry_not_accessible = 1;
748  if (record_debug)
749  warning (_("Process record: error writing memory at "
750  "addr = %s len = %d."),
751  paddress (gdbarch, entry->u.mem.addr),
752  entry->u.mem.len);
753  }
754  else
755  {
756  memcpy (record_full_get_loc (entry), mem,
757  entry->u.mem.len);
758 
759  /* We've changed memory --- check if a hardware
760  watchpoint should trap. Note that this
761  presently assumes the target beneath supports
762  continuable watchpoints. On non-continuable
763  watchpoints target, we'll want to check this
764  _before_ actually doing the memory change, and
765  not doing the change at all if the watchpoint
766  traps. */
768  (get_regcache_aspace (regcache),
769  entry->u.mem.addr, entry->u.mem.len))
771  }
772  }
773  }
774  }
775  break;
776  }
777 }
778 
779 static void record_full_restore (void);
780 
781 /* Asynchronous signal handle registered as event loop source for when
782  we have pending events ready to be passed to the core. */
783 
785 
786 static void
788 {
790 }
791 
792 /* Open the process record target. */
793 
794 static void
795 record_full_core_open_1 (const char *name, int from_tty)
796 {
798  int regnum = gdbarch_num_regs (get_regcache_arch (regcache));
799  int i;
800 
801  /* Get record_full_core_regbuf. */
802  target_fetch_registers (regcache, -1);
804  for (i = 0; i < regnum; i ++)
805  regcache_raw_collect (regcache, i,
807 
808  /* Get record_full_core_start and record_full_core_end. */
809  if (build_section_table (core_bfd, &record_full_core_start,
810  &record_full_core_end))
811  {
814  error (_("\"%s\": Can't find sections: %s"),
815  bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
816  }
817 
820 }
821 
822 /* "to_open" target method for 'live' processes. */
823 
824 static void
825 record_full_open_1 (const char *name, int from_tty)
826 {
827  if (record_debug)
828  fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
829 
830  /* check exec */
832  error (_("Process record: the program is not being run."));
833  if (non_stop)
834  error (_("Process record target can't debug inferior in non-stop mode "
835  "(non-stop)."));
836 
838  error (_("Process record: the current architecture doesn't support "
839  "record function."));
840 
842 }
843 
844 static void record_full_init_record_breakpoints (void);
845 
846 /* "to_open" target method. Open the process record target. */
847 
848 static void
849 record_full_open (const char *name, int from_tty)
850 {
851  struct target_ops *t;
852 
853  if (record_debug)
854  fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open\n");
855 
856  record_preopen ();
857 
858  /* Reset */
861  record_full_list = &record_full_first;
862  record_full_list->next = NULL;
863 
864  if (core_bfd)
865  record_full_core_open_1 (name, from_tty);
866  else
867  record_full_open_1 (name, from_tty);
868 
869  /* Register extra event sources in the event loop. */
870  record_full_async_inferior_event_token
872  NULL);
873 
875 
877 }
878 
879 /* "to_close" target method. Close the process record target. */
880 
881 static void
883 {
884  struct record_full_core_buf_entry *entry;
885 
886  if (record_debug)
887  fprintf_unfiltered (gdb_stdlog, "Process record: record_full_close\n");
888 
889  record_full_list_release (record_full_list);
890 
891  /* Release record_full_core_regbuf. */
893  {
896  }
897 
898  /* Release record_full_core_buf_list. */
899  if (record_full_core_buf_list)
900  {
901  for (entry = record_full_core_buf_list->prev; entry;
902  entry = entry->prev)
903  {
904  xfree (record_full_core_buf_list);
905  record_full_core_buf_list = entry;
906  }
907  record_full_core_buf_list = NULL;
908  }
909 
910  if (record_full_async_inferior_event_token)
911  delete_async_event_handler (&record_full_async_inferior_event_token);
912 }
913 
914 /* "to_async" target method. */
915 
916 static void
918 {
919  if (enable)
920  mark_async_event_handler (record_full_async_inferior_event_token);
921  else
922  clear_async_event_handler (record_full_async_inferior_event_token);
923 
924  ops->beneath->to_async (ops->beneath, enable);
925 }
926 
927 static int record_full_resume_step = 0;
928 
929 /* True if we've been resumed, and so each record_full_wait call should
930  advance execution. If this is false, record_full_wait will return a
931  TARGET_WAITKIND_IGNORE. */
932 static int record_full_resumed = 0;
933 
934 /* The execution direction of the last resume we got. This is
935  necessary for async mode. Vis (order is not strictly accurate):
936 
937  1. user has the global execution direction set to forward
938  2. user does a reverse-step command
939  3. record_full_resume is called with global execution direction
940  temporarily switched to reverse
941  4. GDB's execution direction is reverted back to forward
942  5. target record notifies event loop there's an event to handle
943  6. infrun asks the target which direction was it going, and switches
944  the global execution direction accordingly (to reverse)
945  7. infrun polls an event out of the record target, and handles it
946  8. GDB goes back to the event loop, and goto #4.
947 */
949 
950 /* "to_resume" target method. Resume the process record target. */
951 
952 static void
953 record_full_resume (struct target_ops *ops, ptid_t ptid, int step,
954  enum gdb_signal signal)
955 {
959 
961  {
962  struct gdbarch *gdbarch = target_thread_architecture (ptid);
963 
965 
966  if (!step)
967  {
968  /* This is not hard single step. */
969  if (!gdbarch_software_single_step_p (gdbarch))
970  {
971  /* This is a normal continue. */
972  step = 1;
973  }
974  else
975  {
976  /* This arch support soft sigle step. */
978  {
979  /* This is a soft single step. */
981  }
982  else
983  {
984  /* This is a continue.
985  Try to insert a soft single step breakpoint. */
986  if (!gdbarch_software_single_step (gdbarch,
987  get_current_frame ()))
988  {
989  /* This system don't want use soft single step.
990  Use hard sigle step. */
991  step = 1;
992  }
993  }
994  }
995  }
996 
997  /* Make sure the target beneath reports all signals. */
998  target_pass_signals (0, NULL);
999 
1000  ops->beneath->to_resume (ops->beneath, ptid, step, signal);
1001  }
1002 
1003  /* We are about to start executing the inferior (or simulate it),
1004  let's register it with the event loop. */
1005  if (target_can_async_p ())
1006  target_async (1);
1007 }
1008 
1009 static int record_full_get_sig = 0;
1010 
1011 /* SIGINT signal handler, registered by "to_wait" method. */
1012 
1013 static void
1015 {
1016  if (record_debug)
1017  fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
1018 
1019  /* It will break the running inferior in replay mode. */
1021 
1022  /* It will let record_full_wait set inferior status to get the signal
1023  SIGINT. */
1024  record_full_get_sig = 1;
1025 }
1026 
1027 static void
1029 {
1031  {
1032  if (record_full_list->next)
1033  record_full_list = record_full_list->next;
1034  }
1035  else
1036  record_full_list = record_full_list->prev;
1037 }
1038 
1039 /* "to_wait" target method for process record target.
1040 
1041  In record mode, the target is always run in singlestep mode
1042  (even when gdb says to continue). The to_wait method intercepts
1043  the stop events and determines which ones are to be passed on to
1044  gdb. Most stop events are just singlestep events that gdb is not
1045  to know about, so the to_wait method just records them and keeps
1046  singlestepping.
1047 
1048  In replay mode, this function emulates the recorded execution log,
1049  one instruction at a time (forward or backward), and determines
1050  where to stop. */
1051 
1052 static ptid_t
1055  int options)
1056 {
1057  struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
1058 
1059  if (record_debug)
1061  "Process record: record_full_wait "
1062  "record_full_resume_step = %d, "
1063  "record_full_resumed = %d, direction=%s\n",
1066  ? "forward" : "reverse");
1067 
1068  if (!record_full_resumed)
1069  {
1070  gdb_assert ((options & TARGET_WNOHANG) != 0);
1071 
1072  /* No interesting event. */
1073  status->kind = TARGET_WAITKIND_IGNORE;
1074  return minus_one_ptid;
1075  }
1076 
1077  record_full_get_sig = 0;
1078  signal (SIGINT, record_full_sig_handler);
1079 
1081 
1083  {
1085  {
1086  /* This is a single step. */
1087  return ops->beneath->to_wait (ops->beneath, ptid, status, options);
1088  }
1089  else
1090  {
1091  /* This is not a single step. */
1092  ptid_t ret;
1093  CORE_ADDR tmp_pc;
1095 
1096  while (1)
1097  {
1098  struct thread_info *tp;
1099 
1100  ret = ops->beneath->to_wait (ops->beneath, ptid, status, options);
1101  if (status->kind == TARGET_WAITKIND_IGNORE)
1102  {
1103  if (record_debug)
1105  "Process record: record_full_wait "
1106  "target beneath not done yet\n");
1107  return ret;
1108  }
1109 
1112 
1114  return ret;
1115 
1116  /* Is this a SIGTRAP? */
1117  if (status->kind == TARGET_WAITKIND_STOPPED
1118  && status->value.sig == GDB_SIGNAL_TRAP)
1119  {
1120  struct regcache *regcache;
1121  struct address_space *aspace;
1122  enum target_stop_reason *stop_reason_p
1124 
1125  /* Yes -- this is likely our single-step finishing,
1126  but check if there's any reason the core would be
1127  interested in the event. */
1128 
1129  registers_changed ();
1130  regcache = get_current_regcache ();
1131  tmp_pc = regcache_read_pc (regcache);
1132  aspace = get_regcache_aspace (regcache);
1133 
1135  {
1136  /* Always interested in watchpoints. */
1137  }
1138  else if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1139  stop_reason_p))
1140  {
1141  /* There is a breakpoint here. Let the core
1142  handle it. */
1143  }
1144  else
1145  {
1146  /* This is a single-step trap. Record the
1147  insn and issue another step.
1148  FIXME: this part can be a random SIGTRAP too.
1149  But GDB cannot handle it. */
1150  int step = 1;
1151 
1152  if (!record_full_message_wrapper_safe (regcache,
1153  GDB_SIGNAL_0))
1154  {
1155  status->kind = TARGET_WAITKIND_STOPPED;
1156  status->value.sig = GDB_SIGNAL_0;
1157  break;
1158  }
1159 
1160  if (gdbarch_software_single_step_p (gdbarch))
1161  {
1162  /* Try to insert the software single step breakpoint.
1163  If insert success, set step to 0. */
1165  reinit_frame_cache ();
1166  if (gdbarch_software_single_step (gdbarch,
1167  get_current_frame ()))
1168  step = 0;
1170  }
1171 
1172  if (record_debug)
1174  "Process record: record_full_wait "
1175  "issuing one more step in the "
1176  "target beneath\n");
1177  ops->beneath->to_resume (ops->beneath, ptid, step,
1178  GDB_SIGNAL_0);
1179  continue;
1180  }
1181  }
1182 
1183  /* The inferior is broken by a breakpoint or a signal. */
1184  break;
1185  }
1186 
1187  return ret;
1188  }
1189  }
1190  else
1191  {
1192  struct regcache *regcache = get_current_regcache ();
1193  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1194  struct address_space *aspace = get_regcache_aspace (regcache);
1195  int continue_flag = 1;
1196  int first_record_full_end = 1;
1197  struct cleanup *old_cleanups
1199  CORE_ADDR tmp_pc;
1200 
1202  status->kind = TARGET_WAITKIND_STOPPED;
1203 
1204  /* Check breakpoint when forward execute. */
1206  {
1207  tmp_pc = regcache_read_pc (regcache);
1208  if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1210  {
1211  if (record_debug)
1213  "Process record: break at %s.\n",
1214  paddress (gdbarch, tmp_pc));
1215  goto replay_out;
1216  }
1217  }
1218 
1219  /* If GDB is in terminal_inferior mode, it will not get the signal.
1220  And in GDB replay mode, GDB doesn't need to be in terminal_inferior
1221  mode, because inferior will not executed.
1222  Then set it to terminal_ours to make GDB get the signal. */
1224 
1225  /* In EXEC_FORWARD mode, record_full_list points to the tail of prev
1226  instruction. */
1227  if (execution_direction == EXEC_FORWARD && record_full_list->next)
1228  record_full_list = record_full_list->next;
1229 
1230  /* Loop over the record_full_list, looking for the next place to
1231  stop. */
1232  do
1233  {
1234  /* Check for beginning and end of log. */
1236  && record_full_list == &record_full_first)
1237  {
1238  /* Hit beginning of record log in reverse. */
1239  status->kind = TARGET_WAITKIND_NO_HISTORY;
1240  break;
1241  }
1242  if (execution_direction != EXEC_REVERSE && !record_full_list->next)
1243  {
1244  /* Hit end of record log going forward. */
1245  status->kind = TARGET_WAITKIND_NO_HISTORY;
1246  break;
1247  }
1248 
1249  record_full_exec_insn (regcache, gdbarch, record_full_list);
1250 
1251  if (record_full_list->type == record_full_end)
1252  {
1253  if (record_debug > 1)
1255  "Process record: record_full_end %s to "
1256  "inferior.\n",
1257  host_address_to_string (record_full_list));
1258 
1259  if (first_record_full_end && execution_direction == EXEC_REVERSE)
1260  {
1261  /* When reverse excute, the first record_full_end is the
1262  part of current instruction. */
1263  first_record_full_end = 0;
1264  }
1265  else
1266  {
1267  /* In EXEC_REVERSE mode, this is the record_full_end of prev
1268  instruction.
1269  In EXEC_FORWARD mode, this is the record_full_end of
1270  current instruction. */
1271  /* step */
1273  {
1274  if (record_debug > 1)
1276  "Process record: step.\n");
1277  continue_flag = 0;
1278  }
1279 
1280  /* check breakpoint */
1281  tmp_pc = regcache_read_pc (regcache);
1282  if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1284  {
1285  if (record_debug)
1287  "Process record: break "
1288  "at %s.\n",
1289  paddress (gdbarch, tmp_pc));
1290 
1291  continue_flag = 0;
1292  }
1293 
1295  {
1296  if (record_debug)
1298  "Process record: hit hw "
1299  "watchpoint.\n");
1300  continue_flag = 0;
1301  }
1302  /* Check target signal */
1303  if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1304  /* FIXME: better way to check */
1305  continue_flag = 0;
1306  }
1307  }
1308 
1309  if (continue_flag)
1310  {
1312  {
1313  if (record_full_list->prev)
1314  record_full_list = record_full_list->prev;
1315  }
1316  else
1317  {
1318  if (record_full_list->next)
1319  record_full_list = record_full_list->next;
1320  }
1321  }
1322  }
1323  while (continue_flag);
1324 
1325 replay_out:
1326  if (record_full_get_sig)
1327  status->value.sig = GDB_SIGNAL_INT;
1328  else if (record_full_list->u.end.sigval != GDB_SIGNAL_0)
1329  /* FIXME: better way to check */
1330  status->value.sig = record_full_list->u.end.sigval;
1331  else
1332  status->value.sig = GDB_SIGNAL_TRAP;
1333 
1334  discard_cleanups (old_cleanups);
1335  }
1336 
1337  signal (SIGINT, handle_sigint);
1338 
1339  do_cleanups (set_cleanups);
1340  return inferior_ptid;
1341 }
1342 
1343 static ptid_t
1346  int options)
1347 {
1348  ptid_t return_ptid;
1349 
1350  return_ptid = record_full_wait_1 (ops, ptid, status, options);
1351  if (status->kind != TARGET_WAITKIND_IGNORE)
1352  {
1353  /* We're reporting a stop. Make sure any spurious
1354  target_wait(WNOHANG) doesn't advance the target until the
1355  core wants us resumed again. */
1356  record_full_resumed = 0;
1357  }
1358  return return_ptid;
1359 }
1360 
1361 static int
1363 {
1366  else
1367  return ops->beneath->to_stopped_by_watchpoint (ops->beneath);
1368 }
1369 
1370 static int
1372 {
1374  return 0;
1375  else
1376  return ops->beneath->to_stopped_data_address (ops->beneath, addr_p);
1377 }
1378 
1379 /* The to_stopped_by_sw_breakpoint method of target record-full. */
1380 
1381 static int
1383 {
1385 }
1386 
1387 /* The to_supports_stopped_by_sw_breakpoint method of target
1388  record-full. */
1389 
1390 static int
1392 {
1393  return 1;
1394 }
1395 
1396 /* The to_stopped_by_hw_breakpoint method of target record-full. */
1397 
1398 static int
1400 {
1402 }
1403 
1404 /* The to_supports_stopped_by_sw_breakpoint method of target
1405  record-full. */
1406 
1407 static int
1409 {
1410  return 1;
1411 }
1412 
1413 /* Record registers change (by user or by GDB) to list as an instruction. */
1414 
1415 static void
1417 {
1418  /* Check record_full_insn_num. */
1420 
1421  record_full_arch_list_head = NULL;
1422  record_full_arch_list_tail = NULL;
1423 
1424  if (regnum < 0)
1425  {
1426  int i;
1427 
1428  for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
1429  {
1430  if (record_full_arch_list_add_reg (regcache, i))
1431  {
1432  record_full_list_release (record_full_arch_list_tail);
1433  error (_("Process record: failed to record execution log."));
1434  }
1435  }
1436  }
1437  else
1438  {
1439  if (record_full_arch_list_add_reg (regcache, regnum))
1440  {
1441  record_full_list_release (record_full_arch_list_tail);
1442  error (_("Process record: failed to record execution log."));
1443  }
1444  }
1446  {
1447  record_full_list_release (record_full_arch_list_tail);
1448  error (_("Process record: failed to record execution log."));
1449  }
1450  record_full_list->next = record_full_arch_list_head;
1451  record_full_arch_list_head->prev = record_full_list;
1452  record_full_list = record_full_arch_list_tail;
1453 
1456  else
1458 }
1459 
1460 /* "to_store_registers" method for process record target. */
1461 
1462 static void
1464  struct regcache *regcache,
1465  int regno)
1466 {
1468  {
1470  {
1471  int n;
1472 
1473  /* Let user choose if he wants to write register or not. */
1474  if (regno < 0)
1475  n =
1476  query (_("Because GDB is in replay mode, changing the "
1477  "value of a register will make the execution "
1478  "log unusable from this point onward. "
1479  "Change all registers?"));
1480  else
1481  n =
1482  query (_("Because GDB is in replay mode, changing the value "
1483  "of a register will make the execution log unusable "
1484  "from this point onward. Change register %s?"),
1486  regno));
1487 
1488  if (!n)
1489  {
1490  /* Invalidate the value of regcache that was set in function
1491  "regcache_raw_write". */
1492  if (regno < 0)
1493  {
1494  int i;
1495 
1496  for (i = 0;
1497  i < gdbarch_num_regs (get_regcache_arch (regcache));
1498  i++)
1499  regcache_invalidate (regcache, i);
1500  }
1501  else
1502  regcache_invalidate (regcache, regno);
1503 
1504  error (_("Process record canceled the operation."));
1505  }
1506 
1507  /* Destroy the record from here forward. */
1508  record_full_list_release_following (record_full_list);
1509  }
1510 
1511  record_full_registers_change (regcache, regno);
1512  }
1513  ops->beneath->to_store_registers (ops->beneath, regcache, regno);
1514 }
1515 
1516 /* "to_xfer_partial" method. Behavior is conditional on
1517  RECORD_FULL_IS_REPLAY.
1518  In replay mode, we cannot write memory unles we are willing to
1519  invalidate the record/replay log from this point forward. */
1520 
1521 static enum target_xfer_status
1523  const char *annex, gdb_byte *readbuf,
1524  const gdb_byte *writebuf, ULONGEST offset,
1525  ULONGEST len, ULONGEST *xfered_len)
1526 {
1528  && (object == TARGET_OBJECT_MEMORY
1529  || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
1530  {
1532  {
1533  /* Let user choose if he wants to write memory or not. */
1534  if (!query (_("Because GDB is in replay mode, writing to memory "
1535  "will make the execution log unusable from this "
1536  "point onward. Write memory at address %s?"),
1537  paddress (target_gdbarch (), offset)))
1538  error (_("Process record canceled the operation."));
1539 
1540  /* Destroy the record from here forward. */
1541  record_full_list_release_following (record_full_list);
1542  }
1543 
1544  /* Check record_full_insn_num */
1546 
1547  /* Record registers change to list as an instruction. */
1548  record_full_arch_list_head = NULL;
1549  record_full_arch_list_tail = NULL;
1550  if (record_full_arch_list_add_mem (offset, len))
1551  {
1552  record_full_list_release (record_full_arch_list_tail);
1553  if (record_debug)
1555  "Process record: failed to record "
1556  "execution log.");
1557  return TARGET_XFER_E_IO;
1558  }
1560  {
1561  record_full_list_release (record_full_arch_list_tail);
1562  if (record_debug)
1564  "Process record: failed to record "
1565  "execution log.");
1566  return TARGET_XFER_E_IO;
1567  }
1568  record_full_list->next = record_full_arch_list_head;
1569  record_full_arch_list_head->prev = record_full_list;
1570  record_full_list = record_full_arch_list_tail;
1571 
1574  else
1576  }
1577 
1578  return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1579  readbuf, writebuf, offset,
1580  len, xfered_len);
1581 }
1582 
1583 /* This structure represents a breakpoint inserted while the record
1584  target is active. We use this to know when to install/remove
1585  breakpoints in/from the target beneath. For example, a breakpoint
1586  may be inserted while recording, but removed when not replaying nor
1587  recording. In that case, the breakpoint had not been inserted on
1588  the target beneath, so we should not try to remove it there. */
1589 
1591 {
1592  /* The address and address space the breakpoint was set at. */
1595 
1596  /* True when the breakpoint has been also installed in the target
1597  beneath. This will be false for breakpoints set during replay or
1598  when recording. */
1600 };
1601 
1603 DEF_VEC_P(record_full_breakpoint_p);
1604 
1605 /* The list of breakpoints inserted while the record target is
1606  active. */
1607 VEC(record_full_breakpoint_p) *record_full_breakpoints = NULL;
1608 
1609 static void
1610 record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
1611 {
1613  return;
1614 
1615  if (loc->inserted)
1616  {
1617  struct record_full_breakpoint *bp = XNEW (struct record_full_breakpoint);
1618 
1619  bp->addr = loc->target_info.placed_address;
1621 
1622  bp->in_target_beneath = 1;
1623 
1624  VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1625  }
1626 }
1627 
1628 /* Sync existing breakpoints to record_full_breakpoints. */
1629 
1630 static void
1632 {
1633  VEC_free (record_full_breakpoint_p, record_full_breakpoints);
1634 
1635  iterate_over_bp_locations (record_full_sync_record_breakpoints);
1636 }
1637 
1638 /* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
1639  insert or remove breakpoints in the real target when replaying, nor
1640  when recording. */
1641 
1642 static int
1644  struct gdbarch *gdbarch,
1645  struct bp_target_info *bp_tgt)
1646 {
1647  struct record_full_breakpoint *bp;
1648  int in_target_beneath = 0;
1649 
1650  if (!RECORD_FULL_IS_REPLAY)
1651  {
1652  /* When recording, we currently always single-step, so we don't
1653  really need to install regular breakpoints in the inferior.
1654  However, we do have to insert software single-step
1655  breakpoints, in case the target can't hardware step. To keep
1656  things single, we always insert. */
1657  struct cleanup *old_cleanups;
1658  int ret;
1659 
1660  old_cleanups = record_full_gdb_operation_disable_set ();
1661  ret = ops->beneath->to_insert_breakpoint (ops->beneath, gdbarch, bp_tgt);
1662  do_cleanups (old_cleanups);
1663 
1664  if (ret != 0)
1665  return ret;
1666 
1667  in_target_beneath = 1;
1668  }
1669 
1670  bp = XNEW (struct record_full_breakpoint);
1671  bp->addr = bp_tgt->placed_address;
1672  bp->address_space = bp_tgt->placed_address_space;
1673  bp->in_target_beneath = in_target_beneath;
1674  VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1675  return 0;
1676 }
1677 
1678 /* "to_remove_breakpoint" method for process record target. */
1679 
1680 static int
1682  struct gdbarch *gdbarch,
1683  struct bp_target_info *bp_tgt)
1684 {
1685  struct record_full_breakpoint *bp;
1686  int ix;
1687 
1688  for (ix = 0;
1689  VEC_iterate (record_full_breakpoint_p,
1690  record_full_breakpoints, ix, bp);
1691  ++ix)
1692  {
1693  if (bp->addr == bp_tgt->placed_address
1694  && bp->address_space == bp_tgt->placed_address_space)
1695  {
1696  if (bp->in_target_beneath)
1697  {
1698  struct cleanup *old_cleanups;
1699  int ret;
1700 
1701  old_cleanups = record_full_gdb_operation_disable_set ();
1702  ret = ops->beneath->to_remove_breakpoint (ops->beneath, gdbarch,
1703  bp_tgt);
1704  do_cleanups (old_cleanups);
1705 
1706  if (ret != 0)
1707  return ret;
1708  }
1709 
1710  VEC_unordered_remove (record_full_breakpoint_p,
1711  record_full_breakpoints, ix);
1712  return 0;
1713  }
1714  }
1715 
1716  gdb_assert_not_reached ("removing unknown breakpoint");
1717 }
1718 
1719 /* "to_can_execute_reverse" method for process record target. */
1720 
1721 static int
1723 {
1724  return 1;
1725 }
1726 
1727 /* "to_get_bookmark" method for process record and prec over core. */
1728 
1729 static gdb_byte *
1730 record_full_get_bookmark (struct target_ops *self, const char *args,
1731  int from_tty)
1732 {
1733  char *ret = NULL;
1734 
1735  /* Return stringified form of instruction count. */
1736  if (record_full_list && record_full_list->type == record_full_end)
1737  ret = xstrdup (pulongest (record_full_list->u.end.insn_num));
1738 
1739  if (record_debug)
1740  {
1741  if (ret)
1743  "record_full_get_bookmark returns %s\n", ret);
1744  else
1746  "record_full_get_bookmark returns NULL\n");
1747  }
1748  return (gdb_byte *) ret;
1749 }
1750 
1751 /* "to_goto_bookmark" method for process record and prec over core. */
1752 
1753 static void
1755  const gdb_byte *raw_bookmark, int from_tty)
1756 {
1757  const char *bookmark = (const char *) raw_bookmark;
1758  struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1759 
1760  if (record_debug)
1762  "record_full_goto_bookmark receives %s\n", bookmark);
1763 
1764  if (bookmark[0] == '\'' || bookmark[0] == '\"')
1765  {
1766  char *copy;
1767 
1768  if (bookmark[strlen (bookmark) - 1] != bookmark[0])
1769  error (_("Unbalanced quotes: %s"), bookmark);
1770 
1771 
1772  copy = savestring (bookmark + 1, strlen (bookmark) - 2);
1773  make_cleanup (xfree, copy);
1774  bookmark = copy;
1775  }
1776 
1777  record_goto (bookmark);
1778 
1779  do_cleanups (cleanup);
1780 }
1781 
1782 static enum exec_direction_kind
1784 {
1786 }
1787 
1788 static void
1790 {
1791  struct record_full_entry *p;
1792 
1794  printf_filtered (_("Replay mode:\n"));
1795  else
1796  printf_filtered (_("Record mode:\n"));
1797 
1798  /* Find entry for first actual instruction in the log. */
1799  for (p = record_full_first.next;
1800  p != NULL && p->type != record_full_end;
1801  p = p->next)
1802  ;
1803 
1804  /* Do we have a log at all? */
1805  if (p != NULL && p->type == record_full_end)
1806  {
1807  /* Display instruction number for first instruction in the log. */
1808  printf_filtered (_("Lowest recorded instruction number is %s.\n"),
1809  pulongest (p->u.end.insn_num));
1810 
1811  /* If in replay mode, display where we are in the log. */
1813  printf_filtered (_("Current instruction number is %s.\n"),
1814  pulongest (record_full_list->u.end.insn_num));
1815 
1816  /* Display instruction number for last instruction in the log. */
1817  printf_filtered (_("Highest recorded instruction number is %s.\n"),
1819 
1820  /* Display log count. */
1821  printf_filtered (_("Log contains %u instructions.\n"),
1823  }
1824  else
1825  printf_filtered (_("No instructions have been logged.\n"));
1826 
1827  /* Display max log size. */
1828  printf_filtered (_("Max logged instructions is %u.\n"),
1830 }
1831 
1832 /* The "to_record_delete" target method. */
1833 
1834 static void
1836 {
1837  record_full_list_release_following (record_full_list);
1838 }
1839 
1840 /* The "to_record_is_replaying" target method. */
1841 
1842 static int
1844 {
1845  return RECORD_FULL_IS_REPLAY;
1846 }
1847 
1848 /* Go to a specific entry. */
1849 
1850 static void
1852 {
1853  if (p == NULL)
1854  error (_("Target insn not found."));
1855  else if (p == record_full_list)
1856  error (_("Already at target insn."));
1857  else if (p->u.end.insn_num > record_full_list->u.end.insn_num)
1858  {
1859  printf_filtered (_("Go forward to insn number %s\n"),
1860  pulongest (p->u.end.insn_num));
1862  }
1863  else
1864  {
1865  printf_filtered (_("Go backward to insn number %s\n"),
1866  pulongest (p->u.end.insn_num));
1868  }
1869 
1870  registers_changed ();
1871  reinit_frame_cache ();
1874 }
1875 
1876 /* The "to_goto_record_begin" target method. */
1877 
1878 static void
1880 {
1881  struct record_full_entry *p = NULL;
1882 
1883  for (p = &record_full_first; p != NULL; p = p->next)
1884  if (p->type == record_full_end)
1885  break;
1886 
1888 }
1889 
1890 /* The "to_goto_record_end" target method. */
1891 
1892 static void
1894 {
1895  struct record_full_entry *p = NULL;
1896 
1897  for (p = record_full_list; p->next != NULL; p = p->next)
1898  ;
1899  for (; p!= NULL; p = p->prev)
1900  if (p->type == record_full_end)
1901  break;
1902 
1904 }
1905 
1906 /* The "to_goto_record" target method. */
1907 
1908 static void
1909 record_full_goto (struct target_ops *self, ULONGEST target_insn)
1910 {
1911  struct record_full_entry *p = NULL;
1912 
1913  for (p = &record_full_first; p != NULL; p = p->next)
1914  if (p->type == record_full_end && p->u.end.insn_num == target_insn)
1915  break;
1916 
1918 }
1919 
1920 static void
1922 {
1923  record_full_ops.to_shortname = "record-full";
1924  record_full_ops.to_longname = "Process record and replay target";
1926  "Log program while executing and replay execution from log.";
1952  /* Add bookmark target methods. */
1964 }
1965 
1966 /* "to_resume" method for prec over corefile. */
1967 
1968 static void
1970  enum gdb_signal signal)
1971 {
1972  record_full_resume_step = step;
1973  record_full_resumed = 1;
1975 
1976  /* We are about to start executing the inferior (or simulate it),
1977  let's register it with the event loop. */
1978  if (target_can_async_p ())
1979  target_async (1);
1980 }
1981 
1982 /* "to_kill" method for prec over corefile. */
1983 
1984 static void
1986 {
1987  if (record_debug)
1988  fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
1989 
1991 }
1992 
1993 /* "to_fetch_registers" method for prec over corefile. */
1994 
1995 static void
1997  struct regcache *regcache,
1998  int regno)
1999 {
2000  if (regno < 0)
2001  {
2002  int num = gdbarch_num_regs (get_regcache_arch (regcache));
2003  int i;
2004 
2005  for (i = 0; i < num; i ++)
2006  regcache_raw_supply (regcache, i,
2008  }
2009  else
2010  regcache_raw_supply (regcache, regno,
2012 }
2013 
2014 /* "to_prepare_to_store" method for prec over corefile. */
2015 
2016 static void
2018  struct regcache *regcache)
2019 {
2020 }
2021 
2022 /* "to_store_registers" method for prec over corefile. */
2023 
2024 static void
2026  struct regcache *regcache,
2027  int regno)
2028 {
2030  regcache_raw_collect (regcache, regno,
2032  else
2033  error (_("You can't do that without a process to debug."));
2034 }
2035 
2036 /* "to_xfer_partial" method for prec over corefile. */
2037 
2038 static enum target_xfer_status
2040  enum target_object object,
2041  const char *annex, gdb_byte *readbuf,
2042  const gdb_byte *writebuf, ULONGEST offset,
2043  ULONGEST len, ULONGEST *xfered_len)
2044 {
2045  if (object == TARGET_OBJECT_MEMORY)
2046  {
2047  if (record_full_gdb_operation_disable || !writebuf)
2048  {
2049  struct target_section *p;
2050 
2051  for (p = record_full_core_start; p < record_full_core_end; p++)
2052  {
2053  if (offset >= p->addr)
2054  {
2055  struct record_full_core_buf_entry *entry;
2056  ULONGEST sec_offset;
2057 
2058  if (offset >= p->endaddr)
2059  continue;
2060 
2061  if (offset + len > p->endaddr)
2062  len = p->endaddr - offset;
2063 
2064  sec_offset = offset - p->addr;
2065 
2066  /* Read readbuf or write writebuf p, offset, len. */
2067  /* Check flags. */
2068  if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
2069  || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
2070  {
2071  if (readbuf)
2072  memset (readbuf, 0, len);
2073 
2074  *xfered_len = len;
2075  return TARGET_XFER_OK;
2076  }
2077  /* Get record_full_core_buf_entry. */
2078  for (entry = record_full_core_buf_list; entry;
2079  entry = entry->prev)
2080  if (entry->p == p)
2081  break;
2082  if (writebuf)
2083  {
2084  if (!entry)
2085  {
2086  /* Add a new entry. */
2087  entry = (struct record_full_core_buf_entry *)
2088  xmalloc
2089  (sizeof (struct record_full_core_buf_entry));
2090  entry->p = p;
2091  if (!bfd_malloc_and_get_section
2092  (p->the_bfd_section->owner,
2093  p->the_bfd_section,
2094  &entry->buf))
2095  {
2096  xfree (entry);
2097  return TARGET_XFER_EOF;
2098  }
2100  record_full_core_buf_list = entry;
2101  }
2102 
2103  memcpy (entry->buf + sec_offset, writebuf,
2104  (size_t) len);
2105  }
2106  else
2107  {
2108  if (!entry)
2109  return ops->beneath->to_xfer_partial (ops->beneath,
2110  object, annex,
2111  readbuf, writebuf,
2112  offset, len,
2113  xfered_len);
2114 
2115  memcpy (readbuf, entry->buf + sec_offset,
2116  (size_t) len);
2117  }
2118 
2119  *xfered_len = len;
2120  return TARGET_XFER_OK;
2121  }
2122  }
2123 
2124  return TARGET_XFER_E_IO;
2125  }
2126  else
2127  error (_("You can't do that without a process to debug."));
2128  }
2129 
2130  return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2131  readbuf, writebuf, offset, len,
2132  xfered_len);
2133 }
2134 
2135 /* "to_insert_breakpoint" method for prec over corefile. */
2136 
2137 static int
2139  struct gdbarch *gdbarch,
2140  struct bp_target_info *bp_tgt)
2141 {
2142  return 0;
2143 }
2144 
2145 /* "to_remove_breakpoint" method for prec over corefile. */
2146 
2147 static int
2149  struct gdbarch *gdbarch,
2150  struct bp_target_info *bp_tgt)
2151 {
2152  return 0;
2153 }
2154 
2155 /* "to_has_execution" method for prec over corefile. */
2156 
2157 static int
2159 {
2160  return 1;
2161 }
2162 
2163 static void
2165 {
2166  record_full_core_ops.to_shortname = "record-core";
2167  record_full_core_ops.to_longname = "Process record and replay target";
2169  "Log program while executing and replay execution from log.";
2200  /* Add bookmark target methods. */
2212 }
2213 
2214 /* Record log save-file format
2215  Version 1 (never released)
2216 
2217  Header:
2218  4 bytes: magic number htonl(0x20090829).
2219  NOTE: be sure to change whenever this file format changes!
2220 
2221  Records:
2222  record_full_end:
2223  1 byte: record type (record_full_end, see enum record_full_type).
2224  record_full_reg:
2225  1 byte: record type (record_full_reg, see enum record_full_type).
2226  8 bytes: register id (network byte order).
2227  MAX_REGISTER_SIZE bytes: register value.
2228  record_full_mem:
2229  1 byte: record type (record_full_mem, see enum record_full_type).
2230  8 bytes: memory length (network byte order).
2231  8 bytes: memory address (network byte order).
2232  n bytes: memory value (n == memory length).
2233 
2234  Version 2
2235  4 bytes: magic number netorder32(0x20091016).
2236  NOTE: be sure to change whenever this file format changes!
2237 
2238  Records:
2239  record_full_end:
2240  1 byte: record type (record_full_end, see enum record_full_type).
2241  4 bytes: signal
2242  4 bytes: instruction count
2243  record_full_reg:
2244  1 byte: record type (record_full_reg, see enum record_full_type).
2245  4 bytes: register id (network byte order).
2246  n bytes: register value (n == actual register size).
2247  (eg. 4 bytes for x86 general registers).
2248  record_full_mem:
2249  1 byte: record type (record_full_mem, see enum record_full_type).
2250  4 bytes: memory length (network byte order).
2251  8 bytes: memory address (network byte order).
2252  n bytes: memory value (n == memory length).
2253 
2254 */
2255 
2256 /* bfdcore_read -- read bytes from a core file section. */
2257 
2258 static inline void
2259 bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2260 {
2261  int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2262 
2263  if (ret)
2264  *offset += len;
2265  else
2266  error (_("Failed to read %d bytes from core file %s ('%s')."),
2267  len, bfd_get_filename (obfd),
2268  bfd_errmsg (bfd_get_error ()));
2269 }
2270 
2271 static inline uint64_t
2272 netorder64 (uint64_t input)
2273 {
2274  uint64_t ret;
2275 
2276  store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2277  BFD_ENDIAN_BIG, input);
2278  return ret;
2279 }
2280 
2281 static inline uint32_t
2282 netorder32 (uint32_t input)
2283 {
2284  uint32_t ret;
2285 
2286  store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2287  BFD_ENDIAN_BIG, input);
2288  return ret;
2289 }
2290 
2291 static inline uint16_t
2292 netorder16 (uint16_t input)
2293 {
2294  uint16_t ret;
2295 
2296  store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret),
2297  BFD_ENDIAN_BIG, input);
2298  return ret;
2299 }
2300 
2301 /* Restore the execution log from a core_bfd file. */
2302 static void
2304 {
2305  uint32_t magic;
2306  struct cleanup *old_cleanups;
2307  struct record_full_entry *rec;
2308  asection *osec;
2309  uint32_t osec_size;
2310  int bfd_offset = 0;
2311  struct regcache *regcache;
2312 
2313  /* We restore the execution log from the open core bfd,
2314  if there is one. */
2315  if (core_bfd == NULL)
2316  return;
2317 
2318  /* "record_full_restore" can only be called when record list is empty. */
2319  gdb_assert (record_full_first.next == NULL);
2320 
2321  if (record_debug)
2322  fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
2323 
2324  /* Now need to find our special note section. */
2325  osec = bfd_get_section_by_name (core_bfd, "null0");
2326  if (record_debug)
2327  fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
2328  osec ? "succeeded" : "failed");
2329  if (osec == NULL)
2330  return;
2331  osec_size = bfd_section_size (core_bfd, osec);
2332  if (record_debug)
2333  fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
2334 
2335  /* Check the magic code. */
2336  bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
2337  if (magic != RECORD_FULL_FILE_MAGIC)
2338  error (_("Version mis-match or file format error in core file %s."),
2339  bfd_get_filename (core_bfd));
2340  if (record_debug)
2342  " Reading 4-byte magic cookie "
2343  "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2344  phex_nz (netorder32 (magic), 4));
2345 
2346  /* Restore the entries in recfd into record_full_arch_list_head and
2347  record_full_arch_list_tail. */
2348  record_full_arch_list_head = NULL;
2349  record_full_arch_list_tail = NULL;
2351  old_cleanups = make_cleanup (record_full_arch_list_cleanups, 0);
2352  regcache = get_current_regcache ();
2353 
2354  while (1)
2355  {
2356  uint8_t rectype;
2357  uint32_t regnum, len, signal, count;
2358  uint64_t addr;
2359 
2360  /* We are finished when offset reaches osec_size. */
2361  if (bfd_offset >= osec_size)
2362  break;
2363  bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);
2364 
2365  switch (rectype)
2366  {
2367  case record_full_reg: /* reg */
2368  /* Get register number to regnum. */
2369  bfdcore_read (core_bfd, osec, &regnum,
2370  sizeof (regnum), &bfd_offset);
2371  regnum = netorder32 (regnum);
2372 
2373  rec = record_full_reg_alloc (regcache, regnum);
2374 
2375  /* Get val. */
2377  rec->u.reg.len, &bfd_offset);
2378 
2379  if (record_debug)
2381  " Reading register %d (1 "
2382  "plus %lu plus %d bytes)\n",
2383  rec->u.reg.num,
2384  (unsigned long) sizeof (regnum),
2385  rec->u.reg.len);
2386  break;
2387 
2388  case record_full_mem: /* mem */
2389  /* Get len. */
2390  bfdcore_read (core_bfd, osec, &len,
2391  sizeof (len), &bfd_offset);
2392  len = netorder32 (len);
2393 
2394  /* Get addr. */
2395  bfdcore_read (core_bfd, osec, &addr,
2396  sizeof (addr), &bfd_offset);
2397  addr = netorder64 (addr);
2398 
2399  rec = record_full_mem_alloc (addr, len);
2400 
2401  /* Get val. */
2403  rec->u.mem.len, &bfd_offset);
2404 
2405  if (record_debug)
2407  " Reading memory %s (1 plus "
2408  "%lu plus %lu plus %d bytes)\n",
2410  rec->u.mem.addr),
2411  (unsigned long) sizeof (addr),
2412  (unsigned long) sizeof (len),
2413  rec->u.mem.len);
2414  break;
2415 
2416  case record_full_end: /* end */
2417  rec = record_full_end_alloc ();
2419 
2420  /* Get signal value. */
2421  bfdcore_read (core_bfd, osec, &signal,
2422  sizeof (signal), &bfd_offset);
2423  signal = netorder32 (signal);
2424  rec->u.end.sigval = signal;
2425 
2426  /* Get insn count. */
2427  bfdcore_read (core_bfd, osec, &count,
2428  sizeof (count), &bfd_offset);
2429  count = netorder32 (count);
2430  rec->u.end.insn_num = count;
2431  record_full_insn_count = count + 1;
2432  if (record_debug)
2434  " Reading record_full_end (1 + "
2435  "%lu + %lu bytes), offset == %s\n",
2436  (unsigned long) sizeof (signal),
2437  (unsigned long) sizeof (count),
2439  bfd_offset));
2440  break;
2441 
2442  default:
2443  error (_("Bad entry type in core file %s."),
2444  bfd_get_filename (core_bfd));
2445  break;
2446  }
2447 
2448  /* Add rec to record arch list. */
2450  }
2451 
2452  discard_cleanups (old_cleanups);
2453 
2454  /* Add record_full_arch_list_head to the end of record list. */
2456  record_full_arch_list_head->prev = &record_full_first;
2457  record_full_arch_list_tail->next = NULL;
2458  record_full_list = &record_full_first;
2459 
2460  /* Update record_full_insn_max_num. */
2462  {
2464  warning (_("Auto increase record/replay buffer limit to %u."),
2466  }
2467 
2468  /* Succeeded. */
2469  printf_filtered (_("Restored records from core file %s.\n"),
2470  bfd_get_filename (core_bfd));
2471 
2473 }
2474 
2475 /* bfdcore_write -- write bytes into a core file section. */
2476 
2477 static inline void
2478 bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2479 {
2480  int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2481 
2482  if (ret)
2483  *offset += len;
2484  else
2485  error (_("Failed to write %d bytes to core file %s ('%s')."),
2486  len, bfd_get_filename (obfd),
2487  bfd_errmsg (bfd_get_error ()));
2488 }
2489 
2490 /* Restore the execution log from a file. We use a modified elf
2491  corefile format, with an extra section for our data. */
2492 
2493 static void
2494 cmd_record_full_restore (char *args, int from_tty)
2495 {
2496  core_file_command (args, from_tty);
2497  record_full_open (args, from_tty);
2498 }
2499 
2500 static void
2502 {
2503  bfd *obfd = data;
2504  char *pathname = xstrdup (bfd_get_filename (obfd));
2505 
2506  gdb_bfd_unref (obfd);
2507  unlink (pathname);
2508  xfree (pathname);
2509 }
2510 
2511 /* Save the execution log to a file. We use a modified elf corefile
2512  format, with an extra section for our data. */
2513 
2514 static void
2515 record_full_save (struct target_ops *self, const char *recfilename)
2516 {
2517  struct record_full_entry *cur_record_full_list;
2518  uint32_t magic;
2519  struct regcache *regcache;
2520  struct gdbarch *gdbarch;
2521  struct cleanup *old_cleanups;
2522  struct cleanup *set_cleanups;
2523  bfd *obfd;
2524  int save_size = 0;
2525  asection *osec = NULL;
2526  int bfd_offset = 0;
2527 
2528  /* Open the save file. */
2529  if (record_debug)
2530  fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
2531  recfilename);
2532 
2533  /* Open the output file. */
2534  obfd = create_gcore_bfd (recfilename);
2535  old_cleanups = make_cleanup (record_full_save_cleanups, obfd);
2536 
2537  /* Save the current record entry to "cur_record_full_list". */
2538  cur_record_full_list = record_full_list;
2539 
2540  /* Get the values of regcache and gdbarch. */
2541  regcache = get_current_regcache ();
2542  gdbarch = get_regcache_arch (regcache);
2543 
2544  /* Disable the GDB operation record. */
2545  set_cleanups = record_full_gdb_operation_disable_set ();
2546 
2547  /* Reverse execute to the begin of record list. */
2548  while (1)
2549  {
2550  /* Check for beginning and end of log. */
2551  if (record_full_list == &record_full_first)
2552  break;
2553 
2554  record_full_exec_insn (regcache, gdbarch, record_full_list);
2555 
2556  if (record_full_list->prev)
2557  record_full_list = record_full_list->prev;
2558  }
2559 
2560  /* Compute the size needed for the extra bfd section. */
2561  save_size = 4; /* magic cookie */
2562  for (record_full_list = record_full_first.next; record_full_list;
2563  record_full_list = record_full_list->next)
2564  switch (record_full_list->type)
2565  {
2566  case record_full_end:
2567  save_size += 1 + 4 + 4;
2568  break;
2569  case record_full_reg:
2570  save_size += 1 + 4 + record_full_list->u.reg.len;
2571  break;
2572  case record_full_mem:
2573  save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
2574  break;
2575  }
2576 
2577  /* Make the new bfd section. */
2578  osec = bfd_make_section_anyway_with_flags (obfd, "precord",
2579  SEC_HAS_CONTENTS
2580  | SEC_READONLY);
2581  if (osec == NULL)
2582  error (_("Failed to create 'precord' section for corefile %s: %s"),
2583  recfilename,
2584  bfd_errmsg (bfd_get_error ()));
2585  bfd_set_section_size (obfd, osec, save_size);
2586  bfd_set_section_vma (obfd, osec, 0);
2587  bfd_set_section_alignment (obfd, osec, 0);
2588  bfd_section_lma (obfd, osec) = 0;
2589 
2590  /* Save corefile state. */
2591  write_gcore_file (obfd);
2592 
2593  /* Write out the record log. */
2594  /* Write the magic code. */
2595  magic = RECORD_FULL_FILE_MAGIC;
2596  if (record_debug)
2598  " Writing 4-byte magic cookie "
2599  "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2600  phex_nz (magic, 4));
2601  bfdcore_write (obfd, osec, &magic, sizeof (magic), &bfd_offset);
2602 
2603  /* Save the entries to recfd and forward execute to the end of
2604  record list. */
2605  record_full_list = &record_full_first;
2606  while (1)
2607  {
2608  /* Save entry. */
2609  if (record_full_list != &record_full_first)
2610  {
2611  uint8_t type;
2612  uint32_t regnum, len, signal, count;
2613  uint64_t addr;
2614 
2615  type = record_full_list->type;
2616  bfdcore_write (obfd, osec, &type, sizeof (type), &bfd_offset);
2617 
2618  switch (record_full_list->type)
2619  {
2620  case record_full_reg: /* reg */
2621  if (record_debug)
2623  " Writing register %d (1 "
2624  "plus %lu plus %d bytes)\n",
2625  record_full_list->u.reg.num,
2626  (unsigned long) sizeof (regnum),
2627  record_full_list->u.reg.len);
2628 
2629  /* Write regnum. */
2630  regnum = netorder32 (record_full_list->u.reg.num);
2631  bfdcore_write (obfd, osec, &regnum,
2632  sizeof (regnum), &bfd_offset);
2633 
2634  /* Write regval. */
2635  bfdcore_write (obfd, osec,
2636  record_full_get_loc (record_full_list),
2637  record_full_list->u.reg.len, &bfd_offset);
2638  break;
2639 
2640  case record_full_mem: /* mem */
2641  if (record_debug)
2643  " Writing memory %s (1 plus "
2644  "%lu plus %lu plus %d bytes)\n",
2645  paddress (gdbarch,
2646  record_full_list->u.mem.addr),
2647  (unsigned long) sizeof (addr),
2648  (unsigned long) sizeof (len),
2649  record_full_list->u.mem.len);
2650 
2651  /* Write memlen. */
2652  len = netorder32 (record_full_list->u.mem.len);
2653  bfdcore_write (obfd, osec, &len, sizeof (len), &bfd_offset);
2654 
2655  /* Write memaddr. */
2656  addr = netorder64 (record_full_list->u.mem.addr);
2657  bfdcore_write (obfd, osec, &addr,
2658  sizeof (addr), &bfd_offset);
2659 
2660  /* Write memval. */
2661  bfdcore_write (obfd, osec,
2662  record_full_get_loc (record_full_list),
2663  record_full_list->u.mem.len, &bfd_offset);
2664  break;
2665 
2666  case record_full_end:
2667  if (record_debug)
2669  " Writing record_full_end (1 + "
2670  "%lu + %lu bytes)\n",
2671  (unsigned long) sizeof (signal),
2672  (unsigned long) sizeof (count));
2673  /* Write signal value. */
2674  signal = netorder32 (record_full_list->u.end.sigval);
2675  bfdcore_write (obfd, osec, &signal,
2676  sizeof (signal), &bfd_offset);
2677 
2678  /* Write insn count. */
2679  count = netorder32 (record_full_list->u.end.insn_num);
2680  bfdcore_write (obfd, osec, &count,
2681  sizeof (count), &bfd_offset);
2682  break;
2683  }
2684  }
2685 
2686  /* Execute entry. */
2687  record_full_exec_insn (regcache, gdbarch, record_full_list);
2688 
2689  if (record_full_list->next)
2690  record_full_list = record_full_list->next;
2691  else
2692  break;
2693  }
2694 
2695  /* Reverse execute to cur_record_full_list. */
2696  while (1)
2697  {
2698  /* Check for beginning and end of log. */
2699  if (record_full_list == cur_record_full_list)
2700  break;
2701 
2702  record_full_exec_insn (regcache, gdbarch, record_full_list);
2703 
2704  if (record_full_list->prev)
2705  record_full_list = record_full_list->prev;
2706  }
2707 
2708  do_cleanups (set_cleanups);
2709  gdb_bfd_unref (obfd);
2710  discard_cleanups (old_cleanups);
2711 
2712  /* Succeeded. */
2713  printf_filtered (_("Saved core file %s with execution log.\n"),
2714  recfilename);
2715 }
2716 
2717 /* record_full_goto_insn -- rewind the record log (forward or backward,
2718  depending on DIR) to the given entry, changing the program state
2719  correspondingly. */
2720 
2721 static void
2723  enum exec_direction_kind dir)
2724 {
2725  struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
2726  struct regcache *regcache = get_current_regcache ();
2727  struct gdbarch *gdbarch = get_regcache_arch (regcache);
2728 
2729  /* Assume everything is valid: we will hit the entry,
2730  and we will not hit the end of the recording. */
2731 
2732  if (dir == EXEC_FORWARD)
2733  record_full_list = record_full_list->next;
2734 
2735  do
2736  {
2737  record_full_exec_insn (regcache, gdbarch, record_full_list);
2738  if (dir == EXEC_REVERSE)
2739  record_full_list = record_full_list->prev;
2740  else
2741  record_full_list = record_full_list->next;
2742  } while (record_full_list != entry);
2743  do_cleanups (set_cleanups);
2744 }
2745 
2746 /* Alias for "target record-full". */
2747 
2748 static void
2749 cmd_record_full_start (char *args, int from_tty)
2750 {
2751  execute_command ("target record-full", from_tty);
2752 }
2753 
2754 static void
2755 set_record_full_insn_max_num (char *args, int from_tty,
2756  struct cmd_list_element *c)
2757 {
2759  {
2760  /* Count down record_full_insn_num while releasing records from list. */
2762  {
2765  }
2766  }
2767 }
2768 
2769 /* The "set record full" command. */
2770 
2771 static void
2772 set_record_full_command (char *args, int from_tty)
2773 {
2774  printf_unfiltered (_("\"set record full\" must be followed "
2775  "by an apporpriate subcommand.\n"));
2776  help_list (set_record_full_cmdlist, "set record full ", all_commands,
2777  gdb_stdout);
2778 }
2779 
2780 /* The "show record full" command. */
2781 
2782 static void
2783 show_record_full_command (char *args, int from_tty)
2784 {
2785  cmd_show_list (show_record_full_cmdlist, from_tty, "");
2786 }
2787 
2788 /* Provide a prototype to silence -Wmissing-prototypes. */
2790 
2791 void
2793 {
2794  struct cmd_list_element *c;
2795 
2796  /* Init record_full_first. */
2797  record_full_first.prev = NULL;
2798  record_full_first.next = NULL;
2800 
2806 
2808  _("Start full execution recording."), &record_full_cmdlist,
2809  "record full ", 0, &record_cmdlist);
2810 
2812  _("Restore the execution log from a file.\n\
2813 Argument is filename. File must be created with 'record save'."),
2814  &record_full_cmdlist);
2815  set_cmd_completer (c, filename_completer);
2816 
2817  /* Deprecate the old version without "full" prefix. */
2818  c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
2819  &record_cmdlist);
2820  set_cmd_completer (c, filename_completer);
2821  deprecate_cmd (c, "record full restore");
2822 
2824  _("Set record options"), &set_record_full_cmdlist,
2825  "set record full ", 0, &set_record_cmdlist);
2826 
2828  _("Show record options"), &show_record_full_cmdlist,
2829  "show record full ", 0, &show_record_cmdlist);
2830 
2831  /* Record instructions number limit command. */
2832  add_setshow_boolean_cmd ("stop-at-limit", no_class,
2834 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2835 Show whether record/replay stops when record/replay buffer becomes full."),
2836  _("Default is ON.\n\
2837 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2838 When OFF, if the record/replay buffer becomes full,\n\
2839 delete the oldest recorded instruction to make room for each new one."),
2840  NULL, NULL,
2841  &set_record_full_cmdlist, &show_record_full_cmdlist);
2842 
2843  c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2845  deprecate_cmd (c, "set record full stop-at-limit");
2846 
2847  c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2849  deprecate_cmd (c, "show record full stop-at-limit");
2850 
2851  add_setshow_uinteger_cmd ("insn-number-max", no_class,
2853  _("Set record/replay buffer limit."),
2854  _("Show record/replay buffer limit."), _("\
2855 Set the maximum number of instructions to be stored in the\n\
2856 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2857 limit. Default is 200000."),
2859  NULL, &set_record_full_cmdlist,
2860  &show_record_full_cmdlist);
2861 
2862  c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2864  deprecate_cmd (c, "set record full insn-number-max");
2865 
2866  c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2868  deprecate_cmd (c, "show record full insn-number-max");
2869 
2870  add_setshow_boolean_cmd ("memory-query", no_class,
2872 Set whether query if PREC cannot record memory change of next instruction."),
2873  _("\
2874 Show whether query if PREC cannot record memory change of next instruction."),
2875  _("\
2876 Default is OFF.\n\
2877 When ON, query if PREC cannot record memory change of next instruction."),
2878  NULL, NULL,
2879  &set_record_full_cmdlist,
2880  &show_record_full_cmdlist);
2881 
2882  c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2884  deprecate_cmd (c, "set record full memory-query");
2885 
2886  c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2888  deprecate_cmd (c, "show record full memory-query");
2889 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define target_can_async_p()
Definition: target.h:1748
int gdbarch_software_single_step_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3009
void add_target(struct target_ops *t)
Definition: target.c:395
struct cmd_list_element * show_record_cmdlist
Definition: record.c:53
void target_terminal_ours(void)
Definition: target.c:491
static struct record_full_core_buf_entry * record_full_core_buf_list
Definition: record-full.c:172
static enum exec_direction_kind record_full_execution_direction(struct target_ops *self)
Definition: record-full.c:1783
static struct cmd_list_element * set_record_full_cmdlist
Definition: record-full.c:225
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
Definition: record-full.c:141
void(* to_delete_record)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1142
static struct record_full_entry * record_full_arch_list_head
Definition: record-full.c:193
int(* to_supports_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:513
static void record_full_core_store_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: record-full.c:2025
static int record_full_core_has_execution(struct target_ops *ops, ptid_t the_ptid)
Definition: record-full.c:2158
const char * to_longname
Definition: target.h:433
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
void(* to_goto_bookmark)(struct target_ops *, const gdb_byte *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:681
void(* to_goto_record_begin)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1150
static void record_full_goto_end(struct target_ops *self)
Definition: record-full.c:1893
static void record_full_arch_list_cleanups(void *ignore)
Definition: record-full.c:563
void(* to_save_record)(struct target_ops *, const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1137
int gdbarch_process_record_signal(struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal)
Definition: gdbarch.c:3895
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
static ptid_t record_full_wait_1(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: record-full.c:1053
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void record_full_open(const char *name, int from_tty)
Definition: record-full.c:849
enum gdb_signal signal
Definition: record-full.c:648
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1474
void xfree(void *)
Definition: common-utils.c:97
gdb_byte buf[sizeof(gdb_byte *)]
Definition: record-full.c:89
struct address_space * address_space
Definition: record-full.c:1593
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
Definition: record-full.c:466
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
static void record_full_restore(void)
Definition: record-full.c:2303
struct target_section * p
Definition: record-full.c:164
void record_goto(const char *arg)
Definition: record.c:335
Definition: record-full.c:79
static int record_full_message(struct regcache *regcache, enum gdb_signal signal)
Definition: record-full.c:575
void warning(const char *fmt,...)
Definition: errors.c:26
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition: cli-decode.c:272
int query(const char *ctlstr,...)
Definition: utils.c:1364
int gdbarch_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
Definition: gdbarch.c:3871
struct cmd_list_element * set_record_cmdlist
Definition: record.c:52
int mem_entry_not_accessible
Definition: record-full.c:85
static uint64_t netorder64(uint64_t input)
Definition: record-full.c:2272
void push_target(struct target_ops *t)
Definition: target.c:664
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
Definition: target.h:481
static void record_full_exec_insn(struct regcache *regcache, struct gdbarch *gdbarch, struct record_full_entry *entry)
Definition: record-full.c:699
int build_section_table(struct bfd *some_bfd, struct target_section **start, struct target_section **end)
Definition: exec.c:470
void record_preopen(void)
Definition: record.c:86
struct ui_file * gdb_stdout
Definition: main.c:71
static struct target_ops record_full_core_ops
Definition: record-full.c:209
void record_disconnect(struct target_ops *t, const char *args, int from_tty)
Definition: record.c:133
int unpush_target(struct target_ops *t)
Definition: target.c:711
struct thread_info * inferior_thread(void)
Definition: thread.c:85
void delete_async_event_handler(async_event_handler **async_handler_ptr)
Definition: event-loop.c:1050
unsigned int record_debug
Definition: record.c:33
void target_pass_signals(int numsigs, unsigned char *pass_signals)
Definition: target.c:2261
#define VEC_unordered_remove(T, V, I)
Definition: vec.h:351
void(* to_close)(struct target_ops *)
Definition: target.h:448
void mark_async_event_handler(async_event_handler *async_handler_ptr)
Definition: event-loop.c:1011
#define DEFAULT_RECORD_FULL_INSN_MAX_NUM
Definition: record-full.c:61
gdb_byte * ptr
Definition: record-full.c:99
static void init_record_full_ops(void)
Definition: record-full.c:1921
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
Definition: exceptions.c:228
struct record_full_reg_entry reg
Definition: record-full.c:149
int yquery(const char *ctlstr,...)
Definition: utils.c:1347
static int record_full_supports_stopped_by_sw_breakpoint(struct target_ops *ops)
Definition: record-full.c:1391
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
static void record_full_sig_handler(int signo)
Definition: record-full.c:1014
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
Definition: target.h:484
int gdbarch_software_single_step(struct gdbarch *gdbarch, struct frame_info *frame)
Definition: gdbarch.c:3016
static int record_full_can_execute_reverse(struct target_ops *self)
Definition: record-full.c:1722
static int record_full_stopped_by_sw_breakpoint(struct target_ops *ops)
Definition: record-full.c:1382
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:468
void target_fetch_registers(struct regcache *regcache, int regno)
Definition: target.c:3419
void(* to_info_record)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1133
bfd_byte * buf
Definition: record-full.c:165
static void record_full_list_release_first(void)
Definition: record-full.c:391
#define _(String)
Definition: gdb_locale.h:40
void core_file_command(char *filename, int from_tty)
Definition: corefile.c:68
static void record_full_goto_entry(struct record_full_entry *p)
Definition: record-full.c:1851
void execute_command(char *, int)
Definition: top.c:388
DEF_VEC_P(record_full_breakpoint_p)
static unsigned int record_full_insn_num
Definition: record-full.c:202
static int record_full_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: record-full.c:1681
#define target_stopped_by_watchpoint()
Definition: target.h:1829
int record_full_is_used(void)
Definition: record-full.c:214
unsigned short len
Definition: record-full.c:96
static int record_full_message_wrapper_safe(struct regcache *regcache, enum gdb_signal signal)
Definition: record-full.c:661
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
static void cmd_record_full_restore(char *args, int from_tty)
Definition: record-full.c:2494
gdb_byte buf[2 *sizeof(gdb_byte *)]
Definition: record-full.c:100
static int record_full_is_replaying(struct target_ops *self)
Definition: record-full.c:1843
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
void printf_filtered(const char *format,...)
Definition: utils.c:2388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
Definition: ptid.h:35
static void record_full_reg_release(struct record_full_entry *rec)
Definition: record-full.c:260
record_full_type
Definition: record-full.c:110
static unsigned int record_full_insn_max_num
Definition: record-full.c:200
enum gdb_signal sigval
Definition: record-full.c:106
static void record_full_mem_release(struct record_full_entry *rec)
Definition: record-full.c:288
void null_cleanup(void *arg)
Definition: cleanups.c:295
const char *const name
Definition: aarch64-tdep.c:68
static enum target_xfer_status record_full_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: record-full.c:1522
static void cmd_record_full_start(char *args, int from_tty)
Definition: record-full.c:2749
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
#define OPS_MAGIC
Definition: target.h:1233
char inserted
Definition: breakpoint.h:371
static int record_full_resume_step
Definition: record-full.c:927
static void record_full_end_release(struct record_full_entry *rec)
Definition: record-full.c:312
static struct record_full_entry * record_full_arch_list_tail
Definition: record-full.c:194
struct cleanup * make_cleanup_restore_integer(int *variable)
Definition: utils.c:292
int hardware_watchpoint_inserted_in_range(struct address_space *aspace, CORE_ADDR addr, ULONGEST len)
Definition: breakpoint.c:4323
void inferior_event_handler(enum inferior_event_type event_type, gdb_client_data client_data)
Definition: inf-loop.c:40
static struct cmd_list_element * show_record_full_cmdlist
Definition: record-full.c:226
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void initialize_file_ftype(void)
Definition: defs.h:281
static void record_full_open_1(const char *name, int from_tty)
Definition: record-full.c:825
int record_read_memory(struct gdbarch *gdbarch, CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: record.c:97
static void record_full_arch_list_add(struct record_full_entry *rec)
Definition: record-full.c:421
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
void add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:694
enum gdb_signal sig
Definition: waitstatus.h:108
struct record_full_end_entry end
Definition: record-full.c:153
void target_terminal_inferior(void)
Definition: target.c:470
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
struct record_full_mem_entry mem
Definition: record-full.c:151
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
int(* to_supports_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:500
static void record_full_async(struct target_ops *ops, int enable)
Definition: record-full.c:917
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:464
VEC(record_full_breakpoint_p)
Definition: record-full.c:1607
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
#define TARGET_WNOHANG
Definition: wait.h:28
static void record_full_list_release(struct record_full_entry *rec)
Definition: record-full.c:342
async_event_handler * create_async_event_handler(async_event_handler_func *proc, gdb_client_data client_data)
Definition: event-loop.c:988
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
static void record_full_store_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: record-full.c:1463
union target_waitstatus::@161 value
target_xfer_status
Definition: target.h:219
int(* to_has_execution)(struct target_ops *, ptid_t)
Definition: target.h:655
Definition: gdbtypes.h:749
void iterate_over_bp_locations(walk_bp_location_callback callback)
Definition: breakpoint.c:3005
struct target_ops * find_record_target(void)
Definition: record.c:63
static enum record_full_type record_full_entry_release(struct record_full_entry *rec)
Definition: record-full.c:321
int len
Definition: record-full.c:82
static ptid_t record_full_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: record-full.c:1344
#define enable()
Definition: ser-go32.c:239
exec_direction_kind
Definition: infrun.h:65
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
static const char * type
Definition: language.c:103
void observer_notify_record_changed(struct inferior *inferior, int started)
#define gdb_assert(expr)
Definition: gdb_assert.h:33
void record_detach(struct target_ops *t, const char *args, int from_tty)
Definition: record.c:148
static void record_full_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal)
Definition: record-full.c:953
void write_gcore_file(bfd *obfd)
Definition: gcore.c:115
struct record_full_breakpoint * record_full_breakpoint_p
Definition: record-full.c:1602
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
const char * to_doc
Definition: target.h:434
CORE_ADDR addr
Definition: record-full.c:81
static void record_full_info(struct target_ops *self)
Definition: record-full.c:1789
struct record_full_core_buf_entry * prev
Definition: record-full.c:163
Definition: record-full.c:161
struct cmd_list_element * add_alias_cmd(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:286
int gdbarch_process_record_signal_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3888
CORE_ADDR endaddr
Definition: target.h:2260
#define target_has_execution
Definition: target.h:1726
enum record_full_type type
Definition: record-full.c:145
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
static struct record_full_entry record_full_first
Definition: record-full.c:191
static void record_full_wait_cleanups(void *ignore)
Definition: record-full.c:1028
int regnum
Definition: aarch64-tdep.c:69
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
CORE_ADDR placed_address
Definition: breakpoint.h:232
gdb_byte * ptr
Definition: record-full.c:88
static gdb_byte * record_full_core_regbuf
Definition: record-full.c:169
static void record_full_core_fetch_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: record-full.c:1996
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:460
static uint16_t netorder16(uint16_t input)
Definition: record-full.c:2292
ULONGEST insn_num
Definition: record-full.c:107
static void record_full_core_open_1(const char *name, int from_tty)
Definition: record-full.c:795
struct record_full_entry * next
Definition: record-full.c:144
void(* to_async)(struct target_ops *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:664
#define RECORD_FULL_FILE_MAGIC
Definition: record-full.c:66
struct bfd_section * the_bfd_section
Definition: target.h:2262
static enum exec_direction_kind record_full_execution_dir
Definition: record-full.c:948
static struct target_section * record_full_core_start
Definition: record-full.c:170
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
static int record_full_stopped_by_hw_breakpoint(struct target_ops *ops)
Definition: record-full.c:1399
int record_full_memory_query
Definition: record-full.c:159
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition: thread.c:143
target_object
Definition: target.h:136
void * gdb_client_data
Definition: event-loop.h:70
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:672
CORE_ADDR addr
Definition: target.h:2259
Definition: regdef.h:22
void record_mourn_inferior(struct target_ops *t)
Definition: record.c:163
int record_full_arch_list_add_mem(CORE_ADDR addr, int len)
Definition: record-full.c:489
void(* to_disconnect)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:462
static enum target_xfer_status record_full_core_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: record-full.c:2039
void regcache_invalidate(struct regcache *regcache, int regnum)
Definition: regcache.c:459
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:151
static int record_full_core_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: record-full.c:2138
void record_kill(struct target_ops *t)
Definition: record.c:179
struct cmd_list_element * record_cmdlist
Definition: record.c:50
static int record_full_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: record-full.c:1643
bfd_byte gdb_byte
Definition: common-types.h:38
enum exec_direction_kind(* to_execution_direction)(struct target_ops *) TARGET_DEFAULT_FUNC(default_execution_direction)
Definition: target.h:807
static int record_full_gdb_operation_disable
Definition: record-full.c:676
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
int non_stop
Definition: infrun.c:180
static enum target_stop_reason record_full_stop_reason
Definition: record-full.c:692
static struct target_section * record_full_core_end
Definition: record-full.c:171
static void record_full_goto_bookmark(struct target_ops *self, const gdb_byte *raw_bookmark, int from_tty)
Definition: record-full.c:1754
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:607
enum bp_loc_type loc_type
Definition: breakpoint.h:316
#define ALL_NON_EXITED_THREADS(T)
Definition: gdbthread.h:377
static struct target_ops record_full_ops
Definition: record-full.c:208
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:637
enum target_waitkind kind
Definition: waitstatus.h:100
unsigned short num
Definition: record-full.c:95
static void record_full_core_kill(struct target_ops *ops)
Definition: record-full.c:1985
static struct cmd_list_element * record_full_cmdlist
Definition: record-full.c:229
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:575
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1174
static void set_record_full_insn_max_num(char *args, int from_tty, struct cmd_list_element *c)
Definition: record-full.c:2755
gdb_byte *(* to_get_bookmark)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:678
static gdb_byte * record_full_get_bookmark(struct target_ops *self, const char *args, int from_tty)
Definition: record-full.c:1730
ptid_t inferior_ptid
Definition: infcmd.c:124
enum strata to_stratum
Definition: target.h:650
int(* to_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:497
static void record_full_delete(struct target_ops *self)
Definition: record-full.c:1835
static void record_full_list_release_following(struct record_full_entry *rec)
Definition: record-full.c:368
void(* to_goto_record_end)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1154
static struct record_full_entry * record_full_mem_alloc(CORE_ADDR addr, int len)
Definition: record-full.c:271
void(* to_open)(const char *, int)
Definition: target.h:443
int offset
Definition: agent.c:65
void registers_changed(void)
Definition: regcache.c:624
static ULONGEST record_full_insn_count
Definition: record-full.c:205
#define VEC_free(T, V)
Definition: vec.h:180
static gdb_byte * record_full_get_loc(struct record_full_entry *rec)
Definition: record-full.c:443
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
CORE_ADDR stop_pc
Definition: infcmd.c:128
struct record_full_entry * prev
Definition: record-full.c:143
Definition: record-full.c:104
int(* to_stopped_by_watchpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:542
struct address_space * get_regcache_aspace(const struct regcache *regcache)
Definition: regcache.c:303
static void bfdcore_write(bfd *obfd, asection *osec, void *buf, int len, int *offset)
Definition: record-full.c:2478
int gdbarch_process_record_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3864
static void record_full_goto_begin(struct target_ops *self)
Definition: record-full.c:1879
static struct record_full_entry * record_full_reg_alloc(struct regcache *regcache, int regnum)
Definition: record-full.c:242
static int record_full_resumed
Definition: record-full.c:932
int(* to_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:510
bfd * create_gcore_bfd(const char *filename)
Definition: gcore.c:52
struct inferior * current_inferior(void)
Definition: inferior.c:57
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
const char * to_shortname
Definition: target.h:432
union record_full_reg_entry::@134 u
void delete_single_step_breakpoints(struct thread_info *tp)
Definition: thread.c:121
unsigned long long ULONGEST
Definition: common-types.h:53
static int record_full_supports_stopped_by_hw_breakpoint(struct target_ops *ops)
Definition: record-full.c:1408
union record_full_entry::@135 u
static void record_full_goto_insn(struct record_full_entry *entry, enum exec_direction_kind dir)
Definition: record-full.c:2722
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
int to_magic
Definition: target.h:1224
char * savestring(const char *ptr, size_t len)
Definition: common-utils.c:148
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
void clear_async_event_handler(async_event_handler *async_handler_ptr)
Definition: event-loop.c:1019
static struct record_full_entry * record_full_end_alloc(void)
Definition: record-full.c:299
struct cleanup * record_full_gdb_operation_disable_set(void)
Definition: record-full.c:679
static void init_record_full_core_ops(void)
Definition: record-full.c:2164
int(* to_record_is_replaying)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1146
#define RECORD_FULL_IS_REPLAY
Definition: record-full.c:63
void handle_sigint(int sig)
Definition: event-top.c:839
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
struct bp_target_info target_info
Definition: breakpoint.h:445
static void record_full_close(struct target_ops *self)
Definition: record-full.c:882
static struct async_event_handler * record_full_async_inferior_event_token
Definition: record-full.c:784
bfd * core_bfd
Definition: corefile.c:58
static int record_full_get_sig
Definition: record-full.c:1009
int execution_direction
Definition: infrun.c:7561
void reinit_frame_cache(void)
Definition: frame.c:1687
static void record_full_core_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal)
Definition: record-full.c:1969
int(* to_stopped_data_address)(struct target_ops *, CORE_ADDR *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:546
struct address_space * placed_address_space
Definition: breakpoint.h:225
int record_check_stopped_by_breakpoint(struct address_space *aspace, CORE_ADDR pc, enum target_stop_reason *reason)
Definition: record.c:195
static int record_full_stopped_data_address(struct target_ops *ops, CORE_ADDR *addr_p)
Definition: record-full.c:1371
static void record_full_goto(struct target_ops *self, ULONGEST target_insn)
Definition: record-full.c:1909
static void bfdcore_read(bfd *obfd, asection *osec, void *buf, int len, int *offset)
Definition: record-full.c:2259
static void record_full_core_prepare_to_store(struct target_ops *self, struct regcache *regcache)
Definition: record-full.c:2017
#define target_async(ENABLE)
Definition: target.h:1754
void(* to_prepare_to_store)(struct target_ops *, struct regcache *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:476
union record_full_mem_entry::@133 u
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:474
#define target_thread_architecture(ptid)
Definition: target.h:1797
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
static int record_full_stopped_by_watchpoint(struct target_ops *ops)
Definition: record-full.c:1362
struct regcache * regcache
Definition: record-full.c:647
static void record_full_async_inferior_event_handler(gdb_client_data data)
Definition: record-full.c:787
static uint32_t netorder32(uint32_t input)
Definition: record-full.c:2282
int record_full_arch_list_add_end(void)
Definition: record-full.c:520
Definition: record-full.c:93
static void show_record_full_command(char *args, int from_tty)
Definition: record-full.c:2783
static int record_full_message_wrapper(void *args)
Definition: record-full.c:652
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:850
target_stop_reason
Definition: waitstatus.h:121
static void record_full_check_insn_num(int set_terminal)
Definition: record-full.c:538
void error(const char *fmt,...)
Definition: errors.c:38
static int record_full_core_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: record-full.c:2148
initialize_file_ftype _initialize_record_full
ptid_t minus_one_ptid
Definition: ptid.c:26
static void record_full_registers_change(struct regcache *regcache, int regnum)
Definition: record-full.c:1416
struct target_ops * beneath
Definition: target.h:431
int(* to_can_execute_reverse)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:801
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:930
static int record_full_stop_at_limit
Definition: record-full.c:197
static void record_full_save_cleanups(void *data)
Definition: record-full.c:2501
static void record_full_init_record_breakpoints(void)
Definition: record-full.c:1631
static struct record_full_entry * record_full_list
Definition: record-full.c:192
void(* to_goto_record)(struct target_ops *, ULONGEST insn) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1158
const ULONGEST const LONGEST len
Definition: target.h:309
static void record_full_save(struct target_ops *self, const char *recfilename)
Definition: record-full.c:2515
static void set_record_full_command(char *args, int from_tty)
Definition: record-full.c:2772
void add_deprecated_target_alias(struct target_ops *t, char *alias)
Definition: target.c:403