GDB (xrefs)
/tmp/gdb-7.10/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-2015 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 *
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
111  }
112 
113  if (sym)
114  {
115  proc_desc = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (sym);
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 
138 static 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 
148 static 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 
166 static 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 
178 {
182 };
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 
187 static 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 *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].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].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].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. */
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 
264 static 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 
277 static 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 
296 static 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
304  && !alpha_mdebug_frameless (proc_desc));
305 }
306 
307 static int
309  struct frame_info *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. */
328  if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
329  return 0;
330 
331  return 1;
332 }
333 
334 static const struct frame_unwind alpha_mdebug_frame_unwind = {
335  NORMAL_FRAME,
339  NULL,
341 };
342 
343 static CORE_ADDR
345  void **this_prologue_cache)
346 {
347  struct alpha_mdebug_unwind_cache *info
348  = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
349 
350  return info->vfp;
351 }
352 
353 static CORE_ADDR
355  void **this_prologue_cache)
356 {
357  struct alpha_mdebug_unwind_cache *info
358  = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
359 
360  return info->vfp - PROC_LOCALOFF (info->proc_desc);
361 }
362 
363 static CORE_ADDR
365  void **this_prologue_cache)
366 {
367  struct alpha_mdebug_unwind_cache *info
368  = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
369 
370  return info->vfp - ALPHA_NUM_ARG_REGS * 8;
371 }
372 
373 static const struct frame_base alpha_mdebug_frame_base = {
378 };
379 
380 static const struct frame_base *
382 {
383  CORE_ADDR pc = get_frame_address_in_block (this_frame);
384  struct mdebug_extra_func_info *proc_desc;
385 
386  /* If this PC does not map to a PDR, then clearly this isn't an
387  mdebug frame. */
388  proc_desc = find_proc_desc (pc);
389  if (proc_desc == NULL)
390  return NULL;
391 
392  /* If the maximum debuggable frame size has been exceeded, the
393  proc desc is bogus. Fall back on the heuristic unwinder. */
394  if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
395  return 0;
396 
397  return &alpha_mdebug_frame_base;
398 }
399 
400 
401 void
403 {
404  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
405 
406  frame_unwind_append_unwinder (gdbarch, &alpha_mdebug_frame_unwind);
408 }
void alpha_mdebug_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
#define ALPHA_NUM_ARG_REGS
Definition: alpha-tdep.h:68
#define PROC_PC_REG(proc)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2248
struct trad_frame_saved_reg * saved_regs
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define MDEBUG_EFI_SYMBOL_NAME
Definition: mdebugread.h:38
#define ALPHA_FP0_REGNUM
Definition: alpha-tdep.h:47
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:135
int trad_frame_addr_p(struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:77
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
Definition: trad-frame.c:92
static CORE_ADDR alpha_mdebug_frame_args_address(struct frame_info *this_frame, void **this_prologue_cache)
static void alpha_mdebug_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
#define ALPHA_SP_REGNUM
Definition: alpha-tdep.h:45
#define PROC_REG_MASK(proc)
#define BLOCK_START(bl)
Definition: block.h:116
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
static int alpha_mdebug_in_prologue(CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
static int alpha_mdebug_max_frame_size_exceeded(struct mdebug_extra_func_info *proc_desc)
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
#define PROC_LOCALOFF(proc)
struct mdebug_extra_func_info * proc_desc
static struct value * alpha_mdebug_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
#define ALPHA_PC_REGNUM
Definition: alpha-tdep.h:50
#define PROC_FREG_OFFSET(proc)
static const struct frame_unwind alpha_mdebug_frame_unwind
static CORE_ADDR alpha_mdebug_after_prologue(CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
#define ALPHA_RA_REGNUM
Definition: alpha-tdep.h:42
CORE_ADDR alpha_after_prologue(CORE_ADDR pc)
Definition: alpha-tdep.c:661
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int regnum
Definition: aarch64-tdep.c:69
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
static int alpha_mdebug_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
#define PROC_REG_OFFSET(proc)
Definition: block.h:60
Definition: value.c:172
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
Definition: trad-frame.c:52
static CORE_ADDR alpha_mdebug_frame_base_address(struct frame_info *this_frame, void **this_prologue_cache)
struct 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:1967
static struct mdebug_extra_func_info * find_proc_desc(CORE_ADDR pc)
void frame_base_append_sniffer(struct gdbarch *gdbarch, frame_base_sniffer_ftype *sniffer)
Definition: frame-base.c:82
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
static int alpha_mdebug_frameless(struct mdebug_extra_func_info *proc_desc)
Definition: symtab.h:703
#define PROC_FRAME_OFFSET(proc)
#define SYMBOL_VALUE_BYTES(symbol)
Definition: symtab.h:183
#define PROC_FRAME_REG(proc)
static struct alpha_mdebug_unwind_cache * alpha_mdebug_frame_unwind_cache(struct frame_info *this_frame, void **this_prologue_cache)
static const struct frame_base alpha_mdebug_frame_base
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
#define PROC_FREG_MASK(proc)
static CORE_ADDR alpha_mdebug_frame_locals_address(struct frame_info *this_frame, void **this_prologue_cache)
static const struct frame_base * alpha_mdebug_frame_base_sniffer(struct frame_info *this_frame)