]>
Commit | Line | Data |
---|---|---|
4f460812 | 1 | /* Cache and manage frames for GDB, the GNU debugger. |
96cb11df AC |
2 | |
3 | Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, | |
4 | 2001, 2002 Free Software Foundation, Inc. | |
d65fe839 AC |
5 | |
6 | This file is part of GDB. | |
7 | ||
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. | |
12 | ||
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. | |
17 | ||
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. */ | |
22 | ||
23 | #include "defs.h" | |
24 | #include "frame.h" | |
25 | #include "target.h" | |
26 | #include "value.h" | |
39f77062 | 27 | #include "inferior.h" /* for inferior_ptid */ |
4e052eda | 28 | #include "regcache.h" |
4f460812 | 29 | #include "gdb_assert.h" |
e36180d7 AC |
30 | #include "gdb_string.h" |
31 | #include "builtin-regs.h" | |
d65fe839 | 32 | |
101dcfbe AC |
33 | /* Return a frame uniq ID that can be used to, later re-find the |
34 | frame. */ | |
35 | ||
36 | void | |
37 | get_frame_id (struct frame_info *fi, struct frame_id *id) | |
38 | { | |
39 | if (fi == NULL) | |
40 | { | |
41 | id->base = 0; | |
42 | id->pc = 0; | |
43 | } | |
44 | else | |
45 | { | |
46 | id->base = FRAME_FP (fi); | |
47 | id->pc = fi->pc; | |
48 | } | |
49 | } | |
50 | ||
51 | struct frame_info * | |
52 | frame_find_by_id (struct frame_id id) | |
53 | { | |
54 | struct frame_info *frame; | |
55 | ||
56 | /* ZERO denotes the null frame, let the caller decide what to do | |
57 | about it. Should it instead return get_current_frame()? */ | |
58 | if (id.base == 0 && id.pc == 0) | |
59 | return NULL; | |
60 | ||
61 | for (frame = get_current_frame (); | |
62 | frame != NULL; | |
63 | frame = get_prev_frame (frame)) | |
64 | { | |
65 | if (INNER_THAN (FRAME_FP (frame), id.base)) | |
66 | /* ``inner/current < frame < id.base''. Keep looking along | |
67 | the frame chain. */ | |
68 | continue; | |
69 | if (INNER_THAN (id.base, FRAME_FP (frame))) | |
70 | /* ``inner/current < id.base < frame''. Oops, gone past it. | |
71 | Just give up. */ | |
72 | return NULL; | |
73 | /* FIXME: cagney/2002-04-21: This isn't sufficient. It should | |
74 | use id.pc to check that the two frames belong to the same | |
75 | function. Otherwise we'll do things like match dummy frames | |
76 | or mis-match frameless functions. However, until someone | |
77 | notices, stick with the existing behavour. */ | |
78 | return frame; | |
79 | } | |
80 | return NULL; | |
81 | } | |
82 | ||
4f460812 AC |
83 | void |
84 | frame_register_unwind (struct frame_info *frame, int regnum, | |
85 | int *optimizedp, enum lval_type *lvalp, | |
86 | CORE_ADDR *addrp, int *realnump, void *bufferp) | |
87 | { | |
88 | struct frame_unwind_cache *cache; | |
89 | ||
90 | /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates | |
91 | that the value proper does not need to be fetched. */ | |
92 | gdb_assert (optimizedp != NULL); | |
93 | gdb_assert (lvalp != NULL); | |
94 | gdb_assert (addrp != NULL); | |
95 | gdb_assert (realnump != NULL); | |
96 | /* gdb_assert (bufferp != NULL); */ | |
97 | ||
98 | /* NOTE: cagney/2002-04-14: It would be nice if, instead of a | |
99 | special case, there was always an inner frame dedicated to the | |
100 | hardware registers. Unfortunatly, there is too much unwind code | |
101 | around that looks up/down the frame chain while making the | |
102 | assumption that each frame level is using the same unwind code. */ | |
103 | ||
104 | if (frame == NULL) | |
105 | { | |
106 | /* We're in the inner-most frame, get the value direct from the | |
107 | register cache. */ | |
108 | *optimizedp = 0; | |
109 | *lvalp = lval_register; | |
fa5f27c7 AC |
110 | /* ULGH! Code uses the offset into the raw register byte array |
111 | as a way of identifying a register. */ | |
112 | *addrp = REGISTER_BYTE (regnum); | |
4f460812 AC |
113 | /* Should this code test ``register_cached (regnum) < 0'' and do |
114 | something like set realnum to -1 when the register isn't | |
115 | available? */ | |
116 | *realnump = regnum; | |
117 | if (bufferp) | |
4caf0990 | 118 | deprecated_read_register_gen (regnum, bufferp); |
4f460812 AC |
119 | return; |
120 | } | |
121 | ||
122 | /* Ask this frame to unwind its register. */ | |
123 | frame->register_unwind (frame, &frame->register_unwind_cache, regnum, | |
124 | optimizedp, lvalp, addrp, realnump, bufferp); | |
125 | } | |
126 | ||
135c175f AC |
127 | void |
128 | frame_unwind_signed_register (struct frame_info *frame, int regnum, | |
129 | LONGEST *val) | |
130 | { | |
131 | int optimized; | |
132 | CORE_ADDR addr; | |
133 | int realnum; | |
134 | enum lval_type lval; | |
135 | void *buf = alloca (MAX_REGISTER_RAW_SIZE); | |
136 | frame_register_unwind (frame, regnum, &optimized, &lval, &addr, | |
137 | &realnum, buf); | |
138 | (*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum)); | |
139 | } | |
140 | ||
141 | void | |
142 | frame_unwind_unsigned_register (struct frame_info *frame, int regnum, | |
143 | ULONGEST *val) | |
144 | { | |
145 | int optimized; | |
146 | CORE_ADDR addr; | |
147 | int realnum; | |
148 | enum lval_type lval; | |
149 | void *buf = alloca (MAX_REGISTER_RAW_SIZE); | |
150 | frame_register_unwind (frame, regnum, &optimized, &lval, &addr, | |
151 | &realnum, buf); | |
152 | (*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum)); | |
153 | } | |
4f460812 | 154 | |
f908a0eb AC |
155 | void |
156 | frame_read_unsigned_register (struct frame_info *frame, int regnum, | |
157 | ULONGEST *val) | |
158 | { | |
159 | /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is | |
160 | always a frame. Both this, and the equivalent | |
161 | frame_read_signed_register() function, can only be called with a | |
162 | valid frame. If, for some reason, this function is called | |
163 | without a frame then the problem isn't here, but rather in the | |
164 | caller. It should of first created a frame and then passed that | |
165 | in. */ | |
166 | /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the | |
167 | ``current_frame'' should not be treated as a special case. While | |
168 | ``get_next_frame (current_frame) == NULL'' currently holds, it | |
169 | should, as far as possible, not be relied upon. In the future, | |
170 | ``get_next_frame (current_frame)'' may instead simply return a | |
171 | normal frame object that simply always gets register values from | |
172 | the register cache. Consequently, frame code should try to avoid | |
173 | tests like ``if get_next_frame() == NULL'' and instead just rely | |
174 | on recursive frame calls (like the below code) when manipulating | |
175 | a frame chain. */ | |
176 | gdb_assert (frame != NULL); | |
177 | frame_unwind_unsigned_register (get_next_frame (frame), regnum, val); | |
178 | } | |
179 | ||
180 | void | |
181 | frame_read_signed_register (struct frame_info *frame, int regnum, | |
182 | LONGEST *val) | |
183 | { | |
184 | /* See note in frame_read_unsigned_register(). */ | |
185 | gdb_assert (frame != NULL); | |
186 | frame_unwind_signed_register (get_next_frame (frame), regnum, val); | |
187 | } | |
188 | ||
4f460812 AC |
189 | void |
190 | generic_unwind_get_saved_register (char *raw_buffer, | |
191 | int *optimizedp, | |
192 | CORE_ADDR *addrp, | |
193 | struct frame_info *frame, | |
194 | int regnum, | |
195 | enum lval_type *lvalp) | |
196 | { | |
197 | int optimizedx; | |
198 | CORE_ADDR addrx; | |
199 | int realnumx; | |
200 | enum lval_type lvalx; | |
201 | ||
202 | if (!target_has_registers) | |
203 | error ("No registers."); | |
204 | ||
205 | /* Keep things simple, ensure that all the pointers (except valuep) | |
206 | are non NULL. */ | |
207 | if (optimizedp == NULL) | |
208 | optimizedp = &optimizedx; | |
209 | if (lvalp == NULL) | |
210 | lvalp = &lvalx; | |
211 | if (addrp == NULL) | |
212 | addrp = &addrx; | |
213 | ||
214 | /* Reached the the bottom (youngest, inner most) of the frame chain | |
215 | (youngest, inner most) frame, go direct to the hardware register | |
216 | cache (do not pass go, do not try to cache the value, ...). The | |
217 | unwound value would have been cached in frame->next but that | |
218 | doesn't exist. This doesn't matter as the hardware register | |
219 | cache is stopping any unnecessary accesses to the target. */ | |
220 | ||
221 | /* NOTE: cagney/2002-04-14: It would be nice if, instead of a | |
222 | special case, there was always an inner frame dedicated to the | |
223 | hardware registers. Unfortunatly, there is too much unwind code | |
224 | around that looks up/down the frame chain while making the | |
225 | assumption that each frame level is using the same unwind code. */ | |
226 | ||
227 | if (frame == NULL) | |
228 | frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx, | |
229 | raw_buffer); | |
230 | else | |
231 | frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp, | |
232 | &realnumx, raw_buffer); | |
233 | } | |
234 | ||
d65fe839 AC |
235 | void |
236 | get_saved_register (char *raw_buffer, | |
237 | int *optimized, | |
238 | CORE_ADDR *addrp, | |
239 | struct frame_info *frame, | |
240 | int regnum, | |
241 | enum lval_type *lval) | |
242 | { | |
243 | GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval); | |
244 | } | |
245 | ||
cda5a58a | 246 | /* frame_register_read () |
d65fe839 | 247 | |
cda5a58a | 248 | Find and return the value of REGNUM for the specified stack frame. |
d65fe839 AC |
249 | The number of bytes copied is REGISTER_RAW_SIZE (REGNUM). |
250 | ||
cda5a58a | 251 | Returns 0 if the register value could not be found. */ |
d65fe839 | 252 | |
cda5a58a AC |
253 | int |
254 | frame_register_read (struct frame_info *frame, int regnum, void *myaddr) | |
d65fe839 AC |
255 | { |
256 | int optim; | |
d65fe839 AC |
257 | get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame, |
258 | regnum, (enum lval_type *) NULL); | |
259 | ||
c97dcfc7 AC |
260 | /* FIXME: cagney/2002-05-15: This test, is just bogus. |
261 | ||
262 | It indicates that the target failed to supply a value for a | |
263 | register because it was "not available" at this time. Problem | |
264 | is, the target still has the register and so get saved_register() | |
265 | may be returning a value saved on the stack. */ | |
266 | ||
d65fe839 | 267 | if (register_cached (regnum) < 0) |
cda5a58a | 268 | return 0; /* register value not available */ |
d65fe839 | 269 | |
cda5a58a | 270 | return !optim; |
d65fe839 | 271 | } |
e36180d7 AC |
272 | |
273 | ||
274 | /* Map between a frame register number and its name. A frame register | |
275 | space is a superset of the cooked register space --- it also | |
276 | includes builtin registers. */ | |
277 | ||
278 | int | |
279 | frame_map_name_to_regnum (const char *name, int len) | |
280 | { | |
281 | int i; | |
282 | ||
283 | /* Search register name space. */ | |
284 | for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++) | |
285 | if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i)) | |
286 | && strncmp (name, REGISTER_NAME (i), len) == 0) | |
287 | { | |
288 | return i; | |
289 | } | |
290 | ||
291 | /* Try builtin registers. */ | |
292 | i = builtin_reg_map_name_to_regnum (name, len); | |
293 | if (i >= 0) | |
294 | { | |
295 | /* A builtin register doesn't fall into the architecture's | |
296 | register range. */ | |
297 | gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS); | |
298 | return i; | |
299 | } | |
300 | ||
301 | return -1; | |
302 | } | |
303 | ||
304 | const char * | |
305 | frame_map_regnum_to_name (int regnum) | |
306 | { | |
307 | if (regnum < 0) | |
308 | return NULL; | |
309 | if (regnum < NUM_REGS + NUM_PSEUDO_REGS) | |
310 | return REGISTER_NAME (regnum); | |
311 | return builtin_reg_map_regnum_to_name (regnum); | |
312 | } |