1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 Contributed by Mark Kettenis.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "dwarf2expr.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "complaints.h"
40 #include "dwarf2-frame.h"
42 #include "dwarf2loc.h"
43 #include "exceptions.h"
47 /* Call Frame Information (CFI). */
49 /* Common Information Entry (CIE). */
53 /* Computation Unit for this CIE. */
54 struct comp_unit
*unit
;
56 /* Offset into the .debug_frame section where this CIE was found.
57 Used to identify this CIE. */
60 /* Constant that is factored out of all advance location
62 ULONGEST code_alignment_factor
;
64 /* Constants that is factored out of all offset instructions. */
65 LONGEST data_alignment_factor
;
67 /* Return address column. */
68 ULONGEST return_address_register
;
70 /* Instruction sequence to initialize a register set. */
71 gdb_byte
*initial_instructions
;
74 /* Saved augmentation, in case it's needed later. */
77 /* Encoding of addresses. */
80 /* Target address size in bytes. */
83 /* Target pointer size in bytes. */
86 /* True if a 'z' augmentation existed. */
87 unsigned char saw_z_augmentation
;
89 /* True if an 'S' augmentation existed. */
90 unsigned char signal_frame
;
92 /* The version recorded in the CIE. */
93 unsigned char version
;
95 /* The segment size. */
96 unsigned char segment_size
;
99 struct dwarf2_cie_table
102 struct dwarf2_cie
**entries
;
105 /* Frame Description Entry (FDE). */
109 /* CIE for this FDE. */
110 struct dwarf2_cie
*cie
;
112 /* First location associated with this FDE. */
113 CORE_ADDR initial_location
;
115 /* Number of bytes of program instructions described by this FDE. */
116 CORE_ADDR address_range
;
118 /* Instruction sequence. */
119 gdb_byte
*instructions
;
122 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
124 unsigned char eh_frame_p
;
127 struct dwarf2_fde_table
130 struct dwarf2_fde
**entries
;
133 /* A minimal decoding of DWARF2 compilation units. We only decode
134 what's needed to get to the call frame information. */
138 /* Keep the bfd convenient. */
141 struct objfile
*objfile
;
143 /* Pointer to the .debug_frame section loaded into memory. */
144 gdb_byte
*dwarf_frame_buffer
;
146 /* Length of the loaded .debug_frame section. */
147 bfd_size_type dwarf_frame_size
;
149 /* Pointer to the .debug_frame section. */
150 asection
*dwarf_frame_section
;
152 /* Base for DW_EH_PE_datarel encodings. */
155 /* Base for DW_EH_PE_textrel encodings. */
159 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
,
160 CORE_ADDR
*out_offset
);
162 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
165 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
166 int ptr_len
, const gdb_byte
*buf
,
167 unsigned int *bytes_read_ptr
,
168 CORE_ADDR func_base
);
171 /* Structure describing a frame state. */
173 struct dwarf2_frame_state
175 /* Each register save state can be described in terms of a CFA slot,
176 another register, or a location expression. */
177 struct dwarf2_frame_state_reg_info
179 struct dwarf2_frame_state_reg
*reg
;
189 const gdb_byte
*cfa_exp
;
191 /* Used to implement DW_CFA_remember_state. */
192 struct dwarf2_frame_state_reg_info
*prev
;
195 /* The PC described by the current frame state. */
198 /* Initial register set from the CIE.
199 Used to implement DW_CFA_restore. */
200 struct dwarf2_frame_state_reg_info initial
;
202 /* The information we care about from the CIE. */
205 ULONGEST retaddr_column
;
207 /* Flags for known producer quirks. */
209 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
210 and DW_CFA_def_cfa_offset takes a factored offset. */
211 int armcc_cfa_offsets_sf
;
213 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
214 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
215 int armcc_cfa_offsets_reversed
;
218 /* Store the length the expression for the CFA in the `cfa_reg' field,
219 which is unused in that case. */
220 #define cfa_exp_len cfa_reg
222 /* Assert that the register set RS is large enough to store gdbarch_num_regs
223 columns. If necessary, enlarge the register set. */
226 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
229 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
231 if (num_regs
<= rs
->num_regs
)
234 rs
->reg
= (struct dwarf2_frame_state_reg
*)
235 xrealloc (rs
->reg
, num_regs
* size
);
237 /* Initialize newly allocated registers. */
238 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
239 rs
->num_regs
= num_regs
;
242 /* Copy the register columns in register set RS into newly allocated
243 memory and return a pointer to this newly created copy. */
245 static struct dwarf2_frame_state_reg
*
246 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
248 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
249 struct dwarf2_frame_state_reg
*reg
;
251 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
252 memcpy (reg
, rs
->reg
, size
);
257 /* Release the memory allocated to register set RS. */
260 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
264 dwarf2_frame_state_free_regs (rs
->prev
);
271 /* Release the memory allocated to the frame state FS. */
274 dwarf2_frame_state_free (void *p
)
276 struct dwarf2_frame_state
*fs
= p
;
278 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
279 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
280 xfree (fs
->initial
.reg
);
281 xfree (fs
->regs
.reg
);
286 /* Helper functions for execute_stack_op. */
289 read_reg (void *baton
, int reg
)
291 struct frame_info
*this_frame
= (struct frame_info
*) baton
;
292 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
296 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
298 buf
= alloca (register_size (gdbarch
, regnum
));
299 get_frame_register (this_frame
, regnum
, buf
);
301 /* Convert the register to an integer. This returns a LONGEST
302 rather than a CORE_ADDR, but unpack_pointer does the same thing
303 under the covers, and this makes more sense for non-pointer
304 registers. Maybe read_reg and the associated interfaces should
305 deal with "struct value" instead of CORE_ADDR. */
306 return unpack_long (register_type (gdbarch
, regnum
), buf
);
310 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
312 read_memory (addr
, buf
, len
);
316 no_get_frame_base (void *baton
, const gdb_byte
**start
, size_t *length
)
318 internal_error (__FILE__
, __LINE__
,
319 _("Support for DW_OP_fbreg is unimplemented"));
322 /* Helper function for execute_stack_op. */
325 no_get_frame_cfa (void *baton
)
327 internal_error (__FILE__
, __LINE__
,
328 _("Support for DW_OP_call_frame_cfa is unimplemented"));
331 /* Helper function for execute_stack_op. */
334 no_get_frame_pc (void *baton
)
336 internal_error (__FILE__
, __LINE__
, _("\
337 Support for DW_OP_GNU_implicit_pointer is unimplemented"));
341 no_get_tls_address (void *baton
, CORE_ADDR offset
)
343 internal_error (__FILE__
, __LINE__
, _("\
344 Support for DW_OP_GNU_push_tls_address is unimplemented"));
347 /* Helper function for execute_stack_op. */
350 no_dwarf_call (struct dwarf_expr_context
*ctx
, size_t die_offset
)
352 internal_error (__FILE__
, __LINE__
,
353 _("Support for DW_OP_call* is invalid in CFI"));
356 /* Helper function for execute_stack_op. */
359 no_base_type (struct dwarf_expr_context
*ctx
, size_t die
)
361 error (_("Support for typed DWARF is not supported in CFI"));
364 /* Execute the required actions for both the DW_CFA_restore and
365 DW_CFA_restore_extended instructions. */
367 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
368 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
372 gdb_assert (fs
->initial
.reg
);
373 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
374 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
376 /* Check if this register was explicitly initialized in the
377 CIE initial instructions. If not, default the rule to
379 if (reg
< fs
->initial
.num_regs
)
380 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
382 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
384 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
385 complaint (&symfile_complaints
, _("\
386 incomplete CFI data; DW_CFA_restore unspecified\n\
387 register %s (#%d) at %s"),
388 gdbarch_register_name
389 (gdbarch
, gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
)),
390 gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
),
391 paddress (gdbarch
, fs
->pc
));
394 /* Virtual method table for execute_stack_op below. */
396 static const struct dwarf_expr_context_funcs dwarf2_frame_ctx_funcs
=
409 execute_stack_op (const gdb_byte
*exp
, ULONGEST len
, int addr_size
,
410 CORE_ADDR offset
, struct frame_info
*this_frame
,
411 CORE_ADDR initial
, int initial_in_stack_memory
)
413 struct dwarf_expr_context
*ctx
;
415 struct cleanup
*old_chain
;
417 ctx
= new_dwarf_expr_context ();
418 old_chain
= make_cleanup_free_dwarf_expr_context (ctx
);
419 make_cleanup_value_free_to_mark (value_mark ());
421 ctx
->gdbarch
= get_frame_arch (this_frame
);
422 ctx
->addr_size
= addr_size
;
423 ctx
->offset
= offset
;
424 ctx
->baton
= this_frame
;
425 ctx
->funcs
= &dwarf2_frame_ctx_funcs
;
427 dwarf_expr_push_address (ctx
, initial
, initial_in_stack_memory
);
428 dwarf_expr_eval (ctx
, exp
, len
);
430 if (ctx
->location
== DWARF_VALUE_MEMORY
)
431 result
= dwarf_expr_fetch_address (ctx
, 0);
432 else if (ctx
->location
== DWARF_VALUE_REGISTER
)
433 result
= read_reg (this_frame
, value_as_long (dwarf_expr_fetch (ctx
, 0)));
436 /* This is actually invalid DWARF, but if we ever do run across
437 it somehow, we might as well support it. So, instead, report
438 it as unimplemented. */
440 Not implemented: computing unwound register using explicit value operator"));
443 do_cleanups (old_chain
);
450 execute_cfa_program (struct dwarf2_fde
*fde
, const gdb_byte
*insn_ptr
,
451 const gdb_byte
*insn_end
, struct gdbarch
*gdbarch
,
452 CORE_ADDR pc
, struct dwarf2_frame_state
*fs
)
454 int eh_frame_p
= fde
->eh_frame_p
;
456 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
458 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
460 gdb_byte insn
= *insn_ptr
++;
464 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
465 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
466 else if ((insn
& 0xc0) == DW_CFA_offset
)
469 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
470 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
471 offset
= utmp
* fs
->data_align
;
472 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
473 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
474 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
476 else if ((insn
& 0xc0) == DW_CFA_restore
)
479 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
486 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
487 fde
->cie
->ptr_size
, insn_ptr
,
488 &bytes_read
, fde
->initial_location
);
489 /* Apply the objfile offset for relocatable objects. */
490 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
491 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
492 insn_ptr
+= bytes_read
;
495 case DW_CFA_advance_loc1
:
496 utmp
= extract_unsigned_integer (insn_ptr
, 1, byte_order
);
497 fs
->pc
+= utmp
* fs
->code_align
;
500 case DW_CFA_advance_loc2
:
501 utmp
= extract_unsigned_integer (insn_ptr
, 2, byte_order
);
502 fs
->pc
+= utmp
* fs
->code_align
;
505 case DW_CFA_advance_loc4
:
506 utmp
= extract_unsigned_integer (insn_ptr
, 4, byte_order
);
507 fs
->pc
+= utmp
* fs
->code_align
;
511 case DW_CFA_offset_extended
:
512 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
513 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
514 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
515 offset
= utmp
* fs
->data_align
;
516 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
517 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
518 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
521 case DW_CFA_restore_extended
:
522 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
523 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
526 case DW_CFA_undefined
:
527 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
528 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
529 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
530 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
533 case DW_CFA_same_value
:
534 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
535 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
536 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
537 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
540 case DW_CFA_register
:
541 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
542 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
543 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
544 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
545 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
546 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
547 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
550 case DW_CFA_remember_state
:
552 struct dwarf2_frame_state_reg_info
*new_rs
;
554 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
556 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
557 fs
->regs
.prev
= new_rs
;
561 case DW_CFA_restore_state
:
563 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
567 complaint (&symfile_complaints
, _("\
568 bad CFI data; mismatched DW_CFA_restore_state at %s"),
569 paddress (gdbarch
, fs
->pc
));
573 xfree (fs
->regs
.reg
);
581 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
582 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
584 if (fs
->armcc_cfa_offsets_sf
)
585 utmp
*= fs
->data_align
;
587 fs
->regs
.cfa_offset
= utmp
;
588 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
591 case DW_CFA_def_cfa_register
:
592 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
593 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
596 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
599 case DW_CFA_def_cfa_offset
:
600 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
602 if (fs
->armcc_cfa_offsets_sf
)
603 utmp
*= fs
->data_align
;
605 fs
->regs
.cfa_offset
= utmp
;
606 /* cfa_how deliberately not set. */
612 case DW_CFA_def_cfa_expression
:
613 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
,
614 &fs
->regs
.cfa_exp_len
);
615 fs
->regs
.cfa_exp
= insn_ptr
;
616 fs
->regs
.cfa_how
= CFA_EXP
;
617 insn_ptr
+= fs
->regs
.cfa_exp_len
;
620 case DW_CFA_expression
:
621 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
622 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
623 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
624 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
625 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
626 fs
->regs
.reg
[reg
].exp_len
= utmp
;
627 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
631 case DW_CFA_offset_extended_sf
:
632 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
633 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
634 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
635 offset
*= fs
->data_align
;
636 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
637 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
638 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
641 case DW_CFA_val_offset
:
642 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
643 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
644 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
645 offset
= utmp
* fs
->data_align
;
646 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
647 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
650 case DW_CFA_val_offset_sf
:
651 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
652 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
653 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
654 offset
*= fs
->data_align
;
655 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
656 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
659 case DW_CFA_val_expression
:
660 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
661 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
662 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
663 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
664 fs
->regs
.reg
[reg
].exp_len
= utmp
;
665 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
669 case DW_CFA_def_cfa_sf
:
670 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
671 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
674 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
675 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
676 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
679 case DW_CFA_def_cfa_offset_sf
:
680 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
681 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
682 /* cfa_how deliberately not set. */
685 case DW_CFA_GNU_window_save
:
686 /* This is SPARC-specific code, and contains hard-coded
687 constants for the register numbering scheme used by
688 GCC. Rather than having a architecture-specific
689 operation that's only ever used by a single
690 architecture, we provide the implementation here.
691 Incidentally that's what GCC does too in its
694 int size
= register_size (gdbarch
, 0);
696 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
697 for (reg
= 8; reg
< 16; reg
++)
699 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
700 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
702 for (reg
= 16; reg
< 32; reg
++)
704 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
705 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
710 case DW_CFA_GNU_args_size
:
712 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
715 case DW_CFA_GNU_negative_offset_extended
:
716 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
717 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
718 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
719 offset
*= fs
->data_align
;
720 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
721 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
722 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
726 internal_error (__FILE__
, __LINE__
,
727 _("Unknown CFI encountered."));
732 /* Don't allow remember/restore between CIE and FDE programs. */
733 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
734 fs
->regs
.prev
= NULL
;
738 /* Architecture-specific operations. */
740 /* Per-architecture data key. */
741 static struct gdbarch_data
*dwarf2_frame_data
;
743 struct dwarf2_frame_ops
745 /* Pre-initialize the register state REG for register REGNUM. */
746 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
747 struct frame_info
*);
749 /* Check whether the THIS_FRAME is a signal trampoline. */
750 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
752 /* Convert .eh_frame register number to DWARF register number, or
753 adjust .debug_frame register number. */
754 int (*adjust_regnum
) (struct gdbarch
*, int, int);
757 /* Default architecture-specific register state initialization
761 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
762 struct dwarf2_frame_state_reg
*reg
,
763 struct frame_info
*this_frame
)
765 /* If we have a register that acts as a program counter, mark it as
766 a destination for the return address. If we have a register that
767 serves as the stack pointer, arrange for it to be filled with the
768 call frame address (CFA). The other registers are marked as
771 We copy the return address to the program counter, since many
772 parts in GDB assume that it is possible to get the return address
773 by unwinding the program counter register. However, on ISA's
774 with a dedicated return address register, the CFI usually only
775 contains information to unwind that return address register.
777 The reason we're treating the stack pointer special here is
778 because in many cases GCC doesn't emit CFI for the stack pointer
779 and implicitly assumes that it is equal to the CFA. This makes
780 some sense since the DWARF specification (version 3, draft 8,
783 "Typically, the CFA is defined to be the value of the stack
784 pointer at the call site in the previous frame (which may be
785 different from its value on entry to the current frame)."
787 However, this isn't true for all platforms supported by GCC
788 (e.g. IBM S/390 and zSeries). Those architectures should provide
789 their own architecture-specific initialization function. */
791 if (regnum
== gdbarch_pc_regnum (gdbarch
))
792 reg
->how
= DWARF2_FRAME_REG_RA
;
793 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
794 reg
->how
= DWARF2_FRAME_REG_CFA
;
797 /* Return a default for the architecture-specific operations. */
800 dwarf2_frame_init (struct obstack
*obstack
)
802 struct dwarf2_frame_ops
*ops
;
804 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
805 ops
->init_reg
= dwarf2_frame_default_init_reg
;
809 /* Set the architecture-specific register state initialization
810 function for GDBARCH to INIT_REG. */
813 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
814 void (*init_reg
) (struct gdbarch
*, int,
815 struct dwarf2_frame_state_reg
*,
816 struct frame_info
*))
818 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
820 ops
->init_reg
= init_reg
;
823 /* Pre-initialize the register state REG for register REGNUM. */
826 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
827 struct dwarf2_frame_state_reg
*reg
,
828 struct frame_info
*this_frame
)
830 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
832 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
835 /* Set the architecture-specific signal trampoline recognition
836 function for GDBARCH to SIGNAL_FRAME_P. */
839 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
840 int (*signal_frame_p
) (struct gdbarch
*,
841 struct frame_info
*))
843 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
845 ops
->signal_frame_p
= signal_frame_p
;
848 /* Query the architecture-specific signal frame recognizer for
852 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
853 struct frame_info
*this_frame
)
855 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
857 if (ops
->signal_frame_p
== NULL
)
859 return ops
->signal_frame_p (gdbarch
, this_frame
);
862 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
866 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
867 int (*adjust_regnum
) (struct gdbarch
*,
870 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
872 ops
->adjust_regnum
= adjust_regnum
;
875 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
879 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
,
880 int regnum
, int eh_frame_p
)
882 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
884 if (ops
->adjust_regnum
== NULL
)
886 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
890 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
891 struct dwarf2_fde
*fde
)
895 s
= find_pc_symtab (fs
->pc
);
899 if (producer_is_realview (s
->producer
))
901 if (fde
->cie
->version
== 1)
902 fs
->armcc_cfa_offsets_sf
= 1;
904 if (fde
->cie
->version
== 1)
905 fs
->armcc_cfa_offsets_reversed
= 1;
907 /* The reversed offset problem is present in some compilers
908 using DWARF3, but it was eventually fixed. Check the ARM
909 defined augmentations, which are in the format "armcc" followed
910 by a list of one-character options. The "+" option means
911 this problem is fixed (no quirk needed). If the armcc
912 augmentation is missing, the quirk is needed. */
913 if (fde
->cie
->version
== 3
914 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
915 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
916 fs
->armcc_cfa_offsets_reversed
= 1;
924 dwarf2_compile_cfa_to_ax (struct agent_expr
*expr
, struct axs_value
*loc
,
925 struct gdbarch
*gdbarch
,
927 struct dwarf2_per_cu_data
*data
)
929 const int num_regs
= gdbarch_num_regs (gdbarch
)
930 + gdbarch_num_pseudo_regs (gdbarch
);
931 struct dwarf2_fde
*fde
;
932 CORE_ADDR text_offset
, cfa
;
933 struct dwarf2_frame_state fs
;
936 memset (&fs
, 0, sizeof (struct dwarf2_frame_state
));
940 /* Find the correct FDE. */
941 fde
= dwarf2_frame_find_fde (&fs
.pc
, &text_offset
);
943 error (_("Could not compute CFA; needed to translate this expression"));
945 /* Extract any interesting information from the CIE. */
946 fs
.data_align
= fde
->cie
->data_alignment_factor
;
947 fs
.code_align
= fde
->cie
->code_alignment_factor
;
948 fs
.retaddr_column
= fde
->cie
->return_address_register
;
949 addr_size
= fde
->cie
->addr_size
;
951 /* Check for "quirks" - known bugs in producers. */
952 dwarf2_frame_find_quirks (&fs
, fde
);
954 /* First decode all the insns in the CIE. */
955 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
956 fde
->cie
->end
, gdbarch
, pc
, &fs
);
958 /* Save the initialized register set. */
959 fs
.initial
= fs
.regs
;
960 fs
.initial
.reg
= dwarf2_frame_state_copy_regs (&fs
.regs
);
962 /* Then decode the insns in the FDE up to our target PC. */
963 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
, pc
, &fs
);
965 /* Calculate the CFA. */
966 switch (fs
.regs
.cfa_how
)
970 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, fs
.regs
.cfa_reg
);
973 error (_("Unable to access DWARF register number %d"),
974 (int) fs
.regs
.cfa_reg
); /* FIXME */
975 ax_reg (expr
, regnum
);
977 if (fs
.regs
.cfa_offset
!= 0)
979 if (fs
.armcc_cfa_offsets_reversed
)
980 ax_const_l (expr
, -fs
.regs
.cfa_offset
);
982 ax_const_l (expr
, fs
.regs
.cfa_offset
);
983 ax_simple (expr
, aop_add
);
989 ax_const_l (expr
, text_offset
);
990 dwarf2_compile_expr_to_ax (expr
, loc
, gdbarch
, addr_size
,
992 fs
.regs
.cfa_exp
+ fs
.regs
.cfa_exp_len
,
997 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
1002 struct dwarf2_frame_cache
1004 /* DWARF Call Frame Address. */
1007 /* Set if the return address column was marked as unavailable
1008 (required non-collected memory or registers to compute). */
1009 int unavailable_retaddr
;
1011 /* Set if the return address column was marked as undefined. */
1012 int undefined_retaddr
;
1014 /* Saved registers, indexed by GDB register number, not by DWARF
1016 struct dwarf2_frame_state_reg
*reg
;
1018 /* Return address register. */
1019 struct dwarf2_frame_state_reg retaddr_reg
;
1021 /* Target address size in bytes. */
1024 /* The .text offset. */
1025 CORE_ADDR text_offset
;
1028 static struct dwarf2_frame_cache
*
1029 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1031 struct cleanup
*old_chain
;
1032 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1033 const int num_regs
= gdbarch_num_regs (gdbarch
)
1034 + gdbarch_num_pseudo_regs (gdbarch
);
1035 struct dwarf2_frame_cache
*cache
;
1036 struct dwarf2_frame_state
*fs
;
1037 struct dwarf2_fde
*fde
;
1038 volatile struct gdb_exception ex
;
1043 /* Allocate a new cache. */
1044 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
1045 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
1046 *this_cache
= cache
;
1048 /* Allocate and initialize the frame state. */
1049 fs
= XZALLOC (struct dwarf2_frame_state
);
1050 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
1054 Note that if the next frame is never supposed to return (i.e. a call
1055 to abort), the compiler might optimize away the instruction at
1056 its return address. As a result the return address will
1057 point at some random instruction, and the CFI for that
1058 instruction is probably worthless to us. GCC's unwinder solves
1059 this problem by substracting 1 from the return address to get an
1060 address in the middle of a presumed call instruction (or the
1061 instruction in the associated delay slot). This should only be
1062 done for "normal" frames and not for resume-type frames (signal
1063 handlers, sentinel frames, dummy frames). The function
1064 get_frame_address_in_block does just this. It's not clear how
1065 reliable the method is though; there is the potential for the
1066 register state pre-call being different to that on return. */
1067 fs
->pc
= get_frame_address_in_block (this_frame
);
1069 /* Find the correct FDE. */
1070 fde
= dwarf2_frame_find_fde (&fs
->pc
, &cache
->text_offset
);
1071 gdb_assert (fde
!= NULL
);
1073 /* Extract any interesting information from the CIE. */
1074 fs
->data_align
= fde
->cie
->data_alignment_factor
;
1075 fs
->code_align
= fde
->cie
->code_alignment_factor
;
1076 fs
->retaddr_column
= fde
->cie
->return_address_register
;
1077 cache
->addr_size
= fde
->cie
->addr_size
;
1079 /* Check for "quirks" - known bugs in producers. */
1080 dwarf2_frame_find_quirks (fs
, fde
);
1082 /* First decode all the insns in the CIE. */
1083 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
1084 fde
->cie
->end
, gdbarch
, get_frame_pc (this_frame
), fs
);
1086 /* Save the initialized register set. */
1087 fs
->initial
= fs
->regs
;
1088 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
1090 /* Then decode the insns in the FDE up to our target PC. */
1091 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
,
1092 get_frame_pc (this_frame
), fs
);
1094 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1096 /* Calculate the CFA. */
1097 switch (fs
->regs
.cfa_how
)
1099 case CFA_REG_OFFSET
:
1100 cache
->cfa
= read_reg (this_frame
, fs
->regs
.cfa_reg
);
1101 if (fs
->armcc_cfa_offsets_reversed
)
1102 cache
->cfa
-= fs
->regs
.cfa_offset
;
1104 cache
->cfa
+= fs
->regs
.cfa_offset
;
1109 execute_stack_op (fs
->regs
.cfa_exp
, fs
->regs
.cfa_exp_len
,
1110 cache
->addr_size
, cache
->text_offset
,
1115 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
1120 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1122 cache
->unavailable_retaddr
= 1;
1126 throw_exception (ex
);
1129 /* Initialize the register state. */
1133 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1134 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
1137 /* Go through the DWARF2 CFI generated table and save its register
1138 location information in the cache. Note that we don't skip the
1139 return address column; it's perfectly all right for it to
1140 correspond to a real register. If it doesn't correspond to a
1141 real register, or if we shouldn't treat it as such,
1142 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1143 the range [0, gdbarch_num_regs). */
1145 int column
; /* CFI speak for "register number". */
1147 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
1149 /* Use the GDB register number as the destination index. */
1150 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
1152 /* If there's no corresponding GDB register, ignore it. */
1153 if (regnum
< 0 || regnum
>= num_regs
)
1156 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1157 of all debug info registers. If it doesn't, complain (but
1158 not too loudly). It turns out that GCC assumes that an
1159 unspecified register implies "same value" when CFI (draft
1160 7) specifies nothing at all. Such a register could equally
1161 be interpreted as "undefined". Also note that this check
1162 isn't sufficient; it only checks that all registers in the
1163 range [0 .. max column] are specified, and won't detect
1164 problems when a debug info register falls outside of the
1165 table. We need a way of iterating through all the valid
1166 DWARF2 register numbers. */
1167 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1169 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1170 complaint (&symfile_complaints
, _("\
1171 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1172 gdbarch_register_name (gdbarch
, regnum
),
1173 paddress (gdbarch
, fs
->pc
));
1176 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1180 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1181 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1185 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1187 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1188 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1190 struct dwarf2_frame_state_reg
*retaddr_reg
=
1191 &fs
->regs
.reg
[fs
->retaddr_column
];
1193 /* It seems rather bizarre to specify an "empty" column as
1194 the return adress column. However, this is exactly
1195 what GCC does on some targets. It turns out that GCC
1196 assumes that the return address can be found in the
1197 register corresponding to the return address column.
1198 Incidentally, that's how we should treat a return
1199 address column specifying "same value" too. */
1200 if (fs
->retaddr_column
< fs
->regs
.num_regs
1201 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1202 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1204 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1205 cache
->reg
[regnum
] = *retaddr_reg
;
1207 cache
->retaddr_reg
= *retaddr_reg
;
1211 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1213 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1214 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1218 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1219 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1226 if (fs
->retaddr_column
< fs
->regs
.num_regs
1227 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1228 cache
->undefined_retaddr
= 1;
1230 do_cleanups (old_chain
);
1235 static enum unwind_stop_reason
1236 dwarf2_frame_unwind_stop_reason (struct frame_info
*this_frame
,
1239 struct dwarf2_frame_cache
*cache
1240 = dwarf2_frame_cache (this_frame
, this_cache
);
1242 if (cache
->unavailable_retaddr
)
1243 return UNWIND_UNAVAILABLE
;
1245 if (cache
->undefined_retaddr
)
1246 return UNWIND_OUTERMOST
;
1248 return UNWIND_NO_REASON
;
1252 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1253 struct frame_id
*this_id
)
1255 struct dwarf2_frame_cache
*cache
=
1256 dwarf2_frame_cache (this_frame
, this_cache
);
1258 if (cache
->unavailable_retaddr
)
1261 if (cache
->undefined_retaddr
)
1264 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1267 static struct value
*
1268 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1271 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1272 struct dwarf2_frame_cache
*cache
=
1273 dwarf2_frame_cache (this_frame
, this_cache
);
1277 switch (cache
->reg
[regnum
].how
)
1279 case DWARF2_FRAME_REG_UNDEFINED
:
1280 /* If CFI explicitly specified that the value isn't defined,
1281 mark it as optimized away; the value isn't available. */
1282 return frame_unwind_got_optimized (this_frame
, regnum
);
1284 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1285 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1286 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1288 case DWARF2_FRAME_REG_SAVED_REG
:
1290 = gdbarch_dwarf2_reg_to_regnum (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1291 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1293 case DWARF2_FRAME_REG_SAVED_EXP
:
1294 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1295 cache
->reg
[regnum
].exp_len
,
1296 cache
->addr_size
, cache
->text_offset
,
1297 this_frame
, cache
->cfa
, 1);
1298 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1300 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1301 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1302 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1304 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1305 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1306 cache
->reg
[regnum
].exp_len
,
1307 cache
->addr_size
, cache
->text_offset
,
1308 this_frame
, cache
->cfa
, 1);
1309 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1311 case DWARF2_FRAME_REG_UNSPECIFIED
:
1312 /* GCC, in its infinite wisdom decided to not provide unwind
1313 information for registers that are "same value". Since
1314 DWARF2 (3 draft 7) doesn't define such behavior, said
1315 registers are actually undefined (which is different to CFI
1316 "undefined"). Code above issues a complaint about this.
1317 Here just fudge the books, assume GCC, and that the value is
1318 more inner on the stack. */
1319 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1321 case DWARF2_FRAME_REG_SAME_VALUE
:
1322 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1324 case DWARF2_FRAME_REG_CFA
:
1325 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1327 case DWARF2_FRAME_REG_CFA_OFFSET
:
1328 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1329 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1331 case DWARF2_FRAME_REG_RA_OFFSET
:
1332 addr
= cache
->reg
[regnum
].loc
.offset
;
1333 regnum
= gdbarch_dwarf2_reg_to_regnum
1334 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1335 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1336 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1338 case DWARF2_FRAME_REG_FN
:
1339 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1342 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1347 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1348 struct frame_info
*this_frame
, void **this_cache
)
1350 /* Grab an address that is guarenteed to reside somewhere within the
1351 function. get_frame_pc(), with a no-return next function, can
1352 end up returning something past the end of this function's body.
1353 If the frame we're sniffing for is a signal frame whose start
1354 address is placed on the stack by the OS, its FDE must
1355 extend one byte before its start address or we could potentially
1356 select the FDE of the previous function. */
1357 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1358 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
, NULL
);
1363 /* On some targets, signal trampolines may have unwind information.
1364 We need to recognize them so that we set the frame type
1367 if (fde
->cie
->signal_frame
1368 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1370 return self
->type
== SIGTRAMP_FRAME
;
1372 return self
->type
!= SIGTRAMP_FRAME
;
1375 static const struct frame_unwind dwarf2_frame_unwind
=
1378 dwarf2_frame_unwind_stop_reason
,
1379 dwarf2_frame_this_id
,
1380 dwarf2_frame_prev_register
,
1382 dwarf2_frame_sniffer
1385 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1388 dwarf2_frame_unwind_stop_reason
,
1389 dwarf2_frame_this_id
,
1390 dwarf2_frame_prev_register
,
1392 dwarf2_frame_sniffer
1395 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1398 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1400 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1401 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1405 /* There is no explicitly defined relationship between the CFA and the
1406 location of frame's local variables and arguments/parameters.
1407 Therefore, frame base methods on this page should probably only be
1408 used as a last resort, just to avoid printing total garbage as a
1409 response to the "info frame" command. */
1412 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1414 struct dwarf2_frame_cache
*cache
=
1415 dwarf2_frame_cache (this_frame
, this_cache
);
1420 static const struct frame_base dwarf2_frame_base
=
1422 &dwarf2_frame_unwind
,
1423 dwarf2_frame_base_address
,
1424 dwarf2_frame_base_address
,
1425 dwarf2_frame_base_address
1428 const struct frame_base
*
1429 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1431 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1433 if (dwarf2_frame_find_fde (&block_addr
, NULL
))
1434 return &dwarf2_frame_base
;
1439 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1440 the DWARF unwinder. This is used to implement
1441 DW_OP_call_frame_cfa. */
1444 dwarf2_frame_cfa (struct frame_info
*this_frame
)
1446 while (get_frame_type (this_frame
) == INLINE_FRAME
)
1447 this_frame
= get_prev_frame (this_frame
);
1448 /* This restriction could be lifted if other unwinders are known to
1449 compute the frame base in a way compatible with the DWARF
1451 if (! frame_unwinder_is (this_frame
, &dwarf2_frame_unwind
))
1452 error (_("can't compute CFA for this frame"));
1453 return get_frame_base (this_frame
);
1456 const struct objfile_data
*dwarf2_frame_objfile_data
;
1459 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1461 return bfd_get_8 (abfd
, buf
);
1465 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1467 return bfd_get_32 (abfd
, buf
);
1471 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1473 return bfd_get_64 (abfd
, buf
);
1477 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1480 unsigned int num_read
;
1490 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1493 result
|= ((byte
& 0x7f) << shift
);
1496 while (byte
& 0x80);
1498 *bytes_read_ptr
= num_read
;
1504 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1508 unsigned int num_read
;
1517 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1520 result
|= ((byte
& 0x7f) << shift
);
1523 while (byte
& 0x80);
1525 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1526 result
|= -(((LONGEST
)1) << shift
);
1528 *bytes_read_ptr
= num_read
;
1534 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1538 result
= bfd_get_32 (abfd
, buf
);
1539 if (result
== 0xffffffff)
1541 result
= bfd_get_64 (abfd
, buf
+ 4);
1542 *bytes_read_ptr
= 12;
1545 *bytes_read_ptr
= 4;
1551 /* Pointer encoding helper functions. */
1553 /* GCC supports exception handling based on DWARF2 CFI. However, for
1554 technical reasons, it encodes addresses in its FDE's in a different
1555 way. Several "pointer encodings" are supported. The encoding
1556 that's used for a particular FDE is determined by the 'R'
1557 augmentation in the associated CIE. The argument of this
1558 augmentation is a single byte.
1560 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1561 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1562 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1563 address should be interpreted (absolute, relative to the current
1564 position in the FDE, ...). Bit 7, indicates that the address
1565 should be dereferenced. */
1568 encoding_for_size (unsigned int size
)
1573 return DW_EH_PE_udata2
;
1575 return DW_EH_PE_udata4
;
1577 return DW_EH_PE_udata8
;
1579 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1584 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1585 int ptr_len
, const gdb_byte
*buf
,
1586 unsigned int *bytes_read_ptr
,
1587 CORE_ADDR func_base
)
1592 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1594 if (encoding
& DW_EH_PE_indirect
)
1595 internal_error (__FILE__
, __LINE__
,
1596 _("Unsupported encoding: DW_EH_PE_indirect"));
1598 *bytes_read_ptr
= 0;
1600 switch (encoding
& 0x70)
1602 case DW_EH_PE_absptr
:
1605 case DW_EH_PE_pcrel
:
1606 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1607 base
+= (buf
- unit
->dwarf_frame_buffer
);
1609 case DW_EH_PE_datarel
:
1612 case DW_EH_PE_textrel
:
1615 case DW_EH_PE_funcrel
:
1618 case DW_EH_PE_aligned
:
1620 offset
= buf
- unit
->dwarf_frame_buffer
;
1621 if ((offset
% ptr_len
) != 0)
1623 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1624 buf
+= *bytes_read_ptr
;
1628 internal_error (__FILE__
, __LINE__
,
1629 _("Invalid or unsupported encoding"));
1632 if ((encoding
& 0x07) == 0x00)
1634 encoding
|= encoding_for_size (ptr_len
);
1635 if (bfd_get_sign_extend_vma (unit
->abfd
))
1636 encoding
|= DW_EH_PE_signed
;
1639 switch (encoding
& 0x0f)
1641 case DW_EH_PE_uleb128
:
1644 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1646 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1647 return base
+ value
;
1649 case DW_EH_PE_udata2
:
1650 *bytes_read_ptr
+= 2;
1651 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1652 case DW_EH_PE_udata4
:
1653 *bytes_read_ptr
+= 4;
1654 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1655 case DW_EH_PE_udata8
:
1656 *bytes_read_ptr
+= 8;
1657 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1658 case DW_EH_PE_sleb128
:
1661 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1663 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1664 return base
+ value
;
1666 case DW_EH_PE_sdata2
:
1667 *bytes_read_ptr
+= 2;
1668 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1669 case DW_EH_PE_sdata4
:
1670 *bytes_read_ptr
+= 4;
1671 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1672 case DW_EH_PE_sdata8
:
1673 *bytes_read_ptr
+= 8;
1674 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1676 internal_error (__FILE__
, __LINE__
,
1677 _("Invalid or unsupported encoding"));
1683 bsearch_cie_cmp (const void *key
, const void *element
)
1685 ULONGEST cie_pointer
= *(ULONGEST
*) key
;
1686 struct dwarf2_cie
*cie
= *(struct dwarf2_cie
**) element
;
1688 if (cie_pointer
== cie
->cie_pointer
)
1691 return (cie_pointer
< cie
->cie_pointer
) ? -1 : 1;
1694 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1695 static struct dwarf2_cie
*
1696 find_cie (struct dwarf2_cie_table
*cie_table
, ULONGEST cie_pointer
)
1698 struct dwarf2_cie
**p_cie
;
1700 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1701 bsearch be non-NULL. */
1702 if (cie_table
->entries
== NULL
)
1704 gdb_assert (cie_table
->num_entries
== 0);
1708 p_cie
= bsearch (&cie_pointer
, cie_table
->entries
, cie_table
->num_entries
,
1709 sizeof (cie_table
->entries
[0]), bsearch_cie_cmp
);
1715 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1717 add_cie (struct dwarf2_cie_table
*cie_table
, struct dwarf2_cie
*cie
)
1719 const int n
= cie_table
->num_entries
;
1722 || cie_table
->entries
[n
- 1]->cie_pointer
< cie
->cie_pointer
);
1724 cie_table
->entries
=
1725 xrealloc (cie_table
->entries
, (n
+ 1) * sizeof (cie_table
->entries
[0]));
1726 cie_table
->entries
[n
] = cie
;
1727 cie_table
->num_entries
= n
+ 1;
1731 bsearch_fde_cmp (const void *key
, const void *element
)
1733 CORE_ADDR seek_pc
= *(CORE_ADDR
*) key
;
1734 struct dwarf2_fde
*fde
= *(struct dwarf2_fde
**) element
;
1736 if (seek_pc
< fde
->initial_location
)
1738 if (seek_pc
< fde
->initial_location
+ fde
->address_range
)
1743 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1744 inital location associated with it into *PC. */
1746 static struct dwarf2_fde
*
1747 dwarf2_frame_find_fde (CORE_ADDR
*pc
, CORE_ADDR
*out_offset
)
1749 struct objfile
*objfile
;
1751 ALL_OBJFILES (objfile
)
1753 struct dwarf2_fde_table
*fde_table
;
1754 struct dwarf2_fde
**p_fde
;
1758 fde_table
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1759 if (fde_table
== NULL
)
1761 dwarf2_build_frame_info (objfile
);
1762 fde_table
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1764 gdb_assert (fde_table
!= NULL
);
1766 if (fde_table
->num_entries
== 0)
1769 gdb_assert (objfile
->section_offsets
);
1770 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1772 gdb_assert (fde_table
->num_entries
> 0);
1773 if (*pc
< offset
+ fde_table
->entries
[0]->initial_location
)
1776 seek_pc
= *pc
- offset
;
1777 p_fde
= bsearch (&seek_pc
, fde_table
->entries
, fde_table
->num_entries
,
1778 sizeof (fde_table
->entries
[0]), bsearch_fde_cmp
);
1781 *pc
= (*p_fde
)->initial_location
+ offset
;
1783 *out_offset
= offset
;
1790 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1792 add_fde (struct dwarf2_fde_table
*fde_table
, struct dwarf2_fde
*fde
)
1794 if (fde
->address_range
== 0)
1795 /* Discard useless FDEs. */
1798 fde_table
->num_entries
+= 1;
1799 fde_table
->entries
=
1800 xrealloc (fde_table
->entries
,
1801 fde_table
->num_entries
* sizeof (fde_table
->entries
[0]));
1802 fde_table
->entries
[fde_table
->num_entries
- 1] = fde
;
1805 #ifdef CC_HAS_LONG_LONG
1806 #define DW64_CIE_ID 0xffffffffffffffffULL
1808 #define DW64_CIE_ID ~0
1811 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1816 EH_CIE_TYPE_ID
= 1 << 0,
1817 EH_FDE_TYPE_ID
= 1 << 1,
1818 EH_CIE_OR_FDE_TYPE_ID
= EH_CIE_TYPE_ID
| EH_FDE_TYPE_ID
1821 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1823 struct dwarf2_cie_table
*cie_table
,
1824 struct dwarf2_fde_table
*fde_table
,
1825 enum eh_frame_type entry_type
);
1827 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1828 Return NULL if invalid input, otherwise the next byte to be processed. */
1831 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
,
1832 struct dwarf2_cie_table
*cie_table
,
1833 struct dwarf2_fde_table
*fde_table
,
1834 enum eh_frame_type entry_type
)
1836 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1837 gdb_byte
*buf
, *end
;
1839 unsigned int bytes_read
;
1842 ULONGEST cie_pointer
;
1845 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1849 /* Are we still within the section? */
1850 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1856 /* Distinguish between 32 and 64-bit encoded frame info. */
1857 dwarf64_p
= (bytes_read
== 12);
1859 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1863 cie_id
= DW64_CIE_ID
;
1869 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1874 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1878 if (cie_pointer
== cie_id
)
1880 /* This is a CIE. */
1881 struct dwarf2_cie
*cie
;
1883 unsigned int cie_version
;
1885 /* Check that a CIE was expected. */
1886 if ((entry_type
& EH_CIE_TYPE_ID
) == 0)
1887 error (_("Found a CIE when not expecting it."));
1889 /* Record the offset into the .debug_frame section of this CIE. */
1890 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1892 /* Check whether we've already read it. */
1893 if (find_cie (cie_table
, cie_pointer
))
1896 cie
= (struct dwarf2_cie
*)
1897 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1898 sizeof (struct dwarf2_cie
));
1899 cie
->initial_instructions
= NULL
;
1900 cie
->cie_pointer
= cie_pointer
;
1902 /* The encoding for FDE's in a normal .debug_frame section
1903 depends on the target address size. */
1904 cie
->encoding
= DW_EH_PE_absptr
;
1906 /* We'll determine the final value later, but we need to
1907 initialize it conservatively. */
1908 cie
->signal_frame
= 0;
1910 /* Check version number. */
1911 cie_version
= read_1_byte (unit
->abfd
, buf
);
1912 if (cie_version
!= 1 && cie_version
!= 3 && cie_version
!= 4)
1914 cie
->version
= cie_version
;
1917 /* Interpret the interesting bits of the augmentation. */
1918 cie
->augmentation
= augmentation
= (char *) buf
;
1919 buf
+= (strlen (augmentation
) + 1);
1921 /* Ignore armcc augmentations. We only use them for quirks,
1922 and that doesn't happen until later. */
1923 if (strncmp (augmentation
, "armcc", 5) == 0)
1924 augmentation
+= strlen (augmentation
);
1926 /* The GCC 2.x "eh" augmentation has a pointer immediately
1927 following the augmentation string, so it must be handled
1929 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1932 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1936 if (cie
->version
>= 4)
1938 /* FIXME: check that this is the same as from the CU header. */
1939 cie
->addr_size
= read_1_byte (unit
->abfd
, buf
);
1941 cie
->segment_size
= read_1_byte (unit
->abfd
, buf
);
1946 cie
->addr_size
= gdbarch_dwarf2_addr_size (gdbarch
);
1947 cie
->segment_size
= 0;
1949 /* Address values in .eh_frame sections are defined to have the
1950 target's pointer size. Watchout: This breaks frame info for
1951 targets with pointer size < address size, unless a .debug_frame
1952 section exists as well. */
1954 cie
->ptr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1956 cie
->ptr_size
= cie
->addr_size
;
1958 cie
->code_alignment_factor
=
1959 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1962 cie
->data_alignment_factor
=
1963 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1966 if (cie_version
== 1)
1968 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1972 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1974 cie
->return_address_register
1975 = dwarf2_frame_adjust_regnum (gdbarch
,
1976 cie
->return_address_register
,
1981 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1982 if (cie
->saw_z_augmentation
)
1986 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1990 cie
->initial_instructions
= buf
+ length
;
1994 while (*augmentation
)
1996 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1997 if (*augmentation
== 'L')
2004 /* "R" indicates a byte indicating how FDE addresses are encoded. */
2005 else if (*augmentation
== 'R')
2007 cie
->encoding
= *buf
++;
2011 /* "P" indicates a personality routine in the CIE augmentation. */
2012 else if (*augmentation
== 'P')
2014 /* Skip. Avoid indirection since we throw away the result. */
2015 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
2016 read_encoded_value (unit
, encoding
, cie
->ptr_size
,
2017 buf
, &bytes_read
, 0);
2022 /* "S" indicates a signal frame, such that the return
2023 address must not be decremented to locate the call frame
2024 info for the previous frame; it might even be the first
2025 instruction of a function, so decrementing it would take
2026 us to a different function. */
2027 else if (*augmentation
== 'S')
2029 cie
->signal_frame
= 1;
2033 /* Otherwise we have an unknown augmentation. Assume that either
2034 there is no augmentation data, or we saw a 'z' prefix. */
2037 if (cie
->initial_instructions
)
2038 buf
= cie
->initial_instructions
;
2043 cie
->initial_instructions
= buf
;
2047 add_cie (cie_table
, cie
);
2051 /* This is a FDE. */
2052 struct dwarf2_fde
*fde
;
2054 /* Check that an FDE was expected. */
2055 if ((entry_type
& EH_FDE_TYPE_ID
) == 0)
2056 error (_("Found an FDE when not expecting it."));
2058 /* In an .eh_frame section, the CIE pointer is the delta between the
2059 address within the FDE where the CIE pointer is stored and the
2060 address of the CIE. Convert it to an offset into the .eh_frame
2064 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
2065 cie_pointer
-= (dwarf64_p
? 8 : 4);
2068 /* In either case, validate the result is still within the section. */
2069 if (cie_pointer
>= unit
->dwarf_frame_size
)
2072 fde
= (struct dwarf2_fde
*)
2073 obstack_alloc (&unit
->objfile
->objfile_obstack
,
2074 sizeof (struct dwarf2_fde
));
2075 fde
->cie
= find_cie (cie_table
, cie_pointer
);
2076 if (fde
->cie
== NULL
)
2078 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
2079 eh_frame_p
, cie_table
, fde_table
,
2081 fde
->cie
= find_cie (cie_table
, cie_pointer
);
2084 gdb_assert (fde
->cie
!= NULL
);
2086 fde
->initial_location
=
2087 read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->ptr_size
,
2088 buf
, &bytes_read
, 0);
2091 fde
->address_range
=
2092 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
2093 fde
->cie
->ptr_size
, buf
, &bytes_read
, 0);
2096 /* A 'z' augmentation in the CIE implies the presence of an
2097 augmentation field in the FDE as well. The only thing known
2098 to be in here at present is the LSDA entry for EH. So we
2099 can skip the whole thing. */
2100 if (fde
->cie
->saw_z_augmentation
)
2104 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
2105 buf
+= bytes_read
+ length
;
2110 fde
->instructions
= buf
;
2113 fde
->eh_frame_p
= eh_frame_p
;
2115 add_fde (fde_table
, fde
);
2121 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2122 expect an FDE or a CIE. */
2125 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
,
2126 struct dwarf2_cie_table
*cie_table
,
2127 struct dwarf2_fde_table
*fde_table
,
2128 enum eh_frame_type entry_type
)
2130 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
2132 ptrdiff_t start_offset
;
2136 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
,
2137 cie_table
, fde_table
, entry_type
);
2141 /* We have corrupt input data of some form. */
2143 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2144 and mismatches wrt padding and alignment of debug sections. */
2145 /* Note that there is no requirement in the standard for any
2146 alignment at all in the frame unwind sections. Testing for
2147 alignment before trying to interpret data would be incorrect.
2149 However, GCC traditionally arranged for frame sections to be
2150 sized such that the FDE length and CIE fields happen to be
2151 aligned (in theory, for performance). This, unfortunately,
2152 was done with .align directives, which had the side effect of
2153 forcing the section to be aligned by the linker.
2155 This becomes a problem when you have some other producer that
2156 creates frame sections that are not as strictly aligned. That
2157 produces a hole in the frame info that gets filled by the
2160 The GCC behaviour is arguably a bug, but it's effectively now
2161 part of the ABI, so we're now stuck with it, at least at the
2162 object file level. A smart linker may decide, in the process
2163 of compressing duplicate CIE information, that it can rewrite
2164 the entire output section without this extra padding. */
2166 start_offset
= start
- unit
->dwarf_frame_buffer
;
2167 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
2169 start
+= 4 - (start_offset
& 3);
2170 workaround
= ALIGN4
;
2173 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
2175 start
+= 8 - (start_offset
& 7);
2176 workaround
= ALIGN8
;
2180 /* Nothing left to try. Arrange to return as if we've consumed
2181 the entire input section. Hopefully we'll get valid info from
2182 the other of .debug_frame/.eh_frame. */
2184 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
2194 complaint (&symfile_complaints
, _("\
2195 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2196 unit
->dwarf_frame_section
->owner
->filename
,
2197 unit
->dwarf_frame_section
->name
);
2201 complaint (&symfile_complaints
, _("\
2202 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2203 unit
->dwarf_frame_section
->owner
->filename
,
2204 unit
->dwarf_frame_section
->name
);
2208 complaint (&symfile_complaints
,
2209 _("Corrupt data in %s:%s"),
2210 unit
->dwarf_frame_section
->owner
->filename
,
2211 unit
->dwarf_frame_section
->name
);
2219 qsort_fde_cmp (const void *a
, const void *b
)
2221 struct dwarf2_fde
*aa
= *(struct dwarf2_fde
**)a
;
2222 struct dwarf2_fde
*bb
= *(struct dwarf2_fde
**)b
;
2224 if (aa
->initial_location
== bb
->initial_location
)
2226 if (aa
->address_range
!= bb
->address_range
2227 && aa
->eh_frame_p
== 0 && bb
->eh_frame_p
== 0)
2228 /* Linker bug, e.g. gold/10400.
2229 Work around it by keeping stable sort order. */
2230 return (a
< b
) ? -1 : 1;
2232 /* Put eh_frame entries after debug_frame ones. */
2233 return aa
->eh_frame_p
- bb
->eh_frame_p
;
2236 return (aa
->initial_location
< bb
->initial_location
) ? -1 : 1;
2240 dwarf2_build_frame_info (struct objfile
*objfile
)
2242 struct comp_unit
*unit
;
2243 gdb_byte
*frame_ptr
;
2244 struct dwarf2_cie_table cie_table
;
2245 struct dwarf2_fde_table fde_table
;
2246 struct dwarf2_fde_table
*fde_table2
;
2247 volatile struct gdb_exception e
;
2249 cie_table
.num_entries
= 0;
2250 cie_table
.entries
= NULL
;
2252 fde_table
.num_entries
= 0;
2253 fde_table
.entries
= NULL
;
2255 /* Build a minimal decoding of the DWARF2 compilation unit. */
2256 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
2257 sizeof (struct comp_unit
));
2258 unit
->abfd
= objfile
->obfd
;
2259 unit
->objfile
= objfile
;
2263 if (objfile
->separate_debug_objfile_backlink
== NULL
)
2265 /* Do not read .eh_frame from separate file as they must be also
2266 present in the main file. */
2267 dwarf2_get_section_info (objfile
, DWARF2_EH_FRAME
,
2268 &unit
->dwarf_frame_section
,
2269 &unit
->dwarf_frame_buffer
,
2270 &unit
->dwarf_frame_size
);
2271 if (unit
->dwarf_frame_size
)
2273 asection
*got
, *txt
;
2275 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2276 that is used for the i386/amd64 target, which currently is
2277 the only target in GCC that supports/uses the
2278 DW_EH_PE_datarel encoding. */
2279 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2281 unit
->dbase
= got
->vma
;
2283 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2285 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2287 unit
->tbase
= txt
->vma
;
2289 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2291 frame_ptr
= unit
->dwarf_frame_buffer
;
2292 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2293 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1,
2294 &cie_table
, &fde_table
,
2295 EH_CIE_OR_FDE_TYPE_ID
);
2300 warning (_("skipping .eh_frame info of %s: %s"),
2301 objfile
->name
, e
.message
);
2303 if (fde_table
.num_entries
!= 0)
2305 xfree (fde_table
.entries
);
2306 fde_table
.entries
= NULL
;
2307 fde_table
.num_entries
= 0;
2309 /* The cie_table is discarded by the next if. */
2312 if (cie_table
.num_entries
!= 0)
2314 /* Reinit cie_table: debug_frame has different CIEs. */
2315 xfree (cie_table
.entries
);
2316 cie_table
.num_entries
= 0;
2317 cie_table
.entries
= NULL
;
2322 dwarf2_get_section_info (objfile
, DWARF2_DEBUG_FRAME
,
2323 &unit
->dwarf_frame_section
,
2324 &unit
->dwarf_frame_buffer
,
2325 &unit
->dwarf_frame_size
);
2326 if (unit
->dwarf_frame_size
)
2328 int num_old_fde_entries
= fde_table
.num_entries
;
2330 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2332 frame_ptr
= unit
->dwarf_frame_buffer
;
2333 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2334 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0,
2335 &cie_table
, &fde_table
,
2336 EH_CIE_OR_FDE_TYPE_ID
);
2340 warning (_("skipping .debug_frame info of %s: %s"),
2341 objfile
->name
, e
.message
);
2343 if (fde_table
.num_entries
!= 0)
2345 fde_table
.num_entries
= num_old_fde_entries
;
2346 if (num_old_fde_entries
== 0)
2348 xfree (fde_table
.entries
);
2349 fde_table
.entries
= NULL
;
2353 fde_table
.entries
= xrealloc (fde_table
.entries
,
2354 fde_table
.num_entries
*
2355 sizeof (fde_table
.entries
[0]));
2358 fde_table
.num_entries
= num_old_fde_entries
;
2359 /* The cie_table is discarded by the next if. */
2363 /* Discard the cie_table, it is no longer needed. */
2364 if (cie_table
.num_entries
!= 0)
2366 xfree (cie_table
.entries
);
2367 cie_table
.entries
= NULL
; /* Paranoia. */
2368 cie_table
.num_entries
= 0; /* Paranoia. */
2371 /* Copy fde_table to obstack: it is needed at runtime. */
2372 fde_table2
= (struct dwarf2_fde_table
*)
2373 obstack_alloc (&objfile
->objfile_obstack
, sizeof (*fde_table2
));
2375 if (fde_table
.num_entries
== 0)
2377 fde_table2
->entries
= NULL
;
2378 fde_table2
->num_entries
= 0;
2382 struct dwarf2_fde
*fde_prev
= NULL
;
2383 struct dwarf2_fde
*first_non_zero_fde
= NULL
;
2386 /* Prepare FDE table for lookups. */
2387 qsort (fde_table
.entries
, fde_table
.num_entries
,
2388 sizeof (fde_table
.entries
[0]), qsort_fde_cmp
);
2390 /* Check for leftovers from --gc-sections. The GNU linker sets
2391 the relevant symbols to zero, but doesn't zero the FDE *end*
2392 ranges because there's no relocation there. It's (offset,
2393 length), not (start, end). On targets where address zero is
2394 just another valid address this can be a problem, since the
2395 FDEs appear to be non-empty in the output --- we could pick
2396 out the wrong FDE. To work around this, when overlaps are
2397 detected, we prefer FDEs that do not start at zero.
2399 Start by finding the first FDE with non-zero start. Below
2400 we'll discard all FDEs that start at zero and overlap this
2402 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2404 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2406 if (fde
->initial_location
!= 0)
2408 first_non_zero_fde
= fde
;
2413 /* Since we'll be doing bsearch, squeeze out identical (except
2414 for eh_frame_p) fde entries so bsearch result is predictable.
2415 Also discard leftovers from --gc-sections. */
2416 fde_table2
->num_entries
= 0;
2417 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2419 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2421 if (fde
->initial_location
== 0
2422 && first_non_zero_fde
!= NULL
2423 && (first_non_zero_fde
->initial_location
2424 < fde
->initial_location
+ fde
->address_range
))
2427 if (fde_prev
!= NULL
2428 && fde_prev
->initial_location
== fde
->initial_location
)
2431 obstack_grow (&objfile
->objfile_obstack
, &fde_table
.entries
[i
],
2432 sizeof (fde_table
.entries
[0]));
2433 ++fde_table2
->num_entries
;
2436 fde_table2
->entries
= obstack_finish (&objfile
->objfile_obstack
);
2438 /* Discard the original fde_table. */
2439 xfree (fde_table
.entries
);
2442 set_objfile_data (objfile
, dwarf2_frame_objfile_data
, fde_table2
);
2445 /* Provide a prototype to silence -Wmissing-prototypes. */
2446 void _initialize_dwarf2_frame (void);
2449 _initialize_dwarf2_frame (void)
2451 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2452 dwarf2_frame_objfile_data
= register_objfile_data ();