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
);
583 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
588 /* Don't allow remember/restore between CIE and FDE programs. */
589 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
590 fs
->regs
.prev
= NULL
;
594 /* Architecture-specific operations. */
596 /* Per-architecture data key. */
597 static struct gdbarch_data
*dwarf2_frame_data
;
599 struct dwarf2_frame_ops
601 /* Pre-initialize the register state REG for register REGNUM. */
602 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
603 struct frame_info
*);
605 /* Check whether the frame preceding NEXT_FRAME will be a signal
607 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
609 /* Convert .eh_frame register number to DWARF register number. */
610 int (*eh_frame_regnum
) (struct gdbarch
*, int);
613 /* Default architecture-specific register state initialization
617 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
618 struct dwarf2_frame_state_reg
*reg
,
619 struct frame_info
*next_frame
)
621 /* If we have a register that acts as a program counter, mark it as
622 a destination for the return address. If we have a register that
623 serves as the stack pointer, arrange for it to be filled with the
624 call frame address (CFA). The other registers are marked as
627 We copy the return address to the program counter, since many
628 parts in GDB assume that it is possible to get the return address
629 by unwinding the program counter register. However, on ISA's
630 with a dedicated return address register, the CFI usually only
631 contains information to unwind that return address register.
633 The reason we're treating the stack pointer special here is
634 because in many cases GCC doesn't emit CFI for the stack pointer
635 and implicitly assumes that it is equal to the CFA. This makes
636 some sense since the DWARF specification (version 3, draft 8,
639 "Typically, the CFA is defined to be the value of the stack
640 pointer at the call site in the previous frame (which may be
641 different from its value on entry to the current frame)."
643 However, this isn't true for all platforms supported by GCC
644 (e.g. IBM S/390 and zSeries). Those architectures should provide
645 their own architecture-specific initialization function. */
647 if (regnum
== PC_REGNUM
)
648 reg
->how
= DWARF2_FRAME_REG_RA
;
649 else if (regnum
== SP_REGNUM
)
650 reg
->how
= DWARF2_FRAME_REG_CFA
;
653 /* Return a default for the architecture-specific operations. */
656 dwarf2_frame_init (struct obstack
*obstack
)
658 struct dwarf2_frame_ops
*ops
;
660 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
661 ops
->init_reg
= dwarf2_frame_default_init_reg
;
665 /* Set the architecture-specific register state initialization
666 function for GDBARCH to INIT_REG. */
669 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
670 void (*init_reg
) (struct gdbarch
*, int,
671 struct dwarf2_frame_state_reg
*,
672 struct frame_info
*))
674 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
676 ops
->init_reg
= init_reg
;
679 /* Pre-initialize the register state REG for register REGNUM. */
682 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
683 struct dwarf2_frame_state_reg
*reg
,
684 struct frame_info
*next_frame
)
686 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
688 ops
->init_reg (gdbarch
, regnum
, reg
, next_frame
);
691 /* Set the architecture-specific signal trampoline recognition
692 function for GDBARCH to SIGNAL_FRAME_P. */
695 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
696 int (*signal_frame_p
) (struct gdbarch
*,
697 struct frame_info
*))
699 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
701 ops
->signal_frame_p
= signal_frame_p
;
704 /* Query the architecture-specific signal frame recognizer for
708 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
709 struct frame_info
*next_frame
)
711 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
713 if (ops
->signal_frame_p
== NULL
)
715 return ops
->signal_frame_p (gdbarch
, next_frame
);
718 /* Set the architecture-specific mapping of .eh_frame register numbers to
719 DWARF register numbers. */
722 dwarf2_frame_set_eh_frame_regnum (struct gdbarch
*gdbarch
,
723 int (*eh_frame_regnum
) (struct gdbarch
*,
726 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
728 ops
->eh_frame_regnum
= eh_frame_regnum
;
731 /* Translate a .eh_frame register to DWARF register. */
734 dwarf2_frame_eh_frame_regnum (struct gdbarch
*gdbarch
, int regnum
)
736 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
738 if (ops
->eh_frame_regnum
== NULL
)
740 return ops
->eh_frame_regnum (gdbarch
, regnum
);
744 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
745 struct dwarf2_fde
*fde
)
747 static const char *arm_idents
[] = {
748 "ARM C Compiler, ADS",
749 "Thumb C Compiler, ADS",
750 "ARM C++ Compiler, ADS",
751 "Thumb C++ Compiler, ADS",
752 "ARM/Thumb C/C++ Compiler, RVCT"
758 s
= find_pc_symtab (fs
->pc
);
759 if (s
== NULL
|| s
->producer
== NULL
)
762 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
763 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
765 if (fde
->cie
->version
== 1)
766 fs
->armcc_cfa_offsets_sf
= 1;
768 if (fde
->cie
->version
== 1)
769 fs
->armcc_cfa_offsets_reversed
= 1;
771 /* The reversed offset problem is present in some compilers
772 using DWARF3, but it was eventually fixed. Check the ARM
773 defined augmentations, which are in the format "armcc" followed
774 by a list of one-character options. The "+" option means
775 this problem is fixed (no quirk needed). If the armcc
776 augmentation is missing, the quirk is needed. */
777 if (fde
->cie
->version
== 3
778 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
779 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
780 fs
->armcc_cfa_offsets_reversed
= 1;
787 struct dwarf2_frame_cache
789 /* DWARF Call Frame Address. */
792 /* Set if the return address column was marked as undefined. */
793 int undefined_retaddr
;
795 /* Saved registers, indexed by GDB register number, not by DWARF
797 struct dwarf2_frame_state_reg
*reg
;
799 /* Return address register. */
800 struct dwarf2_frame_state_reg retaddr_reg
;
803 static struct dwarf2_frame_cache
*
804 dwarf2_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
806 struct cleanup
*old_chain
;
807 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
808 const int num_regs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
809 struct dwarf2_frame_cache
*cache
;
810 struct dwarf2_frame_state
*fs
;
811 struct dwarf2_fde
*fde
;
816 /* Allocate a new cache. */
817 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
818 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
820 /* Allocate and initialize the frame state. */
821 fs
= XMALLOC (struct dwarf2_frame_state
);
822 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
823 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
827 Note that if NEXT_FRAME is never supposed to return (i.e. a call
828 to abort), the compiler might optimize away the instruction at
829 NEXT_FRAME's return address. As a result the return address will
830 point at some random instruction, and the CFI for that
831 instruction is probably worthless to us. GCC's unwinder solves
832 this problem by substracting 1 from the return address to get an
833 address in the middle of a presumed call instruction (or the
834 instruction in the associated delay slot). This should only be
835 done for "normal" frames and not for resume-type frames (signal
836 handlers, sentinel frames, dummy frames). The function
837 frame_unwind_address_in_block does just this. It's not clear how
838 reliable the method is though; there is the potential for the
839 register state pre-call being different to that on return. */
840 fs
->pc
= frame_unwind_address_in_block (next_frame
);
842 /* Find the correct FDE. */
843 fde
= dwarf2_frame_find_fde (&fs
->pc
);
844 gdb_assert (fde
!= NULL
);
846 /* Extract any interesting information from the CIE. */
847 fs
->data_align
= fde
->cie
->data_alignment_factor
;
848 fs
->code_align
= fde
->cie
->code_alignment_factor
;
849 fs
->retaddr_column
= fde
->cie
->return_address_register
;
851 /* Check for "quirks" - known bugs in producers. */
852 dwarf2_frame_find_quirks (fs
, fde
);
854 /* First decode all the insns in the CIE. */
855 execute_cfa_program (fde
->cie
->initial_instructions
,
856 fde
->cie
->end
, next_frame
, fs
, fde
->eh_frame_p
);
858 /* Save the initialized register set. */
859 fs
->initial
= fs
->regs
;
860 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
862 /* Then decode the insns in the FDE up to our target PC. */
863 execute_cfa_program (fde
->instructions
, fde
->end
, next_frame
, fs
,
866 /* Caclulate the CFA. */
870 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
871 if (fs
->armcc_cfa_offsets_reversed
)
872 cache
->cfa
-= fs
->cfa_offset
;
874 cache
->cfa
+= fs
->cfa_offset
;
879 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
, next_frame
, 0);
883 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
886 /* Initialize the register state. */
890 for (regnum
= 0; regnum
< num_regs
; regnum
++)
891 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], next_frame
);
894 /* Go through the DWARF2 CFI generated table and save its register
895 location information in the cache. Note that we don't skip the
896 return address column; it's perfectly all right for it to
897 correspond to a real register. If it doesn't correspond to a
898 real register, or if we shouldn't treat it as such,
899 DWARF2_REG_TO_REGNUM should be defined to return a number outside
900 the range [0, NUM_REGS). */
902 int column
; /* CFI speak for "register number". */
904 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
906 /* Use the GDB register number as the destination index. */
907 int regnum
= DWARF2_REG_TO_REGNUM (column
);
909 /* If there's no corresponding GDB register, ignore it. */
910 if (regnum
< 0 || regnum
>= num_regs
)
913 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
914 of all debug info registers. If it doesn't, complain (but
915 not too loudly). It turns out that GCC assumes that an
916 unspecified register implies "same value" when CFI (draft
917 7) specifies nothing at all. Such a register could equally
918 be interpreted as "undefined". Also note that this check
919 isn't sufficient; it only checks that all registers in the
920 range [0 .. max column] are specified, and won't detect
921 problems when a debug info register falls outside of the
922 table. We need a way of iterating through all the valid
923 DWARF2 register numbers. */
924 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
926 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
927 complaint (&symfile_complaints
, _("\
928 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
929 gdbarch_register_name (gdbarch
, regnum
),
933 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
937 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
938 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
942 for (regnum
= 0; regnum
< num_regs
; regnum
++)
944 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
945 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
947 struct dwarf2_frame_state_reg
*retaddr_reg
=
948 &fs
->regs
.reg
[fs
->retaddr_column
];
950 /* It seems rather bizarre to specify an "empty" column as
951 the return adress column. However, this is exactly
952 what GCC does on some targets. It turns out that GCC
953 assumes that the return address can be found in the
954 register corresponding to the return address column.
955 Incidentally, that's how we should treat a return
956 address column specifying "same value" too. */
957 if (fs
->retaddr_column
< fs
->regs
.num_regs
958 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
959 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
961 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
962 cache
->reg
[regnum
] = *retaddr_reg
;
964 cache
->retaddr_reg
= *retaddr_reg
;
968 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
970 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
971 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
975 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
976 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
983 if (fs
->retaddr_column
< fs
->regs
.num_regs
984 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
985 cache
->undefined_retaddr
= 1;
987 do_cleanups (old_chain
);
994 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
995 struct frame_id
*this_id
)
997 struct dwarf2_frame_cache
*cache
=
998 dwarf2_frame_cache (next_frame
, this_cache
);
1000 if (cache
->undefined_retaddr
)
1003 (*this_id
) = frame_id_build (cache
->cfa
, frame_func_unwind (next_frame
));
1007 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
1008 int regnum
, int *optimizedp
,
1009 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1010 int *realnump
, gdb_byte
*valuep
)
1012 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1013 struct dwarf2_frame_cache
*cache
=
1014 dwarf2_frame_cache (next_frame
, this_cache
);
1016 switch (cache
->reg
[regnum
].how
)
1018 case DWARF2_FRAME_REG_UNDEFINED
:
1019 /* If CFI explicitly specified that the value isn't defined,
1020 mark it as optimized away; the value isn't available. */
1027 /* In some cases, for example %eflags on the i386, we have
1028 to provide a sane value, even though this register wasn't
1029 saved. Assume we can get it from NEXT_FRAME. */
1030 frame_unwind_register (next_frame
, regnum
, valuep
);
1034 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1036 *lvalp
= lval_memory
;
1037 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1041 /* Read the value in from memory. */
1042 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1046 case DWARF2_FRAME_REG_SAVED_REG
:
1048 *lvalp
= lval_register
;
1050 *realnump
= DWARF2_REG_TO_REGNUM (cache
->reg
[regnum
].loc
.reg
);
1052 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1055 case DWARF2_FRAME_REG_SAVED_EXP
:
1057 *lvalp
= lval_memory
;
1058 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1059 cache
->reg
[regnum
].exp_len
,
1060 next_frame
, cache
->cfa
);
1064 /* Read the value in from memory. */
1065 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1069 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1075 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1076 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1079 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1085 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1086 execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1087 cache
->reg
[regnum
].exp_len
,
1088 next_frame
, cache
->cfa
));
1091 case DWARF2_FRAME_REG_UNSPECIFIED
:
1092 /* GCC, in its infinite wisdom decided to not provide unwind
1093 information for registers that are "same value". Since
1094 DWARF2 (3 draft 7) doesn't define such behavior, said
1095 registers are actually undefined (which is different to CFI
1096 "undefined"). Code above issues a complaint about this.
1097 Here just fudge the books, assume GCC, and that the value is
1098 more inner on the stack. */
1100 *lvalp
= lval_register
;
1104 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1107 case DWARF2_FRAME_REG_SAME_VALUE
:
1109 *lvalp
= lval_register
;
1113 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1116 case DWARF2_FRAME_REG_CFA
:
1123 /* Store the value. */
1124 store_typed_address (valuep
, builtin_type_void_data_ptr
, cache
->cfa
);
1128 case DWARF2_FRAME_REG_CFA_OFFSET
:
1135 /* Store the value. */
1136 store_typed_address (valuep
, builtin_type_void_data_ptr
,
1137 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1141 case DWARF2_FRAME_REG_RA_OFFSET
:
1148 CORE_ADDR pc
= cache
->reg
[regnum
].loc
.offset
;
1150 regnum
= DWARF2_REG_TO_REGNUM (cache
->retaddr_reg
.loc
.reg
);
1151 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
);
1152 store_typed_address (valuep
, builtin_type_void_func_ptr
, pc
);
1157 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1161 static const struct frame_unwind dwarf2_frame_unwind
=
1164 dwarf2_frame_this_id
,
1165 dwarf2_frame_prev_register
1168 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1171 dwarf2_frame_this_id
,
1172 dwarf2_frame_prev_register
1175 const struct frame_unwind
*
1176 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
1178 /* Grab an address that is guarenteed to reside somewhere within the
1179 function. frame_pc_unwind(), for a no-return next function, can
1180 end up returning something past the end of this function's body. */
1181 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
);
1182 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1186 /* On some targets, signal trampolines may have unwind information.
1187 We need to recognize them so that we set the frame type
1190 if (fde
->cie
->signal_frame
1191 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame
),
1193 return &dwarf2_signal_frame_unwind
;
1195 return &dwarf2_frame_unwind
;
1199 /* There is no explicitly defined relationship between the CFA and the
1200 location of frame's local variables and arguments/parameters.
1201 Therefore, frame base methods on this page should probably only be
1202 used as a last resort, just to avoid printing total garbage as a
1203 response to the "info frame" command. */
1206 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1208 struct dwarf2_frame_cache
*cache
=
1209 dwarf2_frame_cache (next_frame
, this_cache
);
1214 static const struct frame_base dwarf2_frame_base
=
1216 &dwarf2_frame_unwind
,
1217 dwarf2_frame_base_address
,
1218 dwarf2_frame_base_address
,
1219 dwarf2_frame_base_address
1222 const struct frame_base
*
1223 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
1225 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1226 if (dwarf2_frame_find_fde (&pc
))
1227 return &dwarf2_frame_base
;
1232 /* A minimal decoding of DWARF2 compilation units. We only decode
1233 what's needed to get to the call frame information. */
1237 /* Keep the bfd convenient. */
1240 struct objfile
*objfile
;
1242 /* Linked list of CIEs for this object. */
1243 struct dwarf2_cie
*cie
;
1245 /* Pointer to the .debug_frame section loaded into memory. */
1246 gdb_byte
*dwarf_frame_buffer
;
1248 /* Length of the loaded .debug_frame section. */
1249 unsigned long dwarf_frame_size
;
1251 /* Pointer to the .debug_frame section. */
1252 asection
*dwarf_frame_section
;
1254 /* Base for DW_EH_PE_datarel encodings. */
1257 /* Base for DW_EH_PE_textrel encodings. */
1261 const struct objfile_data
*dwarf2_frame_objfile_data
;
1264 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1266 return bfd_get_8 (abfd
, buf
);
1270 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1272 return bfd_get_32 (abfd
, buf
);
1276 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1278 return bfd_get_64 (abfd
, buf
);
1282 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1285 unsigned int num_read
;
1295 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1298 result
|= ((byte
& 0x7f) << shift
);
1301 while (byte
& 0x80);
1303 *bytes_read_ptr
= num_read
;
1309 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1313 unsigned int num_read
;
1322 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1325 result
|= ((byte
& 0x7f) << shift
);
1328 while (byte
& 0x80);
1330 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1331 result
|= -(((LONGEST
)1) << shift
);
1333 *bytes_read_ptr
= num_read
;
1339 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1343 result
= bfd_get_32 (abfd
, buf
);
1344 if (result
== 0xffffffff)
1346 result
= bfd_get_64 (abfd
, buf
+ 4);
1347 *bytes_read_ptr
= 12;
1350 *bytes_read_ptr
= 4;
1356 /* Pointer encoding helper functions. */
1358 /* GCC supports exception handling based on DWARF2 CFI. However, for
1359 technical reasons, it encodes addresses in its FDE's in a different
1360 way. Several "pointer encodings" are supported. The encoding
1361 that's used for a particular FDE is determined by the 'R'
1362 augmentation in the associated CIE. The argument of this
1363 augmentation is a single byte.
1365 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1366 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1367 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1368 address should be interpreted (absolute, relative to the current
1369 position in the FDE, ...). Bit 7, indicates that the address
1370 should be dereferenced. */
1373 encoding_for_size (unsigned int size
)
1378 return DW_EH_PE_udata2
;
1380 return DW_EH_PE_udata4
;
1382 return DW_EH_PE_udata8
;
1384 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1389 size_of_encoded_value (gdb_byte encoding
)
1391 if (encoding
== DW_EH_PE_omit
)
1394 switch (encoding
& 0x07)
1396 case DW_EH_PE_absptr
:
1397 return TYPE_LENGTH (builtin_type_void_data_ptr
);
1398 case DW_EH_PE_udata2
:
1400 case DW_EH_PE_udata4
:
1402 case DW_EH_PE_udata8
:
1405 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1410 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1411 gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1413 int ptr_len
= size_of_encoded_value (DW_EH_PE_absptr
);
1417 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1419 if (encoding
& DW_EH_PE_indirect
)
1420 internal_error (__FILE__
, __LINE__
,
1421 _("Unsupported encoding: DW_EH_PE_indirect"));
1423 *bytes_read_ptr
= 0;
1425 switch (encoding
& 0x70)
1427 case DW_EH_PE_absptr
:
1430 case DW_EH_PE_pcrel
:
1431 base
= bfd_get_section_vma (unit
->bfd
, unit
->dwarf_frame_section
);
1432 base
+= (buf
- unit
->dwarf_frame_buffer
);
1434 case DW_EH_PE_datarel
:
1437 case DW_EH_PE_textrel
:
1440 case DW_EH_PE_funcrel
:
1441 /* FIXME: kettenis/20040501: For now just pretend
1442 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1443 reading the initial location of an FDE it should be treated
1444 as such, and currently that's the only place where this code
1448 case DW_EH_PE_aligned
:
1450 offset
= buf
- unit
->dwarf_frame_buffer
;
1451 if ((offset
% ptr_len
) != 0)
1453 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1454 buf
+= *bytes_read_ptr
;
1458 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1461 if ((encoding
& 0x07) == 0x00)
1462 encoding
|= encoding_for_size (ptr_len
);
1464 switch (encoding
& 0x0f)
1466 case DW_EH_PE_uleb128
:
1469 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1470 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1471 return base
+ value
;
1473 case DW_EH_PE_udata2
:
1474 *bytes_read_ptr
+= 2;
1475 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1476 case DW_EH_PE_udata4
:
1477 *bytes_read_ptr
+= 4;
1478 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1479 case DW_EH_PE_udata8
:
1480 *bytes_read_ptr
+= 8;
1481 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1482 case DW_EH_PE_sleb128
:
1485 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1486 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1487 return base
+ value
;
1489 case DW_EH_PE_sdata2
:
1490 *bytes_read_ptr
+= 2;
1491 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1492 case DW_EH_PE_sdata4
:
1493 *bytes_read_ptr
+= 4;
1494 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1495 case DW_EH_PE_sdata8
:
1496 *bytes_read_ptr
+= 8;
1497 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1499 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1504 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1505 That's why we use a simple linked list here. */
1507 static struct dwarf2_cie
*
1508 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1510 struct dwarf2_cie
*cie
= unit
->cie
;
1514 if (cie
->cie_pointer
== cie_pointer
)
1524 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1526 cie
->next
= unit
->cie
;
1530 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1531 inital location associated with it into *PC. */
1533 static struct dwarf2_fde
*
1534 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1536 struct objfile
*objfile
;
1538 ALL_OBJFILES (objfile
)
1540 struct dwarf2_fde
*fde
;
1543 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1547 gdb_assert (objfile
->section_offsets
);
1548 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1552 if (*pc
>= fde
->initial_location
+ offset
1553 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1555 *pc
= fde
->initial_location
+ offset
;
1567 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1569 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1570 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1573 #ifdef CC_HAS_LONG_LONG
1574 #define DW64_CIE_ID 0xffffffffffffffffULL
1576 #define DW64_CIE_ID ~0
1579 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1582 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1583 the next byte to be processed. */
1585 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1587 gdb_byte
*buf
, *end
;
1589 unsigned int bytes_read
;
1592 ULONGEST cie_pointer
;
1595 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1599 /* Are we still within the section? */
1600 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1606 /* Distinguish between 32 and 64-bit encoded frame info. */
1607 dwarf64_p
= (bytes_read
== 12);
1609 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1613 cie_id
= DW64_CIE_ID
;
1619 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1624 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1628 if (cie_pointer
== cie_id
)
1630 /* This is a CIE. */
1631 struct dwarf2_cie
*cie
;
1633 unsigned int cie_version
;
1635 /* Record the offset into the .debug_frame section of this CIE. */
1636 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1638 /* Check whether we've already read it. */
1639 if (find_cie (unit
, cie_pointer
))
1642 cie
= (struct dwarf2_cie
*)
1643 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1644 sizeof (struct dwarf2_cie
));
1645 cie
->initial_instructions
= NULL
;
1646 cie
->cie_pointer
= cie_pointer
;
1648 /* The encoding for FDE's in a normal .debug_frame section
1649 depends on the target address size. */
1650 cie
->encoding
= DW_EH_PE_absptr
;
1652 /* We'll determine the final value later, but we need to
1653 initialize it conservatively. */
1654 cie
->signal_frame
= 0;
1656 /* Check version number. */
1657 cie_version
= read_1_byte (unit
->abfd
, buf
);
1658 if (cie_version
!= 1 && cie_version
!= 3)
1660 cie
->version
= cie_version
;
1663 /* Interpret the interesting bits of the augmentation. */
1664 cie
->augmentation
= augmentation
= (char *) buf
;
1665 buf
+= (strlen (augmentation
) + 1);
1667 /* Ignore armcc augmentations. We only use them for quirks,
1668 and that doesn't happen until later. */
1669 if (strncmp (augmentation
, "armcc", 5) == 0)
1670 augmentation
+= strlen (augmentation
);
1672 /* The GCC 2.x "eh" augmentation has a pointer immediately
1673 following the augmentation string, so it must be handled
1675 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1678 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1682 cie
->code_alignment_factor
=
1683 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1686 cie
->data_alignment_factor
=
1687 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1690 if (cie_version
== 1)
1692 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1696 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1699 cie
->return_address_register
1700 = dwarf2_frame_eh_frame_regnum (current_gdbarch
,
1701 cie
->return_address_register
);
1705 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1706 if (cie
->saw_z_augmentation
)
1710 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1714 cie
->initial_instructions
= buf
+ length
;
1718 while (*augmentation
)
1720 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1721 if (*augmentation
== 'L')
1728 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1729 else if (*augmentation
== 'R')
1731 cie
->encoding
= *buf
++;
1735 /* "P" indicates a personality routine in the CIE augmentation. */
1736 else if (*augmentation
== 'P')
1738 /* Skip. Avoid indirection since we throw away the result. */
1739 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1740 read_encoded_value (unit
, encoding
, buf
, &bytes_read
);
1745 /* "S" indicates a signal frame, such that the return
1746 address must not be decremented to locate the call frame
1747 info for the previous frame; it might even be the first
1748 instruction of a function, so decrementing it would take
1749 us to a different function. */
1750 else if (*augmentation
== 'S')
1752 cie
->signal_frame
= 1;
1756 /* Otherwise we have an unknown augmentation. Assume that either
1757 there is no augmentation data, or we saw a 'z' prefix. */
1760 if (cie
->initial_instructions
)
1761 buf
= cie
->initial_instructions
;
1766 cie
->initial_instructions
= buf
;
1769 add_cie (unit
, cie
);
1773 /* This is a FDE. */
1774 struct dwarf2_fde
*fde
;
1776 /* In an .eh_frame section, the CIE pointer is the delta between the
1777 address within the FDE where the CIE pointer is stored and the
1778 address of the CIE. Convert it to an offset into the .eh_frame
1782 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1783 cie_pointer
-= (dwarf64_p
? 8 : 4);
1786 /* In either case, validate the result is still within the section. */
1787 if (cie_pointer
>= unit
->dwarf_frame_size
)
1790 fde
= (struct dwarf2_fde
*)
1791 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1792 sizeof (struct dwarf2_fde
));
1793 fde
->cie
= find_cie (unit
, cie_pointer
);
1794 if (fde
->cie
== NULL
)
1796 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1798 fde
->cie
= find_cie (unit
, cie_pointer
);
1801 gdb_assert (fde
->cie
!= NULL
);
1803 fde
->initial_location
=
1804 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1807 fde
->address_range
=
1808 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1811 /* A 'z' augmentation in the CIE implies the presence of an
1812 augmentation field in the FDE as well. The only thing known
1813 to be in here at present is the LSDA entry for EH. So we
1814 can skip the whole thing. */
1815 if (fde
->cie
->saw_z_augmentation
)
1819 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1820 buf
+= bytes_read
+ length
;
1825 fde
->instructions
= buf
;
1828 fde
->eh_frame_p
= eh_frame_p
;
1830 add_fde (unit
, fde
);
1836 /* Read a CIE or FDE in BUF and decode it. */
1838 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1840 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1843 ptrdiff_t start_offset
;
1847 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1851 /* We have corrupt input data of some form. */
1853 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1854 and mismatches wrt padding and alignment of debug sections. */
1855 /* Note that there is no requirement in the standard for any
1856 alignment at all in the frame unwind sections. Testing for
1857 alignment before trying to interpret data would be incorrect.
1859 However, GCC traditionally arranged for frame sections to be
1860 sized such that the FDE length and CIE fields happen to be
1861 aligned (in theory, for performance). This, unfortunately,
1862 was done with .align directives, which had the side effect of
1863 forcing the section to be aligned by the linker.
1865 This becomes a problem when you have some other producer that
1866 creates frame sections that are not as strictly aligned. That
1867 produces a hole in the frame info that gets filled by the
1870 The GCC behaviour is arguably a bug, but it's effectively now
1871 part of the ABI, so we're now stuck with it, at least at the
1872 object file level. A smart linker may decide, in the process
1873 of compressing duplicate CIE information, that it can rewrite
1874 the entire output section without this extra padding. */
1876 start_offset
= start
- unit
->dwarf_frame_buffer
;
1877 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1879 start
+= 4 - (start_offset
& 3);
1880 workaround
= ALIGN4
;
1883 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1885 start
+= 8 - (start_offset
& 7);
1886 workaround
= ALIGN8
;
1890 /* Nothing left to try. Arrange to return as if we've consumed
1891 the entire input section. Hopefully we'll get valid info from
1892 the other of .debug_frame/.eh_frame. */
1894 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1904 complaint (&symfile_complaints
,
1905 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1906 unit
->dwarf_frame_section
->owner
->filename
,
1907 unit
->dwarf_frame_section
->name
);
1911 complaint (&symfile_complaints
,
1912 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1913 unit
->dwarf_frame_section
->owner
->filename
,
1914 unit
->dwarf_frame_section
->name
);
1918 complaint (&symfile_complaints
,
1919 _("Corrupt data in %s:%s"),
1920 unit
->dwarf_frame_section
->owner
->filename
,
1921 unit
->dwarf_frame_section
->name
);
1929 /* FIXME: kettenis/20030504: This still needs to be integrated with
1930 dwarf2read.c in a better way. */
1932 /* Imported from dwarf2read.c. */
1933 extern asection
*dwarf_frame_section
;
1934 extern asection
*dwarf_eh_frame_section
;
1936 /* Imported from dwarf2read.c. */
1937 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1940 dwarf2_build_frame_info (struct objfile
*objfile
)
1942 struct comp_unit unit
;
1943 gdb_byte
*frame_ptr
;
1945 /* Build a minimal decoding of the DWARF2 compilation unit. */
1946 unit
.abfd
= objfile
->obfd
;
1947 unit
.objfile
= objfile
;
1951 /* First add the information from the .eh_frame section. That way,
1952 the FDEs from that section are searched last. */
1953 if (dwarf_eh_frame_section
)
1955 asection
*got
, *txt
;
1958 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1959 dwarf_eh_frame_section
);
1961 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1962 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1964 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1965 that is used for the i386/amd64 target, which currently is
1966 the only target in GCC that supports/uses the
1967 DW_EH_PE_datarel encoding. */
1968 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
1970 unit
.dbase
= got
->vma
;
1972 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1974 txt
= bfd_get_section_by_name (unit
.abfd
, ".text");
1976 unit
.tbase
= txt
->vma
;
1978 frame_ptr
= unit
.dwarf_frame_buffer
;
1979 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1980 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
1983 if (dwarf_frame_section
)
1986 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1987 dwarf_frame_section
);
1988 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
1989 unit
.dwarf_frame_section
= dwarf_frame_section
;
1991 frame_ptr
= unit
.dwarf_frame_buffer
;
1992 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1993 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);
1997 /* Provide a prototype to silence -Wmissing-prototypes. */
1998 void _initialize_dwarf2_frame (void);
2001 _initialize_dwarf2_frame (void)
2003 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2004 dwarf2_frame_objfile_data
= register_objfile_data ();