1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003-2013 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"
35 #include "gdb_assert.h"
36 #include "gdb_string.h"
38 #include "complaints.h"
39 #include "dwarf2-frame.h"
41 #include "dwarf2loc.h"
42 #include "exceptions.h"
43 #include "dwarf2-frame-tailcall.h"
47 /* Call Frame Information (CFI). */
49 /* Common Information Entry (CIE). */
53 /* Computation Unit for this CIE. */
54 struct comp_unit *unit;
56 /* Offset into the .debug_frame section where this CIE was found.
57 Used to identify this CIE. */
60 /* Constant that is factored out of all advance location
62 ULONGEST code_alignment_factor;
64 /* Constants that is factored out of all offset instructions. */
65 LONGEST data_alignment_factor;
67 /* Return address column. */
68 ULONGEST return_address_register;
70 /* Instruction sequence to initialize a register set. */
71 const gdb_byte *initial_instructions;
74 /* Saved augmentation, in case it's needed later. */
77 /* Encoding of addresses. */
80 /* Target address size in bytes. */
83 /* Target pointer size in bytes. */
86 /* True if a 'z' augmentation existed. */
87 unsigned char saw_z_augmentation;
89 /* True if an 'S' augmentation existed. */
90 unsigned char signal_frame;
92 /* The version recorded in the CIE. */
93 unsigned char version;
95 /* The segment size. */
96 unsigned char segment_size;
99 struct dwarf2_cie_table
102 struct dwarf2_cie **entries;
105 /* Frame Description Entry (FDE). */
109 /* CIE for this FDE. */
110 struct dwarf2_cie *cie;
112 /* First location associated with this FDE. */
113 CORE_ADDR initial_location;
115 /* Number of bytes of program instructions described by this FDE. */
116 CORE_ADDR address_range;
118 /* Instruction sequence. */
119 const gdb_byte *instructions;
122 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
124 unsigned char eh_frame_p;
127 struct dwarf2_fde_table
130 struct dwarf2_fde **entries;
133 /* A minimal decoding of DWARF2 compilation units. We only decode
134 what's needed to get to the call frame information. */
138 /* Keep the bfd convenient. */
141 struct objfile *objfile;
143 /* Pointer to the .debug_frame section loaded into memory. */
144 const gdb_byte *dwarf_frame_buffer;
146 /* Length of the loaded .debug_frame section. */
147 bfd_size_type dwarf_frame_size;
149 /* Pointer to the .debug_frame section. */
150 asection *dwarf_frame_section;
152 /* Base for DW_EH_PE_datarel encodings. */
155 /* Base for DW_EH_PE_textrel encodings. */
159 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc,
160 CORE_ADDR *out_offset);
162 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
165 static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
166 int ptr_len, const gdb_byte *buf,
167 unsigned int *bytes_read_ptr,
168 CORE_ADDR func_base);
171 /* Structure describing a frame state. */
173 struct dwarf2_frame_state
175 /* Each register save state can be described in terms of a CFA slot,
176 another register, or a location expression. */
177 struct dwarf2_frame_state_reg_info
179 struct dwarf2_frame_state_reg *reg;
189 const gdb_byte *cfa_exp;
191 /* Used to implement DW_CFA_remember_state. */
192 struct dwarf2_frame_state_reg_info *prev;
195 /* The PC described by the current frame state. */
198 /* Initial register set from the CIE.
199 Used to implement DW_CFA_restore. */
200 struct dwarf2_frame_state_reg_info initial;
202 /* The information we care about from the CIE. */
205 ULONGEST retaddr_column;
207 /* Flags for known producer quirks. */
209 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
210 and DW_CFA_def_cfa_offset takes a factored offset. */
211 int armcc_cfa_offsets_sf;
213 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
214 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
215 int armcc_cfa_offsets_reversed;
218 /* Store the length the expression for the CFA in the `cfa_reg' field,
219 which is unused in that case. */
220 #define cfa_exp_len cfa_reg
222 /* Assert that the register set RS is large enough to store gdbarch_num_regs
223 columns. If necessary, enlarge the register set. */
226 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
229 size_t size = sizeof (struct dwarf2_frame_state_reg);
231 if (num_regs <= rs->num_regs)
234 rs->reg = (struct dwarf2_frame_state_reg *)
235 xrealloc (rs->reg, num_regs * size);
237 /* Initialize newly allocated registers. */
238 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
239 rs->num_regs = num_regs;
242 /* Copy the register columns in register set RS into newly allocated
243 memory and return a pointer to this newly created copy. */
245 static struct dwarf2_frame_state_reg *
246 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
248 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
249 struct dwarf2_frame_state_reg *reg;
251 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
252 memcpy (reg, rs->reg, size);
257 /* Release the memory allocated to register set RS. */
260 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
264 dwarf2_frame_state_free_regs (rs->prev);
271 /* Release the memory allocated to the frame state FS. */
274 dwarf2_frame_state_free (void *p)
276 struct dwarf2_frame_state *fs = p;
278 dwarf2_frame_state_free_regs (fs->initial.prev);
279 dwarf2_frame_state_free_regs (fs->regs.prev);
280 xfree (fs->initial.reg);
281 xfree (fs->regs.reg);
286 /* Helper functions for execute_stack_op. */
289 read_reg (void *baton, int reg)
291 struct frame_info *this_frame = (struct frame_info *) baton;
292 struct gdbarch *gdbarch = get_frame_arch (this_frame);
296 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
298 buf = alloca (register_size (gdbarch, regnum));
299 get_frame_register (this_frame, regnum, buf);
301 /* Convert the register to an integer. This returns a LONGEST
302 rather than a CORE_ADDR, but unpack_pointer does the same thing
303 under the covers, and this makes more sense for non-pointer
304 registers. Maybe read_reg and the associated interfaces should
305 deal with "struct value" instead of CORE_ADDR. */
306 return unpack_long (register_type (gdbarch, regnum), buf);
309 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
311 static struct value *
312 get_reg_value (void *baton, struct type *type, int reg)
314 struct frame_info *this_frame = (struct frame_info *) baton;
315 struct gdbarch *gdbarch = get_frame_arch (this_frame);
316 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
318 return value_from_register (type, regnum, this_frame);
322 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
324 read_memory (addr, buf, len);
327 /* Execute the required actions for both the DW_CFA_restore and
328 DW_CFA_restore_extended instructions. */
330 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
331 struct dwarf2_frame_state *fs, int eh_frame_p)
335 gdb_assert (fs->initial.reg);
336 reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
337 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
339 /* Check if this register was explicitly initialized in the
340 CIE initial instructions. If not, default the rule to
342 if (reg < fs->initial.num_regs)
343 fs->regs.reg[reg] = fs->initial.reg[reg];
345 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
347 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
348 complaint (&symfile_complaints, _("\
349 incomplete CFI data; DW_CFA_restore unspecified\n\
350 register %s (#%d) at %s"),
351 gdbarch_register_name
352 (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
353 gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
354 paddress (gdbarch, fs->pc));
357 /* Virtual method table for execute_stack_op below. */
359 static const struct dwarf_expr_context_funcs dwarf2_frame_ctx_funcs =
364 ctx_no_get_frame_base,
365 ctx_no_get_frame_cfa,
367 ctx_no_get_tls_address,
369 ctx_no_get_base_type,
370 ctx_no_push_dwarf_reg_entry_value,
371 ctx_no_get_addr_index
375 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
376 CORE_ADDR offset, struct frame_info *this_frame,
377 CORE_ADDR initial, int initial_in_stack_memory)
379 struct dwarf_expr_context *ctx;
381 struct cleanup *old_chain;
383 ctx = new_dwarf_expr_context ();
384 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
385 make_cleanup_value_free_to_mark (value_mark ());
387 ctx->gdbarch = get_frame_arch (this_frame);
388 ctx->addr_size = addr_size;
389 ctx->ref_addr_size = -1;
390 ctx->offset = offset;
391 ctx->baton = this_frame;
392 ctx->funcs = &dwarf2_frame_ctx_funcs;
394 dwarf_expr_push_address (ctx, initial, initial_in_stack_memory);
395 dwarf_expr_eval (ctx, exp, len);
397 if (ctx->location == DWARF_VALUE_MEMORY)
398 result = dwarf_expr_fetch_address (ctx, 0);
399 else if (ctx->location == DWARF_VALUE_REGISTER)
400 result = read_reg (this_frame, value_as_long (dwarf_expr_fetch (ctx, 0)));
403 /* This is actually invalid DWARF, but if we ever do run across
404 it somehow, we might as well support it. So, instead, report
405 it as unimplemented. */
407 Not implemented: computing unwound register using explicit value operator"));
410 do_cleanups (old_chain);
416 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
417 PC. Modify FS state accordingly. Return current INSN_PTR where the
418 execution has stopped, one can resume it on the next call. */
420 static const gdb_byte *
421 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
422 const gdb_byte *insn_end, struct gdbarch *gdbarch,
423 CORE_ADDR pc, struct dwarf2_frame_state *fs)
425 int eh_frame_p = fde->eh_frame_p;
426 unsigned int bytes_read;
427 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
429 while (insn_ptr < insn_end && fs->pc <= pc)
431 gdb_byte insn = *insn_ptr++;
435 if ((insn & 0xc0) == DW_CFA_advance_loc)
436 fs->pc += (insn & 0x3f) * fs->code_align;
437 else if ((insn & 0xc0) == DW_CFA_offset)
440 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
441 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
442 offset = utmp * fs->data_align;
443 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
444 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
445 fs->regs.reg[reg].loc.offset = offset;
447 else if ((insn & 0xc0) == DW_CFA_restore)
450 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
457 fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
458 fde->cie->ptr_size, insn_ptr,
459 &bytes_read, fde->initial_location);
460 /* Apply the objfile offset for relocatable objects. */
461 fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
462 SECT_OFF_TEXT (fde->cie->unit->objfile));
463 insn_ptr += bytes_read;
466 case DW_CFA_advance_loc1:
467 utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
468 fs->pc += utmp * fs->code_align;
471 case DW_CFA_advance_loc2:
472 utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
473 fs->pc += utmp * fs->code_align;
476 case DW_CFA_advance_loc4:
477 utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
478 fs->pc += utmp * fs->code_align;
482 case DW_CFA_offset_extended:
483 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
484 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
485 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
486 offset = utmp * fs->data_align;
487 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
488 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
489 fs->regs.reg[reg].loc.offset = offset;
492 case DW_CFA_restore_extended:
493 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
494 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
497 case DW_CFA_undefined:
498 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
499 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
500 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
501 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
504 case DW_CFA_same_value:
505 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
506 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
507 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
508 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
511 case DW_CFA_register:
512 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
513 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
514 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
515 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
516 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
517 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
518 fs->regs.reg[reg].loc.reg = utmp;
521 case DW_CFA_remember_state:
523 struct dwarf2_frame_state_reg_info *new_rs;
525 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
527 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
528 fs->regs.prev = new_rs;
532 case DW_CFA_restore_state:
534 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
538 complaint (&symfile_complaints, _("\
539 bad CFI data; mismatched DW_CFA_restore_state at %s"),
540 paddress (gdbarch, fs->pc));
544 xfree (fs->regs.reg);
552 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
553 fs->regs.cfa_reg = reg;
554 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
556 if (fs->armcc_cfa_offsets_sf)
557 utmp *= fs->data_align;
559 fs->regs.cfa_offset = utmp;
560 fs->regs.cfa_how = CFA_REG_OFFSET;
563 case DW_CFA_def_cfa_register:
564 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
565 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
567 fs->regs.cfa_how = CFA_REG_OFFSET;
570 case DW_CFA_def_cfa_offset:
571 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
573 if (fs->armcc_cfa_offsets_sf)
574 utmp *= fs->data_align;
576 fs->regs.cfa_offset = utmp;
577 /* cfa_how deliberately not set. */
583 case DW_CFA_def_cfa_expression:
584 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
585 fs->regs.cfa_exp_len = utmp;
586 fs->regs.cfa_exp = insn_ptr;
587 fs->regs.cfa_how = CFA_EXP;
588 insn_ptr += fs->regs.cfa_exp_len;
591 case DW_CFA_expression:
592 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
593 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
594 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
595 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
596 fs->regs.reg[reg].loc.exp = insn_ptr;
597 fs->regs.reg[reg].exp_len = utmp;
598 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
602 case DW_CFA_offset_extended_sf:
603 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
604 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
605 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
606 offset *= fs->data_align;
607 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
608 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
609 fs->regs.reg[reg].loc.offset = offset;
612 case DW_CFA_val_offset:
613 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
614 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
615 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
616 offset = utmp * fs->data_align;
617 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
618 fs->regs.reg[reg].loc.offset = offset;
621 case DW_CFA_val_offset_sf:
622 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
623 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
624 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
625 offset *= fs->data_align;
626 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
627 fs->regs.reg[reg].loc.offset = offset;
630 case DW_CFA_val_expression:
631 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
632 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
633 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
634 fs->regs.reg[reg].loc.exp = insn_ptr;
635 fs->regs.reg[reg].exp_len = utmp;
636 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
640 case DW_CFA_def_cfa_sf:
641 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
642 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
644 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
645 fs->regs.cfa_offset = offset * fs->data_align;
646 fs->regs.cfa_how = CFA_REG_OFFSET;
649 case DW_CFA_def_cfa_offset_sf:
650 insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
651 fs->regs.cfa_offset = offset * fs->data_align;
652 /* cfa_how deliberately not set. */
655 case DW_CFA_GNU_window_save:
656 /* This is SPARC-specific code, and contains hard-coded
657 constants for the register numbering scheme used by
658 GCC. Rather than having a architecture-specific
659 operation that's only ever used by a single
660 architecture, we provide the implementation here.
661 Incidentally that's what GCC does too in its
664 int size = register_size (gdbarch, 0);
666 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
667 for (reg = 8; reg < 16; reg++)
669 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
670 fs->regs.reg[reg].loc.reg = reg + 16;
672 for (reg = 16; reg < 32; reg++)
674 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
675 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
680 case DW_CFA_GNU_args_size:
682 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
685 case DW_CFA_GNU_negative_offset_extended:
686 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, ®);
687 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
688 insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
689 offset = utmp * fs->data_align;
690 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
691 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
692 fs->regs.reg[reg].loc.offset = -offset;
696 internal_error (__FILE__, __LINE__,
697 _("Unknown CFI encountered."));
702 if (fs->initial.reg == NULL)
704 /* Don't allow remember/restore between CIE and FDE programs. */
705 dwarf2_frame_state_free_regs (fs->regs.prev);
706 fs->regs.prev = NULL;
713 /* Architecture-specific operations. */
715 /* Per-architecture data key. */
716 static struct gdbarch_data *dwarf2_frame_data;
718 struct dwarf2_frame_ops
720 /* Pre-initialize the register state REG for register REGNUM. */
721 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
722 struct frame_info *);
724 /* Check whether the THIS_FRAME is a signal trampoline. */
725 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
727 /* Convert .eh_frame register number to DWARF register number, or
728 adjust .debug_frame register number. */
729 int (*adjust_regnum) (struct gdbarch *, int, int);
732 /* Default architecture-specific register state initialization
736 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
737 struct dwarf2_frame_state_reg *reg,
738 struct frame_info *this_frame)
740 /* If we have a register that acts as a program counter, mark it as
741 a destination for the return address. If we have a register that
742 serves as the stack pointer, arrange for it to be filled with the
743 call frame address (CFA). The other registers are marked as
746 We copy the return address to the program counter, since many
747 parts in GDB assume that it is possible to get the return address
748 by unwinding the program counter register. However, on ISA's
749 with a dedicated return address register, the CFI usually only
750 contains information to unwind that return address register.
752 The reason we're treating the stack pointer special here is
753 because in many cases GCC doesn't emit CFI for the stack pointer
754 and implicitly assumes that it is equal to the CFA. This makes
755 some sense since the DWARF specification (version 3, draft 8,
758 "Typically, the CFA is defined to be the value of the stack
759 pointer at the call site in the previous frame (which may be
760 different from its value on entry to the current frame)."
762 However, this isn't true for all platforms supported by GCC
763 (e.g. IBM S/390 and zSeries). Those architectures should provide
764 their own architecture-specific initialization function. */
766 if (regnum == gdbarch_pc_regnum (gdbarch))
767 reg->how = DWARF2_FRAME_REG_RA;
768 else if (regnum == gdbarch_sp_regnum (gdbarch))
769 reg->how = DWARF2_FRAME_REG_CFA;
772 /* Return a default for the architecture-specific operations. */
775 dwarf2_frame_init (struct obstack *obstack)
777 struct dwarf2_frame_ops *ops;
779 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
780 ops->init_reg = dwarf2_frame_default_init_reg;
784 /* Set the architecture-specific register state initialization
785 function for GDBARCH to INIT_REG. */
788 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
789 void (*init_reg) (struct gdbarch *, int,
790 struct dwarf2_frame_state_reg *,
791 struct frame_info *))
793 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
795 ops->init_reg = init_reg;
798 /* Pre-initialize the register state REG for register REGNUM. */
801 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
802 struct dwarf2_frame_state_reg *reg,
803 struct frame_info *this_frame)
805 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
807 ops->init_reg (gdbarch, regnum, reg, this_frame);
810 /* Set the architecture-specific signal trampoline recognition
811 function for GDBARCH to SIGNAL_FRAME_P. */
814 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
815 int (*signal_frame_p) (struct gdbarch *,
816 struct frame_info *))
818 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
820 ops->signal_frame_p = signal_frame_p;
823 /* Query the architecture-specific signal frame recognizer for
827 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
828 struct frame_info *this_frame)
830 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
832 if (ops->signal_frame_p == NULL)
834 return ops->signal_frame_p (gdbarch, this_frame);
837 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
841 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
842 int (*adjust_regnum) (struct gdbarch *,
845 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
847 ops->adjust_regnum = adjust_regnum;
850 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
854 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
855 int regnum, int eh_frame_p)
857 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
859 if (ops->adjust_regnum == NULL)
861 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
865 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
866 struct dwarf2_fde *fde)
870 s = find_pc_symtab (fs->pc);
874 if (producer_is_realview (s->producer))
876 if (fde->cie->version == 1)
877 fs->armcc_cfa_offsets_sf = 1;
879 if (fde->cie->version == 1)
880 fs->armcc_cfa_offsets_reversed = 1;
882 /* The reversed offset problem is present in some compilers
883 using DWARF3, but it was eventually fixed. Check the ARM
884 defined augmentations, which are in the format "armcc" followed
885 by a list of one-character options. The "+" option means
886 this problem is fixed (no quirk needed). If the armcc
887 augmentation is missing, the quirk is needed. */
888 if (fde->cie->version == 3
889 && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
890 || strchr (fde->cie->augmentation + 5, '+') == NULL))
891 fs->armcc_cfa_offsets_reversed = 1;
899 dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc,
900 struct gdbarch *gdbarch,
902 struct dwarf2_per_cu_data *data)
904 struct dwarf2_fde *fde;
905 CORE_ADDR text_offset;
906 struct dwarf2_frame_state fs;
909 memset (&fs, 0, sizeof (struct dwarf2_frame_state));
913 /* Find the correct FDE. */
914 fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
916 error (_("Could not compute CFA; needed to translate this expression"));
918 /* Extract any interesting information from the CIE. */
919 fs.data_align = fde->cie->data_alignment_factor;
920 fs.code_align = fde->cie->code_alignment_factor;
921 fs.retaddr_column = fde->cie->return_address_register;
922 addr_size = fde->cie->addr_size;
924 /* Check for "quirks" - known bugs in producers. */
925 dwarf2_frame_find_quirks (&fs, fde);
927 /* First decode all the insns in the CIE. */
928 execute_cfa_program (fde, fde->cie->initial_instructions,
929 fde->cie->end, gdbarch, pc, &fs);
931 /* Save the initialized register set. */
932 fs.initial = fs.regs;
933 fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
935 /* Then decode the insns in the FDE up to our target PC. */
936 execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
938 /* Calculate the CFA. */
939 switch (fs.regs.cfa_how)
943 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, fs.regs.cfa_reg);
946 error (_("Unable to access DWARF register number %d"),
947 (int) fs.regs.cfa_reg); /* FIXME */
948 ax_reg (expr, regnum);
950 if (fs.regs.cfa_offset != 0)
952 if (fs.armcc_cfa_offsets_reversed)
953 ax_const_l (expr, -fs.regs.cfa_offset);
955 ax_const_l (expr, fs.regs.cfa_offset);
956 ax_simple (expr, aop_add);
962 ax_const_l (expr, text_offset);
963 dwarf2_compile_expr_to_ax (expr, loc, gdbarch, addr_size,
965 fs.regs.cfa_exp + fs.regs.cfa_exp_len,
970 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
975 struct dwarf2_frame_cache
977 /* DWARF Call Frame Address. */
980 /* Set if the return address column was marked as unavailable
981 (required non-collected memory or registers to compute). */
982 int unavailable_retaddr;
984 /* Set if the return address column was marked as undefined. */
985 int undefined_retaddr;
987 /* Saved registers, indexed by GDB register number, not by DWARF
989 struct dwarf2_frame_state_reg *reg;
991 /* Return address register. */
992 struct dwarf2_frame_state_reg retaddr_reg;
994 /* Target address size in bytes. */
997 /* The .text offset. */
998 CORE_ADDR text_offset;
1000 /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
1001 sequence. If NULL then it is a normal case with no TAILCALL_FRAME
1002 involved. Non-bottom frames of a virtual tail call frames chain use
1003 dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
1005 void *tailcall_cache;
1008 /* A cleanup that sets a pointer to NULL. */
1011 clear_pointer_cleanup (void *arg)
1018 static struct dwarf2_frame_cache *
1019 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
1021 struct cleanup *reset_cache_cleanup, *old_chain;
1022 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1023 const int num_regs = gdbarch_num_regs (gdbarch)
1024 + gdbarch_num_pseudo_regs (gdbarch);
1025 struct dwarf2_frame_cache *cache;
1026 struct dwarf2_frame_state *fs;
1027 struct dwarf2_fde *fde;
1028 volatile struct gdb_exception ex;
1030 LONGEST entry_cfa_sp_offset;
1031 int entry_cfa_sp_offset_p = 0;
1032 const gdb_byte *instr;
1037 /* Allocate a new cache. */
1038 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1039 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
1040 *this_cache = cache;
1041 reset_cache_cleanup = make_cleanup (clear_pointer_cleanup, this_cache);
1043 /* Allocate and initialize the frame state. */
1044 fs = XZALLOC (struct dwarf2_frame_state);
1045 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1049 Note that if the next frame is never supposed to return (i.e. a call
1050 to abort), the compiler might optimize away the instruction at
1051 its return address. As a result the return address will
1052 point at some random instruction, and the CFI for that
1053 instruction is probably worthless to us. GCC's unwinder solves
1054 this problem by substracting 1 from the return address to get an
1055 address in the middle of a presumed call instruction (or the
1056 instruction in the associated delay slot). This should only be
1057 done for "normal" frames and not for resume-type frames (signal
1058 handlers, sentinel frames, dummy frames). The function
1059 get_frame_address_in_block does just this. It's not clear how
1060 reliable the method is though; there is the potential for the
1061 register state pre-call being different to that on return. */
1062 fs->pc = get_frame_address_in_block (this_frame);
1064 /* Find the correct FDE. */
1065 fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
1066 gdb_assert (fde != NULL);
1068 /* Extract any interesting information from the CIE. */
1069 fs->data_align = fde->cie->data_alignment_factor;
1070 fs->code_align = fde->cie->code_alignment_factor;
1071 fs->retaddr_column = fde->cie->return_address_register;
1072 cache->addr_size = fde->cie->addr_size;
1074 /* Check for "quirks" - known bugs in producers. */
1075 dwarf2_frame_find_quirks (fs, fde);
1077 /* First decode all the insns in the CIE. */
1078 execute_cfa_program (fde, fde->cie->initial_instructions,
1079 fde->cie->end, gdbarch,
1080 get_frame_address_in_block (this_frame), fs);
1082 /* Save the initialized register set. */
1083 fs->initial = fs->regs;
1084 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
1086 if (get_frame_func_if_available (this_frame, &entry_pc))
1088 /* Decode the insns in the FDE up to the entry PC. */
1089 instr = execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1092 if (fs->regs.cfa_how == CFA_REG_OFFSET
1093 && (gdbarch_dwarf2_reg_to_regnum (gdbarch, fs->regs.cfa_reg)
1094 == gdbarch_sp_regnum (gdbarch)))
1096 entry_cfa_sp_offset = fs->regs.cfa_offset;
1097 entry_cfa_sp_offset_p = 1;
1101 instr = fde->instructions;
1103 /* Then decode the insns in the FDE up to our target PC. */
1104 execute_cfa_program (fde, instr, fde->end, gdbarch,
1105 get_frame_address_in_block (this_frame), fs);
1107 TRY_CATCH (ex, RETURN_MASK_ERROR)
1109 /* Calculate the CFA. */
1110 switch (fs->regs.cfa_how)
1112 case CFA_REG_OFFSET:
1113 cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
1114 if (fs->armcc_cfa_offsets_reversed)
1115 cache->cfa -= fs->regs.cfa_offset;
1117 cache->cfa += fs->regs.cfa_offset;
1122 execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1123 cache->addr_size, cache->text_offset,
1128 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1133 if (ex.error == NOT_AVAILABLE_ERROR)
1135 cache->unavailable_retaddr = 1;
1136 do_cleanups (old_chain);
1137 discard_cleanups (reset_cache_cleanup);
1141 throw_exception (ex);
1144 /* Initialize the register state. */
1148 for (regnum = 0; regnum < num_regs; regnum++)
1149 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1152 /* Go through the DWARF2 CFI generated table and save its register
1153 location information in the cache. Note that we don't skip the
1154 return address column; it's perfectly all right for it to
1155 correspond to a real register. If it doesn't correspond to a
1156 real register, or if we shouldn't treat it as such,
1157 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1158 the range [0, gdbarch_num_regs). */
1160 int column; /* CFI speak for "register number". */
1162 for (column = 0; column < fs->regs.num_regs; column++)
1164 /* Use the GDB register number as the destination index. */
1165 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1167 /* If there's no corresponding GDB register, ignore it. */
1168 if (regnum < 0 || regnum >= num_regs)
1171 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1172 of all debug info registers. If it doesn't, complain (but
1173 not too loudly). It turns out that GCC assumes that an
1174 unspecified register implies "same value" when CFI (draft
1175 7) specifies nothing at all. Such a register could equally
1176 be interpreted as "undefined". Also note that this check
1177 isn't sufficient; it only checks that all registers in the
1178 range [0 .. max column] are specified, and won't detect
1179 problems when a debug info register falls outside of the
1180 table. We need a way of iterating through all the valid
1181 DWARF2 register numbers. */
1182 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1184 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1185 complaint (&symfile_complaints, _("\
1186 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1187 gdbarch_register_name (gdbarch, regnum),
1188 paddress (gdbarch, fs->pc));
1191 cache->reg[regnum] = fs->regs.reg[column];
1195 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1196 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1200 for (regnum = 0; regnum < num_regs; regnum++)
1202 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1203 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1205 struct dwarf2_frame_state_reg *retaddr_reg =
1206 &fs->regs.reg[fs->retaddr_column];
1208 /* It seems rather bizarre to specify an "empty" column as
1209 the return adress column. However, this is exactly
1210 what GCC does on some targets. It turns out that GCC
1211 assumes that the return address can be found in the
1212 register corresponding to the return address column.
1213 Incidentally, that's how we should treat a return
1214 address column specifying "same value" too. */
1215 if (fs->retaddr_column < fs->regs.num_regs
1216 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1217 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1219 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1220 cache->reg[regnum] = *retaddr_reg;
1222 cache->retaddr_reg = *retaddr_reg;
1226 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1228 cache->reg[regnum].loc.reg = fs->retaddr_column;
1229 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1233 cache->retaddr_reg.loc.reg = fs->retaddr_column;
1234 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1241 if (fs->retaddr_column < fs->regs.num_regs
1242 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1243 cache->undefined_retaddr = 1;
1245 do_cleanups (old_chain);
1247 /* Try to find a virtual tail call frames chain with bottom (callee) frame
1248 starting at THIS_FRAME. */
1249 dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache,
1250 (entry_cfa_sp_offset_p
1251 ? &entry_cfa_sp_offset : NULL));
1253 discard_cleanups (reset_cache_cleanup);
1257 static enum unwind_stop_reason
1258 dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1261 struct dwarf2_frame_cache *cache
1262 = dwarf2_frame_cache (this_frame, this_cache);
1264 if (cache->unavailable_retaddr)
1265 return UNWIND_UNAVAILABLE;
1267 if (cache->undefined_retaddr)
1268 return UNWIND_OUTERMOST;
1270 return UNWIND_NO_REASON;
1274 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1275 struct frame_id *this_id)
1277 struct dwarf2_frame_cache *cache =
1278 dwarf2_frame_cache (this_frame, this_cache);
1280 if (cache->unavailable_retaddr)
1283 if (cache->undefined_retaddr)
1286 (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1289 static struct value *
1290 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1293 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1294 struct dwarf2_frame_cache *cache =
1295 dwarf2_frame_cache (this_frame, this_cache);
1299 /* Non-bottom frames of a virtual tail call frames chain use
1300 dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1301 them. If dwarf2_tailcall_prev_register_first does not have specific value
1302 unwind the register, tail call frames are assumed to have the register set
1303 of the top caller. */
1304 if (cache->tailcall_cache)
1308 val = dwarf2_tailcall_prev_register_first (this_frame,
1309 &cache->tailcall_cache,
1315 switch (cache->reg[regnum].how)
1317 case DWARF2_FRAME_REG_UNDEFINED:
1318 /* If CFI explicitly specified that the value isn't defined,
1319 mark it as optimized away; the value isn't available. */
1320 return frame_unwind_got_optimized (this_frame, regnum);
1322 case DWARF2_FRAME_REG_SAVED_OFFSET:
1323 addr = cache->cfa + cache->reg[regnum].loc.offset;
1324 return frame_unwind_got_memory (this_frame, regnum, addr);
1326 case DWARF2_FRAME_REG_SAVED_REG:
1328 = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1329 return frame_unwind_got_register (this_frame, regnum, realnum);
1331 case DWARF2_FRAME_REG_SAVED_EXP:
1332 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1333 cache->reg[regnum].exp_len,
1334 cache->addr_size, cache->text_offset,
1335 this_frame, cache->cfa, 1);
1336 return frame_unwind_got_memory (this_frame, regnum, addr);
1338 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1339 addr = cache->cfa + cache->reg[regnum].loc.offset;
1340 return frame_unwind_got_constant (this_frame, regnum, addr);
1342 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1343 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1344 cache->reg[regnum].exp_len,
1345 cache->addr_size, cache->text_offset,
1346 this_frame, cache->cfa, 1);
1347 return frame_unwind_got_constant (this_frame, regnum, addr);
1349 case DWARF2_FRAME_REG_UNSPECIFIED:
1350 /* GCC, in its infinite wisdom decided to not provide unwind
1351 information for registers that are "same value". Since
1352 DWARF2 (3 draft 7) doesn't define such behavior, said
1353 registers are actually undefined (which is different to CFI
1354 "undefined"). Code above issues a complaint about this.
1355 Here just fudge the books, assume GCC, and that the value is
1356 more inner on the stack. */
1357 return frame_unwind_got_register (this_frame, regnum, regnum);
1359 case DWARF2_FRAME_REG_SAME_VALUE:
1360 return frame_unwind_got_register (this_frame, regnum, regnum);
1362 case DWARF2_FRAME_REG_CFA:
1363 return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1365 case DWARF2_FRAME_REG_CFA_OFFSET:
1366 addr = cache->cfa + cache->reg[regnum].loc.offset;
1367 return frame_unwind_got_address (this_frame, regnum, addr);
1369 case DWARF2_FRAME_REG_RA_OFFSET:
1370 addr = cache->reg[regnum].loc.offset;
1371 regnum = gdbarch_dwarf2_reg_to_regnum
1372 (gdbarch, cache->retaddr_reg.loc.reg);
1373 addr += get_frame_register_unsigned (this_frame, regnum);
1374 return frame_unwind_got_address (this_frame, regnum, addr);
1376 case DWARF2_FRAME_REG_FN:
1377 return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1380 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1384 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1385 call frames chain. */
1388 dwarf2_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1390 struct dwarf2_frame_cache *cache = dwarf2_frame_cache (self, &this_cache);
1392 if (cache->tailcall_cache)
1393 dwarf2_tailcall_frame_unwind.dealloc_cache (self, cache->tailcall_cache);
1397 dwarf2_frame_sniffer (const struct frame_unwind *self,
1398 struct frame_info *this_frame, void **this_cache)
1400 /* Grab an address that is guarenteed to reside somewhere within the
1401 function. get_frame_pc(), with a no-return next function, can
1402 end up returning something past the end of this function's body.
1403 If the frame we're sniffing for is a signal frame whose start
1404 address is placed on the stack by the OS, its FDE must
1405 extend one byte before its start address or we could potentially
1406 select the FDE of the previous function. */
1407 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1408 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1413 /* On some targets, signal trampolines may have unwind information.
1414 We need to recognize them so that we set the frame type
1417 if (fde->cie->signal_frame
1418 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1420 return self->type == SIGTRAMP_FRAME;
1422 if (self->type != NORMAL_FRAME)
1425 /* Preinitializa the cache so that TAILCALL_FRAME can find the record by
1426 dwarf2_tailcall_sniffer_first. */
1427 dwarf2_frame_cache (this_frame, this_cache);
1432 static const struct frame_unwind dwarf2_frame_unwind =
1435 dwarf2_frame_unwind_stop_reason,
1436 dwarf2_frame_this_id,
1437 dwarf2_frame_prev_register,
1439 dwarf2_frame_sniffer,
1440 dwarf2_frame_dealloc_cache
1443 static const struct frame_unwind dwarf2_signal_frame_unwind =
1446 dwarf2_frame_unwind_stop_reason,
1447 dwarf2_frame_this_id,
1448 dwarf2_frame_prev_register,
1450 dwarf2_frame_sniffer,
1452 /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1456 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1459 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1461 /* TAILCALL_FRAME must be first to find the record by
1462 dwarf2_tailcall_sniffer_first. */
1463 frame_unwind_append_unwinder (gdbarch, &dwarf2_tailcall_frame_unwind);
1465 frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1466 frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1470 /* There is no explicitly defined relationship between the CFA and the
1471 location of frame's local variables and arguments/parameters.
1472 Therefore, frame base methods on this page should probably only be
1473 used as a last resort, just to avoid printing total garbage as a
1474 response to the "info frame" command. */
1477 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1479 struct dwarf2_frame_cache *cache =
1480 dwarf2_frame_cache (this_frame, this_cache);
1485 static const struct frame_base dwarf2_frame_base =
1487 &dwarf2_frame_unwind,
1488 dwarf2_frame_base_address,
1489 dwarf2_frame_base_address,
1490 dwarf2_frame_base_address
1493 const struct frame_base *
1494 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1496 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1498 if (dwarf2_frame_find_fde (&block_addr, NULL))
1499 return &dwarf2_frame_base;
1504 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1505 the DWARF unwinder. This is used to implement
1506 DW_OP_call_frame_cfa. */
1509 dwarf2_frame_cfa (struct frame_info *this_frame)
1511 while (get_frame_type (this_frame) == INLINE_FRAME)
1512 this_frame = get_prev_frame (this_frame);
1513 /* This restriction could be lifted if other unwinders are known to
1514 compute the frame base in a way compatible with the DWARF
1516 if (!frame_unwinder_is (this_frame, &dwarf2_frame_unwind)
1517 && !frame_unwinder_is (this_frame, &dwarf2_tailcall_frame_unwind))
1518 error (_("can't compute CFA for this frame"));
1519 if (get_frame_unwind_stop_reason (this_frame) == UNWIND_UNAVAILABLE)
1520 throw_error (NOT_AVAILABLE_ERROR,
1521 _("can't compute CFA for this frame: "
1522 "required registers or memory are unavailable"));
1523 return get_frame_base (this_frame);
1526 const struct objfile_data *dwarf2_frame_objfile_data;
1529 read_1_byte (bfd *abfd, const gdb_byte *buf)
1531 return bfd_get_8 (abfd, buf);
1535 read_4_bytes (bfd *abfd, const gdb_byte *buf)
1537 return bfd_get_32 (abfd, buf);
1541 read_8_bytes (bfd *abfd, const gdb_byte *buf)
1543 return bfd_get_64 (abfd, buf);
1547 read_initial_length (bfd *abfd, const gdb_byte *buf,
1548 unsigned int *bytes_read_ptr)
1552 result = bfd_get_32 (abfd, buf);
1553 if (result == 0xffffffff)
1555 result = bfd_get_64 (abfd, buf + 4);
1556 *bytes_read_ptr = 12;
1559 *bytes_read_ptr = 4;
1565 /* Pointer encoding helper functions. */
1567 /* GCC supports exception handling based on DWARF2 CFI. However, for
1568 technical reasons, it encodes addresses in its FDE's in a different
1569 way. Several "pointer encodings" are supported. The encoding
1570 that's used for a particular FDE is determined by the 'R'
1571 augmentation in the associated CIE. The argument of this
1572 augmentation is a single byte.
1574 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1575 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1576 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1577 address should be interpreted (absolute, relative to the current
1578 position in the FDE, ...). Bit 7, indicates that the address
1579 should be dereferenced. */
1582 encoding_for_size (unsigned int size)
1587 return DW_EH_PE_udata2;
1589 return DW_EH_PE_udata4;
1591 return DW_EH_PE_udata8;
1593 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1598 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1599 int ptr_len, const gdb_byte *buf,
1600 unsigned int *bytes_read_ptr,
1601 CORE_ADDR func_base)
1606 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1608 if (encoding & DW_EH_PE_indirect)
1609 internal_error (__FILE__, __LINE__,
1610 _("Unsupported encoding: DW_EH_PE_indirect"));
1612 *bytes_read_ptr = 0;
1614 switch (encoding & 0x70)
1616 case DW_EH_PE_absptr:
1619 case DW_EH_PE_pcrel:
1620 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1621 base += (buf - unit->dwarf_frame_buffer);
1623 case DW_EH_PE_datarel:
1626 case DW_EH_PE_textrel:
1629 case DW_EH_PE_funcrel:
1632 case DW_EH_PE_aligned:
1634 offset = buf - unit->dwarf_frame_buffer;
1635 if ((offset % ptr_len) != 0)
1637 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1638 buf += *bytes_read_ptr;
1642 internal_error (__FILE__, __LINE__,
1643 _("Invalid or unsupported encoding"));
1646 if ((encoding & 0x07) == 0x00)
1648 encoding |= encoding_for_size (ptr_len);
1649 if (bfd_get_sign_extend_vma (unit->abfd))
1650 encoding |= DW_EH_PE_signed;
1653 switch (encoding & 0x0f)
1655 case DW_EH_PE_uleb128:
1658 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1660 *bytes_read_ptr += safe_read_uleb128 (buf, end_buf, &value) - buf;
1661 return base + value;
1663 case DW_EH_PE_udata2:
1664 *bytes_read_ptr += 2;
1665 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1666 case DW_EH_PE_udata4:
1667 *bytes_read_ptr += 4;
1668 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1669 case DW_EH_PE_udata8:
1670 *bytes_read_ptr += 8;
1671 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1672 case DW_EH_PE_sleb128:
1675 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1677 *bytes_read_ptr += safe_read_sleb128 (buf, end_buf, &value) - buf;
1678 return base + value;
1680 case DW_EH_PE_sdata2:
1681 *bytes_read_ptr += 2;
1682 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1683 case DW_EH_PE_sdata4:
1684 *bytes_read_ptr += 4;
1685 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1686 case DW_EH_PE_sdata8:
1687 *bytes_read_ptr += 8;
1688 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1690 internal_error (__FILE__, __LINE__,
1691 _("Invalid or unsupported encoding"));
1697 bsearch_cie_cmp (const void *key, const void *element)
1699 ULONGEST cie_pointer = *(ULONGEST *) key;
1700 struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1702 if (cie_pointer == cie->cie_pointer)
1705 return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1708 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1709 static struct dwarf2_cie *
1710 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1712 struct dwarf2_cie **p_cie;
1714 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1715 bsearch be non-NULL. */
1716 if (cie_table->entries == NULL)
1718 gdb_assert (cie_table->num_entries == 0);
1722 p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1723 sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1729 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1731 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1733 const int n = cie_table->num_entries;
1736 || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1738 cie_table->entries =
1739 xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1740 cie_table->entries[n] = cie;
1741 cie_table->num_entries = n + 1;
1745 bsearch_fde_cmp (const void *key, const void *element)
1747 CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1748 struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1750 if (seek_pc < fde->initial_location)
1752 if (seek_pc < fde->initial_location + fde->address_range)
1757 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1758 inital location associated with it into *PC. */
1760 static struct dwarf2_fde *
1761 dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
1763 struct objfile *objfile;
1765 ALL_OBJFILES (objfile)
1767 struct dwarf2_fde_table *fde_table;
1768 struct dwarf2_fde **p_fde;
1772 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1773 if (fde_table == NULL)
1775 dwarf2_build_frame_info (objfile);
1776 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1778 gdb_assert (fde_table != NULL);
1780 if (fde_table->num_entries == 0)
1783 gdb_assert (objfile->section_offsets);
1784 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1786 gdb_assert (fde_table->num_entries > 0);
1787 if (*pc < offset + fde_table->entries[0]->initial_location)
1790 seek_pc = *pc - offset;
1791 p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1792 sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1795 *pc = (*p_fde)->initial_location + offset;
1797 *out_offset = offset;
1804 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1806 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1808 if (fde->address_range == 0)
1809 /* Discard useless FDEs. */
1812 fde_table->num_entries += 1;
1813 fde_table->entries =
1814 xrealloc (fde_table->entries,
1815 fde_table->num_entries * sizeof (fde_table->entries[0]));
1816 fde_table->entries[fde_table->num_entries - 1] = fde;
1819 #define DW64_CIE_ID 0xffffffffffffffffULL
1821 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1826 EH_CIE_TYPE_ID = 1 << 0,
1827 EH_FDE_TYPE_ID = 1 << 1,
1828 EH_CIE_OR_FDE_TYPE_ID = EH_CIE_TYPE_ID | EH_FDE_TYPE_ID
1831 static const gdb_byte *decode_frame_entry (struct comp_unit *unit,
1832 const gdb_byte *start,
1834 struct dwarf2_cie_table *cie_table,
1835 struct dwarf2_fde_table *fde_table,
1836 enum eh_frame_type entry_type);
1838 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1839 Return NULL if invalid input, otherwise the next byte to be processed. */
1841 static const gdb_byte *
1842 decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
1844 struct dwarf2_cie_table *cie_table,
1845 struct dwarf2_fde_table *fde_table,
1846 enum eh_frame_type entry_type)
1848 struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1849 const gdb_byte *buf, *end;
1851 unsigned int bytes_read;
1854 ULONGEST cie_pointer;
1859 length = read_initial_length (unit->abfd, buf, &bytes_read);
1863 /* Are we still within the section? */
1864 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1870 /* Distinguish between 32 and 64-bit encoded frame info. */
1871 dwarf64_p = (bytes_read == 12);
1873 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1877 cie_id = DW64_CIE_ID;
1883 cie_pointer = read_8_bytes (unit->abfd, buf);
1888 cie_pointer = read_4_bytes (unit->abfd, buf);
1892 if (cie_pointer == cie_id)
1894 /* This is a CIE. */
1895 struct dwarf2_cie *cie;
1897 unsigned int cie_version;
1899 /* Check that a CIE was expected. */
1900 if ((entry_type & EH_CIE_TYPE_ID) == 0)
1901 error (_("Found a CIE when not expecting it."));
1903 /* Record the offset into the .debug_frame section of this CIE. */
1904 cie_pointer = start - unit->dwarf_frame_buffer;
1906 /* Check whether we've already read it. */
1907 if (find_cie (cie_table, cie_pointer))
1910 cie = (struct dwarf2_cie *)
1911 obstack_alloc (&unit->objfile->objfile_obstack,
1912 sizeof (struct dwarf2_cie));
1913 cie->initial_instructions = NULL;
1914 cie->cie_pointer = cie_pointer;
1916 /* The encoding for FDE's in a normal .debug_frame section
1917 depends on the target address size. */
1918 cie->encoding = DW_EH_PE_absptr;
1920 /* We'll determine the final value later, but we need to
1921 initialize it conservatively. */
1922 cie->signal_frame = 0;
1924 /* Check version number. */
1925 cie_version = read_1_byte (unit->abfd, buf);
1926 if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1928 cie->version = cie_version;
1931 /* Interpret the interesting bits of the augmentation. */
1932 cie->augmentation = augmentation = (char *) buf;
1933 buf += (strlen (augmentation) + 1);
1935 /* Ignore armcc augmentations. We only use them for quirks,
1936 and that doesn't happen until later. */
1937 if (strncmp (augmentation, "armcc", 5) == 0)
1938 augmentation += strlen (augmentation);
1940 /* The GCC 2.x "eh" augmentation has a pointer immediately
1941 following the augmentation string, so it must be handled
1943 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1946 buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1950 if (cie->version >= 4)
1952 /* FIXME: check that this is the same as from the CU header. */
1953 cie->addr_size = read_1_byte (unit->abfd, buf);
1955 cie->segment_size = read_1_byte (unit->abfd, buf);
1960 cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1961 cie->segment_size = 0;
1963 /* Address values in .eh_frame sections are defined to have the
1964 target's pointer size. Watchout: This breaks frame info for
1965 targets with pointer size < address size, unless a .debug_frame
1966 section exists as well. */
1968 cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1970 cie->ptr_size = cie->addr_size;
1972 buf = gdb_read_uleb128 (buf, end, &uleb128);
1975 cie->code_alignment_factor = uleb128;
1977 buf = gdb_read_sleb128 (buf, end, &sleb128);
1980 cie->data_alignment_factor = sleb128;
1982 if (cie_version == 1)
1984 cie->return_address_register = read_1_byte (unit->abfd, buf);
1989 buf = gdb_read_uleb128 (buf, end, &uleb128);
1992 cie->return_address_register = uleb128;
1995 cie->return_address_register
1996 = dwarf2_frame_adjust_regnum (gdbarch,
1997 cie->return_address_register,
2000 cie->saw_z_augmentation = (*augmentation == 'z');
2001 if (cie->saw_z_augmentation)
2005 buf = gdb_read_uleb128 (buf, end, &length);
2008 cie->initial_instructions = buf + length;
2012 while (*augmentation)
2014 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
2015 if (*augmentation == 'L')
2022 /* "R" indicates a byte indicating how FDE addresses are encoded. */
2023 else if (*augmentation == 'R')
2025 cie->encoding = *buf++;
2029 /* "P" indicates a personality routine in the CIE augmentation. */
2030 else if (*augmentation == 'P')
2032 /* Skip. Avoid indirection since we throw away the result. */
2033 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
2034 read_encoded_value (unit, encoding, cie->ptr_size,
2035 buf, &bytes_read, 0);
2040 /* "S" indicates a signal frame, such that the return
2041 address must not be decremented to locate the call frame
2042 info for the previous frame; it might even be the first
2043 instruction of a function, so decrementing it would take
2044 us to a different function. */
2045 else if (*augmentation == 'S')
2047 cie->signal_frame = 1;
2051 /* Otherwise we have an unknown augmentation. Assume that either
2052 there is no augmentation data, or we saw a 'z' prefix. */
2055 if (cie->initial_instructions)
2056 buf = cie->initial_instructions;
2061 cie->initial_instructions = buf;
2065 add_cie (cie_table, cie);
2069 /* This is a FDE. */
2070 struct dwarf2_fde *fde;
2072 /* Check that an FDE was expected. */
2073 if ((entry_type & EH_FDE_TYPE_ID) == 0)
2074 error (_("Found an FDE when not expecting it."));
2076 /* In an .eh_frame section, the CIE pointer is the delta between the
2077 address within the FDE where the CIE pointer is stored and the
2078 address of the CIE. Convert it to an offset into the .eh_frame
2082 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2083 cie_pointer -= (dwarf64_p ? 8 : 4);
2086 /* In either case, validate the result is still within the section. */
2087 if (cie_pointer >= unit->dwarf_frame_size)
2090 fde = (struct dwarf2_fde *)
2091 obstack_alloc (&unit->objfile->objfile_obstack,
2092 sizeof (struct dwarf2_fde));
2093 fde->cie = find_cie (cie_table, cie_pointer);
2094 if (fde->cie == NULL)
2096 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
2097 eh_frame_p, cie_table, fde_table,
2099 fde->cie = find_cie (cie_table, cie_pointer);
2102 gdb_assert (fde->cie != NULL);
2104 fde->initial_location =
2105 read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
2106 buf, &bytes_read, 0);
2109 fde->address_range =
2110 read_encoded_value (unit, fde->cie->encoding & 0x0f,
2111 fde->cie->ptr_size, buf, &bytes_read, 0);
2114 /* A 'z' augmentation in the CIE implies the presence of an
2115 augmentation field in the FDE as well. The only thing known
2116 to be in here at present is the LSDA entry for EH. So we
2117 can skip the whole thing. */
2118 if (fde->cie->saw_z_augmentation)
2122 buf = gdb_read_uleb128 (buf, end, &length);
2130 fde->instructions = buf;
2133 fde->eh_frame_p = eh_frame_p;
2135 add_fde (fde_table, fde);
2141 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2142 expect an FDE or a CIE. */
2144 static const gdb_byte *
2145 decode_frame_entry (struct comp_unit *unit, const gdb_byte *start,
2147 struct dwarf2_cie_table *cie_table,
2148 struct dwarf2_fde_table *fde_table,
2149 enum eh_frame_type entry_type)
2151 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2152 const gdb_byte *ret;
2153 ptrdiff_t start_offset;
2157 ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2158 cie_table, fde_table, entry_type);
2162 /* We have corrupt input data of some form. */
2164 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2165 and mismatches wrt padding and alignment of debug sections. */
2166 /* Note that there is no requirement in the standard for any
2167 alignment at all in the frame unwind sections. Testing for
2168 alignment before trying to interpret data would be incorrect.
2170 However, GCC traditionally arranged for frame sections to be
2171 sized such that the FDE length and CIE fields happen to be
2172 aligned (in theory, for performance). This, unfortunately,
2173 was done with .align directives, which had the side effect of
2174 forcing the section to be aligned by the linker.
2176 This becomes a problem when you have some other producer that
2177 creates frame sections that are not as strictly aligned. That
2178 produces a hole in the frame info that gets filled by the
2181 The GCC behaviour is arguably a bug, but it's effectively now
2182 part of the ABI, so we're now stuck with it, at least at the
2183 object file level. A smart linker may decide, in the process
2184 of compressing duplicate CIE information, that it can rewrite
2185 the entire output section without this extra padding. */
2187 start_offset = start - unit->dwarf_frame_buffer;
2188 if (workaround < ALIGN4 && (start_offset & 3) != 0)
2190 start += 4 - (start_offset & 3);
2191 workaround = ALIGN4;
2194 if (workaround < ALIGN8 && (start_offset & 7) != 0)
2196 start += 8 - (start_offset & 7);
2197 workaround = ALIGN8;
2201 /* Nothing left to try. Arrange to return as if we've consumed
2202 the entire input section. Hopefully we'll get valid info from
2203 the other of .debug_frame/.eh_frame. */
2205 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2215 complaint (&symfile_complaints, _("\
2216 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2217 unit->dwarf_frame_section->owner->filename,
2218 unit->dwarf_frame_section->name);
2222 complaint (&symfile_complaints, _("\
2223 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2224 unit->dwarf_frame_section->owner->filename,
2225 unit->dwarf_frame_section->name);
2229 complaint (&symfile_complaints,
2230 _("Corrupt data in %s:%s"),
2231 unit->dwarf_frame_section->owner->filename,
2232 unit->dwarf_frame_section->name);
2240 qsort_fde_cmp (const void *a, const void *b)
2242 struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2243 struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2245 if (aa->initial_location == bb->initial_location)
2247 if (aa->address_range != bb->address_range
2248 && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2249 /* Linker bug, e.g. gold/10400.
2250 Work around it by keeping stable sort order. */
2251 return (a < b) ? -1 : 1;
2253 /* Put eh_frame entries after debug_frame ones. */
2254 return aa->eh_frame_p - bb->eh_frame_p;
2257 return (aa->initial_location < bb->initial_location) ? -1 : 1;
2261 dwarf2_build_frame_info (struct objfile *objfile)
2263 struct comp_unit *unit;
2264 const gdb_byte *frame_ptr;
2265 struct dwarf2_cie_table cie_table;
2266 struct dwarf2_fde_table fde_table;
2267 struct dwarf2_fde_table *fde_table2;
2268 volatile struct gdb_exception e;
2270 cie_table.num_entries = 0;
2271 cie_table.entries = NULL;
2273 fde_table.num_entries = 0;
2274 fde_table.entries = NULL;
2276 /* Build a minimal decoding of the DWARF2 compilation unit. */
2277 unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2278 sizeof (struct comp_unit));
2279 unit->abfd = objfile->obfd;
2280 unit->objfile = objfile;
2284 if (objfile->separate_debug_objfile_backlink == NULL)
2286 /* Do not read .eh_frame from separate file as they must be also
2287 present in the main file. */
2288 dwarf2_get_section_info (objfile, DWARF2_EH_FRAME,
2289 &unit->dwarf_frame_section,
2290 &unit->dwarf_frame_buffer,
2291 &unit->dwarf_frame_size);
2292 if (unit->dwarf_frame_size)
2294 asection *got, *txt;
2296 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2297 that is used for the i386/amd64 target, which currently is
2298 the only target in GCC that supports/uses the
2299 DW_EH_PE_datarel encoding. */
2300 got = bfd_get_section_by_name (unit->abfd, ".got");
2302 unit->dbase = got->vma;
2304 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2306 txt = bfd_get_section_by_name (unit->abfd, ".text");
2308 unit->tbase = txt->vma;
2310 TRY_CATCH (e, RETURN_MASK_ERROR)
2312 frame_ptr = unit->dwarf_frame_buffer;
2313 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2314 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2315 &cie_table, &fde_table,
2316 EH_CIE_OR_FDE_TYPE_ID);
2321 warning (_("skipping .eh_frame info of %s: %s"),
2322 objfile_name (objfile), e.message);
2324 if (fde_table.num_entries != 0)
2326 xfree (fde_table.entries);
2327 fde_table.entries = NULL;
2328 fde_table.num_entries = 0;
2330 /* The cie_table is discarded by the next if. */
2333 if (cie_table.num_entries != 0)
2335 /* Reinit cie_table: debug_frame has different CIEs. */
2336 xfree (cie_table.entries);
2337 cie_table.num_entries = 0;
2338 cie_table.entries = NULL;
2343 dwarf2_get_section_info (objfile, DWARF2_DEBUG_FRAME,
2344 &unit->dwarf_frame_section,
2345 &unit->dwarf_frame_buffer,
2346 &unit->dwarf_frame_size);
2347 if (unit->dwarf_frame_size)
2349 int num_old_fde_entries = fde_table.num_entries;
2351 TRY_CATCH (e, RETURN_MASK_ERROR)
2353 frame_ptr = unit->dwarf_frame_buffer;
2354 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2355 frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2356 &cie_table, &fde_table,
2357 EH_CIE_OR_FDE_TYPE_ID);
2361 warning (_("skipping .debug_frame info of %s: %s"),
2362 objfile_name (objfile), e.message);
2364 if (fde_table.num_entries != 0)
2366 fde_table.num_entries = num_old_fde_entries;
2367 if (num_old_fde_entries == 0)
2369 xfree (fde_table.entries);
2370 fde_table.entries = NULL;
2374 fde_table.entries = xrealloc (fde_table.entries,
2375 fde_table.num_entries *
2376 sizeof (fde_table.entries[0]));
2379 fde_table.num_entries = num_old_fde_entries;
2380 /* The cie_table is discarded by the next if. */
2384 /* Discard the cie_table, it is no longer needed. */
2385 if (cie_table.num_entries != 0)
2387 xfree (cie_table.entries);
2388 cie_table.entries = NULL; /* Paranoia. */
2389 cie_table.num_entries = 0; /* Paranoia. */
2392 /* Copy fde_table to obstack: it is needed at runtime. */
2393 fde_table2 = (struct dwarf2_fde_table *)
2394 obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2396 if (fde_table.num_entries == 0)
2398 fde_table2->entries = NULL;
2399 fde_table2->num_entries = 0;
2403 struct dwarf2_fde *fde_prev = NULL;
2404 struct dwarf2_fde *first_non_zero_fde = NULL;
2407 /* Prepare FDE table for lookups. */
2408 qsort (fde_table.entries, fde_table.num_entries,
2409 sizeof (fde_table.entries[0]), qsort_fde_cmp);
2411 /* Check for leftovers from --gc-sections. The GNU linker sets
2412 the relevant symbols to zero, but doesn't zero the FDE *end*
2413 ranges because there's no relocation there. It's (offset,
2414 length), not (start, end). On targets where address zero is
2415 just another valid address this can be a problem, since the
2416 FDEs appear to be non-empty in the output --- we could pick
2417 out the wrong FDE. To work around this, when overlaps are
2418 detected, we prefer FDEs that do not start at zero.
2420 Start by finding the first FDE with non-zero start. Below
2421 we'll discard all FDEs that start at zero and overlap this
2423 for (i = 0; i < fde_table.num_entries; i++)
2425 struct dwarf2_fde *fde = fde_table.entries[i];
2427 if (fde->initial_location != 0)
2429 first_non_zero_fde = fde;
2434 /* Since we'll be doing bsearch, squeeze out identical (except
2435 for eh_frame_p) fde entries so bsearch result is predictable.
2436 Also discard leftovers from --gc-sections. */
2437 fde_table2->num_entries = 0;
2438 for (i = 0; i < fde_table.num_entries; i++)
2440 struct dwarf2_fde *fde = fde_table.entries[i];
2442 if (fde->initial_location == 0
2443 && first_non_zero_fde != NULL
2444 && (first_non_zero_fde->initial_location
2445 < fde->initial_location + fde->address_range))
2448 if (fde_prev != NULL
2449 && fde_prev->initial_location == fde->initial_location)
2452 obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2453 sizeof (fde_table.entries[0]));
2454 ++fde_table2->num_entries;
2457 fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2459 /* Discard the original fde_table. */
2460 xfree (fde_table.entries);
2463 set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2466 /* Provide a prototype to silence -Wmissing-prototypes. */
2467 void _initialize_dwarf2_frame (void);
2470 _initialize_dwarf2_frame (void)
2472 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2473 dwarf2_frame_objfile_data = register_objfile_data ();