1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003-2016 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"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
36 #include "complaints.h"
37 #include "dwarf2-frame.h"
39 #include "dwarf2loc.h"
40 #include "dwarf2-frame-tailcall.h"
44 /* Call Frame Information (CFI). */
46 /* Common Information Entry (CIE). */
50 /* Computation Unit for this CIE. */
51 struct comp_unit
*unit
;
53 /* Offset into the .debug_frame section where this CIE was found.
54 Used to identify this CIE. */
57 /* Constant that is factored out of all advance location
59 ULONGEST code_alignment_factor
;
61 /* Constants that is factored out of all offset instructions. */
62 LONGEST data_alignment_factor
;
64 /* Return address column. */
65 ULONGEST return_address_register
;
67 /* Instruction sequence to initialize a register set. */
68 const gdb_byte
*initial_instructions
;
71 /* Saved augmentation, in case it's needed later. */
74 /* Encoding of addresses. */
77 /* Target address size in bytes. */
80 /* Target pointer size in bytes. */
83 /* True if a 'z' augmentation existed. */
84 unsigned char saw_z_augmentation
;
86 /* True if an 'S' augmentation existed. */
87 unsigned char signal_frame
;
89 /* The version recorded in the CIE. */
90 unsigned char version
;
92 /* The segment size. */
93 unsigned char segment_size
;
96 struct dwarf2_cie_table
99 struct dwarf2_cie
**entries
;
102 /* Frame Description Entry (FDE). */
106 /* CIE for this FDE. */
107 struct dwarf2_cie
*cie
;
109 /* First location associated with this FDE. */
110 CORE_ADDR initial_location
;
112 /* Number of bytes of program instructions described by this FDE. */
113 CORE_ADDR address_range
;
115 /* Instruction sequence. */
116 const gdb_byte
*instructions
;
119 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
121 unsigned char eh_frame_p
;
124 struct dwarf2_fde_table
127 struct dwarf2_fde
**entries
;
130 /* A minimal decoding of DWARF2 compilation units. We only decode
131 what's needed to get to the call frame information. */
135 /* Keep the bfd convenient. */
138 struct objfile
*objfile
;
140 /* Pointer to the .debug_frame section loaded into memory. */
141 const gdb_byte
*dwarf_frame_buffer
;
143 /* Length of the loaded .debug_frame section. */
144 bfd_size_type dwarf_frame_size
;
146 /* Pointer to the .debug_frame section. */
147 asection
*dwarf_frame_section
;
149 /* Base for DW_EH_PE_datarel encodings. */
152 /* Base for DW_EH_PE_textrel encodings. */
156 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
,
157 CORE_ADDR
*out_offset
);
159 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
162 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
163 int ptr_len
, const gdb_byte
*buf
,
164 unsigned int *bytes_read_ptr
,
165 CORE_ADDR func_base
);
175 struct dwarf2_frame_state_reg_info
177 struct dwarf2_frame_state_reg
*reg
;
182 enum cfa_how_kind cfa_how
;
183 const gdb_byte
*cfa_exp
;
185 /* Used to implement DW_CFA_remember_state. */
186 struct dwarf2_frame_state_reg_info
*prev
;
189 /* Structure describing a frame state. */
191 struct dwarf2_frame_state
193 /* Each register save state can be described in terms of a CFA slot,
194 another register, or a location expression. */
195 struct dwarf2_frame_state_reg_info regs
;
197 /* The PC described by the current frame state. */
200 /* Initial register set from the CIE.
201 Used to implement DW_CFA_restore. */
202 struct dwarf2_frame_state_reg_info initial
;
204 /* The information we care about from the CIE. */
207 ULONGEST retaddr_column
;
209 /* Flags for known producer quirks. */
211 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
212 and DW_CFA_def_cfa_offset takes a factored offset. */
213 int armcc_cfa_offsets_sf
;
215 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
216 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
217 int armcc_cfa_offsets_reversed
;
220 /* Store the length the expression for the CFA in the `cfa_reg' field,
221 which is unused in that case. */
222 #define cfa_exp_len cfa_reg
224 /* Assert that the register set RS is large enough to store gdbarch_num_regs
225 columns. If necessary, enlarge the register set. */
228 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
231 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
233 if (num_regs
<= rs
->num_regs
)
236 rs
->reg
= (struct dwarf2_frame_state_reg
*)
237 xrealloc (rs
->reg
, num_regs
* size
);
239 /* Initialize newly allocated registers. */
240 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
241 rs
->num_regs
= num_regs
;
244 /* Copy the register columns in register set RS into newly allocated
245 memory and return a pointer to this newly created copy. */
247 static struct dwarf2_frame_state_reg
*
248 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
250 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
251 struct dwarf2_frame_state_reg
*reg
;
253 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
254 memcpy (reg
, rs
->reg
, size
);
259 /* Release the memory allocated to register set RS. */
262 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
266 dwarf2_frame_state_free_regs (rs
->prev
);
273 /* Release the memory allocated to the frame state FS. */
276 dwarf2_frame_state_free (void *p
)
278 struct dwarf2_frame_state
*fs
= (struct dwarf2_frame_state
*) p
;
280 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
281 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
282 xfree (fs
->initial
.reg
);
283 xfree (fs
->regs
.reg
);
288 /* Helper functions for execute_stack_op. */
291 read_addr_from_reg (struct frame_info
*this_frame
, int reg
)
293 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
294 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
296 return address_from_register (regnum
, this_frame
);
299 /* Execute the required actions for both the DW_CFA_restore and
300 DW_CFA_restore_extended instructions. */
302 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
303 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
307 gdb_assert (fs
->initial
.reg
);
308 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
309 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
311 /* Check if this register was explicitly initialized in the
312 CIE initial instructions. If not, default the rule to
314 if (reg
< fs
->initial
.num_regs
)
315 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
317 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
319 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
321 int regnum
= dwarf_reg_to_regnum (gdbarch
, reg
);
323 complaint (&symfile_complaints
, _("\
324 incomplete CFI data; DW_CFA_restore unspecified\n\
325 register %s (#%d) at %s"),
326 gdbarch_register_name (gdbarch
, regnum
), regnum
,
327 paddress (gdbarch
, fs
->pc
));
331 class dwarf_expr_executor
: public dwarf_expr_context
335 struct frame_info
*this_frame
;
337 CORE_ADDR
read_addr_from_reg (int reg
) OVERRIDE
339 return ::read_addr_from_reg (this_frame
, reg
);
342 struct value
*get_reg_value (struct type
*type
, int reg
) OVERRIDE
344 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
345 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
347 return value_from_register (type
, regnum
, this_frame
);
350 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) OVERRIDE
352 read_memory (addr
, buf
, len
);
355 void get_frame_base (const gdb_byte
**start
, size_t *length
) OVERRIDE
357 invalid ("DW_OP_fbreg");
360 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
361 union call_site_parameter_u kind_u
,
362 int deref_size
) OVERRIDE
364 invalid ("DW_OP_GNU_entry_value");
367 CORE_ADDR
get_object_address () OVERRIDE
369 invalid ("DW_OP_push_object_address");
372 CORE_ADDR
get_frame_cfa () OVERRIDE
374 invalid ("DW_OP_call_frame_cfa");
377 CORE_ADDR
get_tls_address (CORE_ADDR offset
) OVERRIDE
379 invalid ("DW_OP_form_tls_address");
382 void dwarf_call (cu_offset die_offset
) OVERRIDE
384 invalid ("DW_OP_call*");
387 CORE_ADDR
get_addr_index (unsigned int index
)
389 invalid ("DW_OP_GNU_addr_index");
394 void invalid (const char *op
) ATTRIBUTE_NORETURN
396 error (_("%s is invalid in this context"), op
);
401 execute_stack_op (const gdb_byte
*exp
, ULONGEST len
, int addr_size
,
402 CORE_ADDR offset
, struct frame_info
*this_frame
,
403 CORE_ADDR initial
, int initial_in_stack_memory
)
406 struct cleanup
*old_chain
;
408 dwarf_expr_executor ctx
;
409 old_chain
= make_cleanup_value_free_to_mark (value_mark ());
411 ctx
.this_frame
= this_frame
;
412 ctx
.gdbarch
= get_frame_arch (this_frame
);
413 ctx
.addr_size
= addr_size
;
414 ctx
.ref_addr_size
= -1;
417 ctx
.push_address (initial
, initial_in_stack_memory
);
420 if (ctx
.location
== DWARF_VALUE_MEMORY
)
421 result
= ctx
.fetch_address (0);
422 else if (ctx
.location
== DWARF_VALUE_REGISTER
)
423 result
= ctx
.read_addr_from_reg (value_as_long (ctx
.fetch (0)));
426 /* This is actually invalid DWARF, but if we ever do run across
427 it somehow, we might as well support it. So, instead, report
428 it as unimplemented. */
430 Not implemented: computing unwound register using explicit value operator"));
433 do_cleanups (old_chain
);
439 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
440 PC. Modify FS state accordingly. Return current INSN_PTR where the
441 execution has stopped, one can resume it on the next call. */
443 static const gdb_byte
*
444 execute_cfa_program (struct dwarf2_fde
*fde
, const gdb_byte
*insn_ptr
,
445 const gdb_byte
*insn_end
, struct gdbarch
*gdbarch
,
446 CORE_ADDR pc
, struct dwarf2_frame_state
*fs
)
448 int eh_frame_p
= fde
->eh_frame_p
;
449 unsigned int bytes_read
;
450 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
452 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
454 gdb_byte insn
= *insn_ptr
++;
458 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
459 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
460 else if ((insn
& 0xc0) == DW_CFA_offset
)
463 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
464 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
465 offset
= utmp
* fs
->data_align
;
466 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
467 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
468 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
470 else if ((insn
& 0xc0) == DW_CFA_restore
)
473 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
480 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
481 fde
->cie
->ptr_size
, insn_ptr
,
482 &bytes_read
, fde
->initial_location
);
483 /* Apply the objfile offset for relocatable objects. */
484 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
485 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
486 insn_ptr
+= bytes_read
;
489 case DW_CFA_advance_loc1
:
490 utmp
= extract_unsigned_integer (insn_ptr
, 1, byte_order
);
491 fs
->pc
+= utmp
* fs
->code_align
;
494 case DW_CFA_advance_loc2
:
495 utmp
= extract_unsigned_integer (insn_ptr
, 2, byte_order
);
496 fs
->pc
+= utmp
* fs
->code_align
;
499 case DW_CFA_advance_loc4
:
500 utmp
= extract_unsigned_integer (insn_ptr
, 4, byte_order
);
501 fs
->pc
+= utmp
* fs
->code_align
;
505 case DW_CFA_offset_extended
:
506 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
507 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
508 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
509 offset
= utmp
* fs
->data_align
;
510 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
511 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
512 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
515 case DW_CFA_restore_extended
:
516 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
517 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
520 case DW_CFA_undefined
:
521 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
522 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
523 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
524 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
527 case DW_CFA_same_value
:
528 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
529 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
530 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
531 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
534 case DW_CFA_register
:
535 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
536 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
537 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
538 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
539 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
540 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
541 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
544 case DW_CFA_remember_state
:
546 struct dwarf2_frame_state_reg_info
*new_rs
;
548 new_rs
= XNEW (struct dwarf2_frame_state_reg_info
);
550 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
551 fs
->regs
.prev
= new_rs
;
555 case DW_CFA_restore_state
:
557 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
561 complaint (&symfile_complaints
, _("\
562 bad CFI data; mismatched DW_CFA_restore_state at %s"),
563 paddress (gdbarch
, fs
->pc
));
567 xfree (fs
->regs
.reg
);
575 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
576 fs
->regs
.cfa_reg
= reg
;
577 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
579 if (fs
->armcc_cfa_offsets_sf
)
580 utmp
*= fs
->data_align
;
582 fs
->regs
.cfa_offset
= utmp
;
583 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
586 case DW_CFA_def_cfa_register
:
587 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
588 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
590 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
593 case DW_CFA_def_cfa_offset
:
594 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
596 if (fs
->armcc_cfa_offsets_sf
)
597 utmp
*= fs
->data_align
;
599 fs
->regs
.cfa_offset
= utmp
;
600 /* cfa_how deliberately not set. */
606 case DW_CFA_def_cfa_expression
:
607 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
608 fs
->regs
.cfa_exp_len
= utmp
;
609 fs
->regs
.cfa_exp
= insn_ptr
;
610 fs
->regs
.cfa_how
= CFA_EXP
;
611 insn_ptr
+= fs
->regs
.cfa_exp_len
;
614 case DW_CFA_expression
:
615 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
616 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
617 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
618 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
619 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
620 fs
->regs
.reg
[reg
].exp_len
= utmp
;
621 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
625 case DW_CFA_offset_extended_sf
:
626 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
627 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
628 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
629 offset
*= fs
->data_align
;
630 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
631 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
632 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
635 case DW_CFA_val_offset
:
636 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
637 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
638 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
639 offset
= utmp
* fs
->data_align
;
640 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
641 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
644 case DW_CFA_val_offset_sf
:
645 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
646 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
647 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
648 offset
*= fs
->data_align
;
649 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
650 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
653 case DW_CFA_val_expression
:
654 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
655 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
656 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
657 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
658 fs
->regs
.reg
[reg
].exp_len
= utmp
;
659 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
663 case DW_CFA_def_cfa_sf
:
664 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
665 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
667 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
668 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
669 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
672 case DW_CFA_def_cfa_offset_sf
:
673 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
674 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
675 /* cfa_how deliberately not set. */
678 case DW_CFA_GNU_window_save
:
679 /* This is SPARC-specific code, and contains hard-coded
680 constants for the register numbering scheme used by
681 GCC. Rather than having a architecture-specific
682 operation that's only ever used by a single
683 architecture, we provide the implementation here.
684 Incidentally that's what GCC does too in its
687 int size
= register_size (gdbarch
, 0);
689 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
690 for (reg
= 8; reg
< 16; reg
++)
692 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
693 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
695 for (reg
= 16; reg
< 32; reg
++)
697 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
698 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
703 case DW_CFA_GNU_args_size
:
705 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
708 case DW_CFA_GNU_negative_offset_extended
:
709 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
710 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
711 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
712 offset
= utmp
* fs
->data_align
;
713 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
714 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
715 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
719 internal_error (__FILE__
, __LINE__
,
720 _("Unknown CFI encountered."));
725 if (fs
->initial
.reg
== NULL
)
727 /* Don't allow remember/restore between CIE and FDE programs. */
728 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
729 fs
->regs
.prev
= NULL
;
736 /* Architecture-specific operations. */
738 /* Per-architecture data key. */
739 static struct gdbarch_data
*dwarf2_frame_data
;
741 struct dwarf2_frame_ops
743 /* Pre-initialize the register state REG for register REGNUM. */
744 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
745 struct frame_info
*);
747 /* Check whether the THIS_FRAME is a signal trampoline. */
748 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
750 /* Convert .eh_frame register number to DWARF register number, or
751 adjust .debug_frame register number. */
752 int (*adjust_regnum
) (struct gdbarch
*, int, int);
755 /* Default architecture-specific register state initialization
759 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
760 struct dwarf2_frame_state_reg
*reg
,
761 struct frame_info
*this_frame
)
763 /* If we have a register that acts as a program counter, mark it as
764 a destination for the return address. If we have a register that
765 serves as the stack pointer, arrange for it to be filled with the
766 call frame address (CFA). The other registers are marked as
769 We copy the return address to the program counter, since many
770 parts in GDB assume that it is possible to get the return address
771 by unwinding the program counter register. However, on ISA's
772 with a dedicated return address register, the CFI usually only
773 contains information to unwind that return address register.
775 The reason we're treating the stack pointer special here is
776 because in many cases GCC doesn't emit CFI for the stack pointer
777 and implicitly assumes that it is equal to the CFA. This makes
778 some sense since the DWARF specification (version 3, draft 8,
781 "Typically, the CFA is defined to be the value of the stack
782 pointer at the call site in the previous frame (which may be
783 different from its value on entry to the current frame)."
785 However, this isn't true for all platforms supported by GCC
786 (e.g. IBM S/390 and zSeries). Those architectures should provide
787 their own architecture-specific initialization function. */
789 if (regnum
== gdbarch_pc_regnum (gdbarch
))
790 reg
->how
= DWARF2_FRAME_REG_RA
;
791 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
792 reg
->how
= DWARF2_FRAME_REG_CFA
;
795 /* Return a default for the architecture-specific operations. */
798 dwarf2_frame_init (struct obstack
*obstack
)
800 struct dwarf2_frame_ops
*ops
;
802 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
803 ops
->init_reg
= dwarf2_frame_default_init_reg
;
807 /* Set the architecture-specific register state initialization
808 function for GDBARCH to INIT_REG. */
811 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
812 void (*init_reg
) (struct gdbarch
*, int,
813 struct dwarf2_frame_state_reg
*,
814 struct frame_info
*))
816 struct dwarf2_frame_ops
*ops
817 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
819 ops
->init_reg
= init_reg
;
822 /* Pre-initialize the register state REG for register REGNUM. */
825 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
826 struct dwarf2_frame_state_reg
*reg
,
827 struct frame_info
*this_frame
)
829 struct dwarf2_frame_ops
*ops
830 = (struct dwarf2_frame_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
844 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
846 ops
->signal_frame_p
= signal_frame_p
;
849 /* Query the architecture-specific signal frame recognizer for
853 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
854 struct frame_info
*this_frame
)
856 struct dwarf2_frame_ops
*ops
857 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
859 if (ops
->signal_frame_p
== NULL
)
861 return ops
->signal_frame_p (gdbarch
, this_frame
);
864 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
868 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
869 int (*adjust_regnum
) (struct gdbarch
*,
872 struct dwarf2_frame_ops
*ops
873 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
875 ops
->adjust_regnum
= adjust_regnum
;
878 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
882 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
,
883 int regnum
, int eh_frame_p
)
885 struct dwarf2_frame_ops
*ops
886 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
888 if (ops
->adjust_regnum
== NULL
)
890 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
894 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
895 struct dwarf2_fde
*fde
)
897 struct compunit_symtab
*cust
;
899 cust
= find_pc_compunit_symtab (fs
->pc
);
903 if (producer_is_realview (COMPUNIT_PRODUCER (cust
)))
905 if (fde
->cie
->version
== 1)
906 fs
->armcc_cfa_offsets_sf
= 1;
908 if (fde
->cie
->version
== 1)
909 fs
->armcc_cfa_offsets_reversed
= 1;
911 /* The reversed offset problem is present in some compilers
912 using DWARF3, but it was eventually fixed. Check the ARM
913 defined augmentations, which are in the format "armcc" followed
914 by a list of one-character options. The "+" option means
915 this problem is fixed (no quirk needed). If the armcc
916 augmentation is missing, the quirk is needed. */
917 if (fde
->cie
->version
== 3
918 && (!startswith (fde
->cie
->augmentation
, "armcc")
919 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
920 fs
->armcc_cfa_offsets_reversed
= 1;
927 /* See dwarf2-frame.h. */
930 dwarf2_fetch_cfa_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
931 struct dwarf2_per_cu_data
*data
,
932 int *regnum_out
, LONGEST
*offset_out
,
933 CORE_ADDR
*text_offset_out
,
934 const gdb_byte
**cfa_start_out
,
935 const gdb_byte
**cfa_end_out
)
937 struct dwarf2_fde
*fde
;
938 CORE_ADDR text_offset
;
939 struct dwarf2_frame_state fs
;
941 memset (&fs
, 0, sizeof (struct dwarf2_frame_state
));
945 /* Find the correct FDE. */
946 fde
= dwarf2_frame_find_fde (&fs
.pc
, &text_offset
);
948 error (_("Could not compute CFA; needed to translate this expression"));
950 /* Extract any interesting information from the CIE. */
951 fs
.data_align
= fde
->cie
->data_alignment_factor
;
952 fs
.code_align
= fde
->cie
->code_alignment_factor
;
953 fs
.retaddr_column
= fde
->cie
->return_address_register
;
955 /* Check for "quirks" - known bugs in producers. */
956 dwarf2_frame_find_quirks (&fs
, fde
);
958 /* First decode all the insns in the CIE. */
959 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
960 fde
->cie
->end
, gdbarch
, pc
, &fs
);
962 /* Save the initialized register set. */
963 fs
.initial
= fs
.regs
;
964 fs
.initial
.reg
= dwarf2_frame_state_copy_regs (&fs
.regs
);
966 /* Then decode the insns in the FDE up to our target PC. */
967 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
, pc
, &fs
);
969 /* Calculate the CFA. */
970 switch (fs
.regs
.cfa_how
)
974 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, fs
.regs
.cfa_reg
);
976 *regnum_out
= regnum
;
977 if (fs
.armcc_cfa_offsets_reversed
)
978 *offset_out
= -fs
.regs
.cfa_offset
;
980 *offset_out
= fs
.regs
.cfa_offset
;
985 *text_offset_out
= text_offset
;
986 *cfa_start_out
= fs
.regs
.cfa_exp
;
987 *cfa_end_out
= fs
.regs
.cfa_exp
+ fs
.regs
.cfa_exp_len
;
991 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
996 struct dwarf2_frame_cache
998 /* DWARF Call Frame Address. */
1001 /* Set if the return address column was marked as unavailable
1002 (required non-collected memory or registers to compute). */
1003 int unavailable_retaddr
;
1005 /* Set if the return address column was marked as undefined. */
1006 int undefined_retaddr
;
1008 /* Saved registers, indexed by GDB register number, not by DWARF
1010 struct dwarf2_frame_state_reg
*reg
;
1012 /* Return address register. */
1013 struct dwarf2_frame_state_reg retaddr_reg
;
1015 /* Target address size in bytes. */
1018 /* The .text offset. */
1019 CORE_ADDR text_offset
;
1021 /* True if we already checked whether this frame is the bottom frame
1022 of a virtual tail call frame chain. */
1023 int checked_tailcall_bottom
;
1025 /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
1026 sequence. If NULL then it is a normal case with no TAILCALL_FRAME
1027 involved. Non-bottom frames of a virtual tail call frames chain use
1028 dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
1030 void *tailcall_cache
;
1032 /* The number of bytes to subtract from TAILCALL_FRAME frames frame
1033 base to get the SP, to simulate the return address pushed on the
1035 LONGEST entry_cfa_sp_offset
;
1036 int entry_cfa_sp_offset_p
;
1039 /* A cleanup that sets a pointer to NULL. */
1042 clear_pointer_cleanup (void *arg
)
1044 void **ptr
= (void **) arg
;
1049 static struct dwarf2_frame_cache
*
1050 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1052 struct cleanup
*reset_cache_cleanup
, *old_chain
;
1053 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1054 const int num_regs
= gdbarch_num_regs (gdbarch
)
1055 + gdbarch_num_pseudo_regs (gdbarch
);
1056 struct dwarf2_frame_cache
*cache
;
1057 struct dwarf2_frame_state
*fs
;
1058 struct dwarf2_fde
*fde
;
1060 const gdb_byte
*instr
;
1063 return (struct dwarf2_frame_cache
*) *this_cache
;
1065 /* Allocate a new cache. */
1066 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
1067 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
1068 *this_cache
= cache
;
1069 reset_cache_cleanup
= make_cleanup (clear_pointer_cleanup
, this_cache
);
1071 /* Allocate and initialize the frame state. */
1072 fs
= XCNEW (struct dwarf2_frame_state
);
1073 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
1077 Note that if the next frame is never supposed to return (i.e. a call
1078 to abort), the compiler might optimize away the instruction at
1079 its return address. As a result the return address will
1080 point at some random instruction, and the CFI for that
1081 instruction is probably worthless to us. GCC's unwinder solves
1082 this problem by substracting 1 from the return address to get an
1083 address in the middle of a presumed call instruction (or the
1084 instruction in the associated delay slot). This should only be
1085 done for "normal" frames and not for resume-type frames (signal
1086 handlers, sentinel frames, dummy frames). The function
1087 get_frame_address_in_block does just this. It's not clear how
1088 reliable the method is though; there is the potential for the
1089 register state pre-call being different to that on return. */
1090 fs
->pc
= get_frame_address_in_block (this_frame
);
1092 /* Find the correct FDE. */
1093 fde
= dwarf2_frame_find_fde (&fs
->pc
, &cache
->text_offset
);
1094 gdb_assert (fde
!= NULL
);
1096 /* Extract any interesting information from the CIE. */
1097 fs
->data_align
= fde
->cie
->data_alignment_factor
;
1098 fs
->code_align
= fde
->cie
->code_alignment_factor
;
1099 fs
->retaddr_column
= fde
->cie
->return_address_register
;
1100 cache
->addr_size
= fde
->cie
->addr_size
;
1102 /* Check for "quirks" - known bugs in producers. */
1103 dwarf2_frame_find_quirks (fs
, fde
);
1105 /* First decode all the insns in the CIE. */
1106 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
1107 fde
->cie
->end
, gdbarch
,
1108 get_frame_address_in_block (this_frame
), fs
);
1110 /* Save the initialized register set. */
1111 fs
->initial
= fs
->regs
;
1112 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
1114 if (get_frame_func_if_available (this_frame
, &entry_pc
))
1116 /* Decode the insns in the FDE up to the entry PC. */
1117 instr
= execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
,
1120 if (fs
->regs
.cfa_how
== CFA_REG_OFFSET
1121 && (dwarf_reg_to_regnum (gdbarch
, fs
->regs
.cfa_reg
)
1122 == gdbarch_sp_regnum (gdbarch
)))
1124 cache
->entry_cfa_sp_offset
= fs
->regs
.cfa_offset
;
1125 cache
->entry_cfa_sp_offset_p
= 1;
1129 instr
= fde
->instructions
;
1131 /* Then decode the insns in the FDE up to our target PC. */
1132 execute_cfa_program (fde
, instr
, fde
->end
, gdbarch
,
1133 get_frame_address_in_block (this_frame
), fs
);
1137 /* Calculate the CFA. */
1138 switch (fs
->regs
.cfa_how
)
1140 case CFA_REG_OFFSET
:
1141 cache
->cfa
= read_addr_from_reg (this_frame
, fs
->regs
.cfa_reg
);
1142 if (fs
->armcc_cfa_offsets_reversed
)
1143 cache
->cfa
-= fs
->regs
.cfa_offset
;
1145 cache
->cfa
+= fs
->regs
.cfa_offset
;
1150 execute_stack_op (fs
->regs
.cfa_exp
, fs
->regs
.cfa_exp_len
,
1151 cache
->addr_size
, cache
->text_offset
,
1156 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
1159 CATCH (ex
, RETURN_MASK_ERROR
)
1161 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1163 cache
->unavailable_retaddr
= 1;
1164 do_cleanups (old_chain
);
1165 discard_cleanups (reset_cache_cleanup
);
1169 throw_exception (ex
);
1173 /* Initialize the register state. */
1177 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1178 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
1181 /* Go through the DWARF2 CFI generated table and save its register
1182 location information in the cache. Note that we don't skip the
1183 return address column; it's perfectly all right for it to
1184 correspond to a real register. */
1186 int column
; /* CFI speak for "register number". */
1188 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
1190 /* Use the GDB register number as the destination index. */
1191 int regnum
= dwarf_reg_to_regnum (gdbarch
, column
);
1193 /* Protect against a target returning a bad register. */
1194 if (regnum
< 0 || regnum
>= num_regs
)
1197 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1198 of all debug info registers. If it doesn't, complain (but
1199 not too loudly). It turns out that GCC assumes that an
1200 unspecified register implies "same value" when CFI (draft
1201 7) specifies nothing at all. Such a register could equally
1202 be interpreted as "undefined". Also note that this check
1203 isn't sufficient; it only checks that all registers in the
1204 range [0 .. max column] are specified, and won't detect
1205 problems when a debug info register falls outside of the
1206 table. We need a way of iterating through all the valid
1207 DWARF2 register numbers. */
1208 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1210 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1211 complaint (&symfile_complaints
, _("\
1212 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1213 gdbarch_register_name (gdbarch
, regnum
),
1214 paddress (gdbarch
, fs
->pc
));
1217 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1221 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1222 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1226 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1228 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1229 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1231 struct dwarf2_frame_state_reg
*retaddr_reg
=
1232 &fs
->regs
.reg
[fs
->retaddr_column
];
1234 /* It seems rather bizarre to specify an "empty" column as
1235 the return adress column. However, this is exactly
1236 what GCC does on some targets. It turns out that GCC
1237 assumes that the return address can be found in the
1238 register corresponding to the return address column.
1239 Incidentally, that's how we should treat a return
1240 address column specifying "same value" too. */
1241 if (fs
->retaddr_column
< fs
->regs
.num_regs
1242 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1243 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1245 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1246 cache
->reg
[regnum
] = *retaddr_reg
;
1248 cache
->retaddr_reg
= *retaddr_reg
;
1252 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1254 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1255 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1259 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1260 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1267 if (fs
->retaddr_column
< fs
->regs
.num_regs
1268 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1269 cache
->undefined_retaddr
= 1;
1271 do_cleanups (old_chain
);
1272 discard_cleanups (reset_cache_cleanup
);
1276 static enum unwind_stop_reason
1277 dwarf2_frame_unwind_stop_reason (struct frame_info
*this_frame
,
1280 struct dwarf2_frame_cache
*cache
1281 = dwarf2_frame_cache (this_frame
, this_cache
);
1283 if (cache
->unavailable_retaddr
)
1284 return UNWIND_UNAVAILABLE
;
1286 if (cache
->undefined_retaddr
)
1287 return UNWIND_OUTERMOST
;
1289 return UNWIND_NO_REASON
;
1293 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1294 struct frame_id
*this_id
)
1296 struct dwarf2_frame_cache
*cache
=
1297 dwarf2_frame_cache (this_frame
, this_cache
);
1299 if (cache
->unavailable_retaddr
)
1300 (*this_id
) = frame_id_build_unavailable_stack (get_frame_func (this_frame
));
1301 else if (cache
->undefined_retaddr
)
1304 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1307 static struct value
*
1308 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1311 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1312 struct dwarf2_frame_cache
*cache
=
1313 dwarf2_frame_cache (this_frame
, this_cache
);
1317 /* Check whether THIS_FRAME is the bottom frame of a virtual tail
1318 call frame chain. */
1319 if (!cache
->checked_tailcall_bottom
)
1321 cache
->checked_tailcall_bottom
= 1;
1322 dwarf2_tailcall_sniffer_first (this_frame
, &cache
->tailcall_cache
,
1323 (cache
->entry_cfa_sp_offset_p
1324 ? &cache
->entry_cfa_sp_offset
: NULL
));
1327 /* Non-bottom frames of a virtual tail call frames chain use
1328 dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1329 them. If dwarf2_tailcall_prev_register_first does not have specific value
1330 unwind the register, tail call frames are assumed to have the register set
1331 of the top caller. */
1332 if (cache
->tailcall_cache
)
1336 val
= dwarf2_tailcall_prev_register_first (this_frame
,
1337 &cache
->tailcall_cache
,
1343 switch (cache
->reg
[regnum
].how
)
1345 case DWARF2_FRAME_REG_UNDEFINED
:
1346 /* If CFI explicitly specified that the value isn't defined,
1347 mark it as optimized away; the value isn't available. */
1348 return frame_unwind_got_optimized (this_frame
, regnum
);
1350 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1351 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1352 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1354 case DWARF2_FRAME_REG_SAVED_REG
:
1355 realnum
= dwarf_reg_to_regnum_or_error
1356 (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1357 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1359 case DWARF2_FRAME_REG_SAVED_EXP
:
1360 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1361 cache
->reg
[regnum
].exp_len
,
1362 cache
->addr_size
, cache
->text_offset
,
1363 this_frame
, cache
->cfa
, 1);
1364 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1366 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1367 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1368 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1370 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1371 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1372 cache
->reg
[regnum
].exp_len
,
1373 cache
->addr_size
, cache
->text_offset
,
1374 this_frame
, cache
->cfa
, 1);
1375 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1377 case DWARF2_FRAME_REG_UNSPECIFIED
:
1378 /* GCC, in its infinite wisdom decided to not provide unwind
1379 information for registers that are "same value". Since
1380 DWARF2 (3 draft 7) doesn't define such behavior, said
1381 registers are actually undefined (which is different to CFI
1382 "undefined"). Code above issues a complaint about this.
1383 Here just fudge the books, assume GCC, and that the value is
1384 more inner on the stack. */
1385 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1387 case DWARF2_FRAME_REG_SAME_VALUE
:
1388 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1390 case DWARF2_FRAME_REG_CFA
:
1391 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1393 case DWARF2_FRAME_REG_CFA_OFFSET
:
1394 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1395 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1397 case DWARF2_FRAME_REG_RA_OFFSET
:
1398 addr
= cache
->reg
[regnum
].loc
.offset
;
1399 regnum
= dwarf_reg_to_regnum_or_error
1400 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1401 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1402 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1404 case DWARF2_FRAME_REG_FN
:
1405 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1408 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1412 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1413 call frames chain. */
1416 dwarf2_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1418 struct dwarf2_frame_cache
*cache
= dwarf2_frame_cache (self
, &this_cache
);
1420 if (cache
->tailcall_cache
)
1421 dwarf2_tailcall_frame_unwind
.dealloc_cache (self
, cache
->tailcall_cache
);
1425 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1426 struct frame_info
*this_frame
, void **this_cache
)
1428 /* Grab an address that is guarenteed to reside somewhere within the
1429 function. get_frame_pc(), with a no-return next function, can
1430 end up returning something past the end of this function's body.
1431 If the frame we're sniffing for is a signal frame whose start
1432 address is placed on the stack by the OS, its FDE must
1433 extend one byte before its start address or we could potentially
1434 select the FDE of the previous function. */
1435 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1436 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
, NULL
);
1441 /* On some targets, signal trampolines may have unwind information.
1442 We need to recognize them so that we set the frame type
1445 if (fde
->cie
->signal_frame
1446 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1448 return self
->type
== SIGTRAMP_FRAME
;
1450 if (self
->type
!= NORMAL_FRAME
)
1456 static const struct frame_unwind dwarf2_frame_unwind
=
1459 dwarf2_frame_unwind_stop_reason
,
1460 dwarf2_frame_this_id
,
1461 dwarf2_frame_prev_register
,
1463 dwarf2_frame_sniffer
,
1464 dwarf2_frame_dealloc_cache
1467 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1470 dwarf2_frame_unwind_stop_reason
,
1471 dwarf2_frame_this_id
,
1472 dwarf2_frame_prev_register
,
1474 dwarf2_frame_sniffer
,
1476 /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1480 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1483 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1485 /* TAILCALL_FRAME must be first to find the record by
1486 dwarf2_tailcall_sniffer_first. */
1487 frame_unwind_append_unwinder (gdbarch
, &dwarf2_tailcall_frame_unwind
);
1489 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1490 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1494 /* There is no explicitly defined relationship between the CFA and the
1495 location of frame's local variables and arguments/parameters.
1496 Therefore, frame base methods on this page should probably only be
1497 used as a last resort, just to avoid printing total garbage as a
1498 response to the "info frame" command. */
1501 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1503 struct dwarf2_frame_cache
*cache
=
1504 dwarf2_frame_cache (this_frame
, this_cache
);
1509 static const struct frame_base dwarf2_frame_base
=
1511 &dwarf2_frame_unwind
,
1512 dwarf2_frame_base_address
,
1513 dwarf2_frame_base_address
,
1514 dwarf2_frame_base_address
1517 const struct frame_base
*
1518 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1520 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1522 if (dwarf2_frame_find_fde (&block_addr
, NULL
))
1523 return &dwarf2_frame_base
;
1528 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1529 the DWARF unwinder. This is used to implement
1530 DW_OP_call_frame_cfa. */
1533 dwarf2_frame_cfa (struct frame_info
*this_frame
)
1535 if (frame_unwinder_is (this_frame
, &record_btrace_tailcall_frame_unwind
)
1536 || frame_unwinder_is (this_frame
, &record_btrace_frame_unwind
))
1537 throw_error (NOT_AVAILABLE_ERROR
,
1538 _("cfa not available for record btrace target"));
1540 while (get_frame_type (this_frame
) == INLINE_FRAME
)
1541 this_frame
= get_prev_frame (this_frame
);
1542 if (get_frame_unwind_stop_reason (this_frame
) == UNWIND_UNAVAILABLE
)
1543 throw_error (NOT_AVAILABLE_ERROR
,
1544 _("can't compute CFA for this frame: "
1545 "required registers or memory are unavailable"));
1547 if (get_frame_id (this_frame
).stack_status
!= FID_STACK_VALID
)
1548 throw_error (NOT_AVAILABLE_ERROR
,
1549 _("can't compute CFA for this frame: "
1550 "frame base not available"));
1552 return get_frame_base (this_frame
);
1555 const struct objfile_data
*dwarf2_frame_objfile_data
;
1558 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
1560 return bfd_get_8 (abfd
, buf
);
1564 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
1566 return bfd_get_32 (abfd
, buf
);
1570 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
1572 return bfd_get_64 (abfd
, buf
);
1576 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
,
1577 unsigned int *bytes_read_ptr
)
1581 result
= bfd_get_32 (abfd
, buf
);
1582 if (result
== 0xffffffff)
1584 result
= bfd_get_64 (abfd
, buf
+ 4);
1585 *bytes_read_ptr
= 12;
1588 *bytes_read_ptr
= 4;
1594 /* Pointer encoding helper functions. */
1596 /* GCC supports exception handling based on DWARF2 CFI. However, for
1597 technical reasons, it encodes addresses in its FDE's in a different
1598 way. Several "pointer encodings" are supported. The encoding
1599 that's used for a particular FDE is determined by the 'R'
1600 augmentation in the associated CIE. The argument of this
1601 augmentation is a single byte.
1603 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1604 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1605 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1606 address should be interpreted (absolute, relative to the current
1607 position in the FDE, ...). Bit 7, indicates that the address
1608 should be dereferenced. */
1611 encoding_for_size (unsigned int size
)
1616 return DW_EH_PE_udata2
;
1618 return DW_EH_PE_udata4
;
1620 return DW_EH_PE_udata8
;
1622 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1627 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1628 int ptr_len
, const gdb_byte
*buf
,
1629 unsigned int *bytes_read_ptr
,
1630 CORE_ADDR func_base
)
1635 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1637 if (encoding
& DW_EH_PE_indirect
)
1638 internal_error (__FILE__
, __LINE__
,
1639 _("Unsupported encoding: DW_EH_PE_indirect"));
1641 *bytes_read_ptr
= 0;
1643 switch (encoding
& 0x70)
1645 case DW_EH_PE_absptr
:
1648 case DW_EH_PE_pcrel
:
1649 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1650 base
+= (buf
- unit
->dwarf_frame_buffer
);
1652 case DW_EH_PE_datarel
:
1655 case DW_EH_PE_textrel
:
1658 case DW_EH_PE_funcrel
:
1661 case DW_EH_PE_aligned
:
1663 offset
= buf
- unit
->dwarf_frame_buffer
;
1664 if ((offset
% ptr_len
) != 0)
1666 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1667 buf
+= *bytes_read_ptr
;
1671 internal_error (__FILE__
, __LINE__
,
1672 _("Invalid or unsupported encoding"));
1675 if ((encoding
& 0x07) == 0x00)
1677 encoding
|= encoding_for_size (ptr_len
);
1678 if (bfd_get_sign_extend_vma (unit
->abfd
))
1679 encoding
|= DW_EH_PE_signed
;
1682 switch (encoding
& 0x0f)
1684 case DW_EH_PE_uleb128
:
1687 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1689 *bytes_read_ptr
+= safe_read_uleb128 (buf
, end_buf
, &value
) - buf
;
1690 return base
+ value
;
1692 case DW_EH_PE_udata2
:
1693 *bytes_read_ptr
+= 2;
1694 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1695 case DW_EH_PE_udata4
:
1696 *bytes_read_ptr
+= 4;
1697 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1698 case DW_EH_PE_udata8
:
1699 *bytes_read_ptr
+= 8;
1700 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1701 case DW_EH_PE_sleb128
:
1704 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1706 *bytes_read_ptr
+= safe_read_sleb128 (buf
, end_buf
, &value
) - buf
;
1707 return base
+ value
;
1709 case DW_EH_PE_sdata2
:
1710 *bytes_read_ptr
+= 2;
1711 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1712 case DW_EH_PE_sdata4
:
1713 *bytes_read_ptr
+= 4;
1714 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1715 case DW_EH_PE_sdata8
:
1716 *bytes_read_ptr
+= 8;
1717 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1719 internal_error (__FILE__
, __LINE__
,
1720 _("Invalid or unsupported encoding"));
1726 bsearch_cie_cmp (const void *key
, const void *element
)
1728 ULONGEST cie_pointer
= *(ULONGEST
*) key
;
1729 struct dwarf2_cie
*cie
= *(struct dwarf2_cie
**) element
;
1731 if (cie_pointer
== cie
->cie_pointer
)
1734 return (cie_pointer
< cie
->cie_pointer
) ? -1 : 1;
1737 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1738 static struct dwarf2_cie
*
1739 find_cie (struct dwarf2_cie_table
*cie_table
, ULONGEST cie_pointer
)
1741 struct dwarf2_cie
**p_cie
;
1743 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1744 bsearch be non-NULL. */
1745 if (cie_table
->entries
== NULL
)
1747 gdb_assert (cie_table
->num_entries
== 0);
1751 p_cie
= ((struct dwarf2_cie
**)
1752 bsearch (&cie_pointer
, cie_table
->entries
, cie_table
->num_entries
,
1753 sizeof (cie_table
->entries
[0]), bsearch_cie_cmp
));
1759 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1761 add_cie (struct dwarf2_cie_table
*cie_table
, struct dwarf2_cie
*cie
)
1763 const int n
= cie_table
->num_entries
;
1766 || cie_table
->entries
[n
- 1]->cie_pointer
< cie
->cie_pointer
);
1769 = XRESIZEVEC (struct dwarf2_cie
*, cie_table
->entries
, n
+ 1);
1770 cie_table
->entries
[n
] = cie
;
1771 cie_table
->num_entries
= n
+ 1;
1775 bsearch_fde_cmp (const void *key
, const void *element
)
1777 CORE_ADDR seek_pc
= *(CORE_ADDR
*) key
;
1778 struct dwarf2_fde
*fde
= *(struct dwarf2_fde
**) element
;
1780 if (seek_pc
< fde
->initial_location
)
1782 if (seek_pc
< fde
->initial_location
+ fde
->address_range
)
1787 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1788 inital location associated with it into *PC. */
1790 static struct dwarf2_fde
*
1791 dwarf2_frame_find_fde (CORE_ADDR
*pc
, CORE_ADDR
*out_offset
)
1793 struct objfile
*objfile
;
1795 ALL_OBJFILES (objfile
)
1797 struct dwarf2_fde_table
*fde_table
;
1798 struct dwarf2_fde
**p_fde
;
1802 fde_table
= ((struct dwarf2_fde_table
*)
1803 objfile_data (objfile
, dwarf2_frame_objfile_data
));
1804 if (fde_table
== NULL
)
1806 dwarf2_build_frame_info (objfile
);
1807 fde_table
= ((struct dwarf2_fde_table
*)
1808 objfile_data (objfile
, dwarf2_frame_objfile_data
));
1810 gdb_assert (fde_table
!= NULL
);
1812 if (fde_table
->num_entries
== 0)
1815 gdb_assert (objfile
->section_offsets
);
1816 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1818 gdb_assert (fde_table
->num_entries
> 0);
1819 if (*pc
< offset
+ fde_table
->entries
[0]->initial_location
)
1822 seek_pc
= *pc
- offset
;
1823 p_fde
= ((struct dwarf2_fde
**)
1824 bsearch (&seek_pc
, fde_table
->entries
, fde_table
->num_entries
,
1825 sizeof (fde_table
->entries
[0]), bsearch_fde_cmp
));
1828 *pc
= (*p_fde
)->initial_location
+ offset
;
1830 *out_offset
= offset
;
1837 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1839 add_fde (struct dwarf2_fde_table
*fde_table
, struct dwarf2_fde
*fde
)
1841 if (fde
->address_range
== 0)
1842 /* Discard useless FDEs. */
1845 fde_table
->num_entries
+= 1;
1846 fde_table
->entries
= XRESIZEVEC (struct dwarf2_fde
*, fde_table
->entries
,
1847 fde_table
->num_entries
);
1848 fde_table
->entries
[fde_table
->num_entries
- 1] = fde
;
1851 #define DW64_CIE_ID 0xffffffffffffffffULL
1853 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1858 EH_CIE_TYPE_ID
= 1 << 0,
1859 EH_FDE_TYPE_ID
= 1 << 1,
1860 EH_CIE_OR_FDE_TYPE_ID
= EH_CIE_TYPE_ID
| EH_FDE_TYPE_ID
1863 static const gdb_byte
*decode_frame_entry (struct comp_unit
*unit
,
1864 const gdb_byte
*start
,
1866 struct dwarf2_cie_table
*cie_table
,
1867 struct dwarf2_fde_table
*fde_table
,
1868 enum eh_frame_type entry_type
);
1870 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1871 Return NULL if invalid input, otherwise the next byte to be processed. */
1873 static const gdb_byte
*
1874 decode_frame_entry_1 (struct comp_unit
*unit
, const gdb_byte
*start
,
1876 struct dwarf2_cie_table
*cie_table
,
1877 struct dwarf2_fde_table
*fde_table
,
1878 enum eh_frame_type entry_type
)
1880 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1881 const gdb_byte
*buf
, *end
;
1883 unsigned int bytes_read
;
1886 ULONGEST cie_pointer
;
1891 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1895 /* Are we still within the section? */
1896 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1902 /* Distinguish between 32 and 64-bit encoded frame info. */
1903 dwarf64_p
= (bytes_read
== 12);
1905 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1909 cie_id
= DW64_CIE_ID
;
1915 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1920 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1924 if (cie_pointer
== cie_id
)
1926 /* This is a CIE. */
1927 struct dwarf2_cie
*cie
;
1929 unsigned int cie_version
;
1931 /* Check that a CIE was expected. */
1932 if ((entry_type
& EH_CIE_TYPE_ID
) == 0)
1933 error (_("Found a CIE when not expecting it."));
1935 /* Record the offset into the .debug_frame section of this CIE. */
1936 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1938 /* Check whether we've already read it. */
1939 if (find_cie (cie_table
, cie_pointer
))
1942 cie
= XOBNEW (&unit
->objfile
->objfile_obstack
, struct dwarf2_cie
);
1943 cie
->initial_instructions
= NULL
;
1944 cie
->cie_pointer
= cie_pointer
;
1946 /* The encoding for FDE's in a normal .debug_frame section
1947 depends on the target address size. */
1948 cie
->encoding
= DW_EH_PE_absptr
;
1950 /* We'll determine the final value later, but we need to
1951 initialize it conservatively. */
1952 cie
->signal_frame
= 0;
1954 /* Check version number. */
1955 cie_version
= read_1_byte (unit
->abfd
, buf
);
1956 if (cie_version
!= 1 && cie_version
!= 3 && cie_version
!= 4)
1958 cie
->version
= cie_version
;
1961 /* Interpret the interesting bits of the augmentation. */
1962 cie
->augmentation
= augmentation
= (char *) buf
;
1963 buf
+= (strlen (augmentation
) + 1);
1965 /* Ignore armcc augmentations. We only use them for quirks,
1966 and that doesn't happen until later. */
1967 if (startswith (augmentation
, "armcc"))
1968 augmentation
+= strlen (augmentation
);
1970 /* The GCC 2.x "eh" augmentation has a pointer immediately
1971 following the augmentation string, so it must be handled
1973 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1976 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1980 if (cie
->version
>= 4)
1982 /* FIXME: check that this is the same as from the CU header. */
1983 cie
->addr_size
= read_1_byte (unit
->abfd
, buf
);
1985 cie
->segment_size
= read_1_byte (unit
->abfd
, buf
);
1990 cie
->addr_size
= gdbarch_dwarf2_addr_size (gdbarch
);
1991 cie
->segment_size
= 0;
1993 /* Address values in .eh_frame sections are defined to have the
1994 target's pointer size. Watchout: This breaks frame info for
1995 targets with pointer size < address size, unless a .debug_frame
1996 section exists as well. */
1998 cie
->ptr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
2000 cie
->ptr_size
= cie
->addr_size
;
2002 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
2005 cie
->code_alignment_factor
= uleb128
;
2007 buf
= gdb_read_sleb128 (buf
, end
, &sleb128
);
2010 cie
->data_alignment_factor
= sleb128
;
2012 if (cie_version
== 1)
2014 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
2019 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
2022 cie
->return_address_register
= uleb128
;
2025 cie
->return_address_register
2026 = dwarf2_frame_adjust_regnum (gdbarch
,
2027 cie
->return_address_register
,
2030 cie
->saw_z_augmentation
= (*augmentation
== 'z');
2031 if (cie
->saw_z_augmentation
)
2035 buf
= gdb_read_uleb128 (buf
, end
, &length
);
2038 cie
->initial_instructions
= buf
+ length
;
2042 while (*augmentation
)
2044 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
2045 if (*augmentation
== 'L')
2052 /* "R" indicates a byte indicating how FDE addresses are encoded. */
2053 else if (*augmentation
== 'R')
2055 cie
->encoding
= *buf
++;
2059 /* "P" indicates a personality routine in the CIE augmentation. */
2060 else if (*augmentation
== 'P')
2062 /* Skip. Avoid indirection since we throw away the result. */
2063 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
2064 read_encoded_value (unit
, encoding
, cie
->ptr_size
,
2065 buf
, &bytes_read
, 0);
2070 /* "S" indicates a signal frame, such that the return
2071 address must not be decremented to locate the call frame
2072 info for the previous frame; it might even be the first
2073 instruction of a function, so decrementing it would take
2074 us to a different function. */
2075 else if (*augmentation
== 'S')
2077 cie
->signal_frame
= 1;
2081 /* Otherwise we have an unknown augmentation. Assume that either
2082 there is no augmentation data, or we saw a 'z' prefix. */
2085 if (cie
->initial_instructions
)
2086 buf
= cie
->initial_instructions
;
2091 cie
->initial_instructions
= buf
;
2095 add_cie (cie_table
, cie
);
2099 /* This is a FDE. */
2100 struct dwarf2_fde
*fde
;
2103 /* Check that an FDE was expected. */
2104 if ((entry_type
& EH_FDE_TYPE_ID
) == 0)
2105 error (_("Found an FDE when not expecting it."));
2107 /* In an .eh_frame section, the CIE pointer is the delta between the
2108 address within the FDE where the CIE pointer is stored and the
2109 address of the CIE. Convert it to an offset into the .eh_frame
2113 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
2114 cie_pointer
-= (dwarf64_p
? 8 : 4);
2117 /* In either case, validate the result is still within the section. */
2118 if (cie_pointer
>= unit
->dwarf_frame_size
)
2121 fde
= XOBNEW (&unit
->objfile
->objfile_obstack
, struct dwarf2_fde
);
2122 fde
->cie
= find_cie (cie_table
, cie_pointer
);
2123 if (fde
->cie
== NULL
)
2125 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
2126 eh_frame_p
, cie_table
, fde_table
,
2128 fde
->cie
= find_cie (cie_table
, cie_pointer
);
2131 gdb_assert (fde
->cie
!= NULL
);
2133 addr
= read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->ptr_size
,
2134 buf
, &bytes_read
, 0);
2135 fde
->initial_location
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
2138 fde
->address_range
=
2139 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
2140 fde
->cie
->ptr_size
, buf
, &bytes_read
, 0);
2141 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ fde
->address_range
);
2142 fde
->address_range
= addr
- fde
->initial_location
;
2145 /* A 'z' augmentation in the CIE implies the presence of an
2146 augmentation field in the FDE as well. The only thing known
2147 to be in here at present is the LSDA entry for EH. So we
2148 can skip the whole thing. */
2149 if (fde
->cie
->saw_z_augmentation
)
2153 buf
= gdb_read_uleb128 (buf
, end
, &length
);
2161 fde
->instructions
= buf
;
2164 fde
->eh_frame_p
= eh_frame_p
;
2166 add_fde (fde_table
, fde
);
2172 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2173 expect an FDE or a CIE. */
2175 static const gdb_byte
*
2176 decode_frame_entry (struct comp_unit
*unit
, const gdb_byte
*start
,
2178 struct dwarf2_cie_table
*cie_table
,
2179 struct dwarf2_fde_table
*fde_table
,
2180 enum eh_frame_type entry_type
)
2182 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
2183 const gdb_byte
*ret
;
2184 ptrdiff_t start_offset
;
2188 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
,
2189 cie_table
, fde_table
, entry_type
);
2193 /* We have corrupt input data of some form. */
2195 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2196 and mismatches wrt padding and alignment of debug sections. */
2197 /* Note that there is no requirement in the standard for any
2198 alignment at all in the frame unwind sections. Testing for
2199 alignment before trying to interpret data would be incorrect.
2201 However, GCC traditionally arranged for frame sections to be
2202 sized such that the FDE length and CIE fields happen to be
2203 aligned (in theory, for performance). This, unfortunately,
2204 was done with .align directives, which had the side effect of
2205 forcing the section to be aligned by the linker.
2207 This becomes a problem when you have some other producer that
2208 creates frame sections that are not as strictly aligned. That
2209 produces a hole in the frame info that gets filled by the
2212 The GCC behaviour is arguably a bug, but it's effectively now
2213 part of the ABI, so we're now stuck with it, at least at the
2214 object file level. A smart linker may decide, in the process
2215 of compressing duplicate CIE information, that it can rewrite
2216 the entire output section without this extra padding. */
2218 start_offset
= start
- unit
->dwarf_frame_buffer
;
2219 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
2221 start
+= 4 - (start_offset
& 3);
2222 workaround
= ALIGN4
;
2225 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
2227 start
+= 8 - (start_offset
& 7);
2228 workaround
= ALIGN8
;
2232 /* Nothing left to try. Arrange to return as if we've consumed
2233 the entire input section. Hopefully we'll get valid info from
2234 the other of .debug_frame/.eh_frame. */
2236 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
2246 complaint (&symfile_complaints
, _("\
2247 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2248 unit
->dwarf_frame_section
->owner
->filename
,
2249 unit
->dwarf_frame_section
->name
);
2253 complaint (&symfile_complaints
, _("\
2254 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2255 unit
->dwarf_frame_section
->owner
->filename
,
2256 unit
->dwarf_frame_section
->name
);
2260 complaint (&symfile_complaints
,
2261 _("Corrupt data in %s:%s"),
2262 unit
->dwarf_frame_section
->owner
->filename
,
2263 unit
->dwarf_frame_section
->name
);
2271 qsort_fde_cmp (const void *a
, const void *b
)
2273 struct dwarf2_fde
*aa
= *(struct dwarf2_fde
**)a
;
2274 struct dwarf2_fde
*bb
= *(struct dwarf2_fde
**)b
;
2276 if (aa
->initial_location
== bb
->initial_location
)
2278 if (aa
->address_range
!= bb
->address_range
2279 && aa
->eh_frame_p
== 0 && bb
->eh_frame_p
== 0)
2280 /* Linker bug, e.g. gold/10400.
2281 Work around it by keeping stable sort order. */
2282 return (a
< b
) ? -1 : 1;
2284 /* Put eh_frame entries after debug_frame ones. */
2285 return aa
->eh_frame_p
- bb
->eh_frame_p
;
2288 return (aa
->initial_location
< bb
->initial_location
) ? -1 : 1;
2292 dwarf2_build_frame_info (struct objfile
*objfile
)
2294 struct comp_unit
*unit
;
2295 const gdb_byte
*frame_ptr
;
2296 struct dwarf2_cie_table cie_table
;
2297 struct dwarf2_fde_table fde_table
;
2298 struct dwarf2_fde_table
*fde_table2
;
2300 cie_table
.num_entries
= 0;
2301 cie_table
.entries
= NULL
;
2303 fde_table
.num_entries
= 0;
2304 fde_table
.entries
= NULL
;
2306 /* Build a minimal decoding of the DWARF2 compilation unit. */
2307 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
2308 sizeof (struct comp_unit
));
2309 unit
->abfd
= objfile
->obfd
;
2310 unit
->objfile
= objfile
;
2314 if (objfile
->separate_debug_objfile_backlink
== NULL
)
2316 /* Do not read .eh_frame from separate file as they must be also
2317 present in the main file. */
2318 dwarf2_get_section_info (objfile
, DWARF2_EH_FRAME
,
2319 &unit
->dwarf_frame_section
,
2320 &unit
->dwarf_frame_buffer
,
2321 &unit
->dwarf_frame_size
);
2322 if (unit
->dwarf_frame_size
)
2324 asection
*got
, *txt
;
2326 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2327 that is used for the i386/amd64 target, which currently is
2328 the only target in GCC that supports/uses the
2329 DW_EH_PE_datarel encoding. */
2330 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2332 unit
->dbase
= got
->vma
;
2334 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2336 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2338 unit
->tbase
= txt
->vma
;
2342 frame_ptr
= unit
->dwarf_frame_buffer
;
2343 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2344 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1,
2345 &cie_table
, &fde_table
,
2346 EH_CIE_OR_FDE_TYPE_ID
);
2349 CATCH (e
, RETURN_MASK_ERROR
)
2351 warning (_("skipping .eh_frame info of %s: %s"),
2352 objfile_name (objfile
), e
.message
);
2354 if (fde_table
.num_entries
!= 0)
2356 xfree (fde_table
.entries
);
2357 fde_table
.entries
= NULL
;
2358 fde_table
.num_entries
= 0;
2360 /* The cie_table is discarded by the next if. */
2364 if (cie_table
.num_entries
!= 0)
2366 /* Reinit cie_table: debug_frame has different CIEs. */
2367 xfree (cie_table
.entries
);
2368 cie_table
.num_entries
= 0;
2369 cie_table
.entries
= NULL
;
2374 dwarf2_get_section_info (objfile
, DWARF2_DEBUG_FRAME
,
2375 &unit
->dwarf_frame_section
,
2376 &unit
->dwarf_frame_buffer
,
2377 &unit
->dwarf_frame_size
);
2378 if (unit
->dwarf_frame_size
)
2380 int num_old_fde_entries
= fde_table
.num_entries
;
2384 frame_ptr
= unit
->dwarf_frame_buffer
;
2385 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2386 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0,
2387 &cie_table
, &fde_table
,
2388 EH_CIE_OR_FDE_TYPE_ID
);
2390 CATCH (e
, RETURN_MASK_ERROR
)
2392 warning (_("skipping .debug_frame info of %s: %s"),
2393 objfile_name (objfile
), e
.message
);
2395 if (fde_table
.num_entries
!= 0)
2397 fde_table
.num_entries
= num_old_fde_entries
;
2398 if (num_old_fde_entries
== 0)
2400 xfree (fde_table
.entries
);
2401 fde_table
.entries
= NULL
;
2406 = XRESIZEVEC (struct dwarf2_fde
*, fde_table
.entries
,
2407 fde_table
.num_entries
);
2410 fde_table
.num_entries
= num_old_fde_entries
;
2411 /* The cie_table is discarded by the next if. */
2416 /* Discard the cie_table, it is no longer needed. */
2417 if (cie_table
.num_entries
!= 0)
2419 xfree (cie_table
.entries
);
2420 cie_table
.entries
= NULL
; /* Paranoia. */
2421 cie_table
.num_entries
= 0; /* Paranoia. */
2424 /* Copy fde_table to obstack: it is needed at runtime. */
2425 fde_table2
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_fde_table
);
2427 if (fde_table
.num_entries
== 0)
2429 fde_table2
->entries
= NULL
;
2430 fde_table2
->num_entries
= 0;
2434 struct dwarf2_fde
*fde_prev
= NULL
;
2435 struct dwarf2_fde
*first_non_zero_fde
= NULL
;
2438 /* Prepare FDE table for lookups. */
2439 qsort (fde_table
.entries
, fde_table
.num_entries
,
2440 sizeof (fde_table
.entries
[0]), qsort_fde_cmp
);
2442 /* Check for leftovers from --gc-sections. The GNU linker sets
2443 the relevant symbols to zero, but doesn't zero the FDE *end*
2444 ranges because there's no relocation there. It's (offset,
2445 length), not (start, end). On targets where address zero is
2446 just another valid address this can be a problem, since the
2447 FDEs appear to be non-empty in the output --- we could pick
2448 out the wrong FDE. To work around this, when overlaps are
2449 detected, we prefer FDEs that do not start at zero.
2451 Start by finding the first FDE with non-zero start. Below
2452 we'll discard all FDEs that start at zero and overlap this
2454 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2456 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2458 if (fde
->initial_location
!= 0)
2460 first_non_zero_fde
= fde
;
2465 /* Since we'll be doing bsearch, squeeze out identical (except
2466 for eh_frame_p) fde entries so bsearch result is predictable.
2467 Also discard leftovers from --gc-sections. */
2468 fde_table2
->num_entries
= 0;
2469 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2471 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2473 if (fde
->initial_location
== 0
2474 && first_non_zero_fde
!= NULL
2475 && (first_non_zero_fde
->initial_location
2476 < fde
->initial_location
+ fde
->address_range
))
2479 if (fde_prev
!= NULL
2480 && fde_prev
->initial_location
== fde
->initial_location
)
2483 obstack_grow (&objfile
->objfile_obstack
, &fde_table
.entries
[i
],
2484 sizeof (fde_table
.entries
[0]));
2485 ++fde_table2
->num_entries
;
2489 = (struct dwarf2_fde
**) obstack_finish (&objfile
->objfile_obstack
);
2491 /* Discard the original fde_table. */
2492 xfree (fde_table
.entries
);
2495 set_objfile_data (objfile
, dwarf2_frame_objfile_data
, fde_table2
);
2498 /* Provide a prototype to silence -Wmissing-prototypes. */
2499 void _initialize_dwarf2_frame (void);
2502 _initialize_dwarf2_frame (void)
2504 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2505 dwarf2_frame_objfile_data
= register_objfile_data ();