OpenE2K/binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
99e008fef7
binutils-gdb/gdb/record.c
Michael Snyder afd0cd3fc1 2009-08-04 Hui Zhu <teawater@gmail.com> 
Michael Snyder  <msnyder@vmware.com>

	* record.c (record_mem_entry): New field 'mem_entry_not_accessible'.
	(record_arch_list_add_mem): Initialize 'mem_entry_not_accessible'.
	(record_wait): Set 'mem_entry_not_accessible' flag if target
	memory not readable.  Don't try to change target memory if
	'mem_entry_not_accessible' is set.
2009-08-04 18:19:52 +00:00

1315 lines
36 KiB
C
Raw Blame History

/* Process record and replay target for GDB, the GNU debugger.
Copyright (C) 2008, 2009 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdbcmd.h"
#include "regcache.h"
#include "gdbthread.h"
#include "event-top.h"
#include "exceptions.h"
#include "record.h"
#include <signal.h>
#define DEFAULT_RECORD_INSN_MAX_NUM 200000
#define RECORD_IS_REPLAY \
(record_list->next || execution_direction == EXEC_REVERSE)
/* These are the core struct of record function.
An record_entry is a record of the value change of a register
("record_reg") or a part of memory ("record_mem"). And each
instruction must has a struct record_entry ("record_end") that points out this
is the last struct record_entry of this instruction.
Each struct record_entry is linked to "record_list" by "prev" and "next". */
struct record_reg_entry
{
int num;
gdb_byte *val;
};
struct record_mem_entry
{
CORE_ADDR addr;
int len;
/* Set this flag if target memory for this entry
can no longer be accessed. */
int mem_entry_not_accessible;
gdb_byte *val;
};
enum record_type
{
record_end = 0,
record_reg,
record_mem
};
struct record_entry
{
struct record_entry *prev;
struct record_entry *next;
enum record_type type;
union
{
/* reg */
struct record_reg_entry reg;
/* mem */
struct record_mem_entry mem;
} u;
};
/* This is the debug switch for process record. */
int record_debug = 0;
/* These list is for execution log. */
static struct record_entry record_first;
static struct record_entry *record_list = &record_first;
static struct record_entry *record_arch_list_head = NULL;
static struct record_entry *record_arch_list_tail = NULL;
/* 1 ask user. 0 auto delete the last struct record_entry. */
static int record_stop_at_limit = 1;
static int record_insn_max_num = DEFAULT_RECORD_INSN_MAX_NUM;
static int record_insn_num = 0;
/* The target_ops of process record. */
static struct target_ops record_ops;
/* The beneath function pointers. */
static struct target_ops *record_beneath_to_resume_ops;
static void (*record_beneath_to_resume) (struct target_ops *, ptid_t, int,
enum target_signal);
static struct target_ops *record_beneath_to_wait_ops;
static ptid_t (*record_beneath_to_wait) (struct target_ops *, ptid_t,
struct target_waitstatus *,
int);
static struct target_ops *record_beneath_to_store_registers_ops;
static void (*record_beneath_to_store_registers) (struct target_ops *,
struct regcache *,
int regno);
static struct target_ops *record_beneath_to_xfer_partial_ops;
static LONGEST (*record_beneath_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 (*record_beneath_to_insert_breakpoint) (struct gdbarch *,
struct bp_target_info *);
static int (*record_beneath_to_remove_breakpoint) (struct gdbarch *,
struct bp_target_info *);
static void
record_list_release (struct record_entry *rec)
{
struct record_entry *tmp;
if (!rec)
return;
while (rec->next)
{
rec = rec->next;
}
while (rec->prev)
{
tmp = rec;
rec = rec->prev;
if (tmp->type == record_reg)
xfree (tmp->u.reg.val);
else if (tmp->type == record_mem)
xfree (tmp->u.mem.val);
xfree (tmp);
}
if (rec != &record_first)
xfree (rec);
}
static void
record_list_release_next (void)
{
struct record_entry *rec = record_list;
struct record_entry *tmp = rec->next;
rec->next = NULL;
while (tmp)
{
rec = tmp->next;
if (tmp->type == record_reg)
record_insn_num--;
else if (tmp->type == record_reg)
xfree (tmp->u.reg.val);
else if (tmp->type == record_mem)
xfree (tmp->u.mem.val);
xfree (tmp);
tmp = rec;
}
}
static void
record_list_release_first (void)
{
struct record_entry *tmp = NULL;
enum record_type type;
if (!record_first.next)
return;
while (1)
{
type = record_first.next->type;
if (type == record_reg)
xfree (record_first.next->u.reg.val);
else if (type == record_mem)
xfree (record_first.next->u.mem.val);
tmp = record_first.next;
record_first.next = tmp->next;
xfree (tmp);
if (!record_first.next)
{
gdb_assert (record_insn_num == 1);
break;
}
record_first.next->prev = &record_first;
if (type == record_end)
break;
}
record_insn_num--;
}
/* Add a struct record_entry to record_arch_list. */
static void
record_arch_list_add (struct record_entry *rec)
{
if (record_debug > 1)
fprintf_unfiltered (gdb_stdlog,
"Process record: record_arch_list_add %s.\n",
host_address_to_string (rec));
if (record_arch_list_tail)
{
record_arch_list_tail->next = rec;
rec->prev = record_arch_list_tail;
record_arch_list_tail = rec;
}
else
{
record_arch_list_head = rec;
record_arch_list_tail = rec;
}
}
/* Record the value of a register NUM to record_arch_list. */
int
record_arch_list_add_reg (struct regcache *regcache, int num)
{
struct record_entry *rec;
if (record_debug > 1)
fprintf_unfiltered (gdb_stdlog,
"Process record: add register num = %d to "
"record list.\n",
num);
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;
rec->u.reg.num = num;
regcache_raw_read (regcache, num, rec->u.reg.val);
record_arch_list_add (rec);
return 0;
}
/* Record the value of a region of memory whose address is ADDR and
length is LEN to record_arch_list. */
int
record_arch_list_add_mem (CORE_ADDR addr, int len)
{
struct record_entry *rec;
if (record_debug > 1)
fprintf_unfiltered (gdb_stdlog,
"Process record: add mem addr = %s len = %d to "
"record list.\n",
paddress (target_gdbarch, addr), len);
if (!addr)
return 0;
rec = (struct record_entry *) xmalloc (sizeof (struct record_entry));
rec->u.mem.val = (gdb_byte *) xmalloc (len);
rec->prev = NULL;
rec->next = NULL;
rec->type = record_mem;
rec->u.mem.addr = addr;
rec->u.mem.len = len;
rec->u.mem.mem_entry_not_accessible = 0;
if (target_read_memory (addr, rec->u.mem.val, len))
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
"Process record: error reading memory at "
"addr = %s len = %d.\n",
paddress (target_gdbarch, addr), len);
xfree (rec->u.mem.val);
xfree (rec);
return -1;
}
record_arch_list_add (rec);
return 0;
}
/* Add a record_end type struct record_entry to record_arch_list. */
int
record_arch_list_add_end (void)
{
struct record_entry *rec;
if (record_debug > 1)
fprintf_unfiltered (gdb_stdlog,
"Process record: add end to arch list.\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);
return 0;
}
static void
record_check_insn_num (int set_terminal)
{
if (record_insn_max_num)
{
gdb_assert (record_insn_num <= record_insn_max_num);
if (record_insn_num == record_insn_max_num)
{
/* Ask user what to do. */
if (record_stop_at_limit)
{
int q;
if (set_terminal)
target_terminal_ours ();
q = yquery (_("Do you want to auto delete previous execution "
"log entries when record/replay buffer becomes "
"full (record stop-at-limit)?"));
if (set_terminal)
target_terminal_inferior ();
if (q)
record_stop_at_limit = 0;
else
error (_("Process record: inferior program stopped."));
}
}
}
}
/* 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);
record_arch_list_head = NULL;
record_arch_list_tail = NULL;
/* Check record_insn_num. */
record_check_insn_num (1);
ret = gdbarch_process_record (get_regcache_arch (regcache),
regcache,
regcache_read_pc (regcache));
if (ret > 0)
error (_("Process record: inferior program stopped."));
if (ret < 0)
error (_("Process record: failed to record execution log."));
discard_cleanups (old_cleanups);
record_list->next = record_arch_list_head;
record_arch_list_head->prev = record_list;
record_list = record_arch_list_tail;
if (record_insn_num == record_insn_max_num && record_insn_max_num)
record_list_release_first ();
else
record_insn_num++;
return 1;
}
static int
do_record_message (struct regcache *regcache)
{
return catch_errors (record_message, regcache, NULL, RETURN_MASK_ALL);
}
/* Set to 1 if record_store_registers and record_xfer_partial
doesn't need record. */
static int record_gdb_operation_disable = 0;
struct cleanup *
record_gdb_operation_disable_set (void)
{
struct cleanup *old_cleanups = NULL;
old_cleanups =
make_cleanup_restore_integer (&record_gdb_operation_disable);
record_gdb_operation_disable = 1;
return old_cleanups;
}
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 exec */
if (!target_has_execution)
error (_("Process record: the program is not being run."));
if (non_stop)
error (_("Process record target can't debug inferior in non-stop mode "
"(non-stop)."));
if (target_async_permitted)
error (_("Process record target can't debug inferior in asynchronous "
"mode (target-async)."));
if (!gdbarch_process_record_p (target_gdbarch))
error (_("Process record: the current architecture doesn't support "
"record function."));
/* Check if record target is already running. */
if (current_target.to_stratum == record_stratum)
{
if (!nquery
(_("Process record target already running, do you want to delete "
"the old record log?")))
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;
/* Set the beneath function pointers. */
for (t = current_target.beneath; t != NULL; t = t->beneath)
{
if (!record_beneath_to_resume)
{
record_beneath_to_resume = t->to_resume;
record_beneath_to_resume_ops = t;
}
if (!record_beneath_to_wait)
{
record_beneath_to_wait = t->to_wait;
record_beneath_to_wait_ops = t;
}
if (!record_beneath_to_store_registers)
{
record_beneath_to_store_registers = t->to_store_registers;
record_beneath_to_store_registers_ops = t;
}
if (!record_beneath_to_xfer_partial)
{
record_beneath_to_xfer_partial = t->to_xfer_partial;
record_beneath_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 (!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)
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);
/* Reset */
record_insn_num = 0;
record_list = &record_first;
record_list->next = NULL;
}
static void
record_close (int quitting)
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n");
record_list_release (record_list);
}
static int record_resume_step = 0;
static enum target_signal record_resume_siggnal;
static int record_resume_error;
static void
record_resume (struct target_ops *ops, ptid_t ptid, int step,
enum target_signal siggnal)
{
record_resume_step = step;
record_resume_siggnal = siggnal;
if (!RECORD_IS_REPLAY)
{
if (do_record_message (get_current_regcache ()))
{
record_resume_error = 0;
}
else
{
record_resume_error = 1;
return;
}
record_beneath_to_resume (record_beneath_to_resume_ops, ptid, 1,
siggnal);
}
}
static int record_get_sig = 0;
static void
record_sig_handler (int signo)
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog, "Process record: get a signal\n");
/* It will break the running inferior in replay mode. */
record_resume_step = 1;
/* It will let record_wait set inferior status to get the signal
SIGINT. */
record_get_sig = 1;
}
static void
record_wait_cleanups (void *ignore)
{
if (execution_direction == EXEC_REVERSE)
{
if (record_list->next)
record_list = record_list->next;
}
else
record_list = record_list->prev;
}
/* In replay mode, this function examines the recorded log and
determines where to stop. */
static ptid_t
record_wait (struct target_ops *ops,
ptid_t ptid, struct target_waitstatus *status,
int options)
{
struct cleanup *set_cleanups = record_gdb_operation_disable_set ();
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
"Process record: record_wait "
"record_resume_step = %d\n",
record_resume_step);
if (!RECORD_IS_REPLAY)
{
if (record_resume_error)
{
/* If record_resume get error, return directly. */
status->kind = TARGET_WAITKIND_STOPPED;
status->value.sig = TARGET_SIGNAL_ABRT;
return inferior_ptid;
}
if (record_resume_step)
{
/* This is a single step. */
return record_beneath_to_wait (record_beneath_to_wait_ops,
ptid, status, 0);
}
else
{
/* This is not a single step. */
ptid_t ret;
CORE_ADDR tmp_pc;
while (1)
{
ret = record_beneath_to_wait (record_beneath_to_wait_ops,
ptid, status, 0);
if (status->kind == TARGET_WAITKIND_STOPPED
&& status->value.sig == TARGET_SIGNAL_TRAP)
{
/* Check if there is a breakpoint. */
registers_changed ();
tmp_pc = regcache_read_pc (get_current_regcache ());
if (breakpoint_inserted_here_p (tmp_pc))
{
/* There is a breakpoint. */
CORE_ADDR decr_pc_after_break =
gdbarch_decr_pc_after_break
(get_regcache_arch (get_current_regcache ()));
if (decr_pc_after_break)
{
regcache_write_pc (get_thread_regcache (ret),
tmp_pc + decr_pc_after_break);
}
}
else
{
/* There is not a breakpoint. */
if (!do_record_message (get_current_regcache ()))
{
break;
}
record_beneath_to_resume (record_beneath_to_resume_ops,
ptid, 1,
record_resume_siggnal);
continue;
}
}
/* The inferior is broken by a breakpoint or a signal. */
break;
}
return ret;
}
}
else
{
struct regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int continue_flag = 1;
int first_record_end = 1;
struct cleanup *old_cleanups = make_cleanup (record_wait_cleanups, 0);
CORE_ADDR tmp_pc;
status->kind = TARGET_WAITKIND_STOPPED;
/* Check breakpoint when forward execute. */
if (execution_direction == EXEC_FORWARD)
{
tmp_pc = regcache_read_pc (regcache);
if (breakpoint_inserted_here_p (tmp_pc))
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
"Process record: break at %s.\n",
paddress (gdbarch, tmp_pc));
if (gdbarch_decr_pc_after_break (gdbarch)
&& !record_resume_step)
regcache_write_pc (regcache,
tmp_pc +
gdbarch_decr_pc_after_break (gdbarch));
goto replay_out;
}
}
record_get_sig = 0;
signal (SIGINT, record_sig_handler);
/* If GDB is in terminal_inferior mode, it will not get the signal.
And in GDB replay mode, GDB doesn't need to be in terminal_inferior
mode, because inferior will not executed.
Then set it to terminal_ours to make GDB get the signal. */
target_terminal_ours ();
/* In EXEC_FORWARD mode, record_list points to the tail of prev
instruction. */
if (execution_direction == EXEC_FORWARD && record_list->next)
record_list = record_list->next;
/* Loop over the record_list, looking for the next place to
stop. */
do
{
/* Check for beginning and end of log. */
if (execution_direction == EXEC_REVERSE
&& record_list == &record_first)
{
/* Hit beginning of record log in reverse. */
status->kind = TARGET_WAITKIND_NO_HISTORY;
break;
}
if (execution_direction != EXEC_REVERSE && !record_list->next)
{
/* Hit end of record log going forward. */
status->kind = TARGET_WAITKIND_NO_HISTORY;
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);
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_debug > 1)
fprintf_unfiltered (gdb_stdlog,
"Process record: record_end %s to "
"inferior.\n",
host_address_to_string (record_list));
if (first_record_end && execution_direction == EXEC_REVERSE)
{
/* When reverse excute, the first record_end is the part of
current instruction. */
first_record_end = 0;
}
else
{
/* In EXEC_REVERSE mode, this is the record_end of prev
instruction.
In EXEC_FORWARD mode, this is the record_end of current
instruction. */
/* step */
if (record_resume_step)
{
if (record_debug > 1)
fprintf_unfiltered (gdb_stdlog,
"Process record: step.\n");
continue_flag = 0;
}
/* check breakpoint */
tmp_pc = regcache_read_pc (regcache);
if (breakpoint_inserted_here_p (tmp_pc))
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
"Process record: break "
"at %s.\n",
paddress (gdbarch, tmp_pc));
if (gdbarch_decr_pc_after_break (gdbarch)
&& execution_direction == EXEC_FORWARD
&& !record_resume_step)
regcache_write_pc (regcache,
tmp_pc +
gdbarch_decr_pc_after_break (gdbarch));
continue_flag = 0;
}
}
}
if (continue_flag)
{
if (execution_direction == EXEC_REVERSE)
{
if (record_list->prev)
record_list = record_list->prev;
}
else
{
if (record_list->next)
record_list = record_list->next;
}
}
}
while (continue_flag);
signal (SIGINT, handle_sigint);
replay_out:
if (record_get_sig)
status->value.sig = TARGET_SIGNAL_INT;
else
status->value.sig = TARGET_SIGNAL_TRAP;
discard_cleanups (old_cleanups);
}
do_cleanups (set_cleanups);
return inferior_ptid;
}
static void
record_disconnect (struct target_ops *target, char *args, int from_tty)
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog, "Process record: record_disconnect\n");
unpush_target (&record_ops);
target_disconnect (args, from_tty);
}
static void
record_detach (struct target_ops *ops, char *args, int from_tty)
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog, "Process record: record_detach\n");
unpush_target (&record_ops);
target_detach (args, from_tty);
}
static void
record_mourn_inferior (struct target_ops *ops)
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog, "Process record: "
"record_mourn_inferior\n");
unpush_target (&record_ops);
target_mourn_inferior ();
}
/* Close process record target before killing the inferior process. */
static void
record_kill (struct target_ops *ops)
{
if (record_debug)
fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n");
unpush_target (&record_ops);
target_kill ();
}
/* Record registers change (by user or by GDB) to list as an instruction. */
static void
record_registers_change (struct regcache *regcache, int regnum)
{
/* Check record_insn_num. */
record_check_insn_num (0);
record_arch_list_head = NULL;
record_arch_list_tail = NULL;
if (regnum < 0)
{
int i;
for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
{
if (record_arch_list_add_reg (regcache, i))
{
record_list_release (record_arch_list_tail);
error (_("Process record: failed to record execution log."));
}
}
}
else
{
if (record_arch_list_add_reg (regcache, regnum))
{
record_list_release (record_arch_list_tail);
error (_("Process record: failed to record execution log."));
}
}
if (record_arch_list_add_end ())
{
record_list_release (record_arch_list_tail);
error (_("Process record: failed to record execution log."));
}
record_list->next = record_arch_list_head;
record_arch_list_head->prev = record_list;
record_list = record_arch_list_tail;
if (record_insn_num == record_insn_max_num && record_insn_max_num)
record_list_release_first ();
else
record_insn_num++;
}
static void
record_store_registers (struct target_ops *ops, struct regcache *regcache,
int regno)
{
if (!record_gdb_operation_disable)
{
if (RECORD_IS_REPLAY)
{
int n;
struct cleanup *old_cleanups;
/* Let user choose if he wants to write register or not. */
if (regno < 0)
n =
nquery (_("Because GDB is in replay mode, changing the "
"value of a register will make the execution "
"log unusable from this point onward. "
"Change all registers?"));
else
n =
nquery (_("Because GDB is in replay mode, changing the value "
"of a register will make the execution log unusable "
"from this point onward. Change register %s?"),
gdbarch_register_name (get_regcache_arch (regcache),
regno));
if (!n)
{
/* Invalidate the value of regcache that was set in function
"regcache_raw_write". */
if (regno < 0)
{
int i;
for (i = 0;
i < gdbarch_num_regs (get_regcache_arch (regcache));
i++)
regcache_invalidate (regcache, i);
}
else
regcache_invalidate (regcache, regno);
error (_("Process record canceled the operation."));
}
/* Destroy the record from here forward. */
record_list_release_next ();
}
record_registers_change (regcache, regno);
}
record_beneath_to_store_registers (record_beneath_to_store_registers_ops,
regcache, regno);
}
/* Behavior is conditional on RECORD_IS_REPLAY.
In replay mode, we cannot write memory unles we are willing to
invalidate the record/replay log from this point forward. */
static LONGEST
record_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 (!record_gdb_operation_disable
&& (object == TARGET_OBJECT_MEMORY
|| object == TARGET_OBJECT_RAW_MEMORY) && writebuf)
{
if (RECORD_IS_REPLAY)
{
/* Let user choose if he wants to write memory or not. */
if (!nquery (_("Because GDB is in replay mode, writing to memory "
"will make the execution log unusable from this "
"point onward. Write memory at address %s?"),
paddress (target_gdbarch, offset)))
error (_("Process record canceled the operation."));
/* Destroy the record from here forward. */
record_list_release_next ();
}
/* Check record_insn_num */
record_check_insn_num (0);
/* Record registers change to list as an instruction. */
record_arch_list_head = NULL;
record_arch_list_tail = NULL;
if (record_arch_list_add_mem (offset, len))
{
record_list_release (record_arch_list_tail);
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
_("Process record: failed to record "
"execution log."));
return -1;
}
if (record_arch_list_add_end ())
{
record_list_release (record_arch_list_tail);
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
_("Process record: failed to record "
"execution log."));
return -1;
}
record_list->next = record_arch_list_head;
record_arch_list_head->prev = record_list;
record_list = record_arch_list_tail;
if (record_insn_num == record_insn_max_num && record_insn_max_num)
record_list_release_first ();
else
record_insn_num++;
}
return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_ops,
object, annex, readbuf, writebuf,
offset, len);
}
/* Behavior is conditional on RECORD_IS_REPLAY.
We will not actually insert or remove breakpoints when replaying,
nor when recording. */
static int
record_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
if (!RECORD_IS_REPLAY)
{
struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
int ret = record_beneath_to_insert_breakpoint (gdbarch, bp_tgt);
do_cleanups (old_cleanups);
return ret;
}
return 0;
}
static int
record_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
if (!RECORD_IS_REPLAY)
{
struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
int ret = record_beneath_to_remove_breakpoint (gdbarch, bp_tgt);
do_cleanups (old_cleanups);
return ret;
}
return 0;
}
static int
record_can_execute_reverse (void)
{
return 1;
}
static void
init_record_ops (void)
{
record_ops.to_shortname = "record";
record_ops.to_longname = "Process record and replay target";
record_ops.to_doc =
"Log program while executing and replay execution from log.";
record_ops.to_open = record_open;
record_ops.to_close = record_close;
record_ops.to_resume = record_resume;
record_ops.to_wait = record_wait;
record_ops.to_disconnect = record_disconnect;
record_ops.to_detach = record_detach;
record_ops.to_mourn_inferior = record_mourn_inferior;
record_ops.to_kill = record_kill;
record_ops.to_create_inferior = find_default_create_inferior;
record_ops.to_store_registers = record_store_registers;
record_ops.to_xfer_partial = record_xfer_partial;
record_ops.to_insert_breakpoint = record_insert_breakpoint;
record_ops.to_remove_breakpoint = record_remove_breakpoint;
record_ops.to_can_execute_reverse = record_can_execute_reverse;
record_ops.to_stratum = record_stratum;
record_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)
{
fprintf_filtered (file, _("Debugging of process record target is %s.\n"),
value);
}
/* Alias for "target record". */
static void
cmd_record_start (char *args, int from_tty)
{
execute_command ("target record", from_tty);
}
/* Truncate the record log from the present point
of replay until the end. */
static void
cmd_record_delete (char *args, int from_tty)
{
if (current_target.to_stratum == record_stratum)
{
if (RECORD_IS_REPLAY)
{
if (!from_tty || query (_("Delete the log from this point forward "
"and begin to record the running message "
"at current PC?")))
record_list_release_next ();
}
else
printf_unfiltered (_("Already at end of record list.\n"));
}
else
printf_unfiltered (_("Process record is not started.\n"));
}
/* Implement the "stoprecord" command. */
static void
cmd_record_stop (char *args, int from_tty)
{
if (current_target.to_stratum == record_stratum)
{
if (!record_list || !from_tty || query (_("Delete recorded log and "
"stop recording?")))
unpush_target (&record_ops);
}
else
printf_unfiltered (_("Process record is not started.\n"));
}
/* Set upper limit of record log size. */
static void
set_record_insn_max_num (char *args, int from_tty, struct cmd_list_element *c)
{
if (record_insn_num > record_insn_max_num && record_insn_max_num)
{
printf_unfiltered (_("Record instructions number is bigger than "
"record instructions max number. Auto delete "
"the first ones?\n"));
while (record_insn_num > record_insn_max_num)
record_list_release_first ();
}
}
/* Print the current index into the record log (number of insns recorded
so far). */
static void
show_record_insn_number (char *ignore, int from_tty)
{
printf_unfiltered (_("Record instruction number is %d.\n"),
record_insn_num);
}
static struct cmd_list_element *record_cmdlist, *set_record_cmdlist,
*show_record_cmdlist, *info_record_cmdlist;
static void
set_record_command (char *args, int from_tty)
{
printf_unfiltered (_("\
\"set record\" must be followed by an apporpriate subcommand.\n"));
help_list (set_record_cmdlist, "set record ", all_commands, gdb_stdout);
}
static void
show_record_command (char *args, int from_tty)
{
cmd_show_list (show_record_cmdlist, from_tty, "");
}
static void
info_record_command (char *args, int from_tty)
{
cmd_show_list (info_record_cmdlist, from_tty, "");
}
void
_initialize_record (void)
{
/* Init record_first. */
record_first.prev = NULL;
record_first.next = NULL;
record_first.type = record_end;
init_record_ops ();
add_target (&record_ops);
add_setshow_zinteger_cmd ("record", no_class, &record_debug,
_("Set debugging of record/replay feature."),
_("Show debugging of record/replay feature."),
_("When enabled, debugging output for "
"record/replay feature is displayed."),
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);
add_com_alias ("rec", "record", class_obscure, 1);
add_prefix_cmd ("record", class_support, set_record_command,
_("Set record options"), &set_record_cmdlist,
"set record ", 0, &setlist);
add_alias_cmd ("rec", "record", class_obscure, 1, &setlist);
add_prefix_cmd ("record", class_support, show_record_command,
_("Show record options"), &show_record_cmdlist,
"show record ", 0, &showlist);
add_alias_cmd ("rec", "record", class_obscure, 1, &showlist);
add_prefix_cmd ("record", class_support, info_record_command,
_("Info record options"), &info_record_cmdlist,
"info record ", 0, &infolist);
add_alias_cmd ("rec", "record", class_obscure, 1, &infolist);
add_cmd ("delete", class_obscure, cmd_record_delete,
_("Delete the rest of execution log and start recording it anew."),
&record_cmdlist);
add_alias_cmd ("d", "delete", class_obscure, 1, &record_cmdlist);
add_alias_cmd ("del", "delete", class_obscure, 1, &record_cmdlist);
add_cmd ("stop", class_obscure, cmd_record_stop,
_("Stop the record/replay target."),
&record_cmdlist);
add_alias_cmd ("s", "stop", class_obscure, 1, &record_cmdlist);
/* Record instructions number limit command. */
add_setshow_boolean_cmd ("stop-at-limit", no_class,
&record_stop_at_limit, _("\
Set whether record/replay stops when record/replay buffer becomes full."), _("\
Show whether record/replay stops when record/replay buffer becomes full."), _("\
Default is ON.\n\
When ON, if the record/replay buffer becomes full, ask user what to do.\n\
When OFF, if the record/replay buffer becomes full,\n\
delete the oldest recorded instruction to make room for each new one."),
NULL, NULL,
&set_record_cmdlist, &show_record_cmdlist);
add_setshow_zinteger_cmd ("insn-number-max", no_class,
&record_insn_max_num,
_("Set record/replay buffer limit."),
_("Show record/replay buffer limit."), _("\
Set the maximum number of instructions to be stored in the\n\
record/replay buffer. Zero means unlimited. Default is 200000."),
set_record_insn_max_num,
NULL, &set_record_cmdlist, &show_record_cmdlist);
add_cmd ("insn-number", class_obscure, show_record_insn_number,
_("Show the current number of instructions in the "
"record/replay buffer."), &info_record_cmdlist);
}
Reference in New Issue View Git Blame Copy Permalink