Re: [RFA/RFC] Add dump and load command to process record and replay

[Hui Zhu <teawater at gmail dot com>]

On Tue, Aug 25, 2009 at 01:51, Michael Snyder<msnyder@vmware.com> wrote:
> Hui Zhu wrote:
>>
>> On Mon, Aug 24, 2009 at 07:21, Michael Snyder<msnyder@vmware.com> wrote:
>>>
>>> Hui Zhu wrote:
>>>
>>>> Hi Michael,
>>>>
>>>> I make a new version patch. ?It has a lot of changes.
>>>> Remove record_core and add a new target record_core for core target to
>>>> make the code more clear.
>>>> Make the load together with record_open.
>>>>
>>>> Please help me review it.
>>>
>>> Hi Hui,
>>>
>>> In this review, I'm going to comment only on the parts of the
>>> patch that relate to the record_core_ops (ie. pushing the
>>> record stratum on top of the core file stratum).
>>>
>>> Those parts of the patch are much improved. ?I like this
>>> version a lot better. ?Thanks for reworking it.
>>>
>>
>>
>> Hi Michael,
>>
>> Thanks for your review. ?I make a new patch that update the memset code
>> to:
>
> Way cool, thanks!
>
> Now I can comment on the dump/load part of the patch.
> It does not seem as if previous issues have been addressed:
> 1) Core file and record file are separate, no way to verify
> ? that they correspond to each other.

> 2) Previous log not cleared when loading a new log.
For it, I think we don't need worry about it.  Because I make the
record load together with record_open.  So each time when we load
record, the record list is empty.

>
> Have you considered combining this patch with the idea that I
> proposed -- storing the record log in the core file? ?Seems like
> that would be very easy now -- gdb already has the core file open,
> and there is a global pointer to the BFD.
> See gdbcore.h:extern bfd* core_bfd;

Cool.  If we just want record_core_ops support load, we can remove the
cmd "record load".  :)

>
> In fact, just for fun, I've merged the two patches in my
> local tree. ?It seems to work quite well. ?I can just post
> it here if you like, or here's a hint to show you how it goes:


Why not?  Please post it.  I can not wait to try it.  :)


Thanks,
Hui

>
> static void
> record_load (void)
> {
> ?int recfd;
> ?uint32_t magic;
> ?struct cleanup *old_cleanups2;
> ?struct record_entry *rec;
> ?int insn_number = 0;
> ?asection *osec;
> ?void nullify_last_target_wait_ptid (void);
>
> ?/* We load the execution log from the open core bfd,
> ? ? if there is one. ?*/
> ?if (core_bfd == NULL)
> ? ?return;
>
> ?if (record_debug)
> ? ?fprintf_filtered (gdb_stdlog,
> ? ? ? ? ? ? ? ? ? ? ?_("Restoring recording from core file.\n"));
>
> ?/* Now need to find our special note section. ?*/
> ?osec = bfd_get_section_by_name (core_bfd, "null0");
>
>



>> ? ? ? ? ? ?if (target_read_memory (entry->u.mem.addr, mem,
>> entry->u.mem.len))
>> ? ? ? ? ? ? ?{
>> ? ? ? ? ? ? ? ?record_list->u.mem.mem_entry_not_accessible = 1;
>> ? ? ? ? ? ? ? ?if (record_debug)
>> ? ? ? ? ? ? ? ? ?warning (_("Process record: error reading memory at "
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? "addr = %s len = %d."),
>> ? ? ? ? ? ? ? ? ? ? ? ? ? paddress (gdbarch, entry->u.mem.addr),
>> ? ? ? ? ? ? ? ? ? ? ? ? ? entry->u.mem.len);
>> ? ? ? ? ? ? ?}
>> ? ? ? ? ? ?else
>> ? ? ? ? ? ? ?{
>> ? ? ? ? ? ? ? ?if (target_write_memory (entry->u.mem.addr,
>> entry->u.mem.val,
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? entry->u.mem.len))
>> ? ? ? ? ? ? ? ? ?{
>> ? ? ? ? ? ? ? ? ? ?record_list->u.mem.mem_entry_not_accessible = 1;
>> ? ? ? ? ? ? ? ? ? ?if (record_debug)
>> ? ? ? ? ? ? ? ? ? ? ?warning (_("Process record: error writing memory at "
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? "addr = %s len = %d."),
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? paddress (gdbarch, entry->u.mem.addr),
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? entry->u.mem.len);
>> ? ? ? ? ? ? ? ? ?}
>> ? ? ? ? ? ? ? ?else
>> ? ? ? ? ? ? ? ? ?memcpy (entry->u.mem.val, mem, entry->u.mem.len);
>> ? ? ? ? ? ? ?}
>>
>> Please help me review it.
>>
>> Thanks,
>> Hui
>>
>> ---
>> ?record.c | ?951
>> ++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
>> ?1 file changed, 825 insertions(+), 126 deletions(-)
>>
>> --- a/record.c
>> +++ b/record.c
>> @@ -23,15 +23,23 @@
>> ?#include "gdbthread.h"
>> ?#include "event-top.h"
>> ?#include "exceptions.h"
>> +#include "completer.h"
>> +#include "arch-utils.h"
>> +#include "gdbcore.h"
>> +#include "exec.h"
>> ?#include "record.h"
>>
>> +#include <byteswap.h>
>> ?#include <signal.h>
>> +#include <netinet/in.h>
>>
>> ?#define DEFAULT_RECORD_INSN_MAX_NUM ? ?200000
>>
>> ?#define RECORD_IS_REPLAY \
>> ? ? ?(record_list->next || execution_direction == EXEC_REVERSE)
>>
>> +#define RECORD_FILE_MAGIC ? ? ?htonl(0x20090726)
>> +
>> ?/* These are the core struct of record function.
>>
>> ? ?An record_entry is a record of the value change of a register
>> @@ -78,9 +86,22 @@ struct record_entry
>> ? } u;
>> ?};
>>
>> +struct record_core_buf_entry
>> +{
>> + ?struct record_core_buf_entry *prev;
>> + ?struct target_section *p;
>> + ?bfd_byte *buf;
>> +};
>> +
>> ?/* This is the debug switch for process record. ?*/
>> ?int record_debug = 0;
>>
>> +/* Record buf with core target. ?*/
>> +static gdb_byte *record_core_regbuf = NULL;
>> +static struct target_section *record_core_start;
>> +static struct target_section *record_core_end;
>> +static struct record_core_buf_entry *record_core_buf_list = NULL;
>> +
>> ?/* These list is for execution log. ?*/
>> ?static struct record_entry record_first;
>> ?static struct record_entry *record_list = &record_first;
>> @@ -94,6 +115,7 @@ static int record_insn_num = 0;
>>
>> ?/* The target_ops of process record. ?*/
>> ?static struct target_ops record_ops;
>> +static struct target_ops record_core_ops;
>>
>> ?/* The beneath function pointers. ?*/
>> ?static struct target_ops *record_beneath_to_resume_ops;
>> @@ -169,7 +191,7 @@ record_list_release_next (void)
>> ?}
>>
>> ?static void
>> -record_list_release_first (void)
>> +record_list_release_first_insn (void)
>> ?{
>> ? struct record_entry *tmp = NULL;
>> ? enum record_type type;
>> @@ -340,30 +362,30 @@ record_check_insn_num (int set_terminal)
>> ? ? ? ? ? ? ?if (q)
>> ? ? ? ? ? ? ? ?record_stop_at_limit = 0;
>> ? ? ? ? ? ? ?else
>> - ? ? ? ? ? ? ? error (_("Process record: inferior program stopped."));
>> + ? ? ? ? ? ? ? error (_("Process record: stoped by user."));
>> ? ? ? ? ? ?}
>> ? ? ? ?}
>> ? ? }
>> ?}
>>
>> +static void
>> +record_arch_list_cleanups (void *ignore)
>> +{
>> + ?record_list_release (record_arch_list_tail);
>> +}
>> +
>> ?/* Before inferior step (when GDB record the running message, inferior
>> ? ?only can step), GDB will call this function to record the values to
>> ? ?record_list. ?This function will call gdbarch_process_record to
>> ? ?record the running message of inferior and set them to
>> ? ?record_arch_list, and add it to record_list. ?*/
>>
>> -static void
>> -record_message_cleanups (void *ignore)
>> -{
>> - ?record_list_release (record_arch_list_tail);
>> -}
>> -
>> ?static int
>> ?record_message (void *args)
>> ?{
>> ? int ret;
>> ? struct regcache *regcache = args;
>> - ?struct cleanup *old_cleanups = make_cleanup (record_message_cleanups,
>> 0);
>> + ?struct cleanup *old_cleanups = make_cleanup (record_arch_list_cleanups,
>> 0);
>>
>> ? record_arch_list_head = NULL;
>> ? record_arch_list_tail = NULL;
>> @@ -386,7 +408,7 @@ record_message (void *args)
>> ? record_list = record_arch_list_tail;
>>
>> ? if (record_insn_num == record_insn_max_num && record_insn_max_num)
>> - ? ?record_list_release_first ();
>> + ? ?record_list_release_first_insn ();
>> ? else
>> ? ? record_insn_num++;
>>
>> @@ -416,13 +438,291 @@ record_gdb_operation_disable_set (void)
>> ? return old_cleanups;
>> ?}
>>
>> +static inline void
>> +record_exec_entry (struct regcache *regcache, struct gdbarch *gdbarch,
>> + ? ? ? ? ? ? ? ? ? struct record_entry *entry)
>> +{
>> + ?switch (entry->type)
>> + ? ?{
>> + ? ?case record_reg: /* reg */
>> + ? ? ?{
>> + ? ? ? ?gdb_byte reg[MAX_REGISTER_SIZE];
>> +
>> + ? ? ? ?if (record_debug > 1)
>> + ? ? ? ? ?fprintf_unfiltered (gdb_stdlog,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"Process record: record_reg %s to "
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"inferior num = %d.\n",
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?host_address_to_string (entry),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?entry->u.reg.num);
>> +
>> + ? ? ? ?regcache_cooked_read (regcache, entry->u.reg.num, reg);
>> + ? ? ? ?regcache_cooked_write (regcache, entry->u.reg.num,
>> entry->u.reg.val);
>> + ? ? ? ?memcpy (entry->u.reg.val, reg, MAX_REGISTER_SIZE);
>> + ? ? ?}
>> + ? ? ?break;
>> +
>> + ? ?case record_mem: /* mem */
>> + ? ? ?{
>> + ? ? ? ?if (!record_list->u.mem.mem_entry_not_accessible)
>> + ? ? ? ? ?{
>> + ? ? ? ? ? ?gdb_byte *mem = alloca (entry->u.mem.len);
>> +
>> + ? ? ? ? ? ?if (record_debug > 1)
>> + ? ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"Process record: record_mem %s to "
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"inferior addr = %s len = %d.\n",
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?host_address_to_string (entry),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?paddress (gdbarch, entry->u.mem.addr),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.mem.len);
>> +
>> + ? ? ? ? ? ?if (target_read_memory (entry->u.mem.addr, mem,
>> entry->u.mem.len))
>> + ? ? ? ? ? ? ?{
>> + ? ? ? ? ? ? ? ?record_list->u.mem.mem_entry_not_accessible = 1;
>> + ? ? ? ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ? ? ? ?warning (_("Process record: error reading memory at "
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? "addr = %s len = %d."),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? paddress (gdbarch, entry->u.mem.addr),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? entry->u.mem.len);
>> + ? ? ? ? ? ? ?}
>> + ? ? ? ? ? ?else
>> + ? ? ? ? ? ? ?{
>> + ? ? ? ? ? ? ? ?if (target_write_memory (entry->u.mem.addr,
>> entry->u.mem.val,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? entry->u.mem.len))
>> + ? ? ? ? ? ? ? ? ?{
>> + ? ? ? ? ? ? ? ? ? ?record_list->u.mem.mem_entry_not_accessible = 1;
>> + ? ? ? ? ? ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ? ? ? ? ? ?warning (_("Process record: error writing memory at
>> "
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? "addr = %s len = %d."),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? paddress (gdbarch, entry->u.mem.addr),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? entry->u.mem.len);
>> + ? ? ? ? ? ? ? ? ?}
>> + ? ? ? ? ? ? ? ?else
>> + ? ? ? ? ? ? ? ? ?memcpy (entry->u.mem.val, mem, entry->u.mem.len);
>> + ? ? ? ? ? ? ?}
>> + ? ? ? ? ?}
>> + ? ? ?}
>> + ? ? ?break;
>> + ? ?}
>> +}
>> +
>> +static inline void
>> +record_read_dump (char *recfilename, int fildes, void *buf, size_t nbyte)
>> +{
>> + ?if (read (fildes, buf, nbyte) != nbyte)
>> + ? ?error (_("Failed to read dump of execution records in '%s'."),
>> + ? ? ? ? ? recfilename);
>> +}
>> +
>> ?static void
>> -record_open (char *name, int from_tty)
>> +record_fd_cleanups (void *recfdp)
>> ?{
>> - ?struct target_ops *t;
>> + ?int recfd = *(int *) recfdp;
>> + ?close (recfd);
>> +}
>>
>> - ?if (record_debug)
>> - ? ?fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n");
>> +/* Load the execution log from a file. ?*/
>> +
>> +static void
>> +record_load (char *name)
>> +{
>> + ?int recfd;
>> + ?uint32_t magic;
>> + ?struct cleanup *old_cleanups;
>> + ?struct cleanup *old_cleanups2;
>> + ?struct record_entry *rec;
>> + ?int insn_number = 0;
>> +
>> + ?if (!name || (name && !*name))
>> + ? ?return;
>> +
>> + ?/* Open the load file. ?*/
>> + ?recfd = open (name, O_RDONLY | O_BINARY);
>> + ?if (recfd < 0)
>> + ? ?error (_("Failed to open '%s' for loading execution records: %s"),
>> + ? ? ? ? ? name, strerror (errno));
>> + ?old_cleanups = make_cleanup (record_fd_cleanups, &recfd);
>> +
>> + ?/* Check the magic code. ?*/
>> + ?record_read_dump (name, recfd, &magic, 4);
>> + ?if (magic != RECORD_FILE_MAGIC)
>> + ? ?error (_("'%s' is not a valid dump of execution records."), name);
>> +
>> + ?/* Load the entries in recfd to the record_arch_list_head and
>> + ? ? record_arch_list_tail. ?*/
>> + ?record_arch_list_head = NULL;
>> + ?record_arch_list_tail = NULL;
>> + ?old_cleanups2 = make_cleanup (record_arch_list_cleanups, 0);
>> +
>> + ?while (1)
>> + ? ?{
>> + ? ? ?int ret;
>> + ? ? ?uint8_t tmpu8;
>> + ? ? ?uint64_t tmpu64;
>> +
>> + ? ? ?ret = read (recfd, &tmpu8, 1);
>> + ? ? ?if (ret < 0)
>> + ? ? ? ?error (_("Failed to read dump of execution records in '%s'."),
>> name);
>> + ? ? ?if (ret == 0)
>> + ? ? ? ?break;
>> +
>> + ? ? ?switch (tmpu8)
>> + ? ? ? ?{
>> + ? ? ? ?case record_reg: /* reg */
>> + ? ? ? ? ?rec = (struct record_entry *) xmalloc (sizeof (struct
>> record_entry));
>> + ? ? ? ? ?rec->u.reg.val = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE);
>> + ? ? ? ? ?rec->prev = NULL;
>> + ? ? ? ? ?rec->next = NULL;
>> + ? ? ? ? ?rec->type = record_reg;
>> +
>> + ? ? ? ? ?/* Get num. ?*/
>> + ? ? ? ? ?record_read_dump (name, recfd, &tmpu64, 8);
>> + ? ? ? ? ?if (BYTE_ORDER == LITTLE_ENDIAN)
>> + ? ? ? ? ? ?tmpu64 = bswap_64 (tmpu64);
>> + ? ? ? ? ?rec->u.reg.num = tmpu64;
>> +
>> + ? ? ? ? ?/* Get val. ?*/
>> + ? ? ? ? ?record_read_dump (name, recfd, rec->u.reg.val,
>> MAX_REGISTER_SIZE);
>> +
>> + ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog, _("\
>> +Reading register %d (1 plus 8 plus %d bytes)\n"),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?rec->u.reg.num,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?MAX_REGISTER_SIZE);
>> +
>> + ? ? ? ? ?record_arch_list_add (rec);
>> + ? ? ? ? ?break;
>> +
>> + ? ? ? ?case record_mem: /* mem */
>> + ? ? ? ? ?rec = (struct record_entry *) xmalloc (sizeof (struct
>> record_entry));
>> + ? ? ? ? ?rec->prev = NULL;
>> + ? ? ? ? ?rec->next = NULL;
>> + ? ? ? ? ?rec->type = record_mem;
>> +
>> + ? ? ? ? ?/* Get addr. ?*/
>> + ? ? ? ? ?record_read_dump (name, recfd, &tmpu64, 8);
>> + ? ? ? ? ?if (BYTE_ORDER == LITTLE_ENDIAN)
>> + ? ? ? ? ? ?tmpu64 = bswap_64 (tmpu64);
>> + ? ? ? ? ?rec->u.mem.addr = tmpu64;
>> +
>> + ? ? ? ? ?/* Get len. ?*/
>> + ? ? ? ? ?record_read_dump (name, recfd, &tmpu64, 8);
>> + ? ? ? ? ?if (BYTE_ORDER == LITTLE_ENDIAN)
>> + ? ? ? ? ? ?tmpu64 = bswap_64 (tmpu64);
>> + ? ? ? ? ?rec->u.mem.len = tmpu64;
>> + ? ? ? ? ?rec->u.mem.mem_entry_not_accessible = 0;
>> + ? ? ? ? ?rec->u.mem.val = (gdb_byte *) xmalloc (rec->u.mem.len);
>> +
>> + ? ? ? ? ?/* Get val. ?*/
>> + ? ? ? ? ?record_read_dump (name, recfd, rec->u.mem.val, rec->u.mem.len);
>> +
>> + ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog, _("\
>> +Reading memory %s (1 plus 8 plus 8 bytes plus %d bytes)\n"),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?paddress (get_current_arch (),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?rec->u.mem.addr),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?rec->u.mem.len);
>> +
>> + ? ? ? ? ?record_arch_list_add (rec);
>> + ? ? ? ? ?break;
>> +
>> + ? ? ? ?case record_end: /* end */
>> + ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?_("Reading record_end (1 byte)\n"));
>> +
>> + ? ? ? ? ?rec = (struct record_entry *) xmalloc (sizeof (struct
>> record_entry));
>> + ? ? ? ? ?rec->prev = NULL;
>> + ? ? ? ? ?rec->next = NULL;
>> + ? ? ? ? ?rec->type = record_end;
>> + ? ? ? ? ?record_arch_list_add (rec);
>> + ? ? ? ? ?insn_number ++;
>> + ? ? ? ? ?break;
>> +
>> + ? ? ? ?default:
>> + ? ? ? ? ?error (_("Format of '%s' is not right."), name);
>> + ? ? ? ? ?break;
>> + ? ? ? ?}
>> + ? ?}
>> +
>> + ?discard_cleanups (old_cleanups2);
>> +
>> + ?/* Add record_arch_list_head to the end of record list. ?*/
>> + ?for (rec = record_list; rec->next; rec = rec->next);
>> + ?rec->next = record_arch_list_head;
>> + ?record_arch_list_head->prev = rec;
>> +
>> + ?/* Update record_insn_num and record_insn_max_num. ?*/
>> + ?record_insn_num += insn_number;
>> + ?if (record_insn_num > record_insn_max_num)
>> + ? ?{
>> + ? ? ?record_insn_max_num = record_insn_num;
>> + ? ? ?warning (_("Auto increase record/replay buffer limit to %d."),
>> + ? ? ? ? ? ? ? record_insn_max_num);
>> + ? ?}
>> +
>> + ?do_cleanups (old_cleanups);
>> +
>> + ?/* Succeeded. ?*/
>> + ?fprintf_filtered (gdb_stdout, "Loaded recfile %s.\n", name);
>> +}
>> +
>> +static struct target_ops *tmp_to_resume_ops;
>> +static void (*tmp_to_resume) (struct target_ops *, ptid_t, int,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?enum target_signal);
>> +static struct target_ops *tmp_to_wait_ops;
>> +static ptid_t (*tmp_to_wait) (struct target_ops *, ptid_t,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct target_waitstatus *,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?int);
>> +static struct target_ops *tmp_to_store_registers_ops;
>> +static void (*tmp_to_store_registers) (struct target_ops *,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? struct regcache *,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? int regno);
>> +static struct target_ops *tmp_to_xfer_partial_ops;
>> +static LONGEST (*tmp_to_xfer_partial) (struct target_ops *ops,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? enum target_object object,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? const char *annex,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? gdb_byte *readbuf,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? const gdb_byte *writebuf,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ULONGEST offset,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? LONGEST len);
>> +static int (*tmp_to_insert_breakpoint) (struct gdbarch *,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct bp_target_info *);
>> +static int (*tmp_to_remove_breakpoint) (struct gdbarch *,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct bp_target_info *);
>> +
>> +static void
>> +record_core_open_1 (char *name, int from_tty)
>> +{
>> + ?struct regcache *regcache = get_current_regcache ();
>> + ?int regnum = gdbarch_num_regs (get_regcache_arch (regcache));
>> + ?int i;
>> +
>> + ?if (!name || (name && !*name))
>> + ? ?error (_("Argument for gdb record filename required.\n"));
>> +
>> + ?/* Get record_core_regbuf. ?*/
>> + ?target_fetch_registers (regcache, -1);
>> + ?record_core_regbuf = xmalloc (MAX_REGISTER_SIZE * regnum);
>> + ?for (i = 0; i < regnum; i ++)
>> + ? ?regcache_raw_collect (regcache, i,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ?record_core_regbuf + MAX_REGISTER_SIZE * i);
>> +
>> + ?/* Get record_core_start and record_core_end. ?*/
>> + ?if (build_section_table (core_bfd, &record_core_start,
>> &record_core_end))
>> + ? ?{
>> + ? ? ?xfree (record_core_regbuf);
>> + ? ? ?record_core_regbuf = NULL;
>> + ? ? ?error (_("\"%s\": Can't find sections: %s"),
>> + ? ? ? ? ? ? bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
>> + ? ?}
>> +
>> + ?push_target (&record_core_ops);
>> +}
>> +
>> +static void
>> +record_open_1 (char *name, int from_tty)
>> +{
>> + ?struct target_ops *t;
>>
>> ? /* check exec */
>> ? if (!target_has_execution)
>> @@ -438,6 +738,28 @@ record_open (char *name, int from_tty)
>> ? ? error (_("Process record: the current architecture doesn't support "
>> ? ? ? ? ? ? "record function."));
>>
>> + ?if (!tmp_to_resume)
>> + ? ?error (_("Process record can't get to_resume."));
>> + ?if (!tmp_to_wait)
>> + ? ?error (_("Process record can't get to_wait."));
>> + ?if (!tmp_to_store_registers)
>> + ? ?error (_("Process record can't get to_store_registers."));
>> + ?if (!tmp_to_insert_breakpoint)
>> + ? ?error (_("Process record can't get to_insert_breakpoint."));
>> + ?if (!tmp_to_remove_breakpoint)
>> + ? ?error (_("Process record can't get to_remove_breakpoint."));
>> +
>> + ?push_target (&record_ops);
>> +}
>> +
>> +static void
>> +record_open (char *name, int from_tty)
>> +{
>> + ?struct target_ops *t;
>> +
>> + ?if (record_debug)
>> + ? ?fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n");
>> +
>> ? /* Check if record target is already running. ?*/
>> ? if (current_target.to_stratum == record_stratum)
>> ? ? {
>> @@ -447,70 +769,102 @@ record_open (char *name, int from_tty)
>> ? ? ? ?return;
>> ? ? }
>>
>> - ?/*Reset the beneath function pointers. ?*/
>> - ?record_beneath_to_resume = NULL;
>> - ?record_beneath_to_wait = NULL;
>> - ?record_beneath_to_store_registers = NULL;
>> - ?record_beneath_to_xfer_partial = NULL;
>> - ?record_beneath_to_insert_breakpoint = NULL;
>> - ?record_beneath_to_remove_breakpoint = NULL;
>> + ?/* Reset the tmp beneath pointers. ?*/
>> + ?tmp_to_resume_ops = NULL;
>> + ?tmp_to_resume = NULL;
>> + ?tmp_to_wait_ops = NULL;
>> + ?tmp_to_wait = NULL;
>> + ?tmp_to_store_registers_ops = NULL;
>> + ?tmp_to_store_registers = NULL;
>> + ?tmp_to_xfer_partial_ops = NULL;
>> + ?tmp_to_xfer_partial = NULL;
>> + ?tmp_to_insert_breakpoint = NULL;
>> + ?tmp_to_remove_breakpoint = NULL;
>>
>> ? /* Set the beneath function pointers. ?*/
>> ? for (t = current_target.beneath; t != NULL; t = t->beneath)
>> ? ? {
>> - ? ? ?if (!record_beneath_to_resume)
>> + ? ? ?if (!tmp_to_resume)
>> ? ? ? ? {
>> - ? ? ? ? record_beneath_to_resume = t->to_resume;
>> - ? ? ? ? record_beneath_to_resume_ops = t;
>> + ? ? ? ? tmp_to_resume = t->to_resume;
>> + ? ? ? ? tmp_to_resume_ops = t;
>> ? ? ? ? }
>> - ? ? ?if (!record_beneath_to_wait)
>> + ? ? ?if (!tmp_to_wait)
>> ? ? ? ? {
>> - ? ? ? ? record_beneath_to_wait = t->to_wait;
>> - ? ? ? ? record_beneath_to_wait_ops = t;
>> + ? ? ? ? tmp_to_wait = t->to_wait;
>> + ? ? ? ? tmp_to_wait_ops = t;
>> ? ? ? ? }
>> - ? ? ?if (!record_beneath_to_store_registers)
>> + ? ? ?if (!tmp_to_store_registers)
>> ? ? ? ? {
>> - ? ? ? ? record_beneath_to_store_registers = t->to_store_registers;
>> - ? ? ? ? record_beneath_to_store_registers_ops = t;
>> + ? ? ? ? tmp_to_store_registers = t->to_store_registers;
>> + ? ? ? ? tmp_to_store_registers_ops = t;
>> ? ? ? ? }
>> - ? ? ?if (!record_beneath_to_xfer_partial)
>> + ? ? ?if (!tmp_to_xfer_partial)
>> ? ? ? ? {
>> - ? ? ? ? record_beneath_to_xfer_partial = t->to_xfer_partial;
>> - ? ? ? ? record_beneath_to_xfer_partial_ops = t;
>> + ? ? ? ? tmp_to_xfer_partial = t->to_xfer_partial;
>> + ? ? ? ? tmp_to_xfer_partial_ops = t;
>> ? ? ? ? }
>> - ? ? ?if (!record_beneath_to_insert_breakpoint)
>> - ? ? ? record_beneath_to_insert_breakpoint = t->to_insert_breakpoint;
>> - ? ? ?if (!record_beneath_to_remove_breakpoint)
>> - ? ? ? record_beneath_to_remove_breakpoint = t->to_remove_breakpoint;
>> + ? ? ?if (!tmp_to_insert_breakpoint)
>> + ? ? ? tmp_to_insert_breakpoint = t->to_insert_breakpoint;
>> + ? ? ?if (!tmp_to_remove_breakpoint)
>> + ? ? ? tmp_to_remove_breakpoint = t->to_remove_breakpoint;
>> ? ? }
>> - ?if (!record_beneath_to_resume)
>> - ? ?error (_("Process record can't get to_resume."));
>> - ?if (!record_beneath_to_wait)
>> - ? ?error (_("Process record can't get to_wait."));
>> - ?if (!record_beneath_to_store_registers)
>> - ? ?error (_("Process record can't get to_store_registers."));
>> - ?if (!record_beneath_to_xfer_partial)
>> + ?if (!tmp_to_xfer_partial)
>> ? ? error (_("Process record can't get to_xfer_partial."));
>> - ?if (!record_beneath_to_insert_breakpoint)
>> - ? ?error (_("Process record can't get to_insert_breakpoint."));
>> - ?if (!record_beneath_to_remove_breakpoint)
>> - ? ?error (_("Process record can't get to_remove_breakpoint."));
>>
>> - ?push_target (&record_ops);
>> + ?if (current_target.to_stratum == core_stratum)
>> + ? ?record_core_open_1 (name, from_tty);
>> + ?else
>> + ? ?record_open_1 (name, from_tty);
>>
>> ? /* Reset */
>> ? record_insn_num = 0;
>> ? record_list = &record_first;
>> ? record_list->next = NULL;
>> +
>> + ?/* Set the tmp beneath pointers to beneath pointers. ?*/
>> + ?record_beneath_to_resume_ops = tmp_to_resume_ops;
>> + ?record_beneath_to_resume = tmp_to_resume;
>> + ?record_beneath_to_wait_ops = tmp_to_wait_ops;
>> + ?record_beneath_to_wait = tmp_to_wait;
>> + ?record_beneath_to_store_registers_ops = tmp_to_store_registers_ops;
>> + ?record_beneath_to_store_registers = tmp_to_store_registers;
>> + ?record_beneath_to_xfer_partial_ops = tmp_to_xfer_partial_ops;
>> + ?record_beneath_to_xfer_partial = tmp_to_xfer_partial;
>> + ?record_beneath_to_insert_breakpoint = tmp_to_insert_breakpoint;
>> + ?record_beneath_to_remove_breakpoint = tmp_to_remove_breakpoint;
>> +
>> + ?/* Load if there is argument. ?*/
>> + ?record_load (name);
>> ?}
>>
>> ?static void
>> ?record_close (int quitting)
>> ?{
>> + ?struct record_core_buf_entry *entry;
>> +
>> ? if (record_debug)
>> ? ? fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n");
>>
>> ? record_list_release (record_list);
>> +
>> + ?/* Release record_core_regbuf. ?*/
>> + ?if (record_core_regbuf)
>> + ? ?{
>> + ? ? ?xfree (record_core_regbuf);
>> + ? ? ?record_core_regbuf = NULL;
>> + ? ?}
>> +
>> + ?/* Release record_core_buf_list. ?*/
>> + ?if (record_core_buf_list)
>> + ? ?{
>> + ? ? ?for (entry = record_core_buf_list->prev; entry; entry =
>> entry->prev)
>> + ? ? ? ?{
>> + ? ? ? ? ?xfree (record_core_buf_list);
>> + ? ? ? ? ?record_core_buf_list = entry;
>> + ? ? ? ?}
>> + ? ? ?record_core_buf_list = NULL;
>> + ? ?}
>> ?}
>>
>> ?static int record_resume_step = 0;
>> @@ -584,7 +938,7 @@ record_wait (struct target_ops *ops,
>> ? ? ? ? ? ? ? ? ? ? ? ?"record_resume_step = %d\n",
>> ? ? ? ? ? ? ? ? ? ? ? ?record_resume_step);
>>
>> - ?if (!RECORD_IS_REPLAY)
>> + ?if (!RECORD_IS_REPLAY && ops != &record_core_ops)
>> ? ? {
>> ? ? ? if (record_resume_error)
>> ? ? ? ?{
>> @@ -712,76 +1066,9 @@ record_wait (struct target_ops *ops,
>> ? ? ? ? ? ? ?break;
>> ? ? ? ? ? ?}
>>
>> - ? ? ? ? /* Set ptid, register and memory according to record_list. ?*/
>> - ? ? ? ? if (record_list->type == record_reg)
>> - ? ? ? ? ? {
>> - ? ? ? ? ? ? /* reg */
>> - ? ? ? ? ? ? gdb_byte reg[MAX_REGISTER_SIZE];
>> - ? ? ? ? ? ? if (record_debug > 1)
>> - ? ? ? ? ? ? ? fprintf_unfiltered (gdb_stdlog,
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? "Process record: record_reg %s to "
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? "inferior num = %d.\n",
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? host_address_to_string (record_list),
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? record_list->u.reg.num);
>> - ? ? ? ? ? ? regcache_cooked_read (regcache, record_list->u.reg.num,
>> reg);
>> - ? ? ? ? ? ? regcache_cooked_write (regcache, record_list->u.reg.num,
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.reg.val);
>> - ? ? ? ? ? ? memcpy (record_list->u.reg.val, reg, MAX_REGISTER_SIZE);
>> - ? ? ? ? ? }
>> - ? ? ? ? else if (record_list->type == record_mem)
>> - ? ? ? ? ? {
>> - ? ? ? ? ? ? /* mem */
>> - ? ? ? ? ? ? /* Nothing to do if the entry is flagged not_accessible. ?*/
>> - ? ? ? ? ? ? if (!record_list->u.mem.mem_entry_not_accessible)
>> - ? ? ? ? ? ? ? {
>> - ? ? ? ? ? ? ? ? gdb_byte *mem = alloca (record_list->u.mem.len);
>> - ? ? ? ? ? ? ? ? if (record_debug > 1)
>> - ? ? ? ? ? ? ? ? ? fprintf_unfiltered (gdb_stdlog,
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? "Process record: record_mem %s to
>> "
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? "inferior addr = %s len = %d.\n",
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? host_address_to_string
>> (record_list),
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? paddress (gdbarch,
>> -
>> record_list->u.mem.addr),
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? record_list->u.mem.len);
>> + ? ? ? ? ?record_exec_entry (regcache, gdbarch, record_list);
>>
>> - ? ? ? ? ? ? ? ? if (target_read_memory (record_list->u.mem.addr, mem,
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? record_list->u.mem.len))
>> - ? ? ? ? ? ? ? ? ? {
>> - ? ? ? ? ? ? ? ? ? ? if (execution_direction != EXEC_REVERSE)
>> - ? ? ? ? ? ? ? ? ? ? ? error (_("Process record: error reading memory at
>> "
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"addr = %s len = %d."),
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?paddress (gdbarch,
>> record_list->u.mem.addr),
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.mem.len);
>> - ? ? ? ? ? ? ? ? ? ? else
>> - ? ? ? ? ? ? ? ? ? ? ? /* Read failed --
>> - ? ? ? ? ? ? ? ? ? ? ? ? ?flag entry as not_accessible. ?*/
>> - ? ? ? ? ? ? ? ? ? ? ? record_list->u.mem.mem_entry_not_accessible = 1;
>> - ? ? ? ? ? ? ? ? ? }
>> - ? ? ? ? ? ? ? ? else
>> - ? ? ? ? ? ? ? ? ? {
>> - ? ? ? ? ? ? ? ? ? ? if (target_write_memory (record_list->u.mem.addr,
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.mem.val,
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.mem.len))
>> - ? ? ? ? ? ? ? ? ? ? ? {
>> - ? ? ? ? ? ? ? ? ? ? ? ? if (execution_direction != EXEC_REVERSE)
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? error (_("Process record: error writing memory
>> at "
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"addr = %s len = %d."),
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?paddress (gdbarch,
>> record_list->u.mem.addr),
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.mem.len);
>> - ? ? ? ? ? ? ? ? ? ? ? ? else
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? /* Write failed --
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?flag entry as not_accessible. ?*/
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? record_list->u.mem.mem_entry_not_accessible =
>> 1;
>> - ? ? ? ? ? ? ? ? ? ? ? }
>> - ? ? ? ? ? ? ? ? ? ? else
>> - ? ? ? ? ? ? ? ? ? ? ? {
>> - ? ? ? ? ? ? ? ? ? ? ? ? memcpy (record_list->u.mem.val, mem,
>> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? record_list->u.mem.len);
>> - ? ? ? ? ? ? ? ? ? ? ? }
>> - ? ? ? ? ? ? ? ? ? }
>> - ? ? ? ? ? ? ? }
>> - ? ? ? ? ? }
>> - ? ? ? ? else
>> + ? ? ? ? if (record_list->type == record_end)
>> ? ? ? ? ? ?{
>> ? ? ? ? ? ? ?if (record_debug > 1)
>> ? ? ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog,
>> @@ -901,6 +1188,7 @@ record_kill (struct target_ops *ops)
>> ? ? fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n");
>>
>> ? unpush_target (&record_ops);
>> +
>> ? target_kill ();
>> ?}
>>
>> @@ -945,7 +1233,7 @@ record_registers_change (struct regcache
>> ? record_list = record_arch_list_tail;
>>
>> ? if (record_insn_num == record_insn_max_num && record_insn_max_num)
>> - ? ?record_list_release_first ();
>> + ? ?record_list_release_first_insn ();
>> ? else
>> ? ? record_insn_num++;
>> ?}
>> @@ -1058,7 +1346,7 @@ record_xfer_partial (struct target_ops *
>> ? ? ? record_list = record_arch_list_tail;
>>
>> ? ? ? if (record_insn_num == record_insn_max_num && record_insn_max_num)
>> - ? ? ? record_list_release_first ();
>> + ? ? ? record_list_release_first_insn ();
>> ? ? ? else
>> ? ? ? ?record_insn_num++;
>> ? ? }
>> @@ -1138,6 +1426,191 @@ init_record_ops (void)
>> ?}
>>
>> ?static void
>> +record_core_resume (struct target_ops *ops, ptid_t ptid, int step,
>> + ? ? ? ? ? ? ? ? ? ?enum target_signal siggnal)
>> +{
>> + ?record_resume_step = step;
>> + ?record_resume_siggnal = siggnal;
>> +}
>> +
>> +static void
>> +record_core_kill (struct target_ops *ops)
>> +{
>> + ?if (record_debug)
>> + ? ?fprintf_unfiltered (gdb_stdlog, "Process record:
>> record_core_kill\n");
>> +
>> + ?unpush_target (&record_core_ops);
>> +}
>> +
>> +static void
>> +record_core_fetch_registers (struct target_ops *ops,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? struct regcache *regcache,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? int regno)
>> +{
>> + ?if (regno < 0)
>> + ? ?{
>> + ? ? ?int num = gdbarch_num_regs (get_regcache_arch (regcache));
>> + ? ? ?int i;
>> +
>> + ? ? ?for (i = 0; i < num; i ++)
>> + ? ? ? ?regcache_raw_supply (regcache, i,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? record_core_regbuf + MAX_REGISTER_SIZE * i);
>> + ? ?}
>> + ?else
>> + ? ?regcache_raw_supply (regcache, regno,
>> + ? ? ? ? ? ? ? ? ? ? ? ? record_core_regbuf + MAX_REGISTER_SIZE * regno);
>> +}
>> +
>> +static void
>> +record_core_prepare_to_store (struct regcache *regcache)
>> +{
>> +}
>> +
>> +static void
>> +record_core_store_registers (struct target_ops *ops,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? struct regcache *regcache,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? int regno)
>> +{
>> + ?if (record_gdb_operation_disable)
>> + ? ?regcache_raw_collect (regcache, regno,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ?record_core_regbuf + MAX_REGISTER_SIZE *
>> regno);
>> + ?else
>> + ? ?error (_("You can't do that without a process to debug."));
>> +}
>> +
>> +static LONGEST
>> +record_core_xfer_partial (struct target_ops *ops, enum target_object
>> object,
>> + ? ? ? ? ? ? ? ? ? ? ? ? const char *annex, gdb_byte *readbuf,
>> + ? ? ? ? ? ? ? ? ? ? ? ? const gdb_byte *writebuf, ULONGEST offset,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ?LONGEST len)
>> +{
>> + ? if (object == TARGET_OBJECT_MEMORY)
>> + ? ? {
>> + ? ? ? if (record_gdb_operation_disable || !writebuf)
>> + ? ? ? ? {
>> + ? ? ? ? ? struct target_section *p;
>> + ? ? ? ? ? for (p = record_core_start; p < record_core_end; p++)
>> + ? ? ? ? ? ? {
>> + ? ? ? ? ? ? ? if (offset >= p->addr)
>> + ? ? ? ? ? ? ? ? {
>> + ? ? ? ? ? ? ? ? ? struct record_core_buf_entry *entry;
>> +
>> + ? ? ? ? ? ? ? ? ? if (offset >= p->endaddr)
>> + ? ? ? ? ? ? ? ? ? ? continue;
>> +
>> + ? ? ? ? ? ? ? ? ? if (offset + len > p->endaddr)
>> + ? ? ? ? ? ? ? ? ? ? len = p->endaddr - offset;
>> +
>> + ? ? ? ? ? ? ? ? ? offset -= p->addr;
>> +
>> + ? ? ? ? ? ? ? ? ? /* Read readbuf or write writebuf p, offset, len. ?*/
>> + ? ? ? ? ? ? ? ? ? /* Check flags. ?*/
>> + ? ? ? ? ? ? ? ? ? if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
>> + ? ? ? ? ? ? ? ? ? ? ? || (p->the_bfd_section->flags & SEC_HAS_CONTENTS)
>> == 0)
>> + ? ? ? ? ? ? ? ? ? ? {
>> + ? ? ? ? ? ? ? ? ? ? ? if (readbuf)
>> + ? ? ? ? ? ? ? ? ? ? ? ? memset (readbuf, 0, len);
>> + ? ? ? ? ? ? ? ? ? ? ? return len;
>> + ? ? ? ? ? ? ? ? ? ? }
>> + ? ? ? ? ? ? ? ? ? /* Get record_core_buf_entry. ?*/
>> + ? ? ? ? ? ? ? ? ? for (entry = record_core_buf_list; entry;
>> + ? ? ? ? ? ? ? ? ? ? ? ?entry = entry->prev)
>> + ? ? ? ? ? ? ? ? ? ? if (entry->p == p)
>> + ? ? ? ? ? ? ? ? ? ? ? break;
>> + ? ? ? ? ? ? ? ? ? if (writebuf)
>> + ? ? ? ? ? ? ? ? ? ? {
>> + ? ? ? ? ? ? ? ? ? ? ? if (!entry)
>> + ? ? ? ? ? ? ? ? ? ? ? ? {
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? /* Add a new entry. ?*/
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? entry
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? = (struct record_core_buf_entry *)
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? xmalloc
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? (sizeof (struct
>> record_core_buf_entry));
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? entry->p = p;
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? if (!bfd_malloc_and_get_section (p->bfd,
>> +
>> ?p->the_bfd_section,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?&entry->buf))
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? {
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? xfree (entry);
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? return 0;
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? }
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? entry->prev = record_core_buf_list;
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? record_core_buf_list = entry;
>> + ? ? ? ? ? ? ? ? ? ? ? ? }
>> +
>> + ? ? ? ? ? ? ? ? ? ? ? ?memcpy (entry->buf + offset, writebuf, (size_t)
>> len);
>> + ? ? ? ? ? ? ? ? ? ? }
>> + ? ? ? ? ? ? ? ? ? else
>> + ? ? ? ? ? ? ? ? ? ? {
>> + ? ? ? ? ? ? ? ? ? ? ? if (!entry)
>> + ? ? ? ? ? ? ? ? ? ? ? ? return record_beneath_to_xfer_partial
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?(record_beneath_to_xfer_partial_ops,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? object, annex, readbuf, writebuf,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? offset, len);
>> +
>> + ? ? ? ? ? ? ? ? ? ? ? memcpy (readbuf, entry->buf + offset, (size_t)
>> len);
>> + ? ? ? ? ? ? ? ? ? ? }
>> +
>> + ? ? ? ? ? ? ? ? ? return len;
>> + ? ? ? ? ? ? ? ? }
>> + ? ? ? ? ? ? }
>> +
>> + ? ? ? ? ? return -1;
>> + ? ? ? ? }
>> + ? ? ? else
>> + ? ? ? ? error (_("You can't do that without a process to debug."));
>> + ? ? }
>> +
>> + ?return record_beneath_to_xfer_partial
>> (record_beneath_to_xfer_partial_ops,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? object, annex, readbuf,
>> writebuf,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? offset, len);
>> +}
>> +
>> +static int
>> +record_core_insert_breakpoint (struct gdbarch *gdbarch,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct bp_target_info *bp_tgt)
>> +{
>> + ?return 0;
>> +}
>> +
>> +static int
>> +record_core_remove_breakpoint (struct gdbarch *gdbarch,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct bp_target_info *bp_tgt)
>> +{
>> + ?return 0;
>> +}
>> +
>> +int
>> +record_core_has_execution (struct target_ops *ops)
>> +{
>> + ?return 1;
>> +}
>> +
>> +static void
>> +init_record_core_ops (void)
>> +{
>> + ?record_core_ops.to_shortname = "record_core";
>> + ?record_core_ops.to_longname = "Process record and replay target";
>> + ?record_core_ops.to_doc =
>> + ? ?"Log program while executing and replay execution from log.";
>> + ?record_core_ops.to_open = record_open;
>> + ?record_core_ops.to_close = record_close;
>> + ?record_core_ops.to_resume = record_core_resume;
>> + ?record_core_ops.to_wait = record_wait;
>> + ?record_core_ops.to_kill = record_core_kill;
>> + ?record_core_ops.to_fetch_registers = record_core_fetch_registers;
>> + ?record_core_ops.to_prepare_to_store = record_core_prepare_to_store;
>> + ?record_core_ops.to_store_registers = record_core_store_registers;
>> + ?record_core_ops.to_xfer_partial = record_core_xfer_partial;
>> + ?record_core_ops.to_insert_breakpoint = record_core_insert_breakpoint;
>> + ?record_core_ops.to_remove_breakpoint = record_core_remove_breakpoint;
>> + ?record_core_ops.to_can_execute_reverse = record_can_execute_reverse;
>> + ?record_core_ops.to_has_execution = record_core_has_execution;
>> + ?record_core_ops.to_stratum = record_stratum;
>> + ?record_core_ops.to_magic = OPS_MAGIC;
>> +}
>> +
>> +static void
>> ?show_record_debug (struct ui_file *file, int from_tty,
>> ? ? ? ? ? ? ? ? ? struct cmd_list_element *c, const char *value)
>> ?{
>> @@ -1153,6 +1626,212 @@ cmd_record_start (char *args, int from_t
>> ? execute_command ("target record", from_tty);
>> ?}
>>
>> +static void
>> +cmd_record_load (char *args, int from_tty)
>> +{
>> + ?char buf[512];
>> +
>> + ?snprintf (buf, 512, "target record %s", args);
>> + ?execute_command (buf, from_tty);
>> +}
>> +
>> +static inline void
>> +record_write_dump (char *recfilename, int fildes, const void *buf,
>> + ? ? ? ? ? ? ? ? ? size_t nbyte)
>> +{
>> + ?if (write (fildes, buf, nbyte) != nbyte)
>> + ? ?error (_("Failed to write dump of execution records to '%s'."),
>> + ? ? ? ? ? recfilename);
>> +}
>> +
>> +/* Record log save-file format
>> + ? Version 1
>> +
>> + ? Header:
>> + ? ? 4 bytes: magic number htonl(0x20090726).
>> + ? ? ? NOTE: be sure to change whenever this file format changes!
>> +
>> + ? Records:
>> + ? ? record_end:
>> + ? ? ? 1 byte: ?record type (record_end).
>> + ? ? record_reg:
>> + ? ? ? 1 byte: ?record type (record_reg).
>> + ? ? ? 8 bytes: register id (network byte order).
>> + ? ? ? MAX_REGISTER_SIZE bytes: register value.
>> + ? ? record_mem:
>> + ? ? ? 1 byte: ?record type (record_mem).
>> + ? ? ? 8 bytes: memory address (network byte order).
>> + ? ? ? 8 bytes: memory length (network byte order).
>> + ? ? ? n bytes: memory value (n == memory length).
>> +*/
>> +
>> +/* Dump the execution log to a file. ?*/
>> +
>> +static void
>> +cmd_record_dump (char *args, int from_tty)
>> +{
>> + ?char *recfilename, recfilename_buffer[40];
>> + ?int recfd;
>> + ?struct record_entry *cur_record_list;
>> + ?uint32_t magic;
>> + ?struct regcache *regcache;
>> + ?struct gdbarch *gdbarch;
>> + ?struct cleanup *old_cleanups;
>> + ?struct cleanup *set_cleanups;
>> +
>> + ?if (strcmp (current_target.to_shortname, "record") != 0)
>> + ? ?error (_("Process record is not started.\n"));
>> +
>> + ?if (args && *args)
>> + ? ?recfilename = args;
>> + ?else
>> + ? ?{
>> + ? ? ?/* Default corefile name is "gdb_record.PID". ?*/
>> + ? ? ?snprintf (recfilename_buffer, 40, "gdb_record.%d",
>> + ? ? ? ? ? ? ? ?PIDGET (inferior_ptid));
>> + ? ? ?recfilename = recfilename_buffer;
>> + ? ?}
>> +
>> + ?/* Open the dump file. ?*/
>> + ?if (record_debug)
>> + ? ?fprintf_unfiltered (gdb_stdlog,
>> + ? ? ? ? ? ? ? ? ? ? ? ?_("Saving recording to file '%s'\n"),
>> + ? ? ? ? ? ? ? ? ? ? ? ?recfilename);
>> + ?recfd = open (recfilename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
>> + ? ? ? ? ? ? ? ?S_IRUSR | S_IWUSR);
>> + ?if (recfd < 0)
>> + ? ?error (_("Failed to open '%s' for dump execution records: %s"),
>> + ? ? ? ? ? recfilename, strerror (errno));
>> + ?old_cleanups = make_cleanup (record_fd_cleanups, &recfd);
>> +
>> + ?/* Save the current record entry to "cur_record_list". ?*/
>> + ?cur_record_list = record_list;
>> +
>> + ?/* Get the values of regcache and gdbarch. ?*/
>> + ?regcache = get_current_regcache ();
>> + ?gdbarch = get_regcache_arch (regcache);
>> +
>> + ?/* Disable the GDB operation record. ?*/
>> + ?set_cleanups = record_gdb_operation_disable_set ();
>> +
>> + ?/* Write the magic code. ?*/
>> + ?magic = RECORD_FILE_MAGIC;
>> + ?if (record_debug)
>> + ? ?fprintf_unfiltered (gdb_stdlog, _("\
>> +Writing 4-byte magic cookie RECORD_FILE_MAGIC (0x%08x)\n"),
>> + ? ? ? ? ? ? ? ? ? ? ? ?magic);
>> + ?record_write_dump (recfilename, recfd, &magic, 4);
>> +
>> + ?/* Reverse execute to the begin of record list. ?*/
>> + ?while (1)
>> + ? ?{
>> + ? ? ?/* Check for beginning and end of log. ?*/
>> + ? ? ?if (record_list == &record_first)
>> + ? ? ? ?break;
>> +
>> + ? ? ?record_exec_entry (regcache, gdbarch, record_list);
>> +
>> + ? ? ?if (record_list->prev)
>> + ? ? ? ?record_list = record_list->prev;
>> + ? ?}
>> +
>> + ?/* Dump the entries to recfd and forward execute to the end of
>> + ? ? record list. ?*/
>> + ?while (1)
>> + ? ?{
>> + ? ? ?/* Dump entry. ?*/
>> + ? ? ?if (record_list != &record_first)
>> + ? ? ? ?{
>> + ? ? ? ? ?uint8_t tmpu8;
>> + ? ? ? ? ?uint64_t tmpu64;
>> +
>> + ? ? ? ? ?tmpu8 = record_list->type;
>> + ? ? ? ? ?record_write_dump (recfilename, recfd, &tmpu8, 1);
>> +
>> + ? ? ? ? ?switch (record_list->type)
>> + ? ? ? ? ? ?{
>> + ? ? ? ? ? ?case record_reg: /* reg */
>> + ? ? ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog, _("\
>> +Writing register %d (1 plus 8 plus %d bytes)\n"),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.reg.num,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?MAX_REGISTER_SIZE);
>> +
>> + ? ? ? ? ? ? ?tmpu64 = record_list->u.reg.num;
>> + ? ? ? ? ? ? ?if (BYTE_ORDER == LITTLE_ENDIAN)
>> + ? ? ? ? ? ? ? ?tmpu64 = bswap_64 (tmpu64);
>> + ? ? ? ? ? ? ?record_write_dump (recfilename, recfd, &tmpu64, 8);
>> +
>> + ? ? ? ? ? ? ?record_write_dump (recfilename, recfd,
>> record_list->u.reg.val,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? MAX_REGISTER_SIZE);
>> + ? ? ? ? ? ? ?break;
>> +
>> + ? ? ? ? ? ?case record_mem: /* mem */
>> + ? ? ? ? ? ? ?if (!record_list->u.mem.mem_entry_not_accessible)
>> + ? ? ? ? ? ? ? ?{
>> + ? ? ? ? ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog, _("\
>> +Writing memory %s (1 plus 8 plus 8 bytes plus %d bytes)\n"),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?paddress (gdbarch,
>> +
>> ?record_list->u.mem.addr),
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?record_list->u.mem.len);
>> +
>> + ? ? ? ? ? ? ? ? ?tmpu64 = record_list->u.mem.addr;
>> + ? ? ? ? ? ? ? ? ?if (BYTE_ORDER == LITTLE_ENDIAN)
>> + ? ? ? ? ? ? ? ? ? ?tmpu64 = bswap_64 (tmpu64);
>> + ? ? ? ? ? ? ? ? ?record_write_dump (recfilename, recfd, &tmpu64, 8);
>> +
>> + ? ? ? ? ? ? ? ? ?tmpu64 = record_list->u.mem.len;
>> + ? ? ? ? ? ? ? ? ?if (BYTE_ORDER == LITTLE_ENDIAN)
>> + ? ? ? ? ? ? ? ? ? ?tmpu64 = bswap_64 (tmpu64);
>> + ? ? ? ? ? ? ? ? ?record_write_dump (recfilename, recfd, &tmpu64, 8);
>> +
>> + ? ? ? ? ? ? ? ? ?record_write_dump (recfilename, recfd,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? record_list->u.mem.val,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? record_list->u.mem.len);
>> + ? ? ? ? ? ? ? ?}
>> + ? ? ? ? ? ? ?break;
>> +
>> + ? ? ? ? ? ? ?case record_end:
>> + ? ? ? ? ? ? ? ?/* FIXME: record the contents of record_end rec. ?*/
>> + ? ? ? ? ? ? ? ?if (record_debug)
>> + ? ? ? ? ? ? ? ? ?fprintf_unfiltered (gdb_stdlog,
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?_("Writing record_end (1
>> byte)\n"));
>> + ? ? ? ? ? ? ? ?break;
>> + ? ? ? ? ? ?}
>> + ? ? ? ?}
>> +
>> + ? ? ?/* Execute entry. ?*/
>> + ? ? ?record_exec_entry (regcache, gdbarch, record_list);
>> +
>> + ? ? ?if (record_list->next)
>> + ? ? ? ?record_list = record_list->next;
>> + ? ? ?else
>> + ? ? ? ?break;
>> + ? ?}
>> +
>> + ?/* Reverse execute to cur_record_list. ?*/
>> + ?while (1)
>> + ? ?{
>> + ? ? ?/* Check for beginning and end of log. ?*/
>> + ? ? ?if (record_list == cur_record_list)
>> + ? ? ? ?break;
>> +
>> + ? ? ?record_exec_entry (regcache, gdbarch, record_list);
>> +
>> + ? ? ?if (record_list->prev)
>> + ? ? ? ?record_list = record_list->prev;
>> + ? ?}
>> +
>> + ?do_cleanups (set_cleanups);
>> + ?do_cleanups (old_cleanups);
>> +
>> + ?/* Succeeded. ?*/
>> + ?fprintf_filtered (gdb_stdout, _("Saved dump of execution "
>> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"records to `%s'.\n"),
>> + ? ? ? ? ? ? ? ? ? ?recfilename);
>> +}
>> +
>> ?/* Truncate the record log from the present point
>> ? ?of replay until the end. ?*/
>>
>> @@ -1185,7 +1864,12 @@ cmd_record_stop (char *args, int from_tt
>> ? ? {
>> ? ? ? if (!record_list || !from_tty || query (_("Delete recorded log and "
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"stop recording?")))
>> - ? ? ? unpush_target (&record_ops);
>> + ? ? ? ?{
>> + ? ? ? ? ?if (strcmp (current_target.to_shortname, "record") == 0)
>> + ? ? ? ? ? unpush_target (&record_ops);
>> + ? ? ? ? ?else
>> + ? ? ? ? ? ?unpush_target (&record_core_ops);
>> + ? ? ? ?}
>> ? ? }
>> ? else
>> ? ? printf_unfiltered (_("Process record is not started.\n"));
>> @@ -1203,7 +1887,7 @@ set_record_insn_max_num (char *args, int
>> ? ? ? ? ? ? ? ? ? ? ? ? ? "the first ones?\n"));
>>
>> ? ? ? while (record_insn_num > record_insn_max_num)
>> - ? ? ? record_list_release_first ();
>> + ? ? ? record_list_release_first_insn ();
>> ? ? }
>> ?}
>>
>> @@ -1243,6 +1927,8 @@ info_record_command (char *args, int fro
>> ?void
>> ?_initialize_record (void)
>> ?{
>> + ?struct cmd_list_element *c;
>> +
>> ? /* Init record_first. ?*/
>> ? record_first.prev = NULL;
>> ? record_first.next = NULL;
>> @@ -1250,6 +1936,8 @@ _initialize_record (void)
>>
>> ? init_record_ops ();
>> ? add_target (&record_ops);
>> + ?init_record_core_ops ();
>> + ?add_target (&record_core_ops);
>>
>> ? add_setshow_zinteger_cmd ("record", no_class, &record_debug,
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ?_("Set debugging of record/replay feature."),
>> @@ -1259,9 +1947,10 @@ _initialize_record (void)
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ?NULL, show_record_debug, &setdebuglist,
>> ? ? ? ? ? ? ? ? ? ? ? ? ? ?&showdebuglist);
>>
>> - ?add_prefix_cmd ("record", class_obscure, cmd_record_start,
>> - ? ? ? ? ? ? ? ? _("Abbreviated form of \"target record\" command."),
>> - ? ? ? ? ? ? ? ? &record_cmdlist, "record ", 0, &cmdlist);
>> + ?c = add_prefix_cmd ("record", class_obscure, cmd_record_start,
>> + ? ? ? ? ? ? ? ? ? ? _("Abbreviated form of \"target record\" command."),
>> + ? ? ? ? ? ? ? ? ? ? &record_cmdlist, "record ", 0, &cmdlist);
>> + ?set_cmd_completer (c, filename_completer);
>> ? add_com_alias ("rec", "record", class_obscure, 1);
>> ? add_prefix_cmd ("record", class_support, set_record_command,
>> ? ? ? ? ? ? ? ? ?_("Set record options"), &set_record_cmdlist,
>> @@ -1276,6 +1965,16 @@ _initialize_record (void)
>> ? ? ? ? ? ? ? ? ?"info record ", 0, &infolist);
>> ? add_alias_cmd ("rec", "record", class_obscure, 1, &infolist);
>>
>> + ?c = add_cmd ("load", class_obscure, cmd_record_load,
>> + ? ? ? ? ? ? ?_("Load previously dumped execution records from \
>> +a file given as argument."),
>> + ? ? ? ? ? ? ? &record_cmdlist);
>> + ?set_cmd_completer (c, filename_completer);
>> + ?c = add_cmd ("dump", class_obscure, cmd_record_dump,
>> + ? ? ? ? ? ? ?_("Dump the execution records to a file.\n\
>> +Argument is optional filename. ?Default filename is
>> 'gdb_record.<process_id>'."),
>> + ? ? ? ? ? ? ? &record_cmdlist);
>> + ?set_cmd_completer (c, filename_completer);
>>
>> ? add_cmd ("delete", class_obscure, cmd_record_delete,
>> ? ? ? ? ? _("Delete the rest of execution log and start recording it
>> anew."),
>
>