1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Mark Kettenis.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "dwarf2expr.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "complaints.h"
40 #include "dwarf2-frame.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 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 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 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);
168 /* Structure describing a frame state. */
170 struct dwarf2_frame_state
172 /* Each register save state can be described in terms of a CFA slot,
173 another register, or a location expression. */
174 struct dwarf2_frame_state_reg_info
176 struct dwarf2_frame_state_reg *reg;
186 const gdb_byte *cfa_exp;
188 /* Used to implement DW_CFA_remember_state. */
189 struct dwarf2_frame_state_reg_info *prev;
192 /* The PC described by the current frame state. */
195 /* Initial register set from the CIE.
196 Used to implement DW_CFA_restore. */
197 struct dwarf2_frame_state_reg_info initial;
199 /* The information we care about from the CIE. */
202 ULONGEST retaddr_column;
204 /* Flags for known producer quirks. */
206 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
207 and DW_CFA_def_cfa_offset takes a factored offset. */
208 int armcc_cfa_offsets_sf;
210 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
211 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
212 int armcc_cfa_offsets_reversed;
215 /* Store the length the expression for the CFA in the `cfa_reg' field,
216 which is unused in that case. */
217 #define cfa_exp_len cfa_reg
219 /* Assert that the register set RS is large enough to store gdbarch_num_regs
220 columns. If necessary, enlarge the register set. */
223 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
226 size_t size = sizeof (struct dwarf2_frame_state_reg);
228 if (num_regs <= rs->num_regs)
231 rs->reg = (struct dwarf2_frame_state_reg *)
232 xrealloc (rs->reg, num_regs * size);
234 /* Initialize newly allocated registers. */
235 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
236 rs->num_regs = num_regs;
239 /* Copy the register columns in register set RS into newly allocated
240 memory and return a pointer to this newly created copy. */
242 static struct dwarf2_frame_state_reg *
243 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
245 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
246 struct dwarf2_frame_state_reg *reg;
248 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
249 memcpy (reg, rs->reg, size);
254 /* Release the memory allocated to register set RS. */
257 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
261 dwarf2_frame_state_free_regs (rs->prev);
268 /* Release the memory allocated to the frame state FS. */
271 dwarf2_frame_state_free (void *p)
273 struct dwarf2_frame_state *fs = p;
275 dwarf2_frame_state_free_regs (fs->initial.prev);
276 dwarf2_frame_state_free_regs (fs->regs.prev);
277 xfree (fs->initial.reg);
278 xfree (fs->regs.reg);
283 /* Helper functions for execute_stack_op. */
286 read_reg (void *baton, int reg)
288 struct frame_info *this_frame = (struct frame_info *) baton;
289 struct gdbarch *gdbarch = get_frame_arch (this_frame);
293 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
295 buf = alloca (register_size (gdbarch, regnum));
296 get_frame_register (this_frame, regnum, buf);
298 /* Convert the register to an integer. This returns a LONGEST
299 rather than a CORE_ADDR, but unpack_pointer does the same thing
300 under the covers, and this makes more sense for non-pointer
301 registers. Maybe read_reg and the associated interfaces should
302 deal with "struct value" instead of CORE_ADDR. */
303 return unpack_long (register_type (gdbarch, regnum), buf);
307 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
309 read_memory (addr, buf, len);
313 no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
315 internal_error (__FILE__, __LINE__,
316 _("Support for DW_OP_fbreg is unimplemented"));
319 /* Helper function for execute_stack_op. */
322 no_get_frame_cfa (void *baton)
324 internal_error (__FILE__, __LINE__,
325 _("Support for DW_OP_call_frame_cfa is unimplemented"));
328 /* Helper function for execute_stack_op. */
331 no_get_frame_pc (void *baton)
333 internal_error (__FILE__, __LINE__,
334 _("Support for DW_OP_GNU_implicit_pointer is unimplemented"));
338 no_get_tls_address (void *baton, CORE_ADDR offset)
340 internal_error (__FILE__, __LINE__,
341 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
344 /* Helper function for execute_stack_op. */
347 no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
349 internal_error (__FILE__, __LINE__,
350 _("Support for DW_OP_call* is invalid in CFI"));
353 /* Execute the required actions for both the DW_CFA_restore and
354 DW_CFA_restore_extended instructions. */
356 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
357 struct dwarf2_frame_state *fs, int eh_frame_p)
361 gdb_assert (fs->initial.reg);
362 reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
363 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
365 /* Check if this register was explicitly initialized in the
366 CIE initial instructions. If not, default the rule to
368 if (reg < fs->initial.num_regs)
369 fs->regs.reg[reg] = fs->initial.reg[reg];
371 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
373 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
374 complaint (&symfile_complaints, _("\
375 incomplete CFI data; DW_CFA_restore unspecified\n\
376 register %s (#%d) at %s"),
377 gdbarch_register_name
378 (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
379 gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
380 paddress (gdbarch, fs->pc));
384 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
385 CORE_ADDR offset, struct frame_info *this_frame,
386 CORE_ADDR initial, int initial_in_stack_memory)
388 struct dwarf_expr_context *ctx;
390 struct cleanup *old_chain;
392 ctx = new_dwarf_expr_context ();
393 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
395 ctx->gdbarch = get_frame_arch (this_frame);
396 ctx->addr_size = addr_size;
397 ctx->offset = offset;
398 ctx->baton = this_frame;
399 ctx->read_reg = read_reg;
400 ctx->read_mem = read_mem;
401 ctx->get_frame_base = no_get_frame_base;
402 ctx->get_frame_cfa = no_get_frame_cfa;
403 ctx->get_frame_pc = no_get_frame_pc;
404 ctx->get_tls_address = no_get_tls_address;
405 ctx->dwarf_call = no_dwarf_call;
407 dwarf_expr_push (ctx, initial, initial_in_stack_memory);
408 dwarf_expr_eval (ctx, exp, len);
410 if (ctx->location == DWARF_VALUE_MEMORY)
411 result = dwarf_expr_fetch_address (ctx, 0);
412 else if (ctx->location == DWARF_VALUE_REGISTER)
413 result = read_reg (this_frame, dwarf_expr_fetch (ctx, 0));
416 /* This is actually invalid DWARF, but if we ever do run across
417 it somehow, we might as well support it. So, instead, report
418 it as unimplemented. */
419 error (_("Not implemented: computing unwound register using explicit value operator"));
422 do_cleanups (old_chain);
429 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
430 const gdb_byte *insn_end, struct frame_info *this_frame,
431 struct dwarf2_frame_state *fs)
433 int eh_frame_p = fde->eh_frame_p;
434 CORE_ADDR pc = get_frame_pc (this_frame);
436 struct gdbarch *gdbarch = get_frame_arch (this_frame);
437 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
439 while (insn_ptr < insn_end && fs->pc <= pc)
441 gdb_byte insn = *insn_ptr++;
445 if ((insn & 0xc0) == DW_CFA_advance_loc)
446 fs->pc += (insn & 0x3f) * fs->code_align;
447 else if ((insn & 0xc0) == DW_CFA_offset)
450 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
451 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
452 offset = utmp * fs->data_align;
453 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
454 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
455 fs->regs.reg[reg].loc.offset = offset;
457 else if ((insn & 0xc0) == DW_CFA_restore)
460 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
467 fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
468 fde->cie->ptr_size, insn_ptr,
469 &bytes_read, fde->initial_location);
470 /* Apply the objfile offset for relocatable objects. */
471 fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
472 SECT_OFF_TEXT (fde->cie->unit->objfile));
473 insn_ptr += bytes_read;
476 case DW_CFA_advance_loc1:
477 utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
478 fs->pc += utmp * fs->code_align;
481 case DW_CFA_advance_loc2:
482 utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
483 fs->pc += utmp * fs->code_align;
486 case DW_CFA_advance_loc4:
487 utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
488 fs->pc += utmp * fs->code_align;
492 case DW_CFA_offset_extended:
493 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
494 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
495 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
496 offset = utmp * fs->data_align;
497 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
498 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
499 fs->regs.reg[reg].loc.offset = offset;
502 case DW_CFA_restore_extended:
503 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
504 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
507 case DW_CFA_undefined:
508 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
509 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
510 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
511 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
514 case DW_CFA_same_value:
515 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
516 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
517 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
518 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
521 case DW_CFA_register:
522 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
523 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
524 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
525 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
526 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
527 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
528 fs->regs.reg[reg].loc.reg = utmp;
531 case DW_CFA_remember_state:
533 struct dwarf2_frame_state_reg_info *new_rs;
535 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
537 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
538 fs->regs.prev = new_rs;
542 case DW_CFA_restore_state:
544 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
548 complaint (&symfile_complaints, _("\
549 bad CFI data; mismatched DW_CFA_restore_state at %s"),
550 paddress (gdbarch, fs->pc));
554 xfree (fs->regs.reg);
562 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
563 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
565 if (fs->armcc_cfa_offsets_sf)
566 utmp *= fs->data_align;
568 fs->regs.cfa_offset = utmp;
569 fs->regs.cfa_how = CFA_REG_OFFSET;
572 case DW_CFA_def_cfa_register:
573 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
574 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
577 fs->regs.cfa_how = CFA_REG_OFFSET;
580 case DW_CFA_def_cfa_offset:
581 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
583 if (fs->armcc_cfa_offsets_sf)
584 utmp *= fs->data_align;
586 fs->regs.cfa_offset = utmp;
587 /* cfa_how deliberately not set. */
593 case DW_CFA_def_cfa_expression:
594 insn_ptr = read_uleb128 (insn_ptr, insn_end,
595 &fs->regs.cfa_exp_len);
596 fs->regs.cfa_exp = insn_ptr;
597 fs->regs.cfa_how = CFA_EXP;
598 insn_ptr += fs->regs.cfa_exp_len;
601 case DW_CFA_expression:
602 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
603 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
604 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
605 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
606 fs->regs.reg[reg].loc.exp = insn_ptr;
607 fs->regs.reg[reg].exp_len = utmp;
608 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
612 case DW_CFA_offset_extended_sf:
613 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
614 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
615 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
616 offset *= fs->data_align;
617 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
618 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
619 fs->regs.reg[reg].loc.offset = offset;
622 case DW_CFA_val_offset:
623 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
624 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
625 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
626 offset = utmp * fs->data_align;
627 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
628 fs->regs.reg[reg].loc.offset = offset;
631 case DW_CFA_val_offset_sf:
632 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
633 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
634 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
635 offset *= fs->data_align;
636 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
637 fs->regs.reg[reg].loc.offset = offset;
640 case DW_CFA_val_expression:
641 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
642 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
643 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
644 fs->regs.reg[reg].loc.exp = insn_ptr;
645 fs->regs.reg[reg].exp_len = utmp;
646 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
650 case DW_CFA_def_cfa_sf:
651 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
652 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
655 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
656 fs->regs.cfa_offset = offset * fs->data_align;
657 fs->regs.cfa_how = CFA_REG_OFFSET;
660 case DW_CFA_def_cfa_offset_sf:
661 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
662 fs->regs.cfa_offset = offset * fs->data_align;
663 /* cfa_how deliberately not set. */
666 case DW_CFA_GNU_window_save:
667 /* This is SPARC-specific code, and contains hard-coded
668 constants for the register numbering scheme used by
669 GCC. Rather than having a architecture-specific
670 operation that's only ever used by a single
671 architecture, we provide the implementation here.
672 Incidentally that's what GCC does too in its
675 int size = register_size (gdbarch, 0);
677 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
678 for (reg = 8; reg < 16; reg++)
680 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
681 fs->regs.reg[reg].loc.reg = reg + 16;
683 for (reg = 16; reg < 32; reg++)
685 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
686 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
691 case DW_CFA_GNU_args_size:
693 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
696 case DW_CFA_GNU_negative_offset_extended:
697 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
698 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
699 insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
700 offset *= fs->data_align;
701 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
702 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
703 fs->regs.reg[reg].loc.offset = -offset;
707 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
712 /* Don't allow remember/restore between CIE and FDE programs. */
713 dwarf2_frame_state_free_regs (fs->regs.prev);
714 fs->regs.prev = NULL;
718 /* Architecture-specific operations. */
720 /* Per-architecture data key. */
721 static struct gdbarch_data *dwarf2_frame_data;
723 struct dwarf2_frame_ops
725 /* Pre-initialize the register state REG for register REGNUM. */
726 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
727 struct frame_info *);
729 /* Check whether the THIS_FRAME is a signal trampoline. */
730 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
732 /* Convert .eh_frame register number to DWARF register number, or
733 adjust .debug_frame register number. */
734 int (*adjust_regnum) (struct gdbarch *, int, int);
737 /* Default architecture-specific register state initialization
741 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
742 struct dwarf2_frame_state_reg *reg,
743 struct frame_info *this_frame)
745 /* If we have a register that acts as a program counter, mark it as
746 a destination for the return address. If we have a register that
747 serves as the stack pointer, arrange for it to be filled with the
748 call frame address (CFA). The other registers are marked as
751 We copy the return address to the program counter, since many
752 parts in GDB assume that it is possible to get the return address
753 by unwinding the program counter register. However, on ISA's
754 with a dedicated return address register, the CFI usually only
755 contains information to unwind that return address register.
757 The reason we're treating the stack pointer special here is
758 because in many cases GCC doesn't emit CFI for the stack pointer
759 and implicitly assumes that it is equal to the CFA. This makes
760 some sense since the DWARF specification (version 3, draft 8,
763 "Typically, the CFA is defined to be the value of the stack
764 pointer at the call site in the previous frame (which may be
765 different from its value on entry to the current frame)."
767 However, this isn't true for all platforms supported by GCC
768 (e.g. IBM S/390 and zSeries). Those architectures should provide
769 their own architecture-specific initialization function. */
771 if (regnum == gdbarch_pc_regnum (gdbarch))
772 reg->how = DWARF2_FRAME_REG_RA;
773 else if (regnum == gdbarch_sp_regnum (gdbarch))
774 reg->how = DWARF2_FRAME_REG_CFA;
777 /* Return a default for the architecture-specific operations. */
780 dwarf2_frame_init (struct obstack *obstack)
782 struct dwarf2_frame_ops *ops;
784 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
785 ops->init_reg = dwarf2_frame_default_init_reg;
789 /* Set the architecture-specific register state initialization
790 function for GDBARCH to INIT_REG. */
793 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
794 void (*init_reg) (struct gdbarch *, int,
795 struct dwarf2_frame_state_reg *,
796 struct frame_info *))
798 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
800 ops->init_reg = init_reg;
803 /* Pre-initialize the register state REG for register REGNUM. */
806 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
807 struct dwarf2_frame_state_reg *reg,
808 struct frame_info *this_frame)
810 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
812 ops->init_reg (gdbarch, regnum, reg, this_frame);
815 /* Set the architecture-specific signal trampoline recognition
816 function for GDBARCH to SIGNAL_FRAME_P. */
819 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
820 int (*signal_frame_p) (struct gdbarch *,
821 struct frame_info *))
823 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
825 ops->signal_frame_p = signal_frame_p;
828 /* Query the architecture-specific signal frame recognizer for
832 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
833 struct frame_info *this_frame)
835 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
837 if (ops->signal_frame_p == NULL)
839 return ops->signal_frame_p (gdbarch, this_frame);
842 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
846 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
847 int (*adjust_regnum) (struct gdbarch *,
850 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
852 ops->adjust_regnum = adjust_regnum;
855 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
859 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p)
861 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
863 if (ops->adjust_regnum == NULL)
865 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
869 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
870 struct dwarf2_fde *fde)
874 s = find_pc_symtab (fs->pc);
878 if (producer_is_realview (s->producer))
880 if (fde->cie->version == 1)
881 fs->armcc_cfa_offsets_sf = 1;
883 if (fde->cie->version == 1)
884 fs->armcc_cfa_offsets_reversed = 1;
886 /* The reversed offset problem is present in some compilers
887 using DWARF3, but it was eventually fixed. Check the ARM
888 defined augmentations, which are in the format "armcc" followed
889 by a list of one-character options. The "+" option means
890 this problem is fixed (no quirk needed). If the armcc
891 augmentation is missing, the quirk is needed. */
892 if (fde->cie->version == 3
893 && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
894 || strchr (fde->cie->augmentation + 5, '+') == NULL))
895 fs->armcc_cfa_offsets_reversed = 1;
902 struct dwarf2_frame_cache
904 /* DWARF Call Frame Address. */
907 /* Set if the return address column was marked as undefined. */
908 int undefined_retaddr;
910 /* Saved registers, indexed by GDB register number, not by DWARF
912 struct dwarf2_frame_state_reg *reg;
914 /* Return address register. */
915 struct dwarf2_frame_state_reg retaddr_reg;
917 /* Target address size in bytes. */
920 /* The .text offset. */
921 CORE_ADDR text_offset;
924 static struct dwarf2_frame_cache *
925 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
927 struct cleanup *old_chain;
928 struct gdbarch *gdbarch = get_frame_arch (this_frame);
929 const int num_regs = gdbarch_num_regs (gdbarch)
930 + gdbarch_num_pseudo_regs (gdbarch);
931 struct dwarf2_frame_cache *cache;
932 struct dwarf2_frame_state *fs;
933 struct dwarf2_fde *fde;
938 /* Allocate a new cache. */
939 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
940 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
942 /* Allocate and initialize the frame state. */
943 fs = XMALLOC (struct dwarf2_frame_state);
944 memset (fs, 0, sizeof (struct dwarf2_frame_state));
945 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
949 Note that if the next frame is never supposed to return (i.e. a call
950 to abort), the compiler might optimize away the instruction at
951 its return address. As a result the return address will
952 point at some random instruction, and the CFI for that
953 instruction is probably worthless to us. GCC's unwinder solves
954 this problem by substracting 1 from the return address to get an
955 address in the middle of a presumed call instruction (or the
956 instruction in the associated delay slot). This should only be
957 done for "normal" frames and not for resume-type frames (signal
958 handlers, sentinel frames, dummy frames). The function
959 get_frame_address_in_block does just this. It's not clear how
960 reliable the method is though; there is the potential for the
961 register state pre-call being different to that on return. */
962 fs->pc = get_frame_address_in_block (this_frame);
964 /* Find the correct FDE. */
965 fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
966 gdb_assert (fde != NULL);
968 /* Extract any interesting information from the CIE. */
969 fs->data_align = fde->cie->data_alignment_factor;
970 fs->code_align = fde->cie->code_alignment_factor;
971 fs->retaddr_column = fde->cie->return_address_register;
972 cache->addr_size = fde->cie->addr_size;
974 /* Check for "quirks" - known bugs in producers. */
975 dwarf2_frame_find_quirks (fs, fde);
977 /* First decode all the insns in the CIE. */
978 execute_cfa_program (fde, fde->cie->initial_instructions,
979 fde->cie->end, this_frame, fs);
981 /* Save the initialized register set. */
982 fs->initial = fs->regs;
983 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
985 /* Then decode the insns in the FDE up to our target PC. */
986 execute_cfa_program (fde, fde->instructions, fde->end, this_frame, fs);
988 /* Calculate the CFA. */
989 switch (fs->regs.cfa_how)
992 cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
993 if (fs->armcc_cfa_offsets_reversed)
994 cache->cfa -= fs->regs.cfa_offset;
996 cache->cfa += fs->regs.cfa_offset;
1001 execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1002 cache->addr_size, cache->text_offset,
1007 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1010 /* Initialize the register state. */
1014 for (regnum = 0; regnum < num_regs; regnum++)
1015 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1018 /* Go through the DWARF2 CFI generated table and save its register
1019 location information in the cache. Note that we don't skip the
1020 return address column; it's perfectly all right for it to
1021 correspond to a real register. If it doesn't correspond to a
1022 real register, or if we shouldn't treat it as such,
1023 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1024 the range [0, gdbarch_num_regs). */
1026 int column; /* CFI speak for "register number". */
1028 for (column = 0; column < fs->regs.num_regs; column++)
1030 /* Use the GDB register number as the destination index. */
1031 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1033 /* If there's no corresponding GDB register, ignore it. */
1034 if (regnum < 0 || regnum >= num_regs)
1037 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1038 of all debug info registers. If it doesn't, complain (but
1039 not too loudly). It turns out that GCC assumes that an
1040 unspecified register implies "same value" when CFI (draft
1041 7) specifies nothing at all. Such a register could equally
1042 be interpreted as "undefined". Also note that this check
1043 isn't sufficient; it only checks that all registers in the
1044 range [0 .. max column] are specified, and won't detect
1045 problems when a debug info register falls outside of the
1046 table. We need a way of iterating through all the valid
1047 DWARF2 register numbers. */
1048 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1050 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1051 complaint (&symfile_complaints, _("\
1052 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1053 gdbarch_register_name (gdbarch, regnum),
1054 paddress (gdbarch, fs->pc));
1057 cache->reg[regnum] = fs->regs.reg[column];
1061 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1062 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1066 for (regnum = 0; regnum < num_regs; regnum++)
1068 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1069 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1071 struct dwarf2_frame_state_reg *retaddr_reg =
1072 &fs->regs.reg[fs->retaddr_column];
1074 /* It seems rather bizarre to specify an "empty" column as
1075 the return adress column. However, this is exactly
1076 what GCC does on some targets. It turns out that GCC
1077 assumes that the return address can be found in the
1078 register corresponding to the return address column.
1079 Incidentally, that's how we should treat a return
1080 address column specifying "same value" too. */
1081 if (fs->retaddr_column < fs->regs.num_regs
1082 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1083 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1085 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1086 cache->reg[regnum] = *retaddr_reg;
1088 cache->retaddr_reg = *retaddr_reg;
1092 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1094 cache->reg[regnum].loc.reg = fs->retaddr_column;
1095 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1099 cache->retaddr_reg.loc.reg = fs->retaddr_column;
1100 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1107 if (fs->retaddr_column < fs->regs.num_regs
1108 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1109 cache->undefined_retaddr = 1;
1111 do_cleanups (old_chain);
1113 *this_cache = cache;
1118 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1119 struct frame_id *this_id)
1121 struct dwarf2_frame_cache *cache =
1122 dwarf2_frame_cache (this_frame, this_cache);
1124 if (cache->undefined_retaddr)
1127 (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1130 static struct value *
1131 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1134 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1135 struct dwarf2_frame_cache *cache =
1136 dwarf2_frame_cache (this_frame, this_cache);
1140 switch (cache->reg[regnum].how)
1142 case DWARF2_FRAME_REG_UNDEFINED:
1143 /* If CFI explicitly specified that the value isn't defined,
1144 mark it as optimized away; the value isn't available. */
1145 return frame_unwind_got_optimized (this_frame, regnum);
1147 case DWARF2_FRAME_REG_SAVED_OFFSET:
1148 addr = cache->cfa + cache->reg[regnum].loc.offset;
1149 return frame_unwind_got_memory (this_frame, regnum, addr);
1151 case DWARF2_FRAME_REG_SAVED_REG:
1153 = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1154 return frame_unwind_got_register (this_frame, regnum, realnum);
1156 case DWARF2_FRAME_REG_SAVED_EXP:
1157 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1158 cache->reg[regnum].exp_len,
1159 cache->addr_size, cache->text_offset,
1160 this_frame, cache->cfa, 1);
1161 return frame_unwind_got_memory (this_frame, regnum, addr);
1163 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1164 addr = cache->cfa + cache->reg[regnum].loc.offset;
1165 return frame_unwind_got_constant (this_frame, regnum, addr);
1167 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1168 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1169 cache->reg[regnum].exp_len,
1170 cache->addr_size, cache->text_offset,
1171 this_frame, cache->cfa, 1);
1172 return frame_unwind_got_constant (this_frame, regnum, addr);
1174 case DWARF2_FRAME_REG_UNSPECIFIED:
1175 /* GCC, in its infinite wisdom decided to not provide unwind
1176 information for registers that are "same value". Since
1177 DWARF2 (3 draft 7) doesn't define such behavior, said
1178 registers are actually undefined (which is different to CFI
1179 "undefined"). Code above issues a complaint about this.
1180 Here just fudge the books, assume GCC, and that the value is
1181 more inner on the stack. */
1182 return frame_unwind_got_register (this_frame, regnum, regnum);
1184 case DWARF2_FRAME_REG_SAME_VALUE:
1185 return frame_unwind_got_register (this_frame, regnum, regnum);
1187 case DWARF2_FRAME_REG_CFA:
1188 return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1190 case DWARF2_FRAME_REG_CFA_OFFSET:
1191 addr = cache->cfa + cache->reg[regnum].loc.offset;
1192 return frame_unwind_got_address (this_frame, regnum, addr);
1194 case DWARF2_FRAME_REG_RA_OFFSET:
1195 addr = cache->reg[regnum].loc.offset;
1196 regnum = gdbarch_dwarf2_reg_to_regnum
1197 (gdbarch, cache->retaddr_reg.loc.reg);
1198 addr += get_frame_register_unsigned (this_frame, regnum);
1199 return frame_unwind_got_address (this_frame, regnum, addr);
1201 case DWARF2_FRAME_REG_FN:
1202 return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1205 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1210 dwarf2_frame_sniffer (const struct frame_unwind *self,
1211 struct frame_info *this_frame, void **this_cache)
1213 /* Grab an address that is guarenteed to reside somewhere within the
1214 function. get_frame_pc(), with a no-return next function, can
1215 end up returning something past the end of this function's body.
1216 If the frame we're sniffing for is a signal frame whose start
1217 address is placed on the stack by the OS, its FDE must
1218 extend one byte before its start address or we could potentially
1219 select the FDE of the previous function. */
1220 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1221 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1226 /* On some targets, signal trampolines may have unwind information.
1227 We need to recognize them so that we set the frame type
1230 if (fde->cie->signal_frame
1231 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1233 return self->type == SIGTRAMP_FRAME;
1235 return self->type != SIGTRAMP_FRAME;
1238 static const struct frame_unwind dwarf2_frame_unwind =
1241 dwarf2_frame_this_id,
1242 dwarf2_frame_prev_register,
1244 dwarf2_frame_sniffer
1247 static const struct frame_unwind dwarf2_signal_frame_unwind =
1250 dwarf2_frame_this_id,
1251 dwarf2_frame_prev_register,
1253 dwarf2_frame_sniffer
1256 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1259 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1261 frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1262 frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1266 /* There is no explicitly defined relationship between the CFA and the
1267 location of frame's local variables and arguments/parameters.
1268 Therefore, frame base methods on this page should probably only be
1269 used as a last resort, just to avoid printing total garbage as a
1270 response to the "info frame" command. */
1273 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1275 struct dwarf2_frame_cache *cache =
1276 dwarf2_frame_cache (this_frame, this_cache);
1281 static const struct frame_base dwarf2_frame_base =
1283 &dwarf2_frame_unwind,
1284 dwarf2_frame_base_address,
1285 dwarf2_frame_base_address,
1286 dwarf2_frame_base_address
1289 const struct frame_base *
1290 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1292 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1294 if (dwarf2_frame_find_fde (&block_addr, NULL))
1295 return &dwarf2_frame_base;
1300 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1301 the DWARF unwinder. This is used to implement
1302 DW_OP_call_frame_cfa. */
1305 dwarf2_frame_cfa (struct frame_info *this_frame)
1307 while (get_frame_type (this_frame) == INLINE_FRAME)
1308 this_frame = get_prev_frame (this_frame);
1309 /* This restriction could be lifted if other unwinders are known to
1310 compute the frame base in a way compatible with the DWARF
1312 if (! frame_unwinder_is (this_frame, &dwarf2_frame_unwind))
1313 error (_("can't compute CFA for this frame"));
1314 return get_frame_base (this_frame);
1317 const struct objfile_data *dwarf2_frame_objfile_data;
1320 read_1_byte (bfd *abfd, gdb_byte *buf)
1322 return bfd_get_8 (abfd, buf);
1326 read_4_bytes (bfd *abfd, gdb_byte *buf)
1328 return bfd_get_32 (abfd, buf);
1332 read_8_bytes (bfd *abfd, gdb_byte *buf)
1334 return bfd_get_64 (abfd, buf);
1338 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1341 unsigned int num_read;
1351 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1354 result |= ((byte & 0x7f) << shift);
1357 while (byte & 0x80);
1359 *bytes_read_ptr = num_read;
1365 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1369 unsigned int num_read;
1378 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1381 result |= ((byte & 0x7f) << shift);
1384 while (byte & 0x80);
1386 if (shift < 8 * sizeof (result) && (byte & 0x40))
1387 result |= -(((LONGEST)1) << shift);
1389 *bytes_read_ptr = num_read;
1395 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1399 result = bfd_get_32 (abfd, buf);
1400 if (result == 0xffffffff)
1402 result = bfd_get_64 (abfd, buf + 4);
1403 *bytes_read_ptr = 12;
1406 *bytes_read_ptr = 4;
1412 /* Pointer encoding helper functions. */
1414 /* GCC supports exception handling based on DWARF2 CFI. However, for
1415 technical reasons, it encodes addresses in its FDE's in a different
1416 way. Several "pointer encodings" are supported. The encoding
1417 that's used for a particular FDE is determined by the 'R'
1418 augmentation in the associated CIE. The argument of this
1419 augmentation is a single byte.
1421 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1422 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1423 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1424 address should be interpreted (absolute, relative to the current
1425 position in the FDE, ...). Bit 7, indicates that the address
1426 should be dereferenced. */
1429 encoding_for_size (unsigned int size)
1434 return DW_EH_PE_udata2;
1436 return DW_EH_PE_udata4;
1438 return DW_EH_PE_udata8;
1440 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1445 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1446 int ptr_len, const gdb_byte *buf,
1447 unsigned int *bytes_read_ptr,
1448 CORE_ADDR func_base)
1453 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1455 if (encoding & DW_EH_PE_indirect)
1456 internal_error (__FILE__, __LINE__,
1457 _("Unsupported encoding: DW_EH_PE_indirect"));
1459 *bytes_read_ptr = 0;
1461 switch (encoding & 0x70)
1463 case DW_EH_PE_absptr:
1466 case DW_EH_PE_pcrel:
1467 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1468 base += (buf - unit->dwarf_frame_buffer);
1470 case DW_EH_PE_datarel:
1473 case DW_EH_PE_textrel:
1476 case DW_EH_PE_funcrel:
1479 case DW_EH_PE_aligned:
1481 offset = buf - unit->dwarf_frame_buffer;
1482 if ((offset % ptr_len) != 0)
1484 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1485 buf += *bytes_read_ptr;
1489 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1492 if ((encoding & 0x07) == 0x00)
1494 encoding |= encoding_for_size (ptr_len);
1495 if (bfd_get_sign_extend_vma (unit->abfd))
1496 encoding |= DW_EH_PE_signed;
1499 switch (encoding & 0x0f)
1501 case DW_EH_PE_uleb128:
1504 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1506 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1507 return base + value;
1509 case DW_EH_PE_udata2:
1510 *bytes_read_ptr += 2;
1511 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1512 case DW_EH_PE_udata4:
1513 *bytes_read_ptr += 4;
1514 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1515 case DW_EH_PE_udata8:
1516 *bytes_read_ptr += 8;
1517 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1518 case DW_EH_PE_sleb128:
1521 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1523 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1524 return base + value;
1526 case DW_EH_PE_sdata2:
1527 *bytes_read_ptr += 2;
1528 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1529 case DW_EH_PE_sdata4:
1530 *bytes_read_ptr += 4;
1531 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1532 case DW_EH_PE_sdata8:
1533 *bytes_read_ptr += 8;
1534 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1536 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1542 bsearch_cie_cmp (const void *key, const void *element)
1544 ULONGEST cie_pointer = *(ULONGEST *) key;
1545 struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1547 if (cie_pointer == cie->cie_pointer)
1550 return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1553 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1554 static struct dwarf2_cie *
1555 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1557 struct dwarf2_cie **p_cie;
1559 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1560 bsearch be non-NULL. */
1561 if (cie_table->entries == NULL)
1563 gdb_assert (cie_table->num_entries == 0);
1567 p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1568 sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1574 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1576 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1578 const int n = cie_table->num_entries;
1581 || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1583 cie_table->entries =
1584 xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1585 cie_table->entries[n] = cie;
1586 cie_table->num_entries = n + 1;
1590 bsearch_fde_cmp (const void *key, const void *element)
1592 CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1593 struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1595 if (seek_pc < fde->initial_location)
1597 if (seek_pc < fde->initial_location + fde->address_range)
1602 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1603 inital location associated with it into *PC. */
1605 static struct dwarf2_fde *
1606 dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
1608 struct objfile *objfile;
1610 ALL_OBJFILES (objfile)
1612 struct dwarf2_fde_table *fde_table;
1613 struct dwarf2_fde **p_fde;
1617 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1618 if (fde_table == NULL)
1620 dwarf2_build_frame_info (objfile);
1621 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1623 gdb_assert (fde_table != NULL);
1625 if (fde_table->num_entries == 0)
1628 gdb_assert (objfile->section_offsets);
1629 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1631 gdb_assert (fde_table->num_entries > 0);
1632 if (*pc < offset + fde_table->entries[0]->initial_location)
1635 seek_pc = *pc - offset;
1636 p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1637 sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1640 *pc = (*p_fde)->initial_location + offset;
1642 *out_offset = offset;
1649 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1651 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1653 if (fde->address_range == 0)
1654 /* Discard useless FDEs. */
1657 fde_table->num_entries += 1;
1658 fde_table->entries =
1659 xrealloc (fde_table->entries,
1660 fde_table->num_entries * sizeof (fde_table->entries[0]));
1661 fde_table->entries[fde_table->num_entries - 1] = fde;
1664 #ifdef CC_HAS_LONG_LONG
1665 #define DW64_CIE_ID 0xffffffffffffffffULL
1667 #define DW64_CIE_ID ~0
1670 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1672 struct dwarf2_cie_table *cie_table,
1673 struct dwarf2_fde_table *fde_table);
1675 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1676 the next byte to be processed. */
1678 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1679 struct dwarf2_cie_table *cie_table,
1680 struct dwarf2_fde_table *fde_table)
1682 struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1683 gdb_byte *buf, *end;
1685 unsigned int bytes_read;
1688 ULONGEST cie_pointer;
1691 length = read_initial_length (unit->abfd, buf, &bytes_read);
1695 /* Are we still within the section? */
1696 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1702 /* Distinguish between 32 and 64-bit encoded frame info. */
1703 dwarf64_p = (bytes_read == 12);
1705 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1709 cie_id = DW64_CIE_ID;
1715 cie_pointer = read_8_bytes (unit->abfd, buf);
1720 cie_pointer = read_4_bytes (unit->abfd, buf);
1724 if (cie_pointer == cie_id)
1726 /* This is a CIE. */
1727 struct dwarf2_cie *cie;
1729 unsigned int cie_version;
1731 /* Record the offset into the .debug_frame section of this CIE. */
1732 cie_pointer = start - unit->dwarf_frame_buffer;
1734 /* Check whether we've already read it. */
1735 if (find_cie (cie_table, cie_pointer))
1738 cie = (struct dwarf2_cie *)
1739 obstack_alloc (&unit->objfile->objfile_obstack,
1740 sizeof (struct dwarf2_cie));
1741 cie->initial_instructions = NULL;
1742 cie->cie_pointer = cie_pointer;
1744 /* The encoding for FDE's in a normal .debug_frame section
1745 depends on the target address size. */
1746 cie->encoding = DW_EH_PE_absptr;
1748 /* We'll determine the final value later, but we need to
1749 initialize it conservatively. */
1750 cie->signal_frame = 0;
1752 /* Check version number. */
1753 cie_version = read_1_byte (unit->abfd, buf);
1754 if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1756 cie->version = cie_version;
1759 /* Interpret the interesting bits of the augmentation. */
1760 cie->augmentation = augmentation = (char *) buf;
1761 buf += (strlen (augmentation) + 1);
1763 /* Ignore armcc augmentations. We only use them for quirks,
1764 and that doesn't happen until later. */
1765 if (strncmp (augmentation, "armcc", 5) == 0)
1766 augmentation += strlen (augmentation);
1768 /* The GCC 2.x "eh" augmentation has a pointer immediately
1769 following the augmentation string, so it must be handled
1771 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1774 buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1778 if (cie->version >= 4)
1780 /* FIXME: check that this is the same as from the CU header. */
1781 cie->addr_size = read_1_byte (unit->abfd, buf);
1783 cie->segment_size = read_1_byte (unit->abfd, buf);
1788 cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1789 cie->segment_size = 0;
1791 /* Address values in .eh_frame sections are defined to have the
1792 target's pointer size. Watchout: This breaks frame info for
1793 targets with pointer size < address size, unless a .debug_frame
1794 section exists as well. */
1796 cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1798 cie->ptr_size = cie->addr_size;
1800 cie->code_alignment_factor =
1801 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1804 cie->data_alignment_factor =
1805 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1808 if (cie_version == 1)
1810 cie->return_address_register = read_1_byte (unit->abfd, buf);
1814 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1816 cie->return_address_register
1817 = dwarf2_frame_adjust_regnum (gdbarch,
1818 cie->return_address_register,
1823 cie->saw_z_augmentation = (*augmentation == 'z');
1824 if (cie->saw_z_augmentation)
1828 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1832 cie->initial_instructions = buf + length;
1836 while (*augmentation)
1838 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1839 if (*augmentation == 'L')
1846 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1847 else if (*augmentation == 'R')
1849 cie->encoding = *buf++;
1853 /* "P" indicates a personality routine in the CIE augmentation. */
1854 else if (*augmentation == 'P')
1856 /* Skip. Avoid indirection since we throw away the result. */
1857 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1858 read_encoded_value (unit, encoding, cie->ptr_size,
1859 buf, &bytes_read, 0);
1864 /* "S" indicates a signal frame, such that the return
1865 address must not be decremented to locate the call frame
1866 info for the previous frame; it might even be the first
1867 instruction of a function, so decrementing it would take
1868 us to a different function. */
1869 else if (*augmentation == 'S')
1871 cie->signal_frame = 1;
1875 /* Otherwise we have an unknown augmentation. Assume that either
1876 there is no augmentation data, or we saw a 'z' prefix. */
1879 if (cie->initial_instructions)
1880 buf = cie->initial_instructions;
1885 cie->initial_instructions = buf;
1889 add_cie (cie_table, cie);
1893 /* This is a FDE. */
1894 struct dwarf2_fde *fde;
1896 /* In an .eh_frame section, the CIE pointer is the delta between the
1897 address within the FDE where the CIE pointer is stored and the
1898 address of the CIE. Convert it to an offset into the .eh_frame
1902 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1903 cie_pointer -= (dwarf64_p ? 8 : 4);
1906 /* In either case, validate the result is still within the section. */
1907 if (cie_pointer >= unit->dwarf_frame_size)
1910 fde = (struct dwarf2_fde *)
1911 obstack_alloc (&unit->objfile->objfile_obstack,
1912 sizeof (struct dwarf2_fde));
1913 fde->cie = find_cie (cie_table, cie_pointer);
1914 if (fde->cie == NULL)
1916 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1917 eh_frame_p, cie_table, fde_table);
1918 fde->cie = find_cie (cie_table, cie_pointer);
1921 gdb_assert (fde->cie != NULL);
1923 fde->initial_location =
1924 read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
1925 buf, &bytes_read, 0);
1928 fde->address_range =
1929 read_encoded_value (unit, fde->cie->encoding & 0x0f,
1930 fde->cie->ptr_size, buf, &bytes_read, 0);
1933 /* A 'z' augmentation in the CIE implies the presence of an
1934 augmentation field in the FDE as well. The only thing known
1935 to be in here at present is the LSDA entry for EH. So we
1936 can skip the whole thing. */
1937 if (fde->cie->saw_z_augmentation)
1941 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1942 buf += bytes_read + length;
1947 fde->instructions = buf;
1950 fde->eh_frame_p = eh_frame_p;
1952 add_fde (fde_table, fde);
1958 /* Read a CIE or FDE in BUF and decode it. */
1960 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1961 struct dwarf2_cie_table *cie_table,
1962 struct dwarf2_fde_table *fde_table)
1964 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1966 ptrdiff_t start_offset;
1970 ret = decode_frame_entry_1 (unit, start, eh_frame_p,
1971 cie_table, fde_table);
1975 /* We have corrupt input data of some form. */
1977 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1978 and mismatches wrt padding and alignment of debug sections. */
1979 /* Note that there is no requirement in the standard for any
1980 alignment at all in the frame unwind sections. Testing for
1981 alignment before trying to interpret data would be incorrect.
1983 However, GCC traditionally arranged for frame sections to be
1984 sized such that the FDE length and CIE fields happen to be
1985 aligned (in theory, for performance). This, unfortunately,
1986 was done with .align directives, which had the side effect of
1987 forcing the section to be aligned by the linker.
1989 This becomes a problem when you have some other producer that
1990 creates frame sections that are not as strictly aligned. That
1991 produces a hole in the frame info that gets filled by the
1994 The GCC behaviour is arguably a bug, but it's effectively now
1995 part of the ABI, so we're now stuck with it, at least at the
1996 object file level. A smart linker may decide, in the process
1997 of compressing duplicate CIE information, that it can rewrite
1998 the entire output section without this extra padding. */
2000 start_offset = start - unit->dwarf_frame_buffer;
2001 if (workaround < ALIGN4 && (start_offset & 3) != 0)
2003 start += 4 - (start_offset & 3);
2004 workaround = ALIGN4;
2007 if (workaround < ALIGN8 && (start_offset & 7) != 0)
2009 start += 8 - (start_offset & 7);
2010 workaround = ALIGN8;
2014 /* Nothing left to try. Arrange to return as if we've consumed
2015 the entire input section. Hopefully we'll get valid info from
2016 the other of .debug_frame/.eh_frame. */
2018 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2028 complaint (&symfile_complaints,
2029 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2030 unit->dwarf_frame_section->owner->filename,
2031 unit->dwarf_frame_section->name);
2035 complaint (&symfile_complaints,
2036 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2037 unit->dwarf_frame_section->owner->filename,
2038 unit->dwarf_frame_section->name);
2042 complaint (&symfile_complaints,
2043 _("Corrupt data in %s:%s"),
2044 unit->dwarf_frame_section->owner->filename,
2045 unit->dwarf_frame_section->name);
2053 /* Imported from dwarf2read.c. */
2054 extern void dwarf2_get_section_info (struct objfile *, const char *, asection **,
2055 gdb_byte **, bfd_size_type *);
2058 qsort_fde_cmp (const void *a, const void *b)
2060 struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2061 struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2063 if (aa->initial_location == bb->initial_location)
2065 if (aa->address_range != bb->address_range
2066 && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2067 /* Linker bug, e.g. gold/10400.
2068 Work around it by keeping stable sort order. */
2069 return (a < b) ? -1 : 1;
2071 /* Put eh_frame entries after debug_frame ones. */
2072 return aa->eh_frame_p - bb->eh_frame_p;
2075 return (aa->initial_location < bb->initial_location) ? -1 : 1;
2079 dwarf2_build_frame_info (struct objfile *objfile)
2081 struct comp_unit *unit;
2082 gdb_byte *frame_ptr;
2083 struct dwarf2_cie_table cie_table;
2084 struct dwarf2_fde_table fde_table;
2085 struct dwarf2_fde_table *fde_table2;
2087 cie_table.num_entries = 0;
2088 cie_table.entries = NULL;
2090 fde_table.num_entries = 0;
2091 fde_table.entries = NULL;
2093 /* Build a minimal decoding of the DWARF2 compilation unit. */
2094 unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2095 sizeof (struct comp_unit));
2096 unit->abfd = objfile->obfd;
2097 unit->objfile = objfile;
2101 dwarf2_get_section_info (objfile, ".eh_frame",
2102 &unit->dwarf_frame_section,
2103 &unit->dwarf_frame_buffer,
2104 &unit->dwarf_frame_size);
2105 if (unit->dwarf_frame_size)
2107 asection *got, *txt;
2109 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2110 that is used for the i386/amd64 target, which currently is
2111 the only target in GCC that supports/uses the
2112 DW_EH_PE_datarel encoding. */
2113 got = bfd_get_section_by_name (unit->abfd, ".got");
2115 unit->dbase = got->vma;
2117 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2119 txt = bfd_get_section_by_name (unit->abfd, ".text");
2121 unit->tbase = txt->vma;
2123 frame_ptr = unit->dwarf_frame_buffer;
2124 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2125 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2126 &cie_table, &fde_table);
2128 if (cie_table.num_entries != 0)
2130 /* Reinit cie_table: debug_frame has different CIEs. */
2131 xfree (cie_table.entries);
2132 cie_table.num_entries = 0;
2133 cie_table.entries = NULL;
2137 dwarf2_get_section_info (objfile, ".debug_frame",
2138 &unit->dwarf_frame_section,
2139 &unit->dwarf_frame_buffer,
2140 &unit->dwarf_frame_size);
2141 if (unit->dwarf_frame_size)
2143 frame_ptr = unit->dwarf_frame_buffer;
2144 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2145 frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2146 &cie_table, &fde_table);
2149 /* Discard the cie_table, it is no longer needed. */
2150 if (cie_table.num_entries != 0)
2152 xfree (cie_table.entries);
2153 cie_table.entries = NULL; /* Paranoia. */
2154 cie_table.num_entries = 0; /* Paranoia. */
2157 /* Copy fde_table to obstack: it is needed at runtime. */
2158 fde_table2 = (struct dwarf2_fde_table *)
2159 obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2161 if (fde_table.num_entries == 0)
2163 fde_table2->entries = NULL;
2164 fde_table2->num_entries = 0;
2168 struct dwarf2_fde *fde_prev = NULL;
2169 struct dwarf2_fde *first_non_zero_fde = NULL;
2172 /* Prepare FDE table for lookups. */
2173 qsort (fde_table.entries, fde_table.num_entries,
2174 sizeof (fde_table.entries[0]), qsort_fde_cmp);
2176 /* Check for leftovers from --gc-sections. The GNU linker sets
2177 the relevant symbols to zero, but doesn't zero the FDE *end*
2178 ranges because there's no relocation there. It's (offset,
2179 length), not (start, end). On targets where address zero is
2180 just another valid address this can be a problem, since the
2181 FDEs appear to be non-empty in the output --- we could pick
2182 out the wrong FDE. To work around this, when overlaps are
2183 detected, we prefer FDEs that do not start at zero.
2185 Start by finding the first FDE with non-zero start. Below
2186 we'll discard all FDEs that start at zero and overlap this
2188 for (i = 0; i < fde_table.num_entries; i++)
2190 struct dwarf2_fde *fde = fde_table.entries[i];
2192 if (fde->initial_location != 0)
2194 first_non_zero_fde = fde;
2199 /* Since we'll be doing bsearch, squeeze out identical (except
2200 for eh_frame_p) fde entries so bsearch result is predictable.
2201 Also discard leftovers from --gc-sections. */
2202 fde_table2->num_entries = 0;
2203 for (i = 0; i < fde_table.num_entries; i++)
2205 struct dwarf2_fde *fde = fde_table.entries[i];
2207 if (fde->initial_location == 0
2208 && first_non_zero_fde != NULL
2209 && (first_non_zero_fde->initial_location
2210 < fde->initial_location + fde->address_range))
2213 if (fde_prev != NULL
2214 && fde_prev->initial_location == fde->initial_location)
2217 obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2218 sizeof (fde_table.entries[0]));
2219 ++fde_table2->num_entries;
2222 fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2224 /* Discard the original fde_table. */
2225 xfree (fde_table.entries);
2228 set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2231 /* Provide a prototype to silence -Wmissing-prototypes. */
2232 void _initialize_dwarf2_frame (void);
2235 _initialize_dwarf2_frame (void)
2237 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2238 dwarf2_frame_objfile_data = register_objfile_data ();