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 /* True if a 'z' augmentation existed. */
81 unsigned char saw_z_augmentation;
83 /* True if an 'S' augmentation existed. */
84 unsigned char signal_frame;
86 /* The version recorded in the CIE. */
87 unsigned char version;
89 /* The segment size. */
90 unsigned char segment_size;
93 struct dwarf2_cie_table
96 struct dwarf2_cie **entries;
99 /* Frame Description Entry (FDE). */
103 /* CIE for this FDE. */
104 struct dwarf2_cie *cie;
106 /* First location associated with this FDE. */
107 CORE_ADDR initial_location;
109 /* Number of bytes of program instructions described by this FDE. */
110 CORE_ADDR address_range;
112 /* Instruction sequence. */
113 gdb_byte *instructions;
116 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
118 unsigned char eh_frame_p;
121 struct dwarf2_fde_table
124 struct dwarf2_fde **entries;
127 /* A minimal decoding of DWARF2 compilation units. We only decode
128 what's needed to get to the call frame information. */
132 /* Keep the bfd convenient. */
135 struct objfile *objfile;
137 /* Pointer to the .debug_frame section loaded into memory. */
138 gdb_byte *dwarf_frame_buffer;
140 /* Length of the loaded .debug_frame section. */
141 bfd_size_type dwarf_frame_size;
143 /* Pointer to the .debug_frame section. */
144 asection *dwarf_frame_section;
146 /* Base for DW_EH_PE_datarel encodings. */
149 /* Base for DW_EH_PE_textrel encodings. */
153 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
155 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
158 static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
159 int ptr_len, const gdb_byte *buf,
160 unsigned int *bytes_read_ptr,
161 CORE_ADDR func_base);
164 /* Structure describing a frame state. */
166 struct dwarf2_frame_state
168 /* Each register save state can be described in terms of a CFA slot,
169 another register, or a location expression. */
170 struct dwarf2_frame_state_reg_info
172 struct dwarf2_frame_state_reg *reg;
182 const gdb_byte *cfa_exp;
184 /* Used to implement DW_CFA_remember_state. */
185 struct dwarf2_frame_state_reg_info *prev;
188 /* The PC described by the current frame state. */
191 /* Initial register set from the CIE.
192 Used to implement DW_CFA_restore. */
193 struct dwarf2_frame_state_reg_info initial;
195 /* The information we care about from the CIE. */
198 ULONGEST retaddr_column;
200 /* Flags for known producer quirks. */
202 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
203 and DW_CFA_def_cfa_offset takes a factored offset. */
204 int armcc_cfa_offsets_sf;
206 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
207 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
208 int armcc_cfa_offsets_reversed;
211 /* Store the length the expression for the CFA in the `cfa_reg' field,
212 which is unused in that case. */
213 #define cfa_exp_len cfa_reg
215 /* Assert that the register set RS is large enough to store gdbarch_num_regs
216 columns. If necessary, enlarge the register set. */
219 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
222 size_t size = sizeof (struct dwarf2_frame_state_reg);
224 if (num_regs <= rs->num_regs)
227 rs->reg = (struct dwarf2_frame_state_reg *)
228 xrealloc (rs->reg, num_regs * size);
230 /* Initialize newly allocated registers. */
231 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
232 rs->num_regs = num_regs;
235 /* Copy the register columns in register set RS into newly allocated
236 memory and return a pointer to this newly created copy. */
238 static struct dwarf2_frame_state_reg *
239 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
241 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
242 struct dwarf2_frame_state_reg *reg;
244 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
245 memcpy (reg, rs->reg, size);
250 /* Release the memory allocated to register set RS. */
253 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
257 dwarf2_frame_state_free_regs (rs->prev);
264 /* Release the memory allocated to the frame state FS. */
267 dwarf2_frame_state_free (void *p)
269 struct dwarf2_frame_state *fs = p;
271 dwarf2_frame_state_free_regs (fs->initial.prev);
272 dwarf2_frame_state_free_regs (fs->regs.prev);
273 xfree (fs->initial.reg);
274 xfree (fs->regs.reg);
279 /* Helper functions for execute_stack_op. */
282 read_reg (void *baton, int reg)
284 struct frame_info *this_frame = (struct frame_info *) baton;
285 struct gdbarch *gdbarch = get_frame_arch (this_frame);
289 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
291 buf = alloca (register_size (gdbarch, regnum));
292 get_frame_register (this_frame, regnum, buf);
294 /* Convert the register to an integer. This returns a LONGEST
295 rather than a CORE_ADDR, but unpack_pointer does the same thing
296 under the covers, and this makes more sense for non-pointer
297 registers. Maybe read_reg and the associated interfaces should
298 deal with "struct value" instead of CORE_ADDR. */
299 return unpack_long (register_type (gdbarch, regnum), buf);
303 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
305 read_memory (addr, buf, len);
309 no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
311 internal_error (__FILE__, __LINE__,
312 _("Support for DW_OP_fbreg is unimplemented"));
315 /* Helper function for execute_stack_op. */
318 no_get_frame_cfa (void *baton)
320 internal_error (__FILE__, __LINE__,
321 _("Support for DW_OP_call_frame_cfa is unimplemented"));
325 no_get_tls_address (void *baton, CORE_ADDR offset)
327 internal_error (__FILE__, __LINE__,
328 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
331 /* Helper function for execute_stack_op. */
334 no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
336 internal_error (__FILE__, __LINE__,
337 _("Support for DW_OP_call* is invalid in CFI"));
340 /* Execute the required actions for both the DW_CFA_restore and
341 DW_CFA_restore_extended instructions. */
343 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
344 struct dwarf2_frame_state *fs, int eh_frame_p)
348 gdb_assert (fs->initial.reg);
349 reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
350 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
352 /* Check if this register was explicitly initialized in the
353 CIE initial instructions. If not, default the rule to
355 if (reg < fs->initial.num_regs)
356 fs->regs.reg[reg] = fs->initial.reg[reg];
358 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
360 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
361 complaint (&symfile_complaints, _("\
362 incomplete CFI data; DW_CFA_restore unspecified\n\
363 register %s (#%d) at %s"),
364 gdbarch_register_name
365 (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
366 gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
367 paddress (gdbarch, fs->pc));
371 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
372 struct frame_info *this_frame, CORE_ADDR initial,
373 int initial_in_stack_memory)
375 struct dwarf_expr_context *ctx;
377 struct cleanup *old_chain;
379 ctx = new_dwarf_expr_context ();
380 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
382 ctx->gdbarch = get_frame_arch (this_frame);
383 ctx->addr_size = addr_size;
384 ctx->baton = this_frame;
385 ctx->read_reg = read_reg;
386 ctx->read_mem = read_mem;
387 ctx->get_frame_base = no_get_frame_base;
388 ctx->get_frame_cfa = no_get_frame_cfa;
389 ctx->get_tls_address = no_get_tls_address;
390 ctx->dwarf_call = no_dwarf_call;
392 dwarf_expr_push (ctx, initial, initial_in_stack_memory);
393 dwarf_expr_eval (ctx, exp, len);
394 result = dwarf_expr_fetch (ctx, 0);
396 if (ctx->location == DWARF_VALUE_REGISTER)
397 result = read_reg (this_frame, result);
398 else if (ctx->location != DWARF_VALUE_MEMORY)
400 /* This is actually invalid DWARF, but if we ever do run across
401 it somehow, we might as well support it. So, instead, report
402 it as unimplemented. */
403 error (_("Not implemented: computing unwound register using explicit value operator"));
406 do_cleanups (old_chain);
413 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
414 const gdb_byte *insn_end, struct frame_info *this_frame,
415 struct dwarf2_frame_state *fs)
417 int eh_frame_p = fde->eh_frame_p;
418 CORE_ADDR pc = get_frame_pc (this_frame);
420 struct gdbarch *gdbarch = get_frame_arch (this_frame);
421 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
423 while (insn_ptr < insn_end && fs->pc <= pc)
425 gdb_byte insn = *insn_ptr++;
429 if ((insn & 0xc0) == DW_CFA_advance_loc)
430 fs->pc += (insn & 0x3f) * fs->code_align;
431 else if ((insn & 0xc0) == DW_CFA_offset)
434 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
435 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
436 offset = utmp * fs->data_align;
437 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
438 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
439 fs->regs.reg[reg].loc.offset = offset;
441 else if ((insn & 0xc0) == DW_CFA_restore)
444 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
451 fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
452 fde->cie->addr_size, insn_ptr,
453 &bytes_read, fde->initial_location);
454 /* Apply the objfile offset for relocatable objects. */
455 fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
456 SECT_OFF_TEXT (fde->cie->unit->objfile));
457 insn_ptr += bytes_read;
460 case DW_CFA_advance_loc1:
461 utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
462 fs->pc += utmp * fs->code_align;
465 case DW_CFA_advance_loc2:
466 utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
467 fs->pc += utmp * fs->code_align;
470 case DW_CFA_advance_loc4:
471 utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
472 fs->pc += utmp * fs->code_align;
476 case DW_CFA_offset_extended:
477 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
478 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
479 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
480 offset = utmp * fs->data_align;
481 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
482 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
483 fs->regs.reg[reg].loc.offset = offset;
486 case DW_CFA_restore_extended:
487 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
488 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
491 case DW_CFA_undefined:
492 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
493 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
494 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
495 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
498 case DW_CFA_same_value:
499 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
500 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
501 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
502 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
505 case DW_CFA_register:
506 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
507 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
508 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
509 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
510 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
511 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
512 fs->regs.reg[reg].loc.reg = utmp;
515 case DW_CFA_remember_state:
517 struct dwarf2_frame_state_reg_info *new_rs;
519 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
521 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
522 fs->regs.prev = new_rs;
526 case DW_CFA_restore_state:
528 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
532 complaint (&symfile_complaints, _("\
533 bad CFI data; mismatched DW_CFA_restore_state at %s"),
534 paddress (gdbarch, fs->pc));
538 xfree (fs->regs.reg);
546 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
547 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
549 if (fs->armcc_cfa_offsets_sf)
550 utmp *= fs->data_align;
552 fs->regs.cfa_offset = utmp;
553 fs->regs.cfa_how = CFA_REG_OFFSET;
556 case DW_CFA_def_cfa_register:
557 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
558 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
561 fs->regs.cfa_how = CFA_REG_OFFSET;
564 case DW_CFA_def_cfa_offset:
565 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
567 if (fs->armcc_cfa_offsets_sf)
568 utmp *= fs->data_align;
570 fs->regs.cfa_offset = utmp;
571 /* cfa_how deliberately not set. */
577 case DW_CFA_def_cfa_expression:
578 insn_ptr = read_uleb128 (insn_ptr, insn_end,
579 &fs->regs.cfa_exp_len);
580 fs->regs.cfa_exp = insn_ptr;
581 fs->regs.cfa_how = CFA_EXP;
582 insn_ptr += fs->regs.cfa_exp_len;
585 case DW_CFA_expression:
586 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
587 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
588 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
589 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
590 fs->regs.reg[reg].loc.exp = insn_ptr;
591 fs->regs.reg[reg].exp_len = utmp;
592 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
596 case DW_CFA_offset_extended_sf:
597 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
598 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
599 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
600 offset *= fs->data_align;
601 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
602 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
603 fs->regs.reg[reg].loc.offset = offset;
606 case DW_CFA_val_offset:
607 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
608 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
609 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
610 offset = utmp * fs->data_align;
611 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
612 fs->regs.reg[reg].loc.offset = offset;
615 case DW_CFA_val_offset_sf:
616 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
617 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
618 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
619 offset *= fs->data_align;
620 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
621 fs->regs.reg[reg].loc.offset = offset;
624 case DW_CFA_val_expression:
625 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
626 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
627 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
628 fs->regs.reg[reg].loc.exp = insn_ptr;
629 fs->regs.reg[reg].exp_len = utmp;
630 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
634 case DW_CFA_def_cfa_sf:
635 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
636 fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
639 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
640 fs->regs.cfa_offset = offset * fs->data_align;
641 fs->regs.cfa_how = CFA_REG_OFFSET;
644 case DW_CFA_def_cfa_offset_sf:
645 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
646 fs->regs.cfa_offset = offset * fs->data_align;
647 /* cfa_how deliberately not set. */
650 case DW_CFA_GNU_window_save:
651 /* This is SPARC-specific code, and contains hard-coded
652 constants for the register numbering scheme used by
653 GCC. Rather than having a architecture-specific
654 operation that's only ever used by a single
655 architecture, we provide the implementation here.
656 Incidentally that's what GCC does too in its
659 int size = register_size (gdbarch, 0);
661 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
662 for (reg = 8; reg < 16; reg++)
664 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
665 fs->regs.reg[reg].loc.reg = reg + 16;
667 for (reg = 16; reg < 32; reg++)
669 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
670 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
675 case DW_CFA_GNU_args_size:
677 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
680 case DW_CFA_GNU_negative_offset_extended:
681 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
682 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
683 insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
684 offset *= fs->data_align;
685 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
686 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
687 fs->regs.reg[reg].loc.offset = -offset;
691 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
696 /* Don't allow remember/restore between CIE and FDE programs. */
697 dwarf2_frame_state_free_regs (fs->regs.prev);
698 fs->regs.prev = NULL;
702 /* Architecture-specific operations. */
704 /* Per-architecture data key. */
705 static struct gdbarch_data *dwarf2_frame_data;
707 struct dwarf2_frame_ops
709 /* Pre-initialize the register state REG for register REGNUM. */
710 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
711 struct frame_info *);
713 /* Check whether the THIS_FRAME is a signal trampoline. */
714 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
716 /* Convert .eh_frame register number to DWARF register number, or
717 adjust .debug_frame register number. */
718 int (*adjust_regnum) (struct gdbarch *, int, int);
721 /* Default architecture-specific register state initialization
725 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
726 struct dwarf2_frame_state_reg *reg,
727 struct frame_info *this_frame)
729 /* If we have a register that acts as a program counter, mark it as
730 a destination for the return address. If we have a register that
731 serves as the stack pointer, arrange for it to be filled with the
732 call frame address (CFA). The other registers are marked as
735 We copy the return address to the program counter, since many
736 parts in GDB assume that it is possible to get the return address
737 by unwinding the program counter register. However, on ISA's
738 with a dedicated return address register, the CFI usually only
739 contains information to unwind that return address register.
741 The reason we're treating the stack pointer special here is
742 because in many cases GCC doesn't emit CFI for the stack pointer
743 and implicitly assumes that it is equal to the CFA. This makes
744 some sense since the DWARF specification (version 3, draft 8,
747 "Typically, the CFA is defined to be the value of the stack
748 pointer at the call site in the previous frame (which may be
749 different from its value on entry to the current frame)."
751 However, this isn't true for all platforms supported by GCC
752 (e.g. IBM S/390 and zSeries). Those architectures should provide
753 their own architecture-specific initialization function. */
755 if (regnum == gdbarch_pc_regnum (gdbarch))
756 reg->how = DWARF2_FRAME_REG_RA;
757 else if (regnum == gdbarch_sp_regnum (gdbarch))
758 reg->how = DWARF2_FRAME_REG_CFA;
761 /* Return a default for the architecture-specific operations. */
764 dwarf2_frame_init (struct obstack *obstack)
766 struct dwarf2_frame_ops *ops;
768 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
769 ops->init_reg = dwarf2_frame_default_init_reg;
773 /* Set the architecture-specific register state initialization
774 function for GDBARCH to INIT_REG. */
777 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
778 void (*init_reg) (struct gdbarch *, int,
779 struct dwarf2_frame_state_reg *,
780 struct frame_info *))
782 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
784 ops->init_reg = init_reg;
787 /* Pre-initialize the register state REG for register REGNUM. */
790 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
791 struct dwarf2_frame_state_reg *reg,
792 struct frame_info *this_frame)
794 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
796 ops->init_reg (gdbarch, regnum, reg, this_frame);
799 /* Set the architecture-specific signal trampoline recognition
800 function for GDBARCH to SIGNAL_FRAME_P. */
803 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
804 int (*signal_frame_p) (struct gdbarch *,
805 struct frame_info *))
807 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
809 ops->signal_frame_p = signal_frame_p;
812 /* Query the architecture-specific signal frame recognizer for
816 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
817 struct frame_info *this_frame)
819 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
821 if (ops->signal_frame_p == NULL)
823 return ops->signal_frame_p (gdbarch, this_frame);
826 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
830 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
831 int (*adjust_regnum) (struct gdbarch *,
834 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
836 ops->adjust_regnum = adjust_regnum;
839 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
843 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p)
845 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
847 if (ops->adjust_regnum == NULL)
849 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
853 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
854 struct dwarf2_fde *fde)
858 s = find_pc_symtab (fs->pc);
862 if (producer_is_realview (s->producer))
864 if (fde->cie->version == 1)
865 fs->armcc_cfa_offsets_sf = 1;
867 if (fde->cie->version == 1)
868 fs->armcc_cfa_offsets_reversed = 1;
870 /* The reversed offset problem is present in some compilers
871 using DWARF3, but it was eventually fixed. Check the ARM
872 defined augmentations, which are in the format "armcc" followed
873 by a list of one-character options. The "+" option means
874 this problem is fixed (no quirk needed). If the armcc
875 augmentation is missing, the quirk is needed. */
876 if (fde->cie->version == 3
877 && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
878 || strchr (fde->cie->augmentation + 5, '+') == NULL))
879 fs->armcc_cfa_offsets_reversed = 1;
886 struct dwarf2_frame_cache
888 /* DWARF Call Frame Address. */
891 /* Set if the return address column was marked as undefined. */
892 int undefined_retaddr;
894 /* Saved registers, indexed by GDB register number, not by DWARF
896 struct dwarf2_frame_state_reg *reg;
898 /* Return address register. */
899 struct dwarf2_frame_state_reg retaddr_reg;
901 /* Target address size in bytes. */
905 static struct dwarf2_frame_cache *
906 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
908 struct cleanup *old_chain;
909 struct gdbarch *gdbarch = get_frame_arch (this_frame);
910 const int num_regs = gdbarch_num_regs (gdbarch)
911 + gdbarch_num_pseudo_regs (gdbarch);
912 struct dwarf2_frame_cache *cache;
913 struct dwarf2_frame_state *fs;
914 struct dwarf2_fde *fde;
919 /* Allocate a new cache. */
920 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
921 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
923 /* Allocate and initialize the frame state. */
924 fs = XMALLOC (struct dwarf2_frame_state);
925 memset (fs, 0, sizeof (struct dwarf2_frame_state));
926 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
930 Note that if the next frame is never supposed to return (i.e. a call
931 to abort), the compiler might optimize away the instruction at
932 its return address. As a result the return address will
933 point at some random instruction, and the CFI for that
934 instruction is probably worthless to us. GCC's unwinder solves
935 this problem by substracting 1 from the return address to get an
936 address in the middle of a presumed call instruction (or the
937 instruction in the associated delay slot). This should only be
938 done for "normal" frames and not for resume-type frames (signal
939 handlers, sentinel frames, dummy frames). The function
940 get_frame_address_in_block does just this. It's not clear how
941 reliable the method is though; there is the potential for the
942 register state pre-call being different to that on return. */
943 fs->pc = get_frame_address_in_block (this_frame);
945 /* Find the correct FDE. */
946 fde = dwarf2_frame_find_fde (&fs->pc);
947 gdb_assert (fde != NULL);
949 /* Extract any interesting information from the CIE. */
950 fs->data_align = fde->cie->data_alignment_factor;
951 fs->code_align = fde->cie->code_alignment_factor;
952 fs->retaddr_column = fde->cie->return_address_register;
953 cache->addr_size = fde->cie->addr_size;
955 /* Check for "quirks" - known bugs in producers. */
956 dwarf2_frame_find_quirks (fs, fde);
958 /* First decode all the insns in the CIE. */
959 execute_cfa_program (fde, fde->cie->initial_instructions,
960 fde->cie->end, this_frame, fs);
962 /* Save the initialized register set. */
963 fs->initial = fs->regs;
964 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
966 /* Then decode the insns in the FDE up to our target PC. */
967 execute_cfa_program (fde, fde->instructions, fde->end, this_frame, fs);
969 /* Calculate the CFA. */
970 switch (fs->regs.cfa_how)
973 cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
974 if (fs->armcc_cfa_offsets_reversed)
975 cache->cfa -= fs->regs.cfa_offset;
977 cache->cfa += fs->regs.cfa_offset;
982 execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
983 cache->addr_size, this_frame, 0, 0);
987 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
990 /* Initialize the register state. */
994 for (regnum = 0; regnum < num_regs; regnum++)
995 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
998 /* Go through the DWARF2 CFI generated table and save its register
999 location information in the cache. Note that we don't skip the
1000 return address column; it's perfectly all right for it to
1001 correspond to a real register. If it doesn't correspond to a
1002 real register, or if we shouldn't treat it as such,
1003 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1004 the range [0, gdbarch_num_regs). */
1006 int column; /* CFI speak for "register number". */
1008 for (column = 0; column < fs->regs.num_regs; column++)
1010 /* Use the GDB register number as the destination index. */
1011 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1013 /* If there's no corresponding GDB register, ignore it. */
1014 if (regnum < 0 || regnum >= num_regs)
1017 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1018 of all debug info registers. If it doesn't, complain (but
1019 not too loudly). It turns out that GCC assumes that an
1020 unspecified register implies "same value" when CFI (draft
1021 7) specifies nothing at all. Such a register could equally
1022 be interpreted as "undefined". Also note that this check
1023 isn't sufficient; it only checks that all registers in the
1024 range [0 .. max column] are specified, and won't detect
1025 problems when a debug info register falls outside of the
1026 table. We need a way of iterating through all the valid
1027 DWARF2 register numbers. */
1028 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1030 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1031 complaint (&symfile_complaints, _("\
1032 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1033 gdbarch_register_name (gdbarch, regnum),
1034 paddress (gdbarch, fs->pc));
1037 cache->reg[regnum] = fs->regs.reg[column];
1041 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1042 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1046 for (regnum = 0; regnum < num_regs; regnum++)
1048 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1049 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1051 struct dwarf2_frame_state_reg *retaddr_reg =
1052 &fs->regs.reg[fs->retaddr_column];
1054 /* It seems rather bizarre to specify an "empty" column as
1055 the return adress column. However, this is exactly
1056 what GCC does on some targets. It turns out that GCC
1057 assumes that the return address can be found in the
1058 register corresponding to the return address column.
1059 Incidentally, that's how we should treat a return
1060 address column specifying "same value" too. */
1061 if (fs->retaddr_column < fs->regs.num_regs
1062 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1063 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1065 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1066 cache->reg[regnum] = *retaddr_reg;
1068 cache->retaddr_reg = *retaddr_reg;
1072 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1074 cache->reg[regnum].loc.reg = fs->retaddr_column;
1075 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1079 cache->retaddr_reg.loc.reg = fs->retaddr_column;
1080 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1087 if (fs->retaddr_column < fs->regs.num_regs
1088 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1089 cache->undefined_retaddr = 1;
1091 do_cleanups (old_chain);
1093 *this_cache = cache;
1098 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1099 struct frame_id *this_id)
1101 struct dwarf2_frame_cache *cache =
1102 dwarf2_frame_cache (this_frame, this_cache);
1104 if (cache->undefined_retaddr)
1107 (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1110 static struct value *
1111 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1114 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1115 struct dwarf2_frame_cache *cache =
1116 dwarf2_frame_cache (this_frame, this_cache);
1120 switch (cache->reg[regnum].how)
1122 case DWARF2_FRAME_REG_UNDEFINED:
1123 /* If CFI explicitly specified that the value isn't defined,
1124 mark it as optimized away; the value isn't available. */
1125 return frame_unwind_got_optimized (this_frame, regnum);
1127 case DWARF2_FRAME_REG_SAVED_OFFSET:
1128 addr = cache->cfa + cache->reg[regnum].loc.offset;
1129 return frame_unwind_got_memory (this_frame, regnum, addr);
1131 case DWARF2_FRAME_REG_SAVED_REG:
1133 = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1134 return frame_unwind_got_register (this_frame, regnum, realnum);
1136 case DWARF2_FRAME_REG_SAVED_EXP:
1137 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1138 cache->reg[regnum].exp_len,
1139 cache->addr_size, this_frame, cache->cfa, 1);
1140 return frame_unwind_got_memory (this_frame, regnum, addr);
1142 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1143 addr = cache->cfa + cache->reg[regnum].loc.offset;
1144 return frame_unwind_got_constant (this_frame, regnum, addr);
1146 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1147 addr = execute_stack_op (cache->reg[regnum].loc.exp,
1148 cache->reg[regnum].exp_len,
1149 cache->addr_size, this_frame, cache->cfa, 1);
1150 return frame_unwind_got_constant (this_frame, regnum, addr);
1152 case DWARF2_FRAME_REG_UNSPECIFIED:
1153 /* GCC, in its infinite wisdom decided to not provide unwind
1154 information for registers that are "same value". Since
1155 DWARF2 (3 draft 7) doesn't define such behavior, said
1156 registers are actually undefined (which is different to CFI
1157 "undefined"). Code above issues a complaint about this.
1158 Here just fudge the books, assume GCC, and that the value is
1159 more inner on the stack. */
1160 return frame_unwind_got_register (this_frame, regnum, regnum);
1162 case DWARF2_FRAME_REG_SAME_VALUE:
1163 return frame_unwind_got_register (this_frame, regnum, regnum);
1165 case DWARF2_FRAME_REG_CFA:
1166 return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1168 case DWARF2_FRAME_REG_CFA_OFFSET:
1169 addr = cache->cfa + cache->reg[regnum].loc.offset;
1170 return frame_unwind_got_address (this_frame, regnum, addr);
1172 case DWARF2_FRAME_REG_RA_OFFSET:
1173 addr = cache->reg[regnum].loc.offset;
1174 regnum = gdbarch_dwarf2_reg_to_regnum
1175 (gdbarch, cache->retaddr_reg.loc.reg);
1176 addr += get_frame_register_unsigned (this_frame, regnum);
1177 return frame_unwind_got_address (this_frame, regnum, addr);
1179 case DWARF2_FRAME_REG_FN:
1180 return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1183 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1188 dwarf2_frame_sniffer (const struct frame_unwind *self,
1189 struct frame_info *this_frame, void **this_cache)
1191 /* Grab an address that is guarenteed to reside somewhere within the
1192 function. get_frame_pc(), with a no-return next function, can
1193 end up returning something past the end of this function's body.
1194 If the frame we're sniffing for is a signal frame whose start
1195 address is placed on the stack by the OS, its FDE must
1196 extend one byte before its start address or we could potentially
1197 select the FDE of the previous function. */
1198 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1199 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1204 /* On some targets, signal trampolines may have unwind information.
1205 We need to recognize them so that we set the frame type
1208 if (fde->cie->signal_frame
1209 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1211 return self->type == SIGTRAMP_FRAME;
1213 return self->type != SIGTRAMP_FRAME;
1216 static const struct frame_unwind dwarf2_frame_unwind =
1219 dwarf2_frame_this_id,
1220 dwarf2_frame_prev_register,
1222 dwarf2_frame_sniffer
1225 static const struct frame_unwind dwarf2_signal_frame_unwind =
1228 dwarf2_frame_this_id,
1229 dwarf2_frame_prev_register,
1231 dwarf2_frame_sniffer
1234 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1237 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1239 frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1240 frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1244 /* There is no explicitly defined relationship between the CFA and the
1245 location of frame's local variables and arguments/parameters.
1246 Therefore, frame base methods on this page should probably only be
1247 used as a last resort, just to avoid printing total garbage as a
1248 response to the "info frame" command. */
1251 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1253 struct dwarf2_frame_cache *cache =
1254 dwarf2_frame_cache (this_frame, this_cache);
1259 static const struct frame_base dwarf2_frame_base =
1261 &dwarf2_frame_unwind,
1262 dwarf2_frame_base_address,
1263 dwarf2_frame_base_address,
1264 dwarf2_frame_base_address
1267 const struct frame_base *
1268 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1270 CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1272 if (dwarf2_frame_find_fde (&block_addr))
1273 return &dwarf2_frame_base;
1278 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1279 the DWARF unwinder. This is used to implement
1280 DW_OP_call_frame_cfa. */
1283 dwarf2_frame_cfa (struct frame_info *this_frame)
1285 while (get_frame_type (this_frame) == INLINE_FRAME)
1286 this_frame = get_prev_frame (this_frame);
1287 /* This restriction could be lifted if other unwinders are known to
1288 compute the frame base in a way compatible with the DWARF
1290 if (! frame_unwinder_is (this_frame, &dwarf2_frame_unwind))
1291 error (_("can't compute CFA for this frame"));
1292 return get_frame_base (this_frame);
1295 const struct objfile_data *dwarf2_frame_objfile_data;
1298 read_1_byte (bfd *abfd, gdb_byte *buf)
1300 return bfd_get_8 (abfd, buf);
1304 read_4_bytes (bfd *abfd, gdb_byte *buf)
1306 return bfd_get_32 (abfd, buf);
1310 read_8_bytes (bfd *abfd, gdb_byte *buf)
1312 return bfd_get_64 (abfd, buf);
1316 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1319 unsigned int num_read;
1329 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1332 result |= ((byte & 0x7f) << shift);
1335 while (byte & 0x80);
1337 *bytes_read_ptr = num_read;
1343 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1347 unsigned int num_read;
1356 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1359 result |= ((byte & 0x7f) << shift);
1362 while (byte & 0x80);
1364 if (shift < 8 * sizeof (result) && (byte & 0x40))
1365 result |= -(((LONGEST)1) << shift);
1367 *bytes_read_ptr = num_read;
1373 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1377 result = bfd_get_32 (abfd, buf);
1378 if (result == 0xffffffff)
1380 result = bfd_get_64 (abfd, buf + 4);
1381 *bytes_read_ptr = 12;
1384 *bytes_read_ptr = 4;
1390 /* Pointer encoding helper functions. */
1392 /* GCC supports exception handling based on DWARF2 CFI. However, for
1393 technical reasons, it encodes addresses in its FDE's in a different
1394 way. Several "pointer encodings" are supported. The encoding
1395 that's used for a particular FDE is determined by the 'R'
1396 augmentation in the associated CIE. The argument of this
1397 augmentation is a single byte.
1399 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1400 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1401 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1402 address should be interpreted (absolute, relative to the current
1403 position in the FDE, ...). Bit 7, indicates that the address
1404 should be dereferenced. */
1407 encoding_for_size (unsigned int size)
1412 return DW_EH_PE_udata2;
1414 return DW_EH_PE_udata4;
1416 return DW_EH_PE_udata8;
1418 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1423 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1424 int ptr_len, const gdb_byte *buf,
1425 unsigned int *bytes_read_ptr,
1426 CORE_ADDR func_base)
1431 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1433 if (encoding & DW_EH_PE_indirect)
1434 internal_error (__FILE__, __LINE__,
1435 _("Unsupported encoding: DW_EH_PE_indirect"));
1437 *bytes_read_ptr = 0;
1439 switch (encoding & 0x70)
1441 case DW_EH_PE_absptr:
1444 case DW_EH_PE_pcrel:
1445 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1446 base += (buf - unit->dwarf_frame_buffer);
1448 case DW_EH_PE_datarel:
1451 case DW_EH_PE_textrel:
1454 case DW_EH_PE_funcrel:
1457 case DW_EH_PE_aligned:
1459 offset = buf - unit->dwarf_frame_buffer;
1460 if ((offset % ptr_len) != 0)
1462 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1463 buf += *bytes_read_ptr;
1467 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1470 if ((encoding & 0x07) == 0x00)
1472 encoding |= encoding_for_size (ptr_len);
1473 if (bfd_get_sign_extend_vma (unit->abfd))
1474 encoding |= DW_EH_PE_signed;
1477 switch (encoding & 0x0f)
1479 case DW_EH_PE_uleb128:
1482 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1484 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1485 return base + value;
1487 case DW_EH_PE_udata2:
1488 *bytes_read_ptr += 2;
1489 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1490 case DW_EH_PE_udata4:
1491 *bytes_read_ptr += 4;
1492 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1493 case DW_EH_PE_udata8:
1494 *bytes_read_ptr += 8;
1495 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1496 case DW_EH_PE_sleb128:
1499 const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1501 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1502 return base + value;
1504 case DW_EH_PE_sdata2:
1505 *bytes_read_ptr += 2;
1506 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1507 case DW_EH_PE_sdata4:
1508 *bytes_read_ptr += 4;
1509 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1510 case DW_EH_PE_sdata8:
1511 *bytes_read_ptr += 8;
1512 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1514 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1520 bsearch_cie_cmp (const void *key, const void *element)
1522 ULONGEST cie_pointer = *(ULONGEST *) key;
1523 struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1525 if (cie_pointer == cie->cie_pointer)
1528 return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1531 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1532 static struct dwarf2_cie *
1533 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1535 struct dwarf2_cie **p_cie;
1537 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1538 bsearch be non-NULL. */
1539 if (cie_table->entries == NULL)
1541 gdb_assert (cie_table->num_entries == 0);
1545 p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1546 sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1552 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1554 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1556 const int n = cie_table->num_entries;
1559 || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1561 cie_table->entries =
1562 xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1563 cie_table->entries[n] = cie;
1564 cie_table->num_entries = n + 1;
1568 bsearch_fde_cmp (const void *key, const void *element)
1570 CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1571 struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1573 if (seek_pc < fde->initial_location)
1575 if (seek_pc < fde->initial_location + fde->address_range)
1580 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1581 inital location associated with it into *PC. */
1583 static struct dwarf2_fde *
1584 dwarf2_frame_find_fde (CORE_ADDR *pc)
1586 struct objfile *objfile;
1588 ALL_OBJFILES (objfile)
1590 struct dwarf2_fde_table *fde_table;
1591 struct dwarf2_fde **p_fde;
1595 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1596 if (fde_table == NULL)
1598 dwarf2_build_frame_info (objfile);
1599 fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1601 gdb_assert (fde_table != NULL);
1603 if (fde_table->num_entries == 0)
1606 gdb_assert (objfile->section_offsets);
1607 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1609 gdb_assert (fde_table->num_entries > 0);
1610 if (*pc < offset + fde_table->entries[0]->initial_location)
1613 seek_pc = *pc - offset;
1614 p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1615 sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1618 *pc = (*p_fde)->initial_location + offset;
1625 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1627 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1629 if (fde->address_range == 0)
1630 /* Discard useless FDEs. */
1633 fde_table->num_entries += 1;
1634 fde_table->entries =
1635 xrealloc (fde_table->entries,
1636 fde_table->num_entries * sizeof (fde_table->entries[0]));
1637 fde_table->entries[fde_table->num_entries - 1] = fde;
1640 #ifdef CC_HAS_LONG_LONG
1641 #define DW64_CIE_ID 0xffffffffffffffffULL
1643 #define DW64_CIE_ID ~0
1646 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1648 struct dwarf2_cie_table *cie_table,
1649 struct dwarf2_fde_table *fde_table);
1651 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1652 the next byte to be processed. */
1654 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1655 struct dwarf2_cie_table *cie_table,
1656 struct dwarf2_fde_table *fde_table)
1658 struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1659 gdb_byte *buf, *end;
1661 unsigned int bytes_read;
1664 ULONGEST cie_pointer;
1667 length = read_initial_length (unit->abfd, buf, &bytes_read);
1671 /* Are we still within the section? */
1672 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1678 /* Distinguish between 32 and 64-bit encoded frame info. */
1679 dwarf64_p = (bytes_read == 12);
1681 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1685 cie_id = DW64_CIE_ID;
1691 cie_pointer = read_8_bytes (unit->abfd, buf);
1696 cie_pointer = read_4_bytes (unit->abfd, buf);
1700 if (cie_pointer == cie_id)
1702 /* This is a CIE. */
1703 struct dwarf2_cie *cie;
1705 unsigned int cie_version;
1707 /* Record the offset into the .debug_frame section of this CIE. */
1708 cie_pointer = start - unit->dwarf_frame_buffer;
1710 /* Check whether we've already read it. */
1711 if (find_cie (cie_table, cie_pointer))
1714 cie = (struct dwarf2_cie *)
1715 obstack_alloc (&unit->objfile->objfile_obstack,
1716 sizeof (struct dwarf2_cie));
1717 cie->initial_instructions = NULL;
1718 cie->cie_pointer = cie_pointer;
1720 /* The encoding for FDE's in a normal .debug_frame section
1721 depends on the target address size. */
1722 cie->encoding = DW_EH_PE_absptr;
1724 /* The target address size. For .eh_frame FDEs this is considered
1725 equal to the size of a target pointer. For .dwarf_frame FDEs,
1726 this is supposed to be the target address size from the associated
1727 CU header. FIXME: We do not have a good way to determine the
1728 latter. Always use the target pointer size for now. */
1729 cie->addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1731 /* We'll determine the final value later, but we need to
1732 initialize it conservatively. */
1733 cie->signal_frame = 0;
1735 /* Check version number. */
1736 cie_version = read_1_byte (unit->abfd, buf);
1737 if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1739 cie->version = cie_version;
1742 /* Interpret the interesting bits of the augmentation. */
1743 cie->augmentation = augmentation = (char *) buf;
1744 buf += (strlen (augmentation) + 1);
1746 /* Ignore armcc augmentations. We only use them for quirks,
1747 and that doesn't happen until later. */
1748 if (strncmp (augmentation, "armcc", 5) == 0)
1749 augmentation += strlen (augmentation);
1751 /* The GCC 2.x "eh" augmentation has a pointer immediately
1752 following the augmentation string, so it must be handled
1754 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1757 buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1761 if (cie->version >= 4)
1763 /* FIXME: check that this is the same as from the CU header. */
1764 cie->addr_size = read_1_byte (unit->abfd, buf);
1766 cie->segment_size = read_1_byte (unit->abfd, buf);
1771 cie->addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1772 cie->segment_size = 0;
1775 cie->code_alignment_factor =
1776 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1779 cie->data_alignment_factor =
1780 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1783 if (cie_version == 1)
1785 cie->return_address_register = read_1_byte (unit->abfd, buf);
1789 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1791 cie->return_address_register
1792 = dwarf2_frame_adjust_regnum (gdbarch,
1793 cie->return_address_register,
1798 cie->saw_z_augmentation = (*augmentation == 'z');
1799 if (cie->saw_z_augmentation)
1803 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1807 cie->initial_instructions = buf + length;
1811 while (*augmentation)
1813 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1814 if (*augmentation == 'L')
1821 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1822 else if (*augmentation == 'R')
1824 cie->encoding = *buf++;
1828 /* "P" indicates a personality routine in the CIE augmentation. */
1829 else if (*augmentation == 'P')
1831 /* Skip. Avoid indirection since we throw away the result. */
1832 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1833 read_encoded_value (unit, encoding, cie->addr_size,
1834 buf, &bytes_read, 0);
1839 /* "S" indicates a signal frame, such that the return
1840 address must not be decremented to locate the call frame
1841 info for the previous frame; it might even be the first
1842 instruction of a function, so decrementing it would take
1843 us to a different function. */
1844 else if (*augmentation == 'S')
1846 cie->signal_frame = 1;
1850 /* Otherwise we have an unknown augmentation. Assume that either
1851 there is no augmentation data, or we saw a 'z' prefix. */
1854 if (cie->initial_instructions)
1855 buf = cie->initial_instructions;
1860 cie->initial_instructions = buf;
1864 add_cie (cie_table, cie);
1868 /* This is a FDE. */
1869 struct dwarf2_fde *fde;
1871 /* In an .eh_frame section, the CIE pointer is the delta between the
1872 address within the FDE where the CIE pointer is stored and the
1873 address of the CIE. Convert it to an offset into the .eh_frame
1877 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1878 cie_pointer -= (dwarf64_p ? 8 : 4);
1881 /* In either case, validate the result is still within the section. */
1882 if (cie_pointer >= unit->dwarf_frame_size)
1885 fde = (struct dwarf2_fde *)
1886 obstack_alloc (&unit->objfile->objfile_obstack,
1887 sizeof (struct dwarf2_fde));
1888 fde->cie = find_cie (cie_table, cie_pointer);
1889 if (fde->cie == NULL)
1891 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1892 eh_frame_p, cie_table, fde_table);
1893 fde->cie = find_cie (cie_table, cie_pointer);
1896 gdb_assert (fde->cie != NULL);
1898 fde->initial_location =
1899 read_encoded_value (unit, fde->cie->encoding, fde->cie->addr_size,
1900 buf, &bytes_read, 0);
1903 fde->address_range =
1904 read_encoded_value (unit, fde->cie->encoding & 0x0f,
1905 fde->cie->addr_size, buf, &bytes_read, 0);
1908 /* A 'z' augmentation in the CIE implies the presence of an
1909 augmentation field in the FDE as well. The only thing known
1910 to be in here at present is the LSDA entry for EH. So we
1911 can skip the whole thing. */
1912 if (fde->cie->saw_z_augmentation)
1916 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1917 buf += bytes_read + length;
1922 fde->instructions = buf;
1925 fde->eh_frame_p = eh_frame_p;
1927 add_fde (fde_table, fde);
1933 /* Read a CIE or FDE in BUF and decode it. */
1935 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1936 struct dwarf2_cie_table *cie_table,
1937 struct dwarf2_fde_table *fde_table)
1939 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1941 ptrdiff_t start_offset;
1945 ret = decode_frame_entry_1 (unit, start, eh_frame_p,
1946 cie_table, fde_table);
1950 /* We have corrupt input data of some form. */
1952 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1953 and mismatches wrt padding and alignment of debug sections. */
1954 /* Note that there is no requirement in the standard for any
1955 alignment at all in the frame unwind sections. Testing for
1956 alignment before trying to interpret data would be incorrect.
1958 However, GCC traditionally arranged for frame sections to be
1959 sized such that the FDE length and CIE fields happen to be
1960 aligned (in theory, for performance). This, unfortunately,
1961 was done with .align directives, which had the side effect of
1962 forcing the section to be aligned by the linker.
1964 This becomes a problem when you have some other producer that
1965 creates frame sections that are not as strictly aligned. That
1966 produces a hole in the frame info that gets filled by the
1969 The GCC behaviour is arguably a bug, but it's effectively now
1970 part of the ABI, so we're now stuck with it, at least at the
1971 object file level. A smart linker may decide, in the process
1972 of compressing duplicate CIE information, that it can rewrite
1973 the entire output section without this extra padding. */
1975 start_offset = start - unit->dwarf_frame_buffer;
1976 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1978 start += 4 - (start_offset & 3);
1979 workaround = ALIGN4;
1982 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1984 start += 8 - (start_offset & 7);
1985 workaround = ALIGN8;
1989 /* Nothing left to try. Arrange to return as if we've consumed
1990 the entire input section. Hopefully we'll get valid info from
1991 the other of .debug_frame/.eh_frame. */
1993 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2003 complaint (&symfile_complaints,
2004 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2005 unit->dwarf_frame_section->owner->filename,
2006 unit->dwarf_frame_section->name);
2010 complaint (&symfile_complaints,
2011 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2012 unit->dwarf_frame_section->owner->filename,
2013 unit->dwarf_frame_section->name);
2017 complaint (&symfile_complaints,
2018 _("Corrupt data in %s:%s"),
2019 unit->dwarf_frame_section->owner->filename,
2020 unit->dwarf_frame_section->name);
2028 /* Imported from dwarf2read.c. */
2029 extern void dwarf2_get_section_info (struct objfile *, const char *, asection **,
2030 gdb_byte **, bfd_size_type *);
2033 qsort_fde_cmp (const void *a, const void *b)
2035 struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2036 struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2038 if (aa->initial_location == bb->initial_location)
2040 if (aa->address_range != bb->address_range
2041 && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2042 /* Linker bug, e.g. gold/10400.
2043 Work around it by keeping stable sort order. */
2044 return (a < b) ? -1 : 1;
2046 /* Put eh_frame entries after debug_frame ones. */
2047 return aa->eh_frame_p - bb->eh_frame_p;
2050 return (aa->initial_location < bb->initial_location) ? -1 : 1;
2054 dwarf2_build_frame_info (struct objfile *objfile)
2056 struct comp_unit *unit;
2057 gdb_byte *frame_ptr;
2058 struct dwarf2_cie_table cie_table;
2059 struct dwarf2_fde_table fde_table;
2060 struct dwarf2_fde_table *fde_table2;
2062 cie_table.num_entries = 0;
2063 cie_table.entries = NULL;
2065 fde_table.num_entries = 0;
2066 fde_table.entries = NULL;
2068 /* Build a minimal decoding of the DWARF2 compilation unit. */
2069 unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2070 sizeof (struct comp_unit));
2071 unit->abfd = objfile->obfd;
2072 unit->objfile = objfile;
2076 dwarf2_get_section_info (objfile, ".eh_frame",
2077 &unit->dwarf_frame_section,
2078 &unit->dwarf_frame_buffer,
2079 &unit->dwarf_frame_size);
2080 if (unit->dwarf_frame_size)
2082 asection *got, *txt;
2084 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2085 that is used for the i386/amd64 target, which currently is
2086 the only target in GCC that supports/uses the
2087 DW_EH_PE_datarel encoding. */
2088 got = bfd_get_section_by_name (unit->abfd, ".got");
2090 unit->dbase = got->vma;
2092 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2094 txt = bfd_get_section_by_name (unit->abfd, ".text");
2096 unit->tbase = txt->vma;
2098 frame_ptr = unit->dwarf_frame_buffer;
2099 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2100 frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2101 &cie_table, &fde_table);
2103 if (cie_table.num_entries != 0)
2105 /* Reinit cie_table: debug_frame has different CIEs. */
2106 xfree (cie_table.entries);
2107 cie_table.num_entries = 0;
2108 cie_table.entries = NULL;
2112 dwarf2_get_section_info (objfile, ".debug_frame",
2113 &unit->dwarf_frame_section,
2114 &unit->dwarf_frame_buffer,
2115 &unit->dwarf_frame_size);
2116 if (unit->dwarf_frame_size)
2118 frame_ptr = unit->dwarf_frame_buffer;
2119 while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2120 frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2121 &cie_table, &fde_table);
2124 /* Discard the cie_table, it is no longer needed. */
2125 if (cie_table.num_entries != 0)
2127 xfree (cie_table.entries);
2128 cie_table.entries = NULL; /* Paranoia. */
2129 cie_table.num_entries = 0; /* Paranoia. */
2132 /* Copy fde_table to obstack: it is needed at runtime. */
2133 fde_table2 = (struct dwarf2_fde_table *)
2134 obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2136 if (fde_table.num_entries == 0)
2138 fde_table2->entries = NULL;
2139 fde_table2->num_entries = 0;
2143 struct dwarf2_fde *fde_prev = NULL;
2144 struct dwarf2_fde *first_non_zero_fde = NULL;
2147 /* Prepare FDE table for lookups. */
2148 qsort (fde_table.entries, fde_table.num_entries,
2149 sizeof (fde_table.entries[0]), qsort_fde_cmp);
2151 /* Check for leftovers from --gc-sections. The GNU linker sets
2152 the relevant symbols to zero, but doesn't zero the FDE *end*
2153 ranges because there's no relocation there. It's (offset,
2154 length), not (start, end). On targets where address zero is
2155 just another valid address this can be a problem, since the
2156 FDEs appear to be non-empty in the output --- we could pick
2157 out the wrong FDE. To work around this, when overlaps are
2158 detected, we prefer FDEs that do not start at zero.
2160 Start by finding the first FDE with non-zero start. Below
2161 we'll discard all FDEs that start at zero and overlap this
2163 for (i = 0; i < fde_table.num_entries; i++)
2165 struct dwarf2_fde *fde = fde_table.entries[i];
2167 if (fde->initial_location != 0)
2169 first_non_zero_fde = fde;
2174 /* Since we'll be doing bsearch, squeeze out identical (except
2175 for eh_frame_p) fde entries so bsearch result is predictable.
2176 Also discard leftovers from --gc-sections. */
2177 fde_table2->num_entries = 0;
2178 for (i = 0; i < fde_table.num_entries; i++)
2180 struct dwarf2_fde *fde = fde_table.entries[i];
2182 if (fde->initial_location == 0
2183 && first_non_zero_fde != NULL
2184 && (first_non_zero_fde->initial_location
2185 < fde->initial_location + fde->address_range))
2188 if (fde_prev != NULL
2189 && fde_prev->initial_location == fde->initial_location)
2192 obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2193 sizeof (fde_table.entries[0]));
2194 ++fde_table2->num_entries;
2197 fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2199 /* Discard the original fde_table. */
2200 xfree (fde_table.entries);
2203 set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2206 /* Provide a prototype to silence -Wmissing-prototypes. */
2207 void _initialize_dwarf2_frame (void);
2210 _initialize_dwarf2_frame (void)
2212 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2213 dwarf2_frame_objfile_data = register_objfile_data ();