1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
5 Contributed by Mark Kettenis.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
37 #include "gdb_assert.h"
38 #include "gdb_string.h"
40 #include "complaints.h"
41 #include "dwarf2-frame.h"
43 /* Call Frame Information (CFI). */
45 /* Common Information Entry (CIE). */
49 /* Offset into the .debug_frame section where this CIE was found.
50 Used to identify this CIE. */
53 /* Constant that is factored out of all advance location
55 ULONGEST code_alignment_factor;
57 /* Constants that is factored out of all offset instructions. */
58 LONGEST data_alignment_factor;
60 /* Return address column. */
61 ULONGEST return_address_register;
63 /* Instruction sequence to initialize a register set. */
64 gdb_byte *initial_instructions;
67 /* Saved augmentation, in case it's needed later. */
70 /* Encoding of addresses. */
73 /* True if a 'z' augmentation existed. */
74 unsigned char saw_z_augmentation;
76 /* True if an 'S' augmentation existed. */
77 unsigned char signal_frame;
79 /* The version recorded in the CIE. */
80 unsigned char version;
82 struct dwarf2_cie *next;
85 /* Frame Description Entry (FDE). */
89 /* CIE for this FDE. */
90 struct dwarf2_cie *cie;
92 /* First location associated with this FDE. */
93 CORE_ADDR initial_location;
95 /* Number of bytes of program instructions described by this FDE. */
96 CORE_ADDR address_range;
98 /* Instruction sequence. */
99 gdb_byte *instructions;
102 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
104 unsigned char eh_frame_p;
106 struct dwarf2_fde *next;
109 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
111 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
115 /* Structure describing a frame state. */
117 struct dwarf2_frame_state
119 /* Each register save state can be described in terms of a CFA slot,
120 another register, or a location expression. */
121 struct dwarf2_frame_state_reg_info
123 struct dwarf2_frame_state_reg *reg;
126 /* Used to implement DW_CFA_remember_state. */
127 struct dwarf2_frame_state_reg_info *prev;
139 /* The PC described by the current frame state. */
142 /* Initial register set from the CIE.
143 Used to implement DW_CFA_restore. */
144 struct dwarf2_frame_state_reg_info initial;
146 /* The information we care about from the CIE. */
149 ULONGEST retaddr_column;
151 /* Flags for known producer quirks. */
153 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
154 and DW_CFA_def_cfa_offset takes a factored offset. */
155 int armcc_cfa_offsets_sf;
157 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
158 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
159 int armcc_cfa_offsets_reversed;
162 /* Store the length the expression for the CFA in the `cfa_reg' field,
163 which is unused in that case. */
164 #define cfa_exp_len cfa_reg
166 /* Assert that the register set RS is large enough to store NUM_REGS
167 columns. If necessary, enlarge the register set. */
170 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
173 size_t size = sizeof (struct dwarf2_frame_state_reg);
175 if (num_regs <= rs->num_regs)
178 rs->reg = (struct dwarf2_frame_state_reg *)
179 xrealloc (rs->reg, num_regs * size);
181 /* Initialize newly allocated registers. */
182 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
183 rs->num_regs = num_regs;
186 /* Copy the register columns in register set RS into newly allocated
187 memory and return a pointer to this newly created copy. */
189 static struct dwarf2_frame_state_reg *
190 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
192 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
193 struct dwarf2_frame_state_reg *reg;
195 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
196 memcpy (reg, rs->reg, size);
201 /* Release the memory allocated to register set RS. */
204 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
208 dwarf2_frame_state_free_regs (rs->prev);
215 /* Release the memory allocated to the frame state FS. */
218 dwarf2_frame_state_free (void *p)
220 struct dwarf2_frame_state *fs = p;
222 dwarf2_frame_state_free_regs (fs->initial.prev);
223 dwarf2_frame_state_free_regs (fs->regs.prev);
224 xfree (fs->initial.reg);
225 xfree (fs->regs.reg);
230 /* Helper functions for execute_stack_op. */
233 read_reg (void *baton, int reg)
235 struct frame_info *next_frame = (struct frame_info *) baton;
236 struct gdbarch *gdbarch = get_frame_arch (next_frame);
240 regnum = DWARF2_REG_TO_REGNUM (reg);
242 buf = alloca (register_size (gdbarch, regnum));
243 frame_unwind_register (next_frame, regnum, buf);
245 /* Convert the register to an integer. This returns a LONGEST
246 rather than a CORE_ADDR, but unpack_pointer does the same thing
247 under the covers, and this makes more sense for non-pointer
248 registers. Maybe read_reg and the associated interfaces should
249 deal with "struct value" instead of CORE_ADDR. */
250 return unpack_long (register_type (gdbarch, regnum), buf);
254 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
256 read_memory (addr, buf, len);
260 no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
262 internal_error (__FILE__, __LINE__,
263 _("Support for DW_OP_fbreg is unimplemented"));
267 no_get_tls_address (void *baton, CORE_ADDR offset)
269 internal_error (__FILE__, __LINE__,
270 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
274 execute_stack_op (gdb_byte *exp, ULONGEST len,
275 struct frame_info *next_frame, CORE_ADDR initial)
277 struct dwarf_expr_context *ctx;
280 ctx = new_dwarf_expr_context ();
281 ctx->baton = next_frame;
282 ctx->read_reg = read_reg;
283 ctx->read_mem = read_mem;
284 ctx->get_frame_base = no_get_frame_base;
285 ctx->get_tls_address = no_get_tls_address;
287 dwarf_expr_push (ctx, initial);
288 dwarf_expr_eval (ctx, exp, len);
289 result = dwarf_expr_fetch (ctx, 0);
292 result = read_reg (next_frame, result);
294 free_dwarf_expr_context (ctx);
301 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
302 struct frame_info *next_frame,
303 struct dwarf2_frame_state *fs, int eh_frame_p)
305 CORE_ADDR pc = frame_pc_unwind (next_frame);
307 struct gdbarch *gdbarch = get_frame_arch (next_frame);
309 while (insn_ptr < insn_end && fs->pc <= pc)
311 gdb_byte insn = *insn_ptr++;
315 if ((insn & 0xc0) == DW_CFA_advance_loc)
316 fs->pc += (insn & 0x3f) * fs->code_align;
317 else if ((insn & 0xc0) == DW_CFA_offset)
320 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
321 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
322 offset = utmp * fs->data_align;
323 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
324 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
325 fs->regs.reg[reg].loc.offset = offset;
327 else if ((insn & 0xc0) == DW_CFA_restore)
329 gdb_assert (fs->initial.reg);
331 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
332 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
333 if (reg < fs->initial.num_regs)
334 fs->regs.reg[reg] = fs->initial.reg[reg];
336 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
338 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
339 complaint (&symfile_complaints, _("\
340 incomplete CFI data; DW_CFA_restore unspecified\n\
341 register %s (#%d) at 0x%s"),
342 REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg)),
343 DWARF2_REG_TO_REGNUM(reg), paddr (fs->pc));
350 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
351 insn_ptr += bytes_read;
354 case DW_CFA_advance_loc1:
355 utmp = extract_unsigned_integer (insn_ptr, 1);
356 fs->pc += utmp * fs->code_align;
359 case DW_CFA_advance_loc2:
360 utmp = extract_unsigned_integer (insn_ptr, 2);
361 fs->pc += utmp * fs->code_align;
364 case DW_CFA_advance_loc4:
365 utmp = extract_unsigned_integer (insn_ptr, 4);
366 fs->pc += utmp * fs->code_align;
370 case DW_CFA_offset_extended:
371 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
372 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
373 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
374 offset = utmp * fs->data_align;
375 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
376 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
377 fs->regs.reg[reg].loc.offset = offset;
380 case DW_CFA_restore_extended:
381 gdb_assert (fs->initial.reg);
382 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
383 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
384 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
385 fs->regs.reg[reg] = fs->initial.reg[reg];
388 case DW_CFA_undefined:
389 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
390 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
391 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
392 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
395 case DW_CFA_same_value:
396 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
397 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
398 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
399 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
402 case DW_CFA_register:
403 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
404 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
405 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
406 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
407 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
408 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
409 fs->regs.reg[reg].loc.reg = utmp;
412 case DW_CFA_remember_state:
414 struct dwarf2_frame_state_reg_info *new_rs;
416 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
418 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
419 fs->regs.prev = new_rs;
423 case DW_CFA_restore_state:
425 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
429 complaint (&symfile_complaints, _("\
430 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
434 xfree (fs->regs.reg);
442 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
443 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
445 if (fs->armcc_cfa_offsets_sf)
446 utmp *= fs->data_align;
448 fs->cfa_offset = utmp;
449 fs->cfa_how = CFA_REG_OFFSET;
452 case DW_CFA_def_cfa_register:
453 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
454 fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
456 fs->cfa_how = CFA_REG_OFFSET;
459 case DW_CFA_def_cfa_offset:
460 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
462 if (fs->armcc_cfa_offsets_sf)
463 utmp *= fs->data_align;
465 fs->cfa_offset = utmp;
466 /* cfa_how deliberately not set. */
472 case DW_CFA_def_cfa_expression:
473 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
474 fs->cfa_exp = insn_ptr;
475 fs->cfa_how = CFA_EXP;
476 insn_ptr += fs->cfa_exp_len;
479 case DW_CFA_expression:
480 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
481 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
482 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
483 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
484 fs->regs.reg[reg].loc.exp = insn_ptr;
485 fs->regs.reg[reg].exp_len = utmp;
486 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
490 case DW_CFA_offset_extended_sf:
491 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
492 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
493 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
494 offset *= fs->data_align;
495 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
496 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
497 fs->regs.reg[reg].loc.offset = offset;
500 case DW_CFA_val_offset:
501 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
502 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
503 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
504 offset = utmp * fs->data_align;
505 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
506 fs->regs.reg[reg].loc.offset = offset;
509 case DW_CFA_val_offset_sf:
510 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
511 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
512 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
513 offset *= fs->data_align;
514 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
515 fs->regs.reg[reg].loc.offset = offset;
518 case DW_CFA_val_expression:
519 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
520 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
521 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
522 fs->regs.reg[reg].loc.exp = insn_ptr;
523 fs->regs.reg[reg].exp_len = utmp;
524 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
528 case DW_CFA_def_cfa_sf:
529 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
530 fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
532 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
533 fs->cfa_offset = offset * fs->data_align;
534 fs->cfa_how = CFA_REG_OFFSET;
537 case DW_CFA_def_cfa_offset_sf:
538 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
539 fs->cfa_offset = offset * fs->data_align;
540 /* cfa_how deliberately not set. */
543 case DW_CFA_GNU_window_save:
544 /* This is SPARC-specific code, and contains hard-coded
545 constants for the register numbering scheme used by
546 GCC. Rather than having a architecture-specific
547 operation that's only ever used by a single
548 architecture, we provide the implementation here.
549 Incidentally that's what GCC does too in its
552 struct gdbarch *gdbarch = get_frame_arch (next_frame);
553 int size = register_size(gdbarch, 0);
554 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
555 for (reg = 8; reg < 16; reg++)
557 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
558 fs->regs.reg[reg].loc.reg = reg + 16;
560 for (reg = 16; reg < 32; reg++)
562 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
563 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
568 case DW_CFA_GNU_args_size:
570 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
573 case DW_CFA_GNU_negative_offset_extended:
574 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
575 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
576 insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
577 offset *= fs->data_align;
578 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
579 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
580 fs->regs.reg[reg].loc.offset = -offset;
584 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
589 /* Don't allow remember/restore between CIE and FDE programs. */
590 dwarf2_frame_state_free_regs (fs->regs.prev);
591 fs->regs.prev = NULL;
595 /* Architecture-specific operations. */
597 /* Per-architecture data key. */
598 static struct gdbarch_data *dwarf2_frame_data;
600 struct dwarf2_frame_ops
602 /* Pre-initialize the register state REG for register REGNUM. */
603 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
604 struct frame_info *);
606 /* Check whether the frame preceding NEXT_FRAME will be a signal
608 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
610 /* Convert .eh_frame register number to DWARF register number, or
611 adjust .debug_frame register number. */
612 int (*adjust_regnum) (struct gdbarch *, int, int);
615 /* Default architecture-specific register state initialization
619 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
620 struct dwarf2_frame_state_reg *reg,
621 struct frame_info *next_frame)
623 /* If we have a register that acts as a program counter, mark it as
624 a destination for the return address. If we have a register that
625 serves as the stack pointer, arrange for it to be filled with the
626 call frame address (CFA). The other registers are marked as
629 We copy the return address to the program counter, since many
630 parts in GDB assume that it is possible to get the return address
631 by unwinding the program counter register. However, on ISA's
632 with a dedicated return address register, the CFI usually only
633 contains information to unwind that return address register.
635 The reason we're treating the stack pointer special here is
636 because in many cases GCC doesn't emit CFI for the stack pointer
637 and implicitly assumes that it is equal to the CFA. This makes
638 some sense since the DWARF specification (version 3, draft 8,
641 "Typically, the CFA is defined to be the value of the stack
642 pointer at the call site in the previous frame (which may be
643 different from its value on entry to the current frame)."
645 However, this isn't true for all platforms supported by GCC
646 (e.g. IBM S/390 and zSeries). Those architectures should provide
647 their own architecture-specific initialization function. */
649 if (regnum == PC_REGNUM)
650 reg->how = DWARF2_FRAME_REG_RA;
651 else if (regnum == SP_REGNUM)
652 reg->how = DWARF2_FRAME_REG_CFA;
655 /* Return a default for the architecture-specific operations. */
658 dwarf2_frame_init (struct obstack *obstack)
660 struct dwarf2_frame_ops *ops;
662 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
663 ops->init_reg = dwarf2_frame_default_init_reg;
667 /* Set the architecture-specific register state initialization
668 function for GDBARCH to INIT_REG. */
671 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
672 void (*init_reg) (struct gdbarch *, int,
673 struct dwarf2_frame_state_reg *,
674 struct frame_info *))
676 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
678 ops->init_reg = init_reg;
681 /* Pre-initialize the register state REG for register REGNUM. */
684 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
685 struct dwarf2_frame_state_reg *reg,
686 struct frame_info *next_frame)
688 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
690 ops->init_reg (gdbarch, regnum, reg, next_frame);
693 /* Set the architecture-specific signal trampoline recognition
694 function for GDBARCH to SIGNAL_FRAME_P. */
697 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
698 int (*signal_frame_p) (struct gdbarch *,
699 struct frame_info *))
701 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
703 ops->signal_frame_p = signal_frame_p;
706 /* Query the architecture-specific signal frame recognizer for
710 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
711 struct frame_info *next_frame)
713 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
715 if (ops->signal_frame_p == NULL)
717 return ops->signal_frame_p (gdbarch, next_frame);
720 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
724 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
725 int (*adjust_regnum) (struct gdbarch *,
728 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
730 ops->adjust_regnum = adjust_regnum;
733 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
737 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p)
739 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
741 if (ops->adjust_regnum == NULL)
743 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
747 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
748 struct dwarf2_fde *fde)
750 static const char *arm_idents[] = {
751 "ARM C Compiler, ADS",
752 "Thumb C Compiler, ADS",
753 "ARM C++ Compiler, ADS",
754 "Thumb C++ Compiler, ADS",
755 "ARM/Thumb C/C++ Compiler, RVCT"
761 s = find_pc_symtab (fs->pc);
762 if (s == NULL || s->producer == NULL)
765 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
766 if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
768 if (fde->cie->version == 1)
769 fs->armcc_cfa_offsets_sf = 1;
771 if (fde->cie->version == 1)
772 fs->armcc_cfa_offsets_reversed = 1;
774 /* The reversed offset problem is present in some compilers
775 using DWARF3, but it was eventually fixed. Check the ARM
776 defined augmentations, which are in the format "armcc" followed
777 by a list of one-character options. The "+" option means
778 this problem is fixed (no quirk needed). If the armcc
779 augmentation is missing, the quirk is needed. */
780 if (fde->cie->version == 3
781 && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
782 || strchr (fde->cie->augmentation + 5, '+') == NULL))
783 fs->armcc_cfa_offsets_reversed = 1;
790 struct dwarf2_frame_cache
792 /* DWARF Call Frame Address. */
795 /* Set if the return address column was marked as undefined. */
796 int undefined_retaddr;
798 /* Saved registers, indexed by GDB register number, not by DWARF
800 struct dwarf2_frame_state_reg *reg;
802 /* Return address register. */
803 struct dwarf2_frame_state_reg retaddr_reg;
806 static struct dwarf2_frame_cache *
807 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
809 struct cleanup *old_chain;
810 struct gdbarch *gdbarch = get_frame_arch (next_frame);
811 const int num_regs = NUM_REGS + NUM_PSEUDO_REGS;
812 struct dwarf2_frame_cache *cache;
813 struct dwarf2_frame_state *fs;
814 struct dwarf2_fde *fde;
819 /* Allocate a new cache. */
820 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
821 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
823 /* Allocate and initialize the frame state. */
824 fs = XMALLOC (struct dwarf2_frame_state);
825 memset (fs, 0, sizeof (struct dwarf2_frame_state));
826 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
830 Note that if NEXT_FRAME is never supposed to return (i.e. a call
831 to abort), the compiler might optimize away the instruction at
832 NEXT_FRAME's return address. As a result the return address will
833 point at some random instruction, and the CFI for that
834 instruction is probably worthless to us. GCC's unwinder solves
835 this problem by substracting 1 from the return address to get an
836 address in the middle of a presumed call instruction (or the
837 instruction in the associated delay slot). This should only be
838 done for "normal" frames and not for resume-type frames (signal
839 handlers, sentinel frames, dummy frames). The function
840 frame_unwind_address_in_block does just this. It's not clear how
841 reliable the method is though; there is the potential for the
842 register state pre-call being different to that on return. */
843 fs->pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
845 /* Find the correct FDE. */
846 fde = dwarf2_frame_find_fde (&fs->pc);
847 gdb_assert (fde != NULL);
849 /* Extract any interesting information from the CIE. */
850 fs->data_align = fde->cie->data_alignment_factor;
851 fs->code_align = fde->cie->code_alignment_factor;
852 fs->retaddr_column = fde->cie->return_address_register;
854 /* Check for "quirks" - known bugs in producers. */
855 dwarf2_frame_find_quirks (fs, fde);
857 /* First decode all the insns in the CIE. */
858 execute_cfa_program (fde->cie->initial_instructions,
859 fde->cie->end, next_frame, fs, fde->eh_frame_p);
861 /* Save the initialized register set. */
862 fs->initial = fs->regs;
863 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
865 /* Then decode the insns in the FDE up to our target PC. */
866 execute_cfa_program (fde->instructions, fde->end, next_frame, fs,
869 /* Caclulate the CFA. */
873 cache->cfa = read_reg (next_frame, fs->cfa_reg);
874 if (fs->armcc_cfa_offsets_reversed)
875 cache->cfa -= fs->cfa_offset;
877 cache->cfa += fs->cfa_offset;
882 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
886 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
889 /* Initialize the register state. */
893 for (regnum = 0; regnum < num_regs; regnum++)
894 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
897 /* Go through the DWARF2 CFI generated table and save its register
898 location information in the cache. Note that we don't skip the
899 return address column; it's perfectly all right for it to
900 correspond to a real register. If it doesn't correspond to a
901 real register, or if we shouldn't treat it as such,
902 DWARF2_REG_TO_REGNUM should be defined to return a number outside
903 the range [0, NUM_REGS). */
905 int column; /* CFI speak for "register number". */
907 for (column = 0; column < fs->regs.num_regs; column++)
909 /* Use the GDB register number as the destination index. */
910 int regnum = DWARF2_REG_TO_REGNUM (column);
912 /* If there's no corresponding GDB register, ignore it. */
913 if (regnum < 0 || regnum >= num_regs)
916 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
917 of all debug info registers. If it doesn't, complain (but
918 not too loudly). It turns out that GCC assumes that an
919 unspecified register implies "same value" when CFI (draft
920 7) specifies nothing at all. Such a register could equally
921 be interpreted as "undefined". Also note that this check
922 isn't sufficient; it only checks that all registers in the
923 range [0 .. max column] are specified, and won't detect
924 problems when a debug info register falls outside of the
925 table. We need a way of iterating through all the valid
926 DWARF2 register numbers. */
927 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
929 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
930 complaint (&symfile_complaints, _("\
931 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
932 gdbarch_register_name (gdbarch, regnum),
936 cache->reg[regnum] = fs->regs.reg[column];
940 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
941 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
945 for (regnum = 0; regnum < num_regs; regnum++)
947 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
948 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
950 struct dwarf2_frame_state_reg *retaddr_reg =
951 &fs->regs.reg[fs->retaddr_column];
953 /* It seems rather bizarre to specify an "empty" column as
954 the return adress column. However, this is exactly
955 what GCC does on some targets. It turns out that GCC
956 assumes that the return address can be found in the
957 register corresponding to the return address column.
958 Incidentally, that's how we should treat a return
959 address column specifying "same value" too. */
960 if (fs->retaddr_column < fs->regs.num_regs
961 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
962 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
964 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
965 cache->reg[regnum] = *retaddr_reg;
967 cache->retaddr_reg = *retaddr_reg;
971 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
973 cache->reg[regnum].loc.reg = fs->retaddr_column;
974 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
978 cache->retaddr_reg.loc.reg = fs->retaddr_column;
979 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
986 if (fs->retaddr_column < fs->regs.num_regs
987 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
988 cache->undefined_retaddr = 1;
990 do_cleanups (old_chain);
997 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
998 struct frame_id *this_id)
1000 struct dwarf2_frame_cache *cache =
1001 dwarf2_frame_cache (next_frame, this_cache);
1003 if (cache->undefined_retaddr)
1006 (*this_id) = frame_id_build (cache->cfa,
1007 frame_func_unwind (next_frame, NORMAL_FRAME));
1011 dwarf2_signal_frame_this_id (struct frame_info *next_frame, void **this_cache,
1012 struct frame_id *this_id)
1014 struct dwarf2_frame_cache *cache =
1015 dwarf2_frame_cache (next_frame, this_cache);
1017 if (cache->undefined_retaddr)
1020 (*this_id) = frame_id_build (cache->cfa,
1021 frame_func_unwind (next_frame, SIGTRAMP_FRAME));
1025 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
1026 int regnum, int *optimizedp,
1027 enum lval_type *lvalp, CORE_ADDR *addrp,
1028 int *realnump, gdb_byte *valuep)
1030 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1031 struct dwarf2_frame_cache *cache =
1032 dwarf2_frame_cache (next_frame, this_cache);
1034 switch (cache->reg[regnum].how)
1036 case DWARF2_FRAME_REG_UNDEFINED:
1037 /* If CFI explicitly specified that the value isn't defined,
1038 mark it as optimized away; the value isn't available. */
1045 /* In some cases, for example %eflags on the i386, we have
1046 to provide a sane value, even though this register wasn't
1047 saved. Assume we can get it from NEXT_FRAME. */
1048 frame_unwind_register (next_frame, regnum, valuep);
1052 case DWARF2_FRAME_REG_SAVED_OFFSET:
1054 *lvalp = lval_memory;
1055 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
1059 /* Read the value in from memory. */
1060 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1064 case DWARF2_FRAME_REG_SAVED_REG:
1066 *lvalp = lval_register;
1068 *realnump = DWARF2_REG_TO_REGNUM (cache->reg[regnum].loc.reg);
1070 frame_unwind_register (next_frame, (*realnump), valuep);
1073 case DWARF2_FRAME_REG_SAVED_EXP:
1075 *lvalp = lval_memory;
1076 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
1077 cache->reg[regnum].exp_len,
1078 next_frame, cache->cfa);
1082 /* Read the value in from memory. */
1083 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1087 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1093 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1094 cache->cfa + cache->reg[regnum].loc.offset);
1097 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1103 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1104 execute_stack_op (cache->reg[regnum].loc.exp,
1105 cache->reg[regnum].exp_len,
1106 next_frame, cache->cfa));
1109 case DWARF2_FRAME_REG_UNSPECIFIED:
1110 /* GCC, in its infinite wisdom decided to not provide unwind
1111 information for registers that are "same value". Since
1112 DWARF2 (3 draft 7) doesn't define such behavior, said
1113 registers are actually undefined (which is different to CFI
1114 "undefined"). Code above issues a complaint about this.
1115 Here just fudge the books, assume GCC, and that the value is
1116 more inner on the stack. */
1118 *lvalp = lval_register;
1122 frame_unwind_register (next_frame, (*realnump), valuep);
1125 case DWARF2_FRAME_REG_SAME_VALUE:
1127 *lvalp = lval_register;
1131 frame_unwind_register (next_frame, (*realnump), valuep);
1134 case DWARF2_FRAME_REG_CFA:
1140 pack_long (valuep, register_type (gdbarch, regnum), cache->cfa);
1143 case DWARF2_FRAME_REG_CFA_OFFSET:
1149 pack_long (valuep, register_type (gdbarch, regnum),
1150 cache->cfa + cache->reg[regnum].loc.offset);
1153 case DWARF2_FRAME_REG_RA_OFFSET:
1160 CORE_ADDR pc = cache->reg[regnum].loc.offset;
1162 regnum = DWARF2_REG_TO_REGNUM (cache->retaddr_reg.loc.reg);
1163 pc += frame_unwind_register_unsigned (next_frame, regnum);
1164 pack_long (valuep, register_type (gdbarch, regnum), pc);
1169 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1173 static const struct frame_unwind dwarf2_frame_unwind =
1176 dwarf2_frame_this_id,
1177 dwarf2_frame_prev_register
1180 static const struct frame_unwind dwarf2_signal_frame_unwind =
1183 dwarf2_signal_frame_this_id,
1184 dwarf2_frame_prev_register
1187 const struct frame_unwind *
1188 dwarf2_frame_sniffer (struct frame_info *next_frame)
1190 /* Grab an address that is guarenteed to reside somewhere within the
1191 function. frame_pc_unwind(), for a no-return next function, can
1192 end up returning something past the end of this function's body.
1193 If the frame we're sniffing for is a signal frame whose start
1194 address is placed on the stack by the OS, its FDE must
1195 extend one byte before its start address or we will miss it. */
1196 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
1198 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1202 /* On some targets, signal trampolines may have unwind information.
1203 We need to recognize them so that we set the frame type
1206 if (fde->cie->signal_frame
1207 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
1209 return &dwarf2_signal_frame_unwind;
1211 return &dwarf2_frame_unwind;
1215 /* There is no explicitly defined relationship between the CFA and the
1216 location of frame's local variables and arguments/parameters.
1217 Therefore, frame base methods on this page should probably only be
1218 used as a last resort, just to avoid printing total garbage as a
1219 response to the "info frame" command. */
1222 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1224 struct dwarf2_frame_cache *cache =
1225 dwarf2_frame_cache (next_frame, this_cache);
1230 static const struct frame_base dwarf2_frame_base =
1232 &dwarf2_frame_unwind,
1233 dwarf2_frame_base_address,
1234 dwarf2_frame_base_address,
1235 dwarf2_frame_base_address
1238 const struct frame_base *
1239 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1241 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
1243 if (dwarf2_frame_find_fde (&block_addr))
1244 return &dwarf2_frame_base;
1249 /* A minimal decoding of DWARF2 compilation units. We only decode
1250 what's needed to get to the call frame information. */
1254 /* Keep the bfd convenient. */
1257 struct objfile *objfile;
1259 /* Linked list of CIEs for this object. */
1260 struct dwarf2_cie *cie;
1262 /* Pointer to the .debug_frame section loaded into memory. */
1263 gdb_byte *dwarf_frame_buffer;
1265 /* Length of the loaded .debug_frame section. */
1266 unsigned long dwarf_frame_size;
1268 /* Pointer to the .debug_frame section. */
1269 asection *dwarf_frame_section;
1271 /* Base for DW_EH_PE_datarel encodings. */
1274 /* Base for DW_EH_PE_textrel encodings. */
1278 const struct objfile_data *dwarf2_frame_objfile_data;
1281 read_1_byte (bfd *abfd, gdb_byte *buf)
1283 return bfd_get_8 (abfd, buf);
1287 read_4_bytes (bfd *abfd, gdb_byte *buf)
1289 return bfd_get_32 (abfd, buf);
1293 read_8_bytes (bfd *abfd, gdb_byte *buf)
1295 return bfd_get_64 (abfd, buf);
1299 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1302 unsigned int num_read;
1312 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1315 result |= ((byte & 0x7f) << shift);
1318 while (byte & 0x80);
1320 *bytes_read_ptr = num_read;
1326 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1330 unsigned int num_read;
1339 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1342 result |= ((byte & 0x7f) << shift);
1345 while (byte & 0x80);
1347 if (shift < 8 * sizeof (result) && (byte & 0x40))
1348 result |= -(((LONGEST)1) << shift);
1350 *bytes_read_ptr = num_read;
1356 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1360 result = bfd_get_32 (abfd, buf);
1361 if (result == 0xffffffff)
1363 result = bfd_get_64 (abfd, buf + 4);
1364 *bytes_read_ptr = 12;
1367 *bytes_read_ptr = 4;
1373 /* Pointer encoding helper functions. */
1375 /* GCC supports exception handling based on DWARF2 CFI. However, for
1376 technical reasons, it encodes addresses in its FDE's in a different
1377 way. Several "pointer encodings" are supported. The encoding
1378 that's used for a particular FDE is determined by the 'R'
1379 augmentation in the associated CIE. The argument of this
1380 augmentation is a single byte.
1382 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1383 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1384 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1385 address should be interpreted (absolute, relative to the current
1386 position in the FDE, ...). Bit 7, indicates that the address
1387 should be dereferenced. */
1390 encoding_for_size (unsigned int size)
1395 return DW_EH_PE_udata2;
1397 return DW_EH_PE_udata4;
1399 return DW_EH_PE_udata8;
1401 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1406 size_of_encoded_value (gdb_byte encoding)
1408 if (encoding == DW_EH_PE_omit)
1411 switch (encoding & 0x07)
1413 case DW_EH_PE_absptr:
1414 return TYPE_LENGTH (builtin_type_void_data_ptr);
1415 case DW_EH_PE_udata2:
1417 case DW_EH_PE_udata4:
1419 case DW_EH_PE_udata8:
1422 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1427 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1428 gdb_byte *buf, unsigned int *bytes_read_ptr)
1430 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1434 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1436 if (encoding & DW_EH_PE_indirect)
1437 internal_error (__FILE__, __LINE__,
1438 _("Unsupported encoding: DW_EH_PE_indirect"));
1440 *bytes_read_ptr = 0;
1442 switch (encoding & 0x70)
1444 case DW_EH_PE_absptr:
1447 case DW_EH_PE_pcrel:
1448 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1449 base += (buf - unit->dwarf_frame_buffer);
1451 case DW_EH_PE_datarel:
1454 case DW_EH_PE_textrel:
1457 case DW_EH_PE_funcrel:
1458 /* FIXME: kettenis/20040501: For now just pretend
1459 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1460 reading the initial location of an FDE it should be treated
1461 as such, and currently that's the only place where this code
1465 case DW_EH_PE_aligned:
1467 offset = buf - unit->dwarf_frame_buffer;
1468 if ((offset % ptr_len) != 0)
1470 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1471 buf += *bytes_read_ptr;
1475 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1478 if ((encoding & 0x07) == 0x00)
1480 encoding |= encoding_for_size (ptr_len);
1481 if (bfd_get_sign_extend_vma (unit->abfd))
1482 encoding |= DW_EH_PE_signed;
1485 switch (encoding & 0x0f)
1487 case DW_EH_PE_uleb128:
1490 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1491 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1492 return base + value;
1494 case DW_EH_PE_udata2:
1495 *bytes_read_ptr += 2;
1496 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1497 case DW_EH_PE_udata4:
1498 *bytes_read_ptr += 4;
1499 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1500 case DW_EH_PE_udata8:
1501 *bytes_read_ptr += 8;
1502 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1503 case DW_EH_PE_sleb128:
1506 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1507 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1508 return base + value;
1510 case DW_EH_PE_sdata2:
1511 *bytes_read_ptr += 2;
1512 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1513 case DW_EH_PE_sdata4:
1514 *bytes_read_ptr += 4;
1515 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1516 case DW_EH_PE_sdata8:
1517 *bytes_read_ptr += 8;
1518 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1520 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1525 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1526 That's why we use a simple linked list here. */
1528 static struct dwarf2_cie *
1529 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1531 struct dwarf2_cie *cie = unit->cie;
1535 if (cie->cie_pointer == cie_pointer)
1545 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1547 cie->next = unit->cie;
1551 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1552 inital location associated with it into *PC. */
1554 static struct dwarf2_fde *
1555 dwarf2_frame_find_fde (CORE_ADDR *pc)
1557 struct objfile *objfile;
1559 ALL_OBJFILES (objfile)
1561 struct dwarf2_fde *fde;
1564 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1568 gdb_assert (objfile->section_offsets);
1569 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1573 if (*pc >= fde->initial_location + offset
1574 && *pc < fde->initial_location + offset + fde->address_range)
1576 *pc = fde->initial_location + offset;
1588 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1590 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1591 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1594 #ifdef CC_HAS_LONG_LONG
1595 #define DW64_CIE_ID 0xffffffffffffffffULL
1597 #define DW64_CIE_ID ~0
1600 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1603 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1604 the next byte to be processed. */
1606 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1608 gdb_byte *buf, *end;
1610 unsigned int bytes_read;
1613 ULONGEST cie_pointer;
1616 length = read_initial_length (unit->abfd, buf, &bytes_read);
1620 /* Are we still within the section? */
1621 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1627 /* Distinguish between 32 and 64-bit encoded frame info. */
1628 dwarf64_p = (bytes_read == 12);
1630 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1634 cie_id = DW64_CIE_ID;
1640 cie_pointer = read_8_bytes (unit->abfd, buf);
1645 cie_pointer = read_4_bytes (unit->abfd, buf);
1649 if (cie_pointer == cie_id)
1651 /* This is a CIE. */
1652 struct dwarf2_cie *cie;
1654 unsigned int cie_version;
1656 /* Record the offset into the .debug_frame section of this CIE. */
1657 cie_pointer = start - unit->dwarf_frame_buffer;
1659 /* Check whether we've already read it. */
1660 if (find_cie (unit, cie_pointer))
1663 cie = (struct dwarf2_cie *)
1664 obstack_alloc (&unit->objfile->objfile_obstack,
1665 sizeof (struct dwarf2_cie));
1666 cie->initial_instructions = NULL;
1667 cie->cie_pointer = cie_pointer;
1669 /* The encoding for FDE's in a normal .debug_frame section
1670 depends on the target address size. */
1671 cie->encoding = DW_EH_PE_absptr;
1673 /* We'll determine the final value later, but we need to
1674 initialize it conservatively. */
1675 cie->signal_frame = 0;
1677 /* Check version number. */
1678 cie_version = read_1_byte (unit->abfd, buf);
1679 if (cie_version != 1 && cie_version != 3)
1681 cie->version = cie_version;
1684 /* Interpret the interesting bits of the augmentation. */
1685 cie->augmentation = augmentation = (char *) buf;
1686 buf += (strlen (augmentation) + 1);
1688 /* Ignore armcc augmentations. We only use them for quirks,
1689 and that doesn't happen until later. */
1690 if (strncmp (augmentation, "armcc", 5) == 0)
1691 augmentation += strlen (augmentation);
1693 /* The GCC 2.x "eh" augmentation has a pointer immediately
1694 following the augmentation string, so it must be handled
1696 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1699 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1703 cie->code_alignment_factor =
1704 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1707 cie->data_alignment_factor =
1708 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1711 if (cie_version == 1)
1713 cie->return_address_register = read_1_byte (unit->abfd, buf);
1717 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1719 cie->return_address_register
1720 = dwarf2_frame_adjust_regnum (current_gdbarch,
1721 cie->return_address_register,
1726 cie->saw_z_augmentation = (*augmentation == 'z');
1727 if (cie->saw_z_augmentation)
1731 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1735 cie->initial_instructions = buf + length;
1739 while (*augmentation)
1741 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1742 if (*augmentation == 'L')
1749 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1750 else if (*augmentation == 'R')
1752 cie->encoding = *buf++;
1756 /* "P" indicates a personality routine in the CIE augmentation. */
1757 else if (*augmentation == 'P')
1759 /* Skip. Avoid indirection since we throw away the result. */
1760 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1761 read_encoded_value (unit, encoding, buf, &bytes_read);
1766 /* "S" indicates a signal frame, such that the return
1767 address must not be decremented to locate the call frame
1768 info for the previous frame; it might even be the first
1769 instruction of a function, so decrementing it would take
1770 us to a different function. */
1771 else if (*augmentation == 'S')
1773 cie->signal_frame = 1;
1777 /* Otherwise we have an unknown augmentation. Assume that either
1778 there is no augmentation data, or we saw a 'z' prefix. */
1781 if (cie->initial_instructions)
1782 buf = cie->initial_instructions;
1787 cie->initial_instructions = buf;
1790 add_cie (unit, cie);
1794 /* This is a FDE. */
1795 struct dwarf2_fde *fde;
1797 /* In an .eh_frame section, the CIE pointer is the delta between the
1798 address within the FDE where the CIE pointer is stored and the
1799 address of the CIE. Convert it to an offset into the .eh_frame
1803 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1804 cie_pointer -= (dwarf64_p ? 8 : 4);
1807 /* In either case, validate the result is still within the section. */
1808 if (cie_pointer >= unit->dwarf_frame_size)
1811 fde = (struct dwarf2_fde *)
1812 obstack_alloc (&unit->objfile->objfile_obstack,
1813 sizeof (struct dwarf2_fde));
1814 fde->cie = find_cie (unit, cie_pointer);
1815 if (fde->cie == NULL)
1817 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1819 fde->cie = find_cie (unit, cie_pointer);
1822 gdb_assert (fde->cie != NULL);
1824 fde->initial_location =
1825 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1828 fde->address_range =
1829 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1832 /* A 'z' augmentation in the CIE implies the presence of an
1833 augmentation field in the FDE as well. The only thing known
1834 to be in here at present is the LSDA entry for EH. So we
1835 can skip the whole thing. */
1836 if (fde->cie->saw_z_augmentation)
1840 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1841 buf += bytes_read + length;
1846 fde->instructions = buf;
1849 fde->eh_frame_p = eh_frame_p;
1851 add_fde (unit, fde);
1857 /* Read a CIE or FDE in BUF and decode it. */
1859 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1861 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1864 ptrdiff_t start_offset;
1868 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1872 /* We have corrupt input data of some form. */
1874 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1875 and mismatches wrt padding and alignment of debug sections. */
1876 /* Note that there is no requirement in the standard for any
1877 alignment at all in the frame unwind sections. Testing for
1878 alignment before trying to interpret data would be incorrect.
1880 However, GCC traditionally arranged for frame sections to be
1881 sized such that the FDE length and CIE fields happen to be
1882 aligned (in theory, for performance). This, unfortunately,
1883 was done with .align directives, which had the side effect of
1884 forcing the section to be aligned by the linker.
1886 This becomes a problem when you have some other producer that
1887 creates frame sections that are not as strictly aligned. That
1888 produces a hole in the frame info that gets filled by the
1891 The GCC behaviour is arguably a bug, but it's effectively now
1892 part of the ABI, so we're now stuck with it, at least at the
1893 object file level. A smart linker may decide, in the process
1894 of compressing duplicate CIE information, that it can rewrite
1895 the entire output section without this extra padding. */
1897 start_offset = start - unit->dwarf_frame_buffer;
1898 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1900 start += 4 - (start_offset & 3);
1901 workaround = ALIGN4;
1904 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1906 start += 8 - (start_offset & 7);
1907 workaround = ALIGN8;
1911 /* Nothing left to try. Arrange to return as if we've consumed
1912 the entire input section. Hopefully we'll get valid info from
1913 the other of .debug_frame/.eh_frame. */
1915 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1925 complaint (&symfile_complaints,
1926 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1927 unit->dwarf_frame_section->owner->filename,
1928 unit->dwarf_frame_section->name);
1932 complaint (&symfile_complaints,
1933 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1934 unit->dwarf_frame_section->owner->filename,
1935 unit->dwarf_frame_section->name);
1939 complaint (&symfile_complaints,
1940 _("Corrupt data in %s:%s"),
1941 unit->dwarf_frame_section->owner->filename,
1942 unit->dwarf_frame_section->name);
1950 /* FIXME: kettenis/20030504: This still needs to be integrated with
1951 dwarf2read.c in a better way. */
1953 /* Imported from dwarf2read.c. */
1954 extern asection *dwarf_frame_section;
1955 extern asection *dwarf_eh_frame_section;
1957 /* Imported from dwarf2read.c. */
1958 extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1961 dwarf2_build_frame_info (struct objfile *objfile)
1963 struct comp_unit unit;
1964 gdb_byte *frame_ptr;
1966 /* Build a minimal decoding of the DWARF2 compilation unit. */
1967 unit.abfd = objfile->obfd;
1968 unit.objfile = objfile;
1972 /* First add the information from the .eh_frame section. That way,
1973 the FDEs from that section are searched last. */
1974 if (dwarf_eh_frame_section)
1976 asection *got, *txt;
1979 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1980 dwarf_eh_frame_section);
1982 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1983 unit.dwarf_frame_section = dwarf_eh_frame_section;
1985 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1986 that is used for the i386/amd64 target, which currently is
1987 the only target in GCC that supports/uses the
1988 DW_EH_PE_datarel encoding. */
1989 got = bfd_get_section_by_name (unit.abfd, ".got");
1991 unit.dbase = got->vma;
1993 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1995 txt = bfd_get_section_by_name (unit.abfd, ".text");
1997 unit.tbase = txt->vma;
1999 frame_ptr = unit.dwarf_frame_buffer;
2000 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
2001 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
2004 if (dwarf_frame_section)
2007 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
2008 dwarf_frame_section);
2009 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
2010 unit.dwarf_frame_section = dwarf_frame_section;
2012 frame_ptr = unit.dwarf_frame_buffer;
2013 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
2014 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
2018 /* Provide a prototype to silence -Wmissing-prototypes. */
2019 void _initialize_dwarf2_frame (void);
2022 _initialize_dwarf2_frame (void)
2024 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2025 dwarf2_frame_objfile_data = register_objfile_data ();