1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003-2018 Free Software Foundation, Inc.
5 Contributed by Mark Kettenis.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "dwarf2expr.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
36 #include "complaints.h"
37 #include "dwarf2-frame.h"
38 #include "dwarf2read.h"
40 #include "dwarf2loc.h"
41 #include "dwarf2-frame-tailcall.h"
44 #include "selftest-arch.h"
49 /* Call Frame Information (CFI). */
51 /* Common Information Entry (CIE). */
55 /* Computation Unit for this CIE. */
56 struct comp_unit
*unit
;
58 /* Offset into the .debug_frame section where this CIE was found.
59 Used to identify this CIE. */
62 /* Constant that is factored out of all advance location
64 ULONGEST code_alignment_factor
;
66 /* Constants that is factored out of all offset instructions. */
67 LONGEST data_alignment_factor
;
69 /* Return address column. */
70 ULONGEST return_address_register
;
72 /* Instruction sequence to initialize a register set. */
73 const gdb_byte
*initial_instructions
;
76 /* Saved augmentation, in case it's needed later. */
79 /* Encoding of addresses. */
82 /* Target address size in bytes. */
85 /* Target pointer size in bytes. */
88 /* True if a 'z' augmentation existed. */
89 unsigned char saw_z_augmentation
;
91 /* True if an 'S' augmentation existed. */
92 unsigned char signal_frame
;
94 /* The version recorded in the CIE. */
95 unsigned char version
;
97 /* The segment size. */
98 unsigned char segment_size
;
101 struct dwarf2_cie_table
104 struct dwarf2_cie
**entries
;
107 /* Frame Description Entry (FDE). */
111 /* CIE for this FDE. */
112 struct dwarf2_cie
*cie
;
114 /* First location associated with this FDE. */
115 CORE_ADDR initial_location
;
117 /* Number of bytes of program instructions described by this FDE. */
118 CORE_ADDR address_range
;
120 /* Instruction sequence. */
121 const gdb_byte
*instructions
;
124 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
126 unsigned char eh_frame_p
;
129 struct dwarf2_fde_table
132 struct dwarf2_fde
**entries
;
135 /* A minimal decoding of DWARF2 compilation units. We only decode
136 what's needed to get to the call frame information. */
140 /* Keep the bfd convenient. */
143 struct objfile
*objfile
;
145 /* Pointer to the .debug_frame section loaded into memory. */
146 const gdb_byte
*dwarf_frame_buffer
;
148 /* Length of the loaded .debug_frame section. */
149 bfd_size_type dwarf_frame_size
;
151 /* Pointer to the .debug_frame section. */
152 asection
*dwarf_frame_section
;
154 /* Base for DW_EH_PE_datarel encodings. */
157 /* Base for DW_EH_PE_textrel encodings. */
161 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
,
162 CORE_ADDR
*out_offset
);
164 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
167 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
168 int ptr_len
, const gdb_byte
*buf
,
169 unsigned int *bytes_read_ptr
,
170 CORE_ADDR func_base
);
173 /* See dwarf2-frame.h. */
174 int dwarf2_frame_unwinders_enabled_p
= 1;
176 /* Store the length the expression for the CFA in the `cfa_reg' field,
177 which is unused in that case. */
178 #define cfa_exp_len cfa_reg
180 dwarf2_frame_state::dwarf2_frame_state (CORE_ADDR pc_
, struct dwarf2_cie
*cie
)
181 : pc (pc_
), data_align (cie
->data_alignment_factor
),
182 code_align (cie
->code_alignment_factor
),
183 retaddr_column (cie
->return_address_register
)
188 /* Helper functions for execute_stack_op. */
191 read_addr_from_reg (struct frame_info
*this_frame
, int reg
)
193 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
194 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
196 return address_from_register (regnum
, this_frame
);
199 /* Execute the required actions for both the DW_CFA_restore and
200 DW_CFA_restore_extended instructions. */
202 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
203 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
207 gdb_assert (fs
->initial
.reg
);
208 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
209 fs
->regs
.alloc_regs (reg
+ 1);
211 /* Check if this register was explicitly initialized in the
212 CIE initial instructions. If not, default the rule to
214 if (reg
< fs
->initial
.num_regs
)
215 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
217 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
219 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
221 int regnum
= dwarf_reg_to_regnum (gdbarch
, reg
);
224 incomplete CFI data; DW_CFA_restore unspecified\n\
225 register %s (#%d) at %s"),
226 gdbarch_register_name (gdbarch
, regnum
), regnum
,
227 paddress (gdbarch
, fs
->pc
));
231 class dwarf_expr_executor
: public dwarf_expr_context
235 struct frame_info
*this_frame
;
237 CORE_ADDR
read_addr_from_reg (int reg
) override
239 return ::read_addr_from_reg (this_frame
, reg
);
242 struct value
*get_reg_value (struct type
*type
, int reg
) override
244 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
245 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, reg
);
247 return value_from_register (type
, regnum
, this_frame
);
250 void read_mem (gdb_byte
*buf
, CORE_ADDR addr
, size_t len
) override
252 read_memory (addr
, buf
, len
);
255 void get_frame_base (const gdb_byte
**start
, size_t *length
) override
257 invalid ("DW_OP_fbreg");
260 void push_dwarf_reg_entry_value (enum call_site_parameter_kind kind
,
261 union call_site_parameter_u kind_u
,
262 int deref_size
) override
264 invalid ("DW_OP_entry_value");
267 CORE_ADDR
get_object_address () override
269 invalid ("DW_OP_push_object_address");
272 CORE_ADDR
get_frame_cfa () override
274 invalid ("DW_OP_call_frame_cfa");
277 CORE_ADDR
get_tls_address (CORE_ADDR offset
) override
279 invalid ("DW_OP_form_tls_address");
282 void dwarf_call (cu_offset die_offset
) override
284 invalid ("DW_OP_call*");
287 CORE_ADDR
get_addr_index (unsigned int index
) override
289 invalid ("DW_OP_GNU_addr_index");
294 void invalid (const char *op
) ATTRIBUTE_NORETURN
296 error (_("%s is invalid in this context"), op
);
301 execute_stack_op (const gdb_byte
*exp
, ULONGEST len
, int addr_size
,
302 CORE_ADDR offset
, struct frame_info
*this_frame
,
303 CORE_ADDR initial
, int initial_in_stack_memory
)
307 dwarf_expr_executor ctx
;
308 scoped_value_mark free_values
;
310 ctx
.this_frame
= this_frame
;
311 ctx
.gdbarch
= get_frame_arch (this_frame
);
312 ctx
.addr_size
= addr_size
;
313 ctx
.ref_addr_size
= -1;
316 ctx
.push_address (initial
, initial_in_stack_memory
);
319 if (ctx
.location
== DWARF_VALUE_MEMORY
)
320 result
= ctx
.fetch_address (0);
321 else if (ctx
.location
== DWARF_VALUE_REGISTER
)
322 result
= ctx
.read_addr_from_reg (value_as_long (ctx
.fetch (0)));
325 /* This is actually invalid DWARF, but if we ever do run across
326 it somehow, we might as well support it. So, instead, report
327 it as unimplemented. */
329 Not implemented: computing unwound register using explicit value operator"));
336 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
337 PC. Modify FS state accordingly. Return current INSN_PTR where the
338 execution has stopped, one can resume it on the next call. */
340 static const gdb_byte
*
341 execute_cfa_program (struct dwarf2_fde
*fde
, const gdb_byte
*insn_ptr
,
342 const gdb_byte
*insn_end
, struct gdbarch
*gdbarch
,
343 CORE_ADDR pc
, struct dwarf2_frame_state
*fs
)
345 int eh_frame_p
= fde
->eh_frame_p
;
346 unsigned int bytes_read
;
347 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
349 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
351 gdb_byte insn
= *insn_ptr
++;
355 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
356 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
357 else if ((insn
& 0xc0) == DW_CFA_offset
)
360 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
361 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
362 offset
= utmp
* fs
->data_align
;
363 fs
->regs
.alloc_regs (reg
+ 1);
364 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
365 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
367 else if ((insn
& 0xc0) == DW_CFA_restore
)
370 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
377 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
378 fde
->cie
->ptr_size
, insn_ptr
,
379 &bytes_read
, fde
->initial_location
);
380 /* Apply the objfile offset for relocatable objects. */
381 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
382 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
383 insn_ptr
+= bytes_read
;
386 case DW_CFA_advance_loc1
:
387 utmp
= extract_unsigned_integer (insn_ptr
, 1, byte_order
);
388 fs
->pc
+= utmp
* fs
->code_align
;
391 case DW_CFA_advance_loc2
:
392 utmp
= extract_unsigned_integer (insn_ptr
, 2, byte_order
);
393 fs
->pc
+= utmp
* fs
->code_align
;
396 case DW_CFA_advance_loc4
:
397 utmp
= extract_unsigned_integer (insn_ptr
, 4, byte_order
);
398 fs
->pc
+= utmp
* fs
->code_align
;
402 case DW_CFA_offset_extended
:
403 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
404 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
405 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
406 offset
= utmp
* fs
->data_align
;
407 fs
->regs
.alloc_regs (reg
+ 1);
408 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
409 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
412 case DW_CFA_restore_extended
:
413 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
414 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
417 case DW_CFA_undefined
:
418 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
419 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
420 fs
->regs
.alloc_regs (reg
+ 1);
421 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
424 case DW_CFA_same_value
:
425 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
426 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
427 fs
->regs
.alloc_regs (reg
+ 1);
428 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
431 case DW_CFA_register
:
432 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
433 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
434 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
435 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
436 fs
->regs
.alloc_regs (reg
+ 1);
437 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
438 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
441 case DW_CFA_remember_state
:
443 struct dwarf2_frame_state_reg_info
*new_rs
;
445 new_rs
= new dwarf2_frame_state_reg_info (fs
->regs
);
446 fs
->regs
.prev
= new_rs
;
450 case DW_CFA_restore_state
:
452 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
457 bad CFI data; mismatched DW_CFA_restore_state at %s"),
458 paddress (gdbarch
, fs
->pc
));
461 fs
->regs
= std::move (*old_rs
);
466 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
467 fs
->regs
.cfa_reg
= reg
;
468 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
470 if (fs
->armcc_cfa_offsets_sf
)
471 utmp
*= fs
->data_align
;
473 fs
->regs
.cfa_offset
= utmp
;
474 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
477 case DW_CFA_def_cfa_register
:
478 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
479 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
481 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
484 case DW_CFA_def_cfa_offset
:
485 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
487 if (fs
->armcc_cfa_offsets_sf
)
488 utmp
*= fs
->data_align
;
490 fs
->regs
.cfa_offset
= utmp
;
491 /* cfa_how deliberately not set. */
497 case DW_CFA_def_cfa_expression
:
498 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
499 fs
->regs
.cfa_exp_len
= utmp
;
500 fs
->regs
.cfa_exp
= insn_ptr
;
501 fs
->regs
.cfa_how
= CFA_EXP
;
502 insn_ptr
+= fs
->regs
.cfa_exp_len
;
505 case DW_CFA_expression
:
506 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
507 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
508 fs
->regs
.alloc_regs (reg
+ 1);
509 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
510 fs
->regs
.reg
[reg
].loc
.exp
.start
= insn_ptr
;
511 fs
->regs
.reg
[reg
].loc
.exp
.len
= utmp
;
512 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
516 case DW_CFA_offset_extended_sf
:
517 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
518 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
519 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
520 offset
*= fs
->data_align
;
521 fs
->regs
.alloc_regs (reg
+ 1);
522 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
523 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
526 case DW_CFA_val_offset
:
527 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
528 fs
->regs
.alloc_regs (reg
+ 1);
529 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
530 offset
= utmp
* fs
->data_align
;
531 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
532 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
535 case DW_CFA_val_offset_sf
:
536 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
537 fs
->regs
.alloc_regs (reg
+ 1);
538 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
539 offset
*= fs
->data_align
;
540 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
541 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
544 case DW_CFA_val_expression
:
545 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
546 fs
->regs
.alloc_regs (reg
+ 1);
547 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
548 fs
->regs
.reg
[reg
].loc
.exp
.start
= insn_ptr
;
549 fs
->regs
.reg
[reg
].loc
.exp
.len
= utmp
;
550 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
554 case DW_CFA_def_cfa_sf
:
555 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
556 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
,
558 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
559 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
560 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
563 case DW_CFA_def_cfa_offset_sf
:
564 insn_ptr
= safe_read_sleb128 (insn_ptr
, insn_end
, &offset
);
565 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
566 /* cfa_how deliberately not set. */
569 case DW_CFA_GNU_args_size
:
571 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
574 case DW_CFA_GNU_negative_offset_extended
:
575 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, ®
);
576 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
577 insn_ptr
= safe_read_uleb128 (insn_ptr
, insn_end
, &utmp
);
578 offset
= utmp
* fs
->data_align
;
579 fs
->regs
.alloc_regs (reg
+ 1);
580 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
581 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
585 if (insn
>= DW_CFA_lo_user
&& insn
<= DW_CFA_hi_user
)
587 /* Handle vendor-specific CFI for different architectures. */
588 if (!gdbarch_execute_dwarf_cfa_vendor_op (gdbarch
, insn
, fs
))
589 error (_("Call Frame Instruction op %d in vendor extension "
590 "space is not handled on this architecture."),
594 internal_error (__FILE__
, __LINE__
,
595 _("Unknown CFI encountered."));
600 if (fs
->initial
.reg
== NULL
)
602 /* Don't allow remember/restore between CIE and FDE programs. */
603 delete fs
->regs
.prev
;
604 fs
->regs
.prev
= NULL
;
612 namespace selftests
{
614 /* Unit test to function execute_cfa_program. */
617 execute_cfa_program_test (struct gdbarch
*gdbarch
)
619 struct dwarf2_fde fde
;
620 struct dwarf2_cie cie
;
622 memset (&fde
, 0, sizeof fde
);
623 memset (&cie
, 0, sizeof cie
);
625 cie
.data_alignment_factor
= -4;
626 cie
.code_alignment_factor
= 2;
629 dwarf2_frame_state
fs (0, fde
.cie
);
633 DW_CFA_def_cfa
, 1, 4, /* DW_CFA_def_cfa: r1 ofs 4 */
634 DW_CFA_offset
| 0x2, 1, /* DW_CFA_offset: r2 at cfa-4 */
635 DW_CFA_remember_state
,
636 DW_CFA_restore_state
,
639 const gdb_byte
*insn_end
= insns
+ sizeof (insns
);
640 const gdb_byte
*out
= execute_cfa_program (&fde
, insns
, insn_end
, gdbarch
,
643 SELF_CHECK (out
== insn_end
);
644 SELF_CHECK (fs
.pc
== 0);
646 /* The instructions above only use r1 and r2, but the register numbers
647 used are adjusted by dwarf2_frame_adjust_regnum. */
648 auto r1
= dwarf2_frame_adjust_regnum (gdbarch
, 1, fde
.eh_frame_p
);
649 auto r2
= dwarf2_frame_adjust_regnum (gdbarch
, 2, fde
.eh_frame_p
);
651 SELF_CHECK (fs
.regs
.num_regs
== (std::max (r1
, r2
) + 1));
653 SELF_CHECK (fs
.regs
.reg
[r2
].how
== DWARF2_FRAME_REG_SAVED_OFFSET
);
654 SELF_CHECK (fs
.regs
.reg
[r2
].loc
.offset
== -4);
656 for (auto i
= 0; i
< fs
.regs
.num_regs
; i
++)
658 SELF_CHECK (fs
.regs
.reg
[i
].how
== DWARF2_FRAME_REG_UNSPECIFIED
);
660 SELF_CHECK (fs
.regs
.cfa_reg
== 1);
661 SELF_CHECK (fs
.regs
.cfa_offset
== 4);
662 SELF_CHECK (fs
.regs
.cfa_how
== CFA_REG_OFFSET
);
663 SELF_CHECK (fs
.regs
.cfa_exp
== NULL
);
664 SELF_CHECK (fs
.regs
.prev
== NULL
);
667 } // namespace selftests
668 #endif /* GDB_SELF_TEST */
672 /* Architecture-specific operations. */
674 /* Per-architecture data key. */
675 static struct gdbarch_data
*dwarf2_frame_data
;
677 struct dwarf2_frame_ops
679 /* Pre-initialize the register state REG for register REGNUM. */
680 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
681 struct frame_info
*);
683 /* Check whether the THIS_FRAME is a signal trampoline. */
684 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
686 /* Convert .eh_frame register number to DWARF register number, or
687 adjust .debug_frame register number. */
688 int (*adjust_regnum
) (struct gdbarch
*, int, int);
691 /* Default architecture-specific register state initialization
695 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
696 struct dwarf2_frame_state_reg
*reg
,
697 struct frame_info
*this_frame
)
699 /* If we have a register that acts as a program counter, mark it as
700 a destination for the return address. If we have a register that
701 serves as the stack pointer, arrange for it to be filled with the
702 call frame address (CFA). The other registers are marked as
705 We copy the return address to the program counter, since many
706 parts in GDB assume that it is possible to get the return address
707 by unwinding the program counter register. However, on ISA's
708 with a dedicated return address register, the CFI usually only
709 contains information to unwind that return address register.
711 The reason we're treating the stack pointer special here is
712 because in many cases GCC doesn't emit CFI for the stack pointer
713 and implicitly assumes that it is equal to the CFA. This makes
714 some sense since the DWARF specification (version 3, draft 8,
717 "Typically, the CFA is defined to be the value of the stack
718 pointer at the call site in the previous frame (which may be
719 different from its value on entry to the current frame)."
721 However, this isn't true for all platforms supported by GCC
722 (e.g. IBM S/390 and zSeries). Those architectures should provide
723 their own architecture-specific initialization function. */
725 if (regnum
== gdbarch_pc_regnum (gdbarch
))
726 reg
->how
= DWARF2_FRAME_REG_RA
;
727 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
728 reg
->how
= DWARF2_FRAME_REG_CFA
;
731 /* Return a default for the architecture-specific operations. */
734 dwarf2_frame_init (struct obstack
*obstack
)
736 struct dwarf2_frame_ops
*ops
;
738 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
739 ops
->init_reg
= dwarf2_frame_default_init_reg
;
743 /* Set the architecture-specific register state initialization
744 function for GDBARCH to INIT_REG. */
747 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
748 void (*init_reg
) (struct gdbarch
*, int,
749 struct dwarf2_frame_state_reg
*,
750 struct frame_info
*))
752 struct dwarf2_frame_ops
*ops
753 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
755 ops
->init_reg
= init_reg
;
758 /* Pre-initialize the register state REG for register REGNUM. */
761 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
762 struct dwarf2_frame_state_reg
*reg
,
763 struct frame_info
*this_frame
)
765 struct dwarf2_frame_ops
*ops
766 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
768 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
771 /* Set the architecture-specific signal trampoline recognition
772 function for GDBARCH to SIGNAL_FRAME_P. */
775 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
776 int (*signal_frame_p
) (struct gdbarch
*,
777 struct frame_info
*))
779 struct dwarf2_frame_ops
*ops
780 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
782 ops
->signal_frame_p
= signal_frame_p
;
785 /* Query the architecture-specific signal frame recognizer for
789 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
790 struct frame_info
*this_frame
)
792 struct dwarf2_frame_ops
*ops
793 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
795 if (ops
->signal_frame_p
== NULL
)
797 return ops
->signal_frame_p (gdbarch
, this_frame
);
800 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
804 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
805 int (*adjust_regnum
) (struct gdbarch
*,
808 struct dwarf2_frame_ops
*ops
809 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
811 ops
->adjust_regnum
= adjust_regnum
;
814 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
818 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
,
819 int regnum
, int eh_frame_p
)
821 struct dwarf2_frame_ops
*ops
822 = (struct dwarf2_frame_ops
*) gdbarch_data (gdbarch
, dwarf2_frame_data
);
824 if (ops
->adjust_regnum
== NULL
)
826 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
830 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
831 struct dwarf2_fde
*fde
)
833 struct compunit_symtab
*cust
;
835 cust
= find_pc_compunit_symtab (fs
->pc
);
839 if (producer_is_realview (COMPUNIT_PRODUCER (cust
)))
841 if (fde
->cie
->version
== 1)
842 fs
->armcc_cfa_offsets_sf
= 1;
844 if (fde
->cie
->version
== 1)
845 fs
->armcc_cfa_offsets_reversed
= 1;
847 /* The reversed offset problem is present in some compilers
848 using DWARF3, but it was eventually fixed. Check the ARM
849 defined augmentations, which are in the format "armcc" followed
850 by a list of one-character options. The "+" option means
851 this problem is fixed (no quirk needed). If the armcc
852 augmentation is missing, the quirk is needed. */
853 if (fde
->cie
->version
== 3
854 && (!startswith (fde
->cie
->augmentation
, "armcc")
855 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
856 fs
->armcc_cfa_offsets_reversed
= 1;
863 /* See dwarf2-frame.h. */
866 dwarf2_fetch_cfa_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
867 struct dwarf2_per_cu_data
*data
,
868 int *regnum_out
, LONGEST
*offset_out
,
869 CORE_ADDR
*text_offset_out
,
870 const gdb_byte
**cfa_start_out
,
871 const gdb_byte
**cfa_end_out
)
873 struct dwarf2_fde
*fde
;
874 CORE_ADDR text_offset
;
877 /* Find the correct FDE. */
878 fde
= dwarf2_frame_find_fde (&pc1
, &text_offset
);
880 error (_("Could not compute CFA; needed to translate this expression"));
882 dwarf2_frame_state
fs (pc1
, fde
->cie
);
884 /* Check for "quirks" - known bugs in producers. */
885 dwarf2_frame_find_quirks (&fs
, fde
);
887 /* First decode all the insns in the CIE. */
888 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
889 fde
->cie
->end
, gdbarch
, pc
, &fs
);
891 /* Save the initialized register set. */
892 fs
.initial
= fs
.regs
;
894 /* Then decode the insns in the FDE up to our target PC. */
895 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
, pc
, &fs
);
897 /* Calculate the CFA. */
898 switch (fs
.regs
.cfa_how
)
902 int regnum
= dwarf_reg_to_regnum_or_error (gdbarch
, fs
.regs
.cfa_reg
);
904 *regnum_out
= regnum
;
905 if (fs
.armcc_cfa_offsets_reversed
)
906 *offset_out
= -fs
.regs
.cfa_offset
;
908 *offset_out
= fs
.regs
.cfa_offset
;
913 *text_offset_out
= text_offset
;
914 *cfa_start_out
= fs
.regs
.cfa_exp
;
915 *cfa_end_out
= fs
.regs
.cfa_exp
+ fs
.regs
.cfa_exp_len
;
919 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
924 struct dwarf2_frame_cache
926 /* DWARF Call Frame Address. */
929 /* Set if the return address column was marked as unavailable
930 (required non-collected memory or registers to compute). */
931 int unavailable_retaddr
;
933 /* Set if the return address column was marked as undefined. */
934 int undefined_retaddr
;
936 /* Saved registers, indexed by GDB register number, not by DWARF
938 struct dwarf2_frame_state_reg
*reg
;
940 /* Return address register. */
941 struct dwarf2_frame_state_reg retaddr_reg
;
943 /* Target address size in bytes. */
946 /* The .text offset. */
947 CORE_ADDR text_offset
;
949 /* True if we already checked whether this frame is the bottom frame
950 of a virtual tail call frame chain. */
951 int checked_tailcall_bottom
;
953 /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
954 sequence. If NULL then it is a normal case with no TAILCALL_FRAME
955 involved. Non-bottom frames of a virtual tail call frames chain use
956 dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
958 void *tailcall_cache
;
960 /* The number of bytes to subtract from TAILCALL_FRAME frames frame
961 base to get the SP, to simulate the return address pushed on the
963 LONGEST entry_cfa_sp_offset
;
964 int entry_cfa_sp_offset_p
;
967 static struct dwarf2_frame_cache
*
968 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
970 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
971 const int num_regs
= gdbarch_num_regs (gdbarch
)
972 + gdbarch_num_pseudo_regs (gdbarch
);
973 struct dwarf2_frame_cache
*cache
;
974 struct dwarf2_fde
*fde
;
976 const gdb_byte
*instr
;
979 return (struct dwarf2_frame_cache
*) *this_cache
;
981 /* Allocate a new cache. */
982 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
983 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
988 Note that if the next frame is never supposed to return (i.e. a call
989 to abort), the compiler might optimize away the instruction at
990 its return address. As a result the return address will
991 point at some random instruction, and the CFI for that
992 instruction is probably worthless to us. GCC's unwinder solves
993 this problem by substracting 1 from the return address to get an
994 address in the middle of a presumed call instruction (or the
995 instruction in the associated delay slot). This should only be
996 done for "normal" frames and not for resume-type frames (signal
997 handlers, sentinel frames, dummy frames). The function
998 get_frame_address_in_block does just this. It's not clear how
999 reliable the method is though; there is the potential for the
1000 register state pre-call being different to that on return. */
1001 CORE_ADDR pc1
= get_frame_address_in_block (this_frame
);
1003 /* Find the correct FDE. */
1004 fde
= dwarf2_frame_find_fde (&pc1
, &cache
->text_offset
);
1005 gdb_assert (fde
!= NULL
);
1007 /* Allocate and initialize the frame state. */
1008 struct dwarf2_frame_state
fs (pc1
, fde
->cie
);
1010 cache
->addr_size
= fde
->cie
->addr_size
;
1012 /* Check for "quirks" - known bugs in producers. */
1013 dwarf2_frame_find_quirks (&fs
, fde
);
1015 /* First decode all the insns in the CIE. */
1016 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
1017 fde
->cie
->end
, gdbarch
,
1018 get_frame_address_in_block (this_frame
), &fs
);
1020 /* Save the initialized register set. */
1021 fs
.initial
= fs
.regs
;
1023 if (get_frame_func_if_available (this_frame
, &entry_pc
))
1025 /* Decode the insns in the FDE up to the entry PC. */
1026 instr
= execute_cfa_program (fde
, fde
->instructions
, fde
->end
, gdbarch
,
1029 if (fs
.regs
.cfa_how
== CFA_REG_OFFSET
1030 && (dwarf_reg_to_regnum (gdbarch
, fs
.regs
.cfa_reg
)
1031 == gdbarch_sp_regnum (gdbarch
)))
1033 cache
->entry_cfa_sp_offset
= fs
.regs
.cfa_offset
;
1034 cache
->entry_cfa_sp_offset_p
= 1;
1038 instr
= fde
->instructions
;
1040 /* Then decode the insns in the FDE up to our target PC. */
1041 execute_cfa_program (fde
, instr
, fde
->end
, gdbarch
,
1042 get_frame_address_in_block (this_frame
), &fs
);
1046 /* Calculate the CFA. */
1047 switch (fs
.regs
.cfa_how
)
1049 case CFA_REG_OFFSET
:
1050 cache
->cfa
= read_addr_from_reg (this_frame
, fs
.regs
.cfa_reg
);
1051 if (fs
.armcc_cfa_offsets_reversed
)
1052 cache
->cfa
-= fs
.regs
.cfa_offset
;
1054 cache
->cfa
+= fs
.regs
.cfa_offset
;
1059 execute_stack_op (fs
.regs
.cfa_exp
, fs
.regs
.cfa_exp_len
,
1060 cache
->addr_size
, cache
->text_offset
,
1065 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
1068 CATCH (ex
, RETURN_MASK_ERROR
)
1070 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1072 cache
->unavailable_retaddr
= 1;
1076 throw_exception (ex
);
1080 /* Initialize the register state. */
1084 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1085 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
1088 /* Go through the DWARF2 CFI generated table and save its register
1089 location information in the cache. Note that we don't skip the
1090 return address column; it's perfectly all right for it to
1091 correspond to a real register. */
1093 int column
; /* CFI speak for "register number". */
1095 for (column
= 0; column
< fs
.regs
.num_regs
; column
++)
1097 /* Use the GDB register number as the destination index. */
1098 int regnum
= dwarf_reg_to_regnum (gdbarch
, column
);
1100 /* Protect against a target returning a bad register. */
1101 if (regnum
< 0 || regnum
>= num_regs
)
1104 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1105 of all debug info registers. If it doesn't, complain (but
1106 not too loudly). It turns out that GCC assumes that an
1107 unspecified register implies "same value" when CFI (draft
1108 7) specifies nothing at all. Such a register could equally
1109 be interpreted as "undefined". Also note that this check
1110 isn't sufficient; it only checks that all registers in the
1111 range [0 .. max column] are specified, and won't detect
1112 problems when a debug info register falls outside of the
1113 table. We need a way of iterating through all the valid
1114 DWARF2 register numbers. */
1115 if (fs
.regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1117 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
1119 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1120 gdbarch_register_name (gdbarch
, regnum
),
1121 paddress (gdbarch
, fs
.pc
));
1124 cache
->reg
[regnum
] = fs
.regs
.reg
[column
];
1128 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1129 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1133 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1135 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1136 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1138 struct dwarf2_frame_state_reg
*retaddr_reg
=
1139 &fs
.regs
.reg
[fs
.retaddr_column
];
1141 /* It seems rather bizarre to specify an "empty" column as
1142 the return adress column. However, this is exactly
1143 what GCC does on some targets. It turns out that GCC
1144 assumes that the return address can be found in the
1145 register corresponding to the return address column.
1146 Incidentally, that's how we should treat a return
1147 address column specifying "same value" too. */
1148 if (fs
.retaddr_column
< fs
.regs
.num_regs
1149 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1150 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1152 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1153 cache
->reg
[regnum
] = *retaddr_reg
;
1155 cache
->retaddr_reg
= *retaddr_reg
;
1159 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1161 cache
->reg
[regnum
].loc
.reg
= fs
.retaddr_column
;
1162 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1166 cache
->retaddr_reg
.loc
.reg
= fs
.retaddr_column
;
1167 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1174 if (fs
.retaddr_column
< fs
.regs
.num_regs
1175 && fs
.regs
.reg
[fs
.retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1176 cache
->undefined_retaddr
= 1;
1181 static enum unwind_stop_reason
1182 dwarf2_frame_unwind_stop_reason (struct frame_info
*this_frame
,
1185 struct dwarf2_frame_cache
*cache
1186 = dwarf2_frame_cache (this_frame
, this_cache
);
1188 if (cache
->unavailable_retaddr
)
1189 return UNWIND_UNAVAILABLE
;
1191 if (cache
->undefined_retaddr
)
1192 return UNWIND_OUTERMOST
;
1194 return UNWIND_NO_REASON
;
1198 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1199 struct frame_id
*this_id
)
1201 struct dwarf2_frame_cache
*cache
=
1202 dwarf2_frame_cache (this_frame
, this_cache
);
1204 if (cache
->unavailable_retaddr
)
1205 (*this_id
) = frame_id_build_unavailable_stack (get_frame_func (this_frame
));
1206 else if (cache
->undefined_retaddr
)
1209 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1212 static struct value
*
1213 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1216 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1217 struct dwarf2_frame_cache
*cache
=
1218 dwarf2_frame_cache (this_frame
, this_cache
);
1222 /* Check whether THIS_FRAME is the bottom frame of a virtual tail
1223 call frame chain. */
1224 if (!cache
->checked_tailcall_bottom
)
1226 cache
->checked_tailcall_bottom
= 1;
1227 dwarf2_tailcall_sniffer_first (this_frame
, &cache
->tailcall_cache
,
1228 (cache
->entry_cfa_sp_offset_p
1229 ? &cache
->entry_cfa_sp_offset
: NULL
));
1232 /* Non-bottom frames of a virtual tail call frames chain use
1233 dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1234 them. If dwarf2_tailcall_prev_register_first does not have specific value
1235 unwind the register, tail call frames are assumed to have the register set
1236 of the top caller. */
1237 if (cache
->tailcall_cache
)
1241 val
= dwarf2_tailcall_prev_register_first (this_frame
,
1242 &cache
->tailcall_cache
,
1248 switch (cache
->reg
[regnum
].how
)
1250 case DWARF2_FRAME_REG_UNDEFINED
:
1251 /* If CFI explicitly specified that the value isn't defined,
1252 mark it as optimized away; the value isn't available. */
1253 return frame_unwind_got_optimized (this_frame
, regnum
);
1255 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1256 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1257 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1259 case DWARF2_FRAME_REG_SAVED_REG
:
1260 realnum
= dwarf_reg_to_regnum_or_error
1261 (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1262 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1264 case DWARF2_FRAME_REG_SAVED_EXP
:
1265 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
.start
,
1266 cache
->reg
[regnum
].loc
.exp
.len
,
1267 cache
->addr_size
, cache
->text_offset
,
1268 this_frame
, cache
->cfa
, 1);
1269 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1271 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1272 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1273 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1275 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1276 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
.start
,
1277 cache
->reg
[regnum
].loc
.exp
.len
,
1278 cache
->addr_size
, cache
->text_offset
,
1279 this_frame
, cache
->cfa
, 1);
1280 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1282 case DWARF2_FRAME_REG_UNSPECIFIED
:
1283 /* GCC, in its infinite wisdom decided to not provide unwind
1284 information for registers that are "same value". Since
1285 DWARF2 (3 draft 7) doesn't define such behavior, said
1286 registers are actually undefined (which is different to CFI
1287 "undefined"). Code above issues a complaint about this.
1288 Here just fudge the books, assume GCC, and that the value is
1289 more inner on the stack. */
1290 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1292 case DWARF2_FRAME_REG_SAME_VALUE
:
1293 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1295 case DWARF2_FRAME_REG_CFA
:
1296 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1298 case DWARF2_FRAME_REG_CFA_OFFSET
:
1299 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1300 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1302 case DWARF2_FRAME_REG_RA_OFFSET
:
1303 addr
= cache
->reg
[regnum
].loc
.offset
;
1304 regnum
= dwarf_reg_to_regnum_or_error
1305 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1306 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1307 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1309 case DWARF2_FRAME_REG_FN
:
1310 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1313 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1317 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1318 call frames chain. */
1321 dwarf2_frame_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1323 struct dwarf2_frame_cache
*cache
= dwarf2_frame_cache (self
, &this_cache
);
1325 if (cache
->tailcall_cache
)
1326 dwarf2_tailcall_frame_unwind
.dealloc_cache (self
, cache
->tailcall_cache
);
1330 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1331 struct frame_info
*this_frame
, void **this_cache
)
1333 if (!dwarf2_frame_unwinders_enabled_p
)
1336 /* Grab an address that is guarenteed to reside somewhere within the
1337 function. get_frame_pc(), with a no-return next function, can
1338 end up returning something past the end of this function's body.
1339 If the frame we're sniffing for is a signal frame whose start
1340 address is placed on the stack by the OS, its FDE must
1341 extend one byte before its start address or we could potentially
1342 select the FDE of the previous function. */
1343 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1344 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
, NULL
);
1349 /* On some targets, signal trampolines may have unwind information.
1350 We need to recognize them so that we set the frame type
1353 if (fde
->cie
->signal_frame
1354 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1356 return self
->type
== SIGTRAMP_FRAME
;
1358 if (self
->type
!= NORMAL_FRAME
)
1364 static const struct frame_unwind dwarf2_frame_unwind
=
1367 dwarf2_frame_unwind_stop_reason
,
1368 dwarf2_frame_this_id
,
1369 dwarf2_frame_prev_register
,
1371 dwarf2_frame_sniffer
,
1372 dwarf2_frame_dealloc_cache
1375 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1378 dwarf2_frame_unwind_stop_reason
,
1379 dwarf2_frame_this_id
,
1380 dwarf2_frame_prev_register
,
1382 dwarf2_frame_sniffer
,
1384 /* TAILCALL_CACHE can never be in such frame to need dealloc_cache. */
1388 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1391 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1393 /* TAILCALL_FRAME must be first to find the record by
1394 dwarf2_tailcall_sniffer_first. */
1395 frame_unwind_append_unwinder (gdbarch
, &dwarf2_tailcall_frame_unwind
);
1397 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1398 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1402 /* There is no explicitly defined relationship between the CFA and the
1403 location of frame's local variables and arguments/parameters.
1404 Therefore, frame base methods on this page should probably only be
1405 used as a last resort, just to avoid printing total garbage as a
1406 response to the "info frame" command. */
1409 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1411 struct dwarf2_frame_cache
*cache
=
1412 dwarf2_frame_cache (this_frame
, this_cache
);
1417 static const struct frame_base dwarf2_frame_base
=
1419 &dwarf2_frame_unwind
,
1420 dwarf2_frame_base_address
,
1421 dwarf2_frame_base_address
,
1422 dwarf2_frame_base_address
1425 const struct frame_base
*
1426 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1428 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1430 if (dwarf2_frame_find_fde (&block_addr
, NULL
))
1431 return &dwarf2_frame_base
;
1436 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1437 the DWARF unwinder. This is used to implement
1438 DW_OP_call_frame_cfa. */
1441 dwarf2_frame_cfa (struct frame_info
*this_frame
)
1443 if (frame_unwinder_is (this_frame
, &record_btrace_tailcall_frame_unwind
)
1444 || frame_unwinder_is (this_frame
, &record_btrace_frame_unwind
))
1445 throw_error (NOT_AVAILABLE_ERROR
,
1446 _("cfa not available for record btrace target"));
1448 while (get_frame_type (this_frame
) == INLINE_FRAME
)
1449 this_frame
= get_prev_frame (this_frame
);
1450 if (get_frame_unwind_stop_reason (this_frame
) == UNWIND_UNAVAILABLE
)
1451 throw_error (NOT_AVAILABLE_ERROR
,
1452 _("can't compute CFA for this frame: "
1453 "required registers or memory are unavailable"));
1455 if (get_frame_id (this_frame
).stack_status
!= FID_STACK_VALID
)
1456 throw_error (NOT_AVAILABLE_ERROR
,
1457 _("can't compute CFA for this frame: "
1458 "frame base not available"));
1460 return get_frame_base (this_frame
);
1463 const struct objfile_data
*dwarf2_frame_objfile_data
;
1466 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
1468 return bfd_get_8 (abfd
, buf
);
1472 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
1474 return bfd_get_32 (abfd
, buf
);
1478 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
1480 return bfd_get_64 (abfd
, buf
);
1484 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
,
1485 unsigned int *bytes_read_ptr
)
1489 result
= bfd_get_32 (abfd
, buf
);
1490 if (result
== 0xffffffff)
1492 result
= bfd_get_64 (abfd
, buf
+ 4);
1493 *bytes_read_ptr
= 12;
1496 *bytes_read_ptr
= 4;
1502 /* Pointer encoding helper functions. */
1504 /* GCC supports exception handling based on DWARF2 CFI. However, for
1505 technical reasons, it encodes addresses in its FDE's in a different
1506 way. Several "pointer encodings" are supported. The encoding
1507 that's used for a particular FDE is determined by the 'R'
1508 augmentation in the associated CIE. The argument of this
1509 augmentation is a single byte.
1511 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1512 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1513 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1514 address should be interpreted (absolute, relative to the current
1515 position in the FDE, ...). Bit 7, indicates that the address
1516 should be dereferenced. */
1519 encoding_for_size (unsigned int size
)
1524 return DW_EH_PE_udata2
;
1526 return DW_EH_PE_udata4
;
1528 return DW_EH_PE_udata8
;
1530 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1535 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1536 int ptr_len
, const gdb_byte
*buf
,
1537 unsigned int *bytes_read_ptr
,
1538 CORE_ADDR func_base
)
1543 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1545 if (encoding
& DW_EH_PE_indirect
)
1546 internal_error (__FILE__
, __LINE__
,
1547 _("Unsupported encoding: DW_EH_PE_indirect"));
1549 *bytes_read_ptr
= 0;
1551 switch (encoding
& 0x70)
1553 case DW_EH_PE_absptr
:
1556 case DW_EH_PE_pcrel
:
1557 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1558 base
+= (buf
- unit
->dwarf_frame_buffer
);
1560 case DW_EH_PE_datarel
:
1563 case DW_EH_PE_textrel
:
1566 case DW_EH_PE_funcrel
:
1569 case DW_EH_PE_aligned
:
1571 offset
= buf
- unit
->dwarf_frame_buffer
;
1572 if ((offset
% ptr_len
) != 0)
1574 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1575 buf
+= *bytes_read_ptr
;
1579 internal_error (__FILE__
, __LINE__
,
1580 _("Invalid or unsupported encoding"));
1583 if ((encoding
& 0x07) == 0x00)
1585 encoding
|= encoding_for_size (ptr_len
);
1586 if (bfd_get_sign_extend_vma (unit
->abfd
))
1587 encoding
|= DW_EH_PE_signed
;
1590 switch (encoding
& 0x0f)
1592 case DW_EH_PE_uleb128
:
1595 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1597 *bytes_read_ptr
+= safe_read_uleb128 (buf
, end_buf
, &value
) - buf
;
1598 return base
+ value
;
1600 case DW_EH_PE_udata2
:
1601 *bytes_read_ptr
+= 2;
1602 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1603 case DW_EH_PE_udata4
:
1604 *bytes_read_ptr
+= 4;
1605 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1606 case DW_EH_PE_udata8
:
1607 *bytes_read_ptr
+= 8;
1608 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1609 case DW_EH_PE_sleb128
:
1612 const gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1614 *bytes_read_ptr
+= safe_read_sleb128 (buf
, end_buf
, &value
) - buf
;
1615 return base
+ value
;
1617 case DW_EH_PE_sdata2
:
1618 *bytes_read_ptr
+= 2;
1619 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1620 case DW_EH_PE_sdata4
:
1621 *bytes_read_ptr
+= 4;
1622 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1623 case DW_EH_PE_sdata8
:
1624 *bytes_read_ptr
+= 8;
1625 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1627 internal_error (__FILE__
, __LINE__
,
1628 _("Invalid or unsupported encoding"));
1634 bsearch_cie_cmp (const void *key
, const void *element
)
1636 ULONGEST cie_pointer
= *(ULONGEST
*) key
;
1637 struct dwarf2_cie
*cie
= *(struct dwarf2_cie
**) element
;
1639 if (cie_pointer
== cie
->cie_pointer
)
1642 return (cie_pointer
< cie
->cie_pointer
) ? -1 : 1;
1645 /* Find CIE with the given CIE_POINTER in CIE_TABLE. */
1646 static struct dwarf2_cie
*
1647 find_cie (struct dwarf2_cie_table
*cie_table
, ULONGEST cie_pointer
)
1649 struct dwarf2_cie
**p_cie
;
1651 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1652 bsearch be non-NULL. */
1653 if (cie_table
->entries
== NULL
)
1655 gdb_assert (cie_table
->num_entries
== 0);
1659 p_cie
= ((struct dwarf2_cie
**)
1660 bsearch (&cie_pointer
, cie_table
->entries
, cie_table
->num_entries
,
1661 sizeof (cie_table
->entries
[0]), bsearch_cie_cmp
));
1667 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it. */
1669 add_cie (struct dwarf2_cie_table
*cie_table
, struct dwarf2_cie
*cie
)
1671 const int n
= cie_table
->num_entries
;
1674 || cie_table
->entries
[n
- 1]->cie_pointer
< cie
->cie_pointer
);
1677 = XRESIZEVEC (struct dwarf2_cie
*, cie_table
->entries
, n
+ 1);
1678 cie_table
->entries
[n
] = cie
;
1679 cie_table
->num_entries
= n
+ 1;
1683 bsearch_fde_cmp (const void *key
, const void *element
)
1685 CORE_ADDR seek_pc
= *(CORE_ADDR
*) key
;
1686 struct dwarf2_fde
*fde
= *(struct dwarf2_fde
**) element
;
1688 if (seek_pc
< fde
->initial_location
)
1690 if (seek_pc
< fde
->initial_location
+ fde
->address_range
)
1695 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1696 inital location associated with it into *PC. */
1698 static struct dwarf2_fde
*
1699 dwarf2_frame_find_fde (CORE_ADDR
*pc
, CORE_ADDR
*out_offset
)
1701 struct objfile
*objfile
;
1703 ALL_OBJFILES (objfile
)
1705 struct dwarf2_fde_table
*fde_table
;
1706 struct dwarf2_fde
**p_fde
;
1710 fde_table
= ((struct dwarf2_fde_table
*)
1711 objfile_data (objfile
, dwarf2_frame_objfile_data
));
1712 if (fde_table
== NULL
)
1714 dwarf2_build_frame_info (objfile
);
1715 fde_table
= ((struct dwarf2_fde_table
*)
1716 objfile_data (objfile
, dwarf2_frame_objfile_data
));
1718 gdb_assert (fde_table
!= NULL
);
1720 if (fde_table
->num_entries
== 0)
1723 gdb_assert (objfile
->section_offsets
);
1724 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1726 gdb_assert (fde_table
->num_entries
> 0);
1727 if (*pc
< offset
+ fde_table
->entries
[0]->initial_location
)
1730 seek_pc
= *pc
- offset
;
1731 p_fde
= ((struct dwarf2_fde
**)
1732 bsearch (&seek_pc
, fde_table
->entries
, fde_table
->num_entries
,
1733 sizeof (fde_table
->entries
[0]), bsearch_fde_cmp
));
1736 *pc
= (*p_fde
)->initial_location
+ offset
;
1738 *out_offset
= offset
;
1745 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it. */
1747 add_fde (struct dwarf2_fde_table
*fde_table
, struct dwarf2_fde
*fde
)
1749 if (fde
->address_range
== 0)
1750 /* Discard useless FDEs. */
1753 fde_table
->num_entries
+= 1;
1754 fde_table
->entries
= XRESIZEVEC (struct dwarf2_fde
*, fde_table
->entries
,
1755 fde_table
->num_entries
);
1756 fde_table
->entries
[fde_table
->num_entries
- 1] = fde
;
1759 #define DW64_CIE_ID 0xffffffffffffffffULL
1761 /* Defines the type of eh_frames that are expected to be decoded: CIE, FDE
1766 EH_CIE_TYPE_ID
= 1 << 0,
1767 EH_FDE_TYPE_ID
= 1 << 1,
1768 EH_CIE_OR_FDE_TYPE_ID
= EH_CIE_TYPE_ID
| EH_FDE_TYPE_ID
1771 static const gdb_byte
*decode_frame_entry (struct comp_unit
*unit
,
1772 const gdb_byte
*start
,
1774 struct dwarf2_cie_table
*cie_table
,
1775 struct dwarf2_fde_table
*fde_table
,
1776 enum eh_frame_type entry_type
);
1778 /* Decode the next CIE or FDE, entry_type specifies the expected type.
1779 Return NULL if invalid input, otherwise the next byte to be processed. */
1781 static const gdb_byte
*
1782 decode_frame_entry_1 (struct comp_unit
*unit
, const gdb_byte
*start
,
1784 struct dwarf2_cie_table
*cie_table
,
1785 struct dwarf2_fde_table
*fde_table
,
1786 enum eh_frame_type entry_type
)
1788 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1789 const gdb_byte
*buf
, *end
;
1791 unsigned int bytes_read
;
1794 ULONGEST cie_pointer
;
1799 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1803 /* Are we still within the section? */
1804 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1810 /* Distinguish between 32 and 64-bit encoded frame info. */
1811 dwarf64_p
= (bytes_read
== 12);
1813 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1817 cie_id
= DW64_CIE_ID
;
1823 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1828 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1832 if (cie_pointer
== cie_id
)
1834 /* This is a CIE. */
1835 struct dwarf2_cie
*cie
;
1837 unsigned int cie_version
;
1839 /* Check that a CIE was expected. */
1840 if ((entry_type
& EH_CIE_TYPE_ID
) == 0)
1841 error (_("Found a CIE when not expecting it."));
1843 /* Record the offset into the .debug_frame section of this CIE. */
1844 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1846 /* Check whether we've already read it. */
1847 if (find_cie (cie_table
, cie_pointer
))
1850 cie
= XOBNEW (&unit
->objfile
->objfile_obstack
, struct dwarf2_cie
);
1851 cie
->initial_instructions
= NULL
;
1852 cie
->cie_pointer
= cie_pointer
;
1854 /* The encoding for FDE's in a normal .debug_frame section
1855 depends on the target address size. */
1856 cie
->encoding
= DW_EH_PE_absptr
;
1858 /* We'll determine the final value later, but we need to
1859 initialize it conservatively. */
1860 cie
->signal_frame
= 0;
1862 /* Check version number. */
1863 cie_version
= read_1_byte (unit
->abfd
, buf
);
1864 if (cie_version
!= 1 && cie_version
!= 3 && cie_version
!= 4)
1866 cie
->version
= cie_version
;
1869 /* Interpret the interesting bits of the augmentation. */
1870 cie
->augmentation
= augmentation
= (char *) buf
;
1871 buf
+= (strlen (augmentation
) + 1);
1873 /* Ignore armcc augmentations. We only use them for quirks,
1874 and that doesn't happen until later. */
1875 if (startswith (augmentation
, "armcc"))
1876 augmentation
+= strlen (augmentation
);
1878 /* The GCC 2.x "eh" augmentation has a pointer immediately
1879 following the augmentation string, so it must be handled
1881 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1884 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1888 if (cie
->version
>= 4)
1890 /* FIXME: check that this is the same as from the CU header. */
1891 cie
->addr_size
= read_1_byte (unit
->abfd
, buf
);
1893 cie
->segment_size
= read_1_byte (unit
->abfd
, buf
);
1898 cie
->addr_size
= gdbarch_dwarf2_addr_size (gdbarch
);
1899 cie
->segment_size
= 0;
1901 /* Address values in .eh_frame sections are defined to have the
1902 target's pointer size. Watchout: This breaks frame info for
1903 targets with pointer size < address size, unless a .debug_frame
1904 section exists as well. */
1906 cie
->ptr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1908 cie
->ptr_size
= cie
->addr_size
;
1910 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
1913 cie
->code_alignment_factor
= uleb128
;
1915 buf
= gdb_read_sleb128 (buf
, end
, &sleb128
);
1918 cie
->data_alignment_factor
= sleb128
;
1920 if (cie_version
== 1)
1922 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1927 buf
= gdb_read_uleb128 (buf
, end
, &uleb128
);
1930 cie
->return_address_register
= uleb128
;
1933 cie
->return_address_register
1934 = dwarf2_frame_adjust_regnum (gdbarch
,
1935 cie
->return_address_register
,
1938 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1939 if (cie
->saw_z_augmentation
)
1943 buf
= gdb_read_uleb128 (buf
, end
, &length
);
1946 cie
->initial_instructions
= buf
+ length
;
1950 while (*augmentation
)
1952 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1953 if (*augmentation
== 'L')
1960 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1961 else if (*augmentation
== 'R')
1963 cie
->encoding
= *buf
++;
1967 /* "P" indicates a personality routine in the CIE augmentation. */
1968 else if (*augmentation
== 'P')
1970 /* Skip. Avoid indirection since we throw away the result. */
1971 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1972 read_encoded_value (unit
, encoding
, cie
->ptr_size
,
1973 buf
, &bytes_read
, 0);
1978 /* "S" indicates a signal frame, such that the return
1979 address must not be decremented to locate the call frame
1980 info for the previous frame; it might even be the first
1981 instruction of a function, so decrementing it would take
1982 us to a different function. */
1983 else if (*augmentation
== 'S')
1985 cie
->signal_frame
= 1;
1989 /* Otherwise we have an unknown augmentation. Assume that either
1990 there is no augmentation data, or we saw a 'z' prefix. */
1993 if (cie
->initial_instructions
)
1994 buf
= cie
->initial_instructions
;
1999 cie
->initial_instructions
= buf
;
2003 add_cie (cie_table
, cie
);
2007 /* This is a FDE. */
2008 struct dwarf2_fde
*fde
;
2011 /* Check that an FDE was expected. */
2012 if ((entry_type
& EH_FDE_TYPE_ID
) == 0)
2013 error (_("Found an FDE when not expecting it."));
2015 /* In an .eh_frame section, the CIE pointer is the delta between the
2016 address within the FDE where the CIE pointer is stored and the
2017 address of the CIE. Convert it to an offset into the .eh_frame
2021 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
2022 cie_pointer
-= (dwarf64_p
? 8 : 4);
2025 /* In either case, validate the result is still within the section. */
2026 if (cie_pointer
>= unit
->dwarf_frame_size
)
2029 fde
= XOBNEW (&unit
->objfile
->objfile_obstack
, struct dwarf2_fde
);
2030 fde
->cie
= find_cie (cie_table
, cie_pointer
);
2031 if (fde
->cie
== NULL
)
2033 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
2034 eh_frame_p
, cie_table
, fde_table
,
2036 fde
->cie
= find_cie (cie_table
, cie_pointer
);
2039 gdb_assert (fde
->cie
!= NULL
);
2041 addr
= read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->ptr_size
,
2042 buf
, &bytes_read
, 0);
2043 fde
->initial_location
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
2046 fde
->address_range
=
2047 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
2048 fde
->cie
->ptr_size
, buf
, &bytes_read
, 0);
2049 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ fde
->address_range
);
2050 fde
->address_range
= addr
- fde
->initial_location
;
2053 /* A 'z' augmentation in the CIE implies the presence of an
2054 augmentation field in the FDE as well. The only thing known
2055 to be in here at present is the LSDA entry for EH. So we
2056 can skip the whole thing. */
2057 if (fde
->cie
->saw_z_augmentation
)
2061 buf
= gdb_read_uleb128 (buf
, end
, &length
);
2069 fde
->instructions
= buf
;
2072 fde
->eh_frame_p
= eh_frame_p
;
2074 add_fde (fde_table
, fde
);
2080 /* Read a CIE or FDE in BUF and decode it. Entry_type specifies whether we
2081 expect an FDE or a CIE. */
2083 static const gdb_byte
*
2084 decode_frame_entry (struct comp_unit
*unit
, const gdb_byte
*start
,
2086 struct dwarf2_cie_table
*cie_table
,
2087 struct dwarf2_fde_table
*fde_table
,
2088 enum eh_frame_type entry_type
)
2090 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
2091 const gdb_byte
*ret
;
2092 ptrdiff_t start_offset
;
2096 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
,
2097 cie_table
, fde_table
, entry_type
);
2101 /* We have corrupt input data of some form. */
2103 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2104 and mismatches wrt padding and alignment of debug sections. */
2105 /* Note that there is no requirement in the standard for any
2106 alignment at all in the frame unwind sections. Testing for
2107 alignment before trying to interpret data would be incorrect.
2109 However, GCC traditionally arranged for frame sections to be
2110 sized such that the FDE length and CIE fields happen to be
2111 aligned (in theory, for performance). This, unfortunately,
2112 was done with .align directives, which had the side effect of
2113 forcing the section to be aligned by the linker.
2115 This becomes a problem when you have some other producer that
2116 creates frame sections that are not as strictly aligned. That
2117 produces a hole in the frame info that gets filled by the
2120 The GCC behaviour is arguably a bug, but it's effectively now
2121 part of the ABI, so we're now stuck with it, at least at the
2122 object file level. A smart linker may decide, in the process
2123 of compressing duplicate CIE information, that it can rewrite
2124 the entire output section without this extra padding. */
2126 start_offset
= start
- unit
->dwarf_frame_buffer
;
2127 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
2129 start
+= 4 - (start_offset
& 3);
2130 workaround
= ALIGN4
;
2133 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
2135 start
+= 8 - (start_offset
& 7);
2136 workaround
= ALIGN8
;
2140 /* Nothing left to try. Arrange to return as if we've consumed
2141 the entire input section. Hopefully we'll get valid info from
2142 the other of .debug_frame/.eh_frame. */
2144 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
2155 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2156 unit
->dwarf_frame_section
->owner
->filename
,
2157 unit
->dwarf_frame_section
->name
);
2162 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2163 unit
->dwarf_frame_section
->owner
->filename
,
2164 unit
->dwarf_frame_section
->name
);
2168 complaint (_("Corrupt data in %s:%s"),
2169 unit
->dwarf_frame_section
->owner
->filename
,
2170 unit
->dwarf_frame_section
->name
);
2178 qsort_fde_cmp (const void *a
, const void *b
)
2180 struct dwarf2_fde
*aa
= *(struct dwarf2_fde
**)a
;
2181 struct dwarf2_fde
*bb
= *(struct dwarf2_fde
**)b
;
2183 if (aa
->initial_location
== bb
->initial_location
)
2185 if (aa
->address_range
!= bb
->address_range
2186 && aa
->eh_frame_p
== 0 && bb
->eh_frame_p
== 0)
2187 /* Linker bug, e.g. gold/10400.
2188 Work around it by keeping stable sort order. */
2189 return (a
< b
) ? -1 : 1;
2191 /* Put eh_frame entries after debug_frame ones. */
2192 return aa
->eh_frame_p
- bb
->eh_frame_p
;
2195 return (aa
->initial_location
< bb
->initial_location
) ? -1 : 1;
2199 dwarf2_build_frame_info (struct objfile
*objfile
)
2201 struct comp_unit
*unit
;
2202 const gdb_byte
*frame_ptr
;
2203 struct dwarf2_cie_table cie_table
;
2204 struct dwarf2_fde_table fde_table
;
2205 struct dwarf2_fde_table
*fde_table2
;
2207 cie_table
.num_entries
= 0;
2208 cie_table
.entries
= NULL
;
2210 fde_table
.num_entries
= 0;
2211 fde_table
.entries
= NULL
;
2213 /* Build a minimal decoding of the DWARF2 compilation unit. */
2214 unit
= XOBNEW (&objfile
->objfile_obstack
, comp_unit
);
2215 unit
->abfd
= objfile
->obfd
;
2216 unit
->objfile
= objfile
;
2220 if (objfile
->separate_debug_objfile_backlink
== NULL
)
2222 /* Do not read .eh_frame from separate file as they must be also
2223 present in the main file. */
2224 dwarf2_get_section_info (objfile
, DWARF2_EH_FRAME
,
2225 &unit
->dwarf_frame_section
,
2226 &unit
->dwarf_frame_buffer
,
2227 &unit
->dwarf_frame_size
);
2228 if (unit
->dwarf_frame_size
)
2230 asection
*got
, *txt
;
2232 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2233 that is used for the i386/amd64 target, which currently is
2234 the only target in GCC that supports/uses the
2235 DW_EH_PE_datarel encoding. */
2236 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2238 unit
->dbase
= got
->vma
;
2240 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2242 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2244 unit
->tbase
= txt
->vma
;
2248 frame_ptr
= unit
->dwarf_frame_buffer
;
2249 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2250 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1,
2251 &cie_table
, &fde_table
,
2252 EH_CIE_OR_FDE_TYPE_ID
);
2255 CATCH (e
, RETURN_MASK_ERROR
)
2257 warning (_("skipping .eh_frame info of %s: %s"),
2258 objfile_name (objfile
), e
.message
);
2260 if (fde_table
.num_entries
!= 0)
2262 xfree (fde_table
.entries
);
2263 fde_table
.entries
= NULL
;
2264 fde_table
.num_entries
= 0;
2266 /* The cie_table is discarded by the next if. */
2270 if (cie_table
.num_entries
!= 0)
2272 /* Reinit cie_table: debug_frame has different CIEs. */
2273 xfree (cie_table
.entries
);
2274 cie_table
.num_entries
= 0;
2275 cie_table
.entries
= NULL
;
2280 dwarf2_get_section_info (objfile
, DWARF2_DEBUG_FRAME
,
2281 &unit
->dwarf_frame_section
,
2282 &unit
->dwarf_frame_buffer
,
2283 &unit
->dwarf_frame_size
);
2284 if (unit
->dwarf_frame_size
)
2286 int num_old_fde_entries
= fde_table
.num_entries
;
2290 frame_ptr
= unit
->dwarf_frame_buffer
;
2291 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2292 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0,
2293 &cie_table
, &fde_table
,
2294 EH_CIE_OR_FDE_TYPE_ID
);
2296 CATCH (e
, RETURN_MASK_ERROR
)
2298 warning (_("skipping .debug_frame info of %s: %s"),
2299 objfile_name (objfile
), e
.message
);
2301 if (fde_table
.num_entries
!= 0)
2303 fde_table
.num_entries
= num_old_fde_entries
;
2304 if (num_old_fde_entries
== 0)
2306 xfree (fde_table
.entries
);
2307 fde_table
.entries
= NULL
;
2312 = XRESIZEVEC (struct dwarf2_fde
*, fde_table
.entries
,
2313 fde_table
.num_entries
);
2316 fde_table
.num_entries
= num_old_fde_entries
;
2317 /* The cie_table is discarded by the next if. */
2322 /* Discard the cie_table, it is no longer needed. */
2323 if (cie_table
.num_entries
!= 0)
2325 xfree (cie_table
.entries
);
2326 cie_table
.entries
= NULL
; /* Paranoia. */
2327 cie_table
.num_entries
= 0; /* Paranoia. */
2330 /* Copy fde_table to obstack: it is needed at runtime. */
2331 fde_table2
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_fde_table
);
2333 if (fde_table
.num_entries
== 0)
2335 fde_table2
->entries
= NULL
;
2336 fde_table2
->num_entries
= 0;
2340 struct dwarf2_fde
*fde_prev
= NULL
;
2341 struct dwarf2_fde
*first_non_zero_fde
= NULL
;
2344 /* Prepare FDE table for lookups. */
2345 qsort (fde_table
.entries
, fde_table
.num_entries
,
2346 sizeof (fde_table
.entries
[0]), qsort_fde_cmp
);
2348 /* Check for leftovers from --gc-sections. The GNU linker sets
2349 the relevant symbols to zero, but doesn't zero the FDE *end*
2350 ranges because there's no relocation there. It's (offset,
2351 length), not (start, end). On targets where address zero is
2352 just another valid address this can be a problem, since the
2353 FDEs appear to be non-empty in the output --- we could pick
2354 out the wrong FDE. To work around this, when overlaps are
2355 detected, we prefer FDEs that do not start at zero.
2357 Start by finding the first FDE with non-zero start. Below
2358 we'll discard all FDEs that start at zero and overlap this
2360 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2362 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2364 if (fde
->initial_location
!= 0)
2366 first_non_zero_fde
= fde
;
2371 /* Since we'll be doing bsearch, squeeze out identical (except
2372 for eh_frame_p) fde entries so bsearch result is predictable.
2373 Also discard leftovers from --gc-sections. */
2374 fde_table2
->num_entries
= 0;
2375 for (i
= 0; i
< fde_table
.num_entries
; i
++)
2377 struct dwarf2_fde
*fde
= fde_table
.entries
[i
];
2379 if (fde
->initial_location
== 0
2380 && first_non_zero_fde
!= NULL
2381 && (first_non_zero_fde
->initial_location
2382 < fde
->initial_location
+ fde
->address_range
))
2385 if (fde_prev
!= NULL
2386 && fde_prev
->initial_location
== fde
->initial_location
)
2389 obstack_grow (&objfile
->objfile_obstack
, &fde_table
.entries
[i
],
2390 sizeof (fde_table
.entries
[0]));
2391 ++fde_table2
->num_entries
;
2395 = (struct dwarf2_fde
**) obstack_finish (&objfile
->objfile_obstack
);
2397 /* Discard the original fde_table. */
2398 xfree (fde_table
.entries
);
2401 set_objfile_data (objfile
, dwarf2_frame_objfile_data
, fde_table2
);
2404 /* Handle 'maintenance show dwarf unwinders'. */
2407 show_dwarf_unwinders_enabled_p (struct ui_file
*file
, int from_tty
,
2408 struct cmd_list_element
*c
,
2411 fprintf_filtered (file
,
2412 _("The DWARF stack unwinders are currently %s.\n"),
2417 _initialize_dwarf2_frame (void)
2419 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2420 dwarf2_frame_objfile_data
= register_objfile_data ();
2422 add_setshow_boolean_cmd ("unwinders", class_obscure
,
2423 &dwarf2_frame_unwinders_enabled_p
, _("\
2424 Set whether the DWARF stack frame unwinders are used."), _("\
2425 Show whether the DWARF stack frame unwinders are used."), _("\
2426 When enabled the DWARF stack frame unwinders can be used for architectures\n\
2427 that support the DWARF unwinders. Enabling the DWARF unwinders for an\n\
2428 architecture that doesn't support them will have no effect."),
2430 show_dwarf_unwinders_enabled_p
,
2432 &show_dwarf_cmdlist
);
2435 selftests::register_test_foreach_arch ("execute_cfa_program",
2436 selftests::execute_cfa_program_test
);