GDB (xrefs)
Loading...
Searching...
No Matches
alpha-mdebug-tdep.c
Go to the documentation of this file.
1/* Target-dependent mdebug code for the ALPHA architecture.
2 Copyright (C) 1993-2023 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18
19#include "defs.h"
20#include "frame.h"
21#include "frame-unwind.h"
22#include "frame-base.h"
23#include "symtab.h"
24#include "gdbcore.h"
25#include "block.h"
26#include "trad-frame.h"
27
28#include "alpha-tdep.h"
29#include "mdebugread.h"
30#include "gdbarch.h"
31
32/* FIXME: Some of this code should perhaps be merged with mips. */
33
34/* Layout of a stack frame on the alpha:
35
36 | |
37 pdr members: | 7th ... nth arg, |
38 | `pushed' by caller. |
39 | |
40----------------|-------------------------------|<-- old_sp == vfp
41 ^ ^ ^ ^ | |
42 | | | | | |
43 | |localoff | Copies of 1st .. 6th |
44 | | | | | argument if necessary. |
45 | | | v | |
46 | | | --- |-------------------------------|<-- LOCALS_ADDRESS
47 | | | | |
48 | | | | Locals and temporaries. |
49 | | | | |
50 | | | |-------------------------------|
51 | | | | |
52 |-fregoffset | Saved float registers. |
53 | | | | F9 |
54 | | | | . |
55 | | | | . |
56 | | | | F2 |
57 | | v | |
58 | | -------|-------------------------------|
59 | | | |
60 | | | Saved registers. |
61 | | | S6 |
62 |-regoffset | . |
63 | | | . |
64 | | | S0 |
65 | | | pdr.pcreg |
66 | v | |
67 | ----------|-------------------------------|
68 | | |
69 frameoffset | Argument build area, gets |
70 | | 7th ... nth arg for any |
71 | | called procedure. |
72 v | |
73 -------------|-------------------------------|<-- sp
74 | |
75*/
76
77#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)
78#define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
79#define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
80#define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
81#define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
82#define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
83#define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
84#define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
85#define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
86
87/* Locate the mdebug PDR for the given PC. Return null if one can't
88 be found; you'll have to fall back to other methods in that case. */
89
90static struct mdebug_extra_func_info *
91find_proc_desc (CORE_ADDR pc)
92{
93 const struct block *b = block_for_pc (pc);
94 struct mdebug_extra_func_info *proc_desc = NULL;
95 struct symbol *sym = NULL;
96 const char *sh_name = NULL;
97
98 if (b)
99 {
100 CORE_ADDR startaddr;
101 find_pc_partial_function (pc, &sh_name, &startaddr, NULL);
102
103 if (startaddr > b->start ())
104 /* This is the "pathological" case referred to in a comment in
105 print_frame_info. It might be better to move this check into
106 symbol reading. */
107 sym = NULL;
108 else
110 0).symbol;
111 }
112
113 if (sym)
114 {
115 proc_desc = (struct mdebug_extra_func_info *) sym->value_bytes ();
116
117 /* Correct incorrect setjmp procedure descriptor from the library
118 to make backtrace through setjmp work. */
119 if (proc_desc->pdr.pcreg == 0
120 && strcmp (sh_name, "setjmp") == 0)
121 {
122 proc_desc->pdr.pcreg = ALPHA_RA_REGNUM;
123 proc_desc->pdr.regmask = 0x80000000;
124 proc_desc->pdr.regoffset = -4;
125 }
126
127 /* If we never found a PDR for this function in symbol reading,
128 then examine prologues to find the information. */
129 if (proc_desc->pdr.framereg == -1)
130 proc_desc = NULL;
131 }
132
133 return proc_desc;
134}
135
136/* Return a non-zero result if the function is frameless; zero otherwise. */
137
138static int
140{
141 return (PROC_FRAME_REG (proc_desc) == ALPHA_SP_REGNUM
142 && PROC_FRAME_OFFSET (proc_desc) == 0);
143}
144
145/* This returns the PC of the first inst after the prologue. If we can't
146 find the prologue, then return 0. */
147
148static CORE_ADDR
150 struct mdebug_extra_func_info *proc_desc)
151{
152 if (proc_desc)
153 {
154 /* If function is frameless, then we need to do it the hard way. I
155 strongly suspect that frameless always means prologueless... */
156 if (alpha_mdebug_frameless (proc_desc))
157 return 0;
158 }
159
160 return alpha_after_prologue (pc);
161}
162
163/* Return non-zero if we *might* be in a function prologue. Return zero
164 if we are definitively *not* in a function prologue. */
165
166static int
168 struct mdebug_extra_func_info *proc_desc)
169{
170 CORE_ADDR after_prologue_pc = alpha_mdebug_after_prologue (pc, proc_desc);
171 return (after_prologue_pc == 0 || pc < after_prologue_pc);
172}
173
174
175/* Frame unwinder that reads mdebug PDRs. */
176
183
184/* Extract all of the information about the frame from PROC_DESC
185 and store the resulting register save locations in the structure. */
186
187static struct alpha_mdebug_unwind_cache *
189 void **this_prologue_cache)
190{
191 struct alpha_mdebug_unwind_cache *info;
192 struct mdebug_extra_func_info *proc_desc;
193 ULONGEST vfp;
194 CORE_ADDR pc, reg_position;
195 unsigned long mask;
196 int ireg, returnreg;
197
198 if (*this_prologue_cache)
199 return (struct alpha_mdebug_unwind_cache *) *this_prologue_cache;
200
202 *this_prologue_cache = info;
203 pc = get_frame_address_in_block (this_frame);
204
205 /* ??? We don't seem to be able to cache the lookup of the PDR
206 from alpha_mdebug_frame_p. It'd be nice if we could change
207 the arguments to that function. Oh well. */
208 proc_desc = find_proc_desc (pc);
209 info->proc_desc = proc_desc;
210 gdb_assert (proc_desc != NULL);
211
212 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
213
214 /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */
215 vfp = get_frame_register_unsigned (this_frame, PROC_FRAME_REG (proc_desc));
216 vfp += PROC_FRAME_OFFSET (info->proc_desc);
217 info->vfp = vfp;
218
219 /* Fill in the offsets for the registers which gen_mask says were saved. */
220
221 reg_position = vfp + PROC_REG_OFFSET (proc_desc);
222 mask = PROC_REG_MASK (proc_desc);
223 returnreg = PROC_PC_REG (proc_desc);
224
225 /* Note that RA is always saved first, regardless of its actual
226 register number. */
227 if (mask & (1 << returnreg))
228 {
229 /* Clear bit for RA so we don't save it again later. */
230 mask &= ~(1 << returnreg);
231
232 info->saved_regs[returnreg].set_addr (reg_position);
233 reg_position += 8;
234 }
235
236 for (ireg = 0; ireg <= 31; ++ireg)
237 if (mask & (1 << ireg))
238 {
239 info->saved_regs[ireg].set_addr (reg_position);
240 reg_position += 8;
241 }
242
243 reg_position = vfp + PROC_FREG_OFFSET (proc_desc);
244 mask = PROC_FREG_MASK (proc_desc);
245
246 for (ireg = 0; ireg <= 31; ++ireg)
247 if (mask & (1 << ireg))
248 {
249 info->saved_regs[ALPHA_FP0_REGNUM + ireg].set_addr (reg_position);
250 reg_position += 8;
251 }
252
253 /* The stack pointer of the previous frame is computed by popping
254 the current stack frame. */
255 if (!info->saved_regs[ALPHA_SP_REGNUM].is_addr ())
256 info->saved_regs[ALPHA_SP_REGNUM].set_value (vfp);
257
258 return info;
259}
260
261/* Given a GDB frame, determine the address of the calling function's
262 frame. This will be used to create a new GDB frame struct. */
263
264static void
266 void **this_prologue_cache,
267 struct frame_id *this_id)
268{
269 struct alpha_mdebug_unwind_cache *info
270 = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
271
272 *this_id = frame_id_build (info->vfp, get_frame_func (this_frame));
273}
274
275/* Retrieve the value of REGNUM in FRAME. Don't give up! */
276
277static struct value *
279 void **this_prologue_cache, int regnum)
280{
281 struct alpha_mdebug_unwind_cache *info
282 = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
283
284 /* The PC of the previous frame is stored in the link register of
285 the current frame. Frob regnum so that we pull the value from
286 the correct place. */
287 if (regnum == ALPHA_PC_REGNUM)
288 regnum = PROC_PC_REG (info->proc_desc);
289
290 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
291}
292
293/* Return a non-zero result if the size of the stack frame exceeds the
294 maximum debuggable frame size (512 Kbytes); zero otherwise. */
295
296static int
298{
299 /* If frame offset is null, we can be in two cases: either the
300 function is frameless (the stack frame is null) or its
301 frame exceeds the maximum debuggable frame size (512 Kbytes). */
302
303 return (PROC_FRAME_OFFSET (proc_desc) == 0
305}
306
307static int
309 frame_info_ptr this_frame,
310 void **this_cache)
311{
312 CORE_ADDR pc = get_frame_address_in_block (this_frame);
313 struct mdebug_extra_func_info *proc_desc;
314
315 /* If this PC does not map to a PDR, then clearly this isn't an
316 mdebug frame. */
317 proc_desc = find_proc_desc (pc);
318 if (proc_desc == NULL)
319 return 0;
320
321 /* If we're in the prologue, the PDR for this frame is not yet valid.
322 Say no here and we'll fall back on the heuristic unwinder. */
323 if (alpha_mdebug_in_prologue (pc, proc_desc))
324 return 0;
325
326 /* If the maximum debuggable frame size has been exceeded, the
327 proc desc is bogus. Fall back on the heuristic unwinder. */
329 return 0;
330
331 return 1;
332}
333
344
345static CORE_ADDR
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
355static CORE_ADDR
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
365static CORE_ADDR
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
381
382static const struct frame_base *
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. */
397 return 0;
398
400}
401
402
403void
int regnum
#define PROC_FREG_OFFSET(proc)
void alpha_mdebug_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static CORE_ADDR alpha_mdebug_after_prologue(CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
static int alpha_mdebug_max_frame_size_exceeded(struct mdebug_extra_func_info *proc_desc)
#define PROC_REG_MASK(proc)
static CORE_ADDR alpha_mdebug_frame_args_address(frame_info_ptr this_frame, void **this_prologue_cache)
#define PROC_FREG_MASK(proc)
#define PROC_LOCALOFF(proc)
static CORE_ADDR alpha_mdebug_frame_locals_address(frame_info_ptr this_frame, void **this_prologue_cache)
static const struct frame_base * alpha_mdebug_frame_base_sniffer(frame_info_ptr this_frame)
static CORE_ADDR alpha_mdebug_frame_base_address(frame_info_ptr this_frame, void **this_prologue_cache)
static int alpha_mdebug_frameless(struct mdebug_extra_func_info *proc_desc)
static struct value * alpha_mdebug_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static int alpha_mdebug_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_cache)
static void alpha_mdebug_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
#define PROC_FRAME_OFFSET(proc)
static struct alpha_mdebug_unwind_cache * alpha_mdebug_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
#define PROC_PC_REG(proc)
#define PROC_FRAME_REG(proc)
static const struct frame_unwind alpha_mdebug_frame_unwind
static const struct frame_base alpha_mdebug_frame_base
static int alpha_mdebug_in_prologue(CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
static struct mdebug_extra_func_info * find_proc_desc(CORE_ADDR pc)
#define PROC_REG_OFFSET(proc)
#define ALPHA_PC_REGNUM
Definition alpha-tdep.h:52
#define ALPHA_SP_REGNUM
Definition alpha-tdep.h:47
#define ALPHA_FP0_REGNUM
Definition alpha-tdep.h:49
#define ALPHA_NUM_ARG_REGS
Definition alpha-tdep.h:70
CORE_ADDR alpha_after_prologue(CORE_ADDR pc)
#define ALPHA_RA_REGNUM
Definition alpha-tdep.h:44
const struct block * block_for_pc(CORE_ADDR pc)
Definition block.c:276
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
Definition blockframe.c:373
void frame_base_append_sniffer(struct gdbarch *gdbarch, frame_base_sniffer_ftype *sniffer)
Definition frame-base.c:81
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
Definition frame.c:1098
CORE_ADDR get_frame_address_in_block(frame_info_ptr this_frame)
Definition frame.c:2742
@ NORMAL_FRAME
Definition frame.h:187
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition frame.h:825
#define MDEBUG_EFI_SYMBOL_NAME
Definition mdebugread.h:38
struct mdebug_extra_func_info * proc_desc
trad_frame_saved_reg * saved_regs
struct symbol * symbol
Definition symtab.h:1533
Definition block.h:109
CORE_ADDR start() const
Definition block.h:111
const gdb_byte * value_bytes() const
Definition symtab.h:1374
Definition value.h:130
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition symtab.c:1964
@ LABEL_DOMAIN
Definition symtab.h:924
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition trad-frame.c:62
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
Definition trad-frame.c:187