Simplify target_async hook interface
[external/binutils.git] / gdb / record-full.c
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
79 struct record_full_mem_entry
80 {
81   CORE_ADDR addr;
82   int len;
83   /* Set this flag if target memory for this entry
84      can no longer be accessed.  */
85   int mem_entry_not_accessible;
86   union
87   {
88     gdb_byte *ptr;
89     gdb_byte buf[sizeof (gdb_byte *)];
90   } u;
91 };
92
93 struct record_full_reg_entry
94 {
95   unsigned short num;
96   unsigned short len;
97   union 
98   {
99     gdb_byte *ptr;
100     gdb_byte buf[2 * sizeof (gdb_byte *)];
101   } u;
102 };
103
104 struct record_full_end_entry
105 {
106   enum gdb_signal sigval;
107   ULONGEST insn_num;
108 };
109
110 enum record_full_type
111 {
112   record_full_end = 0,
113   record_full_reg,
114   record_full_mem
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
141 struct record_full_entry
142 {
143   struct record_full_entry *prev;
144   struct record_full_entry *next;
145   enum record_full_type type;
146   union
147   {
148     /* reg */
149     struct record_full_reg_entry reg;
150     /* mem */
151     struct record_full_mem_entry mem;
152     /* end */
153     struct record_full_end_entry end;
154   } u;
155 };
156
157 /* If true, query if PREC cannot record memory
158    change of next instruction.  */
159 int record_full_memory_query = 0;
160
161 struct record_full_core_buf_entry
162 {
163   struct record_full_core_buf_entry *prev;
164   struct target_section *p;
165   bfd_byte *buf;
166 };
167
168 /* Record buf with core target.  */
169 static gdb_byte *record_full_core_regbuf = NULL;
170 static struct target_section *record_full_core_start;
171 static struct target_section *record_full_core_end;
172 static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
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
191 static struct record_full_entry record_full_first;
192 static struct record_full_entry *record_full_list = &record_full_first;
193 static struct record_full_entry *record_full_arch_list_head = NULL;
194 static struct record_full_entry *record_full_arch_list_tail = NULL;
195
196 /* 1 ask user. 0 auto delete the last struct record_full_entry.  */
197 static int record_full_stop_at_limit = 1;
198 /* Maximum allowed number of insns in execution log.  */
199 static unsigned int record_full_insn_max_num
200         = DEFAULT_RECORD_FULL_INSN_MAX_NUM;
201 /* Actual count of insns presently in execution log.  */
202 static unsigned int record_full_insn_num = 0;
203 /* Count of insns logged so far (may be larger
204    than count of insns presently in execution log).  */
205 static ULONGEST record_full_insn_count;
206
207 /* The target_ops of process record.  */
208 static struct target_ops record_full_ops;
209 static struct target_ops record_full_core_ops;
210
211 /* See record-full.h.  */
212
213 int
214 record_full_is_used (void)
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".  */
225 static struct cmd_list_element *set_record_full_cmdlist;
226 static struct cmd_list_element *show_record_full_cmdlist;
227
228 /* Command list for "record full".  */
229 static struct cmd_list_element *record_full_cmdlist;
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 *
242 record_full_reg_alloc (struct regcache *regcache, int regnum)
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
260 record_full_reg_release (struct record_full_entry *rec)
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 *
271 record_full_mem_alloc (CORE_ADDR addr, int len)
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
288 record_full_mem_release (struct record_full_entry *rec)
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 *
299 record_full_end_alloc (void)
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
312 record_full_end_release (struct record_full_entry *rec)
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
321 record_full_entry_release (struct record_full_entry *rec)
322 {
323   enum record_full_type type = rec->type;
324
325   switch (type) {
326   case record_full_reg:
327     record_full_reg_release (rec);
328     break;
329   case record_full_mem:
330     record_full_mem_release (rec);
331     break;
332   case record_full_end:
333     record_full_end_release (rec);
334     break;
335   }
336   return type;
337 }
338
339 /* Free all record entries in list pointed to by REC.  */
340
341 static void
342 record_full_list_release (struct record_full_entry *rec)
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;
353       record_full_entry_release (rec->next);
354     }
355
356   if (rec == &record_full_first)
357     {
358       record_full_insn_num = 0;
359       record_full_first.next = NULL;
360     }
361   else
362     record_full_entry_release (rec);
363 }
364
365 /* Free all record entries forward of the given list position.  */
366
367 static void
368 record_full_list_release_following (struct record_full_entry *rec)
369 {
370   struct record_full_entry *tmp = rec->next;
371
372   rec->next = NULL;
373   while (tmp)
374     {
375       rec = tmp->next;
376       if (record_full_entry_release (tmp) == record_full_end)
377         {
378           record_full_insn_num--;
379           record_full_insn_count--;
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
391 record_full_list_release_first (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.  */
407       if (record_full_entry_release (tmp) == record_full_end)
408         break;  /* End loop at first record_full_end.  */
409
410       if (!record_full_first.next)
411         {
412           gdb_assert (record_full_insn_num == 1);
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
421 record_full_arch_list_add (struct record_full_entry *rec)
422 {
423   if (record_debug > 1)
424     fprintf_unfiltered (gdb_stdlog,
425                         "Process record: record_full_arch_list_add %s.\n",
426                         host_address_to_string (rec));
427
428   if (record_full_arch_list_tail)
429     {
430       record_full_arch_list_tail->next = rec;
431       rec->prev = record_full_arch_list_tail;
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 *
443 record_full_get_loc (struct record_full_entry *rec)
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
466 record_full_arch_list_add_reg (struct regcache *regcache, int regnum)
467 {
468   struct record_full_entry *rec;
469
470   if (record_debug > 1)
471     fprintf_unfiltered (gdb_stdlog,
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
480   record_full_arch_list_add (rec);
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
489 record_full_arch_list_add_mem (CORE_ADDR addr, int len)
490 {
491   struct record_full_entry *rec;
492
493   if (record_debug > 1)
494     fprintf_unfiltered (gdb_stdlog,
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     {
507       record_full_mem_release (rec);
508       return -1;
509     }
510
511   record_full_arch_list_add (rec);
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
520 record_full_arch_list_add_end (void)
521 {
522   struct record_full_entry *rec;
523
524   if (record_debug > 1)
525     fprintf_unfiltered (gdb_stdlog,
526                         "Process record: add end to arch list.\n");
527
528   rec = record_full_end_alloc ();
529   rec->u.end.sigval = GDB_SIGNAL_0;
530   rec->u.end.insn_num = ++record_full_insn_count;
531
532   record_full_arch_list_add (rec);
533
534   return 0;
535 }
536
537 static void
538 record_full_check_insn_num (int set_terminal)
539 {
540   if (record_full_insn_num == record_full_insn_max_num)
541     {
542       /* Ask user what to do.  */
543       if (record_full_stop_at_limit)
544         {
545           int q;
546
547           if (set_terminal)
548             target_terminal_ours ();
549           q = yquery (_("Do you want to auto delete previous execution "
550                         "log entries when record/replay buffer becomes "
551                         "full (record full stop-at-limit)?"));
552           if (set_terminal)
553             target_terminal_inferior ();
554           if (q)
555             record_full_stop_at_limit = 0;
556           else
557             error (_("Process record: stopped by user."));
558         }
559     }
560 }
561
562 static void
563 record_full_arch_list_cleanups (void *ignore)
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
580     = make_cleanup (record_full_arch_list_cleanups, 0);
581
582   record_full_arch_list_head = NULL;
583   record_full_arch_list_tail = NULL;
584
585   /* Check record_full_insn_num.  */
586   record_full_check_insn_num (1);
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
638   if (record_full_insn_num == record_full_insn_max_num)
639     record_full_list_release_first ();
640   else
641     record_full_insn_num++;
642
643   return 1;
644 }
645
646 struct record_full_message_args {
647   struct regcache *regcache;
648   enum gdb_signal signal;
649 };
650
651 static int
652 record_full_message_wrapper (void *args)
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
661 record_full_message_wrapper_safe (struct regcache *regcache,
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,
670                        RETURN_MASK_ALL);
671 }
672
673 /* Set to 1 if record_full_store_registers and record_full_xfer_partial
674    doesn't need record.  */
675
676 static int record_full_gdb_operation_disable = 0;
677
678 struct cleanup *
679 record_full_gdb_operation_disable_set (void)
680 {
681   struct cleanup *old_cleanups = NULL;
682
683   old_cleanups =
684     make_cleanup_restore_integer (&record_full_gdb_operation_disable);
685   record_full_gdb_operation_disable = 1;
686
687   return old_cleanups;
688 }
689
690 /* Flag set to TRUE for target_stopped_by_watchpoint.  */
691 static enum target_stop_reason record_full_stop_reason
692   = TARGET_STOPPED_BY_NO_REASON;
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
699 record_full_exec_insn (struct regcache *regcache,
700                        struct gdbarch *gdbarch,
701                        struct record_full_entry *entry)
702 {
703   switch (entry->type)
704     {
705     case record_full_reg: /* reg */
706       {
707         gdb_byte reg[MAX_REGISTER_SIZE];
708
709         if (record_debug > 1)
710           fprintf_unfiltered (gdb_stdlog,
711                               "Process record: record_full_reg %s to "
712                               "inferior num = %d.\n",
713                               host_address_to_string (entry),
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)
731               fprintf_unfiltered (gdb_stdlog,
732                                   "Process record: record_full_mem %s to "
733                                   "inferior addr = %s len = %d.\n",
734                                   host_address_to_string (entry),
735                                   paddress (gdbarch, entry->u.mem.addr),
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.  */
767                     if (hardware_watchpoint_inserted_in_range
768                         (get_regcache_aspace (regcache),
769                          entry->u.mem.addr, entry->u.mem.len))
770                       record_full_stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
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
784 static struct async_event_handler *record_full_async_inferior_event_token;
785
786 static void
787 record_full_async_inferior_event_handler (gdb_client_data data)
788 {
789   inferior_event_handler (INF_REG_EVENT, NULL);
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 {
797   struct regcache *regcache = get_current_regcache ();
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);
803   record_full_core_regbuf = xmalloc (MAX_REGISTER_SIZE * regnum);
804   for (i = 0; i < regnum; i ++)
805     regcache_raw_collect (regcache, i,
806                           record_full_core_regbuf + MAX_REGISTER_SIZE * i);
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     {
812       xfree (record_full_core_regbuf);
813       record_full_core_regbuf = NULL;
814       error (_("\"%s\": Can't find sections: %s"),
815              bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
816     }
817
818   push_target (&record_full_core_ops);
819   record_full_restore ();
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 */
831   if (!target_has_execution)
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
837   if (!gdbarch_process_record_p (target_gdbarch ()))
838     error (_("Process record: the current architecture doesn't support "
839              "record function."));
840
841   push_target (&record_full_ops);
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 */
859   record_full_insn_num = 0;
860   record_full_insn_count = 0;
861   record_full_list = &record_full_first;
862   record_full_list->next = NULL;
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
871     = create_async_event_handler (record_full_async_inferior_event_handler,
872                                   NULL);
873
874   record_full_init_record_breakpoints ();
875
876   observer_notify_record_changed (current_inferior (),  1);
877 }
878
879 /* "to_close" target method.  Close the process record target.  */
880
881 static void
882 record_full_close (struct target_ops *self)
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.  */
892   if (record_full_core_regbuf)
893     {
894       xfree (record_full_core_regbuf);
895       record_full_core_regbuf = NULL;
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
917 record_full_async (struct target_ops *ops, int enable)
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 */
948 static enum exec_direction_kind record_full_execution_dir = EXEC_FORWARD;
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 {
956   record_full_resume_step = step;
957   record_full_resumed = 1;
958   record_full_execution_dir = execution_direction;
959
960   if (!RECORD_FULL_IS_REPLAY)
961     {
962       struct gdbarch *gdbarch = target_thread_architecture (ptid);
963
964       record_full_message (get_current_regcache (), signal);
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.  */
977               if (thread_has_single_step_breakpoints_set (inferior_thread ()))
978                 {
979                   /* This is a soft single step.  */
980                   record_full_resume_step = 1;
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
1014 record_full_sig_handler (int signo)
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.  */
1020   record_full_resume_step = 1;
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
1028 record_full_wait_cleanups (void *ignore)
1029 {
1030   if (execution_direction == EXEC_REVERSE)
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
1053 record_full_wait_1 (struct target_ops *ops,
1054                     ptid_t ptid, struct target_waitstatus *status,
1055                     int options)
1056 {
1057   struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
1058
1059   if (record_debug)
1060     fprintf_unfiltered (gdb_stdlog,
1061                         "Process record: record_full_wait "
1062                         "record_full_resume_step = %d, "
1063                         "record_full_resumed = %d, direction=%s\n",
1064                         record_full_resume_step, record_full_resumed,
1065                         record_full_execution_dir == EXEC_FORWARD
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
1080   record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1081
1082   if (!RECORD_FULL_IS_REPLAY && ops != &record_full_core_ops)
1083     {
1084       if (record_full_resume_step)
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;
1094           struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);
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)
1104                     fprintf_unfiltered (gdb_stdlog,
1105                                         "Process record: record_full_wait "
1106                                         "target beneath not done yet\n");
1107                   return ret;
1108                 }
1109
1110               ALL_NON_EXITED_THREADS (tp)
1111                 delete_single_step_breakpoints (tp);
1112
1113               if (record_full_resume_step)
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
1123                     = &record_full_stop_reason;
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
1134                   if (target_stopped_by_watchpoint ())
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.  */
1164                           set_executing (inferior_ptid, 0);
1165                           reinit_frame_cache ();
1166                           if (gdbarch_software_single_step (gdbarch,
1167                                                             get_current_frame ()))
1168                             step = 0;
1169                           set_executing (inferior_ptid, 1);
1170                         }
1171
1172                       if (record_debug)
1173                         fprintf_unfiltered (gdb_stdlog,
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
1198         = make_cleanup (record_full_wait_cleanups, 0);
1199       CORE_ADDR tmp_pc;
1200
1201       record_full_stop_reason = TARGET_STOPPED_BY_NO_REASON;
1202       status->kind = TARGET_WAITKIND_STOPPED;
1203
1204       /* Check breakpoint when forward execute.  */
1205       if (execution_direction == EXEC_FORWARD)
1206         {
1207           tmp_pc = regcache_read_pc (regcache);
1208           if (record_check_stopped_by_breakpoint (aspace, tmp_pc,
1209                                                   &record_full_stop_reason))
1210             {
1211               if (record_debug)
1212                 fprintf_unfiltered (gdb_stdlog,
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.  */
1223       target_terminal_ours ();
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.  */
1235           if (execution_direction == EXEC_REVERSE
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)
1254                 fprintf_unfiltered (gdb_stdlog,
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 */
1272                   if (record_full_resume_step)
1273                     {
1274                       if (record_debug > 1)
1275                         fprintf_unfiltered (gdb_stdlog,
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,
1283                                                           &record_full_stop_reason))
1284                     {
1285                       if (record_debug)
1286                         fprintf_unfiltered (gdb_stdlog,
1287                                             "Process record: break "
1288                                             "at %s.\n",
1289                                             paddress (gdbarch, tmp_pc));
1290
1291                       continue_flag = 0;
1292                     }
1293
1294                   if (record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
1295                     {
1296                       if (record_debug)
1297                         fprintf_unfiltered (gdb_stdlog,
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             {
1311               if (execution_direction == EXEC_REVERSE)
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
1344 record_full_wait (struct target_ops *ops,
1345                   ptid_t ptid, struct target_waitstatus *status,
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
1362 record_full_stopped_by_watchpoint (struct target_ops *ops)
1363 {
1364   if (RECORD_FULL_IS_REPLAY)
1365     return record_full_stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
1366   else
1367     return ops->beneath->to_stopped_by_watchpoint (ops->beneath);
1368 }
1369
1370 static int
1371 record_full_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
1372 {
1373   if (RECORD_FULL_IS_REPLAY)
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
1382 record_full_stopped_by_sw_breakpoint (struct target_ops *ops)
1383 {
1384   return record_full_stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
1385 }
1386
1387 /* The to_supports_stopped_by_sw_breakpoint method of target
1388    record-full.  */
1389
1390 static int
1391 record_full_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
1392 {
1393   return 1;
1394 }
1395
1396 /* The to_stopped_by_hw_breakpoint method of target record-full.  */
1397
1398 static int
1399 record_full_stopped_by_hw_breakpoint (struct target_ops *ops)
1400 {
1401   return record_full_stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
1402 }
1403
1404 /* The to_supports_stopped_by_sw_breakpoint method of target
1405    record-full.  */
1406
1407 static int
1408 record_full_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
1409 {
1410   return 1;
1411 }
1412
1413 /* Record registers change (by user or by GDB) to list as an instruction.  */
1414
1415 static void
1416 record_full_registers_change (struct regcache *regcache, int regnum)
1417 {
1418   /* Check record_full_insn_num.  */
1419   record_full_check_insn_num (0);
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     }
1445   if (record_full_arch_list_add_end ())
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
1454   if (record_full_insn_num == record_full_insn_max_num)
1455     record_full_list_release_first ();
1456   else
1457     record_full_insn_num++;
1458 }
1459
1460 /* "to_store_registers" method for process record target.  */
1461
1462 static void
1463 record_full_store_registers (struct target_ops *ops,
1464                              struct regcache *regcache,
1465                              int regno)
1466 {
1467   if (!record_full_gdb_operation_disable)
1468     {
1469       if (RECORD_FULL_IS_REPLAY)
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?"),
1485                       gdbarch_register_name (get_regcache_arch (regcache),
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
1522 record_full_xfer_partial (struct target_ops *ops, enum target_object object,
1523                           const char *annex, gdb_byte *readbuf,
1524                           const gdb_byte *writebuf, ULONGEST offset,
1525                           ULONGEST len, ULONGEST *xfered_len)
1526 {
1527   if (!record_full_gdb_operation_disable
1528       && (object == TARGET_OBJECT_MEMORY
1529           || object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
1530     {
1531       if (RECORD_FULL_IS_REPLAY)
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 */
1545       record_full_check_insn_num (0);
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)
1554             fprintf_unfiltered (gdb_stdlog,
1555                                 "Process record: failed to record "
1556                                 "execution log.");
1557           return TARGET_XFER_E_IO;
1558         }
1559       if (record_full_arch_list_add_end ())
1560         {
1561           record_full_list_release (record_full_arch_list_tail);
1562           if (record_debug)
1563             fprintf_unfiltered (gdb_stdlog,
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
1572       if (record_full_insn_num == record_full_insn_max_num)
1573         record_full_list_release_first ();
1574       else
1575         record_full_insn_num++;
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
1590 struct record_full_breakpoint
1591 {
1592   /* The address and address space the breakpoint was set at.  */
1593   struct address_space *address_space;
1594   CORE_ADDR addr;
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.  */
1599   int in_target_beneath;
1600 };
1601
1602 typedef struct record_full_breakpoint *record_full_breakpoint_p;
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 {
1612   if (loc->loc_type != bp_loc_software_breakpoint)
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;
1620       bp->address_space = loc->target_info.placed_address_space;
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
1631 record_full_init_record_breakpoints (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
1643 record_full_insert_breakpoint (struct target_ops *ops,
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
1681 record_full_remove_breakpoint (struct target_ops *ops,
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
1722 record_full_can_execute_reverse (struct target_ops *self)
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)
1742         fprintf_unfiltered (gdb_stdlog,
1743                             "record_full_get_bookmark returns %s\n", ret);
1744       else
1745         fprintf_unfiltered (gdb_stdlog,
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
1754 record_full_goto_bookmark (struct target_ops *self,
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)
1761     fprintf_unfiltered (gdb_stdlog,
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
1783 record_full_execution_direction (struct target_ops *self)
1784 {
1785   return record_full_execution_dir;
1786 }
1787
1788 static void
1789 record_full_info (struct target_ops *self)
1790 {
1791   struct record_full_entry *p;
1792
1793   if (RECORD_FULL_IS_REPLAY)
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.  */
1812       if (RECORD_FULL_IS_REPLAY)
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"),
1818                        pulongest (record_full_insn_count));
1819
1820       /* Display log count.  */
1821       printf_filtered (_("Log contains %u instructions.\n"),
1822                        record_full_insn_num);
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"),
1829                    record_full_insn_max_num);
1830 }
1831
1832 /* The "to_record_delete" target method.  */
1833
1834 static void
1835 record_full_delete (struct target_ops *self)
1836 {
1837   record_full_list_release_following (record_full_list);
1838 }
1839
1840 /* The "to_record_is_replaying" target method.  */
1841
1842 static int
1843 record_full_is_replaying (struct target_ops *self)
1844 {
1845   return RECORD_FULL_IS_REPLAY;
1846 }
1847
1848 /* Go to a specific entry.  */
1849
1850 static void
1851 record_full_goto_entry (struct record_full_entry *p)
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));
1861       record_full_goto_insn (p, EXEC_FORWARD);
1862     }
1863   else
1864     {
1865       printf_filtered (_("Go backward to insn number %s\n"),
1866                        pulongest (p->u.end.insn_num));
1867       record_full_goto_insn (p, EXEC_REVERSE);
1868     }
1869
1870   registers_changed ();
1871   reinit_frame_cache ();
1872   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1873 }
1874
1875 /* The "to_goto_record_begin" target method.  */
1876
1877 static void
1878 record_full_goto_begin (struct target_ops *self)
1879 {
1880   struct record_full_entry *p = NULL;
1881
1882   for (p = &record_full_first; p != NULL; p = p->next)
1883     if (p->type == record_full_end)
1884       break;
1885
1886   record_full_goto_entry (p);
1887 }
1888
1889 /* The "to_goto_record_end" target method.  */
1890
1891 static void
1892 record_full_goto_end (struct target_ops *self)
1893 {
1894   struct record_full_entry *p = NULL;
1895
1896   for (p = record_full_list; p->next != NULL; p = p->next)
1897     ;
1898   for (; p!= NULL; p = p->prev)
1899     if (p->type == record_full_end)
1900       break;
1901
1902   record_full_goto_entry (p);
1903 }
1904
1905 /* The "to_goto_record" target method.  */
1906
1907 static void
1908 record_full_goto (struct target_ops *self, ULONGEST target_insn)
1909 {
1910   struct record_full_entry *p = NULL;
1911
1912   for (p = &record_full_first; p != NULL; p = p->next)
1913     if (p->type == record_full_end && p->u.end.insn_num == target_insn)
1914       break;
1915
1916   record_full_goto_entry (p);
1917 }
1918
1919 static void
1920 init_record_full_ops (void)
1921 {
1922   record_full_ops.to_shortname = "record-full";
1923   record_full_ops.to_longname = "Process record and replay target";
1924   record_full_ops.to_doc =
1925     "Log program while executing and replay execution from log.";
1926   record_full_ops.to_open = record_full_open;
1927   record_full_ops.to_close = record_full_close;
1928   record_full_ops.to_async = record_full_async;
1929   record_full_ops.to_resume = record_full_resume;
1930   record_full_ops.to_wait = record_full_wait;
1931   record_full_ops.to_disconnect = record_disconnect;
1932   record_full_ops.to_detach = record_detach;
1933   record_full_ops.to_mourn_inferior = record_mourn_inferior;
1934   record_full_ops.to_kill = record_kill;
1935   record_full_ops.to_store_registers = record_full_store_registers;
1936   record_full_ops.to_xfer_partial = record_full_xfer_partial;
1937   record_full_ops.to_insert_breakpoint = record_full_insert_breakpoint;
1938   record_full_ops.to_remove_breakpoint = record_full_remove_breakpoint;
1939   record_full_ops.to_stopped_by_watchpoint = record_full_stopped_by_watchpoint;
1940   record_full_ops.to_stopped_data_address = record_full_stopped_data_address;
1941   record_full_ops.to_stopped_by_sw_breakpoint
1942     = record_full_stopped_by_sw_breakpoint;
1943   record_full_ops.to_supports_stopped_by_sw_breakpoint
1944     = record_full_supports_stopped_by_sw_breakpoint;
1945   record_full_ops.to_stopped_by_hw_breakpoint
1946     = record_full_stopped_by_hw_breakpoint;
1947   record_full_ops.to_supports_stopped_by_hw_breakpoint
1948     = record_full_supports_stopped_by_hw_breakpoint;
1949   record_full_ops.to_can_execute_reverse = record_full_can_execute_reverse;
1950   record_full_ops.to_stratum = record_stratum;
1951   /* Add bookmark target methods.  */
1952   record_full_ops.to_get_bookmark = record_full_get_bookmark;
1953   record_full_ops.to_goto_bookmark = record_full_goto_bookmark;
1954   record_full_ops.to_execution_direction = record_full_execution_direction;
1955   record_full_ops.to_info_record = record_full_info;
1956   record_full_ops.to_save_record = record_full_save;
1957   record_full_ops.to_delete_record = record_full_delete;
1958   record_full_ops.to_record_is_replaying = record_full_is_replaying;
1959   record_full_ops.to_goto_record_begin = record_full_goto_begin;
1960   record_full_ops.to_goto_record_end = record_full_goto_end;
1961   record_full_ops.to_goto_record = record_full_goto;
1962   record_full_ops.to_magic = OPS_MAGIC;
1963 }
1964
1965 /* "to_resume" method for prec over corefile.  */
1966
1967 static void
1968 record_full_core_resume (struct target_ops *ops, ptid_t ptid, int step,
1969                          enum gdb_signal signal)
1970 {
1971   record_full_resume_step = step;
1972   record_full_resumed = 1;
1973   record_full_execution_dir = execution_direction;
1974
1975   /* We are about to start executing the inferior (or simulate it),
1976      let's register it with the event loop.  */
1977   if (target_can_async_p ())
1978     target_async (1);
1979 }
1980
1981 /* "to_kill" method for prec over corefile.  */
1982
1983 static void
1984 record_full_core_kill (struct target_ops *ops)
1985 {
1986   if (record_debug)
1987     fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
1988
1989   unpush_target (&record_full_core_ops);
1990 }
1991
1992 /* "to_fetch_registers" method for prec over corefile.  */
1993
1994 static void
1995 record_full_core_fetch_registers (struct target_ops *ops,
1996                                   struct regcache *regcache,
1997                                   int regno)
1998 {
1999   if (regno < 0)
2000     {
2001       int num = gdbarch_num_regs (get_regcache_arch (regcache));
2002       int i;
2003
2004       for (i = 0; i < num; i ++)
2005         regcache_raw_supply (regcache, i,
2006                              record_full_core_regbuf + MAX_REGISTER_SIZE * i);
2007     }
2008   else
2009     regcache_raw_supply (regcache, regno,
2010                          record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2011 }
2012
2013 /* "to_prepare_to_store" method for prec over corefile.  */
2014
2015 static void
2016 record_full_core_prepare_to_store (struct target_ops *self,
2017                                    struct regcache *regcache)
2018 {
2019 }
2020
2021 /* "to_store_registers" method for prec over corefile.  */
2022
2023 static void
2024 record_full_core_store_registers (struct target_ops *ops,
2025                              struct regcache *regcache,
2026                              int regno)
2027 {
2028   if (record_full_gdb_operation_disable)
2029     regcache_raw_collect (regcache, regno,
2030                           record_full_core_regbuf + MAX_REGISTER_SIZE * regno);
2031   else
2032     error (_("You can't do that without a process to debug."));
2033 }
2034
2035 /* "to_xfer_partial" method for prec over corefile.  */
2036
2037 static enum target_xfer_status
2038 record_full_core_xfer_partial (struct target_ops *ops,
2039                                enum target_object object,
2040                                const char *annex, gdb_byte *readbuf,
2041                                const gdb_byte *writebuf, ULONGEST offset,
2042                                ULONGEST len, ULONGEST *xfered_len)
2043 {
2044   if (object == TARGET_OBJECT_MEMORY)
2045     {
2046       if (record_full_gdb_operation_disable || !writebuf)
2047         {
2048           struct target_section *p;
2049
2050           for (p = record_full_core_start; p < record_full_core_end; p++)
2051             {
2052               if (offset >= p->addr)
2053                 {
2054                   struct record_full_core_buf_entry *entry;
2055                   ULONGEST sec_offset;
2056
2057                   if (offset >= p->endaddr)
2058                     continue;
2059
2060                   if (offset + len > p->endaddr)
2061                     len = p->endaddr - offset;
2062
2063                   sec_offset = offset - p->addr;
2064
2065                   /* Read readbuf or write writebuf p, offset, len.  */
2066                   /* Check flags.  */
2067                   if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
2068                       || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
2069                     {
2070                       if (readbuf)
2071                         memset (readbuf, 0, len);
2072
2073                       *xfered_len = len;
2074                       return TARGET_XFER_OK;
2075                     }
2076                   /* Get record_full_core_buf_entry.  */
2077                   for (entry = record_full_core_buf_list; entry;
2078                        entry = entry->prev)
2079                     if (entry->p == p)
2080                       break;
2081                   if (writebuf)
2082                     {
2083                       if (!entry)
2084                         {
2085                           /* Add a new entry.  */
2086                           entry = (struct record_full_core_buf_entry *)
2087                             xmalloc
2088                             (sizeof (struct record_full_core_buf_entry));
2089                           entry->p = p;
2090                           if (!bfd_malloc_and_get_section
2091                                 (p->the_bfd_section->owner,
2092                                  p->the_bfd_section,
2093                                  &entry->buf))
2094                             {
2095                               xfree (entry);
2096                               return TARGET_XFER_EOF;
2097                             }
2098                           entry->prev = record_full_core_buf_list;
2099                           record_full_core_buf_list = entry;
2100                         }
2101
2102                       memcpy (entry->buf + sec_offset, writebuf,
2103                               (size_t) len);
2104                     }
2105                   else
2106                     {
2107                       if (!entry)
2108                         return ops->beneath->to_xfer_partial (ops->beneath,
2109                                                               object, annex,
2110                                                               readbuf, writebuf,
2111                                                               offset, len,
2112                                                               xfered_len);
2113
2114                       memcpy (readbuf, entry->buf + sec_offset,
2115                               (size_t) len);
2116                     }
2117
2118                   *xfered_len = len;
2119                   return TARGET_XFER_OK;
2120                 }
2121             }
2122
2123           return TARGET_XFER_E_IO;
2124         }
2125       else
2126         error (_("You can't do that without a process to debug."));
2127     }
2128
2129   return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2130                                         readbuf, writebuf, offset, len,
2131                                         xfered_len);
2132 }
2133
2134 /* "to_insert_breakpoint" method for prec over corefile.  */
2135
2136 static int
2137 record_full_core_insert_breakpoint (struct target_ops *ops,
2138                                     struct gdbarch *gdbarch,
2139                                     struct bp_target_info *bp_tgt)
2140 {
2141   return 0;
2142 }
2143
2144 /* "to_remove_breakpoint" method for prec over corefile.  */
2145
2146 static int
2147 record_full_core_remove_breakpoint (struct target_ops *ops,
2148                                     struct gdbarch *gdbarch,
2149                                     struct bp_target_info *bp_tgt)
2150 {
2151   return 0;
2152 }
2153
2154 /* "to_has_execution" method for prec over corefile.  */
2155
2156 static int
2157 record_full_core_has_execution (struct target_ops *ops, ptid_t the_ptid)
2158 {
2159   return 1;
2160 }
2161
2162 static void
2163 init_record_full_core_ops (void)
2164 {
2165   record_full_core_ops.to_shortname = "record-core";
2166   record_full_core_ops.to_longname = "Process record and replay target";
2167   record_full_core_ops.to_doc =
2168     "Log program while executing and replay execution from log.";
2169   record_full_core_ops.to_open = record_full_open;
2170   record_full_core_ops.to_close = record_full_close;
2171   record_full_core_ops.to_async = record_full_async;
2172   record_full_core_ops.to_resume = record_full_core_resume;
2173   record_full_core_ops.to_wait = record_full_wait;
2174   record_full_core_ops.to_kill = record_full_core_kill;
2175   record_full_core_ops.to_fetch_registers = record_full_core_fetch_registers;
2176   record_full_core_ops.to_prepare_to_store = record_full_core_prepare_to_store;
2177   record_full_core_ops.to_store_registers = record_full_core_store_registers;
2178   record_full_core_ops.to_xfer_partial = record_full_core_xfer_partial;
2179   record_full_core_ops.to_insert_breakpoint
2180     = record_full_core_insert_breakpoint;
2181   record_full_core_ops.to_remove_breakpoint
2182     = record_full_core_remove_breakpoint;
2183   record_full_core_ops.to_stopped_by_watchpoint
2184     = record_full_stopped_by_watchpoint;
2185   record_full_core_ops.to_stopped_data_address
2186     = record_full_stopped_data_address;
2187   record_full_core_ops.to_stopped_by_sw_breakpoint
2188     = record_full_stopped_by_sw_breakpoint;
2189   record_full_core_ops.to_supports_stopped_by_sw_breakpoint
2190     = record_full_supports_stopped_by_sw_breakpoint;
2191   record_full_core_ops.to_stopped_by_hw_breakpoint
2192     = record_full_stopped_by_hw_breakpoint;
2193   record_full_core_ops.to_supports_stopped_by_hw_breakpoint
2194     = record_full_supports_stopped_by_hw_breakpoint;
2195   record_full_core_ops.to_can_execute_reverse
2196     = record_full_can_execute_reverse;
2197   record_full_core_ops.to_has_execution = record_full_core_has_execution;
2198   record_full_core_ops.to_stratum = record_stratum;
2199   /* Add bookmark target methods.  */
2200   record_full_core_ops.to_get_bookmark = record_full_get_bookmark;
2201   record_full_core_ops.to_goto_bookmark = record_full_goto_bookmark;
2202   record_full_core_ops.to_execution_direction
2203     = record_full_execution_direction;
2204   record_full_core_ops.to_info_record = record_full_info;
2205   record_full_core_ops.to_delete_record = record_full_delete;
2206   record_full_core_ops.to_record_is_replaying = record_full_is_replaying;
2207   record_full_core_ops.to_goto_record_begin = record_full_goto_begin;
2208   record_full_core_ops.to_goto_record_end = record_full_goto_end;
2209   record_full_core_ops.to_goto_record = record_full_goto;
2210   record_full_core_ops.to_magic = OPS_MAGIC;
2211 }
2212
2213 /* Record log save-file format
2214    Version 1 (never released)
2215
2216    Header:
2217      4 bytes: magic number htonl(0x20090829).
2218        NOTE: be sure to change whenever this file format changes!
2219
2220    Records:
2221      record_full_end:
2222        1 byte:  record type (record_full_end, see enum record_full_type).
2223      record_full_reg:
2224        1 byte:  record type (record_full_reg, see enum record_full_type).
2225        8 bytes: register id (network byte order).
2226        MAX_REGISTER_SIZE bytes: register value.
2227      record_full_mem:
2228        1 byte:  record type (record_full_mem, see enum record_full_type).
2229        8 bytes: memory length (network byte order).
2230        8 bytes: memory address (network byte order).
2231        n bytes: memory value (n == memory length).
2232
2233    Version 2
2234      4 bytes: magic number netorder32(0x20091016).
2235        NOTE: be sure to change whenever this file format changes!
2236
2237    Records:
2238      record_full_end:
2239        1 byte:  record type (record_full_end, see enum record_full_type).
2240        4 bytes: signal
2241        4 bytes: instruction count
2242      record_full_reg:
2243        1 byte:  record type (record_full_reg, see enum record_full_type).
2244        4 bytes: register id (network byte order).
2245        n bytes: register value (n == actual register size).
2246                 (eg. 4 bytes for x86 general registers).
2247      record_full_mem:
2248        1 byte:  record type (record_full_mem, see enum record_full_type).
2249        4 bytes: memory length (network byte order).
2250        8 bytes: memory address (network byte order).
2251        n bytes: memory value (n == memory length).
2252
2253 */
2254
2255 /* bfdcore_read -- read bytes from a core file section.  */
2256
2257 static inline void
2258 bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2259 {
2260   int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2261
2262   if (ret)
2263     *offset += len;
2264   else
2265     error (_("Failed to read %d bytes from core file %s ('%s')."),
2266            len, bfd_get_filename (obfd),
2267            bfd_errmsg (bfd_get_error ()));
2268 }
2269
2270 static inline uint64_t
2271 netorder64 (uint64_t input)
2272 {
2273   uint64_t ret;
2274
2275   store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret), 
2276                           BFD_ENDIAN_BIG, input);
2277   return ret;
2278 }
2279
2280 static inline uint32_t
2281 netorder32 (uint32_t input)
2282 {
2283   uint32_t ret;
2284
2285   store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret), 
2286                           BFD_ENDIAN_BIG, input);
2287   return ret;
2288 }
2289
2290 static inline uint16_t
2291 netorder16 (uint16_t input)
2292 {
2293   uint16_t ret;
2294
2295   store_unsigned_integer ((gdb_byte *) &ret, sizeof (ret), 
2296                           BFD_ENDIAN_BIG, input);
2297   return ret;
2298 }
2299
2300 /* Restore the execution log from a core_bfd file.  */
2301 static void
2302 record_full_restore (void)
2303 {
2304   uint32_t magic;
2305   struct cleanup *old_cleanups;
2306   struct record_full_entry *rec;
2307   asection *osec;
2308   uint32_t osec_size;
2309   int bfd_offset = 0;
2310   struct regcache *regcache;
2311
2312   /* We restore the execution log from the open core bfd,
2313      if there is one.  */
2314   if (core_bfd == NULL)
2315     return;
2316
2317   /* "record_full_restore" can only be called when record list is empty.  */
2318   gdb_assert (record_full_first.next == NULL);
2319  
2320   if (record_debug)
2321     fprintf_unfiltered (gdb_stdlog, "Restoring recording from core file.\n");
2322
2323   /* Now need to find our special note section.  */
2324   osec = bfd_get_section_by_name (core_bfd, "null0");
2325   if (record_debug)
2326     fprintf_unfiltered (gdb_stdlog, "Find precord section %s.\n",
2327                         osec ? "succeeded" : "failed");
2328   if (osec == NULL)
2329     return;
2330   osec_size = bfd_section_size (core_bfd, osec);
2331   if (record_debug)
2332     fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
2333
2334   /* Check the magic code.  */
2335   bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
2336   if (magic != RECORD_FULL_FILE_MAGIC)
2337     error (_("Version mis-match or file format error in core file %s."),
2338            bfd_get_filename (core_bfd));
2339   if (record_debug)
2340     fprintf_unfiltered (gdb_stdlog,
2341                         "  Reading 4-byte magic cookie "
2342                         "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2343                         phex_nz (netorder32 (magic), 4));
2344
2345   /* Restore the entries in recfd into record_full_arch_list_head and
2346      record_full_arch_list_tail.  */
2347   record_full_arch_list_head = NULL;
2348   record_full_arch_list_tail = NULL;
2349   record_full_insn_num = 0;
2350   old_cleanups = make_cleanup (record_full_arch_list_cleanups, 0);
2351   regcache = get_current_regcache ();
2352
2353   while (1)
2354     {
2355       uint8_t rectype;
2356       uint32_t regnum, len, signal, count;
2357       uint64_t addr;
2358
2359       /* We are finished when offset reaches osec_size.  */
2360       if (bfd_offset >= osec_size)
2361         break;
2362       bfdcore_read (core_bfd, osec, &rectype, sizeof (rectype), &bfd_offset);
2363
2364       switch (rectype)
2365         {
2366         case record_full_reg: /* reg */
2367           /* Get register number to regnum.  */
2368           bfdcore_read (core_bfd, osec, &regnum,
2369                         sizeof (regnum), &bfd_offset);
2370           regnum = netorder32 (regnum);
2371
2372           rec = record_full_reg_alloc (regcache, regnum);
2373
2374           /* Get val.  */
2375           bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2376                         rec->u.reg.len, &bfd_offset);
2377
2378           if (record_debug)
2379             fprintf_unfiltered (gdb_stdlog,
2380                                 "  Reading register %d (1 "
2381                                 "plus %lu plus %d bytes)\n",
2382                                 rec->u.reg.num,
2383                                 (unsigned long) sizeof (regnum),
2384                                 rec->u.reg.len);
2385           break;
2386
2387         case record_full_mem: /* mem */
2388           /* Get len.  */
2389           bfdcore_read (core_bfd, osec, &len, 
2390                         sizeof (len), &bfd_offset);
2391           len = netorder32 (len);
2392
2393           /* Get addr.  */
2394           bfdcore_read (core_bfd, osec, &addr,
2395                         sizeof (addr), &bfd_offset);
2396           addr = netorder64 (addr);
2397
2398           rec = record_full_mem_alloc (addr, len);
2399
2400           /* Get val.  */
2401           bfdcore_read (core_bfd, osec, record_full_get_loc (rec),
2402                         rec->u.mem.len, &bfd_offset);
2403
2404           if (record_debug)
2405             fprintf_unfiltered (gdb_stdlog,
2406                                 "  Reading memory %s (1 plus "
2407                                 "%lu plus %lu plus %d bytes)\n",
2408                                 paddress (get_current_arch (),
2409                                           rec->u.mem.addr),
2410                                 (unsigned long) sizeof (addr),
2411                                 (unsigned long) sizeof (len),
2412                                 rec->u.mem.len);
2413           break;
2414
2415         case record_full_end: /* end */
2416           rec = record_full_end_alloc ();
2417           record_full_insn_num ++;
2418
2419           /* Get signal value.  */
2420           bfdcore_read (core_bfd, osec, &signal, 
2421                         sizeof (signal), &bfd_offset);
2422           signal = netorder32 (signal);
2423           rec->u.end.sigval = signal;
2424
2425           /* Get insn count.  */
2426           bfdcore_read (core_bfd, osec, &count, 
2427                         sizeof (count), &bfd_offset);
2428           count = netorder32 (count);
2429           rec->u.end.insn_num = count;
2430           record_full_insn_count = count + 1;
2431           if (record_debug)
2432             fprintf_unfiltered (gdb_stdlog,
2433                                 "  Reading record_full_end (1 + "
2434                                 "%lu + %lu bytes), offset == %s\n",
2435                                 (unsigned long) sizeof (signal),
2436                                 (unsigned long) sizeof (count),
2437                                 paddress (get_current_arch (),
2438                                           bfd_offset));
2439           break;
2440
2441         default:
2442           error (_("Bad entry type in core file %s."),
2443                  bfd_get_filename (core_bfd));
2444           break;
2445         }
2446
2447       /* Add rec to record arch list.  */
2448       record_full_arch_list_add (rec);
2449     }
2450
2451   discard_cleanups (old_cleanups);
2452
2453   /* Add record_full_arch_list_head to the end of record list.  */
2454   record_full_first.next = record_full_arch_list_head;
2455   record_full_arch_list_head->prev = &record_full_first;
2456   record_full_arch_list_tail->next = NULL;
2457   record_full_list = &record_full_first;
2458
2459   /* Update record_full_insn_max_num.  */
2460   if (record_full_insn_num > record_full_insn_max_num)
2461     {
2462       record_full_insn_max_num = record_full_insn_num;
2463       warning (_("Auto increase record/replay buffer limit to %u."),
2464                record_full_insn_max_num);
2465     }
2466
2467   /* Succeeded.  */
2468   printf_filtered (_("Restored records from core file %s.\n"),
2469                    bfd_get_filename (core_bfd));
2470
2471   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2472 }
2473
2474 /* bfdcore_write -- write bytes into a core file section.  */
2475
2476 static inline void
2477 bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset)
2478 {
2479   int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2480
2481   if (ret)
2482     *offset += len;
2483   else
2484     error (_("Failed to write %d bytes to core file %s ('%s')."),
2485            len, bfd_get_filename (obfd),
2486            bfd_errmsg (bfd_get_error ()));
2487 }
2488
2489 /* Restore the execution log from a file.  We use a modified elf
2490    corefile format, with an extra section for our data.  */
2491
2492 static void
2493 cmd_record_full_restore (char *args, int from_tty)
2494 {
2495   core_file_command (args, from_tty);
2496   record_full_open (args, from_tty);
2497 }
2498
2499 static void
2500 record_full_save_cleanups (void *data)
2501 {
2502   bfd *obfd = data;
2503   char *pathname = xstrdup (bfd_get_filename (obfd));
2504
2505   gdb_bfd_unref (obfd);
2506   unlink (pathname);
2507   xfree (pathname);
2508 }
2509
2510 /* Save the execution log to a file.  We use a modified elf corefile
2511    format, with an extra section for our data.  */
2512
2513 static void
2514 record_full_save (struct target_ops *self, const char *recfilename)
2515 {
2516   struct record_full_entry *cur_record_full_list;
2517   uint32_t magic;
2518   struct regcache *regcache;
2519   struct gdbarch *gdbarch;
2520   struct cleanup *old_cleanups;
2521   struct cleanup *set_cleanups;
2522   bfd *obfd;
2523   int save_size = 0;
2524   asection *osec = NULL;
2525   int bfd_offset = 0;
2526
2527   /* Open the save file.  */
2528   if (record_debug)
2529     fprintf_unfiltered (gdb_stdlog, "Saving execution log to core file '%s'\n",
2530                         recfilename);
2531
2532   /* Open the output file.  */
2533   obfd = create_gcore_bfd (recfilename);
2534   old_cleanups = make_cleanup (record_full_save_cleanups, obfd);
2535
2536   /* Save the current record entry to "cur_record_full_list".  */
2537   cur_record_full_list = record_full_list;
2538
2539   /* Get the values of regcache and gdbarch.  */
2540   regcache = get_current_regcache ();
2541   gdbarch = get_regcache_arch (regcache);
2542
2543   /* Disable the GDB operation record.  */
2544   set_cleanups = record_full_gdb_operation_disable_set ();
2545
2546   /* Reverse execute to the begin of record list.  */
2547   while (1)
2548     {
2549       /* Check for beginning and end of log.  */
2550       if (record_full_list == &record_full_first)
2551         break;
2552
2553       record_full_exec_insn (regcache, gdbarch, record_full_list);
2554
2555       if (record_full_list->prev)
2556         record_full_list = record_full_list->prev;
2557     }
2558
2559   /* Compute the size needed for the extra bfd section.  */
2560   save_size = 4;        /* magic cookie */
2561   for (record_full_list = record_full_first.next; record_full_list;
2562        record_full_list = record_full_list->next)
2563     switch (record_full_list->type)
2564       {
2565       case record_full_end:
2566         save_size += 1 + 4 + 4;
2567         break;
2568       case record_full_reg:
2569         save_size += 1 + 4 + record_full_list->u.reg.len;
2570         break;
2571       case record_full_mem:
2572         save_size += 1 + 4 + 8 + record_full_list->u.mem.len;
2573         break;
2574       }
2575
2576   /* Make the new bfd section.  */
2577   osec = bfd_make_section_anyway_with_flags (obfd, "precord",
2578                                              SEC_HAS_CONTENTS
2579                                              | SEC_READONLY);
2580   if (osec == NULL)
2581     error (_("Failed to create 'precord' section for corefile %s: %s"),
2582            recfilename,
2583            bfd_errmsg (bfd_get_error ()));
2584   bfd_set_section_size (obfd, osec, save_size);
2585   bfd_set_section_vma (obfd, osec, 0);
2586   bfd_set_section_alignment (obfd, osec, 0);
2587   bfd_section_lma (obfd, osec) = 0;
2588
2589   /* Save corefile state.  */
2590   write_gcore_file (obfd);
2591
2592   /* Write out the record log.  */
2593   /* Write the magic code.  */
2594   magic = RECORD_FULL_FILE_MAGIC;
2595   if (record_debug)
2596     fprintf_unfiltered (gdb_stdlog,
2597                         "  Writing 4-byte magic cookie "
2598                         "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2599                       phex_nz (magic, 4));
2600   bfdcore_write (obfd, osec, &magic, sizeof (magic), &bfd_offset);
2601
2602   /* Save the entries to recfd and forward execute to the end of
2603      record list.  */
2604   record_full_list = &record_full_first;
2605   while (1)
2606     {
2607       /* Save entry.  */
2608       if (record_full_list != &record_full_first)
2609         {
2610           uint8_t type;
2611           uint32_t regnum, len, signal, count;
2612           uint64_t addr;
2613
2614           type = record_full_list->type;
2615           bfdcore_write (obfd, osec, &type, sizeof (type), &bfd_offset);
2616
2617           switch (record_full_list->type)
2618             {
2619             case record_full_reg: /* reg */
2620               if (record_debug)
2621                 fprintf_unfiltered (gdb_stdlog,
2622                                     "  Writing register %d (1 "
2623                                     "plus %lu plus %d bytes)\n",
2624                                     record_full_list->u.reg.num,
2625                                     (unsigned long) sizeof (regnum),
2626                                     record_full_list->u.reg.len);
2627
2628               /* Write regnum.  */
2629               regnum = netorder32 (record_full_list->u.reg.num);
2630               bfdcore_write (obfd, osec, &regnum,
2631                              sizeof (regnum), &bfd_offset);
2632
2633               /* Write regval.  */
2634               bfdcore_write (obfd, osec,
2635                              record_full_get_loc (record_full_list),
2636                              record_full_list->u.reg.len, &bfd_offset);
2637               break;
2638
2639             case record_full_mem: /* mem */
2640               if (record_debug)
2641                 fprintf_unfiltered (gdb_stdlog,
2642                                     "  Writing memory %s (1 plus "
2643                                     "%lu plus %lu plus %d bytes)\n",
2644                                     paddress (gdbarch,
2645                                               record_full_list->u.mem.addr),
2646                                     (unsigned long) sizeof (addr),
2647                                     (unsigned long) sizeof (len),
2648                                     record_full_list->u.mem.len);
2649
2650               /* Write memlen.  */
2651               len = netorder32 (record_full_list->u.mem.len);
2652               bfdcore_write (obfd, osec, &len, sizeof (len), &bfd_offset);
2653
2654               /* Write memaddr.  */
2655               addr = netorder64 (record_full_list->u.mem.addr);
2656               bfdcore_write (obfd, osec, &addr, 
2657                              sizeof (addr), &bfd_offset);
2658
2659               /* Write memval.  */
2660               bfdcore_write (obfd, osec,
2661                              record_full_get_loc (record_full_list),
2662                              record_full_list->u.mem.len, &bfd_offset);
2663               break;
2664
2665               case record_full_end:
2666                 if (record_debug)
2667                   fprintf_unfiltered (gdb_stdlog,
2668                                       "  Writing record_full_end (1 + "
2669                                       "%lu + %lu bytes)\n", 
2670                                       (unsigned long) sizeof (signal),
2671                                       (unsigned long) sizeof (count));
2672                 /* Write signal value.  */
2673                 signal = netorder32 (record_full_list->u.end.sigval);
2674                 bfdcore_write (obfd, osec, &signal,
2675                                sizeof (signal), &bfd_offset);
2676
2677                 /* Write insn count.  */
2678                 count = netorder32 (record_full_list->u.end.insn_num);
2679                 bfdcore_write (obfd, osec, &count,
2680                                sizeof (count), &bfd_offset);
2681                 break;
2682             }
2683         }
2684
2685       /* Execute entry.  */
2686       record_full_exec_insn (regcache, gdbarch, record_full_list);
2687
2688       if (record_full_list->next)
2689         record_full_list = record_full_list->next;
2690       else
2691         break;
2692     }
2693
2694   /* Reverse execute to cur_record_full_list.  */
2695   while (1)
2696     {
2697       /* Check for beginning and end of log.  */
2698       if (record_full_list == cur_record_full_list)
2699         break;
2700
2701       record_full_exec_insn (regcache, gdbarch, record_full_list);
2702
2703       if (record_full_list->prev)
2704         record_full_list = record_full_list->prev;
2705     }
2706
2707   do_cleanups (set_cleanups);
2708   gdb_bfd_unref (obfd);
2709   discard_cleanups (old_cleanups);
2710
2711   /* Succeeded.  */
2712   printf_filtered (_("Saved core file %s with execution log.\n"),
2713                    recfilename);
2714 }
2715
2716 /* record_full_goto_insn -- rewind the record log (forward or backward,
2717    depending on DIR) to the given entry, changing the program state
2718    correspondingly.  */
2719
2720 static void
2721 record_full_goto_insn (struct record_full_entry *entry,
2722                        enum exec_direction_kind dir)
2723 {
2724   struct cleanup *set_cleanups = record_full_gdb_operation_disable_set ();
2725   struct regcache *regcache = get_current_regcache ();
2726   struct gdbarch *gdbarch = get_regcache_arch (regcache);
2727
2728   /* Assume everything is valid: we will hit the entry,
2729      and we will not hit the end of the recording.  */
2730
2731   if (dir == EXEC_FORWARD)
2732     record_full_list = record_full_list->next;
2733
2734   do
2735     {
2736       record_full_exec_insn (regcache, gdbarch, record_full_list);
2737       if (dir == EXEC_REVERSE)
2738         record_full_list = record_full_list->prev;
2739       else
2740         record_full_list = record_full_list->next;
2741     } while (record_full_list != entry);
2742   do_cleanups (set_cleanups);
2743 }
2744
2745 /* Alias for "target record-full".  */
2746
2747 static void
2748 cmd_record_full_start (char *args, int from_tty)
2749 {
2750   execute_command ("target record-full", from_tty);
2751 }
2752
2753 static void
2754 set_record_full_insn_max_num (char *args, int from_tty,
2755                               struct cmd_list_element *c)
2756 {
2757   if (record_full_insn_num > record_full_insn_max_num)
2758     {
2759       /* Count down record_full_insn_num while releasing records from list.  */
2760       while (record_full_insn_num > record_full_insn_max_num)
2761        {
2762          record_full_list_release_first ();
2763          record_full_insn_num--;
2764        }
2765     }
2766 }
2767
2768 /* The "set record full" command.  */
2769
2770 static void
2771 set_record_full_command (char *args, int from_tty)
2772 {
2773   printf_unfiltered (_("\"set record full\" must be followed "
2774                        "by an apporpriate subcommand.\n"));
2775   help_list (set_record_full_cmdlist, "set record full ", all_commands,
2776              gdb_stdout);
2777 }
2778
2779 /* The "show record full" command.  */
2780
2781 static void
2782 show_record_full_command (char *args, int from_tty)
2783 {
2784   cmd_show_list (show_record_full_cmdlist, from_tty, "");
2785 }
2786
2787 /* Provide a prototype to silence -Wmissing-prototypes.  */
2788 extern initialize_file_ftype _initialize_record_full;
2789
2790 void
2791 _initialize_record_full (void)
2792 {
2793   struct cmd_list_element *c;
2794
2795   /* Init record_full_first.  */
2796   record_full_first.prev = NULL;
2797   record_full_first.next = NULL;
2798   record_full_first.type = record_full_end;
2799
2800   init_record_full_ops ();
2801   add_target (&record_full_ops);
2802   add_deprecated_target_alias (&record_full_ops, "record");
2803   init_record_full_core_ops ();
2804   add_target (&record_full_core_ops);
2805
2806   add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
2807                   _("Start full execution recording."), &record_full_cmdlist,
2808                   "record full ", 0, &record_cmdlist);
2809
2810   c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
2811                _("Restore the execution log from a file.\n\
2812 Argument is filename.  File must be created with 'record save'."),
2813                &record_full_cmdlist);
2814   set_cmd_completer (c, filename_completer);
2815
2816   /* Deprecate the old version without "full" prefix.  */
2817   c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
2818                      &record_cmdlist);
2819   set_cmd_completer (c, filename_completer);
2820   deprecate_cmd (c, "record full restore");
2821
2822   add_prefix_cmd ("full", class_support, set_record_full_command,
2823                   _("Set record options"), &set_record_full_cmdlist,
2824                   "set record full ", 0, &set_record_cmdlist);
2825
2826   add_prefix_cmd ("full", class_support, show_record_full_command,
2827                   _("Show record options"), &show_record_full_cmdlist,
2828                   "show record full ", 0, &show_record_cmdlist);
2829
2830   /* Record instructions number limit command.  */
2831   add_setshow_boolean_cmd ("stop-at-limit", no_class,
2832                            &record_full_stop_at_limit, _("\
2833 Set whether record/replay stops when record/replay buffer becomes full."), _("\
2834 Show whether record/replay stops when record/replay buffer becomes full."),
2835                            _("Default is ON.\n\
2836 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2837 When OFF, if the record/replay buffer becomes full,\n\
2838 delete the oldest recorded instruction to make room for each new one."),
2839                            NULL, NULL,
2840                            &set_record_full_cmdlist, &show_record_full_cmdlist);
2841
2842   c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2843                      &set_record_cmdlist);
2844   deprecate_cmd (c, "set record full stop-at-limit");
2845
2846   c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
2847                      &show_record_cmdlist);
2848   deprecate_cmd (c, "show record full stop-at-limit");
2849
2850   add_setshow_uinteger_cmd ("insn-number-max", no_class,
2851                             &record_full_insn_max_num,
2852                             _("Set record/replay buffer limit."),
2853                             _("Show record/replay buffer limit."), _("\
2854 Set the maximum number of instructions to be stored in the\n\
2855 record/replay buffer.  A value of either \"unlimited\" or zero means no\n\
2856 limit.  Default is 200000."),
2857                             set_record_full_insn_max_num,
2858                             NULL, &set_record_full_cmdlist,
2859                             &show_record_full_cmdlist);
2860
2861   c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2862                      &set_record_cmdlist);
2863   deprecate_cmd (c, "set record full insn-number-max");
2864
2865   c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
2866                      &show_record_cmdlist);
2867   deprecate_cmd (c, "show record full insn-number-max");
2868
2869   add_setshow_boolean_cmd ("memory-query", no_class,
2870                            &record_full_memory_query, _("\
2871 Set whether query if PREC cannot record memory change of next instruction."),
2872                            _("\
2873 Show whether query if PREC cannot record memory change of next instruction."),
2874                            _("\
2875 Default is OFF.\n\
2876 When ON, query if PREC cannot record memory change of next instruction."),
2877                            NULL, NULL,
2878                            &set_record_full_cmdlist,
2879                            &show_record_full_cmdlist);
2880
2881   c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2882                      &set_record_cmdlist);
2883   deprecate_cmd (c, "set record full memory-query");
2884
2885   c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
2886                      &show_record_cmdlist);
2887   deprecate_cmd (c, "show record full memory-query");
2888 }