projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
* Makefile.am: Run "make dep-am".
[deliverable/binutils-gdb.git] / gdb / dwarf2-frame.c
... / ...
CommitLineData
1/* Frame unwinder for frames with DWARF Call Frame Information.
2
3 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 Contributed by Mark Kettenis.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
23
24#include "defs.h"
25#include "dwarf2expr.h"
26#include "elf/dwarf2.h"
27#include "frame.h"
28#include "frame-base.h"
29#include "frame-unwind.h"
30#include "gdbcore.h"
31#include "gdbtypes.h"
32#include "symtab.h"
33#include "objfiles.h"
34#include "regcache.h"
35
36#include "gdb_assert.h"
37#include "gdb_string.h"
38
39#include "complaints.h"
40#include "dwarf2-frame.h"
41
42/* Call Frame Information (CFI). */
43
44/* Common Information Entry (CIE). */
45
46struct dwarf2_cie
47{
48 /* Offset into the .debug_frame section where this CIE was found.
49 Used to identify this CIE. */
50 ULONGEST cie_pointer;
51
52 /* Constant that is factored out of all advance location
53 instructions. */
54 ULONGEST code_alignment_factor;
55
56 /* Constants that is factored out of all offset instructions. */
57 LONGEST data_alignment_factor;
58
59 /* Return address column. */
60 ULONGEST return_address_register;
61
62 /* Instruction sequence to initialize a register set. */
63 gdb_byte *initial_instructions;
64 gdb_byte *end;
65
66 /* Encoding of addresses. */
67 gdb_byte encoding;
68
69 /* True if a 'z' augmentation existed. */
70 unsigned char saw_z_augmentation;
71
72 struct dwarf2_cie *next;
73};
74
75/* Frame Description Entry (FDE). */
76
77struct dwarf2_fde
78{
79 /* CIE for this FDE. */
80 struct dwarf2_cie *cie;
81
82 /* First location associated with this FDE. */
83 CORE_ADDR initial_location;
84
85 /* Number of bytes of program instructions described by this FDE. */
86 CORE_ADDR address_range;
87
88 /* Instruction sequence. */
89 gdb_byte *instructions;
90 gdb_byte *end;
91
92 struct dwarf2_fde *next;
93};
94
95static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
96\f
97
98/* Structure describing a frame state. */
99
100struct dwarf2_frame_state
101{
102 /* Each register save state can be described in terms of a CFA slot,
103 another register, or a location expression. */
104 struct dwarf2_frame_state_reg_info
105 {
106 struct dwarf2_frame_state_reg *reg;
107 int num_regs;
108
109 /* Used to implement DW_CFA_remember_state. */
110 struct dwarf2_frame_state_reg_info *prev;
111 } regs;
112
113 LONGEST cfa_offset;
114 ULONGEST cfa_reg;
115 gdb_byte *cfa_exp;
116 enum {
117 CFA_UNSET,
118 CFA_REG_OFFSET,
119 CFA_EXP
120 } cfa_how;
121
122 /* The PC described by the current frame state. */
123 CORE_ADDR pc;
124
125 /* Initial register set from the CIE.
126 Used to implement DW_CFA_restore. */
127 struct dwarf2_frame_state_reg_info initial;
128
129 /* The information we care about from the CIE. */
130 LONGEST data_align;
131 ULONGEST code_align;
132 ULONGEST retaddr_column;
133};
134
135/* Store the length the expression for the CFA in the `cfa_reg' field,
136 which is unused in that case. */
137#define cfa_exp_len cfa_reg
138
139/* Assert that the register set RS is large enough to store NUM_REGS
140 columns. If necessary, enlarge the register set. */
141
142static void
143dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
144 int num_regs)
145{
146 size_t size = sizeof (struct dwarf2_frame_state_reg);
147
148 if (num_regs <= rs->num_regs)
149 return;
150
151 rs->reg = (struct dwarf2_frame_state_reg *)
152 xrealloc (rs->reg, num_regs * size);
153
154 /* Initialize newly allocated registers. */
155 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
156 rs->num_regs = num_regs;
157}
158
159/* Copy the register columns in register set RS into newly allocated
160 memory and return a pointer to this newly created copy. */
161
162static struct dwarf2_frame_state_reg *
163dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
164{
165 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
166 struct dwarf2_frame_state_reg *reg;
167
168 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
169 memcpy (reg, rs->reg, size);
170
171 return reg;
172}
173
174/* Release the memory allocated to register set RS. */
175
176static void
177dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
178{
179 if (rs)
180 {
181 dwarf2_frame_state_free_regs (rs->prev);
182
183 xfree (rs->reg);
184 xfree (rs);
185 }
186}
187
188/* Release the memory allocated to the frame state FS. */
189
190static void
191dwarf2_frame_state_free (void *p)
192{
193 struct dwarf2_frame_state *fs = p;
194
195 dwarf2_frame_state_free_regs (fs->initial.prev);
196 dwarf2_frame_state_free_regs (fs->regs.prev);
197 xfree (fs->initial.reg);
198 xfree (fs->regs.reg);
199 xfree (fs);
200}
201\f
202
203/* Helper functions for execute_stack_op. */
204
205static CORE_ADDR
206read_reg (void *baton, int reg)
207{
208 struct frame_info *next_frame = (struct frame_info *) baton;
209 struct gdbarch *gdbarch = get_frame_arch (next_frame);
210 int regnum;
211 gdb_byte *buf;
212
213 regnum = DWARF2_REG_TO_REGNUM (reg);
214
215 buf = alloca (register_size (gdbarch, regnum));
216 frame_unwind_register (next_frame, regnum, buf);
217 return extract_typed_address (buf, builtin_type_void_data_ptr);
218}
219
220static void
221read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
222{
223 read_memory (addr, buf, len);
224}
225
226static void
227no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
228{
229 internal_error (__FILE__, __LINE__,
230 _("Support for DW_OP_fbreg is unimplemented"));
231}
232
233static CORE_ADDR
234no_get_tls_address (void *baton, CORE_ADDR offset)
235{
236 internal_error (__FILE__, __LINE__,
237 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
238}
239
240static CORE_ADDR
241execute_stack_op (gdb_byte *exp, ULONGEST len,
242 struct frame_info *next_frame, CORE_ADDR initial)
243{
244 struct dwarf_expr_context *ctx;
245 CORE_ADDR result;
246
247 ctx = new_dwarf_expr_context ();
248 ctx->baton = next_frame;
249 ctx->read_reg = read_reg;
250 ctx->read_mem = read_mem;
251 ctx->get_frame_base = no_get_frame_base;
252 ctx->get_tls_address = no_get_tls_address;
253
254 dwarf_expr_push (ctx, initial);
255 dwarf_expr_eval (ctx, exp, len);
256 result = dwarf_expr_fetch (ctx, 0);
257
258 if (ctx->in_reg)
259 result = read_reg (next_frame, result);
260
261 free_dwarf_expr_context (ctx);
262
263 return result;
264}
265\f
266
267static void
268execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
269 struct frame_info *next_frame,
270 struct dwarf2_frame_state *fs)
271{
272 CORE_ADDR pc = frame_pc_unwind (next_frame);
273 int bytes_read;
274
275 while (insn_ptr < insn_end && fs->pc <= pc)
276 {
277 gdb_byte insn = *insn_ptr++;
278 ULONGEST utmp, reg;
279 LONGEST offset;
280
281 if ((insn & 0xc0) == DW_CFA_advance_loc)
282 fs->pc += (insn & 0x3f) * fs->code_align;
283 else if ((insn & 0xc0) == DW_CFA_offset)
284 {
285 reg = insn & 0x3f;
286 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
287 offset = utmp * fs->data_align;
288 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
289 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
290 fs->regs.reg[reg].loc.offset = offset;
291 }
292 else if ((insn & 0xc0) == DW_CFA_restore)
293 {
294 gdb_assert (fs->initial.reg);
295 reg = insn & 0x3f;
296 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
297 if (reg < fs->initial.num_regs)
298 fs->regs.reg[reg] = fs->initial.reg[reg];
299 else
300 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
301
302 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
303 complaint (&symfile_complaints, _("\
304incomplete CFI data; DW_CFA_restore unspecified\n\
305register %s (#%d) at 0x%s"),
306 REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
307 DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
308 }
309 else
310 {
311 switch (insn)
312 {
313 case DW_CFA_set_loc:
314 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
315 insn_ptr += bytes_read;
316 break;
317
318 case DW_CFA_advance_loc1:
319 utmp = extract_unsigned_integer (insn_ptr, 1);
320 fs->pc += utmp * fs->code_align;
321 insn_ptr++;
322 break;
323 case DW_CFA_advance_loc2:
324 utmp = extract_unsigned_integer (insn_ptr, 2);
325 fs->pc += utmp * fs->code_align;
326 insn_ptr += 2;
327 break;
328 case DW_CFA_advance_loc4:
329 utmp = extract_unsigned_integer (insn_ptr, 4);
330 fs->pc += utmp * fs->code_align;
331 insn_ptr += 4;
332 break;
333
334 case DW_CFA_offset_extended:
335 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
336 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
337 offset = utmp * fs->data_align;
338 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
339 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
340 fs->regs.reg[reg].loc.offset = offset;
341 break;
342
343 case DW_CFA_restore_extended:
344 gdb_assert (fs->initial.reg);
345 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
346 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
347 fs->regs.reg[reg] = fs->initial.reg[reg];
348 break;
349
350 case DW_CFA_undefined:
351 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
352 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
353 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
354 break;
355
356 case DW_CFA_same_value:
357 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
358 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
359 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
360 break;
361
362 case DW_CFA_register:
363 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
364 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
365 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
366 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
367 fs->regs.reg[reg].loc.reg = utmp;
368 break;
369
370 case DW_CFA_remember_state:
371 {
372 struct dwarf2_frame_state_reg_info *new_rs;
373
374 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
375 *new_rs = fs->regs;
376 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
377 fs->regs.prev = new_rs;
378 }
379 break;
380
381 case DW_CFA_restore_state:
382 {
383 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
384
385 if (old_rs == NULL)
386 {
387 complaint (&symfile_complaints, _("\
388bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
389 }
390 else
391 {
392 xfree (fs->regs.reg);
393 fs->regs = *old_rs;
394 xfree (old_rs);
395 }
396 }
397 break;
398
399 case DW_CFA_def_cfa:
400 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
401 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
402 fs->cfa_offset = utmp;
403 fs->cfa_how = CFA_REG_OFFSET;
404 break;
405
406 case DW_CFA_def_cfa_register:
407 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
408 fs->cfa_how = CFA_REG_OFFSET;
409 break;
410
411 case DW_CFA_def_cfa_offset:
412 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
413 fs->cfa_offset = utmp;
414 /* cfa_how deliberately not set. */
415 break;
416
417 case DW_CFA_nop:
418 break;
419
420 case DW_CFA_def_cfa_expression:
421 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
422 fs->cfa_exp = insn_ptr;
423 fs->cfa_how = CFA_EXP;
424 insn_ptr += fs->cfa_exp_len;
425 break;
426
427 case DW_CFA_expression:
428 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
429 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
430 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
431 fs->regs.reg[reg].loc.exp = insn_ptr;
432 fs->regs.reg[reg].exp_len = utmp;
433 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
434 insn_ptr += utmp;
435 break;
436
437 case DW_CFA_offset_extended_sf:
438 insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
439 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
440 offset *= fs->data_align;
441 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
442 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
443 fs->regs.reg[reg].loc.offset = offset;
444 break;
445
446 case DW_CFA_def_cfa_sf:
447 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
448 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
449 fs->cfa_offset = offset * fs->data_align;
450 fs->cfa_how = CFA_REG_OFFSET;
451 break;
452
453 case DW_CFA_def_cfa_offset_sf:
454 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
455 fs->cfa_offset = offset * fs->data_align;
456 /* cfa_how deliberately not set. */
457 break;
458
459 case DW_CFA_GNU_window_save:
460 /* This is SPARC-specific code, and contains hard-coded
461 constants for the register numbering scheme used by
462 GCC. Rather than having a architecture-specific
463 operation that's only ever used by a single
464 architecture, we provide the implementation here.
465 Incidentally that's what GCC does too in its
466 unwinder. */
467 {
468 struct gdbarch *gdbarch = get_frame_arch (next_frame);
469 int size = register_size(gdbarch, 0);
470 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
471 for (reg = 8; reg < 16; reg++)
472 {
473 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
474 fs->regs.reg[reg].loc.reg = reg + 16;
475 }
476 for (reg = 16; reg < 32; reg++)
477 {
478 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
479 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
480 }
481 }
482 break;
483
484 case DW_CFA_GNU_args_size:
485 /* Ignored. */
486 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
487 break;
488
489 default:
490 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
491 }
492 }
493 }
494
495 /* Don't allow remember/restore between CIE and FDE programs. */
496 dwarf2_frame_state_free_regs (fs->regs.prev);
497 fs->regs.prev = NULL;
498}
499\f
500
501/* Architecture-specific operations. */
502
503/* Per-architecture data key. */
504static struct gdbarch_data *dwarf2_frame_data;
505
506struct dwarf2_frame_ops
507{
508 /* Pre-initialize the register state REG for register REGNUM. */
509 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *);
510
511 /* Check whether the frame preceding NEXT_FRAME will be a signal
512 trampoline. */
513 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
514};
515
516/* Default architecture-specific register state initialization
517 function. */
518
519static void
520dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
521 struct dwarf2_frame_state_reg *reg)
522{
523 /* If we have a register that acts as a program counter, mark it as
524 a destination for the return address. If we have a register that
525 serves as the stack pointer, arrange for it to be filled with the
526 call frame address (CFA). The other registers are marked as
527 unspecified.
528
529 We copy the return address to the program counter, since many
530 parts in GDB assume that it is possible to get the return address
531 by unwinding the program counter register. However, on ISA's
532 with a dedicated return address register, the CFI usually only
533 contains information to unwind that return address register.
534
535 The reason we're treating the stack pointer special here is
536 because in many cases GCC doesn't emit CFI for the stack pointer
537 and implicitly assumes that it is equal to the CFA. This makes
538 some sense since the DWARF specification (version 3, draft 8,
539 p. 102) says that:
540
541 "Typically, the CFA is defined to be the value of the stack
542 pointer at the call site in the previous frame (which may be
543 different from its value on entry to the current frame)."
544
545 However, this isn't true for all platforms supported by GCC
546 (e.g. IBM S/390 and zSeries). Those architectures should provide
547 their own architecture-specific initialization function. */
548
549 if (regnum == PC_REGNUM)
550 reg->how = DWARF2_FRAME_REG_RA;
551 else if (regnum == SP_REGNUM)
552 reg->how = DWARF2_FRAME_REG_CFA;
553}
554
555/* Return a default for the architecture-specific operations. */
556
557static void *
558dwarf2_frame_init (struct obstack *obstack)
559{
560 struct dwarf2_frame_ops *ops;
561
562 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
563 ops->init_reg = dwarf2_frame_default_init_reg;
564 return ops;
565}
566
567/* Set the architecture-specific register state initialization
568 function for GDBARCH to INIT_REG. */
569
570void
571dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
572 void (*init_reg) (struct gdbarch *, int,
573 struct dwarf2_frame_state_reg *))
574{
575 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
576
577 ops->init_reg = init_reg;
578}
579
580/* Pre-initialize the register state REG for register REGNUM. */
581
582static void
583dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
584 struct dwarf2_frame_state_reg *reg)
585{
586 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
587
588 ops->init_reg (gdbarch, regnum, reg);
589}
590
591/* Set the architecture-specific signal trampoline recognition
592 function for GDBARCH to SIGNAL_FRAME_P. */
593
594void
595dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
596 int (*signal_frame_p) (struct gdbarch *,
597 struct frame_info *))
598{
599 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
600
601 ops->signal_frame_p = signal_frame_p;
602}
603
604/* Query the architecture-specific signal frame recognizer for
605 NEXT_FRAME. */
606
607static int
608dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
609 struct frame_info *next_frame)
610{
611 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
612
613 if (ops->signal_frame_p == NULL)
614 return 0;
615 return ops->signal_frame_p (gdbarch, next_frame);
616}
617\f
618
619struct dwarf2_frame_cache
620{
621 /* DWARF Call Frame Address. */
622 CORE_ADDR cfa;
623
624 /* Set if the return address column was marked as undefined. */
625 int undefined_retaddr;
626
627 /* Saved registers, indexed by GDB register number, not by DWARF
628 register number. */
629 struct dwarf2_frame_state_reg *reg;
630
631 /* Return address register. */
632 struct dwarf2_frame_state_reg retaddr_reg;
633};
634
635static struct dwarf2_frame_cache *
636dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
637{
638 struct cleanup *old_chain;
639 struct gdbarch *gdbarch = get_frame_arch (next_frame);
640 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
641 struct dwarf2_frame_cache *cache;
642 struct dwarf2_frame_state *fs;
643 struct dwarf2_fde *fde;
644
645 if (*this_cache)
646 return *this_cache;
647
648 /* Allocate a new cache. */
649 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
650 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
651
652 /* Allocate and initialize the frame state. */
653 fs = XMALLOC (struct dwarf2_frame_state);
654 memset (fs, 0, sizeof (struct dwarf2_frame_state));
655 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
656
657 /* Unwind the PC.
658
659 Note that if NEXT_FRAME is never supposed to return (i.e. a call
660 to abort), the compiler might optimize away the instruction at
661 NEXT_FRAME's return address. As a result the return address will
662 point at some random instruction, and the CFI for that
663 instruction is probably worthless to us. GCC's unwinder solves
664 this problem by substracting 1 from the return address to get an
665 address in the middle of a presumed call instruction (or the
666 instruction in the associated delay slot). This should only be
667 done for "normal" frames and not for resume-type frames (signal
668 handlers, sentinel frames, dummy frames). The function
669 frame_unwind_address_in_block does just this. It's not clear how
670 reliable the method is though; there is the potential for the
671 register state pre-call being different to that on return. */
672 fs->pc = frame_unwind_address_in_block (next_frame);
673
674 /* Find the correct FDE. */
675 fde = dwarf2_frame_find_fde (&fs->pc);
676 gdb_assert (fde != NULL);
677
678 /* Extract any interesting information from the CIE. */
679 fs->data_align = fde->cie->data_alignment_factor;
680 fs->code_align = fde->cie->code_alignment_factor;
681 fs->retaddr_column = fde->cie->return_address_register;
682
683 /* First decode all the insns in the CIE. */
684 execute_cfa_program (fde->cie->initial_instructions,
685 fde->cie->end, next_frame, fs);
686
687 /* Save the initialized register set. */
688 fs->initial = fs->regs;
689 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
690
691 /* Then decode the insns in the FDE up to our target PC. */
692 execute_cfa_program (fde->instructions, fde->end, next_frame, fs);
693
694 /* Caclulate the CFA. */
695 switch (fs->cfa_how)
696 {
697 case CFA_REG_OFFSET:
698 cache->cfa = read_reg (next_frame, fs->cfa_reg);
699 cache->cfa += fs->cfa_offset;
700 break;
701
702 case CFA_EXP:
703 cache->cfa =
704 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
705 break;
706
707 default:
708 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
709 }
710
711 /* Initialize the register state. */
712 {
713 int regnum;
714
715 for (regnum = 0; regnum < num_regs; regnum++)
716 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]);
717 }
718
719 /* Go through the DWARF2 CFI generated table and save its register
720 location information in the cache. Note that we don't skip the
721 return address column; it's perfectly all right for it to
722 correspond to a real register. If it doesn't correspond to a
723 real register, or if we shouldn't treat it as such,
724 DWARF2_REG_TO_REGNUM should be defined to return a number outside
725 the range [0, NUM_REGS). */
726 {
727 int column; /* CFI speak for "register number". */
728
729 for (column = 0; column < fs->regs.num_regs; column++)
730 {
731 /* Use the GDB register number as the destination index. */
732 int regnum = DWARF2_REG_TO_REGNUM (column);
733
734 /* If there's no corresponding GDB register, ignore it. */
735 if (regnum < 0 || regnum >= num_regs)
736 continue;
737
738 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
739 of all debug info registers. If it doesn't, complain (but
740 not too loudly). It turns out that GCC assumes that an
741 unspecified register implies "same value" when CFI (draft
742 7) specifies nothing at all. Such a register could equally
743 be interpreted as "undefined". Also note that this check
744 isn't sufficient; it only checks that all registers in the
745 range [0 .. max column] are specified, and won't detect
746 problems when a debug info register falls outside of the
747 table. We need a way of iterating through all the valid
748 DWARF2 register numbers. */
749 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
750 {
751 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
752 complaint (&symfile_complaints, _("\
753incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
754 gdbarch_register_name (gdbarch, regnum),
755 paddr_nz (fs->pc));
756 }
757 else
758 cache->reg[regnum] = fs->regs.reg[column];
759 }
760 }
761
762 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
763 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
764 {
765 int regnum;
766
767 for (regnum = 0; regnum < num_regs; regnum++)
768 {
769 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
770 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
771 {
772 struct dwarf2_frame_state_reg *retaddr_reg =
773 &fs->regs.reg[fs->retaddr_column];
774
775 /* It seems rather bizarre to specify an "empty" column as
776 the return adress column. However, this is exactly
777 what GCC does on some targets. It turns out that GCC
778 assumes that the return address can be found in the
779 register corresponding to the return address column.
780 Incidentally, that's how we should treat a return
781 address column specifying "same value" too. */
782 if (fs->retaddr_column < fs->regs.num_regs
783 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
784 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
785 {
786 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
787 cache->reg[regnum] = *retaddr_reg;
788 else
789 cache->retaddr_reg = *retaddr_reg;
790 }
791 else
792 {
793 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
794 {
795 cache->reg[regnum].loc.reg = fs->retaddr_column;
796 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
797 }
798 else
799 {
800 cache->retaddr_reg.loc.reg = fs->retaddr_column;
801 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
802 }
803 }
804 }
805 }
806 }
807
808 if (fs->retaddr_column < fs->regs.num_regs
809 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
810 cache->undefined_retaddr = 1;
811
812 do_cleanups (old_chain);
813
814 *this_cache = cache;
815 return cache;
816}
817
818static void
819dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
820 struct frame_id *this_id)
821{
822 struct dwarf2_frame_cache *cache =
823 dwarf2_frame_cache (next_frame, this_cache);
824
825 if (cache->undefined_retaddr)
826 return;
827
828 (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
829}
830
831static void
832dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
833 int regnum, int *optimizedp,
834 enum lval_type *lvalp, CORE_ADDR *addrp,
835 int *realnump, gdb_byte *valuep)
836{
837 struct gdbarch *gdbarch = get_frame_arch (next_frame);
838 struct dwarf2_frame_cache *cache =
839 dwarf2_frame_cache (next_frame, this_cache);
840
841 switch (cache->reg[regnum].how)
842 {
843 case DWARF2_FRAME_REG_UNDEFINED:
844 /* If CFI explicitly specified that the value isn't defined,
845 mark it as optimized away; the value isn't available. */
846 *optimizedp = 1;
847 *lvalp = not_lval;
848 *addrp = 0;
849 *realnump = -1;
850 if (valuep)
851 {
852 /* In some cases, for example %eflags on the i386, we have
853 to provide a sane value, even though this register wasn't
854 saved. Assume we can get it from NEXT_FRAME. */
855 frame_unwind_register (next_frame, regnum, valuep);
856 }
857 break;
858
859 case DWARF2_FRAME_REG_SAVED_OFFSET:
860 *optimizedp = 0;
861 *lvalp = lval_memory;
862 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
863 *realnump = -1;
864 if (valuep)
865 {
866 /* Read the value in from memory. */
867 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
868 }
869 break;
870
871 case DWARF2_FRAME_REG_SAVED_REG:
872 *optimizedp = 0;
873 *lvalp = lval_register;
874 *addrp = 0;
875 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
876 if (valuep)
877 frame_unwind_register (next_frame, (*realnump), valuep);
878 break;
879
880 case DWARF2_FRAME_REG_SAVED_EXP:
881 *optimizedp = 0;
882 *lvalp = lval_memory;
883 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
884 cache->reg[regnum].exp_len,
885 next_frame, cache->cfa);
886 *realnump = -1;
887 if (valuep)
888 {
889 /* Read the value in from memory. */
890 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
891 }
892 break;
893
894 case DWARF2_FRAME_REG_UNSPECIFIED:
895 /* GCC, in its infinite wisdom decided to not provide unwind
896 information for registers that are "same value". Since
897 DWARF2 (3 draft 7) doesn't define such behavior, said
898 registers are actually undefined (which is different to CFI
899 "undefined"). Code above issues a complaint about this.
900 Here just fudge the books, assume GCC, and that the value is
901 more inner on the stack. */
902 *optimizedp = 0;
903 *lvalp = lval_register;
904 *addrp = 0;
905 *realnump = regnum;
906 if (valuep)
907 frame_unwind_register (next_frame, (*realnump), valuep);
908 break;
909
910 case DWARF2_FRAME_REG_SAME_VALUE:
911 *optimizedp = 0;
912 *lvalp = lval_register;
913 *addrp = 0;
914 *realnump = regnum;
915 if (valuep)
916 frame_unwind_register (next_frame, (*realnump), valuep);
917 break;
918
919 case DWARF2_FRAME_REG_CFA:
920 *optimizedp = 0;
921 *lvalp = not_lval;
922 *addrp = 0;
923 *realnump = -1;
924 if (valuep)
925 {
926 /* Store the value. */
927 store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
928 }
929 break;
930
931 case DWARF2_FRAME_REG_CFA_OFFSET:
932 *optimizedp = 0;
933 *lvalp = not_lval;
934 *addrp = 0;
935 *realnump = -1;
936 if (valuep)
937 {
938 /* Store the value. */
939 store_typed_address (valuep, builtin_type_void_data_ptr,
940 cache->cfa + cache->reg[regnum].loc.offset);
941 }
942 break;
943
944 case DWARF2_FRAME_REG_RA_OFFSET:
945 *optimizedp = 0;
946 *lvalp = not_lval;
947 *addrp = 0;
948 *realnump = -1;
949 if (valuep)
950 {
951 CORE_ADDR pc = cache->reg[regnum].loc.offset;
952
953 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
954 pc += frame_unwind_register_unsigned (next_frame, regnum);
955 store_typed_address (valuep, builtin_type_void_func_ptr, pc);
956 }
957 break;
958
959 default:
960 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
961 }
962}
963
964static const struct frame_unwind dwarf2_frame_unwind =
965{
966 NORMAL_FRAME,
967 dwarf2_frame_this_id,
968 dwarf2_frame_prev_register
969};
970
971static const struct frame_unwind dwarf2_signal_frame_unwind =
972{
973 SIGTRAMP_FRAME,
974 dwarf2_frame_this_id,
975 dwarf2_frame_prev_register
976};
977
978const struct frame_unwind *
979dwarf2_frame_sniffer (struct frame_info *next_frame)
980{
981 /* Grab an address that is guarenteed to reside somewhere within the
982 function. frame_pc_unwind(), for a no-return next function, can
983 end up returning something past the end of this function's body. */
984 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
985 if (!dwarf2_frame_find_fde (&block_addr))
986 return NULL;
987
988 /* On some targets, signal trampolines may have unwind information.
989 We need to recognize them so that we set the frame type
990 correctly. */
991
992 if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
993 next_frame))
994 return &dwarf2_signal_frame_unwind;
995
996 return &dwarf2_frame_unwind;
997}
998\f
999
1000/* There is no explicitly defined relationship between the CFA and the
1001 location of frame's local variables and arguments/parameters.
1002 Therefore, frame base methods on this page should probably only be
1003 used as a last resort, just to avoid printing total garbage as a
1004 response to the "info frame" command. */
1005
1006static CORE_ADDR
1007dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1008{
1009 struct dwarf2_frame_cache *cache =
1010 dwarf2_frame_cache (next_frame, this_cache);
1011
1012 return cache->cfa;
1013}
1014
1015static const struct frame_base dwarf2_frame_base =
1016{
1017 &dwarf2_frame_unwind,
1018 dwarf2_frame_base_address,
1019 dwarf2_frame_base_address,
1020 dwarf2_frame_base_address
1021};
1022
1023const struct frame_base *
1024dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1025{
1026 CORE_ADDR pc = frame_pc_unwind (next_frame);
1027 if (dwarf2_frame_find_fde (&pc))
1028 return &dwarf2_frame_base;
1029
1030 return NULL;
1031}
1032\f
1033/* A minimal decoding of DWARF2 compilation units. We only decode
1034 what's needed to get to the call frame information. */
1035
1036struct comp_unit
1037{
1038 /* Keep the bfd convenient. */
1039 bfd *abfd;
1040
1041 struct objfile *objfile;
1042
1043 /* Linked list of CIEs for this object. */
1044 struct dwarf2_cie *cie;
1045
1046 /* Pointer to the .debug_frame section loaded into memory. */
1047 gdb_byte *dwarf_frame_buffer;
1048
1049 /* Length of the loaded .debug_frame section. */
1050 unsigned long dwarf_frame_size;
1051
1052 /* Pointer to the .debug_frame section. */
1053 asection *dwarf_frame_section;
1054
1055 /* Base for DW_EH_PE_datarel encodings. */
1056 bfd_vma dbase;
1057
1058 /* Base for DW_EH_PE_textrel encodings. */
1059 bfd_vma tbase;
1060};
1061
1062const struct objfile_data *dwarf2_frame_objfile_data;
1063
1064static unsigned int
1065read_1_byte (bfd *abfd, gdb_byte *buf)
1066{
1067 return bfd_get_8 (abfd, buf);
1068}
1069
1070static unsigned int
1071read_4_bytes (bfd *abfd, gdb_byte *buf)
1072{
1073 return bfd_get_32 (abfd, buf);
1074}
1075
1076static ULONGEST
1077read_8_bytes (bfd *abfd, gdb_byte *buf)
1078{
1079 return bfd_get_64 (abfd, buf);
1080}
1081
1082static ULONGEST
1083read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1084{
1085 ULONGEST result;
1086 unsigned int num_read;
1087 int shift;
1088 gdb_byte byte;
1089
1090 result = 0;
1091 shift = 0;
1092 num_read = 0;
1093
1094 do
1095 {
1096 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1097 buf++;
1098 num_read++;
1099 result |= ((byte & 0x7f) << shift);
1100 shift += 7;
1101 }
1102 while (byte & 0x80);
1103
1104 *bytes_read_ptr = num_read;
1105
1106 return result;
1107}
1108
1109static LONGEST
1110read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1111{
1112 LONGEST result;
1113 int shift;
1114 unsigned int num_read;
1115 gdb_byte byte;
1116
1117 result = 0;
1118 shift = 0;
1119 num_read = 0;
1120
1121 do
1122 {
1123 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1124 buf++;
1125 num_read++;
1126 result |= ((byte & 0x7f) << shift);
1127 shift += 7;
1128 }
1129 while (byte & 0x80);
1130
1131 if (shift < 8 * sizeof (result) && (byte & 0x40))
1132 result |= -(((LONGEST)1) << shift);
1133
1134 *bytes_read_ptr = num_read;
1135
1136 return result;
1137}
1138
1139static ULONGEST
1140read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1141{
1142 LONGEST result;
1143
1144 result = bfd_get_32 (abfd, buf);
1145 if (result == 0xffffffff)
1146 {
1147 result = bfd_get_64 (abfd, buf + 4);
1148 *bytes_read_ptr = 12;
1149 }
1150 else
1151 *bytes_read_ptr = 4;
1152
1153 return result;
1154}
1155\f
1156
1157/* Pointer encoding helper functions. */
1158
1159/* GCC supports exception handling based on DWARF2 CFI. However, for
1160 technical reasons, it encodes addresses in its FDE's in a different
1161 way. Several "pointer encodings" are supported. The encoding
1162 that's used for a particular FDE is determined by the 'R'
1163 augmentation in the associated CIE. The argument of this
1164 augmentation is a single byte.
1165
1166 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1167 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1168 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1169 address should be interpreted (absolute, relative to the current
1170 position in the FDE, ...). Bit 7, indicates that the address
1171 should be dereferenced. */
1172
1173static gdb_byte
1174encoding_for_size (unsigned int size)
1175{
1176 switch (size)
1177 {
1178 case 2:
1179 return DW_EH_PE_udata2;
1180 case 4:
1181 return DW_EH_PE_udata4;
1182 case 8:
1183 return DW_EH_PE_udata8;
1184 default:
1185 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1186 }
1187}
1188
1189static unsigned int
1190size_of_encoded_value (gdb_byte encoding)
1191{
1192 if (encoding == DW_EH_PE_omit)
1193 return 0;
1194
1195 switch (encoding & 0x07)
1196 {
1197 case DW_EH_PE_absptr:
1198 return TYPE_LENGTH (builtin_type_void_data_ptr);
1199 case DW_EH_PE_udata2:
1200 return 2;
1201 case DW_EH_PE_udata4:
1202 return 4;
1203 case DW_EH_PE_udata8:
1204 return 8;
1205 default:
1206 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1207 }
1208}
1209
1210static CORE_ADDR
1211read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1212 gdb_byte *buf, unsigned int *bytes_read_ptr)
1213{
1214 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1215 ptrdiff_t offset;
1216 CORE_ADDR base;
1217
1218 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1219 FDE's. */
1220 if (encoding & DW_EH_PE_indirect)
1221 internal_error (__FILE__, __LINE__,
1222 _("Unsupported encoding: DW_EH_PE_indirect"));
1223
1224 *bytes_read_ptr = 0;
1225
1226 switch (encoding & 0x70)
1227 {
1228 case DW_EH_PE_absptr:
1229 base = 0;
1230 break;
1231 case DW_EH_PE_pcrel:
1232 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1233 base += (buf - unit->dwarf_frame_buffer);
1234 break;
1235 case DW_EH_PE_datarel:
1236 base = unit->dbase;
1237 break;
1238 case DW_EH_PE_textrel:
1239 base = unit->tbase;
1240 break;
1241 case DW_EH_PE_funcrel:
1242 /* FIXME: kettenis/20040501: For now just pretend
1243 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1244 reading the initial location of an FDE it should be treated
1245 as such, and currently that's the only place where this code
1246 is used. */
1247 base = 0;
1248 break;
1249 case DW_EH_PE_aligned:
1250 base = 0;
1251 offset = buf - unit->dwarf_frame_buffer;
1252 if ((offset % ptr_len) != 0)
1253 {
1254 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1255 buf += *bytes_read_ptr;
1256 }
1257 break;
1258 default:
1259 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1260 }
1261
1262 if ((encoding & 0x07) == 0x00)
1263 encoding |= encoding_for_size (ptr_len);
1264
1265 switch (encoding & 0x0f)
1266 {
1267 case DW_EH_PE_uleb128:
1268 {
1269 ULONGEST value;
1270 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1271 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1272 return base + value;
1273 }
1274 case DW_EH_PE_udata2:
1275 *bytes_read_ptr += 2;
1276 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1277 case DW_EH_PE_udata4:
1278 *bytes_read_ptr += 4;
1279 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1280 case DW_EH_PE_udata8:
1281 *bytes_read_ptr += 8;
1282 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1283 case DW_EH_PE_sleb128:
1284 {
1285 LONGEST value;
1286 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1287 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1288 return base + value;
1289 }
1290 case DW_EH_PE_sdata2:
1291 *bytes_read_ptr += 2;
1292 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1293 case DW_EH_PE_sdata4:
1294 *bytes_read_ptr += 4;
1295 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1296 case DW_EH_PE_sdata8:
1297 *bytes_read_ptr += 8;
1298 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1299 default:
1300 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1301 }
1302}
1303\f
1304
1305/* GCC uses a single CIE for all FDEs in a .debug_frame section.
1306 That's why we use a simple linked list here. */
1307
1308static struct dwarf2_cie *
1309find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1310{
1311 struct dwarf2_cie *cie = unit->cie;
1312
1313 while (cie)
1314 {
1315 if (cie->cie_pointer == cie_pointer)
1316 return cie;
1317
1318 cie = cie->next;
1319 }
1320
1321 return NULL;
1322}
1323
1324static void
1325add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1326{
1327 cie->next = unit->cie;
1328 unit->cie = cie;
1329}
1330
1331/* Find the FDE for *PC. Return a pointer to the FDE, and store the
1332 inital location associated with it into *PC. */
1333
1334static struct dwarf2_fde *
1335dwarf2_frame_find_fde (CORE_ADDR *pc)
1336{
1337 struct objfile *objfile;
1338
1339 ALL_OBJFILES (objfile)
1340 {
1341 struct dwarf2_fde *fde;
1342 CORE_ADDR offset;
1343
1344 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1345 if (fde == NULL)
1346 continue;
1347
1348 gdb_assert (objfile->section_offsets);
1349 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1350
1351 while (fde)
1352 {
1353 if (*pc >= fde->initial_location + offset
1354 && *pc < fde->initial_location + offset + fde->address_range)
1355 {
1356 *pc = fde->initial_location + offset;
1357 return fde;
1358 }
1359
1360 fde = fde->next;
1361 }
1362 }
1363
1364 return NULL;
1365}
1366
1367static void
1368add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1369{
1370 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1371 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1372}
1373
1374#ifdef CC_HAS_LONG_LONG
1375#define DW64_CIE_ID 0xffffffffffffffffULL
1376#else
1377#define DW64_CIE_ID ~0
1378#endif
1379
1380static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1381 int eh_frame_p);
1382
1383/* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1384 the next byte to be processed. */
1385static gdb_byte *
1386decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1387{
1388 gdb_byte *buf, *end;
1389 LONGEST length;
1390 unsigned int bytes_read;
1391 int dwarf64_p;
1392 ULONGEST cie_id;
1393 ULONGEST cie_pointer;
1394
1395 buf = start;
1396 length = read_initial_length (unit->abfd, buf, &bytes_read);
1397 buf += bytes_read;
1398 end = buf + length;
1399
1400 /* Are we still within the section? */
1401 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1402 return NULL;
1403
1404 if (length == 0)
1405 return end;
1406
1407 /* Distinguish between 32 and 64-bit encoded frame info. */
1408 dwarf64_p = (bytes_read == 12);
1409
1410 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1411 if (eh_frame_p)
1412 cie_id = 0;
1413 else if (dwarf64_p)
1414 cie_id = DW64_CIE_ID;
1415 else
1416 cie_id = DW_CIE_ID;
1417
1418 if (dwarf64_p)
1419 {
1420 cie_pointer = read_8_bytes (unit->abfd, buf);
1421 buf += 8;
1422 }
1423 else
1424 {
1425 cie_pointer = read_4_bytes (unit->abfd, buf);
1426 buf += 4;
1427 }
1428
1429 if (cie_pointer == cie_id)
1430 {
1431 /* This is a CIE. */
1432 struct dwarf2_cie *cie;
1433 char *augmentation;
1434 unsigned int cie_version;
1435
1436 /* Record the offset into the .debug_frame section of this CIE. */
1437 cie_pointer = start - unit->dwarf_frame_buffer;
1438
1439 /* Check whether we've already read it. */
1440 if (find_cie (unit, cie_pointer))
1441 return end;
1442
1443 cie = (struct dwarf2_cie *)
1444 obstack_alloc (&unit->objfile->objfile_obstack,
1445 sizeof (struct dwarf2_cie));
1446 cie->initial_instructions = NULL;
1447 cie->cie_pointer = cie_pointer;
1448
1449 /* The encoding for FDE's in a normal .debug_frame section
1450 depends on the target address size. */
1451 cie->encoding = DW_EH_PE_absptr;
1452
1453 /* Check version number. */
1454 cie_version = read_1_byte (unit->abfd, buf);
1455 if (cie_version != 1 && cie_version != 3)
1456 return NULL;
1457 buf += 1;
1458
1459 /* Interpret the interesting bits of the augmentation. */
1460 augmentation = (char *) buf;
1461 buf += (strlen (augmentation) + 1);
1462
1463 /* The GCC 2.x "eh" augmentation has a pointer immediately
1464 following the augmentation string, so it must be handled
1465 first. */
1466 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1467 {
1468 /* Skip. */
1469 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1470 augmentation += 2;
1471 }
1472
1473 cie->code_alignment_factor =
1474 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1475 buf += bytes_read;
1476
1477 cie->data_alignment_factor =
1478 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1479 buf += bytes_read;
1480
1481 if (cie_version == 1)
1482 {
1483 cie->return_address_register = read_1_byte (unit->abfd, buf);
1484 bytes_read = 1;
1485 }
1486 else
1487 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1488 &bytes_read);
1489 buf += bytes_read;
1490
1491 cie->saw_z_augmentation = (*augmentation == 'z');
1492 if (cie->saw_z_augmentation)
1493 {
1494 ULONGEST length;
1495
1496 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1497 buf += bytes_read;
1498 if (buf > end)
1499 return NULL;
1500 cie->initial_instructions = buf + length;
1501 augmentation++;
1502 }
1503
1504 while (*augmentation)
1505 {
1506 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1507 if (*augmentation == 'L')
1508 {
1509 /* Skip. */
1510 buf++;
1511 augmentation++;
1512 }
1513
1514 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1515 else if (*augmentation == 'R')
1516 {
1517 cie->encoding = *buf++;
1518 augmentation++;
1519 }
1520
1521 /* "P" indicates a personality routine in the CIE augmentation. */
1522 else if (*augmentation == 'P')
1523 {
1524 /* Skip. Avoid indirection since we throw away the result. */
1525 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1526 read_encoded_value (unit, encoding, buf, &bytes_read);
1527 buf += bytes_read;
1528 augmentation++;
1529 }
1530
1531 /* Otherwise we have an unknown augmentation.
1532 Bail out unless we saw a 'z' prefix. */
1533 else
1534 {
1535 if (cie->initial_instructions == NULL)
1536 return end;
1537
1538 /* Skip unknown augmentations. */
1539 buf = cie->initial_instructions;
1540 break;
1541 }
1542 }
1543
1544 cie->initial_instructions = buf;
1545 cie->end = end;
1546
1547 add_cie (unit, cie);
1548 }
1549 else
1550 {
1551 /* This is a FDE. */
1552 struct dwarf2_fde *fde;
1553
1554 /* In an .eh_frame section, the CIE pointer is the delta between the
1555 address within the FDE where the CIE pointer is stored and the
1556 address of the CIE. Convert it to an offset into the .eh_frame
1557 section. */
1558 if (eh_frame_p)
1559 {
1560 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1561 cie_pointer -= (dwarf64_p ? 8 : 4);
1562 }
1563
1564 /* In either case, validate the result is still within the section. */
1565 if (cie_pointer >= unit->dwarf_frame_size)
1566 return NULL;
1567
1568 fde = (struct dwarf2_fde *)
1569 obstack_alloc (&unit->objfile->objfile_obstack,
1570 sizeof (struct dwarf2_fde));
1571 fde->cie = find_cie (unit, cie_pointer);
1572 if (fde->cie == NULL)
1573 {
1574 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1575 eh_frame_p);
1576 fde->cie = find_cie (unit, cie_pointer);
1577 }
1578
1579 gdb_assert (fde->cie != NULL);
1580
1581 fde->initial_location =
1582 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1583 buf += bytes_read;
1584
1585 fde->address_range =
1586 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1587 buf += bytes_read;
1588
1589 /* A 'z' augmentation in the CIE implies the presence of an
1590 augmentation field in the FDE as well. The only thing known
1591 to be in here at present is the LSDA entry for EH. So we
1592 can skip the whole thing. */
1593 if (fde->cie->saw_z_augmentation)
1594 {
1595 ULONGEST length;
1596
1597 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1598 buf += bytes_read + length;
1599 if (buf > end)
1600 return NULL;
1601 }
1602
1603 fde->instructions = buf;
1604 fde->end = end;
1605
1606 add_fde (unit, fde);
1607 }
1608
1609 return end;
1610}
1611
1612/* Read a CIE or FDE in BUF and decode it. */
1613static gdb_byte *
1614decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1615{
1616 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1617 gdb_byte *ret;
1618 const char *msg;
1619 ptrdiff_t start_offset;
1620
1621 while (1)
1622 {
1623 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1624 if (ret != NULL)
1625 break;
1626
1627 /* We have corrupt input data of some form. */
1628
1629 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1630 and mismatches wrt padding and alignment of debug sections. */
1631 /* Note that there is no requirement in the standard for any
1632 alignment at all in the frame unwind sections. Testing for
1633 alignment before trying to interpret data would be incorrect.
1634
1635 However, GCC traditionally arranged for frame sections to be
1636 sized such that the FDE length and CIE fields happen to be
1637 aligned (in theory, for performance). This, unfortunately,
1638 was done with .align directives, which had the side effect of
1639 forcing the section to be aligned by the linker.
1640
1641 This becomes a problem when you have some other producer that
1642 creates frame sections that are not as strictly aligned. That
1643 produces a hole in the frame info that gets filled by the
1644 linker with zeros.
1645
1646 The GCC behaviour is arguably a bug, but it's effectively now
1647 part of the ABI, so we're now stuck with it, at least at the
1648 object file level. A smart linker may decide, in the process
1649 of compressing duplicate CIE information, that it can rewrite
1650 the entire output section without this extra padding. */
1651
1652 start_offset = start - unit->dwarf_frame_buffer;
1653 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1654 {
1655 start += 4 - (start_offset & 3);
1656 workaround = ALIGN4;
1657 continue;
1658 }
1659 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1660 {
1661 start += 8 - (start_offset & 7);
1662 workaround = ALIGN8;
1663 continue;
1664 }
1665
1666 /* Nothing left to try. Arrange to return as if we've consumed
1667 the entire input section. Hopefully we'll get valid info from
1668 the other of .debug_frame/.eh_frame. */
1669 workaround = FAIL;
1670 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1671 break;
1672 }
1673
1674 switch (workaround)
1675 {
1676 case NONE:
1677 break;
1678
1679 case ALIGN4:
1680 complaint (&symfile_complaints,
1681 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1682 unit->dwarf_frame_section->owner->filename,
1683 unit->dwarf_frame_section->name);
1684 break;
1685
1686 case ALIGN8:
1687 complaint (&symfile_complaints,
1688 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1689 unit->dwarf_frame_section->owner->filename,
1690 unit->dwarf_frame_section->name);
1691 break;
1692
1693 default:
1694 complaint (&symfile_complaints,
1695 _("Corrupt data in %s:%s"),
1696 unit->dwarf_frame_section->owner->filename,
1697 unit->dwarf_frame_section->name);
1698 break;
1699 }
1700
1701 return ret;
1702}
1703\f
1704
1705/* FIXME: kettenis/20030504: This still needs to be integrated with
1706 dwarf2read.c in a better way. */
1707
1708/* Imported from dwarf2read.c. */
1709extern asection *dwarf_frame_section;
1710extern asection *dwarf_eh_frame_section;
1711
1712/* Imported from dwarf2read.c. */
1713extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1714
1715void
1716dwarf2_build_frame_info (struct objfile *objfile)
1717{
1718 struct comp_unit unit;
1719 gdb_byte *frame_ptr;
1720
1721 /* Build a minimal decoding of the DWARF2 compilation unit. */
1722 unit.abfd = objfile->obfd;
1723 unit.objfile = objfile;
1724 unit.dbase = 0;
1725 unit.tbase = 0;
1726
1727 /* First add the information from the .eh_frame section. That way,
1728 the FDEs from that section are searched last. */
1729 if (dwarf_eh_frame_section)
1730 {
1731 asection *got, *txt;
1732
1733 unit.cie = NULL;
1734 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1735 dwarf_eh_frame_section);
1736
1737 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1738 unit.dwarf_frame_section = dwarf_eh_frame_section;
1739
1740 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1741 that is used for the i386/amd64 target, which currently is
1742 the only target in GCC that supports/uses the
1743 DW_EH_PE_datarel encoding. */
1744 got = bfd_get_section_by_name (unit.abfd, ".got");
1745 if (got)
1746 unit.dbase = got->vma;
1747
1748 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1749 so far. */
1750 txt = bfd_get_section_by_name (unit.abfd, ".text");
1751 if (txt)
1752 unit.tbase = txt->vma;
1753
1754 frame_ptr = unit.dwarf_frame_buffer;
1755 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1756 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
1757 }
1758
1759 if (dwarf_frame_section)
1760 {
1761 unit.cie = NULL;
1762 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1763 dwarf_frame_section);
1764 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1765 unit.dwarf_frame_section = dwarf_frame_section;
1766
1767 frame_ptr = unit.dwarf_frame_buffer;
1768 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1769 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1770 }
1771}
1772
1773/* Provide a prototype to silence -Wmissing-prototypes. */
1774void _initialize_dwarf2_frame (void);
1775
1776void
1777_initialize_dwarf2_frame (void)
1778{
1779 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
1780 dwarf2_frame_objfile_data = register_objfile_data ();
1781}
GDB Binutils - Deliverables
This page took 0.033498 seconds and 4 git commands to generate.