1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003-2016 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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "dwarf2expr.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
36 #include "complaints.h"
37 #include "dwarf2-frame.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame-tailcall.h"
44 /* Call Frame Information (CFI). */
46 /* Common Information Entry (CIE). */
50 /* Computation Unit for this CIE. */
51 struct comp_unit *unit;
53 /* Offset into the .debug_frame section where this CIE was found.
54 Used to identify this CIE. */
57 /* Constant that is factored out of all advance location
59 ULONGEST code_alignment_factor;
61 /* Constants that is factored out of all offset instructions. */
62 LONGEST data_alignment_factor;
64 /* Return address column. */
65 ULONGEST return_address_register;
67 /* Instruction sequence to initialize a register set. */
68 const gdb_byte *initial_instructions;
71 /* Saved augmentation, in case it's needed later. */
74 /* Encoding of addresses. */
77 /* Target address size in bytes. */
80 /* Target pointer size in bytes. */
83 /* True if a 'z' augmentation existed. */
84 unsigned char saw_z_augmentation;
86 /* True if an 'S' augmentation existed. */
87 unsigned char signal_frame;
89 /* The version recorded in the CIE. */
90 unsigned char version;
92 /* The segment size. */
93 unsigned char segment_size;
96 struct dwarf2_cie_table
99 struct dwarf2_cie **entries;
102 /* Frame Description Entry (FDE). */
106 /* CIE for this FDE. */
107 struct dwarf2_cie *cie;
109 /* First location associated with this FDE. */
110 CORE_ADDR initial_location;
112 /* Number of bytes of program instructions described by this FDE. */
113 CORE_ADDR address_range;
115 /* Instruction sequence. */
116 const gdb_byte *instructions;
119 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
121 unsigned char eh_frame_p;
124 struct dwarf2_fde_table
127 struct dwarf2_fde **entries;
130 /* A minimal decoding of DWARF2 compilation units. We only decode
131 what's needed to get to the call frame information. */
135 /* Keep the bfd convenient. */
138 struct objfile *objfile;
140 /* Pointer to the .debug_frame section loaded into memory. */
141 const gdb_byte *dwarf_frame_buffer;
143 /* Length of the loaded .debug_frame section. */
144 bfd_size_type dwarf_frame_size;
146 /* Pointer to the .debug_frame section. */
147 asection *dwarf_frame_section;
149 /* Base for DW_EH_PE_datarel encodings. */
152 /* Base for DW_EH_PE_textrel encodings. */
156 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc,
157 CORE_ADDR *out_offset);
159 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
162 static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
163 int ptr_len, const gdb_byte *buf,
164 unsigned int *bytes_read_ptr,
165 CORE_ADDR func_base);
175 struct dwarf2_frame_state_reg_info
177 struct dwarf2_frame_state_reg *reg;
182 enum cfa_how_kind cfa_how;
183 const gdb_byte *cfa_exp;
185 /* Used to implement DW_CFA_remember_state. */
186 struct dwarf2_frame_state_reg_info *prev;
189 /* Structure describing a frame state. */
191 struct dwarf2_frame_state
193 /* Each register save state can be described in terms of a CFA slot,
194 another register, or a location expression. */
195 struct dwarf2_frame_state_reg_info regs;
197 /* The PC described by the current frame state. */
200 /* Initial register set from the CIE.
201 Used to implement DW_CFA_restore. */
202 struct dwarf2_frame_state_reg_info initial;
204 /* The information we care about from the CIE. */
207 ULONGEST retaddr_column;
209 /* Flags for known producer quirks. */
211 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
212 and DW_CFA_def_cfa_offset takes a factored offset. */
213 int armcc_cfa_offsets_sf;
215 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
216 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
217 int armcc_cfa_offsets_reversed;
220 /* Store the length the expression for the CFA in the `cfa_reg' field,
221 which is unused in that case. */
222 #define cfa_exp_len cfa_reg
224 /* Assert that the register set RS is large enough to store gdbarch_num_regs
225 columns. If necessary, enlarge the register set. */
228 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
231 size_t size = sizeof (struct dwarf2_frame_state_reg);
233 if (num_regs <= rs->num_regs)
236 rs->reg = (struct dwarf2_frame_state_reg *)
237 xrealloc (rs->reg, num_regs * size);
239 /* Initialize newly allocated registers. */
240 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
241 rs->num_regs = num_regs;
244 /* Copy the register columns in register set RS into newly allocated
245 memory and return a pointer to this newly created copy. */
247 static struct dwarf2_frame_state_reg *
248 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
250 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
251 struct dwarf2_frame_state_reg *reg;
253 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
254 memcpy (reg, rs->reg, size);
259 /* Release the memory allocated to register set RS. */
262 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
266 dwarf2_frame_state_free_regs (rs->prev);
273 /* Release the memory allocated to the frame state FS. */
276 dwarf2_frame_state_free (void *p)
278 struct dwarf2_frame_state *fs = (struct dwarf2_frame_state *) p;
280 dwarf2_frame_state_free_regs (fs->initial.prev);
281 dwarf2_frame_state_free_regs (fs->regs.prev);
282 xfree (fs->initial.reg);
283 xfree (fs->regs.reg);
288 /* Helper functions for execute_stack_op. */
291 read_addr_from_reg (struct frame_info *this_frame, int reg)
293 struct gdbarch *gdbarch = get_frame_arch (this_frame);
294 int regnum = dwarf_reg_to_regnum_or_error (gdbarch, reg);
296 return address_from_register (regnum, this_frame);
299 /* Execute the required actions for both the DW_CFA_restore and
300 DW_CFA_restore_extended instructions. */
302 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
303 struct dwarf2_frame_state *fs, int eh_frame_p)
307 gdb_assert (fs->initial.reg);
308 reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
309 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
311 /* Check if this register was explicitly initialized in the
312 CIE initial instructions. If not, default the rule to
314 if (reg < fs->initial.num_regs)
315 fs->regs.reg[reg] = fs->initial.reg[reg];
317 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
319 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
321 int regnum = dwarf_reg_to_regnum (gdbarch, reg);
323 complaint (&symfile_complaints, _("\
324 incomplete CFI data; DW_CFA_restore unspecified\n\
325 register %s (#%d) at %s"),
326 gdbarch_register_name (gdbarch, regnum), regnum,
327 paddress (gdbarch, fs->pc));
331 class dwarf_expr_executor : public dwarf_expr_context
335 struct frame_info *this_frame;
337 CORE_ADDR read_addr_from_reg (int reg) OVERRIDE
339 return ::read_addr_from_reg (this_frame, reg);
342 struct value *get_reg_value (struct type *type, int reg) OVERRIDE
344 struct gdbarch *gdbarch = get_frame_arch (this_frame);
345 int regnum = dwarf_reg_to_regnum_or_error (gdbarch, reg);
347 return value_from_register (type, regnum, this_frame);
350 void read_mem (gdb_byte *buf, CORE_ADDR addr, size_t len) OVERRIDE
352 read_memory (addr, buf, len);
357 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
358 CORE_ADDR offset, struct frame_info *this_frame,
359 CORE_ADDR initial, int initial_in_stack_memory)
362 struct cleanup *old_chain;
364 dwarf_expr_executor ctx;
365 old_chain = make_cleanup_value_free_to_mark (value_mark ());
367 ctx.this_frame = this_frame;
368 ctx.gdbarch = get_frame_arch (this_frame);
369 ctx.addr_size = addr_size;
370 ctx.ref_addr_size = -1;
373 ctx.push_address (initial, initial_in_stack_memory);
376 if (ctx.location == DWARF_VALUE_MEMORY)
377 result = ctx.fetch_address (0);
378 else if (ctx.location == DWARF_VALUE_REGISTER)
379 result = ctx.read_addr_from_reg (value_as_long (ctx.fetch (0)));
382 /* This is actually invalid DWARF, but if we ever do run across
383 it somehow, we might as well support it. So, instead, report
384 it as unimplemented. */
386 Not implemented: computing unwound register using explicit value operator"));
389 do_cleanups (old_chain);
395 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
396 PC. Modify FS state accordingly. Return current INSN_PTR where the
397 execution has stopped, one can resume it on the next call. */
399 static const gdb_byte *
400 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
401 const gdb_byte *insn_end, struct gdbarch *gdbarch,
402 CORE_ADDR pc, struct dwarf2_frame_state *fs)
404 int eh_frame_p = fde->eh_frame_p;
405 unsigned int bytes_read;
406 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
408 while (insn_ptr < insn_end && fs->pc <= pc)
410 gdb_byte insn = *insn_ptr++;
414 if ((insn & 0xc0) == DW_CFA_advance_loc)
415 fs->pc += (insn & 0x3f) * fs->code_align;
416 else if ((insn & 0xc0) == DW_CFA_offset)
419 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
420 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
421 offset = utmp * fs->data_align;
422 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
423 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
424 fs->regs.reg[reg].loc.offset = offset;
426 else if ((insn & 0xc0) == DW_CFA_restore)
429 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
436 fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
437 fde->cie->ptr_size, insn_ptr,
438 &bytes_read, fde->initial_location);
439 /* Apply the objfile offset for relocatable objects. */
440 fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
441 SECT_OFF_TEXT (fde->cie->unit->objfile));
442 insn_ptr += bytes_read;
445 case DW_CFA_advance_loc1:
446 utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
447 fs->pc += utmp * fs->code_align;
450 case DW_CFA_advance_loc2:
451 utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
452 fs->pc += utmp * fs->code_align;
455 case DW_CFA_advance_loc4:
456 utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
457 fs->pc += utmp * fs->code_align;
461 case DW_CFA_offset_extended:
462 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
463 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
464 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
465 offset = utmp * fs->data_align;
466 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
467 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
468 fs->regs.reg[reg].loc.offset = offset;
471 case DW_CFA_restore_extended:
472 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
473 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
476 case DW_CFA_undefined:
477 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
478 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
479 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
480 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
483 case DW_CFA_same_value:
484 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
485 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
486 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
487 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
490 case DW_CFA_register:
491 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
492 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
493 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
494 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
495 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
496 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
497 fs->regs.reg[reg].loc.reg = utmp;
500 case DW_CFA_remember_state:
502 struct dwarf2_frame_state_reg_info *new_rs;
504 new_rs = XNEW (struct dwarf2_frame_state_reg_info);
506 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
507 fs->regs.prev = new_rs;
511 case DW_CFA_restore_state:
513 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
517 complaint (&symfile_complaints, _("\
518 bad CFI data; mismatched DW_CFA_restore_state at %s"),
519 paddress (gdbarch, fs->pc));
523 xfree (fs->regs.reg);
531 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
532 fs->regs.cfa_reg = reg;
533 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
535 if (fs->armcc_cfa_offsets_sf)
536 utmp *= fs->data_align;
538 fs->regs.cfa_offset = utmp;
539 fs->regs.cfa_how = CFA_REG_OFFSET;
542 case DW_CFA_def_cfa_register:
543 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
544 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
546 fs->regs.cfa_how = CFA_REG_OFFSET;
549 case DW_CFA_def_cfa_offset:
550 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
552 if (fs->armcc_cfa_offsets_sf)
553 utmp *= fs->data_align;
555 fs->regs.cfa_offset = utmp;
556 /* cfa_how deliberately not set. */
562 case DW_CFA_def_cfa_expression:
563 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
564 fs->regs.cfa_exp_len = utmp;
565 fs->regs.cfa_exp = insn_ptr;
566 fs->regs.cfa_how = CFA_EXP;
567 insn_ptr += fs->regs.cfa_exp_len;
570 case DW_CFA_expression:
571 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
572 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
573 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
574 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
575 fs->regs.reg[reg].loc.exp = insn_ptr;
576 fs->regs.reg[reg].exp_len = utmp;
577 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
581 case DW_CFA_offset_extended_sf:
582 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
583 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
584 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
585 offset *= fs->data_align;
586 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
587 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
588 fs->regs.reg[reg].loc.offset = offset;
591 case DW_CFA_val_offset:
592 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
593 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
594 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
595 offset = utmp * fs->data_align;
596 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
597 fs->regs.reg[reg].loc.offset = offset;
600 case DW_CFA_val_offset_sf:
601 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
602 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
603 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
604 offset *= fs->data_align;
605 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
606 fs->regs.reg[reg].loc.offset = offset;
609 case DW_CFA_val_expression:
610 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
611 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
612 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
613 fs->regs.reg[reg].loc.exp = insn_ptr;
614 fs->regs.reg[reg].exp_len = utmp;
615 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
619 case DW_CFA_def_cfa_sf:
620 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
621 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
623 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
624 fs->regs.cfa_offset = offset * fs->data_align;
625 fs->regs.cfa_how = CFA_REG_OFFSET;
628 case DW_CFA_def_cfa_offset_sf:
629 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
630 fs->regs.cfa_offset = offset * fs->data_align;
631 /* cfa_how deliberately not set. */
634 case DW_CFA_GNU_window_save:
635 /* This is SPARC-specific code, and contains hard-coded
636 constants for the register numbering scheme used by
637 GCC. Rather than having a architecture-specific
638 operation that's only ever used by a single
639 architecture, we provide the implementation here.
640 Incidentally that's what GCC does too in its
643 int size = register_size (gdbarch, 0);
645 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
646 for (reg = 8; reg < 16; reg++)
648 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
649 fs->regs.reg[reg].loc.reg = reg + 16;
651 for (reg = 16; reg < 32; reg++)
653 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
654 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
659 case DW_CFA_GNU_args_size:
661 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
664 case DW_CFA_GNU_negative_offset_extended:
665 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
666 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
667 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
668 offset = utmp * fs->data_align;
669 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
670 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
671 fs->regs.reg[reg].loc.offset = -offset;
675 internal_error (__FILE__, __LINE__,
676 _("Unknown CFI encountered."));
681 if (fs->initial.reg == NULL)
683 /* Don't allow remember/restore between CIE and FDE programs. */
684 dwarf2_frame_state_free_regs (fs->regs.prev);
685 fs->regs.prev = NULL;
692 /* Architecture-specific operations. */
694 /* Per-architecture data key. */
695 static struct gdbarch_data *dwarf2_frame_data;
697 struct dwarf2_frame_ops
699 /* Pre-initialize the register state REG for register REGNUM. */
700 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
701 struct frame_info *);
703 /* Check whether the THIS_FRAME is a signal trampoline. */
704 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
706 /* Convert .eh_frame register number to DWARF register number, or
707 adjust .debug_frame register number. */
708 int (*adjust_regnum) (struct gdbarch *, int, int);
711 /* Default architecture-specific register state initialization
715 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
716 struct dwarf2_frame_state_reg *reg,
717 struct frame_info *this_frame)
719 /* If we have a register that acts as a program counter, mark it as
720 a destination for the return address. If we have a register that
721 serves as the stack pointer, arrange for it to be filled with the
722 call frame address (CFA). The other registers are marked as
725 We copy the return address to the program counter, since many
726 parts in GDB assume that it is possible to get the return address
727 by unwinding the program counter register. However, on ISA's
728 with a dedicated return address register, the CFI usually only
729 contains information to unwind that return address register.
731 The reason we're treating the stack pointer special here is
732 because in many cases GCC doesn't emit CFI for the stack pointer
733 and implicitly assumes that it is equal to the CFA. This makes
734 some sense since the DWARF specification (version 3, draft 8,
737 "Typically, the CFA is defined to be the value of the stack
738 pointer at the call site in the previous frame (which may be
739 different from its value on entry to the current frame)."
741 However, this isn't true for all platforms supported by GCC
742 (e.g. IBM S/390 and zSeries). Those architectures should provide
743 their own architecture-specific initialization function. */
745 if (regnum == gdbarch_pc_regnum (gdbarch))
746 reg->how = DWARF2_FRAME_REG_RA;
747 else if (regnum == gdbarch_sp_regnum (gdbarch))
748 reg->how = DWARF2_FRAME_REG_CFA;
751 /* Return a default for the architecture-specific operations. */
754 dwarf2_frame_init (struct obstack *obstack)
756 struct dwarf2_frame_ops *ops;
758 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
759 ops->init_reg = dwarf2_frame_default_init_reg;
763 /* Set the architecture-specific register state initialization
764 function for GDBARCH to INIT_REG. */
767 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
768 void (*init_reg) (struct gdbarch *, int,
769 struct dwarf2_frame_state_reg *,
770 struct frame_info *))
772 struct dwarf2_frame_ops *ops
773 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
775 ops->init_reg = init_reg;
778 /* Pre-initialize the register state REG for register REGNUM. */
781 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
782 struct dwarf2_frame_state_reg *reg,
783 struct frame_info *this_frame)
785 struct dwarf2_frame_ops *ops
786 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
788 ops->init_reg (gdbarch, regnum, reg, this_frame);
791 /* Set the architecture-specific signal trampoline recognition
792 function for GDBARCH to SIGNAL_FRAME_P. */
795 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
796 int (*signal_frame_p) (struct gdbarch *,
797 struct frame_info *))
799 struct dwarf2_frame_ops *ops
800 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
802 ops->signal_frame_p = signal_frame_p;
805 /* Query the architecture-specific signal frame recognizer for
809 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
810 struct frame_info *this_frame)
812 struct dwarf2_frame_ops *ops
813 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
815 if (ops->signal_frame_p == NULL)
817 return ops->signal_frame_p (gdbarch, this_frame);
820 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
824 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
825 int (*adjust_regnum) (struct gdbarch *,
828 struct dwarf2_frame_ops *ops
829 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
831 ops->adjust_regnum = adjust_regnum;
834 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
838 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
839 int regnum, int eh_frame_p)
841 struct dwarf2_frame_ops *ops
842 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
844 if (ops->adjust_regnum == NULL)
846 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
850 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
851 struct dwarf2_fde *fde)
853 struct compunit_symtab *cust;
855 cust = find_pc_compunit_symtab (fs->pc);
859 if (producer_is_realview (COMPUNIT_PRODUCER (cust)))
861 if (fde->cie->version == 1)
862 fs->armcc_cfa_offsets_sf = 1;
864 if (fde->cie->version == 1)
865 fs->armcc_cfa_offsets_reversed = 1;
867 /* The reversed offset problem is present in some compilers
868 using DWARF3, but it was eventually fixed. Check the ARM
869 defined augmentations, which are in the format "armcc" followed
870 by a list of one-character options. The "+" option means
871 this problem is fixed (no quirk needed). If the armcc
872 augmentation is missing, the quirk is needed. */
873 if (fde->cie->version == 3
874 && (!startswith (fde->cie->augmentation, "armcc")
875 || strchr (fde->cie->augmentation + 5, '+') == NULL))
876 fs->armcc_cfa_offsets_reversed = 1;
883 /* See dwarf2-frame.h. */
886 dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc,
887 struct dwarf2_per_cu_data *data,
888 int *regnum_out, LONGEST *offset_out,
889 CORE_ADDR *text_offset_out,
890 const gdb_byte **cfa_start_out,
891 const gdb_byte **cfa_end_out)
893 struct dwarf2_fde *fde;
894 CORE_ADDR text_offset;
895 struct dwarf2_frame_state fs;
897 memset (&fs, 0, sizeof (struct dwarf2_frame_state));
901 /* Find the correct FDE. */
902 fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
904 error (_("Could not compute CFA; needed to translate this expression"));
906 /* Extract any interesting information from the CIE. */
907 fs.data_align = fde->cie->data_alignment_factor;
908 fs.code_align = fde->cie->code_alignment_factor;
909 fs.retaddr_column = fde->cie->return_address_register;
911 /* Check for "quirks" - known bugs in producers. */
912 dwarf2_frame_find_quirks (&fs, fde);
914 /* First decode all the insns in the CIE. */
915 execute_cfa_program (fde, fde->cie->initial_instructions,
916 fde->cie->end, gdbarch, pc, &fs);
918 /* Save the initialized register set. */
919 fs.initial = fs.regs;
920 fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
922 /* Then decode the insns in the FDE up to our target PC. */
923 execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
925 /* Calculate the CFA. */
926 switch (fs.regs.cfa_how)
930 int regnum = dwarf_reg_to_regnum_or_error (gdbarch, fs.regs.cfa_reg);
932 *regnum_out = regnum;
933 if (fs.armcc_cfa_offsets_reversed)
934 *offset_out = -fs.regs.cfa_offset;
936 *offset_out = fs.regs.cfa_offset;
941 *text_offset_out = text_offset;
942 *cfa_start_out = fs.regs.cfa_exp;
943 *cfa_end_out = fs.regs.cfa_exp + fs.regs.cfa_exp_len;
947 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
952 struct dwarf2_frame_cache
954 /* DWARF Call Frame Address. */
957 /* Set if the return address column was marked as unavailable
958 (required non-collected memory or registers to compute). */
959 int unavailable_retaddr;
961 /* Set if the return address column was marked as undefined. */
962 int undefined_retaddr;
964 /* Saved registers, indexed by GDB register number, not by DWARF
966 struct dwarf2_frame_state_reg *reg;
968 /* Return address register. */
969 struct dwarf2_frame_state_reg retaddr_reg;
971 /* Target address size in bytes. */
974 /* The .text offset. */
975 CORE_ADDR text_offset;
977 /* True if we already checked whether this frame is the bottom frame
978 of a virtual tail call frame chain. */
979 int checked_tailcall_bottom;
981 /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
982 sequence. If NULL then it is a normal case with no TAILCALL_FRAME
983 involved. Non-bottom frames of a virtual tail call frames chain use
984 dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
986 void *tailcall_cache;
988 /* The number of bytes to subtract from TAILCALL_FRAME frames frame
989 base to get the SP, to simulate the return address pushed on the
991 LONGEST entry_cfa_sp_offset;
992 int entry_cfa_sp_offset_p;
995 /* A cleanup that sets a pointer to NULL. */
998 clear_pointer_cleanup (void *arg)
1000 void **ptr = (void **) arg;
1005 static struct dwarf2_frame_cache *
1006 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
1008 struct cleanup *reset_cache_cleanup, *old_chain;
1009 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1010 const int num_regs = gdbarch_num_regs (gdbarch)
1011 + gdbarch_num_pseudo_regs (gdbarch);
1012 struct dwarf2_frame_cache *cache;
1013 struct dwarf2_frame_state *fs;
1014 struct dwarf2_fde *fde;
1016 const gdb_byte *instr;
1019 return (struct dwarf2_frame_cache *) *this_cache;
1021 /* Allocate a new cache. */
1022 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1023 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
1024 *this_cache = cache;
1025 reset_cache_cleanup = make_cleanup (clear_pointer_cleanup, this_cache);
1027 /* Allocate and initialize the frame state. */
1028 fs = XCNEW (struct dwarf2_frame_state);
1029 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1033 Note that if the next frame is never supposed to return (i.e. a call
1034 to abort), the compiler might optimize away the instruction at
1035 its return address. As a result the return address will
1036 point at some random instruction, and the CFI for that
1037 instruction is probably worthless to us. GCC's unwinder solves
1038 this problem by substracting 1 from the return address to get an
1039 address in the middle of a presumed call instruction (or the
1040 instruction in the associated delay slot). This should only be
1041 done for "normal" frames and not for resume-type frames (signal
1042 handlers, sentinel frames, dummy frames). The function
1043 get_frame_address_in_block does just this. It's not clear how
1044 reliable the method is though; there is the potential for the
1045 register state pre-call being different to that on return. */
1046 fs->pc = get_frame_address_in_block (this_frame);
1048 /* Find the correct FDE. */
1049 fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
1050 gdb_assert (fde != NULL);
1052 /* Extract any interesting information from the CIE. */
1053 fs->data_align = fde->cie->data_alignment_factor;
1054 fs->code_align = fde->cie->code_alignment_factor;
1055 fs->retaddr_column = fde->cie->return_address_register;
1056 cache->addr_size = fde->cie->addr_size;
1058 /* Check for "quirks" - known bugs in producers. */
1059 dwarf2_frame_find_quirks (fs, fde);
1061 /* First decode all the insns in the CIE. */
1062 execute_cfa_program (fde, fde->cie->initial_instructions,
1063 fde->cie->end, gdbarch,
1064 get_frame_address_in_block (this_frame), fs);
1066 /* Save the initialized register set. */
1067 fs->initial = fs->regs;
1068 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
1070 if (get_frame_func_if_available (this_frame, &entry_pc))
1072 /* Decode the insns in the FDE up to the entry PC. */
1073 instr = execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1076 if (fs->regs.cfa_how == CFA_REG_OFFSET
1077 && (dwarf_reg_to_regnum (gdbarch, fs->regs.cfa_reg)
1078 == gdbarch_sp_regnum (gdbarch)))
1080 cache->entry_cfa_sp_offset = fs->regs.cfa_offset;
1081 cache->entry_cfa_sp_offset_p = 1;
1085 instr = fde->instructions;
1087 /* Then decode the insns in the FDE up to our target PC. */
1088 execute_cfa_program (fde, instr, fde->end, gdbarch,
1089 get_frame_address_in_block (this_frame), fs);
1093 /* Calculate the CFA. */
1094 switch (fs->regs.cfa_how)
1096 case CFA_REG_OFFSET:
1097 cache->cfa = read_addr_from_reg (this_frame, fs->regs.cfa_reg);
1098 if (fs->armcc_cfa_offsets_reversed)
1099 cache->cfa -= fs->regs.cfa_offset;
1101 cache->cfa += fs->regs.cfa_offset;
1106 execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1107 cache->addr_size, cache->text_offset,
1112 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1115 CATCH (ex, RETURN_MASK_ERROR)
1117 if (ex.error == NOT_AVAILABLE_ERROR)
1119 cache->unavailable_retaddr = 1;
1120 do_cleanups (old_chain);
1121 discard_cleanups (reset_cache_cleanup);
1125 throw_exception (ex);
1129 /* Initialize the register state. */
1133 for (regnum = 0; regnum < num_regs; regnum++)
1134 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1137 /* Go through the DWARF2 CFI generated table and save its register
1138 location information in the cache. Note that we don't skip the
1139 return address column; it's perfectly all right for it to
1140 correspond to a real register. */
1142 int column; /* CFI speak for "register number". */
1144 for (column = 0; column < fs->regs.num_regs; column++)
1146 /* Use the GDB register number as the destination index. */
1147 int regnum = dwarf_reg_to_regnum (gdbarch, column);
1149 /* Protect against a target returning a bad register. */
1150 if (regnum < 0 || regnum >= num_regs)
1153 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1154 of all debug info registers. If it doesn't, complain (but
1155 not too loudly). It turns out that GCC assumes that an
1156 unspecified register implies "same value" when CFI (draft
1157 7) specifies nothing at all. Such a register could equally
1158 be interpreted as "undefined". Also note that this check
1159 isn't sufficient; it only checks that all registers in the
1160 range [0 .. max column] are specified, and won't detect
1161 problems when a debug info register falls outside of the
1162 table. We need a way of iterating through all the valid
1163 DWARF2 register numbers. */
1164 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1166 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1167 complaint (&symfile_complaints, _("\
1168 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1169 gdbarch_register_name (gdbarch, regnum),
1170 paddress (gdbarch, fs->pc));
1173 cache->reg[regnum] = fs->regs.reg[column];
1177 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1178 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1182 for (regnum = 0; regnum < num_regs; regnum++)
1184 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1185 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1187 struct dwarf2_frame_state_reg *retaddr_reg =
1188 &fs->regs.reg[fs->retaddr_column];
1190 /* It seems rather bizarre to specify an "empty" column as
1191 the return adress column. However, this is exactly
1192 what GCC does on some targets. It turns out that GCC
1193 assumes that the return address can be found in the
1194 register corresponding to the return address column.
1195 Incidentally, that's how we should treat a return
1196 address column specifying "same value" too. */
1197 if (fs->retaddr_column < fs->regs.num_regs
1198 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1199 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1201 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1202 cache->reg[regnum] = *retaddr_reg;
1204 cache->retaddr_reg = *retaddr_reg;
1208 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1210 cache->reg[regnum].loc.reg = fs->retaddr_column;
1211 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1215 cache->retaddr_reg.loc.reg = fs->retaddr_column;
1216 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1223 if (fs->retaddr_column < fs->regs.num_regs
1224 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1225 cache->undefined_retaddr = 1;
1227 do_cleanups (old_chain);
1228 discard_cleanups (reset_cache_cleanup);
1232 static enum unwind_stop_reason
1233 dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1236 struct dwarf2_frame_cache *cache
1237 = dwarf2_frame_cache (this_frame, this_cache);
1239 if (cache->unavailable_retaddr)
1240 return UNWIND_UNAVAILABLE;
1242 if (cache->undefined_retaddr)
1243 return UNWIND_OUTERMOST;
1245 return UNWIND_NO_REASON;
1249 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1250 struct frame_id *this_id)
1252 struct dwarf2_frame_cache *cache =
1253 dwarf2_frame_cache (this_frame, this_cache);
1255 if (cache->unavailable_retaddr)
1256 (*this_id) = frame_id_build_unavailable_stack (get_frame_func (this_frame));
1257 else if (cache->undefined_retaddr)
1260 (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1263 static struct value *
1264 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1267 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1268 struct dwarf2_frame_cache *cache =
1269 dwarf2_frame_cache (this_frame, this_cache);
1273 /* Check whether THIS_FRAME is the bottom frame of a virtual tail
1274 call frame chain. */
1275 if (!cache->checked_tailcall_bottom)
1277 cache->checked_tailcall_bottom = 1;
1278 dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache,
1279 (cache->entry_cfa_sp_offset_p
1280 ? &cache->entry_cfa_sp_offset : NULL));
1283 /* Non-bottom frames of a virtual tail call frames chain use
1284 dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1285 them. If dwarf2_tailcall_prev_register_first does not have specific value
1286 unwind the register, tail call frames are assumed to have the register set
1287 of the top caller. */
1288 if (cache->tailcall_cache)
1292 val = dwarf2_tailcall_prev_register_first (this_frame,
1293 &cache->tailcall_cache,
1299 switch (cache->reg[regnum].how)
1301 case DWARF2_FRAME_REG_UNDEFINED:
1302 /* If CFI explicitly specified that the value isn't defined,
1303 mark it as optimized away; the value isn't available. */
1304 return frame_unwind_got_optimized (this_frame, regnum);
1306 case DWARF2_FRAME_REG_SAVED_OFFSET:
1307 addr = cache->cfa + cache->reg[regnum].loc.offset;
1308 return frame_unwind_got_memory (this_frame, regnum, addr);
1310 case DWARF2_FRAME_REG_SAVED_REG:
1311 realnum = dwarf_reg_to_regnum_or_error
1312 (gdbarch, cache->reg[regnum].loc.reg);
1313 return frame_unwind_got_register (this_frame, regnum, realnum);
1315 case DWARF2_FRAME_REG_SAVED_EXP:
1316 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1317 cache->reg[regnum].exp_len,
1318 cache->addr_size, cache->text_offset,
1319 this_frame, cache->cfa, 1);
1320 return frame_unwind_got_memory (this_frame, regnum, addr);
1322 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1323 addr = cache->cfa + cache->reg[regnum].loc.offset;
1324 return frame_unwind_got_constant (this_frame, regnum, addr);
1326 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1327 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1328 cache->reg[regnum].exp_len,
1329 cache->addr_size, cache->text_offset,
1330 this_frame, cache->cfa, 1);
1331 return frame_unwind_got_constant (this_frame, regnum, addr);
1333 case DWARF2_FRAME_REG_UNSPECIFIED:
1334 /* GCC, in its infinite wisdom decided to not provide unwind
1335 information for registers that are "same value". Since
1336 DWARF2 (3 draft 7) doesn't define such behavior, said
1337 registers are actually undefined (which is different to CFI
1338 "undefined"). Code above issues a complaint about this.
1339 Here just fudge the books, assume GCC, and that the value is
1340 more inner on the stack. */
1341 return frame_unwind_got_register (this_frame, regnum, regnum);
1343 case DWARF2_FRAME_REG_SAME_VALUE:
1344 return frame_unwind_got_register (this_frame, regnum, regnum);
1346 case DWARF2_FRAME_REG_CFA:
1347 return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1349 case DWARF2_FRAME_REG_CFA_OFFSET:
1350 addr = cache->cfa + cache->reg[regnum].loc.offset;
1351 return frame_unwind_got_address (this_frame, regnum, addr);
1353 case DWARF2_FRAME_REG_RA_OFFSET:
1354 addr = cache->reg[regnum].loc.offset;
1355 regnum = dwarf_reg_to_regnum_or_error
1356 (gdbarch, cache->retaddr_reg.loc.reg);
1357 addr += get_frame_register_unsigned (this_frame, regnum);
1358 return frame_unwind_got_address (this_frame, regnum, addr);
1360 case DWARF2_FRAME_REG_FN:
1361 return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1364 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1368 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1369 call frames chain. */
1372 dwarf2_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1374 struct dwarf2_frame_cache *cache = dwarf2_frame_cache (self, &this_cache);
1376 if (cache->tailcall_cache)
1377 dwarf2_tailcall_frame_unwind.dealloc_cache (self, cache->tailcall_cache);
1381 dwarf2_frame_sniffer (const struct frame_unwind *self,
1382 struct frame_info *this_frame, void **this_cache)
1384 /* Grab an address that is guarenteed to reside somewhere within the
1385 function. get_frame_pc(), with a no-return next function, can
1386 end up returning something past the end of this function's body.
1387 If the frame we're sniffing for is a signal frame whose start
1388 address is placed on the stack by the OS, its FDE must
1389 extend one byte before its start address or we could potentially
1390 select the FDE of the previous function. */
1391 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1392 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1397 /* On some targets, signal trampolines may have unwind information.
1398 We need to recognize them so that we set the frame type
1401 if (fde->cie->signal_frame
1402 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1404 return self->type == SIGTRAMP_FRAME;
1406 if (self->type != NORMAL_FRAME)
1412 static const struct frame_unwind dwarf2_frame_unwind =
1415 dwarf2_frame_unwind_stop_reason,
1416 dwarf2_frame_this_id,
1417 dwarf2_frame_prev_register,
1419 dwarf2_frame_sniffer,
1420 dwarf2_frame_dealloc_cache
1423 static const struct frame_unwind dwarf2_signal_frame_unwind =
1426 dwarf2_frame_unwind_stop_reason,
1427 dwarf2_frame_this_id,
1428 dwarf2_frame_prev_register,
1430 dwarf2_frame_sniffer,
1432 /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1436 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1439 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1441 /* TAILCALL_FRAME must be first to find the record by
1442 dwarf2_tailcall_sniffer_first. */
1443 frame_unwind_append_unwinder (gdbarch, &dwarf2_tailcall_frame_unwind);
1445 frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1446 frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1450 /* There is no explicitly defined relationship between the CFA and the
1451 location of frame's local variables and arguments/parameters.
1452 Therefore, frame base methods on this page should probably only be
1453 used as a last resort, just to avoid printing total garbage as a
1454 response to the "info frame" command. */
1457 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1459 struct dwarf2_frame_cache *cache =
1460 dwarf2_frame_cache (this_frame, this_cache);
1465 static const struct frame_base dwarf2_frame_base =
1467 &dwarf2_frame_unwind,
1468 dwarf2_frame_base_address,
1469 dwarf2_frame_base_address,
1470 dwarf2_frame_base_address
1473 const struct frame_base *
1474 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1476 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1478 if (dwarf2_frame_find_fde (&block_addr, NULL))
1479 return &dwarf2_frame_base;
1484 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1485 the DWARF unwinder. This is used to implement
1486 DW_OP_call_frame_cfa. */
1489 dwarf2_frame_cfa (struct frame_info *this_frame)
1491 if (frame_unwinder_is (this_frame, &record_btrace_tailcall_frame_unwind)
1492 || frame_unwinder_is (this_frame, &record_btrace_frame_unwind))
1493 throw_error (NOT_AVAILABLE_ERROR,
1494 _("cfa not available for record btrace target"));
1496 while (get_frame_type (this_frame) == INLINE_FRAME)
1497 this_frame = get_prev_frame (this_frame);
1498 if (get_frame_unwind_stop_reason (this_frame) == UNWIND_UNAVAILABLE)
1499 throw_error (NOT_AVAILABLE_ERROR,
1500 _("can't compute CFA for this frame: "
1501 "required registers or memory are unavailable"));
1503 if (get_frame_id (this_frame).stack_status != FID_STACK_VALID)
1504 throw_error (NOT_AVAILABLE_ERROR,
1505 _("can't compute CFA for this frame: "
1506 "frame base not available"));
1508 return get_frame_base (this_frame);
1511 const struct objfile_data *dwarf2_frame_objfile_data;
1514 read_1_byte (bfd *abfd, const gdb_byte *buf)
1516 return bfd_get_8 (abfd, buf);
1520 read_4_bytes (bfd *abfd, const gdb_byte *buf)
1522 return bfd_get_32 (abfd, buf);
1526 read_8_bytes (bfd *abfd, const gdb_byte *buf)
1528 return bfd_get_64 (abfd, buf);
1532 read_initial_length (bfd *abfd, const gdb_byte *buf,
1533 unsigned int *bytes_read_ptr)
1537 result = bfd_get_32 (abfd, buf);
1538 if (result == 0xffffffff)
1540 result = bfd_get_64 (abfd, buf + 4);
1541 *bytes_read_ptr = 12;
1544 *bytes_read_ptr = 4;
1550 /* Pointer encoding helper functions. */
1552 /* GCC supports exception handling based on DWARF2 CFI. However, for
1553 technical reasons, it encodes addresses in its FDE's in a different
1554 way. Several "pointer encodings" are supported. The encoding
1555 that's used for a particular FDE is determined by the 'R'
1556 augmentation in the associated CIE. The argument of this
1557 augmentation is a single byte.
1559 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1560 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1561 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1562 address should be interpreted (absolute, relative to the current
1563 position in the FDE, ...). Bit 7, indicates that the address
1564 should be dereferenced. */
1567 encoding_for_size (unsigned int size)
1572 return DW_EH_PE_udata2;
1574 return DW_EH_PE_udata4;
1576 return DW_EH_PE_udata8;
1578 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1583 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1584 int ptr_len, const gdb_byte *buf,
1585 unsigned int *bytes_read_ptr,
1586 CORE_ADDR func_base)
1591 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1593 if (encoding & DW_EH_PE_indirect)
1594 internal_error (__FILE__, __LINE__,
1595 _("Unsupported encoding: DW_EH_PE_indirect"));
1597 *bytes_read_ptr = 0;
1599 switch (encoding & 0x70)
1601 case DW_EH_PE_absptr:
1604 case DW_EH_PE_pcrel:
1605 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1606 base += (buf - unit->dwarf_frame_buffer);
1608 case DW_EH_PE_datarel:
1611 case DW_EH_PE_textrel:
1614 case DW_EH_PE_funcrel:
1617 case DW_EH_PE_aligned:
1619 offset = buf - unit->dwarf_frame_buffer;
1620 if ((offset % ptr_len) != 0)
1622 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1623 buf += *bytes_read_ptr;
1627 internal_error (__FILE__, __LINE__,
1628 _("Invalid or unsupported encoding"));
1631 if ((encoding & 0x07) == 0x00)
1633 encoding |= encoding_for_size (ptr_len);
1634 if (bfd_get_sign_extend_vma (unit->abfd))
1635 encoding |= DW_EH_PE_signed;
1638 switch (encoding & 0x0f)
1640 case DW_EH_PE_uleb128:
1643 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1645 *bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf;
1646 return base + value;
1648 case DW_EH_PE_udata2:
1649 *bytes_read_ptr += 2;
1650 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1651 case DW_EH_PE_udata4:
1652 *bytes_read_ptr += 4;
1653 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1654 case DW_EH_PE_udata8:
1655 *bytes_read_ptr += 8;
1656 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1657 case DW_EH_PE_sleb128:
1660 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1662 *bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf;
1663 return base + value;
1665 case DW_EH_PE_sdata2:
1666 *bytes_read_ptr += 2;
1667 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1668 case DW_EH_PE_sdata4:
1669 *bytes_read_ptr += 4;
1670 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1671 case DW_EH_PE_sdata8:
1672 *bytes_read_ptr += 8;
1673 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1675 internal_error (__FILE__, __LINE__,
1676 _("Invalid or unsupported encoding"));
1682 bsearch_cie_cmp (const void *key, const void *element)
1684 ULONGEST cie_pointer = *(ULONGEST *) key;
1685 struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1687 if (cie_pointer == cie->cie_pointer)
1690 return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1693 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1694 static struct dwarf2_cie *
1695 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1697 struct dwarf2_cie **p_cie;
1699 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1700 bsearch be non-NULL. */
1701 if (cie_table->entries == NULL)
1703 gdb_assert (cie_table->num_entries == 0);
1707 p_cie = ((struct dwarf2_cie **)
1708 bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1709 sizeof (cie_table->entries[0]), bsearch_cie_cmp));
1715 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1717 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1719 const int n = cie_table->num_entries;
1722 || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1725 = XRESIZEVEC (struct dwarf2_cie *, cie_table->entries, n + 1);
1726 cie_table->entries[n] = cie;
1727 cie_table->num_entries = n + 1;
1731 bsearch_fde_cmp (const void *key, const void *element)
1733 CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1734 struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1736 if (seek_pc < fde->initial_location)
1738 if (seek_pc < fde->initial_location + fde->address_range)
1743 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1744 inital location associated with it into *PC. */
1746 static struct dwarf2_fde *
1747 dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
1749 struct objfile *objfile;
1751 ALL_OBJFILES (objfile)
1753 struct dwarf2_fde_table *fde_table;
1754 struct dwarf2_fde **p_fde;
1758 fde_table = ((struct dwarf2_fde_table *)
1759 objfile_data (objfile, dwarf2_frame_objfile_data));
1760 if (fde_table == NULL)
1762 dwarf2_build_frame_info (objfile);
1763 fde_table = ((struct dwarf2_fde_table *)
1764 objfile_data (objfile, dwarf2_frame_objfile_data));
1766 gdb_assert (fde_table != NULL);
1768 if (fde_table->num_entries == 0)
1771 gdb_assert (objfile->section_offsets);
1772 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1774 gdb_assert (fde_table->num_entries > 0);
1775 if (*pc < offset + fde_table->entries[0]->initial_location)
1778 seek_pc = *pc - offset;
1779 p_fde = ((struct dwarf2_fde **)
1780 bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1781 sizeof (fde_table->entries[0]), bsearch_fde_cmp));
1784 *pc = (*p_fde)->initial_location + offset;
1786 *out_offset = offset;
1793 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1795 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1797 if (fde->address_range == 0)
1798 /* Discard useless FDEs. */
1801 fde_table->num_entries += 1;
1802 fde_table->entries = XRESIZEVEC (struct dwarf2_fde *, fde_table->entries,
1803 fde_table->num_entries);
1804 fde_table->entries[fde_table->num_entries - 1] = fde;
1807 #define DW64_CIE_ID 0xffffffffffffffffULL
1809 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1814 EH_CIE_TYPE_ID = 1 << 0,
1815 EH_FDE_TYPE_ID = 1 << 1,
1816 EH_CIE_OR_FDE_TYPE_ID = EH_CIE_TYPE_ID | EH_FDE_TYPE_ID
1819 static const gdb_byte *decode_frame_entry (struct comp_unit *unit,
1820 const gdb_byte *start,
1822 struct dwarf2_cie_table *cie_table,
1823 struct dwarf2_fde_table *fde_table,
1824 enum eh_frame_type entry_type);
1826 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1827 Return NULL if invalid input, otherwise the next byte to be processed. */
1829 static const gdb_byte *
1830 decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
1832 struct dwarf2_cie_table *cie_table,
1833 struct dwarf2_fde_table *fde_table,
1834 enum eh_frame_type entry_type)
1836 struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1837 const gdb_byte *buf, *end;
1839 unsigned int bytes_read;
1842 ULONGEST cie_pointer;
1847 length = read_initial_length (unit->abfd, buf, &bytes_read);
1851 /* Are we still within the section? */
1852 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1858 /* Distinguish between 32 and 64-bit encoded frame info. */
1859 dwarf64_p = (bytes_read == 12);
1861 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1865 cie_id = DW64_CIE_ID;
1871 cie_pointer = read_8_bytes (unit->abfd, buf);
1876 cie_pointer = read_4_bytes (unit->abfd, buf);
1880 if (cie_pointer == cie_id)
1882 /* This is a CIE. */
1883 struct dwarf2_cie *cie;
1885 unsigned int cie_version;
1887 /* Check that a CIE was expected. */
1888 if ((entry_type & EH_CIE_TYPE_ID) == 0)
1889 error (_("Found a CIE when not expecting it."));
1891 /* Record the offset into the .debug_frame section of this CIE. */
1892 cie_pointer = start - unit->dwarf_frame_buffer;
1894 /* Check whether we've already read it. */
1895 if (find_cie (cie_table, cie_pointer))
1898 cie = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_cie);
1899 cie->initial_instructions = NULL;
1900 cie->cie_pointer = cie_pointer;
1902 /* The encoding for FDE's in a normal .debug_frame section
1903 depends on the target address size. */
1904 cie->encoding = DW_EH_PE_absptr;
1906 /* We'll determine the final value later, but we need to
1907 initialize it conservatively. */
1908 cie->signal_frame = 0;
1910 /* Check version number. */
1911 cie_version = read_1_byte (unit->abfd, buf);
1912 if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1914 cie->version = cie_version;
1917 /* Interpret the interesting bits of the augmentation. */
1918 cie->augmentation = augmentation = (char *) buf;
1919 buf += (strlen (augmentation) + 1);
1921 /* Ignore armcc augmentations. We only use them for quirks,
1922 and that doesn't happen until later. */
1923 if (startswith (augmentation, "armcc"))
1924 augmentation += strlen (augmentation);
1926 /* The GCC 2.x "eh" augmentation has a pointer immediately
1927 following the augmentation string, so it must be handled
1929 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1932 buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1936 if (cie->version >= 4)
1938 /* FIXME: check that this is the same as from the CU header. */
1939 cie->addr_size = read_1_byte (unit->abfd, buf);
1941 cie->segment_size = read_1_byte (unit->abfd, buf);
1946 cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1947 cie->segment_size = 0;
1949 /* Address values in .eh_frame sections are defined to have the
1950 target's pointer size. Watchout: This breaks frame info for
1951 targets with pointer size < address size, unless a .debug_frame
1952 section exists as well. */
1954 cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1956 cie->ptr_size = cie->addr_size;
1958 buf = gdb_read_uleb128 (buf, end, &uleb128);
1961 cie->code_alignment_factor = uleb128;
1963 buf = gdb_read_sleb128 (buf, end, &sleb128);
1966 cie->data_alignment_factor = sleb128;
1968 if (cie_version == 1)
1970 cie->return_address_register = read_1_byte (unit->abfd, buf);
1975 buf = gdb_read_uleb128 (buf, end, &uleb128);
1978 cie->return_address_register = uleb128;
1981 cie->return_address_register
1982 = dwarf2_frame_adjust_regnum (gdbarch,
1983 cie->return_address_register,
1986 cie->saw_z_augmentation = (*augmentation == 'z');
1987 if (cie->saw_z_augmentation)
1991 buf = gdb_read_uleb128 (buf, end, &length);
1994 cie->initial_instructions = buf + length;
1998 while (*augmentation)
2000 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
2001 if (*augmentation == 'L')
2008 /* "R" indicates a byte indicating how FDE addresses are encoded. */
2009 else if (*augmentation == 'R')
2011 cie->encoding = *buf++;
2015 /* "P" indicates a personality routine in the CIE augmentation. */
2016 else if (*augmentation == 'P')
2018 /* Skip. Avoid indirection since we throw away the result. */
2019 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
2020 read_encoded_value (unit, encoding, cie->ptr_size,
2021 buf, &bytes_read, 0);
2026 /* "S" indicates a signal frame, such that the return
2027 address must not be decremented to locate the call frame
2028 info for the previous frame; it might even be the first
2029 instruction of a function, so decrementing it would take
2030 us to a different function. */
2031 else if (*augmentation == 'S')
2033 cie->signal_frame = 1;
2037 /* Otherwise we have an unknown augmentation. Assume that either
2038 there is no augmentation data, or we saw a 'z' prefix. */
2041 if (cie->initial_instructions)
2042 buf = cie->initial_instructions;
2047 cie->initial_instructions = buf;
2051 add_cie (cie_table, cie);
2055 /* This is a FDE. */
2056 struct dwarf2_fde *fde;
2059 /* Check that an FDE was expected. */
2060 if ((entry_type & EH_FDE_TYPE_ID) == 0)
2061 error (_("Found an FDE when not expecting it."));
2063 /* In an .eh_frame section, the CIE pointer is the delta between the
2064 address within the FDE where the CIE pointer is stored and the
2065 address of the CIE. Convert it to an offset into the .eh_frame
2069 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2070 cie_pointer -= (dwarf64_p ? 8 : 4);
2073 /* In either case, validate the result is still within the section. */
2074 if (cie_pointer >= unit->dwarf_frame_size)
2077 fde = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_fde);
2078 fde->cie = find_cie (cie_table, cie_pointer);
2079 if (fde->cie == NULL)
2081 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
2082 eh_frame_p, cie_table, fde_table,
2084 fde->cie = find_cie (cie_table, cie_pointer);
2087 gdb_assert (fde->cie != NULL);
2089 addr = read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
2090 buf, &bytes_read, 0);
2091 fde->initial_location = gdbarch_adjust_dwarf2_addr (gdbarch, addr);
2094 fde->address_range =
2095 read_encoded_value (unit, fde->cie->encoding & 0x0f,
2096 fde->cie->ptr_size, buf, &bytes_read, 0);
2097 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + fde->address_range);
2098 fde->address_range = addr - fde->initial_location;
2101 /* A 'z' augmentation in the CIE implies the presence of an
2102 augmentation field in the FDE as well. The only thing known
2103 to be in here at present is the LSDA entry for EH. So we
2104 can skip the whole thing. */
2105 if (fde->cie->saw_z_augmentation)
2109 buf = gdb_read_uleb128 (buf, end, &length);
2117 fde->instructions = buf;
2120 fde->eh_frame_p = eh_frame_p;
2122 add_fde (fde_table, fde);
2128 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2129 expect an FDE or a CIE. */
2131 static const gdb_byte *
2132 decode_frame_entry (struct comp_unit *unit, const gdb_byte *start,
2134 struct dwarf2_cie_table *cie_table,
2135 struct dwarf2_fde_table *fde_table,
2136 enum eh_frame_type entry_type)
2138 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2139 const gdb_byte *ret;
2140 ptrdiff_t start_offset;
2144 ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2145 cie_table, fde_table, entry_type);
2149 /* We have corrupt input data of some form. */
2151 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2152 and mismatches wrt padding and alignment of debug sections. */
2153 /* Note that there is no requirement in the standard for any
2154 alignment at all in the frame unwind sections. Testing for
2155 alignment before trying to interpret data would be incorrect.
2157 However, GCC traditionally arranged for frame sections to be
2158 sized such that the FDE length and CIE fields happen to be
2159 aligned (in theory, for performance). This, unfortunately,
2160 was done with .align directives, which had the side effect of
2161 forcing the section to be aligned by the linker.
2163 This becomes a problem when you have some other producer that
2164 creates frame sections that are not as strictly aligned. That
2165 produces a hole in the frame info that gets filled by the
2168 The GCC behaviour is arguably a bug, but it's effectively now
2169 part of the ABI, so we're now stuck with it, at least at the
2170 object file level. A smart linker may decide, in the process
2171 of compressing duplicate CIE information, that it can rewrite
2172 the entire output section without this extra padding. */
2174 start_offset = start - unit->dwarf_frame_buffer;
2175 if (workaround < ALIGN4 && (start_offset & 3) != 0)
2177 start += 4 - (start_offset & 3);
2178 workaround = ALIGN4;
2181 if (workaround < ALIGN8 && (start_offset & 7) != 0)
2183 start += 8 - (start_offset & 7);
2184 workaround = ALIGN8;
2188 /* Nothing left to try. Arrange to return as if we've consumed
2189 the entire input section. Hopefully we'll get valid info from
2190 the other of .debug_frame/.eh_frame. */
2192 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2202 complaint (&symfile_complaints, _("\
2203 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2204 unit->dwarf_frame_section->owner->filename,
2205 unit->dwarf_frame_section->name);
2209 complaint (&symfile_complaints, _("\
2210 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2211 unit->dwarf_frame_section->owner->filename,
2212 unit->dwarf_frame_section->name);
2216 complaint (&symfile_complaints,
2217 _("Corrupt data in %s:%s"),
2218 unit->dwarf_frame_section->owner->filename,
2219 unit->dwarf_frame_section->name);
2227 qsort_fde_cmp (const void *a, const void *b)
2229 struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2230 struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2232 if (aa->initial_location == bb->initial_location)
2234 if (aa->address_range != bb->address_range
2235 && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2236 /* Linker bug, e.g. gold/10400.
2237 Work around it by keeping stable sort order. */
2238 return (a < b) ? -1 : 1;
2240 /* Put eh_frame entries after debug_frame ones. */
2241 return aa->eh_frame_p - bb->eh_frame_p;
2244 return (aa->initial_location < bb->initial_location) ? -1 : 1;
2248 dwarf2_build_frame_info (struct objfile *objfile)
2250 struct comp_unit *unit;
2251 const gdb_byte *frame_ptr;
2252 struct dwarf2_cie_table cie_table;
2253 struct dwarf2_fde_table fde_table;
2254 struct dwarf2_fde_table *fde_table2;
2256 cie_table.num_entries = 0;
2257 cie_table.entries = NULL;
2259 fde_table.num_entries = 0;
2260 fde_table.entries = NULL;
2262 /* Build a minimal decoding of the DWARF2 compilation unit. */
2263 unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2264 sizeof (struct comp_unit));
2265 unit->abfd = objfile->obfd;
2266 unit->objfile = objfile;
2270 if (objfile->separate_debug_objfile_backlink == NULL)
2272 /* Do not read .eh_frame from separate file as they must be also
2273 present in the main file. */
2274 dwarf2_get_section_info (objfile, DWARF2_EH_FRAME,
2275 &unit->dwarf_frame_section,
2276 &unit->dwarf_frame_buffer,
2277 &unit->dwarf_frame_size);
2278 if (unit->dwarf_frame_size)
2280 asection *got, *txt;
2282 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2283 that is used for the i386/amd64 target, which currently is
2284 the only target in GCC that supports/uses the
2285 DW_EH_PE_datarel encoding. */
2286 got = bfd_get_section_by_name (unit->abfd, ".got");
2288 unit->dbase = got->vma;
2290 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2292 txt = bfd_get_section_by_name (unit->abfd, ".text");
2294 unit->tbase = txt->vma;
2298 frame_ptr = unit->dwarf_frame_buffer;
2299 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2300 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2301 &cie_table, &fde_table,
2302 EH_CIE_OR_FDE_TYPE_ID);
2305 CATCH (e, RETURN_MASK_ERROR)
2307 warning (_("skipping .eh_frame info of %s: %s"),
2308 objfile_name (objfile), e.message);
2310 if (fde_table.num_entries != 0)
2312 xfree (fde_table.entries);
2313 fde_table.entries = NULL;
2314 fde_table.num_entries = 0;
2316 /* The cie_table is discarded by the next if. */
2320 if (cie_table.num_entries != 0)
2322 /* Reinit cie_table: debug_frame has different CIEs. */
2323 xfree (cie_table.entries);
2324 cie_table.num_entries = 0;
2325 cie_table.entries = NULL;
2330 dwarf2_get_section_info (objfile, DWARF2_DEBUG_FRAME,
2331 &unit->dwarf_frame_section,
2332 &unit->dwarf_frame_buffer,
2333 &unit->dwarf_frame_size);
2334 if (unit->dwarf_frame_size)
2336 int num_old_fde_entries = fde_table.num_entries;
2340 frame_ptr = unit->dwarf_frame_buffer;
2341 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2342 frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2343 &cie_table, &fde_table,
2344 EH_CIE_OR_FDE_TYPE_ID);
2346 CATCH (e, RETURN_MASK_ERROR)
2348 warning (_("skipping .debug_frame info of %s: %s"),
2349 objfile_name (objfile), e.message);
2351 if (fde_table.num_entries != 0)
2353 fde_table.num_entries = num_old_fde_entries;
2354 if (num_old_fde_entries == 0)
2356 xfree (fde_table.entries);
2357 fde_table.entries = NULL;
2362 = XRESIZEVEC (struct dwarf2_fde *, fde_table.entries,
2363 fde_table.num_entries);
2366 fde_table.num_entries = num_old_fde_entries;
2367 /* The cie_table is discarded by the next if. */
2372 /* Discard the cie_table, it is no longer needed. */
2373 if (cie_table.num_entries != 0)
2375 xfree (cie_table.entries);
2376 cie_table.entries = NULL; /* Paranoia. */
2377 cie_table.num_entries = 0; /* Paranoia. */
2380 /* Copy fde_table to obstack: it is needed at runtime. */
2381 fde_table2 = XOBNEW (&objfile->objfile_obstack, struct dwarf2_fde_table);
2383 if (fde_table.num_entries == 0)
2385 fde_table2->entries = NULL;
2386 fde_table2->num_entries = 0;
2390 struct dwarf2_fde *fde_prev = NULL;
2391 struct dwarf2_fde *first_non_zero_fde = NULL;
2394 /* Prepare FDE table for lookups. */
2395 qsort (fde_table.entries, fde_table.num_entries,
2396 sizeof (fde_table.entries[0]), qsort_fde_cmp);
2398 /* Check for leftovers from --gc-sections. The GNU linker sets
2399 the relevant symbols to zero, but doesn't zero the FDE *end*
2400 ranges because there's no relocation there. It's (offset,
2401 length), not (start, end). On targets where address zero is
2402 just another valid address this can be a problem, since the
2403 FDEs appear to be non-empty in the output --- we could pick
2404 out the wrong FDE. To work around this, when overlaps are
2405 detected, we prefer FDEs that do not start at zero.
2407 Start by finding the first FDE with non-zero start. Below
2408 we'll discard all FDEs that start at zero and overlap this
2410 for (i = 0; i < fde_table.num_entries; i++)
2412 struct dwarf2_fde *fde = fde_table.entries[i];
2414 if (fde->initial_location != 0)
2416 first_non_zero_fde = fde;
2421 /* Since we'll be doing bsearch, squeeze out identical (except
2422 for eh_frame_p) fde entries so bsearch result is predictable.
2423 Also discard leftovers from --gc-sections. */
2424 fde_table2->num_entries = 0;
2425 for (i = 0; i < fde_table.num_entries; i++)
2427 struct dwarf2_fde *fde = fde_table.entries[i];
2429 if (fde->initial_location == 0
2430 && first_non_zero_fde != NULL
2431 && (first_non_zero_fde->initial_location
2432 < fde->initial_location + fde->address_range))
2435 if (fde_prev != NULL
2436 && fde_prev->initial_location == fde->initial_location)
2439 obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2440 sizeof (fde_table.entries[0]));
2441 ++fde_table2->num_entries;
2445 = (struct dwarf2_fde **) obstack_finish (&objfile->objfile_obstack);
2447 /* Discard the original fde_table. */
2448 xfree (fde_table.entries);
2451 set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2454 /* Provide a prototype to silence -Wmissing-prototypes. */
2455 void _initialize_dwarf2_frame (void);
2458 _initialize_dwarf2_frame (void)
2460 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2461 dwarf2_frame_objfile_data = register_objfile_data ();