GDB (xrefs)

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