Commit | Line | Data |
---|---|---|
9c1412c1 AC |
1 | /* Code dealing with dummy stack frames, for GDB, the GNU debugger. |
2 | ||
3 | Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, | |
4 | 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software | |
5 | Foundation, Inc. | |
6 | ||
7 | This file is part of GDB. | |
8 | ||
9 | This program is free software; you can redistribute it and/or modify | |
10 | it under the terms of the GNU General Public License as published by | |
11 | the Free Software Foundation; either version 2 of the License, or | |
12 | (at your option) any later version. | |
13 | ||
14 | This program is distributed in the hope that it will be useful, | |
15 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | GNU General Public License for more details. | |
18 | ||
19 | You should have received a copy of the GNU General Public License | |
20 | along with this program; if not, write to the Free Software | |
21 | Foundation, Inc., 59 Temple Place - Suite 330, | |
22 | Boston, MA 02111-1307, USA. */ | |
23 | ||
24 | ||
25 | #include "defs.h" | |
26 | #include "dummy-frame.h" | |
27 | #include "regcache.h" | |
28 | #include "frame.h" | |
29 | #include "inferior.h" | |
30 | #include "gdb_assert.h" | |
494cca16 | 31 | #include "frame-unwind.h" |
9c1412c1 AC |
32 | |
33 | /* Dummy frame. This saves the processor state just prior to setting | |
34 | up the inferior function call. Older targets save the registers | |
35 | on the target stack (but that really slows down function calls). */ | |
36 | ||
37 | struct dummy_frame | |
38 | { | |
39 | struct dummy_frame *next; | |
40 | ||
f18c5a73 AC |
41 | /* These values belong to the caller (the previous frame, the frame |
42 | that this unwinds back to). */ | |
9c1412c1 AC |
43 | CORE_ADDR pc; |
44 | CORE_ADDR fp; | |
45 | CORE_ADDR sp; | |
46 | CORE_ADDR top; | |
c689142b | 47 | struct frame_id id; |
9c1412c1 AC |
48 | struct regcache *regcache; |
49 | ||
50 | /* Address range of the call dummy code. Look for PC in the range | |
51 | [LO..HI) (after allowing for DECR_PC_AFTER_BREAK). */ | |
52 | CORE_ADDR call_lo; | |
53 | CORE_ADDR call_hi; | |
54 | }; | |
55 | ||
56 | static struct dummy_frame *dummy_frame_stack = NULL; | |
57 | ||
58 | /* Function: find_dummy_frame(pc, fp, sp) | |
59 | ||
60 | Search the stack of dummy frames for one matching the given PC and | |
5e0f933e | 61 | FP/SP. Unlike pc_in_dummy_frame(), this function doesn't need to |
9c1412c1 AC |
62 | adjust for DECR_PC_AFTER_BREAK. This is because it is only legal |
63 | to call this function after the PC has been adjusted. */ | |
64 | ||
8779790c AC |
65 | static struct dummy_frame * |
66 | find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) | |
9c1412c1 AC |
67 | { |
68 | struct dummy_frame *dummyframe; | |
69 | ||
70 | for (dummyframe = dummy_frame_stack; dummyframe != NULL; | |
71 | dummyframe = dummyframe->next) | |
72 | { | |
73 | /* Does the PC fall within the dummy frame's breakpoint | |
74 | instruction. If not, discard this one. */ | |
75 | if (!(pc >= dummyframe->call_lo && pc < dummyframe->call_hi)) | |
76 | continue; | |
77 | /* Does the FP match? */ | |
78 | if (dummyframe->top != 0) | |
79 | { | |
80 | /* If the target architecture explicitly saved the | |
81 | top-of-stack before the inferior function call, assume | |
82 | that that same architecture will always pass in an FP | |
83 | (frame base) value that eactly matches that saved TOS. | |
84 | Don't check the saved SP and SP as they can lead to false | |
85 | hits. */ | |
86 | if (fp != dummyframe->top) | |
87 | continue; | |
88 | } | |
89 | else | |
90 | { | |
91 | /* An older target that hasn't explicitly or implicitly | |
92 | saved the dummy frame's top-of-stack. Try matching the | |
93 | FP against the saved SP and FP. NOTE: If you're trying | |
94 | to fix a problem with GDB not correctly finding a dummy | |
95 | frame, check the comments that go with FRAME_ALIGN() and | |
96 | SAVE_DUMMY_FRAME_TOS(). */ | |
97 | if (fp != dummyframe->fp && fp != dummyframe->sp) | |
98 | continue; | |
99 | } | |
100 | /* The FP matches this dummy frame. */ | |
8779790c | 101 | return dummyframe; |
9c1412c1 AC |
102 | } |
103 | ||
8779790c AC |
104 | return NULL; |
105 | } | |
106 | ||
107 | struct dummy_frame * | |
108 | cached_find_dummy_frame (struct frame_info *frame, void **cache) | |
109 | { | |
110 | if ((*cache) == NULL) | |
bdd78e62 | 111 | (*cache) = find_dummy_frame (get_frame_pc (frame), get_frame_base (frame)); |
8779790c AC |
112 | return (*cache); |
113 | } | |
114 | ||
115 | struct regcache * | |
116 | generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) | |
117 | { | |
118 | struct dummy_frame *dummy = find_dummy_frame (pc, fp); | |
119 | if (dummy != NULL) | |
120 | return dummy->regcache; | |
121 | else | |
122 | return NULL; | |
9c1412c1 AC |
123 | } |
124 | ||
125 | char * | |
126 | deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) | |
127 | { | |
128 | struct regcache *regcache = generic_find_dummy_frame (pc, fp); | |
129 | if (regcache == NULL) | |
130 | return NULL; | |
131 | return deprecated_grub_regcache_for_registers (regcache); | |
132 | } | |
133 | ||
134 | /* Function: pc_in_call_dummy (pc, sp, fp) | |
135 | ||
136 | Return true if the PC falls in a dummy frame created by gdb for an | |
137 | inferior call. The code below which allows DECR_PC_AFTER_BREAK is | |
138 | for infrun.c, which may give the function a PC without that | |
139 | subtracted out. */ | |
140 | ||
141 | int | |
142 | generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp) | |
5e0f933e AC |
143 | { |
144 | return pc_in_dummy_frame (pc); | |
145 | } | |
146 | ||
147 | /* Return non-zero if the PC falls in a dummy frame. | |
148 | ||
149 | The code below which allows DECR_PC_AFTER_BREAK is for infrun.c, | |
150 | which may give the function a PC without that subtracted out. | |
151 | ||
152 | FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can | |
153 | figure out what the real PC (as in the resume address) is BEFORE | |
154 | calling this function (Oh, and I'm not even sure that this function | |
155 | is called with an decremented PC, the call to pc_in_call_dummy() in | |
156 | that file is conditional on !CALL_DUMMY_BREAKPOINT_OFFSET_P yet | |
157 | generic dummy targets set CALL_DUMMY_BREAKPOINT_OFFSET. True?). */ | |
158 | ||
159 | int | |
160 | pc_in_dummy_frame (CORE_ADDR pc) | |
9c1412c1 AC |
161 | { |
162 | struct dummy_frame *dummyframe; | |
163 | for (dummyframe = dummy_frame_stack; | |
164 | dummyframe != NULL; | |
165 | dummyframe = dummyframe->next) | |
166 | { | |
167 | if ((pc >= dummyframe->call_lo) | |
168 | && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK)) | |
169 | return 1; | |
170 | } | |
171 | return 0; | |
172 | } | |
173 | ||
174 | /* Function: read_register_dummy | |
175 | Find a saved register from before GDB calls a function in the inferior */ | |
176 | ||
177 | CORE_ADDR | |
178 | deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno) | |
179 | { | |
180 | struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp); | |
181 | ||
182 | if (dummy_regs) | |
183 | { | |
184 | /* NOTE: cagney/2002-08-12: Replaced a call to | |
185 | regcache_raw_read_as_address() with a call to | |
186 | regcache_cooked_read_unsigned(). The old, ...as_address | |
187 | function was eventually calling extract_unsigned_integer (via | |
188 | extract_address) to unpack the registers value. The below is | |
189 | doing an unsigned extract so that it is functionally | |
190 | equivalent. The read needs to be cooked as, otherwise, it | |
191 | will never correctly return the value of a register in the | |
192 | [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range. */ | |
193 | ULONGEST val; | |
194 | regcache_cooked_read_unsigned (dummy_regs, regno, &val); | |
195 | return val; | |
196 | } | |
197 | else | |
198 | return 0; | |
199 | } | |
200 | ||
201 | /* Save all the registers on the dummy frame stack. Most ports save the | |
202 | registers on the target stack. This results in lots of unnecessary memory | |
203 | references, which are slow when debugging via a serial line. Instead, we | |
204 | save all the registers internally, and never write them to the stack. The | |
205 | registers get restored when the called function returns to the entry point, | |
206 | where a breakpoint is laying in wait. */ | |
207 | ||
208 | void | |
209 | generic_push_dummy_frame (void) | |
210 | { | |
211 | struct dummy_frame *dummy_frame; | |
8b36eed8 | 212 | CORE_ADDR fp = get_frame_base (get_current_frame ()); |
9c1412c1 AC |
213 | |
214 | /* check to see if there are stale dummy frames, | |
215 | perhaps left over from when a longjump took us out of a | |
216 | function that was called by the debugger */ | |
217 | ||
218 | dummy_frame = dummy_frame_stack; | |
219 | while (dummy_frame) | |
220 | if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */ | |
221 | { | |
222 | dummy_frame_stack = dummy_frame->next; | |
223 | regcache_xfree (dummy_frame->regcache); | |
224 | xfree (dummy_frame); | |
225 | dummy_frame = dummy_frame_stack; | |
226 | } | |
227 | else | |
228 | dummy_frame = dummy_frame->next; | |
229 | ||
230 | dummy_frame = xmalloc (sizeof (struct dummy_frame)); | |
231 | dummy_frame->regcache = regcache_xmalloc (current_gdbarch); | |
232 | ||
233 | dummy_frame->pc = read_pc (); | |
234 | dummy_frame->sp = read_sp (); | |
235 | dummy_frame->top = 0; | |
236 | dummy_frame->fp = fp; | |
c689142b | 237 | dummy_frame->id = get_frame_id (get_current_frame ()); |
9c1412c1 AC |
238 | regcache_cpy (dummy_frame->regcache, current_regcache); |
239 | dummy_frame->next = dummy_frame_stack; | |
240 | dummy_frame_stack = dummy_frame; | |
241 | } | |
242 | ||
243 | void | |
244 | generic_save_dummy_frame_tos (CORE_ADDR sp) | |
245 | { | |
246 | dummy_frame_stack->top = sp; | |
247 | } | |
248 | ||
249 | /* Record the upper/lower bounds on the address of the call dummy. */ | |
250 | ||
251 | void | |
252 | generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi) | |
253 | { | |
254 | dummy_frame_stack->call_lo = lo; | |
255 | dummy_frame_stack->call_hi = hi; | |
256 | } | |
257 | ||
258 | /* Restore the machine state from either the saved dummy stack or a | |
259 | real stack frame. */ | |
260 | ||
261 | void | |
262 | generic_pop_current_frame (void (*popper) (struct frame_info * frame)) | |
263 | { | |
264 | struct frame_info *frame = get_current_frame (); | |
5e0f933e AC |
265 | if (get_frame_type (frame) == DUMMY_FRAME) |
266 | /* NOTE: cagney/2002-22-23: Does this ever occure? Surely a dummy | |
267 | frame will have already been poped by the "infrun.c" code. */ | |
9c1412c1 AC |
268 | generic_pop_dummy_frame (); |
269 | else | |
270 | (*popper) (frame); | |
271 | } | |
272 | ||
dbe9fe58 AC |
273 | /* Discard the innermost dummy frame from the dummy frame stack |
274 | (passed in as a parameter). */ | |
275 | ||
276 | static void | |
277 | discard_innermost_dummy (struct dummy_frame **stack) | |
278 | { | |
279 | struct dummy_frame *tbd = (*stack); | |
280 | (*stack) = (*stack)->next; | |
281 | regcache_xfree (tbd->regcache); | |
282 | xfree (tbd); | |
283 | } | |
284 | ||
285 | /* Function: dummy_frame_pop. Restore the machine state from a saved | |
286 | dummy stack frame. */ | |
287 | ||
288 | static void | |
289 | dummy_frame_pop (struct frame_info *fi, void **cache, | |
290 | struct regcache *regcache) | |
291 | { | |
292 | struct dummy_frame *dummy = cached_find_dummy_frame (fi, cache); | |
293 | ||
294 | /* If it isn't, what are we even doing here? */ | |
295 | gdb_assert (get_frame_type (fi) == DUMMY_FRAME); | |
296 | ||
297 | if (dummy == NULL) | |
298 | error ("Can't pop dummy frame!"); | |
299 | ||
300 | /* Discard all dummy frames up-to but not including this one. */ | |
301 | while (dummy_frame_stack != dummy) | |
302 | discard_innermost_dummy (&dummy_frame_stack); | |
303 | ||
304 | /* Restore this one. */ | |
305 | regcache_cpy (regcache, dummy->regcache); | |
306 | flush_cached_frames (); | |
307 | ||
308 | /* Now discard it. */ | |
309 | discard_innermost_dummy (&dummy_frame_stack); | |
310 | ||
311 | /* Note: target changed would be better. Registers, memory and | |
312 | frame are all invalid. */ | |
313 | flush_cached_frames (); | |
314 | } | |
9c1412c1 AC |
315 | |
316 | void | |
317 | generic_pop_dummy_frame (void) | |
318 | { | |
319 | struct dummy_frame *dummy_frame = dummy_frame_stack; | |
320 | ||
321 | /* FIXME: what if the first frame isn't the right one, eg.. | |
322 | because one call-by-hand function has done a longjmp into another one? */ | |
323 | ||
324 | if (!dummy_frame) | |
325 | error ("Can't pop dummy frame!"); | |
9c1412c1 AC |
326 | regcache_cpy (current_regcache, dummy_frame->regcache); |
327 | flush_cached_frames (); | |
328 | ||
dbe9fe58 | 329 | discard_innermost_dummy (&dummy_frame_stack); |
9c1412c1 AC |
330 | } |
331 | ||
332 | /* Function: fix_call_dummy | |
333 | Stub function. Generic dummy frames typically do not need to fix | |
334 | the frame being created */ | |
335 | ||
336 | void | |
337 | generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, | |
338 | struct value **args, struct type *type, int gcc_p) | |
339 | { | |
340 | return; | |
341 | } | |
342 | ||
343 | /* Given a call-dummy dummy-frame, return the registers. Here the | |
344 | register value is taken from the local copy of the register buffer. */ | |
345 | ||
494cca16 | 346 | static void |
8779790c AC |
347 | dummy_frame_register_unwind (struct frame_info *frame, void **cache, |
348 | int regnum, int *optimized, | |
349 | enum lval_type *lvalp, CORE_ADDR *addrp, | |
350 | int *realnum, void *bufferp) | |
9c1412c1 | 351 | { |
8779790c AC |
352 | struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); |
353 | gdb_assert (dummy != NULL); | |
9c1412c1 AC |
354 | |
355 | /* Describe the register's location. Generic dummy frames always | |
356 | have the register value in an ``expression''. */ | |
357 | *optimized = 0; | |
358 | *lvalp = not_lval; | |
359 | *addrp = 0; | |
360 | *realnum = -1; | |
361 | ||
362 | /* If needed, find and return the value of the register. */ | |
363 | if (bufferp != NULL) | |
364 | { | |
9c1412c1 AC |
365 | /* Return the actual value. */ |
366 | /* Use the regcache_cooked_read() method so that it, on the fly, | |
367 | constructs either a raw or pseudo register from the raw | |
368 | register cache. */ | |
8779790c | 369 | regcache_cooked_read (dummy->regcache, regnum, bufferp); |
9c1412c1 AC |
370 | } |
371 | } | |
372 | ||
494cca16 AC |
373 | /* Assuming that FRAME is a dummy, return the resume address for the |
374 | previous frame. */ | |
375 | ||
376 | static CORE_ADDR | |
f18c5a73 AC |
377 | dummy_frame_pc_unwind (struct frame_info *frame, |
378 | void **cache) | |
379 | { | |
380 | struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); | |
381 | /* Oops! In a dummy-frame but can't find the stack dummy. Pretend | |
382 | that the frame doesn't unwind. Should this function instead | |
383 | return a has-no-caller indication? */ | |
384 | if (dummy == NULL) | |
385 | return 0; | |
386 | return dummy->pc; | |
387 | } | |
388 | ||
c689142b | 389 | |
494cca16 AC |
390 | /* Assuming that FRAME is a dummy, return the ID of the calling frame |
391 | (the frame that the dummy has the saved state of). */ | |
392 | ||
393 | static void | |
394 | dummy_frame_id_unwind (struct frame_info *frame, | |
395 | void **cache, | |
c170fb60 | 396 | struct frame_id *id) |
c689142b AC |
397 | { |
398 | struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); | |
399 | /* Oops! In a dummy-frame but can't find the stack dummy. Pretend | |
400 | that the frame doesn't unwind. Should this function instead | |
401 | return a has-no-caller indication? */ | |
402 | if (dummy == NULL) | |
c170fb60 AC |
403 | (*id) = null_frame_id; |
404 | else | |
405 | (*id) = dummy->id; | |
c689142b AC |
406 | } |
407 | ||
494cca16 AC |
408 | static struct frame_unwind dummy_frame_unwind = |
409 | { | |
dbe9fe58 | 410 | dummy_frame_pop, |
494cca16 AC |
411 | dummy_frame_pc_unwind, |
412 | dummy_frame_id_unwind, | |
413 | dummy_frame_register_unwind | |
414 | }; | |
415 | ||
416 | const struct frame_unwind * | |
417 | dummy_frame_p (CORE_ADDR pc) | |
418 | { | |
419 | if (DEPRECATED_PC_IN_CALL_DUMMY_P () | |
420 | ? DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0) | |
421 | : pc_in_dummy_frame (pc)) | |
422 | return &dummy_frame_unwind; | |
423 | else | |
424 | return NULL; | |
425 | } |