/* Cache and manage the values of registers for GDB, the GNU debugger.
|
/* Cache and manage the values of registers for GDB, the GNU debugger.
|
Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001
|
Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Boston, MA 02111-1307, USA. */
|
Boston, MA 02111-1307, USA. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "frame.h"
|
#include "frame.h"
|
#include "target.h"
|
#include "target.h"
|
#include "value.h"
|
#include "value.h"
|
#include "inferior.h" /* for inferior_ptid */
|
#include "inferior.h" /* for inferior_ptid */
|
#include "regcache.h"
|
#include "regcache.h"
|
|
|
/* FIND_SAVED_REGISTER ()
|
/* FIND_SAVED_REGISTER ()
|
|
|
Return the address in which frame FRAME's value of register REGNUM
|
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.
|
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
|
If REGNUM specifies the SP, the value we return is actually
|
the SP value, not an address where it was saved. */
|
the SP value, not an address where it was saved. */
|
|
|
CORE_ADDR
|
CORE_ADDR
|
find_saved_register (struct frame_info *frame, int regnum)
|
find_saved_register (struct frame_info *frame, int regnum)
|
{
|
{
|
register struct frame_info *frame1 = NULL;
|
register struct frame_info *frame1 = NULL;
|
register CORE_ADDR addr = 0;
|
register CORE_ADDR addr = 0;
|
|
|
if (frame == NULL) /* No regs saved if want current frame */
|
if (frame == NULL) /* No regs saved if want current frame */
|
return 0;
|
return 0;
|
|
|
#ifdef HAVE_REGISTER_WINDOWS
|
#ifdef HAVE_REGISTER_WINDOWS
|
/* We assume that a register in a register window will only be saved
|
/* 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
|
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
|
towards inner frames), so we only call get_frame_saved_regs on
|
the current frame. This is directly in contradiction to the
|
the current frame. This is directly in contradiction to the
|
usage below, which assumes that registers used in a frame must be
|
usage below, which assumes that registers used in a frame must be
|
saved in a lower (more interior) frame. This change is a result
|
saved in a lower (more interior) frame. This change is a result
|
of working on a register window machine; get_frame_saved_regs
|
of working on a register window machine; get_frame_saved_regs
|
always returns the registers saved within a frame, within the
|
always returns the registers saved within a frame, within the
|
context (register namespace) of that frame. */
|
context (register namespace) of that frame. */
|
|
|
/* However, note that we don't want this to return anything if
|
/* 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,
|
nothing is saved (if there's a frame inside of this one). Also,
|
callers to this routine asking for the stack pointer want the
|
callers to this routine asking for the stack pointer want the
|
stack pointer saved for *this* frame; this is returned from the
|
stack pointer saved for *this* frame; this is returned from the
|
next frame. */
|
next frame. */
|
|
|
if (REGISTER_IN_WINDOW_P (regnum))
|
if (REGISTER_IN_WINDOW_P (regnum))
|
{
|
{
|
frame1 = get_next_frame (frame);
|
frame1 = get_next_frame (frame);
|
if (!frame1)
|
if (!frame1)
|
return 0; /* Registers of this frame are active. */
|
return 0; /* Registers of this frame are active. */
|
|
|
/* Get the SP from the next frame in; it will be this
|
/* Get the SP from the next frame in; it will be this
|
current frame. */
|
current frame. */
|
if (regnum != SP_REGNUM)
|
if (regnum != SP_REGNUM)
|
frame1 = frame;
|
frame1 = frame;
|
|
|
FRAME_INIT_SAVED_REGS (frame1);
|
FRAME_INIT_SAVED_REGS (frame1);
|
return frame1->saved_regs[regnum]; /* ... which might be zero */
|
return frame1->saved_regs[regnum]; /* ... which might be zero */
|
}
|
}
|
#endif /* HAVE_REGISTER_WINDOWS */
|
#endif /* HAVE_REGISTER_WINDOWS */
|
|
|
/* Note that this next routine assumes that registers used in
|
/* Note that this next routine assumes that registers used in
|
frame x will be saved only in the frame that x calls and
|
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
|
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. */
|
above macro takes care of it, so we should be all right. */
|
while (1)
|
while (1)
|
{
|
{
|
QUIT;
|
QUIT;
|
frame1 = get_prev_frame (frame1);
|
frame1 = get_prev_frame (frame1);
|
if (frame1 == 0 || frame1 == frame)
|
if (frame1 == 0 || frame1 == frame)
|
break;
|
break;
|
FRAME_INIT_SAVED_REGS (frame1);
|
FRAME_INIT_SAVED_REGS (frame1);
|
if (frame1->saved_regs[regnum])
|
if (frame1->saved_regs[regnum])
|
addr = frame1->saved_regs[regnum];
|
addr = frame1->saved_regs[regnum];
|
}
|
}
|
|
|
return addr;
|
return addr;
|
}
|
}
|
|
|
/* DEFAULT_GET_SAVED_REGISTER ()
|
/* DEFAULT_GET_SAVED_REGISTER ()
|
|
|
Find register number REGNUM relative to FRAME and put its (raw,
|
Find register number REGNUM relative to FRAME and put its (raw,
|
target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
|
target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
|
variable was optimized out (and thus can't be fetched). Set *LVAL
|
variable was optimized out (and thus can't be fetched). Set *LVAL
|
to lval_memory, lval_register, or not_lval, depending on whether
|
to lval_memory, lval_register, or not_lval, depending on whether
|
the value was fetched from memory, from a register, or in a strange
|
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
|
and non-modifiable way (e.g. a frame pointer which was calculated
|
rather than fetched). Set *ADDRP to the address, either in memory
|
rather than fetched). Set *ADDRP to the address, either in memory
|
on as a REGISTER_BYTE offset into the registers array.
|
on as a REGISTER_BYTE offset into the registers array.
|
|
|
Note that this implementation never sets *LVAL to not_lval. But
|
Note that this implementation never sets *LVAL to not_lval. But
|
it can be replaced by defining GET_SAVED_REGISTER and supplying
|
it can be replaced by defining GET_SAVED_REGISTER and supplying
|
your own.
|
your own.
|
|
|
The argument RAW_BUFFER must point to aligned memory. */
|
The argument RAW_BUFFER must point to aligned memory. */
|
|
|
static void
|
static void
|
default_get_saved_register (char *raw_buffer,
|
default_get_saved_register (char *raw_buffer,
|
int *optimized,
|
int *optimized,
|
CORE_ADDR *addrp,
|
CORE_ADDR *addrp,
|
struct frame_info *frame,
|
struct frame_info *frame,
|
int regnum,
|
int regnum,
|
enum lval_type *lval)
|
enum lval_type *lval)
|
{
|
{
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
|
|
if (!target_has_registers)
|
if (!target_has_registers)
|
error ("No registers.");
|
error ("No registers.");
|
|
|
/* Normal systems don't optimize out things with register numbers. */
|
/* Normal systems don't optimize out things with register numbers. */
|
if (optimized != NULL)
|
if (optimized != NULL)
|
*optimized = 0;
|
*optimized = 0;
|
addr = find_saved_register (frame, regnum);
|
addr = find_saved_register (frame, regnum);
|
if (addr != 0)
|
if (addr != 0)
|
{
|
{
|
if (lval != NULL)
|
if (lval != NULL)
|
*lval = lval_memory;
|
*lval = lval_memory;
|
if (regnum == SP_REGNUM)
|
if (regnum == SP_REGNUM)
|
{
|
{
|
if (raw_buffer != NULL)
|
if (raw_buffer != NULL)
|
{
|
{
|
/* Put it back in target format. */
|
/* Put it back in target format. */
|
store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
|
store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
|
(LONGEST) addr);
|
(LONGEST) addr);
|
}
|
}
|
if (addrp != NULL)
|
if (addrp != NULL)
|
*addrp = 0;
|
*addrp = 0;
|
return;
|
return;
|
}
|
}
|
if (raw_buffer != NULL)
|
if (raw_buffer != NULL)
|
target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
|
target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
|
}
|
}
|
else
|
else
|
{
|
{
|
if (lval != NULL)
|
if (lval != NULL)
|
*lval = lval_register;
|
*lval = lval_register;
|
addr = REGISTER_BYTE (regnum);
|
addr = REGISTER_BYTE (regnum);
|
if (raw_buffer != NULL)
|
if (raw_buffer != NULL)
|
read_register_gen (regnum, raw_buffer);
|
read_register_gen (regnum, raw_buffer);
|
}
|
}
|
if (addrp != NULL)
|
if (addrp != NULL)
|
*addrp = addr;
|
*addrp = addr;
|
}
|
}
|
|
|
#if !defined (GET_SAVED_REGISTER)
|
#if !defined (GET_SAVED_REGISTER)
|
#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
|
#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
|
default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
|
default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
|
#endif
|
#endif
|
|
|
void
|
void
|
get_saved_register (char *raw_buffer,
|
get_saved_register (char *raw_buffer,
|
int *optimized,
|
int *optimized,
|
CORE_ADDR *addrp,
|
CORE_ADDR *addrp,
|
struct frame_info *frame,
|
struct frame_info *frame,
|
int regnum,
|
int regnum,
|
enum lval_type *lval)
|
enum lval_type *lval)
|
{
|
{
|
GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
|
GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
|
}
|
}
|
|
|
/* READ_RELATIVE_REGISTER_RAW_BYTES_FOR_FRAME
|
/* READ_RELATIVE_REGISTER_RAW_BYTES_FOR_FRAME
|
|
|
Copy the bytes of register REGNUM, relative to the input stack frame,
|
Copy the bytes of register REGNUM, relative to the input stack frame,
|
into our memory at MYADDR, in target byte order.
|
into our memory at MYADDR, in target byte order.
|
The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
|
The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
|
|
|
Returns 1 if could not be read, 0 if could. */
|
Returns 1 if could not be read, 0 if could. */
|
|
|
/* FIXME: This function increases the confusion between FP_REGNUM
|
/* FIXME: This function increases the confusion between FP_REGNUM
|
and the virtual/pseudo-frame pointer. */
|
and the virtual/pseudo-frame pointer. */
|
|
|
static int
|
static int
|
read_relative_register_raw_bytes_for_frame (int regnum,
|
read_relative_register_raw_bytes_for_frame (int regnum,
|
char *myaddr,
|
char *myaddr,
|
struct frame_info *frame)
|
struct frame_info *frame)
|
{
|
{
|
int optim;
|
int optim;
|
if (regnum == FP_REGNUM && frame)
|
if (regnum == FP_REGNUM && frame)
|
{
|
{
|
/* Put it back in target format. */
|
/* Put it back in target format. */
|
store_address (myaddr, REGISTER_RAW_SIZE (FP_REGNUM),
|
store_address (myaddr, REGISTER_RAW_SIZE (FP_REGNUM),
|
(LONGEST) FRAME_FP (frame));
|
(LONGEST) FRAME_FP (frame));
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
|
get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
|
regnum, (enum lval_type *) NULL);
|
regnum, (enum lval_type *) NULL);
|
|
|
if (register_cached (regnum) < 0)
|
if (register_cached (regnum) < 0)
|
return 1; /* register value not available */
|
return 1; /* register value not available */
|
|
|
return optim;
|
return optim;
|
}
|
}
|
|
|
/* READ_RELATIVE_REGISTER_RAW_BYTES
|
/* READ_RELATIVE_REGISTER_RAW_BYTES
|
|
|
Copy the bytes of register REGNUM, relative to the current stack
|
Copy the bytes of register REGNUM, relative to the current stack
|
frame, into our memory at MYADDR, in target byte order.
|
frame, into our memory at MYADDR, in target byte order.
|
The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
|
The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
|
|
|
Returns 1 if could not be read, 0 if could. */
|
Returns 1 if could not be read, 0 if could. */
|
|
|
int
|
int
|
read_relative_register_raw_bytes (int regnum, char *myaddr)
|
read_relative_register_raw_bytes (int regnum, char *myaddr)
|
{
|
{
|
return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
|
return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
|
selected_frame);
|
selected_frame);
|
}
|
}
|
|
|
