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" | |
31 | ||
32 | /* Dummy frame. This saves the processor state just prior to setting | |
33 | up the inferior function call. Older targets save the registers | |
34 | on the target stack (but that really slows down function calls). */ | |
35 | ||
36 | struct dummy_frame | |
37 | { | |
38 | struct dummy_frame *next; | |
39 | ||
f18c5a73 AC |
40 | /* These values belong to the caller (the previous frame, the frame |
41 | that this unwinds back to). */ | |
9c1412c1 AC |
42 | CORE_ADDR pc; |
43 | CORE_ADDR fp; | |
44 | CORE_ADDR sp; | |
45 | CORE_ADDR top; | |
46 | struct regcache *regcache; | |
47 | ||
48 | /* Address range of the call dummy code. Look for PC in the range | |
49 | [LO..HI) (after allowing for DECR_PC_AFTER_BREAK). */ | |
50 | CORE_ADDR call_lo; | |
51 | CORE_ADDR call_hi; | |
52 | }; | |
53 | ||
54 | static struct dummy_frame *dummy_frame_stack = NULL; | |
55 | ||
56 | /* Function: find_dummy_frame(pc, fp, sp) | |
57 | ||
58 | Search the stack of dummy frames for one matching the given PC and | |
5e0f933e | 59 | FP/SP. Unlike pc_in_dummy_frame(), this function doesn't need to |
9c1412c1 AC |
60 | adjust for DECR_PC_AFTER_BREAK. This is because it is only legal |
61 | to call this function after the PC has been adjusted. */ | |
62 | ||
8779790c AC |
63 | static struct dummy_frame * |
64 | find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) | |
9c1412c1 AC |
65 | { |
66 | struct dummy_frame *dummyframe; | |
67 | ||
68 | for (dummyframe = dummy_frame_stack; dummyframe != NULL; | |
69 | dummyframe = dummyframe->next) | |
70 | { | |
71 | /* Does the PC fall within the dummy frame's breakpoint | |
72 | instruction. If not, discard this one. */ | |
73 | if (!(pc >= dummyframe->call_lo && pc < dummyframe->call_hi)) | |
74 | continue; | |
75 | /* Does the FP match? */ | |
76 | if (dummyframe->top != 0) | |
77 | { | |
78 | /* If the target architecture explicitly saved the | |
79 | top-of-stack before the inferior function call, assume | |
80 | that that same architecture will always pass in an FP | |
81 | (frame base) value that eactly matches that saved TOS. | |
82 | Don't check the saved SP and SP as they can lead to false | |
83 | hits. */ | |
84 | if (fp != dummyframe->top) | |
85 | continue; | |
86 | } | |
87 | else | |
88 | { | |
89 | /* An older target that hasn't explicitly or implicitly | |
90 | saved the dummy frame's top-of-stack. Try matching the | |
91 | FP against the saved SP and FP. NOTE: If you're trying | |
92 | to fix a problem with GDB not correctly finding a dummy | |
93 | frame, check the comments that go with FRAME_ALIGN() and | |
94 | SAVE_DUMMY_FRAME_TOS(). */ | |
95 | if (fp != dummyframe->fp && fp != dummyframe->sp) | |
96 | continue; | |
97 | } | |
98 | /* The FP matches this dummy frame. */ | |
8779790c | 99 | return dummyframe; |
9c1412c1 AC |
100 | } |
101 | ||
8779790c AC |
102 | return NULL; |
103 | } | |
104 | ||
105 | struct dummy_frame * | |
106 | cached_find_dummy_frame (struct frame_info *frame, void **cache) | |
107 | { | |
108 | if ((*cache) == NULL) | |
109 | (*cache) = find_dummy_frame (frame->pc, frame->frame); | |
110 | return (*cache); | |
111 | } | |
112 | ||
113 | struct regcache * | |
114 | generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) | |
115 | { | |
116 | struct dummy_frame *dummy = find_dummy_frame (pc, fp); | |
117 | if (dummy != NULL) | |
118 | return dummy->regcache; | |
119 | else | |
120 | return NULL; | |
9c1412c1 AC |
121 | } |
122 | ||
123 | char * | |
124 | deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp) | |
125 | { | |
126 | struct regcache *regcache = generic_find_dummy_frame (pc, fp); | |
127 | if (regcache == NULL) | |
128 | return NULL; | |
129 | return deprecated_grub_regcache_for_registers (regcache); | |
130 | } | |
131 | ||
132 | /* Function: pc_in_call_dummy (pc, sp, fp) | |
133 | ||
134 | Return true if the PC falls in a dummy frame created by gdb for an | |
135 | inferior call. The code below which allows DECR_PC_AFTER_BREAK is | |
136 | for infrun.c, which may give the function a PC without that | |
137 | subtracted out. */ | |
138 | ||
139 | int | |
140 | generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp) | |
5e0f933e AC |
141 | { |
142 | return pc_in_dummy_frame (pc); | |
143 | } | |
144 | ||
145 | /* Return non-zero if the PC falls in a dummy frame. | |
146 | ||
147 | The code below which allows DECR_PC_AFTER_BREAK is for infrun.c, | |
148 | which may give the function a PC without that subtracted out. | |
149 | ||
150 | FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can | |
151 | figure out what the real PC (as in the resume address) is BEFORE | |
152 | calling this function (Oh, and I'm not even sure that this function | |
153 | is called with an decremented PC, the call to pc_in_call_dummy() in | |
154 | that file is conditional on !CALL_DUMMY_BREAKPOINT_OFFSET_P yet | |
155 | generic dummy targets set CALL_DUMMY_BREAKPOINT_OFFSET. True?). */ | |
156 | ||
157 | int | |
158 | pc_in_dummy_frame (CORE_ADDR pc) | |
9c1412c1 AC |
159 | { |
160 | struct dummy_frame *dummyframe; | |
161 | for (dummyframe = dummy_frame_stack; | |
162 | dummyframe != NULL; | |
163 | dummyframe = dummyframe->next) | |
164 | { | |
165 | if ((pc >= dummyframe->call_lo) | |
166 | && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK)) | |
167 | return 1; | |
168 | } | |
169 | return 0; | |
170 | } | |
171 | ||
172 | /* Function: read_register_dummy | |
173 | Find a saved register from before GDB calls a function in the inferior */ | |
174 | ||
175 | CORE_ADDR | |
176 | deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno) | |
177 | { | |
178 | struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp); | |
179 | ||
180 | if (dummy_regs) | |
181 | { | |
182 | /* NOTE: cagney/2002-08-12: Replaced a call to | |
183 | regcache_raw_read_as_address() with a call to | |
184 | regcache_cooked_read_unsigned(). The old, ...as_address | |
185 | function was eventually calling extract_unsigned_integer (via | |
186 | extract_address) to unpack the registers value. The below is | |
187 | doing an unsigned extract so that it is functionally | |
188 | equivalent. The read needs to be cooked as, otherwise, it | |
189 | will never correctly return the value of a register in the | |
190 | [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range. */ | |
191 | ULONGEST val; | |
192 | regcache_cooked_read_unsigned (dummy_regs, regno, &val); | |
193 | return val; | |
194 | } | |
195 | else | |
196 | return 0; | |
197 | } | |
198 | ||
199 | /* Save all the registers on the dummy frame stack. Most ports save the | |
200 | registers on the target stack. This results in lots of unnecessary memory | |
201 | references, which are slow when debugging via a serial line. Instead, we | |
202 | save all the registers internally, and never write them to the stack. The | |
203 | registers get restored when the called function returns to the entry point, | |
204 | where a breakpoint is laying in wait. */ | |
205 | ||
206 | void | |
207 | generic_push_dummy_frame (void) | |
208 | { | |
209 | struct dummy_frame *dummy_frame; | |
210 | CORE_ADDR fp = (get_current_frame ())->frame; | |
211 | ||
212 | /* check to see if there are stale dummy frames, | |
213 | perhaps left over from when a longjump took us out of a | |
214 | function that was called by the debugger */ | |
215 | ||
216 | dummy_frame = dummy_frame_stack; | |
217 | while (dummy_frame) | |
218 | if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */ | |
219 | { | |
220 | dummy_frame_stack = dummy_frame->next; | |
221 | regcache_xfree (dummy_frame->regcache); | |
222 | xfree (dummy_frame); | |
223 | dummy_frame = dummy_frame_stack; | |
224 | } | |
225 | else | |
226 | dummy_frame = dummy_frame->next; | |
227 | ||
228 | dummy_frame = xmalloc (sizeof (struct dummy_frame)); | |
229 | dummy_frame->regcache = regcache_xmalloc (current_gdbarch); | |
230 | ||
231 | dummy_frame->pc = read_pc (); | |
232 | dummy_frame->sp = read_sp (); | |
233 | dummy_frame->top = 0; | |
234 | dummy_frame->fp = fp; | |
235 | regcache_cpy (dummy_frame->regcache, current_regcache); | |
236 | dummy_frame->next = dummy_frame_stack; | |
237 | dummy_frame_stack = dummy_frame; | |
238 | } | |
239 | ||
240 | void | |
241 | generic_save_dummy_frame_tos (CORE_ADDR sp) | |
242 | { | |
243 | dummy_frame_stack->top = sp; | |
244 | } | |
245 | ||
246 | /* Record the upper/lower bounds on the address of the call dummy. */ | |
247 | ||
248 | void | |
249 | generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi) | |
250 | { | |
251 | dummy_frame_stack->call_lo = lo; | |
252 | dummy_frame_stack->call_hi = hi; | |
253 | } | |
254 | ||
255 | /* Restore the machine state from either the saved dummy stack or a | |
256 | real stack frame. */ | |
257 | ||
258 | void | |
259 | generic_pop_current_frame (void (*popper) (struct frame_info * frame)) | |
260 | { | |
261 | struct frame_info *frame = get_current_frame (); | |
5e0f933e AC |
262 | if (get_frame_type (frame) == DUMMY_FRAME) |
263 | /* NOTE: cagney/2002-22-23: Does this ever occure? Surely a dummy | |
264 | frame will have already been poped by the "infrun.c" code. */ | |
9c1412c1 AC |
265 | generic_pop_dummy_frame (); |
266 | else | |
267 | (*popper) (frame); | |
268 | } | |
269 | ||
270 | /* Function: pop_dummy_frame | |
271 | Restore the machine state from a saved dummy stack frame. */ | |
272 | ||
273 | void | |
274 | generic_pop_dummy_frame (void) | |
275 | { | |
276 | struct dummy_frame *dummy_frame = dummy_frame_stack; | |
277 | ||
278 | /* FIXME: what if the first frame isn't the right one, eg.. | |
279 | because one call-by-hand function has done a longjmp into another one? */ | |
280 | ||
281 | if (!dummy_frame) | |
282 | error ("Can't pop dummy frame!"); | |
283 | dummy_frame_stack = dummy_frame->next; | |
284 | regcache_cpy (current_regcache, dummy_frame->regcache); | |
285 | flush_cached_frames (); | |
286 | ||
287 | regcache_xfree (dummy_frame->regcache); | |
288 | xfree (dummy_frame); | |
289 | } | |
290 | ||
291 | /* Function: fix_call_dummy | |
292 | Stub function. Generic dummy frames typically do not need to fix | |
293 | the frame being created */ | |
294 | ||
295 | void | |
296 | generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, | |
297 | struct value **args, struct type *type, int gcc_p) | |
298 | { | |
299 | return; | |
300 | } | |
301 | ||
302 | /* Given a call-dummy dummy-frame, return the registers. Here the | |
303 | register value is taken from the local copy of the register buffer. */ | |
304 | ||
305 | void | |
8779790c AC |
306 | dummy_frame_register_unwind (struct frame_info *frame, void **cache, |
307 | int regnum, int *optimized, | |
308 | enum lval_type *lvalp, CORE_ADDR *addrp, | |
309 | int *realnum, void *bufferp) | |
9c1412c1 | 310 | { |
8779790c AC |
311 | struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); |
312 | gdb_assert (dummy != NULL); | |
9c1412c1 AC |
313 | |
314 | /* Describe the register's location. Generic dummy frames always | |
315 | have the register value in an ``expression''. */ | |
316 | *optimized = 0; | |
317 | *lvalp = not_lval; | |
318 | *addrp = 0; | |
319 | *realnum = -1; | |
320 | ||
321 | /* If needed, find and return the value of the register. */ | |
322 | if (bufferp != NULL) | |
323 | { | |
9c1412c1 AC |
324 | /* Return the actual value. */ |
325 | /* Use the regcache_cooked_read() method so that it, on the fly, | |
326 | constructs either a raw or pseudo register from the raw | |
327 | register cache. */ | |
8779790c | 328 | regcache_cooked_read (dummy->regcache, regnum, bufferp); |
9c1412c1 AC |
329 | } |
330 | } | |
331 | ||
f18c5a73 AC |
332 | CORE_ADDR |
333 | dummy_frame_pc_unwind (struct frame_info *frame, | |
334 | void **cache) | |
335 | { | |
336 | struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); | |
337 | /* Oops! In a dummy-frame but can't find the stack dummy. Pretend | |
338 | that the frame doesn't unwind. Should this function instead | |
339 | return a has-no-caller indication? */ | |
340 | if (dummy == NULL) | |
341 | return 0; | |
342 | return dummy->pc; | |
343 | } | |
344 |