1 /* Cache and manage frames 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 */
29 #include "gdb_assert.h"
31 /* FIND_SAVED_REGISTER ()
33 Return the address in which frame FRAME's value of register REGNUM
34 has been saved in memory. Or return zero if it has not been saved.
35 If REGNUM specifies the SP, the value we return is actually
36 the SP value, not an address where it was saved. */
39 find_saved_register (struct frame_info
*frame
, int regnum
)
41 register struct frame_info
*frame1
= NULL
;
42 register CORE_ADDR addr
= 0;
44 if (frame
== NULL
) /* No regs saved if want current frame */
47 /* Note that this next routine assumes that registers used in
48 frame x will be saved only in the frame that x calls and
49 frames interior to it. This is not true on the sparc, but the
50 above macro takes care of it, so we should be all right. */
54 frame1
= get_next_frame (frame
);
58 FRAME_INIT_SAVED_REGS (frame1
);
59 if (frame1
->saved_regs
[regnum
])
60 addr
= frame1
->saved_regs
[regnum
];
66 /* DEFAULT_GET_SAVED_REGISTER ()
68 Find register number REGNUM relative to FRAME and put its (raw,
69 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
70 variable was optimized out (and thus can't be fetched). Set *LVAL
71 to lval_memory, lval_register, or not_lval, depending on whether
72 the value was fetched from memory, from a register, or in a strange
73 and non-modifiable way (e.g. a frame pointer which was calculated
74 rather than fetched). Set *ADDRP to the address, either in memory
75 on as a REGISTER_BYTE offset into the registers array.
77 Note that this implementation never sets *LVAL to not_lval. But
78 it can be replaced by defining GET_SAVED_REGISTER and supplying
81 The argument RAW_BUFFER must point to aligned memory. */
84 default_get_saved_register (char *raw_buffer
,
87 struct frame_info
*frame
,
93 if (!target_has_registers
)
94 error ("No registers.");
96 /* Normal systems don't optimize out things with register numbers. */
97 if (optimized
!= NULL
)
99 addr
= find_saved_register (frame
, regnum
);
104 if (regnum
== SP_REGNUM
)
106 if (raw_buffer
!= NULL
)
108 /* Put it back in target format. */
109 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
116 if (raw_buffer
!= NULL
)
117 target_read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
122 *lval
= lval_register
;
123 addr
= REGISTER_BYTE (regnum
);
124 if (raw_buffer
!= NULL
)
125 read_register_gen (regnum
, raw_buffer
);
132 frame_register_unwind (struct frame_info
*frame
, int regnum
,
133 int *optimizedp
, enum lval_type
*lvalp
,
134 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
136 struct frame_unwind_cache
*cache
;
138 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
139 that the value proper does not need to be fetched. */
140 gdb_assert (optimizedp
!= NULL
);
141 gdb_assert (lvalp
!= NULL
);
142 gdb_assert (addrp
!= NULL
);
143 gdb_assert (realnump
!= NULL
);
144 /* gdb_assert (bufferp != NULL); */
146 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
147 special case, there was always an inner frame dedicated to the
148 hardware registers. Unfortunatly, there is too much unwind code
149 around that looks up/down the frame chain while making the
150 assumption that each frame level is using the same unwind code. */
154 /* We're in the inner-most frame, get the value direct from the
157 *lvalp
= lval_register
;
159 /* Should this code test ``register_cached (regnum) < 0'' and do
160 something like set realnum to -1 when the register isn't
164 read_register_gen (regnum
, bufferp
);
168 /* Ask this frame to unwind its register. */
169 frame
->register_unwind (frame
, &frame
->register_unwind_cache
, regnum
,
170 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
175 generic_unwind_get_saved_register (char *raw_buffer
,
178 struct frame_info
*frame
,
180 enum lval_type
*lvalp
)
185 enum lval_type lvalx
;
187 if (!target_has_registers
)
188 error ("No registers.");
190 /* Keep things simple, ensure that all the pointers (except valuep)
192 if (optimizedp
== NULL
)
193 optimizedp
= &optimizedx
;
199 /* Reached the the bottom (youngest, inner most) of the frame chain
200 (youngest, inner most) frame, go direct to the hardware register
201 cache (do not pass go, do not try to cache the value, ...). The
202 unwound value would have been cached in frame->next but that
203 doesn't exist. This doesn't matter as the hardware register
204 cache is stopping any unnecessary accesses to the target. */
206 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
207 special case, there was always an inner frame dedicated to the
208 hardware registers. Unfortunatly, there is too much unwind code
209 around that looks up/down the frame chain while making the
210 assumption that each frame level is using the same unwind code. */
213 frame_register_unwind (NULL
, regnum
, optimizedp
, lvalp
, addrp
, &realnumx
,
216 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
217 &realnumx
, raw_buffer
);
220 #if !defined (GET_SAVED_REGISTER)
221 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
222 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
226 get_saved_register (char *raw_buffer
,
229 struct frame_info
*frame
,
231 enum lval_type
*lval
)
233 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
236 /* frame_register_read ()
238 Find and return the value of REGNUM for the specified stack frame.
239 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
241 Returns 0 if the register value could not be found. */
244 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
247 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, frame
,
248 regnum
, (enum lval_type
*) NULL
);
250 /* FIXME: cagney/2002-05-15: This test, is just bogus.
252 It indicates that the target failed to supply a value for a
253 register because it was "not available" at this time. Problem
254 is, the target still has the register and so get saved_register()
255 may be returning a value saved on the stack. */
257 if (register_cached (regnum
) < 0)
258 return 0; /* register value not available */
This page took 0.03364 seconds and 4 git commands to generate.