1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003-2020 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 "dwarf2/expr.h"
25 #include "dwarf2/leb.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
37 #include "complaints.h"
38 #include "dwarf2/frame.h"
39 #include "dwarf2/read.h"
41 #include "dwarf2/loc.h"
42 #include "dwarf2/frame-tailcall.h"
43 #include "gdbsupport/gdb_binary_search.h"
45 #include "gdbsupport/selftest.h"
46 #include "selftest-arch.h"
48 #include <unordered_map>
54 /* Call Frame Information (CFI). */
56 /* Common Information Entry (CIE). */
60 /* Computation Unit for this CIE. */
61 struct comp_unit
*unit
;
63 /* Offset into the .debug_frame section where this CIE was found.
64 Used to identify this CIE. */
67 /* Constant that is factored out of all advance location
69 ULONGEST code_alignment_factor
;
71 /* Constants that is factored out of all offset instructions. */
72 LONGEST data_alignment_factor
;
74 /* Return address column. */
75 ULONGEST return_address_register
;
77 /* Instruction sequence to initialize a register set. */
78 const gdb_byte
*initial_instructions
;
81 /* Saved augmentation, in case it's needed later. */
84 /* Encoding of addresses. */
87 /* Target address size in bytes. */
90 /* Target pointer size in bytes. */
93 /* True if a 'z' augmentation existed. */
94 unsigned char saw_z_augmentation
;
96 /* True if an 'S' augmentation existed. */
97 unsigned char signal_frame
;
99 /* The version recorded in the CIE. */
100 unsigned char version
;
102 /* The segment size. */
103 unsigned char segment_size
;
106 /* The CIE table is used to find CIEs during parsing, but then
107 discarded. It maps from the CIE's offset to the CIE. */
108 typedef std::unordered_map
<ULONGEST
, dwarf2_cie
*> dwarf2_cie_table
;
110 /* Frame Description Entry (FDE). */
114 /* CIE for this FDE. */
115 struct dwarf2_cie
*cie
;
117 /* First location associated with this FDE. */
118 CORE_ADDR initial_location
;
120 /* Number of bytes of program instructions described by this FDE. */
121 CORE_ADDR address_range
;
123 /* Instruction sequence. */
124 const gdb_byte
*instructions
;
127 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
129 unsigned char eh_frame_p
;
132 typedef std::vector
<dwarf2_fde
*> dwarf2_fde_table
;
134 /* A minimal decoding of DWARF2 compilation units. We only decode
135 what's needed to get to the call frame information. */
139 comp_unit (struct objfile
*objf
)
144 /* Keep the bfd convenient. */
147 /* Pointer to the .debug_frame section loaded into memory. */
148 const gdb_byte
*dwarf_frame_buffer
= nullptr;
150 /* Length of the loaded .debug_frame section. */
151 bfd_size_type dwarf_frame_size
= 0;
153 /* Pointer to the .debug_frame section. */
154 asection
*dwarf_frame_section
= nullptr;
156 /* Base for DW_EH_PE_datarel encodings. */
159 /* Base for DW_EH_PE_textrel encodings. */
163 dwarf2_fde_table fde_table
;
165 /* Hold data used by this module. */
166 auto_obstack obstack
;
169 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
,
170 CORE_ADDR
*out_offset
);
172 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
175 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
176 int ptr_len
, const gdb_byte
*buf
,
177 unsigned int *bytes_read_ptr
,
178 CORE_ADDR func_base
);
181 /* See dwarf2-frame.h. */
182 bool dwarf2_frame_unwinders_enabled_p
= true;
184 /* Store the length the expression for the CFA in the `cfa_reg' field,
185 which is unused in that case. */
186 #define cfa_exp_len cfa_reg
188 dwarf2_frame_state::dwarf2_frame_state (CORE_ADDR pc_
, struct dwarf2_cie
*cie
)
189 : pc (pc_
), data_align (cie
->data_alignment_factor
),
190 code_align (cie
->code_alignment_factor
),
191 retaddr_column (cie
->return_address_register
)
196 /* Helper functions for execute_stack_op. */
199 read_addr_from_reg (struct frame_info
*this_frame
, int reg
)
201 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
202 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
204 return address_from_register (regnum
, this_frame
);
207 /* Execute the required actions for both the DW_CFA_restore and
208 DW_CFA_restore_extended instructions. */
210 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
211 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
215 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
216 fs
->regs
.alloc_regs (reg
+ 1);
218 /* Check if this register was explicitly initialized in the
219 CIE initial instructions. If not, default the rule to
221 if (reg
< fs
->initial
.reg
.size ())
222 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
224 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
226 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
228 int regnum
= dwarf_reg_to_regnum (gdbarch
, reg
);
231 incomplete CFI data; DW_CFA_restore unspecified\n\
232 register %s (#%d) at %s"),
233 gdbarch_register_name (gdbarch
, regnum
), regnum
,
234 paddress (gdbarch
, fs
->pc
));
238 class dwarf_expr_executor
: public dwarf_expr_context
242 struct frame_info
*this_frame
;
244 CORE_ADDR
read_addr_from_reg (int reg
) override
246 return ::read_addr_from_reg (this_frame
, reg
);
249 struct value
*get_reg_value (struct type
*type
, int reg
) override
251 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
252 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
254 return value_from_register (type
, regnum
, this_frame
);
257 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
259 read_memory (addr
, buf
, len
);
262 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
264 invalid ("DW_OP_fbreg");
267 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
268 union call_site_parameter_u kind_u
,
269 int deref_size
) override
271 invalid ("DW_OP_entry_value");
274 CORE_ADDR
get_object_address () override
276 invalid ("DW_OP_push_object_address");
279 CORE_ADDR
get_frame_cfa () override
281 invalid ("DW_OP_call_frame_cfa");
284 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
286 invalid ("DW_OP_form_tls_address");
289 void dwarf_call (cu_offset die_offset
) override
291 invalid ("DW_OP_call*");
294 struct value
*dwarf_variable_value (sect_offset sect_off
) override
296 invalid ("DW_OP_GNU_variable_value");
299 CORE_ADDR
get_addr_index (unsigned int index
) override
301 invalid ("DW_OP_addrx or DW_OP_GNU_addr_index");
306 void invalid (const char *op
) ATTRIBUTE_NORETURN
308 error (_("%s is invalid in this context"), op
);
313 execute_stack_op (const gdb_byte
*exp
, ULONGEST len
, int addr_size
,
314 CORE_ADDR offset
, struct frame_info
*this_frame
,
315 CORE_ADDR initial
, int initial_in_stack_memory
)
319 dwarf_expr_executor ctx
;
320 scoped_value_mark free_values
;
322 ctx
.this_frame
= this_frame
;
323 ctx
.gdbarch
= get_frame_arch (this_frame
);
324 ctx
.addr_size
= addr_size
;
325 ctx
.ref_addr_size
= -1;
328 ctx
.push_address (initial
, initial_in_stack_memory
);
331 if (ctx
.location
== DWARF_VALUE_MEMORY
)
332 result
= ctx
.fetch_address (0);
333 else if (ctx
.location
== DWARF_VALUE_REGISTER
)
334 result
= ctx
.read_addr_from_reg (value_as_long (ctx
.fetch (0)));
337 /* This is actually invalid DWARF, but if we ever do run across
338 it somehow, we might as well support it. So, instead, report
339 it as unimplemented. */
341 Not implemented: computing unwound register using explicit value operator"));
348 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
349 PC. Modify FS state accordingly. Return current INSN_PTR where the
350 execution has stopped, one can resume it on the next call. */
352 static const gdb_byte
*
353 execute_cfa_program (struct dwarf2_fde
*fde
, const gdb_byte
*insn_ptr
,
354 const gdb_byte
*insn_end
, struct gdbarch
*gdbarch
,
355 CORE_ADDR pc
, struct dwarf2_frame_state
*fs
,
356 CORE_ADDR text_offset
)
358 int eh_frame_p
= fde
->eh_frame_p
;
359 unsigned int bytes_read
;
360 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
362 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
364 gdb_byte insn
= *insn_ptr
++;
368 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
369 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
370 else if ((insn
& 0xc0) == DW_CFA_offset
)
373 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
374 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
375 offset
= utmp
* fs
->data_align
;
376 fs
->regs
.alloc_regs (reg
+ 1);
377 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
378 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
380 else if ((insn
& 0xc0) == DW_CFA_restore
)
383 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
390 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
391 fde
->cie
->ptr_size
, insn_ptr
,
392 &bytes_read
, fde
->initial_location
);
393 /* Apply the text offset for relocatable objects. */
394 fs
->pc
+= text_offset
;
395 insn_ptr
+= bytes_read
;
398 case DW_CFA_advance_loc1
:
399 utmp
= extract_unsigned_integer (insn_ptr
, 1, byte_order
);
400 fs
->pc
+= utmp
* fs
->code_align
;
403 case DW_CFA_advance_loc2
:
404 utmp
= extract_unsigned_integer (insn_ptr
, 2, byte_order
);
405 fs
->pc
+= utmp
* fs
->code_align
;
408 case DW_CFA_advance_loc4
:
409 utmp
= extract_unsigned_integer (insn_ptr
, 4, byte_order
);
410 fs
->pc
+= utmp
* fs
->code_align
;
414 case DW_CFA_offset_extended
:
415 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
416 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
417 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
418 offset
= utmp
* fs
->data_align
;
419 fs
->regs
.alloc_regs (reg
+ 1);
420 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
421 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
424 case DW_CFA_restore_extended
:
425 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
426 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
429 case DW_CFA_undefined
:
430 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
431 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
432 fs
->regs
.alloc_regs (reg
+ 1);
433 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
436 case DW_CFA_same_value
:
437 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
438 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
439 fs
->regs
.alloc_regs (reg
+ 1);
440 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
443 case DW_CFA_register
:
444 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
445 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
446 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
447 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
448 fs
->regs
.alloc_regs (reg
+ 1);
449 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
450 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
453 case DW_CFA_remember_state
:
455 struct dwarf2_frame_state_reg_info
*new_rs
;
457 new_rs
= new dwarf2_frame_state_reg_info (fs
->regs
);
458 fs
->regs
.prev
= new_rs
;
462 case DW_CFA_restore_state
:
464 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
469 bad CFI data; mismatched DW_CFA_restore_state at %s"),
470 paddress (gdbarch
, fs
->pc
));
473 fs
->regs
= std::move (*old_rs
);
478 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
479 fs
->regs
.cfa_reg
= reg
;
480 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
482 if (fs
->armcc_cfa_offsets_sf
)
483 utmp
*= fs
->data_align
;
485 fs
->regs
.cfa_offset
= utmp
;
486 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
489 case DW_CFA_def_cfa_register
:
490 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
491 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
493 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
496 case DW_CFA_def_cfa_offset
:
497 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
499 if (fs
->armcc_cfa_offsets_sf
)
500 utmp
*= fs
->data_align
;
502 fs
->regs
.cfa_offset
= utmp
;
503 /* cfa_how deliberately not set. */
509 case DW_CFA_def_cfa_expression
:
510 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
511 fs
->regs
.cfa_exp_len
= utmp
;
512 fs
->regs
.cfa_exp
= insn_ptr
;
513 fs
->regs
.cfa_how
= CFA_EXP
;
514 insn_ptr
+= fs
->regs
.cfa_exp_len
;
517 case DW_CFA_expression
:
518 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
519 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
520 fs
->regs
.alloc_regs (reg
+ 1);
521 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
522 fs
->regs
.reg
[reg
].loc
.exp
.start
= insn_ptr
;
523 fs
->regs
.reg
[reg
].loc
.exp
.len
= utmp
;
524 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
528 case DW_CFA_offset_extended_sf
:
529 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
530 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
531 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
532 offset
*= fs
->data_align
;
533 fs
->regs
.alloc_regs (reg
+ 1);
534 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
535 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
538 case DW_CFA_val_offset
:
539 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
540 fs
->regs
.alloc_regs (reg
+ 1);
541 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
542 offset
= utmp
* fs
->data_align
;
543 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
544 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
547 case DW_CFA_val_offset_sf
:
548 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
549 fs
->regs
.alloc_regs (reg
+ 1);
550 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
551 offset
*= fs
->data_align
;
552 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
553 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
556 case DW_CFA_val_expression
:
557 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
558 fs
->regs
.alloc_regs (reg
+ 1);
559 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
560 fs
->regs
.reg
[reg
].loc
.exp
.start
= insn_ptr
;
561 fs
->regs
.reg
[reg
].loc
.exp
.len
= utmp
;
562 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
566 case DW_CFA_def_cfa_sf
:
567 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
568 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
570 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
571 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
572 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
575 case DW_CFA_def_cfa_offset_sf
:
576 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
577 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
578 /* cfa_how deliberately not set. */
581 case DW_CFA_GNU_args_size
:
583 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
586 case DW_CFA_GNU_negative_offset_extended
:
587 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
588 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
589 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
590 offset
= utmp
* fs
->data_align
;
591 fs
->regs
.alloc_regs (reg
+ 1);
592 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
593 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
597 if (insn
>= DW_CFA_lo_user
&& insn
<= DW_CFA_hi_user
)
599 /* Handle vendor-specific CFI for different architectures. */
600 if (!gdbarch_execute_dwarf_cfa_vendor_op (gdbarch
, insn
, fs
))
601 error (_("Call Frame Instruction op %d in vendor extension "
602 "space is not handled on this architecture."),
606 internal_error (__FILE__
, __LINE__
,
607 _("Unknown CFI encountered."));
612 if (fs
->initial
.reg
.empty ())
614 /* Don't allow remember/restore between CIE and FDE programs. */
615 delete fs
->regs
.prev
;
616 fs
->regs
.prev
= NULL
;
624 namespace selftests
{
626 /* Unit test to function execute_cfa_program. */
629 execute_cfa_program_test (struct gdbarch
*gdbarch
)
631 struct dwarf2_fde fde
;
632 struct dwarf2_cie cie
;
634 memset (&fde
, 0, sizeof fde
);
635 memset (&cie
, 0, sizeof cie
);
637 cie
.data_alignment_factor
= -4;
638 cie
.code_alignment_factor
= 2;
641 dwarf2_frame_state
fs (0, fde
.cie
);
645 DW_CFA_def_cfa
, 1, 4, /* DW_CFA_def_cfa: r1 ofs 4 */
646 DW_CFA_offset
| 0x2, 1, /* DW_CFA_offset: r2 at cfa-4 */
647 DW_CFA_remember_state
,
648 DW_CFA_restore_state
,
651 const gdb_byte
*insn_end
= insns
+ sizeof (insns
);
652 const gdb_byte
*out
= execute_cfa_program (&fde
, insns
, insn_end
, gdbarch
,
655 SELF_CHECK (out
== insn_end
);
656 SELF_CHECK (fs
.pc
== 0);
658 /* The instructions above only use r1 and r2, but the register numbers
659 used are adjusted by dwarf2_frame_adjust_regnum. */
660 auto r1
= dwarf2_frame_adjust_regnum (gdbarch
, 1, fde
.eh_frame_p
);
661 auto r2
= dwarf2_frame_adjust_regnum (gdbarch
, 2, fde
.eh_frame_p
);
663 SELF_CHECK (fs
.regs
.reg
.size () == (std::max (r1
, r2
) + 1));
665 SELF_CHECK (fs
.regs
.reg
[r2
].how
== DWARF2_FRAME_REG_SAVED_OFFSET
);
666 SELF_CHECK (fs
.regs
.reg
[r2
].loc
.offset
== -4);
668 for (auto i
= 0; i
< fs
.regs
.reg
.size (); i
++)
670 SELF_CHECK (fs
.regs
.reg
[i
].how
== DWARF2_FRAME_REG_UNSPECIFIED
);
672 SELF_CHECK (fs
.regs
.cfa_reg
== 1);
673 SELF_CHECK (fs
.regs
.cfa_offset
== 4);
674 SELF_CHECK (fs
.regs
.cfa_how
== CFA_REG_OFFSET
);
675 SELF_CHECK (fs
.regs
.cfa_exp
== NULL
);
676 SELF_CHECK (fs
.regs
.prev
== NULL
);
679 } // namespace selftests
680 #endif /* GDB_SELF_TEST */
684 /* Architecture-specific operations. */
686 /* Per-architecture data key. */
687 static struct gdbarch_data
*dwarf2_frame_data
;
689 struct dwarf2_frame_ops
691 /* Pre-initialize the register state REG for register REGNUM. */
692 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
693 struct frame_info
*);
695 /* Check whether the THIS_FRAME is a signal trampoline. */
696 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
698 /* Convert .eh_frame register number to DWARF register number, or
699 adjust .debug_frame register number. */
700 int (*adjust_regnum
) (struct gdbarch
*, int, int);
703 /* Default architecture-specific register state initialization
707 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
708 struct dwarf2_frame_state_reg
*reg
,
709 struct frame_info
*this_frame
)
711 /* If we have a register that acts as a program counter, mark it as
712 a destination for the return address. If we have a register that
713 serves as the stack pointer, arrange for it to be filled with the
714 call frame address (CFA). The other registers are marked as
717 We copy the return address to the program counter, since many
718 parts in GDB assume that it is possible to get the return address
719 by unwinding the program counter register. However, on ISA's
720 with a dedicated return address register, the CFI usually only
721 contains information to unwind that return address register.
723 The reason we're treating the stack pointer special here is
724 because in many cases GCC doesn't emit CFI for the stack pointer
725 and implicitly assumes that it is equal to the CFA. This makes
726 some sense since the DWARF specification (version 3, draft 8,
729 "Typically, the CFA is defined to be the value of the stack
730 pointer at the call site in the previous frame (which may be
731 different from its value on entry to the current frame)."
733 However, this isn't true for all platforms supported by GCC
734 (e.g. IBM S/390 and zSeries). Those architectures should provide
735 their own architecture-specific initialization function. */
737 if (regnum
== gdbarch_pc_regnum (gdbarch
))
738 reg
->how
= DWARF2_FRAME_REG_RA
;
739 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
740 reg
->how
= DWARF2_FRAME_REG_CFA
;
743 /* Return a default for the architecture-specific operations. */
746 dwarf2_frame_init (struct obstack
*obstack
)
748 struct dwarf2_frame_ops
*ops
;
750 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
751 ops
->init_reg
= dwarf2_frame_default_init_reg
;
755 /* Set the architecture-specific register state initialization
756 function for GDBARCH to INIT_REG. */
759 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
760 void (*init_reg
) (struct gdbarch
*, int,
761 struct dwarf2_frame_state_reg
*,
762 struct frame_info
*))
764 struct dwarf2_frame_ops
*ops
765 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
767 ops
->init_reg
= init_reg
;
770 /* Pre-initialize the register state REG for register REGNUM. */
773 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
774 struct dwarf2_frame_state_reg
*reg
,
775 struct frame_info
*this_frame
)
777 struct dwarf2_frame_ops
*ops
778 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
780 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
783 /* Set the architecture-specific signal trampoline recognition
784 function for GDBARCH to SIGNAL_FRAME_P. */
787 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
788 int (*signal_frame_p
) (struct gdbarch
*,
789 struct frame_info
*))
791 struct dwarf2_frame_ops
*ops
792 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
794 ops
->signal_frame_p
= signal_frame_p
;
797 /* Query the architecture-specific signal frame recognizer for
801 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
802 struct frame_info
*this_frame
)
804 struct dwarf2_frame_ops
*ops
805 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
807 if (ops
->signal_frame_p
== NULL
)
809 return ops
->signal_frame_p (gdbarch
, this_frame
);
812 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
816 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
817 int (*adjust_regnum
) (struct gdbarch
*,
820 struct dwarf2_frame_ops
*ops
821 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
823 ops
->adjust_regnum
= adjust_regnum
;
826 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
830 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
,
831 int regnum
, int eh_frame_p
)
833 struct dwarf2_frame_ops
*ops
834 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
836 if (ops
->adjust_regnum
== NULL
)
838 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
842 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
843 struct dwarf2_fde
*fde
)
845 struct compunit_symtab
*cust
;
847 cust
= find_pc_compunit_symtab (fs
->pc
);
851 if (producer_is_realview (COMPUNIT_PRODUCER (cust
)))
853 if (fde
->cie
->version
== 1)
854 fs
->armcc_cfa_offsets_sf
= 1;
856 if (fde
->cie
->version
== 1)
857 fs
->armcc_cfa_offsets_reversed
= 1;
859 /* The reversed offset problem is present in some compilers
860 using DWARF3, but it was eventually fixed. Check the ARM
861 defined augmentations, which are in the format "armcc" followed
862 by a list of one-character options. The "+" option means
863 this problem is fixed (no quirk needed). If the armcc
864 augmentation is missing, the quirk is needed. */
865 if (fde
->cie
->version
== 3
866 && (!startswith (fde
->cie
->augmentation
, "armcc")
867 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
868 fs
->armcc_cfa_offsets_reversed
= 1;
875 /* See dwarf2-frame.h. */
878 dwarf2_fetch_cfa_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
879 struct dwarf2_per_cu_data
*data
,
880 int *regnum_out
, LONGEST
*offset_out
,
881 CORE_ADDR
*text_offset_out
,
882 const gdb_byte
**cfa_start_out
,
883 const gdb_byte
**cfa_end_out
)
885 struct dwarf2_fde
*fde
;
886 CORE_ADDR text_offset
;
889 /* Find the correct FDE. */
890 fde
= dwarf2_frame_find_fde (&pc1
, &text_offset
);
892 error (_("Could not compute CFA; needed to translate this expression"));
894 dwarf2_frame_state
fs (pc1
, fde
->cie
);
896 /* Check for "quirks" - known bugs in producers. */
897 dwarf2_frame_find_quirks (&fs
, fde
);
899 /* First decode all the insns in the CIE. */
900 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
901 fde
->cie
->end
, gdbarch
, pc
, &fs
, text_offset
);
903 /* Save the initialized register set. */
904 fs
.initial
= fs
.regs
;
906 /* Then decode the insns in the FDE up to our target PC. */
907 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
, pc
, &fs
,
910 /* Calculate the CFA. */
911 switch (fs
.regs
.cfa_how
)
915 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, fs
.regs
.cfa_reg
);
917 *regnum_out
= regnum
;
918 if (fs
.armcc_cfa_offsets_reversed
)
919 *offset_out
= -fs
.regs
.cfa_offset
;
921 *offset_out
= fs
.regs
.cfa_offset
;
926 *text_offset_out
= text_offset
;
927 *cfa_start_out
= fs
.regs
.cfa_exp
;
928 *cfa_end_out
= fs
.regs
.cfa_exp
+ fs
.regs
.cfa_exp_len
;
932 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
937 struct dwarf2_frame_cache
939 /* DWARF Call Frame Address. */
942 /* Set if the return address column was marked as unavailable
943 (required non-collected memory or registers to compute). */
944 int unavailable_retaddr
;
946 /* Set if the return address column was marked as undefined. */
947 int undefined_retaddr
;
949 /* Saved registers, indexed by GDB register number, not by DWARF
951 struct dwarf2_frame_state_reg
*reg
;
953 /* Return address register. */
954 struct dwarf2_frame_state_reg retaddr_reg
;
956 /* Target address size in bytes. */
959 /* The .text offset. */
960 CORE_ADDR text_offset
;
962 /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
963 sequence. If NULL then it is a normal case with no TAILCALL_FRAME
964 involved. Non-bottom frames of a virtual tail call frames chain use
965 dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
967 void *tailcall_cache
;
970 static struct dwarf2_frame_cache
*
971 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
973 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
974 const int num_regs
= gdbarch_num_cooked_regs (gdbarch
);
975 struct dwarf2_frame_cache
*cache
;
976 struct dwarf2_fde
*fde
;
978 const gdb_byte
*instr
;
981 return (struct dwarf2_frame_cache
*) *this_cache
;
983 /* Allocate a new cache. */
984 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
985 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
990 Note that if the next frame is never supposed to return (i.e. a call
991 to abort), the compiler might optimize away the instruction at
992 its return address. As a result the return address will
993 point at some random instruction, and the CFI for that
994 instruction is probably worthless to us. GCC's unwinder solves
995 this problem by substracting 1 from the return address to get an
996 address in the middle of a presumed call instruction (or the
997 instruction in the associated delay slot). This should only be
998 done for "normal" frames and not for resume-type frames (signal
999 handlers, sentinel frames, dummy frames). The function
1000 get_frame_address_in_block does just this. It's not clear how
1001 reliable the method is though; there is the potential for the
1002 register state pre-call being different to that on return. */
1003 CORE_ADDR pc1
= get_frame_address_in_block (this_frame
);
1005 /* Find the correct FDE. */
1006 fde
= dwarf2_frame_find_fde (&pc1
, &cache
->text_offset
);
1007 gdb_assert (fde
!= NULL
);
1009 /* Allocate and initialize the frame state. */
1010 struct dwarf2_frame_state
fs (pc1
, fde
->cie
);
1012 cache
->addr_size
= fde
->cie
->addr_size
;
1014 /* Check for "quirks" - known bugs in producers. */
1015 dwarf2_frame_find_quirks (&fs
, fde
);
1017 /* First decode all the insns in the CIE. */
1018 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
1019 fde
->cie
->end
, gdbarch
,
1020 get_frame_address_in_block (this_frame
), &fs
,
1021 cache
->text_offset
);
1023 /* Save the initialized register set. */
1024 fs
.initial
= fs
.regs
;
1026 /* Fetching the entry pc for THIS_FRAME won't necessarily result
1027 in an address that's within the range of FDE locations. This
1028 is due to the possibility of the function occupying non-contiguous
1030 LONGEST entry_cfa_sp_offset
;
1031 int entry_cfa_sp_offset_p
= 0;
1032 if (get_frame_func_if_available (this_frame
, &entry_pc
)
1033 && fde
->initial_location
<= entry_pc
1034 && entry_pc
< fde
->initial_location
+ fde
->address_range
)
1036 /* Decode the insns in the FDE up to the entry PC. */
1037 instr
= execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
,
1038 entry_pc
, &fs
, cache
->text_offset
);
1040 if (fs
.regs
.cfa_how
== CFA_REG_OFFSET
1041 && (dwarf_reg_to_regnum (gdbarch
, fs
.regs
.cfa_reg
)
1042 == gdbarch_sp_regnum (gdbarch
)))
1044 entry_cfa_sp_offset
= fs
.regs
.cfa_offset
;
1045 entry_cfa_sp_offset_p
= 1;
1049 instr
= fde
->instructions
;
1051 /* Then decode the insns in the FDE up to our target PC. */
1052 execute_cfa_program (fde
, instr
, fde
->end
, gdbarch
,
1053 get_frame_address_in_block (this_frame
), &fs
,
1054 cache
->text_offset
);
1058 /* Calculate the CFA. */
1059 switch (fs
.regs
.cfa_how
)
1061 case CFA_REG_OFFSET
:
1062 cache
->cfa
= read_addr_from_reg (this_frame
, fs
.regs
.cfa_reg
);
1063 if (fs
.armcc_cfa_offsets_reversed
)
1064 cache
->cfa
-= fs
.regs
.cfa_offset
;
1066 cache
->cfa
+= fs
.regs
.cfa_offset
;
1071 execute_stack_op (fs
.regs
.cfa_exp
, fs
.regs
.cfa_exp_len
,
1072 cache
->addr_size
, cache
->text_offset
,
1077 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
1080 catch (const gdb_exception_error
&ex
)
1082 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1084 cache
->unavailable_retaddr
= 1;
1091 /* Initialize the register state. */
1095 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1096 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
1099 /* Go through the DWARF2 CFI generated table and save its register
1100 location information in the cache. Note that we don't skip the
1101 return address column; it's perfectly all right for it to
1102 correspond to a real register. */
1104 int column
; /* CFI speak for "register number". */
1106 for (column
= 0; column
< fs
.regs
.reg
.size (); column
++)
1108 /* Use the GDB register number as the destination index. */
1109 int regnum
= dwarf_reg_to_regnum (gdbarch
, column
);
1111 /* Protect against a target returning a bad register. */
1112 if (regnum
< 0 || regnum
>= num_regs
)
1115 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1116 of all debug info registers. If it doesn't, complain (but
1117 not too loudly). It turns out that GCC assumes that an
1118 unspecified register implies "same value" when CFI (draft
1119 7) specifies nothing at all. Such a register could equally
1120 be interpreted as "undefined". Also note that this check
1121 isn't sufficient; it only checks that all registers in the
1122 range [0 .. max column] are specified, and won't detect
1123 problems when a debug info register falls outside of the
1124 table. We need a way of iterating through all the valid
1125 DWARF2 register numbers. */
1126 if (fs
.regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1128 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1130 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1131 gdbarch_register_name (gdbarch
, regnum
),
1132 paddress (gdbarch
, fs
.pc
));
1135 cache
->reg
[regnum
] = fs
.regs
.reg
[column
];
1139 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1140 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1144 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1146 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1147 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1149 const std::vector
<struct dwarf2_frame_state_reg
> ®s
1151 ULONGEST retaddr_column
= fs
.retaddr_column
;
1153 /* It seems rather bizarre to specify an "empty" column as
1154 the return adress column. However, this is exactly
1155 what GCC does on some targets. It turns out that GCC
1156 assumes that the return address can be found in the
1157 register corresponding to the return address column.
1158 Incidentally, that's how we should treat a return
1159 address column specifying "same value" too. */
1160 if (fs
.retaddr_column
< fs
.regs
.reg
.size ()
1161 && regs
[retaddr_column
].how
!= DWARF2_FRAME_REG_UNSPECIFIED
1162 && regs
[retaddr_column
].how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1164 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1165 cache
->reg
[regnum
] = regs
[retaddr_column
];
1167 cache
->retaddr_reg
= regs
[retaddr_column
];
1171 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1173 cache
->reg
[regnum
].loc
.reg
= fs
.retaddr_column
;
1174 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1178 cache
->retaddr_reg
.loc
.reg
= fs
.retaddr_column
;
1179 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1186 if (fs
.retaddr_column
< fs
.regs
.reg
.size ()
1187 && fs
.regs
.reg
[fs
.retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1188 cache
->undefined_retaddr
= 1;
1190 dwarf2_tailcall_sniffer_first (this_frame
, &cache
->tailcall_cache
,
1191 (entry_cfa_sp_offset_p
1192 ? &entry_cfa_sp_offset
: NULL
));
1197 static enum unwind_stop_reason
1198 dwarf2_frame_unwind_stop_reason (struct frame_info
*this_frame
,
1201 struct dwarf2_frame_cache
*cache
1202 = dwarf2_frame_cache (this_frame
, this_cache
);
1204 if (cache
->unavailable_retaddr
)
1205 return UNWIND_UNAVAILABLE
;
1207 if (cache
->undefined_retaddr
)
1208 return UNWIND_OUTERMOST
;
1210 return UNWIND_NO_REASON
;
1214 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1215 struct frame_id
*this_id
)
1217 struct dwarf2_frame_cache
*cache
=
1218 dwarf2_frame_cache (this_frame
, this_cache
);
1220 if (cache
->unavailable_retaddr
)
1221 (*this_id
) = frame_id_build_unavailable_stack (get_frame_func (this_frame
));
1222 else if (cache
->undefined_retaddr
)
1225 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1228 static struct value
*
1229 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1232 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1233 struct dwarf2_frame_cache
*cache
=
1234 dwarf2_frame_cache (this_frame
, this_cache
);
1238 /* Non-bottom frames of a virtual tail call frames chain use
1239 dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1240 them. If dwarf2_tailcall_prev_register_first does not have specific value
1241 unwind the register, tail call frames are assumed to have the register set
1242 of the top caller. */
1243 if (cache
->tailcall_cache
)
1247 val
= dwarf2_tailcall_prev_register_first (this_frame
,
1248 &cache
->tailcall_cache
,
1254 switch (cache
->reg
[regnum
].how
)
1256 case DWARF2_FRAME_REG_UNDEFINED
:
1257 /* If CFI explicitly specified that the value isn't defined,
1258 mark it as optimized away; the value isn't available. */
1259 return frame_unwind_got_optimized (this_frame
, regnum
);
1261 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1262 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1263 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1265 case DWARF2_FRAME_REG_SAVED_REG
:
1266 realnum
= dwarf_reg_to_regnum_or_error
1267 (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1268 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1270 case DWARF2_FRAME_REG_SAVED_EXP
:
1271 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
.start
,
1272 cache
->reg
[regnum
].loc
.exp
.len
,
1273 cache
->addr_size
, cache
->text_offset
,
1274 this_frame
, cache
->cfa
, 1);
1275 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1277 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1278 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1279 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1281 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1282 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
.start
,
1283 cache
->reg
[regnum
].loc
.exp
.len
,
1284 cache
->addr_size
, cache
->text_offset
,
1285 this_frame
, cache
->cfa
, 1);
1286 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1288 case DWARF2_FRAME_REG_UNSPECIFIED
:
1289 /* GCC, in its infinite wisdom decided to not provide unwind
1290 information for registers that are "same value". Since
1291 DWARF2 (3 draft 7) doesn't define such behavior, said
1292 registers are actually undefined (which is different to CFI
1293 "undefined"). Code above issues a complaint about this.
1294 Here just fudge the books, assume GCC, and that the value is
1295 more inner on the stack. */
1296 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1298 case DWARF2_FRAME_REG_SAME_VALUE
:
1299 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1301 case DWARF2_FRAME_REG_CFA
:
1302 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1304 case DWARF2_FRAME_REG_CFA_OFFSET
:
1305 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1306 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1308 case DWARF2_FRAME_REG_RA_OFFSET
:
1309 addr
= cache
->reg
[regnum
].loc
.offset
;
1310 regnum
= dwarf_reg_to_regnum_or_error
1311 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1312 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1313 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1315 case DWARF2_FRAME_REG_FN
:
1316 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1319 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1323 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1324 call frames chain. */
1327 dwarf2_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1329 struct dwarf2_frame_cache
*cache
= dwarf2_frame_cache (self
, &this_cache
);
1331 if (cache
->tailcall_cache
)
1332 dwarf2_tailcall_frame_unwind
.dealloc_cache (self
, cache
->tailcall_cache
);
1336 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1337 struct frame_info
*this_frame
, void **this_cache
)
1339 if (!dwarf2_frame_unwinders_enabled_p
)
1342 /* Grab an address that is guaranteed to reside somewhere within the
1343 function. get_frame_pc(), with a no-return next function, can
1344 end up returning something past the end of this function's body.
1345 If the frame we're sniffing for is a signal frame whose start
1346 address is placed on the stack by the OS, its FDE must
1347 extend one byte before its start address or we could potentially
1348 select the FDE of the previous function. */
1349 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1350 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
, NULL
);
1355 /* On some targets, signal trampolines may have unwind information.
1356 We need to recognize them so that we set the frame type
1359 if (fde
->cie
->signal_frame
1360 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1362 return self
->type
== SIGTRAMP_FRAME
;
1364 if (self
->type
!= NORMAL_FRAME
)
1370 static const struct frame_unwind dwarf2_frame_unwind
=
1373 dwarf2_frame_unwind_stop_reason
,
1374 dwarf2_frame_this_id
,
1375 dwarf2_frame_prev_register
,
1377 dwarf2_frame_sniffer
,
1378 dwarf2_frame_dealloc_cache
1381 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1384 dwarf2_frame_unwind_stop_reason
,
1385 dwarf2_frame_this_id
,
1386 dwarf2_frame_prev_register
,
1388 dwarf2_frame_sniffer
,
1390 /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1394 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1397 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1399 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1400 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1404 /* There is no explicitly defined relationship between the CFA and the
1405 location of frame's local variables and arguments/parameters.
1406 Therefore, frame base methods on this page should probably only be
1407 used as a last resort, just to avoid printing total garbage as a
1408 response to the "info frame" command. */
1411 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1413 struct dwarf2_frame_cache
*cache
=
1414 dwarf2_frame_cache (this_frame
, this_cache
);
1419 static const struct frame_base dwarf2_frame_base
=
1421 &dwarf2_frame_unwind
,
1422 dwarf2_frame_base_address
,
1423 dwarf2_frame_base_address
,
1424 dwarf2_frame_base_address
1427 const struct frame_base
*
1428 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1430 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1432 if (dwarf2_frame_find_fde (&block_addr
, NULL
))
1433 return &dwarf2_frame_base
;
1438 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1439 the DWARF unwinder. This is used to implement
1440 DW_OP_call_frame_cfa. */
1443 dwarf2_frame_cfa (struct frame_info
*this_frame
)
1445 if (frame_unwinder_is (this_frame
, &record_btrace_tailcall_frame_unwind
)
1446 || frame_unwinder_is (this_frame
, &record_btrace_frame_unwind
))
1447 throw_error (NOT_AVAILABLE_ERROR
,
1448 _("cfa not available for record btrace target"));
1450 while (get_frame_type (this_frame
) == INLINE_FRAME
)
1451 this_frame
= get_prev_frame (this_frame
);
1452 if (get_frame_unwind_stop_reason (this_frame
) == UNWIND_UNAVAILABLE
)
1453 throw_error (NOT_AVAILABLE_ERROR
,
1454 _("can't compute CFA for this frame: "
1455 "required registers or memory are unavailable"));
1457 if (get_frame_id (this_frame
).stack_status
!= FID_STACK_VALID
)
1458 throw_error (NOT_AVAILABLE_ERROR
,
1459 _("can't compute CFA for this frame: "
1460 "frame base not available"));
1462 return get_frame_base (this_frame
);
1465 /* We store the frame data on the BFD. This is only done if it is
1466 independent of the address space and so can be shared. */
1467 static const struct bfd_key
<comp_unit
> dwarf2_frame_bfd_data
;
1469 /* If any BFD sections require relocations (note; really should be if
1470 any debug info requires relocations), then we store the frame data
1471 on the objfile instead, and do not share it. */
1472 const struct objfile_key
<comp_unit
> dwarf2_frame_objfile_data
;
1475 /* Pointer encoding helper functions. */
1477 /* GCC supports exception handling based on DWARF2 CFI. However, for
1478 technical reasons, it encodes addresses in its FDE's in a different
1479 way. Several "pointer encodings" are supported. The encoding
1480 that's used for a particular FDE is determined by the 'R'
1481 augmentation in the associated CIE. The argument of this
1482 augmentation is a single byte.
1484 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1485 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1486 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1487 address should be interpreted (absolute, relative to the current
1488 position in the FDE, ...). Bit 7, indicates that the address
1489 should be dereferenced. */
1492 encoding_for_size (unsigned int size
)
1497 return DW_EH_PE_udata2
;
1499 return DW_EH_PE_udata4
;
1501 return DW_EH_PE_udata8
;
1503 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1508 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1509 int ptr_len
, const gdb_byte
*buf
,
1510 unsigned int *bytes_read_ptr
,
1511 CORE_ADDR func_base
)
1516 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1518 if (encoding
& DW_EH_PE_indirect
)
1519 internal_error (__FILE__
, __LINE__
,
1520 _("Unsupported encoding: DW_EH_PE_indirect"));
1522 *bytes_read_ptr
= 0;
1524 switch (encoding
& 0x70)
1526 case DW_EH_PE_absptr
:
1529 case DW_EH_PE_pcrel
:
1530 base
= bfd_section_vma (unit
->dwarf_frame_section
);
1531 base
+= (buf
- unit
->dwarf_frame_buffer
);
1533 case DW_EH_PE_datarel
:
1536 case DW_EH_PE_textrel
:
1539 case DW_EH_PE_funcrel
:
1542 case DW_EH_PE_aligned
:
1544 offset
= buf
- unit
->dwarf_frame_buffer
;
1545 if ((offset
% ptr_len
) != 0)
1547 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1548 buf
+= *bytes_read_ptr
;
1552 internal_error (__FILE__
, __LINE__
,
1553 _("Invalid or unsupported encoding"));
1556 if ((encoding
& 0x07) == 0x00)
1558 encoding
|= encoding_for_size (ptr_len
);
1559 if (bfd_get_sign_extend_vma (unit
->abfd
))
1560 encoding
|= DW_EH_PE_signed
;
1563 switch (encoding
& 0x0f)
1565 case DW_EH_PE_uleb128
:
1568 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1570 *bytes_read_ptr
+= safe_read_uleb128 (buf
, end_buf
, &value
) - buf
;
1571 return base
+ value
;
1573 case DW_EH_PE_udata2
:
1574 *bytes_read_ptr
+= 2;
1575 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1576 case DW_EH_PE_udata4
:
1577 *bytes_read_ptr
+= 4;
1578 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1579 case DW_EH_PE_udata8
:
1580 *bytes_read_ptr
+= 8;
1581 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1582 case DW_EH_PE_sleb128
:
1585 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1587 *bytes_read_ptr
+= safe_read_sleb128 (buf
, end_buf
, &value
) - buf
;
1588 return base
+ value
;
1590 case DW_EH_PE_sdata2
:
1591 *bytes_read_ptr
+= 2;
1592 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1593 case DW_EH_PE_sdata4
:
1594 *bytes_read_ptr
+= 4;
1595 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1596 case DW_EH_PE_sdata8
:
1597 *bytes_read_ptr
+= 8;
1598 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1600 internal_error (__FILE__
, __LINE__
,
1601 _("Invalid or unsupported encoding"));
1606 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1607 static struct dwarf2_cie
*
1608 find_cie (const dwarf2_cie_table
&cie_table
, ULONGEST cie_pointer
)
1610 auto iter
= cie_table
.find (cie_pointer
);
1611 if (iter
!= cie_table
.end ())
1612 return iter
->second
;
1617 bsearch_fde_cmp (const dwarf2_fde
*fde
, CORE_ADDR seek_pc
)
1619 if (fde
->initial_location
+ fde
->address_range
<= seek_pc
)
1621 if (fde
->initial_location
<= seek_pc
)
1626 /* Find an existing comp_unit for an objfile, if any. */
1629 find_comp_unit (struct objfile
*objfile
)
1631 bfd
*abfd
= objfile
->obfd
;
1632 if (gdb_bfd_requires_relocations (abfd
))
1633 return dwarf2_frame_bfd_data
.get (abfd
);
1634 return dwarf2_frame_objfile_data
.get (objfile
);
1637 /* Store the comp_unit on OBJFILE, or the corresponding BFD, as
1641 set_comp_unit (struct objfile
*objfile
, struct comp_unit
*unit
)
1643 bfd
*abfd
= objfile
->obfd
;
1644 if (gdb_bfd_requires_relocations (abfd
))
1645 return dwarf2_frame_bfd_data
.set (abfd
, unit
);
1646 return dwarf2_frame_objfile_data
.set (objfile
, unit
);
1649 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1650 initial location associated with it into *PC. */
1652 static struct dwarf2_fde
*
1653 dwarf2_frame_find_fde (CORE_ADDR
*pc
, CORE_ADDR
*out_offset
)
1655 for (objfile
*objfile
: current_program_space
->objfiles ())
1660 comp_unit
*unit
= find_comp_unit (objfile
);
1663 dwarf2_build_frame_info (objfile
);
1664 unit
= find_comp_unit (objfile
);
1666 gdb_assert (unit
!= NULL
);
1668 dwarf2_fde_table
*fde_table
= &unit
->fde_table
;
1669 if (fde_table
->empty ())
1672 gdb_assert (!objfile
->section_offsets
.empty ());
1673 offset
= objfile
->text_section_offset ();
1675 gdb_assert (!fde_table
->empty ());
1676 if (*pc
< offset
+ (*fde_table
)[0]->initial_location
)
1679 seek_pc
= *pc
- offset
;
1680 auto it
= gdb::binary_search (fde_table
->begin (), fde_table
->end (),
1681 seek_pc
, bsearch_fde_cmp
);
1682 if (it
!= fde_table
->end ())
1684 *pc
= (*it
)->initial_location
+ offset
;
1686 *out_offset
= offset
;
1693 /* Add FDE to FDE_TABLE. */
1695 add_fde (dwarf2_fde_table
*fde_table
, struct dwarf2_fde
*fde
)
1697 if (fde
->address_range
== 0)
1698 /* Discard useless FDEs. */
1701 fde_table
->push_back (fde
);
1704 #define DW64_CIE_ID 0xffffffffffffffffULL
1706 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1711 EH_CIE_TYPE_ID
= 1 << 0,
1712 EH_FDE_TYPE_ID
= 1 << 1,
1713 EH_CIE_OR_FDE_TYPE_ID
= EH_CIE_TYPE_ID
| EH_FDE_TYPE_ID
1716 static const gdb_byte
*decode_frame_entry (struct gdbarch
*gdbarch
,
1717 struct comp_unit
*unit
,
1718 const gdb_byte
*start
,
1720 dwarf2_cie_table
&cie_table
,
1721 dwarf2_fde_table
*fde_table
,
1722 enum eh_frame_type entry_type
);
1724 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1725 Return NULL if invalid input, otherwise the next byte to be processed. */
1727 static const gdb_byte
*
1728 decode_frame_entry_1 (struct gdbarch
*gdbarch
,
1729 struct comp_unit
*unit
, const gdb_byte
*start
,
1731 dwarf2_cie_table
&cie_table
,
1732 dwarf2_fde_table
*fde_table
,
1733 enum eh_frame_type entry_type
)
1735 const gdb_byte
*buf
, *end
;
1737 unsigned int bytes_read
;
1740 ULONGEST cie_pointer
;
1745 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
, false);
1747 end
= buf
+ (size_t) length
;
1752 /* Are we still within the section? */
1753 if (end
<= buf
|| end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1756 /* Distinguish between 32 and 64-bit encoded frame info. */
1757 dwarf64_p
= (bytes_read
== 12);
1759 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1763 cie_id
= DW64_CIE_ID
;
1769 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1774 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1778 if (cie_pointer
== cie_id
)
1780 /* This is a CIE. */
1781 struct dwarf2_cie
*cie
;
1783 unsigned int cie_version
;
1785 /* Check that a CIE was expected. */
1786 if ((entry_type
& EH_CIE_TYPE_ID
) == 0)
1787 error (_("Found a CIE when not expecting it."));
1789 /* Record the offset into the .debug_frame section of this CIE. */
1790 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1792 /* Check whether we've already read it. */
1793 if (find_cie (cie_table
, cie_pointer
))
1796 cie
= XOBNEW (&unit
->obstack
, struct dwarf2_cie
);
1797 cie
->initial_instructions
= NULL
;
1798 cie
->cie_pointer
= cie_pointer
;
1800 /* The encoding for FDE's in a normal .debug_frame section
1801 depends on the target address size. */
1802 cie
->encoding
= DW_EH_PE_absptr
;
1804 /* We'll determine the final value later, but we need to
1805 initialize it conservatively. */
1806 cie
->signal_frame
= 0;
1808 /* Check version number. */
1809 cie_version
= read_1_byte (unit
->abfd
, buf
);
1810 if (cie_version
!= 1 && cie_version
!= 3 && cie_version
!= 4)
1812 cie
->version
= cie_version
;
1815 /* Interpret the interesting bits of the augmentation. */
1816 cie
->augmentation
= augmentation
= (char *) buf
;
1817 buf
+= (strlen (augmentation
) + 1);
1819 /* Ignore armcc augmentations. We only use them for quirks,
1820 and that doesn't happen until later. */
1821 if (startswith (augmentation
, "armcc"))
1822 augmentation
+= strlen (augmentation
);
1824 /* The GCC 2.x "eh" augmentation has a pointer immediately
1825 following the augmentation string, so it must be handled
1827 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1830 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1834 if (cie
->version
>= 4)
1836 /* FIXME: check that this is the same as from the CU header. */
1837 cie
->addr_size
= read_1_byte (unit
->abfd
, buf
);
1839 cie
->segment_size
= read_1_byte (unit
->abfd
, buf
);
1844 cie
->addr_size
= gdbarch_dwarf2_addr_size (gdbarch
);
1845 cie
->segment_size
= 0;
1847 /* Address values in .eh_frame sections are defined to have the
1848 target's pointer size. Watchout: This breaks frame info for
1849 targets with pointer size < address size, unless a .debug_frame
1850 section exists as well. */
1852 cie
->ptr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1854 cie
->ptr_size
= cie
->addr_size
;
1856 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
1859 cie
->code_alignment_factor
= uleb128
;
1861 buf
= gdb_read_sleb128 (buf
, end
, &sleb128
);
1864 cie
->data_alignment_factor
= sleb128
;
1866 if (cie_version
== 1)
1868 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1873 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
1876 cie
->return_address_register
= uleb128
;
1879 cie
->return_address_register
1880 = dwarf2_frame_adjust_regnum (gdbarch
,
1881 cie
->return_address_register
,
1884 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1885 if (cie
->saw_z_augmentation
)
1887 uint64_t uleb_length
;
1889 buf
= gdb_read_uleb128 (buf
, end
, &uleb_length
);
1892 cie
->initial_instructions
= buf
+ uleb_length
;
1896 while (*augmentation
)
1898 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1899 if (*augmentation
== 'L')
1906 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1907 else if (*augmentation
== 'R')
1909 cie
->encoding
= *buf
++;
1913 /* "P" indicates a personality routine in the CIE augmentation. */
1914 else if (*augmentation
== 'P')
1916 /* Skip. Avoid indirection since we throw away the result. */
1917 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1918 read_encoded_value (unit
, encoding
, cie
->ptr_size
,
1919 buf
, &bytes_read
, 0);
1924 /* "S" indicates a signal frame, such that the return
1925 address must not be decremented to locate the call frame
1926 info for the previous frame; it might even be the first
1927 instruction of a function, so decrementing it would take
1928 us to a different function. */
1929 else if (*augmentation
== 'S')
1931 cie
->signal_frame
= 1;
1935 /* Otherwise we have an unknown augmentation. Assume that either
1936 there is no augmentation data, or we saw a 'z' prefix. */
1939 if (cie
->initial_instructions
)
1940 buf
= cie
->initial_instructions
;
1945 cie
->initial_instructions
= buf
;
1949 cie_table
[cie
->cie_pointer
] = cie
;
1953 /* This is a FDE. */
1954 struct dwarf2_fde
*fde
;
1957 /* Check that an FDE was expected. */
1958 if ((entry_type
& EH_FDE_TYPE_ID
) == 0)
1959 error (_("Found an FDE when not expecting it."));
1961 /* In an .eh_frame section, the CIE pointer is the delta between the
1962 address within the FDE where the CIE pointer is stored and the
1963 address of the CIE. Convert it to an offset into the .eh_frame
1967 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1968 cie_pointer
-= (dwarf64_p
? 8 : 4);
1971 /* In either case, validate the result is still within the section. */
1972 if (cie_pointer
>= unit
->dwarf_frame_size
)
1975 fde
= XOBNEW (&unit
->obstack
, struct dwarf2_fde
);
1976 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1977 if (fde
->cie
== NULL
)
1979 decode_frame_entry (gdbarch
, unit
,
1980 unit
->dwarf_frame_buffer
+ cie_pointer
,
1981 eh_frame_p
, cie_table
, fde_table
,
1983 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1986 gdb_assert (fde
->cie
!= NULL
);
1988 addr
= read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->ptr_size
,
1989 buf
, &bytes_read
, 0);
1990 fde
->initial_location
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
1993 fde
->address_range
=
1994 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1995 fde
->cie
->ptr_size
, buf
, &bytes_read
, 0);
1996 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ fde
->address_range
);
1997 fde
->address_range
= addr
- fde
->initial_location
;
2000 /* A 'z' augmentation in the CIE implies the presence of an
2001 augmentation field in the FDE as well. The only thing known
2002 to be in here at present is the LSDA entry for EH. So we
2003 can skip the whole thing. */
2004 if (fde
->cie
->saw_z_augmentation
)
2006 uint64_t uleb_length
;
2008 buf
= gdb_read_uleb128 (buf
, end
, &uleb_length
);
2016 fde
->instructions
= buf
;
2019 fde
->eh_frame_p
= eh_frame_p
;
2021 add_fde (fde_table
, fde
);
2027 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2028 expect an FDE or a CIE. */
2030 static const gdb_byte
*
2031 decode_frame_entry (struct gdbarch
*gdbarch
,
2032 struct comp_unit
*unit
, const gdb_byte
*start
,
2034 dwarf2_cie_table
&cie_table
,
2035 dwarf2_fde_table
*fde_table
,
2036 enum eh_frame_type entry_type
)
2038 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
2039 const gdb_byte
*ret
;
2040 ptrdiff_t start_offset
;
2044 ret
= decode_frame_entry_1 (gdbarch
, unit
, start
, eh_frame_p
,
2045 cie_table
, fde_table
, entry_type
);
2049 /* We have corrupt input data of some form. */
2051 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2052 and mismatches wrt padding and alignment of debug sections. */
2053 /* Note that there is no requirement in the standard for any
2054 alignment at all in the frame unwind sections. Testing for
2055 alignment before trying to interpret data would be incorrect.
2057 However, GCC traditionally arranged for frame sections to be
2058 sized such that the FDE length and CIE fields happen to be
2059 aligned (in theory, for performance). This, unfortunately,
2060 was done with .align directives, which had the side effect of
2061 forcing the section to be aligned by the linker.
2063 This becomes a problem when you have some other producer that
2064 creates frame sections that are not as strictly aligned. That
2065 produces a hole in the frame info that gets filled by the
2068 The GCC behaviour is arguably a bug, but it's effectively now
2069 part of the ABI, so we're now stuck with it, at least at the
2070 object file level. A smart linker may decide, in the process
2071 of compressing duplicate CIE information, that it can rewrite
2072 the entire output section without this extra padding. */
2074 start_offset
= start
- unit
->dwarf_frame_buffer
;
2075 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
2077 start
+= 4 - (start_offset
& 3);
2078 workaround
= ALIGN4
;
2081 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
2083 start
+= 8 - (start_offset
& 7);
2084 workaround
= ALIGN8
;
2088 /* Nothing left to try. Arrange to return as if we've consumed
2089 the entire input section. Hopefully we'll get valid info from
2090 the other of .debug_frame/.eh_frame. */
2092 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
2103 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2104 unit
->dwarf_frame_section
->owner
->filename
,
2105 unit
->dwarf_frame_section
->name
);
2110 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2111 unit
->dwarf_frame_section
->owner
->filename
,
2112 unit
->dwarf_frame_section
->name
);
2116 complaint (_("Corrupt data in %s:%s"),
2117 unit
->dwarf_frame_section
->owner
->filename
,
2118 unit
->dwarf_frame_section
->name
);
2126 fde_is_less_than (const dwarf2_fde
*aa
, const dwarf2_fde
*bb
)
2128 if (aa
->initial_location
== bb
->initial_location
)
2130 if (aa
->address_range
!= bb
->address_range
2131 && aa
->eh_frame_p
== 0 && bb
->eh_frame_p
== 0)
2132 /* Linker bug, e.g. gold/10400.
2133 Work around it by keeping stable sort order. */
2136 /* Put eh_frame entries after debug_frame ones. */
2137 return aa
->eh_frame_p
< bb
->eh_frame_p
;
2140 return aa
->initial_location
< bb
->initial_location
;
2144 dwarf2_build_frame_info (struct objfile
*objfile
)
2146 const gdb_byte
*frame_ptr
;
2147 dwarf2_cie_table cie_table
;
2148 dwarf2_fde_table fde_table
;
2150 struct gdbarch
*gdbarch
= objfile
->arch ();
2152 /* Build a minimal decoding of the DWARF2 compilation unit. */
2153 std::unique_ptr
<comp_unit
> unit (new comp_unit (objfile
));
2155 if (objfile
->separate_debug_objfile_backlink
== NULL
)
2157 /* Do not read .eh_frame from separate file as they must be also
2158 present in the main file. */
2159 dwarf2_get_section_info (objfile
, DWARF2_EH_FRAME
,
2160 &unit
->dwarf_frame_section
,
2161 &unit
->dwarf_frame_buffer
,
2162 &unit
->dwarf_frame_size
);
2163 if (unit
->dwarf_frame_size
)
2165 asection
*got
, *txt
;
2167 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2168 that is used for the i386/amd64 target, which currently is
2169 the only target in GCC that supports/uses the
2170 DW_EH_PE_datarel encoding. */
2171 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2173 unit
->dbase
= got
->vma
;
2175 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2177 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2179 unit
->tbase
= txt
->vma
;
2183 frame_ptr
= unit
->dwarf_frame_buffer
;
2184 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2185 frame_ptr
= decode_frame_entry (gdbarch
, unit
.get (),
2187 cie_table
, &fde_table
,
2188 EH_CIE_OR_FDE_TYPE_ID
);
2191 catch (const gdb_exception_error
&e
)
2193 warning (_("skipping .eh_frame info of %s: %s"),
2194 objfile_name (objfile
), e
.what ());
2197 /* The cie_table is discarded below. */
2204 dwarf2_get_section_info (objfile
, DWARF2_DEBUG_FRAME
,
2205 &unit
->dwarf_frame_section
,
2206 &unit
->dwarf_frame_buffer
,
2207 &unit
->dwarf_frame_size
);
2208 if (unit
->dwarf_frame_size
)
2210 size_t num_old_fde_entries
= fde_table
.size ();
2214 frame_ptr
= unit
->dwarf_frame_buffer
;
2215 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2216 frame_ptr
= decode_frame_entry (gdbarch
, unit
.get (), frame_ptr
, 0,
2217 cie_table
, &fde_table
,
2218 EH_CIE_OR_FDE_TYPE_ID
);
2220 catch (const gdb_exception_error
&e
)
2222 warning (_("skipping .debug_frame info of %s: %s"),
2223 objfile_name (objfile
), e
.what ());
2225 fde_table
.resize (num_old_fde_entries
);
2229 struct dwarf2_fde
*fde_prev
= NULL
;
2230 struct dwarf2_fde
*first_non_zero_fde
= NULL
;
2232 /* Prepare FDE table for lookups. */
2233 std::sort (fde_table
.begin (), fde_table
.end (), fde_is_less_than
);
2235 /* Check for leftovers from --gc-sections. The GNU linker sets
2236 the relevant symbols to zero, but doesn't zero the FDE *end*
2237 ranges because there's no relocation there. It's (offset,
2238 length), not (start, end). On targets where address zero is
2239 just another valid address this can be a problem, since the
2240 FDEs appear to be non-empty in the output --- we could pick
2241 out the wrong FDE. To work around this, when overlaps are
2242 detected, we prefer FDEs that do not start at zero.
2244 Start by finding the first FDE with non-zero start. Below
2245 we'll discard all FDEs that start at zero and overlap this
2247 for (struct dwarf2_fde
*fde
: fde_table
)
2249 if (fde
->initial_location
!= 0)
2251 first_non_zero_fde
= fde
;
2256 /* Since we'll be doing bsearch, squeeze out identical (except
2257 for eh_frame_p) fde entries so bsearch result is predictable.
2258 Also discard leftovers from --gc-sections. */
2259 for (struct dwarf2_fde
*fde
: fde_table
)
2261 if (fde
->initial_location
== 0
2262 && first_non_zero_fde
!= NULL
2263 && (first_non_zero_fde
->initial_location
2264 < fde
->initial_location
+ fde
->address_range
))
2267 if (fde_prev
!= NULL
2268 && fde_prev
->initial_location
== fde
->initial_location
)
2271 unit
->fde_table
.push_back (fde
);
2274 unit
->fde_table
.shrink_to_fit ();
2276 set_comp_unit (objfile
, unit
.release ());
2279 /* Handle 'maintenance show dwarf unwinders'. */
2282 show_dwarf_unwinders_enabled_p (struct ui_file
*file
, int from_tty
,
2283 struct cmd_list_element
*c
,
2286 fprintf_filtered (file
,
2287 _("The DWARF stack unwinders are currently %s.\n"),
2291 void _initialize_dwarf2_frame ();
2293 _initialize_dwarf2_frame ()
2295 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2297 add_setshow_boolean_cmd ("unwinders", class_obscure
,
2298 &dwarf2_frame_unwinders_enabled_p
, _("\
2299 Set whether the DWARF stack frame unwinders are used."), _("\
2300 Show whether the DWARF stack frame unwinders are used."), _("\
2301 When enabled the DWARF stack frame unwinders can be used for architectures\n\
2302 that support the DWARF unwinders. Enabling the DWARF unwinders for an\n\
2303 architecture that doesn't support them will have no effect."),
2305 show_dwarf_unwinders_enabled_p
,
2307 &show_dwarf_cmdlist
);
2310 selftests::register_test_foreach_arch ("execute_cfa_program",
2311 selftests::execute_cfa_program_test
);