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
);
112 /* Structure describing a frame state. */
114 struct dwarf2_frame_state
116 /* Each register save state can be described in terms of a CFA slot,
117 another register, or a location expression. */
118 struct dwarf2_frame_state_reg_info
120 struct dwarf2_frame_state_reg
*reg
;
123 /* Used to implement DW_CFA_remember_state. */
124 struct dwarf2_frame_state_reg_info
*prev
;
136 /* The PC described by the current frame state. */
139 /* Initial register set from the CIE.
140 Used to implement DW_CFA_restore. */
141 struct dwarf2_frame_state_reg_info initial
;
143 /* The information we care about from the CIE. */
146 ULONGEST retaddr_column
;
148 /* Flags for known producer quirks. */
150 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
151 and DW_CFA_def_cfa_offset takes a factored offset. */
152 int armcc_cfa_offsets_sf
;
154 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
155 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
156 int armcc_cfa_offsets_reversed
;
159 /* Store the length the expression for the CFA in the `cfa_reg' field,
160 which is unused in that case. */
161 #define cfa_exp_len cfa_reg
163 /* Assert that the register set RS is large enough to store NUM_REGS
164 columns. If necessary, enlarge the register set. */
167 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
170 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
172 if (num_regs
<= rs
->num_regs
)
175 rs
->reg
= (struct dwarf2_frame_state_reg
*)
176 xrealloc (rs
->reg
, num_regs
* size
);
178 /* Initialize newly allocated registers. */
179 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
180 rs
->num_regs
= num_regs
;
183 /* Copy the register columns in register set RS into newly allocated
184 memory and return a pointer to this newly created copy. */
186 static struct dwarf2_frame_state_reg
*
187 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
189 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
190 struct dwarf2_frame_state_reg
*reg
;
192 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
193 memcpy (reg
, rs
->reg
, size
);
198 /* Release the memory allocated to register set RS. */
201 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
205 dwarf2_frame_state_free_regs (rs
->prev
);
212 /* Release the memory allocated to the frame state FS. */
215 dwarf2_frame_state_free (void *p
)
217 struct dwarf2_frame_state
*fs
= p
;
219 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
220 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
221 xfree (fs
->initial
.reg
);
222 xfree (fs
->regs
.reg
);
227 /* Helper functions for execute_stack_op. */
230 read_reg (void *baton
, int reg
)
232 struct frame_info
*next_frame
= (struct frame_info
*) baton
;
233 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
237 regnum
= DWARF2_REG_TO_REGNUM (reg
);
239 buf
= alloca (register_size (gdbarch
, regnum
));
240 frame_unwind_register (next_frame
, regnum
, buf
);
242 /* Convert the register to an integer. This returns a LONGEST
243 rather than a CORE_ADDR, but unpack_pointer does the same thing
244 under the covers, and this makes more sense for non-pointer
245 registers. Maybe read_reg and the associated interfaces should
246 deal with "struct value" instead of CORE_ADDR. */
247 return unpack_long (register_type (gdbarch
, regnum
), buf
);
251 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
253 read_memory (addr
, buf
, len
);
257 no_get_frame_base (void *baton
, gdb_byte
**start
, size_t *length
)
259 internal_error (__FILE__
, __LINE__
,
260 _("Support for DW_OP_fbreg is unimplemented"));
264 no_get_tls_address (void *baton
, CORE_ADDR offset
)
266 internal_error (__FILE__
, __LINE__
,
267 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
271 execute_stack_op (gdb_byte
*exp
, ULONGEST len
,
272 struct frame_info
*next_frame
, CORE_ADDR initial
)
274 struct dwarf_expr_context
*ctx
;
277 ctx
= new_dwarf_expr_context ();
278 ctx
->baton
= next_frame
;
279 ctx
->read_reg
= read_reg
;
280 ctx
->read_mem
= read_mem
;
281 ctx
->get_frame_base
= no_get_frame_base
;
282 ctx
->get_tls_address
= no_get_tls_address
;
284 dwarf_expr_push (ctx
, initial
);
285 dwarf_expr_eval (ctx
, exp
, len
);
286 result
= dwarf_expr_fetch (ctx
, 0);
289 result
= read_reg (next_frame
, result
);
291 free_dwarf_expr_context (ctx
);
298 execute_cfa_program (gdb_byte
*insn_ptr
, gdb_byte
*insn_end
,
299 struct frame_info
*next_frame
,
300 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
302 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
304 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
306 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
308 gdb_byte insn
= *insn_ptr
++;
312 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
313 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
314 else if ((insn
& 0xc0) == DW_CFA_offset
)
318 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
319 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
320 offset
= utmp
* fs
->data_align
;
321 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
322 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
323 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
325 else if ((insn
& 0xc0) == DW_CFA_restore
)
327 gdb_assert (fs
->initial
.reg
);
330 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
331 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
332 if (reg
< fs
->initial
.num_regs
)
333 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
335 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
337 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
338 complaint (&symfile_complaints
, _("\
339 incomplete CFI data; DW_CFA_restore unspecified\n\
340 register %s (#%d) at 0x%s"),
341 REGISTER_NAME(DWARF2_REG_TO_REGNUM(reg
)),
342 DWARF2_REG_TO_REGNUM(reg
), paddr (fs
->pc
));
349 fs
->pc
= dwarf2_read_address (insn_ptr
, insn_end
, &bytes_read
);
350 insn_ptr
+= bytes_read
;
353 case DW_CFA_advance_loc1
:
354 utmp
= extract_unsigned_integer (insn_ptr
, 1);
355 fs
->pc
+= utmp
* fs
->code_align
;
358 case DW_CFA_advance_loc2
:
359 utmp
= extract_unsigned_integer (insn_ptr
, 2);
360 fs
->pc
+= utmp
* fs
->code_align
;
363 case DW_CFA_advance_loc4
:
364 utmp
= extract_unsigned_integer (insn_ptr
, 4);
365 fs
->pc
+= utmp
* fs
->code_align
;
369 case DW_CFA_offset_extended
:
370 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
372 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
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
, ®
);
384 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
385 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
386 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
389 case DW_CFA_undefined
:
390 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
392 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
393 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
394 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
397 case DW_CFA_same_value
:
398 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
400 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
401 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
402 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
405 case DW_CFA_register
:
406 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
408 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
409 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
411 utmp
= dwarf2_frame_eh_frame_regnum (gdbarch
, utmp
);
412 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
413 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
414 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
417 case DW_CFA_remember_state
:
419 struct dwarf2_frame_state_reg_info
*new_rs
;
421 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
423 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
424 fs
->regs
.prev
= new_rs
;
428 case DW_CFA_restore_state
:
430 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
434 complaint (&symfile_complaints
, _("\
435 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs
->pc
));
439 xfree (fs
->regs
.reg
);
447 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
448 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
450 if (fs
->armcc_cfa_offsets_sf
)
451 utmp
*= fs
->data_align
;
453 fs
->cfa_offset
= utmp
;
454 fs
->cfa_how
= CFA_REG_OFFSET
;
457 case DW_CFA_def_cfa_register
:
458 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
460 fs
->cfa_reg
= dwarf2_frame_eh_frame_regnum (gdbarch
,
462 fs
->cfa_how
= CFA_REG_OFFSET
;
465 case DW_CFA_def_cfa_offset
:
466 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
468 if (fs
->armcc_cfa_offsets_sf
)
469 utmp
*= fs
->data_align
;
471 fs
->cfa_offset
= utmp
;
472 /* cfa_how deliberately not set. */
478 case DW_CFA_def_cfa_expression
:
479 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_exp_len
);
480 fs
->cfa_exp
= insn_ptr
;
481 fs
->cfa_how
= CFA_EXP
;
482 insn_ptr
+= fs
->cfa_exp_len
;
485 case DW_CFA_expression
:
486 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
488 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
489 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
490 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
491 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
492 fs
->regs
.reg
[reg
].exp_len
= utmp
;
493 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
497 case DW_CFA_offset_extended_sf
:
498 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
500 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
501 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
502 offset
*= fs
->data_align
;
503 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
504 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
505 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
508 case DW_CFA_val_offset
:
509 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
510 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
511 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
512 offset
= utmp
* fs
->data_align
;
513 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
514 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
517 case DW_CFA_val_offset_sf
:
518 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
519 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
520 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
521 offset
*= fs
->data_align
;
522 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
523 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
526 case DW_CFA_val_expression
:
527 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
528 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
529 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
530 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
531 fs
->regs
.reg
[reg
].exp_len
= utmp
;
532 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
536 case DW_CFA_def_cfa_sf
:
537 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
539 fs
->cfa_reg
= dwarf2_frame_eh_frame_regnum (gdbarch
,
541 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
542 fs
->cfa_offset
= offset
* fs
->data_align
;
543 fs
->cfa_how
= CFA_REG_OFFSET
;
546 case DW_CFA_def_cfa_offset_sf
:
547 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
548 fs
->cfa_offset
= offset
* fs
->data_align
;
549 /* cfa_how deliberately not set. */
552 case DW_CFA_GNU_window_save
:
553 /* This is SPARC-specific code, and contains hard-coded
554 constants for the register numbering scheme used by
555 GCC. Rather than having a architecture-specific
556 operation that's only ever used by a single
557 architecture, we provide the implementation here.
558 Incidentally that's what GCC does too in its
561 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
562 int size
= register_size(gdbarch
, 0);
563 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
564 for (reg
= 8; reg
< 16; reg
++)
566 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
567 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
569 for (reg
= 16; reg
< 32; reg
++)
571 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
572 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
577 case DW_CFA_GNU_args_size
:
579 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
582 case DW_CFA_GNU_negative_offset_extended
:
583 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
585 reg
= dwarf2_frame_eh_frame_regnum (gdbarch
, reg
);
586 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
587 offset
*= fs
->data_align
;
588 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
589 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
590 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
594 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
599 /* Don't allow remember/restore between CIE and FDE programs. */
600 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
601 fs
->regs
.prev
= NULL
;
605 /* Architecture-specific operations. */
607 /* Per-architecture data key. */
608 static struct gdbarch_data
*dwarf2_frame_data
;
610 struct dwarf2_frame_ops
612 /* Pre-initialize the register state REG for register REGNUM. */
613 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
614 struct frame_info
*);
616 /* Check whether the frame preceding NEXT_FRAME will be a signal
618 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
620 /* Convert .eh_frame register number to DWARF register number. */
621 int (*eh_frame_regnum
) (struct gdbarch
*, int);
624 /* Default architecture-specific register state initialization
628 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
629 struct dwarf2_frame_state_reg
*reg
,
630 struct frame_info
*next_frame
)
632 /* If we have a register that acts as a program counter, mark it as
633 a destination for the return address. If we have a register that
634 serves as the stack pointer, arrange for it to be filled with the
635 call frame address (CFA). The other registers are marked as
638 We copy the return address to the program counter, since many
639 parts in GDB assume that it is possible to get the return address
640 by unwinding the program counter register. However, on ISA's
641 with a dedicated return address register, the CFI usually only
642 contains information to unwind that return address register.
644 The reason we're treating the stack pointer special here is
645 because in many cases GCC doesn't emit CFI for the stack pointer
646 and implicitly assumes that it is equal to the CFA. This makes
647 some sense since the DWARF specification (version 3, draft 8,
650 "Typically, the CFA is defined to be the value of the stack
651 pointer at the call site in the previous frame (which may be
652 different from its value on entry to the current frame)."
654 However, this isn't true for all platforms supported by GCC
655 (e.g. IBM S/390 and zSeries). Those architectures should provide
656 their own architecture-specific initialization function. */
658 if (regnum
== PC_REGNUM
)
659 reg
->how
= DWARF2_FRAME_REG_RA
;
660 else if (regnum
== SP_REGNUM
)
661 reg
->how
= DWARF2_FRAME_REG_CFA
;
664 /* Return a default for the architecture-specific operations. */
667 dwarf2_frame_init (struct obstack
*obstack
)
669 struct dwarf2_frame_ops
*ops
;
671 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
672 ops
->init_reg
= dwarf2_frame_default_init_reg
;
676 /* Set the architecture-specific register state initialization
677 function for GDBARCH to INIT_REG. */
680 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
681 void (*init_reg
) (struct gdbarch
*, int,
682 struct dwarf2_frame_state_reg
*,
683 struct frame_info
*))
685 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
687 ops
->init_reg
= init_reg
;
690 /* Pre-initialize the register state REG for register REGNUM. */
693 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
694 struct dwarf2_frame_state_reg
*reg
,
695 struct frame_info
*next_frame
)
697 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
699 ops
->init_reg (gdbarch
, regnum
, reg
, next_frame
);
702 /* Set the architecture-specific signal trampoline recognition
703 function for GDBARCH to SIGNAL_FRAME_P. */
706 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
707 int (*signal_frame_p
) (struct gdbarch
*,
708 struct frame_info
*))
710 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
712 ops
->signal_frame_p
= signal_frame_p
;
715 /* Query the architecture-specific signal frame recognizer for
719 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
720 struct frame_info
*next_frame
)
722 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
724 if (ops
->signal_frame_p
== NULL
)
726 return ops
->signal_frame_p (gdbarch
, next_frame
);
729 /* Set the architecture-specific mapping of .eh_frame register numbers to
730 DWARF register numbers. */
733 dwarf2_frame_set_eh_frame_regnum (struct gdbarch
*gdbarch
,
734 int (*eh_frame_regnum
) (struct gdbarch
*,
737 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
739 ops
->eh_frame_regnum
= eh_frame_regnum
;
742 /* Translate a .eh_frame register to DWARF register. */
745 dwarf2_frame_eh_frame_regnum (struct gdbarch
*gdbarch
, int regnum
)
747 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
749 if (ops
->eh_frame_regnum
== NULL
)
751 return ops
->eh_frame_regnum (gdbarch
, regnum
);
755 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
756 struct dwarf2_fde
*fde
)
758 static const char *arm_idents
[] = {
759 "ARM C Compiler, ADS",
760 "Thumb C Compiler, ADS",
761 "ARM C++ Compiler, ADS",
762 "Thumb C++ Compiler, ADS",
763 "ARM/Thumb C/C++ Compiler, RVCT"
769 s
= find_pc_symtab (fs
->pc
);
770 if (s
== NULL
|| s
->producer
== NULL
)
773 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
774 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
776 if (fde
->cie
->version
== 1)
777 fs
->armcc_cfa_offsets_sf
= 1;
779 if (fde
->cie
->version
== 1)
780 fs
->armcc_cfa_offsets_reversed
= 1;
782 /* The reversed offset problem is present in some compilers
783 using DWARF3, but it was eventually fixed. Check the ARM
784 defined augmentations, which are in the format "armcc" followed
785 by a list of one-character options. The "+" option means
786 this problem is fixed (no quirk needed). If the armcc
787 augmentation is missing, the quirk is needed. */
788 if (fde
->cie
->version
== 3
789 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
790 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
791 fs
->armcc_cfa_offsets_reversed
= 1;
798 struct dwarf2_frame_cache
800 /* DWARF Call Frame Address. */
803 /* Set if the return address column was marked as undefined. */
804 int undefined_retaddr
;
806 /* Saved registers, indexed by GDB register number, not by DWARF
808 struct dwarf2_frame_state_reg
*reg
;
810 /* Return address register. */
811 struct dwarf2_frame_state_reg retaddr_reg
;
814 static struct dwarf2_frame_cache
*
815 dwarf2_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
817 struct cleanup
*old_chain
;
818 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
819 const int num_regs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
820 struct dwarf2_frame_cache
*cache
;
821 struct dwarf2_frame_state
*fs
;
822 struct dwarf2_fde
*fde
;
827 /* Allocate a new cache. */
828 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
829 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
831 /* Allocate and initialize the frame state. */
832 fs
= XMALLOC (struct dwarf2_frame_state
);
833 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
834 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
838 Note that if NEXT_FRAME is never supposed to return (i.e. a call
839 to abort), the compiler might optimize away the instruction at
840 NEXT_FRAME's return address. As a result the return address will
841 point at some random instruction, and the CFI for that
842 instruction is probably worthless to us. GCC's unwinder solves
843 this problem by substracting 1 from the return address to get an
844 address in the middle of a presumed call instruction (or the
845 instruction in the associated delay slot). This should only be
846 done for "normal" frames and not for resume-type frames (signal
847 handlers, sentinel frames, dummy frames). The function
848 frame_unwind_address_in_block does just this. It's not clear how
849 reliable the method is though; there is the potential for the
850 register state pre-call being different to that on return. */
851 fs
->pc
= frame_unwind_address_in_block (next_frame
);
853 /* Find the correct FDE. */
854 fde
= dwarf2_frame_find_fde (&fs
->pc
);
855 gdb_assert (fde
!= NULL
);
857 /* Extract any interesting information from the CIE. */
858 fs
->data_align
= fde
->cie
->data_alignment_factor
;
859 fs
->code_align
= fde
->cie
->code_alignment_factor
;
860 fs
->retaddr_column
= fde
->cie
->return_address_register
;
862 /* Check for "quirks" - known bugs in producers. */
863 dwarf2_frame_find_quirks (fs
, fde
);
865 /* First decode all the insns in the CIE. */
866 execute_cfa_program (fde
->cie
->initial_instructions
,
867 fde
->cie
->end
, next_frame
, fs
, fde
->eh_frame_p
);
869 /* Save the initialized register set. */
870 fs
->initial
= fs
->regs
;
871 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
873 /* Then decode the insns in the FDE up to our target PC. */
874 execute_cfa_program (fde
->instructions
, fde
->end
, next_frame
, fs
,
877 /* Caclulate the CFA. */
881 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
882 if (fs
->armcc_cfa_offsets_reversed
)
883 cache
->cfa
-= fs
->cfa_offset
;
885 cache
->cfa
+= fs
->cfa_offset
;
890 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
, next_frame
, 0);
894 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
897 /* Initialize the register state. */
901 for (regnum
= 0; regnum
< num_regs
; regnum
++)
902 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], next_frame
);
905 /* Go through the DWARF2 CFI generated table and save its register
906 location information in the cache. Note that we don't skip the
907 return address column; it's perfectly all right for it to
908 correspond to a real register. If it doesn't correspond to a
909 real register, or if we shouldn't treat it as such,
910 DWARF2_REG_TO_REGNUM should be defined to return a number outside
911 the range [0, NUM_REGS). */
913 int column
; /* CFI speak for "register number". */
915 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
917 /* Use the GDB register number as the destination index. */
918 int regnum
= DWARF2_REG_TO_REGNUM (column
);
920 /* If there's no corresponding GDB register, ignore it. */
921 if (regnum
< 0 || regnum
>= num_regs
)
924 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
925 of all debug info registers. If it doesn't, complain (but
926 not too loudly). It turns out that GCC assumes that an
927 unspecified register implies "same value" when CFI (draft
928 7) specifies nothing at all. Such a register could equally
929 be interpreted as "undefined". Also note that this check
930 isn't sufficient; it only checks that all registers in the
931 range [0 .. max column] are specified, and won't detect
932 problems when a debug info register falls outside of the
933 table. We need a way of iterating through all the valid
934 DWARF2 register numbers. */
935 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
937 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
938 complaint (&symfile_complaints
, _("\
939 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
940 gdbarch_register_name (gdbarch
, regnum
),
944 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
948 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
949 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
953 for (regnum
= 0; regnum
< num_regs
; regnum
++)
955 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
956 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
958 struct dwarf2_frame_state_reg
*retaddr_reg
=
959 &fs
->regs
.reg
[fs
->retaddr_column
];
961 /* It seems rather bizarre to specify an "empty" column as
962 the return adress column. However, this is exactly
963 what GCC does on some targets. It turns out that GCC
964 assumes that the return address can be found in the
965 register corresponding to the return address column.
966 Incidentally, that's how we should treat a return
967 address column specifying "same value" too. */
968 if (fs
->retaddr_column
< fs
->regs
.num_regs
969 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
970 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
972 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
973 cache
->reg
[regnum
] = *retaddr_reg
;
975 cache
->retaddr_reg
= *retaddr_reg
;
979 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
981 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
982 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
986 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
987 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
994 if (fs
->retaddr_column
< fs
->regs
.num_regs
995 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
996 cache
->undefined_retaddr
= 1;
998 do_cleanups (old_chain
);
1000 *this_cache
= cache
;
1005 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1006 struct frame_id
*this_id
)
1008 struct dwarf2_frame_cache
*cache
=
1009 dwarf2_frame_cache (next_frame
, this_cache
);
1011 if (cache
->undefined_retaddr
)
1014 (*this_id
) = frame_id_build (cache
->cfa
, frame_func_unwind (next_frame
));
1018 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
1019 int regnum
, int *optimizedp
,
1020 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1021 int *realnump
, gdb_byte
*valuep
)
1023 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1024 struct dwarf2_frame_cache
*cache
=
1025 dwarf2_frame_cache (next_frame
, this_cache
);
1027 switch (cache
->reg
[regnum
].how
)
1029 case DWARF2_FRAME_REG_UNDEFINED
:
1030 /* If CFI explicitly specified that the value isn't defined,
1031 mark it as optimized away; the value isn't available. */
1038 /* In some cases, for example %eflags on the i386, we have
1039 to provide a sane value, even though this register wasn't
1040 saved. Assume we can get it from NEXT_FRAME. */
1041 frame_unwind_register (next_frame
, regnum
, valuep
);
1045 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1047 *lvalp
= lval_memory
;
1048 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1052 /* Read the value in from memory. */
1053 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1057 case DWARF2_FRAME_REG_SAVED_REG
:
1059 *lvalp
= lval_register
;
1061 *realnump
= DWARF2_REG_TO_REGNUM (cache
->reg
[regnum
].loc
.reg
);
1063 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1066 case DWARF2_FRAME_REG_SAVED_EXP
:
1068 *lvalp
= lval_memory
;
1069 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1070 cache
->reg
[regnum
].exp_len
,
1071 next_frame
, cache
->cfa
);
1075 /* Read the value in from memory. */
1076 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1080 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1086 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1087 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1090 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1096 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1097 execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1098 cache
->reg
[regnum
].exp_len
,
1099 next_frame
, cache
->cfa
));
1102 case DWARF2_FRAME_REG_UNSPECIFIED
:
1103 /* GCC, in its infinite wisdom decided to not provide unwind
1104 information for registers that are "same value". Since
1105 DWARF2 (3 draft 7) doesn't define such behavior, said
1106 registers are actually undefined (which is different to CFI
1107 "undefined"). Code above issues a complaint about this.
1108 Here just fudge the books, assume GCC, and that the value is
1109 more inner on the stack. */
1111 *lvalp
= lval_register
;
1115 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1118 case DWARF2_FRAME_REG_SAME_VALUE
:
1120 *lvalp
= lval_register
;
1124 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1127 case DWARF2_FRAME_REG_CFA
:
1134 /* Store the value. */
1135 store_typed_address (valuep
, builtin_type_void_data_ptr
, cache
->cfa
);
1139 case DWARF2_FRAME_REG_CFA_OFFSET
:
1146 /* Store the value. */
1147 store_typed_address (valuep
, builtin_type_void_data_ptr
,
1148 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1152 case DWARF2_FRAME_REG_RA_OFFSET
:
1159 CORE_ADDR pc
= cache
->reg
[regnum
].loc
.offset
;
1161 regnum
= DWARF2_REG_TO_REGNUM (cache
->retaddr_reg
.loc
.reg
);
1162 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
);
1163 store_typed_address (valuep
, builtin_type_void_func_ptr
, pc
);
1168 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1172 static const struct frame_unwind dwarf2_frame_unwind
=
1175 dwarf2_frame_this_id
,
1176 dwarf2_frame_prev_register
1179 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1182 dwarf2_frame_this_id
,
1183 dwarf2_frame_prev_register
1186 const struct frame_unwind
*
1187 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
1189 /* Grab an address that is guarenteed to reside somewhere within the
1190 function. frame_pc_unwind(), for a no-return next function, can
1191 end up returning something past the end of this function's body. */
1192 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
);
1193 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1197 /* On some targets, signal trampolines may have unwind information.
1198 We need to recognize them so that we set the frame type
1201 if (fde
->cie
->signal_frame
1202 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame
),
1204 return &dwarf2_signal_frame_unwind
;
1206 return &dwarf2_frame_unwind
;
1210 /* There is no explicitly defined relationship between the CFA and the
1211 location of frame's local variables and arguments/parameters.
1212 Therefore, frame base methods on this page should probably only be
1213 used as a last resort, just to avoid printing total garbage as a
1214 response to the "info frame" command. */
1217 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1219 struct dwarf2_frame_cache
*cache
=
1220 dwarf2_frame_cache (next_frame
, this_cache
);
1225 static const struct frame_base dwarf2_frame_base
=
1227 &dwarf2_frame_unwind
,
1228 dwarf2_frame_base_address
,
1229 dwarf2_frame_base_address
,
1230 dwarf2_frame_base_address
1233 const struct frame_base
*
1234 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
1236 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1237 if (dwarf2_frame_find_fde (&pc
))
1238 return &dwarf2_frame_base
;
1243 /* A minimal decoding of DWARF2 compilation units. We only decode
1244 what's needed to get to the call frame information. */
1248 /* Keep the bfd convenient. */
1251 struct objfile
*objfile
;
1253 /* Linked list of CIEs for this object. */
1254 struct dwarf2_cie
*cie
;
1256 /* Pointer to the .debug_frame section loaded into memory. */
1257 gdb_byte
*dwarf_frame_buffer
;
1259 /* Length of the loaded .debug_frame section. */
1260 unsigned long dwarf_frame_size
;
1262 /* Pointer to the .debug_frame section. */
1263 asection
*dwarf_frame_section
;
1265 /* Base for DW_EH_PE_datarel encodings. */
1268 /* Base for DW_EH_PE_textrel encodings. */
1272 const struct objfile_data
*dwarf2_frame_objfile_data
;
1275 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1277 return bfd_get_8 (abfd
, buf
);
1281 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1283 return bfd_get_32 (abfd
, buf
);
1287 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1289 return bfd_get_64 (abfd
, buf
);
1293 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1296 unsigned int num_read
;
1306 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1309 result
|= ((byte
& 0x7f) << shift
);
1312 while (byte
& 0x80);
1314 *bytes_read_ptr
= num_read
;
1320 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1324 unsigned int num_read
;
1333 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1336 result
|= ((byte
& 0x7f) << shift
);
1339 while (byte
& 0x80);
1341 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1342 result
|= -(((LONGEST
)1) << shift
);
1344 *bytes_read_ptr
= num_read
;
1350 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1354 result
= bfd_get_32 (abfd
, buf
);
1355 if (result
== 0xffffffff)
1357 result
= bfd_get_64 (abfd
, buf
+ 4);
1358 *bytes_read_ptr
= 12;
1361 *bytes_read_ptr
= 4;
1367 /* Pointer encoding helper functions. */
1369 /* GCC supports exception handling based on DWARF2 CFI. However, for
1370 technical reasons, it encodes addresses in its FDE's in a different
1371 way. Several "pointer encodings" are supported. The encoding
1372 that's used for a particular FDE is determined by the 'R'
1373 augmentation in the associated CIE. The argument of this
1374 augmentation is a single byte.
1376 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1377 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1378 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1379 address should be interpreted (absolute, relative to the current
1380 position in the FDE, ...). Bit 7, indicates that the address
1381 should be dereferenced. */
1384 encoding_for_size (unsigned int size
)
1389 return DW_EH_PE_udata2
;
1391 return DW_EH_PE_udata4
;
1393 return DW_EH_PE_udata8
;
1395 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1400 size_of_encoded_value (gdb_byte encoding
)
1402 if (encoding
== DW_EH_PE_omit
)
1405 switch (encoding
& 0x07)
1407 case DW_EH_PE_absptr
:
1408 return TYPE_LENGTH (builtin_type_void_data_ptr
);
1409 case DW_EH_PE_udata2
:
1411 case DW_EH_PE_udata4
:
1413 case DW_EH_PE_udata8
:
1416 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1421 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1422 gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1424 int ptr_len
= size_of_encoded_value (DW_EH_PE_absptr
);
1428 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1430 if (encoding
& DW_EH_PE_indirect
)
1431 internal_error (__FILE__
, __LINE__
,
1432 _("Unsupported encoding: DW_EH_PE_indirect"));
1434 *bytes_read_ptr
= 0;
1436 switch (encoding
& 0x70)
1438 case DW_EH_PE_absptr
:
1441 case DW_EH_PE_pcrel
:
1442 base
= bfd_get_section_vma (unit
->bfd
, unit
->dwarf_frame_section
);
1443 base
+= (buf
- unit
->dwarf_frame_buffer
);
1445 case DW_EH_PE_datarel
:
1448 case DW_EH_PE_textrel
:
1451 case DW_EH_PE_funcrel
:
1452 /* FIXME: kettenis/20040501: For now just pretend
1453 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1454 reading the initial location of an FDE it should be treated
1455 as such, and currently that's the only place where this code
1459 case DW_EH_PE_aligned
:
1461 offset
= buf
- unit
->dwarf_frame_buffer
;
1462 if ((offset
% ptr_len
) != 0)
1464 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1465 buf
+= *bytes_read_ptr
;
1469 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1472 if ((encoding
& 0x07) == 0x00)
1473 encoding
|= encoding_for_size (ptr_len
);
1475 switch (encoding
& 0x0f)
1477 case DW_EH_PE_uleb128
:
1480 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1481 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1482 return base
+ value
;
1484 case DW_EH_PE_udata2
:
1485 *bytes_read_ptr
+= 2;
1486 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1487 case DW_EH_PE_udata4
:
1488 *bytes_read_ptr
+= 4;
1489 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1490 case DW_EH_PE_udata8
:
1491 *bytes_read_ptr
+= 8;
1492 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1493 case DW_EH_PE_sleb128
:
1496 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1497 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1498 return base
+ value
;
1500 case DW_EH_PE_sdata2
:
1501 *bytes_read_ptr
+= 2;
1502 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1503 case DW_EH_PE_sdata4
:
1504 *bytes_read_ptr
+= 4;
1505 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1506 case DW_EH_PE_sdata8
:
1507 *bytes_read_ptr
+= 8;
1508 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1510 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1515 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1516 That's why we use a simple linked list here. */
1518 static struct dwarf2_cie
*
1519 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1521 struct dwarf2_cie
*cie
= unit
->cie
;
1525 if (cie
->cie_pointer
== cie_pointer
)
1535 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1537 cie
->next
= unit
->cie
;
1541 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1542 inital location associated with it into *PC. */
1544 static struct dwarf2_fde
*
1545 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1547 struct objfile
*objfile
;
1549 ALL_OBJFILES (objfile
)
1551 struct dwarf2_fde
*fde
;
1554 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1558 gdb_assert (objfile
->section_offsets
);
1559 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1563 if (*pc
>= fde
->initial_location
+ offset
1564 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1566 *pc
= fde
->initial_location
+ offset
;
1578 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1580 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1581 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1584 #ifdef CC_HAS_LONG_LONG
1585 #define DW64_CIE_ID 0xffffffffffffffffULL
1587 #define DW64_CIE_ID ~0
1590 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1593 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1594 the next byte to be processed. */
1596 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1598 gdb_byte
*buf
, *end
;
1600 unsigned int bytes_read
;
1603 ULONGEST cie_pointer
;
1606 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1610 /* Are we still within the section? */
1611 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1617 /* Distinguish between 32 and 64-bit encoded frame info. */
1618 dwarf64_p
= (bytes_read
== 12);
1620 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1624 cie_id
= DW64_CIE_ID
;
1630 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1635 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1639 if (cie_pointer
== cie_id
)
1641 /* This is a CIE. */
1642 struct dwarf2_cie
*cie
;
1644 unsigned int cie_version
;
1646 /* Record the offset into the .debug_frame section of this CIE. */
1647 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1649 /* Check whether we've already read it. */
1650 if (find_cie (unit
, cie_pointer
))
1653 cie
= (struct dwarf2_cie
*)
1654 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1655 sizeof (struct dwarf2_cie
));
1656 cie
->initial_instructions
= NULL
;
1657 cie
->cie_pointer
= cie_pointer
;
1659 /* The encoding for FDE's in a normal .debug_frame section
1660 depends on the target address size. */
1661 cie
->encoding
= DW_EH_PE_absptr
;
1663 /* We'll determine the final value later, but we need to
1664 initialize it conservatively. */
1665 cie
->signal_frame
= 0;
1667 /* Check version number. */
1668 cie_version
= read_1_byte (unit
->abfd
, buf
);
1669 if (cie_version
!= 1 && cie_version
!= 3)
1671 cie
->version
= cie_version
;
1674 /* Interpret the interesting bits of the augmentation. */
1675 cie
->augmentation
= augmentation
= (char *) buf
;
1676 buf
+= (strlen (augmentation
) + 1);
1678 /* Ignore armcc augmentations. We only use them for quirks,
1679 and that doesn't happen until later. */
1680 if (strncmp (augmentation
, "armcc", 5) == 0)
1681 augmentation
+= strlen (augmentation
);
1683 /* The GCC 2.x "eh" augmentation has a pointer immediately
1684 following the augmentation string, so it must be handled
1686 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1689 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1693 cie
->code_alignment_factor
=
1694 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1697 cie
->data_alignment_factor
=
1698 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1701 if (cie_version
== 1)
1703 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1707 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1710 cie
->return_address_register
1711 = dwarf2_frame_eh_frame_regnum (current_gdbarch
,
1712 cie
->return_address_register
);
1716 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1717 if (cie
->saw_z_augmentation
)
1721 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1725 cie
->initial_instructions
= buf
+ length
;
1729 while (*augmentation
)
1731 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1732 if (*augmentation
== 'L')
1739 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1740 else if (*augmentation
== 'R')
1742 cie
->encoding
= *buf
++;
1746 /* "P" indicates a personality routine in the CIE augmentation. */
1747 else if (*augmentation
== 'P')
1749 /* Skip. Avoid indirection since we throw away the result. */
1750 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1751 read_encoded_value (unit
, encoding
, buf
, &bytes_read
);
1756 /* "S" indicates a signal frame, such that the return
1757 address must not be decremented to locate the call frame
1758 info for the previous frame; it might even be the first
1759 instruction of a function, so decrementing it would take
1760 us to a different function. */
1761 else if (*augmentation
== 'S')
1763 cie
->signal_frame
= 1;
1767 /* Otherwise we have an unknown augmentation. Assume that either
1768 there is no augmentation data, or we saw a 'z' prefix. */
1771 if (cie
->initial_instructions
)
1772 buf
= cie
->initial_instructions
;
1777 cie
->initial_instructions
= buf
;
1780 add_cie (unit
, cie
);
1784 /* This is a FDE. */
1785 struct dwarf2_fde
*fde
;
1787 /* In an .eh_frame section, the CIE pointer is the delta between the
1788 address within the FDE where the CIE pointer is stored and the
1789 address of the CIE. Convert it to an offset into the .eh_frame
1793 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1794 cie_pointer
-= (dwarf64_p
? 8 : 4);
1797 /* In either case, validate the result is still within the section. */
1798 if (cie_pointer
>= unit
->dwarf_frame_size
)
1801 fde
= (struct dwarf2_fde
*)
1802 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1803 sizeof (struct dwarf2_fde
));
1804 fde
->cie
= find_cie (unit
, cie_pointer
);
1805 if (fde
->cie
== NULL
)
1807 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1809 fde
->cie
= find_cie (unit
, cie_pointer
);
1812 gdb_assert (fde
->cie
!= NULL
);
1814 fde
->initial_location
=
1815 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1818 fde
->address_range
=
1819 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1822 /* A 'z' augmentation in the CIE implies the presence of an
1823 augmentation field in the FDE as well. The only thing known
1824 to be in here at present is the LSDA entry for EH. So we
1825 can skip the whole thing. */
1826 if (fde
->cie
->saw_z_augmentation
)
1830 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1831 buf
+= bytes_read
+ length
;
1836 fde
->instructions
= buf
;
1839 fde
->eh_frame_p
= eh_frame_p
;
1841 add_fde (unit
, fde
);
1847 /* Read a CIE or FDE in BUF and decode it. */
1849 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1851 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1854 ptrdiff_t start_offset
;
1858 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1862 /* We have corrupt input data of some form. */
1864 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1865 and mismatches wrt padding and alignment of debug sections. */
1866 /* Note that there is no requirement in the standard for any
1867 alignment at all in the frame unwind sections. Testing for
1868 alignment before trying to interpret data would be incorrect.
1870 However, GCC traditionally arranged for frame sections to be
1871 sized such that the FDE length and CIE fields happen to be
1872 aligned (in theory, for performance). This, unfortunately,
1873 was done with .align directives, which had the side effect of
1874 forcing the section to be aligned by the linker.
1876 This becomes a problem when you have some other producer that
1877 creates frame sections that are not as strictly aligned. That
1878 produces a hole in the frame info that gets filled by the
1881 The GCC behaviour is arguably a bug, but it's effectively now
1882 part of the ABI, so we're now stuck with it, at least at the
1883 object file level. A smart linker may decide, in the process
1884 of compressing duplicate CIE information, that it can rewrite
1885 the entire output section without this extra padding. */
1887 start_offset
= start
- unit
->dwarf_frame_buffer
;
1888 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1890 start
+= 4 - (start_offset
& 3);
1891 workaround
= ALIGN4
;
1894 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1896 start
+= 8 - (start_offset
& 7);
1897 workaround
= ALIGN8
;
1901 /* Nothing left to try. Arrange to return as if we've consumed
1902 the entire input section. Hopefully we'll get valid info from
1903 the other of .debug_frame/.eh_frame. */
1905 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1915 complaint (&symfile_complaints
,
1916 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1917 unit
->dwarf_frame_section
->owner
->filename
,
1918 unit
->dwarf_frame_section
->name
);
1922 complaint (&symfile_complaints
,
1923 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1924 unit
->dwarf_frame_section
->owner
->filename
,
1925 unit
->dwarf_frame_section
->name
);
1929 complaint (&symfile_complaints
,
1930 _("Corrupt data in %s:%s"),
1931 unit
->dwarf_frame_section
->owner
->filename
,
1932 unit
->dwarf_frame_section
->name
);
1940 /* FIXME: kettenis/20030504: This still needs to be integrated with
1941 dwarf2read.c in a better way. */
1943 /* Imported from dwarf2read.c. */
1944 extern asection
*dwarf_frame_section
;
1945 extern asection
*dwarf_eh_frame_section
;
1947 /* Imported from dwarf2read.c. */
1948 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1951 dwarf2_build_frame_info (struct objfile
*objfile
)
1953 struct comp_unit unit
;
1954 gdb_byte
*frame_ptr
;
1956 /* Build a minimal decoding of the DWARF2 compilation unit. */
1957 unit
.abfd
= objfile
->obfd
;
1958 unit
.objfile
= objfile
;
1962 /* First add the information from the .eh_frame section. That way,
1963 the FDEs from that section are searched last. */
1964 if (dwarf_eh_frame_section
)
1966 asection
*got
, *txt
;
1969 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1970 dwarf_eh_frame_section
);
1972 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1973 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1975 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1976 that is used for the i386/amd64 target, which currently is
1977 the only target in GCC that supports/uses the
1978 DW_EH_PE_datarel encoding. */
1979 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
1981 unit
.dbase
= got
->vma
;
1983 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1985 txt
= bfd_get_section_by_name (unit
.abfd
, ".text");
1987 unit
.tbase
= txt
->vma
;
1989 frame_ptr
= unit
.dwarf_frame_buffer
;
1990 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1991 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
1994 if (dwarf_frame_section
)
1997 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1998 dwarf_frame_section
);
1999 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
2000 unit
.dwarf_frame_section
= dwarf_frame_section
;
2002 frame_ptr
= unit
.dwarf_frame_buffer
;
2003 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
2004 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);
2008 /* Provide a prototype to silence -Wmissing-prototypes. */
2009 void _initialize_dwarf2_frame (void);
2012 _initialize_dwarf2_frame (void)
2014 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2015 dwarf2_frame_objfile_data
= register_objfile_data ();