1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "dwarf2expr.h"
24 #include "elf/dwarf2.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
35 #include "gdb_assert.h"
36 #include "gdb_string.h"
38 #include "complaints.h"
39 #include "dwarf2-frame.h"
41 /* Call Frame Information (CFI). */
43 /* Common Information Entry (CIE). */
47 /* Offset into the .debug_frame section where this CIE was found.
48 Used to identify this CIE. */
51 /* Constant that is factored out of all advance location
53 ULONGEST code_alignment_factor;
55 /* Constants that is factored out of all offset instructions. */
56 LONGEST data_alignment_factor;
58 /* Return address column. */
59 ULONGEST return_address_register;
61 /* Instruction sequence to initialize a register set. */
62 gdb_byte *initial_instructions;
65 /* Saved augmentation, in case it's needed later. */
68 /* Encoding of addresses. */
71 /* True if a 'z' augmentation existed. */
72 unsigned char saw_z_augmentation;
74 /* True if an 'S' augmentation existed. */
75 unsigned char signal_frame;
77 /* The version recorded in the CIE. */
78 unsigned char version;
80 struct dwarf2_cie *next;
83 /* Frame Description Entry (FDE). */
87 /* CIE for this FDE. */
88 struct dwarf2_cie *cie;
90 /* First location associated with this FDE. */
91 CORE_ADDR initial_location;
93 /* Number of bytes of program instructions described by this FDE. */
94 CORE_ADDR address_range;
96 /* Instruction sequence. */
97 gdb_byte *instructions;
100 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
102 unsigned char eh_frame_p;
104 struct dwarf2_fde *next;
107 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc);
109 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
113 /* Structure describing a frame state. */
115 struct dwarf2_frame_state
117 /* Each register save state can be described in terms of a CFA slot,
118 another register, or a location expression. */
119 struct dwarf2_frame_state_reg_info
121 struct dwarf2_frame_state_reg *reg;
124 /* Used to implement DW_CFA_remember_state. */
125 struct dwarf2_frame_state_reg_info *prev;
137 /* The PC described by the current frame state. */
140 /* Initial register set from the CIE.
141 Used to implement DW_CFA_restore. */
142 struct dwarf2_frame_state_reg_info initial;
144 /* The information we care about from the CIE. */
147 ULONGEST retaddr_column;
149 /* Flags for known producer quirks. */
151 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
152 and DW_CFA_def_cfa_offset takes a factored offset. */
153 int armcc_cfa_offsets_sf;
155 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
156 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
157 int armcc_cfa_offsets_reversed;
160 /* Store the length the expression for the CFA in the `cfa_reg' field,
161 which is unused in that case. */
162 #define cfa_exp_len cfa_reg
164 /* Assert that the register set RS is large enough to store gdbarch_num_regs
165 columns. If necessary, enlarge the register set. */
168 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
171 size_t size = sizeof (struct dwarf2_frame_state_reg);
173 if (num_regs <= rs->num_regs)
176 rs->reg = (struct dwarf2_frame_state_reg *)
177 xrealloc (rs->reg, num_regs * size);
179 /* Initialize newly allocated registers. */
180 memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
181 rs->num_regs = num_regs;
184 /* Copy the register columns in register set RS into newly allocated
185 memory and return a pointer to this newly created copy. */
187 static struct dwarf2_frame_state_reg *
188 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
190 size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
191 struct dwarf2_frame_state_reg *reg;
193 reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
194 memcpy (reg, rs->reg, size);
199 /* Release the memory allocated to register set RS. */
202 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
206 dwarf2_frame_state_free_regs (rs->prev);
213 /* Release the memory allocated to the frame state FS. */
216 dwarf2_frame_state_free (void *p)
218 struct dwarf2_frame_state *fs = p;
220 dwarf2_frame_state_free_regs (fs->initial.prev);
221 dwarf2_frame_state_free_regs (fs->regs.prev);
222 xfree (fs->initial.reg);
223 xfree (fs->regs.reg);
228 /* Helper functions for execute_stack_op. */
231 read_reg (void *baton, int reg)
233 struct frame_info *next_frame = (struct frame_info *) baton;
234 struct gdbarch *gdbarch = get_frame_arch (next_frame);
238 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
240 buf = alloca (register_size (gdbarch, regnum));
241 frame_unwind_register (next_frame, regnum, buf);
243 /* Convert the register to an integer. This returns a LONGEST
244 rather than a CORE_ADDR, but unpack_pointer does the same thing
245 under the covers, and this makes more sense for non-pointer
246 registers. Maybe read_reg and the associated interfaces should
247 deal with "struct value" instead of CORE_ADDR. */
248 return unpack_long (register_type (gdbarch, regnum), buf);
252 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
254 read_memory (addr, buf, len);
258 no_get_frame_base (void *baton, gdb_byte **start, size_t *length)
260 internal_error (__FILE__, __LINE__,
261 _("Support for DW_OP_fbreg is unimplemented"));
265 no_get_tls_address (void *baton, CORE_ADDR offset)
267 internal_error (__FILE__, __LINE__,
268 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
271 /* Execute the required actions for both the DW_CFA_restore and
272 DW_CFA_restore_extended instructions. */
274 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
275 struct dwarf2_frame_state *fs, int eh_frame_p)
279 gdb_assert (fs->initial.reg);
280 reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
281 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
283 /* Check if this register was explicitly initialized in the
284 CIE initial instructions. If not, default the rule to
286 if (reg < fs->initial.num_regs)
287 fs->regs.reg[reg] = fs->initial.reg[reg];
289 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
291 if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
292 complaint (&symfile_complaints, _("\
293 incomplete CFI data; DW_CFA_restore unspecified\n\
294 register %s (#%d) at 0x%s"),
295 gdbarch_register_name
296 (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
297 gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
302 execute_stack_op (gdb_byte *exp, ULONGEST len,
303 struct frame_info *next_frame, CORE_ADDR initial)
305 struct dwarf_expr_context *ctx;
308 ctx = new_dwarf_expr_context ();
309 ctx->baton = next_frame;
310 ctx->read_reg = read_reg;
311 ctx->read_mem = read_mem;
312 ctx->get_frame_base = no_get_frame_base;
313 ctx->get_tls_address = no_get_tls_address;
315 dwarf_expr_push (ctx, initial);
316 dwarf_expr_eval (ctx, exp, len);
317 result = dwarf_expr_fetch (ctx, 0);
320 result = read_reg (next_frame, result);
322 free_dwarf_expr_context (ctx);
329 execute_cfa_program (gdb_byte *insn_ptr, gdb_byte *insn_end,
330 struct frame_info *next_frame,
331 struct dwarf2_frame_state *fs, int eh_frame_p)
333 CORE_ADDR pc = frame_pc_unwind (next_frame);
335 struct gdbarch *gdbarch = get_frame_arch (next_frame);
337 while (insn_ptr < insn_end && fs->pc <= pc)
339 gdb_byte insn = *insn_ptr++;
343 if ((insn & 0xc0) == DW_CFA_advance_loc)
344 fs->pc += (insn & 0x3f) * fs->code_align;
345 else if ((insn & 0xc0) == DW_CFA_offset)
348 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
349 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
350 offset = utmp * fs->data_align;
351 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
352 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
353 fs->regs.reg[reg].loc.offset = offset;
355 else if ((insn & 0xc0) == DW_CFA_restore)
358 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
365 fs->pc = dwarf2_read_address (insn_ptr, insn_end, &bytes_read);
366 insn_ptr += bytes_read;
369 case DW_CFA_advance_loc1:
370 utmp = extract_unsigned_integer (insn_ptr, 1);
371 fs->pc += utmp * fs->code_align;
374 case DW_CFA_advance_loc2:
375 utmp = extract_unsigned_integer (insn_ptr, 2);
376 fs->pc += utmp * fs->code_align;
379 case DW_CFA_advance_loc4:
380 utmp = extract_unsigned_integer (insn_ptr, 4);
381 fs->pc += utmp * fs->code_align;
385 case DW_CFA_offset_extended:
386 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
387 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
388 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
389 offset = utmp * fs->data_align;
390 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
391 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
392 fs->regs.reg[reg].loc.offset = offset;
395 case DW_CFA_restore_extended:
396 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
397 dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
400 case DW_CFA_undefined:
401 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
402 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
403 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
404 fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
407 case DW_CFA_same_value:
408 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
409 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
410 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
411 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
414 case DW_CFA_register:
415 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
416 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
417 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
418 utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
419 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
420 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
421 fs->regs.reg[reg].loc.reg = utmp;
424 case DW_CFA_remember_state:
426 struct dwarf2_frame_state_reg_info *new_rs;
428 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
430 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
431 fs->regs.prev = new_rs;
435 case DW_CFA_restore_state:
437 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
441 complaint (&symfile_complaints, _("\
442 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
446 xfree (fs->regs.reg);
454 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
455 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
457 if (fs->armcc_cfa_offsets_sf)
458 utmp *= fs->data_align;
460 fs->cfa_offset = utmp;
461 fs->cfa_how = CFA_REG_OFFSET;
464 case DW_CFA_def_cfa_register:
465 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
466 fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
468 fs->cfa_how = CFA_REG_OFFSET;
471 case DW_CFA_def_cfa_offset:
472 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
474 if (fs->armcc_cfa_offsets_sf)
475 utmp *= fs->data_align;
477 fs->cfa_offset = utmp;
478 /* cfa_how deliberately not set. */
484 case DW_CFA_def_cfa_expression:
485 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_exp_len);
486 fs->cfa_exp = insn_ptr;
487 fs->cfa_how = CFA_EXP;
488 insn_ptr += fs->cfa_exp_len;
491 case DW_CFA_expression:
492 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
493 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
494 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
495 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
496 fs->regs.reg[reg].loc.exp = insn_ptr;
497 fs->regs.reg[reg].exp_len = utmp;
498 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
502 case DW_CFA_offset_extended_sf:
503 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
504 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
505 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
506 offset *= fs->data_align;
507 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
508 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
509 fs->regs.reg[reg].loc.offset = offset;
512 case DW_CFA_val_offset:
513 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
514 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
515 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
516 offset = utmp * fs->data_align;
517 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
518 fs->regs.reg[reg].loc.offset = offset;
521 case DW_CFA_val_offset_sf:
522 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
523 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
524 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
525 offset *= fs->data_align;
526 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
527 fs->regs.reg[reg].loc.offset = offset;
530 case DW_CFA_val_expression:
531 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
532 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
533 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
534 fs->regs.reg[reg].loc.exp = insn_ptr;
535 fs->regs.reg[reg].exp_len = utmp;
536 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
540 case DW_CFA_def_cfa_sf:
541 insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->cfa_reg);
542 fs->cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, fs->cfa_reg,
544 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
545 fs->cfa_offset = offset * fs->data_align;
546 fs->cfa_how = CFA_REG_OFFSET;
549 case DW_CFA_def_cfa_offset_sf:
550 insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
551 fs->cfa_offset = offset * fs->data_align;
552 /* cfa_how deliberately not set. */
555 case DW_CFA_GNU_window_save:
556 /* This is SPARC-specific code, and contains hard-coded
557 constants for the register numbering scheme used by
558 GCC. Rather than having a architecture-specific
559 operation that's only ever used by a single
560 architecture, we provide the implementation here.
561 Incidentally that's what GCC does too in its
564 struct gdbarch *gdbarch = get_frame_arch (next_frame);
565 int size = register_size(gdbarch, 0);
566 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
567 for (reg = 8; reg < 16; reg++)
569 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
570 fs->regs.reg[reg].loc.reg = reg + 16;
572 for (reg = 16; reg < 32; reg++)
574 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
575 fs->regs.reg[reg].loc.offset = (reg - 16) * size;
580 case DW_CFA_GNU_args_size:
582 insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
585 case DW_CFA_GNU_negative_offset_extended:
586 insn_ptr = read_uleb128 (insn_ptr, insn_end, ®);
587 reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
588 insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
589 offset *= fs->data_align;
590 dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
591 fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
592 fs->regs.reg[reg].loc.offset = -offset;
596 internal_error (__FILE__, __LINE__, _("Unknown CFI encountered."));
601 /* Don't allow remember/restore between CIE and FDE programs. */
602 dwarf2_frame_state_free_regs (fs->regs.prev);
603 fs->regs.prev = NULL;
607 /* Architecture-specific operations. */
609 /* Per-architecture data key. */
610 static struct gdbarch_data *dwarf2_frame_data;
612 struct dwarf2_frame_ops
614 /* Pre-initialize the register state REG for register REGNUM. */
615 void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
616 struct frame_info *);
618 /* Check whether the frame preceding NEXT_FRAME will be a signal
620 int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
622 /* Convert .eh_frame register number to DWARF register number, or
623 adjust .debug_frame register number. */
624 int (*adjust_regnum) (struct gdbarch *, int, int);
627 /* Default architecture-specific register state initialization
631 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
632 struct dwarf2_frame_state_reg *reg,
633 struct frame_info *next_frame)
635 /* If we have a register that acts as a program counter, mark it as
636 a destination for the return address. If we have a register that
637 serves as the stack pointer, arrange for it to be filled with the
638 call frame address (CFA). The other registers are marked as
641 We copy the return address to the program counter, since many
642 parts in GDB assume that it is possible to get the return address
643 by unwinding the program counter register. However, on ISA's
644 with a dedicated return address register, the CFI usually only
645 contains information to unwind that return address register.
647 The reason we're treating the stack pointer special here is
648 because in many cases GCC doesn't emit CFI for the stack pointer
649 and implicitly assumes that it is equal to the CFA. This makes
650 some sense since the DWARF specification (version 3, draft 8,
653 "Typically, the CFA is defined to be the value of the stack
654 pointer at the call site in the previous frame (which may be
655 different from its value on entry to the current frame)."
657 However, this isn't true for all platforms supported by GCC
658 (e.g. IBM S/390 and zSeries). Those architectures should provide
659 their own architecture-specific initialization function. */
661 if (regnum == gdbarch_pc_regnum (gdbarch))
662 reg->how = DWARF2_FRAME_REG_RA;
663 else if (regnum == gdbarch_sp_regnum (gdbarch))
664 reg->how = DWARF2_FRAME_REG_CFA;
667 /* Return a default for the architecture-specific operations. */
670 dwarf2_frame_init (struct obstack *obstack)
672 struct dwarf2_frame_ops *ops;
674 ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
675 ops->init_reg = dwarf2_frame_default_init_reg;
679 /* Set the architecture-specific register state initialization
680 function for GDBARCH to INIT_REG. */
683 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
684 void (*init_reg) (struct gdbarch *, int,
685 struct dwarf2_frame_state_reg *,
686 struct frame_info *))
688 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
690 ops->init_reg = init_reg;
693 /* Pre-initialize the register state REG for register REGNUM. */
696 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
697 struct dwarf2_frame_state_reg *reg,
698 struct frame_info *next_frame)
700 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
702 ops->init_reg (gdbarch, regnum, reg, next_frame);
705 /* Set the architecture-specific signal trampoline recognition
706 function for GDBARCH to SIGNAL_FRAME_P. */
709 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
710 int (*signal_frame_p) (struct gdbarch *,
711 struct frame_info *))
713 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
715 ops->signal_frame_p = signal_frame_p;
718 /* Query the architecture-specific signal frame recognizer for
722 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
723 struct frame_info *next_frame)
725 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
727 if (ops->signal_frame_p == NULL)
729 return ops->signal_frame_p (gdbarch, next_frame);
732 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
736 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
737 int (*adjust_regnum) (struct gdbarch *,
740 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
742 ops->adjust_regnum = adjust_regnum;
745 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
749 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum, int eh_frame_p)
751 struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
753 if (ops->adjust_regnum == NULL)
755 return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
759 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
760 struct dwarf2_fde *fde)
762 static const char *arm_idents[] = {
763 "ARM C Compiler, ADS",
764 "Thumb C Compiler, ADS",
765 "ARM C++ Compiler, ADS",
766 "Thumb C++ Compiler, ADS",
767 "ARM/Thumb C/C++ Compiler, RVCT"
773 s = find_pc_symtab (fs->pc);
774 if (s == NULL || s->producer == NULL)
777 for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
778 if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
780 if (fde->cie->version == 1)
781 fs->armcc_cfa_offsets_sf = 1;
783 if (fde->cie->version == 1)
784 fs->armcc_cfa_offsets_reversed = 1;
786 /* The reversed offset problem is present in some compilers
787 using DWARF3, but it was eventually fixed. Check the ARM
788 defined augmentations, which are in the format "armcc" followed
789 by a list of one-character options. The "+" option means
790 this problem is fixed (no quirk needed). If the armcc
791 augmentation is missing, the quirk is needed. */
792 if (fde->cie->version == 3
793 && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
794 || strchr (fde->cie->augmentation + 5, '+') == NULL))
795 fs->armcc_cfa_offsets_reversed = 1;
802 struct dwarf2_frame_cache
804 /* DWARF Call Frame Address. */
807 /* Set if the return address column was marked as undefined. */
808 int undefined_retaddr;
810 /* Saved registers, indexed by GDB register number, not by DWARF
812 struct dwarf2_frame_state_reg *reg;
814 /* Return address register. */
815 struct dwarf2_frame_state_reg retaddr_reg;
818 static struct dwarf2_frame_cache *
819 dwarf2_frame_cache (struct frame_info *next_frame, void **this_cache)
821 struct cleanup *old_chain;
822 struct gdbarch *gdbarch = get_frame_arch (next_frame);
823 const int num_regs = gdbarch_num_regs (gdbarch)
824 + gdbarch_num_pseudo_regs (gdbarch);
825 struct dwarf2_frame_cache *cache;
826 struct dwarf2_frame_state *fs;
827 struct dwarf2_fde *fde;
832 /* Allocate a new cache. */
833 cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
834 cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
836 /* Allocate and initialize the frame state. */
837 fs = XMALLOC (struct dwarf2_frame_state);
838 memset (fs, 0, sizeof (struct dwarf2_frame_state));
839 old_chain = make_cleanup (dwarf2_frame_state_free, fs);
843 Note that if NEXT_FRAME is never supposed to return (i.e. a call
844 to abort), the compiler might optimize away the instruction at
845 NEXT_FRAME's return address. As a result the return address will
846 point at some random instruction, and the CFI for that
847 instruction is probably worthless to us. GCC's unwinder solves
848 this problem by substracting 1 from the return address to get an
849 address in the middle of a presumed call instruction (or the
850 instruction in the associated delay slot). This should only be
851 done for "normal" frames and not for resume-type frames (signal
852 handlers, sentinel frames, dummy frames). The function
853 frame_unwind_address_in_block does just this. It's not clear how
854 reliable the method is though; there is the potential for the
855 register state pre-call being different to that on return. */
856 fs->pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
858 /* Find the correct FDE. */
859 fde = dwarf2_frame_find_fde (&fs->pc);
860 gdb_assert (fde != NULL);
862 /* Extract any interesting information from the CIE. */
863 fs->data_align = fde->cie->data_alignment_factor;
864 fs->code_align = fde->cie->code_alignment_factor;
865 fs->retaddr_column = fde->cie->return_address_register;
867 /* Check for "quirks" - known bugs in producers. */
868 dwarf2_frame_find_quirks (fs, fde);
870 /* First decode all the insns in the CIE. */
871 execute_cfa_program (fde->cie->initial_instructions,
872 fde->cie->end, next_frame, fs, fde->eh_frame_p);
874 /* Save the initialized register set. */
875 fs->initial = fs->regs;
876 fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
878 /* Then decode the insns in the FDE up to our target PC. */
879 execute_cfa_program (fde->instructions, fde->end, next_frame, fs,
882 /* Caclulate the CFA. */
886 cache->cfa = read_reg (next_frame, fs->cfa_reg);
887 if (fs->armcc_cfa_offsets_reversed)
888 cache->cfa -= fs->cfa_offset;
890 cache->cfa += fs->cfa_offset;
895 execute_stack_op (fs->cfa_exp, fs->cfa_exp_len, next_frame, 0);
899 internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
902 /* Initialize the register state. */
906 for (regnum = 0; regnum < num_regs; regnum++)
907 dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], next_frame);
910 /* Go through the DWARF2 CFI generated table and save its register
911 location information in the cache. Note that we don't skip the
912 return address column; it's perfectly all right for it to
913 correspond to a real register. If it doesn't correspond to a
914 real register, or if we shouldn't treat it as such,
915 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
916 the range [0, gdbarch_num_regs). */
918 int column; /* CFI speak for "register number". */
920 for (column = 0; column < fs->regs.num_regs; column++)
922 /* Use the GDB register number as the destination index. */
923 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
925 /* If there's no corresponding GDB register, ignore it. */
926 if (regnum < 0 || regnum >= num_regs)
929 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
930 of all debug info registers. If it doesn't, complain (but
931 not too loudly). It turns out that GCC assumes that an
932 unspecified register implies "same value" when CFI (draft
933 7) specifies nothing at all. Such a register could equally
934 be interpreted as "undefined". Also note that this check
935 isn't sufficient; it only checks that all registers in the
936 range [0 .. max column] are specified, and won't detect
937 problems when a debug info register falls outside of the
938 table. We need a way of iterating through all the valid
939 DWARF2 register numbers. */
940 if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
942 if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
943 complaint (&symfile_complaints, _("\
944 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
945 gdbarch_register_name (gdbarch, regnum),
949 cache->reg[regnum] = fs->regs.reg[column];
953 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
954 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
958 for (regnum = 0; regnum < num_regs; regnum++)
960 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
961 || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
963 struct dwarf2_frame_state_reg *retaddr_reg =
964 &fs->regs.reg[fs->retaddr_column];
966 /* It seems rather bizarre to specify an "empty" column as
967 the return adress column. However, this is exactly
968 what GCC does on some targets. It turns out that GCC
969 assumes that the return address can be found in the
970 register corresponding to the return address column.
971 Incidentally, that's how we should treat a return
972 address column specifying "same value" too. */
973 if (fs->retaddr_column < fs->regs.num_regs
974 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
975 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
977 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
978 cache->reg[regnum] = *retaddr_reg;
980 cache->retaddr_reg = *retaddr_reg;
984 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
986 cache->reg[regnum].loc.reg = fs->retaddr_column;
987 cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
991 cache->retaddr_reg.loc.reg = fs->retaddr_column;
992 cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
999 if (fs->retaddr_column < fs->regs.num_regs
1000 && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1001 cache->undefined_retaddr = 1;
1003 do_cleanups (old_chain);
1005 *this_cache = cache;
1010 dwarf2_frame_this_id (struct frame_info *next_frame, void **this_cache,
1011 struct frame_id *this_id)
1013 struct dwarf2_frame_cache *cache =
1014 dwarf2_frame_cache (next_frame, this_cache);
1016 if (cache->undefined_retaddr)
1019 (*this_id) = frame_id_build (cache->cfa,
1020 frame_func_unwind (next_frame, NORMAL_FRAME));
1024 dwarf2_signal_frame_this_id (struct frame_info *next_frame, void **this_cache,
1025 struct frame_id *this_id)
1027 struct dwarf2_frame_cache *cache =
1028 dwarf2_frame_cache (next_frame, this_cache);
1030 if (cache->undefined_retaddr)
1033 (*this_id) = frame_id_build (cache->cfa,
1034 frame_func_unwind (next_frame, SIGTRAMP_FRAME));
1038 dwarf2_frame_prev_register (struct frame_info *next_frame, void **this_cache,
1039 int regnum, int *optimizedp,
1040 enum lval_type *lvalp, CORE_ADDR *addrp,
1041 int *realnump, gdb_byte *valuep)
1043 struct gdbarch *gdbarch = get_frame_arch (next_frame);
1044 struct dwarf2_frame_cache *cache =
1045 dwarf2_frame_cache (next_frame, this_cache);
1047 switch (cache->reg[regnum].how)
1049 case DWARF2_FRAME_REG_UNDEFINED:
1050 /* If CFI explicitly specified that the value isn't defined,
1051 mark it as optimized away; the value isn't available. */
1058 /* In some cases, for example %eflags on the i386, we have
1059 to provide a sane value, even though this register wasn't
1060 saved. Assume we can get it from NEXT_FRAME. */
1061 frame_unwind_register (next_frame, regnum, valuep);
1065 case DWARF2_FRAME_REG_SAVED_OFFSET:
1067 *lvalp = lval_memory;
1068 *addrp = cache->cfa + cache->reg[regnum].loc.offset;
1072 /* Read the value in from memory. */
1073 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1077 case DWARF2_FRAME_REG_SAVED_REG:
1079 *lvalp = lval_register;
1081 *realnump = gdbarch_dwarf2_reg_to_regnum
1082 (gdbarch, cache->reg[regnum].loc.reg);
1084 frame_unwind_register (next_frame, (*realnump), valuep);
1087 case DWARF2_FRAME_REG_SAVED_EXP:
1089 *lvalp = lval_memory;
1090 *addrp = execute_stack_op (cache->reg[regnum].loc.exp,
1091 cache->reg[regnum].exp_len,
1092 next_frame, cache->cfa);
1096 /* Read the value in from memory. */
1097 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
1101 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1107 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1108 cache->cfa + cache->reg[regnum].loc.offset);
1111 case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1117 store_unsigned_integer (valuep, register_size (gdbarch, regnum),
1118 execute_stack_op (cache->reg[regnum].loc.exp,
1119 cache->reg[regnum].exp_len,
1120 next_frame, cache->cfa));
1123 case DWARF2_FRAME_REG_UNSPECIFIED:
1124 /* GCC, in its infinite wisdom decided to not provide unwind
1125 information for registers that are "same value". Since
1126 DWARF2 (3 draft 7) doesn't define such behavior, said
1127 registers are actually undefined (which is different to CFI
1128 "undefined"). Code above issues a complaint about this.
1129 Here just fudge the books, assume GCC, and that the value is
1130 more inner on the stack. */
1132 *lvalp = lval_register;
1136 frame_unwind_register (next_frame, (*realnump), valuep);
1139 case DWARF2_FRAME_REG_SAME_VALUE:
1141 *lvalp = lval_register;
1145 frame_unwind_register (next_frame, (*realnump), valuep);
1148 case DWARF2_FRAME_REG_CFA:
1154 pack_long (valuep, register_type (gdbarch, regnum), cache->cfa);
1157 case DWARF2_FRAME_REG_CFA_OFFSET:
1163 pack_long (valuep, register_type (gdbarch, regnum),
1164 cache->cfa + cache->reg[regnum].loc.offset);
1167 case DWARF2_FRAME_REG_RA_OFFSET:
1174 CORE_ADDR pc = cache->reg[regnum].loc.offset;
1176 regnum = gdbarch_dwarf2_reg_to_regnum
1177 (gdbarch, cache->retaddr_reg.loc.reg);
1178 pc += frame_unwind_register_unsigned (next_frame, regnum);
1179 pack_long (valuep, register_type (gdbarch, regnum), pc);
1184 internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1188 static const struct frame_unwind dwarf2_frame_unwind =
1191 dwarf2_frame_this_id,
1192 dwarf2_frame_prev_register
1195 static const struct frame_unwind dwarf2_signal_frame_unwind =
1198 dwarf2_signal_frame_this_id,
1199 dwarf2_frame_prev_register
1202 const struct frame_unwind *
1203 dwarf2_frame_sniffer (struct frame_info *next_frame)
1205 /* Grab an address that is guarenteed to reside somewhere within the
1206 function. frame_pc_unwind(), for a no-return next function, can
1207 end up returning something past the end of this function's body.
1208 If the frame we're sniffing for is a signal frame whose start
1209 address is placed on the stack by the OS, its FDE must
1210 extend one byte before its start address or we will miss it. */
1211 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
1213 struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1217 /* On some targets, signal trampolines may have unwind information.
1218 We need to recognize them so that we set the frame type
1221 if (fde->cie->signal_frame
1222 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame),
1224 return &dwarf2_signal_frame_unwind;
1226 return &dwarf2_frame_unwind;
1230 /* There is no explicitly defined relationship between the CFA and the
1231 location of frame's local variables and arguments/parameters.
1232 Therefore, frame base methods on this page should probably only be
1233 used as a last resort, just to avoid printing total garbage as a
1234 response to the "info frame" command. */
1237 dwarf2_frame_base_address (struct frame_info *next_frame, void **this_cache)
1239 struct dwarf2_frame_cache *cache =
1240 dwarf2_frame_cache (next_frame, this_cache);
1245 static const struct frame_base dwarf2_frame_base =
1247 &dwarf2_frame_unwind,
1248 dwarf2_frame_base_address,
1249 dwarf2_frame_base_address,
1250 dwarf2_frame_base_address
1253 const struct frame_base *
1254 dwarf2_frame_base_sniffer (struct frame_info *next_frame)
1256 CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame,
1258 if (dwarf2_frame_find_fde (&block_addr))
1259 return &dwarf2_frame_base;
1264 /* A minimal decoding of DWARF2 compilation units. We only decode
1265 what's needed to get to the call frame information. */
1269 /* Keep the bfd convenient. */
1272 struct objfile *objfile;
1274 /* Linked list of CIEs for this object. */
1275 struct dwarf2_cie *cie;
1277 /* Pointer to the .debug_frame section loaded into memory. */
1278 gdb_byte *dwarf_frame_buffer;
1280 /* Length of the loaded .debug_frame section. */
1281 unsigned long dwarf_frame_size;
1283 /* Pointer to the .debug_frame section. */
1284 asection *dwarf_frame_section;
1286 /* Base for DW_EH_PE_datarel encodings. */
1289 /* Base for DW_EH_PE_textrel encodings. */
1293 const struct objfile_data *dwarf2_frame_objfile_data;
1296 read_1_byte (bfd *abfd, gdb_byte *buf)
1298 return bfd_get_8 (abfd, buf);
1302 read_4_bytes (bfd *abfd, gdb_byte *buf)
1304 return bfd_get_32 (abfd, buf);
1308 read_8_bytes (bfd *abfd, gdb_byte *buf)
1310 return bfd_get_64 (abfd, buf);
1314 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1317 unsigned int num_read;
1327 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1330 result |= ((byte & 0x7f) << shift);
1333 while (byte & 0x80);
1335 *bytes_read_ptr = num_read;
1341 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1345 unsigned int num_read;
1354 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1357 result |= ((byte & 0x7f) << shift);
1360 while (byte & 0x80);
1362 if (shift < 8 * sizeof (result) && (byte & 0x40))
1363 result |= -(((LONGEST)1) << shift);
1365 *bytes_read_ptr = num_read;
1371 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1375 result = bfd_get_32 (abfd, buf);
1376 if (result == 0xffffffff)
1378 result = bfd_get_64 (abfd, buf + 4);
1379 *bytes_read_ptr = 12;
1382 *bytes_read_ptr = 4;
1388 /* Pointer encoding helper functions. */
1390 /* GCC supports exception handling based on DWARF2 CFI. However, for
1391 technical reasons, it encodes addresses in its FDE's in a different
1392 way. Several "pointer encodings" are supported. The encoding
1393 that's used for a particular FDE is determined by the 'R'
1394 augmentation in the associated CIE. The argument of this
1395 augmentation is a single byte.
1397 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1398 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1399 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1400 address should be interpreted (absolute, relative to the current
1401 position in the FDE, ...). Bit 7, indicates that the address
1402 should be dereferenced. */
1405 encoding_for_size (unsigned int size)
1410 return DW_EH_PE_udata2;
1412 return DW_EH_PE_udata4;
1414 return DW_EH_PE_udata8;
1416 internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1421 size_of_encoded_value (gdb_byte encoding)
1423 if (encoding == DW_EH_PE_omit)
1426 switch (encoding & 0x07)
1428 case DW_EH_PE_absptr:
1429 return TYPE_LENGTH (builtin_type_void_data_ptr);
1430 case DW_EH_PE_udata2:
1432 case DW_EH_PE_udata4:
1434 case DW_EH_PE_udata8:
1437 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1442 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1443 gdb_byte *buf, unsigned int *bytes_read_ptr)
1445 int ptr_len = size_of_encoded_value (DW_EH_PE_absptr);
1449 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1451 if (encoding & DW_EH_PE_indirect)
1452 internal_error (__FILE__, __LINE__,
1453 _("Unsupported encoding: DW_EH_PE_indirect"));
1455 *bytes_read_ptr = 0;
1457 switch (encoding & 0x70)
1459 case DW_EH_PE_absptr:
1462 case DW_EH_PE_pcrel:
1463 base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1464 base += (buf - unit->dwarf_frame_buffer);
1466 case DW_EH_PE_datarel:
1469 case DW_EH_PE_textrel:
1472 case DW_EH_PE_funcrel:
1473 /* FIXME: kettenis/20040501: For now just pretend
1474 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1475 reading the initial location of an FDE it should be treated
1476 as such, and currently that's the only place where this code
1480 case DW_EH_PE_aligned:
1482 offset = buf - unit->dwarf_frame_buffer;
1483 if ((offset % ptr_len) != 0)
1485 *bytes_read_ptr = ptr_len - (offset % ptr_len);
1486 buf += *bytes_read_ptr;
1490 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1493 if ((encoding & 0x07) == 0x00)
1495 encoding |= encoding_for_size (ptr_len);
1496 if (bfd_get_sign_extend_vma (unit->abfd))
1497 encoding |= DW_EH_PE_signed;
1500 switch (encoding & 0x0f)
1502 case DW_EH_PE_uleb128:
1505 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1506 *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1507 return base + value;
1509 case DW_EH_PE_udata2:
1510 *bytes_read_ptr += 2;
1511 return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1512 case DW_EH_PE_udata4:
1513 *bytes_read_ptr += 4;
1514 return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1515 case DW_EH_PE_udata8:
1516 *bytes_read_ptr += 8;
1517 return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1518 case DW_EH_PE_sleb128:
1521 gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1522 *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1523 return base + value;
1525 case DW_EH_PE_sdata2:
1526 *bytes_read_ptr += 2;
1527 return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1528 case DW_EH_PE_sdata4:
1529 *bytes_read_ptr += 4;
1530 return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1531 case DW_EH_PE_sdata8:
1532 *bytes_read_ptr += 8;
1533 return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1535 internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1540 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1541 That's why we use a simple linked list here. */
1543 static struct dwarf2_cie *
1544 find_cie (struct comp_unit *unit, ULONGEST cie_pointer)
1546 struct dwarf2_cie *cie = unit->cie;
1550 if (cie->cie_pointer == cie_pointer)
1560 add_cie (struct comp_unit *unit, struct dwarf2_cie *cie)
1562 cie->next = unit->cie;
1566 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1567 inital location associated with it into *PC. */
1569 static struct dwarf2_fde *
1570 dwarf2_frame_find_fde (CORE_ADDR *pc)
1572 struct objfile *objfile;
1574 ALL_OBJFILES (objfile)
1576 struct dwarf2_fde *fde;
1579 fde = objfile_data (objfile, dwarf2_frame_objfile_data);
1583 gdb_assert (objfile->section_offsets);
1584 offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1588 if (*pc >= fde->initial_location + offset
1589 && *pc < fde->initial_location + offset + fde->address_range)
1591 *pc = fde->initial_location + offset;
1603 add_fde (struct comp_unit *unit, struct dwarf2_fde *fde)
1605 fde->next = objfile_data (unit->objfile, dwarf2_frame_objfile_data);
1606 set_objfile_data (unit->objfile, dwarf2_frame_objfile_data, fde);
1609 #ifdef CC_HAS_LONG_LONG
1610 #define DW64_CIE_ID 0xffffffffffffffffULL
1612 #define DW64_CIE_ID ~0
1615 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1618 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1619 the next byte to be processed. */
1621 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1623 gdb_byte *buf, *end;
1625 unsigned int bytes_read;
1628 ULONGEST cie_pointer;
1631 length = read_initial_length (unit->abfd, buf, &bytes_read);
1635 /* Are we still within the section? */
1636 if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1642 /* Distinguish between 32 and 64-bit encoded frame info. */
1643 dwarf64_p = (bytes_read == 12);
1645 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1649 cie_id = DW64_CIE_ID;
1655 cie_pointer = read_8_bytes (unit->abfd, buf);
1660 cie_pointer = read_4_bytes (unit->abfd, buf);
1664 if (cie_pointer == cie_id)
1666 /* This is a CIE. */
1667 struct dwarf2_cie *cie;
1669 unsigned int cie_version;
1671 /* Record the offset into the .debug_frame section of this CIE. */
1672 cie_pointer = start - unit->dwarf_frame_buffer;
1674 /* Check whether we've already read it. */
1675 if (find_cie (unit, cie_pointer))
1678 cie = (struct dwarf2_cie *)
1679 obstack_alloc (&unit->objfile->objfile_obstack,
1680 sizeof (struct dwarf2_cie));
1681 cie->initial_instructions = NULL;
1682 cie->cie_pointer = cie_pointer;
1684 /* The encoding for FDE's in a normal .debug_frame section
1685 depends on the target address size. */
1686 cie->encoding = DW_EH_PE_absptr;
1688 /* We'll determine the final value later, but we need to
1689 initialize it conservatively. */
1690 cie->signal_frame = 0;
1692 /* Check version number. */
1693 cie_version = read_1_byte (unit->abfd, buf);
1694 if (cie_version != 1 && cie_version != 3)
1696 cie->version = cie_version;
1699 /* Interpret the interesting bits of the augmentation. */
1700 cie->augmentation = augmentation = (char *) buf;
1701 buf += (strlen (augmentation) + 1);
1703 /* Ignore armcc augmentations. We only use them for quirks,
1704 and that doesn't happen until later. */
1705 if (strncmp (augmentation, "armcc", 5) == 0)
1706 augmentation += strlen (augmentation);
1708 /* The GCC 2.x "eh" augmentation has a pointer immediately
1709 following the augmentation string, so it must be handled
1711 if (augmentation[0] == 'e' && augmentation[1] == 'h')
1714 buf += TYPE_LENGTH (builtin_type_void_data_ptr);
1718 cie->code_alignment_factor =
1719 read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1722 cie->data_alignment_factor =
1723 read_signed_leb128 (unit->abfd, buf, &bytes_read);
1726 if (cie_version == 1)
1728 cie->return_address_register = read_1_byte (unit->abfd, buf);
1732 cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1734 cie->return_address_register
1735 = dwarf2_frame_adjust_regnum (current_gdbarch,
1736 cie->return_address_register,
1741 cie->saw_z_augmentation = (*augmentation == 'z');
1742 if (cie->saw_z_augmentation)
1746 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1750 cie->initial_instructions = buf + length;
1754 while (*augmentation)
1756 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1757 if (*augmentation == 'L')
1764 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1765 else if (*augmentation == 'R')
1767 cie->encoding = *buf++;
1771 /* "P" indicates a personality routine in the CIE augmentation. */
1772 else if (*augmentation == 'P')
1774 /* Skip. Avoid indirection since we throw away the result. */
1775 gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1776 read_encoded_value (unit, encoding, buf, &bytes_read);
1781 /* "S" indicates a signal frame, such that the return
1782 address must not be decremented to locate the call frame
1783 info for the previous frame; it might even be the first
1784 instruction of a function, so decrementing it would take
1785 us to a different function. */
1786 else if (*augmentation == 'S')
1788 cie->signal_frame = 1;
1792 /* Otherwise we have an unknown augmentation. Assume that either
1793 there is no augmentation data, or we saw a 'z' prefix. */
1796 if (cie->initial_instructions)
1797 buf = cie->initial_instructions;
1802 cie->initial_instructions = buf;
1805 add_cie (unit, cie);
1809 /* This is a FDE. */
1810 struct dwarf2_fde *fde;
1812 /* In an .eh_frame section, the CIE pointer is the delta between the
1813 address within the FDE where the CIE pointer is stored and the
1814 address of the CIE. Convert it to an offset into the .eh_frame
1818 cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1819 cie_pointer -= (dwarf64_p ? 8 : 4);
1822 /* In either case, validate the result is still within the section. */
1823 if (cie_pointer >= unit->dwarf_frame_size)
1826 fde = (struct dwarf2_fde *)
1827 obstack_alloc (&unit->objfile->objfile_obstack,
1828 sizeof (struct dwarf2_fde));
1829 fde->cie = find_cie (unit, cie_pointer);
1830 if (fde->cie == NULL)
1832 decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1834 fde->cie = find_cie (unit, cie_pointer);
1837 gdb_assert (fde->cie != NULL);
1839 fde->initial_location =
1840 read_encoded_value (unit, fde->cie->encoding, buf, &bytes_read);
1843 fde->address_range =
1844 read_encoded_value (unit, fde->cie->encoding & 0x0f, buf, &bytes_read);
1847 /* A 'z' augmentation in the CIE implies the presence of an
1848 augmentation field in the FDE as well. The only thing known
1849 to be in here at present is the LSDA entry for EH. So we
1850 can skip the whole thing. */
1851 if (fde->cie->saw_z_augmentation)
1855 length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1856 buf += bytes_read + length;
1861 fde->instructions = buf;
1864 fde->eh_frame_p = eh_frame_p;
1866 add_fde (unit, fde);
1872 /* Read a CIE or FDE in BUF and decode it. */
1874 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p)
1876 enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1879 ptrdiff_t start_offset;
1883 ret = decode_frame_entry_1 (unit, start, eh_frame_p);
1887 /* We have corrupt input data of some form. */
1889 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1890 and mismatches wrt padding and alignment of debug sections. */
1891 /* Note that there is no requirement in the standard for any
1892 alignment at all in the frame unwind sections. Testing for
1893 alignment before trying to interpret data would be incorrect.
1895 However, GCC traditionally arranged for frame sections to be
1896 sized such that the FDE length and CIE fields happen to be
1897 aligned (in theory, for performance). This, unfortunately,
1898 was done with .align directives, which had the side effect of
1899 forcing the section to be aligned by the linker.
1901 This becomes a problem when you have some other producer that
1902 creates frame sections that are not as strictly aligned. That
1903 produces a hole in the frame info that gets filled by the
1906 The GCC behaviour is arguably a bug, but it's effectively now
1907 part of the ABI, so we're now stuck with it, at least at the
1908 object file level. A smart linker may decide, in the process
1909 of compressing duplicate CIE information, that it can rewrite
1910 the entire output section without this extra padding. */
1912 start_offset = start - unit->dwarf_frame_buffer;
1913 if (workaround < ALIGN4 && (start_offset & 3) != 0)
1915 start += 4 - (start_offset & 3);
1916 workaround = ALIGN4;
1919 if (workaround < ALIGN8 && (start_offset & 7) != 0)
1921 start += 8 - (start_offset & 7);
1922 workaround = ALIGN8;
1926 /* Nothing left to try. Arrange to return as if we've consumed
1927 the entire input section. Hopefully we'll get valid info from
1928 the other of .debug_frame/.eh_frame. */
1930 ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1940 complaint (&symfile_complaints,
1941 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1942 unit->dwarf_frame_section->owner->filename,
1943 unit->dwarf_frame_section->name);
1947 complaint (&symfile_complaints,
1948 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1949 unit->dwarf_frame_section->owner->filename,
1950 unit->dwarf_frame_section->name);
1954 complaint (&symfile_complaints,
1955 _("Corrupt data in %s:%s"),
1956 unit->dwarf_frame_section->owner->filename,
1957 unit->dwarf_frame_section->name);
1965 /* FIXME: kettenis/20030504: This still needs to be integrated with
1966 dwarf2read.c in a better way. */
1968 /* Imported from dwarf2read.c. */
1969 extern asection *dwarf_frame_section;
1970 extern asection *dwarf_eh_frame_section;
1972 /* Imported from dwarf2read.c. */
1973 extern gdb_byte *dwarf2_read_section (struct objfile *objfile, asection *sectp);
1976 dwarf2_build_frame_info (struct objfile *objfile)
1978 struct comp_unit unit;
1979 gdb_byte *frame_ptr;
1981 /* Build a minimal decoding of the DWARF2 compilation unit. */
1982 unit.abfd = objfile->obfd;
1983 unit.objfile = objfile;
1987 /* First add the information from the .eh_frame section. That way,
1988 the FDEs from that section are searched last. */
1989 if (dwarf_eh_frame_section)
1991 asection *got, *txt;
1994 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
1995 dwarf_eh_frame_section);
1997 unit.dwarf_frame_size = bfd_get_section_size (dwarf_eh_frame_section);
1998 unit.dwarf_frame_section = dwarf_eh_frame_section;
2000 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2001 that is used for the i386/amd64 target, which currently is
2002 the only target in GCC that supports/uses the
2003 DW_EH_PE_datarel encoding. */
2004 got = bfd_get_section_by_name (unit.abfd, ".got");
2006 unit.dbase = got->vma;
2008 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2010 txt = bfd_get_section_by_name (unit.abfd, ".text");
2012 unit.tbase = txt->vma;
2014 frame_ptr = unit.dwarf_frame_buffer;
2015 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
2016 frame_ptr = decode_frame_entry (&unit, frame_ptr, 1);
2019 if (dwarf_frame_section)
2022 unit.dwarf_frame_buffer = dwarf2_read_section (objfile,
2023 dwarf_frame_section);
2024 unit.dwarf_frame_size = bfd_get_section_size (dwarf_frame_section);
2025 unit.dwarf_frame_section = dwarf_frame_section;
2027 frame_ptr = unit.dwarf_frame_buffer;
2028 while (frame_ptr < unit.dwarf_frame_buffer + unit.dwarf_frame_size)
2029 frame_ptr = decode_frame_entry (&unit, frame_ptr, 0);
2033 /* Provide a prototype to silence -Wmissing-prototypes. */
2034 void _initialize_dwarf2_frame (void);
2037 _initialize_dwarf2_frame (void)
2039 dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2040 dwarf2_frame_objfile_data = register_objfile_data ();