1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007, 2008 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"
24 #include "elf/dwarf2.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
35 #include "gdb_assert.h"
36 #include "gdb_string.h"
38 #include "complaints.h"
39 #include "dwarf2-frame.h"
43 /* Call Frame Information (CFI). */
45 /* Common Information Entry (CIE). */
49 /* Computation Unit for this CIE. */
50 struct comp_unit
*unit
;
52 /* Offset into the .debug_frame section where this CIE was found.
53 Used to identify this CIE. */
56 /* Constant that is factored out of all advance location
58 ULONGEST code_alignment_factor
;
60 /* Constants that is factored out of all offset instructions. */
61 LONGEST data_alignment_factor
;
63 /* Return address column. */
64 ULONGEST return_address_register
;
66 /* Instruction sequence to initialize a register set. */
67 gdb_byte
*initial_instructions
;
70 /* Saved augmentation, in case it's needed later. */
73 /* Encoding of addresses. */
76 /* Target address size in bytes. */
79 /* True if a 'z' augmentation existed. */
80 unsigned char saw_z_augmentation
;
82 /* True if an 'S' augmentation existed. */
83 unsigned char signal_frame
;
85 /* The version recorded in the CIE. */
86 unsigned char version
;
88 struct dwarf2_cie
*next
;
91 /* Frame Description Entry (FDE). */
95 /* CIE for this FDE. */
96 struct dwarf2_cie
*cie
;
98 /* First location associated with this FDE. */
99 CORE_ADDR initial_location
;
101 /* Number of bytes of program instructions described by this FDE. */
102 CORE_ADDR address_range
;
104 /* Instruction sequence. */
105 gdb_byte
*instructions
;
108 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
110 unsigned char eh_frame_p
;
112 struct dwarf2_fde
*next
;
115 /* A minimal decoding of DWARF2 compilation units. We only decode
116 what's needed to get to the call frame information. */
120 /* Keep the bfd convenient. */
123 struct objfile
*objfile
;
125 /* Linked list of CIEs for this object. */
126 struct dwarf2_cie
*cie
;
128 /* Pointer to the .debug_frame section loaded into memory. */
129 gdb_byte
*dwarf_frame_buffer
;
131 /* Length of the loaded .debug_frame section. */
132 unsigned long dwarf_frame_size
;
134 /* Pointer to the .debug_frame section. */
135 asection
*dwarf_frame_section
;
137 /* Base for DW_EH_PE_datarel encodings. */
140 /* Base for DW_EH_PE_textrel encodings. */
144 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
);
146 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
149 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
150 int ptr_len
, gdb_byte
*buf
,
151 unsigned int *bytes_read_ptr
,
152 CORE_ADDR func_base
);
155 /* Structure describing a frame state. */
157 struct dwarf2_frame_state
159 /* Each register save state can be described in terms of a CFA slot,
160 another register, or a location expression. */
161 struct dwarf2_frame_state_reg_info
163 struct dwarf2_frame_state_reg
*reg
;
166 /* Used to implement DW_CFA_remember_state. */
167 struct dwarf2_frame_state_reg_info
*prev
;
179 /* The PC described by the current frame state. */
182 /* Initial register set from the CIE.
183 Used to implement DW_CFA_restore. */
184 struct dwarf2_frame_state_reg_info initial
;
186 /* The information we care about from the CIE. */
189 ULONGEST retaddr_column
;
191 /* Flags for known producer quirks. */
193 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
194 and DW_CFA_def_cfa_offset takes a factored offset. */
195 int armcc_cfa_offsets_sf
;
197 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
198 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
199 int armcc_cfa_offsets_reversed
;
202 /* Store the length the expression for the CFA in the `cfa_reg' field,
203 which is unused in that case. */
204 #define cfa_exp_len cfa_reg
206 /* Assert that the register set RS is large enough to store gdbarch_num_regs
207 columns. If necessary, enlarge the register set. */
210 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
213 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
215 if (num_regs
<= rs
->num_regs
)
218 rs
->reg
= (struct dwarf2_frame_state_reg
*)
219 xrealloc (rs
->reg
, num_regs
* size
);
221 /* Initialize newly allocated registers. */
222 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
223 rs
->num_regs
= num_regs
;
226 /* Copy the register columns in register set RS into newly allocated
227 memory and return a pointer to this newly created copy. */
229 static struct dwarf2_frame_state_reg
*
230 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
232 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
233 struct dwarf2_frame_state_reg
*reg
;
235 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
236 memcpy (reg
, rs
->reg
, size
);
241 /* Release the memory allocated to register set RS. */
244 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
248 dwarf2_frame_state_free_regs (rs
->prev
);
255 /* Release the memory allocated to the frame state FS. */
258 dwarf2_frame_state_free (void *p
)
260 struct dwarf2_frame_state
*fs
= p
;
262 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
263 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
264 xfree (fs
->initial
.reg
);
265 xfree (fs
->regs
.reg
);
270 /* Helper functions for execute_stack_op. */
273 read_reg (void *baton
, int reg
)
275 struct frame_info
*this_frame
= (struct frame_info
*) baton
;
276 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
280 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
282 buf
= alloca (register_size (gdbarch
, regnum
));
283 get_frame_register (this_frame
, regnum
, buf
);
285 /* Convert the register to an integer. This returns a LONGEST
286 rather than a CORE_ADDR, but unpack_pointer does the same thing
287 under the covers, and this makes more sense for non-pointer
288 registers. Maybe read_reg and the associated interfaces should
289 deal with "struct value" instead of CORE_ADDR. */
290 return unpack_long (register_type (gdbarch
, regnum
), buf
);
294 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
296 read_memory (addr
, buf
, len
);
300 no_get_frame_base (void *baton
, gdb_byte
**start
, size_t *length
)
302 internal_error (__FILE__
, __LINE__
,
303 _("Support for DW_OP_fbreg is unimplemented"));
307 no_get_tls_address (void *baton
, CORE_ADDR offset
)
309 internal_error (__FILE__
, __LINE__
,
310 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
313 /* Execute the required actions for both the DW_CFA_restore and
314 DW_CFA_restore_extended instructions. */
316 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
317 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
321 gdb_assert (fs
->initial
.reg
);
322 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
323 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
325 /* Check if this register was explicitly initialized in the
326 CIE initial instructions. If not, default the rule to
328 if (reg
< fs
->initial
.num_regs
)
329 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
331 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
333 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
334 complaint (&symfile_complaints
, _("\
335 incomplete CFI data; DW_CFA_restore unspecified\n\
336 register %s (#%d) at 0x%s"),
337 gdbarch_register_name
338 (gdbarch
, gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
)),
339 gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
),
344 execute_stack_op (gdb_byte
*exp
, ULONGEST len
, int addr_size
,
345 struct frame_info
*this_frame
, CORE_ADDR initial
)
347 struct dwarf_expr_context
*ctx
;
350 ctx
= new_dwarf_expr_context ();
351 ctx
->addr_size
= addr_size
;
352 ctx
->baton
= this_frame
;
353 ctx
->read_reg
= read_reg
;
354 ctx
->read_mem
= read_mem
;
355 ctx
->get_frame_base
= no_get_frame_base
;
356 ctx
->get_tls_address
= no_get_tls_address
;
358 dwarf_expr_push (ctx
, initial
);
359 dwarf_expr_eval (ctx
, exp
, len
);
360 result
= dwarf_expr_fetch (ctx
, 0);
363 result
= read_reg (this_frame
, result
);
365 free_dwarf_expr_context (ctx
);
372 execute_cfa_program (struct dwarf2_fde
*fde
, gdb_byte
*insn_ptr
,
373 gdb_byte
*insn_end
, struct frame_info
*this_frame
,
374 struct dwarf2_frame_state
*fs
)
376 int eh_frame_p
= fde
->eh_frame_p
;
377 CORE_ADDR pc
= get_frame_pc (this_frame
);
379 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
381 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
383 gdb_byte insn
= *insn_ptr
++;
387 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
388 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
389 else if ((insn
& 0xc0) == DW_CFA_offset
)
392 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
393 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
394 offset
= utmp
* fs
->data_align
;
395 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
396 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
397 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
399 else if ((insn
& 0xc0) == DW_CFA_restore
)
402 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
409 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
410 fde
->cie
->addr_size
, insn_ptr
,
411 &bytes_read
, fde
->initial_location
);
412 /* Apply the objfile offset for relocatable objects. */
413 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
414 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
415 insn_ptr
+= bytes_read
;
418 case DW_CFA_advance_loc1
:
419 utmp
= extract_unsigned_integer (insn_ptr
, 1);
420 fs
->pc
+= utmp
* fs
->code_align
;
423 case DW_CFA_advance_loc2
:
424 utmp
= extract_unsigned_integer (insn_ptr
, 2);
425 fs
->pc
+= utmp
* fs
->code_align
;
428 case DW_CFA_advance_loc4
:
429 utmp
= extract_unsigned_integer (insn_ptr
, 4);
430 fs
->pc
+= utmp
* fs
->code_align
;
434 case DW_CFA_offset_extended
:
435 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
436 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
437 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
438 offset
= utmp
* fs
->data_align
;
439 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
440 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
441 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
444 case DW_CFA_restore_extended
:
445 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
446 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
449 case DW_CFA_undefined
:
450 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
451 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
452 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
453 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
456 case DW_CFA_same_value
:
457 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
458 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
459 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
460 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
463 case DW_CFA_register
:
464 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
465 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
466 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
467 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
468 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
469 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
470 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
473 case DW_CFA_remember_state
:
475 struct dwarf2_frame_state_reg_info
*new_rs
;
477 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
479 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
480 fs
->regs
.prev
= new_rs
;
484 case DW_CFA_restore_state
:
486 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
490 complaint (&symfile_complaints
, _("\
491 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs
->pc
));
495 xfree (fs
->regs
.reg
);
503 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
504 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
506 if (fs
->armcc_cfa_offsets_sf
)
507 utmp
*= fs
->data_align
;
509 fs
->cfa_offset
= utmp
;
510 fs
->cfa_how
= CFA_REG_OFFSET
;
513 case DW_CFA_def_cfa_register
:
514 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
515 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
517 fs
->cfa_how
= CFA_REG_OFFSET
;
520 case DW_CFA_def_cfa_offset
:
521 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
523 if (fs
->armcc_cfa_offsets_sf
)
524 utmp
*= fs
->data_align
;
526 fs
->cfa_offset
= utmp
;
527 /* cfa_how deliberately not set. */
533 case DW_CFA_def_cfa_expression
:
534 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_exp_len
);
535 fs
->cfa_exp
= insn_ptr
;
536 fs
->cfa_how
= CFA_EXP
;
537 insn_ptr
+= fs
->cfa_exp_len
;
540 case DW_CFA_expression
:
541 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
542 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
543 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
544 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
545 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
546 fs
->regs
.reg
[reg
].exp_len
= utmp
;
547 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
551 case DW_CFA_offset_extended_sf
:
552 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
553 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
554 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
555 offset
*= fs
->data_align
;
556 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
557 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
558 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
561 case DW_CFA_val_offset
:
562 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
563 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
564 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
565 offset
= utmp
* fs
->data_align
;
566 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
567 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
570 case DW_CFA_val_offset_sf
:
571 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
572 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
573 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
574 offset
*= fs
->data_align
;
575 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
576 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
579 case DW_CFA_val_expression
:
580 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
581 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
582 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
583 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
584 fs
->regs
.reg
[reg
].exp_len
= utmp
;
585 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
589 case DW_CFA_def_cfa_sf
:
590 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
591 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
593 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
594 fs
->cfa_offset
= offset
* fs
->data_align
;
595 fs
->cfa_how
= CFA_REG_OFFSET
;
598 case DW_CFA_def_cfa_offset_sf
:
599 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
600 fs
->cfa_offset
= offset
* fs
->data_align
;
601 /* cfa_how deliberately not set. */
604 case DW_CFA_GNU_window_save
:
605 /* This is SPARC-specific code, and contains hard-coded
606 constants for the register numbering scheme used by
607 GCC. Rather than having a architecture-specific
608 operation that's only ever used by a single
609 architecture, we provide the implementation here.
610 Incidentally that's what GCC does too in its
613 int size
= register_size (gdbarch
, 0);
614 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
615 for (reg
= 8; reg
< 16; reg
++)
617 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
618 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
620 for (reg
= 16; reg
< 32; reg
++)
622 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
623 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
628 case DW_CFA_GNU_args_size
:
630 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
633 case DW_CFA_GNU_negative_offset_extended
:
634 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
635 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
636 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
637 offset
*= fs
->data_align
;
638 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
639 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
640 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
644 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
649 /* Don't allow remember/restore between CIE and FDE programs. */
650 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
651 fs
->regs
.prev
= NULL
;
655 /* Architecture-specific operations. */
657 /* Per-architecture data key. */
658 static struct gdbarch_data
*dwarf2_frame_data
;
660 struct dwarf2_frame_ops
662 /* Pre-initialize the register state REG for register REGNUM. */
663 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
664 struct frame_info
*);
666 /* Check whether the THIS_FRAME is a signal trampoline. */
667 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
669 /* Convert .eh_frame register number to DWARF register number, or
670 adjust .debug_frame register number. */
671 int (*adjust_regnum
) (struct gdbarch
*, int, int);
674 /* Default architecture-specific register state initialization
678 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
679 struct dwarf2_frame_state_reg
*reg
,
680 struct frame_info
*this_frame
)
682 /* If we have a register that acts as a program counter, mark it as
683 a destination for the return address. If we have a register that
684 serves as the stack pointer, arrange for it to be filled with the
685 call frame address (CFA). The other registers are marked as
688 We copy the return address to the program counter, since many
689 parts in GDB assume that it is possible to get the return address
690 by unwinding the program counter register. However, on ISA's
691 with a dedicated return address register, the CFI usually only
692 contains information to unwind that return address register.
694 The reason we're treating the stack pointer special here is
695 because in many cases GCC doesn't emit CFI for the stack pointer
696 and implicitly assumes that it is equal to the CFA. This makes
697 some sense since the DWARF specification (version 3, draft 8,
700 "Typically, the CFA is defined to be the value of the stack
701 pointer at the call site in the previous frame (which may be
702 different from its value on entry to the current frame)."
704 However, this isn't true for all platforms supported by GCC
705 (e.g. IBM S/390 and zSeries). Those architectures should provide
706 their own architecture-specific initialization function. */
708 if (regnum
== gdbarch_pc_regnum (gdbarch
))
709 reg
->how
= DWARF2_FRAME_REG_RA
;
710 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
711 reg
->how
= DWARF2_FRAME_REG_CFA
;
714 /* Return a default for the architecture-specific operations. */
717 dwarf2_frame_init (struct obstack
*obstack
)
719 struct dwarf2_frame_ops
*ops
;
721 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
722 ops
->init_reg
= dwarf2_frame_default_init_reg
;
726 /* Set the architecture-specific register state initialization
727 function for GDBARCH to INIT_REG. */
730 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
731 void (*init_reg
) (struct gdbarch
*, int,
732 struct dwarf2_frame_state_reg
*,
733 struct frame_info
*))
735 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
737 ops
->init_reg
= init_reg
;
740 /* Pre-initialize the register state REG for register REGNUM. */
743 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
744 struct dwarf2_frame_state_reg
*reg
,
745 struct frame_info
*this_frame
)
747 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
749 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
752 /* Set the architecture-specific signal trampoline recognition
753 function for GDBARCH to SIGNAL_FRAME_P. */
756 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
757 int (*signal_frame_p
) (struct gdbarch
*,
758 struct frame_info
*))
760 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
762 ops
->signal_frame_p
= signal_frame_p
;
765 /* Query the architecture-specific signal frame recognizer for
769 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
770 struct frame_info
*this_frame
)
772 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
774 if (ops
->signal_frame_p
== NULL
)
776 return ops
->signal_frame_p (gdbarch
, this_frame
);
779 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
783 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
784 int (*adjust_regnum
) (struct gdbarch
*,
787 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
789 ops
->adjust_regnum
= adjust_regnum
;
792 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
796 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
798 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
800 if (ops
->adjust_regnum
== NULL
)
802 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
806 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
807 struct dwarf2_fde
*fde
)
809 static const char *arm_idents
[] = {
810 "ARM C Compiler, ADS",
811 "Thumb C Compiler, ADS",
812 "ARM C++ Compiler, ADS",
813 "Thumb C++ Compiler, ADS",
814 "ARM/Thumb C/C++ Compiler, RVCT"
820 s
= find_pc_symtab (fs
->pc
);
821 if (s
== NULL
|| s
->producer
== NULL
)
824 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
825 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
827 if (fde
->cie
->version
== 1)
828 fs
->armcc_cfa_offsets_sf
= 1;
830 if (fde
->cie
->version
== 1)
831 fs
->armcc_cfa_offsets_reversed
= 1;
833 /* The reversed offset problem is present in some compilers
834 using DWARF3, but it was eventually fixed. Check the ARM
835 defined augmentations, which are in the format "armcc" followed
836 by a list of one-character options. The "+" option means
837 this problem is fixed (no quirk needed). If the armcc
838 augmentation is missing, the quirk is needed. */
839 if (fde
->cie
->version
== 3
840 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
841 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
842 fs
->armcc_cfa_offsets_reversed
= 1;
849 struct dwarf2_frame_cache
851 /* DWARF Call Frame Address. */
854 /* Set if the return address column was marked as undefined. */
855 int undefined_retaddr
;
857 /* Saved registers, indexed by GDB register number, not by DWARF
859 struct dwarf2_frame_state_reg
*reg
;
861 /* Return address register. */
862 struct dwarf2_frame_state_reg retaddr_reg
;
864 /* Target address size in bytes. */
868 static struct dwarf2_frame_cache
*
869 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
871 struct cleanup
*old_chain
;
872 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
873 const int num_regs
= gdbarch_num_regs (gdbarch
)
874 + gdbarch_num_pseudo_regs (gdbarch
);
875 struct dwarf2_frame_cache
*cache
;
876 struct dwarf2_frame_state
*fs
;
877 struct dwarf2_fde
*fde
;
882 /* Allocate a new cache. */
883 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
884 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
886 /* Allocate and initialize the frame state. */
887 fs
= XMALLOC (struct dwarf2_frame_state
);
888 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
889 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
893 Note that if the next frame is never supposed to return (i.e. a call
894 to abort), the compiler might optimize away the instruction at
895 its return address. As a result the return address will
896 point at some random instruction, and the CFI for that
897 instruction is probably worthless to us. GCC's unwinder solves
898 this problem by substracting 1 from the return address to get an
899 address in the middle of a presumed call instruction (or the
900 instruction in the associated delay slot). This should only be
901 done for "normal" frames and not for resume-type frames (signal
902 handlers, sentinel frames, dummy frames). The function
903 frame_unwind_address_in_block does just this. It's not clear how
904 reliable the method is though; there is the potential for the
905 register state pre-call being different to that on return. */
906 fs
->pc
= get_frame_address_in_block (this_frame
);
908 /* Find the correct FDE. */
909 fde
= dwarf2_frame_find_fde (&fs
->pc
);
910 gdb_assert (fde
!= NULL
);
912 /* Extract any interesting information from the CIE. */
913 fs
->data_align
= fde
->cie
->data_alignment_factor
;
914 fs
->code_align
= fde
->cie
->code_alignment_factor
;
915 fs
->retaddr_column
= fde
->cie
->return_address_register
;
916 cache
->addr_size
= fde
->cie
->addr_size
;
918 /* Check for "quirks" - known bugs in producers. */
919 dwarf2_frame_find_quirks (fs
, fde
);
921 /* First decode all the insns in the CIE. */
922 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
923 fde
->cie
->end
, this_frame
, fs
);
925 /* Save the initialized register set. */
926 fs
->initial
= fs
->regs
;
927 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
929 /* Then decode the insns in the FDE up to our target PC. */
930 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, this_frame
, fs
);
932 /* Caclulate the CFA. */
936 cache
->cfa
= read_reg (this_frame
, fs
->cfa_reg
);
937 if (fs
->armcc_cfa_offsets_reversed
)
938 cache
->cfa
-= fs
->cfa_offset
;
940 cache
->cfa
+= fs
->cfa_offset
;
945 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
,
946 cache
->addr_size
, this_frame
, 0);
950 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
953 /* Initialize the register state. */
957 for (regnum
= 0; regnum
< num_regs
; regnum
++)
958 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
961 /* Go through the DWARF2 CFI generated table and save its register
962 location information in the cache. Note that we don't skip the
963 return address column; it's perfectly all right for it to
964 correspond to a real register. If it doesn't correspond to a
965 real register, or if we shouldn't treat it as such,
966 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
967 the range [0, gdbarch_num_regs). */
969 int column
; /* CFI speak for "register number". */
971 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
973 /* Use the GDB register number as the destination index. */
974 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
976 /* If there's no corresponding GDB register, ignore it. */
977 if (regnum
< 0 || regnum
>= num_regs
)
980 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
981 of all debug info registers. If it doesn't, complain (but
982 not too loudly). It turns out that GCC assumes that an
983 unspecified register implies "same value" when CFI (draft
984 7) specifies nothing at all. Such a register could equally
985 be interpreted as "undefined". Also note that this check
986 isn't sufficient; it only checks that all registers in the
987 range [0 .. max column] are specified, and won't detect
988 problems when a debug info register falls outside of the
989 table. We need a way of iterating through all the valid
990 DWARF2 register numbers. */
991 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
993 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
994 complaint (&symfile_complaints
, _("\
995 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
996 gdbarch_register_name (gdbarch
, regnum
),
1000 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1004 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1005 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1009 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1011 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1012 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1014 struct dwarf2_frame_state_reg
*retaddr_reg
=
1015 &fs
->regs
.reg
[fs
->retaddr_column
];
1017 /* It seems rather bizarre to specify an "empty" column as
1018 the return adress column. However, this is exactly
1019 what GCC does on some targets. It turns out that GCC
1020 assumes that the return address can be found in the
1021 register corresponding to the return address column.
1022 Incidentally, that's how we should treat a return
1023 address column specifying "same value" too. */
1024 if (fs
->retaddr_column
< fs
->regs
.num_regs
1025 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1026 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1028 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1029 cache
->reg
[regnum
] = *retaddr_reg
;
1031 cache
->retaddr_reg
= *retaddr_reg
;
1035 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1037 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1038 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1042 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1043 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1050 if (fs
->retaddr_column
< fs
->regs
.num_regs
1051 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1052 cache
->undefined_retaddr
= 1;
1054 do_cleanups (old_chain
);
1056 *this_cache
= cache
;
1061 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1062 struct frame_id
*this_id
)
1064 struct dwarf2_frame_cache
*cache
=
1065 dwarf2_frame_cache (this_frame
, this_cache
);
1067 if (cache
->undefined_retaddr
)
1070 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1073 static struct value
*
1074 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1077 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1078 struct dwarf2_frame_cache
*cache
=
1079 dwarf2_frame_cache (this_frame
, this_cache
);
1083 switch (cache
->reg
[regnum
].how
)
1085 case DWARF2_FRAME_REG_UNDEFINED
:
1086 /* If CFI explicitly specified that the value isn't defined,
1087 mark it as optimized away; the value isn't available. */
1088 return frame_unwind_got_optimized (this_frame
, regnum
);
1090 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1091 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1092 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1094 case DWARF2_FRAME_REG_SAVED_REG
:
1096 = gdbarch_dwarf2_reg_to_regnum (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1097 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1099 case DWARF2_FRAME_REG_SAVED_EXP
:
1100 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1101 cache
->reg
[regnum
].exp_len
,
1102 cache
->addr_size
, this_frame
, cache
->cfa
);
1103 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1105 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1106 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1107 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1109 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1110 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1111 cache
->reg
[regnum
].exp_len
,
1112 cache
->addr_size
, this_frame
, cache
->cfa
);
1113 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1115 case DWARF2_FRAME_REG_UNSPECIFIED
:
1116 /* GCC, in its infinite wisdom decided to not provide unwind
1117 information for registers that are "same value". Since
1118 DWARF2 (3 draft 7) doesn't define such behavior, said
1119 registers are actually undefined (which is different to CFI
1120 "undefined"). Code above issues a complaint about this.
1121 Here just fudge the books, assume GCC, and that the value is
1122 more inner on the stack. */
1123 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1125 case DWARF2_FRAME_REG_SAME_VALUE
:
1126 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1128 case DWARF2_FRAME_REG_CFA
:
1129 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1131 case DWARF2_FRAME_REG_CFA_OFFSET
:
1132 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1133 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1135 case DWARF2_FRAME_REG_RA_OFFSET
:
1136 addr
= cache
->reg
[regnum
].loc
.offset
;
1137 regnum
= gdbarch_dwarf2_reg_to_regnum
1138 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1139 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1140 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1143 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1148 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1149 struct frame_info
*this_frame
, void **this_cache
)
1151 /* Grab an address that is guarenteed to reside somewhere within the
1152 function. get_frame_pc(), with a no-return next function, can
1153 end up returning something past the end of this function's body.
1154 If the frame we're sniffing for is a signal frame whose start
1155 address is placed on the stack by the OS, its FDE must
1156 extend one byte before its start address or we could potentially
1157 select the FDE of the previous function. */
1158 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1159 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1163 /* On some targets, signal trampolines may have unwind information.
1164 We need to recognize them so that we set the frame type
1167 if (fde
->cie
->signal_frame
1168 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1170 return self
->type
== SIGTRAMP_FRAME
;
1172 return self
->type
!= SIGTRAMP_FRAME
;
1175 static const struct frame_unwind dwarf2_frame_unwind
=
1178 dwarf2_frame_this_id
,
1179 dwarf2_frame_prev_register
,
1181 dwarf2_frame_sniffer
1184 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1187 dwarf2_frame_this_id
,
1188 dwarf2_frame_prev_register
,
1190 dwarf2_frame_sniffer
1193 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1196 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1198 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1199 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1203 /* There is no explicitly defined relationship between the CFA and the
1204 location of frame's local variables and arguments/parameters.
1205 Therefore, frame base methods on this page should probably only be
1206 used as a last resort, just to avoid printing total garbage as a
1207 response to the "info frame" command. */
1210 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1212 struct dwarf2_frame_cache
*cache
=
1213 dwarf2_frame_cache (this_frame
, this_cache
);
1218 static const struct frame_base dwarf2_frame_base
=
1220 &dwarf2_frame_unwind
,
1221 dwarf2_frame_base_address
,
1222 dwarf2_frame_base_address
,
1223 dwarf2_frame_base_address
1226 const struct frame_base
*
1227 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1229 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1230 if (dwarf2_frame_find_fde (&block_addr
))
1231 return &dwarf2_frame_base
;
1236 const struct objfile_data
*dwarf2_frame_objfile_data
;
1239 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1241 return bfd_get_8 (abfd
, buf
);
1245 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1247 return bfd_get_32 (abfd
, buf
);
1251 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1253 return bfd_get_64 (abfd
, buf
);
1257 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1260 unsigned int num_read
;
1270 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1273 result
|= ((byte
& 0x7f) << shift
);
1276 while (byte
& 0x80);
1278 *bytes_read_ptr
= num_read
;
1284 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1288 unsigned int num_read
;
1297 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1300 result
|= ((byte
& 0x7f) << shift
);
1303 while (byte
& 0x80);
1305 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1306 result
|= -(((LONGEST
)1) << shift
);
1308 *bytes_read_ptr
= num_read
;
1314 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1318 result
= bfd_get_32 (abfd
, buf
);
1319 if (result
== 0xffffffff)
1321 result
= bfd_get_64 (abfd
, buf
+ 4);
1322 *bytes_read_ptr
= 12;
1325 *bytes_read_ptr
= 4;
1331 /* Pointer encoding helper functions. */
1333 /* GCC supports exception handling based on DWARF2 CFI. However, for
1334 technical reasons, it encodes addresses in its FDE's in a different
1335 way. Several "pointer encodings" are supported. The encoding
1336 that's used for a particular FDE is determined by the 'R'
1337 augmentation in the associated CIE. The argument of this
1338 augmentation is a single byte.
1340 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1341 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1342 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1343 address should be interpreted (absolute, relative to the current
1344 position in the FDE, ...). Bit 7, indicates that the address
1345 should be dereferenced. */
1348 encoding_for_size (unsigned int size
)
1353 return DW_EH_PE_udata2
;
1355 return DW_EH_PE_udata4
;
1357 return DW_EH_PE_udata8
;
1359 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1364 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1365 int ptr_len
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
,
1366 CORE_ADDR func_base
)
1371 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1373 if (encoding
& DW_EH_PE_indirect
)
1374 internal_error (__FILE__
, __LINE__
,
1375 _("Unsupported encoding: DW_EH_PE_indirect"));
1377 *bytes_read_ptr
= 0;
1379 switch (encoding
& 0x70)
1381 case DW_EH_PE_absptr
:
1384 case DW_EH_PE_pcrel
:
1385 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1386 base
+= (buf
- unit
->dwarf_frame_buffer
);
1388 case DW_EH_PE_datarel
:
1391 case DW_EH_PE_textrel
:
1394 case DW_EH_PE_funcrel
:
1397 case DW_EH_PE_aligned
:
1399 offset
= buf
- unit
->dwarf_frame_buffer
;
1400 if ((offset
% ptr_len
) != 0)
1402 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1403 buf
+= *bytes_read_ptr
;
1407 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1410 if ((encoding
& 0x07) == 0x00)
1412 encoding
|= encoding_for_size (ptr_len
);
1413 if (bfd_get_sign_extend_vma (unit
->abfd
))
1414 encoding
|= DW_EH_PE_signed
;
1417 switch (encoding
& 0x0f)
1419 case DW_EH_PE_uleb128
:
1422 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1423 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1424 return base
+ value
;
1426 case DW_EH_PE_udata2
:
1427 *bytes_read_ptr
+= 2;
1428 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1429 case DW_EH_PE_udata4
:
1430 *bytes_read_ptr
+= 4;
1431 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1432 case DW_EH_PE_udata8
:
1433 *bytes_read_ptr
+= 8;
1434 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1435 case DW_EH_PE_sleb128
:
1438 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1439 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1440 return base
+ value
;
1442 case DW_EH_PE_sdata2
:
1443 *bytes_read_ptr
+= 2;
1444 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1445 case DW_EH_PE_sdata4
:
1446 *bytes_read_ptr
+= 4;
1447 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1448 case DW_EH_PE_sdata8
:
1449 *bytes_read_ptr
+= 8;
1450 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1452 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1457 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1458 That's why we use a simple linked list here. */
1460 static struct dwarf2_cie
*
1461 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1463 struct dwarf2_cie
*cie
= unit
->cie
;
1467 if (cie
->cie_pointer
== cie_pointer
)
1477 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1479 cie
->next
= unit
->cie
;
1484 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1485 inital location associated with it into *PC. */
1487 static struct dwarf2_fde
*
1488 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1490 struct objfile
*objfile
;
1492 ALL_OBJFILES (objfile
)
1494 struct dwarf2_fde
*fde
;
1497 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1501 gdb_assert (objfile
->section_offsets
);
1502 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1506 if (*pc
>= fde
->initial_location
+ offset
1507 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1509 *pc
= fde
->initial_location
+ offset
;
1521 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1523 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1524 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1527 #ifdef CC_HAS_LONG_LONG
1528 #define DW64_CIE_ID 0xffffffffffffffffULL
1530 #define DW64_CIE_ID ~0
1533 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1536 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1537 the next byte to be processed. */
1539 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1541 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1542 gdb_byte
*buf
, *end
;
1544 unsigned int bytes_read
;
1547 ULONGEST cie_pointer
;
1550 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1554 /* Are we still within the section? */
1555 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1561 /* Distinguish between 32 and 64-bit encoded frame info. */
1562 dwarf64_p
= (bytes_read
== 12);
1564 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1568 cie_id
= DW64_CIE_ID
;
1574 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1579 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1583 if (cie_pointer
== cie_id
)
1585 /* This is a CIE. */
1586 struct dwarf2_cie
*cie
;
1588 unsigned int cie_version
;
1590 /* Record the offset into the .debug_frame section of this CIE. */
1591 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1593 /* Check whether we've already read it. */
1594 if (find_cie (unit
, cie_pointer
))
1597 cie
= (struct dwarf2_cie
*)
1598 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1599 sizeof (struct dwarf2_cie
));
1600 cie
->initial_instructions
= NULL
;
1601 cie
->cie_pointer
= cie_pointer
;
1603 /* The encoding for FDE's in a normal .debug_frame section
1604 depends on the target address size. */
1605 cie
->encoding
= DW_EH_PE_absptr
;
1607 /* The target address size. For .eh_frame FDEs this is considered
1608 equal to the size of a target pointer. For .dwarf_frame FDEs,
1609 this is supposed to be the target address size from the associated
1610 CU header. FIXME: We do not have a good way to determine the
1611 latter. Always use the target pointer size for now. */
1612 cie
->addr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1614 /* We'll determine the final value later, but we need to
1615 initialize it conservatively. */
1616 cie
->signal_frame
= 0;
1618 /* Check version number. */
1619 cie_version
= read_1_byte (unit
->abfd
, buf
);
1620 if (cie_version
!= 1 && cie_version
!= 3)
1622 cie
->version
= cie_version
;
1625 /* Interpret the interesting bits of the augmentation. */
1626 cie
->augmentation
= augmentation
= (char *) buf
;
1627 buf
+= (strlen (augmentation
) + 1);
1629 /* Ignore armcc augmentations. We only use them for quirks,
1630 and that doesn't happen until later. */
1631 if (strncmp (augmentation
, "armcc", 5) == 0)
1632 augmentation
+= strlen (augmentation
);
1634 /* The GCC 2.x "eh" augmentation has a pointer immediately
1635 following the augmentation string, so it must be handled
1637 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1640 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1644 cie
->code_alignment_factor
=
1645 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1648 cie
->data_alignment_factor
=
1649 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1652 if (cie_version
== 1)
1654 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1658 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1660 cie
->return_address_register
1661 = dwarf2_frame_adjust_regnum (gdbarch
,
1662 cie
->return_address_register
,
1667 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1668 if (cie
->saw_z_augmentation
)
1672 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1676 cie
->initial_instructions
= buf
+ length
;
1680 while (*augmentation
)
1682 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1683 if (*augmentation
== 'L')
1690 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1691 else if (*augmentation
== 'R')
1693 cie
->encoding
= *buf
++;
1697 /* "P" indicates a personality routine in the CIE augmentation. */
1698 else if (*augmentation
== 'P')
1700 /* Skip. Avoid indirection since we throw away the result. */
1701 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1702 read_encoded_value (unit
, encoding
, cie
->addr_size
,
1703 buf
, &bytes_read
, 0);
1708 /* "S" indicates a signal frame, such that the return
1709 address must not be decremented to locate the call frame
1710 info for the previous frame; it might even be the first
1711 instruction of a function, so decrementing it would take
1712 us to a different function. */
1713 else if (*augmentation
== 'S')
1715 cie
->signal_frame
= 1;
1719 /* Otherwise we have an unknown augmentation. Assume that either
1720 there is no augmentation data, or we saw a 'z' prefix. */
1723 if (cie
->initial_instructions
)
1724 buf
= cie
->initial_instructions
;
1729 cie
->initial_instructions
= buf
;
1732 add_cie (unit
, cie
);
1736 /* This is a FDE. */
1737 struct dwarf2_fde
*fde
;
1739 /* In an .eh_frame section, the CIE pointer is the delta between the
1740 address within the FDE where the CIE pointer is stored and the
1741 address of the CIE. Convert it to an offset into the .eh_frame
1745 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1746 cie_pointer
-= (dwarf64_p
? 8 : 4);
1749 /* In either case, validate the result is still within the section. */
1750 if (cie_pointer
>= unit
->dwarf_frame_size
)
1753 fde
= (struct dwarf2_fde
*)
1754 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1755 sizeof (struct dwarf2_fde
));
1756 fde
->cie
= find_cie (unit
, cie_pointer
);
1757 if (fde
->cie
== NULL
)
1759 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1761 fde
->cie
= find_cie (unit
, cie_pointer
);
1764 gdb_assert (fde
->cie
!= NULL
);
1766 fde
->initial_location
=
1767 read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->addr_size
,
1768 buf
, &bytes_read
, 0);
1771 fde
->address_range
=
1772 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1773 fde
->cie
->addr_size
, buf
, &bytes_read
, 0);
1776 /* A 'z' augmentation in the CIE implies the presence of an
1777 augmentation field in the FDE as well. The only thing known
1778 to be in here at present is the LSDA entry for EH. So we
1779 can skip the whole thing. */
1780 if (fde
->cie
->saw_z_augmentation
)
1784 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1785 buf
+= bytes_read
+ length
;
1790 fde
->instructions
= buf
;
1793 fde
->eh_frame_p
= eh_frame_p
;
1795 add_fde (unit
, fde
);
1801 /* Read a CIE or FDE in BUF and decode it. */
1803 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1805 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1808 ptrdiff_t start_offset
;
1812 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1816 /* We have corrupt input data of some form. */
1818 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1819 and mismatches wrt padding and alignment of debug sections. */
1820 /* Note that there is no requirement in the standard for any
1821 alignment at all in the frame unwind sections. Testing for
1822 alignment before trying to interpret data would be incorrect.
1824 However, GCC traditionally arranged for frame sections to be
1825 sized such that the FDE length and CIE fields happen to be
1826 aligned (in theory, for performance). This, unfortunately,
1827 was done with .align directives, which had the side effect of
1828 forcing the section to be aligned by the linker.
1830 This becomes a problem when you have some other producer that
1831 creates frame sections that are not as strictly aligned. That
1832 produces a hole in the frame info that gets filled by the
1835 The GCC behaviour is arguably a bug, but it's effectively now
1836 part of the ABI, so we're now stuck with it, at least at the
1837 object file level. A smart linker may decide, in the process
1838 of compressing duplicate CIE information, that it can rewrite
1839 the entire output section without this extra padding. */
1841 start_offset
= start
- unit
->dwarf_frame_buffer
;
1842 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1844 start
+= 4 - (start_offset
& 3);
1845 workaround
= ALIGN4
;
1848 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1850 start
+= 8 - (start_offset
& 7);
1851 workaround
= ALIGN8
;
1855 /* Nothing left to try. Arrange to return as if we've consumed
1856 the entire input section. Hopefully we'll get valid info from
1857 the other of .debug_frame/.eh_frame. */
1859 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1869 complaint (&symfile_complaints
,
1870 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1871 unit
->dwarf_frame_section
->owner
->filename
,
1872 unit
->dwarf_frame_section
->name
);
1876 complaint (&symfile_complaints
,
1877 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1878 unit
->dwarf_frame_section
->owner
->filename
,
1879 unit
->dwarf_frame_section
->name
);
1883 complaint (&symfile_complaints
,
1884 _("Corrupt data in %s:%s"),
1885 unit
->dwarf_frame_section
->owner
->filename
,
1886 unit
->dwarf_frame_section
->name
);
1894 /* FIXME: kettenis/20030504: This still needs to be integrated with
1895 dwarf2read.c in a better way. */
1897 /* Imported from dwarf2read.c. */
1898 extern asection
*dwarf_frame_section
;
1899 extern asection
*dwarf_eh_frame_section
;
1901 /* Imported from dwarf2read.c. */
1902 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1905 dwarf2_build_frame_info (struct objfile
*objfile
)
1907 struct comp_unit
*unit
;
1908 gdb_byte
*frame_ptr
;
1910 /* Build a minimal decoding of the DWARF2 compilation unit. */
1911 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
1912 sizeof (struct comp_unit
));
1913 unit
->abfd
= objfile
->obfd
;
1914 unit
->objfile
= objfile
;
1918 /* First add the information from the .eh_frame section. That way,
1919 the FDEs from that section are searched last. */
1920 if (dwarf_eh_frame_section
)
1922 asection
*got
, *txt
;
1925 unit
->dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1926 dwarf_eh_frame_section
);
1928 unit
->dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1929 unit
->dwarf_frame_section
= dwarf_eh_frame_section
;
1931 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1932 that is used for the i386/amd64 target, which currently is
1933 the only target in GCC that supports/uses the
1934 DW_EH_PE_datarel encoding. */
1935 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
1937 unit
->dbase
= got
->vma
;
1939 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1941 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
1943 unit
->tbase
= txt
->vma
;
1945 frame_ptr
= unit
->dwarf_frame_buffer
;
1946 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1947 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1);
1950 if (dwarf_frame_section
)
1953 unit
->dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1954 dwarf_frame_section
);
1955 unit
->dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
1956 unit
->dwarf_frame_section
= dwarf_frame_section
;
1958 frame_ptr
= unit
->dwarf_frame_buffer
;
1959 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1960 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0);
1964 /* Provide a prototype to silence -Wmissing-prototypes. */
1965 void _initialize_dwarf2_frame (void);
1968 _initialize_dwarf2_frame (void)
1970 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
1971 dwarf2_frame_objfile_data
= register_objfile_data ();