+2002-05-16 Andrew Cagney <ac131313@redhat.com>
+
+
+ * blockframe.c, regbuf.c, rs6000-tdep.c: Include "regcache.h".
+
+** REMEMBER TO FIX DEPENDENCIES
+
+ * regcache.c: Update copyright.
+
+ * regbuf.c (regbuf_descr): gdbarch_data finally takes a gdbarch
+ parameter.
+
+ * rs6000-tdep.c (rs6000_extract_return_value): Update.
+ (rs6000_extract_struct_value_address): Update.
+
+ * infrun.c (write_inferior_status_register): Update.
+ (save_inferior_status): Update.
+ (discard_inferior_status): Update.
+ (build_infrun): Update.
+
+2002-05-15 Andrew Cagney <ac131313@redhat.com>
+
+ * infcmd.c: Include "regcache.h" instead of "regbuf.h".
+
+ * infrun.c (save_inferior_status): Update.
+ (struct inferior_status): Change type of stop_registers and
+ registers to `struct regcache'.
+ (restore_inferior_status):
+
+ * regcache.h (regcache_dup): Declare.
+
+ * valops.c (hand_function_call): Update.
+
+ * gdbarch.sh (struct regcache): Declare opaque.
+ (EXTRACT_STRUCT_VALUE_ADDRESS): Ditto.
+ (EXTRACT_RETURN_VALUE): Ditto.
+ * gdbarch.h, gdbarch.c: Regenerate.
+
+ * values.c (value_being_returned): Change retbuf parameter to a
+ `struct regcache'.
+
+ * inferior.h (run_stack_dummy): Change retbuf to a `struct
+ regcache'.
+ * value.h (value_being_returned): Ditto.
+
+ * infcmd.c (run_stack_dummy): Update.
+ (run_stack_dummy): Change parameter to regcache.
+
+ * infrun.c (stop_registers): Change type to ``struct regcache''.
+ * inferior.h (stop_registers): Ditto.
+
+ * regcache.c (build_regcache): Update.
+ (regcache_restore): Ditto.
+ (regcache_save): Ditto.
+ (_initialize_regcache): Swap current_regcache instead of
+ regcache_regbuf.
+
+ * blockframe.c (generic_get_saved_register):
+
+ * regcache.h (regcache_read_as_address): Declare.
+ (regcache_xfree, regcache_xmalloc):
+
+ * blockframe.c (generic_read_register_dummy): Update.
+ (generic_push_dummy_frame): Update.
+
+ * frame.h (generic_find_dummy_frame): Change return type to
+ ``struct regcache''.
+
+ * blockframe.c (struct dummy_frame): Replace regbuf with regcache.
+ (generic_find_dummy_frame): Update.
+
+ * regcache.h (struct regbuf): Delete declaration.
+ (current_regcache): Declare.
+ (struct regcache): Declare opaque.
+ (struct regbuf): Delete.
+
+ * regcache.c (regcache_write): Add regcache parameter. Only pass
+ through to target code when backed by a real target.
+ (regcache_read): Ditto.
+ (struct regcache): define.
+ (current_regcache): New global variable.
+ (regcache_regbuf): Delete.
+
2002-05-16 Richard Earnshaw <rearnsha@arm.com>
* regbuf.c (regbuf_descr): gdbarch_data() now takes a gdbarch
demangle.c dwarfread.c dwarf2read.c elfread.c environ.c eval.c \
event-loop.c event-top.c \
expprint.c f-exp.y f-lang.c f-typeprint.c f-valprint.c \
- findvar.c regcache.c regbuf.c gdbarch.c arch-utils.c gdbtypes.c \
+ findvar.c regcache.c gdbarch.c arch-utils.c gdbtypes.c \
inf-loop.c infcmd.c inflow.c infrun.c language.c \
kod.c kod-cisco.c \
ui-out.c cli-out.c \
monitor_h = monitor.h
objfiles_h = objfiles.h
parser_defs_h = parser-defs.h $(doublest_h)
-regbuf_h = regbuf.h
regcache_h = regcache.h
remote_h = remote.h
remote_utils_h = remote-utils.h $(target_h)
gdbarch.o arch-utils.o gdbtypes.o copying.o $(DEPFILES) \
memattr.o mem-break.o target.o parse.o language.o $(YYOBJ) buildsym.o \
builtin-regs.o std-regs.o \
- signals.o regbuf.o \
+ signals.o \
kod.o kod-cisco.o \
gdb-events.o \
exec.o bcache.o objfiles.o minsyms.o maint.o demangle.o \
bcache.o: bcache.c $(bcache_h) $(defs_h)
blockframe.o: blockframe.c $(defs_h) $(gdbcore_h) $(inferior_h) \
- $(objfiles_h) $(symfile_h) $(target_h) $(regcache_h) $(regbuf_h)
+ $(objfiles_h) $(symfile_h) $(target_h) $(regcache_h)
breakpoint.o: breakpoint.c $(defs_h) $(gdbcmd_h) $(gdbcore_h) \
$(inferior_h) $(language_h) $(target_h) $(gdbthread_h) \
frame.o: frame.c $(defs_h) $(frame_h) $(target_h) $(value_h) $(inferior_h) \
$(regcache_h)
-regbuf.o: regbuf.c $(defs_h) $(regbuf_h) gdb_assert.h
-
-regcache.o: regcache.c $(defs_h) $(inferior_h) $(target_h) $(regcache_h) \
- $(regbuf_h)
+regcache.o: regcache.c $(defs_h) $(inferior_h) $(target_h) $(regcache_h)
fork-child.o: fork-child.c $(gdb_wait_h) $(defs_h) $(gdbcore_h) \
$(inferior_h) $(target_h) $(terminal_h) $(gdbthread_h) $(gdb_string_h)
infcmd.o: infcmd.c $(defs_h) environ.h $(gdbcmd_h) $(gdbcore_h) \
$(inferior_h) $(target_h) $(language_h) $(symfile_h) $(gdb_string_h) \
- $(ui_out_h) $(completer_h) $(regbuf_h)
+ $(ui_out_h) $(completer_h)
inflow.o: inflow.c $(bfd_h) $(command_h) $(defs_h) $(inferior_h) \
$(target_h) $(terminal_h) $(gdbthread_h) $(gdb_string_h)
$(gdb_stabs_h) $(regcache_h) $(arch_utils_h)
rs6000-tdep.o: rs6000-tdep.c $(defs_h) $(gdbcore_h) $(inferior_h) \
- $(target_h) ppc-tdep.h $(regcache_h) $(value_h) $(parser_defs_h) \
- $(regbuf_h)
+ $(target_h) ppc-tdep.h $(regcache_h) $(value_h) $(parser_defs_h)
s390-tdep.o: s390-tdep.c $(defs_h) $(arch_utils_h) $(frame_h) $(inferior_h) \
$(symtab_h) $(target_h) $(gdbcore_h) $(gdbcmd_h) $(symfile_h) \
#include "inferior.h" /* for read_pc */
#include "annotate.h"
#include "regcache.h"
-#include "regbuf.h"
/* Prototypes for exported functions. */
CORE_ADDR fp;
CORE_ADDR sp;
CORE_ADDR top;
- struct regbuf *regbuf;
+ struct regcache *regcache;
/* Address range of the call dummy code. Look for PC in the range
[LO..HI) (after allowing for DECR_PC_AFTER_BREAK). */
adjust for DECR_PC_AFTER_BREAK. This is because it is only legal
to call this function after the PC has been adjusted. */
-struct regbuf *
+struct regcache *
generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
{
struct dummy_frame *dummyframe;
|| fp == dummyframe->sp
|| fp == dummyframe->top))
/* The frame in question lies between the saved fp and sp, inclusive */
- return dummyframe->regbuf;
+ return dummyframe->regcache;
return 0;
}
CORE_ADDR
generic_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
{
- struct regbuf *dummy_regs = generic_find_dummy_frame (pc, fp);
+ struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp);
if (dummy_regs)
- return regbuf_read_as_address (dummy_regs, regno);
+ return regcache_read_as_address (dummy_regs, regno);
else
return 0;
}
if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */
{
dummy_frame_stack = dummy_frame->next;
- regbuf_xfree (dummy_frame->regbuf);
+ regcache_xfree (dummy_frame->regcache);
xfree (dummy_frame);
dummy_frame = dummy_frame_stack;
}
dummy_frame = dummy_frame->next;
dummy_frame = xmalloc (sizeof (struct dummy_frame));
- dummy_frame->regbuf = regbuf_xmalloc (current_gdbarch);
- regcache_save (dummy_frame->regbuf);
+ dummy_frame->regcache = regcache_xmalloc (current_gdbarch);
+ regcache_save (dummy_frame->regcache);
dummy_frame->pc = read_pc ();
dummy_frame->sp = read_sp ();
if (!dummy_frame)
error ("Can't pop dummy frame!");
dummy_frame_stack = dummy_frame->next;
- regcache_restore (dummy_frame->regbuf);
+ regcache_restore (dummy_frame->regcache);
flush_cached_frames ();
- regbuf_xfree (dummy_frame->regbuf);
+ regcache_xfree (dummy_frame->regcache);
xfree (dummy_frame);
}
if (lval) /* found it in a CALL_DUMMY frame */
*lval = not_lval;
if (raw_buffer)
- regbuf_read (generic_find_dummy_frame (frame->pc, frame->frame),
- regnum, raw_buffer);
+ regcache_read (generic_find_dummy_frame (frame->pc, frame->frame),
+ regnum, raw_buffer);
return;
}
extern int generic_pc_in_call_dummy (CORE_ADDR pc,
CORE_ADDR sp, CORE_ADDR fp);
-extern struct regbuf *generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp);
+extern struct regcache *generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp);
extern void generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
int nargs, struct value **args,
/* Macro might contain `[{}]' when not multi-arch */
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
- "EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
- XSTRING (EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
+ "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
+ XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
#ifdef EXTRACT_STRUCT_VALUE_ADDRESS
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
- "EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
- XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
+ "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
+ XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
}
void
-gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regbuf *regbuf, char *valbuf)
+gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, char *valbuf)
{
gdb_assert (gdbarch != NULL);
if (gdbarch->extract_return_value == 0)
"gdbarch: gdbarch_extract_return_value invalid");
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
- gdbarch->extract_return_value (type, regbuf, valbuf);
+ gdbarch->extract_return_value (type, regcache, valbuf);
}
void
}
CORE_ADDR
-gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regbuf *regbuf)
+gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
{
gdb_assert (gdbarch != NULL);
if (gdbarch->extract_struct_value_address == 0)
"gdbarch: gdbarch_extract_struct_value_address invalid");
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
- return gdbarch->extract_struct_value_address (regbuf);
+ return gdbarch->extract_struct_value_address (regcache);
}
void
struct value;
struct objfile;
struct minimal_symbol;
-struct regbuf;
+struct regcache;
extern struct gdbarch *current_gdbarch;
#endif
#endif
-typedef void (gdbarch_extract_return_value_ftype) (struct type *type, struct regbuf *regbuf, char *valbuf);
-extern void gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regbuf *regbuf, char *valbuf);
+typedef void (gdbarch_extract_return_value_ftype) (struct type *type, struct regcache *regcache, char *valbuf);
+extern void gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, char *valbuf);
extern void set_gdbarch_extract_return_value (struct gdbarch *gdbarch, gdbarch_extract_return_value_ftype *extract_return_value);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (EXTRACT_RETURN_VALUE)
#error "Non multi-arch definition of EXTRACT_RETURN_VALUE"
#endif
#if GDB_MULTI_ARCH
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRACT_RETURN_VALUE)
-#define EXTRACT_RETURN_VALUE(type, regbuf, valbuf) (gdbarch_extract_return_value (current_gdbarch, type, regbuf, valbuf))
+#define EXTRACT_RETURN_VALUE(type, regcache, valbuf) (gdbarch_extract_return_value (current_gdbarch, type, regcache, valbuf))
#endif
#endif
/* Default (function) for non- multi-arch platforms. */
#if (!GDB_MULTI_ARCH) && !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
-#define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (internal_error (__FILE__, __LINE__, "EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
+#define EXTRACT_STRUCT_VALUE_ADDRESS(regcache) (internal_error (__FILE__, __LINE__, "EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
#endif
-typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) (struct regbuf *regbuf);
-extern CORE_ADDR gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regbuf *regbuf);
+typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) (struct regcache *regcache);
+extern CORE_ADDR gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache);
extern void set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, gdbarch_extract_struct_value_address_ftype *extract_struct_value_address);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (EXTRACT_STRUCT_VALUE_ADDRESS)
#error "Non multi-arch definition of EXTRACT_STRUCT_VALUE_ADDRESS"
#endif
#if GDB_MULTI_ARCH
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
-#define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (gdbarch_extract_struct_value_address (current_gdbarch, regbuf))
+#define EXTRACT_STRUCT_VALUE_ADDRESS(regcache) (gdbarch_extract_struct_value_address (current_gdbarch, regcache))
#endif
#endif
F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
#
f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
-f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, struct regbuf *regbuf, char *valbuf:type, regbuf, valbuf::0:0
+f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, struct regcache *regcache, char *valbuf:type, regcache, valbuf::0:0
f:2:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr:::default_push_arguments::0
f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
F:2:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
#
f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
-F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:struct regbuf *regbuf:regbuf:::0
+F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:struct regcache *regcache:regcache:::0
f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0
#
f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
struct value;
struct objfile;
struct minimal_symbol;
-struct regbuf;
+struct regcache;
extern struct gdbarch *current_gdbarch;
#include "ui-out.h"
#include "event-top.h"
#include "parser-defs.h"
-#include "regbuf.h"
+#include "regcache.h"
/* Functions exported for general use: */
will eventually be popped when we do hit the dummy end breakpoint). */
int
-run_stack_dummy (CORE_ADDR addr, struct regbuf **buffer)
+run_stack_dummy (CORE_ADDR addr, struct regcache **buffer)
{
struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
int saved_async = 0;
return 2;
/* On normal return, the stack dummy has been popped already. */
- *buffer = regbuf_dup (stop_registers);
+ *buffer = regcache_dup (stop_registers);
return 0;
}
\f
extern void terminal_ours (void);
-extern int run_stack_dummy (CORE_ADDR, struct regbuf **retbuf);
+extern int run_stack_dummy (CORE_ADDR, struct regcache **retbuf);
extern CORE_ADDR read_pc (void);
Thus this contains the return value from the called function (assuming
values are returned in a register). */
-extern struct regbuf *stop_registers;
+extern struct regcache *stop_registers;
/* Nonzero if the child process in inferior_ptid was attached rather
than forked. */
#include "inf-loop.h"
#include "regcache.h"
#include "value.h"
-#include "regbuf.h"
/* Prototypes for local functions */
Thus this contains the return value from the called function (assuming
values are returned in a register). */
-struct regbuf *stop_registers;
+struct regcache *stop_registers;
/* Nonzero if program stopped due to error trying to insert breakpoints. */
int stop_after_trap;
int stop_soon_quietly;
CORE_ADDR selected_frame_address;
- struct regbuf *stop_registers;
+ struct regcache *stop_registers;
/* These are here because if call_function_by_hand has written some
registers and then decides to call error(), we better not have changed
any registers. */
- struct regbuf *registers;
+ struct regcache *registers;
int selected_level;
int breakpoint_proceeded;
int size = REGISTER_RAW_SIZE (regno);
void *buf = alloca (size);
store_signed_integer (buf, size, val);
- regbuf_write (inf_status->registers, regno, buf);
+ regcache_write (inf_status->registers, regno, buf);
}
/* Save all of the information associated with the inferior<==>gdb
inf_status->restore_stack_info = restore_stack_info;
inf_status->proceed_to_finish = proceed_to_finish;
- inf_status->stop_registers = regbuf_dup (stop_registers);
- inf_status->registers = regbuf_xmalloc (current_gdbarch);
+ inf_status->stop_registers = regcache_dup (stop_registers);
+ inf_status->registers = regcache_xmalloc (current_gdbarch);
regcache_save (inf_status->registers);
record_selected_frame (&(inf_status->selected_frame_address),
proceed_to_finish = inf_status->proceed_to_finish;
/* FIXME: Is the restore of stop_registers always needed? */
- regbuf_xfree (stop_registers);
+ regcache_xfree (stop_registers);
stop_registers = inf_status->stop_registers;
/* The inferior can be gone if the user types "print exit(0)"
(and perhaps other times). */
if (target_has_execution)
regcache_restore (inf_status->registers);
- regbuf_xfree (inf_status->registers);
+ regcache_xfree (inf_status->registers);
/* FIXME: If we are being called after stopping in a function which
is called from gdb, we should not be trying to restore the
{
/* See save_inferior_status for info on stop_bpstat. */
bpstat_clear (&inf_status->stop_bpstat);
- regbuf_xfree (inf_status->registers);
- regbuf_xfree (inf_status->stop_registers);
+ regcache_xfree (inf_status->registers);
+ regcache_xfree (inf_status->stop_registers);
xfree (inf_status);
}
static void
build_infrun (void)
{
- stop_registers = regbuf_xmalloc (current_gdbarch);
+ stop_registers = regcache_xmalloc (current_gdbarch);
}
void
+2002-05-16 Andrew Cagney <ac131313@redhat.com>
+
+ * mi-main.c (register_changed_p): Update.
+ (setup_architecture_data): Update
+ (_initialize_mi_main): Don't call setup_architecture_data.
+
2002-05-11 Andrew Cagney <ac131313@redhat.com>
* mi-main.c: Include "regbuf.h".
static char *last_async_command;
static char *previous_async_command;
static char *mi_error_message;
-static struct regbuf *old_regs;
+static struct regcache *old_regs;
extern void _initialize_mi_main (void);
static char *mi_input (char *);
if (! frame_register_read (selected_frame, regnum, raw_buffer))
return -1;
- regbuf_read (old_regs, regnum, old_buffer);
+ regcache_read (old_regs, regnum, old_buffer);
if (memcmp (old_buffer, raw_buffer, REGISTER_RAW_SIZE (regnum)) == 0)
return 0;
/* Found a changed register. Update the buffer and return 1. */
- regbuf_write (old_regs, regnum, raw_buffer);
+ regcache_write (old_regs, regnum, raw_buffer);
return 1;
}
static void
setup_architecture_data (void)
{
- old_regs = regbuf_xmalloc (current_gdbarch);
+ old_regs = regcache_xmalloc (current_gdbarch);
}
static void
return;
init_ui_hook = mi_init_ui;
- setup_architecture_data ();
register_gdbarch_swap (&old_regs, sizeof (old_regs), NULL);
register_gdbarch_swap (NULL, 0, setup_architecture_data);
if (event_loop_p)
/* Per-architecture object describing the layout of a register buffer.
Computed once when the architecture is created */
-struct gdbarch_data *regbuf_data_handle;
+struct gdbarch_data *regcache_data_handle;
struct regbuf_descr
{
int i;
/* FIXME: cagney/2002-05-11: gdbarch_data() should take that
``gdbarch'' as a parameter. */
- struct regbuf_descr *descr = gdbarch_data (gdbarch,
- regbuf_data_handle);
+ struct regbuf_descr *descr = gdbarch_data (gdbarch, regbuf_data_handle);
if (descr != NULL)
return descr;
/* Cache and manage the values of registers for GDB, the GNU debugger.
- Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
+ 2001, 2002 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcmd.h"
#include "regcache.h"
#include "gdb_assert.h"
-#include "regbuf.h"
/*
* DATA STRUCTURE
* Here is the actual register cache.
*/
-/* Global structure containing the current regbuf. */
+/* Per-architecture object describing the layout of a register cache.
+ Computed once when the architecture is created */
+
+struct gdbarch_data *regcache_data_handle;
+
+struct regcache_descr
+{
+ /* The architecture this descriptor belongs to. */
+ struct gdbarch *gdbarch;
+ /* Total number of registers in the buffer. */
+ int nr_registers;
+ /* Size of the register buffer, over-allocate making room for both
+ real and pseudo-registers. */
+ /* FIXME: cagney/2002-05-11: This over-allocation shouldn't be
+ necessary. Unfortunatly, some targets store real values in
+ pseudo-registers and we want to be sure those targets don't crash
+ GDB. Once that code has been trashed this can be pruned down to
+ just raw registers. */
+ long sizeof_registers;
+ /* Offset into the register buffer for each register. */
+ long *register_offset;
+ /* Size, in bytes of the register valid array. */
+ long sizeof_register_valid_p;
+ /* Size, in ``bytes'', of a register. */
+ long *sizeof_register;
+};
+
+static struct regcache_descr *
+regcache_descr (struct gdbarch *gdbarch)
+{
+ int i;
+ struct regcache_descr *descr;
+ /* FIXME: cagney/2002-05-11: gdbarch_data() should take that
+ ``gdbarch'' as a parameter. */
+ gdb_assert (gdbarch != NULL);
+
+ descr = gdbarch_data (gdbarch, regcache_data_handle);
+ if (descr != NULL)
+ return descr;
+
+ descr = XMALLOC (struct regcache_descr);
+ descr->gdbarch = gdbarch;
+
+ /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
+ in the register buffer. Unfortunatly some architectures do. */
+ descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS;
+ descr->sizeof_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
+
+ /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
+ code should compute the offets et.al. at runtime. This currently
+ isn't possible because some targets overlap register locations -
+ see the mess in read_register_bytes() and write_register_bytes()
+ registers. */
+ descr->sizeof_register = XCALLOC (descr->nr_registers, long);
+ descr->register_offset = XCALLOC (descr->nr_registers, long);
+ for (i = 0; i < descr->nr_registers; i++)
+ {
+ descr->register_offset[i] = REGISTER_BYTE (i);
+ descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
+ }
+
+ /* Come up with the real size of the registers buffer. */
+ descr->sizeof_registers = REGISTER_BYTES; /* OK use. */
+ for (i = 0; i < descr->nr_registers; i++)
+ {
+ long regend;
+ /* Keep extending the buffer so that there is always enough
+ space for all registers. The comparison is necessary since
+ legacy code is free to put registers in random places in the
+ buffer separated by holes. Once REGISTER_BYTE() is killed
+ this can be greatly simplified. */
+ /* FIXME: cagney/2001-12-04: This code shouldn't need to use
+ REGISTER_BYTE(). Unfortunatly, legacy code likes to lay the
+ buffer out so that certain registers just happen to overlap.
+ Ulgh! New targets use gdbarch's register read/write and
+ entirely avoid this uglyness. */
+ regend = descr->register_offset[i] + descr->sizeof_register[i];
+ if (descr->sizeof_registers < regend)
+ descr->sizeof_registers = regend;
+ }
+ set_gdbarch_data (gdbarch, regcache_data_handle, descr);
+ return descr;
+}
+
+static void
+xfree_regcache_descr (struct gdbarch *gdbarch, void *ptr)
+{
+ struct regcache_descr *descr = ptr;
+ if (descr == NULL)
+ return;
+ xfree (descr->register_offset);
+ xfree (descr->sizeof_register);
+ descr->register_offset = NULL;
+ descr->sizeof_register = NULL;
+ xfree (descr);
+}
+
+/* For moment, ``struct regcache'' is just a character buffer. */
+
+struct regcache
+{
+ struct regcache_descr *descr;
+ char *registers;
+ char *register_valid_p;
+ /* If a value isn't in the cache should the corresponding target be
+ queried for a value. */
+ int passthrough_p;
+};
+
+struct regcache *
+regcache_xmalloc (struct gdbarch *gdbarch)
+{
+ struct regcache_descr *descr;
+ struct regcache *regcache;
+ gdb_assert (gdbarch != NULL);
+ descr = regcache_descr (gdbarch);
+ regcache = XMALLOC (struct regcache);
+ regcache->descr = descr;
+ regcache->registers = XCALLOC (descr->sizeof_registers, char);
+ regcache->register_valid_p = XCALLOC (descr->sizeof_register_valid_p, char);
+ regcache->passthrough_p = 0;
+ return regcache;
+}
+
+void
+regcache_xfree (struct regcache *regcache)
+{
+ if (regcache == NULL)
+ return;
+ xfree (regcache->registers);
+ xfree (regcache->register_valid_p);
+ xfree (regcache);
+}
+
+void
+do_regcache_xfree (void *buf)
+{
+ regcache_xfree (buf);
+}
+
+struct regcache *
+regcache_xmalloc_with_cleanup (struct gdbarch *gdbarch)
+{
+ struct regcache *regcache = regcache_xmalloc (gdbarch);
+ make_cleanup (do_regcache_xfree, regcache);
+ return regcache;
+}
+
+struct regcache *
+regcache_dup (struct regcache *regcache)
+{
+ struct regcache *newbuf;
+ gdb_assert (current_regcache != NULL);
+ newbuf = regcache_xmalloc (regcache->descr->gdbarch);
+ memcpy (newbuf->registers, regcache->registers,
+ regcache->descr->sizeof_registers);
+ memcpy (newbuf->register_valid_p, regcache->register_valid_p,
+ regcache->descr->sizeof_register_valid_p);
+ return newbuf;
+}
+
+int
+regcache_valid_p (struct regcache *regcache, int regnum)
+{
+ gdb_assert (regcache != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
+ return regcache->register_valid_p[regnum];
+}
+
+CORE_ADDR
+regcache_read_as_address (struct regcache *regcache, int regnum)
+{
+ char *buf;
+ gdb_assert (regcache != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
+ buf = alloca (regcache->descr->sizeof_register[regnum]);
+ regcache_read (regcache, regnum, buf);
+ return extract_address (buf, regcache->descr->sizeof_register[regnum]);
+}
+
+char *
+grub_around_regcache_for_registers (struct regcache *regcache)
+{
+ return regcache->registers;
+}
+
+char *
+grub_around_regcache_for_register_valid (struct regcache *regcache)
+{
+ return regcache->register_valid_p;
+}
+
+/* Global structure containing the current regcache. */
/* FIXME: cagney/2002-05-11: The two global arrays registers[] and
register_valid[] currently point into this structure. */
-
-struct regbuf *regcache_regbuf;
+struct regcache *current_regcache;
/* NOTE: this is a write-through cache. There is no "dirty" bit for
recording if the register values have been changed (eg. by the
}
void
-regcache_read (int rawnum, char *buf)
+regcache_read (struct regcache *regcache, int regnum, char *buf)
{
- gdb_assert (rawnum >= 0 && rawnum < (NUM_REGS + NUM_PSEUDO_REGS));
- /* For moment, just use underlying legacy code. Ulgh!!! */
- legacy_read_register_gen (rawnum, buf);
+ gdb_assert (regcache != NULL && buf != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
+ if (regcache->passthrough_p)
+ /* For moment, just use underlying legacy code. Ulgh!!! This
+ silently and very indirectly updates the regcache's regcache via
+ the global register_valid[]. */
+ legacy_read_register_gen (regnum, buf);
+ else
+ {
+ memcpy (buf, (regcache->registers
+ + regcache->descr->register_offset[regnum]),
+ regcache->descr->sizeof_register[regnum]);
+ }
}
void
}
void
-regcache_write (int rawnum, char *buf)
+regcache_write (struct regcache *regcache, int regnum, char *buf)
{
- gdb_assert (rawnum >= 0 && rawnum < (NUM_REGS + NUM_PSEUDO_REGS));
- /* For moment, just use underlying legacy code. Ulgh!!! */
- legacy_write_register_gen (rawnum, buf);
+ gdb_assert (regcache != NULL && buf != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
+ if (regcache->passthrough_p)
+ /* For moment, just use underlying legacy code. Ulgh!!! This
+ silently and very indirectly updates the regcache's regcache via
+ the global register_valid[]. */
+ legacy_write_register_gen (regnum, buf);
+ else
+ {
+ memcpy (regcache->registers + regcache->descr->register_offset[regnum], buf,
+ regcache->descr->sizeof_register[regnum]);
+ regcache->register_valid_p[regnum] = 1;
+ }
}
void
static void
build_regcache (void)
{
- regcache_regbuf = regbuf_xmalloc (current_gdbarch);
- registers = grub_around_regbuf_for_registers (regcache_regbuf);
- register_valid = grub_around_regbuf_for_register_valid (regcache_regbuf);
+ current_regcache = regcache_xmalloc (current_gdbarch);
+ current_regcache->passthrough_p = 1;
+ registers = grub_around_regcache_for_registers (current_regcache);
+ register_valid = grub_around_regcache_for_register_valid (current_regcache);
}
void
-regcache_save (struct regbuf *regbuf)
+regcache_save (struct regcache *regcache)
{
- /* FIXME: cagney/2002-05-11: This assumes that the current
- architecture and the regbuf architecture are identical. */
- char *regbuf_registers = grub_around_regbuf_for_registers (regbuf);
- char *regbuf_register_valid = grub_around_regbuf_for_register_valid (regbuf);
- memcpy (regbuf_registers, registers, REGISTER_BYTES);
- memcpy (regbuf_register_valid, register_valid, NUM_REGS + NUM_PSEUDO_REGS);
+ gdb_assert (current_regcache != NULL && regcache != NULL);
+ gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
+ memcpy (grub_around_regcache_for_registers (regcache),
+ grub_around_regcache_for_registers (current_regcache),
+ regcache->descr->sizeof_registers);
+ memcpy (grub_around_regcache_for_register_valid (regcache),
+ grub_around_regcache_for_register_valid (current_regcache),
+ regcache->descr->sizeof_register_valid_p);
}
void
-regcache_restore (struct regbuf *regbuf)
+regcache_restore (struct regcache *regcache)
{
- char *regbuf_registers = grub_around_regbuf_for_registers (regbuf);
- write_register_bytes (0, regbuf_registers, REGISTER_BYTES);
+ char *regcache_registers;
+ gdb_assert (current_regcache != NULL && regcache != NULL);
+ gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
+ regcache_registers = grub_around_regcache_for_registers (regcache);
+ /* NOTE: cagney, this should be regcache->sizeof_registers but,
+ again, things are screwed as it might copy pseudo registers. */
+ write_register_bytes (0, regcache_registers, REGISTER_BYTES);
}
void
-regcache_restore_no_writethrough (struct regbuf *regbuf)
+regcache_restore_no_writethrough (struct regcache *regcache)
{
- char *regbuf_registers = grub_around_regbuf_for_registers (regbuf);
- memcpy (registers, regbuf_registers, REGISTER_BYTES);
+ char *regcache_registers;
+ gdb_assert (current_regcache != NULL && regcache != NULL);
+ gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
+ regcache_registers = grub_around_regcache_for_registers (regcache);
+ memcpy (registers, regcache_registers, REGISTER_BYTES);
}
void
_initialize_regcache (void)
{
- REGISTER_GDBARCH_SWAP (regcache_regbuf);
+ regcache_data_handle = register_gdbarch_data (NULL, xfree_regcache_descr);
+ REGISTER_GDBARCH_SWAP (current_regcache);
register_gdbarch_swap (®isters, sizeof (registers), NULL);
register_gdbarch_swap (®ister_valid, sizeof (register_valid), NULL);
register_gdbarch_swap (NULL, 0, build_regcache);
/* Cache and manage the values of registers for GDB, the GNU debugger.
- Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
+ 2001, 2002 Free Software Foundation, Inc.
This file is part of GDB.
#ifndef REGCACHE_H
#define REGCACHE_H
-struct regbuf;
+struct regcache;
+
+extern struct regcache *current_regcache;
+
+void regcache_xfree (struct regcache *regcache);
+struct regcache *regcache_xmalloc (struct gdbarch *gdbarch);
/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
regcache. */
-void regcache_read (int rawnum, char *buf);
-void regcache_write (int rawnum, char *buf);
+void regcache_read (struct regcache *regcache, int rawnum, char *buf);
+void regcache_write (struct regcache *regcache, int rawnum, char *buf);
+int regcache_valid_p (struct regcache *regcache, int regnum);
+CORE_ADDR regcache_read_as_address (struct regcache *regcache, int rawnum);
/* Transfer a raw register [0..NUM_REGS) between the regcache and the
target. These functions are called by the target in response to a
write through - it is strictly for code that needs to restore the
target's registers to a previous state. */
-extern void regcache_save (struct regbuf *regbuf);
-extern void regcache_restore (struct regbuf *regbufx);
-extern void regcache_restore_no_writethrough (struct regbuf *regbufx);
+extern void regcache_save (struct regcache *regcache);
+extern void regcache_restore (struct regcache *regcache);
+extern void regcache_restore_no_writethrough (struct regcache *regcache);
+extern struct regcache *regcache_dup (struct regcache *regcache);
+
+extern char *grub_around_regcache_for_registers (struct regcache *);
+extern char *grub_around_regcache_for_register_valid (struct regcache *);
extern int register_cached (int regnum);
#include "solib-svr4.h"
#include "ppc-tdep.h"
-#include "regbuf.h" /* For grub_around_regbuf_for_registers. */
+#include "regcache.h" /* For grub_around_regcache_for_registers. */
/* If the kernel has to deliver a signal, it pushes a sigcontext
structure on the stack and then calls the signal handler, passing
REGBUF, and copy that return value into VALBUF in virtual format. */
static void
-rs6000_extract_return_value (struct type *valtype, struct regbuf *regs,
+rs6000_extract_return_value (struct type *valtype, struct regcache *regs,
char *valbuf)
{
int offset = 0;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- char *regbuf = grub_around_regbuf_for_registers (regs);
+ char *regbuf = grub_around_regcache_for_registers (regs);
if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
{
as a CORE_ADDR (or an expression that can be used as one). */
static CORE_ADDR
-rs6000_extract_struct_value_address (struct regbuf *regs)
+rs6000_extract_struct_value_address (struct regcache *regs)
{
/* FIXME: cagney/2002-05-11: This global variable is just a hack! */
return rs6000_struct_return_address;
SAVE_DUMMY_FRAME_TOS (sp);
{
- struct regbuf *retbuf = NULL;
+ struct regcache *retbuf = NULL;
char *name;
struct symbol *symbol;
#if !defined (VALUE_H)
#define VALUE_H 1
-struct regbuf;
+struct regcache;
#include "doublest.h"
extern struct value *value_subscript (struct value *array, struct value *idx);
extern struct value *value_being_returned (struct type *valtype,
- struct regbuf *retbuf,
+ struct regcache *regcache,
int struct_return);
extern struct value *value_in (struct value *element, struct value *set);
/* ARGSUSED */
struct value *
-value_being_returned (struct type *valtype, struct regbuf *retbuf,
+value_being_returned (struct type *valtype, struct regcache *retbuf,
int struct_return)
{
struct value *val;
projects / thirdparty / binutils-gdb.git / commitdiff
