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.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "frame-unwind.h"
23 #include "frame-base.h"
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include "trad-frame.h"
31 #include "alpha-tdep.h"
32 #include "mdebugread.h"
34 /* FIXME: Some of this code should perhaps be merged with mips. */
37 /* Layout of a stack frame on the alpha:
40 pdr members: | 7th ... nth arg, |
41 | `pushed' by caller. |
43 ----------------|-------------------------------|<-- old_sp == vfp
46 | |localoff | Copies of 1st .. 6th |
47 | | | | | argument if necessary. |
49 | | | --- |-------------------------------|<-- LOCALS_ADDRESS
51 | | | | Locals and temporaries. |
53 | | | |-------------------------------|
55 |-fregoffset | Saved float registers. |
61 | | -------|-------------------------------|
63 | | | Saved registers. |
70 | ----------|-------------------------------|
72 frameoffset | Argument build area, gets |
73 | | 7th ... nth arg for any |
74 | | called procedure. |
76 -------------|-------------------------------|<-- sp
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)
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. */
94 static struct mdebug_extra_func_info
*
95 find_proc_desc (CORE_ADDR pc
)
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
;
105 find_pc_partial_function (pc
, &sh_name
, &startaddr
, NULL
);
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
113 sym
= lookup_symbol (MDEBUG_EFI_SYMBOL_NAME
, b
, LABEL_DOMAIN
, 0);
118 proc_desc
= (struct mdebug_extra_func_info
*) SYMBOL_VALUE_BYTES (sym
);
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)
125 proc_desc
->pdr
.pcreg
= ALPHA_RA_REGNUM
;
126 proc_desc
->pdr
.regmask
= 0x80000000;
127 proc_desc
->pdr
.regoffset
= -4;
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)
139 /* Return a non-zero result if the function is frameless; zero otherwise. */
142 alpha_mdebug_frameless (struct mdebug_extra_func_info
*proc_desc
)
144 return (PROC_FRAME_REG (proc_desc
) == ALPHA_SP_REGNUM
145 && PROC_FRAME_OFFSET (proc_desc
) == 0);
148 /* This returns the PC of the first inst after the prologue. If we can't
149 find the prologue, then return 0. */
152 alpha_mdebug_after_prologue (CORE_ADDR pc
,
153 struct mdebug_extra_func_info
*proc_desc
)
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
))
163 return alpha_after_prologue (pc
);
166 /* Return non-zero if we *might* be in a function prologue. Return zero
167 if we are definitively *not* in a function prologue. */
170 alpha_mdebug_in_prologue (CORE_ADDR pc
,
171 struct mdebug_extra_func_info
*proc_desc
)
173 CORE_ADDR after_prologue_pc
= alpha_mdebug_after_prologue (pc
, proc_desc
);
174 return (after_prologue_pc
== 0 || pc
< after_prologue_pc
);
178 /* Frame unwinder that reads mdebug PDRs. */
180 struct alpha_mdebug_unwind_cache
182 struct mdebug_extra_func_info
*proc_desc
;
184 struct trad_frame_saved_reg
*saved_regs
;
187 /* Extract all of the information about the frame from PROC_DESC
188 and store the resulting register save locations in the structure. */
190 static struct alpha_mdebug_unwind_cache
*
191 alpha_mdebug_frame_unwind_cache (struct frame_info
*this_frame
,
192 void **this_prologue_cache
)
194 struct alpha_mdebug_unwind_cache
*info
;
195 struct mdebug_extra_func_info
*proc_desc
;
197 CORE_ADDR pc
, reg_position
;
201 if (*this_prologue_cache
)
202 return *this_prologue_cache
;
204 info
= FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache
);
205 *this_prologue_cache
= info
;
206 pc
= get_frame_address_in_block (this_frame
);
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
);
215 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
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
);
222 /* Fill in the offsets for the registers which gen_mask says were saved. */
224 reg_position
= vfp
+ PROC_REG_OFFSET (proc_desc
);
225 mask
= PROC_REG_MASK (proc_desc
);
226 returnreg
= PROC_PC_REG (proc_desc
);
228 /* Note that RA is always saved first, regardless of its actual
230 if (mask
& (1 << returnreg
))
232 /* Clear bit for RA so we don't save it again later. */
233 mask
&= ~(1 << returnreg
);
235 info
->saved_regs
[returnreg
].addr
= reg_position
;
239 for (ireg
= 0; ireg
<= 31; ++ireg
)
240 if (mask
& (1 << ireg
))
242 info
->saved_regs
[ireg
].addr
= reg_position
;
246 reg_position
= vfp
+ PROC_FREG_OFFSET (proc_desc
);
247 mask
= PROC_FREG_MASK (proc_desc
);
249 for (ireg
= 0; ireg
<= 31; ++ireg
)
250 if (mask
& (1 << ireg
))
252 info
->saved_regs
[ALPHA_FP0_REGNUM
+ ireg
].addr
= reg_position
;
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
);
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. */
268 alpha_mdebug_frame_this_id (struct frame_info
*this_frame
,
269 void **this_prologue_cache
,
270 struct frame_id
*this_id
)
272 struct alpha_mdebug_unwind_cache
*info
273 = alpha_mdebug_frame_unwind_cache (this_frame
, this_prologue_cache
);
275 *this_id
= frame_id_build (info
->vfp
, get_frame_func (this_frame
));
278 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
280 static struct value
*
281 alpha_mdebug_frame_prev_register (struct frame_info
*this_frame
,
282 void **this_prologue_cache
, int regnum
)
284 struct alpha_mdebug_unwind_cache
*info
285 = alpha_mdebug_frame_unwind_cache (this_frame
, this_prologue_cache
);
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
);
293 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
296 /* Return a non-zero result if the size of the stack frame exceeds the
297 maximum debuggable frame size (512 Kbytes); zero otherwise. */
300 alpha_mdebug_max_frame_size_exceeded (struct mdebug_extra_func_info
*proc_desc
)
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). */
306 return (PROC_FRAME_OFFSET (proc_desc
) == 0
307 && !alpha_mdebug_frameless (proc_desc
));
311 alpha_mdebug_frame_sniffer (const struct frame_unwind
*self
,
312 struct frame_info
*this_frame
,
315 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
316 struct mdebug_extra_func_info
*proc_desc
;
318 /* If this PC does not map to a PDR, then clearly this isn't an
320 proc_desc
= find_proc_desc (pc
);
321 if (proc_desc
== NULL
)
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
))
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
))
337 static const struct frame_unwind alpha_mdebug_frame_unwind
= {
339 alpha_mdebug_frame_this_id
,
340 alpha_mdebug_frame_prev_register
,
342 alpha_mdebug_frame_sniffer
346 alpha_mdebug_frame_base_address (struct frame_info
*this_frame
,
347 void **this_prologue_cache
)
349 struct alpha_mdebug_unwind_cache
*info
350 = alpha_mdebug_frame_unwind_cache (this_frame
, this_prologue_cache
);
356 alpha_mdebug_frame_locals_address (struct frame_info
*this_frame
,
357 void **this_prologue_cache
)
359 struct alpha_mdebug_unwind_cache
*info
360 = alpha_mdebug_frame_unwind_cache (this_frame
, this_prologue_cache
);
362 return info
->vfp
- PROC_LOCALOFF (info
->proc_desc
);
366 alpha_mdebug_frame_args_address (struct frame_info
*this_frame
,
367 void **this_prologue_cache
)
369 struct alpha_mdebug_unwind_cache
*info
370 = alpha_mdebug_frame_unwind_cache (this_frame
, this_prologue_cache
);
372 return info
->vfp
- ALPHA_NUM_ARG_REGS
* 8;
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
382 static const struct frame_base
*
383 alpha_mdebug_frame_base_sniffer (struct frame_info
*this_frame
)
385 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
386 struct mdebug_extra_func_info
*proc_desc
;
388 /* If this PC does not map to a PDR, then clearly this isn't an
390 proc_desc
= find_proc_desc (pc
);
391 if (proc_desc
== NULL
)
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
))
399 return &alpha_mdebug_frame_base
;
404 alpha_mdebug_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
406 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
408 frame_unwind_append_unwinder (gdbarch
, &alpha_mdebug_frame_unwind
);
409 frame_base_append_sniffer (gdbarch
, alpha_mdebug_frame_base_sniffer
);