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 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "dwarf2expr.h"
24 #include "elf/dwarf2.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
35 #include "gdb_assert.h"
36 #include "gdb_string.h"
38 #include "complaints.h"
39 #include "dwarf2-frame.h"
41 /* Call Frame Information (CFI). */
43 /* Common Information Entry (CIE). */
47 /* Offset into the .debug_frame section where this CIE was found.
48 Used to identify this CIE. */
51 /* Constant that is factored out of all advance location
53 ULONGEST code_alignment_factor
;
55 /* Constants that is factored out of all offset instructions. */
56 LONGEST data_alignment_factor
;
58 /* Return address column. */
59 ULONGEST return_address_register
;
61 /* Instruction sequence to initialize a register set. */
62 gdb_byte
*initial_instructions
;
65 /* Saved augmentation, in case it's needed later. */
68 /* Encoding of addresses. */
71 /* True if a 'z' augmentation existed. */
72 unsigned char saw_z_augmentation
;
74 /* True if an 'S' augmentation existed. */
75 unsigned char signal_frame
;
77 /* The version recorded in the CIE. */
78 unsigned char version
;
80 struct dwarf2_cie
*next
;
83 /* Frame Description Entry (FDE). */
87 /* CIE for this FDE. */
88 struct dwarf2_cie
*cie
;
90 /* First location associated with this FDE. */
91 CORE_ADDR initial_location
;
93 /* Number of bytes of program instructions described by this FDE. */
94 CORE_ADDR address_range
;
96 /* Instruction sequence. */
97 gdb_byte
*instructions
;
100 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
102 unsigned char eh_frame_p
;
104 struct dwarf2_fde
*next
;
107 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
);
109 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
113 /* Structure describing a frame state. */
115 struct dwarf2_frame_state
117 /* Each register save state can be described in terms of a CFA slot,
118 another register, or a location expression. */
119 struct dwarf2_frame_state_reg_info
121 struct dwarf2_frame_state_reg
*reg
;
124 /* Used to implement DW_CFA_remember_state. */
125 struct dwarf2_frame_state_reg_info
*prev
;
137 /* The PC described by the current frame state. */
140 /* Initial register set from the CIE.
141 Used to implement DW_CFA_restore. */
142 struct dwarf2_frame_state_reg_info initial
;
144 /* The information we care about from the CIE. */
147 ULONGEST retaddr_column
;
149 /* Flags for known producer quirks. */
151 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
152 and DW_CFA_def_cfa_offset takes a factored offset. */
153 int armcc_cfa_offsets_sf
;
155 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
156 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
157 int armcc_cfa_offsets_reversed
;
160 /* Store the length the expression for the CFA in the `cfa_reg' field,
161 which is unused in that case. */
162 #define cfa_exp_len cfa_reg
164 /* Assert that the register set RS is large enough to store gdbarch_num_regs
165 columns. If necessary, enlarge the register set. */
168 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
171 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
173 if (num_regs
<= rs
->num_regs
)
176 rs
->reg
= (struct dwarf2_frame_state_reg
*)
177 xrealloc (rs
->reg
, num_regs
* size
);
179 /* Initialize newly allocated registers. */
180 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
181 rs
->num_regs
= num_regs
;
184 /* Copy the register columns in register set RS into newly allocated
185 memory and return a pointer to this newly created copy. */
187 static struct dwarf2_frame_state_reg
*
188 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
190 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
191 struct dwarf2_frame_state_reg
*reg
;
193 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
194 memcpy (reg
, rs
->reg
, size
);
199 /* Release the memory allocated to register set RS. */
202 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
206 dwarf2_frame_state_free_regs (rs
->prev
);
213 /* Release the memory allocated to the frame state FS. */
216 dwarf2_frame_state_free (void *p
)
218 struct dwarf2_frame_state
*fs
= p
;
220 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
221 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
222 xfree (fs
->initial
.reg
);
223 xfree (fs
->regs
.reg
);
228 /* Helper functions for execute_stack_op. */
231 read_reg (void *baton
, int reg
)
233 struct frame_info
*next_frame
= (struct frame_info
*) baton
;
234 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
238 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
240 buf
= alloca (register_size (gdbarch
, regnum
));
241 frame_unwind_register (next_frame
, regnum
, buf
);
243 /* Convert the register to an integer. This returns a LONGEST
244 rather than a CORE_ADDR, but unpack_pointer does the same thing
245 under the covers, and this makes more sense for non-pointer
246 registers. Maybe read_reg and the associated interfaces should
247 deal with "struct value" instead of CORE_ADDR. */
248 return unpack_long (register_type (gdbarch
, regnum
), buf
);
252 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
254 read_memory (addr
, buf
, len
);
258 no_get_frame_base (void *baton
, gdb_byte
**start
, size_t *length
)
260 internal_error (__FILE__
, __LINE__
,
261 _("Support for DW_OP_fbreg is unimplemented"));
265 no_get_tls_address (void *baton
, CORE_ADDR offset
)
267 internal_error (__FILE__
, __LINE__
,
268 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
272 execute_stack_op (gdb_byte
*exp
, ULONGEST len
,
273 struct frame_info
*next_frame
, CORE_ADDR initial
)
275 struct dwarf_expr_context
*ctx
;
278 ctx
= new_dwarf_expr_context ();
279 ctx
->baton
= next_frame
;
280 ctx
->read_reg
= read_reg
;
281 ctx
->read_mem
= read_mem
;
282 ctx
->get_frame_base
= no_get_frame_base
;
283 ctx
->get_tls_address
= no_get_tls_address
;
285 dwarf_expr_push (ctx
, initial
);
286 dwarf_expr_eval (ctx
, exp
, len
);
287 result
= dwarf_expr_fetch (ctx
, 0);
290 result
= read_reg (next_frame
, result
);
292 free_dwarf_expr_context (ctx
);
299 execute_cfa_program (gdb_byte
*insn_ptr
, gdb_byte
*insn_end
,
300 struct frame_info
*next_frame
,
301 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
303 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
305 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
307 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
309 gdb_byte insn
= *insn_ptr
++;
313 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
314 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
315 else if ((insn
& 0xc0) == DW_CFA_offset
)
318 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
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
);
329 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
330 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
331 if (reg
< fs
->initial
.num_regs
)
332 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
334 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
336 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
337 complaint (&symfile_complaints
, _("\
338 incomplete CFI data; DW_CFA_restore unspecified\n\
339 register %s (#%d) at 0x%s"),
340 gdbarch_register_name
341 (gdbarch
, gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
)),
342 gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
),
350 fs
->pc
= dwarf2_read_address (insn_ptr
, insn_end
, &bytes_read
);
351 insn_ptr
+= bytes_read
;
354 case DW_CFA_advance_loc1
:
355 utmp
= extract_unsigned_integer (insn_ptr
, 1);
356 fs
->pc
+= utmp
* fs
->code_align
;
359 case DW_CFA_advance_loc2
:
360 utmp
= extract_unsigned_integer (insn_ptr
, 2);
361 fs
->pc
+= utmp
* fs
->code_align
;
364 case DW_CFA_advance_loc4
:
365 utmp
= extract_unsigned_integer (insn_ptr
, 4);
366 fs
->pc
+= utmp
* fs
->code_align
;
370 case DW_CFA_offset_extended
:
371 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
372 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
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
, ®
);
383 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
384 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
385 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
388 case DW_CFA_undefined
:
389 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
390 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
391 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
392 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
395 case DW_CFA_same_value
:
396 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
397 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
398 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
399 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
402 case DW_CFA_register
:
403 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
404 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
405 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
406 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
407 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
408 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
409 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
412 case DW_CFA_remember_state
:
414 struct dwarf2_frame_state_reg_info
*new_rs
;
416 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
418 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
419 fs
->regs
.prev
= new_rs
;
423 case DW_CFA_restore_state
:
425 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
429 complaint (&symfile_complaints
, _("\
430 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs
->pc
));
434 xfree (fs
->regs
.reg
);
442 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
443 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
445 if (fs
->armcc_cfa_offsets_sf
)
446 utmp
*= fs
->data_align
;
448 fs
->cfa_offset
= utmp
;
449 fs
->cfa_how
= CFA_REG_OFFSET
;
452 case DW_CFA_def_cfa_register
:
453 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
454 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
456 fs
->cfa_how
= CFA_REG_OFFSET
;
459 case DW_CFA_def_cfa_offset
:
460 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
462 if (fs
->armcc_cfa_offsets_sf
)
463 utmp
*= fs
->data_align
;
465 fs
->cfa_offset
= utmp
;
466 /* cfa_how deliberately not set. */
472 case DW_CFA_def_cfa_expression
:
473 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_exp_len
);
474 fs
->cfa_exp
= insn_ptr
;
475 fs
->cfa_how
= CFA_EXP
;
476 insn_ptr
+= fs
->cfa_exp_len
;
479 case DW_CFA_expression
:
480 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
481 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
482 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
483 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
484 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
485 fs
->regs
.reg
[reg
].exp_len
= utmp
;
486 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
490 case DW_CFA_offset_extended_sf
:
491 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
492 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
493 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
494 offset
*= fs
->data_align
;
495 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
496 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
497 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
500 case DW_CFA_val_offset
:
501 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
502 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
503 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
504 offset
= utmp
* fs
->data_align
;
505 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
506 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
509 case DW_CFA_val_offset_sf
:
510 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
511 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
512 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
513 offset
*= fs
->data_align
;
514 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
515 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
518 case DW_CFA_val_expression
:
519 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
520 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
521 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
522 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
523 fs
->regs
.reg
[reg
].exp_len
= utmp
;
524 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
528 case DW_CFA_def_cfa_sf
:
529 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
530 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
532 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
533 fs
->cfa_offset
= offset
* fs
->data_align
;
534 fs
->cfa_how
= CFA_REG_OFFSET
;
537 case DW_CFA_def_cfa_offset_sf
:
538 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
539 fs
->cfa_offset
= offset
* fs
->data_align
;
540 /* cfa_how deliberately not set. */
543 case DW_CFA_GNU_window_save
:
544 /* This is SPARC-specific code, and contains hard-coded
545 constants for the register numbering scheme used by
546 GCC. Rather than having a architecture-specific
547 operation that's only ever used by a single
548 architecture, we provide the implementation here.
549 Incidentally that's what GCC does too in its
552 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
553 int size
= register_size(gdbarch
, 0);
554 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
555 for (reg
= 8; reg
< 16; reg
++)
557 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
558 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
560 for (reg
= 16; reg
< 32; reg
++)
562 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
563 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
568 case DW_CFA_GNU_args_size
:
570 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
573 case DW_CFA_GNU_negative_offset_extended
:
574 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
575 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
576 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
577 offset
*= fs
->data_align
;
578 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
579 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
580 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
584 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
589 /* Don't allow remember/restore between CIE and FDE programs. */
590 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
591 fs
->regs
.prev
= NULL
;
595 /* Architecture-specific operations. */
597 /* Per-architecture data key. */
598 static struct gdbarch_data
*dwarf2_frame_data
;
600 struct dwarf2_frame_ops
602 /* Pre-initialize the register state REG for register REGNUM. */
603 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
604 struct frame_info
*);
606 /* Check whether the frame preceding NEXT_FRAME will be a signal
608 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
610 /* Convert .eh_frame register number to DWARF register number, or
611 adjust .debug_frame register number. */
612 int (*adjust_regnum
) (struct gdbarch
*, int, int);
615 /* Default architecture-specific register state initialization
619 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
620 struct dwarf2_frame_state_reg
*reg
,
621 struct frame_info
*next_frame
)
623 /* If we have a register that acts as a program counter, mark it as
624 a destination for the return address. If we have a register that
625 serves as the stack pointer, arrange for it to be filled with the
626 call frame address (CFA). The other registers are marked as
629 We copy the return address to the program counter, since many
630 parts in GDB assume that it is possible to get the return address
631 by unwinding the program counter register. However, on ISA's
632 with a dedicated return address register, the CFI usually only
633 contains information to unwind that return address register.
635 The reason we're treating the stack pointer special here is
636 because in many cases GCC doesn't emit CFI for the stack pointer
637 and implicitly assumes that it is equal to the CFA. This makes
638 some sense since the DWARF specification (version 3, draft 8,
641 "Typically, the CFA is defined to be the value of the stack
642 pointer at the call site in the previous frame (which may be
643 different from its value on entry to the current frame)."
645 However, this isn't true for all platforms supported by GCC
646 (e.g. IBM S/390 and zSeries). Those architectures should provide
647 their own architecture-specific initialization function. */
649 if (regnum
== gdbarch_pc_regnum (gdbarch
))
650 reg
->how
= DWARF2_FRAME_REG_RA
;
651 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
652 reg
->how
= DWARF2_FRAME_REG_CFA
;
655 /* Return a default for the architecture-specific operations. */
658 dwarf2_frame_init (struct obstack
*obstack
)
660 struct dwarf2_frame_ops
*ops
;
662 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
663 ops
->init_reg
= dwarf2_frame_default_init_reg
;
667 /* Set the architecture-specific register state initialization
668 function for GDBARCH to INIT_REG. */
671 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
672 void (*init_reg
) (struct gdbarch
*, int,
673 struct dwarf2_frame_state_reg
*,
674 struct frame_info
*))
676 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
678 ops
->init_reg
= init_reg
;
681 /* Pre-initialize the register state REG for register REGNUM. */
684 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
685 struct dwarf2_frame_state_reg
*reg
,
686 struct frame_info
*next_frame
)
688 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
690 ops
->init_reg (gdbarch
, regnum
, reg
, next_frame
);
693 /* Set the architecture-specific signal trampoline recognition
694 function for GDBARCH to SIGNAL_FRAME_P. */
697 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
698 int (*signal_frame_p
) (struct gdbarch
*,
699 struct frame_info
*))
701 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
703 ops
->signal_frame_p
= signal_frame_p
;
706 /* Query the architecture-specific signal frame recognizer for
710 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
711 struct frame_info
*next_frame
)
713 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
715 if (ops
->signal_frame_p
== NULL
)
717 return ops
->signal_frame_p (gdbarch
, next_frame
);
720 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
724 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
725 int (*adjust_regnum
) (struct gdbarch
*,
728 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
730 ops
->adjust_regnum
= adjust_regnum
;
733 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
737 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
739 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
741 if (ops
->adjust_regnum
== NULL
)
743 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
747 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
748 struct dwarf2_fde
*fde
)
750 static const char *arm_idents
[] = {
751 "ARM C Compiler, ADS",
752 "Thumb C Compiler, ADS",
753 "ARM C++ Compiler, ADS",
754 "Thumb C++ Compiler, ADS",
755 "ARM/Thumb C/C++ Compiler, RVCT"
761 s
= find_pc_symtab (fs
->pc
);
762 if (s
== NULL
|| s
->producer
== NULL
)
765 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
766 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
768 if (fde
->cie
->version
== 1)
769 fs
->armcc_cfa_offsets_sf
= 1;
771 if (fde
->cie
->version
== 1)
772 fs
->armcc_cfa_offsets_reversed
= 1;
774 /* The reversed offset problem is present in some compilers
775 using DWARF3, but it was eventually fixed. Check the ARM
776 defined augmentations, which are in the format "armcc" followed
777 by a list of one-character options. The "+" option means
778 this problem is fixed (no quirk needed). If the armcc
779 augmentation is missing, the quirk is needed. */
780 if (fde
->cie
->version
== 3
781 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
782 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
783 fs
->armcc_cfa_offsets_reversed
= 1;
790 struct dwarf2_frame_cache
792 /* DWARF Call Frame Address. */
795 /* Set if the return address column was marked as undefined. */
796 int undefined_retaddr
;
798 /* Saved registers, indexed by GDB register number, not by DWARF
800 struct dwarf2_frame_state_reg
*reg
;
802 /* Return address register. */
803 struct dwarf2_frame_state_reg retaddr_reg
;
806 static struct dwarf2_frame_cache
*
807 dwarf2_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
809 struct cleanup
*old_chain
;
810 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
811 const int num_regs
= gdbarch_num_regs (gdbarch
)
812 + gdbarch_num_pseudo_regs (gdbarch
);
813 struct dwarf2_frame_cache
*cache
;
814 struct dwarf2_frame_state
*fs
;
815 struct dwarf2_fde
*fde
;
820 /* Allocate a new cache. */
821 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
822 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
824 /* Allocate and initialize the frame state. */
825 fs
= XMALLOC (struct dwarf2_frame_state
);
826 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
827 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
831 Note that if NEXT_FRAME is never supposed to return (i.e. a call
832 to abort), the compiler might optimize away the instruction at
833 NEXT_FRAME's return address. As a result the return address will
834 point at some random instruction, and the CFI for that
835 instruction is probably worthless to us. GCC's unwinder solves
836 this problem by substracting 1 from the return address to get an
837 address in the middle of a presumed call instruction (or the
838 instruction in the associated delay slot). This should only be
839 done for "normal" frames and not for resume-type frames (signal
840 handlers, sentinel frames, dummy frames). The function
841 frame_unwind_address_in_block does just this. It's not clear how
842 reliable the method is though; there is the potential for the
843 register state pre-call being different to that on return. */
844 fs
->pc
= frame_unwind_address_in_block (next_frame
, NORMAL_FRAME
);
846 /* Find the correct FDE. */
847 fde
= dwarf2_frame_find_fde (&fs
->pc
);
848 gdb_assert (fde
!= NULL
);
850 /* Extract any interesting information from the CIE. */
851 fs
->data_align
= fde
->cie
->data_alignment_factor
;
852 fs
->code_align
= fde
->cie
->code_alignment_factor
;
853 fs
->retaddr_column
= fde
->cie
->return_address_register
;
855 /* Check for "quirks" - known bugs in producers. */
856 dwarf2_frame_find_quirks (fs
, fde
);
858 /* First decode all the insns in the CIE. */
859 execute_cfa_program (fde
->cie
->initial_instructions
,
860 fde
->cie
->end
, next_frame
, fs
, fde
->eh_frame_p
);
862 /* Save the initialized register set. */
863 fs
->initial
= fs
->regs
;
864 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
866 /* Then decode the insns in the FDE up to our target PC. */
867 execute_cfa_program (fde
->instructions
, fde
->end
, next_frame
, fs
,
870 /* Caclulate the CFA. */
874 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
875 if (fs
->armcc_cfa_offsets_reversed
)
876 cache
->cfa
-= fs
->cfa_offset
;
878 cache
->cfa
+= fs
->cfa_offset
;
883 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
, next_frame
, 0);
887 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
890 /* Initialize the register state. */
894 for (regnum
= 0; regnum
< num_regs
; regnum
++)
895 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], next_frame
);
898 /* Go through the DWARF2 CFI generated table and save its register
899 location information in the cache. Note that we don't skip the
900 return address column; it's perfectly all right for it to
901 correspond to a real register. If it doesn't correspond to a
902 real register, or if we shouldn't treat it as such,
903 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
904 the range [0, gdbarch_num_regs). */
906 int column
; /* CFI speak for "register number". */
908 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
910 /* Use the GDB register number as the destination index. */
911 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
913 /* If there's no corresponding GDB register, ignore it. */
914 if (regnum
< 0 || regnum
>= num_regs
)
917 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
918 of all debug info registers. If it doesn't, complain (but
919 not too loudly). It turns out that GCC assumes that an
920 unspecified register implies "same value" when CFI (draft
921 7) specifies nothing at all. Such a register could equally
922 be interpreted as "undefined". Also note that this check
923 isn't sufficient; it only checks that all registers in the
924 range [0 .. max column] are specified, and won't detect
925 problems when a debug info register falls outside of the
926 table. We need a way of iterating through all the valid
927 DWARF2 register numbers. */
928 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
930 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
931 complaint (&symfile_complaints
, _("\
932 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
933 gdbarch_register_name (gdbarch
, regnum
),
937 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
941 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
942 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
946 for (regnum
= 0; regnum
< num_regs
; regnum
++)
948 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
949 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
951 struct dwarf2_frame_state_reg
*retaddr_reg
=
952 &fs
->regs
.reg
[fs
->retaddr_column
];
954 /* It seems rather bizarre to specify an "empty" column as
955 the return adress column. However, this is exactly
956 what GCC does on some targets. It turns out that GCC
957 assumes that the return address can be found in the
958 register corresponding to the return address column.
959 Incidentally, that's how we should treat a return
960 address column specifying "same value" too. */
961 if (fs
->retaddr_column
< fs
->regs
.num_regs
962 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
963 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
965 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
966 cache
->reg
[regnum
] = *retaddr_reg
;
968 cache
->retaddr_reg
= *retaddr_reg
;
972 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
974 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
975 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
979 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
980 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
987 if (fs
->retaddr_column
< fs
->regs
.num_regs
988 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
989 cache
->undefined_retaddr
= 1;
991 do_cleanups (old_chain
);
998 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
999 struct frame_id
*this_id
)
1001 struct dwarf2_frame_cache
*cache
=
1002 dwarf2_frame_cache (next_frame
, this_cache
);
1004 if (cache
->undefined_retaddr
)
1007 (*this_id
) = frame_id_build (cache
->cfa
,
1008 frame_func_unwind (next_frame
, NORMAL_FRAME
));
1012 dwarf2_signal_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1013 struct frame_id
*this_id
)
1015 struct dwarf2_frame_cache
*cache
=
1016 dwarf2_frame_cache (next_frame
, this_cache
);
1018 if (cache
->undefined_retaddr
)
1021 (*this_id
) = frame_id_build (cache
->cfa
,
1022 frame_func_unwind (next_frame
, SIGTRAMP_FRAME
));
1026 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
1027 int regnum
, int *optimizedp
,
1028 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1029 int *realnump
, gdb_byte
*valuep
)
1031 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1032 struct dwarf2_frame_cache
*cache
=
1033 dwarf2_frame_cache (next_frame
, this_cache
);
1035 switch (cache
->reg
[regnum
].how
)
1037 case DWARF2_FRAME_REG_UNDEFINED
:
1038 /* If CFI explicitly specified that the value isn't defined,
1039 mark it as optimized away; the value isn't available. */
1046 /* In some cases, for example %eflags on the i386, we have
1047 to provide a sane value, even though this register wasn't
1048 saved. Assume we can get it from NEXT_FRAME. */
1049 frame_unwind_register (next_frame
, regnum
, valuep
);
1053 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1055 *lvalp
= lval_memory
;
1056 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1060 /* Read the value in from memory. */
1061 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1065 case DWARF2_FRAME_REG_SAVED_REG
:
1067 *lvalp
= lval_register
;
1069 *realnump
= gdbarch_dwarf2_reg_to_regnum
1070 (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1072 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1075 case DWARF2_FRAME_REG_SAVED_EXP
:
1077 *lvalp
= lval_memory
;
1078 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1079 cache
->reg
[regnum
].exp_len
,
1080 next_frame
, cache
->cfa
);
1084 /* Read the value in from memory. */
1085 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1089 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1095 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1096 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1099 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1105 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1106 execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1107 cache
->reg
[regnum
].exp_len
,
1108 next_frame
, cache
->cfa
));
1111 case DWARF2_FRAME_REG_UNSPECIFIED
:
1112 /* GCC, in its infinite wisdom decided to not provide unwind
1113 information for registers that are "same value". Since
1114 DWARF2 (3 draft 7) doesn't define such behavior, said
1115 registers are actually undefined (which is different to CFI
1116 "undefined"). Code above issues a complaint about this.
1117 Here just fudge the books, assume GCC, and that the value is
1118 more inner on the stack. */
1120 *lvalp
= lval_register
;
1124 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1127 case DWARF2_FRAME_REG_SAME_VALUE
:
1129 *lvalp
= lval_register
;
1133 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1136 case DWARF2_FRAME_REG_CFA
:
1142 pack_long (valuep
, register_type (gdbarch
, regnum
), cache
->cfa
);
1145 case DWARF2_FRAME_REG_CFA_OFFSET
:
1151 pack_long (valuep
, register_type (gdbarch
, regnum
),
1152 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1155 case DWARF2_FRAME_REG_RA_OFFSET
:
1162 CORE_ADDR pc
= cache
->reg
[regnum
].loc
.offset
;
1164 regnum
= gdbarch_dwarf2_reg_to_regnum
1165 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1166 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
);
1167 pack_long (valuep
, register_type (gdbarch
, regnum
), pc
);
1172 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1176 static const struct frame_unwind dwarf2_frame_unwind
=
1179 dwarf2_frame_this_id
,
1180 dwarf2_frame_prev_register
1183 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1186 dwarf2_signal_frame_this_id
,
1187 dwarf2_frame_prev_register
1190 const struct frame_unwind
*
1191 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
1193 /* Grab an address that is guarenteed to reside somewhere within the
1194 function. frame_pc_unwind(), for a no-return next function, can
1195 end up returning something past the end of this function's body.
1196 If the frame we're sniffing for is a signal frame whose start
1197 address is placed on the stack by the OS, its FDE must
1198 extend one byte before its start address or we will miss it. */
1199 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1201 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1205 /* On some targets, signal trampolines may have unwind information.
1206 We need to recognize them so that we set the frame type
1209 if (fde
->cie
->signal_frame
1210 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame
),
1212 return &dwarf2_signal_frame_unwind
;
1214 return &dwarf2_frame_unwind
;
1218 /* There is no explicitly defined relationship between the CFA and the
1219 location of frame's local variables and arguments/parameters.
1220 Therefore, frame base methods on this page should probably only be
1221 used as a last resort, just to avoid printing total garbage as a
1222 response to the "info frame" command. */
1225 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1227 struct dwarf2_frame_cache
*cache
=
1228 dwarf2_frame_cache (next_frame
, this_cache
);
1233 static const struct frame_base dwarf2_frame_base
=
1235 &dwarf2_frame_unwind
,
1236 dwarf2_frame_base_address
,
1237 dwarf2_frame_base_address
,
1238 dwarf2_frame_base_address
1241 const struct frame_base
*
1242 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
1244 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1246 if (dwarf2_frame_find_fde (&block_addr
))
1247 return &dwarf2_frame_base
;
1252 /* A minimal decoding of DWARF2 compilation units. We only decode
1253 what's needed to get to the call frame information. */
1257 /* Keep the bfd convenient. */
1260 struct objfile
*objfile
;
1262 /* Linked list of CIEs for this object. */
1263 struct dwarf2_cie
*cie
;
1265 /* Pointer to the .debug_frame section loaded into memory. */
1266 gdb_byte
*dwarf_frame_buffer
;
1268 /* Length of the loaded .debug_frame section. */
1269 unsigned long dwarf_frame_size
;
1271 /* Pointer to the .debug_frame section. */
1272 asection
*dwarf_frame_section
;
1274 /* Base for DW_EH_PE_datarel encodings. */
1277 /* Base for DW_EH_PE_textrel encodings. */
1281 const struct objfile_data
*dwarf2_frame_objfile_data
;
1284 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1286 return bfd_get_8 (abfd
, buf
);
1290 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1292 return bfd_get_32 (abfd
, buf
);
1296 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1298 return bfd_get_64 (abfd
, buf
);
1302 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1305 unsigned int num_read
;
1315 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1318 result
|= ((byte
& 0x7f) << shift
);
1321 while (byte
& 0x80);
1323 *bytes_read_ptr
= num_read
;
1329 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1333 unsigned int num_read
;
1342 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1345 result
|= ((byte
& 0x7f) << shift
);
1348 while (byte
& 0x80);
1350 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1351 result
|= -(((LONGEST
)1) << shift
);
1353 *bytes_read_ptr
= num_read
;
1359 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1363 result
= bfd_get_32 (abfd
, buf
);
1364 if (result
== 0xffffffff)
1366 result
= bfd_get_64 (abfd
, buf
+ 4);
1367 *bytes_read_ptr
= 12;
1370 *bytes_read_ptr
= 4;
1376 /* Pointer encoding helper functions. */
1378 /* GCC supports exception handling based on DWARF2 CFI. However, for
1379 technical reasons, it encodes addresses in its FDE's in a different
1380 way. Several "pointer encodings" are supported. The encoding
1381 that's used for a particular FDE is determined by the 'R'
1382 augmentation in the associated CIE. The argument of this
1383 augmentation is a single byte.
1385 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1386 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1387 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1388 address should be interpreted (absolute, relative to the current
1389 position in the FDE, ...). Bit 7, indicates that the address
1390 should be dereferenced. */
1393 encoding_for_size (unsigned int size
)
1398 return DW_EH_PE_udata2
;
1400 return DW_EH_PE_udata4
;
1402 return DW_EH_PE_udata8
;
1404 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1409 size_of_encoded_value (gdb_byte encoding
)
1411 if (encoding
== DW_EH_PE_omit
)
1414 switch (encoding
& 0x07)
1416 case DW_EH_PE_absptr
:
1417 return TYPE_LENGTH (builtin_type_void_data_ptr
);
1418 case DW_EH_PE_udata2
:
1420 case DW_EH_PE_udata4
:
1422 case DW_EH_PE_udata8
:
1425 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1430 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1431 gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1433 int ptr_len
= size_of_encoded_value (DW_EH_PE_absptr
);
1437 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1439 if (encoding
& DW_EH_PE_indirect
)
1440 internal_error (__FILE__
, __LINE__
,
1441 _("Unsupported encoding: DW_EH_PE_indirect"));
1443 *bytes_read_ptr
= 0;
1445 switch (encoding
& 0x70)
1447 case DW_EH_PE_absptr
:
1450 case DW_EH_PE_pcrel
:
1451 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1452 base
+= (buf
- unit
->dwarf_frame_buffer
);
1454 case DW_EH_PE_datarel
:
1457 case DW_EH_PE_textrel
:
1460 case DW_EH_PE_funcrel
:
1461 /* FIXME: kettenis/20040501: For now just pretend
1462 DW_EH_PE_funcrel is equivalent to DW_EH_PE_absptr. For
1463 reading the initial location of an FDE it should be treated
1464 as such, and currently that's the only place where this code
1468 case DW_EH_PE_aligned
:
1470 offset
= buf
- unit
->dwarf_frame_buffer
;
1471 if ((offset
% ptr_len
) != 0)
1473 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1474 buf
+= *bytes_read_ptr
;
1478 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1481 if ((encoding
& 0x07) == 0x00)
1483 encoding
|= encoding_for_size (ptr_len
);
1484 if (bfd_get_sign_extend_vma (unit
->abfd
))
1485 encoding
|= DW_EH_PE_signed
;
1488 switch (encoding
& 0x0f)
1490 case DW_EH_PE_uleb128
:
1493 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1494 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1495 return base
+ value
;
1497 case DW_EH_PE_udata2
:
1498 *bytes_read_ptr
+= 2;
1499 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1500 case DW_EH_PE_udata4
:
1501 *bytes_read_ptr
+= 4;
1502 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1503 case DW_EH_PE_udata8
:
1504 *bytes_read_ptr
+= 8;
1505 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1506 case DW_EH_PE_sleb128
:
1509 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1510 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1511 return base
+ value
;
1513 case DW_EH_PE_sdata2
:
1514 *bytes_read_ptr
+= 2;
1515 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1516 case DW_EH_PE_sdata4
:
1517 *bytes_read_ptr
+= 4;
1518 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1519 case DW_EH_PE_sdata8
:
1520 *bytes_read_ptr
+= 8;
1521 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1523 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1528 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1529 That's why we use a simple linked list here. */
1531 static struct dwarf2_cie
*
1532 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1534 struct dwarf2_cie
*cie
= unit
->cie
;
1538 if (cie
->cie_pointer
== cie_pointer
)
1548 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1550 cie
->next
= unit
->cie
;
1554 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1555 inital location associated with it into *PC. */
1557 static struct dwarf2_fde
*
1558 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1560 struct objfile
*objfile
;
1562 ALL_OBJFILES (objfile
)
1564 struct dwarf2_fde
*fde
;
1567 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1571 gdb_assert (objfile
->section_offsets
);
1572 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1576 if (*pc
>= fde
->initial_location
+ offset
1577 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1579 *pc
= fde
->initial_location
+ offset
;
1591 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1593 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1594 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1597 #ifdef CC_HAS_LONG_LONG
1598 #define DW64_CIE_ID 0xffffffffffffffffULL
1600 #define DW64_CIE_ID ~0
1603 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1606 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1607 the next byte to be processed. */
1609 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1611 gdb_byte
*buf
, *end
;
1613 unsigned int bytes_read
;
1616 ULONGEST cie_pointer
;
1619 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1623 /* Are we still within the section? */
1624 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1630 /* Distinguish between 32 and 64-bit encoded frame info. */
1631 dwarf64_p
= (bytes_read
== 12);
1633 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1637 cie_id
= DW64_CIE_ID
;
1643 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1648 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1652 if (cie_pointer
== cie_id
)
1654 /* This is a CIE. */
1655 struct dwarf2_cie
*cie
;
1657 unsigned int cie_version
;
1659 /* Record the offset into the .debug_frame section of this CIE. */
1660 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1662 /* Check whether we've already read it. */
1663 if (find_cie (unit
, cie_pointer
))
1666 cie
= (struct dwarf2_cie
*)
1667 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1668 sizeof (struct dwarf2_cie
));
1669 cie
->initial_instructions
= NULL
;
1670 cie
->cie_pointer
= cie_pointer
;
1672 /* The encoding for FDE's in a normal .debug_frame section
1673 depends on the target address size. */
1674 cie
->encoding
= DW_EH_PE_absptr
;
1676 /* We'll determine the final value later, but we need to
1677 initialize it conservatively. */
1678 cie
->signal_frame
= 0;
1680 /* Check version number. */
1681 cie_version
= read_1_byte (unit
->abfd
, buf
);
1682 if (cie_version
!= 1 && cie_version
!= 3)
1684 cie
->version
= cie_version
;
1687 /* Interpret the interesting bits of the augmentation. */
1688 cie
->augmentation
= augmentation
= (char *) buf
;
1689 buf
+= (strlen (augmentation
) + 1);
1691 /* Ignore armcc augmentations. We only use them for quirks,
1692 and that doesn't happen until later. */
1693 if (strncmp (augmentation
, "armcc", 5) == 0)
1694 augmentation
+= strlen (augmentation
);
1696 /* The GCC 2.x "eh" augmentation has a pointer immediately
1697 following the augmentation string, so it must be handled
1699 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1702 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1706 cie
->code_alignment_factor
=
1707 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1710 cie
->data_alignment_factor
=
1711 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1714 if (cie_version
== 1)
1716 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1720 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1722 cie
->return_address_register
1723 = dwarf2_frame_adjust_regnum (current_gdbarch
,
1724 cie
->return_address_register
,
1729 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1730 if (cie
->saw_z_augmentation
)
1734 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1738 cie
->initial_instructions
= buf
+ length
;
1742 while (*augmentation
)
1744 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1745 if (*augmentation
== 'L')
1752 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1753 else if (*augmentation
== 'R')
1755 cie
->encoding
= *buf
++;
1759 /* "P" indicates a personality routine in the CIE augmentation. */
1760 else if (*augmentation
== 'P')
1762 /* Skip. Avoid indirection since we throw away the result. */
1763 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1764 read_encoded_value (unit
, encoding
, buf
, &bytes_read
);
1769 /* "S" indicates a signal frame, such that the return
1770 address must not be decremented to locate the call frame
1771 info for the previous frame; it might even be the first
1772 instruction of a function, so decrementing it would take
1773 us to a different function. */
1774 else if (*augmentation
== 'S')
1776 cie
->signal_frame
= 1;
1780 /* Otherwise we have an unknown augmentation. Assume that either
1781 there is no augmentation data, or we saw a 'z' prefix. */
1784 if (cie
->initial_instructions
)
1785 buf
= cie
->initial_instructions
;
1790 cie
->initial_instructions
= buf
;
1793 add_cie (unit
, cie
);
1797 /* This is a FDE. */
1798 struct dwarf2_fde
*fde
;
1800 /* In an .eh_frame section, the CIE pointer is the delta between the
1801 address within the FDE where the CIE pointer is stored and the
1802 address of the CIE. Convert it to an offset into the .eh_frame
1806 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1807 cie_pointer
-= (dwarf64_p
? 8 : 4);
1810 /* In either case, validate the result is still within the section. */
1811 if (cie_pointer
>= unit
->dwarf_frame_size
)
1814 fde
= (struct dwarf2_fde
*)
1815 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1816 sizeof (struct dwarf2_fde
));
1817 fde
->cie
= find_cie (unit
, cie_pointer
);
1818 if (fde
->cie
== NULL
)
1820 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1822 fde
->cie
= find_cie (unit
, cie_pointer
);
1825 gdb_assert (fde
->cie
!= NULL
);
1827 fde
->initial_location
=
1828 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1831 fde
->address_range
=
1832 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1835 /* A 'z' augmentation in the CIE implies the presence of an
1836 augmentation field in the FDE as well. The only thing known
1837 to be in here at present is the LSDA entry for EH. So we
1838 can skip the whole thing. */
1839 if (fde
->cie
->saw_z_augmentation
)
1843 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1844 buf
+= bytes_read
+ length
;
1849 fde
->instructions
= buf
;
1852 fde
->eh_frame_p
= eh_frame_p
;
1854 add_fde (unit
, fde
);
1860 /* Read a CIE or FDE in BUF and decode it. */
1862 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1864 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1867 ptrdiff_t start_offset
;
1871 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1875 /* We have corrupt input data of some form. */
1877 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1878 and mismatches wrt padding and alignment of debug sections. */
1879 /* Note that there is no requirement in the standard for any
1880 alignment at all in the frame unwind sections. Testing for
1881 alignment before trying to interpret data would be incorrect.
1883 However, GCC traditionally arranged for frame sections to be
1884 sized such that the FDE length and CIE fields happen to be
1885 aligned (in theory, for performance). This, unfortunately,
1886 was done with .align directives, which had the side effect of
1887 forcing the section to be aligned by the linker.
1889 This becomes a problem when you have some other producer that
1890 creates frame sections that are not as strictly aligned. That
1891 produces a hole in the frame info that gets filled by the
1894 The GCC behaviour is arguably a bug, but it's effectively now
1895 part of the ABI, so we're now stuck with it, at least at the
1896 object file level. A smart linker may decide, in the process
1897 of compressing duplicate CIE information, that it can rewrite
1898 the entire output section without this extra padding. */
1900 start_offset
= start
- unit
->dwarf_frame_buffer
;
1901 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1903 start
+= 4 - (start_offset
& 3);
1904 workaround
= ALIGN4
;
1907 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1909 start
+= 8 - (start_offset
& 7);
1910 workaround
= ALIGN8
;
1914 /* Nothing left to try. Arrange to return as if we've consumed
1915 the entire input section. Hopefully we'll get valid info from
1916 the other of .debug_frame/.eh_frame. */
1918 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1928 complaint (&symfile_complaints
,
1929 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1930 unit
->dwarf_frame_section
->owner
->filename
,
1931 unit
->dwarf_frame_section
->name
);
1935 complaint (&symfile_complaints
,
1936 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1937 unit
->dwarf_frame_section
->owner
->filename
,
1938 unit
->dwarf_frame_section
->name
);
1942 complaint (&symfile_complaints
,
1943 _("Corrupt data in %s:%s"),
1944 unit
->dwarf_frame_section
->owner
->filename
,
1945 unit
->dwarf_frame_section
->name
);
1953 /* FIXME: kettenis/20030504: This still needs to be integrated with
1954 dwarf2read.c in a better way. */
1956 /* Imported from dwarf2read.c. */
1957 extern asection
*dwarf_frame_section
;
1958 extern asection
*dwarf_eh_frame_section
;
1960 /* Imported from dwarf2read.c. */
1961 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1964 dwarf2_build_frame_info (struct objfile
*objfile
)
1966 struct comp_unit unit
;
1967 gdb_byte
*frame_ptr
;
1969 /* Build a minimal decoding of the DWARF2 compilation unit. */
1970 unit
.abfd
= objfile
->obfd
;
1971 unit
.objfile
= objfile
;
1975 /* First add the information from the .eh_frame section. That way,
1976 the FDEs from that section are searched last. */
1977 if (dwarf_eh_frame_section
)
1979 asection
*got
, *txt
;
1982 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1983 dwarf_eh_frame_section
);
1985 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1986 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1988 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1989 that is used for the i386/amd64 target, which currently is
1990 the only target in GCC that supports/uses the
1991 DW_EH_PE_datarel encoding. */
1992 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
1994 unit
.dbase
= got
->vma
;
1996 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1998 txt
= bfd_get_section_by_name (unit
.abfd
, ".text");
2000 unit
.tbase
= txt
->vma
;
2002 frame_ptr
= unit
.dwarf_frame_buffer
;
2003 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
2004 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
2007 if (dwarf_frame_section
)
2010 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
2011 dwarf_frame_section
);
2012 unit
.dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
2013 unit
.dwarf_frame_section
= dwarf_frame_section
;
2015 frame_ptr
= unit
.dwarf_frame_buffer
;
2016 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
2017 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);
2021 /* Provide a prototype to silence -Wmissing-prototypes. */
2022 void _initialize_dwarf2_frame (void);
2025 _initialize_dwarf2_frame (void)
2027 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2028 dwarf2_frame_objfile_data
= register_objfile_data ();