1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "inferior.h" /* for inferior_ptid */
30 /* FIND_SAVED_REGISTER ()
32 Return the address in which frame FRAME's value of register REGNUM
33 has been saved in memory. Or return zero if it has not been saved.
34 If REGNUM specifies the SP, the value we return is actually
35 the SP value, not an address where it was saved. */
38 find_saved_register (struct frame_info
*frame
, int regnum
)
40 register struct frame_info
*frame1
= NULL
;
41 register CORE_ADDR addr
= 0;
43 if (frame
== NULL
) /* No regs saved if want current frame */
46 #ifdef HAVE_REGISTER_WINDOWS
47 /* We assume that a register in a register window will only be saved
48 in one place (since the name changes and/or disappears as you go
49 towards inner frames), so we only call get_frame_saved_regs on
50 the current frame. This is directly in contradiction to the
51 usage below, which assumes that registers used in a frame must be
52 saved in a lower (more interior) frame. This change is a result
53 of working on a register window machine; get_frame_saved_regs
54 always returns the registers saved within a frame, within the
55 context (register namespace) of that frame. */
57 /* However, note that we don't want this to return anything if
58 nothing is saved (if there's a frame inside of this one). Also,
59 callers to this routine asking for the stack pointer want the
60 stack pointer saved for *this* frame; this is returned from the
63 if (REGISTER_IN_WINDOW_P (regnum
))
65 frame1
= get_next_frame (frame
);
67 return 0; /* Registers of this frame are active. */
69 /* Get the SP from the next frame in; it will be this
71 if (regnum
!= SP_REGNUM
)
74 FRAME_INIT_SAVED_REGS (frame1
);
75 return frame1
->saved_regs
[regnum
]; /* ... which might be zero */
77 #endif /* HAVE_REGISTER_WINDOWS */
79 /* Note that this next routine assumes that registers used in
80 frame x will be saved only in the frame that x calls and
81 frames interior to it. This is not true on the sparc, but the
82 above macro takes care of it, so we should be all right. */
86 frame1
= get_prev_frame (frame1
);
87 if (frame1
== 0 || frame1
== frame
)
89 FRAME_INIT_SAVED_REGS (frame1
);
90 if (frame1
->saved_regs
[regnum
])
91 addr
= frame1
->saved_regs
[regnum
];
97 /* DEFAULT_GET_SAVED_REGISTER ()
99 Find register number REGNUM relative to FRAME and put its (raw,
100 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
101 variable was optimized out (and thus can't be fetched). Set *LVAL
102 to lval_memory, lval_register, or not_lval, depending on whether
103 the value was fetched from memory, from a register, or in a strange
104 and non-modifiable way (e.g. a frame pointer which was calculated
105 rather than fetched). Set *ADDRP to the address, either in memory
106 on as a REGISTER_BYTE offset into the registers array.
108 Note that this implementation never sets *LVAL to not_lval. But
109 it can be replaced by defining GET_SAVED_REGISTER and supplying
112 The argument RAW_BUFFER must point to aligned memory. */
115 default_get_saved_register (char *raw_buffer
,
118 struct frame_info
*frame
,
120 enum lval_type
*lval
)
124 if (!target_has_registers
)
125 error ("No registers.");
127 /* Normal systems don't optimize out things with register numbers. */
128 if (optimized
!= NULL
)
130 addr
= find_saved_register (frame
, regnum
);
135 if (regnum
== SP_REGNUM
)
137 if (raw_buffer
!= NULL
)
139 /* Put it back in target format. */
140 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
147 if (raw_buffer
!= NULL
)
148 target_read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
153 *lval
= lval_register
;
154 addr
= REGISTER_BYTE (regnum
);
155 if (raw_buffer
!= NULL
)
156 read_register_gen (regnum
, raw_buffer
);
162 #if !defined (GET_SAVED_REGISTER)
163 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
164 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
168 get_saved_register (char *raw_buffer
,
171 struct frame_info
*frame
,
173 enum lval_type
*lval
)
175 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
178 /* frame_register_read ()
180 Find and return the value of REGNUM for the specified stack frame.
181 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
183 Returns 0 if the register value could not be found. */
186 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
189 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, frame
,
190 regnum
, (enum lval_type
*) NULL
);
192 /* FIXME: cagney/2002-04-10: This test is just bogus. It is no
193 indication of the validity of the register. The value could
194 easily be found (on the stack) even though the corresponding
195 register isn't available. */
196 if (register_cached (regnum
) < 0)
197 return 0; /* register value not available */