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
, NORMAL_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
,
1015 frame_func_unwind (next_frame
, NORMAL_FRAME
));
1019 dwarf2_signal_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1020 struct frame_id
*this_id
)
1022 struct dwarf2_frame_cache
*cache
=
1023 dwarf2_frame_cache (next_frame
, this_cache
);
1025 if (cache
->undefined_retaddr
)
1028 (*this_id
) = frame_id_build (cache
->cfa
,
1029 frame_func_unwind (next_frame
, SIGTRAMP_FRAME
));
1033 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
1034 int regnum
, int *optimizedp
,
1035 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1036 int *realnump
, gdb_byte
*valuep
)
1038 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1039 struct dwarf2_frame_cache
*cache
=
1040 dwarf2_frame_cache (next_frame
, this_cache
);
1042 switch (cache
->reg
[regnum
].how
)
1044 case DWARF2_FRAME_REG_UNDEFINED
:
1045 /* If CFI explicitly specified that the value isn't defined,
1046 mark it as optimized away; the value isn't available. */
1053 /* In some cases, for example %eflags on the i386, we have
1054 to provide a sane value, even though this register wasn't
1055 saved. Assume we can get it from NEXT_FRAME. */
1056 frame_unwind_register (next_frame
, regnum
, valuep
);
1060 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1062 *lvalp
= lval_memory
;
1063 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1067 /* Read the value in from memory. */
1068 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1072 case DWARF2_FRAME_REG_SAVED_REG
:
1074 *lvalp
= lval_register
;
1076 *realnump
= DWARF2_REG_TO_REGNUM (cache
->reg
[regnum
].loc
.reg
);
1078 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1081 case DWARF2_FRAME_REG_SAVED_EXP
:
1083 *lvalp
= lval_memory
;
1084 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1085 cache
->reg
[regnum
].exp_len
,
1086 next_frame
, cache
->cfa
);
1090 /* Read the value in from memory. */
1091 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1095 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1101 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1102 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1105 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1111 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1112 execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1113 cache
->reg
[regnum
].exp_len
,
1114 next_frame
, cache
->cfa
));
1117 case DWARF2_FRAME_REG_UNSPECIFIED
:
1118 /* GCC, in its infinite wisdom decided to not provide unwind
1119 information for registers that are "same value". Since
1120 DWARF2 (3 draft 7) doesn't define such behavior, said
1121 registers are actually undefined (which is different to CFI
1122 "undefined"). Code above issues a complaint about this.
1123 Here just fudge the books, assume GCC, and that the value is
1124 more inner on the stack. */
1126 *lvalp
= lval_register
;
1130 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1133 case DWARF2_FRAME_REG_SAME_VALUE
:
1135 *lvalp
= lval_register
;
1139 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1142 case DWARF2_FRAME_REG_CFA
:
1149 /* Store the value. */
1150 store_typed_address (valuep
, builtin_type_void_data_ptr
, cache
->cfa
);
1154 case DWARF2_FRAME_REG_CFA_OFFSET
:
1161 /* Store the value. */
1162 store_typed_address (valuep
, builtin_type_void_data_ptr
,
1163 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
= DWARF2_REG_TO_REGNUM (cache
->retaddr_reg
.loc
.reg
);
1177 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
);
1178 store_typed_address (valuep
, builtin_type_void_func_ptr
, pc
);
1183 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1187 static const struct frame_unwind dwarf2_frame_unwind
=
1190 dwarf2_frame_this_id
,
1191 dwarf2_frame_prev_register
1194 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1197 dwarf2_signal_frame_this_id
,
1198 dwarf2_frame_prev_register
1201 const struct frame_unwind
*
1202 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
1204 /* Grab an address that is guarenteed to reside somewhere within the
1205 function. frame_pc_unwind(), for a no-return next function, can
1206 end up returning something past the end of this function's body.
1207 If the frame we're sniffing for is a signal frame whose start
1208 address is placed on the stack by the OS, its FDE must
1209 extend one byte before its start address or we will miss it. */
1210 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1212 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1216 /* On some targets, signal trampolines may have unwind information.
1217 We need to recognize them so that we set the frame type
1220 if (fde
->cie
->signal_frame
1221 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame
),
1223 return &dwarf2_signal_frame_unwind
;
1225 return &dwarf2_frame_unwind
;
1229 /* There is no explicitly defined relationship between the CFA and the
1230 location of frame's local variables and arguments/parameters.
1231 Therefore, frame base methods on this page should probably only be
1232 used as a last resort, just to avoid printing total garbage as a
1233 response to the "info frame" command. */
1236 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1238 struct dwarf2_frame_cache
*cache
=
1239 dwarf2_frame_cache (next_frame
, this_cache
);
1244 static const struct frame_base dwarf2_frame_base
=
1246 &dwarf2_frame_unwind
,
1247 dwarf2_frame_base_address
,
1248 dwarf2_frame_base_address
,
1249 dwarf2_frame_base_address
1252 const struct frame_base
*
1253 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
1255 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1257 if (dwarf2_frame_find_fde (&block_addr
))
1258 return &dwarf2_frame_base
;
1263 /* A minimal decoding of DWARF2 compilation units. We only decode
1264 what's needed to get to the call frame information. */
1268 /* Keep the bfd convenient. */
1271 struct objfile
*objfile
;
1273 /* Linked list of CIEs for this object. */
1274 struct dwarf2_cie
*cie
;
1276 /* Pointer to the .debug_frame section loaded into memory. */
1277 gdb_byte
*dwarf_frame_buffer
;
1279 /* Length of the loaded .debug_frame section. */
1280 unsigned long dwarf_frame_size
;
1282 /* Pointer to the .debug_frame section. */
1283 asection
*dwarf_frame_section
;
1285 /* Base for DW_EH_PE_datarel encodings. */
1288 /* Base for DW_EH_PE_textrel encodings. */
1292 const struct objfile_data
*dwarf2_frame_objfile_data
;
1295 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1297 return bfd_get_8 (abfd
, buf
);
1301 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1303 return bfd_get_32 (abfd
, buf
);
1307 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1309 return bfd_get_64 (abfd
, buf
);
1313 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1316 unsigned int num_read
;
1326 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1329 result
|= ((byte
& 0x7f) << shift
);
1332 while (byte
& 0x80);
1334 *bytes_read_ptr
= num_read
;
1340 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1344 unsigned int num_read
;
1353 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1356 result
|= ((byte
& 0x7f) << shift
);
1359 while (byte
& 0x80);
1361 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1362 result
|= -(((LONGEST
)1) << shift
);
1364 *bytes_read_ptr
= num_read
;
1370 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1374 result
= bfd_get_32 (abfd
, buf
);
1375 if (result
== 0xffffffff)
1377 result
= bfd_get_64 (abfd
, buf
+ 4);
1378 *bytes_read_ptr
= 12;
1381 *bytes_read_ptr
= 4;
1387 /* Pointer encoding helper functions. */
1389 /* GCC supports exception handling based on DWARF2 CFI. However, for
1390 technical reasons, it encodes addresses in its FDE's in a different
1391 way. Several "pointer encodings" are supported. The encoding
1392 that's used for a particular FDE is determined by the 'R'
1393 augmentation in the associated CIE. The argument of this
1394 augmentation is a single byte.
1396 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1397 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1398 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1399 address should be interpreted (absolute, relative to the current
1400 position in the FDE, ...). Bit 7, indicates that the address
1401 should be dereferenced. */
1404 encoding_for_size (unsigned int size
)
1409 return DW_EH_PE_udata2
;
1411 return DW_EH_PE_udata4
;
1413 return DW_EH_PE_udata8
;
1415 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1420 size_of_encoded_value (gdb_byte encoding
)
1422 if (encoding
== DW_EH_PE_omit
)
1425 switch (encoding
& 0x07)
1427 case DW_EH_PE_absptr
:
1428 return TYPE_LENGTH (builtin_type_void_data_ptr
);
1429 case DW_EH_PE_udata2
:
1431 case DW_EH_PE_udata4
:
1433 case DW_EH_PE_udata8
:
1436 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1441 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1442 gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1444 int ptr_len
= size_of_encoded_value (DW_EH_PE_absptr
);
1448 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1450 if (encoding
& DW_EH_PE_indirect
)
1451 internal_error (__FILE__
, __LINE__
,
1452 _("Unsupported encoding: DW_EH_PE_indirect"));
1454 *bytes_read_ptr
= 0;
1456 switch (encoding
& 0x70)
1458 case DW_EH_PE_absptr
:
1461 case DW_EH_PE_pcrel
:
1462 base
= bfd_get_section_vma (unit
->bfd
, unit
->dwarf_frame_section
);
1463 base
+= (buf
- unit
->dwarf_frame_buffer
);
1465 case DW_EH_PE_datarel
:
1468 case DW_EH_PE_textrel
:
1471 case DW_EH_PE_funcrel
:
1472 /* FIXME: kettenis/20040501: For now just pretend
1473 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1474 reading the initial location of an FDE it should be treated
1475 as such, and currently that's the only place where this code
1479 case DW_EH_PE_aligned
:
1481 offset
= buf
- unit
->dwarf_frame_buffer
;
1482 if ((offset
% ptr_len
) != 0)
1484 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1485 buf
+= *bytes_read_ptr
;
1489 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1492 if ((encoding
& 0x07) == 0x00)
1493 encoding
|= encoding_for_size (ptr_len
);
1495 switch (encoding
& 0x0f)
1497 case DW_EH_PE_uleb128
:
1500 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1501 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1502 return base
+ value
;
1504 case DW_EH_PE_udata2
:
1505 *bytes_read_ptr
+= 2;
1506 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1507 case DW_EH_PE_udata4
:
1508 *bytes_read_ptr
+= 4;
1509 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1510 case DW_EH_PE_udata8
:
1511 *bytes_read_ptr
+= 8;
1512 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1513 case DW_EH_PE_sleb128
:
1516 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1517 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1518 return base
+ value
;
1520 case DW_EH_PE_sdata2
:
1521 *bytes_read_ptr
+= 2;
1522 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1523 case DW_EH_PE_sdata4
:
1524 *bytes_read_ptr
+= 4;
1525 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1526 case DW_EH_PE_sdata8
:
1527 *bytes_read_ptr
+= 8;
1528 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1530 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1535 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1536 That's why we use a simple linked list here. */
1538 static struct dwarf2_cie
*
1539 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1541 struct dwarf2_cie
*cie
= unit
->cie
;
1545 if (cie
->cie_pointer
== cie_pointer
)
1555 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1557 cie
->next
= unit
->cie
;
1561 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1562 inital location associated with it into *PC. */
1564 static struct dwarf2_fde
*
1565 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1567 struct objfile
*objfile
;
1569 ALL_OBJFILES (objfile
)
1571 struct dwarf2_fde
*fde
;
1574 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1578 gdb_assert (objfile
->section_offsets
);
1579 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1583 if (*pc
>= fde
->initial_location
+ offset
1584 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1586 *pc
= fde
->initial_location
+ offset
;
1598 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1600 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1601 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1604 #ifdef CC_HAS_LONG_LONG
1605 #define DW64_CIE_ID 0xffffffffffffffffULL
1607 #define DW64_CIE_ID ~0
1610 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1613 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1614 the next byte to be processed. */
1616 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1618 gdb_byte
*buf
, *end
;
1620 unsigned int bytes_read
;
1623 ULONGEST cie_pointer
;
1626 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1630 /* Are we still within the section? */
1631 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1637 /* Distinguish between 32 and 64-bit encoded frame info. */
1638 dwarf64_p
= (bytes_read
== 12);
1640 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1644 cie_id
= DW64_CIE_ID
;
1650 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1655 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1659 if (cie_pointer
== cie_id
)
1661 /* This is a CIE. */
1662 struct dwarf2_cie
*cie
;
1664 unsigned int cie_version
;
1666 /* Record the offset into the .debug_frame section of this CIE. */
1667 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1669 /* Check whether we've already read it. */
1670 if (find_cie (unit
, cie_pointer
))
1673 cie
= (struct dwarf2_cie
*)
1674 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1675 sizeof (struct dwarf2_cie
));
1676 cie
->initial_instructions
= NULL
;
1677 cie
->cie_pointer
= cie_pointer
;
1679 /* The encoding for FDE's in a normal .debug_frame section
1680 depends on the target address size. */
1681 cie
->encoding
= DW_EH_PE_absptr
;
1683 /* We'll determine the final value later, but we need to
1684 initialize it conservatively. */
1685 cie
->signal_frame
= 0;
1687 /* Check version number. */
1688 cie_version
= read_1_byte (unit
->abfd
, buf
);
1689 if (cie_version
!= 1 && cie_version
!= 3)
1691 cie
->version
= cie_version
;
1694 /* Interpret the interesting bits of the augmentation. */
1695 cie
->augmentation
= augmentation
= (char *) buf
;
1696 buf
+= (strlen (augmentation
) + 1);
1698 /* Ignore armcc augmentations. We only use them for quirks,
1699 and that doesn't happen until later. */
1700 if (strncmp (augmentation
, "armcc", 5) == 0)
1701 augmentation
+= strlen (augmentation
);
1703 /* The GCC 2.x "eh" augmentation has a pointer immediately
1704 following the augmentation string, so it must be handled
1706 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1709 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1713 cie
->code_alignment_factor
=
1714 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1717 cie
->data_alignment_factor
=
1718 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1721 if (cie_version
== 1)
1723 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1727 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1730 cie
->return_address_register
1731 = dwarf2_frame_eh_frame_regnum (current_gdbarch
,
1732 cie
->return_address_register
);
1736 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1737 if (cie
->saw_z_augmentation
)
1741 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1745 cie
->initial_instructions
= buf
+ length
;
1749 while (*augmentation
)
1751 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1752 if (*augmentation
== 'L')
1759 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1760 else if (*augmentation
== 'R')
1762 cie
->encoding
= *buf
++;
1766 /* "P" indicates a personality routine in the CIE augmentation. */
1767 else if (*augmentation
== 'P')
1769 /* Skip. Avoid indirection since we throw away the result. */
1770 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1771 read_encoded_value (unit
, encoding
, buf
, &bytes_read
);
1776 /* "S" indicates a signal frame, such that the return
1777 address must not be decremented to locate the call frame
1778 info for the previous frame; it might even be the first
1779 instruction of a function, so decrementing it would take
1780 us to a different function. */
1781 else if (*augmentation
== 'S')
1783 cie
->signal_frame
= 1;
1787 /* Otherwise we have an unknown augmentation. Assume that either
1788 there is no augmentation data, or we saw a 'z' prefix. */
1791 if (cie
->initial_instructions
)
1792 buf
= cie
->initial_instructions
;
1797 cie
->initial_instructions
= buf
;
1800 add_cie (unit
, cie
);
1804 /* This is a FDE. */
1805 struct dwarf2_fde
*fde
;
1807 /* In an .eh_frame section, the CIE pointer is the delta between the
1808 address within the FDE where the CIE pointer is stored and the
1809 address of the CIE. Convert it to an offset into the .eh_frame
1813 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1814 cie_pointer
-= (dwarf64_p
? 8 : 4);
1817 /* In either case, validate the result is still within the section. */
1818 if (cie_pointer
>= unit
->dwarf_frame_size
)
1821 fde
= (struct dwarf2_fde
*)
1822 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1823 sizeof (struct dwarf2_fde
));
1824 fde
->cie
= find_cie (unit
, cie_pointer
);
1825 if (fde
->cie
== NULL
)
1827 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1829 fde
->cie
= find_cie (unit
, cie_pointer
);
1832 gdb_assert (fde
->cie
!= NULL
);
1834 fde
->initial_location
=
1835 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1838 fde
->address_range
=
1839 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1842 /* A 'z' augmentation in the CIE implies the presence of an
1843 augmentation field in the FDE as well. The only thing known
1844 to be in here at present is the LSDA entry for EH. So we
1845 can skip the whole thing. */
1846 if (fde
->cie
->saw_z_augmentation
)
1850 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1851 buf
+= bytes_read
+ length
;
1856 fde
->instructions
= buf
;
1859 fde
->eh_frame_p
= eh_frame_p
;
1861 add_fde (unit
, fde
);
1867 /* Read a CIE or FDE in BUF and decode it. */
1869 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1871 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1874 ptrdiff_t start_offset
;
1878 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1882 /* We have corrupt input data of some form. */
1884 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1885 and mismatches wrt padding and alignment of debug sections. */
1886 /* Note that there is no requirement in the standard for any
1887 alignment at all in the frame unwind sections. Testing for
1888 alignment before trying to interpret data would be incorrect.
1890 However, GCC traditionally arranged for frame sections to be
1891 sized such that the FDE length and CIE fields happen to be
1892 aligned (in theory, for performance). This, unfortunately,
1893 was done with .align directives, which had the side effect of
1894 forcing the section to be aligned by the linker.
1896 This becomes a problem when you have some other producer that
1897 creates frame sections that are not as strictly aligned. That
1898 produces a hole in the frame info that gets filled by the
1901 The GCC behaviour is arguably a bug, but it's effectively now
1902 part of the ABI, so we're now stuck with it, at least at the
1903 object file level. A smart linker may decide, in the process
1904 of compressing duplicate CIE information, that it can rewrite
1905 the entire output section without this extra padding. */
1907 start_offset
= start
- unit
->dwarf_frame_buffer
;
1908 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1910 start
+= 4 - (start_offset
& 3);
1911 workaround
= ALIGN4
;
1914 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1916 start
+= 8 - (start_offset
& 7);
1917 workaround
= ALIGN8
;
1921 /* Nothing left to try. Arrange to return as if we've consumed
1922 the entire input section. Hopefully we'll get valid info from
1923 the other of .debug_frame/.eh_frame. */
1925 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1935 complaint (&symfile_complaints
,
1936 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1937 unit
->dwarf_frame_section
->owner
->filename
,
1938 unit
->dwarf_frame_section
->name
);
1942 complaint (&symfile_complaints
,
1943 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1944 unit
->dwarf_frame_section
->owner
->filename
,
1945 unit
->dwarf_frame_section
->name
);
1949 complaint (&symfile_complaints
,
1950 _("Corrupt data in %s:%s"),
1951 unit
->dwarf_frame_section
->owner
->filename
,
1952 unit
->dwarf_frame_section
->name
);
1960 /* FIXME: kettenis/20030504: This still needs to be integrated with
1961 dwarf2read.c in a better way. */
1963 /* Imported from dwarf2read.c. */
1964 extern asection
*dwarf_frame_section
;
1965 extern asection
*dwarf_eh_frame_section
;
1967 /* Imported from dwarf2read.c. */
1968 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1971 dwarf2_build_frame_info (struct objfile
*objfile
)
1973 struct comp_unit unit
;
1974 gdb_byte
*frame_ptr
;
1976 /* Build a minimal decoding of the DWARF2 compilation unit. */
1977 unit
.abfd
= objfile
->obfd
;
1978 unit
.objfile
= objfile
;
1982 /* First add the information from the .eh_frame section. That way,
1983 the FDEs from that section are searched last. */
1984 if (dwarf_eh_frame_section
)
1986 asection
*got
, *txt
;
1989 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1990 dwarf_eh_frame_section
);
1992 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1993 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1995 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1996 that is used for the i386/amd64 target, which currently is
1997 the only target in GCC that supports/uses the
1998 DW_EH_PE_datarel encoding. */
1999 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
2001 unit
.dbase
= got
->vma
;
2003 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2005 txt
= bfd_get_section_by_name (unit
.abfd
, ".text");
2007 unit
.tbase
= txt
->vma
;
2009 frame_ptr
= unit
.dwarf_frame_buffer
;
2010 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
2011 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
2014 if (dwarf_frame_section
)
2017 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
2018 dwarf_frame_section
);
2019 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
2020 unit
.dwarf_frame_section
= dwarf_frame_section
;
2022 frame_ptr
= unit
.dwarf_frame_buffer
;
2023 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
2024 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);
2028 /* Provide a prototype to silence -Wmissing-prototypes. */
2029 void _initialize_dwarf2_frame (void);
2032 _initialize_dwarf2_frame (void)
2034 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2035 dwarf2_frame_objfile_data
= register_objfile_data ();