1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003-2017 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);
355 void get_frame_base (const gdb_byte **start, size_t *length) OVERRIDE
357 invalid ("DW_OP_fbreg");
360 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind,
361 union call_site_parameter_u kind_u,
362 int deref_size) OVERRIDE
364 invalid ("DW_OP_entry_value");
367 CORE_ADDR get_object_address () OVERRIDE
369 invalid ("DW_OP_push_object_address");
372 CORE_ADDR get_frame_cfa () OVERRIDE
374 invalid ("DW_OP_call_frame_cfa");
377 CORE_ADDR get_tls_address (CORE_ADDR offset) OVERRIDE
379 invalid ("DW_OP_form_tls_address");
382 void dwarf_call (cu_offset die_offset) OVERRIDE
384 invalid ("DW_OP_call*");
387 CORE_ADDR get_addr_index (unsigned int index)
389 invalid ("DW_OP_GNU_addr_index");
394 void invalid (const char *op) ATTRIBUTE_NORETURN
396 error (_("%s is invalid in this context"), op);
401 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
402 CORE_ADDR offset, struct frame_info *this_frame,
403 CORE_ADDR initial, int initial_in_stack_memory)
407 dwarf_expr_executor ctx;
408 scoped_value_mark free_values;
410 ctx.this_frame = this_frame;
411 ctx.gdbarch = get_frame_arch (this_frame);
412 ctx.addr_size = addr_size;
413 ctx.ref_addr_size = -1;
416 ctx.push_address (initial, initial_in_stack_memory);
419 if (ctx.location == DWARF_VALUE_MEMORY)
420 result = ctx.fetch_address (0);
421 else if (ctx.location == DWARF_VALUE_REGISTER)
422 result = ctx.read_addr_from_reg (value_as_long (ctx.fetch (0)));
425 /* This is actually invalid DWARF, but if we ever do run across
426 it somehow, we might as well support it. So, instead, report
427 it as unimplemented. */
429 Not implemented: computing unwound register using explicit value operator"));
436 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
437 PC. Modify FS state accordingly. Return current INSN_PTR where the
438 execution has stopped, one can resume it on the next call. */
440 static const gdb_byte *
441 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
442 const gdb_byte *insn_end, struct gdbarch *gdbarch,
443 CORE_ADDR pc, struct dwarf2_frame_state *fs)
445 int eh_frame_p = fde->eh_frame_p;
446 unsigned int bytes_read;
447 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
449 while (insn_ptr < insn_end && fs->pc <= pc)
451 gdb_byte insn = *insn_ptr++;
455 if ((insn & 0xc0) == DW_CFA_advance_loc)
456 fs->pc += (insn & 0x3f) * fs->code_align;
457 else if ((insn & 0xc0) == DW_CFA_offset)
460 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
461 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
462 offset = utmp * fs->data_align;
463 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
464 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
465 fs->regs.reg[reg].loc.offset = offset;
467 else if ((insn & 0xc0) == DW_CFA_restore)
470 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
477 fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
478 fde->cie->ptr_size, insn_ptr,
479 &bytes_read, fde->initial_location);
480 /* Apply the objfile offset for relocatable objects. */
481 fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
482 SECT_OFF_TEXT (fde->cie->unit->objfile));
483 insn_ptr += bytes_read;
486 case DW_CFA_advance_loc1:
487 utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
488 fs->pc += utmp * fs->code_align;
491 case DW_CFA_advance_loc2:
492 utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
493 fs->pc += utmp * fs->code_align;
496 case DW_CFA_advance_loc4:
497 utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
498 fs->pc += utmp * fs->code_align;
502 case DW_CFA_offset_extended:
503 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
504 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
505 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
506 offset = utmp * fs->data_align;
507 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
508 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
509 fs->regs.reg[reg].loc.offset = offset;
512 case DW_CFA_restore_extended:
513 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
514 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
517 case DW_CFA_undefined:
518 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
519 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
520 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
521 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
524 case DW_CFA_same_value:
525 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
526 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
527 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
528 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
531 case DW_CFA_register:
532 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
533 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
534 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
535 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
536 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
537 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
538 fs->regs.reg[reg].loc.reg = utmp;
541 case DW_CFA_remember_state:
543 struct dwarf2_frame_state_reg_info *new_rs;
545 new_rs = XNEW (struct dwarf2_frame_state_reg_info);
547 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
548 fs->regs.prev = new_rs;
552 case DW_CFA_restore_state:
554 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
558 complaint (&symfile_complaints, _("\
559 bad CFI data; mismatched DW_CFA_restore_state at %s"),
560 paddress (gdbarch, fs->pc));
564 xfree (fs->regs.reg);
572 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
573 fs->regs.cfa_reg = reg;
574 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
576 if (fs->armcc_cfa_offsets_sf)
577 utmp *= fs->data_align;
579 fs->regs.cfa_offset = utmp;
580 fs->regs.cfa_how = CFA_REG_OFFSET;
583 case DW_CFA_def_cfa_register:
584 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
585 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
587 fs->regs.cfa_how = CFA_REG_OFFSET;
590 case DW_CFA_def_cfa_offset:
591 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
593 if (fs->armcc_cfa_offsets_sf)
594 utmp *= fs->data_align;
596 fs->regs.cfa_offset = utmp;
597 /* cfa_how deliberately not set. */
603 case DW_CFA_def_cfa_expression:
604 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
605 fs->regs.cfa_exp_len = utmp;
606 fs->regs.cfa_exp = insn_ptr;
607 fs->regs.cfa_how = CFA_EXP;
608 insn_ptr += fs->regs.cfa_exp_len;
611 case DW_CFA_expression:
612 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
613 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
614 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
615 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
616 fs->regs.reg[reg].loc.exp = insn_ptr;
617 fs->regs.reg[reg].exp_len = utmp;
618 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
622 case DW_CFA_offset_extended_sf:
623 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
624 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
625 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
626 offset *= fs->data_align;
627 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
628 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
629 fs->regs.reg[reg].loc.offset = offset;
632 case DW_CFA_val_offset:
633 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
634 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
635 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
636 offset = utmp * fs->data_align;
637 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
638 fs->regs.reg[reg].loc.offset = offset;
641 case DW_CFA_val_offset_sf:
642 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
643 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
644 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
645 offset *= fs->data_align;
646 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
647 fs->regs.reg[reg].loc.offset = offset;
650 case DW_CFA_val_expression:
651 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
652 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
653 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
654 fs->regs.reg[reg].loc.exp = insn_ptr;
655 fs->regs.reg[reg].exp_len = utmp;
656 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
660 case DW_CFA_def_cfa_sf:
661 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
662 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
664 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
665 fs->regs.cfa_offset = offset * fs->data_align;
666 fs->regs.cfa_how = CFA_REG_OFFSET;
669 case DW_CFA_def_cfa_offset_sf:
670 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
671 fs->regs.cfa_offset = offset * fs->data_align;
672 /* cfa_how deliberately not set. */
675 case DW_CFA_GNU_window_save:
676 /* This is SPARC-specific code, and contains hard-coded
677 constants for the register numbering scheme used by
678 GCC. Rather than having a architecture-specific
679 operation that's only ever used by a single
680 architecture, we provide the implementation here.
681 Incidentally that's what GCC does too in its
684 int size = register_size (gdbarch, 0);
686 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
687 for (reg = 8; reg < 16; reg++)
689 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
690 fs->regs.reg[reg].loc.reg = reg + 16;
692 for (reg = 16; reg < 32; reg++)
694 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
695 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
700 case DW_CFA_GNU_args_size:
702 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
705 case DW_CFA_GNU_negative_offset_extended:
706 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
707 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
708 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
709 offset = utmp * fs->data_align;
710 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
711 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
712 fs->regs.reg[reg].loc.offset = -offset;
716 internal_error (__FILE__, __LINE__,
717 _("Unknown CFI encountered."));
722 if (fs->initial.reg == NULL)
724 /* Don't allow remember/restore between CIE and FDE programs. */
725 dwarf2_frame_state_free_regs (fs->regs.prev);
726 fs->regs.prev = NULL;
733 /* Architecture-specific operations. */
735 /* Per-architecture data key. */
736 static struct gdbarch_data *dwarf2_frame_data;
738 struct dwarf2_frame_ops
740 /* Pre-initialize the register state REG for register REGNUM. */
741 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
742 struct frame_info *);
744 /* Check whether the THIS_FRAME is a signal trampoline. */
745 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
747 /* Convert .eh_frame register number to DWARF register number, or
748 adjust .debug_frame register number. */
749 int (*adjust_regnum) (struct gdbarch *, int, int);
752 /* Default architecture-specific register state initialization
756 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
757 struct dwarf2_frame_state_reg *reg,
758 struct frame_info *this_frame)
760 /* If we have a register that acts as a program counter, mark it as
761 a destination for the return address. If we have a register that
762 serves as the stack pointer, arrange for it to be filled with the
763 call frame address (CFA). The other registers are marked as
766 We copy the return address to the program counter, since many
767 parts in GDB assume that it is possible to get the return address
768 by unwinding the program counter register. However, on ISA's
769 with a dedicated return address register, the CFI usually only
770 contains information to unwind that return address register.
772 The reason we're treating the stack pointer special here is
773 because in many cases GCC doesn't emit CFI for the stack pointer
774 and implicitly assumes that it is equal to the CFA. This makes
775 some sense since the DWARF specification (version 3, draft 8,
778 "Typically, the CFA is defined to be the value of the stack
779 pointer at the call site in the previous frame (which may be
780 different from its value on entry to the current frame)."
782 However, this isn't true for all platforms supported by GCC
783 (e.g. IBM S/390 and zSeries). Those architectures should provide
784 their own architecture-specific initialization function. */
786 if (regnum == gdbarch_pc_regnum (gdbarch))
787 reg->how = DWARF2_FRAME_REG_RA;
788 else if (regnum == gdbarch_sp_regnum (gdbarch))
789 reg->how = DWARF2_FRAME_REG_CFA;
792 /* Return a default for the architecture-specific operations. */
795 dwarf2_frame_init (struct obstack *obstack)
797 struct dwarf2_frame_ops *ops;
799 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
800 ops->init_reg = dwarf2_frame_default_init_reg;
804 /* Set the architecture-specific register state initialization
805 function for GDBARCH to INIT_REG. */
808 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
809 void (*init_reg) (struct gdbarch *, int,
810 struct dwarf2_frame_state_reg *,
811 struct frame_info *))
813 struct dwarf2_frame_ops *ops
814 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
816 ops->init_reg = init_reg;
819 /* Pre-initialize the register state REG for register REGNUM. */
822 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
823 struct dwarf2_frame_state_reg *reg,
824 struct frame_info *this_frame)
826 struct dwarf2_frame_ops *ops
827 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
829 ops->init_reg (gdbarch, regnum, reg, this_frame);
832 /* Set the architecture-specific signal trampoline recognition
833 function for GDBARCH to SIGNAL_FRAME_P. */
836 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
837 int (*signal_frame_p) (struct gdbarch *,
838 struct frame_info *))
840 struct dwarf2_frame_ops *ops
841 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
843 ops->signal_frame_p = signal_frame_p;
846 /* Query the architecture-specific signal frame recognizer for
850 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
851 struct frame_info *this_frame)
853 struct dwarf2_frame_ops *ops
854 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
856 if (ops->signal_frame_p == NULL)
858 return ops->signal_frame_p (gdbarch, this_frame);
861 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
865 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
866 int (*adjust_regnum) (struct gdbarch *,
869 struct dwarf2_frame_ops *ops
870 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
872 ops->adjust_regnum = adjust_regnum;
875 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
879 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
880 int regnum, int eh_frame_p)
882 struct dwarf2_frame_ops *ops
883 = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
885 if (ops->adjust_regnum == NULL)
887 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
891 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
892 struct dwarf2_fde *fde)
894 struct compunit_symtab *cust;
896 cust = find_pc_compunit_symtab (fs->pc);
900 if (producer_is_realview (COMPUNIT_PRODUCER (cust)))
902 if (fde->cie->version == 1)
903 fs->armcc_cfa_offsets_sf = 1;
905 if (fde->cie->version == 1)
906 fs->armcc_cfa_offsets_reversed = 1;
908 /* The reversed offset problem is present in some compilers
909 using DWARF3, but it was eventually fixed. Check the ARM
910 defined augmentations, which are in the format "armcc" followed
911 by a list of one-character options. The "+" option means
912 this problem is fixed (no quirk needed). If the armcc
913 augmentation is missing, the quirk is needed. */
914 if (fde->cie->version == 3
915 && (!startswith (fde->cie->augmentation, "armcc")
916 || strchr (fde->cie->augmentation + 5, '+') == NULL))
917 fs->armcc_cfa_offsets_reversed = 1;
924 /* See dwarf2-frame.h. */
927 dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc,
928 struct dwarf2_per_cu_data *data,
929 int *regnum_out, LONGEST *offset_out,
930 CORE_ADDR *text_offset_out,
931 const gdb_byte **cfa_start_out,
932 const gdb_byte **cfa_end_out)
934 struct dwarf2_fde *fde;
935 CORE_ADDR text_offset;
936 struct dwarf2_frame_state fs;
938 memset (&fs, 0, sizeof (struct dwarf2_frame_state));
942 /* Find the correct FDE. */
943 fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
945 error (_("Could not compute CFA; needed to translate this expression"));
947 /* Extract any interesting information from the CIE. */
948 fs.data_align = fde->cie->data_alignment_factor;
949 fs.code_align = fde->cie->code_alignment_factor;
950 fs.retaddr_column = fde->cie->return_address_register;
952 /* Check for "quirks" - known bugs in producers. */
953 dwarf2_frame_find_quirks (&fs, fde);
955 /* First decode all the insns in the CIE. */
956 execute_cfa_program (fde, fde->cie->initial_instructions,
957 fde->cie->end, gdbarch, pc, &fs);
959 /* Save the initialized register set. */
960 fs.initial = fs.regs;
961 fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
963 /* Then decode the insns in the FDE up to our target PC. */
964 execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
966 /* Calculate the CFA. */
967 switch (fs.regs.cfa_how)
971 int regnum = dwarf_reg_to_regnum_or_error (gdbarch, fs.regs.cfa_reg);
973 *regnum_out = regnum;
974 if (fs.armcc_cfa_offsets_reversed)
975 *offset_out = -fs.regs.cfa_offset;
977 *offset_out = fs.regs.cfa_offset;
982 *text_offset_out = text_offset;
983 *cfa_start_out = fs.regs.cfa_exp;
984 *cfa_end_out = fs.regs.cfa_exp + fs.regs.cfa_exp_len;
988 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
993 struct dwarf2_frame_cache
995 /* DWARF Call Frame Address. */
998 /* Set if the return address column was marked as unavailable
999 (required non-collected memory or registers to compute). */
1000 int unavailable_retaddr;
1002 /* Set if the return address column was marked as undefined. */
1003 int undefined_retaddr;
1005 /* Saved registers, indexed by GDB register number, not by DWARF
1007 struct dwarf2_frame_state_reg *reg;
1009 /* Return address register. */
1010 struct dwarf2_frame_state_reg retaddr_reg;
1012 /* Target address size in bytes. */
1015 /* The .text offset. */
1016 CORE_ADDR text_offset;
1018 /* True if we already checked whether this frame is the bottom frame
1019 of a virtual tail call frame chain. */
1020 int checked_tailcall_bottom;
1022 /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
1023 sequence. If NULL then it is a normal case with no TAILCALL_FRAME
1024 involved. Non-bottom frames of a virtual tail call frames chain use
1025 dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
1027 void *tailcall_cache;
1029 /* The number of bytes to subtract from TAILCALL_FRAME frames frame
1030 base to get the SP, to simulate the return address pushed on the
1032 LONGEST entry_cfa_sp_offset;
1033 int entry_cfa_sp_offset_p;
1036 /* A cleanup that sets a pointer to NULL. */
1039 clear_pointer_cleanup (void *arg)
1041 void **ptr = (void **) arg;
1046 static struct dwarf2_frame_cache *
1047 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
1049 struct cleanup *reset_cache_cleanup, *old_chain;
1050 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1051 const int num_regs = gdbarch_num_regs (gdbarch)
1052 + gdbarch_num_pseudo_regs (gdbarch);
1053 struct dwarf2_frame_cache *cache;
1054 struct dwarf2_frame_state *fs;
1055 struct dwarf2_fde *fde;
1057 const gdb_byte *instr;
1060 return (struct dwarf2_frame_cache *) *this_cache;
1062 /* Allocate a new cache. */
1063 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1064 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
1065 *this_cache = cache;
1066 reset_cache_cleanup = make_cleanup (clear_pointer_cleanup, this_cache);
1068 /* Allocate and initialize the frame state. */
1069 fs = XCNEW (struct dwarf2_frame_state);
1070 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1074 Note that if the next frame is never supposed to return (i.e. a call
1075 to abort), the compiler might optimize away the instruction at
1076 its return address. As a result the return address will
1077 point at some random instruction, and the CFI for that
1078 instruction is probably worthless to us. GCC's unwinder solves
1079 this problem by substracting 1 from the return address to get an
1080 address in the middle of a presumed call instruction (or the
1081 instruction in the associated delay slot). This should only be
1082 done for "normal" frames and not for resume-type frames (signal
1083 handlers, sentinel frames, dummy frames). The function
1084 get_frame_address_in_block does just this. It's not clear how
1085 reliable the method is though; there is the potential for the
1086 register state pre-call being different to that on return. */
1087 fs->pc = get_frame_address_in_block (this_frame);
1089 /* Find the correct FDE. */
1090 fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
1091 gdb_assert (fde != NULL);
1093 /* Extract any interesting information from the CIE. */
1094 fs->data_align = fde->cie->data_alignment_factor;
1095 fs->code_align = fde->cie->code_alignment_factor;
1096 fs->retaddr_column = fde->cie->return_address_register;
1097 cache->addr_size = fde->cie->addr_size;
1099 /* Check for "quirks" - known bugs in producers. */
1100 dwarf2_frame_find_quirks (fs, fde);
1102 /* First decode all the insns in the CIE. */
1103 execute_cfa_program (fde, fde->cie->initial_instructions,
1104 fde->cie->end, gdbarch,
1105 get_frame_address_in_block (this_frame), fs);
1107 /* Save the initialized register set. */
1108 fs->initial = fs->regs;
1109 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
1111 if (get_frame_func_if_available (this_frame, &entry_pc))
1113 /* Decode the insns in the FDE up to the entry PC. */
1114 instr = execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1117 if (fs->regs.cfa_how == CFA_REG_OFFSET
1118 && (dwarf_reg_to_regnum (gdbarch, fs->regs.cfa_reg)
1119 == gdbarch_sp_regnum (gdbarch)))
1121 cache->entry_cfa_sp_offset = fs->regs.cfa_offset;
1122 cache->entry_cfa_sp_offset_p = 1;
1126 instr = fde->instructions;
1128 /* Then decode the insns in the FDE up to our target PC. */
1129 execute_cfa_program (fde, instr, fde->end, gdbarch,
1130 get_frame_address_in_block (this_frame), fs);
1134 /* Calculate the CFA. */
1135 switch (fs->regs.cfa_how)
1137 case CFA_REG_OFFSET:
1138 cache->cfa = read_addr_from_reg (this_frame, fs->regs.cfa_reg);
1139 if (fs->armcc_cfa_offsets_reversed)
1140 cache->cfa -= fs->regs.cfa_offset;
1142 cache->cfa += fs->regs.cfa_offset;
1147 execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1148 cache->addr_size, cache->text_offset,
1153 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1156 CATCH (ex, RETURN_MASK_ERROR)
1158 if (ex.error == NOT_AVAILABLE_ERROR)
1160 cache->unavailable_retaddr = 1;
1161 do_cleanups (old_chain);
1162 discard_cleanups (reset_cache_cleanup);
1166 throw_exception (ex);
1170 /* Initialize the register state. */
1174 for (regnum = 0; regnum < num_regs; regnum++)
1175 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1178 /* Go through the DWARF2 CFI generated table and save its register
1179 location information in the cache. Note that we don't skip the
1180 return address column; it's perfectly all right for it to
1181 correspond to a real register. */
1183 int column; /* CFI speak for "register number". */
1185 for (column = 0; column < fs->regs.num_regs; column++)
1187 /* Use the GDB register number as the destination index. */
1188 int regnum = dwarf_reg_to_regnum (gdbarch, column);
1190 /* Protect against a target returning a bad register. */
1191 if (regnum < 0 || regnum >= num_regs)
1194 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1195 of all debug info registers. If it doesn't, complain (but
1196 not too loudly). It turns out that GCC assumes that an
1197 unspecified register implies "same value" when CFI (draft
1198 7) specifies nothing at all. Such a register could equally
1199 be interpreted as "undefined". Also note that this check
1200 isn't sufficient; it only checks that all registers in the
1201 range [0 .. max column] are specified, and won't detect
1202 problems when a debug info register falls outside of the
1203 table. We need a way of iterating through all the valid
1204 DWARF2 register numbers. */
1205 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1207 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1208 complaint (&symfile_complaints, _("\
1209 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1210 gdbarch_register_name (gdbarch, regnum),
1211 paddress (gdbarch, fs->pc));
1214 cache->reg[regnum] = fs->regs.reg[column];
1218 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1219 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1223 for (regnum = 0; regnum < num_regs; regnum++)
1225 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1226 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1228 struct dwarf2_frame_state_reg *retaddr_reg =
1229 &fs->regs.reg[fs->retaddr_column];
1231 /* It seems rather bizarre to specify an "empty" column as
1232 the return adress column. However, this is exactly
1233 what GCC does on some targets. It turns out that GCC
1234 assumes that the return address can be found in the
1235 register corresponding to the return address column.
1236 Incidentally, that's how we should treat a return
1237 address column specifying "same value" too. */
1238 if (fs->retaddr_column < fs->regs.num_regs
1239 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1240 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1242 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1243 cache->reg[regnum] = *retaddr_reg;
1245 cache->retaddr_reg = *retaddr_reg;
1249 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1251 cache->reg[regnum].loc.reg = fs->retaddr_column;
1252 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1256 cache->retaddr_reg.loc.reg = fs->retaddr_column;
1257 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1264 if (fs->retaddr_column < fs->regs.num_regs
1265 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1266 cache->undefined_retaddr = 1;
1268 do_cleanups (old_chain);
1269 discard_cleanups (reset_cache_cleanup);
1273 static enum unwind_stop_reason
1274 dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1277 struct dwarf2_frame_cache *cache
1278 = dwarf2_frame_cache (this_frame, this_cache);
1280 if (cache->unavailable_retaddr)
1281 return UNWIND_UNAVAILABLE;
1283 if (cache->undefined_retaddr)
1284 return UNWIND_OUTERMOST;
1286 return UNWIND_NO_REASON;
1290 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1291 struct frame_id *this_id)
1293 struct dwarf2_frame_cache *cache =
1294 dwarf2_frame_cache (this_frame, this_cache);
1296 if (cache->unavailable_retaddr)
1297 (*this_id) = frame_id_build_unavailable_stack (get_frame_func (this_frame));
1298 else if (cache->undefined_retaddr)
1301 (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1304 static struct value *
1305 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1308 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1309 struct dwarf2_frame_cache *cache =
1310 dwarf2_frame_cache (this_frame, this_cache);
1314 /* Check whether THIS_FRAME is the bottom frame of a virtual tail
1315 call frame chain. */
1316 if (!cache->checked_tailcall_bottom)
1318 cache->checked_tailcall_bottom = 1;
1319 dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache,
1320 (cache->entry_cfa_sp_offset_p
1321 ? &cache->entry_cfa_sp_offset : NULL));
1324 /* Non-bottom frames of a virtual tail call frames chain use
1325 dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1326 them. If dwarf2_tailcall_prev_register_first does not have specific value
1327 unwind the register, tail call frames are assumed to have the register set
1328 of the top caller. */
1329 if (cache->tailcall_cache)
1333 val = dwarf2_tailcall_prev_register_first (this_frame,
1334 &cache->tailcall_cache,
1340 switch (cache->reg[regnum].how)
1342 case DWARF2_FRAME_REG_UNDEFINED:
1343 /* If CFI explicitly specified that the value isn't defined,
1344 mark it as optimized away; the value isn't available. */
1345 return frame_unwind_got_optimized (this_frame, regnum);
1347 case DWARF2_FRAME_REG_SAVED_OFFSET:
1348 addr = cache->cfa + cache->reg[regnum].loc.offset;
1349 return frame_unwind_got_memory (this_frame, regnum, addr);
1351 case DWARF2_FRAME_REG_SAVED_REG:
1352 realnum = dwarf_reg_to_regnum_or_error
1353 (gdbarch, cache->reg[regnum].loc.reg);
1354 return frame_unwind_got_register (this_frame, regnum, realnum);
1356 case DWARF2_FRAME_REG_SAVED_EXP:
1357 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1358 cache->reg[regnum].exp_len,
1359 cache->addr_size, cache->text_offset,
1360 this_frame, cache->cfa, 1);
1361 return frame_unwind_got_memory (this_frame, regnum, addr);
1363 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1364 addr = cache->cfa + cache->reg[regnum].loc.offset;
1365 return frame_unwind_got_constant (this_frame, regnum, addr);
1367 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1368 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1369 cache->reg[regnum].exp_len,
1370 cache->addr_size, cache->text_offset,
1371 this_frame, cache->cfa, 1);
1372 return frame_unwind_got_constant (this_frame, regnum, addr);
1374 case DWARF2_FRAME_REG_UNSPECIFIED:
1375 /* GCC, in its infinite wisdom decided to not provide unwind
1376 information for registers that are "same value". Since
1377 DWARF2 (3 draft 7) doesn't define such behavior, said
1378 registers are actually undefined (which is different to CFI
1379 "undefined"). Code above issues a complaint about this.
1380 Here just fudge the books, assume GCC, and that the value is
1381 more inner on the stack. */
1382 return frame_unwind_got_register (this_frame, regnum, regnum);
1384 case DWARF2_FRAME_REG_SAME_VALUE:
1385 return frame_unwind_got_register (this_frame, regnum, regnum);
1387 case DWARF2_FRAME_REG_CFA:
1388 return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1390 case DWARF2_FRAME_REG_CFA_OFFSET:
1391 addr = cache->cfa + cache->reg[regnum].loc.offset;
1392 return frame_unwind_got_address (this_frame, regnum, addr);
1394 case DWARF2_FRAME_REG_RA_OFFSET:
1395 addr = cache->reg[regnum].loc.offset;
1396 regnum = dwarf_reg_to_regnum_or_error
1397 (gdbarch, cache->retaddr_reg.loc.reg);
1398 addr += get_frame_register_unsigned (this_frame, regnum);
1399 return frame_unwind_got_address (this_frame, regnum, addr);
1401 case DWARF2_FRAME_REG_FN:
1402 return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1405 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1409 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1410 call frames chain. */
1413 dwarf2_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1415 struct dwarf2_frame_cache *cache = dwarf2_frame_cache (self, &this_cache);
1417 if (cache->tailcall_cache)
1418 dwarf2_tailcall_frame_unwind.dealloc_cache (self, cache->tailcall_cache);
1422 dwarf2_frame_sniffer (const struct frame_unwind *self,
1423 struct frame_info *this_frame, void **this_cache)
1425 /* Grab an address that is guarenteed to reside somewhere within the
1426 function. get_frame_pc(), with a no-return next function, can
1427 end up returning something past the end of this function's body.
1428 If the frame we're sniffing for is a signal frame whose start
1429 address is placed on the stack by the OS, its FDE must
1430 extend one byte before its start address or we could potentially
1431 select the FDE of the previous function. */
1432 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1433 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1438 /* On some targets, signal trampolines may have unwind information.
1439 We need to recognize them so that we set the frame type
1442 if (fde->cie->signal_frame
1443 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1445 return self->type == SIGTRAMP_FRAME;
1447 if (self->type != NORMAL_FRAME)
1453 static const struct frame_unwind dwarf2_frame_unwind =
1456 dwarf2_frame_unwind_stop_reason,
1457 dwarf2_frame_this_id,
1458 dwarf2_frame_prev_register,
1460 dwarf2_frame_sniffer,
1461 dwarf2_frame_dealloc_cache
1464 static const struct frame_unwind dwarf2_signal_frame_unwind =
1467 dwarf2_frame_unwind_stop_reason,
1468 dwarf2_frame_this_id,
1469 dwarf2_frame_prev_register,
1471 dwarf2_frame_sniffer,
1473 /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1477 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1480 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1482 /* TAILCALL_FRAME must be first to find the record by
1483 dwarf2_tailcall_sniffer_first. */
1484 frame_unwind_append_unwinder (gdbarch, &dwarf2_tailcall_frame_unwind);
1486 frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1487 frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1491 /* There is no explicitly defined relationship between the CFA and the
1492 location of frame's local variables and arguments/parameters.
1493 Therefore, frame base methods on this page should probably only be
1494 used as a last resort, just to avoid printing total garbage as a
1495 response to the "info frame" command. */
1498 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1500 struct dwarf2_frame_cache *cache =
1501 dwarf2_frame_cache (this_frame, this_cache);
1506 static const struct frame_base dwarf2_frame_base =
1508 &dwarf2_frame_unwind,
1509 dwarf2_frame_base_address,
1510 dwarf2_frame_base_address,
1511 dwarf2_frame_base_address
1514 const struct frame_base *
1515 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1517 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1519 if (dwarf2_frame_find_fde (&block_addr, NULL))
1520 return &dwarf2_frame_base;
1525 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1526 the DWARF unwinder. This is used to implement
1527 DW_OP_call_frame_cfa. */
1530 dwarf2_frame_cfa (struct frame_info *this_frame)
1532 if (frame_unwinder_is (this_frame, &record_btrace_tailcall_frame_unwind)
1533 || frame_unwinder_is (this_frame, &record_btrace_frame_unwind))
1534 throw_error (NOT_AVAILABLE_ERROR,
1535 _("cfa not available for record btrace target"));
1537 while (get_frame_type (this_frame) == INLINE_FRAME)
1538 this_frame = get_prev_frame (this_frame);
1539 if (get_frame_unwind_stop_reason (this_frame) == UNWIND_UNAVAILABLE)
1540 throw_error (NOT_AVAILABLE_ERROR,
1541 _("can't compute CFA for this frame: "
1542 "required registers or memory are unavailable"));
1544 if (get_frame_id (this_frame).stack_status != FID_STACK_VALID)
1545 throw_error (NOT_AVAILABLE_ERROR,
1546 _("can't compute CFA for this frame: "
1547 "frame base not available"));
1549 return get_frame_base (this_frame);
1552 const struct objfile_data *dwarf2_frame_objfile_data;
1555 read_1_byte (bfd *abfd, const gdb_byte *buf)
1557 return bfd_get_8 (abfd, buf);
1561 read_4_bytes (bfd *abfd, const gdb_byte *buf)
1563 return bfd_get_32 (abfd, buf);
1567 read_8_bytes (bfd *abfd, const gdb_byte *buf)
1569 return bfd_get_64 (abfd, buf);
1573 read_initial_length (bfd *abfd, const gdb_byte *buf,
1574 unsigned int *bytes_read_ptr)
1578 result = bfd_get_32 (abfd, buf);
1579 if (result == 0xffffffff)
1581 result = bfd_get_64 (abfd, buf + 4);
1582 *bytes_read_ptr = 12;
1585 *bytes_read_ptr = 4;
1591 /* Pointer encoding helper functions. */
1593 /* GCC supports exception handling based on DWARF2 CFI. However, for
1594 technical reasons, it encodes addresses in its FDE's in a different
1595 way. Several "pointer encodings" are supported. The encoding
1596 that's used for a particular FDE is determined by the 'R'
1597 augmentation in the associated CIE. The argument of this
1598 augmentation is a single byte.
1600 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1601 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1602 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1603 address should be interpreted (absolute, relative to the current
1604 position in the FDE, ...). Bit 7, indicates that the address
1605 should be dereferenced. */
1608 encoding_for_size (unsigned int size)
1613 return DW_EH_PE_udata2;
1615 return DW_EH_PE_udata4;
1617 return DW_EH_PE_udata8;
1619 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1624 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1625 int ptr_len, const gdb_byte *buf,
1626 unsigned int *bytes_read_ptr,
1627 CORE_ADDR func_base)
1632 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1634 if (encoding & DW_EH_PE_indirect)
1635 internal_error (__FILE__, __LINE__,
1636 _("Unsupported encoding: DW_EH_PE_indirect"));
1638 *bytes_read_ptr = 0;
1640 switch (encoding & 0x70)
1642 case DW_EH_PE_absptr:
1645 case DW_EH_PE_pcrel:
1646 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1647 base += (buf - unit->dwarf_frame_buffer);
1649 case DW_EH_PE_datarel:
1652 case DW_EH_PE_textrel:
1655 case DW_EH_PE_funcrel:
1658 case DW_EH_PE_aligned:
1660 offset = buf - unit->dwarf_frame_buffer;
1661 if ((offset % ptr_len) != 0)
1663 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1664 buf += *bytes_read_ptr;
1668 internal_error (__FILE__, __LINE__,
1669 _("Invalid or unsupported encoding"));
1672 if ((encoding & 0x07) == 0x00)
1674 encoding |= encoding_for_size (ptr_len);
1675 if (bfd_get_sign_extend_vma (unit->abfd))
1676 encoding |= DW_EH_PE_signed;
1679 switch (encoding & 0x0f)
1681 case DW_EH_PE_uleb128:
1684 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1686 *bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf;
1687 return base + value;
1689 case DW_EH_PE_udata2:
1690 *bytes_read_ptr += 2;
1691 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1692 case DW_EH_PE_udata4:
1693 *bytes_read_ptr += 4;
1694 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1695 case DW_EH_PE_udata8:
1696 *bytes_read_ptr += 8;
1697 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1698 case DW_EH_PE_sleb128:
1701 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1703 *bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf;
1704 return base + value;
1706 case DW_EH_PE_sdata2:
1707 *bytes_read_ptr += 2;
1708 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1709 case DW_EH_PE_sdata4:
1710 *bytes_read_ptr += 4;
1711 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1712 case DW_EH_PE_sdata8:
1713 *bytes_read_ptr += 8;
1714 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1716 internal_error (__FILE__, __LINE__,
1717 _("Invalid or unsupported encoding"));
1723 bsearch_cie_cmp (const void *key, const void *element)
1725 ULONGEST cie_pointer = *(ULONGEST *) key;
1726 struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1728 if (cie_pointer == cie->cie_pointer)
1731 return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1734 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1735 static struct dwarf2_cie *
1736 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1738 struct dwarf2_cie **p_cie;
1740 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1741 bsearch be non-NULL. */
1742 if (cie_table->entries == NULL)
1744 gdb_assert (cie_table->num_entries == 0);
1748 p_cie = ((struct dwarf2_cie **)
1749 bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1750 sizeof (cie_table->entries[0]), bsearch_cie_cmp));
1756 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1758 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1760 const int n = cie_table->num_entries;
1763 || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1766 = XRESIZEVEC (struct dwarf2_cie *, cie_table->entries, n + 1);
1767 cie_table->entries[n] = cie;
1768 cie_table->num_entries = n + 1;
1772 bsearch_fde_cmp (const void *key, const void *element)
1774 CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1775 struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1777 if (seek_pc < fde->initial_location)
1779 if (seek_pc < fde->initial_location + fde->address_range)
1784 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1785 inital location associated with it into *PC. */
1787 static struct dwarf2_fde *
1788 dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
1790 struct objfile *objfile;
1792 ALL_OBJFILES (objfile)
1794 struct dwarf2_fde_table *fde_table;
1795 struct dwarf2_fde **p_fde;
1799 fde_table = ((struct dwarf2_fde_table *)
1800 objfile_data (objfile, dwarf2_frame_objfile_data));
1801 if (fde_table == NULL)
1803 dwarf2_build_frame_info (objfile);
1804 fde_table = ((struct dwarf2_fde_table *)
1805 objfile_data (objfile, dwarf2_frame_objfile_data));
1807 gdb_assert (fde_table != NULL);
1809 if (fde_table->num_entries == 0)
1812 gdb_assert (objfile->section_offsets);
1813 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1815 gdb_assert (fde_table->num_entries > 0);
1816 if (*pc < offset + fde_table->entries[0]->initial_location)
1819 seek_pc = *pc - offset;
1820 p_fde = ((struct dwarf2_fde **)
1821 bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1822 sizeof (fde_table->entries[0]), bsearch_fde_cmp));
1825 *pc = (*p_fde)->initial_location + offset;
1827 *out_offset = offset;
1834 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1836 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1838 if (fde->address_range == 0)
1839 /* Discard useless FDEs. */
1842 fde_table->num_entries += 1;
1843 fde_table->entries = XRESIZEVEC (struct dwarf2_fde *, fde_table->entries,
1844 fde_table->num_entries);
1845 fde_table->entries[fde_table->num_entries - 1] = fde;
1848 #define DW64_CIE_ID 0xffffffffffffffffULL
1850 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1855 EH_CIE_TYPE_ID = 1 << 0,
1856 EH_FDE_TYPE_ID = 1 << 1,
1857 EH_CIE_OR_FDE_TYPE_ID = EH_CIE_TYPE_ID | EH_FDE_TYPE_ID
1860 static const gdb_byte *decode_frame_entry (struct comp_unit *unit,
1861 const gdb_byte *start,
1863 struct dwarf2_cie_table *cie_table,
1864 struct dwarf2_fde_table *fde_table,
1865 enum eh_frame_type entry_type);
1867 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1868 Return NULL if invalid input, otherwise the next byte to be processed. */
1870 static const gdb_byte *
1871 decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
1873 struct dwarf2_cie_table *cie_table,
1874 struct dwarf2_fde_table *fde_table,
1875 enum eh_frame_type entry_type)
1877 struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1878 const gdb_byte *buf, *end;
1880 unsigned int bytes_read;
1883 ULONGEST cie_pointer;
1888 length = read_initial_length (unit->abfd, buf, &bytes_read);
1892 /* Are we still within the section? */
1893 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1899 /* Distinguish between 32 and 64-bit encoded frame info. */
1900 dwarf64_p = (bytes_read == 12);
1902 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1906 cie_id = DW64_CIE_ID;
1912 cie_pointer = read_8_bytes (unit->abfd, buf);
1917 cie_pointer = read_4_bytes (unit->abfd, buf);
1921 if (cie_pointer == cie_id)
1923 /* This is a CIE. */
1924 struct dwarf2_cie *cie;
1926 unsigned int cie_version;
1928 /* Check that a CIE was expected. */
1929 if ((entry_type & EH_CIE_TYPE_ID) == 0)
1930 error (_("Found a CIE when not expecting it."));
1932 /* Record the offset into the .debug_frame section of this CIE. */
1933 cie_pointer = start - unit->dwarf_frame_buffer;
1935 /* Check whether we've already read it. */
1936 if (find_cie (cie_table, cie_pointer))
1939 cie = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_cie);
1940 cie->initial_instructions = NULL;
1941 cie->cie_pointer = cie_pointer;
1943 /* The encoding for FDE's in a normal .debug_frame section
1944 depends on the target address size. */
1945 cie->encoding = DW_EH_PE_absptr;
1947 /* We'll determine the final value later, but we need to
1948 initialize it conservatively. */
1949 cie->signal_frame = 0;
1951 /* Check version number. */
1952 cie_version = read_1_byte (unit->abfd, buf);
1953 if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1955 cie->version = cie_version;
1958 /* Interpret the interesting bits of the augmentation. */
1959 cie->augmentation = augmentation = (char *) buf;
1960 buf += (strlen (augmentation) + 1);
1962 /* Ignore armcc augmentations. We only use them for quirks,
1963 and that doesn't happen until later. */
1964 if (startswith (augmentation, "armcc"))
1965 augmentation += strlen (augmentation);
1967 /* The GCC 2.x "eh" augmentation has a pointer immediately
1968 following the augmentation string, so it must be handled
1970 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1973 buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1977 if (cie->version >= 4)
1979 /* FIXME: check that this is the same as from the CU header. */
1980 cie->addr_size = read_1_byte (unit->abfd, buf);
1982 cie->segment_size = read_1_byte (unit->abfd, buf);
1987 cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1988 cie->segment_size = 0;
1990 /* Address values in .eh_frame sections are defined to have the
1991 target's pointer size. Watchout: This breaks frame info for
1992 targets with pointer size < address size, unless a .debug_frame
1993 section exists as well. */
1995 cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1997 cie->ptr_size = cie->addr_size;
1999 buf = gdb_read_uleb128 (buf, end, &uleb128);
2002 cie->code_alignment_factor = uleb128;
2004 buf = gdb_read_sleb128 (buf, end, &sleb128);
2007 cie->data_alignment_factor = sleb128;
2009 if (cie_version == 1)
2011 cie->return_address_register = read_1_byte (unit->abfd, buf);
2016 buf = gdb_read_uleb128 (buf, end, &uleb128);
2019 cie->return_address_register = uleb128;
2022 cie->return_address_register
2023 = dwarf2_frame_adjust_regnum (gdbarch,
2024 cie->return_address_register,
2027 cie->saw_z_augmentation = (*augmentation == 'z');
2028 if (cie->saw_z_augmentation)
2032 buf = gdb_read_uleb128 (buf, end, &length);
2035 cie->initial_instructions = buf + length;
2039 while (*augmentation)
2041 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
2042 if (*augmentation == 'L')
2049 /* "R" indicates a byte indicating how FDE addresses are encoded. */
2050 else if (*augmentation == 'R')
2052 cie->encoding = *buf++;
2056 /* "P" indicates a personality routine in the CIE augmentation. */
2057 else if (*augmentation == 'P')
2059 /* Skip. Avoid indirection since we throw away the result. */
2060 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
2061 read_encoded_value (unit, encoding, cie->ptr_size,
2062 buf, &bytes_read, 0);
2067 /* "S" indicates a signal frame, such that the return
2068 address must not be decremented to locate the call frame
2069 info for the previous frame; it might even be the first
2070 instruction of a function, so decrementing it would take
2071 us to a different function. */
2072 else if (*augmentation == 'S')
2074 cie->signal_frame = 1;
2078 /* Otherwise we have an unknown augmentation. Assume that either
2079 there is no augmentation data, or we saw a 'z' prefix. */
2082 if (cie->initial_instructions)
2083 buf = cie->initial_instructions;
2088 cie->initial_instructions = buf;
2092 add_cie (cie_table, cie);
2096 /* This is a FDE. */
2097 struct dwarf2_fde *fde;
2100 /* Check that an FDE was expected. */
2101 if ((entry_type & EH_FDE_TYPE_ID) == 0)
2102 error (_("Found an FDE when not expecting it."));
2104 /* In an .eh_frame section, the CIE pointer is the delta between the
2105 address within the FDE where the CIE pointer is stored and the
2106 address of the CIE. Convert it to an offset into the .eh_frame
2110 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2111 cie_pointer -= (dwarf64_p ? 8 : 4);
2114 /* In either case, validate the result is still within the section. */
2115 if (cie_pointer >= unit->dwarf_frame_size)
2118 fde = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_fde);
2119 fde->cie = find_cie (cie_table, cie_pointer);
2120 if (fde->cie == NULL)
2122 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
2123 eh_frame_p, cie_table, fde_table,
2125 fde->cie = find_cie (cie_table, cie_pointer);
2128 gdb_assert (fde->cie != NULL);
2130 addr = read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
2131 buf, &bytes_read, 0);
2132 fde->initial_location = gdbarch_adjust_dwarf2_addr (gdbarch, addr);
2135 fde->address_range =
2136 read_encoded_value (unit, fde->cie->encoding & 0x0f,
2137 fde->cie->ptr_size, buf, &bytes_read, 0);
2138 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + fde->address_range);
2139 fde->address_range = addr - fde->initial_location;
2142 /* A 'z' augmentation in the CIE implies the presence of an
2143 augmentation field in the FDE as well. The only thing known
2144 to be in here at present is the LSDA entry for EH. So we
2145 can skip the whole thing. */
2146 if (fde->cie->saw_z_augmentation)
2150 buf = gdb_read_uleb128 (buf, end, &length);
2158 fde->instructions = buf;
2161 fde->eh_frame_p = eh_frame_p;
2163 add_fde (fde_table, fde);
2169 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2170 expect an FDE or a CIE. */
2172 static const gdb_byte *
2173 decode_frame_entry (struct comp_unit *unit, const gdb_byte *start,
2175 struct dwarf2_cie_table *cie_table,
2176 struct dwarf2_fde_table *fde_table,
2177 enum eh_frame_type entry_type)
2179 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2180 const gdb_byte *ret;
2181 ptrdiff_t start_offset;
2185 ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2186 cie_table, fde_table, entry_type);
2190 /* We have corrupt input data of some form. */
2192 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2193 and mismatches wrt padding and alignment of debug sections. */
2194 /* Note that there is no requirement in the standard for any
2195 alignment at all in the frame unwind sections. Testing for
2196 alignment before trying to interpret data would be incorrect.
2198 However, GCC traditionally arranged for frame sections to be
2199 sized such that the FDE length and CIE fields happen to be
2200 aligned (in theory, for performance). This, unfortunately,
2201 was done with .align directives, which had the side effect of
2202 forcing the section to be aligned by the linker.
2204 This becomes a problem when you have some other producer that
2205 creates frame sections that are not as strictly aligned. That
2206 produces a hole in the frame info that gets filled by the
2209 The GCC behaviour is arguably a bug, but it's effectively now
2210 part of the ABI, so we're now stuck with it, at least at the
2211 object file level. A smart linker may decide, in the process
2212 of compressing duplicate CIE information, that it can rewrite
2213 the entire output section without this extra padding. */
2215 start_offset = start - unit->dwarf_frame_buffer;
2216 if (workaround < ALIGN4 && (start_offset & 3) != 0)
2218 start += 4 - (start_offset & 3);
2219 workaround = ALIGN4;
2222 if (workaround < ALIGN8 && (start_offset & 7) != 0)
2224 start += 8 - (start_offset & 7);
2225 workaround = ALIGN8;
2229 /* Nothing left to try. Arrange to return as if we've consumed
2230 the entire input section. Hopefully we'll get valid info from
2231 the other of .debug_frame/.eh_frame. */
2233 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2243 complaint (&symfile_complaints, _("\
2244 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2245 unit->dwarf_frame_section->owner->filename,
2246 unit->dwarf_frame_section->name);
2250 complaint (&symfile_complaints, _("\
2251 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2252 unit->dwarf_frame_section->owner->filename,
2253 unit->dwarf_frame_section->name);
2257 complaint (&symfile_complaints,
2258 _("Corrupt data in %s:%s"),
2259 unit->dwarf_frame_section->owner->filename,
2260 unit->dwarf_frame_section->name);
2268 qsort_fde_cmp (const void *a, const void *b)
2270 struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2271 struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2273 if (aa->initial_location == bb->initial_location)
2275 if (aa->address_range != bb->address_range
2276 && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2277 /* Linker bug, e.g. gold/10400.
2278 Work around it by keeping stable sort order. */
2279 return (a < b) ? -1 : 1;
2281 /* Put eh_frame entries after debug_frame ones. */
2282 return aa->eh_frame_p - bb->eh_frame_p;
2285 return (aa->initial_location < bb->initial_location) ? -1 : 1;
2289 dwarf2_build_frame_info (struct objfile *objfile)
2291 struct comp_unit *unit;
2292 const gdb_byte *frame_ptr;
2293 struct dwarf2_cie_table cie_table;
2294 struct dwarf2_fde_table fde_table;
2295 struct dwarf2_fde_table *fde_table2;
2297 cie_table.num_entries = 0;
2298 cie_table.entries = NULL;
2300 fde_table.num_entries = 0;
2301 fde_table.entries = NULL;
2303 /* Build a minimal decoding of the DWARF2 compilation unit. */
2304 unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2305 sizeof (struct comp_unit));
2306 unit->abfd = objfile->obfd;
2307 unit->objfile = objfile;
2311 if (objfile->separate_debug_objfile_backlink == NULL)
2313 /* Do not read .eh_frame from separate file as they must be also
2314 present in the main file. */
2315 dwarf2_get_section_info (objfile, DWARF2_EH_FRAME,
2316 &unit->dwarf_frame_section,
2317 &unit->dwarf_frame_buffer,
2318 &unit->dwarf_frame_size);
2319 if (unit->dwarf_frame_size)
2321 asection *got, *txt;
2323 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2324 that is used for the i386/amd64 target, which currently is
2325 the only target in GCC that supports/uses the
2326 DW_EH_PE_datarel encoding. */
2327 got = bfd_get_section_by_name (unit->abfd, ".got");
2329 unit->dbase = got->vma;
2331 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2333 txt = bfd_get_section_by_name (unit->abfd, ".text");
2335 unit->tbase = txt->vma;
2339 frame_ptr = unit->dwarf_frame_buffer;
2340 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2341 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2342 &cie_table, &fde_table,
2343 EH_CIE_OR_FDE_TYPE_ID);
2346 CATCH (e, RETURN_MASK_ERROR)
2348 warning (_("skipping .eh_frame info of %s: %s"),
2349 objfile_name (objfile), e.message);
2351 if (fde_table.num_entries != 0)
2353 xfree (fde_table.entries);
2354 fde_table.entries = NULL;
2355 fde_table.num_entries = 0;
2357 /* The cie_table is discarded by the next if. */
2361 if (cie_table.num_entries != 0)
2363 /* Reinit cie_table: debug_frame has different CIEs. */
2364 xfree (cie_table.entries);
2365 cie_table.num_entries = 0;
2366 cie_table.entries = NULL;
2371 dwarf2_get_section_info (objfile, DWARF2_DEBUG_FRAME,
2372 &unit->dwarf_frame_section,
2373 &unit->dwarf_frame_buffer,
2374 &unit->dwarf_frame_size);
2375 if (unit->dwarf_frame_size)
2377 int num_old_fde_entries = fde_table.num_entries;
2381 frame_ptr = unit->dwarf_frame_buffer;
2382 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2383 frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2384 &cie_table, &fde_table,
2385 EH_CIE_OR_FDE_TYPE_ID);
2387 CATCH (e, RETURN_MASK_ERROR)
2389 warning (_("skipping .debug_frame info of %s: %s"),
2390 objfile_name (objfile), e.message);
2392 if (fde_table.num_entries != 0)
2394 fde_table.num_entries = num_old_fde_entries;
2395 if (num_old_fde_entries == 0)
2397 xfree (fde_table.entries);
2398 fde_table.entries = NULL;
2403 = XRESIZEVEC (struct dwarf2_fde *, fde_table.entries,
2404 fde_table.num_entries);
2407 fde_table.num_entries = num_old_fde_entries;
2408 /* The cie_table is discarded by the next if. */
2413 /* Discard the cie_table, it is no longer needed. */
2414 if (cie_table.num_entries != 0)
2416 xfree (cie_table.entries);
2417 cie_table.entries = NULL; /* Paranoia. */
2418 cie_table.num_entries = 0; /* Paranoia. */
2421 /* Copy fde_table to obstack: it is needed at runtime. */
2422 fde_table2 = XOBNEW (&objfile->objfile_obstack, struct dwarf2_fde_table);
2424 if (fde_table.num_entries == 0)
2426 fde_table2->entries = NULL;
2427 fde_table2->num_entries = 0;
2431 struct dwarf2_fde *fde_prev = NULL;
2432 struct dwarf2_fde *first_non_zero_fde = NULL;
2435 /* Prepare FDE table for lookups. */
2436 qsort (fde_table.entries, fde_table.num_entries,
2437 sizeof (fde_table.entries[0]), qsort_fde_cmp);
2439 /* Check for leftovers from --gc-sections. The GNU linker sets
2440 the relevant symbols to zero, but doesn't zero the FDE *end*
2441 ranges because there's no relocation there. It's (offset,
2442 length), not (start, end). On targets where address zero is
2443 just another valid address this can be a problem, since the
2444 FDEs appear to be non-empty in the output --- we could pick
2445 out the wrong FDE. To work around this, when overlaps are
2446 detected, we prefer FDEs that do not start at zero.
2448 Start by finding the first FDE with non-zero start. Below
2449 we'll discard all FDEs that start at zero and overlap this
2451 for (i = 0; i < fde_table.num_entries; i++)
2453 struct dwarf2_fde *fde = fde_table.entries[i];
2455 if (fde->initial_location != 0)
2457 first_non_zero_fde = fde;
2462 /* Since we'll be doing bsearch, squeeze out identical (except
2463 for eh_frame_p) fde entries so bsearch result is predictable.
2464 Also discard leftovers from --gc-sections. */
2465 fde_table2->num_entries = 0;
2466 for (i = 0; i < fde_table.num_entries; i++)
2468 struct dwarf2_fde *fde = fde_table.entries[i];
2470 if (fde->initial_location == 0
2471 && first_non_zero_fde != NULL
2472 && (first_non_zero_fde->initial_location
2473 < fde->initial_location + fde->address_range))
2476 if (fde_prev != NULL
2477 && fde_prev->initial_location == fde->initial_location)
2480 obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2481 sizeof (fde_table.entries[0]));
2482 ++fde_table2->num_entries;
2486 = (struct dwarf2_fde **) obstack_finish (&objfile->objfile_obstack);
2488 /* Discard the original fde_table. */
2489 xfree (fde_table.entries);
2492 set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2495 /* Provide a prototype to silence -Wmissing-prototypes. */
2496 void _initialize_dwarf2_frame (void);
2499 _initialize_dwarf2_frame (void)
2501 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2502 dwarf2_frame_objfile_data = register_objfile_data ();