/* Process record and replay target for GDB, the GNU debugger.
- Copyright (C) 2013-2018 Free Software Foundation, Inc.
+ Copyright (C) 2013-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include "record-full.h"
#include "elf-bfd.h"
#include "gcore.h"
-#include "event-loop.h"
+#include "gdbsupport/event-loop.h"
#include "inf-loop.h"
#include "gdb_bfd.h"
#include "observable.h"
#include "infrun.h"
-#include "common/gdb_unlinker.h"
-#include "common/byte-vector.h"
+#include "gdbsupport/gdb_unlinker.h"
+#include "gdbsupport/byte-vector.h"
+#include "async-event.h"
#include <signal.h>
mode, and we build up an execution log in which, for each executed
instruction, we record all changes in memory and register state.
This is invisible to the user, to whom it just looks like an
- ordinary debugging session (except for performance degredation).
+ ordinary debugging session (except for performance degradation).
In replay mode, instead of actually letting the inferior run as a
process, we simulate its execution by playing back the recorded
/* If true, query if PREC cannot record memory
change of next instruction. */
-int record_full_memory_query = 0;
+bool record_full_memory_query = false;
struct record_full_core_buf_entry
{
/* Record buf with core target. */
static detached_regcache *record_full_core_regbuf = NULL;
-static struct target_section *record_full_core_start;
-static struct target_section *record_full_core_end;
+static target_section_table record_full_core_sections;
static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
/* The following variables are used for managing the linked list that
record_full_list serves two functions:
1) In record mode, it anchors the end of the list.
2) In replay mode, it traverses the list and points to
- the next instruction that must be emulated.
+ the next instruction that must be emulated.
record_full_arch_list_head and record_full_arch_list_tail are used
to manage a separate list, which is used to build up the change
static struct record_full_entry *record_full_arch_list_head = NULL;
static struct record_full_entry *record_full_arch_list_tail = NULL;
-/* 1 ask user. 0 auto delete the last struct record_full_entry. */
-static int record_full_stop_at_limit = 1;
+/* true ask user. false auto delete the last struct record_full_entry. */
+static bool record_full_stop_at_limit = true;
/* Maximum allowed number of insns in execution log. */
static unsigned int record_full_insn_max_num
= DEFAULT_RECORD_FULL_INSN_MAX_NUM;
class record_full_base_target : public target_ops
{
public:
- record_full_base_target ()
- { to_stratum = record_stratum; }
-
const target_info &info () const override = 0;
+ strata stratum () const override { return record_stratum; }
+
void close () override;
void async (int) override;
- ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
bool stopped_by_watchpoint () override;
bool stopped_data_address (CORE_ADDR *) override;
const target_info &info () const override
{ return record_full_target_info; }
- void commit_resume () override;
void resume (ptid_t, int, enum gdb_signal) override;
void disconnect (const char *, int) override;
void detach (inferior *, int) override;
struct bp_target_info *,
enum remove_bp_reason) override;
- bool has_execution (ptid_t) override;
+ bool has_execution (inferior *inf) override;
};
static record_full_target record_full_ops;
int ret;
struct gdbarch *gdbarch = regcache->arch ();
- TRY
+ try
{
record_full_arch_list_head = NULL;
record_full_arch_list_tail = NULL;
if (ret < 0)
error (_("Process record: failed to record execution log."));
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
record_full_list_release (record_full_arch_list_tail);
- throw_exception (ex);
+ throw;
}
- END_CATCH
record_full_list->next = record_full_arch_list_head;
record_full_arch_list_head->prev = record_full_list;
record_full_message_wrapper_safe (struct regcache *regcache,
enum gdb_signal signal)
{
- TRY
+ try
{
record_full_message (regcache, signal);
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
return false;
}
- END_CATCH
return true;
}
{
gdb::byte_vector reg (entry->u.reg.len);
- if (record_debug > 1)
- fprintf_unfiltered (gdb_stdlog,
- "Process record: record_full_reg %s to "
- "inferior num = %d.\n",
- host_address_to_string (entry),
- entry->u.reg.num);
+ if (record_debug > 1)
+ fprintf_unfiltered (gdb_stdlog,
+ "Process record: record_full_reg %s to "
+ "inferior num = %d.\n",
+ host_address_to_string (entry),
+ entry->u.reg.num);
- regcache->cooked_read (entry->u.reg.num, reg.data ());
- regcache->cooked_write (entry->u.reg.num, record_full_get_loc (entry));
- memcpy (record_full_get_loc (entry), reg.data (), entry->u.reg.len);
+ regcache->cooked_read (entry->u.reg.num, reg.data ());
+ regcache->cooked_write (entry->u.reg.num, record_full_get_loc (entry));
+ memcpy (record_full_get_loc (entry), reg.data (), entry->u.reg.len);
}
break;
case record_full_mem: /* mem */
{
/* Nothing to do if the entry is flagged not_accessible. */
- if (!entry->u.mem.mem_entry_not_accessible)
- {
+ if (!entry->u.mem.mem_entry_not_accessible)
+ {
gdb::byte_vector mem (entry->u.mem.len);
- if (record_debug > 1)
- fprintf_unfiltered (gdb_stdlog,
- "Process record: record_full_mem %s to "
- "inferior addr = %s len = %d.\n",
- host_address_to_string (entry),
- paddress (gdbarch, entry->u.mem.addr),
- entry->u.mem.len);
+ if (record_debug > 1)
+ fprintf_unfiltered (gdb_stdlog,
+ "Process record: record_full_mem %s to "
+ "inferior addr = %s len = %d.\n",
+ host_address_to_string (entry),
+ paddress (gdbarch, entry->u.mem.addr),
+ entry->u.mem.len);
- if (record_read_memory (gdbarch,
+ if (record_read_memory (gdbarch,
entry->u.mem.addr, mem.data (),
entry->u.mem.len))
entry->u.mem.mem_entry_not_accessible = 1;
- else
- {
- if (target_write_memory (entry->u.mem.addr,
+ else
+ {
+ if (target_write_memory (entry->u.mem.addr,
record_full_get_loc (entry),
entry->u.mem.len))
- {
- entry->u.mem.mem_entry_not_accessible = 1;
- if (record_debug)
- warning (_("Process record: error writing memory at "
+ {
+ entry->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
+ paddress (gdbarch, entry->u.mem.addr),
+ entry->u.mem.len);
+ }
+ else
{
memcpy (record_full_get_loc (entry), mem.data (),
entry->u.mem.len);
entry->u.mem.addr, entry->u.mem.len))
record_full_stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
}
- }
- }
+ }
+ }
}
break;
}
static void
record_full_async_inferior_event_handler (gdb_client_data data)
{
- inferior_event_handler (INF_REG_EVENT, NULL);
+ inferior_event_handler (INF_REG_EVENT);
}
/* Open the process record target for 'core' files. */
for (i = 0; i < regnum; i ++)
record_full_core_regbuf->raw_supply (i, *regcache);
- /* Get record_full_core_start and record_full_core_end. */
- if (build_section_table (core_bfd, &record_full_core_start,
- &record_full_core_end))
- {
- delete record_full_core_regbuf;
- record_full_core_regbuf = NULL;
- error (_("\"%s\": Can't find sections: %s"),
- bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
- }
+ record_full_core_sections = build_section_table (core_bfd);
- push_target (&record_full_core_ops);
+ current_inferior ()->push_target (&record_full_core_ops);
record_full_restore ();
}
fprintf_unfiltered (gdb_stdlog, "Process record: record_full_open_1\n");
/* check exec */
- if (!target_has_execution)
+ 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 "
error (_("Process record: the current architecture doesn't support "
"record function."));
- push_target (&record_full_ops);
+ current_inferior ()->push_target (&record_full_ops);
}
static void record_full_init_record_breakpoints (void);
/* Register extra event sources in the event loop. */
record_full_async_inferior_event_token
= create_async_event_handler (record_full_async_inferior_event_handler,
- NULL);
+ NULL, "record-full");
record_full_init_record_breakpoints ();
}
/* Release record_full_core_buf_list. */
- if (record_full_core_buf_list)
+ while (record_full_core_buf_list)
{
- for (entry = record_full_core_buf_list->prev; entry;
- entry = entry->prev)
- {
- xfree (record_full_core_buf_list);
- record_full_core_buf_list = entry;
- }
- record_full_core_buf_list = NULL;
+ entry = record_full_core_buf_list;
+ record_full_core_buf_list = record_full_core_buf_list->prev;
+ xfree (entry);
}
if (record_full_async_inferior_event_token)
beneath ()->async (enable);
}
+/* The PTID and STEP arguments last passed to
+ record_full_target::resume. */
+static ptid_t record_full_resume_ptid = null_ptid;
static int record_full_resume_step = 0;
/* True if we've been resumed, and so each record_full_wait call should
void
record_full_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
{
+ record_full_resume_ptid = inferior_ptid;
record_full_resume_step = step;
record_full_resumed = 1;
record_full_execution_dir = ::execution_direction;
record_full_message (get_current_regcache (), signal);
if (!step)
- {
- /* This is not hard single step. */
- if (!gdbarch_software_single_step_p (gdbarch))
- {
- /* This is a normal continue. */
- step = 1;
- }
- else
- {
- /* This arch supports soft single step. */
- if (thread_has_single_step_breakpoints_set (inferior_thread ()))
- {
- /* This is a soft single step. */
- record_full_resume_step = 1;
- }
- else
+ {
+ /* This is not hard single step. */
+ if (!gdbarch_software_single_step_p (gdbarch))
+ {
+ /* This is a normal continue. */
+ step = 1;
+ }
+ else
+ {
+ /* This arch supports soft single step. */
+ if (thread_has_single_step_breakpoints_set (inferior_thread ()))
+ {
+ /* This is a soft single step. */
+ record_full_resume_step = 1;
+ }
+ else
step = !insert_single_step_breakpoints (gdbarch);
- }
- }
+ }
+ }
/* Make sure the target beneath reports all signals. */
- target_pass_signals (0, NULL);
+ target_pass_signals ({});
this->beneath ()->resume (ptid, step, signal);
}
target_async (1);
}
-/* "commit_resume" method for process record target. */
-
-void
-record_full_target::commit_resume ()
-{
- if (!RECORD_FULL_IS_REPLAY)
- beneath ()->commit_resume ();
-}
-
static int record_full_get_sig = 0;
/* SIGINT signal handler, registered by "wait" method. */
static ptid_t
record_full_wait_1 (struct target_ops *ops,
ptid_t ptid, struct target_waitstatus *status,
- int options)
+ target_wait_flags options)
{
scoped_restore restore_operation_disable
= record_full_gdb_operation_disable_set ();
/* This is not a single step. */
ptid_t ret;
CORE_ADDR tmp_pc;
- struct gdbarch *gdbarch = target_thread_architecture (inferior_ptid);
+ struct gdbarch *gdbarch
+ = target_thread_architecture (record_full_resume_ptid);
while (1)
{
- struct thread_info *tp;
-
ret = ops->beneath ()->wait (ptid, status, options);
if (status->kind == TARGET_WAITKIND_IGNORE)
{
return ret;
}
- ALL_NON_EXITED_THREADS (tp)
- delete_single_step_breakpoints (tp);
+ for (thread_info *tp : all_non_exited_threads ())
+ delete_single_step_breakpoints (tp);
if (record_full_resume_step)
return ret;
interested in the event. */
registers_changed ();
+ switch_to_thread (current_inferior ()->process_target (),
+ ret);
regcache = get_current_regcache ();
tmp_pc = regcache_read_pc (regcache);
const struct address_space *aspace = regcache->aspace ();
else
{
/* This is a single-step trap. Record the
- insn and issue another step.
- FIXME: this part can be a random SIGTRAP too.
- But GDB cannot handle it. */
- int step = 1;
+ insn and issue another step.
+ FIXME: this part can be a random SIGTRAP too.
+ But GDB cannot handle it. */
+ int step = 1;
if (!record_full_message_wrapper_safe (regcache,
GDB_SIGNAL_0))
- {
- status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = GDB_SIGNAL_0;
- break;
- }
+ {
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = GDB_SIGNAL_0;
+ break;
+ }
+
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
- if (gdbarch_software_single_step_p (gdbarch))
+ if (gdbarch_software_single_step_p (gdbarch))
{
/* Try to insert the software single step breakpoint.
If insert success, set step to 0. */
- set_executing (inferior_ptid, 0);
+ set_executing (proc_target, inferior_ptid, false);
reinit_frame_cache ();
step = !insert_single_step_breakpoints (gdbarch);
- set_executing (inferior_ptid, 1);
+ set_executing (proc_target, inferior_ptid, true);
}
if (record_debug)
"issuing one more step in the "
"target beneath\n");
ops->beneath ()->resume (ptid, step, GDB_SIGNAL_0);
- ops->beneath ()->commit_resume ();
+ proc_target->commit_resumed_state = true;
+ proc_target->commit_resumed ();
+ proc_target->commit_resumed_state = false;
continue;
}
}
}
else
{
+ switch_to_thread (current_inferior ()->process_target (),
+ record_full_resume_ptid);
struct regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = regcache->arch ();
const struct address_space *aspace = regcache->aspace ();
int continue_flag = 1;
int first_record_full_end = 1;
- TRY
+ try
{
CORE_ADDR tmp_pc;
if (first_record_full_end
&& execution_direction == EXEC_REVERSE)
{
- /* When reverse excute, the first
+ /* When reverse execute, the first
record_full_end is the part of current
instruction. */
first_record_full_end = 0;
else
status->value.sig = GDB_SIGNAL_TRAP;
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
if (execution_direction == EXEC_REVERSE)
{
else
record_full_list = record_full_list->prev;
- throw_exception (ex);
+ throw;
}
- END_CATCH
}
signal (SIGINT, handle_sigint);
ptid_t
record_full_base_target::wait (ptid_t ptid, struct target_waitstatus *status,
- int options)
+ target_wait_flags options)
{
ptid_t return_ptid;
+ clear_async_event_handler (record_full_async_inferior_event_token);
+
return_ptid = record_full_wait_1 (this, ptid, status, options);
if (status->kind != TARGET_WAITKIND_IGNORE)
{
if (!n)
{
/* Invalidate the value of regcache that was set in function
- "regcache_raw_write". */
+ "regcache_raw_write". */
if (regno < 0)
{
int i;
{
/* Let user choose if he wants to write memory or not. */
if (!query (_("Because GDB is in replay mode, writing to memory "
- "will make the execution log unusable from this "
- "point onward. Write memory at address %s?"),
+ "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."));
active. */
static std::vector<record_full_breakpoint> record_full_breakpoints;
-static void
-record_full_sync_record_breakpoints (struct bp_location *loc, void *data)
-{
- if (loc->loc_type != bp_loc_software_breakpoint)
- return;
-
- if (loc->inserted)
- {
- record_full_breakpoints.emplace_back
- (loc->target_info.placed_address_space,
- loc->target_info.placed_address,
- 1);
- }
-}
-
/* Sync existing breakpoints to record_full_breakpoints. */
static void
{
record_full_breakpoints.clear ();
- iterate_over_bp_locations (record_full_sync_record_breakpoints);
+ for (bp_location *loc : all_bp_locations ())
+ {
+ if (loc->loc_type != bp_loc_software_breakpoint)
+ continue;
+
+ if (loc->inserted)
+ record_full_breakpoints.emplace_back
+ (loc->target_info.placed_address_space,
+ loc->target_info.placed_address, 1);
+ }
}
/* Behavior is conditional on RECORD_FULL_IS_REPLAY. We will not actually
if (record_debug)
fprintf_unfiltered (gdb_stdlog, "Process record: record_full_core_kill\n");
- unpush_target (this);
+ current_inferior ()->unpush_target (this);
}
/* "fetch_registers" method for prec over corefile. */
{
if (record_full_gdb_operation_disable || !writebuf)
{
- struct target_section *p;
-
- for (p = record_full_core_start; p < record_full_core_end; p++)
+ for (target_section &p : record_full_core_sections)
{
- if (offset >= p->addr)
+ if (offset >= p.addr)
{
struct record_full_core_buf_entry *entry;
ULONGEST sec_offset;
- if (offset >= p->endaddr)
+ if (offset >= p.endaddr)
continue;
- if (offset + len > p->endaddr)
- len = p->endaddr - offset;
+ if (offset + len > p.endaddr)
+ len = p.endaddr - offset;
- sec_offset = offset - p->addr;
+ sec_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 (p.the_bfd_section->flags & SEC_CONSTRUCTOR
+ || (p.the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
{
if (readbuf)
memset (readbuf, 0, len);
/* Get record_full_core_buf_entry. */
for (entry = record_full_core_buf_list; entry;
entry = entry->prev)
- if (entry->p == p)
+ if (entry->p == &p)
break;
if (writebuf)
{
{
/* Add a new entry. */
entry = XNEW (struct record_full_core_buf_entry);
- entry->p = p;
+ entry->p = &p;
if (!bfd_malloc_and_get_section
- (p->the_bfd_section->owner,
- p->the_bfd_section,
+ (p.the_bfd_section->owner,
+ p.the_bfd_section,
&entry->buf))
{
xfree (entry);
/* "has_execution" method for prec over corefile. */
bool
-record_full_core_target::has_execution (ptid_t the_ptid)
+record_full_core_target::has_execution (inferior *inf)
{
return true;
}
1 byte: record type (record_full_reg, see enum record_full_type).
4 bytes: register id (network byte order).
n bytes: register value (n == actual register size).
- (eg. 4 bytes for x86 general registers).
+ (eg. 4 bytes for x86 general registers).
record_full_mem:
1 byte: record type (record_full_mem, see enum record_full_type).
4 bytes: memory length (network byte order).
osec ? "succeeded" : "failed");
if (osec == NULL)
return;
- osec_size = bfd_section_size (core_bfd, osec);
+ osec_size = bfd_section_size (osec);
if (record_debug)
- fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (core_bfd, osec));
+ fprintf_unfiltered (gdb_stdlog, "%s", bfd_section_name (osec));
/* Check the magic code. */
bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset);
record_full_arch_list_tail = NULL;
record_full_insn_num = 0;
- TRY
+ try
{
regcache = get_current_regcache ();
record_full_arch_list_add (rec);
}
}
- CATCH (ex, RETURN_MASK_ALL)
+ catch (const gdb_exception &ex)
{
record_full_list_release (record_full_arch_list_tail);
- throw_exception (ex);
+ throw;
}
- END_CATCH
/* Add record_full_arch_list_head to the end of record list. */
record_full_first.next = record_full_arch_list_head;
{
record_full_insn_max_num = record_full_insn_num;
warning (_("Auto increase record/replay buffer limit to %u."),
- record_full_insn_max_num);
+ record_full_insn_max_num);
}
/* Succeeded. */
{
/* Check for beginning and end of log. */
if (record_full_list == &record_full_first)
- break;
+ break;
record_full_exec_insn (regcache, gdbarch, record_full_list);
if (record_full_list->prev)
- record_full_list = record_full_list->prev;
+ record_full_list = record_full_list->prev;
}
/* Compute the size needed for the extra bfd section. */
/* Make the new bfd section. */
osec = bfd_make_section_anyway_with_flags (obfd.get (), "precord",
- SEC_HAS_CONTENTS
- | SEC_READONLY);
+ SEC_HAS_CONTENTS
+ | SEC_READONLY);
if (osec == NULL)
error (_("Failed to create 'precord' section for corefile %s: %s"),
recfilename,
- bfd_errmsg (bfd_get_error ()));
- bfd_set_section_size (obfd.get (), osec, save_size);
- bfd_set_section_vma (obfd.get (), osec, 0);
- bfd_set_section_alignment (obfd.get (), osec, 0);
- bfd_section_lma (obfd.get (), osec) = 0;
+ bfd_errmsg (bfd_get_error ()));
+ bfd_set_section_size (osec, save_size);
+ bfd_set_section_vma (osec, 0);
+ bfd_set_section_alignment (osec, 0);
/* Save corefile state. */
write_gcore_file (obfd.get ());
{
/* Save entry. */
if (record_full_list != &record_full_first)
- {
+ {
uint8_t type;
uint32_t regnum, len, signal, count;
- uint64_t addr;
+ uint64_t addr;
type = record_full_list->type;
- bfdcore_write (obfd.get (), osec, &type, sizeof (type), &bfd_offset);
+ bfdcore_write (obfd.get (), osec, &type, sizeof (type), &bfd_offset);
- switch (record_full_list->type)
- {
- case record_full_reg: /* reg */
+ switch (record_full_list->type)
+ {
+ case record_full_reg: /* reg */
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
" Writing register %d (1 "
(unsigned long) sizeof (regnum),
record_full_list->u.reg.len);
- /* Write regnum. */
- regnum = netorder32 (record_full_list->u.reg.num);
- bfdcore_write (obfd.get (), osec, ®num,
+ /* Write regnum. */
+ regnum = netorder32 (record_full_list->u.reg.num);
+ bfdcore_write (obfd.get (), osec, ®num,
sizeof (regnum), &bfd_offset);
- /* Write regval. */
- bfdcore_write (obfd.get (), osec,
+ /* Write regval. */
+ bfdcore_write (obfd.get (), osec,
record_full_get_loc (record_full_list),
record_full_list->u.reg.len, &bfd_offset);
- break;
+ break;
- case record_full_mem: /* mem */
+ case record_full_mem: /* mem */
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
" Writing memory %s (1 plus "
bfdcore_write (obfd.get (), osec,
record_full_get_loc (record_full_list),
record_full_list->u.mem.len, &bfd_offset);
- break;
+ break;
- case record_full_end:
+ case record_full_end:
if (record_debug)
fprintf_unfiltered (gdb_stdlog,
" Writing record_full_end (1 + "
count = netorder32 (record_full_list->u.end.insn_num);
bfdcore_write (obfd.get (), osec, &count,
sizeof (count), &bfd_offset);
- break;
- }
- }
+ break;
+ }
+ }
/* Execute entry. */
record_full_exec_insn (regcache, gdbarch, record_full_list);
if (record_full_list->next)
- record_full_list = record_full_list->next;
+ record_full_list = record_full_list->next;
else
- break;
+ break;
}
/* Reverse execute to cur_record_full_list. */
{
/* Check for beginning and end of log. */
if (record_full_list == cur_record_full_list)
- break;
+ break;
record_full_exec_insn (regcache, gdbarch, record_full_list);
if (record_full_list->prev)
- record_full_list = record_full_list->prev;
+ record_full_list = record_full_list->prev;
}
unlink_file.keep ();
/* Count down record_full_insn_num while releasing records from list. */
while (record_full_insn_num > record_full_insn_max_num)
{
- record_full_list_release_first ();
- record_full_insn_num--;
+ record_full_list_release_first ();
+ record_full_insn_num--;
}
}
}
-/* The "set record full" command. */
-
-static void
-set_record_full_command (const char *args, int from_tty)
-{
- printf_unfiltered (_("\"set record full\" must be followed "
- "by an appropriate subcommand.\n"));
- help_list (set_record_full_cmdlist, "set record full ", all_commands,
- gdb_stdout);
-}
-
-/* The "show record full" command. */
-
-static void
-show_record_full_command (const char *args, int from_tty)
-{
- cmd_show_list (show_record_full_cmdlist, from_tty, "");
-}
-
+void _initialize_record_full ();
void
-_initialize_record_full (void)
+_initialize_record_full ()
{
struct cmd_list_element *c;
add_prefix_cmd ("full", class_obscure, cmd_record_full_start,
_("Start full execution recording."), &record_full_cmdlist,
- "record full ", 0, &record_cmdlist);
+ 0, &record_cmdlist);
- c = add_cmd ("restore", class_obscure, cmd_record_full_restore,
+ cmd_list_element *record_full_restore_cmd
+ = add_cmd ("restore", class_obscure, cmd_record_full_restore,
_("Restore the execution log from a file.\n\
Argument is filename. File must be created with 'record save'."),
&record_full_cmdlist);
- set_cmd_completer (c, filename_completer);
+ set_cmd_completer (record_full_restore_cmd, filename_completer);
/* Deprecate the old version without "full" prefix. */
- c = add_alias_cmd ("restore", "full restore", class_obscure, 1,
+ c = add_alias_cmd ("restore", record_full_restore_cmd, class_obscure, 1,
&record_cmdlist);
set_cmd_completer (c, filename_completer);
deprecate_cmd (c, "record full restore");
- add_prefix_cmd ("full", class_support, set_record_full_command,
- _("Set record options"), &set_record_full_cmdlist,
- "set record full ", 0, &set_record_cmdlist);
+ add_basic_prefix_cmd ("full", class_support,
+ _("Set record options."), &set_record_full_cmdlist,
+ 0, &set_record_cmdlist);
- add_prefix_cmd ("full", class_support, show_record_full_command,
- _("Show record options"), &show_record_full_cmdlist,
- "show record full ", 0, &show_record_cmdlist);
+ add_show_prefix_cmd ("full", class_support,
+ _("Show record options."), &show_record_full_cmdlist,
+ 0, &show_record_cmdlist);
/* Record instructions number limit command. */
- add_setshow_boolean_cmd ("stop-at-limit", no_class,
- &record_full_stop_at_limit, _("\
+ set_show_commands set_record_full_stop_at_limit_cmds
+ = add_setshow_boolean_cmd ("stop-at-limit", no_class,
+ &record_full_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_full_cmdlist, &show_record_full_cmdlist);
+ NULL, NULL,
+ &set_record_full_cmdlist,
+ &show_record_full_cmdlist);
- c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
+ c = add_alias_cmd ("stop-at-limit",
+ set_record_full_stop_at_limit_cmds.set, no_class, 1,
&set_record_cmdlist);
deprecate_cmd (c, "set record full stop-at-limit");
- c = add_alias_cmd ("stop-at-limit", "full stop-at-limit", no_class, 1,
+ c = add_alias_cmd ("stop-at-limit",
+ set_record_full_stop_at_limit_cmds.show, no_class, 1,
&show_record_cmdlist);
deprecate_cmd (c, "show record full stop-at-limit");
- add_setshow_uinteger_cmd ("insn-number-max", no_class,
- &record_full_insn_max_num,
- _("Set record/replay buffer limit."),
- _("Show record/replay buffer limit."), _("\
+ set_show_commands record_full_insn_number_max_cmds
+ = add_setshow_uinteger_cmd ("insn-number-max", no_class,
+ &record_full_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. A value of either \"unlimited\" or zero means no\n\
limit. Default is 200000."),
- set_record_full_insn_max_num,
- NULL, &set_record_full_cmdlist,
- &show_record_full_cmdlist);
+ set_record_full_insn_max_num,
+ NULL, &set_record_full_cmdlist,
+ &show_record_full_cmdlist);
- c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
- &set_record_cmdlist);
+ c = add_alias_cmd ("insn-number-max", record_full_insn_number_max_cmds.set,
+ no_class, 1, &set_record_cmdlist);
deprecate_cmd (c, "set record full insn-number-max");
- c = add_alias_cmd ("insn-number-max", "full insn-number-max", no_class, 1,
- &show_record_cmdlist);
+ c = add_alias_cmd ("insn-number-max", record_full_insn_number_max_cmds.show,
+ no_class, 1, &show_record_cmdlist);
deprecate_cmd (c, "show record full insn-number-max");
- add_setshow_boolean_cmd ("memory-query", no_class,
- &record_full_memory_query, _("\
+ set_show_commands record_full_memory_query_cmds
+ = add_setshow_boolean_cmd ("memory-query", no_class,
+ &record_full_memory_query, _("\
Set whether query if PREC cannot record memory change of next instruction."),
- _("\
+ _("\
Show whether query if PREC cannot record memory change of next instruction."),
- _("\
+ _("\
Default is OFF.\n\
When ON, query if PREC cannot record memory change of next instruction."),
- NULL, NULL,
- &set_record_full_cmdlist,
- &show_record_full_cmdlist);
+ NULL, NULL,
+ &set_record_full_cmdlist,
+ &show_record_full_cmdlist);
- c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
- &set_record_cmdlist);
+ c = add_alias_cmd ("memory-query", record_full_memory_query_cmds.set,
+ no_class, 1, &set_record_cmdlist);
deprecate_cmd (c, "set record full memory-query");
- c = add_alias_cmd ("memory-query", "full memory-query", no_class, 1,
- &show_record_cmdlist);
+ c = add_alias_cmd ("memory-query", record_full_memory_query_cmds.show,
+ no_class, 1,&show_record_cmdlist);
deprecate_cmd (c, "show record full memory-query");
}
projects / deliverable / binutils-gdb.git / blobdiff