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 /* Keep the bfd convenient. */
142 struct objfile
*objfile
;
144 /* Pointer to the .debug_frame section loaded into memory. */
145 const gdb_byte
*dwarf_frame_buffer
;
147 /* Length of the loaded .debug_frame section. */
148 bfd_size_type dwarf_frame_size
;
150 /* Pointer to the .debug_frame section. */
151 asection
*dwarf_frame_section
;
153 /* Base for DW_EH_PE_datarel encodings. */
156 /* Base for DW_EH_PE_textrel encodings. */
160 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
,
161 CORE_ADDR
*out_offset
);
163 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
166 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
167 int ptr_len
, const gdb_byte
*buf
,
168 unsigned int *bytes_read_ptr
,
169 CORE_ADDR func_base
);
172 /* See dwarf2-frame.h. */
173 bool dwarf2_frame_unwinders_enabled_p
= true;
175 /* Store the length the expression for the CFA in the `cfa_reg' field,
176 which is unused in that case. */
177 #define cfa_exp_len cfa_reg
179 dwarf2_frame_state::dwarf2_frame_state (CORE_ADDR pc_
, struct dwarf2_cie
*cie
)
180 : pc (pc_
), data_align (cie
->data_alignment_factor
),
181 code_align (cie
->code_alignment_factor
),
182 retaddr_column (cie
->return_address_register
)
187 /* Helper functions for execute_stack_op. */
190 read_addr_from_reg (struct frame_info
*this_frame
, int reg
)
192 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
193 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
195 return address_from_register (regnum
, this_frame
);
198 /* Execute the required actions for both the DW_CFA_restore and
199 DW_CFA_restore_extended instructions. */
201 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
202 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
206 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
207 fs
->regs
.alloc_regs (reg
+ 1);
209 /* Check if this register was explicitly initialized in the
210 CIE initial instructions. If not, default the rule to
212 if (reg
< fs
->initial
.reg
.size ())
213 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
215 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
217 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
219 int regnum
= dwarf_reg_to_regnum (gdbarch
, reg
);
222 incomplete CFI data; DW_CFA_restore unspecified\n\
223 register %s (#%d) at %s"),
224 gdbarch_register_name (gdbarch
, regnum
), regnum
,
225 paddress (gdbarch
, fs
->pc
));
229 class dwarf_expr_executor
: public dwarf_expr_context
233 struct frame_info
*this_frame
;
235 CORE_ADDR
read_addr_from_reg (int reg
) override
237 return ::read_addr_from_reg (this_frame
, reg
);
240 struct value
*get_reg_value (struct type
*type
, int reg
) override
242 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
243 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
245 return value_from_register (type
, regnum
, this_frame
);
248 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
250 read_memory (addr
, buf
, len
);
253 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
255 invalid ("DW_OP_fbreg");
258 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
259 union call_site_parameter_u kind_u
,
260 int deref_size
) override
262 invalid ("DW_OP_entry_value");
265 CORE_ADDR
get_object_address () override
267 invalid ("DW_OP_push_object_address");
270 CORE_ADDR
get_frame_cfa () override
272 invalid ("DW_OP_call_frame_cfa");
275 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
277 invalid ("DW_OP_form_tls_address");
280 void dwarf_call (cu_offset die_offset
) override
282 invalid ("DW_OP_call*");
285 struct value
*dwarf_variable_value (sect_offset sect_off
) override
287 invalid ("DW_OP_GNU_variable_value");
290 CORE_ADDR
get_addr_index (unsigned int index
) override
292 invalid ("DW_OP_addrx or DW_OP_GNU_addr_index");
297 void invalid (const char *op
) ATTRIBUTE_NORETURN
299 error (_("%s is invalid in this context"), op
);
304 execute_stack_op (const gdb_byte
*exp
, ULONGEST len
, int addr_size
,
305 CORE_ADDR offset
, struct frame_info
*this_frame
,
306 CORE_ADDR initial
, int initial_in_stack_memory
)
310 dwarf_expr_executor ctx
;
311 scoped_value_mark free_values
;
313 ctx
.this_frame
= this_frame
;
314 ctx
.gdbarch
= get_frame_arch (this_frame
);
315 ctx
.addr_size
= addr_size
;
316 ctx
.ref_addr_size
= -1;
319 ctx
.push_address (initial
, initial_in_stack_memory
);
322 if (ctx
.location
== DWARF_VALUE_MEMORY
)
323 result
= ctx
.fetch_address (0);
324 else if (ctx
.location
== DWARF_VALUE_REGISTER
)
325 result
= ctx
.read_addr_from_reg (value_as_long (ctx
.fetch (0)));
328 /* This is actually invalid DWARF, but if we ever do run across
329 it somehow, we might as well support it. So, instead, report
330 it as unimplemented. */
332 Not implemented: computing unwound register using explicit value operator"));
339 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
340 PC. Modify FS state accordingly. Return current INSN_PTR where the
341 execution has stopped, one can resume it on the next call. */
343 static const gdb_byte
*
344 execute_cfa_program (struct dwarf2_fde
*fde
, const gdb_byte
*insn_ptr
,
345 const gdb_byte
*insn_end
, struct gdbarch
*gdbarch
,
346 CORE_ADDR pc
, struct dwarf2_frame_state
*fs
)
348 int eh_frame_p
= fde
->eh_frame_p
;
349 unsigned int bytes_read
;
350 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
352 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
354 gdb_byte insn
= *insn_ptr
++;
358 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
359 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
360 else if ((insn
& 0xc0) == DW_CFA_offset
)
363 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
364 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
365 offset
= utmp
* fs
->data_align
;
366 fs
->regs
.alloc_regs (reg
+ 1);
367 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
368 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
370 else if ((insn
& 0xc0) == DW_CFA_restore
)
373 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
380 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
381 fde
->cie
->ptr_size
, insn_ptr
,
382 &bytes_read
, fde
->initial_location
);
383 /* Apply the objfile offset for relocatable objects. */
384 fs
->pc
+= fde
->cie
->unit
->objfile
->text_section_offset ();
385 insn_ptr
+= bytes_read
;
388 case DW_CFA_advance_loc1
:
389 utmp
= extract_unsigned_integer (insn_ptr
, 1, byte_order
);
390 fs
->pc
+= utmp
* fs
->code_align
;
393 case DW_CFA_advance_loc2
:
394 utmp
= extract_unsigned_integer (insn_ptr
, 2, byte_order
);
395 fs
->pc
+= utmp
* fs
->code_align
;
398 case DW_CFA_advance_loc4
:
399 utmp
= extract_unsigned_integer (insn_ptr
, 4, byte_order
);
400 fs
->pc
+= utmp
* fs
->code_align
;
404 case DW_CFA_offset_extended
:
405 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
406 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
407 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
408 offset
= utmp
* fs
->data_align
;
409 fs
->regs
.alloc_regs (reg
+ 1);
410 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
411 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
414 case DW_CFA_restore_extended
:
415 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
416 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
419 case DW_CFA_undefined
:
420 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
421 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
422 fs
->regs
.alloc_regs (reg
+ 1);
423 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
426 case DW_CFA_same_value
:
427 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
428 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
429 fs
->regs
.alloc_regs (reg
+ 1);
430 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
433 case DW_CFA_register
:
434 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
435 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
436 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
437 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
438 fs
->regs
.alloc_regs (reg
+ 1);
439 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
440 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
443 case DW_CFA_remember_state
:
445 struct dwarf2_frame_state_reg_info
*new_rs
;
447 new_rs
= new dwarf2_frame_state_reg_info (fs
->regs
);
448 fs
->regs
.prev
= new_rs
;
452 case DW_CFA_restore_state
:
454 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
459 bad CFI data; mismatched DW_CFA_restore_state at %s"),
460 paddress (gdbarch
, fs
->pc
));
463 fs
->regs
= std::move (*old_rs
);
468 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
469 fs
->regs
.cfa_reg
= reg
;
470 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
472 if (fs
->armcc_cfa_offsets_sf
)
473 utmp
*= fs
->data_align
;
475 fs
->regs
.cfa_offset
= utmp
;
476 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
479 case DW_CFA_def_cfa_register
:
480 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
481 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
483 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
486 case DW_CFA_def_cfa_offset
:
487 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
489 if (fs
->armcc_cfa_offsets_sf
)
490 utmp
*= fs
->data_align
;
492 fs
->regs
.cfa_offset
= utmp
;
493 /* cfa_how deliberately not set. */
499 case DW_CFA_def_cfa_expression
:
500 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
501 fs
->regs
.cfa_exp_len
= utmp
;
502 fs
->regs
.cfa_exp
= insn_ptr
;
503 fs
->regs
.cfa_how
= CFA_EXP
;
504 insn_ptr
+= fs
->regs
.cfa_exp_len
;
507 case DW_CFA_expression
:
508 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
509 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
510 fs
->regs
.alloc_regs (reg
+ 1);
511 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
512 fs
->regs
.reg
[reg
].loc
.exp
.start
= insn_ptr
;
513 fs
->regs
.reg
[reg
].loc
.exp
.len
= utmp
;
514 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
518 case DW_CFA_offset_extended_sf
:
519 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
520 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
521 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
522 offset
*= fs
->data_align
;
523 fs
->regs
.alloc_regs (reg
+ 1);
524 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
525 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
528 case DW_CFA_val_offset
:
529 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
530 fs
->regs
.alloc_regs (reg
+ 1);
531 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
532 offset
= utmp
* fs
->data_align
;
533 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
534 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
537 case DW_CFA_val_offset_sf
:
538 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
539 fs
->regs
.alloc_regs (reg
+ 1);
540 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
541 offset
*= fs
->data_align
;
542 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
543 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
546 case DW_CFA_val_expression
:
547 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
548 fs
->regs
.alloc_regs (reg
+ 1);
549 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
550 fs
->regs
.reg
[reg
].loc
.exp
.start
= insn_ptr
;
551 fs
->regs
.reg
[reg
].loc
.exp
.len
= utmp
;
552 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
556 case DW_CFA_def_cfa_sf
:
557 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
558 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
560 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
561 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
562 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
565 case DW_CFA_def_cfa_offset_sf
:
566 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
567 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
568 /* cfa_how deliberately not set. */
571 case DW_CFA_GNU_args_size
:
573 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
576 case DW_CFA_GNU_negative_offset_extended
:
577 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
578 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
579 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
580 offset
= utmp
* fs
->data_align
;
581 fs
->regs
.alloc_regs (reg
+ 1);
582 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
583 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
587 if (insn
>= DW_CFA_lo_user
&& insn
<= DW_CFA_hi_user
)
589 /* Handle vendor-specific CFI for different architectures. */
590 if (!gdbarch_execute_dwarf_cfa_vendor_op (gdbarch
, insn
, fs
))
591 error (_("Call Frame Instruction op %d in vendor extension "
592 "space is not handled on this architecture."),
596 internal_error (__FILE__
, __LINE__
,
597 _("Unknown CFI encountered."));
602 if (fs
->initial
.reg
.empty ())
604 /* Don't allow remember/restore between CIE and FDE programs. */
605 delete fs
->regs
.prev
;
606 fs
->regs
.prev
= NULL
;
614 namespace selftests
{
616 /* Unit test to function execute_cfa_program. */
619 execute_cfa_program_test (struct gdbarch
*gdbarch
)
621 struct dwarf2_fde fde
;
622 struct dwarf2_cie cie
;
624 memset (&fde
, 0, sizeof fde
);
625 memset (&cie
, 0, sizeof cie
);
627 cie
.data_alignment_factor
= -4;
628 cie
.code_alignment_factor
= 2;
631 dwarf2_frame_state
fs (0, fde
.cie
);
635 DW_CFA_def_cfa
, 1, 4, /* DW_CFA_def_cfa: r1 ofs 4 */
636 DW_CFA_offset
| 0x2, 1, /* DW_CFA_offset: r2 at cfa-4 */
637 DW_CFA_remember_state
,
638 DW_CFA_restore_state
,
641 const gdb_byte
*insn_end
= insns
+ sizeof (insns
);
642 const gdb_byte
*out
= execute_cfa_program (&fde
, insns
, insn_end
, gdbarch
,
645 SELF_CHECK (out
== insn_end
);
646 SELF_CHECK (fs
.pc
== 0);
648 /* The instructions above only use r1 and r2, but the register numbers
649 used are adjusted by dwarf2_frame_adjust_regnum. */
650 auto r1
= dwarf2_frame_adjust_regnum (gdbarch
, 1, fde
.eh_frame_p
);
651 auto r2
= dwarf2_frame_adjust_regnum (gdbarch
, 2, fde
.eh_frame_p
);
653 SELF_CHECK (fs
.regs
.reg
.size () == (std::max (r1
, r2
) + 1));
655 SELF_CHECK (fs
.regs
.reg
[r2
].how
== DWARF2_FRAME_REG_SAVED_OFFSET
);
656 SELF_CHECK (fs
.regs
.reg
[r2
].loc
.offset
== -4);
658 for (auto i
= 0; i
< fs
.regs
.reg
.size (); i
++)
660 SELF_CHECK (fs
.regs
.reg
[i
].how
== DWARF2_FRAME_REG_UNSPECIFIED
);
662 SELF_CHECK (fs
.regs
.cfa_reg
== 1);
663 SELF_CHECK (fs
.regs
.cfa_offset
== 4);
664 SELF_CHECK (fs
.regs
.cfa_how
== CFA_REG_OFFSET
);
665 SELF_CHECK (fs
.regs
.cfa_exp
== NULL
);
666 SELF_CHECK (fs
.regs
.prev
== NULL
);
669 } // namespace selftests
670 #endif /* GDB_SELF_TEST */
674 /* Architecture-specific operations. */
676 /* Per-architecture data key. */
677 static struct gdbarch_data
*dwarf2_frame_data
;
679 struct dwarf2_frame_ops
681 /* Pre-initialize the register state REG for register REGNUM. */
682 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
683 struct frame_info
*);
685 /* Check whether the THIS_FRAME is a signal trampoline. */
686 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
688 /* Convert .eh_frame register number to DWARF register number, or
689 adjust .debug_frame register number. */
690 int (*adjust_regnum
) (struct gdbarch
*, int, int);
693 /* Default architecture-specific register state initialization
697 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
698 struct dwarf2_frame_state_reg
*reg
,
699 struct frame_info
*this_frame
)
701 /* If we have a register that acts as a program counter, mark it as
702 a destination for the return address. If we have a register that
703 serves as the stack pointer, arrange for it to be filled with the
704 call frame address (CFA). The other registers are marked as
707 We copy the return address to the program counter, since many
708 parts in GDB assume that it is possible to get the return address
709 by unwinding the program counter register. However, on ISA's
710 with a dedicated return address register, the CFI usually only
711 contains information to unwind that return address register.
713 The reason we're treating the stack pointer special here is
714 because in many cases GCC doesn't emit CFI for the stack pointer
715 and implicitly assumes that it is equal to the CFA. This makes
716 some sense since the DWARF specification (version 3, draft 8,
719 "Typically, the CFA is defined to be the value of the stack
720 pointer at the call site in the previous frame (which may be
721 different from its value on entry to the current frame)."
723 However, this isn't true for all platforms supported by GCC
724 (e.g. IBM S/390 and zSeries). Those architectures should provide
725 their own architecture-specific initialization function. */
727 if (regnum
== gdbarch_pc_regnum (gdbarch
))
728 reg
->how
= DWARF2_FRAME_REG_RA
;
729 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
730 reg
->how
= DWARF2_FRAME_REG_CFA
;
733 /* Return a default for the architecture-specific operations. */
736 dwarf2_frame_init (struct obstack
*obstack
)
738 struct dwarf2_frame_ops
*ops
;
740 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
741 ops
->init_reg
= dwarf2_frame_default_init_reg
;
745 /* Set the architecture-specific register state initialization
746 function for GDBARCH to INIT_REG. */
749 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
750 void (*init_reg
) (struct gdbarch
*, int,
751 struct dwarf2_frame_state_reg
*,
752 struct frame_info
*))
754 struct dwarf2_frame_ops
*ops
755 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
757 ops
->init_reg
= init_reg
;
760 /* Pre-initialize the register state REG for register REGNUM. */
763 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
764 struct dwarf2_frame_state_reg
*reg
,
765 struct frame_info
*this_frame
)
767 struct dwarf2_frame_ops
*ops
768 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
770 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
773 /* Set the architecture-specific signal trampoline recognition
774 function for GDBARCH to SIGNAL_FRAME_P. */
777 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
778 int (*signal_frame_p
) (struct gdbarch
*,
779 struct frame_info
*))
781 struct dwarf2_frame_ops
*ops
782 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
784 ops
->signal_frame_p
= signal_frame_p
;
787 /* Query the architecture-specific signal frame recognizer for
791 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
792 struct frame_info
*this_frame
)
794 struct dwarf2_frame_ops
*ops
795 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
797 if (ops
->signal_frame_p
== NULL
)
799 return ops
->signal_frame_p (gdbarch
, this_frame
);
802 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
806 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
807 int (*adjust_regnum
) (struct gdbarch
*,
810 struct dwarf2_frame_ops
*ops
811 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
813 ops
->adjust_regnum
= adjust_regnum
;
816 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
820 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
,
821 int regnum
, int eh_frame_p
)
823 struct dwarf2_frame_ops
*ops
824 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
826 if (ops
->adjust_regnum
== NULL
)
828 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
832 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
833 struct dwarf2_fde
*fde
)
835 struct compunit_symtab
*cust
;
837 cust
= find_pc_compunit_symtab (fs
->pc
);
841 if (producer_is_realview (COMPUNIT_PRODUCER (cust
)))
843 if (fde
->cie
->version
== 1)
844 fs
->armcc_cfa_offsets_sf
= 1;
846 if (fde
->cie
->version
== 1)
847 fs
->armcc_cfa_offsets_reversed
= 1;
849 /* The reversed offset problem is present in some compilers
850 using DWARF3, but it was eventually fixed. Check the ARM
851 defined augmentations, which are in the format "armcc" followed
852 by a list of one-character options. The "+" option means
853 this problem is fixed (no quirk needed). If the armcc
854 augmentation is missing, the quirk is needed. */
855 if (fde
->cie
->version
== 3
856 && (!startswith (fde
->cie
->augmentation
, "armcc")
857 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
858 fs
->armcc_cfa_offsets_reversed
= 1;
865 /* See dwarf2-frame.h. */
868 dwarf2_fetch_cfa_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
869 struct dwarf2_per_cu_data
*data
,
870 int *regnum_out
, LONGEST
*offset_out
,
871 CORE_ADDR
*text_offset_out
,
872 const gdb_byte
**cfa_start_out
,
873 const gdb_byte
**cfa_end_out
)
875 struct dwarf2_fde
*fde
;
876 CORE_ADDR text_offset
;
879 /* Find the correct FDE. */
880 fde
= dwarf2_frame_find_fde (&pc1
, &text_offset
);
882 error (_("Could not compute CFA; needed to translate this expression"));
884 dwarf2_frame_state
fs (pc1
, fde
->cie
);
886 /* Check for "quirks" - known bugs in producers. */
887 dwarf2_frame_find_quirks (&fs
, fde
);
889 /* First decode all the insns in the CIE. */
890 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
891 fde
->cie
->end
, gdbarch
, pc
, &fs
);
893 /* Save the initialized register set. */
894 fs
.initial
= fs
.regs
;
896 /* Then decode the insns in the FDE up to our target PC. */
897 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
, pc
, &fs
);
899 /* Calculate the CFA. */
900 switch (fs
.regs
.cfa_how
)
904 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, fs
.regs
.cfa_reg
);
906 *regnum_out
= regnum
;
907 if (fs
.armcc_cfa_offsets_reversed
)
908 *offset_out
= -fs
.regs
.cfa_offset
;
910 *offset_out
= fs
.regs
.cfa_offset
;
915 *text_offset_out
= text_offset
;
916 *cfa_start_out
= fs
.regs
.cfa_exp
;
917 *cfa_end_out
= fs
.regs
.cfa_exp
+ fs
.regs
.cfa_exp_len
;
921 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
926 struct dwarf2_frame_cache
928 /* DWARF Call Frame Address. */
931 /* Set if the return address column was marked as unavailable
932 (required non-collected memory or registers to compute). */
933 int unavailable_retaddr
;
935 /* Set if the return address column was marked as undefined. */
936 int undefined_retaddr
;
938 /* Saved registers, indexed by GDB register number, not by DWARF
940 struct dwarf2_frame_state_reg
*reg
;
942 /* Return address register. */
943 struct dwarf2_frame_state_reg retaddr_reg
;
945 /* Target address size in bytes. */
948 /* The .text offset. */
949 CORE_ADDR text_offset
;
951 /* True if we already checked whether this frame is the bottom frame
952 of a virtual tail call frame chain. */
953 int checked_tailcall_bottom
;
955 /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
956 sequence. If NULL then it is a normal case with no TAILCALL_FRAME
957 involved. Non-bottom frames of a virtual tail call frames chain use
958 dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
960 void *tailcall_cache
;
962 /* The number of bytes to subtract from TAILCALL_FRAME frames frame
963 base to get the SP, to simulate the return address pushed on the
965 LONGEST entry_cfa_sp_offset
;
966 int entry_cfa_sp_offset_p
;
969 static struct dwarf2_frame_cache
*
970 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
972 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
973 const int num_regs
= gdbarch_num_cooked_regs (gdbarch
);
974 struct dwarf2_frame_cache
*cache
;
975 struct dwarf2_fde
*fde
;
977 const gdb_byte
*instr
;
980 return (struct dwarf2_frame_cache
*) *this_cache
;
982 /* Allocate a new cache. */
983 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
984 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
989 Note that if the next frame is never supposed to return (i.e. a call
990 to abort), the compiler might optimize away the instruction at
991 its return address. As a result the return address will
992 point at some random instruction, and the CFI for that
993 instruction is probably worthless to us. GCC's unwinder solves
994 this problem by substracting 1 from the return address to get an
995 address in the middle of a presumed call instruction (or the
996 instruction in the associated delay slot). This should only be
997 done for "normal" frames and not for resume-type frames (signal
998 handlers, sentinel frames, dummy frames). The function
999 get_frame_address_in_block does just this. It's not clear how
1000 reliable the method is though; there is the potential for the
1001 register state pre-call being different to that on return. */
1002 CORE_ADDR pc1
= get_frame_address_in_block (this_frame
);
1004 /* Find the correct FDE. */
1005 fde
= dwarf2_frame_find_fde (&pc1
, &cache
->text_offset
);
1006 gdb_assert (fde
!= NULL
);
1008 /* Allocate and initialize the frame state. */
1009 struct dwarf2_frame_state
fs (pc1
, fde
->cie
);
1011 cache
->addr_size
= fde
->cie
->addr_size
;
1013 /* Check for "quirks" - known bugs in producers. */
1014 dwarf2_frame_find_quirks (&fs
, fde
);
1016 /* First decode all the insns in the CIE. */
1017 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
1018 fde
->cie
->end
, gdbarch
,
1019 get_frame_address_in_block (this_frame
), &fs
);
1021 /* Save the initialized register set. */
1022 fs
.initial
= fs
.regs
;
1024 /* Fetching the entry pc for THIS_FRAME won't necessarily result
1025 in an address that's within the range of FDE locations. This
1026 is due to the possibility of the function occupying non-contiguous
1028 if (get_frame_func_if_available (this_frame
, &entry_pc
)
1029 && fde
->initial_location
<= entry_pc
1030 && entry_pc
< fde
->initial_location
+ fde
->address_range
)
1032 /* Decode the insns in the FDE up to the entry PC. */
1033 instr
= execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
,
1036 if (fs
.regs
.cfa_how
== CFA_REG_OFFSET
1037 && (dwarf_reg_to_regnum (gdbarch
, fs
.regs
.cfa_reg
)
1038 == gdbarch_sp_regnum (gdbarch
)))
1040 cache
->entry_cfa_sp_offset
= fs
.regs
.cfa_offset
;
1041 cache
->entry_cfa_sp_offset_p
= 1;
1045 instr
= fde
->instructions
;
1047 /* Then decode the insns in the FDE up to our target PC. */
1048 execute_cfa_program (fde
, instr
, fde
->end
, gdbarch
,
1049 get_frame_address_in_block (this_frame
), &fs
);
1053 /* Calculate the CFA. */
1054 switch (fs
.regs
.cfa_how
)
1056 case CFA_REG_OFFSET
:
1057 cache
->cfa
= read_addr_from_reg (this_frame
, fs
.regs
.cfa_reg
);
1058 if (fs
.armcc_cfa_offsets_reversed
)
1059 cache
->cfa
-= fs
.regs
.cfa_offset
;
1061 cache
->cfa
+= fs
.regs
.cfa_offset
;
1066 execute_stack_op (fs
.regs
.cfa_exp
, fs
.regs
.cfa_exp_len
,
1067 cache
->addr_size
, cache
->text_offset
,
1072 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
1075 catch (const gdb_exception_error
&ex
)
1077 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1079 cache
->unavailable_retaddr
= 1;
1086 /* Initialize the register state. */
1090 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1091 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
1094 /* Go through the DWARF2 CFI generated table and save its register
1095 location information in the cache. Note that we don't skip the
1096 return address column; it's perfectly all right for it to
1097 correspond to a real register. */
1099 int column
; /* CFI speak for "register number". */
1101 for (column
= 0; column
< fs
.regs
.reg
.size (); column
++)
1103 /* Use the GDB register number as the destination index. */
1104 int regnum
= dwarf_reg_to_regnum (gdbarch
, column
);
1106 /* Protect against a target returning a bad register. */
1107 if (regnum
< 0 || regnum
>= num_regs
)
1110 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1111 of all debug info registers. If it doesn't, complain (but
1112 not too loudly). It turns out that GCC assumes that an
1113 unspecified register implies "same value" when CFI (draft
1114 7) specifies nothing at all. Such a register could equally
1115 be interpreted as "undefined". Also note that this check
1116 isn't sufficient; it only checks that all registers in the
1117 range [0 .. max column] are specified, and won't detect
1118 problems when a debug info register falls outside of the
1119 table. We need a way of iterating through all the valid
1120 DWARF2 register numbers. */
1121 if (fs
.regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1123 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1125 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1126 gdbarch_register_name (gdbarch
, regnum
),
1127 paddress (gdbarch
, fs
.pc
));
1130 cache
->reg
[regnum
] = fs
.regs
.reg
[column
];
1134 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1135 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1139 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1141 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1142 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1144 const std::vector
<struct dwarf2_frame_state_reg
> ®s
1146 ULONGEST retaddr_column
= fs
.retaddr_column
;
1148 /* It seems rather bizarre to specify an "empty" column as
1149 the return adress column. However, this is exactly
1150 what GCC does on some targets. It turns out that GCC
1151 assumes that the return address can be found in the
1152 register corresponding to the return address column.
1153 Incidentally, that's how we should treat a return
1154 address column specifying "same value" too. */
1155 if (fs
.retaddr_column
< fs
.regs
.reg
.size ()
1156 && regs
[retaddr_column
].how
!= DWARF2_FRAME_REG_UNSPECIFIED
1157 && regs
[retaddr_column
].how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1159 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1160 cache
->reg
[regnum
] = regs
[retaddr_column
];
1162 cache
->retaddr_reg
= regs
[retaddr_column
];
1166 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1168 cache
->reg
[regnum
].loc
.reg
= fs
.retaddr_column
;
1169 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1173 cache
->retaddr_reg
.loc
.reg
= fs
.retaddr_column
;
1174 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1181 if (fs
.retaddr_column
< fs
.regs
.reg
.size ()
1182 && fs
.regs
.reg
[fs
.retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1183 cache
->undefined_retaddr
= 1;
1188 static enum unwind_stop_reason
1189 dwarf2_frame_unwind_stop_reason (struct frame_info
*this_frame
,
1192 struct dwarf2_frame_cache
*cache
1193 = dwarf2_frame_cache (this_frame
, this_cache
);
1195 if (cache
->unavailable_retaddr
)
1196 return UNWIND_UNAVAILABLE
;
1198 if (cache
->undefined_retaddr
)
1199 return UNWIND_OUTERMOST
;
1201 return UNWIND_NO_REASON
;
1205 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1206 struct frame_id
*this_id
)
1208 struct dwarf2_frame_cache
*cache
=
1209 dwarf2_frame_cache (this_frame
, this_cache
);
1211 if (cache
->unavailable_retaddr
)
1212 (*this_id
) = frame_id_build_unavailable_stack (get_frame_func (this_frame
));
1213 else if (cache
->undefined_retaddr
)
1216 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1219 static struct value
*
1220 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1223 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1224 struct dwarf2_frame_cache
*cache
=
1225 dwarf2_frame_cache (this_frame
, this_cache
);
1229 /* Check whether THIS_FRAME is the bottom frame of a virtual tail
1230 call frame chain. */
1231 if (!cache
->checked_tailcall_bottom
)
1233 cache
->checked_tailcall_bottom
= 1;
1234 dwarf2_tailcall_sniffer_first (this_frame
, &cache
->tailcall_cache
,
1235 (cache
->entry_cfa_sp_offset_p
1236 ? &cache
->entry_cfa_sp_offset
: NULL
));
1239 /* Non-bottom frames of a virtual tail call frames chain use
1240 dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1241 them. If dwarf2_tailcall_prev_register_first does not have specific value
1242 unwind the register, tail call frames are assumed to have the register set
1243 of the top caller. */
1244 if (cache
->tailcall_cache
)
1248 val
= dwarf2_tailcall_prev_register_first (this_frame
,
1249 &cache
->tailcall_cache
,
1255 switch (cache
->reg
[regnum
].how
)
1257 case DWARF2_FRAME_REG_UNDEFINED
:
1258 /* If CFI explicitly specified that the value isn't defined,
1259 mark it as optimized away; the value isn't available. */
1260 return frame_unwind_got_optimized (this_frame
, regnum
);
1262 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1263 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1264 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1266 case DWARF2_FRAME_REG_SAVED_REG
:
1267 realnum
= dwarf_reg_to_regnum_or_error
1268 (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1269 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1271 case DWARF2_FRAME_REG_SAVED_EXP
:
1272 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
.start
,
1273 cache
->reg
[regnum
].loc
.exp
.len
,
1274 cache
->addr_size
, cache
->text_offset
,
1275 this_frame
, cache
->cfa
, 1);
1276 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1278 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1279 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1280 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1282 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1283 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
.start
,
1284 cache
->reg
[regnum
].loc
.exp
.len
,
1285 cache
->addr_size
, cache
->text_offset
,
1286 this_frame
, cache
->cfa
, 1);
1287 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1289 case DWARF2_FRAME_REG_UNSPECIFIED
:
1290 /* GCC, in its infinite wisdom decided to not provide unwind
1291 information for registers that are "same value". Since
1292 DWARF2 (3 draft 7) doesn't define such behavior, said
1293 registers are actually undefined (which is different to CFI
1294 "undefined"). Code above issues a complaint about this.
1295 Here just fudge the books, assume GCC, and that the value is
1296 more inner on the stack. */
1297 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1299 case DWARF2_FRAME_REG_SAME_VALUE
:
1300 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1302 case DWARF2_FRAME_REG_CFA
:
1303 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1305 case DWARF2_FRAME_REG_CFA_OFFSET
:
1306 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1307 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1309 case DWARF2_FRAME_REG_RA_OFFSET
:
1310 addr
= cache
->reg
[regnum
].loc
.offset
;
1311 regnum
= dwarf_reg_to_regnum_or_error
1312 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1313 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1314 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1316 case DWARF2_FRAME_REG_FN
:
1317 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1320 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1324 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1325 call frames chain. */
1328 dwarf2_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1330 struct dwarf2_frame_cache
*cache
= dwarf2_frame_cache (self
, &this_cache
);
1332 if (cache
->tailcall_cache
)
1333 dwarf2_tailcall_frame_unwind
.dealloc_cache (self
, cache
->tailcall_cache
);
1337 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1338 struct frame_info
*this_frame
, void **this_cache
)
1340 if (!dwarf2_frame_unwinders_enabled_p
)
1343 /* Grab an address that is guaranteed to reside somewhere within the
1344 function. get_frame_pc(), with a no-return next function, can
1345 end up returning something past the end of this function's body.
1346 If the frame we're sniffing for is a signal frame whose start
1347 address is placed on the stack by the OS, its FDE must
1348 extend one byte before its start address or we could potentially
1349 select the FDE of the previous function. */
1350 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1351 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
, NULL
);
1356 /* On some targets, signal trampolines may have unwind information.
1357 We need to recognize them so that we set the frame type
1360 if (fde
->cie
->signal_frame
1361 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1363 return self
->type
== SIGTRAMP_FRAME
;
1365 if (self
->type
!= NORMAL_FRAME
)
1371 static const struct frame_unwind dwarf2_frame_unwind
=
1374 dwarf2_frame_unwind_stop_reason
,
1375 dwarf2_frame_this_id
,
1376 dwarf2_frame_prev_register
,
1378 dwarf2_frame_sniffer
,
1379 dwarf2_frame_dealloc_cache
1382 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1385 dwarf2_frame_unwind_stop_reason
,
1386 dwarf2_frame_this_id
,
1387 dwarf2_frame_prev_register
,
1389 dwarf2_frame_sniffer
,
1391 /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1395 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1398 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1400 /* TAILCALL_FRAME must be first to find the record by
1401 dwarf2_tailcall_sniffer_first. */
1402 frame_unwind_append_unwinder (gdbarch
, &dwarf2_tailcall_frame_unwind
);
1404 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1405 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1409 /* There is no explicitly defined relationship between the CFA and the
1410 location of frame's local variables and arguments/parameters.
1411 Therefore, frame base methods on this page should probably only be
1412 used as a last resort, just to avoid printing total garbage as a
1413 response to the "info frame" command. */
1416 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1418 struct dwarf2_frame_cache
*cache
=
1419 dwarf2_frame_cache (this_frame
, this_cache
);
1424 static const struct frame_base dwarf2_frame_base
=
1426 &dwarf2_frame_unwind
,
1427 dwarf2_frame_base_address
,
1428 dwarf2_frame_base_address
,
1429 dwarf2_frame_base_address
1432 const struct frame_base
*
1433 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1435 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1437 if (dwarf2_frame_find_fde (&block_addr
, NULL
))
1438 return &dwarf2_frame_base
;
1443 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1444 the DWARF unwinder. This is used to implement
1445 DW_OP_call_frame_cfa. */
1448 dwarf2_frame_cfa (struct frame_info
*this_frame
)
1450 if (frame_unwinder_is (this_frame
, &record_btrace_tailcall_frame_unwind
)
1451 || frame_unwinder_is (this_frame
, &record_btrace_frame_unwind
))
1452 throw_error (NOT_AVAILABLE_ERROR
,
1453 _("cfa not available for record btrace target"));
1455 while (get_frame_type (this_frame
) == INLINE_FRAME
)
1456 this_frame
= get_prev_frame (this_frame
);
1457 if (get_frame_unwind_stop_reason (this_frame
) == UNWIND_UNAVAILABLE
)
1458 throw_error (NOT_AVAILABLE_ERROR
,
1459 _("can't compute CFA for this frame: "
1460 "required registers or memory are unavailable"));
1462 if (get_frame_id (this_frame
).stack_status
!= FID_STACK_VALID
)
1463 throw_error (NOT_AVAILABLE_ERROR
,
1464 _("can't compute CFA for this frame: "
1465 "frame base not available"));
1467 return get_frame_base (this_frame
);
1470 static const struct objfile_key
<dwarf2_fde_table
> dwarf2_frame_objfile_data
;
1474 /* Pointer encoding helper functions. */
1476 /* GCC supports exception handling based on DWARF2 CFI. However, for
1477 technical reasons, it encodes addresses in its FDE's in a different
1478 way. Several "pointer encodings" are supported. The encoding
1479 that's used for a particular FDE is determined by the 'R'
1480 augmentation in the associated CIE. The argument of this
1481 augmentation is a single byte.
1483 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1484 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1485 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1486 address should be interpreted (absolute, relative to the current
1487 position in the FDE, ...). Bit 7, indicates that the address
1488 should be dereferenced. */
1491 encoding_for_size (unsigned int size
)
1496 return DW_EH_PE_udata2
;
1498 return DW_EH_PE_udata4
;
1500 return DW_EH_PE_udata8
;
1502 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1507 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1508 int ptr_len
, const gdb_byte
*buf
,
1509 unsigned int *bytes_read_ptr
,
1510 CORE_ADDR func_base
)
1515 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1517 if (encoding
& DW_EH_PE_indirect
)
1518 internal_error (__FILE__
, __LINE__
,
1519 _("Unsupported encoding: DW_EH_PE_indirect"));
1521 *bytes_read_ptr
= 0;
1523 switch (encoding
& 0x70)
1525 case DW_EH_PE_absptr
:
1528 case DW_EH_PE_pcrel
:
1529 base
= bfd_section_vma (unit
->dwarf_frame_section
);
1530 base
+= (buf
- unit
->dwarf_frame_buffer
);
1532 case DW_EH_PE_datarel
:
1535 case DW_EH_PE_textrel
:
1538 case DW_EH_PE_funcrel
:
1541 case DW_EH_PE_aligned
:
1543 offset
= buf
- unit
->dwarf_frame_buffer
;
1544 if ((offset
% ptr_len
) != 0)
1546 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1547 buf
+= *bytes_read_ptr
;
1551 internal_error (__FILE__
, __LINE__
,
1552 _("Invalid or unsupported encoding"));
1555 if ((encoding
& 0x07) == 0x00)
1557 encoding
|= encoding_for_size (ptr_len
);
1558 if (bfd_get_sign_extend_vma (unit
->abfd
))
1559 encoding
|= DW_EH_PE_signed
;
1562 switch (encoding
& 0x0f)
1564 case DW_EH_PE_uleb128
:
1567 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1569 *bytes_read_ptr
+= safe_read_uleb128 (buf
, end_buf
, &value
) - buf
;
1570 return base
+ value
;
1572 case DW_EH_PE_udata2
:
1573 *bytes_read_ptr
+= 2;
1574 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1575 case DW_EH_PE_udata4
:
1576 *bytes_read_ptr
+= 4;
1577 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1578 case DW_EH_PE_udata8
:
1579 *bytes_read_ptr
+= 8;
1580 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1581 case DW_EH_PE_sleb128
:
1584 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1586 *bytes_read_ptr
+= safe_read_sleb128 (buf
, end_buf
, &value
) - buf
;
1587 return base
+ value
;
1589 case DW_EH_PE_sdata2
:
1590 *bytes_read_ptr
+= 2;
1591 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1592 case DW_EH_PE_sdata4
:
1593 *bytes_read_ptr
+= 4;
1594 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1595 case DW_EH_PE_sdata8
:
1596 *bytes_read_ptr
+= 8;
1597 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1599 internal_error (__FILE__
, __LINE__
,
1600 _("Invalid or unsupported encoding"));
1605 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1606 static struct dwarf2_cie
*
1607 find_cie (const dwarf2_cie_table
&cie_table
, ULONGEST cie_pointer
)
1609 auto iter
= cie_table
.find (cie_pointer
);
1610 if (iter
!= cie_table
.end ())
1611 return iter
->second
;
1616 bsearch_fde_cmp (const dwarf2_fde
*fde
, CORE_ADDR seek_pc
)
1618 if (fde
->initial_location
+ fde
->address_range
<= seek_pc
)
1620 if (fde
->initial_location
<= seek_pc
)
1625 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1626 initial location associated with it into *PC. */
1628 static struct dwarf2_fde
*
1629 dwarf2_frame_find_fde (CORE_ADDR
*pc
, CORE_ADDR
*out_offset
)
1631 for (objfile
*objfile
: current_program_space
->objfiles ())
1633 dwarf2_fde_table
*fde_table
;
1637 fde_table
= dwarf2_frame_objfile_data
.get (objfile
);
1638 if (fde_table
== NULL
)
1640 dwarf2_build_frame_info (objfile
);
1641 fde_table
= dwarf2_frame_objfile_data
.get (objfile
);
1643 gdb_assert (fde_table
!= NULL
);
1645 if (fde_table
->empty ())
1648 gdb_assert (!objfile
->section_offsets
.empty ());
1649 offset
= objfile
->text_section_offset ();
1651 gdb_assert (!fde_table
->empty ());
1652 if (*pc
< offset
+ (*fde_table
)[0]->initial_location
)
1655 seek_pc
= *pc
- offset
;
1656 auto it
= gdb::binary_search (fde_table
->begin (), fde_table
->end (),
1657 seek_pc
, bsearch_fde_cmp
);
1658 if (it
!= fde_table
->end ())
1660 *pc
= (*it
)->initial_location
+ offset
;
1662 *out_offset
= offset
;
1669 /* Add FDE to FDE_TABLE. */
1671 add_fde (dwarf2_fde_table
*fde_table
, struct dwarf2_fde
*fde
)
1673 if (fde
->address_range
== 0)
1674 /* Discard useless FDEs. */
1677 fde_table
->push_back (fde
);
1680 #define DW64_CIE_ID 0xffffffffffffffffULL
1682 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1687 EH_CIE_TYPE_ID
= 1 << 0,
1688 EH_FDE_TYPE_ID
= 1 << 1,
1689 EH_CIE_OR_FDE_TYPE_ID
= EH_CIE_TYPE_ID
| EH_FDE_TYPE_ID
1692 static const gdb_byte
*decode_frame_entry (struct comp_unit
*unit
,
1693 const gdb_byte
*start
,
1695 dwarf2_cie_table
&cie_table
,
1696 dwarf2_fde_table
*fde_table
,
1697 enum eh_frame_type entry_type
);
1699 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1700 Return NULL if invalid input, otherwise the next byte to be processed. */
1702 static const gdb_byte
*
1703 decode_frame_entry_1 (struct comp_unit
*unit
, const gdb_byte
*start
,
1705 dwarf2_cie_table
&cie_table
,
1706 dwarf2_fde_table
*fde_table
,
1707 enum eh_frame_type entry_type
)
1709 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1710 const gdb_byte
*buf
, *end
;
1712 unsigned int bytes_read
;
1715 ULONGEST cie_pointer
;
1720 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
, false);
1722 end
= buf
+ (size_t) length
;
1727 /* Are we still within the section? */
1728 if (end
<= buf
|| end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1731 /* Distinguish between 32 and 64-bit encoded frame info. */
1732 dwarf64_p
= (bytes_read
== 12);
1734 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1738 cie_id
= DW64_CIE_ID
;
1744 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1749 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1753 if (cie_pointer
== cie_id
)
1755 /* This is a CIE. */
1756 struct dwarf2_cie
*cie
;
1758 unsigned int cie_version
;
1760 /* Check that a CIE was expected. */
1761 if ((entry_type
& EH_CIE_TYPE_ID
) == 0)
1762 error (_("Found a CIE when not expecting it."));
1764 /* Record the offset into the .debug_frame section of this CIE. */
1765 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1767 /* Check whether we've already read it. */
1768 if (find_cie (cie_table
, cie_pointer
))
1771 cie
= XOBNEW (&unit
->objfile
->objfile_obstack
, struct dwarf2_cie
);
1772 cie
->initial_instructions
= NULL
;
1773 cie
->cie_pointer
= cie_pointer
;
1775 /* The encoding for FDE's in a normal .debug_frame section
1776 depends on the target address size. */
1777 cie
->encoding
= DW_EH_PE_absptr
;
1779 /* We'll determine the final value later, but we need to
1780 initialize it conservatively. */
1781 cie
->signal_frame
= 0;
1783 /* Check version number. */
1784 cie_version
= read_1_byte (unit
->abfd
, buf
);
1785 if (cie_version
!= 1 && cie_version
!= 3 && cie_version
!= 4)
1787 cie
->version
= cie_version
;
1790 /* Interpret the interesting bits of the augmentation. */
1791 cie
->augmentation
= augmentation
= (char *) buf
;
1792 buf
+= (strlen (augmentation
) + 1);
1794 /* Ignore armcc augmentations. We only use them for quirks,
1795 and that doesn't happen until later. */
1796 if (startswith (augmentation
, "armcc"))
1797 augmentation
+= strlen (augmentation
);
1799 /* The GCC 2.x "eh" augmentation has a pointer immediately
1800 following the augmentation string, so it must be handled
1802 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1805 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1809 if (cie
->version
>= 4)
1811 /* FIXME: check that this is the same as from the CU header. */
1812 cie
->addr_size
= read_1_byte (unit
->abfd
, buf
);
1814 cie
->segment_size
= read_1_byte (unit
->abfd
, buf
);
1819 cie
->addr_size
= gdbarch_dwarf2_addr_size (gdbarch
);
1820 cie
->segment_size
= 0;
1822 /* Address values in .eh_frame sections are defined to have the
1823 target's pointer size. Watchout: This breaks frame info for
1824 targets with pointer size < address size, unless a .debug_frame
1825 section exists as well. */
1827 cie
->ptr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1829 cie
->ptr_size
= cie
->addr_size
;
1831 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
1834 cie
->code_alignment_factor
= uleb128
;
1836 buf
= gdb_read_sleb128 (buf
, end
, &sleb128
);
1839 cie
->data_alignment_factor
= sleb128
;
1841 if (cie_version
== 1)
1843 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1848 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
1851 cie
->return_address_register
= uleb128
;
1854 cie
->return_address_register
1855 = dwarf2_frame_adjust_regnum (gdbarch
,
1856 cie
->return_address_register
,
1859 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1860 if (cie
->saw_z_augmentation
)
1862 uint64_t uleb_length
;
1864 buf
= gdb_read_uleb128 (buf
, end
, &uleb_length
);
1867 cie
->initial_instructions
= buf
+ uleb_length
;
1871 while (*augmentation
)
1873 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1874 if (*augmentation
== 'L')
1881 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1882 else if (*augmentation
== 'R')
1884 cie
->encoding
= *buf
++;
1888 /* "P" indicates a personality routine in the CIE augmentation. */
1889 else if (*augmentation
== 'P')
1891 /* Skip. Avoid indirection since we throw away the result. */
1892 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1893 read_encoded_value (unit
, encoding
, cie
->ptr_size
,
1894 buf
, &bytes_read
, 0);
1899 /* "S" indicates a signal frame, such that the return
1900 address must not be decremented to locate the call frame
1901 info for the previous frame; it might even be the first
1902 instruction of a function, so decrementing it would take
1903 us to a different function. */
1904 else if (*augmentation
== 'S')
1906 cie
->signal_frame
= 1;
1910 /* Otherwise we have an unknown augmentation. Assume that either
1911 there is no augmentation data, or we saw a 'z' prefix. */
1914 if (cie
->initial_instructions
)
1915 buf
= cie
->initial_instructions
;
1920 cie
->initial_instructions
= buf
;
1924 cie_table
[cie
->cie_pointer
] = cie
;
1928 /* This is a FDE. */
1929 struct dwarf2_fde
*fde
;
1932 /* Check that an FDE was expected. */
1933 if ((entry_type
& EH_FDE_TYPE_ID
) == 0)
1934 error (_("Found an FDE when not expecting it."));
1936 /* In an .eh_frame section, the CIE pointer is the delta between the
1937 address within the FDE where the CIE pointer is stored and the
1938 address of the CIE. Convert it to an offset into the .eh_frame
1942 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1943 cie_pointer
-= (dwarf64_p
? 8 : 4);
1946 /* In either case, validate the result is still within the section. */
1947 if (cie_pointer
>= unit
->dwarf_frame_size
)
1950 fde
= XOBNEW (&unit
->objfile
->objfile_obstack
, struct dwarf2_fde
);
1951 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1952 if (fde
->cie
== NULL
)
1954 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1955 eh_frame_p
, cie_table
, fde_table
,
1957 fde
->cie
= find_cie (cie_table
, cie_pointer
);
1960 gdb_assert (fde
->cie
!= NULL
);
1962 addr
= read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->ptr_size
,
1963 buf
, &bytes_read
, 0);
1964 fde
->initial_location
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
1967 fde
->address_range
=
1968 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1969 fde
->cie
->ptr_size
, buf
, &bytes_read
, 0);
1970 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ fde
->address_range
);
1971 fde
->address_range
= addr
- fde
->initial_location
;
1974 /* A 'z' augmentation in the CIE implies the presence of an
1975 augmentation field in the FDE as well. The only thing known
1976 to be in here at present is the LSDA entry for EH. So we
1977 can skip the whole thing. */
1978 if (fde
->cie
->saw_z_augmentation
)
1980 uint64_t uleb_length
;
1982 buf
= gdb_read_uleb128 (buf
, end
, &uleb_length
);
1990 fde
->instructions
= buf
;
1993 fde
->eh_frame_p
= eh_frame_p
;
1995 add_fde (fde_table
, fde
);
2001 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2002 expect an FDE or a CIE. */
2004 static const gdb_byte
*
2005 decode_frame_entry (struct comp_unit
*unit
, const gdb_byte
*start
,
2007 dwarf2_cie_table
&cie_table
,
2008 dwarf2_fde_table
*fde_table
,
2009 enum eh_frame_type entry_type
)
2011 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
2012 const gdb_byte
*ret
;
2013 ptrdiff_t start_offset
;
2017 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
,
2018 cie_table
, fde_table
, entry_type
);
2022 /* We have corrupt input data of some form. */
2024 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2025 and mismatches wrt padding and alignment of debug sections. */
2026 /* Note that there is no requirement in the standard for any
2027 alignment at all in the frame unwind sections. Testing for
2028 alignment before trying to interpret data would be incorrect.
2030 However, GCC traditionally arranged for frame sections to be
2031 sized such that the FDE length and CIE fields happen to be
2032 aligned (in theory, for performance). This, unfortunately,
2033 was done with .align directives, which had the side effect of
2034 forcing the section to be aligned by the linker.
2036 This becomes a problem when you have some other producer that
2037 creates frame sections that are not as strictly aligned. That
2038 produces a hole in the frame info that gets filled by the
2041 The GCC behaviour is arguably a bug, but it's effectively now
2042 part of the ABI, so we're now stuck with it, at least at the
2043 object file level. A smart linker may decide, in the process
2044 of compressing duplicate CIE information, that it can rewrite
2045 the entire output section without this extra padding. */
2047 start_offset
= start
- unit
->dwarf_frame_buffer
;
2048 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
2050 start
+= 4 - (start_offset
& 3);
2051 workaround
= ALIGN4
;
2054 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
2056 start
+= 8 - (start_offset
& 7);
2057 workaround
= ALIGN8
;
2061 /* Nothing left to try. Arrange to return as if we've consumed
2062 the entire input section. Hopefully we'll get valid info from
2063 the other of .debug_frame/.eh_frame. */
2065 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
2076 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2077 unit
->dwarf_frame_section
->owner
->filename
,
2078 unit
->dwarf_frame_section
->name
);
2083 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2084 unit
->dwarf_frame_section
->owner
->filename
,
2085 unit
->dwarf_frame_section
->name
);
2089 complaint (_("Corrupt data in %s:%s"),
2090 unit
->dwarf_frame_section
->owner
->filename
,
2091 unit
->dwarf_frame_section
->name
);
2099 fde_is_less_than (const dwarf2_fde
*aa
, const dwarf2_fde
*bb
)
2101 if (aa
->initial_location
== bb
->initial_location
)
2103 if (aa
->address_range
!= bb
->address_range
2104 && aa
->eh_frame_p
== 0 && bb
->eh_frame_p
== 0)
2105 /* Linker bug, e.g. gold/10400.
2106 Work around it by keeping stable sort order. */
2109 /* Put eh_frame entries after debug_frame ones. */
2110 return aa
->eh_frame_p
< bb
->eh_frame_p
;
2113 return aa
->initial_location
< bb
->initial_location
;
2117 dwarf2_build_frame_info (struct objfile
*objfile
)
2119 struct comp_unit
*unit
;
2120 const gdb_byte
*frame_ptr
;
2121 dwarf2_cie_table cie_table
;
2122 dwarf2_fde_table fde_table
;
2123 dwarf2_fde_table
*fde_table2
;
2125 /* Build a minimal decoding of the DWARF2 compilation unit. */
2126 unit
= XOBNEW (&objfile
->objfile_obstack
, comp_unit
);
2127 unit
->abfd
= objfile
->obfd
;
2128 unit
->objfile
= objfile
;
2132 if (objfile
->separate_debug_objfile_backlink
== NULL
)
2134 /* Do not read .eh_frame from separate file as they must be also
2135 present in the main file. */
2136 dwarf2_get_section_info (objfile
, DWARF2_EH_FRAME
,
2137 &unit
->dwarf_frame_section
,
2138 &unit
->dwarf_frame_buffer
,
2139 &unit
->dwarf_frame_size
);
2140 if (unit
->dwarf_frame_size
)
2142 asection
*got
, *txt
;
2144 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2145 that is used for the i386/amd64 target, which currently is
2146 the only target in GCC that supports/uses the
2147 DW_EH_PE_datarel encoding. */
2148 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2150 unit
->dbase
= got
->vma
;
2152 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2154 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2156 unit
->tbase
= txt
->vma
;
2160 frame_ptr
= unit
->dwarf_frame_buffer
;
2161 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2162 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1,
2163 cie_table
, &fde_table
,
2164 EH_CIE_OR_FDE_TYPE_ID
);
2167 catch (const gdb_exception_error
&e
)
2169 warning (_("skipping .eh_frame info of %s: %s"),
2170 objfile_name (objfile
), e
.what ());
2173 /* The cie_table is discarded below. */
2180 dwarf2_get_section_info (objfile
, DWARF2_DEBUG_FRAME
,
2181 &unit
->dwarf_frame_section
,
2182 &unit
->dwarf_frame_buffer
,
2183 &unit
->dwarf_frame_size
);
2184 if (unit
->dwarf_frame_size
)
2186 size_t num_old_fde_entries
= fde_table
.size ();
2190 frame_ptr
= unit
->dwarf_frame_buffer
;
2191 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2192 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0,
2193 cie_table
, &fde_table
,
2194 EH_CIE_OR_FDE_TYPE_ID
);
2196 catch (const gdb_exception_error
&e
)
2198 warning (_("skipping .debug_frame info of %s: %s"),
2199 objfile_name (objfile
), e
.what ());
2201 fde_table
.resize (num_old_fde_entries
);
2205 fde_table2
= new dwarf2_fde_table
;
2207 struct dwarf2_fde
*fde_prev
= NULL
;
2208 struct dwarf2_fde
*first_non_zero_fde
= NULL
;
2210 /* Prepare FDE table for lookups. */
2211 std::sort (fde_table
.begin (), fde_table
.end (), fde_is_less_than
);
2213 /* Check for leftovers from --gc-sections. The GNU linker sets
2214 the relevant symbols to zero, but doesn't zero the FDE *end*
2215 ranges because there's no relocation there. It's (offset,
2216 length), not (start, end). On targets where address zero is
2217 just another valid address this can be a problem, since the
2218 FDEs appear to be non-empty in the output --- we could pick
2219 out the wrong FDE. To work around this, when overlaps are
2220 detected, we prefer FDEs that do not start at zero.
2222 Start by finding the first FDE with non-zero start. Below
2223 we'll discard all FDEs that start at zero and overlap this
2225 for (struct dwarf2_fde
*fde
: fde_table
)
2227 if (fde
->initial_location
!= 0)
2229 first_non_zero_fde
= fde
;
2234 /* Since we'll be doing bsearch, squeeze out identical (except
2235 for eh_frame_p) fde entries so bsearch result is predictable.
2236 Also discard leftovers from --gc-sections. */
2237 for (struct dwarf2_fde
*fde
: fde_table
)
2239 if (fde
->initial_location
== 0
2240 && first_non_zero_fde
!= NULL
2241 && (first_non_zero_fde
->initial_location
2242 < fde
->initial_location
+ fde
->address_range
))
2245 if (fde_prev
!= NULL
2246 && fde_prev
->initial_location
== fde
->initial_location
)
2249 fde_table2
->push_back (fde
);
2252 fde_table2
->shrink_to_fit ();
2254 dwarf2_frame_objfile_data
.set (objfile
, fde_table2
);
2257 /* Handle 'maintenance show dwarf unwinders'. */
2260 show_dwarf_unwinders_enabled_p (struct ui_file
*file
, int from_tty
,
2261 struct cmd_list_element
*c
,
2264 fprintf_filtered (file
,
2265 _("The DWARF stack unwinders are currently %s.\n"),
2269 void _initialize_dwarf2_frame ();
2271 _initialize_dwarf2_frame ()
2273 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2275 add_setshow_boolean_cmd ("unwinders", class_obscure
,
2276 &dwarf2_frame_unwinders_enabled_p
, _("\
2277 Set whether the DWARF stack frame unwinders are used."), _("\
2278 Show whether the DWARF stack frame unwinders are used."), _("\
2279 When enabled the DWARF stack frame unwinders can be used for architectures\n\
2280 that support the DWARF unwinders. Enabling the DWARF unwinders for an\n\
2281 architecture that doesn't support them will have no effect."),
2283 show_dwarf_unwinders_enabled_p
,
2285 &show_dwarf_cmdlist
);
2288 selftests::register_test_foreach_arch ("execute_cfa_program",
2289 selftests::execute_cfa_program_test
);