Commit | Line | Data |
---|---|---|
d2427a71 RH |
1 | /* Target-dependent mdebug code for the ALPHA architecture. |
2 | Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 | |
3 | Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, Inc., 59 Temple Place - Suite 330, | |
20 | Boston, MA 02111-1307, USA. */ | |
21 | ||
22 | #include "defs.h" | |
23 | #include "frame.h" | |
24 | #include "frame-unwind.h" | |
25 | #include "frame-base.h" | |
26 | #include "inferior.h" | |
27 | #include "symtab.h" | |
28 | #include "value.h" | |
29 | #include "gdbcmd.h" | |
30 | #include "gdbcore.h" | |
31 | #include "dis-asm.h" | |
32 | #include "symfile.h" | |
33 | #include "objfiles.h" | |
34 | #include "gdb_string.h" | |
35 | #include "linespec.h" | |
36 | #include "regcache.h" | |
37 | #include "doublest.h" | |
38 | #include "arch-utils.h" | |
39 | #include "osabi.h" | |
40 | #include "block.h" | |
41 | #include "gdb_assert.h" | |
42 | ||
43 | #include "elf-bfd.h" | |
44 | ||
45 | #include "alpha-tdep.h" | |
46 | ||
47 | /* FIXME: Some of this code should perhaps be merged with mips. */ | |
48 | ||
49 | /* *INDENT-OFF* */ | |
50 | /* Layout of a stack frame on the alpha: | |
51 | ||
52 | | | | |
53 | pdr members: | 7th ... nth arg, | | |
54 | | `pushed' by caller. | | |
55 | | | | |
56 | ----------------|-------------------------------|<-- old_sp == vfp | |
57 | ^ ^ ^ ^ | | | |
58 | | | | | | | | |
59 | | |localoff | Copies of 1st .. 6th | | |
60 | | | | | | argument if necessary. | | |
61 | | | | v | | | |
62 | | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS | |
63 | | | | | | | |
64 | | | | | Locals and temporaries. | | |
65 | | | | | | | |
66 | | | | |-------------------------------| | |
67 | | | | | | | |
68 | |-fregoffset | Saved float registers. | | |
69 | | | | | F9 | | |
70 | | | | | . | | |
71 | | | | | . | | |
72 | | | | | F2 | | |
73 | | | v | | | |
74 | | | -------|-------------------------------| | |
75 | | | | | | |
76 | | | | Saved registers. | | |
77 | | | | S6 | | |
78 | |-regoffset | . | | |
79 | | | | . | | |
80 | | | | S0 | | |
81 | | | | pdr.pcreg | | |
82 | | v | | | |
83 | | ----------|-------------------------------| | |
84 | | | | | |
85 | frameoffset | Argument build area, gets | | |
86 | | | 7th ... nth arg for any | | |
87 | | | called procedure. | | |
88 | v | | | |
89 | -------------|-------------------------------|<-- sp | |
90 | | | | |
91 | */ | |
92 | /* *INDENT-ON* */ | |
93 | ||
94 | #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) | |
95 | #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset) | |
96 | #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg) | |
97 | #define PROC_REG_MASK(proc) ((proc)->pdr.regmask) | |
98 | #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask) | |
99 | #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset) | |
100 | #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset) | |
101 | #define PROC_PC_REG(proc) ((proc)->pdr.pcreg) | |
102 | #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff) | |
103 | \f | |
104 | /* Locate the mdebug PDR for the given PC. Return null if one can't | |
105 | be found; you'll have to fall back to other methods in that case. */ | |
106 | ||
107 | static alpha_extra_func_info_t | |
108 | find_proc_desc (CORE_ADDR pc) | |
109 | { | |
110 | struct block *b = block_for_pc (pc); | |
111 | alpha_extra_func_info_t proc_desc = NULL; | |
112 | struct symbol *sym = NULL; | |
113 | ||
114 | if (b) | |
115 | { | |
116 | CORE_ADDR startaddr; | |
117 | find_pc_partial_function (pc, NULL, &startaddr, NULL); | |
118 | ||
119 | if (startaddr > BLOCK_START (b)) | |
120 | /* This is the "pathological" case referred to in a comment in | |
121 | print_frame_info. It might be better to move this check into | |
122 | symbol reading. */ | |
123 | sym = NULL; | |
124 | else | |
125 | sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0, NULL); | |
126 | } | |
127 | ||
128 | if (sym) | |
129 | { | |
130 | proc_desc = (alpha_extra_func_info_t) SYMBOL_VALUE (sym); | |
131 | ||
132 | /* If we never found a PDR for this function in symbol reading, | |
133 | then examine prologues to find the information. */ | |
134 | if (proc_desc->pdr.framereg == -1) | |
135 | proc_desc = NULL; | |
136 | } | |
137 | ||
138 | return proc_desc; | |
139 | } | |
140 | ||
141 | /* This returns the PC of the first inst after the prologue. If we can't | |
142 | find the prologue, then return 0. */ | |
143 | ||
144 | static CORE_ADDR | |
145 | alpha_mdebug_after_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc) | |
146 | { | |
147 | if (proc_desc) | |
148 | { | |
149 | /* If function is frameless, then we need to do it the hard way. I | |
150 | strongly suspect that frameless always means prologueless... */ | |
151 | if (PROC_FRAME_REG (proc_desc) == SP_REGNUM | |
152 | && PROC_FRAME_OFFSET (proc_desc) == 0) | |
153 | return 0; | |
154 | } | |
155 | ||
156 | return alpha_after_prologue (pc); | |
157 | } | |
158 | ||
159 | /* Return non-zero if we *might* be in a function prologue. Return zero | |
160 | if we are definitively *not* in a function prologue. */ | |
161 | ||
162 | static int | |
163 | alpha_mdebug_in_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc) | |
164 | { | |
165 | CORE_ADDR after_prologue_pc = alpha_mdebug_after_prologue (pc, proc_desc); | |
166 | return (after_prologue_pc == 0 || pc < after_prologue_pc); | |
167 | } | |
168 | ||
169 | \f | |
170 | /* Frame unwinder that reads mdebug PDRs. */ | |
171 | ||
172 | struct alpha_mdebug_unwind_cache | |
173 | { | |
174 | alpha_extra_func_info_t proc_desc; | |
175 | CORE_ADDR vfp; | |
176 | CORE_ADDR *saved_regs; | |
d2427a71 RH |
177 | }; |
178 | ||
179 | /* Extract all of the information about the frame from PROC_DESC | |
180 | and store the resulting register save locations in the structure. */ | |
181 | ||
182 | static struct alpha_mdebug_unwind_cache * | |
183 | alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, | |
184 | void **this_prologue_cache) | |
185 | { | |
186 | struct alpha_mdebug_unwind_cache *info; | |
187 | alpha_extra_func_info_t proc_desc; | |
188 | ULONGEST vfp; | |
189 | CORE_ADDR pc, reg_position; | |
190 | unsigned long mask; | |
191 | int ireg, returnreg; | |
192 | ||
193 | if (*this_prologue_cache) | |
194 | return *this_prologue_cache; | |
195 | ||
196 | info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache); | |
197 | *this_prologue_cache = info; | |
198 | pc = frame_pc_unwind (next_frame); | |
199 | ||
200 | /* ??? We don't seem to be able to cache the lookup of the PDR | |
201 | from alpha_mdebug_frame_p. It'd be nice if we could change | |
202 | the arguments to that function. Oh well. */ | |
203 | proc_desc = find_proc_desc (pc); | |
204 | info->proc_desc = proc_desc; | |
205 | gdb_assert (proc_desc != NULL); | |
206 | ||
d2427a71 RH |
207 | info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS); |
208 | ||
209 | /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */ | |
210 | frame_unwind_unsigned_register (next_frame, PROC_FRAME_REG (proc_desc), &vfp); | |
211 | vfp += PROC_FRAME_OFFSET (info->proc_desc); | |
212 | info->vfp = vfp; | |
213 | ||
214 | /* Fill in the offsets for the registers which gen_mask says were saved. */ | |
215 | ||
216 | reg_position = vfp + PROC_REG_OFFSET (proc_desc); | |
217 | mask = PROC_REG_MASK (proc_desc); | |
218 | returnreg = PROC_PC_REG (proc_desc); | |
219 | ||
220 | /* Note that RA is always saved first, regardless of its actual | |
221 | register number. */ | |
222 | if (mask & (1 << returnreg)) | |
223 | { | |
224 | /* Clear bit for RA so we don't save it again later. */ | |
225 | mask &= ~(1 << returnreg); | |
226 | ||
227 | info->saved_regs[returnreg] = reg_position; | |
228 | reg_position += 8; | |
229 | } | |
230 | ||
231 | for (ireg = 0; ireg <= 31; ++ireg) | |
232 | if (mask & (1 << ireg)) | |
233 | { | |
234 | info->saved_regs[ireg] = reg_position; | |
235 | reg_position += 8; | |
236 | } | |
237 | ||
238 | reg_position = vfp + PROC_FREG_OFFSET (proc_desc); | |
239 | mask = PROC_FREG_MASK (proc_desc); | |
240 | ||
241 | for (ireg = 0; ireg <= 31; ++ireg) | |
242 | if (mask & (1 << ireg)) | |
243 | { | |
244 | info->saved_regs[FP0_REGNUM + ireg] = reg_position; | |
245 | reg_position += 8; | |
246 | } | |
247 | ||
248 | return info; | |
249 | } | |
250 | ||
251 | /* Given a GDB frame, determine the address of the calling function's | |
252 | frame. This will be used to create a new GDB frame struct. */ | |
253 | ||
254 | static void | |
255 | alpha_mdebug_frame_this_id (struct frame_info *next_frame, | |
256 | void **this_prologue_cache, | |
257 | struct frame_id *this_id) | |
258 | { | |
259 | struct alpha_mdebug_unwind_cache *info | |
260 | = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); | |
261 | ||
fbe586ae | 262 | *this_id = frame_id_build (info->vfp, frame_func_unwind (next_frame)); |
d2427a71 RH |
263 | } |
264 | ||
265 | /* Retrieve the value of REGNUM in FRAME. Don't give up! */ | |
266 | ||
267 | static void | |
268 | alpha_mdebug_frame_prev_register (struct frame_info *next_frame, | |
269 | void **this_prologue_cache, | |
270 | int regnum, int *optimizedp, | |
271 | enum lval_type *lvalp, CORE_ADDR *addrp, | |
272 | int *realnump, void *bufferp) | |
273 | { | |
274 | struct alpha_mdebug_unwind_cache *info | |
275 | = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); | |
276 | ||
d2427a71 RH |
277 | /* The PC of the previous frame is stored in the link register of |
278 | the current frame. Frob regnum so that we pull the value from | |
279 | the correct place. */ | |
280 | if (regnum == PC_REGNUM) | |
281 | regnum = PROC_PC_REG (info->proc_desc); | |
282 | ||
283 | /* For all registers known to be saved in the current frame, | |
284 | do the obvious and pull the value out. */ | |
285 | if (info->saved_regs[regnum]) | |
286 | { | |
287 | *optimizedp = 0; | |
288 | *lvalp = lval_memory; | |
289 | *addrp = info->saved_regs[regnum]; | |
290 | *realnump = -1; | |
291 | if (bufferp != NULL) | |
292 | read_memory (*addrp, bufferp, ALPHA_REGISTER_SIZE); | |
293 | return; | |
294 | } | |
295 | ||
296 | /* The stack pointer of the previous frame is computed by popping | |
297 | the current stack frame. */ | |
298 | if (regnum == SP_REGNUM) | |
299 | { | |
300 | *optimizedp = 0; | |
301 | *lvalp = not_lval; | |
302 | *addrp = 0; | |
303 | *realnump = -1; | |
304 | if (bufferp != NULL) | |
305 | store_unsigned_integer (bufferp, ALPHA_REGISTER_SIZE, info->vfp); | |
306 | return; | |
307 | } | |
308 | ||
309 | /* Otherwise assume the next frame has the same register value. */ | |
310 | frame_register (next_frame, regnum, optimizedp, lvalp, addrp, | |
311 | realnump, bufferp); | |
312 | } | |
313 | ||
314 | static const struct frame_unwind alpha_mdebug_frame_unwind = { | |
315 | NORMAL_FRAME, | |
316 | alpha_mdebug_frame_this_id, | |
317 | alpha_mdebug_frame_prev_register | |
318 | }; | |
319 | ||
320 | const struct frame_unwind * | |
321 | alpha_mdebug_frame_p (CORE_ADDR pc) | |
322 | { | |
323 | alpha_extra_func_info_t proc_desc; | |
324 | ||
325 | /* If this PC does not map to a PDR, then clearly this isn't an | |
326 | mdebug frame. */ | |
327 | proc_desc = find_proc_desc (pc); | |
328 | if (proc_desc == NULL) | |
329 | return NULL; | |
330 | ||
fbe586ae RH |
331 | /* If we're in the prologue, the PDR for this frame is not yet valid. |
332 | Say no here and we'll fall back on the heuristic unwinder. */ | |
333 | if (alpha_mdebug_in_prologue (pc, proc_desc)) | |
334 | return NULL; | |
335 | ||
d2427a71 RH |
336 | return &alpha_mdebug_frame_unwind; |
337 | } | |
338 | ||
339 | static CORE_ADDR | |
340 | alpha_mdebug_frame_base_address (struct frame_info *next_frame, | |
341 | void **this_prologue_cache) | |
342 | { | |
343 | struct alpha_mdebug_unwind_cache *info | |
344 | = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); | |
345 | ||
fbe586ae | 346 | return info->vfp; |
d2427a71 RH |
347 | } |
348 | ||
349 | static CORE_ADDR | |
350 | alpha_mdebug_frame_locals_address (struct frame_info *next_frame, | |
351 | void **this_prologue_cache) | |
352 | { | |
353 | struct alpha_mdebug_unwind_cache *info | |
354 | = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); | |
d2427a71 | 355 | |
fbe586ae | 356 | return info->vfp - PROC_LOCALOFF (info->proc_desc); |
d2427a71 RH |
357 | } |
358 | ||
359 | static CORE_ADDR | |
360 | alpha_mdebug_frame_args_address (struct frame_info *next_frame, | |
361 | void **this_prologue_cache) | |
362 | { | |
363 | struct alpha_mdebug_unwind_cache *info | |
364 | = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); | |
d2427a71 | 365 | |
fbe586ae | 366 | return info->vfp - ALPHA_NUM_ARG_REGS * 8; |
d2427a71 RH |
367 | } |
368 | ||
369 | static const struct frame_base alpha_mdebug_frame_base = { | |
370 | &alpha_mdebug_frame_unwind, | |
371 | alpha_mdebug_frame_base_address, | |
372 | alpha_mdebug_frame_locals_address, | |
373 | alpha_mdebug_frame_args_address | |
374 | }; | |
375 | ||
376 | static const struct frame_base * | |
377 | alpha_mdebug_frame_base_p (CORE_ADDR pc) | |
378 | { | |
379 | alpha_extra_func_info_t proc_desc; | |
380 | ||
381 | /* If this PC does not map to a PDR, then clearly this isn't an | |
382 | mdebug frame. */ | |
383 | proc_desc = find_proc_desc (pc); | |
384 | if (proc_desc == NULL) | |
385 | return NULL; | |
386 | ||
387 | return &alpha_mdebug_frame_base; | |
388 | } | |
389 | ||
390 | \f | |
391 | void | |
392 | alpha_mdebug_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
393 | { | |
394 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
395 | ||
396 | frame_unwind_append_predicate (gdbarch, alpha_mdebug_frame_p); | |
397 | frame_base_append_predicate (gdbarch, alpha_mdebug_frame_base_p); | |
398 | } |