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 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"
30 #include "alpha-tdep.h"
31 #include "mdebugread.h"
33 /* FIXME: Some of this code should perhaps be merged with mips. */
36 /* Layout of a stack frame on the alpha:
39 pdr members: | 7th ... nth arg, |
40 | `pushed' by caller. |
42 ----------------|-------------------------------|<-- old_sp == vfp
45 | |localoff | Copies of 1st .. 6th |
46 | | | | | argument if necessary. |
48 | | | --- |-------------------------------|<-- LOCALS_ADDRESS
50 | | | | Locals and temporaries. |
52 | | | |-------------------------------|
54 |-fregoffset | Saved float registers. |
60 | | -------|-------------------------------|
62 | | | Saved registers. |
69 | ----------|-------------------------------|
71 frameoffset | Argument build area, gets |
72 | | 7th ... nth arg for any |
73 | | called procedure. |
75 -------------|-------------------------------|<-- sp
80 #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)
81 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
82 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
83 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
84 #define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
85 #define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
86 #define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
87 #define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
88 #define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
90 /* Locate the mdebug PDR for the given PC. Return null if one can't
91 be found; you'll have to fall back to other methods in that case. */
93 static struct mdebug_extra_func_info *
94 find_proc_desc (CORE_ADDR pc)
96 struct block *b = block_for_pc (pc);
97 struct mdebug_extra_func_info *proc_desc = NULL;
98 struct symbol *sym = NULL;
104 find_pc_partial_function (pc, &sh_name, &startaddr, NULL);
106 if (startaddr > BLOCK_START (b))
107 /* This is the "pathological" case referred to in a comment in
108 print_frame_info. It might be better to move this check into
112 sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0, NULL);
117 proc_desc = (struct mdebug_extra_func_info *) SYMBOL_VALUE (sym);
119 /* Correct incorrect setjmp procedure descriptor from the library
120 to make backtrace through setjmp work. */
121 if (proc_desc->pdr.pcreg == 0
122 && strcmp (sh_name, "setjmp") == 0)
124 proc_desc->pdr.pcreg = ALPHA_RA_REGNUM;
125 proc_desc->pdr.regmask = 0x80000000;
126 proc_desc->pdr.regoffset = -4;
129 /* If we never found a PDR for this function in symbol reading,
130 then examine prologues to find the information. */
131 if (proc_desc->pdr.framereg == -1)
138 /* This returns the PC of the first inst after the prologue. If we can't
139 find the prologue, then return 0. */
142 alpha_mdebug_after_prologue (CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
146 /* If function is frameless, then we need to do it the hard way. I
147 strongly suspect that frameless always means prologueless... */
148 if (PROC_FRAME_REG (proc_desc) == ALPHA_SP_REGNUM
149 && PROC_FRAME_OFFSET (proc_desc) == 0)
153 return alpha_after_prologue (pc);
156 /* Return non-zero if we *might* be in a function prologue. Return zero
157 if we are definitively *not* in a function prologue. */
160 alpha_mdebug_in_prologue (CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
162 CORE_ADDR after_prologue_pc = alpha_mdebug_after_prologue (pc, proc_desc);
163 return (after_prologue_pc == 0 || pc < after_prologue_pc);
167 /* Frame unwinder that reads mdebug PDRs. */
169 struct alpha_mdebug_unwind_cache
171 struct mdebug_extra_func_info *proc_desc;
173 CORE_ADDR *saved_regs;
176 /* Extract all of the information about the frame from PROC_DESC
177 and store the resulting register save locations in the structure. */
179 static struct alpha_mdebug_unwind_cache *
180 alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame,
181 void **this_prologue_cache)
183 struct alpha_mdebug_unwind_cache *info;
184 struct mdebug_extra_func_info *proc_desc;
186 CORE_ADDR pc, reg_position;
190 if (*this_prologue_cache)
191 return *this_prologue_cache;
193 info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache);
194 *this_prologue_cache = info;
195 pc = frame_pc_unwind (next_frame);
197 /* ??? We don't seem to be able to cache the lookup of the PDR
198 from alpha_mdebug_frame_p. It'd be nice if we could change
199 the arguments to that function. Oh well. */
200 proc_desc = find_proc_desc (pc);
201 info->proc_desc = proc_desc;
202 gdb_assert (proc_desc != NULL);
204 info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
206 /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */
207 vfp = frame_unwind_register_unsigned (next_frame, PROC_FRAME_REG (proc_desc));
208 vfp += PROC_FRAME_OFFSET (info->proc_desc);
211 /* Fill in the offsets for the registers which gen_mask says were saved. */
213 reg_position = vfp + PROC_REG_OFFSET (proc_desc);
214 mask = PROC_REG_MASK (proc_desc);
215 returnreg = PROC_PC_REG (proc_desc);
217 /* Note that RA is always saved first, regardless of its actual
219 if (mask & (1 << returnreg))
221 /* Clear bit for RA so we don't save it again later. */
222 mask &= ~(1 << returnreg);
224 info->saved_regs[returnreg] = reg_position;
228 for (ireg = 0; ireg <= 31; ++ireg)
229 if (mask & (1 << ireg))
231 info->saved_regs[ireg] = reg_position;
235 reg_position = vfp + PROC_FREG_OFFSET (proc_desc);
236 mask = PROC_FREG_MASK (proc_desc);
238 for (ireg = 0; ireg <= 31; ++ireg)
239 if (mask & (1 << ireg))
241 info->saved_regs[ALPHA_FP0_REGNUM + ireg] = reg_position;
248 /* Given a GDB frame, determine the address of the calling function's
249 frame. This will be used to create a new GDB frame struct. */
252 alpha_mdebug_frame_this_id (struct frame_info *next_frame,
253 void **this_prologue_cache,
254 struct frame_id *this_id)
256 struct alpha_mdebug_unwind_cache *info
257 = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
259 *this_id = frame_id_build (info->vfp,
260 frame_func_unwind (next_frame, NORMAL_FRAME));
263 /* Retrieve the value of REGNUM in FRAME. Don't give up! */
266 alpha_mdebug_frame_prev_register (struct frame_info *next_frame,
267 void **this_prologue_cache,
268 int regnum, int *optimizedp,
269 enum lval_type *lvalp, CORE_ADDR *addrp,
270 int *realnump, gdb_byte *bufferp)
272 struct alpha_mdebug_unwind_cache *info
273 = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
275 /* The PC of the previous frame is stored in the link register of
276 the current frame. Frob regnum so that we pull the value from
277 the correct place. */
278 if (regnum == ALPHA_PC_REGNUM)
279 regnum = PROC_PC_REG (info->proc_desc);
281 /* For all registers known to be saved in the current frame,
282 do the obvious and pull the value out. */
283 if (info->saved_regs[regnum])
286 *lvalp = lval_memory;
287 *addrp = info->saved_regs[regnum];
290 get_frame_memory (next_frame, *addrp, bufferp, ALPHA_REGISTER_SIZE);
294 /* The stack pointer of the previous frame is computed by popping
295 the current stack frame. */
296 if (regnum == ALPHA_SP_REGNUM)
303 store_unsigned_integer (bufferp, ALPHA_REGISTER_SIZE, info->vfp);
307 /* Otherwise assume the next frame has the same register value. */
309 *lvalp = lval_register;
313 frame_unwind_register (next_frame, *realnump, bufferp);
316 static const struct frame_unwind alpha_mdebug_frame_unwind = {
318 alpha_mdebug_frame_this_id,
319 alpha_mdebug_frame_prev_register
322 const struct frame_unwind *
323 alpha_mdebug_frame_sniffer (struct frame_info *next_frame)
325 CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
326 struct mdebug_extra_func_info *proc_desc;
328 /* If this PC does not map to a PDR, then clearly this isn't an
330 proc_desc = find_proc_desc (pc);
331 if (proc_desc == NULL)
334 /* If we're in the prologue, the PDR for this frame is not yet valid.
335 Say no here and we'll fall back on the heuristic unwinder. */
336 if (alpha_mdebug_in_prologue (pc, proc_desc))
339 return &alpha_mdebug_frame_unwind;
343 alpha_mdebug_frame_base_address (struct frame_info *next_frame,
344 void **this_prologue_cache)
346 struct alpha_mdebug_unwind_cache *info
347 = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
353 alpha_mdebug_frame_locals_address (struct frame_info *next_frame,
354 void **this_prologue_cache)
356 struct alpha_mdebug_unwind_cache *info
357 = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
359 return info->vfp - PROC_LOCALOFF (info->proc_desc);
363 alpha_mdebug_frame_args_address (struct frame_info *next_frame,
364 void **this_prologue_cache)
366 struct alpha_mdebug_unwind_cache *info
367 = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
369 return info->vfp - ALPHA_NUM_ARG_REGS * 8;
372 static const struct frame_base alpha_mdebug_frame_base = {
373 &alpha_mdebug_frame_unwind,
374 alpha_mdebug_frame_base_address,
375 alpha_mdebug_frame_locals_address,
376 alpha_mdebug_frame_args_address
379 static const struct frame_base *
380 alpha_mdebug_frame_base_sniffer (struct frame_info *next_frame)
382 CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
383 struct mdebug_extra_func_info *proc_desc;
385 /* If this PC does not map to a PDR, then clearly this isn't an
387 proc_desc = find_proc_desc (pc);
388 if (proc_desc == NULL)
391 return &alpha_mdebug_frame_base;
396 alpha_mdebug_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
398 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
400 frame_unwind_append_sniffer (gdbarch, alpha_mdebug_frame_sniffer);
401 frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer);