1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
5 Contributed by Mark Kettenis.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
37 #include "gdb_assert.h"
38 #include "gdb_string.h"
40 #include "complaints.h"
41 #include "dwarf2-frame.h"
43 /* Call Frame Information (CFI). */
45 /* Common Information Entry (CIE). */
49 /* Offset into the .debug_frame section where this CIE was found.
50 Used to identify this CIE. */
53 /* Constant that is factored out of all advance location
55 ULONGEST code_alignment_factor;
57 /* Constants that is factored out of all offset instructions. */
58 LONGEST data_alignment_factor;
60 /* Return address column. */
61 ULONGEST return_address_register;
63 /* Instruction sequence to initialize a register set. */
64 gdb_byte *initial_instructions;
67 /* Encoding of addresses. */
70 /* True if a 'z' augmentation existed. */
71 unsigned char saw_z_augmentation;
73 /* True if an 'S' augmentation existed. */
74 unsigned char signal_frame;
76 struct dwarf2_cie *next;
79 /* Frame Description Entry (FDE). */
83 /* CIE for this FDE. */
84 struct dwarf2_cie *cie;
86 /* First location associated with this FDE. */
87 CORE_ADDR initial_location;
89 /* Number of bytes of program instructions described by this FDE. */
90 CORE_ADDR address_range;
92 /* Instruction sequence. */
93 gdb_byte *instructions;
96 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
98 unsigned char eh_frame_p;
100 struct dwarf2_fde *next;
103 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
106 /* Structure describing a frame state. */
108 struct dwarf2_frame_state
110 /* Each register save state can be described in terms of a CFA slot,
111 another register, or a location expression. */
112 struct dwarf2_frame_state_reg_info
114 struct dwarf2_frame_state_reg *reg;
117 /* Used to implement DW_CFA_remember_state. */
118 struct dwarf2_frame_state_reg_info *prev;
130 /* The PC described by the current frame state. */
133 /* Initial register set from the CIE.
134 Used to implement DW_CFA_restore. */
135 struct dwarf2_frame_state_reg_info initial;
137 /* The information we care about from the CIE. */
140 ULONGEST retaddr_column;
143 /* Store the length the expression for the CFA in the `cfa_reg' field,
144 which is unused in that case. */
145 #define cfa_exp_len cfa_reg
147 /* Assert that the register set RS is large enough to store NUM_REGS
148 columns. If necessary, enlarge the register set. */
151 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
154 size_t size = sizeof (struct dwarf2_frame_state_reg);
156 if (num_regs <= rs->num_regs)
159 rs->reg = (struct dwarf2_frame_state_reg *)
160 xrealloc (rs->reg, num_regs * size);
162 /* Initialize newly allocated registers. */
163 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
164 rs->num_regs = num_regs;
167 /* Copy the register columns in register set RS into newly allocated
168 memory and return a pointer to this newly created copy. */
170 static struct dwarf2_frame_state_reg *
171 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
173 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
174 struct dwarf2_frame_state_reg *reg;
176 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
177 memcpy (reg, rs->reg, size);
182 /* Release the memory allocated to register set RS. */
185 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
189 dwarf2_frame_state_free_regs (rs->prev);
196 /* Release the memory allocated to the frame state FS. */
199 dwarf2_frame_state_free (void *p)
201 struct dwarf2_frame_state *fs = p;
203 dwarf2_frame_state_free_regs (fs->initial.prev);
204 dwarf2_frame_state_free_regs (fs->regs.prev);
205 xfree (fs->initial.reg);
206 xfree (fs->regs.reg);
211 /* Helper functions for execute_stack_op. */
214 read_reg (void *baton, int reg)
216 struct frame_info *next_frame = (struct frame_info *) baton;
217 struct gdbarch *gdbarch = get_frame_arch (next_frame);
221 regnum = DWARF2_REG_TO_REGNUM (reg);
223 buf = alloca (register_size (gdbarch, regnum));
224 frame_unwind_register (next_frame, regnum, buf);
226 /* Convert the register to an integer. This returns a LONGEST
227 rather than a CORE_ADDR, but unpack_pointer does the same thing
228 under the covers, and this makes more sense for non-pointer
229 registers. Maybe read_reg and the associated interfaces should
230 deal with "struct value" instead of CORE_ADDR. */
231 return unpack_long (register_type (gdbarch, regnum), buf);
235 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
237 read_memory (addr, buf, len);
241 no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
243 internal_error (__FILE__, __LINE__,
244 _("Support for DW_OP_fbreg is unimplemented"));
248 no_get_tls_address (void *baton, CORE_ADDR offset)
250 internal_error (__FILE__, __LINE__,
251 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
255 execute_stack_op (gdb_byte *exp, ULONGEST len,
256 struct frame_info *next_frame, CORE_ADDR initial)
258 struct dwarf_expr_context *ctx;
261 ctx = new_dwarf_expr_context ();
262 ctx->baton = next_frame;
263 ctx->read_reg = read_reg;
264 ctx->read_mem = read_mem;
265 ctx->get_frame_base = no_get_frame_base;
266 ctx->get_tls_address = no_get_tls_address;
268 dwarf_expr_push (ctx, initial);
269 dwarf_expr_eval (ctx, exp, len);
270 result = dwarf_expr_fetch (ctx, 0);
273 result = read_reg (next_frame, result);
275 free_dwarf_expr_context (ctx);
282 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
283 struct frame_info *next_frame,
284 struct dwarf2_frame_state *fs, int eh_frame_p)
286 CORE_ADDR pc = frame_pc_unwind (next_frame);
288 struct gdbarch *gdbarch = get_frame_arch (next_frame);
290 while (insn_ptr < insn_end && fs->pc <= pc)
292 gdb_byte insn = *insn_ptr++;
296 if ((insn & 0xc0) == DW_CFA_advance_loc)
297 fs->pc += (insn & 0x3f) * fs->code_align;
298 else if ((insn & 0xc0) == DW_CFA_offset)
302 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
303 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
304 offset = utmp * fs->data_align;
305 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
306 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
307 fs->regs.reg[reg].loc.offset = offset;
309 else if ((insn & 0xc0) == DW_CFA_restore)
311 gdb_assert (fs->initial.reg);
314 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
315 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
316 if (reg < fs->initial.num_regs)
317 fs->regs.reg[reg] = fs->initial.reg[reg];
319 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
321 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
322 complaint (&symfile_complaints, _("\
323 incomplete CFI data; DW_CFA_restore unspecified\n\
324 register %s (#%d) at 0x%s"),
325 REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
326 DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
333 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
334 insn_ptr += bytes_read;
337 case DW_CFA_advance_loc1:
338 utmp = extract_unsigned_integer (insn_ptr, 1);
339 fs->pc += utmp * fs->code_align;
342 case DW_CFA_advance_loc2:
343 utmp = extract_unsigned_integer (insn_ptr, 2);
344 fs->pc += utmp * fs->code_align;
347 case DW_CFA_advance_loc4:
348 utmp = extract_unsigned_integer (insn_ptr, 4);
349 fs->pc += utmp * fs->code_align;
353 case DW_CFA_offset_extended:
354 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
356 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
357 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
358 offset = utmp * fs->data_align;
359 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
360 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
361 fs->regs.reg[reg].loc.offset = offset;
364 case DW_CFA_restore_extended:
365 gdb_assert (fs->initial.reg);
366 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
368 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
369 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
370 fs->regs.reg[reg] = fs->initial.reg[reg];
373 case DW_CFA_undefined:
374 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
376 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
377 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
378 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
381 case DW_CFA_same_value:
382 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
384 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
385 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
386 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
389 case DW_CFA_register:
390 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
392 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
393 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
395 utmp = dwarf2_frame_eh_frame_regnum (gdbarch, utmp);
396 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
397 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
398 fs->regs.reg[reg].loc.reg = utmp;
401 case DW_CFA_remember_state:
403 struct dwarf2_frame_state_reg_info *new_rs;
405 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
407 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
408 fs->regs.prev = new_rs;
412 case DW_CFA_restore_state:
414 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
418 complaint (&symfile_complaints, _("\
419 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
423 xfree (fs->regs.reg);
431 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
432 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
433 fs->cfa_offset = utmp;
434 fs->cfa_how = CFA_REG_OFFSET;
437 case DW_CFA_def_cfa_register:
438 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
440 fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
442 fs->cfa_how = CFA_REG_OFFSET;
445 case DW_CFA_def_cfa_offset:
446 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
447 fs->cfa_offset = utmp;
448 /* cfa_how deliberately not set. */
454 case DW_CFA_def_cfa_expression:
455 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
456 fs->cfa_exp = insn_ptr;
457 fs->cfa_how = CFA_EXP;
458 insn_ptr += fs->cfa_exp_len;
461 case DW_CFA_expression:
462 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
464 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
465 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
466 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
467 fs->regs.reg[reg].loc.exp = insn_ptr;
468 fs->regs.reg[reg].exp_len = utmp;
469 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
473 case DW_CFA_offset_extended_sf:
474 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
476 reg = dwarf2_frame_eh_frame_regnum (gdbarch, reg);
477 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
478 offset *= fs->data_align;
479 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
480 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
481 fs->regs.reg[reg].loc.offset = offset;
484 case DW_CFA_def_cfa_sf:
485 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
487 fs->cfa_reg = dwarf2_frame_eh_frame_regnum (gdbarch,
489 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
490 fs->cfa_offset = offset * fs->data_align;
491 fs->cfa_how = CFA_REG_OFFSET;
494 case DW_CFA_def_cfa_offset_sf:
495 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
496 fs->cfa_offset = offset * fs->data_align;
497 /* cfa_how deliberately not set. */
500 case DW_CFA_GNU_window_save:
501 /* This is SPARC-specific code, and contains hard-coded
502 constants for the register numbering scheme used by
503 GCC. Rather than having a architecture-specific
504 operation that's only ever used by a single
505 architecture, we provide the implementation here.
506 Incidentally that's what GCC does too in its
509 struct gdbarch *gdbarch = get_frame_arch (next_frame);
510 int size = register_size(gdbarch, 0);
511 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
512 for (reg = 8; reg < 16; reg++)
514 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
515 fs->regs.reg[reg].loc.reg = reg + 16;
517 for (reg = 16; reg < 32; reg++)
519 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
520 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
525 case DW_CFA_GNU_args_size:
527 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
531 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
536 /* Don't allow remember/restore between CIE and FDE programs. */
537 dwarf2_frame_state_free_regs (fs->regs.prev);
538 fs->regs.prev = NULL;
542 /* Architecture-specific operations. */
544 /* Per-architecture data key. */
545 static struct gdbarch_data *dwarf2_frame_data;
547 struct dwarf2_frame_ops
549 /* Pre-initialize the register state REG for register REGNUM. */
550 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
551 struct frame_info *);
553 /* Check whether the frame preceding NEXT_FRAME will be a signal
555 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
557 /* Convert .eh_frame register number to DWARF register number. */
558 int (*eh_frame_regnum) (struct gdbarch *, int);
561 /* Default architecture-specific register state initialization
565 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
566 struct dwarf2_frame_state_reg *reg,
567 struct frame_info *next_frame)
569 /* If we have a register that acts as a program counter, mark it as
570 a destination for the return address. If we have a register that
571 serves as the stack pointer, arrange for it to be filled with the
572 call frame address (CFA). The other registers are marked as
575 We copy the return address to the program counter, since many
576 parts in GDB assume that it is possible to get the return address
577 by unwinding the program counter register. However, on ISA's
578 with a dedicated return address register, the CFI usually only
579 contains information to unwind that return address register.
581 The reason we're treating the stack pointer special here is
582 because in many cases GCC doesn't emit CFI for the stack pointer
583 and implicitly assumes that it is equal to the CFA. This makes
584 some sense since the DWARF specification (version 3, draft 8,
587 "Typically, the CFA is defined to be the value of the stack
588 pointer at the call site in the previous frame (which may be
589 different from its value on entry to the current frame)."
591 However, this isn't true for all platforms supported by GCC
592 (e.g. IBM S/390 and zSeries). Those architectures should provide
593 their own architecture-specific initialization function. */
595 if (regnum == PC_REGNUM)
596 reg->how = DWARF2_FRAME_REG_RA;
597 else if (regnum == SP_REGNUM)
598 reg->how = DWARF2_FRAME_REG_CFA;
601 /* Return a default for the architecture-specific operations. */
604 dwarf2_frame_init (struct obstack *obstack)
606 struct dwarf2_frame_ops *ops;
608 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
609 ops->init_reg = dwarf2_frame_default_init_reg;
613 /* Set the architecture-specific register state initialization
614 function for GDBARCH to INIT_REG. */
617 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
618 void (*init_reg) (struct gdbarch *, int,
619 struct dwarf2_frame_state_reg *,
620 struct frame_info *))
622 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
624 ops->init_reg = init_reg;
627 /* Pre-initialize the register state REG for register REGNUM. */
630 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
631 struct dwarf2_frame_state_reg *reg,
632 struct frame_info *next_frame)
634 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
636 ops->init_reg (gdbarch, regnum, reg, next_frame);
639 /* Set the architecture-specific signal trampoline recognition
640 function for GDBARCH to SIGNAL_FRAME_P. */
643 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
644 int (*signal_frame_p) (struct gdbarch *,
645 struct frame_info *))
647 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
649 ops->signal_frame_p = signal_frame_p;
652 /* Query the architecture-specific signal frame recognizer for
656 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
657 struct frame_info *next_frame)
659 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
661 if (ops->signal_frame_p == NULL)
663 return ops->signal_frame_p (gdbarch, next_frame);
666 /* Set the architecture-specific mapping of .eh_frame register numbers to
667 DWARF register numbers. */
670 dwarf2_frame_set_eh_frame_regnum (struct gdbarch *gdbarch,
671 int (*eh_frame_regnum) (struct gdbarch *,
674 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
676 ops->eh_frame_regnum = eh_frame_regnum;
679 /* Translate a .eh_frame register to DWARF register. */
682 dwarf2_frame_eh_frame_regnum (struct gdbarch *gdbarch, int regnum)
684 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
686 if (ops->eh_frame_regnum == NULL)
688 return ops->eh_frame_regnum (gdbarch, regnum);
692 struct dwarf2_frame_cache
694 /* DWARF Call Frame Address. */
697 /* Set if the return address column was marked as undefined. */
698 int undefined_retaddr;
700 /* Saved registers, indexed by GDB register number, not by DWARF
702 struct dwarf2_frame_state_reg *reg;
704 /* Return address register. */
705 struct dwarf2_frame_state_reg retaddr_reg;
708 static struct dwarf2_frame_cache *
709 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
711 struct cleanup *old_chain;
712 struct gdbarch *gdbarch = get_frame_arch (next_frame);
713 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
714 struct dwarf2_frame_cache *cache;
715 struct dwarf2_frame_state *fs;
716 struct dwarf2_fde *fde;
721 /* Allocate a new cache. */
722 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
723 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
725 /* Allocate and initialize the frame state. */
726 fs = XMALLOC (struct dwarf2_frame_state);
727 memset (fs, 0, sizeof (struct dwarf2_frame_state));
728 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
732 Note that if NEXT_FRAME is never supposed to return (i.e. a call
733 to abort), the compiler might optimize away the instruction at
734 NEXT_FRAME's return address. As a result the return address will
735 point at some random instruction, and the CFI for that
736 instruction is probably worthless to us. GCC's unwinder solves
737 this problem by substracting 1 from the return address to get an
738 address in the middle of a presumed call instruction (or the
739 instruction in the associated delay slot). This should only be
740 done for "normal" frames and not for resume-type frames (signal
741 handlers, sentinel frames, dummy frames). The function
742 frame_unwind_address_in_block does just this. It's not clear how
743 reliable the method is though; there is the potential for the
744 register state pre-call being different to that on return. */
745 fs->pc = frame_unwind_address_in_block (next_frame);
747 /* Find the correct FDE. */
748 fde = dwarf2_frame_find_fde (&fs->pc);
749 gdb_assert (fde != NULL);
751 /* Extract any interesting information from the CIE. */
752 fs->data_align = fde->cie->data_alignment_factor;
753 fs->code_align = fde->cie->code_alignment_factor;
754 fs->retaddr_column = fde->cie->return_address_register;
756 /* First decode all the insns in the CIE. */
757 execute_cfa_program (fde->cie->initial_instructions,
758 fde->cie->end, next_frame, fs, fde->eh_frame_p);
760 /* Save the initialized register set. */
761 fs->initial = fs->regs;
762 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
764 /* Then decode the insns in the FDE up to our target PC. */
765 execute_cfa_program (fde->instructions, fde->end, next_frame, fs,
768 /* Caclulate the CFA. */
772 cache->cfa = read_reg (next_frame, fs->cfa_reg);
773 cache->cfa += fs->cfa_offset;
778 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
782 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
785 /* Initialize the register state. */
789 for (regnum = 0; regnum < num_regs; regnum++)
790 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
793 /* Go through the DWARF2 CFI generated table and save its register
794 location information in the cache. Note that we don't skip the
795 return address column; it's perfectly all right for it to
796 correspond to a real register. If it doesn't correspond to a
797 real register, or if we shouldn't treat it as such,
798 DWARF2_REG_TO_REGNUM should be defined to return a number outside
799 the range [0, NUM_REGS). */
801 int column; /* CFI speak for "register number". */
803 for (column = 0; column < fs->regs.num_regs; column++)
805 /* Use the GDB register number as the destination index. */
806 int regnum = DWARF2_REG_TO_REGNUM (column);
808 /* If there's no corresponding GDB register, ignore it. */
809 if (regnum < 0 || regnum >= num_regs)
812 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
813 of all debug info registers. If it doesn't, complain (but
814 not too loudly). It turns out that GCC assumes that an
815 unspecified register implies "same value" when CFI (draft
816 7) specifies nothing at all. Such a register could equally
817 be interpreted as "undefined". Also note that this check
818 isn't sufficient; it only checks that all registers in the
819 range [0 .. max column] are specified, and won't detect
820 problems when a debug info register falls outside of the
821 table. We need a way of iterating through all the valid
822 DWARF2 register numbers. */
823 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
825 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
826 complaint (&symfile_complaints, _("\
827 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
828 gdbarch_register_name (gdbarch, regnum),
832 cache->reg[regnum] = fs->regs.reg[column];
836 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
837 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
841 for (regnum = 0; regnum < num_regs; regnum++)
843 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
844 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
846 struct dwarf2_frame_state_reg *retaddr_reg =
847 &fs->regs.reg[fs->retaddr_column];
849 /* It seems rather bizarre to specify an "empty" column as
850 the return adress column. However, this is exactly
851 what GCC does on some targets. It turns out that GCC
852 assumes that the return address can be found in the
853 register corresponding to the return address column.
854 Incidentally, that's how we should treat a return
855 address column specifying "same value" too. */
856 if (fs->retaddr_column < fs->regs.num_regs
857 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
858 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
860 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
861 cache->reg[regnum] = *retaddr_reg;
863 cache->retaddr_reg = *retaddr_reg;
867 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
869 cache->reg[regnum].loc.reg = fs->retaddr_column;
870 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
874 cache->retaddr_reg.loc.reg = fs->retaddr_column;
875 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
882 if (fs->retaddr_column < fs->regs.num_regs
883 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
884 cache->undefined_retaddr = 1;
886 do_cleanups (old_chain);
893 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
894 struct frame_id *this_id)
896 struct dwarf2_frame_cache *cache =
897 dwarf2_frame_cache (next_frame, this_cache);
899 if (cache->undefined_retaddr)
902 (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
906 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
907 int regnum, int *optimizedp,
908 enum lval_type *lvalp, CORE_ADDR *addrp,
909 int *realnump, gdb_byte *valuep)
911 struct gdbarch *gdbarch = get_frame_arch (next_frame);
912 struct dwarf2_frame_cache *cache =
913 dwarf2_frame_cache (next_frame, this_cache);
915 switch (cache->reg[regnum].how)
917 case DWARF2_FRAME_REG_UNDEFINED:
918 /* If CFI explicitly specified that the value isn't defined,
919 mark it as optimized away; the value isn't available. */
926 /* In some cases, for example %eflags on the i386, we have
927 to provide a sane value, even though this register wasn't
928 saved. Assume we can get it from NEXT_FRAME. */
929 frame_unwind_register (next_frame, regnum, valuep);
933 case DWARF2_FRAME_REG_SAVED_OFFSET:
935 *lvalp = lval_memory;
936 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
940 /* Read the value in from memory. */
941 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
945 case DWARF2_FRAME_REG_SAVED_REG:
947 *lvalp = lval_register;
949 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
951 frame_unwind_register (next_frame, (*realnump), valuep);
954 case DWARF2_FRAME_REG_SAVED_EXP:
956 *lvalp = lval_memory;
957 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
958 cache->reg[regnum].exp_len,
959 next_frame, cache->cfa);
963 /* Read the value in from memory. */
964 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
968 case DWARF2_FRAME_REG_UNSPECIFIED:
969 /* GCC, in its infinite wisdom decided to not provide unwind
970 information for registers that are "same value". Since
971 DWARF2 (3 draft 7) doesn't define such behavior, said
972 registers are actually undefined (which is different to CFI
973 "undefined"). Code above issues a complaint about this.
974 Here just fudge the books, assume GCC, and that the value is
975 more inner on the stack. */
977 *lvalp = lval_register;
981 frame_unwind_register (next_frame, (*realnump), valuep);
984 case DWARF2_FRAME_REG_SAME_VALUE:
986 *lvalp = lval_register;
990 frame_unwind_register (next_frame, (*realnump), valuep);
993 case DWARF2_FRAME_REG_CFA:
1000 /* Store the value. */
1001 store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
1005 case DWARF2_FRAME_REG_CFA_OFFSET:
1012 /* Store the value. */
1013 store_typed_address (valuep, builtin_type_void_data_ptr,
1014 cache->cfa + cache->reg[regnum].loc.offset);
1018 case DWARF2_FRAME_REG_RA_OFFSET:
1025 CORE_ADDR pc = cache->reg[regnum].loc.offset;
1027 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
1028 pc += frame_unwind_register_unsigned (next_frame, regnum);
1029 store_typed_address (valuep, builtin_type_void_func_ptr, pc);
1034 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1038 static const struct frame_unwind dwarf2_frame_unwind =
1041 dwarf2_frame_this_id,
1042 dwarf2_frame_prev_register
1045 static const struct frame_unwind dwarf2_signal_frame_unwind =
1048 dwarf2_frame_this_id,
1049 dwarf2_frame_prev_register
1052 const struct frame_unwind *
1053 dwarf2_frame_sniffer (struct frame_info *next_frame)
1055 /* Grab an address that is guarenteed to reside somewhere within the
1056 function. frame_pc_unwind(), for a no-return next function, can
1057 end up returning something past the end of this function's body. */
1058 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
1059 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1063 /* On some targets, signal trampolines may have unwind information.
1064 We need to recognize them so that we set the frame type
1067 if (fde->cie->signal_frame
1068 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
1070 return &dwarf2_signal_frame_unwind;
1072 return &dwarf2_frame_unwind;
1076 /* There is no explicitly defined relationship between the CFA and the
1077 location of frame's local variables and arguments/parameters.
1078 Therefore, frame base methods on this page should probably only be
1079 used as a last resort, just to avoid printing total garbage as a
1080 response to the "info frame" command. */
1083 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1085 struct dwarf2_frame_cache *cache =
1086 dwarf2_frame_cache (next_frame, this_cache);
1091 static const struct frame_base dwarf2_frame_base =
1093 &dwarf2_frame_unwind,
1094 dwarf2_frame_base_address,
1095 dwarf2_frame_base_address,
1096 dwarf2_frame_base_address
1099 const struct frame_base *
1100 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1102 CORE_ADDR pc = frame_pc_unwind (next_frame);
1103 if (dwarf2_frame_find_fde (&pc))
1104 return &dwarf2_frame_base;
1109 /* A minimal decoding of DWARF2 compilation units. We only decode
1110 what's needed to get to the call frame information. */
1114 /* Keep the bfd convenient. */
1117 struct objfile *objfile;
1119 /* Linked list of CIEs for this object. */
1120 struct dwarf2_cie *cie;
1122 /* Pointer to the .debug_frame section loaded into memory. */
1123 gdb_byte *dwarf_frame_buffer;
1125 /* Length of the loaded .debug_frame section. */
1126 unsigned long dwarf_frame_size;
1128 /* Pointer to the .debug_frame section. */
1129 asection *dwarf_frame_section;
1131 /* Base for DW_EH_PE_datarel encodings. */
1134 /* Base for DW_EH_PE_textrel encodings. */
1138 const struct objfile_data *dwarf2_frame_objfile_data;
1141 read_1_byte (bfd *abfd, gdb_byte *buf)
1143 return bfd_get_8 (abfd, buf);
1147 read_4_bytes (bfd *abfd, gdb_byte *buf)
1149 return bfd_get_32 (abfd, buf);
1153 read_8_bytes (bfd *abfd, gdb_byte *buf)
1155 return bfd_get_64 (abfd, buf);
1159 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1162 unsigned int num_read;
1172 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1175 result |= ((byte & 0x7f) << shift);
1178 while (byte & 0x80);
1180 *bytes_read_ptr = num_read;
1186 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1190 unsigned int num_read;
1199 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1202 result |= ((byte & 0x7f) << shift);
1205 while (byte & 0x80);
1207 if (shift < 8 * sizeof (result) && (byte & 0x40))
1208 result |= -(((LONGEST)1) << shift);
1210 *bytes_read_ptr = num_read;
1216 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1220 result = bfd_get_32 (abfd, buf);
1221 if (result == 0xffffffff)
1223 result = bfd_get_64 (abfd, buf + 4);
1224 *bytes_read_ptr = 12;
1227 *bytes_read_ptr = 4;
1233 /* Pointer encoding helper functions. */
1235 /* GCC supports exception handling based on DWARF2 CFI. However, for
1236 technical reasons, it encodes addresses in its FDE's in a different
1237 way. Several "pointer encodings" are supported. The encoding
1238 that's used for a particular FDE is determined by the 'R'
1239 augmentation in the associated CIE. The argument of this
1240 augmentation is a single byte.
1242 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1243 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1244 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1245 address should be interpreted (absolute, relative to the current
1246 position in the FDE, ...). Bit 7, indicates that the address
1247 should be dereferenced. */
1250 encoding_for_size (unsigned int size)
1255 return DW_EH_PE_udata2;
1257 return DW_EH_PE_udata4;
1259 return DW_EH_PE_udata8;
1261 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1266 size_of_encoded_value (gdb_byte encoding)
1268 if (encoding == DW_EH_PE_omit)
1271 switch (encoding & 0x07)
1273 case DW_EH_PE_absptr:
1274 return TYPE_LENGTH (builtin_type_void_data_ptr);
1275 case DW_EH_PE_udata2:
1277 case DW_EH_PE_udata4:
1279 case DW_EH_PE_udata8:
1282 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1287 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1288 gdb_byte *buf, unsigned int *bytes_read_ptr)
1290 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1294 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1296 if (encoding & DW_EH_PE_indirect)
1297 internal_error (__FILE__, __LINE__,
1298 _("Unsupported encoding: DW_EH_PE_indirect"));
1300 *bytes_read_ptr = 0;
1302 switch (encoding & 0x70)
1304 case DW_EH_PE_absptr:
1307 case DW_EH_PE_pcrel:
1308 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1309 base += (buf - unit->dwarf_frame_buffer);
1311 case DW_EH_PE_datarel:
1314 case DW_EH_PE_textrel:
1317 case DW_EH_PE_funcrel:
1318 /* FIXME: kettenis/20040501: For now just pretend
1319 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1320 reading the initial location of an FDE it should be treated
1321 as such, and currently that's the only place where this code
1325 case DW_EH_PE_aligned:
1327 offset = buf - unit->dwarf_frame_buffer;
1328 if ((offset % ptr_len) != 0)
1330 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1331 buf += *bytes_read_ptr;
1335 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1338 if ((encoding & 0x07) == 0x00)
1339 encoding |= encoding_for_size (ptr_len);
1341 switch (encoding & 0x0f)
1343 case DW_EH_PE_uleb128:
1346 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1347 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1348 return base + value;
1350 case DW_EH_PE_udata2:
1351 *bytes_read_ptr += 2;
1352 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1353 case DW_EH_PE_udata4:
1354 *bytes_read_ptr += 4;
1355 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1356 case DW_EH_PE_udata8:
1357 *bytes_read_ptr += 8;
1358 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1359 case DW_EH_PE_sleb128:
1362 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1363 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1364 return base + value;
1366 case DW_EH_PE_sdata2:
1367 *bytes_read_ptr += 2;
1368 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1369 case DW_EH_PE_sdata4:
1370 *bytes_read_ptr += 4;
1371 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1372 case DW_EH_PE_sdata8:
1373 *bytes_read_ptr += 8;
1374 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1376 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1381 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1382 That's why we use a simple linked list here. */
1384 static struct dwarf2_cie *
1385 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1387 struct dwarf2_cie *cie = unit->cie;
1391 if (cie->cie_pointer == cie_pointer)
1401 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1403 cie->next = unit->cie;
1407 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1408 inital location associated with it into *PC. */
1410 static struct dwarf2_fde *
1411 dwarf2_frame_find_fde (CORE_ADDR *pc)
1413 struct objfile *objfile;
1415 ALL_OBJFILES (objfile)
1417 struct dwarf2_fde *fde;
1420 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1424 gdb_assert (objfile->section_offsets);
1425 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1429 if (*pc >= fde->initial_location + offset
1430 && *pc < fde->initial_location + offset + fde->address_range)
1432 *pc = fde->initial_location + offset;
1444 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1446 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1447 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1450 #ifdef CC_HAS_LONG_LONG
1451 #define DW64_CIE_ID 0xffffffffffffffffULL
1453 #define DW64_CIE_ID ~0
1456 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1459 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1460 the next byte to be processed. */
1462 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1464 gdb_byte *buf, *end;
1466 unsigned int bytes_read;
1469 ULONGEST cie_pointer;
1472 length = read_initial_length (unit->abfd, buf, &bytes_read);
1476 /* Are we still within the section? */
1477 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1483 /* Distinguish between 32 and 64-bit encoded frame info. */
1484 dwarf64_p = (bytes_read == 12);
1486 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1490 cie_id = DW64_CIE_ID;
1496 cie_pointer = read_8_bytes (unit->abfd, buf);
1501 cie_pointer = read_4_bytes (unit->abfd, buf);
1505 if (cie_pointer == cie_id)
1507 /* This is a CIE. */
1508 struct dwarf2_cie *cie;
1510 unsigned int cie_version;
1512 /* Record the offset into the .debug_frame section of this CIE. */
1513 cie_pointer = start - unit->dwarf_frame_buffer;
1515 /* Check whether we've already read it. */
1516 if (find_cie (unit, cie_pointer))
1519 cie = (struct dwarf2_cie *)
1520 obstack_alloc (&unit->objfile->objfile_obstack,
1521 sizeof (struct dwarf2_cie));
1522 cie->initial_instructions = NULL;
1523 cie->cie_pointer = cie_pointer;
1525 /* The encoding for FDE's in a normal .debug_frame section
1526 depends on the target address size. */
1527 cie->encoding = DW_EH_PE_absptr;
1529 /* We'll determine the final value later, but we need to
1530 initialize it conservatively. */
1531 cie->signal_frame = 0;
1533 /* Check version number. */
1534 cie_version = read_1_byte (unit->abfd, buf);
1535 if (cie_version != 1 && cie_version != 3)
1539 /* Interpret the interesting bits of the augmentation. */
1540 augmentation = (char *) buf;
1541 buf += (strlen (augmentation) + 1);
1543 /* The GCC 2.x "eh" augmentation has a pointer immediately
1544 following the augmentation string, so it must be handled
1546 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1549 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1553 cie->code_alignment_factor =
1554 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1557 cie->data_alignment_factor =
1558 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1561 if (cie_version == 1)
1563 cie->return_address_register = read_1_byte (unit->abfd, buf);
1567 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1570 cie->return_address_register
1571 = dwarf2_frame_eh_frame_regnum (current_gdbarch,
1572 cie->return_address_register);
1576 cie->saw_z_augmentation = (*augmentation == 'z');
1577 if (cie->saw_z_augmentation)
1581 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1585 cie->initial_instructions = buf + length;
1589 while (*augmentation)
1591 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1592 if (*augmentation == 'L')
1599 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1600 else if (*augmentation == 'R')
1602 cie->encoding = *buf++;
1606 /* "P" indicates a personality routine in the CIE augmentation. */
1607 else if (*augmentation == 'P')
1609 /* Skip. Avoid indirection since we throw away the result. */
1610 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1611 read_encoded_value (unit, encoding, buf, &bytes_read);
1616 /* "S" indicates a signal frame, such that the return
1617 address must not be decremented to locate the call frame
1618 info for the previous frame; it might even be the first
1619 instruction of a function, so decrementing it would take
1620 us to a different function. */
1621 else if (*augmentation == 'S')
1623 cie->signal_frame = 1;
1627 /* Otherwise we have an unknown augmentation.
1628 Bail out unless we saw a 'z' prefix. */
1631 if (cie->initial_instructions == NULL)
1634 /* Skip unknown augmentations. */
1635 buf = cie->initial_instructions;
1640 cie->initial_instructions = buf;
1643 add_cie (unit, cie);
1647 /* This is a FDE. */
1648 struct dwarf2_fde *fde;
1650 /* In an .eh_frame section, the CIE pointer is the delta between the
1651 address within the FDE where the CIE pointer is stored and the
1652 address of the CIE. Convert it to an offset into the .eh_frame
1656 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1657 cie_pointer -= (dwarf64_p ? 8 : 4);
1660 /* In either case, validate the result is still within the section. */
1661 if (cie_pointer >= unit->dwarf_frame_size)
1664 fde = (struct dwarf2_fde *)
1665 obstack_alloc (&unit->objfile->objfile_obstack,
1666 sizeof (struct dwarf2_fde));
1667 fde->cie = find_cie (unit, cie_pointer);
1668 if (fde->cie == NULL)
1670 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1672 fde->cie = find_cie (unit, cie_pointer);
1675 gdb_assert (fde->cie != NULL);
1677 fde->initial_location =
1678 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1681 fde->address_range =
1682 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1685 /* A 'z' augmentation in the CIE implies the presence of an
1686 augmentation field in the FDE as well. The only thing known
1687 to be in here at present is the LSDA entry for EH. So we
1688 can skip the whole thing. */
1689 if (fde->cie->saw_z_augmentation)
1693 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1694 buf += bytes_read + length;
1699 fde->instructions = buf;
1702 fde->eh_frame_p = eh_frame_p;
1704 add_fde (unit, fde);
1710 /* Read a CIE or FDE in BUF and decode it. */
1712 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1714 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1717 ptrdiff_t start_offset;
1721 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1725 /* We have corrupt input data of some form. */
1727 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1728 and mismatches wrt padding and alignment of debug sections. */
1729 /* Note that there is no requirement in the standard for any
1730 alignment at all in the frame unwind sections. Testing for
1731 alignment before trying to interpret data would be incorrect.
1733 However, GCC traditionally arranged for frame sections to be
1734 sized such that the FDE length and CIE fields happen to be
1735 aligned (in theory, for performance). This, unfortunately,
1736 was done with .align directives, which had the side effect of
1737 forcing the section to be aligned by the linker.
1739 This becomes a problem when you have some other producer that
1740 creates frame sections that are not as strictly aligned. That
1741 produces a hole in the frame info that gets filled by the
1744 The GCC behaviour is arguably a bug, but it's effectively now
1745 part of the ABI, so we're now stuck with it, at least at the
1746 object file level. A smart linker may decide, in the process
1747 of compressing duplicate CIE information, that it can rewrite
1748 the entire output section without this extra padding. */
1750 start_offset = start - unit->dwarf_frame_buffer;
1751 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1753 start += 4 - (start_offset & 3);
1754 workaround = ALIGN4;
1757 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1759 start += 8 - (start_offset & 7);
1760 workaround = ALIGN8;
1764 /* Nothing left to try. Arrange to return as if we've consumed
1765 the entire input section. Hopefully we'll get valid info from
1766 the other of .debug_frame/.eh_frame. */
1768 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1778 complaint (&symfile_complaints,
1779 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1780 unit->dwarf_frame_section->owner->filename,
1781 unit->dwarf_frame_section->name);
1785 complaint (&symfile_complaints,
1786 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1787 unit->dwarf_frame_section->owner->filename,
1788 unit->dwarf_frame_section->name);
1792 complaint (&symfile_complaints,
1793 _("Corrupt data in %s:%s"),
1794 unit->dwarf_frame_section->owner->filename,
1795 unit->dwarf_frame_section->name);
1803 /* FIXME: kettenis/20030504: This still needs to be integrated with
1804 dwarf2read.c in a better way. */
1806 /* Imported from dwarf2read.c. */
1807 extern asection *dwarf_frame_section;
1808 extern asection *dwarf_eh_frame_section;
1810 /* Imported from dwarf2read.c. */
1811 extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1814 dwarf2_build_frame_info (struct objfile *objfile)
1816 struct comp_unit unit;
1817 gdb_byte *frame_ptr;
1819 /* Build a minimal decoding of the DWARF2 compilation unit. */
1820 unit.abfd = objfile->obfd;
1821 unit.objfile = objfile;
1825 /* First add the information from the .eh_frame section. That way,
1826 the FDEs from that section are searched last. */
1827 if (dwarf_eh_frame_section)
1829 asection *got, *txt;
1832 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1833 dwarf_eh_frame_section);
1835 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1836 unit.dwarf_frame_section = dwarf_eh_frame_section;
1838 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1839 that is used for the i386/amd64 target, which currently is
1840 the only target in GCC that supports/uses the
1841 DW_EH_PE_datarel encoding. */
1842 got = bfd_get_section_by_name (unit.abfd, ".got");
1844 unit.dbase = got->vma;
1846 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1848 txt = bfd_get_section_by_name (unit.abfd, ".text");
1850 unit.tbase = txt->vma;
1852 frame_ptr = unit.dwarf_frame_buffer;
1853 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1854 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
1857 if (dwarf_frame_section)
1860 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1861 dwarf_frame_section);
1862 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1863 unit.dwarf_frame_section = dwarf_frame_section;
1865 frame_ptr = unit.dwarf_frame_buffer;
1866 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1867 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1871 /* Provide a prototype to silence -Wmissing-prototypes. */
1872 void _initialize_dwarf2_frame (void);
1875 _initialize_dwarf2_frame (void)
1877 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
1878 dwarf2_frame_objfile_data = register_objfile_data ();