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 *);
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_CFA_OFFSET:
938 /* Store the value. */
939 store_typed_address (valuep, builtin_type_void_data_ptr,
940 cache->cfa + cache->reg[regnum].loc.offset);
944 case DWARF2_FRAME_REG_RA_OFFSET:
951 CORE_ADDR pc = cache->reg[regnum].loc.offset;
953 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
954 pc += frame_unwind_register_unsigned (next_frame, regnum);
955 store_typed_address (valuep, builtin_type_void_func_ptr, pc);
960 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
964 static const struct frame_unwind dwarf2_frame_unwind =
967 dwarf2_frame_this_id,
968 dwarf2_frame_prev_register
971 static const struct frame_unwind dwarf2_signal_frame_unwind =
974 dwarf2_frame_this_id,
975 dwarf2_frame_prev_register
978 const struct frame_unwind *
979 dwarf2_frame_sniffer (struct frame_info *next_frame)
981 /* Grab an address that is guarenteed to reside somewhere within the
982 function. frame_pc_unwind(), for a no-return next function, can
983 end up returning something past the end of this function's body. */
984 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame);
985 if (!dwarf2_frame_find_fde (&block_addr))
988 /* On some targets, signal trampolines may have unwind information.
989 We need to recognize them so that we set the frame type
992 if (dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
994 return &dwarf2_signal_frame_unwind;
996 return &dwarf2_frame_unwind;
1000 /* There is no explicitly defined relationship between the CFA and the
1001 location of frame's local variables and arguments/parameters.
1002 Therefore, frame base methods on this page should probably only be
1003 used as a last resort, just to avoid printing total garbage as a
1004 response to the "info frame" command. */
1007 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1009 struct dwarf2_frame_cache *cache =
1010 dwarf2_frame_cache (next_frame, this_cache);
1015 static const struct frame_base dwarf2_frame_base =
1017 &dwarf2_frame_unwind,
1018 dwarf2_frame_base_address,
1019 dwarf2_frame_base_address,
1020 dwarf2_frame_base_address
1023 const struct frame_base *
1024 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1026 CORE_ADDR pc = frame_pc_unwind (next_frame);
1027 if (dwarf2_frame_find_fde (&pc))
1028 return &dwarf2_frame_base;
1033 /* A minimal decoding of DWARF2 compilation units. We only decode
1034 what's needed to get to the call frame information. */
1038 /* Keep the bfd convenient. */
1041 struct objfile *objfile;
1043 /* Linked list of CIEs for this object. */
1044 struct dwarf2_cie *cie;
1046 /* Pointer to the .debug_frame section loaded into memory. */
1047 gdb_byte *dwarf_frame_buffer;
1049 /* Length of the loaded .debug_frame section. */
1050 unsigned long dwarf_frame_size;
1052 /* Pointer to the .debug_frame section. */
1053 asection *dwarf_frame_section;
1055 /* Base for DW_EH_PE_datarel encodings. */
1058 /* Base for DW_EH_PE_textrel encodings. */
1062 const struct objfile_data *dwarf2_frame_objfile_data;
1065 read_1_byte (bfd *abfd, gdb_byte *buf)
1067 return bfd_get_8 (abfd, buf);
1071 read_4_bytes (bfd *abfd, gdb_byte *buf)
1073 return bfd_get_32 (abfd, buf);
1077 read_8_bytes (bfd *abfd, gdb_byte *buf)
1079 return bfd_get_64 (abfd, buf);
1083 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1086 unsigned int num_read;
1096 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1099 result |= ((byte & 0x7f) << shift);
1102 while (byte & 0x80);
1104 *bytes_read_ptr = num_read;
1110 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1114 unsigned int num_read;
1123 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1126 result |= ((byte & 0x7f) << shift);
1129 while (byte & 0x80);
1131 if (shift < 8 * sizeof (result) && (byte & 0x40))
1132 result |= -(((LONGEST)1) << shift);
1134 *bytes_read_ptr = num_read;
1140 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1144 result = bfd_get_32 (abfd, buf);
1145 if (result == 0xffffffff)
1147 result = bfd_get_64 (abfd, buf + 4);
1148 *bytes_read_ptr = 12;
1151 *bytes_read_ptr = 4;
1157 /* Pointer encoding helper functions. */
1159 /* GCC supports exception handling based on DWARF2 CFI. However, for
1160 technical reasons, it encodes addresses in its FDE's in a different
1161 way. Several "pointer encodings" are supported. The encoding
1162 that's used for a particular FDE is determined by the 'R'
1163 augmentation in the associated CIE. The argument of this
1164 augmentation is a single byte.
1166 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1167 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1168 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1169 address should be interpreted (absolute, relative to the current
1170 position in the FDE, ...). Bit 7, indicates that the address
1171 should be dereferenced. */
1174 encoding_for_size (unsigned int size)
1179 return DW_EH_PE_udata2;
1181 return DW_EH_PE_udata4;
1183 return DW_EH_PE_udata8;
1185 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1190 size_of_encoded_value (gdb_byte encoding)
1192 if (encoding == DW_EH_PE_omit)
1195 switch (encoding & 0x07)
1197 case DW_EH_PE_absptr:
1198 return TYPE_LENGTH (builtin_type_void_data_ptr);
1199 case DW_EH_PE_udata2:
1201 case DW_EH_PE_udata4:
1203 case DW_EH_PE_udata8:
1206 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1211 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1212 gdb_byte *buf, unsigned int *bytes_read_ptr)
1214 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1218 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1220 if (encoding & DW_EH_PE_indirect)
1221 internal_error (__FILE__, __LINE__,
1222 _("Unsupported encoding: DW_EH_PE_indirect"));
1224 *bytes_read_ptr = 0;
1226 switch (encoding & 0x70)
1228 case DW_EH_PE_absptr:
1231 case DW_EH_PE_pcrel:
1232 base = bfd_get_section_vma (unit->bfd, unit->dwarf_frame_section);
1233 base += (buf - unit->dwarf_frame_buffer);
1235 case DW_EH_PE_datarel:
1238 case DW_EH_PE_textrel:
1241 case DW_EH_PE_funcrel:
1242 /* FIXME: kettenis/20040501: For now just pretend
1243 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1244 reading the initial location of an FDE it should be treated
1245 as such, and currently that's the only place where this code
1249 case DW_EH_PE_aligned:
1251 offset = buf - unit->dwarf_frame_buffer;
1252 if ((offset % ptr_len) != 0)
1254 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1255 buf += *bytes_read_ptr;
1259 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1262 if ((encoding & 0x07) == 0x00)
1263 encoding |= encoding_for_size (ptr_len);
1265 switch (encoding & 0x0f)
1267 case DW_EH_PE_uleb128:
1270 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1271 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1272 return base + value;
1274 case DW_EH_PE_udata2:
1275 *bytes_read_ptr += 2;
1276 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1277 case DW_EH_PE_udata4:
1278 *bytes_read_ptr += 4;
1279 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1280 case DW_EH_PE_udata8:
1281 *bytes_read_ptr += 8;
1282 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1283 case DW_EH_PE_sleb128:
1286 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1287 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1288 return base + value;
1290 case DW_EH_PE_sdata2:
1291 *bytes_read_ptr += 2;
1292 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1293 case DW_EH_PE_sdata4:
1294 *bytes_read_ptr += 4;
1295 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1296 case DW_EH_PE_sdata8:
1297 *bytes_read_ptr += 8;
1298 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1300 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1305 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1306 That's why we use a simple linked list here. */
1308 static struct dwarf2_cie *
1309 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1311 struct dwarf2_cie *cie = unit->cie;
1315 if (cie->cie_pointer == cie_pointer)
1325 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1327 cie->next = unit->cie;
1331 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1332 inital location associated with it into *PC. */
1334 static struct dwarf2_fde *
1335 dwarf2_frame_find_fde (CORE_ADDR *pc)
1337 struct objfile *objfile;
1339 ALL_OBJFILES (objfile)
1341 struct dwarf2_fde *fde;
1344 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1348 gdb_assert (objfile->section_offsets);
1349 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1353 if (*pc >= fde->initial_location + offset
1354 && *pc < fde->initial_location + offset + fde->address_range)
1356 *pc = fde->initial_location + offset;
1368 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1370 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1371 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1374 #ifdef CC_HAS_LONG_LONG
1375 #define DW64_CIE_ID 0xffffffffffffffffULL
1377 #define DW64_CIE_ID ~0
1380 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1383 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1384 the next byte to be processed. */
1386 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1388 gdb_byte *buf, *end;
1390 unsigned int bytes_read;
1393 ULONGEST cie_pointer;
1396 length = read_initial_length (unit->abfd, buf, &bytes_read);
1400 /* Are we still within the section? */
1401 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1407 /* Distinguish between 32 and 64-bit encoded frame info. */
1408 dwarf64_p = (bytes_read == 12);
1410 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1414 cie_id = DW64_CIE_ID;
1420 cie_pointer = read_8_bytes (unit->abfd, buf);
1425 cie_pointer = read_4_bytes (unit->abfd, buf);
1429 if (cie_pointer == cie_id)
1431 /* This is a CIE. */
1432 struct dwarf2_cie *cie;
1434 unsigned int cie_version;
1436 /* Record the offset into the .debug_frame section of this CIE. */
1437 cie_pointer = start - unit->dwarf_frame_buffer;
1439 /* Check whether we've already read it. */
1440 if (find_cie (unit, cie_pointer))
1443 cie = (struct dwarf2_cie *)
1444 obstack_alloc (&unit->objfile->objfile_obstack,
1445 sizeof (struct dwarf2_cie));
1446 cie->initial_instructions = NULL;
1447 cie->cie_pointer = cie_pointer;
1449 /* The encoding for FDE's in a normal .debug_frame section
1450 depends on the target address size. */
1451 cie->encoding = DW_EH_PE_absptr;
1453 /* Check version number. */
1454 cie_version = read_1_byte (unit->abfd, buf);
1455 if (cie_version != 1 && cie_version != 3)
1459 /* Interpret the interesting bits of the augmentation. */
1460 augmentation = (char *) buf;
1461 buf += (strlen (augmentation) + 1);
1463 /* The GCC 2.x "eh" augmentation has a pointer immediately
1464 following the augmentation string, so it must be handled
1466 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1469 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1473 cie->code_alignment_factor =
1474 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1477 cie->data_alignment_factor =
1478 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1481 if (cie_version == 1)
1483 cie->return_address_register = read_1_byte (unit->abfd, buf);
1487 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1491 cie->saw_z_augmentation = (*augmentation == 'z');
1492 if (cie->saw_z_augmentation)
1496 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1500 cie->initial_instructions = buf + length;
1504 while (*augmentation)
1506 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1507 if (*augmentation == 'L')
1514 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1515 else if (*augmentation == 'R')
1517 cie->encoding = *buf++;
1521 /* "P" indicates a personality routine in the CIE augmentation. */
1522 else if (*augmentation == 'P')
1524 /* Skip. Avoid indirection since we throw away the result. */
1525 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1526 read_encoded_value (unit, encoding, buf, &bytes_read);
1531 /* Otherwise we have an unknown augmentation.
1532 Bail out unless we saw a 'z' prefix. */
1535 if (cie->initial_instructions == NULL)
1538 /* Skip unknown augmentations. */
1539 buf = cie->initial_instructions;
1544 cie->initial_instructions = buf;
1547 add_cie (unit, cie);
1551 /* This is a FDE. */
1552 struct dwarf2_fde *fde;
1554 /* In an .eh_frame section, the CIE pointer is the delta between the
1555 address within the FDE where the CIE pointer is stored and the
1556 address of the CIE. Convert it to an offset into the .eh_frame
1560 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1561 cie_pointer -= (dwarf64_p ? 8 : 4);
1564 /* In either case, validate the result is still within the section. */
1565 if (cie_pointer >= unit->dwarf_frame_size)
1568 fde = (struct dwarf2_fde *)
1569 obstack_alloc (&unit->objfile->objfile_obstack,
1570 sizeof (struct dwarf2_fde));
1571 fde->cie = find_cie (unit, cie_pointer);
1572 if (fde->cie == NULL)
1574 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1576 fde->cie = find_cie (unit, cie_pointer);
1579 gdb_assert (fde->cie != NULL);
1581 fde->initial_location =
1582 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1585 fde->address_range =
1586 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1589 /* A 'z' augmentation in the CIE implies the presence of an
1590 augmentation field in the FDE as well. The only thing known
1591 to be in here at present is the LSDA entry for EH. So we
1592 can skip the whole thing. */
1593 if (fde->cie->saw_z_augmentation)
1597 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1598 buf += bytes_read + length;
1603 fde->instructions = buf;
1606 add_fde (unit, fde);
1612 /* Read a CIE or FDE in BUF and decode it. */
1614 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1616 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1619 ptrdiff_t start_offset;
1623 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1627 /* We have corrupt input data of some form. */
1629 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1630 and mismatches wrt padding and alignment of debug sections. */
1631 /* Note that there is no requirement in the standard for any
1632 alignment at all in the frame unwind sections. Testing for
1633 alignment before trying to interpret data would be incorrect.
1635 However, GCC traditionally arranged for frame sections to be
1636 sized such that the FDE length and CIE fields happen to be
1637 aligned (in theory, for performance). This, unfortunately,
1638 was done with .align directives, which had the side effect of
1639 forcing the section to be aligned by the linker.
1641 This becomes a problem when you have some other producer that
1642 creates frame sections that are not as strictly aligned. That
1643 produces a hole in the frame info that gets filled by the
1646 The GCC behaviour is arguably a bug, but it's effectively now
1647 part of the ABI, so we're now stuck with it, at least at the
1648 object file level. A smart linker may decide, in the process
1649 of compressing duplicate CIE information, that it can rewrite
1650 the entire output section without this extra padding. */
1652 start_offset = start - unit->dwarf_frame_buffer;
1653 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1655 start += 4 - (start_offset & 3);
1656 workaround = ALIGN4;
1659 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1661 start += 8 - (start_offset & 7);
1662 workaround = ALIGN8;
1666 /* Nothing left to try. Arrange to return as if we've consumed
1667 the entire input section. Hopefully we'll get valid info from
1668 the other of .debug_frame/.eh_frame. */
1670 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1680 complaint (&symfile_complaints,
1681 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1682 unit->dwarf_frame_section->owner->filename,
1683 unit->dwarf_frame_section->name);
1687 complaint (&symfile_complaints,
1688 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1689 unit->dwarf_frame_section->owner->filename,
1690 unit->dwarf_frame_section->name);
1694 complaint (&symfile_complaints,
1695 _("Corrupt data in %s:%s"),
1696 unit->dwarf_frame_section->owner->filename,
1697 unit->dwarf_frame_section->name);
1705 /* FIXME: kettenis/20030504: This still needs to be integrated with
1706 dwarf2read.c in a better way. */
1708 /* Imported from dwarf2read.c. */
1709 extern asection *dwarf_frame_section;
1710 extern asection *dwarf_eh_frame_section;
1712 /* Imported from dwarf2read.c. */
1713 extern char *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1716 dwarf2_build_frame_info (struct objfile *objfile)
1718 struct comp_unit unit;
1719 gdb_byte *frame_ptr;
1721 /* Build a minimal decoding of the DWARF2 compilation unit. */
1722 unit.abfd = objfile->obfd;
1723 unit.objfile = objfile;
1727 /* First add the information from the .eh_frame section. That way,
1728 the FDEs from that section are searched last. */
1729 if (dwarf_eh_frame_section)
1731 asection *got, *txt;
1734 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1735 dwarf_eh_frame_section);
1737 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1738 unit.dwarf_frame_section = dwarf_eh_frame_section;
1740 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1741 that is used for the i386/amd64 target, which currently is
1742 the only target in GCC that supports/uses the
1743 DW_EH_PE_datarel encoding. */
1744 got = bfd_get_section_by_name (unit.abfd, ".got");
1746 unit.dbase = got->vma;
1748 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1750 txt = bfd_get_section_by_name (unit.abfd, ".text");
1752 unit.tbase = txt->vma;
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, 1);
1759 if (dwarf_frame_section)
1762 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1763 dwarf_frame_section);
1764 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
1765 unit.dwarf_frame_section = dwarf_frame_section;
1767 frame_ptr = unit.dwarf_frame_buffer;
1768 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
1769 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
1773 /* Provide a prototype to silence -Wmissing-prototypes. */
1774 void _initialize_dwarf2_frame (void);
1777 _initialize_dwarf2_frame (void)
1779 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
1780 dwarf2_frame_objfile_data = register_objfile_data ();