Automatic date update in version.in
[platform/upstream/binutils.git] / gdb / alpha-mdebug-tdep.c
1 /* Target-dependent mdebug code for the ALPHA architecture.
2    Copyright (C) 1993-2014 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 \f
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, 0);
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
139 alpha_mdebug_frameless (struct mdebug_extra_func_info *proc_desc)
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
149 alpha_mdebug_after_prologue (CORE_ADDR pc,
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
167 alpha_mdebug_in_prologue (CORE_ADDR pc,
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 \f
175 /* Frame unwinder that reads mdebug PDRs.  */
176
177 struct alpha_mdebug_unwind_cache
178 {
179   struct mdebug_extra_func_info *proc_desc;
180   CORE_ADDR vfp;
181   struct trad_frame_saved_reg *saved_regs;
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 *
188 alpha_mdebug_frame_unwind_cache (struct frame_info *this_frame, 
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
201   info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache);
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.  */
255   if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
256    trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, 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
264 static void
265 alpha_mdebug_frame_this_id (struct frame_info *this_frame,
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 *
278 alpha_mdebug_frame_prev_register (struct frame_info *this_frame,
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
297 alpha_mdebug_max_frame_size_exceeded (struct mdebug_extra_func_info *proc_desc)
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
308 alpha_mdebug_frame_sniffer (const struct frame_unwind *self,
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,
336   default_frame_unwind_stop_reason,
337   alpha_mdebug_frame_this_id,
338   alpha_mdebug_frame_prev_register,
339   NULL,
340   alpha_mdebug_frame_sniffer
341 };
342
343 static CORE_ADDR
344 alpha_mdebug_frame_base_address (struct frame_info *this_frame,
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
354 alpha_mdebug_frame_locals_address (struct frame_info *this_frame,
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
364 alpha_mdebug_frame_args_address (struct frame_info *this_frame,
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 = {
374   &alpha_mdebug_frame_unwind,
375   alpha_mdebug_frame_base_address,
376   alpha_mdebug_frame_locals_address,
377   alpha_mdebug_frame_args_address
378 };
379
380 static const struct frame_base *
381 alpha_mdebug_frame_base_sniffer (struct frame_info *this_frame)
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 \f
401 void
402 alpha_mdebug_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
403 {
404   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
405
406   frame_unwind_append_unwinder (gdbarch, &alpha_mdebug_frame_unwind);
407   frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer);
408 }