]>
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 | |
59 | FP/SP. Unlike PC_IN_CALL_DUMMY, this function doesn't need to | |
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) | |
141 | { | |
142 | struct dummy_frame *dummyframe; | |
143 | for (dummyframe = dummy_frame_stack; | |
144 | dummyframe != NULL; | |
145 | dummyframe = dummyframe->next) | |
146 | { | |
147 | if ((pc >= dummyframe->call_lo) | |
148 | && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK)) | |
149 | return 1; | |
150 | } | |
151 | return 0; | |
152 | } | |
153 | ||
154 | /* Function: read_register_dummy | |
155 | Find a saved register from before GDB calls a function in the inferior */ | |
156 | ||
157 | CORE_ADDR | |
158 | deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno) | |
159 | { | |
160 | struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp); | |
161 | ||
162 | if (dummy_regs) | |
163 | { | |
164 | /* NOTE: cagney/2002-08-12: Replaced a call to | |
165 | regcache_raw_read_as_address() with a call to | |
166 | regcache_cooked_read_unsigned(). The old, ...as_address | |
167 | function was eventually calling extract_unsigned_integer (via | |
168 | extract_address) to unpack the registers value. The below is | |
169 | doing an unsigned extract so that it is functionally | |
170 | equivalent. The read needs to be cooked as, otherwise, it | |
171 | will never correctly return the value of a register in the | |
172 | [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range. */ | |
173 | ULONGEST val; | |
174 | regcache_cooked_read_unsigned (dummy_regs, regno, &val); | |
175 | return val; | |
176 | } | |
177 | else | |
178 | return 0; | |
179 | } | |
180 | ||
181 | /* Save all the registers on the dummy frame stack. Most ports save the | |
182 | registers on the target stack. This results in lots of unnecessary memory | |
183 | references, which are slow when debugging via a serial line. Instead, we | |
184 | save all the registers internally, and never write them to the stack. The | |
185 | registers get restored when the called function returns to the entry point, | |
186 | where a breakpoint is laying in wait. */ | |
187 | ||
188 | void | |
189 | generic_push_dummy_frame (void) | |
190 | { | |
191 | struct dummy_frame *dummy_frame; | |
192 | CORE_ADDR fp = (get_current_frame ())->frame; | |
193 | ||
194 | /* check to see if there are stale dummy frames, | |
195 | perhaps left over from when a longjump took us out of a | |
196 | function that was called by the debugger */ | |
197 | ||
198 | dummy_frame = dummy_frame_stack; | |
199 | while (dummy_frame) | |
200 | if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */ | |
201 | { | |
202 | dummy_frame_stack = dummy_frame->next; | |
203 | regcache_xfree (dummy_frame->regcache); | |
204 | xfree (dummy_frame); | |
205 | dummy_frame = dummy_frame_stack; | |
206 | } | |
207 | else | |
208 | dummy_frame = dummy_frame->next; | |
209 | ||
210 | dummy_frame = xmalloc (sizeof (struct dummy_frame)); | |
211 | dummy_frame->regcache = regcache_xmalloc (current_gdbarch); | |
212 | ||
213 | dummy_frame->pc = read_pc (); | |
214 | dummy_frame->sp = read_sp (); | |
215 | dummy_frame->top = 0; | |
216 | dummy_frame->fp = fp; | |
217 | regcache_cpy (dummy_frame->regcache, current_regcache); | |
218 | dummy_frame->next = dummy_frame_stack; | |
219 | dummy_frame_stack = dummy_frame; | |
220 | } | |
221 | ||
222 | void | |
223 | generic_save_dummy_frame_tos (CORE_ADDR sp) | |
224 | { | |
225 | dummy_frame_stack->top = sp; | |
226 | } | |
227 | ||
228 | /* Record the upper/lower bounds on the address of the call dummy. */ | |
229 | ||
230 | void | |
231 | generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi) | |
232 | { | |
233 | dummy_frame_stack->call_lo = lo; | |
234 | dummy_frame_stack->call_hi = hi; | |
235 | } | |
236 | ||
237 | /* Restore the machine state from either the saved dummy stack or a | |
238 | real stack frame. */ | |
239 | ||
240 | void | |
241 | generic_pop_current_frame (void (*popper) (struct frame_info * frame)) | |
242 | { | |
243 | struct frame_info *frame = get_current_frame (); | |
244 | ||
245 | if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame)) | |
246 | generic_pop_dummy_frame (); | |
247 | else | |
248 | (*popper) (frame); | |
249 | } | |
250 | ||
251 | /* Function: pop_dummy_frame | |
252 | Restore the machine state from a saved dummy stack frame. */ | |
253 | ||
254 | void | |
255 | generic_pop_dummy_frame (void) | |
256 | { | |
257 | struct dummy_frame *dummy_frame = dummy_frame_stack; | |
258 | ||
259 | /* FIXME: what if the first frame isn't the right one, eg.. | |
260 | because one call-by-hand function has done a longjmp into another one? */ | |
261 | ||
262 | if (!dummy_frame) | |
263 | error ("Can't pop dummy frame!"); | |
264 | dummy_frame_stack = dummy_frame->next; | |
265 | regcache_cpy (current_regcache, dummy_frame->regcache); | |
266 | flush_cached_frames (); | |
267 | ||
268 | regcache_xfree (dummy_frame->regcache); | |
269 | xfree (dummy_frame); | |
270 | } | |
271 | ||
272 | /* Function: fix_call_dummy | |
273 | Stub function. Generic dummy frames typically do not need to fix | |
274 | the frame being created */ | |
275 | ||
276 | void | |
277 | generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, | |
278 | struct value **args, struct type *type, int gcc_p) | |
279 | { | |
280 | return; | |
281 | } | |
282 | ||
283 | /* Given a call-dummy dummy-frame, return the registers. Here the | |
284 | register value is taken from the local copy of the register buffer. */ | |
285 | ||
286 | void | |
8779790c AC |
287 | dummy_frame_register_unwind (struct frame_info *frame, void **cache, |
288 | int regnum, int *optimized, | |
289 | enum lval_type *lvalp, CORE_ADDR *addrp, | |
290 | int *realnum, void *bufferp) | |
9c1412c1 | 291 | { |
8779790c AC |
292 | struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); |
293 | gdb_assert (dummy != NULL); | |
9c1412c1 AC |
294 | |
295 | /* Describe the register's location. Generic dummy frames always | |
296 | have the register value in an ``expression''. */ | |
297 | *optimized = 0; | |
298 | *lvalp = not_lval; | |
299 | *addrp = 0; | |
300 | *realnum = -1; | |
301 | ||
302 | /* If needed, find and return the value of the register. */ | |
303 | if (bufferp != NULL) | |
304 | { | |
9c1412c1 AC |
305 | /* Return the actual value. */ |
306 | /* Use the regcache_cooked_read() method so that it, on the fly, | |
307 | constructs either a raw or pseudo register from the raw | |
308 | register cache. */ | |
8779790c | 309 | regcache_cooked_read (dummy->regcache, regnum, bufferp); |
9c1412c1 AC |
310 | } |
311 | } | |
312 | ||
f18c5a73 AC |
313 | CORE_ADDR |
314 | dummy_frame_pc_unwind (struct frame_info *frame, | |
315 | void **cache) | |
316 | { | |
317 | struct dummy_frame *dummy = cached_find_dummy_frame (frame, cache); | |
318 | /* Oops! In a dummy-frame but can't find the stack dummy. Pretend | |
319 | that the frame doesn't unwind. Should this function instead | |
320 | return a has-no-caller indication? */ | |
321 | if (dummy == NULL) | |
322 | return 0; | |
323 | return dummy->pc; | |
324 | } | |
325 |