1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005 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 /* Encoding of addresses. */
70 /* True if a 'z' augmentation existed. */
71 unsigned char saw_z_augmentation;
73 /* True if an 'S' augmentation existed. */
74 unsigned char signal_frame;
76 struct dwarf2_cie *next;
79 /* Frame Description Entry (FDE). */
83 /* CIE for this FDE. */
84 struct dwarf2_cie *cie;
86 /* First location associated with this FDE. */
87 CORE_ADDR initial_location;
89 /* Number of bytes of program instructions described by this FDE. */
90 CORE_ADDR address_range;
92 /* Instruction sequence. */
93 gdb_byte *instructions;
96 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
98 unsigned char eh_frame_p;
100 struct dwarf2_fde *next;
103 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
106 /* Structure describing a frame state. */
108 struct dwarf2_frame_state
110 /* Each register save state can be described in terms of a CFA slot,
111 another register, or a location expression. */
112 struct dwarf2_frame_state_reg_info
114 struct dwarf2_frame_state_reg *reg;
117 /* Used to implement DW_CFA_remember_state. */
118 struct dwarf2_frame_state_reg_info *prev;
130 /* The PC described by the current frame state. */
133 /* Initial register set from the CIE.
134 Used to implement DW_CFA_restore. */
135 struct dwarf2_frame_state_reg_info initial;
137 /* The information we care about from the CIE. */
140 ULONGEST retaddr_column;
143 /* Store the length the expression for the CFA in the `cfa_reg' field,
144 which is unused in that case. */
145 #define cfa_exp_len cfa_reg
147 /* Assert that the register set RS is large enough to store NUM_REGS
148 columns. If necessary, enlarge the register set. */
151 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
154 size_t size = sizeof (struct dwarf2_frame_state_reg);
156 if (num_regs <= rs->num_regs)
159 rs->reg = (struct dwarf2_frame_state_reg *)
160 xrealloc (rs->reg, num_regs * size);
162 /* Initialize newly allocated registers. */
163 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
164 rs->num_regs = num_regs;
167 /* Copy the register columns in register set RS into newly allocated
168 memory and return a pointer to this newly created copy. */
170 static struct dwarf2_frame_state_reg *
171 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
173 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
174 struct dwarf2_frame_state_reg *reg;
176 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
177 memcpy (reg, rs->reg, size);
182 /* Release the memory allocated to register set RS. */
185 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
189 dwarf2_frame_state_free_regs (rs->prev);
196 /* Release the memory allocated to the frame state FS. */
199 dwarf2_frame_state_free (void *p)
201 struct dwarf2_frame_state *fs = p;
203 dwarf2_frame_state_free_regs (fs->initial.prev);
204 dwarf2_frame_state_free_regs (fs->regs.prev);
205 xfree (fs->initial.reg);
206 xfree (fs->regs.reg);
211 /* Helper functions for execute_stack_op. */
214 read_reg (void *baton, int reg)
216 struct frame_info *next_frame = (struct frame_info *) baton;
217 struct gdbarch *gdbarch = get_frame_arch (next_frame);
221 regnum = DWARF2_REG_TO_REGNUM (reg);
223 buf = alloca (register_size (gdbarch, regnum));
224 frame_unwind_register (next_frame, regnum, buf);
226 /* Convert the register to an integer. This returns a LONGEST
227 rather than a CORE_ADDR, but unpack_pointer does the same thing
228 under the covers, and this makes more sense for non-pointer
229 registers. Maybe read_reg and the associated interfaces should
230 deal with "struct value" instead of CORE_ADDR. */
231 return unpack_long (register_type (gdbarch, regnum), buf);
235 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
237 read_memory (addr, buf, len);
241 no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
243 internal_error (__FILE__, __LINE__,
244 _("Support for DW_OP_fbreg is unimplemented"));
248 no_get_tls_address (void *baton, CORE_ADDR offset)
250 internal_error (__FILE__, __LINE__,
251 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
255 execute_stack_op (gdb_byte *exp, ULONGEST len,
256 struct frame_info *next_frame, CORE_ADDR initial)
258 struct dwarf_expr_context *ctx;
261 ctx = new_dwarf_expr_context ();
262 ctx->baton = next_frame;
263 ctx->read_reg = read_reg;
264 ctx->read_mem = read_mem;
265 ctx->get_frame_base = no_get_frame_base;
266 ctx->get_tls_address = no_get_tls_address;
268 dwarf_expr_push (ctx, initial);
269 dwarf_expr_eval (ctx, exp, len);
270 result = dwarf_expr_fetch (ctx, 0);
273 result = read_reg (next_frame, result);
275 free_dwarf_expr_context (ctx);
282 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
283 struct frame_info *next_frame,
284 struct dwarf2_frame_state *fs, int eh_frame_p)
286 CORE_ADDR pc = frame_pc_unwind (next_frame);
288 struct gdbarch *gdbarch = get_frame_arch (next_frame);
290 while (insn_ptr < insn_end && fs->pc <= pc)
292 gdb_byte insn = *insn_ptr++;
296 if ((insn & 0xc0) == DW_CFA_advance_loc)
297 fs->pc += (insn & 0x3f) * fs->code_align;
298 else if ((insn & 0xc0) == DW_CFA_offset)
302 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
303 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
304 offset = utmp * fs->data_align;
305 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
306 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
307 fs->regs.reg[reg].loc.offset = offset;
309 else if ((insn & 0xc0) == DW_CFA_restore)
311 gdb_assert (fs->initial.reg);
314 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
315 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
316 if (reg < fs->initial.num_regs)
317 fs->regs.reg[reg] = fs->initial.reg[reg];
319 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
321 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
322 complaint (&symfile_complaints, _("\
323 incomplete CFI data; DW_CFA_restore unspecified\n\
324 register %s (#%d) at 0x%s"),
325 REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
326 DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
333 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
334 insn_ptr += bytes_read;
337 case DW_CFA_advance_loc1:
338 utmp = extract_unsigned_integer (insn_ptr, 1);
339 fs->pc += utmp * fs->code_align;
342 case DW_CFA_advance_loc2:
343 utmp = extract_unsigned_integer (insn_ptr, 2);
344 fs->pc += utmp * fs->code_align;
347 case DW_CFA_advance_loc4:
348 utmp = extract_unsigned_integer (insn_ptr, 4);
349 fs->pc += utmp * fs->code_align;
353 case DW_CFA_offset_extended:
354 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
356 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
357 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
358 offset = utmp * fs->data_align;
359 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
360 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
361 fs->regs.reg[reg].loc.offset = offset;
364 case DW_CFA_restore_extended:
365 gdb_assert (fs->initial.reg);
366 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
368 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
369 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
370 fs->regs.reg[reg] = fs->initial.reg[reg];
373 case DW_CFA_undefined:
374 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
376 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
377 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
378 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
381 case DW_CFA_same_value:
382 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
384 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
385 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
386 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
389 case DW_CFA_register:
390 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
392 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
393 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
395 utmp = dwarf2_frame_eh_frame_regnum (gdbarch, utmp);
396 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
397 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
398 fs->regs.reg[reg].loc.reg = utmp;
401 case DW_CFA_remember_state:
403 struct dwarf2_frame_state_reg_info *new_rs;
405 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
407 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
408 fs->regs.prev = new_rs;
412 case DW_CFA_restore_state:
414 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
418 complaint (&symfile_complaints, _("\
419 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
423 xfree (fs->regs.reg);
431 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
432 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
433 fs->cfa_offset = utmp;
434 fs->cfa_how = CFA_REG_OFFSET;
437 case DW_CFA_def_cfa_register:
438 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
440 fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
442 fs->cfa_how = CFA_REG_OFFSET;
445 case DW_CFA_def_cfa_offset:
446 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
447 fs->cfa_offset = utmp;
448 /* cfa_how deliberately not set. */
454 case DW_CFA_def_cfa_expression:
455 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
456 fs->cfa_exp = insn_ptr;
457 fs->cfa_how = CFA_EXP;
458 insn_ptr += fs->cfa_exp_len;
461 case DW_CFA_expression:
462 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
464 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
465 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
466 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
467 fs->regs.reg[reg].loc.exp = insn_ptr;
468 fs->regs.reg[reg].exp_len = utmp;
469 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
473 case DW_CFA_offset_extended_sf:
474 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
476 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
477 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
478 offset *= fs->data_align;
479 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
480 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
481 fs->regs.reg[reg].loc.offset = offset;
484 case DW_CFA_val_offset:
485 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
486 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
487 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
488 offset = utmp * fs->data_align;
489 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
490 fs->regs.reg[reg].loc.offset = offset;
493 case DW_CFA_val_offset_sf:
494 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
495 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
496 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
497 offset *= fs->data_align;
498 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
499 fs->regs.reg[reg].loc.offset = offset;
502 case DW_CFA_val_expression:
503 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
504 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
505 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
506 fs->regs.reg[reg].loc.exp = insn_ptr;
507 fs->regs.reg[reg].exp_len = utmp;
508 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
512 case DW_CFA_def_cfa_sf:
513 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
515 fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
517 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
518 fs->cfa_offset = offset * fs->data_align;
519 fs->cfa_how = CFA_REG_OFFSET;
522 case DW_CFA_def_cfa_offset_sf:
523 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
524 fs->cfa_offset = offset * fs->data_align;
525 /* cfa_how deliberately not set. */
528 case DW_CFA_GNU_window_save:
529 /* This is SPARC-specific code, and contains hard-coded
530 constants for the register numbering scheme used by
531 GCC. Rather than having a architecture-specific
532 operation that's only ever used by a single
533 architecture, we provide the implementation here.
534 Incidentally that's what GCC does too in its
537 struct gdbarch *gdbarch = get_frame_arch (next_frame);
538 int size = register_size(gdbarch, 0);
539 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
540 for (reg = 8; reg < 16; reg++)
542 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
543 fs->regs.reg[reg].loc.reg = reg + 16;
545 for (reg = 16; reg < 32; reg++)
547 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
548 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
553 case DW_CFA_GNU_args_size:
555 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
559 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
564 /* Don't allow remember/restore between CIE and FDE programs. */
565 dwarf2_frame_state_free_regs (fs->regs.prev);
566 fs->regs.prev = NULL;
570 /* Architecture-specific operations. */
572 /* Per-architecture data key. */
573 static struct gdbarch_data *dwarf2_frame_data;
575 struct dwarf2_frame_ops
577 /* Pre-initialize the register state REG for register REGNUM. */
578 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
579 struct frame_info *);
581 /* Check whether the frame preceding NEXT_FRAME will be a signal
583 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
585 /* Convert .eh_frame register number to DWARF register number. */
586 int (*eh_frame_regnum) (struct gdbarch *, int);
589 /* Default architecture-specific register state initialization
593 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
594 struct dwarf2_frame_state_reg *reg,
595 struct frame_info *next_frame)
597 /* If we have a register that acts as a program counter, mark it as
598 a destination for the return address. If we have a register that
599 serves as the stack pointer, arrange for it to be filled with the
600 call frame address (CFA). The other registers are marked as
603 We copy the return address to the program counter, since many
604 parts in GDB assume that it is possible to get the return address
605 by unwinding the program counter register. However, on ISA's
606 with a dedicated return address register, the CFI usually only
607 contains information to unwind that return address register.
609 The reason we're treating the stack pointer special here is
610 because in many cases GCC doesn't emit CFI for the stack pointer
611 and implicitly assumes that it is equal to the CFA. This makes
612 some sense since the DWARF specification (version 3, draft 8,
615 "Typically, the CFA is defined to be the value of the stack
616 pointer at the call site in the previous frame (which may be
617 different from its value on entry to the current frame)."
619 However, this isn't true for all platforms supported by GCC
620 (e.g. IBM S/390 and zSeries). Those architectures should provide
621 their own architecture-specific initialization function. */
623 if (regnum == PC_REGNUM)
624 reg->how = DWARF2_FRAME_REG_RA;
625 else if (regnum == SP_REGNUM)
626 reg->how = DWARF2_FRAME_REG_CFA;
629 /* Return a default for the architecture-specific operations. */
632 dwarf2_frame_init (struct obstack *obstack)
634 struct dwarf2_frame_ops *ops;
636 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
637 ops->init_reg = dwarf2_frame_default_init_reg;
641 /* Set the architecture-specific register state initialization
642 function for GDBARCH to INIT_REG. */
645 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
646 void (*init_reg) (struct gdbarch *, int,
647 struct dwarf2_frame_state_reg *,
648 struct frame_info *))
650 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
652 ops->init_reg = init_reg;
655 /* Pre-initialize the register state REG for register REGNUM. */
658 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
659 struct dwarf2_frame_state_reg *reg,
660 struct frame_info *next_frame)
662 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
664 ops->init_reg (gdbarch, regnum, reg, next_frame);
667 /* Set the architecture-specific signal trampoline recognition
668 function for GDBARCH to SIGNAL_FRAME_P. */
671 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
672 int (*signal_frame_p) (struct gdbarch *,
673 struct frame_info *))
675 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
677 ops->signal_frame_p = signal_frame_p;
680 /* Query the architecture-specific signal frame recognizer for
684 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
685 struct frame_info *next_frame)
687 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
689 if (ops->signal_frame_p == NULL)
691 return ops->signal_frame_p (gdbarch, next_frame);
694 /* Set the architecture-specific mapping of .eh_frame register numbers to
695 DWARF register numbers. */
698 dwarf2_frame_set_eh_frame_regnum (struct gdbarch *gdbarch,
699 int (*eh_frame_regnum) (struct gdbarch *,
702 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
704 ops->eh_frame_regnum = eh_frame_regnum;
707 /* Translate a .eh_frame register to DWARF register. */
710 dwarf2_frame_eh_frame_regnum (struct gdbarch *gdbarch, int regnum)
712 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
714 if (ops->eh_frame_regnum == NULL)
716 return ops->eh_frame_regnum (gdbarch, regnum);
720 struct dwarf2_frame_cache
722 /* DWARF Call Frame Address. */
725 /* Set if the return address column was marked as undefined. */
726 int undefined_retaddr;
728 /* Saved registers, indexed by GDB register number, not by DWARF
730 struct dwarf2_frame_state_reg *reg;
732 /* Return address register. */
733 struct dwarf2_frame_state_reg retaddr_reg;
736 static struct dwarf2_frame_cache *
737 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
739 struct cleanup *old_chain;
740 struct gdbarch *gdbarch = get_frame_arch (next_frame);
741 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
742 struct dwarf2_frame_cache *cache;
743 struct dwarf2_frame_state *fs;
744 struct dwarf2_fde *fde;
749 /* Allocate a new cache. */
750 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
751 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
753 /* Allocate and initialize the frame state. */
754 fs = XMALLOC (struct dwarf2_frame_state);
755 memset (fs, 0, sizeof (struct dwarf2_frame_state));
756 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
760 Note that if NEXT_FRAME is never supposed to return (i.e. a call
761 to abort), the compiler might optimize away the instruction at
762 NEXT_FRAME's return address. As a result the return address will
763 point at some random instruction, and the CFI for that
764 instruction is probably worthless to us. GCC's unwinder solves
765 this problem by substracting 1 from the return address to get an
766 address in the middle of a presumed call instruction (or the
767 instruction in the associated delay slot). This should only be
768 done for "normal" frames and not for resume-type frames (signal
769 handlers, sentinel frames, dummy frames). The function
770 frame_unwind_address_in_block does just this. It's not clear how
771 reliable the method is though; there is the potential for the
772 register state pre-call being different to that on return. */
773 fs->pc = frame_unwind_address_in_block (next_frame);
775 /* Find the correct FDE. */
776 fde = dwarf2_frame_find_fde (&fs->pc);
777 gdb_assert (fde != NULL);
779 /* Extract any interesting information from the CIE. */
780 fs->data_align = fde->cie->data_alignment_factor;
781 fs->code_align = fde->cie->code_alignment_factor;
782 fs->retaddr_column = fde->cie->return_address_register;
784 /* First decode all the insns in the CIE. */
785 execute_cfa_program (fde->cie->initial_instructions,
786 fde->cie->end, next_frame, fs, fde->eh_frame_p);
788 /* Save the initialized register set. */
789 fs->initial = fs->regs;
790 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
792 /* Then decode the insns in the FDE up to our target PC. */
793 execute_cfa_program (fde->instructions, fde->end, next_frame, fs,
796 /* Caclulate the CFA. */
800 cache->cfa = read_reg (next_frame, fs->cfa_reg);
801 cache->cfa += fs->cfa_offset;
806 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
810 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
813 /* Initialize the register state. */
817 for (regnum = 0; regnum < num_regs; regnum++)
818 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
821 /* Go through the DWARF2 CFI generated table and save its register
822 location information in the cache. Note that we don't skip the
823 return address column; it's perfectly all right for it to
824 correspond to a real register. If it doesn't correspond to a
825 real register, or if we shouldn't treat it as such,
826 DWARF2_REG_TO_REGNUM should be defined to return a number outside
827 the range [0, NUM_REGS). */
829 int column; /* CFI speak for "register number". */
831 for (column = 0; column < fs->regs.num_regs; column++)
833 /* Use the GDB register number as the destination index. */
834 int regnum = DWARF2_REG_TO_REGNUM (column);
836 /* If there's no corresponding GDB register, ignore it. */
837 if (regnum < 0 || regnum >= num_regs)
840 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
841 of all debug info registers. If it doesn't, complain (but
842 not too loudly). It turns out that GCC assumes that an
843 unspecified register implies "same value" when CFI (draft
844 7) specifies nothing at all. Such a register could equally
845 be interpreted as "undefined". Also note that this check
846 isn't sufficient; it only checks that all registers in the
847 range [0 .. max column] are specified, and won't detect
848 problems when a debug info register falls outside of the
849 table. We need a way of iterating through all the valid
850 DWARF2 register numbers. */
851 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
853 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
854 complaint (&symfile_complaints, _("\
855 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
856 gdbarch_register_name (gdbarch, regnum),
860 cache->reg[regnum] = fs->regs.reg[column];
864 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
865 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
869 for (regnum = 0; regnum < num_regs; regnum++)
871 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
872 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
874 struct dwarf2_frame_state_reg *retaddr_reg =
875 &fs->regs.reg[fs->retaddr_column];
877 /* It seems rather bizarre to specify an "empty" column as
878 the return adress column. However, this is exactly
879 what GCC does on some targets. It turns out that GCC
880 assumes that the return address can be found in the
881 register corresponding to the return address column.
882 Incidentally, that's how we should treat a return
883 address column specifying "same value" too. */
884 if (fs->retaddr_column < fs->regs.num_regs
885 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
886 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
888 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
889 cache->reg[regnum] = *retaddr_reg;
891 cache->retaddr_reg = *retaddr_reg;
895 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
897 cache->reg[regnum].loc.reg = fs->retaddr_column;
898 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
902 cache->retaddr_reg.loc.reg = fs->retaddr_column;
903 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
910 if (fs->retaddr_column < fs->regs.num_regs
911 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
912 cache->undefined_retaddr = 1;
914 do_cleanups (old_chain);
921 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
922 struct frame_id *this_id)
924 struct dwarf2_frame_cache *cache =
925 dwarf2_frame_cache (next_frame, this_cache);
927 if (cache->undefined_retaddr)
930 (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
934 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
935 int regnum, int *optimizedp,
936 enum lval_type *lvalp, CORE_ADDR *addrp,
937 int *realnump, gdb_byte *valuep)
939 struct gdbarch *gdbarch = get_frame_arch (next_frame);
940 struct dwarf2_frame_cache *cache =
941 dwarf2_frame_cache (next_frame, this_cache);
943 switch (cache->reg[regnum].how)
945 case DWARF2_FRAME_REG_UNDEFINED:
946 /* If CFI explicitly specified that the value isn't defined,
947 mark it as optimized away; the value isn't available. */
954 /* In some cases, for example %eflags on the i386, we have
955 to provide a sane value, even though this register wasn't
956 saved. Assume we can get it from NEXT_FRAME. */
957 frame_unwind_register (next_frame, regnum, valuep);
961 case DWARF2_FRAME_REG_SAVED_OFFSET:
963 *lvalp = lval_memory;
964 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
968 /* Read the value in from memory. */
969 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
973 case DWARF2_FRAME_REG_SAVED_REG:
975 *lvalp = lval_register;
977 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
979 frame_unwind_register (next_frame, (*realnump), valuep);
982 case DWARF2_FRAME_REG_SAVED_EXP:
984 *lvalp = lval_memory;
985 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
986 cache->reg[regnum].exp_len,
987 next_frame, cache->cfa);
991 /* Read the value in from memory. */
992 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
996 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1002 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1003 cache->cfa + cache->reg[regnum].loc.offset);
1006 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1012 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1013 execute_stack_op (cache->reg[regnum].loc.exp,
1014 cache->reg[regnum].exp_len,
1015 next_frame, cache->cfa));
1018 case DWARF2_FRAME_REG_UNSPECIFIED:
1019 /* GCC, in its infinite wisdom decided to not provide unwind
1020 information for registers that are "same value". Since
1021 DWARF2 (3 draft 7) doesn't define such behavior, said
1022 registers are actually undefined (which is different to CFI
1023 "undefined"). Code above issues a complaint about this.
1024 Here just fudge the books, assume GCC, and that the value is
1025 more inner on the stack. */
1027 *lvalp = lval_register;
1031 frame_unwind_register (next_frame, (*realnump), valuep);
1034 case DWARF2_FRAME_REG_SAME_VALUE:
1036 *lvalp = lval_register;
1040 frame_unwind_register (next_frame, (*realnump), valuep);
1043 case DWARF2_FRAME_REG_CFA:
1050 /* Store the value. */
1051 store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
1055 case DWARF2_FRAME_REG_CFA_OFFSET:
1062 /* Store the value. */
1063 store_typed_address (valuep, builtin_type_void_data_ptr,
1064 cache->cfa + cache->reg[regnum].loc.offset);
1068 case DWARF2_FRAME_REG_RA_OFFSET:
1075 CORE_ADDR pc = cache->reg[regnum].loc.offset;
1077 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
1078 pc += frame_unwind_register_unsigned (next_frame, regnum);
1079 store_typed_address (valuep, builtin_type_void_func_ptr, pc);
1084 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1088 static const struct frame_unwind dwarf2_frame_unwind =
1091 dwarf2_frame_this_id,
1092 dwarf2_frame_prev_register
1095 static const struct frame_unwind dwarf2_signal_frame_unwind =
1098 dwarf2_frame_this_id,
1099 dwarf2_frame_prev_register
1102 const struct frame_unwind *
1103 dwarf2_frame_sniffer (struct frame_info *next_frame)
1105 /* Grab an address that is guarenteed to reside somewhere within the
1106 function. frame_pc_unwind(), for a no-return next function, can
1107 end up returning something past the end of this function's body. */
1108 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
1109 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1113 /* On some targets, signal trampolines may have unwind information.
1114 We need to recognize them so that we set the frame type
1117 if (fde->cie->signal_frame
1118 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
1120 return &dwarf2_signal_frame_unwind;
1122 return &dwarf2_frame_unwind;
1126 /* There is no explicitly defined relationship between the CFA and the
1127 location of frame's local variables and arguments/parameters.
1128 Therefore, frame base methods on this page should probably only be
1129 used as a last resort, just to avoid printing total garbage as a
1130 response to the "info frame" command. */
1133 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1135 struct dwarf2_frame_cache *cache =
1136 dwarf2_frame_cache (next_frame, this_cache);
1141 static const struct frame_base dwarf2_frame_base =
1143 &dwarf2_frame_unwind,
1144 dwarf2_frame_base_address,
1145 dwarf2_frame_base_address,
1146 dwarf2_frame_base_address
1149 const struct frame_base *
1150 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1152 CORE_ADDR pc = frame_pc_unwind (next_frame);
1153 if (dwarf2_frame_find_fde (&pc))
1154 return &dwarf2_frame_base;
1159 /* A minimal decoding of DWARF2 compilation units. We only decode
1160 what's needed to get to the call frame information. */
1164 /* Keep the bfd convenient. */
1167 struct objfile *objfile;
1169 /* Linked list of CIEs for this object. */
1170 struct dwarf2_cie *cie;
1172 /* Pointer to the .debug_frame section loaded into memory. */
1173 gdb_byte *dwarf_frame_buffer;
1175 /* Length of the loaded .debug_frame section. */
1176 unsigned long dwarf_frame_size;
1178 /* Pointer to the .debug_frame section. */
1179 asection *dwarf_frame_section;
1181 /* Base for DW_EH_PE_datarel encodings. */
1184 /* Base for DW_EH_PE_textrel encodings. */
1188 const struct objfile_data *dwarf2_frame_objfile_data;
1191 read_1_byte (bfd *abfd, gdb_byte *buf)
1193 return bfd_get_8 (abfd, buf);
1197 read_4_bytes (bfd *abfd, gdb_byte *buf)
1199 return bfd_get_32 (abfd, buf);
1203 read_8_bytes (bfd *abfd, gdb_byte *buf)
1205 return bfd_get_64 (abfd, buf);
1209 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1212 unsigned int num_read;
1222 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1225 result |= ((byte & 0x7f) << shift);
1228 while (byte & 0x80);
1230 *bytes_read_ptr = num_read;
1236 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1240 unsigned int num_read;
1249 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1252 result |= ((byte & 0x7f) << shift);
1255 while (byte & 0x80);
1257 if (shift < 8 * sizeof (result) && (byte & 0x40))
1258 result |= -(((LONGEST)1) << shift);
1260 *bytes_read_ptr = num_read;
1266 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1270 result = bfd_get_32 (abfd, buf);
1271 if (result == 0xffffffff)
1273 result = bfd_get_64 (abfd, buf + 4);
1274 *bytes_read_ptr = 12;
1277 *bytes_read_ptr = 4;
1283 /* Pointer encoding helper functions. */
1285 /* GCC supports exception handling based on DWARF2 CFI. However, for
1286 technical reasons, it encodes addresses in its FDE's in a different
1287 way. Several "pointer encodings" are supported. The encoding
1288 that's used for a particular FDE is determined by the 'R'
1289 augmentation in the associated CIE. The argument of this
1290 augmentation is a single byte.
1292 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1293 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1294 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1295 address should be interpreted (absolute, relative to the current
1296 position in the FDE, ...). Bit 7, indicates that the address
1297 should be dereferenced. */
1300 encoding_for_size (unsigned int size)
1305 return DW_EH_PE_udata2;
1307 return DW_EH_PE_udata4;
1309 return DW_EH_PE_udata8;
1311 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1316 size_of_encoded_value (gdb_byte encoding)
1318 if (encoding == DW_EH_PE_omit)
1321 switch (encoding & 0x07)
1323 case DW_EH_PE_absptr:
1324 return TYPE_LENGTH (builtin_type_void_data_ptr);
1325 case DW_EH_PE_udata2:
1327 case DW_EH_PE_udata4:
1329 case DW_EH_PE_udata8:
1332 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1337 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1338 gdb_byte *buf, unsigned int *bytes_read_ptr)
1340 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1344 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1346 if (encoding & DW_EH_PE_indirect)
1347 internal_error (__FILE__, __LINE__,
1348 _("Unsupported encoding: DW_EH_PE_indirect"));
1350 *bytes_read_ptr = 0;
1352 switch (encoding & 0x70)
1354 case DW_EH_PE_absptr:
1357 case DW_EH_PE_pcrel:
1358 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1359 base += (buf - unit->dwarf_frame_buffer);
1361 case DW_EH_PE_datarel:
1364 case DW_EH_PE_textrel:
1367 case DW_EH_PE_funcrel:
1368 /* FIXME: kettenis/20040501: For now just pretend
1369 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1370 reading the initial location of an FDE it should be treated
1371 as such, and currently that's the only place where this code
1375 case DW_EH_PE_aligned:
1377 offset = buf - unit->dwarf_frame_buffer;
1378 if ((offset % ptr_len) != 0)
1380 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1381 buf += *bytes_read_ptr;
1385 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1388 if ((encoding & 0x07) == 0x00)
1389 encoding |= encoding_for_size (ptr_len);
1391 switch (encoding & 0x0f)
1393 case DW_EH_PE_uleb128:
1396 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1397 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1398 return base + value;
1400 case DW_EH_PE_udata2:
1401 *bytes_read_ptr += 2;
1402 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1403 case DW_EH_PE_udata4:
1404 *bytes_read_ptr += 4;
1405 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1406 case DW_EH_PE_udata8:
1407 *bytes_read_ptr += 8;
1408 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1409 case DW_EH_PE_sleb128:
1412 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1413 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1414 return base + value;
1416 case DW_EH_PE_sdata2:
1417 *bytes_read_ptr += 2;
1418 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1419 case DW_EH_PE_sdata4:
1420 *bytes_read_ptr += 4;
1421 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1422 case DW_EH_PE_sdata8:
1423 *bytes_read_ptr += 8;
1424 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1426 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1431 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1432 That's why we use a simple linked list here. */
1434 static struct dwarf2_cie *
1435 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1437 struct dwarf2_cie *cie = unit->cie;
1441 if (cie->cie_pointer == cie_pointer)
1451 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1453 cie->next = unit->cie;
1457 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1458 inital location associated with it into *PC. */
1460 static struct dwarf2_fde *
1461 dwarf2_frame_find_fde (CORE_ADDR *pc)
1463 struct objfile *objfile;
1465 ALL_OBJFILES (objfile)
1467 struct dwarf2_fde *fde;
1470 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1474 gdb_assert (objfile->section_offsets);
1475 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1479 if (*pc >= fde->initial_location + offset
1480 && *pc < fde->initial_location + offset + fde->address_range)
1482 *pc = fde->initial_location + offset;
1494 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1496 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1497 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1500 #ifdef CC_HAS_LONG_LONG
1501 #define DW64_CIE_ID 0xffffffffffffffffULL
1503 #define DW64_CIE_ID ~0
1506 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1509 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1510 the next byte to be processed. */
1512 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1514 gdb_byte *buf, *end;
1516 unsigned int bytes_read;
1519 ULONGEST cie_pointer;
1522 length = read_initial_length (unit->abfd, buf, &bytes_read);
1526 /* Are we still within the section? */
1527 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1533 /* Distinguish between 32 and 64-bit encoded frame info. */
1534 dwarf64_p = (bytes_read == 12);
1536 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1540 cie_id = DW64_CIE_ID;
1546 cie_pointer = read_8_bytes (unit->abfd, buf);
1551 cie_pointer = read_4_bytes (unit->abfd, buf);
1555 if (cie_pointer == cie_id)
1557 /* This is a CIE. */
1558 struct dwarf2_cie *cie;
1560 unsigned int cie_version;
1562 /* Record the offset into the .debug_frame section of this CIE. */
1563 cie_pointer = start - unit->dwarf_frame_buffer;
1565 /* Check whether we've already read it. */
1566 if (find_cie (unit, cie_pointer))
1569 cie = (struct dwarf2_cie *)
1570 obstack_alloc (&unit->objfile->objfile_obstack,
1571 sizeof (struct dwarf2_cie));
1572 cie->initial_instructions = NULL;
1573 cie->cie_pointer = cie_pointer;
1575 /* The encoding for FDE's in a normal .debug_frame section
1576 depends on the target address size. */
1577 cie->encoding = DW_EH_PE_absptr;
1579 /* We'll determine the final value later, but we need to
1580 initialize it conservatively. */
1581 cie->signal_frame = 0;
1583 /* Check version number. */
1584 cie_version = read_1_byte (unit->abfd, buf);
1585 if (cie_version != 1 && cie_version != 3)
1589 /* Interpret the interesting bits of the augmentation. */
1590 augmentation = (char *) buf;
1591 buf += (strlen (augmentation) + 1);
1593 /* The GCC 2.x "eh" augmentation has a pointer immediately
1594 following the augmentation string, so it must be handled
1596 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1599 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1603 cie->code_alignment_factor =
1604 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1607 cie->data_alignment_factor =
1608 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1611 if (cie_version == 1)
1613 cie->return_address_register = read_1_byte (unit->abfd, buf);
1617 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1620 cie->return_address_register
1621 = dwarf2_frame_eh_frame_regnum (current_gdbarch,
1622 cie->return_address_register);
1626 cie->saw_z_augmentation = (*augmentation == 'z');
1627 if (cie->saw_z_augmentation)
1631 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1635 cie->initial_instructions = buf + length;
1639 while (*augmentation)
1641 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1642 if (*augmentation == 'L')
1649 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1650 else if (*augmentation == 'R')
1652 cie->encoding = *buf++;
1656 /* "P" indicates a personality routine in the CIE augmentation. */
1657 else if (*augmentation == 'P')
1659 /* Skip. Avoid indirection since we throw away the result. */
1660 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1661 read_encoded_value (unit, encoding, buf, &bytes_read);
1666 /* "S" indicates a signal frame, such that the return
1667 address must not be decremented to locate the call frame
1668 info for the previous frame; it might even be the first
1669 instruction of a function, so decrementing it would take
1670 us to a different function. */
1671 else if (*augmentation == 'S')
1673 cie->signal_frame = 1;
1677 /* Otherwise we have an unknown augmentation. Assume that either
1678 there is no augmentation data, or we saw a 'z' prefix. */
1681 if (cie->initial_instructions)
1682 buf = cie->initial_instructions;
1687 cie->initial_instructions = buf;
1690 add_cie (unit, cie);
1694 /* This is a FDE. */
1695 struct dwarf2_fde *fde;
1697 /* In an .eh_frame section, the CIE pointer is the delta between the
1698 address within the FDE where the CIE pointer is stored and the
1699 address of the CIE. Convert it to an offset into the .eh_frame
1703 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1704 cie_pointer -= (dwarf64_p ? 8 : 4);
1707 /* In either case, validate the result is still within the section. */
1708 if (cie_pointer >= unit->dwarf_frame_size)
1711 fde = (struct dwarf2_fde *)
1712 obstack_alloc (&unit->objfile->objfile_obstack,
1713 sizeof (struct dwarf2_fde));
1714 fde->cie = find_cie (unit, cie_pointer);
1715 if (fde->cie == NULL)
1717 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1719 fde->cie = find_cie (unit, cie_pointer);
1722 gdb_assert (fde->cie != NULL);
1724 fde->initial_location =
1725 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1728 fde->address_range =
1729 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1732 /* A 'z' augmentation in the CIE implies the presence of an
1733 augmentation field in the FDE as well. The only thing known
1734 to be in here at present is the LSDA entry for EH. So we
1735 can skip the whole thing. */
1736 if (fde->cie->saw_z_augmentation)
1740 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1741 buf += bytes_read + length;
1746 fde->instructions = buf;
1749 fde->eh_frame_p = eh_frame_p;
1751 add_fde (unit, fde);
1757 /* Read a CIE or FDE in BUF and decode it. */
1759 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1761 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1764 ptrdiff_t start_offset;
1768 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1772 /* We have corrupt input data of some form. */
1774 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1775 and mismatches wrt padding and alignment of debug sections. */
1776 /* Note that there is no requirement in the standard for any
1777 alignment at all in the frame unwind sections. Testing for
1778 alignment before trying to interpret data would be incorrect.
1780 However, GCC traditionally arranged for frame sections to be
1781 sized such that the FDE length and CIE fields happen to be
1782 aligned (in theory, for performance). This, unfortunately,
1783 was done with .align directives, which had the side effect of
1784 forcing the section to be aligned by the linker.
1786 This becomes a problem when you have some other producer that
1787 creates frame sections that are not as strictly aligned. That
1788 produces a hole in the frame info that gets filled by the
1791 The GCC behaviour is arguably a bug, but it's effectively now
1792 part of the ABI, so we're now stuck with it, at least at the
1793 object file level. A smart linker may decide, in the process
1794 of compressing duplicate CIE information, that it can rewrite
1795 the entire output section without this extra padding. */
1797 start_offset = start - unit->dwarf_frame_buffer;
1798 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1800 start += 4 - (start_offset & 3);
1801 workaround = ALIGN4;
1804 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1806 start += 8 - (start_offset & 7);
1807 workaround = ALIGN8;
1811 /* Nothing left to try. Arrange to return as if we've consumed
1812 the entire input section. Hopefully we'll get valid info from
1813 the other of .debug_frame/.eh_frame. */
1815 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1825 complaint (&symfile_complaints,
1826 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1827 unit->dwarf_frame_section->owner->filename,
1828 unit->dwarf_frame_section->name);
1832 complaint (&symfile_complaints,
1833 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1834 unit->dwarf_frame_section->owner->filename,
1835 unit->dwarf_frame_section->name);
1839 complaint (&symfile_complaints,
1840 _("Corrupt data in %s:%s"),
1841 unit->dwarf_frame_section->owner->filename,
1842 unit->dwarf_frame_section->name);
1850 /* FIXME: kettenis/20030504: This still needs to be integrated with
1851 dwarf2read.c in a better way. */
1853 /* Imported from dwarf2read.c. */
1854 extern asection *dwarf_frame_section;
1855 extern asection *dwarf_eh_frame_section;
1857 /* Imported from dwarf2read.c. */
1858 extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1861 dwarf2_build_frame_info (struct objfile *objfile)
1863 struct comp_unit unit;
1864 gdb_byte *frame_ptr;
1866 /* Build a minimal decoding of the DWARF2 compilation unit. */
1867 unit.abfd = objfile->obfd;
1868 unit.objfile = objfile;
1872 /* First add the information from the .eh_frame section. That way,
1873 the FDEs from that section are searched last. */
1874 if (dwarf_eh_frame_section)
1876 asection *got, *txt;
1879 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1880 dwarf_eh_frame_section);
1882 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1883 unit.dwarf_frame_section = dwarf_eh_frame_section;
1885 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1886 that is used for the i386/amd64 target, which currently is
1887 the only target in GCC that supports/uses the
1888 DW_EH_PE_datarel encoding. */
1889 got = bfd_get_section_by_name (unit.abfd, ".got");
1891 unit.dbase = got->vma;
1893 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1895 txt = bfd_get_section_by_name (unit.abfd, ".text");
1897 unit.tbase = txt->vma;
1899 frame_ptr = unit.dwarf_frame_buffer;
1900 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1901 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
1904 if (dwarf_frame_section)
1907 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1908 dwarf_frame_section);
1909 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1910 unit.dwarf_frame_section = dwarf_frame_section;
1912 frame_ptr = unit.dwarf_frame_buffer;
1913 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1914 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1918 /* Provide a prototype to silence -Wmissing-prototypes. */
1919 void _initialize_dwarf2_frame (void);
1922 _initialize_dwarf2_frame (void)
1924 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
1925 dwarf2_frame_objfile_data = register_objfile_data ();