209 static struct regcache *
214 struct regcache *regcache;
218 regcache = XNEW (
struct regcache);
249 if (regcache == NULL)
360 void *cooked_read_context)
379 status = cooked_read (cooked_read_context, regnum, buf);
389 struct regcache *regcache = src;
395 struct regcache *src);
438 struct regcache *newbuf;
489 struct regcache *new_regcache;
491 for (list = current_regcache; list; list = list->
next)
502 current_regcache = list;
531 if (!current_thread_arch || !
ptid_equal (current_thread_ptid, ptid))
533 current_thread_ptid =
ptid;
569 for (list = current_regcache; list; list = list->
next)
598 *list_link = list->
next;
605 list_link = &list->
next;
612 current_thread_arch = NULL;
640 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
677 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
697 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
715 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
729 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
740 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
741 if (regnum < regcache->descr->nr_raw_registers)
787 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
789 if (regnum < regcache->descr->nr_raw_registers
794 struct value *result;
824 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
844 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
863 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
877 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
888 struct cleanup *chain_before_save_inferior;
889 struct cleanup *chain_before_invalidate_register;
892 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
917 chain_before_invalidate_register
934 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
935 if (regnum < regcache->descr->nr_raw_registers)
952 int offset,
int len,
void *in,
const void *out,
956 void (*write) (
struct regcache *regcache,
int regnum,
965 if (offset + len == 0)
975 status =
read (regcache, regnum, reg);
981 memcpy (in, reg + offset, len);
983 memcpy (reg + offset, out, len);
988 write (regcache, regnum, reg);
1007 int offset,
int len,
const gdb_byte *buf)
1018 int offset,
int len,
gdb_byte *buf)
1029 int offset,
int len,
const gdb_byte *buf)
1047 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1055 memcpy (regbuf, buf, size);
1063 memset (regbuf, 0, size);
1076 gdb_assert (regcache != NULL && buf != NULL);
1077 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1081 memcpy (buf, regbuf, size);
1090 const struct regcache *regcache,
1091 struct regcache *out_regcache,
1092 int regnum,
const void *in_buf,
1093 void *out_buf,
size_t size)
1096 int offs = 0,
count;
1101 int slot_size = map->
size;
1108 && (regnum < regno || regnum >= regno +
count)))
1109 offs +=
count * slot_size;
1111 else if (regnum == -1)
1112 for (;
count--; regno++, offs += slot_size)
1114 if (offs + slot_size > size)
1128 offs += (regnum -
regno) * slot_size;
1129 if (offs + slot_size > size)
1150 struct regcache *regcache,
1151 int regnum,
const void *buf,
size_t size)
1163 const struct regcache *regcache,
1164 int regnum,
void *buf,
size_t size)
1196 _(
"regcache_read_pc: Unable to find PC"));
1212 _(
"regcache_write_pc: Unable to update PC"));
1243 int footnote_nr = 0;
1244 int footnote_register_size = 0;
1245 int footnote_register_offset = 0;
1246 int footnote_register_type_name_null = 0;
1247 long register_offset = 0;
1280 else if (p[0] ==
'\0')
1314 if (!footnote_register_offset)
1315 footnote_register_offset = ++footnote_nr;
1339 static const char blt[] =
"builtin_type";
1346 if (!footnote_register_type_name_null)
1347 footnote_register_type_name_null = ++footnote_nr;
1348 n =
xstrprintf (
"*%d", footnote_register_type_name_null);
1410 const char *sep =
"";
1434 else if (regnum < regcache->descr->nr_raw_registers)
1447 if (footnote_register_size)
1449 footnote_register_size);
1450 if (footnote_register_offset)
1452 footnote_register_offset);
1453 if (footnote_register_type_name_null)
1455 "*%d: Register type's name NULL.\n",
1456 footnote_register_type_name_null);
1513 regcache_descr_handle
1520 _(
"Force gdb to flush its register cache (maintainer command)"));
1523 _(
"Print the internal register configuration.\n"
1527 _(
"Print the internal register configuration "
1528 "including raw values.\n"
1532 _(
"Print the internal register configuration "
1533 "including cooked values.\n"
1537 _(
"Print the internal register configuration "
1538 "including each register's group.\n"
1539 "Takes an optional file parameter."),
1543 Print the internal register configuration including each register's\n\
1544 remote register number and buffer offset in the g/G packets.\n\
1545 Takes an optional file parameter."),
static struct regcache_list * current_regcache
ssize_t read(int fd, void *buf, size_t count)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
struct value * value_mark(void)
int gdbarch_pseudo_register_read_value_p(struct gdbarch *gdbarch)
static void regcache_observer_target_changed(struct target_ops *target)
static struct regcache_descr * regcache_descr(struct gdbarch *gdbarch)
void value_free_to_mark(struct value *mark)
long sizeof_raw_register_status
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
void gdbarch_write_pc(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR val)
long sizeof_raw_registers
struct regcache * get_thread_regcache(ptid_t ptid)
static void maintenance_print_registers(char *args, int from_tty)
long sizeof_cooked_register_status
static void maintenance_print_remote_registers(char *args, int from_tty)
#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE)
void store_signed_integer(gdb_byte *, int, enum bfd_endian, LONGEST)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
static struct cleanup * make_cleanup_regcache_invalidate(struct regcache *regcache, int regnum)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
static void regcache_cpy_no_passthrough(struct regcache *dst, struct regcache *src)
struct type ** register_type
#define TYPE_NAME(thistype)
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
struct ui_file * gdb_stdout
struct ui_file * gdb_fopen(const char *name, const char *mode)
int ptid_match(ptid_t ptid, ptid_t filter)
void internal_error(const char *file, int line, const char *fmt,...)
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
struct address_space * target_thread_address_space(ptid_t ptid)
struct regcache * regcache_xmalloc(struct gdbarch *gdbarch, struct address_space *aspace)
void regcache_cooked_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
void mark_value_bytes_unavailable(struct value *value, int offset, int length)
int gdbarch_write_pc_p(struct gdbarch *gdbarch)
struct reggroup *const restore_reggroup
int gdbarch_num_regs(struct gdbarch *gdbarch)
void target_fetch_registers(struct regcache *regcache, int regno)
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
struct value * allocate_value(struct type *type)
struct regcache * get_current_regcache(void)
signed char * register_status
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
void printf_filtered(const char *format,...)
#define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE)
struct regcache * regcache_dup(struct regcache *src)
void regcache_raw_write_signed(struct regcache *regcache, int regnum, LONGEST val)
int gdbarch_read_pc_p(struct gdbarch *gdbarch)
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
void null_cleanup(void *arg)
struct observer * observer_attach_target_changed(observer_target_changed_ftype *f)
struct cleanup * save_inferior_ptid(void)
CORE_ADDR gdbarch_read_pc(struct gdbarch *gdbarch, struct regcache *regcache)
enum register_status regcache_raw_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
#define target_prepare_to_store(regcache)
struct cleanup * make_cleanup_dtor(make_cleanup_ftype *function, void *arg, make_cleanup_dtor_ftype *dtor)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
void initialize_file_ftype(void)
static void * init_regcache_descr(struct gdbarch *gdbarch)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
int gdbarch_cannot_store_register(struct gdbarch *gdbarch, int regnum)
long sizeof_cooked_registers
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 regcache_transfer_regset(const struct regset *regset, const struct regcache *regcache, struct regcache *out_regcache, int regnum, const void *in_buf, void *out_buf, size_t size)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
#define VALUE_REGNUM(val)
static void maintenance_print_raw_registers(char *args, int from_tty)
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
static void do_regcache_xfree(void *data)
void regcache_cpy(struct regcache *dst, struct regcache *src)
static struct regcache * regcache_xmalloc_1(struct gdbarch *gdbarch, struct address_space *aspace, int readonly_p)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
static void reg_flush_command(char *command, int from_tty)
static int startswith(const char *string, const char *pattern)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
char * xstrprintf(const char *format,...)
static enum register_status do_cooked_read(void *src, int regnum, gdb_byte *buf)
struct value * gdbarch_pseudo_register_read_value(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum)
struct observer * observer_attach_thread_ptid_changed(observer_thread_ptid_changed_ftype *f)
struct cmd_list_element * maintenanceprintlist
struct type * gdbarch_register_type(struct gdbarch *gdbarch, int reg_nr)
void regcache_invalidate(struct regcache *regcache, int regnum)
struct regcache_descr * descr
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
int value_entirely_available(struct value *value)
void discard_cleanups(struct cleanup *old_chain)
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
int gdbarch_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
struct value * regcache_cooked_read_value(struct regcache *regcache, int regnum)
enum register_status regcache_register_status(const struct regcache *regcache, int regnum)
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
enum register_status gdbarch_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, gdb_byte *buf)
void registers_changed_ptid(ptid_t ptid)
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void regcache_save(struct regcache *dst, regcache_cooked_read_ftype *cooked_read, void *src)
static void regcache_dump(struct regcache *regcache, struct ui_file *file, enum regcache_dump_what what_to_dump)
initialize_file_ftype _initialize_regcache
void registers_changed(void)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct regcache_list * next
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
struct regcache * get_thread_arch_aspace_regcache(ptid_t ptid, struct gdbarch *gdbarch, struct address_space *aspace)
struct address_space * aspace
struct cleanup * make_cleanup_regcache_xfree(struct regcache *regcache)
enum register_status() regcache_cooked_read_ftype(void *src, int regnum, gdb_byte *buf)
struct address_space * get_regcache_aspace(const struct regcache *regcache)
static struct gdbarch * current_thread_arch
static void do_regcache_invalidate(void *data)
void regcache_xfree(struct regcache *regcache)
void gdbarch_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
unsigned long long ULONGEST
void target_store_registers(struct regcache *regcache, int regno)
static gdb_byte * register_buffer(const struct regcache *regcache, int regnum)
int register_size(struct gdbarch *gdbarch, int regnum)
struct type * value_type(const struct value *value)
enum register_status regcache_cooked_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
struct value::@177::@178 computed
int remote_register_number_and_offset(struct gdbarch *gdbarch, int regnum, int *pnum, int *poffset)
static void regcache_thread_ptid_changed(ptid_t old_ptid, ptid_t new_ptid)
static void maintenance_print_cooked_registers(char *args, int from_tty)
gdb_byte * value_contents_raw(struct value *value)
struct reggroup * reggroup_next(struct gdbarch *gdbarch, struct reggroup *last)
struct reggroup *const save_reggroup
static void maintenance_print_register_groups(char *args, int from_tty)
#define TYPE_LENGTH(thistype)
void( regcache_read_ftype)(struct regcache *regcache, int regnum, void *buf)
static ptid_t current_thread_ptid
void reinit_frame_cache(void)
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
struct regcache * get_thread_regcache_for_ptid(ptid_t ptid)
#define target_thread_architecture(ptid)
struct regcache * regcache
static void regcache_print(char *args, enum regcache_dump_what what_to_dump)
struct gdbarch_data * gdbarch_data_register_post_init(gdbarch_data_post_init_ftype *post_init)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
enum register_status regcache_cooked_read_signed(struct regcache *regcache, int regnum, LONGEST *val)
static enum register_status regcache_xfer_part(struct regcache *regcache, int regnum, int offset, int len, void *in, const void *out, enum register_status(*read)(struct regcache *regcache, int regnum, gdb_byte *buf), void(*write)(struct regcache *regcache, int regnum, const gdb_byte *buf))
void throw_error(enum errors error, const char *fmt,...)
const char * reggroup_name(struct reggroup *group)
void do_cleanups(struct cleanup *old_chain)
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
void( regcache_write_ftype)(struct regcache *regcache, int regnum, const void *buf)
struct regcache * get_thread_arch_regcache(ptid_t ptid, struct gdbarch *gdbarch)
struct regcache * regcache
void print_hex_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
static void regcache_restore(struct regcache *dst, regcache_cooked_read_ftype *cooked_read, void *cooked_read_context)
struct gdbarch_data * regcache_descr_handle
enum register_status regcache_raw_read_signed(struct regcache *regcache, int regnum, LONGEST *val)