1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
5 Contributed by Mark Kettenis.
7 This file is part of GDB.
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.
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.
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. */
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
37 #include "gdb_assert.h"
38 #include "gdb_string.h"
40 #include "complaints.h"
41 #include "dwarf2-frame.h"
43 /* Call Frame Information (CFI). */
45 /* Common Information Entry (CIE). */
49 /* Offset into the .debug_frame section where this CIE was found.
50 Used to identify this CIE. */
53 /* Constant that is factored out of all advance location
55 ULONGEST code_alignment_factor;
57 /* Constants that is factored out of all offset instructions. */
58 LONGEST data_alignment_factor;
60 /* Return address column. */
61 ULONGEST return_address_register;
63 /* Instruction sequence to initialize a register set. */
64 gdb_byte *initial_instructions;
67 /* Saved augmentation, in case it's needed later. */
70 /* Encoding of addresses. */
73 /* True if a 'z' augmentation existed. */
74 unsigned char saw_z_augmentation;
76 /* True if an 'S' augmentation existed. */
77 unsigned char signal_frame;
79 /* The version recorded in the CIE. */
80 unsigned char version;
82 struct dwarf2_cie *next;
85 /* Frame Description Entry (FDE). */
89 /* CIE for this FDE. */
90 struct dwarf2_cie *cie;
92 /* First location associated with this FDE. */
93 CORE_ADDR initial_location;
95 /* Number of bytes of program instructions described by this FDE. */
96 CORE_ADDR address_range;
98 /* Instruction sequence. */
99 gdb_byte *instructions;
102 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
104 unsigned char eh_frame_p;
106 struct dwarf2_fde *next;
109 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
111 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
115 /* Structure describing a frame state. */
117 struct dwarf2_frame_state
119 /* Each register save state can be described in terms of a CFA slot,
120 another register, or a location expression. */
121 struct dwarf2_frame_state_reg_info
123 struct dwarf2_frame_state_reg *reg;
126 /* Used to implement DW_CFA_remember_state. */
127 struct dwarf2_frame_state_reg_info *prev;
139 /* The PC described by the current frame state. */
142 /* Initial register set from the CIE.
143 Used to implement DW_CFA_restore. */
144 struct dwarf2_frame_state_reg_info initial;
146 /* The information we care about from the CIE. */
149 ULONGEST retaddr_column;
151 /* Flags for known producer quirks. */
153 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
154 and DW_CFA_def_cfa_offset takes a factored offset. */
155 int armcc_cfa_offsets_sf;
157 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
158 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
159 int armcc_cfa_offsets_reversed;
162 /* Store the length the expression for the CFA in the `cfa_reg' field,
163 which is unused in that case. */
164 #define cfa_exp_len cfa_reg
166 /* Assert that the register set RS is large enough to store gdbarch_num_regs
167 columns. If necessary, enlarge the register set. */
170 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
173 size_t size = sizeof (struct dwarf2_frame_state_reg);
175 if (num_regs <= rs->num_regs)
178 rs->reg = (struct dwarf2_frame_state_reg *)
179 xrealloc (rs->reg, num_regs * size);
181 /* Initialize newly allocated registers. */
182 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
183 rs->num_regs = num_regs;
186 /* Copy the register columns in register set RS into newly allocated
187 memory and return a pointer to this newly created copy. */
189 static struct dwarf2_frame_state_reg *
190 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
192 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
193 struct dwarf2_frame_state_reg *reg;
195 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
196 memcpy (reg, rs->reg, size);
201 /* Release the memory allocated to register set RS. */
204 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
208 dwarf2_frame_state_free_regs (rs->prev);
215 /* Release the memory allocated to the frame state FS. */
218 dwarf2_frame_state_free (void *p)
220 struct dwarf2_frame_state *fs = p;
222 dwarf2_frame_state_free_regs (fs->initial.prev);
223 dwarf2_frame_state_free_regs (fs->regs.prev);
224 xfree (fs->initial.reg);
225 xfree (fs->regs.reg);
230 /* Helper functions for execute_stack_op. */
233 read_reg (void *baton, int reg)
235 struct frame_info *next_frame = (struct frame_info *) baton;
236 struct gdbarch *gdbarch = get_frame_arch (next_frame);
240 regnum = DWARF2_REG_TO_REGNUM (reg);
242 buf = alloca (register_size (gdbarch, regnum));
243 frame_unwind_register (next_frame, regnum, buf);
245 /* Convert the register to an integer. This returns a LONGEST
246 rather than a CORE_ADDR, but unpack_pointer does the same thing
247 under the covers, and this makes more sense for non-pointer
248 registers. Maybe read_reg and the associated interfaces should
249 deal with "struct value" instead of CORE_ADDR. */
250 return unpack_long (register_type (gdbarch, regnum), buf);
254 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
256 read_memory (addr, buf, len);
260 no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
262 internal_error (__FILE__, __LINE__,
263 _("Support for DW_OP_fbreg is unimplemented"));
267 no_get_tls_address (void *baton, CORE_ADDR offset)
269 internal_error (__FILE__, __LINE__,
270 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
274 execute_stack_op (gdb_byte *exp, ULONGEST len,
275 struct frame_info *next_frame, CORE_ADDR initial)
277 struct dwarf_expr_context *ctx;
280 ctx = new_dwarf_expr_context ();
281 ctx->baton = next_frame;
282 ctx->read_reg = read_reg;
283 ctx->read_mem = read_mem;
284 ctx->get_frame_base = no_get_frame_base;
285 ctx->get_tls_address = no_get_tls_address;
287 dwarf_expr_push (ctx, initial);
288 dwarf_expr_eval (ctx, exp, len);
289 result = dwarf_expr_fetch (ctx, 0);
292 result = read_reg (next_frame, result);
294 free_dwarf_expr_context (ctx);
301 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
302 struct frame_info *next_frame,
303 struct dwarf2_frame_state *fs, int eh_frame_p)
305 CORE_ADDR pc = frame_pc_unwind (next_frame);
307 struct gdbarch *gdbarch = get_frame_arch (next_frame);
309 while (insn_ptr < insn_end && fs->pc <= pc)
311 gdb_byte insn = *insn_ptr++;
315 if ((insn & 0xc0) == DW_CFA_advance_loc)
316 fs->pc += (insn & 0x3f) * fs->code_align;
317 else if ((insn & 0xc0) == DW_CFA_offset)
320 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
321 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
322 offset = utmp * fs->data_align;
323 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
324 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
325 fs->regs.reg[reg].loc.offset = offset;
327 else if ((insn & 0xc0) == DW_CFA_restore)
329 gdb_assert (fs->initial.reg);
331 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
332 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
333 if (reg < fs->initial.num_regs)
334 fs->regs.reg[reg] = fs->initial.reg[reg];
336 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
338 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
339 complaint (&symfile_complaints, _("\
340 incomplete CFI data; DW_CFA_restore unspecified\n\
341 register %s (#%d) at 0x%s"),
342 gdbarch_register_name
343 (current_gdbarch, DWARF2_REG_TO_REGNUM(reg)),
344 DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
351 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
352 insn_ptr += bytes_read;
355 case DW_CFA_advance_loc1:
356 utmp = extract_unsigned_integer (insn_ptr, 1);
357 fs->pc += utmp * fs->code_align;
360 case DW_CFA_advance_loc2:
361 utmp = extract_unsigned_integer (insn_ptr, 2);
362 fs->pc += utmp * fs->code_align;
365 case DW_CFA_advance_loc4:
366 utmp = extract_unsigned_integer (insn_ptr, 4);
367 fs->pc += utmp * fs->code_align;
371 case DW_CFA_offset_extended:
372 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
373 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
374 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
375 offset = utmp * fs->data_align;
376 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
377 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
378 fs->regs.reg[reg].loc.offset = offset;
381 case DW_CFA_restore_extended:
382 gdb_assert (fs->initial.reg);
383 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
384 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
385 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
386 fs->regs.reg[reg] = fs->initial.reg[reg];
389 case DW_CFA_undefined:
390 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
391 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
392 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
393 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
396 case DW_CFA_same_value:
397 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
398 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
399 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
400 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
403 case DW_CFA_register:
404 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
405 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
406 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
407 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
408 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
409 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
410 fs->regs.reg[reg].loc.reg = utmp;
413 case DW_CFA_remember_state:
415 struct dwarf2_frame_state_reg_info *new_rs;
417 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
419 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
420 fs->regs.prev = new_rs;
424 case DW_CFA_restore_state:
426 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
430 complaint (&symfile_complaints, _("\
431 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
435 xfree (fs->regs.reg);
443 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
444 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
446 if (fs->armcc_cfa_offsets_sf)
447 utmp *= fs->data_align;
449 fs->cfa_offset = utmp;
450 fs->cfa_how = CFA_REG_OFFSET;
453 case DW_CFA_def_cfa_register:
454 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
455 fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
457 fs->cfa_how = CFA_REG_OFFSET;
460 case DW_CFA_def_cfa_offset:
461 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
463 if (fs->armcc_cfa_offsets_sf)
464 utmp *= fs->data_align;
466 fs->cfa_offset = utmp;
467 /* cfa_how deliberately not set. */
473 case DW_CFA_def_cfa_expression:
474 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
475 fs->cfa_exp = insn_ptr;
476 fs->cfa_how = CFA_EXP;
477 insn_ptr += fs->cfa_exp_len;
480 case DW_CFA_expression:
481 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
482 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
483 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
484 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
485 fs->regs.reg[reg].loc.exp = insn_ptr;
486 fs->regs.reg[reg].exp_len = utmp;
487 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
491 case DW_CFA_offset_extended_sf:
492 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
493 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
494 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
495 offset *= fs->data_align;
496 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
497 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
498 fs->regs.reg[reg].loc.offset = offset;
501 case DW_CFA_val_offset:
502 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
503 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
504 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
505 offset = utmp * fs->data_align;
506 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
507 fs->regs.reg[reg].loc.offset = offset;
510 case DW_CFA_val_offset_sf:
511 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
512 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
513 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
514 offset *= fs->data_align;
515 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
516 fs->regs.reg[reg].loc.offset = offset;
519 case DW_CFA_val_expression:
520 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
521 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
522 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
523 fs->regs.reg[reg].loc.exp = insn_ptr;
524 fs->regs.reg[reg].exp_len = utmp;
525 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
529 case DW_CFA_def_cfa_sf:
530 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
531 fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
533 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
534 fs->cfa_offset = offset * fs->data_align;
535 fs->cfa_how = CFA_REG_OFFSET;
538 case DW_CFA_def_cfa_offset_sf:
539 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
540 fs->cfa_offset = offset * fs->data_align;
541 /* cfa_how deliberately not set. */
544 case DW_CFA_GNU_window_save:
545 /* This is SPARC-specific code, and contains hard-coded
546 constants for the register numbering scheme used by
547 GCC. Rather than having a architecture-specific
548 operation that's only ever used by a single
549 architecture, we provide the implementation here.
550 Incidentally that's what GCC does too in its
553 struct gdbarch *gdbarch = get_frame_arch (next_frame);
554 int size = register_size(gdbarch, 0);
555 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
556 for (reg = 8; reg < 16; reg++)
558 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
559 fs->regs.reg[reg].loc.reg = reg + 16;
561 for (reg = 16; reg < 32; reg++)
563 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
564 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
569 case DW_CFA_GNU_args_size:
571 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
574 case DW_CFA_GNU_negative_offset_extended:
575 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
576 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
577 insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
578 offset *= fs->data_align;
579 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
580 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
581 fs->regs.reg[reg].loc.offset = -offset;
585 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
590 /* Don't allow remember/restore between CIE and FDE programs. */
591 dwarf2_frame_state_free_regs (fs->regs.prev);
592 fs->regs.prev = NULL;
596 /* Architecture-specific operations. */
598 /* Per-architecture data key. */
599 static struct gdbarch_data *dwarf2_frame_data;
601 struct dwarf2_frame_ops
603 /* Pre-initialize the register state REG for register REGNUM. */
604 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
605 struct frame_info *);
607 /* Check whether the frame preceding NEXT_FRAME will be a signal
609 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
611 /* Convert .eh_frame register number to DWARF register number, or
612 adjust .debug_frame register number. */
613 int (*adjust_regnum) (struct gdbarch *, int, int);
616 /* Default architecture-specific register state initialization
620 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
621 struct dwarf2_frame_state_reg *reg,
622 struct frame_info *next_frame)
624 /* If we have a register that acts as a program counter, mark it as
625 a destination for the return address. If we have a register that
626 serves as the stack pointer, arrange for it to be filled with the
627 call frame address (CFA). The other registers are marked as
630 We copy the return address to the program counter, since many
631 parts in GDB assume that it is possible to get the return address
632 by unwinding the program counter register. However, on ISA's
633 with a dedicated return address register, the CFI usually only
634 contains information to unwind that return address register.
636 The reason we're treating the stack pointer special here is
637 because in many cases GCC doesn't emit CFI for the stack pointer
638 and implicitly assumes that it is equal to the CFA. This makes
639 some sense since the DWARF specification (version 3, draft 8,
642 "Typically, the CFA is defined to be the value of the stack
643 pointer at the call site in the previous frame (which may be
644 different from its value on entry to the current frame)."
646 However, this isn't true for all platforms supported by GCC
647 (e.g. IBM S/390 and zSeries). Those architectures should provide
648 their own architecture-specific initialization function. */
650 if (regnum == PC_REGNUM)
651 reg->how = DWARF2_FRAME_REG_RA;
652 else if (regnum == SP_REGNUM)
653 reg->how = DWARF2_FRAME_REG_CFA;
656 /* Return a default for the architecture-specific operations. */
659 dwarf2_frame_init (struct obstack *obstack)
661 struct dwarf2_frame_ops *ops;
663 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
664 ops->init_reg = dwarf2_frame_default_init_reg;
668 /* Set the architecture-specific register state initialization
669 function for GDBARCH to INIT_REG. */
672 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
673 void (*init_reg) (struct gdbarch *, int,
674 struct dwarf2_frame_state_reg *,
675 struct frame_info *))
677 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
679 ops->init_reg = init_reg;
682 /* Pre-initialize the register state REG for register REGNUM. */
685 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
686 struct dwarf2_frame_state_reg *reg,
687 struct frame_info *next_frame)
689 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
691 ops->init_reg (gdbarch, regnum, reg, next_frame);
694 /* Set the architecture-specific signal trampoline recognition
695 function for GDBARCH to SIGNAL_FRAME_P. */
698 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
699 int (*signal_frame_p) (struct gdbarch *,
700 struct frame_info *))
702 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
704 ops->signal_frame_p = signal_frame_p;
707 /* Query the architecture-specific signal frame recognizer for
711 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
712 struct frame_info *next_frame)
714 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
716 if (ops->signal_frame_p == NULL)
718 return ops->signal_frame_p (gdbarch, next_frame);
721 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
725 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
726 int (*adjust_regnum) (struct gdbarch *,
729 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
731 ops->adjust_regnum = adjust_regnum;
734 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
738 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p)
740 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
742 if (ops->adjust_regnum == NULL)
744 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
748 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
749 struct dwarf2_fde *fde)
751 static const char *arm_idents[] = {
752 "ARM C Compiler, ADS",
753 "Thumb C Compiler, ADS",
754 "ARM C++ Compiler, ADS",
755 "Thumb C++ Compiler, ADS",
756 "ARM/Thumb C/C++ Compiler, RVCT"
762 s = find_pc_symtab (fs->pc);
763 if (s == NULL || s->producer == NULL)
766 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
767 if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
769 if (fde->cie->version == 1)
770 fs->armcc_cfa_offsets_sf = 1;
772 if (fde->cie->version == 1)
773 fs->armcc_cfa_offsets_reversed = 1;
775 /* The reversed offset problem is present in some compilers
776 using DWARF3, but it was eventually fixed. Check the ARM
777 defined augmentations, which are in the format "armcc" followed
778 by a list of one-character options. The "+" option means
779 this problem is fixed (no quirk needed). If the armcc
780 augmentation is missing, the quirk is needed. */
781 if (fde->cie->version == 3
782 && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
783 || strchr (fde->cie->augmentation + 5, '+') == NULL))
784 fs->armcc_cfa_offsets_reversed = 1;
791 struct dwarf2_frame_cache
793 /* DWARF Call Frame Address. */
796 /* Set if the return address column was marked as undefined. */
797 int undefined_retaddr;
799 /* Saved registers, indexed by GDB register number, not by DWARF
801 struct dwarf2_frame_state_reg *reg;
803 /* Return address register. */
804 struct dwarf2_frame_state_reg retaddr_reg;
807 static struct dwarf2_frame_cache *
808 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
810 struct cleanup *old_chain;
811 struct gdbarch *gdbarch = get_frame_arch (next_frame);
812 const int num_regs = gdbarch_num_regs (current_gdbarch)
813 + gdbarch_num_pseudo_regs (current_gdbarch);
814 struct dwarf2_frame_cache *cache;
815 struct dwarf2_frame_state *fs;
816 struct dwarf2_fde *fde;
821 /* Allocate a new cache. */
822 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
823 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
825 /* Allocate and initialize the frame state. */
826 fs = XMALLOC (struct dwarf2_frame_state);
827 memset (fs, 0, sizeof (struct dwarf2_frame_state));
828 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
832 Note that if NEXT_FRAME is never supposed to return (i.e. a call
833 to abort), the compiler might optimize away the instruction at
834 NEXT_FRAME's return address. As a result the return address will
835 point at some random instruction, and the CFI for that
836 instruction is probably worthless to us. GCC's unwinder solves
837 this problem by substracting 1 from the return address to get an
838 address in the middle of a presumed call instruction (or the
839 instruction in the associated delay slot). This should only be
840 done for "normal" frames and not for resume-type frames (signal
841 handlers, sentinel frames, dummy frames). The function
842 frame_unwind_address_in_block does just this. It's not clear how
843 reliable the method is though; there is the potential for the
844 register state pre-call being different to that on return. */
845 fs->pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
847 /* Find the correct FDE. */
848 fde = dwarf2_frame_find_fde (&fs->pc);
849 gdb_assert (fde != NULL);
851 /* Extract any interesting information from the CIE. */
852 fs->data_align = fde->cie->data_alignment_factor;
853 fs->code_align = fde->cie->code_alignment_factor;
854 fs->retaddr_column = fde->cie->return_address_register;
856 /* Check for "quirks" - known bugs in producers. */
857 dwarf2_frame_find_quirks (fs, fde);
859 /* First decode all the insns in the CIE. */
860 execute_cfa_program (fde->cie->initial_instructions,
861 fde->cie->end, next_frame, fs, fde->eh_frame_p);
863 /* Save the initialized register set. */
864 fs->initial = fs->regs;
865 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
867 /* Then decode the insns in the FDE up to our target PC. */
868 execute_cfa_program (fde->instructions, fde->end, next_frame, fs,
871 /* Caclulate the CFA. */
875 cache->cfa = read_reg (next_frame, fs->cfa_reg);
876 if (fs->armcc_cfa_offsets_reversed)
877 cache->cfa -= fs->cfa_offset;
879 cache->cfa += fs->cfa_offset;
884 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
888 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
891 /* Initialize the register state. */
895 for (regnum = 0; regnum < num_regs; regnum++)
896 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
899 /* Go through the DWARF2 CFI generated table and save its register
900 location information in the cache. Note that we don't skip the
901 return address column; it's perfectly all right for it to
902 correspond to a real register. If it doesn't correspond to a
903 real register, or if we shouldn't treat it as such,
904 DWARF2_REG_TO_REGNUM should be defined to return a number outside
905 the range [0, gdbarch_num_regs). */
907 int column; /* CFI speak for "register number". */
909 for (column = 0; column < fs->regs.num_regs; column++)
911 /* Use the GDB register number as the destination index. */
912 int regnum = DWARF2_REG_TO_REGNUM (column);
914 /* If there's no corresponding GDB register, ignore it. */
915 if (regnum < 0 || regnum >= num_regs)
918 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
919 of all debug info registers. If it doesn't, complain (but
920 not too loudly). It turns out that GCC assumes that an
921 unspecified register implies "same value" when CFI (draft
922 7) specifies nothing at all. Such a register could equally
923 be interpreted as "undefined". Also note that this check
924 isn't sufficient; it only checks that all registers in the
925 range [0 .. max column] are specified, and won't detect
926 problems when a debug info register falls outside of the
927 table. We need a way of iterating through all the valid
928 DWARF2 register numbers. */
929 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
931 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
932 complaint (&symfile_complaints, _("\
933 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
934 gdbarch_register_name (gdbarch, regnum),
938 cache->reg[regnum] = fs->regs.reg[column];
942 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
943 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
947 for (regnum = 0; regnum < num_regs; regnum++)
949 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
950 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
952 struct dwarf2_frame_state_reg *retaddr_reg =
953 &fs->regs.reg[fs->retaddr_column];
955 /* It seems rather bizarre to specify an "empty" column as
956 the return adress column. However, this is exactly
957 what GCC does on some targets. It turns out that GCC
958 assumes that the return address can be found in the
959 register corresponding to the return address column.
960 Incidentally, that's how we should treat a return
961 address column specifying "same value" too. */
962 if (fs->retaddr_column < fs->regs.num_regs
963 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
964 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
966 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
967 cache->reg[regnum] = *retaddr_reg;
969 cache->retaddr_reg = *retaddr_reg;
973 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
975 cache->reg[regnum].loc.reg = fs->retaddr_column;
976 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
980 cache->retaddr_reg.loc.reg = fs->retaddr_column;
981 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
988 if (fs->retaddr_column < fs->regs.num_regs
989 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
990 cache->undefined_retaddr = 1;
992 do_cleanups (old_chain);
999 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
1000 struct frame_id *this_id)
1002 struct dwarf2_frame_cache *cache =
1003 dwarf2_frame_cache (next_frame, this_cache);
1005 if (cache->undefined_retaddr)
1008 (*this_id) = frame_id_build (cache->cfa,
1009 frame_func_unwind (next_frame, NORMAL_FRAME));
1013 dwarf2_signal_frame_this_id (struct frame_info *next_frame, void **this_cache,
1014 struct frame_id *this_id)
1016 struct dwarf2_frame_cache *cache =
1017 dwarf2_frame_cache (next_frame, this_cache);
1019 if (cache->undefined_retaddr)
1022 (*this_id) = frame_id_build (cache->cfa,
1023 frame_func_unwind (next_frame, SIGTRAMP_FRAME));
1027 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
1028 int regnum, int *optimizedp,
1029 enum lval_type *lvalp, CORE_ADDR *addrp,
1030 int *realnump, gdb_byte *valuep)
1032 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1033 struct dwarf2_frame_cache *cache =
1034 dwarf2_frame_cache (next_frame, this_cache);
1036 switch (cache->reg[regnum].how)
1038 case DWARF2_FRAME_REG_UNDEFINED:
1039 /* If CFI explicitly specified that the value isn't defined,
1040 mark it as optimized away; the value isn't available. */
1047 /* In some cases, for example %eflags on the i386, we have
1048 to provide a sane value, even though this register wasn't
1049 saved. Assume we can get it from NEXT_FRAME. */
1050 frame_unwind_register (next_frame, regnum, valuep);
1054 case DWARF2_FRAME_REG_SAVED_OFFSET:
1056 *lvalp = lval_memory;
1057 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
1061 /* Read the value in from memory. */
1062 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1066 case DWARF2_FRAME_REG_SAVED_REG:
1068 *lvalp = lval_register;
1070 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
1072 frame_unwind_register (next_frame, (*realnump), valuep);
1075 case DWARF2_FRAME_REG_SAVED_EXP:
1077 *lvalp = lval_memory;
1078 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
1079 cache->reg[regnum].exp_len,
1080 next_frame, cache->cfa);
1084 /* Read the value in from memory. */
1085 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1089 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1095 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1096 cache->cfa + cache->reg[regnum].loc.offset);
1099 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1105 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1106 execute_stack_op (cache->reg[regnum].loc.exp,
1107 cache->reg[regnum].exp_len,
1108 next_frame, cache->cfa));
1111 case DWARF2_FRAME_REG_UNSPECIFIED:
1112 /* GCC, in its infinite wisdom decided to not provide unwind
1113 information for registers that are "same value". Since
1114 DWARF2 (3 draft 7) doesn't define such behavior, said
1115 registers are actually undefined (which is different to CFI
1116 "undefined"). Code above issues a complaint about this.
1117 Here just fudge the books, assume GCC, and that the value is
1118 more inner on the stack. */
1120 *lvalp = lval_register;
1124 frame_unwind_register (next_frame, (*realnump), valuep);
1127 case DWARF2_FRAME_REG_SAME_VALUE:
1129 *lvalp = lval_register;
1133 frame_unwind_register (next_frame, (*realnump), valuep);
1136 case DWARF2_FRAME_REG_CFA:
1142 pack_long (valuep, register_type (gdbarch, regnum), cache->cfa);
1145 case DWARF2_FRAME_REG_CFA_OFFSET:
1151 pack_long (valuep, register_type (gdbarch, regnum),
1152 cache->cfa + cache->reg[regnum].loc.offset);
1155 case DWARF2_FRAME_REG_RA_OFFSET:
1162 CORE_ADDR pc = cache->reg[regnum].loc.offset;
1164 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
1165 pc += frame_unwind_register_unsigned (next_frame, regnum);
1166 pack_long (valuep, register_type (gdbarch, regnum), pc);
1171 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1175 static const struct frame_unwind dwarf2_frame_unwind =
1178 dwarf2_frame_this_id,
1179 dwarf2_frame_prev_register
1182 static const struct frame_unwind dwarf2_signal_frame_unwind =
1185 dwarf2_signal_frame_this_id,
1186 dwarf2_frame_prev_register
1189 const struct frame_unwind *
1190 dwarf2_frame_sniffer (struct frame_info *next_frame)
1192 /* Grab an address that is guarenteed to reside somewhere within the
1193 function. frame_pc_unwind(), for a no-return next function, can
1194 end up returning something past the end of this function's body.
1195 If the frame we're sniffing for is a signal frame whose start
1196 address is placed on the stack by the OS, its FDE must
1197 extend one byte before its start address or we will miss it. */
1198 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
1200 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1204 /* On some targets, signal trampolines may have unwind information.
1205 We need to recognize them so that we set the frame type
1208 if (fde->cie->signal_frame
1209 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
1211 return &dwarf2_signal_frame_unwind;
1213 return &dwarf2_frame_unwind;
1217 /* There is no explicitly defined relationship between the CFA and the
1218 location of frame's local variables and arguments/parameters.
1219 Therefore, frame base methods on this page should probably only be
1220 used as a last resort, just to avoid printing total garbage as a
1221 response to the "info frame" command. */
1224 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1226 struct dwarf2_frame_cache *cache =
1227 dwarf2_frame_cache (next_frame, this_cache);
1232 static const struct frame_base dwarf2_frame_base =
1234 &dwarf2_frame_unwind,
1235 dwarf2_frame_base_address,
1236 dwarf2_frame_base_address,
1237 dwarf2_frame_base_address
1240 const struct frame_base *
1241 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1243 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
1245 if (dwarf2_frame_find_fde (&block_addr))
1246 return &dwarf2_frame_base;
1251 /* A minimal decoding of DWARF2 compilation units. We only decode
1252 what's needed to get to the call frame information. */
1256 /* Keep the bfd convenient. */
1259 struct objfile *objfile;
1261 /* Linked list of CIEs for this object. */
1262 struct dwarf2_cie *cie;
1264 /* Pointer to the .debug_frame section loaded into memory. */
1265 gdb_byte *dwarf_frame_buffer;
1267 /* Length of the loaded .debug_frame section. */
1268 unsigned long dwarf_frame_size;
1270 /* Pointer to the .debug_frame section. */
1271 asection *dwarf_frame_section;
1273 /* Base for DW_EH_PE_datarel encodings. */
1276 /* Base for DW_EH_PE_textrel encodings. */
1280 const struct objfile_data *dwarf2_frame_objfile_data;
1283 read_1_byte (bfd *abfd, gdb_byte *buf)
1285 return bfd_get_8 (abfd, buf);
1289 read_4_bytes (bfd *abfd, gdb_byte *buf)
1291 return bfd_get_32 (abfd, buf);
1295 read_8_bytes (bfd *abfd, gdb_byte *buf)
1297 return bfd_get_64 (abfd, buf);
1301 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1304 unsigned int num_read;
1314 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1317 result |= ((byte & 0x7f) << shift);
1320 while (byte & 0x80);
1322 *bytes_read_ptr = num_read;
1328 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1332 unsigned int num_read;
1341 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1344 result |= ((byte & 0x7f) << shift);
1347 while (byte & 0x80);
1349 if (shift < 8 * sizeof (result) && (byte & 0x40))
1350 result |= -(((LONGEST)1) << shift);
1352 *bytes_read_ptr = num_read;
1358 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1362 result = bfd_get_32 (abfd, buf);
1363 if (result == 0xffffffff)
1365 result = bfd_get_64 (abfd, buf + 4);
1366 *bytes_read_ptr = 12;
1369 *bytes_read_ptr = 4;
1375 /* Pointer encoding helper functions. */
1377 /* GCC supports exception handling based on DWARF2 CFI. However, for
1378 technical reasons, it encodes addresses in its FDE's in a different
1379 way. Several "pointer encodings" are supported. The encoding
1380 that's used for a particular FDE is determined by the 'R'
1381 augmentation in the associated CIE. The argument of this
1382 augmentation is a single byte.
1384 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1385 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1386 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1387 address should be interpreted (absolute, relative to the current
1388 position in the FDE, ...). Bit 7, indicates that the address
1389 should be dereferenced. */
1392 encoding_for_size (unsigned int size)
1397 return DW_EH_PE_udata2;
1399 return DW_EH_PE_udata4;
1401 return DW_EH_PE_udata8;
1403 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1408 size_of_encoded_value (gdb_byte encoding)
1410 if (encoding == DW_EH_PE_omit)
1413 switch (encoding & 0x07)
1415 case DW_EH_PE_absptr:
1416 return TYPE_LENGTH (builtin_type_void_data_ptr);
1417 case DW_EH_PE_udata2:
1419 case DW_EH_PE_udata4:
1421 case DW_EH_PE_udata8:
1424 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1429 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1430 gdb_byte *buf, unsigned int *bytes_read_ptr)
1432 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1436 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1438 if (encoding & DW_EH_PE_indirect)
1439 internal_error (__FILE__, __LINE__,
1440 _("Unsupported encoding: DW_EH_PE_indirect"));
1442 *bytes_read_ptr = 0;
1444 switch (encoding & 0x70)
1446 case DW_EH_PE_absptr:
1449 case DW_EH_PE_pcrel:
1450 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1451 base += (buf - unit->dwarf_frame_buffer);
1453 case DW_EH_PE_datarel:
1456 case DW_EH_PE_textrel:
1459 case DW_EH_PE_funcrel:
1460 /* FIXME: kettenis/20040501: For now just pretend
1461 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1462 reading the initial location of an FDE it should be treated
1463 as such, and currently that's the only place where this code
1467 case DW_EH_PE_aligned:
1469 offset = buf - unit->dwarf_frame_buffer;
1470 if ((offset % ptr_len) != 0)
1472 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1473 buf += *bytes_read_ptr;
1477 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1480 if ((encoding & 0x07) == 0x00)
1482 encoding |= encoding_for_size (ptr_len);
1483 if (bfd_get_sign_extend_vma (unit->abfd))
1484 encoding |= DW_EH_PE_signed;
1487 switch (encoding & 0x0f)
1489 case DW_EH_PE_uleb128:
1492 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1493 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1494 return base + value;
1496 case DW_EH_PE_udata2:
1497 *bytes_read_ptr += 2;
1498 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1499 case DW_EH_PE_udata4:
1500 *bytes_read_ptr += 4;
1501 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1502 case DW_EH_PE_udata8:
1503 *bytes_read_ptr += 8;
1504 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1505 case DW_EH_PE_sleb128:
1508 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1509 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1510 return base + value;
1512 case DW_EH_PE_sdata2:
1513 *bytes_read_ptr += 2;
1514 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1515 case DW_EH_PE_sdata4:
1516 *bytes_read_ptr += 4;
1517 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1518 case DW_EH_PE_sdata8:
1519 *bytes_read_ptr += 8;
1520 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1522 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1527 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1528 That's why we use a simple linked list here. */
1530 static struct dwarf2_cie *
1531 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1533 struct dwarf2_cie *cie = unit->cie;
1537 if (cie->cie_pointer == cie_pointer)
1547 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1549 cie->next = unit->cie;
1553 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1554 inital location associated with it into *PC. */
1556 static struct dwarf2_fde *
1557 dwarf2_frame_find_fde (CORE_ADDR *pc)
1559 struct objfile *objfile;
1561 ALL_OBJFILES (objfile)
1563 struct dwarf2_fde *fde;
1566 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1570 gdb_assert (objfile->section_offsets);
1571 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1575 if (*pc >= fde->initial_location + offset
1576 && *pc < fde->initial_location + offset + fde->address_range)
1578 *pc = fde->initial_location + offset;
1590 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1592 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1593 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1596 #ifdef CC_HAS_LONG_LONG
1597 #define DW64_CIE_ID 0xffffffffffffffffULL
1599 #define DW64_CIE_ID ~0
1602 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1605 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1606 the next byte to be processed. */
1608 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1610 gdb_byte *buf, *end;
1612 unsigned int bytes_read;
1615 ULONGEST cie_pointer;
1618 length = read_initial_length (unit->abfd, buf, &bytes_read);
1622 /* Are we still within the section? */
1623 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1629 /* Distinguish between 32 and 64-bit encoded frame info. */
1630 dwarf64_p = (bytes_read == 12);
1632 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1636 cie_id = DW64_CIE_ID;
1642 cie_pointer = read_8_bytes (unit->abfd, buf);
1647 cie_pointer = read_4_bytes (unit->abfd, buf);
1651 if (cie_pointer == cie_id)
1653 /* This is a CIE. */
1654 struct dwarf2_cie *cie;
1656 unsigned int cie_version;
1658 /* Record the offset into the .debug_frame section of this CIE. */
1659 cie_pointer = start - unit->dwarf_frame_buffer;
1661 /* Check whether we've already read it. */
1662 if (find_cie (unit, cie_pointer))
1665 cie = (struct dwarf2_cie *)
1666 obstack_alloc (&unit->objfile->objfile_obstack,
1667 sizeof (struct dwarf2_cie));
1668 cie->initial_instructions = NULL;
1669 cie->cie_pointer = cie_pointer;
1671 /* The encoding for FDE's in a normal .debug_frame section
1672 depends on the target address size. */
1673 cie->encoding = DW_EH_PE_absptr;
1675 /* We'll determine the final value later, but we need to
1676 initialize it conservatively. */
1677 cie->signal_frame = 0;
1679 /* Check version number. */
1680 cie_version = read_1_byte (unit->abfd, buf);
1681 if (cie_version != 1 && cie_version != 3)
1683 cie->version = cie_version;
1686 /* Interpret the interesting bits of the augmentation. */
1687 cie->augmentation = augmentation = (char *) buf;
1688 buf += (strlen (augmentation) + 1);
1690 /* Ignore armcc augmentations. We only use them for quirks,
1691 and that doesn't happen until later. */
1692 if (strncmp (augmentation, "armcc", 5) == 0)
1693 augmentation += strlen (augmentation);
1695 /* The GCC 2.x "eh" augmentation has a pointer immediately
1696 following the augmentation string, so it must be handled
1698 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1701 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1705 cie->code_alignment_factor =
1706 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1709 cie->data_alignment_factor =
1710 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1713 if (cie_version == 1)
1715 cie->return_address_register = read_1_byte (unit->abfd, buf);
1719 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1721 cie->return_address_register
1722 = dwarf2_frame_adjust_regnum (current_gdbarch,
1723 cie->return_address_register,
1728 cie->saw_z_augmentation = (*augmentation == 'z');
1729 if (cie->saw_z_augmentation)
1733 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1737 cie->initial_instructions = buf + length;
1741 while (*augmentation)
1743 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1744 if (*augmentation == 'L')
1751 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1752 else if (*augmentation == 'R')
1754 cie->encoding = *buf++;
1758 /* "P" indicates a personality routine in the CIE augmentation. */
1759 else if (*augmentation == 'P')
1761 /* Skip. Avoid indirection since we throw away the result. */
1762 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1763 read_encoded_value (unit, encoding, buf, &bytes_read);
1768 /* "S" indicates a signal frame, such that the return
1769 address must not be decremented to locate the call frame
1770 info for the previous frame; it might even be the first
1771 instruction of a function, so decrementing it would take
1772 us to a different function. */
1773 else if (*augmentation == 'S')
1775 cie->signal_frame = 1;
1779 /* Otherwise we have an unknown augmentation. Assume that either
1780 there is no augmentation data, or we saw a 'z' prefix. */
1783 if (cie->initial_instructions)
1784 buf = cie->initial_instructions;
1789 cie->initial_instructions = buf;
1792 add_cie (unit, cie);
1796 /* This is a FDE. */
1797 struct dwarf2_fde *fde;
1799 /* In an .eh_frame section, the CIE pointer is the delta between the
1800 address within the FDE where the CIE pointer is stored and the
1801 address of the CIE. Convert it to an offset into the .eh_frame
1805 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1806 cie_pointer -= (dwarf64_p ? 8 : 4);
1809 /* In either case, validate the result is still within the section. */
1810 if (cie_pointer >= unit->dwarf_frame_size)
1813 fde = (struct dwarf2_fde *)
1814 obstack_alloc (&unit->objfile->objfile_obstack,
1815 sizeof (struct dwarf2_fde));
1816 fde->cie = find_cie (unit, cie_pointer);
1817 if (fde->cie == NULL)
1819 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1821 fde->cie = find_cie (unit, cie_pointer);
1824 gdb_assert (fde->cie != NULL);
1826 fde->initial_location =
1827 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1830 fde->address_range =
1831 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1834 /* A 'z' augmentation in the CIE implies the presence of an
1835 augmentation field in the FDE as well. The only thing known
1836 to be in here at present is the LSDA entry for EH. So we
1837 can skip the whole thing. */
1838 if (fde->cie->saw_z_augmentation)
1842 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1843 buf += bytes_read + length;
1848 fde->instructions = buf;
1851 fde->eh_frame_p = eh_frame_p;
1853 add_fde (unit, fde);
1859 /* Read a CIE or FDE in BUF and decode it. */
1861 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1863 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1866 ptrdiff_t start_offset;
1870 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1874 /* We have corrupt input data of some form. */
1876 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1877 and mismatches wrt padding and alignment of debug sections. */
1878 /* Note that there is no requirement in the standard for any
1879 alignment at all in the frame unwind sections. Testing for
1880 alignment before trying to interpret data would be incorrect.
1882 However, GCC traditionally arranged for frame sections to be
1883 sized such that the FDE length and CIE fields happen to be
1884 aligned (in theory, for performance). This, unfortunately,
1885 was done with .align directives, which had the side effect of
1886 forcing the section to be aligned by the linker.
1888 This becomes a problem when you have some other producer that
1889 creates frame sections that are not as strictly aligned. That
1890 produces a hole in the frame info that gets filled by the
1893 The GCC behaviour is arguably a bug, but it's effectively now
1894 part of the ABI, so we're now stuck with it, at least at the
1895 object file level. A smart linker may decide, in the process
1896 of compressing duplicate CIE information, that it can rewrite
1897 the entire output section without this extra padding. */
1899 start_offset = start - unit->dwarf_frame_buffer;
1900 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1902 start += 4 - (start_offset & 3);
1903 workaround = ALIGN4;
1906 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1908 start += 8 - (start_offset & 7);
1909 workaround = ALIGN8;
1913 /* Nothing left to try. Arrange to return as if we've consumed
1914 the entire input section. Hopefully we'll get valid info from
1915 the other of .debug_frame/.eh_frame. */
1917 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1927 complaint (&symfile_complaints,
1928 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1929 unit->dwarf_frame_section->owner->filename,
1930 unit->dwarf_frame_section->name);
1934 complaint (&symfile_complaints,
1935 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1936 unit->dwarf_frame_section->owner->filename,
1937 unit->dwarf_frame_section->name);
1941 complaint (&symfile_complaints,
1942 _("Corrupt data in %s:%s"),
1943 unit->dwarf_frame_section->owner->filename,
1944 unit->dwarf_frame_section->name);
1952 /* FIXME: kettenis/20030504: This still needs to be integrated with
1953 dwarf2read.c in a better way. */
1955 /* Imported from dwarf2read.c. */
1956 extern asection *dwarf_frame_section;
1957 extern asection *dwarf_eh_frame_section;
1959 /* Imported from dwarf2read.c. */
1960 extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1963 dwarf2_build_frame_info (struct objfile *objfile)
1965 struct comp_unit unit;
1966 gdb_byte *frame_ptr;
1968 /* Build a minimal decoding of the DWARF2 compilation unit. */
1969 unit.abfd = objfile->obfd;
1970 unit.objfile = objfile;
1974 /* First add the information from the .eh_frame section. That way,
1975 the FDEs from that section are searched last. */
1976 if (dwarf_eh_frame_section)
1978 asection *got, *txt;
1981 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1982 dwarf_eh_frame_section);
1984 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1985 unit.dwarf_frame_section = dwarf_eh_frame_section;
1987 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1988 that is used for the i386/amd64 target, which currently is
1989 the only target in GCC that supports/uses the
1990 DW_EH_PE_datarel encoding. */
1991 got = bfd_get_section_by_name (unit.abfd, ".got");
1993 unit.dbase = got->vma;
1995 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1997 txt = bfd_get_section_by_name (unit.abfd, ".text");
1999 unit.tbase = txt->vma;
2001 frame_ptr = unit.dwarf_frame_buffer;
2002 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
2003 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
2006 if (dwarf_frame_section)
2009 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
2010 dwarf_frame_section);
2011 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
2012 unit.dwarf_frame_section = dwarf_frame_section;
2014 frame_ptr = unit.dwarf_frame_buffer;
2015 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
2016 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
2020 /* Provide a prototype to silence -Wmissing-prototypes. */
2021 void _initialize_dwarf2_frame (void);
2024 _initialize_dwarf2_frame (void)
2026 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2027 dwarf2_frame_objfile_data = register_objfile_data ();