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"
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 *,
510 struct frame_info *);
512 /* Check whether the frame preceding NEXT_FRAME will be a signal
514 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
517 /* Default architecture-specific register state initialization
521 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
522 struct dwarf2_frame_state_reg *reg,
523 struct frame_info *next_frame)
525 /* If we have a register that acts as a program counter, mark it as
526 a destination for the return address. If we have a register that
527 serves as the stack pointer, arrange for it to be filled with the
528 call frame address (CFA). The other registers are marked as
531 We copy the return address to the program counter, since many
532 parts in GDB assume that it is possible to get the return address
533 by unwinding the program counter register. However, on ISA's
534 with a dedicated return address register, the CFI usually only
535 contains information to unwind that return address register.
537 The reason we're treating the stack pointer special here is
538 because in many cases GCC doesn't emit CFI for the stack pointer
539 and implicitly assumes that it is equal to the CFA. This makes
540 some sense since the DWARF specification (version 3, draft 8,
543 "Typically, the CFA is defined to be the value of the stack
544 pointer at the call site in the previous frame (which may be
545 different from its value on entry to the current frame)."
547 However, this isn't true for all platforms supported by GCC
548 (e.g. IBM S/390 and zSeries). Those architectures should provide
549 their own architecture-specific initialization function. */
551 if (regnum == PC_REGNUM)
552 reg->how = DWARF2_FRAME_REG_RA;
553 else if (regnum == SP_REGNUM)
554 reg->how = DWARF2_FRAME_REG_CFA;
557 /* Return a default for the architecture-specific operations. */
560 dwarf2_frame_init (struct obstack *obstack)
562 struct dwarf2_frame_ops *ops;
564 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
565 ops->init_reg = dwarf2_frame_default_init_reg;
569 /* Set the architecture-specific register state initialization
570 function for GDBARCH to INIT_REG. */
573 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
574 void (*init_reg) (struct gdbarch *, int,
575 struct dwarf2_frame_state_reg *,
576 struct frame_info *))
578 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
580 ops->init_reg = init_reg;
583 /* Pre-initialize the register state REG for register REGNUM. */
586 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
587 struct dwarf2_frame_state_reg *reg,
588 struct frame_info *next_frame)
590 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
592 ops->init_reg (gdbarch, regnum, reg, next_frame);
595 /* Set the architecture-specific signal trampoline recognition
596 function for GDBARCH to SIGNAL_FRAME_P. */
599 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
600 int (*signal_frame_p) (struct gdbarch *,
601 struct frame_info *))
603 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
605 ops->signal_frame_p = signal_frame_p;
608 /* Query the architecture-specific signal frame recognizer for
612 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
613 struct frame_info *next_frame)
615 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
617 if (ops->signal_frame_p == NULL)
619 return ops->signal_frame_p (gdbarch, next_frame);
623 struct dwarf2_frame_cache
625 /* DWARF Call Frame Address. */
628 /* Set if the return address column was marked as undefined. */
629 int undefined_retaddr;
631 /* Saved registers, indexed by GDB register number, not by DWARF
633 struct dwarf2_frame_state_reg *reg;
635 /* Return address register. */
636 struct dwarf2_frame_state_reg retaddr_reg;
639 static struct dwarf2_frame_cache *
640 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
642 struct cleanup *old_chain;
643 struct gdbarch *gdbarch = get_frame_arch (next_frame);
644 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
645 struct dwarf2_frame_cache *cache;
646 struct dwarf2_frame_state *fs;
647 struct dwarf2_fde *fde;
652 /* Allocate a new cache. */
653 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
654 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
656 /* Allocate and initialize the frame state. */
657 fs = XMALLOC (struct dwarf2_frame_state);
658 memset (fs, 0, sizeof (struct dwarf2_frame_state));
659 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
663 Note that if NEXT_FRAME is never supposed to return (i.e. a call
664 to abort), the compiler might optimize away the instruction at
665 NEXT_FRAME's return address. As a result the return address will
666 point at some random instruction, and the CFI for that
667 instruction is probably worthless to us. GCC's unwinder solves
668 this problem by substracting 1 from the return address to get an
669 address in the middle of a presumed call instruction (or the
670 instruction in the associated delay slot). This should only be
671 done for "normal" frames and not for resume-type frames (signal
672 handlers, sentinel frames, dummy frames). The function
673 frame_unwind_address_in_block does just this. It's not clear how
674 reliable the method is though; there is the potential for the
675 register state pre-call being different to that on return. */
676 fs->pc = frame_unwind_address_in_block (next_frame);
678 /* Find the correct FDE. */
679 fde = dwarf2_frame_find_fde (&fs->pc);
680 gdb_assert (fde != NULL);
682 /* Extract any interesting information from the CIE. */
683 fs->data_align = fde->cie->data_alignment_factor;
684 fs->code_align = fde->cie->code_alignment_factor;
685 fs->retaddr_column = fde->cie->return_address_register;
687 /* First decode all the insns in the CIE. */
688 execute_cfa_program (fde->cie->initial_instructions,
689 fde->cie->end, next_frame, fs);
691 /* Save the initialized register set. */
692 fs->initial = fs->regs;
693 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
695 /* Then decode the insns in the FDE up to our target PC. */
696 execute_cfa_program (fde->instructions, fde->end, next_frame, fs);
698 /* Caclulate the CFA. */
702 cache->cfa = read_reg (next_frame, fs->cfa_reg);
703 cache->cfa += fs->cfa_offset;
708 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
712 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
715 /* Initialize the register state. */
719 for (regnum = 0; regnum < num_regs; regnum++)
720 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
723 /* Go through the DWARF2 CFI generated table and save its register
724 location information in the cache. Note that we don't skip the
725 return address column; it's perfectly all right for it to
726 correspond to a real register. If it doesn't correspond to a
727 real register, or if we shouldn't treat it as such,
728 DWARF2_REG_TO_REGNUM should be defined to return a number outside
729 the range [0, NUM_REGS). */
731 int column; /* CFI speak for "register number". */
733 for (column = 0; column < fs->regs.num_regs; column++)
735 /* Use the GDB register number as the destination index. */
736 int regnum = DWARF2_REG_TO_REGNUM (column);
738 /* If there's no corresponding GDB register, ignore it. */
739 if (regnum < 0 || regnum >= num_regs)
742 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
743 of all debug info registers. If it doesn't, complain (but
744 not too loudly). It turns out that GCC assumes that an
745 unspecified register implies "same value" when CFI (draft
746 7) specifies nothing at all. Such a register could equally
747 be interpreted as "undefined". Also note that this check
748 isn't sufficient; it only checks that all registers in the
749 range [0 .. max column] are specified, and won't detect
750 problems when a debug info register falls outside of the
751 table. We need a way of iterating through all the valid
752 DWARF2 register numbers. */
753 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
755 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
756 complaint (&symfile_complaints, _("\
757 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
758 gdbarch_register_name (gdbarch, regnum),
762 cache->reg[regnum] = fs->regs.reg[column];
766 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
767 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
771 for (regnum = 0; regnum < num_regs; regnum++)
773 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
774 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
776 struct dwarf2_frame_state_reg *retaddr_reg =
777 &fs->regs.reg[fs->retaddr_column];
779 /* It seems rather bizarre to specify an "empty" column as
780 the return adress column. However, this is exactly
781 what GCC does on some targets. It turns out that GCC
782 assumes that the return address can be found in the
783 register corresponding to the return address column.
784 Incidentally, that's how we should treat a return
785 address column specifying "same value" too. */
786 if (fs->retaddr_column < fs->regs.num_regs
787 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
788 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
790 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
791 cache->reg[regnum] = *retaddr_reg;
793 cache->retaddr_reg = *retaddr_reg;
797 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
799 cache->reg[regnum].loc.reg = fs->retaddr_column;
800 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
804 cache->retaddr_reg.loc.reg = fs->retaddr_column;
805 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
812 if (fs->retaddr_column < fs->regs.num_regs
813 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
814 cache->undefined_retaddr = 1;
816 do_cleanups (old_chain);
823 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
824 struct frame_id *this_id)
826 struct dwarf2_frame_cache *cache =
827 dwarf2_frame_cache (next_frame, this_cache);
829 if (cache->undefined_retaddr)
832 (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame));
836 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
837 int regnum, int *optimizedp,
838 enum lval_type *lvalp, CORE_ADDR *addrp,
839 int *realnump, gdb_byte *valuep)
841 struct gdbarch *gdbarch = get_frame_arch (next_frame);
842 struct dwarf2_frame_cache *cache =
843 dwarf2_frame_cache (next_frame, this_cache);
845 switch (cache->reg[regnum].how)
847 case DWARF2_FRAME_REG_UNDEFINED:
848 /* If CFI explicitly specified that the value isn't defined,
849 mark it as optimized away; the value isn't available. */
856 /* In some cases, for example %eflags on the i386, we have
857 to provide a sane value, even though this register wasn't
858 saved. Assume we can get it from NEXT_FRAME. */
859 frame_unwind_register (next_frame, regnum, valuep);
863 case DWARF2_FRAME_REG_SAVED_OFFSET:
865 *lvalp = lval_memory;
866 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
870 /* Read the value in from memory. */
871 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
875 case DWARF2_FRAME_REG_SAVED_REG:
877 *lvalp = lval_register;
879 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
881 frame_unwind_register (next_frame, (*realnump), valuep);
884 case DWARF2_FRAME_REG_SAVED_EXP:
886 *lvalp = lval_memory;
887 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
888 cache->reg[regnum].exp_len,
889 next_frame, cache->cfa);
893 /* Read the value in from memory. */
894 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
898 case DWARF2_FRAME_REG_UNSPECIFIED:
899 /* GCC, in its infinite wisdom decided to not provide unwind
900 information for registers that are "same value". Since
901 DWARF2 (3 draft 7) doesn't define such behavior, said
902 registers are actually undefined (which is different to CFI
903 "undefined"). Code above issues a complaint about this.
904 Here just fudge the books, assume GCC, and that the value is
905 more inner on the stack. */
907 *lvalp = lval_register;
911 frame_unwind_register (next_frame, (*realnump), valuep);
914 case DWARF2_FRAME_REG_SAME_VALUE:
916 *lvalp = lval_register;
920 frame_unwind_register (next_frame, (*realnump), valuep);
923 case DWARF2_FRAME_REG_CFA:
930 /* Store the value. */
931 store_typed_address (valuep, builtin_type_void_data_ptr, cache->cfa);
935 case DWARF2_FRAME_REG_CFA_OFFSET:
942 /* Store the value. */
943 store_typed_address (valuep, builtin_type_void_data_ptr,
944 cache->cfa + cache->reg[regnum].loc.offset);
948 case DWARF2_FRAME_REG_RA_OFFSET:
955 CORE_ADDR pc = cache->reg[regnum].loc.offset;
957 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
958 pc += frame_unwind_register_unsigned (next_frame, regnum);
959 store_typed_address (valuep, builtin_type_void_func_ptr, pc);
964 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
968 static const struct frame_unwind dwarf2_frame_unwind =
971 dwarf2_frame_this_id,
972 dwarf2_frame_prev_register
975 static const struct frame_unwind dwarf2_signal_frame_unwind =
978 dwarf2_frame_this_id,
979 dwarf2_frame_prev_register
982 const struct frame_unwind *
983 dwarf2_frame_sniffer (struct frame_info *next_frame)
985 /* Grab an address that is guarenteed to reside somewhere within the
986 function. frame_pc_unwind(), for a no-return next function, can
987 end up returning something past the end of this function's body. */
988 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
989 if (!dwarf2_frame_find_fde (&block_addr))
992 /* On some targets, signal trampolines may have unwind information.
993 We need to recognize them so that we set the frame type
996 if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
998 return &dwarf2_signal_frame_unwind;
1000 return &dwarf2_frame_unwind;
1004 /* There is no explicitly defined relationship between the CFA and the
1005 location of frame's local variables and arguments/parameters.
1006 Therefore, frame base methods on this page should probably only be
1007 used as a last resort, just to avoid printing total garbage as a
1008 response to the "info frame" command. */
1011 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1013 struct dwarf2_frame_cache *cache =
1014 dwarf2_frame_cache (next_frame, this_cache);
1019 static const struct frame_base dwarf2_frame_base =
1021 &dwarf2_frame_unwind,
1022 dwarf2_frame_base_address,
1023 dwarf2_frame_base_address,
1024 dwarf2_frame_base_address
1027 const struct frame_base *
1028 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1030 CORE_ADDR pc = frame_pc_unwind (next_frame);
1031 if (dwarf2_frame_find_fde (&pc))
1032 return &dwarf2_frame_base;
1037 /* A minimal decoding of DWARF2 compilation units. We only decode
1038 what's needed to get to the call frame information. */
1042 /* Keep the bfd convenient. */
1045 struct objfile *objfile;
1047 /* Linked list of CIEs for this object. */
1048 struct dwarf2_cie *cie;
1050 /* Pointer to the .debug_frame section loaded into memory. */
1051 gdb_byte *dwarf_frame_buffer;
1053 /* Length of the loaded .debug_frame section. */
1054 unsigned long dwarf_frame_size;
1056 /* Pointer to the .debug_frame section. */
1057 asection *dwarf_frame_section;
1059 /* Base for DW_EH_PE_datarel encodings. */
1062 /* Base for DW_EH_PE_textrel encodings. */
1066 const struct objfile_data *dwarf2_frame_objfile_data;
1069 read_1_byte (bfd *abfd, gdb_byte *buf)
1071 return bfd_get_8 (abfd, buf);
1075 read_4_bytes (bfd *abfd, gdb_byte *buf)
1077 return bfd_get_32 (abfd, buf);
1081 read_8_bytes (bfd *abfd, gdb_byte *buf)
1083 return bfd_get_64 (abfd, buf);
1087 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1090 unsigned int num_read;
1100 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1103 result |= ((byte & 0x7f) << shift);
1106 while (byte & 0x80);
1108 *bytes_read_ptr = num_read;
1114 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1118 unsigned int num_read;
1127 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1130 result |= ((byte & 0x7f) << shift);
1133 while (byte & 0x80);
1135 if (shift < 8 * sizeof (result) && (byte & 0x40))
1136 result |= -(((LONGEST)1) << shift);
1138 *bytes_read_ptr = num_read;
1144 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1148 result = bfd_get_32 (abfd, buf);
1149 if (result == 0xffffffff)
1151 result = bfd_get_64 (abfd, buf + 4);
1152 *bytes_read_ptr = 12;
1155 *bytes_read_ptr = 4;
1161 /* Pointer encoding helper functions. */
1163 /* GCC supports exception handling based on DWARF2 CFI. However, for
1164 technical reasons, it encodes addresses in its FDE's in a different
1165 way. Several "pointer encodings" are supported. The encoding
1166 that's used for a particular FDE is determined by the 'R'
1167 augmentation in the associated CIE. The argument of this
1168 augmentation is a single byte.
1170 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1171 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1172 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1173 address should be interpreted (absolute, relative to the current
1174 position in the FDE, ...). Bit 7, indicates that the address
1175 should be dereferenced. */
1178 encoding_for_size (unsigned int size)
1183 return DW_EH_PE_udata2;
1185 return DW_EH_PE_udata4;
1187 return DW_EH_PE_udata8;
1189 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1194 size_of_encoded_value (gdb_byte encoding)
1196 if (encoding == DW_EH_PE_omit)
1199 switch (encoding & 0x07)
1201 case DW_EH_PE_absptr:
1202 return TYPE_LENGTH (builtin_type_void_data_ptr);
1203 case DW_EH_PE_udata2:
1205 case DW_EH_PE_udata4:
1207 case DW_EH_PE_udata8:
1210 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1215 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1216 gdb_byte *buf, unsigned int *bytes_read_ptr)
1218 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1222 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1224 if (encoding & DW_EH_PE_indirect)
1225 internal_error (__FILE__, __LINE__,
1226 _("Unsupported encoding: DW_EH_PE_indirect"));
1228 *bytes_read_ptr = 0;
1230 switch (encoding & 0x70)
1232 case DW_EH_PE_absptr:
1235 case DW_EH_PE_pcrel:
1236 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1237 base += (buf - unit->dwarf_frame_buffer);
1239 case DW_EH_PE_datarel:
1242 case DW_EH_PE_textrel:
1245 case DW_EH_PE_funcrel:
1246 /* FIXME: kettenis/20040501: For now just pretend
1247 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1248 reading the initial location of an FDE it should be treated
1249 as such, and currently that's the only place where this code
1253 case DW_EH_PE_aligned:
1255 offset = buf - unit->dwarf_frame_buffer;
1256 if ((offset % ptr_len) != 0)
1258 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1259 buf += *bytes_read_ptr;
1263 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1266 if ((encoding & 0x07) == 0x00)
1267 encoding |= encoding_for_size (ptr_len);
1269 switch (encoding & 0x0f)
1271 case DW_EH_PE_uleb128:
1274 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1275 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1276 return base + value;
1278 case DW_EH_PE_udata2:
1279 *bytes_read_ptr += 2;
1280 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1281 case DW_EH_PE_udata4:
1282 *bytes_read_ptr += 4;
1283 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1284 case DW_EH_PE_udata8:
1285 *bytes_read_ptr += 8;
1286 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1287 case DW_EH_PE_sleb128:
1290 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1291 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1292 return base + value;
1294 case DW_EH_PE_sdata2:
1295 *bytes_read_ptr += 2;
1296 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1297 case DW_EH_PE_sdata4:
1298 *bytes_read_ptr += 4;
1299 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1300 case DW_EH_PE_sdata8:
1301 *bytes_read_ptr += 8;
1302 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1304 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1309 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1310 That's why we use a simple linked list here. */
1312 static struct dwarf2_cie *
1313 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1315 struct dwarf2_cie *cie = unit->cie;
1319 if (cie->cie_pointer == cie_pointer)
1329 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1331 cie->next = unit->cie;
1335 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1336 inital location associated with it into *PC. */
1338 static struct dwarf2_fde *
1339 dwarf2_frame_find_fde (CORE_ADDR *pc)
1341 struct objfile *objfile;
1343 ALL_OBJFILES (objfile)
1345 struct dwarf2_fde *fde;
1348 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1352 gdb_assert (objfile->section_offsets);
1353 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1357 if (*pc >= fde->initial_location + offset
1358 && *pc < fde->initial_location + offset + fde->address_range)
1360 *pc = fde->initial_location + offset;
1372 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1374 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1375 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1378 #ifdef CC_HAS_LONG_LONG
1379 #define DW64_CIE_ID 0xffffffffffffffffULL
1381 #define DW64_CIE_ID ~0
1384 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1387 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1388 the next byte to be processed. */
1390 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1392 gdb_byte *buf, *end;
1394 unsigned int bytes_read;
1397 ULONGEST cie_pointer;
1400 length = read_initial_length (unit->abfd, buf, &bytes_read);
1404 /* Are we still within the section? */
1405 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1411 /* Distinguish between 32 and 64-bit encoded frame info. */
1412 dwarf64_p = (bytes_read == 12);
1414 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1418 cie_id = DW64_CIE_ID;
1424 cie_pointer = read_8_bytes (unit->abfd, buf);
1429 cie_pointer = read_4_bytes (unit->abfd, buf);
1433 if (cie_pointer == cie_id)
1435 /* This is a CIE. */
1436 struct dwarf2_cie *cie;
1438 unsigned int cie_version;
1440 /* Record the offset into the .debug_frame section of this CIE. */
1441 cie_pointer = start - unit->dwarf_frame_buffer;
1443 /* Check whether we've already read it. */
1444 if (find_cie (unit, cie_pointer))
1447 cie = (struct dwarf2_cie *)
1448 obstack_alloc (&unit->objfile->objfile_obstack,
1449 sizeof (struct dwarf2_cie));
1450 cie->initial_instructions = NULL;
1451 cie->cie_pointer = cie_pointer;
1453 /* The encoding for FDE's in a normal .debug_frame section
1454 depends on the target address size. */
1455 cie->encoding = DW_EH_PE_absptr;
1457 /* Check version number. */
1458 cie_version = read_1_byte (unit->abfd, buf);
1459 if (cie_version != 1 && cie_version != 3)
1463 /* Interpret the interesting bits of the augmentation. */
1464 augmentation = (char *) buf;
1465 buf += (strlen (augmentation) + 1);
1467 /* The GCC 2.x "eh" augmentation has a pointer immediately
1468 following the augmentation string, so it must be handled
1470 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1473 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1477 cie->code_alignment_factor =
1478 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1481 cie->data_alignment_factor =
1482 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1485 if (cie_version == 1)
1487 cie->return_address_register = read_1_byte (unit->abfd, buf);
1491 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1495 cie->saw_z_augmentation = (*augmentation == 'z');
1496 if (cie->saw_z_augmentation)
1500 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1504 cie->initial_instructions = buf + length;
1508 while (*augmentation)
1510 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1511 if (*augmentation == 'L')
1518 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1519 else if (*augmentation == 'R')
1521 cie->encoding = *buf++;
1525 /* "P" indicates a personality routine in the CIE augmentation. */
1526 else if (*augmentation == 'P')
1528 /* Skip. Avoid indirection since we throw away the result. */
1529 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1530 read_encoded_value (unit, encoding, buf, &bytes_read);
1535 /* Otherwise we have an unknown augmentation.
1536 Bail out unless we saw a 'z' prefix. */
1539 if (cie->initial_instructions == NULL)
1542 /* Skip unknown augmentations. */
1543 buf = cie->initial_instructions;
1548 cie->initial_instructions = buf;
1551 add_cie (unit, cie);
1555 /* This is a FDE. */
1556 struct dwarf2_fde *fde;
1558 /* In an .eh_frame section, the CIE pointer is the delta between the
1559 address within the FDE where the CIE pointer is stored and the
1560 address of the CIE. Convert it to an offset into the .eh_frame
1564 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1565 cie_pointer -= (dwarf64_p ? 8 : 4);
1568 /* In either case, validate the result is still within the section. */
1569 if (cie_pointer >= unit->dwarf_frame_size)
1572 fde = (struct dwarf2_fde *)
1573 obstack_alloc (&unit->objfile->objfile_obstack,
1574 sizeof (struct dwarf2_fde));
1575 fde->cie = find_cie (unit, cie_pointer);
1576 if (fde->cie == NULL)
1578 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1580 fde->cie = find_cie (unit, cie_pointer);
1583 gdb_assert (fde->cie != NULL);
1585 fde->initial_location =
1586 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1589 fde->address_range =
1590 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1593 /* A 'z' augmentation in the CIE implies the presence of an
1594 augmentation field in the FDE as well. The only thing known
1595 to be in here at present is the LSDA entry for EH. So we
1596 can skip the whole thing. */
1597 if (fde->cie->saw_z_augmentation)
1601 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1602 buf += bytes_read + length;
1607 fde->instructions = buf;
1610 add_fde (unit, fde);
1616 /* Read a CIE or FDE in BUF and decode it. */
1618 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1620 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1623 ptrdiff_t start_offset;
1627 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1631 /* We have corrupt input data of some form. */
1633 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1634 and mismatches wrt padding and alignment of debug sections. */
1635 /* Note that there is no requirement in the standard for any
1636 alignment at all in the frame unwind sections. Testing for
1637 alignment before trying to interpret data would be incorrect.
1639 However, GCC traditionally arranged for frame sections to be
1640 sized such that the FDE length and CIE fields happen to be
1641 aligned (in theory, for performance). This, unfortunately,
1642 was done with .align directives, which had the side effect of
1643 forcing the section to be aligned by the linker.
1645 This becomes a problem when you have some other producer that
1646 creates frame sections that are not as strictly aligned. That
1647 produces a hole in the frame info that gets filled by the
1650 The GCC behaviour is arguably a bug, but it's effectively now
1651 part of the ABI, so we're now stuck with it, at least at the
1652 object file level. A smart linker may decide, in the process
1653 of compressing duplicate CIE information, that it can rewrite
1654 the entire output section without this extra padding. */
1656 start_offset = start - unit->dwarf_frame_buffer;
1657 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1659 start += 4 - (start_offset & 3);
1660 workaround = ALIGN4;
1663 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1665 start += 8 - (start_offset & 7);
1666 workaround = ALIGN8;
1670 /* Nothing left to try. Arrange to return as if we've consumed
1671 the entire input section. Hopefully we'll get valid info from
1672 the other of .debug_frame/.eh_frame. */
1674 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1684 complaint (&symfile_complaints,
1685 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1686 unit->dwarf_frame_section->owner->filename,
1687 unit->dwarf_frame_section->name);
1691 complaint (&symfile_complaints,
1692 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1693 unit->dwarf_frame_section->owner->filename,
1694 unit->dwarf_frame_section->name);
1698 complaint (&symfile_complaints,
1699 _("Corrupt data in %s:%s"),
1700 unit->dwarf_frame_section->owner->filename,
1701 unit->dwarf_frame_section->name);
1709 /* FIXME: kettenis/20030504: This still needs to be integrated with
1710 dwarf2read.c in a better way. */
1712 /* Imported from dwarf2read.c. */
1713 extern asection *dwarf_frame_section;
1714 extern asection *dwarf_eh_frame_section;
1716 /* Imported from dwarf2read.c. */
1717 extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1720 dwarf2_build_frame_info (struct objfile *objfile)
1722 struct comp_unit unit;
1723 gdb_byte *frame_ptr;
1725 /* Build a minimal decoding of the DWARF2 compilation unit. */
1726 unit.abfd = objfile->obfd;
1727 unit.objfile = objfile;
1731 /* First add the information from the .eh_frame section. That way,
1732 the FDEs from that section are searched last. */
1733 if (dwarf_eh_frame_section)
1735 asection *got, *txt;
1738 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1739 dwarf_eh_frame_section);
1741 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1742 unit.dwarf_frame_section = dwarf_eh_frame_section;
1744 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1745 that is used for the i386/amd64 target, which currently is
1746 the only target in GCC that supports/uses the
1747 DW_EH_PE_datarel encoding. */
1748 got = bfd_get_section_by_name (unit.abfd, ".got");
1750 unit.dbase = got->vma;
1752 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1754 txt = bfd_get_section_by_name (unit.abfd, ".text");
1756 unit.tbase = txt->vma;
1758 frame_ptr = unit.dwarf_frame_buffer;
1759 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1760 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
1763 if (dwarf_frame_section)
1766 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1767 dwarf_frame_section);
1768 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1769 unit.dwarf_frame_section = dwarf_frame_section;
1771 frame_ptr = unit.dwarf_frame_buffer;
1772 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1773 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1777 /* Provide a prototype to silence -Wmissing-prototypes. */
1778 void _initialize_dwarf2_frame (void);
1781 _initialize_dwarf2_frame (void)
1783 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
1784 dwarf2_frame_objfile_data = register_objfile_data ();