1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
5 Contributed by Mark Kettenis.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
37 #include "gdb_assert.h"
38 #include "gdb_string.h"
40 #include "complaints.h"
41 #include "dwarf2-frame.h"
43 /* Call Frame Information (CFI). */
45 /* Common Information Entry (CIE). */
49 /* Offset into the .debug_frame section where this CIE was found.
50 Used to identify this CIE. */
53 /* Constant that is factored out of all advance location
55 ULONGEST code_alignment_factor
;
57 /* Constants that is factored out of all offset instructions. */
58 LONGEST data_alignment_factor
;
60 /* Return address column. */
61 ULONGEST return_address_register
;
63 /* Instruction sequence to initialize a register set. */
64 gdb_byte
*initial_instructions
;
67 /* Saved augmentation, in case it's needed later. */
70 /* Encoding of addresses. */
73 /* True if a 'z' augmentation existed. */
74 unsigned char saw_z_augmentation
;
76 /* True if an 'S' augmentation existed. */
77 unsigned char signal_frame
;
79 /* The version recorded in the CIE. */
80 unsigned char version
;
82 struct dwarf2_cie
*next
;
85 /* Frame Description Entry (FDE). */
89 /* CIE for this FDE. */
90 struct dwarf2_cie
*cie
;
92 /* First location associated with this FDE. */
93 CORE_ADDR initial_location
;
95 /* Number of bytes of program instructions described by this FDE. */
96 CORE_ADDR address_range
;
98 /* Instruction sequence. */
99 gdb_byte
*instructions
;
102 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
104 unsigned char eh_frame_p
;
106 struct dwarf2_fde
*next
;
109 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
);
111 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
115 /* Structure describing a frame state. */
117 struct dwarf2_frame_state
119 /* Each register save state can be described in terms of a CFA slot,
120 another register, or a location expression. */
121 struct dwarf2_frame_state_reg_info
123 struct dwarf2_frame_state_reg
*reg
;
126 /* Used to implement DW_CFA_remember_state. */
127 struct dwarf2_frame_state_reg_info
*prev
;
139 /* The PC described by the current frame state. */
142 /* Initial register set from the CIE.
143 Used to implement DW_CFA_restore. */
144 struct dwarf2_frame_state_reg_info initial
;
146 /* The information we care about from the CIE. */
149 ULONGEST retaddr_column
;
151 /* Flags for known producer quirks. */
153 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
154 and DW_CFA_def_cfa_offset takes a factored offset. */
155 int armcc_cfa_offsets_sf
;
157 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
158 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
159 int armcc_cfa_offsets_reversed
;
162 /* Store the length the expression for the CFA in the `cfa_reg' field,
163 which is unused in that case. */
164 #define cfa_exp_len cfa_reg
166 /* Assert that the register set RS is large enough to store gdbarch_num_regs
167 columns. If necessary, enlarge the register set. */
170 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
173 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
175 if (num_regs
<= rs
->num_regs
)
178 rs
->reg
= (struct dwarf2_frame_state_reg
*)
179 xrealloc (rs
->reg
, num_regs
* size
);
181 /* Initialize newly allocated registers. */
182 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
183 rs
->num_regs
= num_regs
;
186 /* Copy the register columns in register set RS into newly allocated
187 memory and return a pointer to this newly created copy. */
189 static struct dwarf2_frame_state_reg
*
190 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
192 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
193 struct dwarf2_frame_state_reg
*reg
;
195 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
196 memcpy (reg
, rs
->reg
, size
);
201 /* Release the memory allocated to register set RS. */
204 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
208 dwarf2_frame_state_free_regs (rs
->prev
);
215 /* Release the memory allocated to the frame state FS. */
218 dwarf2_frame_state_free (void *p
)
220 struct dwarf2_frame_state
*fs
= p
;
222 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
223 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
224 xfree (fs
->initial
.reg
);
225 xfree (fs
->regs
.reg
);
230 /* Helper functions for execute_stack_op. */
233 read_reg (void *baton
, int reg
)
235 struct frame_info
*next_frame
= (struct frame_info
*) baton
;
236 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
240 regnum
= gdbarch_dwarf2_reg_to_regnum (current_gdbarch
, reg
);
242 buf
= alloca (register_size (gdbarch
, regnum
));
243 frame_unwind_register (next_frame
, regnum
, buf
);
245 /* Convert the register to an integer. This returns a LONGEST
246 rather than a CORE_ADDR, but unpack_pointer does the same thing
247 under the covers, and this makes more sense for non-pointer
248 registers. Maybe read_reg and the associated interfaces should
249 deal with "struct value" instead of CORE_ADDR. */
250 return unpack_long (register_type (gdbarch
, regnum
), buf
);
254 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
256 read_memory (addr
, buf
, len
);
260 no_get_frame_base (void *baton
, gdb_byte
**start
, size_t *length
)
262 internal_error (__FILE__
, __LINE__
,
263 _("Support for DW_OP_fbreg is unimplemented"));
267 no_get_tls_address (void *baton
, CORE_ADDR offset
)
269 internal_error (__FILE__
, __LINE__
,
270 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
274 execute_stack_op (gdb_byte
*exp
, ULONGEST len
,
275 struct frame_info
*next_frame
, CORE_ADDR initial
)
277 struct dwarf_expr_context
*ctx
;
280 ctx
= new_dwarf_expr_context ();
281 ctx
->baton
= next_frame
;
282 ctx
->read_reg
= read_reg
;
283 ctx
->read_mem
= read_mem
;
284 ctx
->get_frame_base
= no_get_frame_base
;
285 ctx
->get_tls_address
= no_get_tls_address
;
287 dwarf_expr_push (ctx
, initial
);
288 dwarf_expr_eval (ctx
, exp
, len
);
289 result
= dwarf_expr_fetch (ctx
, 0);
292 result
= read_reg (next_frame
, result
);
294 free_dwarf_expr_context (ctx
);
301 execute_cfa_program (gdb_byte
*insn_ptr
, gdb_byte
*insn_end
,
302 struct frame_info
*next_frame
,
303 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
305 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
307 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
309 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
311 gdb_byte insn
= *insn_ptr
++;
315 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
316 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
317 else if ((insn
& 0xc0) == DW_CFA_offset
)
320 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
321 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
322 offset
= utmp
* fs
->data_align
;
323 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
324 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
325 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
327 else if ((insn
& 0xc0) == DW_CFA_restore
)
329 gdb_assert (fs
->initial
.reg
);
331 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
332 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
333 if (reg
< fs
->initial
.num_regs
)
334 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
336 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
338 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
339 complaint (&symfile_complaints
, _("\
340 incomplete CFI data; DW_CFA_restore unspecified\n\
341 register %s (#%d) at 0x%s"),
342 gdbarch_register_name
343 (current_gdbarch
, gdbarch_dwarf2_reg_to_regnum
344 (current_gdbarch
, reg
)),
345 gdbarch_dwarf2_reg_to_regnum (current_gdbarch
, reg
),
353 fs
->pc
= dwarf2_read_address (insn_ptr
, insn_end
, &bytes_read
);
354 insn_ptr
+= bytes_read
;
357 case DW_CFA_advance_loc1
:
358 utmp
= extract_unsigned_integer (insn_ptr
, 1);
359 fs
->pc
+= utmp
* fs
->code_align
;
362 case DW_CFA_advance_loc2
:
363 utmp
= extract_unsigned_integer (insn_ptr
, 2);
364 fs
->pc
+= utmp
* fs
->code_align
;
367 case DW_CFA_advance_loc4
:
368 utmp
= extract_unsigned_integer (insn_ptr
, 4);
369 fs
->pc
+= utmp
* fs
->code_align
;
373 case DW_CFA_offset_extended
:
374 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
375 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
376 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
377 offset
= utmp
* fs
->data_align
;
378 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
379 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
380 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
383 case DW_CFA_restore_extended
:
384 gdb_assert (fs
->initial
.reg
);
385 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
386 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
387 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
388 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
391 case DW_CFA_undefined
:
392 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
393 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
394 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
395 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
398 case DW_CFA_same_value
:
399 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
400 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
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
, ®
);
407 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
408 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
409 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
410 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
411 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
412 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
415 case DW_CFA_remember_state
:
417 struct dwarf2_frame_state_reg_info
*new_rs
;
419 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
421 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
422 fs
->regs
.prev
= new_rs
;
426 case DW_CFA_restore_state
:
428 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
432 complaint (&symfile_complaints
, _("\
433 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs
->pc
));
437 xfree (fs
->regs
.reg
);
445 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
446 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
448 if (fs
->armcc_cfa_offsets_sf
)
449 utmp
*= fs
->data_align
;
451 fs
->cfa_offset
= utmp
;
452 fs
->cfa_how
= CFA_REG_OFFSET
;
455 case DW_CFA_def_cfa_register
:
456 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
457 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
459 fs
->cfa_how
= CFA_REG_OFFSET
;
462 case DW_CFA_def_cfa_offset
:
463 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
465 if (fs
->armcc_cfa_offsets_sf
)
466 utmp
*= fs
->data_align
;
468 fs
->cfa_offset
= utmp
;
469 /* cfa_how deliberately not set. */
475 case DW_CFA_def_cfa_expression
:
476 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_exp_len
);
477 fs
->cfa_exp
= insn_ptr
;
478 fs
->cfa_how
= CFA_EXP
;
479 insn_ptr
+= fs
->cfa_exp_len
;
482 case DW_CFA_expression
:
483 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
484 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
485 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
486 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
487 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
488 fs
->regs
.reg
[reg
].exp_len
= utmp
;
489 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
493 case DW_CFA_offset_extended_sf
:
494 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
495 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
496 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
497 offset
*= fs
->data_align
;
498 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
499 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
500 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
503 case DW_CFA_val_offset
:
504 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
505 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
506 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
507 offset
= utmp
* fs
->data_align
;
508 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
509 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
512 case DW_CFA_val_offset_sf
:
513 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
514 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
515 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
516 offset
*= fs
->data_align
;
517 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
518 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
521 case DW_CFA_val_expression
:
522 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
523 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
524 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
525 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
526 fs
->regs
.reg
[reg
].exp_len
= utmp
;
527 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
531 case DW_CFA_def_cfa_sf
:
532 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
533 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
535 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
536 fs
->cfa_offset
= offset
* fs
->data_align
;
537 fs
->cfa_how
= CFA_REG_OFFSET
;
540 case DW_CFA_def_cfa_offset_sf
:
541 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
542 fs
->cfa_offset
= offset
* fs
->data_align
;
543 /* cfa_how deliberately not set. */
546 case DW_CFA_GNU_window_save
:
547 /* This is SPARC-specific code, and contains hard-coded
548 constants for the register numbering scheme used by
549 GCC. Rather than having a architecture-specific
550 operation that's only ever used by a single
551 architecture, we provide the implementation here.
552 Incidentally that's what GCC does too in its
555 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
556 int size
= register_size(gdbarch
, 0);
557 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
558 for (reg
= 8; reg
< 16; reg
++)
560 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
561 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
563 for (reg
= 16; reg
< 32; reg
++)
565 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
566 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
571 case DW_CFA_GNU_args_size
:
573 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
576 case DW_CFA_GNU_negative_offset_extended
:
577 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
578 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
579 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
580 offset
*= fs
->data_align
;
581 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
582 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
583 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
587 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
592 /* Don't allow remember/restore between CIE and FDE programs. */
593 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
594 fs
->regs
.prev
= NULL
;
598 /* Architecture-specific operations. */
600 /* Per-architecture data key. */
601 static struct gdbarch_data
*dwarf2_frame_data
;
603 struct dwarf2_frame_ops
605 /* Pre-initialize the register state REG for register REGNUM. */
606 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
607 struct frame_info
*);
609 /* Check whether the frame preceding NEXT_FRAME will be a signal
611 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
613 /* Convert .eh_frame register number to DWARF register number, or
614 adjust .debug_frame register number. */
615 int (*adjust_regnum
) (struct gdbarch
*, int, int);
618 /* Default architecture-specific register state initialization
622 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
623 struct dwarf2_frame_state_reg
*reg
,
624 struct frame_info
*next_frame
)
626 /* If we have a register that acts as a program counter, mark it as
627 a destination for the return address. If we have a register that
628 serves as the stack pointer, arrange for it to be filled with the
629 call frame address (CFA). The other registers are marked as
632 We copy the return address to the program counter, since many
633 parts in GDB assume that it is possible to get the return address
634 by unwinding the program counter register. However, on ISA's
635 with a dedicated return address register, the CFI usually only
636 contains information to unwind that return address register.
638 The reason we're treating the stack pointer special here is
639 because in many cases GCC doesn't emit CFI for the stack pointer
640 and implicitly assumes that it is equal to the CFA. This makes
641 some sense since the DWARF specification (version 3, draft 8,
644 "Typically, the CFA is defined to be the value of the stack
645 pointer at the call site in the previous frame (which may be
646 different from its value on entry to the current frame)."
648 However, this isn't true for all platforms supported by GCC
649 (e.g. IBM S/390 and zSeries). Those architectures should provide
650 their own architecture-specific initialization function. */
652 if (regnum
== gdbarch_pc_regnum (current_gdbarch
))
653 reg
->how
= DWARF2_FRAME_REG_RA
;
654 else if (regnum
== gdbarch_sp_regnum (current_gdbarch
))
655 reg
->how
= DWARF2_FRAME_REG_CFA
;
658 /* Return a default for the architecture-specific operations. */
661 dwarf2_frame_init (struct obstack
*obstack
)
663 struct dwarf2_frame_ops
*ops
;
665 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
666 ops
->init_reg
= dwarf2_frame_default_init_reg
;
670 /* Set the architecture-specific register state initialization
671 function for GDBARCH to INIT_REG. */
674 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
675 void (*init_reg
) (struct gdbarch
*, int,
676 struct dwarf2_frame_state_reg
*,
677 struct frame_info
*))
679 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
681 ops
->init_reg
= init_reg
;
684 /* Pre-initialize the register state REG for register REGNUM. */
687 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
688 struct dwarf2_frame_state_reg
*reg
,
689 struct frame_info
*next_frame
)
691 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
693 ops
->init_reg (gdbarch
, regnum
, reg
, next_frame
);
696 /* Set the architecture-specific signal trampoline recognition
697 function for GDBARCH to SIGNAL_FRAME_P. */
700 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
701 int (*signal_frame_p
) (struct gdbarch
*,
702 struct frame_info
*))
704 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
706 ops
->signal_frame_p
= signal_frame_p
;
709 /* Query the architecture-specific signal frame recognizer for
713 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
714 struct frame_info
*next_frame
)
716 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
718 if (ops
->signal_frame_p
== NULL
)
720 return ops
->signal_frame_p (gdbarch
, next_frame
);
723 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
727 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
728 int (*adjust_regnum
) (struct gdbarch
*,
731 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
733 ops
->adjust_regnum
= adjust_regnum
;
736 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
740 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
742 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
744 if (ops
->adjust_regnum
== NULL
)
746 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
750 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
751 struct dwarf2_fde
*fde
)
753 static const char *arm_idents
[] = {
754 "ARM C Compiler, ADS",
755 "Thumb C Compiler, ADS",
756 "ARM C++ Compiler, ADS",
757 "Thumb C++ Compiler, ADS",
758 "ARM/Thumb C/C++ Compiler, RVCT"
764 s
= find_pc_symtab (fs
->pc
);
765 if (s
== NULL
|| s
->producer
== NULL
)
768 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
769 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
771 if (fde
->cie
->version
== 1)
772 fs
->armcc_cfa_offsets_sf
= 1;
774 if (fde
->cie
->version
== 1)
775 fs
->armcc_cfa_offsets_reversed
= 1;
777 /* The reversed offset problem is present in some compilers
778 using DWARF3, but it was eventually fixed. Check the ARM
779 defined augmentations, which are in the format "armcc" followed
780 by a list of one-character options. The "+" option means
781 this problem is fixed (no quirk needed). If the armcc
782 augmentation is missing, the quirk is needed. */
783 if (fde
->cie
->version
== 3
784 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
785 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
786 fs
->armcc_cfa_offsets_reversed
= 1;
793 struct dwarf2_frame_cache
795 /* DWARF Call Frame Address. */
798 /* Set if the return address column was marked as undefined. */
799 int undefined_retaddr
;
801 /* Saved registers, indexed by GDB register number, not by DWARF
803 struct dwarf2_frame_state_reg
*reg
;
805 /* Return address register. */
806 struct dwarf2_frame_state_reg retaddr_reg
;
809 static struct dwarf2_frame_cache
*
810 dwarf2_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
812 struct cleanup
*old_chain
;
813 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
814 const int num_regs
= gdbarch_num_regs (current_gdbarch
)
815 + gdbarch_num_pseudo_regs (current_gdbarch
);
816 struct dwarf2_frame_cache
*cache
;
817 struct dwarf2_frame_state
*fs
;
818 struct dwarf2_fde
*fde
;
823 /* Allocate a new cache. */
824 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
825 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
827 /* Allocate and initialize the frame state. */
828 fs
= XMALLOC (struct dwarf2_frame_state
);
829 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
830 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
834 Note that if NEXT_FRAME is never supposed to return (i.e. a call
835 to abort), the compiler might optimize away the instruction at
836 NEXT_FRAME's return address. As a result the return address will
837 point at some random instruction, and the CFI for that
838 instruction is probably worthless to us. GCC's unwinder solves
839 this problem by substracting 1 from the return address to get an
840 address in the middle of a presumed call instruction (or the
841 instruction in the associated delay slot). This should only be
842 done for "normal" frames and not for resume-type frames (signal
843 handlers, sentinel frames, dummy frames). The function
844 frame_unwind_address_in_block does just this. It's not clear how
845 reliable the method is though; there is the potential for the
846 register state pre-call being different to that on return. */
847 fs
->pc
= frame_unwind_address_in_block (next_frame
, NORMAL_FRAME
);
849 /* Find the correct FDE. */
850 fde
= dwarf2_frame_find_fde (&fs
->pc
);
851 gdb_assert (fde
!= NULL
);
853 /* Extract any interesting information from the CIE. */
854 fs
->data_align
= fde
->cie
->data_alignment_factor
;
855 fs
->code_align
= fde
->cie
->code_alignment_factor
;
856 fs
->retaddr_column
= fde
->cie
->return_address_register
;
858 /* Check for "quirks" - known bugs in producers. */
859 dwarf2_frame_find_quirks (fs
, fde
);
861 /* First decode all the insns in the CIE. */
862 execute_cfa_program (fde
->cie
->initial_instructions
,
863 fde
->cie
->end
, next_frame
, fs
, fde
->eh_frame_p
);
865 /* Save the initialized register set. */
866 fs
->initial
= fs
->regs
;
867 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
869 /* Then decode the insns in the FDE up to our target PC. */
870 execute_cfa_program (fde
->instructions
, fde
->end
, next_frame
, fs
,
873 /* Caclulate the CFA. */
877 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
878 if (fs
->armcc_cfa_offsets_reversed
)
879 cache
->cfa
-= fs
->cfa_offset
;
881 cache
->cfa
+= fs
->cfa_offset
;
886 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
, next_frame
, 0);
890 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
893 /* Initialize the register state. */
897 for (regnum
= 0; regnum
< num_regs
; regnum
++)
898 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], next_frame
);
901 /* Go through the DWARF2 CFI generated table and save its register
902 location information in the cache. Note that we don't skip the
903 return address column; it's perfectly all right for it to
904 correspond to a real register. If it doesn't correspond to a
905 real register, or if we shouldn't treat it as such,
906 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
907 the range [0, gdbarch_num_regs). */
909 int column
; /* CFI speak for "register number". */
911 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
913 /* Use the GDB register number as the destination index. */
914 int regnum
= gdbarch_dwarf2_reg_to_regnum (current_gdbarch
, column
);
916 /* If there's no corresponding GDB register, ignore it. */
917 if (regnum
< 0 || regnum
>= num_regs
)
920 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
921 of all debug info registers. If it doesn't, complain (but
922 not too loudly). It turns out that GCC assumes that an
923 unspecified register implies "same value" when CFI (draft
924 7) specifies nothing at all. Such a register could equally
925 be interpreted as "undefined". Also note that this check
926 isn't sufficient; it only checks that all registers in the
927 range [0 .. max column] are specified, and won't detect
928 problems when a debug info register falls outside of the
929 table. We need a way of iterating through all the valid
930 DWARF2 register numbers. */
931 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
933 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
934 complaint (&symfile_complaints
, _("\
935 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
936 gdbarch_register_name (gdbarch
, regnum
),
940 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
944 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
945 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
949 for (regnum
= 0; regnum
< num_regs
; regnum
++)
951 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
952 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
954 struct dwarf2_frame_state_reg
*retaddr_reg
=
955 &fs
->regs
.reg
[fs
->retaddr_column
];
957 /* It seems rather bizarre to specify an "empty" column as
958 the return adress column. However, this is exactly
959 what GCC does on some targets. It turns out that GCC
960 assumes that the return address can be found in the
961 register corresponding to the return address column.
962 Incidentally, that's how we should treat a return
963 address column specifying "same value" too. */
964 if (fs
->retaddr_column
< fs
->regs
.num_regs
965 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
966 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
968 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
969 cache
->reg
[regnum
] = *retaddr_reg
;
971 cache
->retaddr_reg
= *retaddr_reg
;
975 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
977 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
978 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
982 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
983 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
990 if (fs
->retaddr_column
< fs
->regs
.num_regs
991 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
992 cache
->undefined_retaddr
= 1;
994 do_cleanups (old_chain
);
1001 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1002 struct frame_id
*this_id
)
1004 struct dwarf2_frame_cache
*cache
=
1005 dwarf2_frame_cache (next_frame
, this_cache
);
1007 if (cache
->undefined_retaddr
)
1010 (*this_id
) = frame_id_build (cache
->cfa
,
1011 frame_func_unwind (next_frame
, NORMAL_FRAME
));
1015 dwarf2_signal_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1016 struct frame_id
*this_id
)
1018 struct dwarf2_frame_cache
*cache
=
1019 dwarf2_frame_cache (next_frame
, this_cache
);
1021 if (cache
->undefined_retaddr
)
1024 (*this_id
) = frame_id_build (cache
->cfa
,
1025 frame_func_unwind (next_frame
, SIGTRAMP_FRAME
));
1029 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
1030 int regnum
, int *optimizedp
,
1031 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1032 int *realnump
, gdb_byte
*valuep
)
1034 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1035 struct dwarf2_frame_cache
*cache
=
1036 dwarf2_frame_cache (next_frame
, this_cache
);
1038 switch (cache
->reg
[regnum
].how
)
1040 case DWARF2_FRAME_REG_UNDEFINED
:
1041 /* If CFI explicitly specified that the value isn't defined,
1042 mark it as optimized away; the value isn't available. */
1049 /* In some cases, for example %eflags on the i386, we have
1050 to provide a sane value, even though this register wasn't
1051 saved. Assume we can get it from NEXT_FRAME. */
1052 frame_unwind_register (next_frame
, regnum
, valuep
);
1056 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1058 *lvalp
= lval_memory
;
1059 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1063 /* Read the value in from memory. */
1064 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1068 case DWARF2_FRAME_REG_SAVED_REG
:
1070 *lvalp
= lval_register
;
1072 *realnump
= gdbarch_dwarf2_reg_to_regnum
1073 (current_gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1075 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1078 case DWARF2_FRAME_REG_SAVED_EXP
:
1080 *lvalp
= lval_memory
;
1081 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1082 cache
->reg
[regnum
].exp_len
,
1083 next_frame
, cache
->cfa
);
1087 /* Read the value in from memory. */
1088 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1092 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1098 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1099 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1102 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1108 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1109 execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1110 cache
->reg
[regnum
].exp_len
,
1111 next_frame
, cache
->cfa
));
1114 case DWARF2_FRAME_REG_UNSPECIFIED
:
1115 /* GCC, in its infinite wisdom decided to not provide unwind
1116 information for registers that are "same value". Since
1117 DWARF2 (3 draft 7) doesn't define such behavior, said
1118 registers are actually undefined (which is different to CFI
1119 "undefined"). Code above issues a complaint about this.
1120 Here just fudge the books, assume GCC, and that the value is
1121 more inner on the stack. */
1123 *lvalp
= lval_register
;
1127 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1130 case DWARF2_FRAME_REG_SAME_VALUE
:
1132 *lvalp
= lval_register
;
1136 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1139 case DWARF2_FRAME_REG_CFA
:
1145 pack_long (valuep
, register_type (gdbarch
, regnum
), cache
->cfa
);
1148 case DWARF2_FRAME_REG_CFA_OFFSET
:
1154 pack_long (valuep
, register_type (gdbarch
, regnum
),
1155 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1158 case DWARF2_FRAME_REG_RA_OFFSET
:
1165 CORE_ADDR pc
= cache
->reg
[regnum
].loc
.offset
;
1167 regnum
= gdbarch_dwarf2_reg_to_regnum
1168 (current_gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1169 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
);
1170 pack_long (valuep
, register_type (gdbarch
, regnum
), pc
);
1175 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1179 static const struct frame_unwind dwarf2_frame_unwind
=
1182 dwarf2_frame_this_id
,
1183 dwarf2_frame_prev_register
1186 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1189 dwarf2_signal_frame_this_id
,
1190 dwarf2_frame_prev_register
1193 const struct frame_unwind
*
1194 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
1196 /* Grab an address that is guarenteed to reside somewhere within the
1197 function. frame_pc_unwind(), for a no-return next function, can
1198 end up returning something past the end of this function's body.
1199 If the frame we're sniffing for is a signal frame whose start
1200 address is placed on the stack by the OS, its FDE must
1201 extend one byte before its start address or we will miss it. */
1202 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1204 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1208 /* On some targets, signal trampolines may have unwind information.
1209 We need to recognize them so that we set the frame type
1212 if (fde
->cie
->signal_frame
1213 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame
),
1215 return &dwarf2_signal_frame_unwind
;
1217 return &dwarf2_frame_unwind
;
1221 /* There is no explicitly defined relationship between the CFA and the
1222 location of frame's local variables and arguments/parameters.
1223 Therefore, frame base methods on this page should probably only be
1224 used as a last resort, just to avoid printing total garbage as a
1225 response to the "info frame" command. */
1228 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1230 struct dwarf2_frame_cache
*cache
=
1231 dwarf2_frame_cache (next_frame
, this_cache
);
1236 static const struct frame_base dwarf2_frame_base
=
1238 &dwarf2_frame_unwind
,
1239 dwarf2_frame_base_address
,
1240 dwarf2_frame_base_address
,
1241 dwarf2_frame_base_address
1244 const struct frame_base
*
1245 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
1247 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1249 if (dwarf2_frame_find_fde (&block_addr
))
1250 return &dwarf2_frame_base
;
1255 /* A minimal decoding of DWARF2 compilation units. We only decode
1256 what's needed to get to the call frame information. */
1260 /* Keep the bfd convenient. */
1263 struct objfile
*objfile
;
1265 /* Linked list of CIEs for this object. */
1266 struct dwarf2_cie
*cie
;
1268 /* Pointer to the .debug_frame section loaded into memory. */
1269 gdb_byte
*dwarf_frame_buffer
;
1271 /* Length of the loaded .debug_frame section. */
1272 unsigned long dwarf_frame_size
;
1274 /* Pointer to the .debug_frame section. */
1275 asection
*dwarf_frame_section
;
1277 /* Base for DW_EH_PE_datarel encodings. */
1280 /* Base for DW_EH_PE_textrel encodings. */
1284 const struct objfile_data
*dwarf2_frame_objfile_data
;
1287 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1289 return bfd_get_8 (abfd
, buf
);
1293 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1295 return bfd_get_32 (abfd
, buf
);
1299 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1301 return bfd_get_64 (abfd
, buf
);
1305 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1308 unsigned int num_read
;
1318 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1321 result
|= ((byte
& 0x7f) << shift
);
1324 while (byte
& 0x80);
1326 *bytes_read_ptr
= num_read
;
1332 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1336 unsigned int num_read
;
1345 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1348 result
|= ((byte
& 0x7f) << shift
);
1351 while (byte
& 0x80);
1353 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1354 result
|= -(((LONGEST
)1) << shift
);
1356 *bytes_read_ptr
= num_read
;
1362 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1366 result
= bfd_get_32 (abfd
, buf
);
1367 if (result
== 0xffffffff)
1369 result
= bfd_get_64 (abfd
, buf
+ 4);
1370 *bytes_read_ptr
= 12;
1373 *bytes_read_ptr
= 4;
1379 /* Pointer encoding helper functions. */
1381 /* GCC supports exception handling based on DWARF2 CFI. However, for
1382 technical reasons, it encodes addresses in its FDE's in a different
1383 way. Several "pointer encodings" are supported. The encoding
1384 that's used for a particular FDE is determined by the 'R'
1385 augmentation in the associated CIE. The argument of this
1386 augmentation is a single byte.
1388 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1389 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1390 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1391 address should be interpreted (absolute, relative to the current
1392 position in the FDE, ...). Bit 7, indicates that the address
1393 should be dereferenced. */
1396 encoding_for_size (unsigned int size
)
1401 return DW_EH_PE_udata2
;
1403 return DW_EH_PE_udata4
;
1405 return DW_EH_PE_udata8
;
1407 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1412 size_of_encoded_value (gdb_byte encoding
)
1414 if (encoding
== DW_EH_PE_omit
)
1417 switch (encoding
& 0x07)
1419 case DW_EH_PE_absptr
:
1420 return TYPE_LENGTH (builtin_type_void_data_ptr
);
1421 case DW_EH_PE_udata2
:
1423 case DW_EH_PE_udata4
:
1425 case DW_EH_PE_udata8
:
1428 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1433 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1434 gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1436 int ptr_len
= size_of_encoded_value (DW_EH_PE_absptr
);
1440 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1442 if (encoding
& DW_EH_PE_indirect
)
1443 internal_error (__FILE__
, __LINE__
,
1444 _("Unsupported encoding: DW_EH_PE_indirect"));
1446 *bytes_read_ptr
= 0;
1448 switch (encoding
& 0x70)
1450 case DW_EH_PE_absptr
:
1453 case DW_EH_PE_pcrel
:
1454 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1455 base
+= (buf
- unit
->dwarf_frame_buffer
);
1457 case DW_EH_PE_datarel
:
1460 case DW_EH_PE_textrel
:
1463 case DW_EH_PE_funcrel
:
1464 /* FIXME: kettenis/20040501: For now just pretend
1465 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1466 reading the initial location of an FDE it should be treated
1467 as such, and currently that's the only place where this code
1471 case DW_EH_PE_aligned
:
1473 offset
= buf
- unit
->dwarf_frame_buffer
;
1474 if ((offset
% ptr_len
) != 0)
1476 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1477 buf
+= *bytes_read_ptr
;
1481 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1484 if ((encoding
& 0x07) == 0x00)
1486 encoding
|= encoding_for_size (ptr_len
);
1487 if (bfd_get_sign_extend_vma (unit
->abfd
))
1488 encoding
|= DW_EH_PE_signed
;
1491 switch (encoding
& 0x0f)
1493 case DW_EH_PE_uleb128
:
1496 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1497 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1498 return base
+ value
;
1500 case DW_EH_PE_udata2
:
1501 *bytes_read_ptr
+= 2;
1502 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1503 case DW_EH_PE_udata4
:
1504 *bytes_read_ptr
+= 4;
1505 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1506 case DW_EH_PE_udata8
:
1507 *bytes_read_ptr
+= 8;
1508 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1509 case DW_EH_PE_sleb128
:
1512 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1513 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1514 return base
+ value
;
1516 case DW_EH_PE_sdata2
:
1517 *bytes_read_ptr
+= 2;
1518 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1519 case DW_EH_PE_sdata4
:
1520 *bytes_read_ptr
+= 4;
1521 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1522 case DW_EH_PE_sdata8
:
1523 *bytes_read_ptr
+= 8;
1524 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1526 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1531 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1532 That's why we use a simple linked list here. */
1534 static struct dwarf2_cie
*
1535 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1537 struct dwarf2_cie
*cie
= unit
->cie
;
1541 if (cie
->cie_pointer
== cie_pointer
)
1551 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1553 cie
->next
= unit
->cie
;
1557 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1558 inital location associated with it into *PC. */
1560 static struct dwarf2_fde
*
1561 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1563 struct objfile
*objfile
;
1565 ALL_OBJFILES (objfile
)
1567 struct dwarf2_fde
*fde
;
1570 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1574 gdb_assert (objfile
->section_offsets
);
1575 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1579 if (*pc
>= fde
->initial_location
+ offset
1580 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1582 *pc
= fde
->initial_location
+ offset
;
1594 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1596 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1597 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1600 #ifdef CC_HAS_LONG_LONG
1601 #define DW64_CIE_ID 0xffffffffffffffffULL
1603 #define DW64_CIE_ID ~0
1606 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1609 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1610 the next byte to be processed. */
1612 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1614 gdb_byte
*buf
, *end
;
1616 unsigned int bytes_read
;
1619 ULONGEST cie_pointer
;
1622 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1626 /* Are we still within the section? */
1627 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1633 /* Distinguish between 32 and 64-bit encoded frame info. */
1634 dwarf64_p
= (bytes_read
== 12);
1636 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1640 cie_id
= DW64_CIE_ID
;
1646 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1651 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1655 if (cie_pointer
== cie_id
)
1657 /* This is a CIE. */
1658 struct dwarf2_cie
*cie
;
1660 unsigned int cie_version
;
1662 /* Record the offset into the .debug_frame section of this CIE. */
1663 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1665 /* Check whether we've already read it. */
1666 if (find_cie (unit
, cie_pointer
))
1669 cie
= (struct dwarf2_cie
*)
1670 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1671 sizeof (struct dwarf2_cie
));
1672 cie
->initial_instructions
= NULL
;
1673 cie
->cie_pointer
= cie_pointer
;
1675 /* The encoding for FDE's in a normal .debug_frame section
1676 depends on the target address size. */
1677 cie
->encoding
= DW_EH_PE_absptr
;
1679 /* We'll determine the final value later, but we need to
1680 initialize it conservatively. */
1681 cie
->signal_frame
= 0;
1683 /* Check version number. */
1684 cie_version
= read_1_byte (unit
->abfd
, buf
);
1685 if (cie_version
!= 1 && cie_version
!= 3)
1687 cie
->version
= cie_version
;
1690 /* Interpret the interesting bits of the augmentation. */
1691 cie
->augmentation
= augmentation
= (char *) buf
;
1692 buf
+= (strlen (augmentation
) + 1);
1694 /* Ignore armcc augmentations. We only use them for quirks,
1695 and that doesn't happen until later. */
1696 if (strncmp (augmentation
, "armcc", 5) == 0)
1697 augmentation
+= strlen (augmentation
);
1699 /* The GCC 2.x "eh" augmentation has a pointer immediately
1700 following the augmentation string, so it must be handled
1702 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1705 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1709 cie
->code_alignment_factor
=
1710 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1713 cie
->data_alignment_factor
=
1714 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1717 if (cie_version
== 1)
1719 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1723 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1725 cie
->return_address_register
1726 = dwarf2_frame_adjust_regnum (current_gdbarch
,
1727 cie
->return_address_register
,
1732 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1733 if (cie
->saw_z_augmentation
)
1737 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1741 cie
->initial_instructions
= buf
+ length
;
1745 while (*augmentation
)
1747 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1748 if (*augmentation
== 'L')
1755 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1756 else if (*augmentation
== 'R')
1758 cie
->encoding
= *buf
++;
1762 /* "P" indicates a personality routine in the CIE augmentation. */
1763 else if (*augmentation
== 'P')
1765 /* Skip. Avoid indirection since we throw away the result. */
1766 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1767 read_encoded_value (unit
, encoding
, buf
, &bytes_read
);
1772 /* "S" indicates a signal frame, such that the return
1773 address must not be decremented to locate the call frame
1774 info for the previous frame; it might even be the first
1775 instruction of a function, so decrementing it would take
1776 us to a different function. */
1777 else if (*augmentation
== 'S')
1779 cie
->signal_frame
= 1;
1783 /* Otherwise we have an unknown augmentation. Assume that either
1784 there is no augmentation data, or we saw a 'z' prefix. */
1787 if (cie
->initial_instructions
)
1788 buf
= cie
->initial_instructions
;
1793 cie
->initial_instructions
= buf
;
1796 add_cie (unit
, cie
);
1800 /* This is a FDE. */
1801 struct dwarf2_fde
*fde
;
1803 /* In an .eh_frame section, the CIE pointer is the delta between the
1804 address within the FDE where the CIE pointer is stored and the
1805 address of the CIE. Convert it to an offset into the .eh_frame
1809 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1810 cie_pointer
-= (dwarf64_p
? 8 : 4);
1813 /* In either case, validate the result is still within the section. */
1814 if (cie_pointer
>= unit
->dwarf_frame_size
)
1817 fde
= (struct dwarf2_fde
*)
1818 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1819 sizeof (struct dwarf2_fde
));
1820 fde
->cie
= find_cie (unit
, cie_pointer
);
1821 if (fde
->cie
== NULL
)
1823 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1825 fde
->cie
= find_cie (unit
, cie_pointer
);
1828 gdb_assert (fde
->cie
!= NULL
);
1830 fde
->initial_location
=
1831 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1834 fde
->address_range
=
1835 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1838 /* A 'z' augmentation in the CIE implies the presence of an
1839 augmentation field in the FDE as well. The only thing known
1840 to be in here at present is the LSDA entry for EH. So we
1841 can skip the whole thing. */
1842 if (fde
->cie
->saw_z_augmentation
)
1846 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1847 buf
+= bytes_read
+ length
;
1852 fde
->instructions
= buf
;
1855 fde
->eh_frame_p
= eh_frame_p
;
1857 add_fde (unit
, fde
);
1863 /* Read a CIE or FDE in BUF and decode it. */
1865 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1867 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1870 ptrdiff_t start_offset
;
1874 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1878 /* We have corrupt input data of some form. */
1880 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1881 and mismatches wrt padding and alignment of debug sections. */
1882 /* Note that there is no requirement in the standard for any
1883 alignment at all in the frame unwind sections. Testing for
1884 alignment before trying to interpret data would be incorrect.
1886 However, GCC traditionally arranged for frame sections to be
1887 sized such that the FDE length and CIE fields happen to be
1888 aligned (in theory, for performance). This, unfortunately,
1889 was done with .align directives, which had the side effect of
1890 forcing the section to be aligned by the linker.
1892 This becomes a problem when you have some other producer that
1893 creates frame sections that are not as strictly aligned. That
1894 produces a hole in the frame info that gets filled by the
1897 The GCC behaviour is arguably a bug, but it's effectively now
1898 part of the ABI, so we're now stuck with it, at least at the
1899 object file level. A smart linker may decide, in the process
1900 of compressing duplicate CIE information, that it can rewrite
1901 the entire output section without this extra padding. */
1903 start_offset
= start
- unit
->dwarf_frame_buffer
;
1904 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1906 start
+= 4 - (start_offset
& 3);
1907 workaround
= ALIGN4
;
1910 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1912 start
+= 8 - (start_offset
& 7);
1913 workaround
= ALIGN8
;
1917 /* Nothing left to try. Arrange to return as if we've consumed
1918 the entire input section. Hopefully we'll get valid info from
1919 the other of .debug_frame/.eh_frame. */
1921 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1931 complaint (&symfile_complaints
,
1932 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1933 unit
->dwarf_frame_section
->owner
->filename
,
1934 unit
->dwarf_frame_section
->name
);
1938 complaint (&symfile_complaints
,
1939 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1940 unit
->dwarf_frame_section
->owner
->filename
,
1941 unit
->dwarf_frame_section
->name
);
1945 complaint (&symfile_complaints
,
1946 _("Corrupt data in %s:%s"),
1947 unit
->dwarf_frame_section
->owner
->filename
,
1948 unit
->dwarf_frame_section
->name
);
1956 /* FIXME: kettenis/20030504: This still needs to be integrated with
1957 dwarf2read.c in a better way. */
1959 /* Imported from dwarf2read.c. */
1960 extern asection
*dwarf_frame_section
;
1961 extern asection
*dwarf_eh_frame_section
;
1963 /* Imported from dwarf2read.c. */
1964 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1967 dwarf2_build_frame_info (struct objfile
*objfile
)
1969 struct comp_unit unit
;
1970 gdb_byte
*frame_ptr
;
1972 /* Build a minimal decoding of the DWARF2 compilation unit. */
1973 unit
.abfd
= objfile
->obfd
;
1974 unit
.objfile
= objfile
;
1978 /* First add the information from the .eh_frame section. That way,
1979 the FDEs from that section are searched last. */
1980 if (dwarf_eh_frame_section
)
1982 asection
*got
, *txt
;
1985 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1986 dwarf_eh_frame_section
);
1988 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1989 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1991 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1992 that is used for the i386/amd64 target, which currently is
1993 the only target in GCC that supports/uses the
1994 DW_EH_PE_datarel encoding. */
1995 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
1997 unit
.dbase
= got
->vma
;
1999 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2001 txt
= bfd_get_section_by_name (unit
.abfd
, ".text");
2003 unit
.tbase
= txt
->vma
;
2005 frame_ptr
= unit
.dwarf_frame_buffer
;
2006 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
2007 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
2010 if (dwarf_frame_section
)
2013 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
2014 dwarf_frame_section
);
2015 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
2016 unit
.dwarf_frame_section
= dwarf_frame_section
;
2018 frame_ptr
= unit
.dwarf_frame_buffer
;
2019 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
2020 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);
2024 /* Provide a prototype to silence -Wmissing-prototypes. */
2025 void _initialize_dwarf2_frame (void);
2028 _initialize_dwarf2_frame (void)
2030 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2031 dwarf2_frame_objfile_data
= register_objfile_data ();