*** empty log message ***
[deliverable/binutils-gdb.git] / gdb / alpha-mdebug-tdep.c
1 /* Target-dependent mdebug code for the ALPHA architecture.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2007, 2008, 2009, 2010, 2011 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 3 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, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "frame.h"
22 #include "frame-unwind.h"
23 #include "frame-base.h"
24 #include "symtab.h"
25 #include "gdbcore.h"
26 #include "block.h"
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include "trad-frame.h"
30
31 #include "alpha-tdep.h"
32 #include "mdebugread.h"
33
34 /* FIXME: Some of this code should perhaps be merged with mips. */
35
36 /* *INDENT-OFF* */
37 /* Layout of a stack frame on the alpha:
38
39 | |
40 pdr members: | 7th ... nth arg, |
41 | `pushed' by caller. |
42 | |
43 ----------------|-------------------------------|<-- old_sp == vfp
44 ^ ^ ^ ^ | |
45 | | | | | |
46 | |localoff | Copies of 1st .. 6th |
47 | | | | | argument if necessary. |
48 | | | v | |
49 | | | --- |-------------------------------|<-- LOCALS_ADDRESS
50 | | | | |
51 | | | | Locals and temporaries. |
52 | | | | |
53 | | | |-------------------------------|
54 | | | | |
55 |-fregoffset | Saved float registers. |
56 | | | | F9 |
57 | | | | . |
58 | | | | . |
59 | | | | F2 |
60 | | v | |
61 | | -------|-------------------------------|
62 | | | |
63 | | | Saved registers. |
64 | | | S6 |
65 |-regoffset | . |
66 | | | . |
67 | | | S0 |
68 | | | pdr.pcreg |
69 | v | |
70 | ----------|-------------------------------|
71 | | |
72 frameoffset | Argument build area, gets |
73 | | 7th ... nth arg for any |
74 | | called procedure. |
75 v | |
76 -------------|-------------------------------|<-- sp
77 | |
78 */
79 /* *INDENT-ON* */
80
81 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)
82 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
83 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
84 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
85 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
86 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
87 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
88 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
89 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
90 \f
91 /* Locate the mdebug PDR for the given PC. Return null if one can't
92 be found; you'll have to fall back to other methods in that case. */
93
94 static struct mdebug_extra_func_info *
95 find_proc_desc (CORE_ADDR pc)
96 {
97 struct block *b = block_for_pc (pc);
98 struct mdebug_extra_func_info *proc_desc = NULL;
99 struct symbol *sym = NULL;
100 char *sh_name = NULL;
101
102 if (b)
103 {
104 CORE_ADDR startaddr;
105 find_pc_partial_function (pc, &sh_name, &startaddr, NULL);
106
107 if (startaddr > BLOCK_START (b))
108 /* This is the "pathological" case referred to in a comment in
109 print_frame_info. It might be better to move this check into
110 symbol reading. */
111 sym = NULL;
112 else
113 sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0);
114 }
115
116 if (sym)
117 {
118 proc_desc = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (sym);
119
120 /* Correct incorrect setjmp procedure descriptor from the library
121 to make backtrace through setjmp work. */
122 if (proc_desc->pdr.pcreg == 0
123 && strcmp (sh_name, "setjmp") == 0)
124 {
125 proc_desc->pdr.pcreg = ALPHA_RA_REGNUM;
126 proc_desc->pdr.regmask = 0x80000000;
127 proc_desc->pdr.regoffset = -4;
128 }
129
130 /* If we never found a PDR for this function in symbol reading,
131 then examine prologues to find the information. */
132 if (proc_desc->pdr.framereg == -1)
133 proc_desc = NULL;
134 }
135
136 return proc_desc;
137 }
138
139 /* Return a non-zero result if the function is frameless; zero otherwise. */
140
141 static int
142 alpha_mdebug_frameless (struct mdebug_extra_func_info *proc_desc)
143 {
144 return (PROC_FRAME_REG (proc_desc) == ALPHA_SP_REGNUM
145 && PROC_FRAME_OFFSET (proc_desc) == 0);
146 }
147
148 /* This returns the PC of the first inst after the prologue. If we can't
149 find the prologue, then return 0. */
150
151 static CORE_ADDR
152 alpha_mdebug_after_prologue (CORE_ADDR pc,
153 struct mdebug_extra_func_info *proc_desc)
154 {
155 if (proc_desc)
156 {
157 /* If function is frameless, then we need to do it the hard way. I
158 strongly suspect that frameless always means prologueless... */
159 if (alpha_mdebug_frameless (proc_desc))
160 return 0;
161 }
162
163 return alpha_after_prologue (pc);
164 }
165
166 /* Return non-zero if we *might* be in a function prologue. Return zero
167 if we are definitively *not* in a function prologue. */
168
169 static int
170 alpha_mdebug_in_prologue (CORE_ADDR pc,
171 struct mdebug_extra_func_info *proc_desc)
172 {
173 CORE_ADDR after_prologue_pc = alpha_mdebug_after_prologue (pc, proc_desc);
174 return (after_prologue_pc == 0 || pc < after_prologue_pc);
175 }
176
177 \f
178 /* Frame unwinder that reads mdebug PDRs. */
179
180 struct alpha_mdebug_unwind_cache
181 {
182 struct mdebug_extra_func_info *proc_desc;
183 CORE_ADDR vfp;
184 struct trad_frame_saved_reg *saved_regs;
185 };
186
187 /* Extract all of the information about the frame from PROC_DESC
188 and store the resulting register save locations in the structure. */
189
190 static struct alpha_mdebug_unwind_cache *
191 alpha_mdebug_frame_unwind_cache (struct frame_info *this_frame,
192 void **this_prologue_cache)
193 {
194 struct alpha_mdebug_unwind_cache *info;
195 struct mdebug_extra_func_info *proc_desc;
196 ULONGEST vfp;
197 CORE_ADDR pc, reg_position;
198 unsigned long mask;
199 int ireg, returnreg;
200
201 if (*this_prologue_cache)
202 return *this_prologue_cache;
203
204 info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache);
205 *this_prologue_cache = info;
206 pc = get_frame_address_in_block (this_frame);
207
208 /* ??? We don't seem to be able to cache the lookup of the PDR
209 from alpha_mdebug_frame_p. It'd be nice if we could change
210 the arguments to that function. Oh well. */
211 proc_desc = find_proc_desc (pc);
212 info->proc_desc = proc_desc;
213 gdb_assert (proc_desc != NULL);
214
215 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
216
217 /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */
218 vfp = get_frame_register_unsigned (this_frame, PROC_FRAME_REG (proc_desc));
219 vfp += PROC_FRAME_OFFSET (info->proc_desc);
220 info->vfp = vfp;
221
222 /* Fill in the offsets for the registers which gen_mask says were saved. */
223
224 reg_position = vfp + PROC_REG_OFFSET (proc_desc);
225 mask = PROC_REG_MASK (proc_desc);
226 returnreg = PROC_PC_REG (proc_desc);
227
228 /* Note that RA is always saved first, regardless of its actual
229 register number. */
230 if (mask & (1 << returnreg))
231 {
232 /* Clear bit for RA so we don't save it again later. */
233 mask &= ~(1 << returnreg);
234
235 info->saved_regs[returnreg].addr = reg_position;
236 reg_position += 8;
237 }
238
239 for (ireg = 0; ireg <= 31; ++ireg)
240 if (mask & (1 << ireg))
241 {
242 info->saved_regs[ireg].addr = reg_position;
243 reg_position += 8;
244 }
245
246 reg_position = vfp + PROC_FREG_OFFSET (proc_desc);
247 mask = PROC_FREG_MASK (proc_desc);
248
249 for (ireg = 0; ireg <= 31; ++ireg)
250 if (mask & (1 << ireg))
251 {
252 info->saved_regs[ALPHA_FP0_REGNUM + ireg].addr = reg_position;
253 reg_position += 8;
254 }
255
256 /* The stack pointer of the previous frame is computed by popping
257 the current stack frame. */
258 if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
259 trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, vfp);
260
261 return info;
262 }
263
264 /* Given a GDB frame, determine the address of the calling function's
265 frame. This will be used to create a new GDB frame struct. */
266
267 static void
268 alpha_mdebug_frame_this_id (struct frame_info *this_frame,
269 void **this_prologue_cache,
270 struct frame_id *this_id)
271 {
272 struct alpha_mdebug_unwind_cache *info
273 = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
274
275 *this_id = frame_id_build (info->vfp, get_frame_func (this_frame));
276 }
277
278 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
279
280 static struct value *
281 alpha_mdebug_frame_prev_register (struct frame_info *this_frame,
282 void **this_prologue_cache, int regnum)
283 {
284 struct alpha_mdebug_unwind_cache *info
285 = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
286
287 /* The PC of the previous frame is stored in the link register of
288 the current frame. Frob regnum so that we pull the value from
289 the correct place. */
290 if (regnum == ALPHA_PC_REGNUM)
291 regnum = PROC_PC_REG (info->proc_desc);
292
293 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
294 }
295
296 /* Return a non-zero result if the size of the stack frame exceeds the
297 maximum debuggable frame size (512 Kbytes); zero otherwise. */
298
299 static int
300 alpha_mdebug_max_frame_size_exceeded (struct mdebug_extra_func_info *proc_desc)
301 {
302 /* If frame offset is null, we can be in two cases: either the
303 function is frameless (the stack frame is null) or its
304 frame exceeds the maximum debuggable frame size (512 Kbytes). */
305
306 return (PROC_FRAME_OFFSET (proc_desc) == 0
307 && !alpha_mdebug_frameless (proc_desc));
308 }
309
310 static int
311 alpha_mdebug_frame_sniffer (const struct frame_unwind *self,
312 struct frame_info *this_frame,
313 void **this_cache)
314 {
315 CORE_ADDR pc = get_frame_address_in_block (this_frame);
316 struct mdebug_extra_func_info *proc_desc;
317
318 /* If this PC does not map to a PDR, then clearly this isn't an
319 mdebug frame. */
320 proc_desc = find_proc_desc (pc);
321 if (proc_desc == NULL)
322 return 0;
323
324 /* If we're in the prologue, the PDR for this frame is not yet valid.
325 Say no here and we'll fall back on the heuristic unwinder. */
326 if (alpha_mdebug_in_prologue (pc, proc_desc))
327 return 0;
328
329 /* If the maximum debuggable frame size has been exceeded, the
330 proc desc is bogus. Fall back on the heuristic unwinder. */
331 if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
332 return 0;
333
334 return 1;
335 }
336
337 static const struct frame_unwind alpha_mdebug_frame_unwind = {
338 NORMAL_FRAME,
339 alpha_mdebug_frame_this_id,
340 alpha_mdebug_frame_prev_register,
341 NULL,
342 alpha_mdebug_frame_sniffer
343 };
344
345 static CORE_ADDR
346 alpha_mdebug_frame_base_address (struct frame_info *this_frame,
347 void **this_prologue_cache)
348 {
349 struct alpha_mdebug_unwind_cache *info
350 = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
351
352 return info->vfp;
353 }
354
355 static CORE_ADDR
356 alpha_mdebug_frame_locals_address (struct frame_info *this_frame,
357 void **this_prologue_cache)
358 {
359 struct alpha_mdebug_unwind_cache *info
360 = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
361
362 return info->vfp - PROC_LOCALOFF (info->proc_desc);
363 }
364
365 static CORE_ADDR
366 alpha_mdebug_frame_args_address (struct frame_info *this_frame,
367 void **this_prologue_cache)
368 {
369 struct alpha_mdebug_unwind_cache *info
370 = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
371
372 return info->vfp - ALPHA_NUM_ARG_REGS * 8;
373 }
374
375 static const struct frame_base alpha_mdebug_frame_base = {
376 &alpha_mdebug_frame_unwind,
377 alpha_mdebug_frame_base_address,
378 alpha_mdebug_frame_locals_address,
379 alpha_mdebug_frame_args_address
380 };
381
382 static const struct frame_base *
383 alpha_mdebug_frame_base_sniffer (struct frame_info *this_frame)
384 {
385 CORE_ADDR pc = get_frame_address_in_block (this_frame);
386 struct mdebug_extra_func_info *proc_desc;
387
388 /* If this PC does not map to a PDR, then clearly this isn't an
389 mdebug frame. */
390 proc_desc = find_proc_desc (pc);
391 if (proc_desc == NULL)
392 return NULL;
393
394 /* If the maximum debuggable frame size has been exceeded, the
395 proc desc is bogus. Fall back on the heuristic unwinder. */
396 if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
397 return 0;
398
399 return &alpha_mdebug_frame_base;
400 }
401
402 \f
403 void
404 alpha_mdebug_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
405 {
406 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
407
408 frame_unwind_append_unwinder (gdbarch, &alpha_mdebug_frame_unwind);
409 frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer);
410 }
This page took 0.054832 seconds and 4 git commands to generate.