1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright 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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "complaints.h"
40 #include "dwarf2-frame.h"
42 /* Call Frame Information (CFI). */
44 /* Common Information Entry (CIE). */
48 /* Offset into the .debug_frame section where this CIE was found.
49 Used to identify this CIE. */
52 /* Constant that is factored out of all advance location
54 ULONGEST code_alignment_factor;
56 /* Constants that is factored out of all offset instructions. */
57 LONGEST data_alignment_factor;
59 /* Return address column. */
60 ULONGEST return_address_register;
62 /* Instruction sequence to initialize a register set. */
63 gdb_byte *initial_instructions;
66 /* Encoding of addresses. */
69 /* True if a 'z' augmentation existed. */
70 unsigned char saw_z_augmentation;
72 struct dwarf2_cie *next;
75 /* Frame Description Entry (FDE). */
79 /* CIE for this FDE. */
80 struct dwarf2_cie *cie;
82 /* First location associated with this FDE. */
83 CORE_ADDR initial_location;
85 /* Number of bytes of program instructions described by this FDE. */
86 CORE_ADDR address_range;
88 /* Instruction sequence. */
89 gdb_byte *instructions;
92 struct dwarf2_fde *next;
95 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
98 /* Structure describing a frame state. */
100 struct dwarf2_frame_state
102 /* Each register save state can be described in terms of a CFA slot,
103 another register, or a location expression. */
104 struct dwarf2_frame_state_reg_info
106 struct dwarf2_frame_state_reg *reg;
109 /* Used to implement DW_CFA_remember_state. */
110 struct dwarf2_frame_state_reg_info *prev;
122 /* The PC described by the current frame state. */
125 /* Initial register set from the CIE.
126 Used to implement DW_CFA_restore. */
127 struct dwarf2_frame_state_reg_info initial;
129 /* The information we care about from the CIE. */
132 ULONGEST retaddr_column;
135 /* Store the length the expression for the CFA in the `cfa_reg' field,
136 which is unused in that case. */
137 #define cfa_exp_len cfa_reg
139 /* Assert that the register set RS is large enough to store NUM_REGS
140 columns. If necessary, enlarge the register set. */
143 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
146 size_t size = sizeof (struct dwarf2_frame_state_reg);
148 if (num_regs <= rs->num_regs)
151 rs->reg = (struct dwarf2_frame_state_reg *)
152 xrealloc (rs->reg, num_regs * size);
154 /* Initialize newly allocated registers. */
155 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
156 rs->num_regs = num_regs;
159 /* Copy the register columns in register set RS into newly allocated
160 memory and return a pointer to this newly created copy. */
162 static struct dwarf2_frame_state_reg *
163 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
165 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
166 struct dwarf2_frame_state_reg *reg;
168 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
169 memcpy (reg, rs->reg, size);
174 /* Release the memory allocated to register set RS. */
177 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
181 dwarf2_frame_state_free_regs (rs->prev);
188 /* Release the memory allocated to the frame state FS. */
191 dwarf2_frame_state_free (void *p)
193 struct dwarf2_frame_state *fs = p;
195 dwarf2_frame_state_free_regs (fs->initial.prev);
196 dwarf2_frame_state_free_regs (fs->regs.prev);
197 xfree (fs->initial.reg);
198 xfree (fs->regs.reg);
203 /* Helper functions for execute_stack_op. */
206 read_reg (void *baton, int reg)
208 struct frame_info *next_frame = (struct frame_info *) baton;
209 struct gdbarch *gdbarch = get_frame_arch (next_frame);
213 regnum = DWARF2_REG_TO_REGNUM (reg);
215 buf = alloca (register_size (gdbarch, regnum));
216 frame_unwind_register (next_frame, regnum, buf);
217 return extract_typed_address (buf, builtin_type_void_data_ptr);
221 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
223 read_memory (addr, buf, len);
227 no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
229 internal_error (__FILE__, __LINE__,
230 _("Support for DW_OP_fbreg is unimplemented"));
234 no_get_tls_address (void *baton, CORE_ADDR offset)
236 internal_error (__FILE__, __LINE__,
237 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
241 execute_stack_op (gdb_byte *exp, ULONGEST len,
242 struct frame_info *next_frame, CORE_ADDR initial)
244 struct dwarf_expr_context *ctx;
247 ctx = new_dwarf_expr_context ();
248 ctx->baton = next_frame;
249 ctx->read_reg = read_reg;
250 ctx->read_mem = read_mem;
251 ctx->get_frame_base = no_get_frame_base;
252 ctx->get_tls_address = no_get_tls_address;
254 dwarf_expr_push (ctx, initial);
255 dwarf_expr_eval (ctx, exp, len);
256 result = dwarf_expr_fetch (ctx, 0);
259 result = read_reg (next_frame, result);
261 free_dwarf_expr_context (ctx);
268 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
269 struct frame_info *next_frame,
270 struct dwarf2_frame_state *fs)
272 CORE_ADDR pc = frame_pc_unwind (next_frame);
275 while (insn_ptr < insn_end && fs->pc <= pc)
277 gdb_byte insn = *insn_ptr++;
281 if ((insn & 0xc0) == DW_CFA_advance_loc)
282 fs->pc += (insn & 0x3f) * fs->code_align;
283 else if ((insn & 0xc0) == DW_CFA_offset)
286 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
287 offset = utmp * fs->data_align;
288 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
289 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
290 fs->regs.reg[reg].loc.offset = offset;
292 else if ((insn & 0xc0) == DW_CFA_restore)
294 gdb_assert (fs->initial.reg);
296 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
297 if (reg < fs->initial.num_regs)
298 fs->regs.reg[reg] = fs->initial.reg[reg];
300 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
302 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
303 complaint (&symfile_complaints, _("\
304 incomplete CFI data; DW_CFA_restore unspecified\n\
305 register %s (#%d) at 0x%s"),
306 REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
307 DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
314 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
315 insn_ptr += bytes_read;
318 case DW_CFA_advance_loc1:
319 utmp = extract_unsigned_integer (insn_ptr, 1);
320 fs->pc += utmp * fs->code_align;
323 case DW_CFA_advance_loc2:
324 utmp = extract_unsigned_integer (insn_ptr, 2);
325 fs->pc += utmp * fs->code_align;
328 case DW_CFA_advance_loc4:
329 utmp = extract_unsigned_integer (insn_ptr, 4);
330 fs->pc += utmp * fs->code_align;
334 case DW_CFA_offset_extended:
335 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
336 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
337 offset = utmp * fs->data_align;
338 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
339 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
340 fs->regs.reg[reg].loc.offset = offset;
343 case DW_CFA_restore_extended:
344 gdb_assert (fs->initial.reg);
345 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
346 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
347 fs->regs.reg[reg] = fs->initial.reg[reg];
350 case DW_CFA_undefined:
351 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
352 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
353 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
356 case DW_CFA_same_value:
357 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
358 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
359 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
362 case DW_CFA_register:
363 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
364 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
365 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
366 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
367 fs->regs.reg[reg].loc.reg = utmp;
370 case DW_CFA_remember_state:
372 struct dwarf2_frame_state_reg_info *new_rs;
374 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
376 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
377 fs->regs.prev = new_rs;
381 case DW_CFA_restore_state:
383 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
387 complaint (&symfile_complaints, _("\
388 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
392 xfree (fs->regs.reg);
400 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
401 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
402 fs->cfa_offset = utmp;
403 fs->cfa_how = CFA_REG_OFFSET;
406 case DW_CFA_def_cfa_register:
407 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
408 fs->cfa_how = CFA_REG_OFFSET;
411 case DW_CFA_def_cfa_offset:
412 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
413 fs->cfa_offset = utmp;
414 /* cfa_how deliberately not set. */
420 case DW_CFA_def_cfa_expression:
421 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
422 fs->cfa_exp = insn_ptr;
423 fs->cfa_how = CFA_EXP;
424 insn_ptr += fs->cfa_exp_len;
427 case DW_CFA_expression:
428 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
429 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
430 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
431 fs->regs.reg[reg].loc.exp = insn_ptr;
432 fs->regs.reg[reg].exp_len = utmp;
433 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
437 case DW_CFA_offset_extended_sf:
438 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
439 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
440 offset *= fs->data_align;
441 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
442 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
443 fs->regs.reg[reg].loc.offset = offset;
446 case DW_CFA_def_cfa_sf:
447 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
448 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
449 fs->cfa_offset = offset * fs->data_align;
450 fs->cfa_how = CFA_REG_OFFSET;
453 case DW_CFA_def_cfa_offset_sf:
454 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
455 fs->cfa_offset = offset * fs->data_align;
456 /* cfa_how deliberately not set. */
459 case DW_CFA_GNU_window_save:
460 /* This is SPARC-specific code, and contains hard-coded
461 constants for the register numbering scheme used by
462 GCC. Rather than having a architecture-specific
463 operation that's only ever used by a single
464 architecture, we provide the implementation here.
465 Incidentally that's what GCC does too in its
468 struct gdbarch *gdbarch = get_frame_arch (next_frame);
469 int size = register_size(gdbarch, 0);
470 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
471 for (reg = 8; reg < 16; reg++)
473 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
474 fs->regs.reg[reg].loc.reg = reg + 16;
476 for (reg = 16; reg < 32; reg++)
478 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
479 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
484 case DW_CFA_GNU_args_size:
486 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
490 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
495 /* Don't allow remember/restore between CIE and FDE programs. */
496 dwarf2_frame_state_free_regs (fs->regs.prev);
497 fs->regs.prev = NULL;
501 /* Architecture-specific operations. */
503 /* Per-architecture data key. */
504 static struct gdbarch_data *dwarf2_frame_data;
506 struct dwarf2_frame_ops
508 /* Pre-initialize the register state REG for register REGNUM. */
509 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *);
511 /* Check whether the frame preceding NEXT_FRAME will be a signal
513 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
516 /* Default architecture-specific register state initialization
520 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
521 struct dwarf2_frame_state_reg *reg)
523 /* If we have a register that acts as a program counter, mark it as
524 a destination for the return address. If we have a register that
525 serves as the stack pointer, arrange for it to be filled with the
526 call frame address (CFA). The other registers are marked as
529 We copy the return address to the program counter, since many
530 parts in GDB assume that it is possible to get the return address
531 by unwinding the program counter register. However, on ISA's
532 with a dedicated return address register, the CFI usually only
533 contains information to unwind that return address register.
535 The reason we're treating the stack pointer special here is
536 because in many cases GCC doesn't emit CFI for the stack pointer
537 and implicitly assumes that it is equal to the CFA. This makes
538 some sense since the DWARF specification (version 3, draft 8,
541 "Typically, the CFA is defined to be the value of the stack
542 pointer at the call site in the previous frame (which may be
543 different from its value on entry to the current frame)."
545 However, this isn't true for all platforms supported by GCC
546 (e.g. IBM S/390 and zSeries). Those architectures should provide
547 their own architecture-specific initialization function. */
549 if (regnum == PC_REGNUM)
550 reg->how = DWARF2_FRAME_REG_RA;
551 else if (regnum == SP_REGNUM)
552 reg->how = DWARF2_FRAME_REG_CFA;
555 /* Return a default for the architecture-specific operations. */
558 dwarf2_frame_init (struct obstack *obstack)
560 struct dwarf2_frame_ops *ops;
562 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
563 ops->init_reg = dwarf2_frame_default_init_reg;
567 /* Set the architecture-specific register state initialization
568 function for GDBARCH to INIT_REG. */
571 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
572 void (*init_reg) (struct gdbarch *, int,
573 struct dwarf2_frame_state_reg *))
575 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
577 ops->init_reg = init_reg;
580 /* Pre-initialize the register state REG for register REGNUM. */
583 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
584 struct dwarf2_frame_state_reg *reg)
586 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
588 ops->init_reg (gdbarch, regnum, reg);
591 /* Set the architecture-specific signal trampoline recognition
592 function for GDBARCH to SIGNAL_FRAME_P. */
595 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
596 int (*signal_frame_p) (struct gdbarch *,
597 struct frame_info *))
599 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
601 ops->signal_frame_p = signal_frame_p;
604 /* Query the architecture-specific signal frame recognizer for
608 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
609 struct frame_info *next_frame)
611 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
613 if (ops->signal_frame_p == NULL)
615 return ops->signal_frame_p (gdbarch, next_frame);
619 struct dwarf2_frame_cache
621 /* DWARF Call Frame Address. */
624 /* Set if the return address column was marked as undefined. */
625 int undefined_retaddr;
627 /* Saved registers, indexed by GDB register number, not by DWARF
629 struct dwarf2_frame_state_reg *reg;
631 /* Return address register. */
632 struct dwarf2_frame_state_reg retaddr_reg;
635 static struct dwarf2_frame_cache *
636 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
638 struct cleanup *old_chain;
639 struct gdbarch *gdbarch = get_frame_arch (next_frame);
640 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
641 struct dwarf2_frame_cache *cache;
642 struct dwarf2_frame_state *fs;
643 struct dwarf2_fde *fde;
648 /* Allocate a new cache. */
649 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
650 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
652 /* Allocate and initialize the frame state. */
653 fs = XMALLOC (struct dwarf2_frame_state);
654 memset (fs, 0, sizeof (struct dwarf2_frame_state));
655 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
659 Note that if NEXT_FRAME is never supposed to return (i.e. a call
660 to abort), the compiler might optimize away the instruction at
661 NEXT_FRAME's return address. As a result the return address will
662 point at some random instruction, and the CFI for that
663 instruction is probably worthless to us. GCC's unwinder solves
664 this problem by substracting 1 from the return address to get an
665 address in the middle of a presumed call instruction (or the
666 instruction in the associated delay slot). This should only be
667 done for "normal" frames and not for resume-type frames (signal
668 handlers, sentinel frames, dummy frames). The function
669 frame_unwind_address_in_block does just this. It's not clear how
670 reliable the method is though; there is the potential for the
671 register state pre-call being different to that on return. */
672 fs->pc = frame_unwind_address_in_block (next_frame);
674 /* Find the correct FDE. */
675 fde = dwarf2_frame_find_fde (&fs->pc);
676 gdb_assert (fde != NULL);
678 /* Extract any interesting information from the CIE. */
679 fs->data_align = fde->cie->data_alignment_factor;
680 fs->code_align = fde->cie->code_alignment_factor;
681 fs->retaddr_column = fde->cie->return_address_register;
683 /* First decode all the insns in the CIE. */
684 execute_cfa_program (fde->cie->initial_instructions,
685 fde->cie->end, next_frame, fs);
687 /* Save the initialized register set. */
688 fs->initial = fs->regs;
689 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
691 /* Then decode the insns in the FDE up to our target PC. */
692 execute_cfa_program (fde->instructions, fde->end, next_frame, fs);
694 /* Caclulate the CFA. */
698 cache->cfa = read_reg (next_frame, fs->cfa_reg);
699 cache->cfa += fs->cfa_offset;
704 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
708 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
711 /* Initialize the register state. */
715 for (regnum = 0; regnum < num_regs; regnum++)
716 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum]);
719 /* Go through the DWARF2 CFI generated table and save its register
720 location information in the cache. Note that we don't skip the
721 return address column; it's perfectly all right for it to
722 correspond to a real register. If it doesn't correspond to a
723 real register, or if we shouldn't treat it as such,
724 DWARF2_REG_TO_REGNUM should be defined to return a number outside
725 the range [0, NUM_REGS). */
727 int column; /* CFI speak for "register number". */
729 for (column = 0; column < fs->regs.num_regs; column++)
731 /* Use the GDB register number as the destination index. */
732 int regnum = DWARF2_REG_TO_REGNUM (column);
734 /* If there's no corresponding GDB register, ignore it. */
735 if (regnum < 0 || regnum >= num_regs)
738 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
739 of all debug info registers. If it doesn't, complain (but
740 not too loudly). It turns out that GCC assumes that an
741 unspecified register implies "same value" when CFI (draft
742 7) specifies nothing at all. Such a register could equally
743 be interpreted as "undefined". Also note that this check
744 isn't sufficient; it only checks that all registers in the
745 range [0 .. max column] are specified, and won't detect
746 problems when a debug info register falls outside of the
747 table. We need a way of iterating through all the valid
748 DWARF2 register numbers. */
749 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
751 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
752 complaint (&symfile_complaints, _("\
753 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
754 gdbarch_register_name (gdbarch, regnum),
758 cache->reg[regnum] = fs->regs.reg[column];
762 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
763 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
767 for (regnum = 0; regnum < num_regs; regnum++)
769 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
770 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
772 struct dwarf2_frame_state_reg *retaddr_reg =
773 &fs->regs.reg[fs->retaddr_column];
775 /* It seems rather bizarre to specify an "empty" column as
776 the return adress column. However, this is exactly
777 what GCC does on some targets. It turns out that GCC
778 assumes that the return address can be found in the
779 register corresponding to the return address column.
780 Incidentally, that's how we should treat a return
781 address column specifying "same value" too. */
782 if (fs->retaddr_column < fs->regs.num_regs
783 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
784 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
786 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
787 cache->reg[regnum] = *retaddr_reg;
789 cache->retaddr_reg = *retaddr_reg;
793 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
795 cache->reg[regnum].loc.reg = fs->retaddr_column;
796 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
800 cache->retaddr_reg.loc.reg = fs->retaddr_column;
801 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
808 if (fs->retaddr_column < fs->regs.num_regs
809 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
810 cache->undefined_retaddr = 1;
812 do_cleanups (old_chain);
819 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
820 struct frame_id *this_id)
822 struct dwarf2_frame_cache *cache =
823 dwarf2_frame_cache (next_frame, this_cache);
825 if (cache->undefined_retaddr)
828 (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
832 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
833 int regnum, int *optimizedp,
834 enum lval_type *lvalp, CORE_ADDR *addrp,
835 int *realnump, gdb_byte *valuep)
837 struct gdbarch *gdbarch = get_frame_arch (next_frame);
838 struct dwarf2_frame_cache *cache =
839 dwarf2_frame_cache (next_frame, this_cache);
841 switch (cache->reg[regnum].how)
843 case DWARF2_FRAME_REG_UNDEFINED:
844 /* If CFI explicitly specified that the value isn't defined,
845 mark it as optimized away; the value isn't available. */
852 /* In some cases, for example %eflags on the i386, we have
853 to provide a sane value, even though this register wasn't
854 saved. Assume we can get it from NEXT_FRAME. */
855 frame_unwind_register (next_frame, regnum, valuep);
859 case DWARF2_FRAME_REG_SAVED_OFFSET:
861 *lvalp = lval_memory;
862 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
866 /* Read the value in from memory. */
867 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
871 case DWARF2_FRAME_REG_SAVED_REG:
873 *lvalp = lval_register;
875 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
877 frame_unwind_register (next_frame, (*realnump), valuep);
880 case DWARF2_FRAME_REG_SAVED_EXP:
882 *lvalp = lval_memory;
883 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
884 cache->reg[regnum].exp_len,
885 next_frame, cache->cfa);
889 /* Read the value in from memory. */
890 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
894 case DWARF2_FRAME_REG_UNSPECIFIED:
895 /* GCC, in its infinite wisdom decided to not provide unwind
896 information for registers that are "same value". Since
897 DWARF2 (3 draft 7) doesn't define such behavior, said
898 registers are actually undefined (which is different to CFI
899 "undefined"). Code above issues a complaint about this.
900 Here just fudge the books, assume GCC, and that the value is
901 more inner on the stack. */
903 *lvalp = lval_register;
907 frame_unwind_register (next_frame, (*realnump), valuep);
910 case DWARF2_FRAME_REG_SAME_VALUE:
912 *lvalp = lval_register;
916 frame_unwind_register (next_frame, (*realnump), valuep);
919 case DWARF2_FRAME_REG_CFA:
926 /* Store the value. */
927 store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
931 case DWARF2_FRAME_REG_RA_OFFSET:
938 CORE_ADDR pc = cache->reg[regnum].loc.offset;
940 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
941 pc += frame_unwind_register_unsigned (next_frame, regnum);
942 store_typed_address (valuep, builtin_type_void_func_ptr, pc);
947 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
951 static const struct frame_unwind dwarf2_frame_unwind =
954 dwarf2_frame_this_id,
955 dwarf2_frame_prev_register
958 static const struct frame_unwind dwarf2_signal_frame_unwind =
961 dwarf2_frame_this_id,
962 dwarf2_frame_prev_register
965 const struct frame_unwind *
966 dwarf2_frame_sniffer (struct frame_info *next_frame)
968 /* Grab an address that is guarenteed to reside somewhere within the
969 function. frame_pc_unwind(), for a no-return next function, can
970 end up returning something past the end of this function's body. */
971 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
972 if (!dwarf2_frame_find_fde (&block_addr))
975 /* On some targets, signal trampolines may have unwind information.
976 We need to recognize them so that we set the frame type
979 if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
981 return &dwarf2_signal_frame_unwind;
983 return &dwarf2_frame_unwind;
987 /* There is no explicitly defined relationship between the CFA and the
988 location of frame's local variables and arguments/parameters.
989 Therefore, frame base methods on this page should probably only be
990 used as a last resort, just to avoid printing total garbage as a
991 response to the "info frame" command. */
994 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
996 struct dwarf2_frame_cache *cache =
997 dwarf2_frame_cache (next_frame, this_cache);
1002 static const struct frame_base dwarf2_frame_base =
1004 &dwarf2_frame_unwind,
1005 dwarf2_frame_base_address,
1006 dwarf2_frame_base_address,
1007 dwarf2_frame_base_address
1010 const struct frame_base *
1011 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1013 CORE_ADDR pc = frame_pc_unwind (next_frame);
1014 if (dwarf2_frame_find_fde (&pc))
1015 return &dwarf2_frame_base;
1020 /* A minimal decoding of DWARF2 compilation units. We only decode
1021 what's needed to get to the call frame information. */
1025 /* Keep the bfd convenient. */
1028 struct objfile *objfile;
1030 /* Linked list of CIEs for this object. */
1031 struct dwarf2_cie *cie;
1033 /* Pointer to the .debug_frame section loaded into memory. */
1034 gdb_byte *dwarf_frame_buffer;
1036 /* Length of the loaded .debug_frame section. */
1037 unsigned long dwarf_frame_size;
1039 /* Pointer to the .debug_frame section. */
1040 asection *dwarf_frame_section;
1042 /* Base for DW_EH_PE_datarel encodings. */
1045 /* Base for DW_EH_PE_textrel encodings. */
1049 const struct objfile_data *dwarf2_frame_objfile_data;
1052 read_1_byte (bfd *abfd, gdb_byte *buf)
1054 return bfd_get_8 (abfd, buf);
1058 read_4_bytes (bfd *abfd, gdb_byte *buf)
1060 return bfd_get_32 (abfd, buf);
1064 read_8_bytes (bfd *abfd, gdb_byte *buf)
1066 return bfd_get_64 (abfd, buf);
1070 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1073 unsigned int num_read;
1083 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1086 result |= ((byte & 0x7f) << shift);
1089 while (byte & 0x80);
1091 *bytes_read_ptr = num_read;
1097 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1101 unsigned int num_read;
1110 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1113 result |= ((byte & 0x7f) << shift);
1116 while (byte & 0x80);
1118 if (shift < 8 * sizeof (result) && (byte & 0x40))
1119 result |= -(((LONGEST)1) << shift);
1121 *bytes_read_ptr = num_read;
1127 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1131 result = bfd_get_32 (abfd, buf);
1132 if (result == 0xffffffff)
1134 result = bfd_get_64 (abfd, buf + 4);
1135 *bytes_read_ptr = 12;
1138 *bytes_read_ptr = 4;
1144 /* Pointer encoding helper functions. */
1146 /* GCC supports exception handling based on DWARF2 CFI. However, for
1147 technical reasons, it encodes addresses in its FDE's in a different
1148 way. Several "pointer encodings" are supported. The encoding
1149 that's used for a particular FDE is determined by the 'R'
1150 augmentation in the associated CIE. The argument of this
1151 augmentation is a single byte.
1153 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1154 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1155 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1156 address should be interpreted (absolute, relative to the current
1157 position in the FDE, ...). Bit 7, indicates that the address
1158 should be dereferenced. */
1161 encoding_for_size (unsigned int size)
1166 return DW_EH_PE_udata2;
1168 return DW_EH_PE_udata4;
1170 return DW_EH_PE_udata8;
1172 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1177 size_of_encoded_value (gdb_byte encoding)
1179 if (encoding == DW_EH_PE_omit)
1182 switch (encoding & 0x07)
1184 case DW_EH_PE_absptr:
1185 return TYPE_LENGTH (builtin_type_void_data_ptr);
1186 case DW_EH_PE_udata2:
1188 case DW_EH_PE_udata4:
1190 case DW_EH_PE_udata8:
1193 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1198 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1199 gdb_byte *buf, unsigned int *bytes_read_ptr)
1201 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1205 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1207 if (encoding & DW_EH_PE_indirect)
1208 internal_error (__FILE__, __LINE__,
1209 _("Unsupported encoding: DW_EH_PE_indirect"));
1211 *bytes_read_ptr = 0;
1213 switch (encoding & 0x70)
1215 case DW_EH_PE_absptr:
1218 case DW_EH_PE_pcrel:
1219 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1220 base += (buf - unit->dwarf_frame_buffer);
1222 case DW_EH_PE_datarel:
1225 case DW_EH_PE_textrel:
1228 case DW_EH_PE_funcrel:
1229 /* FIXME: kettenis/20040501: For now just pretend
1230 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1231 reading the initial location of an FDE it should be treated
1232 as such, and currently that's the only place where this code
1236 case DW_EH_PE_aligned:
1238 offset = buf - unit->dwarf_frame_buffer;
1239 if ((offset % ptr_len) != 0)
1241 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1242 buf += *bytes_read_ptr;
1246 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1249 if ((encoding & 0x07) == 0x00)
1250 encoding |= encoding_for_size (ptr_len);
1252 switch (encoding & 0x0f)
1254 case DW_EH_PE_uleb128:
1257 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1258 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1259 return base + value;
1261 case DW_EH_PE_udata2:
1262 *bytes_read_ptr += 2;
1263 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1264 case DW_EH_PE_udata4:
1265 *bytes_read_ptr += 4;
1266 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1267 case DW_EH_PE_udata8:
1268 *bytes_read_ptr += 8;
1269 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1270 case DW_EH_PE_sleb128:
1273 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1274 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1275 return base + value;
1277 case DW_EH_PE_sdata2:
1278 *bytes_read_ptr += 2;
1279 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1280 case DW_EH_PE_sdata4:
1281 *bytes_read_ptr += 4;
1282 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1283 case DW_EH_PE_sdata8:
1284 *bytes_read_ptr += 8;
1285 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1287 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1292 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1293 That's why we use a simple linked list here. */
1295 static struct dwarf2_cie *
1296 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1298 struct dwarf2_cie *cie = unit->cie;
1302 if (cie->cie_pointer == cie_pointer)
1312 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1314 cie->next = unit->cie;
1318 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1319 inital location associated with it into *PC. */
1321 static struct dwarf2_fde *
1322 dwarf2_frame_find_fde (CORE_ADDR *pc)
1324 struct objfile *objfile;
1326 ALL_OBJFILES (objfile)
1328 struct dwarf2_fde *fde;
1331 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1335 gdb_assert (objfile->section_offsets);
1336 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1340 if (*pc >= fde->initial_location + offset
1341 && *pc < fde->initial_location + offset + fde->address_range)
1343 *pc = fde->initial_location + offset;
1355 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1357 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1358 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1361 #ifdef CC_HAS_LONG_LONG
1362 #define DW64_CIE_ID 0xffffffffffffffffULL
1364 #define DW64_CIE_ID ~0
1367 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1370 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1371 the next byte to be processed. */
1373 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1375 gdb_byte *buf, *end;
1377 unsigned int bytes_read;
1380 ULONGEST cie_pointer;
1383 length = read_initial_length (unit->abfd, buf, &bytes_read);
1387 /* Are we still within the section? */
1388 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1394 /* Distinguish between 32 and 64-bit encoded frame info. */
1395 dwarf64_p = (bytes_read == 12);
1397 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1401 cie_id = DW64_CIE_ID;
1407 cie_pointer = read_8_bytes (unit->abfd, buf);
1412 cie_pointer = read_4_bytes (unit->abfd, buf);
1416 if (cie_pointer == cie_id)
1418 /* This is a CIE. */
1419 struct dwarf2_cie *cie;
1421 unsigned int cie_version;
1423 /* Record the offset into the .debug_frame section of this CIE. */
1424 cie_pointer = start - unit->dwarf_frame_buffer;
1426 /* Check whether we've already read it. */
1427 if (find_cie (unit, cie_pointer))
1430 cie = (struct dwarf2_cie *)
1431 obstack_alloc (&unit->objfile->objfile_obstack,
1432 sizeof (struct dwarf2_cie));
1433 cie->initial_instructions = NULL;
1434 cie->cie_pointer = cie_pointer;
1436 /* The encoding for FDE's in a normal .debug_frame section
1437 depends on the target address size. */
1438 cie->encoding = DW_EH_PE_absptr;
1440 /* Check version number. */
1441 cie_version = read_1_byte (unit->abfd, buf);
1442 if (cie_version != 1 && cie_version != 3)
1446 /* Interpret the interesting bits of the augmentation. */
1447 augmentation = (char *) buf;
1448 buf += (strlen (augmentation) + 1);
1450 /* The GCC 2.x "eh" augmentation has a pointer immediately
1451 following the augmentation string, so it must be handled
1453 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1456 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1460 cie->code_alignment_factor =
1461 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1464 cie->data_alignment_factor =
1465 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1468 if (cie_version == 1)
1470 cie->return_address_register = read_1_byte (unit->abfd, buf);
1474 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1478 cie->saw_z_augmentation = (*augmentation == 'z');
1479 if (cie->saw_z_augmentation)
1483 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1487 cie->initial_instructions = buf + length;
1491 while (*augmentation)
1493 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1494 if (*augmentation == 'L')
1501 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1502 else if (*augmentation == 'R')
1504 cie->encoding = *buf++;
1508 /* "P" indicates a personality routine in the CIE augmentation. */
1509 else if (*augmentation == 'P')
1511 /* Skip. Avoid indirection since we throw away the result. */
1512 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1513 read_encoded_value (unit, encoding, buf, &bytes_read);
1518 /* Otherwise we have an unknown augmentation.
1519 Bail out unless we saw a 'z' prefix. */
1522 if (cie->initial_instructions == NULL)
1525 /* Skip unknown augmentations. */
1526 buf = cie->initial_instructions;
1531 cie->initial_instructions = buf;
1534 add_cie (unit, cie);
1538 /* This is a FDE. */
1539 struct dwarf2_fde *fde;
1541 /* In an .eh_frame section, the CIE pointer is the delta between the
1542 address within the FDE where the CIE pointer is stored and the
1543 address of the CIE. Convert it to an offset into the .eh_frame
1547 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1548 cie_pointer -= (dwarf64_p ? 8 : 4);
1551 /* In either case, validate the result is still within the section. */
1552 if (cie_pointer >= unit->dwarf_frame_size)
1555 fde = (struct dwarf2_fde *)
1556 obstack_alloc (&unit->objfile->objfile_obstack,
1557 sizeof (struct dwarf2_fde));
1558 fde->cie = find_cie (unit, cie_pointer);
1559 if (fde->cie == NULL)
1561 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1563 fde->cie = find_cie (unit, cie_pointer);
1566 gdb_assert (fde->cie != NULL);
1568 fde->initial_location =
1569 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1572 fde->address_range =
1573 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1576 /* A 'z' augmentation in the CIE implies the presence of an
1577 augmentation field in the FDE as well. The only thing known
1578 to be in here at present is the LSDA entry for EH. So we
1579 can skip the whole thing. */
1580 if (fde->cie->saw_z_augmentation)
1584 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1585 buf += bytes_read + length;
1590 fde->instructions = buf;
1593 add_fde (unit, fde);
1599 /* Read a CIE or FDE in BUF and decode it. */
1601 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1603 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1606 ptrdiff_t start_offset;
1610 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1614 /* We have corrupt input data of some form. */
1616 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1617 and mismatches wrt padding and alignment of debug sections. */
1618 /* Note that there is no requirement in the standard for any
1619 alignment at all in the frame unwind sections. Testing for
1620 alignment before trying to interpret data would be incorrect.
1622 However, GCC traditionally arranged for frame sections to be
1623 sized such that the FDE length and CIE fields happen to be
1624 aligned (in theory, for performance). This, unfortunately,
1625 was done with .align directives, which had the side effect of
1626 forcing the section to be aligned by the linker.
1628 This becomes a problem when you have some other producer that
1629 creates frame sections that are not as strictly aligned. That
1630 produces a hole in the frame info that gets filled by the
1633 The GCC behaviour is arguably a bug, but it's effectively now
1634 part of the ABI, so we're now stuck with it, at least at the
1635 object file level. A smart linker may decide, in the process
1636 of compressing duplicate CIE information, that it can rewrite
1637 the entire output section without this extra padding. */
1639 start_offset = start - unit->dwarf_frame_buffer;
1640 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1642 start += 4 - (start_offset & 3);
1643 workaround = ALIGN4;
1646 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1648 start += 8 - (start_offset & 7);
1649 workaround = ALIGN8;
1653 /* Nothing left to try. Arrange to return as if we've consumed
1654 the entire input section. Hopefully we'll get valid info from
1655 the other of .debug_frame/.eh_frame. */
1657 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1667 complaint (&symfile_complaints,
1668 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1669 unit->dwarf_frame_section->owner->filename,
1670 unit->dwarf_frame_section->name);
1674 complaint (&symfile_complaints,
1675 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1676 unit->dwarf_frame_section->owner->filename,
1677 unit->dwarf_frame_section->name);
1681 complaint (&symfile_complaints,
1682 _("Corrupt data in %s:%s"),
1683 unit->dwarf_frame_section->owner->filename,
1684 unit->dwarf_frame_section->name);
1692 /* FIXME: kettenis/20030504: This still needs to be integrated with
1693 dwarf2read.c in a better way. */
1695 /* Imported from dwarf2read.c. */
1696 extern asection *dwarf_frame_section;
1697 extern asection *dwarf_eh_frame_section;
1699 /* Imported from dwarf2read.c. */
1700 extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1703 dwarf2_build_frame_info (struct objfile *objfile)
1705 struct comp_unit unit;
1706 gdb_byte *frame_ptr;
1708 /* Build a minimal decoding of the DWARF2 compilation unit. */
1709 unit.abfd = objfile->obfd;
1710 unit.objfile = objfile;
1714 /* First add the information from the .eh_frame section. That way,
1715 the FDEs from that section are searched last. */
1716 if (dwarf_eh_frame_section)
1718 asection *got, *txt;
1721 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1722 dwarf_eh_frame_section);
1724 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1725 unit.dwarf_frame_section = dwarf_eh_frame_section;
1727 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1728 that is used for the i386/amd64 target, which currently is
1729 the only target in GCC that supports/uses the
1730 DW_EH_PE_datarel encoding. */
1731 got = bfd_get_section_by_name (unit.abfd, ".got");
1733 unit.dbase = got->vma;
1735 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1737 txt = bfd_get_section_by_name (unit.abfd, ".text");
1739 unit.tbase = txt->vma;
1741 frame_ptr = unit.dwarf_frame_buffer;
1742 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1743 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
1746 if (dwarf_frame_section)
1749 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1750 dwarf_frame_section);
1751 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1752 unit.dwarf_frame_section = dwarf_frame_section;
1754 frame_ptr = unit.dwarf_frame_buffer;
1755 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1756 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1760 /* Provide a prototype to silence -Wmissing-prototypes. */
1761 void _initialize_dwarf2_frame (void);
1764 _initialize_dwarf2_frame (void)
1766 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
1767 dwarf2_frame_objfile_data = register_objfile_data ();