This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[PATCH]: Make the register cache a separate module.
- To: gdb-patches at sourceware dot cygnus dot com
- Subject: [PATCH]: Make the register cache a separate module.
- From: Michael Snyder <msnyder at cygnus dot com>
- Date: Sun, 9 Jul 2000 23:16:23 -0700 (PDT)
This patch moves the register cache out of findvar.c and into a new
module called regcache.c.
2000-07-07 Michael Snyder <msnyder@cleaver.cygnus.com>
* findvar.c (_initialize_findvar, build_findvar, write_fp, read_fp,
generic_target_write_fp, generic_target_read_fp, write_sp, read_sp,
generic_target_write_sp, generic_target_read_sp, write_pc, read_pc,
generic_target_write_pc, generic_target_read_pc, write_pc_pid,
read_pc_pid, supply_register, write_register_pid, write_register,
read_register_pid, read_register, write_register_bytes,
read_register_bytes, write_register_gen, read_register_gen,
registers_fetched, registers_changed, find_saved_register,
read_relative_register_raw_bytes, default_get_saved_register,
read_relative_register_raw_bytes_for_frame, get_saved_register):
Move from this file into new file regcache.c.
(register_valid, registers_pid, registers): Ditto.
* regcache.c: New file to hold the register cache.
(register_cached): New function to read register_valid array.
* value.h (register_cached): Declare.
* defs.h (default_get_saved_register): Delete decl of static function.
* Makefile.in: Add regcache module.
Index: defs.h
===================================================================
RCS file: /cvs/src/src/gdb/defs.h,v
retrieving revision 1.26
diff -p -r1.26 defs.h
*** defs.h 2000/06/19 10:14:22 1.26
--- defs.h 2000/07/10 06:15:03
*************** enum lval_type
*** 587,597 ****
struct frame_info;
- void default_get_saved_register (char *raw_buffer, int *optimized,
- CORE_ADDR * addrp,
- struct frame_info *frame, int regnum,
- enum lval_type *lval);
-
/* From readline (but not in any readline .h files). */
extern char *tilde_expand (char *);
--- 587,592 ----
Index: value.h
===================================================================
RCS file: /cvs/src/src/gdb/value.h,v
retrieving revision 1.5
diff -p -r1.5 value.h
*** value.h 2000/05/28 01:12:33 1.5
--- value.h 2000/07/10 06:15:03
*************** extern void write_register_pid (int regn
*** 471,476 ****
--- 471,478 ----
extern void supply_register (int regno, char *val);
+ extern int register_cached (int regno);
+
extern void get_saved_register (char *raw_buffer, int *optimized,
CORE_ADDR * addrp,
struct frame_info *frame,
Index: findvar.c
===================================================================
RCS file: /cvs/src/src/gdb/findvar.c,v
retrieving revision 1.13
diff -p -r1.13 findvar.c
*** findvar.c 2000/06/04 13:46:37 1.13
--- findvar.c 2000/07/10 06:15:03
***************
*** 37,54 ****
const struct floatformat floatformat_unknown;
- /* Registers we shouldn't try to store. */
- #if !defined (CANNOT_STORE_REGISTER)
- #define CANNOT_STORE_REGISTER(regno) 0
- #endif
-
- void write_register_gen (int, char *);
-
- static int
- read_relative_register_raw_bytes_for_frame (int regnum,
- char *myaddr,
- struct frame_info *frame);
-
/* Basic byte-swapping routines. GDB has needed these for a long time...
All extract a target-format integer at ADDR which is LEN bytes long. */
--- 37,42 ----
*************** store_floating (void *addr, int len, DOU
*** 391,591 ****
error ("Can't deal with a floating point number of %d bytes.", len);
}
}
-
-
- /* Return the address in which frame FRAME's value of register REGNUM
- has been saved in memory. Or return zero if it has not been saved.
- If REGNUM specifies the SP, the value we return is actually
- the SP value, not an address where it was saved. */
-
- CORE_ADDR
- find_saved_register (frame, regnum)
- struct frame_info *frame;
- int regnum;
- {
- register struct frame_info *frame1 = NULL;
- register CORE_ADDR addr = 0;
-
- if (frame == NULL) /* No regs saved if want current frame */
- return 0;
-
- #ifdef HAVE_REGISTER_WINDOWS
- /* We assume that a register in a register window will only be saved
- in one place (since the name changes and/or disappears as you go
- towards inner frames), so we only call get_frame_saved_regs on
- the current frame. This is directly in contradiction to the
- usage below, which assumes that registers used in a frame must be
- saved in a lower (more interior) frame. This change is a result
- of working on a register window machine; get_frame_saved_regs
- always returns the registers saved within a frame, within the
- context (register namespace) of that frame. */
-
- /* However, note that we don't want this to return anything if
- nothing is saved (if there's a frame inside of this one). Also,
- callers to this routine asking for the stack pointer want the
- stack pointer saved for *this* frame; this is returned from the
- next frame. */
-
- if (REGISTER_IN_WINDOW_P (regnum))
- {
- frame1 = get_next_frame (frame);
- if (!frame1)
- return 0; /* Registers of this frame are active. */
-
- /* Get the SP from the next frame in; it will be this
- current frame. */
- if (regnum != SP_REGNUM)
- frame1 = frame;
-
- FRAME_INIT_SAVED_REGS (frame1);
- return frame1->saved_regs[regnum]; /* ... which might be zero */
- }
- #endif /* HAVE_REGISTER_WINDOWS */
-
- /* Note that this next routine assumes that registers used in
- frame x will be saved only in the frame that x calls and
- frames interior to it. This is not true on the sparc, but the
- above macro takes care of it, so we should be all right. */
- while (1)
- {
- QUIT;
- frame1 = get_prev_frame (frame1);
- if (frame1 == 0 || frame1 == frame)
- break;
- FRAME_INIT_SAVED_REGS (frame1);
- if (frame1->saved_regs[regnum])
- addr = frame1->saved_regs[regnum];
- }
-
- return addr;
- }
-
- /* Find register number REGNUM relative to FRAME and put its (raw,
- target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
- variable was optimized out (and thus can't be fetched). Set *LVAL
- to lval_memory, lval_register, or not_lval, depending on whether
- the value was fetched from memory, from a register, or in a strange
- and non-modifiable way (e.g. a frame pointer which was calculated
- rather than fetched). Set *ADDRP to the address, either in memory
- on as a REGISTER_BYTE offset into the registers array.
-
- Note that this implementation never sets *LVAL to not_lval. But
- it can be replaced by defining GET_SAVED_REGISTER and supplying
- your own.
- The argument RAW_BUFFER must point to aligned memory. */
-
- void
- default_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
- char *raw_buffer;
- int *optimized;
- CORE_ADDR *addrp;
- struct frame_info *frame;
- int regnum;
- enum lval_type *lval;
- {
- CORE_ADDR addr;
-
- if (!target_has_registers)
- error ("No registers.");
-
- /* Normal systems don't optimize out things with register numbers. */
- if (optimized != NULL)
- *optimized = 0;
- addr = find_saved_register (frame, regnum);
- if (addr != 0)
- {
- if (lval != NULL)
- *lval = lval_memory;
- if (regnum == SP_REGNUM)
- {
- if (raw_buffer != NULL)
- {
- /* Put it back in target format. */
- store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
- (LONGEST) addr);
- }
- if (addrp != NULL)
- *addrp = 0;
- return;
- }
- if (raw_buffer != NULL)
- read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
- }
- else
- {
- if (lval != NULL)
- *lval = lval_register;
- addr = REGISTER_BYTE (regnum);
- if (raw_buffer != NULL)
- read_register_gen (regnum, raw_buffer);
- }
- if (addrp != NULL)
- *addrp = addr;
- }
-
- #if !defined (GET_SAVED_REGISTER)
- #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
- default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
- #endif
- void
- get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
- char *raw_buffer;
- int *optimized;
- CORE_ADDR *addrp;
- struct frame_info *frame;
- int regnum;
- enum lval_type *lval;
- {
- GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
- }
-
- /* Copy the bytes of register REGNUM, relative to the input stack frame,
- into our memory at MYADDR, in target byte order.
- The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
-
- Returns 1 if could not be read, 0 if could. */
-
- static int
- read_relative_register_raw_bytes_for_frame (regnum, myaddr, frame)
- int regnum;
- char *myaddr;
- struct frame_info *frame;
- {
- int optim;
- if (regnum == FP_REGNUM && frame)
- {
- /* Put it back in target format. */
- store_address (myaddr, REGISTER_RAW_SIZE (FP_REGNUM),
- (LONGEST) FRAME_FP (frame));
-
- return 0;
- }
-
- get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
- regnum, (enum lval_type *) NULL);
-
- if (register_valid[regnum] < 0)
- return 1; /* register value not available */
-
- return optim;
- }
-
- /* Copy the bytes of register REGNUM, relative to the current stack frame,
- into our memory at MYADDR, in target byte order.
- The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
-
- Returns 1 if could not be read, 0 if could. */
-
- int
- read_relative_register_raw_bytes (regnum, myaddr)
- int regnum;
- char *myaddr;
- {
- return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
- selected_frame);
- }
-
/* Return a `value' with the contents of register REGNUM
in its virtual format, with the type specified by
REGISTER_VIRTUAL_TYPE.
--- 379,385 ----
*************** value_of_register (regnum)
*** 606,612 ****
get_saved_register (raw_buffer, &optim, &addr,
selected_frame, regnum, &lval);
! if (register_valid[regnum] < 0)
return NULL; /* register value not available */
reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
--- 400,406 ----
get_saved_register (raw_buffer, &optim, &addr,
selected_frame, regnum, &lval);
! if (register_cached (regnum) < 0)
return NULL; /* register value not available */
reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
*************** value_of_register (regnum)
*** 633,1212 ****
VALUE_OPTIMIZED_OUT (reg_val) = optim;
return reg_val;
}
-
- /* Low level examining and depositing of registers.
-
- The caller is responsible for making
- sure that the inferior is stopped before calling the fetching routines,
- or it will get garbage. (a change from GDB version 3, in which
- the caller got the value from the last stop). */
-
- /* Contents and state of the registers (in target byte order). */
-
- char *registers;
-
- /* VALID_REGISTER is non-zero if it has been fetched, -1 if the
- register value was not available. */
-
- signed char *register_valid;
-
- /* The thread/process associated with the current set of registers. For now,
- -1 is special, and means `no current process'. */
- int registers_pid = -1;
-
- /* Indicate that registers may have changed, so invalidate the cache. */
-
- void
- registers_changed ()
- {
- int i;
- int numregs = ARCH_NUM_REGS;
-
- registers_pid = -1;
-
- /* Force cleanup of any alloca areas if using C alloca instead of
- a builtin alloca. This particular call is used to clean up
- areas allocated by low level target code which may build up
- during lengthy interactions between gdb and the target before
- gdb gives control to the user (ie watchpoints). */
- alloca (0);
-
- for (i = 0; i < numregs; i++)
- register_valid[i] = 0;
-
- if (registers_changed_hook)
- registers_changed_hook ();
- }
-
- /* Indicate that all registers have been fetched, so mark them all valid. */
- void
- registers_fetched ()
- {
- int i;
- int numregs = ARCH_NUM_REGS;
- for (i = 0; i < numregs; i++)
- register_valid[i] = 1;
- }
-
- /* read_register_bytes and write_register_bytes are generally a *BAD*
- idea. They are inefficient because they need to check for partial
- updates, which can only be done by scanning through all of the
- registers and seeing if the bytes that are being read/written fall
- inside of an invalid register. [The main reason this is necessary
- is that register sizes can vary, so a simple index won't suffice.]
- It is far better to call read_register_gen and write_register_gen
- if you want to get at the raw register contents, as it only takes a
- regno as an argument, and therefore can't do a partial register
- update.
-
- Prior to the recent fixes to check for partial updates, both read
- and write_register_bytes always checked to see if any registers
- were stale, and then called target_fetch_registers (-1) to update
- the whole set. This caused really slowed things down for remote
- targets. */
-
- /* Copy INLEN bytes of consecutive data from registers
- starting with the INREGBYTE'th byte of register data
- into memory at MYADDR. */
-
- void
- read_register_bytes (inregbyte, myaddr, inlen)
- int inregbyte;
- char *myaddr;
- int inlen;
- {
- int inregend = inregbyte + inlen;
- int regno;
-
- if (registers_pid != inferior_pid)
- {
- registers_changed ();
- registers_pid = inferior_pid;
- }
-
- /* See if we are trying to read bytes from out-of-date registers. If so,
- update just those registers. */
-
- for (regno = 0; regno < NUM_REGS; regno++)
- {
- int regstart, regend;
-
- if (register_valid[regno])
- continue;
-
- if (REGISTER_NAME (regno) == NULL || *REGISTER_NAME (regno) == '\0')
- continue;
-
- regstart = REGISTER_BYTE (regno);
- regend = regstart + REGISTER_RAW_SIZE (regno);
-
- if (regend <= inregbyte || inregend <= regstart)
- /* The range the user wants to read doesn't overlap with regno. */
- continue;
-
- /* We've found an invalid register where at least one byte will be read.
- Update it from the target. */
- target_fetch_registers (regno);
-
- if (!register_valid[regno])
- error ("read_register_bytes: Couldn't update register %d.", regno);
- }
-
- if (myaddr != NULL)
- memcpy (myaddr, ®isters[inregbyte], inlen);
- }
-
- /* Read register REGNO into memory at MYADDR, which must be large enough
- for REGISTER_RAW_BYTES (REGNO). Target byte-order.
- If the register is known to be the size of a CORE_ADDR or smaller,
- read_register can be used instead. */
- void
- read_register_gen (regno, myaddr)
- int regno;
- char *myaddr;
- {
- if (registers_pid != inferior_pid)
- {
- registers_changed ();
- registers_pid = inferior_pid;
- }
-
- if (!register_valid[regno])
- target_fetch_registers (regno);
- memcpy (myaddr, ®isters[REGISTER_BYTE (regno)],
- REGISTER_RAW_SIZE (regno));
- }
-
- /* Write register REGNO at MYADDR to the target. MYADDR points at
- REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
-
- void
- write_register_gen (regno, myaddr)
- int regno;
- char *myaddr;
- {
- int size;
-
- /* On the sparc, writing %g0 is a no-op, so we don't even want to change
- the registers array if something writes to this register. */
- if (CANNOT_STORE_REGISTER (regno))
- return;
-
- if (registers_pid != inferior_pid)
- {
- registers_changed ();
- registers_pid = inferior_pid;
- }
-
- size = REGISTER_RAW_SIZE (regno);
-
- /* If we have a valid copy of the register, and new value == old value,
- then don't bother doing the actual store. */
-
- if (register_valid[regno]
- && memcmp (®isters[REGISTER_BYTE (regno)], myaddr, size) == 0)
- return;
-
- target_prepare_to_store ();
-
- memcpy (®isters[REGISTER_BYTE (regno)], myaddr, size);
-
- register_valid[regno] = 1;
-
- target_store_registers (regno);
- }
-
- /* Copy INLEN bytes of consecutive data from memory at MYADDR
- into registers starting with the MYREGSTART'th byte of register data. */
-
- void
- write_register_bytes (myregstart, myaddr, inlen)
- int myregstart;
- char *myaddr;
- int inlen;
- {
- int myregend = myregstart + inlen;
- int regno;
-
- target_prepare_to_store ();
-
- /* Scan through the registers updating any that are covered by the range
- myregstart<=>myregend using write_register_gen, which does nice things
- like handling threads, and avoiding updates when the new and old contents
- are the same. */
-
- for (regno = 0; regno < NUM_REGS; regno++)
- {
- int regstart, regend;
-
- regstart = REGISTER_BYTE (regno);
- regend = regstart + REGISTER_RAW_SIZE (regno);
-
- /* Is this register completely outside the range the user is writing? */
- if (myregend <= regstart || regend <= myregstart)
- /* do nothing */ ;
-
- /* Is this register completely within the range the user is writing? */
- else if (myregstart <= regstart && regend <= myregend)
- write_register_gen (regno, myaddr + (regstart - myregstart));
-
- /* The register partially overlaps the range being written. */
- else
- {
- char regbuf[MAX_REGISTER_RAW_SIZE];
- /* What's the overlap between this register's bytes and
- those the caller wants to write? */
- int overlapstart = max (regstart, myregstart);
- int overlapend = min (regend, myregend);
-
- /* We may be doing a partial update of an invalid register.
- Update it from the target before scribbling on it. */
- read_register_gen (regno, regbuf);
-
- memcpy (registers + overlapstart,
- myaddr + (overlapstart - myregstart),
- overlapend - overlapstart);
-
- target_store_registers (regno);
- }
- }
- }
-
-
- /* Return the raw contents of register REGNO, regarding it as an integer. */
- /* This probably should be returning LONGEST rather than CORE_ADDR. */
-
- CORE_ADDR
- read_register (regno)
- int regno;
- {
- if (registers_pid != inferior_pid)
- {
- registers_changed ();
- registers_pid = inferior_pid;
- }
-
- if (!register_valid[regno])
- target_fetch_registers (regno);
- return ((CORE_ADDR)
- extract_unsigned_integer (®isters[REGISTER_BYTE (regno)],
- REGISTER_RAW_SIZE (regno)));
- }
-
- CORE_ADDR
- read_register_pid (regno, pid)
- int regno, pid;
- {
- int save_pid;
- CORE_ADDR retval;
-
- if (pid == inferior_pid)
- return read_register (regno);
-
- save_pid = inferior_pid;
-
- inferior_pid = pid;
-
- retval = read_register (regno);
-
- inferior_pid = save_pid;
-
- return retval;
- }
-
- /* Store VALUE, into the raw contents of register number REGNO.
- This should probably write a LONGEST rather than a CORE_ADDR */
-
- void
- write_register (regno, val)
- int regno;
- LONGEST val;
- {
- PTR buf;
- int size;
-
- /* On the sparc, writing %g0 is a no-op, so we don't even want to change
- the registers array if something writes to this register. */
- if (CANNOT_STORE_REGISTER (regno))
- return;
-
- if (registers_pid != inferior_pid)
- {
- registers_changed ();
- registers_pid = inferior_pid;
- }
-
- size = REGISTER_RAW_SIZE (regno);
- buf = alloca (size);
- store_signed_integer (buf, size, (LONGEST) val);
-
- /* If we have a valid copy of the register, and new value == old value,
- then don't bother doing the actual store. */
-
- if (register_valid[regno]
- && memcmp (®isters[REGISTER_BYTE (regno)], buf, size) == 0)
- return;
-
- target_prepare_to_store ();
-
- memcpy (®isters[REGISTER_BYTE (regno)], buf, size);
-
- register_valid[regno] = 1;
-
- target_store_registers (regno);
- }
-
- void
- write_register_pid (regno, val, pid)
- int regno;
- CORE_ADDR val;
- int pid;
- {
- int save_pid;
-
- if (pid == inferior_pid)
- {
- write_register (regno, val);
- return;
- }
-
- save_pid = inferior_pid;
-
- inferior_pid = pid;
-
- write_register (regno, val);
-
- inferior_pid = save_pid;
- }
-
- /* Record that register REGNO contains VAL.
- This is used when the value is obtained from the inferior or core dump,
- so there is no need to store the value there.
-
- If VAL is a NULL pointer, then it's probably an unsupported register. We
- just set it's value to all zeros. We might want to record this fact, and
- report it to the users of read_register and friends.
- */
-
- void
- supply_register (regno, val)
- int regno;
- char *val;
- {
- #if 1
- if (registers_pid != inferior_pid)
- {
- registers_changed ();
- registers_pid = inferior_pid;
- }
- #endif
-
- register_valid[regno] = 1;
- if (val)
- memcpy (®isters[REGISTER_BYTE (regno)], val, REGISTER_RAW_SIZE (regno));
- else
- memset (®isters[REGISTER_BYTE (regno)], '\000', REGISTER_RAW_SIZE (regno));
-
- /* On some architectures, e.g. HPPA, there are a few stray bits in some
- registers, that the rest of the code would like to ignore. */
- #ifdef CLEAN_UP_REGISTER_VALUE
- CLEAN_UP_REGISTER_VALUE (regno, ®isters[REGISTER_BYTE (regno)]);
- #endif
- }
-
-
- /* This routine is getting awfully cluttered with #if's. It's probably
- time to turn this into READ_PC and define it in the tm.h file.
- Ditto for write_pc.
-
- 1999-06-08: The following were re-written so that it assumes the
- existance of a TARGET_READ_PC et.al. macro. A default generic
- version of that macro is made available where needed.
-
- Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
- by the multi-arch framework, it will eventually be possible to
- eliminate the intermediate read_pc_pid(). The client would call
- TARGET_READ_PC directly. (cagney). */
-
- #ifndef TARGET_READ_PC
- #define TARGET_READ_PC generic_target_read_pc
- #endif
-
- CORE_ADDR
- generic_target_read_pc (int pid)
- {
- #ifdef PC_REGNUM
- if (PC_REGNUM >= 0)
- {
- CORE_ADDR pc_val = ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, pid));
- return pc_val;
- }
- #endif
- internal_error ("generic_target_read_pc");
- return 0;
- }
-
- CORE_ADDR
- read_pc_pid (pid)
- int pid;
- {
- int saved_inferior_pid;
- CORE_ADDR pc_val;
-
- /* In case pid != inferior_pid. */
- saved_inferior_pid = inferior_pid;
- inferior_pid = pid;
-
- pc_val = TARGET_READ_PC (pid);
-
- inferior_pid = saved_inferior_pid;
- return pc_val;
- }
-
- CORE_ADDR
- read_pc ()
- {
- return read_pc_pid (inferior_pid);
- }
-
- #ifndef TARGET_WRITE_PC
- #define TARGET_WRITE_PC generic_target_write_pc
- #endif
-
- void
- generic_target_write_pc (pc, pid)
- CORE_ADDR pc;
- int pid;
- {
- #ifdef PC_REGNUM
- if (PC_REGNUM >= 0)
- write_register_pid (PC_REGNUM, pc, pid);
- if (NPC_REGNUM >= 0)
- write_register_pid (NPC_REGNUM, pc + 4, pid);
- if (NNPC_REGNUM >= 0)
- write_register_pid (NNPC_REGNUM, pc + 8, pid);
- #else
- internal_error ("generic_target_write_pc");
- #endif
- }
-
- void
- write_pc_pid (pc, pid)
- CORE_ADDR pc;
- int pid;
- {
- int saved_inferior_pid;
-
- /* In case pid != inferior_pid. */
- saved_inferior_pid = inferior_pid;
- inferior_pid = pid;
-
- TARGET_WRITE_PC (pc, pid);
-
- inferior_pid = saved_inferior_pid;
- }
-
- void
- write_pc (pc)
- CORE_ADDR pc;
- {
- write_pc_pid (pc, inferior_pid);
- }
-
- /* Cope with strage ways of getting to the stack and frame pointers */
-
- #ifndef TARGET_READ_SP
- #define TARGET_READ_SP generic_target_read_sp
- #endif
-
- CORE_ADDR
- generic_target_read_sp ()
- {
- #ifdef SP_REGNUM
- if (SP_REGNUM >= 0)
- return read_register (SP_REGNUM);
- #endif
- internal_error ("generic_target_read_sp");
- }
-
- CORE_ADDR
- read_sp ()
- {
- return TARGET_READ_SP ();
- }
-
- #ifndef TARGET_WRITE_SP
- #define TARGET_WRITE_SP generic_target_write_sp
- #endif
-
- void
- generic_target_write_sp (val)
- CORE_ADDR val;
- {
- #ifdef SP_REGNUM
- if (SP_REGNUM >= 0)
- {
- write_register (SP_REGNUM, val);
- return;
- }
- #endif
- internal_error ("generic_target_write_sp");
- }
-
- void
- write_sp (val)
- CORE_ADDR val;
- {
- TARGET_WRITE_SP (val);
- }
-
- #ifndef TARGET_READ_FP
- #define TARGET_READ_FP generic_target_read_fp
- #endif
-
- CORE_ADDR
- generic_target_read_fp ()
- {
- #ifdef FP_REGNUM
- if (FP_REGNUM >= 0)
- return read_register (FP_REGNUM);
- #endif
- internal_error ("generic_target_read_fp");
- }
-
- CORE_ADDR
- read_fp ()
- {
- return TARGET_READ_FP ();
- }
-
- #ifndef TARGET_WRITE_FP
- #define TARGET_WRITE_FP generic_target_write_fp
- #endif
-
- void
- generic_target_write_fp (val)
- CORE_ADDR val;
- {
- #ifdef FP_REGNUM
- if (FP_REGNUM >= 0)
- {
- write_register (FP_REGNUM, val);
- return;
- }
- #endif
- internal_error ("generic_target_write_fp");
- }
-
- void
- write_fp (val)
- CORE_ADDR val;
- {
- TARGET_WRITE_FP (val);
- }
-
-
/* Given a pointer of type TYPE in target form in BUF, return the
address it represents. */
CORE_ADDR
--- 427,433 ----
*************** value_from_register (type, regnum, frame
*** 1578,1584 ****
page_regnum,
&lval);
! if (register_valid[page_regnum] == -1)
return NULL; /* register value not available */
if (lval == lval_register)
--- 799,805 ----
page_regnum,
&lval);
! if (register_cached (page_regnum) == -1)
return NULL; /* register value not available */
if (lval == lval_register)
*************** value_from_register (type, regnum, frame
*** 1595,1601 ****
regnum,
&lval);
! if (register_valid[regnum] == -1)
return NULL; /* register value not available */
if (lval == lval_register)
--- 816,822 ----
regnum,
&lval);
! if (register_cached (regnum) == -1)
return NULL; /* register value not available */
if (lval == lval_register)
*************** value_from_register (type, regnum, frame
*** 1621,1627 ****
local_regnum,
&lval);
! if (register_valid[local_regnum] == -1)
return NULL; /* register value not available */
if (regnum == local_regnum)
--- 842,848 ----
local_regnum,
&lval);
! if (register_cached (local_regnum) == -1)
return NULL; /* register value not available */
if (regnum == local_regnum)
*************** value_from_register (type, regnum, frame
*** 1686,1692 ****
get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
! if (register_valid[regnum] == -1)
return NULL; /* register value not available */
VALUE_OPTIMIZED_OUT (v) = optim;
--- 907,913 ----
get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
! if (register_cached (regnum) == -1)
return NULL; /* register value not available */
VALUE_OPTIMIZED_OUT (v) = optim;
*************** locate_var_value (var, frame)
*** 1781,1810 ****
break;
}
return 0; /* For lint -- never reached */
- }
-
-
- static void build_findvar (void);
- static void
- build_findvar ()
- {
- /* We allocate some extra slop since we do a lot of memcpy's around
- `registers', and failing-soft is better than failing hard. */
- int sizeof_registers = REGISTER_BYTES + /* SLOP */ 256;
- int sizeof_register_valid = NUM_REGS * sizeof (*register_valid);
- registers = xmalloc (sizeof_registers);
- memset (registers, 0, sizeof_registers);
- register_valid = xmalloc (sizeof_register_valid);
- memset (register_valid, 0, sizeof_register_valid);
- }
-
- void _initialize_findvar (void);
- void
- _initialize_findvar ()
- {
- build_findvar ();
-
- register_gdbarch_swap (®isters, sizeof (registers), NULL);
- register_gdbarch_swap (®ister_valid, sizeof (register_valid), NULL);
- register_gdbarch_swap (NULL, 0, build_findvar);
}
--- 1002,1005 ----
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.1
diff -p -r1.1 regcache.c
*** regcache.c 2000/07/10 06:14:40 1.1
--- regcache.c 2000/07/10 06:15:03
***************
*** 0 ****
--- 1,840 ----
+ /* Cache and manage the values of registers for GDB, the GNU debugger.
+ Copyright 1986, 87, 89, 91, 94, 95, 96, 1998, 2000
+ Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+ #include "defs.h"
+ #include "frame.h"
+ #include "inferior.h"
+ #include "target.h"
+ #include "gdbarch.h"
+
+ /*
+ * DATA STRUCTURE
+ *
+ * Here is the actual register cache.
+ */
+
+ /* NOTE: this is a write-back cache. There is no "dirty" bit for
+ recording if the register values have been changed (eg. by the
+ user). Therefore all registers must be written back to the
+ target when appropriate. */
+
+ /* REGISTERS contains the cached register values (in target byte order). */
+
+ char *registers;
+
+ /* REGISTER_VALID is 0 if the register needs to be fetched,
+ 1 if it has been fetched, and
+ -1 if the register value was not available.
+ "Not available" means don't try to fetch it again. */
+
+ signed char *register_valid;
+
+ /* The thread/process associated with the current set of registers.
+ For now, -1 is special, and means `no current process'. */
+
+ static int registers_pid = -1;
+
+ /*
+ * FUNCTIONS:
+ */
+
+ /* REGISTER_CACHED()
+
+ Returns 0 if the value is not in the cache (needs fetch).
+ >0 if the value is in the cache.
+ <0 if the value is permanently unavailable (don't ask again). */
+
+ int
+ register_cached (int regnum)
+ {
+ return register_valid[regnum];
+ }
+
+ /* FIND_SAVED_REGISTER ()
+
+ Return the address in which frame FRAME's value of register REGNUM
+ has been saved in memory. Or return zero if it has not been saved.
+ If REGNUM specifies the SP, the value we return is actually
+ the SP value, not an address where it was saved. */
+
+ CORE_ADDR
+ find_saved_register (struct frame_info *frame, int regnum)
+ {
+ register struct frame_info *frame1 = NULL;
+ register CORE_ADDR addr = 0;
+
+ if (frame == NULL) /* No regs saved if want current frame */
+ return 0;
+
+ #ifdef HAVE_REGISTER_WINDOWS
+ /* We assume that a register in a register window will only be saved
+ in one place (since the name changes and/or disappears as you go
+ towards inner frames), so we only call get_frame_saved_regs on
+ the current frame. This is directly in contradiction to the
+ usage below, which assumes that registers used in a frame must be
+ saved in a lower (more interior) frame. This change is a result
+ of working on a register window machine; get_frame_saved_regs
+ always returns the registers saved within a frame, within the
+ context (register namespace) of that frame. */
+
+ /* However, note that we don't want this to return anything if
+ nothing is saved (if there's a frame inside of this one). Also,
+ callers to this routine asking for the stack pointer want the
+ stack pointer saved for *this* frame; this is returned from the
+ next frame. */
+
+ if (REGISTER_IN_WINDOW_P (regnum))
+ {
+ frame1 = get_next_frame (frame);
+ if (!frame1)
+ return 0; /* Registers of this frame are active. */
+
+ /* Get the SP from the next frame in; it will be this
+ current frame. */
+ if (regnum != SP_REGNUM)
+ frame1 = frame;
+
+ FRAME_INIT_SAVED_REGS (frame1);
+ return frame1->saved_regs[regnum]; /* ... which might be zero */
+ }
+ #endif /* HAVE_REGISTER_WINDOWS */
+
+ /* Note that this next routine assumes that registers used in
+ frame x will be saved only in the frame that x calls and
+ frames interior to it. This is not true on the sparc, but the
+ above macro takes care of it, so we should be all right. */
+ while (1)
+ {
+ QUIT;
+ frame1 = get_prev_frame (frame1);
+ if (frame1 == 0 || frame1 == frame)
+ break;
+ FRAME_INIT_SAVED_REGS (frame1);
+ if (frame1->saved_regs[regnum])
+ addr = frame1->saved_regs[regnum];
+ }
+
+ return addr;
+ }
+
+ /* DEFAULT_GET_SAVED_REGISTER ()
+
+ Find register number REGNUM relative to FRAME and put its (raw,
+ target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
+ variable was optimized out (and thus can't be fetched). Set *LVAL
+ to lval_memory, lval_register, or not_lval, depending on whether
+ the value was fetched from memory, from a register, or in a strange
+ and non-modifiable way (e.g. a frame pointer which was calculated
+ rather than fetched). Set *ADDRP to the address, either in memory
+ on as a REGISTER_BYTE offset into the registers array.
+
+ Note that this implementation never sets *LVAL to not_lval. But
+ it can be replaced by defining GET_SAVED_REGISTER and supplying
+ your own.
+
+ The argument RAW_BUFFER must point to aligned memory. */
+
+ static void
+ default_get_saved_register (char *raw_buffer,
+ int *optimized,
+ CORE_ADDR *addrp,
+ struct frame_info *frame,
+ int regnum,
+ enum lval_type *lval)
+ {
+ CORE_ADDR addr;
+
+ if (!target_has_registers)
+ error ("No registers.");
+
+ /* Normal systems don't optimize out things with register numbers. */
+ if (optimized != NULL)
+ *optimized = 0;
+ addr = find_saved_register (frame, regnum);
+ if (addr != 0)
+ {
+ if (lval != NULL)
+ *lval = lval_memory;
+ if (regnum == SP_REGNUM)
+ {
+ if (raw_buffer != NULL)
+ {
+ /* Put it back in target format. */
+ store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
+ (LONGEST) addr);
+ }
+ if (addrp != NULL)
+ *addrp = 0;
+ return;
+ }
+ if (raw_buffer != NULL)
+ target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
+ }
+ else
+ {
+ if (lval != NULL)
+ *lval = lval_register;
+ addr = REGISTER_BYTE (regnum);
+ if (raw_buffer != NULL)
+ read_register_gen (regnum, raw_buffer);
+ }
+ if (addrp != NULL)
+ *addrp = addr;
+ }
+
+ #if !defined (GET_SAVED_REGISTER)
+ #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+ default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
+ #endif
+
+ void
+ get_saved_register (char *raw_buffer,
+ int *optimized,
+ CORE_ADDR *addrp,
+ struct frame_info *frame,
+ int regnum,
+ enum lval_type *lval)
+ {
+ GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
+ }
+
+ /* READ_RELATIVE_REGISTER_RAW_BYTES_FOR_FRAME
+
+ Copy the bytes of register REGNUM, relative to the input stack frame,
+ into our memory at MYADDR, in target byte order.
+ The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
+
+ Returns 1 if could not be read, 0 if could. */
+
+ /* FIXME: This function increases the confusion between FP_REGNUM
+ and the virtual/pseudo-frame pointer. */
+
+ static int
+ read_relative_register_raw_bytes_for_frame (int regnum,
+ char *myaddr,
+ struct frame_info *frame)
+ {
+ int optim;
+ if (regnum == FP_REGNUM && frame)
+ {
+ /* Put it back in target format. */
+ store_address (myaddr, REGISTER_RAW_SIZE (FP_REGNUM),
+ (LONGEST) FRAME_FP (frame));
+
+ return 0;
+ }
+
+ get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
+ regnum, (enum lval_type *) NULL);
+
+ if (register_valid[regnum] < 0)
+ return 1; /* register value not available */
+
+ return optim;
+ }
+
+ /* READ_RELATIVE_REGISTER_RAW_BYTES
+
+ Copy the bytes of register REGNUM, relative to the current stack
+ frame, into our memory at MYADDR, in target byte order.
+ The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
+
+ Returns 1 if could not be read, 0 if could. */
+
+ int
+ read_relative_register_raw_bytes (int regnum, char *myaddr)
+ {
+ return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
+ selected_frame);
+ }
+
+
+ /* Low level examining and depositing of registers.
+
+ The caller is responsible for making sure that the inferior is
+ stopped before calling the fetching routines, or it will get
+ garbage. (a change from GDB version 3, in which the caller got the
+ value from the last stop). */
+
+ /* REGISTERS_CHANGED ()
+
+ Indicate that registers may have changed, so invalidate the cache. */
+
+ void
+ registers_changed (void)
+ {
+ int i;
+ int numregs = ARCH_NUM_REGS;
+
+ registers_pid = -1;
+
+ /* Force cleanup of any alloca areas if using C alloca instead of
+ a builtin alloca. This particular call is used to clean up
+ areas allocated by low level target code which may build up
+ during lengthy interactions between gdb and the target before
+ gdb gives control to the user (ie watchpoints). */
+ alloca (0);
+
+ for (i = 0; i < numregs; i++)
+ register_valid[i] = 0;
+
+ if (registers_changed_hook)
+ registers_changed_hook ();
+ }
+
+ /* REGISTERS_FETCHED ()
+
+ Indicate that all registers have been fetched, so mark them all valid. */
+
+
+ void
+ registers_fetched (void)
+ {
+ int i;
+ int numregs = ARCH_NUM_REGS;
+
+ for (i = 0; i < numregs; i++)
+ register_valid[i] = 1;
+ }
+
+ /* read_register_bytes and write_register_bytes are generally a *BAD*
+ idea. They are inefficient because they need to check for partial
+ updates, which can only be done by scanning through all of the
+ registers and seeing if the bytes that are being read/written fall
+ inside of an invalid register. [The main reason this is necessary
+ is that register sizes can vary, so a simple index won't suffice.]
+ It is far better to call read_register_gen and write_register_gen
+ if you want to get at the raw register contents, as it only takes a
+ regno as an argument, and therefore can't do a partial register
+ update.
+
+ Prior to the recent fixes to check for partial updates, both read
+ and write_register_bytes always checked to see if any registers
+ were stale, and then called target_fetch_registers (-1) to update
+ the whole set. This caused really slowed things down for remote
+ targets. */
+
+ /* Copy INLEN bytes of consecutive data from registers
+ starting with the INREGBYTE'th byte of register data
+ into memory at MYADDR. */
+
+ void
+ read_register_bytes (int inregbyte, char *myaddr, int inlen)
+ {
+ int inregend = inregbyte + inlen;
+ int regno;
+
+ if (registers_pid != inferior_pid)
+ {
+ registers_changed ();
+ registers_pid = inferior_pid;
+ }
+
+ /* See if we are trying to read bytes from out-of-date registers. If so,
+ update just those registers. */
+
+ for (regno = 0; regno < NUM_REGS; regno++)
+ {
+ int regstart, regend;
+
+ if (register_valid[regno])
+ continue;
+
+ if (REGISTER_NAME (regno) == NULL || *REGISTER_NAME (regno) == '\0')
+ continue;
+
+ regstart = REGISTER_BYTE (regno);
+ regend = regstart + REGISTER_RAW_SIZE (regno);
+
+ if (regend <= inregbyte || inregend <= regstart)
+ /* The range the user wants to read doesn't overlap with regno. */
+ continue;
+
+ /* We've found an invalid register where at least one byte will be read.
+ Update it from the target. */
+ target_fetch_registers (regno);
+
+ if (!register_valid[regno])
+ error ("read_register_bytes: Couldn't update register %d.", regno);
+ }
+
+ if (myaddr != NULL)
+ memcpy (myaddr, ®isters[inregbyte], inlen);
+ }
+
+ /* Read register REGNO into memory at MYADDR, which must be large
+ enough for REGISTER_RAW_BYTES (REGNO). Target byte-order. If the
+ register is known to be the size of a CORE_ADDR or smaller,
+ read_register can be used instead. */
+
+ void
+ read_register_gen (int regno, char *myaddr)
+ {
+ if (registers_pid != inferior_pid)
+ {
+ registers_changed ();
+ registers_pid = inferior_pid;
+ }
+
+ if (!register_valid[regno])
+ target_fetch_registers (regno);
+ memcpy (myaddr, ®isters[REGISTER_BYTE (regno)],
+ REGISTER_RAW_SIZE (regno));
+ }
+
+ /* Write register REGNO at MYADDR to the target. MYADDR points at
+ REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
+
+ /* Registers we shouldn't try to store. */
+ #if !defined (CANNOT_STORE_REGISTER)
+ #define CANNOT_STORE_REGISTER(regno) 0
+ #endif
+
+ void
+ write_register_gen (int regno, char *myaddr)
+ {
+ int size;
+
+ /* On the sparc, writing %g0 is a no-op, so we don't even want to
+ change the registers array if something writes to this register. */
+ if (CANNOT_STORE_REGISTER (regno))
+ return;
+
+ if (registers_pid != inferior_pid)
+ {
+ registers_changed ();
+ registers_pid = inferior_pid;
+ }
+
+ size = REGISTER_RAW_SIZE (regno);
+
+ /* If we have a valid copy of the register, and new value == old value,
+ then don't bother doing the actual store. */
+
+ if (register_valid[regno]
+ && memcmp (®isters[REGISTER_BYTE (regno)], myaddr, size) == 0)
+ return;
+
+ target_prepare_to_store ();
+
+ memcpy (®isters[REGISTER_BYTE (regno)], myaddr, size);
+
+ register_valid[regno] = 1;
+
+ target_store_registers (regno);
+ }
+
+ /* Copy INLEN bytes of consecutive data from memory at MYADDR
+ into registers starting with the MYREGSTART'th byte of register data. */
+
+ void
+ write_register_bytes (int myregstart, char *myaddr, int inlen)
+ {
+ int myregend = myregstart + inlen;
+ int regno;
+
+ target_prepare_to_store ();
+
+ /* Scan through the registers updating any that are covered by the
+ range myregstart<=>myregend using write_register_gen, which does
+ nice things like handling threads, and avoiding updates when the
+ new and old contents are the same. */
+
+ for (regno = 0; regno < NUM_REGS; regno++)
+ {
+ int regstart, regend;
+
+ regstart = REGISTER_BYTE (regno);
+ regend = regstart + REGISTER_RAW_SIZE (regno);
+
+ /* Is this register completely outside the range the user is writing? */
+ if (myregend <= regstart || regend <= myregstart)
+ /* do nothing */ ;
+
+ /* Is this register completely within the range the user is writing? */
+ else if (myregstart <= regstart && regend <= myregend)
+ write_register_gen (regno, myaddr + (regstart - myregstart));
+
+ /* The register partially overlaps the range being written. */
+ else
+ {
+ char regbuf[MAX_REGISTER_RAW_SIZE];
+ /* What's the overlap between this register's bytes and
+ those the caller wants to write? */
+ int overlapstart = max (regstart, myregstart);
+ int overlapend = min (regend, myregend);
+
+ /* We may be doing a partial update of an invalid register.
+ Update it from the target before scribbling on it. */
+ read_register_gen (regno, regbuf);
+
+ memcpy (registers + overlapstart,
+ myaddr + (overlapstart - myregstart),
+ overlapend - overlapstart);
+
+ target_store_registers (regno);
+ }
+ }
+ }
+
+
+ /* Return the raw contents of register REGNO, regarding it as an
+ integer. This probably should be returning LONGEST rather than
+ CORE_ADDR. */
+
+ CORE_ADDR
+ read_register (int regno)
+ {
+ if (registers_pid != inferior_pid)
+ {
+ registers_changed ();
+ registers_pid = inferior_pid;
+ }
+
+ if (!register_valid[regno])
+ target_fetch_registers (regno);
+
+ return ((CORE_ADDR)
+ extract_unsigned_integer (®isters[REGISTER_BYTE (regno)],
+ REGISTER_RAW_SIZE (regno)));
+ }
+
+ CORE_ADDR
+ read_register_pid (int regno, int pid)
+ {
+ int save_pid;
+ CORE_ADDR retval;
+
+ if (pid == inferior_pid)
+ return read_register (regno);
+
+ save_pid = inferior_pid;
+
+ inferior_pid = pid;
+
+ retval = read_register (regno);
+
+ inferior_pid = save_pid;
+
+ return retval;
+ }
+
+ /* Store VALUE, into the raw contents of register number REGNO. */
+
+ void
+ write_register (int regno, LONGEST val)
+ {
+ PTR buf;
+ int size;
+
+ /* On the sparc, writing %g0 is a no-op, so we don't even want to
+ change the registers array if something writes to this register. */
+ if (CANNOT_STORE_REGISTER (regno))
+ return;
+
+ if (registers_pid != inferior_pid)
+ {
+ registers_changed ();
+ registers_pid = inferior_pid;
+ }
+
+ size = REGISTER_RAW_SIZE (regno);
+ buf = alloca (size);
+ store_signed_integer (buf, size, (LONGEST) val);
+
+ /* If we have a valid copy of the register, and new value == old value,
+ then don't bother doing the actual store. */
+
+ if (register_valid[regno]
+ && memcmp (®isters[REGISTER_BYTE (regno)], buf, size) == 0)
+ return;
+
+ target_prepare_to_store ();
+
+ memcpy (®isters[REGISTER_BYTE (regno)], buf, size);
+
+ register_valid[regno] = 1;
+
+ target_store_registers (regno);
+ }
+
+ void
+ write_register_pid (int regno, CORE_ADDR val, int pid)
+ {
+ int save_pid;
+
+ if (pid == inferior_pid)
+ {
+ write_register (regno, val);
+ return;
+ }
+
+ save_pid = inferior_pid;
+
+ inferior_pid = pid;
+
+ write_register (regno, val);
+
+ inferior_pid = save_pid;
+ }
+
+ /* SUPPLY_REGISTER()
+
+ Record that register REGNO contains VAL. This is used when the
+ value is obtained from the inferior or core dump, so there is no
+ need to store the value there.
+
+ If VAL is a NULL pointer, then it's probably an unsupported register.
+ We just set it's value to all zeros. We might want to record this
+ fact, and report it to the users of read_register and friends. */
+
+ void
+ supply_register (int regno, char *val)
+ {
+ #if 1
+ if (registers_pid != inferior_pid)
+ {
+ registers_changed ();
+ registers_pid = inferior_pid;
+ }
+ #endif
+
+ register_valid[regno] = 1;
+ if (val)
+ memcpy (®isters[REGISTER_BYTE (regno)], val,
+ REGISTER_RAW_SIZE (regno));
+ else
+ memset (®isters[REGISTER_BYTE (regno)], '\000',
+ REGISTER_RAW_SIZE (regno));
+
+ /* On some architectures, e.g. HPPA, there are a few stray bits in
+ some registers, that the rest of the code would like to ignore. */
+
+ #ifdef CLEAN_UP_REGISTER_VALUE
+ CLEAN_UP_REGISTER_VALUE (regno, ®isters[REGISTER_BYTE (regno)]);
+ #endif
+ }
+
+ /* read_pc, write_pc, read_sp, write_sp, read_fp, write_fp, etc.
+ Special handling for registers PC, SP, and FP. */
+
+ /* This routine is getting awfully cluttered with #if's. It's probably
+ time to turn this into READ_PC and define it in the tm.h file.
+ Ditto for write_pc.
+
+ 1999-06-08: The following were re-written so that it assumes the
+ existance of a TARGET_READ_PC et.al. macro. A default generic
+ version of that macro is made available where needed.
+
+ Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
+ by the multi-arch framework, it will eventually be possible to
+ eliminate the intermediate read_pc_pid(). The client would call
+ TARGET_READ_PC directly. (cagney). */
+
+ #ifndef TARGET_READ_PC
+ #define TARGET_READ_PC generic_target_read_pc
+ #endif
+
+ CORE_ADDR
+ generic_target_read_pc (int pid)
+ {
+ #ifdef PC_REGNUM
+ if (PC_REGNUM >= 0)
+ {
+ CORE_ADDR pc_val = ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, pid));
+ return pc_val;
+ }
+ #endif
+ internal_error ("generic_target_read_pc");
+ return 0;
+ }
+
+ CORE_ADDR
+ read_pc_pid (int pid)
+ {
+ int saved_inferior_pid;
+ CORE_ADDR pc_val;
+
+ /* In case pid != inferior_pid. */
+ saved_inferior_pid = inferior_pid;
+ inferior_pid = pid;
+
+ pc_val = TARGET_READ_PC (pid);
+
+ inferior_pid = saved_inferior_pid;
+ return pc_val;
+ }
+
+ CORE_ADDR
+ read_pc (void)
+ {
+ return read_pc_pid (inferior_pid);
+ }
+
+ #ifndef TARGET_WRITE_PC
+ #define TARGET_WRITE_PC generic_target_write_pc
+ #endif
+
+ void
+ generic_target_write_pc (CORE_ADDR pc, int pid)
+ {
+ #ifdef PC_REGNUM
+ if (PC_REGNUM >= 0)
+ write_register_pid (PC_REGNUM, pc, pid);
+ if (NPC_REGNUM >= 0)
+ write_register_pid (NPC_REGNUM, pc + 4, pid);
+ if (NNPC_REGNUM >= 0)
+ write_register_pid (NNPC_REGNUM, pc + 8, pid);
+ #else
+ internal_error ("generic_target_write_pc");
+ #endif
+ }
+
+ void
+ write_pc_pid (CORE_ADDR pc, int pid)
+ {
+ int saved_inferior_pid;
+
+ /* In case pid != inferior_pid. */
+ saved_inferior_pid = inferior_pid;
+ inferior_pid = pid;
+
+ TARGET_WRITE_PC (pc, pid);
+
+ inferior_pid = saved_inferior_pid;
+ }
+
+ void
+ write_pc (CORE_ADDR pc)
+ {
+ write_pc_pid (pc, inferior_pid);
+ }
+
+ /* Cope with strage ways of getting to the stack and frame pointers */
+
+ #ifndef TARGET_READ_SP
+ #define TARGET_READ_SP generic_target_read_sp
+ #endif
+
+ CORE_ADDR
+ generic_target_read_sp (void)
+ {
+ #ifdef SP_REGNUM
+ if (SP_REGNUM >= 0)
+ return read_register (SP_REGNUM);
+ #endif
+ internal_error ("generic_target_read_sp");
+ }
+
+ CORE_ADDR
+ read_sp (void)
+ {
+ return TARGET_READ_SP ();
+ }
+
+ #ifndef TARGET_WRITE_SP
+ #define TARGET_WRITE_SP generic_target_write_sp
+ #endif
+
+ void
+ generic_target_write_sp (CORE_ADDR val)
+ {
+ #ifdef SP_REGNUM
+ if (SP_REGNUM >= 0)
+ {
+ write_register (SP_REGNUM, val);
+ return;
+ }
+ #endif
+ internal_error ("generic_target_write_sp");
+ }
+
+ void
+ write_sp (CORE_ADDR val)
+ {
+ TARGET_WRITE_SP (val);
+ }
+
+ #ifndef TARGET_READ_FP
+ #define TARGET_READ_FP generic_target_read_fp
+ #endif
+
+ CORE_ADDR
+ generic_target_read_fp (void)
+ {
+ #ifdef FP_REGNUM
+ if (FP_REGNUM >= 0)
+ return read_register (FP_REGNUM);
+ #endif
+ internal_error ("generic_target_read_fp");
+ }
+
+ CORE_ADDR
+ read_fp (void)
+ {
+ return TARGET_READ_FP ();
+ }
+
+ #ifndef TARGET_WRITE_FP
+ #define TARGET_WRITE_FP generic_target_write_fp
+ #endif
+
+ void
+ generic_target_write_fp (CORE_ADDR val)
+ {
+ #ifdef FP_REGNUM
+ if (FP_REGNUM >= 0)
+ {
+ write_register (FP_REGNUM, val);
+ return;
+ }
+ #endif
+ internal_error ("generic_target_write_fp");
+ }
+
+ void
+ write_fp (CORE_ADDR val)
+ {
+ TARGET_WRITE_FP (val);
+ }
+
+ static void
+ build_regcache (void)
+ {
+ /* We allocate some extra slop since we do a lot of memcpy's around
+ `registers', and failing-soft is better than failing hard. */
+ int sizeof_registers = REGISTER_BYTES + /* SLOP */ 256;
+ int sizeof_register_valid = NUM_REGS * sizeof (*register_valid);
+ registers = xmalloc (sizeof_registers);
+ memset (registers, 0, sizeof_registers);
+ register_valid = xmalloc (sizeof_register_valid);
+ memset (register_valid, 0, sizeof_register_valid);
+ }
+
+ void
+ _initialize_regcache (void)
+ {
+ build_regcache ();
+
+ register_gdbarch_swap (®isters, sizeof (registers), NULL);
+ register_gdbarch_swap (®ister_valid, sizeof (register_valid), NULL);
+ register_gdbarch_swap (NULL, 0, build_regcache);
+ }
Index: Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.38
diff -p -r1.38 Makefile.in
*** Makefile.in 2000/07/05 08:12:04 1.38
--- Makefile.in 2000/07/10 06:15:03
***************
*** 1,5 ****
! # Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
! # 1998, 1999, 2000 Free Software Foundation, Inc.
# This file is part of GDB.
--- 1,5 ----
! # Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
! # Free Software Foundation, Inc.
# This file is part of GDB.
*************** RUNTESTFLAGS=
*** 342,348 ****
# part of libiberty) a POSIX interface. But at least for now the
# host-dependent makefile fragment might need to use something else
# besides ser-unix.o
! SER_HARDWIRE = @SER_HARDWIRE@
# The `remote' debugging target is supported for most architectures,
# but not all (e.g. 960)
--- 342,348 ----
# part of libiberty) a POSIX interface. But at least for now the
# host-dependent makefile fragment might need to use something else
# besides ser-unix.o
! SER_HARDWIRE = ser-unix.o ser-pipe.o
# The `remote' debugging target is supported for most architectures,
# but not all (e.g. 960)
*************** ANNOTATE_OBS = annotate.o
*** 368,374 ****
FLAGS_TO_PASS = \
"prefix=$(prefix)" \
"exec_prefix=$(exec_prefix)" \
- "infodir=$(infodir)" \
"against=$(against)" \
"AR=$(AR)" \
"AR_FLAGS=$(AR_FLAGS)" \
--- 368,373 ----
*************** SFILES = ax-general.c ax-gdb.c bcache.c
*** 481,487 ****
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 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 \
--- 480,486 ----
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 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 \
*************** TAGFILES_NO_SRCDIR = $(SFILES) $(HFILES_
*** 615,624 ****
$(POSSLIBS)
TAGFILES_WITH_SRCDIR = $(HFILES_WITH_SRCDIR)
! COMMON_OBS = version.o blockframe.o breakpoint.o findvar.o stack.o thread.o \
source.o values.o eval.o valops.o valarith.o valprint.o printcmd.o \
symtab.o symfile.o symmisc.o infcmd.o infrun.o command.o \
! expprint.o environ.o \
event-loop.o event-top.o inf-loop.o \
gdbarch.o arch-utils.o gdbtypes.o copying.o $(DEPFILES) \
mem-break.o target.o parse.o language.o $(YYOBJ) buildsym.o \
--- 614,623 ----
$(POSSLIBS)
TAGFILES_WITH_SRCDIR = $(HFILES_WITH_SRCDIR)
! COMMON_OBS = version.o blockframe.o breakpoint.o findvar.o regcache.o \
source.o values.o eval.o valops.o valarith.o valprint.o printcmd.o \
symtab.o symfile.o symmisc.o infcmd.o infrun.o command.o \
! expprint.o environ.o stack.o thread.o \
event-loop.o event-top.o inf-loop.o \
gdbarch.o arch-utils.o gdbtypes.o copying.o $(DEPFILES) \
mem-break.o target.o parse.o language.o $(YYOBJ) buildsym.o \
*************** expprint.o: expprint.c $(defs_h) $(expre
*** 1275,1280 ****
--- 1274,1281 ----
findvar.o: findvar.c $(defs_h) $(gdbcore_h) $(inferior_h) target.h \
gdb_string.h
+
+ regcache.o: regcache.c $(defs_h) $(inferior_h) target.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