61 #define DEFAULT_RECORD_FULL_INSN_MAX_NUM 200000
63 #define RECORD_FULL_IS_REPLAY \
64 (record_full_list->next || execution_direction == EXEC_REVERSE)
66 #define RECORD_FULL_FILE_MAGIC netorder32(0x20091016)
234 const char *recfilename);
425 "Process record: record_full_arch_list_add %s.\n",
428 if (record_full_arch_list_tail)
430 record_full_arch_list_tail->
next = rec;
432 record_full_arch_list_tail = rec;
436 record_full_arch_list_head = rec;
437 record_full_arch_list_tail = rec;
472 "Process record: add register num = %d to "
495 "Process record: add mem addr = %s len = %d to "
526 "Process record: add end to arch list.\n");
549 q =
yquery (
_(
"Do you want to auto delete previous execution "
550 "log entries when record/replay buffer becomes "
551 "full (record full stop-at-limit)?"));
557 error (
_(
"Process record: stopped by user."));
582 record_full_arch_list_head = NULL;
583 record_full_arch_list_tail = NULL;
617 if (signal == GDB_SIGNAL_0
628 error (
_(
"Process record: inferior program stopped."));
630 error (
_(
"Process record: failed to record execution log."));
657 record_full_args->
signal);
681 struct cleanup *old_cleanups = NULL;
711 "Process record: record_full_reg %s to "
712 "inferior num = %d.\n",
732 "Process record: record_full_mem %s to "
733 "inferior addr = %s len = %d.\n",
749 warning (
_(
"Process record: error writing memory at "
750 "addr = %s len = %d."),
804 for (i = 0; i <
regnum; i ++)
810 &record_full_core_end))
814 error (
_(
"\"%s\": Can't find sections: %s"),
815 bfd_get_filename (
core_bfd), bfd_errmsg (bfd_get_error ()));
832 error (
_(
"Process record: the program is not being run."));
834 error (
_(
"Process record target can't debug inferior in non-stop mode "
838 error (
_(
"Process record: the current architecture doesn't support "
839 "record function."));
862 record_full_list->
next = NULL;
870 record_full_async_inferior_event_token
899 if (record_full_core_buf_list)
901 for (entry = record_full_core_buf_list->
prev; entry;
904 xfree (record_full_core_buf_list);
905 record_full_core_buf_list = entry;
907 record_full_core_buf_list = NULL;
910 if (record_full_async_inferior_event_token)
954 enum gdb_signal signal)
1032 if (record_full_list->
next)
1033 record_full_list = record_full_list->
next;
1036 record_full_list = record_full_list->
prev;
1061 "Process record: record_full_wait "
1062 "record_full_resume_step = %d, "
1063 "record_full_resumed = %d, direction=%s\n",
1066 ?
"forward" :
"reverse");
1105 "Process record: record_full_wait "
1106 "target beneath not done yet\n");
1118 && status->
value.
sig == GDB_SIGNAL_TRAP)
1174 "Process record: record_full_wait "
1175 "issuing one more step in the "
1176 "target beneath\n");
1195 int continue_flag = 1;
1196 int first_record_full_end = 1;
1213 "Process record: break at %s.\n",
1228 record_full_list = record_full_list->
next;
1255 "Process record: record_full_end %s to "
1263 first_record_full_end = 0;
1276 "Process record: step.\n");
1287 "Process record: break "
1298 "Process record: hit hw "
1303 if (record_full_list->
u.
end.
sigval != GDB_SIGNAL_0)
1313 if (record_full_list->
prev)
1314 record_full_list = record_full_list->
prev;
1318 if (record_full_list->
next)
1319 record_full_list = record_full_list->
next;
1323 while (continue_flag);
1327 status->
value.
sig = GDB_SIGNAL_INT;
1328 else if (record_full_list->
u.
end.
sigval != GDB_SIGNAL_0)
1332 status->
value.
sig = GDB_SIGNAL_TRAP;
1421 record_full_arch_list_head = NULL;
1422 record_full_arch_list_tail = NULL;
1433 error (
_(
"Process record: failed to record execution log."));
1442 error (
_(
"Process record: failed to record execution log."));
1448 error (
_(
"Process record: failed to record execution log."));
1476 query (
_(
"Because GDB is in replay mode, changing the "
1477 "value of a register will make the execution "
1478 "log unusable from this point onward. "
1479 "Change all registers?"));
1482 query (
_(
"Because GDB is in replay mode, changing the value "
1483 "of a register will make the execution log unusable "
1484 "from this point onward. Change register %s?"),
1504 error (
_(
"Process record canceled the operation."));
1523 const char *annex,
gdb_byte *readbuf,
1534 if (!
query (
_(
"Because GDB is in replay mode, writing to memory "
1535 "will make the execution log unusable from this "
1536 "point onward. Write memory at address %s?"),
1538 error (
_(
"Process record canceled the operation."));
1548 record_full_arch_list_head = NULL;
1549 record_full_arch_list_tail = NULL;
1555 "Process record: failed to record "
1564 "Process record: failed to record "
1579 readbuf, writebuf, offset,
1607 VEC(record_full_breakpoint_p) *record_full_breakpoints = NULL;
1610 record_full_sync_record_breakpoints (
struct bp_location *loc,
void *data)
1624 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1633 VEC_free (record_full_breakpoint_p, record_full_breakpoints);
1667 in_target_beneath = 1;
1674 VEC_safe_push (record_full_breakpoint_p, record_full_breakpoints, bp);
1690 record_full_breakpoints, ix, bp);
1711 record_full_breakpoints, ix);
1743 "record_full_get_bookmark returns %s\n", ret);
1746 "record_full_get_bookmark returns NULL\n");
1755 const gdb_byte *raw_bookmark,
int from_tty)
1757 const char *
bookmark = (
const char *) raw_bookmark;
1762 "record_full_goto_bookmark receives %s\n", bookmark);
1764 if (bookmark[0] ==
'\'' || bookmark[0] ==
'\"')
1768 if (bookmark[strlen (bookmark) - 1] != bookmark[0])
1769 error (
_(
"Unbalanced quotes: %s"), bookmark);
1772 copy =
savestring (bookmark + 1, strlen (bookmark) - 2);
1854 error (
_(
"Target insn not found."));
1855 else if (p == record_full_list)
1856 error (
_(
"Already at target insn."));
1897 for (p = record_full_list; p->
next != NULL; p = p->
next)
1899 for (; p!= NULL; p = p->
prev)
1926 "Log program while executing and replay execution from log.";
1970 enum gdb_signal signal)
2005 for (i = 0; i < num; i ++)
2033 error (
_(
"You can't do that without a process to debug."));
2041 const char *annex,
gdb_byte *readbuf,
2053 if (offset >= p->
addr)
2061 if (offset + len > p->
endaddr)
2064 sec_offset = offset - p->
addr;
2072 memset (readbuf, 0, len);
2078 for (entry = record_full_core_buf_list; entry;
2079 entry = entry->
prev)
2091 if (!bfd_malloc_and_get_section
2100 record_full_core_buf_list = entry;
2103 memcpy (entry->
buf + sec_offset, writebuf,
2115 memcpy (readbuf, entry->
buf + sec_offset,
2127 error (
_(
"You can't do that without a process to debug."));
2131 readbuf, writebuf, offset, len,
2169 "Log program while executing and replay execution from log.";
2261 int ret = bfd_get_section_contents (obfd, osec, buf, *offset, len);
2266 error (
_(
"Failed to read %d bytes from core file %s ('%s')."),
2267 len, bfd_get_filename (obfd),
2268 bfd_errmsg (bfd_get_error ()));
2271 static inline uint64_t
2277 BFD_ENDIAN_BIG, input);
2281 static inline uint32_t
2287 BFD_ENDIAN_BIG, input);
2291 static inline uint16_t
2297 BFD_ENDIAN_BIG, input);
2325 osec = bfd_get_section_by_name (
core_bfd,
"null0");
2328 osec ?
"succeeded" :
"failed");
2331 osec_size = bfd_section_size (
core_bfd, osec);
2338 error (
_(
"Version mis-match or file format error in core file %s."),
2342 " Reading 4-byte magic cookie "
2343 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2348 record_full_arch_list_head = NULL;
2349 record_full_arch_list_tail = NULL;
2361 if (bfd_offset >= osec_size)
2370 sizeof (regnum), &bfd_offset);
2381 " Reading register %d (1 "
2382 "plus %lu plus %d bytes)\n",
2384 (
unsigned long) sizeof (regnum),
2391 sizeof (len), &bfd_offset);
2396 sizeof (addr), &bfd_offset);
2407 " Reading memory %s (1 plus "
2408 "%lu plus %lu plus %d bytes)\n",
2411 (
unsigned long) sizeof (addr),
2412 (
unsigned long)
sizeof (len),
2422 sizeof (signal), &bfd_offset);
2428 sizeof (count), &bfd_offset);
2434 " Reading record_full_end (1 + "
2435 "%lu + %lu bytes), offset == %s\n",
2436 (
unsigned long)
sizeof (signal),
2437 (
unsigned long)
sizeof (count),
2443 error (
_(
"Bad entry type in core file %s."),
2457 record_full_arch_list_tail->
next = NULL;
2464 warning (
_(
"Auto increase record/replay buffer limit to %u."),
2480 int ret = bfd_set_section_contents (obfd, osec, buf, *offset, len);
2485 error (
_(
"Failed to write %d bytes to core file %s ('%s')."),
2486 len, bfd_get_filename (obfd),
2487 bfd_errmsg (bfd_get_error ()));
2504 char *pathname = xstrdup (bfd_get_filename (obfd));
2525 asection *osec = NULL;
2556 if (record_full_list->
prev)
2557 record_full_list = record_full_list->
prev;
2563 record_full_list = record_full_list->
next)
2564 switch (record_full_list->
type)
2567 save_size += 1 + 4 + 4;
2570 save_size += 1 + 4 + record_full_list->
u.
reg.
len;
2573 save_size += 1 + 4 + 8 + record_full_list->
u.
mem.
len;
2578 osec = bfd_make_section_anyway_with_flags (obfd,
"precord",
2582 error (
_(
"Failed to create 'precord' section for corefile %s: %s"),
2584 bfd_errmsg (bfd_get_error ()));
2585 bfd_set_section_size (obfd, osec, save_size);
2586 bfd_set_section_vma (obfd, osec, 0);
2587 bfd_set_section_alignment (obfd, osec, 0);
2588 bfd_section_lma (obfd, osec) = 0;
2598 " Writing 4-byte magic cookie "
2599 "RECORD_FULL_FILE_MAGIC (0x%s)\n",
2601 bfdcore_write (obfd, osec, &magic,
sizeof (magic), &bfd_offset);
2615 type = record_full_list->
type;
2616 bfdcore_write (obfd, osec, &type,
sizeof (type), &bfd_offset);
2618 switch (record_full_list->
type)
2623 " Writing register %d (1 "
2624 "plus %lu plus %d bytes)\n",
2626 (
unsigned long) sizeof (regnum),
2632 sizeof (regnum), &bfd_offset);
2637 record_full_list->
u.
reg.
len, &bfd_offset);
2643 " Writing memory %s (1 plus "
2644 "%lu plus %lu plus %d bytes)\n",
2647 (
unsigned long) sizeof (addr),
2648 (
unsigned long)
sizeof (len),
2653 bfdcore_write (obfd, osec, &len,
sizeof (len), &bfd_offset);
2658 sizeof (addr), &bfd_offset);
2663 record_full_list->
u.
mem.
len, &bfd_offset);
2669 " Writing record_full_end (1 + "
2670 "%lu + %lu bytes)\n",
2671 (
unsigned long)
sizeof (signal),
2672 (
unsigned long)
sizeof (count));
2676 sizeof (signal), &bfd_offset);
2681 sizeof (count), &bfd_offset);
2689 if (record_full_list->
next)
2690 record_full_list = record_full_list->
next;
2699 if (record_full_list == cur_record_full_list)
2704 if (record_full_list->
prev)
2705 record_full_list = record_full_list->
prev;
2733 record_full_list = record_full_list->
next;
2739 record_full_list = record_full_list->
prev;
2741 record_full_list = record_full_list->
next;
2742 }
while (record_full_list != entry);
2775 "by an apporpriate subcommand.\n"));
2808 _(
"Start full execution recording."), &record_full_cmdlist,
2812 _(
"Restore the execution log from a file.\n\
2813 Argument is filename. File must be created with 'record save'."),
2814 &record_full_cmdlist);
2824 _(
"Set record options"), &set_record_full_cmdlist,
2828 _(
"Show record options"), &show_record_full_cmdlist,
2834 Set whether record/replay stops when record/replay buffer becomes full."),
_(
"\
2835 Show whether record/replay stops when record/replay buffer becomes full."),
2836 _(
"Default is ON.\n\
2837 When ON, if the record/replay buffer becomes full, ask user what to do.\n\
2838 When OFF, if the record/replay buffer becomes full,\n\
2839 delete the oldest recorded instruction to make room for each new one."),
2841 &set_record_full_cmdlist, &show_record_full_cmdlist);
2853 _(
"Set record/replay buffer limit."),
2854 _(
"Show record/replay buffer limit."),
_(
"\
2855 Set the maximum number of instructions to be stored in the\n\
2856 record/replay buffer. A value of either \"unlimited\" or zero means no\n\
2857 limit. Default is 200000."),
2859 NULL, &set_record_full_cmdlist,
2860 &show_record_full_cmdlist);
2872 Set whether query if PREC cannot record memory change of next instruction."),
2874 Show whether query if PREC cannot record memory change of next instruction."),
2877 When ON, query if PREC cannot record memory change of next instruction."),
2879 &set_record_full_cmdlist,
2880 &show_record_full_cmdlist);
struct gdbarch * target_gdbarch(void)
#define target_can_async_p()
int gdbarch_software_single_step_p(struct gdbarch *gdbarch)
void add_target(struct target_ops *t)
struct cmd_list_element * show_record_cmdlist
void target_terminal_ours(void)
static struct record_full_core_buf_entry * record_full_core_buf_list
static enum exec_direction_kind record_full_execution_direction(struct target_ops *self)
static struct cmd_list_element * set_record_full_cmdlist
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
void(* to_delete_record)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
static struct record_full_entry * record_full_arch_list_head
int(* to_supports_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
static void record_full_core_store_registers(struct target_ops *ops, struct regcache *regcache, int regno)
static int record_full_core_has_execution(struct target_ops *ops, ptid_t the_ptid)
struct frame_info * get_selected_frame(const char *message)
void(* to_goto_bookmark)(struct target_ops *, const gdb_byte *, int) TARGET_DEFAULT_NORETURN(tcomplain())
void(* to_goto_record_begin)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
static void record_full_goto_end(struct target_ops *self)
static void record_full_arch_list_cleanups(void *ignore)
void(* to_save_record)(struct target_ops *, const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
int gdbarch_process_record_signal(struct gdbarch *gdbarch, struct regcache *regcache, enum gdb_signal signal)
struct frame_info * get_current_frame(void)
static ptid_t record_full_wait_1(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
static void record_full_open(const char *name, int from_tty)
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
gdb_byte buf[sizeof(gdb_byte *)]
struct address_space * address_space
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
static void record_full_restore(void)
struct target_section * p
void record_goto(const char *arg)
static int record_full_message(struct regcache *regcache, enum gdb_signal signal)
void warning(const char *fmt,...)
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
int query(const char *ctlstr,...)
int gdbarch_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
struct cmd_list_element * set_record_cmdlist
int mem_entry_not_accessible
static uint64_t netorder64(uint64_t input)
void push_target(struct target_ops *t)
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
static void record_full_exec_insn(struct regcache *regcache, struct gdbarch *gdbarch, struct record_full_entry *entry)
int build_section_table(struct bfd *some_bfd, struct target_section **start, struct target_section **end)
void record_preopen(void)
struct ui_file * gdb_stdout
static struct target_ops record_full_core_ops
void record_disconnect(struct target_ops *t, const char *args, int from_tty)
int unpush_target(struct target_ops *t)
struct thread_info * inferior_thread(void)
void delete_async_event_handler(async_event_handler **async_handler_ptr)
unsigned int record_debug
void target_pass_signals(int numsigs, unsigned char *pass_signals)
#define VEC_unordered_remove(T, V, I)
void(* to_close)(struct target_ops *)
void mark_async_event_handler(async_event_handler *async_handler_ptr)
#define DEFAULT_RECORD_FULL_INSN_MAX_NUM
static void init_record_full_ops(void)
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
struct record_full_reg_entry reg
int yquery(const char *ctlstr,...)
static int record_full_supports_stopped_by_sw_breakpoint(struct target_ops *ops)
#define VEC_safe_push(T, V, O)
static void record_full_sig_handler(int signo)
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
int gdbarch_software_single_step(struct gdbarch *gdbarch, struct frame_info *frame)
static int record_full_can_execute_reverse(struct target_ops *self)
static int record_full_stopped_by_sw_breakpoint(struct target_ops *ops)
int gdbarch_num_regs(struct gdbarch *gdbarch)
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_NORETURN(noprocess())
void target_fetch_registers(struct regcache *regcache, int regno)
void(* to_info_record)(struct target_ops *) TARGET_DEFAULT_IGNORE()
static void record_full_list_release_first(void)
void core_file_command(char *filename, int from_tty)
static void record_full_goto_entry(struct record_full_entry *p)
void execute_command(char *, int)
DEF_VEC_P(record_full_breakpoint_p)
static unsigned int record_full_insn_num
static int record_full_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
#define target_stopped_by_watchpoint()
int record_full_is_used(void)
static int record_full_message_wrapper_safe(struct regcache *regcache, enum gdb_signal signal)
struct regcache * get_current_regcache(void)
static void cmd_record_full_restore(char *args, int from_tty)
gdb_byte buf[2 *sizeof(gdb_byte *)]
static int record_full_is_replaying(struct target_ops *self)
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
void printf_filtered(const char *format,...)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
static void record_full_reg_release(struct record_full_entry *rec)
static unsigned int record_full_insn_max_num
static void record_full_mem_release(struct record_full_entry *rec)
void null_cleanup(void *arg)
static enum target_xfer_status record_full_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
static void cmd_record_full_start(char *args, int from_tty)
#define VEC_iterate(T, V, I, P)
static int record_full_resume_step
static void record_full_end_release(struct record_full_entry *rec)
static struct record_full_entry * record_full_arch_list_tail
struct cleanup * make_cleanup_restore_integer(int *variable)
int hardware_watchpoint_inserted_in_range(struct address_space *aspace, CORE_ADDR addr, ULONGEST len)
void inferior_event_handler(enum inferior_event_type event_type, gdb_client_data client_data)
static struct cmd_list_element * show_record_full_cmdlist
void gdb_bfd_unref(struct bfd *abfd)
void initialize_file_ftype(void)
static void record_full_open_1(const char *name, int from_tty)
int record_read_memory(struct gdbarch *gdbarch, CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static void record_full_arch_list_add(struct record_full_entry *rec)
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
void add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct record_full_end_entry end
void target_terminal_inferior(void)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
struct record_full_mem_entry mem
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
int(* to_supports_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
static void record_full_async(struct target_ops *ops, int enable)
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
VEC(record_full_breakpoint_p)
#define gdb_assert_not_reached(message)
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
static void record_full_list_release(struct record_full_entry *rec)
async_event_handler * create_async_event_handler(async_event_handler_func *proc, gdb_client_data client_data)
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
static void record_full_store_registers(struct target_ops *ops, struct regcache *regcache, int regno)
union target_waitstatus::@161 value
char * pulongest(ULONGEST u)
int(* to_has_execution)(struct target_ops *, ptid_t)
void iterate_over_bp_locations(walk_bp_location_callback callback)
struct target_ops * find_record_target(void)
static enum record_full_type record_full_entry_release(struct record_full_entry *rec)
static ptid_t record_full_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
struct gdbarch * get_current_arch(void)
void observer_notify_record_changed(struct inferior *inferior, int started)
void record_detach(struct target_ops *t, const char *args, int from_tty)
static void record_full_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal)
void write_gcore_file(bfd *obfd)
struct record_full_breakpoint * record_full_breakpoint_p
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
static void record_full_info(struct target_ops *self)
struct record_full_core_buf_entry * prev
struct cmd_list_element * add_alias_cmd(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
int gdbarch_process_record_signal_p(struct gdbarch *gdbarch)
#define target_has_execution
enum record_full_type type
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
static struct record_full_entry record_full_first
static void record_full_wait_cleanups(void *ignore)
void printf_unfiltered(const char *format,...)
static gdb_byte * record_full_core_regbuf
static void record_full_core_fetch_registers(struct target_ops *ops, struct regcache *regcache, int regno)
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
static uint16_t netorder16(uint16_t input)
static void record_full_core_open_1(const char *name, int from_tty)
struct record_full_entry * next
void(* to_async)(struct target_ops *, int) TARGET_DEFAULT_NORETURN(tcomplain())
#define RECORD_FULL_FILE_MAGIC
struct bfd_section * the_bfd_section
static enum exec_direction_kind record_full_execution_dir
static struct target_section * record_full_core_start
struct ui_file * gdb_stdlog
static int record_full_stopped_by_hw_breakpoint(struct target_ops *ops)
int record_full_memory_query
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
void record_mourn_inferior(struct target_ops *t)
int record_full_arch_list_add_mem(CORE_ADDR addr, int len)
void(* to_disconnect)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
static enum target_xfer_status record_full_core_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
void regcache_invalidate(struct regcache *regcache, int regnum)
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
static int record_full_core_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
void record_kill(struct target_ops *t)
struct cmd_list_element * record_cmdlist
static int record_full_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
enum exec_direction_kind(* to_execution_direction)(struct target_ops *) TARGET_DEFAULT_FUNC(default_execution_direction)
static int record_full_gdb_operation_disable
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
void discard_cleanups(struct cleanup *old_chain)
static enum target_stop_reason record_full_stop_reason
static struct target_section * record_full_core_end
static void record_full_goto_bookmark(struct target_ops *self, const gdb_byte *raw_bookmark, int from_tty)
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
enum bp_loc_type loc_type
char * phex_nz(ULONGEST l, int sizeof_l)
#define ALL_NON_EXITED_THREADS(T)
static struct target_ops record_full_ops
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
enum target_waitkind kind
static void record_full_core_kill(struct target_ops *ops)
static struct cmd_list_element * record_full_cmdlist
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
CORE_ADDR regcache_read_pc(struct regcache *regcache)
static void set_record_full_insn_max_num(char *args, int from_tty, struct cmd_list_element *c)
gdb_byte *(* to_get_bookmark)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
static gdb_byte * record_full_get_bookmark(struct target_ops *self, const char *args, int from_tty)
int(* to_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
static void record_full_delete(struct target_ops *self)
const char * host_address_to_string(const void *addr)
static void record_full_list_release_following(struct record_full_entry *rec)
void(* to_goto_record_end)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
static struct record_full_entry * record_full_mem_alloc(CORE_ADDR addr, int len)
void(* to_open)(const char *, int)
void registers_changed(void)
static ULONGEST record_full_insn_count
static gdb_byte * record_full_get_loc(struct record_full_entry *rec)
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
struct record_full_entry * prev
int(* to_stopped_by_watchpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
struct address_space * get_regcache_aspace(const struct regcache *regcache)
static void bfdcore_write(bfd *obfd, asection *osec, void *buf, int len, int *offset)
int gdbarch_process_record_p(struct gdbarch *gdbarch)
static void record_full_goto_begin(struct target_ops *self)
static struct record_full_entry * record_full_reg_alloc(struct regcache *regcache, int regnum)
static int record_full_resumed
int(* to_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
bfd * create_gcore_bfd(const char *filename)
struct inferior * current_inferior(void)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
const char * to_shortname
union record_full_reg_entry::@134 u
void delete_single_step_breakpoints(struct thread_info *tp)
unsigned long long ULONGEST
static int record_full_supports_stopped_by_hw_breakpoint(struct target_ops *ops)
union record_full_entry::@135 u
static void record_full_goto_insn(struct record_full_entry *entry, enum exec_direction_kind dir)
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
char * savestring(const char *ptr, size_t len)
int register_size(struct gdbarch *gdbarch, int regnum)
void clear_async_event_handler(async_event_handler *async_handler_ptr)
static struct record_full_entry * record_full_end_alloc(void)
struct cleanup * record_full_gdb_operation_disable_set(void)
static void init_record_full_core_ops(void)
int(* to_record_is_replaying)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
#define RECORD_FULL_IS_REPLAY
void handle_sigint(int sig)
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
struct bp_target_info target_info
static void record_full_close(struct target_ops *self)
static struct async_event_handler * record_full_async_inferior_event_token
static int record_full_get_sig
void reinit_frame_cache(void)
static void record_full_core_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal)
int(* to_stopped_data_address)(struct target_ops *, CORE_ADDR *) TARGET_DEFAULT_RETURN(0)
struct address_space * placed_address_space
int record_check_stopped_by_breakpoint(struct address_space *aspace, CORE_ADDR pc, enum target_stop_reason *reason)
static int record_full_stopped_data_address(struct target_ops *ops, CORE_ADDR *addr_p)
static void record_full_goto(struct target_ops *self, ULONGEST target_insn)
static void bfdcore_read(bfd *obfd, asection *osec, void *buf, int len, int *offset)
static void record_full_core_prepare_to_store(struct target_ops *self, struct regcache *regcache)
#define target_async(ENABLE)
void(* to_prepare_to_store)(struct target_ops *, struct regcache *) TARGET_DEFAULT_NORETURN(noprocess())
union record_full_mem_entry::@133 u
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
#define target_thread_architecture(ptid)
PTR xcalloc(size_t number, size_t size)
static int record_full_stopped_by_watchpoint(struct target_ops *ops)
struct regcache * regcache
static void record_full_async_inferior_event_handler(gdb_client_data data)
static uint32_t netorder32(uint32_t input)
int record_full_arch_list_add_end(void)
static void show_record_full_command(char *args, int from_tty)
static int record_full_message_wrapper(void *args)
void set_executing(ptid_t ptid, int executing)
static void record_full_check_insn_num(int set_terminal)
void error(const char *fmt,...)
static int record_full_core_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
initialize_file_ftype _initialize_record_full
static void record_full_registers_change(struct regcache *regcache, int regnum)
struct target_ops * beneath
int(* to_can_execute_reverse)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
void do_cleanups(struct cleanup *old_chain)
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
static int record_full_stop_at_limit
static void record_full_save_cleanups(void *data)
static void record_full_init_record_breakpoints(void)
static struct record_full_entry * record_full_list
void(* to_goto_record)(struct target_ops *, ULONGEST insn) TARGET_DEFAULT_NORETURN(tcomplain())
const ULONGEST const LONGEST len
static void record_full_save(struct target_ops *self, const char *recfilename)
static void set_record_full_command(char *args, int from_tty)
void add_deprecated_target_alias(struct target_ops *t, char *alias)