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
*next_frame
= (struct frame_info
*) baton
;
276 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
280 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
282 buf
= alloca (register_size (gdbarch
, regnum
));
283 frame_unwind_register (next_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
*next_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
= next_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 (next_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
*next_frame
,
374 struct dwarf2_frame_state
*fs
)
376 int eh_frame_p
= fde
->eh_frame_p
;
377 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
379 struct gdbarch
*gdbarch
= get_frame_arch (next_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 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
614 int size
= register_size(gdbarch
, 0);
615 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
616 for (reg
= 8; reg
< 16; reg
++)
618 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
619 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
621 for (reg
= 16; reg
< 32; reg
++)
623 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
624 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
629 case DW_CFA_GNU_args_size
:
631 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
634 case DW_CFA_GNU_negative_offset_extended
:
635 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
636 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
637 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
638 offset
*= fs
->data_align
;
639 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
640 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
641 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
645 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
650 /* Don't allow remember/restore between CIE and FDE programs. */
651 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
652 fs
->regs
.prev
= NULL
;
656 /* Architecture-specific operations. */
658 /* Per-architecture data key. */
659 static struct gdbarch_data
*dwarf2_frame_data
;
661 struct dwarf2_frame_ops
663 /* Pre-initialize the register state REG for register REGNUM. */
664 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
665 struct frame_info
*);
667 /* Check whether the frame preceding NEXT_FRAME will be a signal
669 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
671 /* Convert .eh_frame register number to DWARF register number, or
672 adjust .debug_frame register number. */
673 int (*adjust_regnum
) (struct gdbarch
*, int, int);
676 /* Default architecture-specific register state initialization
680 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
681 struct dwarf2_frame_state_reg
*reg
,
682 struct frame_info
*next_frame
)
684 /* If we have a register that acts as a program counter, mark it as
685 a destination for the return address. If we have a register that
686 serves as the stack pointer, arrange for it to be filled with the
687 call frame address (CFA). The other registers are marked as
690 We copy the return address to the program counter, since many
691 parts in GDB assume that it is possible to get the return address
692 by unwinding the program counter register. However, on ISA's
693 with a dedicated return address register, the CFI usually only
694 contains information to unwind that return address register.
696 The reason we're treating the stack pointer special here is
697 because in many cases GCC doesn't emit CFI for the stack pointer
698 and implicitly assumes that it is equal to the CFA. This makes
699 some sense since the DWARF specification (version 3, draft 8,
702 "Typically, the CFA is defined to be the value of the stack
703 pointer at the call site in the previous frame (which may be
704 different from its value on entry to the current frame)."
706 However, this isn't true for all platforms supported by GCC
707 (e.g. IBM S/390 and zSeries). Those architectures should provide
708 their own architecture-specific initialization function. */
710 if (regnum
== gdbarch_pc_regnum (gdbarch
))
711 reg
->how
= DWARF2_FRAME_REG_RA
;
712 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
713 reg
->how
= DWARF2_FRAME_REG_CFA
;
716 /* Return a default for the architecture-specific operations. */
719 dwarf2_frame_init (struct obstack
*obstack
)
721 struct dwarf2_frame_ops
*ops
;
723 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
724 ops
->init_reg
= dwarf2_frame_default_init_reg
;
728 /* Set the architecture-specific register state initialization
729 function for GDBARCH to INIT_REG. */
732 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
733 void (*init_reg
) (struct gdbarch
*, int,
734 struct dwarf2_frame_state_reg
*,
735 struct frame_info
*))
737 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
739 ops
->init_reg
= init_reg
;
742 /* Pre-initialize the register state REG for register REGNUM. */
745 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
746 struct dwarf2_frame_state_reg
*reg
,
747 struct frame_info
*next_frame
)
749 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
751 ops
->init_reg (gdbarch
, regnum
, reg
, next_frame
);
754 /* Set the architecture-specific signal trampoline recognition
755 function for GDBARCH to SIGNAL_FRAME_P. */
758 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
759 int (*signal_frame_p
) (struct gdbarch
*,
760 struct frame_info
*))
762 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
764 ops
->signal_frame_p
= signal_frame_p
;
767 /* Query the architecture-specific signal frame recognizer for
771 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
772 struct frame_info
*next_frame
)
774 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
776 if (ops
->signal_frame_p
== NULL
)
778 return ops
->signal_frame_p (gdbarch
, next_frame
);
781 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
785 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
786 int (*adjust_regnum
) (struct gdbarch
*,
789 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
791 ops
->adjust_regnum
= adjust_regnum
;
794 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
798 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
800 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
802 if (ops
->adjust_regnum
== NULL
)
804 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
808 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
809 struct dwarf2_fde
*fde
)
811 static const char *arm_idents
[] = {
812 "ARM C Compiler, ADS",
813 "Thumb C Compiler, ADS",
814 "ARM C++ Compiler, ADS",
815 "Thumb C++ Compiler, ADS",
816 "ARM/Thumb C/C++ Compiler, RVCT"
822 s
= find_pc_symtab (fs
->pc
);
823 if (s
== NULL
|| s
->producer
== NULL
)
826 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
827 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
829 if (fde
->cie
->version
== 1)
830 fs
->armcc_cfa_offsets_sf
= 1;
832 if (fde
->cie
->version
== 1)
833 fs
->armcc_cfa_offsets_reversed
= 1;
835 /* The reversed offset problem is present in some compilers
836 using DWARF3, but it was eventually fixed. Check the ARM
837 defined augmentations, which are in the format "armcc" followed
838 by a list of one-character options. The "+" option means
839 this problem is fixed (no quirk needed). If the armcc
840 augmentation is missing, the quirk is needed. */
841 if (fde
->cie
->version
== 3
842 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
843 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
844 fs
->armcc_cfa_offsets_reversed
= 1;
851 struct dwarf2_frame_cache
853 /* DWARF Call Frame Address. */
856 /* Set if the return address column was marked as undefined. */
857 int undefined_retaddr
;
859 /* Saved registers, indexed by GDB register number, not by DWARF
861 struct dwarf2_frame_state_reg
*reg
;
863 /* Return address register. */
864 struct dwarf2_frame_state_reg retaddr_reg
;
866 /* Target address size in bytes. */
870 static struct dwarf2_frame_cache
*
871 dwarf2_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
873 struct cleanup
*old_chain
;
874 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
875 const int num_regs
= gdbarch_num_regs (gdbarch
)
876 + gdbarch_num_pseudo_regs (gdbarch
);
877 struct dwarf2_frame_cache
*cache
;
878 struct dwarf2_frame_state
*fs
;
879 struct dwarf2_fde
*fde
;
884 /* Allocate a new cache. */
885 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
886 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
888 /* Allocate and initialize the frame state. */
889 fs
= XMALLOC (struct dwarf2_frame_state
);
890 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
891 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
895 Note that if NEXT_FRAME is never supposed to return (i.e. a call
896 to abort), the compiler might optimize away the instruction at
897 NEXT_FRAME's return address. As a result the return address will
898 point at some random instruction, and the CFI for that
899 instruction is probably worthless to us. GCC's unwinder solves
900 this problem by substracting 1 from the return address to get an
901 address in the middle of a presumed call instruction (or the
902 instruction in the associated delay slot). This should only be
903 done for "normal" frames and not for resume-type frames (signal
904 handlers, sentinel frames, dummy frames). The function
905 frame_unwind_address_in_block does just this. It's not clear how
906 reliable the method is though; there is the potential for the
907 register state pre-call being different to that on return. */
908 fs
->pc
= frame_unwind_address_in_block (next_frame
, NORMAL_FRAME
);
910 /* Find the correct FDE. */
911 fde
= dwarf2_frame_find_fde (&fs
->pc
);
912 gdb_assert (fde
!= NULL
);
914 /* Extract any interesting information from the CIE. */
915 fs
->data_align
= fde
->cie
->data_alignment_factor
;
916 fs
->code_align
= fde
->cie
->code_alignment_factor
;
917 fs
->retaddr_column
= fde
->cie
->return_address_register
;
918 cache
->addr_size
= fde
->cie
->addr_size
;
920 /* Check for "quirks" - known bugs in producers. */
921 dwarf2_frame_find_quirks (fs
, fde
);
923 /* First decode all the insns in the CIE. */
924 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
925 fde
->cie
->end
, next_frame
, fs
);
927 /* Save the initialized register set. */
928 fs
->initial
= fs
->regs
;
929 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
931 /* Then decode the insns in the FDE up to our target PC. */
932 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, next_frame
, fs
);
934 /* Caclulate the CFA. */
938 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
939 if (fs
->armcc_cfa_offsets_reversed
)
940 cache
->cfa
-= fs
->cfa_offset
;
942 cache
->cfa
+= fs
->cfa_offset
;
947 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
,
948 cache
->addr_size
, next_frame
, 0);
952 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
955 /* Initialize the register state. */
959 for (regnum
= 0; regnum
< num_regs
; regnum
++)
960 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], next_frame
);
963 /* Go through the DWARF2 CFI generated table and save its register
964 location information in the cache. Note that we don't skip the
965 return address column; it's perfectly all right for it to
966 correspond to a real register. If it doesn't correspond to a
967 real register, or if we shouldn't treat it as such,
968 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
969 the range [0, gdbarch_num_regs). */
971 int column
; /* CFI speak for "register number". */
973 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
975 /* Use the GDB register number as the destination index. */
976 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
978 /* If there's no corresponding GDB register, ignore it. */
979 if (regnum
< 0 || regnum
>= num_regs
)
982 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
983 of all debug info registers. If it doesn't, complain (but
984 not too loudly). It turns out that GCC assumes that an
985 unspecified register implies "same value" when CFI (draft
986 7) specifies nothing at all. Such a register could equally
987 be interpreted as "undefined". Also note that this check
988 isn't sufficient; it only checks that all registers in the
989 range [0 .. max column] are specified, and won't detect
990 problems when a debug info register falls outside of the
991 table. We need a way of iterating through all the valid
992 DWARF2 register numbers. */
993 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
995 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
996 complaint (&symfile_complaints
, _("\
997 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
998 gdbarch_register_name (gdbarch
, regnum
),
1002 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1006 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1007 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1011 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1013 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1014 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1016 struct dwarf2_frame_state_reg
*retaddr_reg
=
1017 &fs
->regs
.reg
[fs
->retaddr_column
];
1019 /* It seems rather bizarre to specify an "empty" column as
1020 the return adress column. However, this is exactly
1021 what GCC does on some targets. It turns out that GCC
1022 assumes that the return address can be found in the
1023 register corresponding to the return address column.
1024 Incidentally, that's how we should treat a return
1025 address column specifying "same value" too. */
1026 if (fs
->retaddr_column
< fs
->regs
.num_regs
1027 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1028 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1030 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1031 cache
->reg
[regnum
] = *retaddr_reg
;
1033 cache
->retaddr_reg
= *retaddr_reg
;
1037 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1039 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1040 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1044 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1045 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1052 if (fs
->retaddr_column
< fs
->regs
.num_regs
1053 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1054 cache
->undefined_retaddr
= 1;
1056 do_cleanups (old_chain
);
1058 *this_cache
= cache
;
1063 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1064 struct frame_id
*this_id
)
1066 struct dwarf2_frame_cache
*cache
=
1067 dwarf2_frame_cache (next_frame
, this_cache
);
1069 if (cache
->undefined_retaddr
)
1072 (*this_id
) = frame_id_build (cache
->cfa
,
1073 frame_func_unwind (next_frame
, NORMAL_FRAME
));
1077 dwarf2_signal_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1078 struct frame_id
*this_id
)
1080 struct dwarf2_frame_cache
*cache
=
1081 dwarf2_frame_cache (next_frame
, this_cache
);
1083 if (cache
->undefined_retaddr
)
1086 (*this_id
) = frame_id_build (cache
->cfa
,
1087 frame_func_unwind (next_frame
, SIGTRAMP_FRAME
));
1091 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
1092 int regnum
, int *optimizedp
,
1093 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1094 int *realnump
, gdb_byte
*valuep
)
1096 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1097 struct dwarf2_frame_cache
*cache
=
1098 dwarf2_frame_cache (next_frame
, this_cache
);
1100 switch (cache
->reg
[regnum
].how
)
1102 case DWARF2_FRAME_REG_UNDEFINED
:
1103 /* If CFI explicitly specified that the value isn't defined,
1104 mark it as optimized away; the value isn't available. */
1111 /* In some cases, for example %eflags on the i386, we have
1112 to provide a sane value, even though this register wasn't
1113 saved. Assume we can get it from NEXT_FRAME. */
1114 frame_unwind_register (next_frame
, regnum
, valuep
);
1118 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1120 *lvalp
= lval_memory
;
1121 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1125 /* Read the value in from memory. */
1126 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1130 case DWARF2_FRAME_REG_SAVED_REG
:
1132 *lvalp
= lval_register
;
1134 *realnump
= gdbarch_dwarf2_reg_to_regnum
1135 (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1137 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1140 case DWARF2_FRAME_REG_SAVED_EXP
:
1142 *lvalp
= lval_memory
;
1143 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1144 cache
->reg
[regnum
].exp_len
,
1145 cache
->addr_size
, next_frame
, cache
->cfa
);
1149 /* Read the value in from memory. */
1150 read_memory (*addrp
, valuep
, register_size (gdbarch
, regnum
));
1154 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1160 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1161 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1164 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1170 store_unsigned_integer (valuep
, register_size (gdbarch
, regnum
),
1171 execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1172 cache
->reg
[regnum
].exp_len
,
1173 cache
->addr_size
, next_frame
,
1177 case DWARF2_FRAME_REG_UNSPECIFIED
:
1178 /* GCC, in its infinite wisdom decided to not provide unwind
1179 information for registers that are "same value". Since
1180 DWARF2 (3 draft 7) doesn't define such behavior, said
1181 registers are actually undefined (which is different to CFI
1182 "undefined"). Code above issues a complaint about this.
1183 Here just fudge the books, assume GCC, and that the value is
1184 more inner on the stack. */
1186 *lvalp
= lval_register
;
1190 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1193 case DWARF2_FRAME_REG_SAME_VALUE
:
1195 *lvalp
= lval_register
;
1199 frame_unwind_register (next_frame
, (*realnump
), valuep
);
1202 case DWARF2_FRAME_REG_CFA
:
1208 pack_long (valuep
, register_type (gdbarch
, regnum
), cache
->cfa
);
1211 case DWARF2_FRAME_REG_CFA_OFFSET
:
1217 pack_long (valuep
, register_type (gdbarch
, regnum
),
1218 cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
);
1221 case DWARF2_FRAME_REG_RA_OFFSET
:
1228 CORE_ADDR pc
= cache
->reg
[regnum
].loc
.offset
;
1230 regnum
= gdbarch_dwarf2_reg_to_regnum
1231 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1232 pc
+= frame_unwind_register_unsigned (next_frame
, regnum
);
1233 pack_long (valuep
, register_type (gdbarch
, regnum
), pc
);
1238 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1242 static const struct frame_unwind dwarf2_frame_unwind
=
1245 dwarf2_frame_this_id
,
1246 dwarf2_frame_prev_register
1249 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1252 dwarf2_signal_frame_this_id
,
1253 dwarf2_frame_prev_register
1256 const struct frame_unwind
*
1257 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
1259 /* Grab an address that is guarenteed to reside somewhere within the
1260 function. frame_pc_unwind(), for a no-return next function, can
1261 end up returning something past the end of this function's body.
1262 If the frame we're sniffing for is a signal frame whose start
1263 address is placed on the stack by the OS, its FDE must
1264 extend one byte before its start address or we will miss it. */
1265 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1267 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1271 /* On some targets, signal trampolines may have unwind information.
1272 We need to recognize them so that we set the frame type
1275 if (fde
->cie
->signal_frame
1276 || dwarf2_frame_signal_frame_p (get_frame_arch (next_frame
),
1278 return &dwarf2_signal_frame_unwind
;
1280 return &dwarf2_frame_unwind
;
1284 /* There is no explicitly defined relationship between the CFA and the
1285 location of frame's local variables and arguments/parameters.
1286 Therefore, frame base methods on this page should probably only be
1287 used as a last resort, just to avoid printing total garbage as a
1288 response to the "info frame" command. */
1291 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
1293 struct dwarf2_frame_cache
*cache
=
1294 dwarf2_frame_cache (next_frame
, this_cache
);
1299 static const struct frame_base dwarf2_frame_base
=
1301 &dwarf2_frame_unwind
,
1302 dwarf2_frame_base_address
,
1303 dwarf2_frame_base_address
,
1304 dwarf2_frame_base_address
1307 const struct frame_base
*
1308 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
1310 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
,
1312 if (dwarf2_frame_find_fde (&block_addr
))
1313 return &dwarf2_frame_base
;
1318 const struct objfile_data
*dwarf2_frame_objfile_data
;
1321 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1323 return bfd_get_8 (abfd
, buf
);
1327 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1329 return bfd_get_32 (abfd
, buf
);
1333 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1335 return bfd_get_64 (abfd
, buf
);
1339 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1342 unsigned int num_read
;
1352 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1355 result
|= ((byte
& 0x7f) << shift
);
1358 while (byte
& 0x80);
1360 *bytes_read_ptr
= num_read
;
1366 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1370 unsigned int num_read
;
1379 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1382 result
|= ((byte
& 0x7f) << shift
);
1385 while (byte
& 0x80);
1387 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1388 result
|= -(((LONGEST
)1) << shift
);
1390 *bytes_read_ptr
= num_read
;
1396 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1400 result
= bfd_get_32 (abfd
, buf
);
1401 if (result
== 0xffffffff)
1403 result
= bfd_get_64 (abfd
, buf
+ 4);
1404 *bytes_read_ptr
= 12;
1407 *bytes_read_ptr
= 4;
1413 /* Pointer encoding helper functions. */
1415 /* GCC supports exception handling based on DWARF2 CFI. However, for
1416 technical reasons, it encodes addresses in its FDE's in a different
1417 way. Several "pointer encodings" are supported. The encoding
1418 that's used for a particular FDE is determined by the 'R'
1419 augmentation in the associated CIE. The argument of this
1420 augmentation is a single byte.
1422 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1423 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1424 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1425 address should be interpreted (absolute, relative to the current
1426 position in the FDE, ...). Bit 7, indicates that the address
1427 should be dereferenced. */
1430 encoding_for_size (unsigned int size
)
1435 return DW_EH_PE_udata2
;
1437 return DW_EH_PE_udata4
;
1439 return DW_EH_PE_udata8
;
1441 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1446 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1447 int ptr_len
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
,
1448 CORE_ADDR func_base
)
1453 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1455 if (encoding
& DW_EH_PE_indirect
)
1456 internal_error (__FILE__
, __LINE__
,
1457 _("Unsupported encoding: DW_EH_PE_indirect"));
1459 *bytes_read_ptr
= 0;
1461 switch (encoding
& 0x70)
1463 case DW_EH_PE_absptr
:
1466 case DW_EH_PE_pcrel
:
1467 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1468 base
+= (buf
- unit
->dwarf_frame_buffer
);
1470 case DW_EH_PE_datarel
:
1473 case DW_EH_PE_textrel
:
1476 case DW_EH_PE_funcrel
:
1479 case DW_EH_PE_aligned
:
1481 offset
= buf
- unit
->dwarf_frame_buffer
;
1482 if ((offset
% ptr_len
) != 0)
1484 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1485 buf
+= *bytes_read_ptr
;
1489 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1492 if ((encoding
& 0x07) == 0x00)
1494 encoding
|= encoding_for_size (ptr_len
);
1495 if (bfd_get_sign_extend_vma (unit
->abfd
))
1496 encoding
|= DW_EH_PE_signed
;
1499 switch (encoding
& 0x0f)
1501 case DW_EH_PE_uleb128
:
1504 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1505 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1506 return base
+ value
;
1508 case DW_EH_PE_udata2
:
1509 *bytes_read_ptr
+= 2;
1510 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1511 case DW_EH_PE_udata4
:
1512 *bytes_read_ptr
+= 4;
1513 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1514 case DW_EH_PE_udata8
:
1515 *bytes_read_ptr
+= 8;
1516 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1517 case DW_EH_PE_sleb128
:
1520 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1521 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1522 return base
+ value
;
1524 case DW_EH_PE_sdata2
:
1525 *bytes_read_ptr
+= 2;
1526 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1527 case DW_EH_PE_sdata4
:
1528 *bytes_read_ptr
+= 4;
1529 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1530 case DW_EH_PE_sdata8
:
1531 *bytes_read_ptr
+= 8;
1532 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1534 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1539 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1540 That's why we use a simple linked list here. */
1542 static struct dwarf2_cie
*
1543 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1545 struct dwarf2_cie
*cie
= unit
->cie
;
1549 if (cie
->cie_pointer
== cie_pointer
)
1559 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1561 cie
->next
= unit
->cie
;
1566 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1567 inital location associated with it into *PC. */
1569 static struct dwarf2_fde
*
1570 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1572 struct objfile
*objfile
;
1574 ALL_OBJFILES (objfile
)
1576 struct dwarf2_fde
*fde
;
1579 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1583 gdb_assert (objfile
->section_offsets
);
1584 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1588 if (*pc
>= fde
->initial_location
+ offset
1589 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1591 *pc
= fde
->initial_location
+ offset
;
1603 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1605 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1606 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1609 #ifdef CC_HAS_LONG_LONG
1610 #define DW64_CIE_ID 0xffffffffffffffffULL
1612 #define DW64_CIE_ID ~0
1615 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1618 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1619 the next byte to be processed. */
1621 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1623 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1624 gdb_byte
*buf
, *end
;
1626 unsigned int bytes_read
;
1629 ULONGEST cie_pointer
;
1632 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1636 /* Are we still within the section? */
1637 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1643 /* Distinguish between 32 and 64-bit encoded frame info. */
1644 dwarf64_p
= (bytes_read
== 12);
1646 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1650 cie_id
= DW64_CIE_ID
;
1656 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1661 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1665 if (cie_pointer
== cie_id
)
1667 /* This is a CIE. */
1668 struct dwarf2_cie
*cie
;
1670 unsigned int cie_version
;
1672 /* Record the offset into the .debug_frame section of this CIE. */
1673 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1675 /* Check whether we've already read it. */
1676 if (find_cie (unit
, cie_pointer
))
1679 cie
= (struct dwarf2_cie
*)
1680 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1681 sizeof (struct dwarf2_cie
));
1682 cie
->initial_instructions
= NULL
;
1683 cie
->cie_pointer
= cie_pointer
;
1685 /* The encoding for FDE's in a normal .debug_frame section
1686 depends on the target address size. */
1687 cie
->encoding
= DW_EH_PE_absptr
;
1689 /* The target address size. For .eh_frame FDEs this is considered
1690 equal to the size of a target pointer. For .dwarf_frame FDEs,
1691 this is supposed to be the target address size from the associated
1692 CU header. FIXME: We do not have a good way to determine the
1693 latter. Always use the target pointer size for now. */
1694 cie
->addr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1696 /* We'll determine the final value later, but we need to
1697 initialize it conservatively. */
1698 cie
->signal_frame
= 0;
1700 /* Check version number. */
1701 cie_version
= read_1_byte (unit
->abfd
, buf
);
1702 if (cie_version
!= 1 && cie_version
!= 3)
1704 cie
->version
= cie_version
;
1707 /* Interpret the interesting bits of the augmentation. */
1708 cie
->augmentation
= augmentation
= (char *) buf
;
1709 buf
+= (strlen (augmentation
) + 1);
1711 /* Ignore armcc augmentations. We only use them for quirks,
1712 and that doesn't happen until later. */
1713 if (strncmp (augmentation
, "armcc", 5) == 0)
1714 augmentation
+= strlen (augmentation
);
1716 /* The GCC 2.x "eh" augmentation has a pointer immediately
1717 following the augmentation string, so it must be handled
1719 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1722 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1726 cie
->code_alignment_factor
=
1727 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1730 cie
->data_alignment_factor
=
1731 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1734 if (cie_version
== 1)
1736 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1740 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1742 cie
->return_address_register
1743 = dwarf2_frame_adjust_regnum (gdbarch
,
1744 cie
->return_address_register
,
1749 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1750 if (cie
->saw_z_augmentation
)
1754 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1758 cie
->initial_instructions
= buf
+ length
;
1762 while (*augmentation
)
1764 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1765 if (*augmentation
== 'L')
1772 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1773 else if (*augmentation
== 'R')
1775 cie
->encoding
= *buf
++;
1779 /* "P" indicates a personality routine in the CIE augmentation. */
1780 else if (*augmentation
== 'P')
1782 /* Skip. Avoid indirection since we throw away the result. */
1783 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1784 read_encoded_value (unit
, encoding
, cie
->addr_size
,
1785 buf
, &bytes_read
, 0);
1790 /* "S" indicates a signal frame, such that the return
1791 address must not be decremented to locate the call frame
1792 info for the previous frame; it might even be the first
1793 instruction of a function, so decrementing it would take
1794 us to a different function. */
1795 else if (*augmentation
== 'S')
1797 cie
->signal_frame
= 1;
1801 /* Otherwise we have an unknown augmentation. Assume that either
1802 there is no augmentation data, or we saw a 'z' prefix. */
1805 if (cie
->initial_instructions
)
1806 buf
= cie
->initial_instructions
;
1811 cie
->initial_instructions
= buf
;
1814 add_cie (unit
, cie
);
1818 /* This is a FDE. */
1819 struct dwarf2_fde
*fde
;
1821 /* In an .eh_frame section, the CIE pointer is the delta between the
1822 address within the FDE where the CIE pointer is stored and the
1823 address of the CIE. Convert it to an offset into the .eh_frame
1827 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1828 cie_pointer
-= (dwarf64_p
? 8 : 4);
1831 /* In either case, validate the result is still within the section. */
1832 if (cie_pointer
>= unit
->dwarf_frame_size
)
1835 fde
= (struct dwarf2_fde
*)
1836 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1837 sizeof (struct dwarf2_fde
));
1838 fde
->cie
= find_cie (unit
, cie_pointer
);
1839 if (fde
->cie
== NULL
)
1841 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1843 fde
->cie
= find_cie (unit
, cie_pointer
);
1846 gdb_assert (fde
->cie
!= NULL
);
1848 fde
->initial_location
=
1849 read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->addr_size
,
1850 buf
, &bytes_read
, 0);
1853 fde
->address_range
=
1854 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1855 fde
->cie
->addr_size
, buf
, &bytes_read
, 0);
1858 /* A 'z' augmentation in the CIE implies the presence of an
1859 augmentation field in the FDE as well. The only thing known
1860 to be in here at present is the LSDA entry for EH. So we
1861 can skip the whole thing. */
1862 if (fde
->cie
->saw_z_augmentation
)
1866 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1867 buf
+= bytes_read
+ length
;
1872 fde
->instructions
= buf
;
1875 fde
->eh_frame_p
= eh_frame_p
;
1877 add_fde (unit
, fde
);
1883 /* Read a CIE or FDE in BUF and decode it. */
1885 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1887 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1890 ptrdiff_t start_offset
;
1894 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1898 /* We have corrupt input data of some form. */
1900 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1901 and mismatches wrt padding and alignment of debug sections. */
1902 /* Note that there is no requirement in the standard for any
1903 alignment at all in the frame unwind sections. Testing for
1904 alignment before trying to interpret data would be incorrect.
1906 However, GCC traditionally arranged for frame sections to be
1907 sized such that the FDE length and CIE fields happen to be
1908 aligned (in theory, for performance). This, unfortunately,
1909 was done with .align directives, which had the side effect of
1910 forcing the section to be aligned by the linker.
1912 This becomes a problem when you have some other producer that
1913 creates frame sections that are not as strictly aligned. That
1914 produces a hole in the frame info that gets filled by the
1917 The GCC behaviour is arguably a bug, but it's effectively now
1918 part of the ABI, so we're now stuck with it, at least at the
1919 object file level. A smart linker may decide, in the process
1920 of compressing duplicate CIE information, that it can rewrite
1921 the entire output section without this extra padding. */
1923 start_offset
= start
- unit
->dwarf_frame_buffer
;
1924 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1926 start
+= 4 - (start_offset
& 3);
1927 workaround
= ALIGN4
;
1930 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1932 start
+= 8 - (start_offset
& 7);
1933 workaround
= ALIGN8
;
1937 /* Nothing left to try. Arrange to return as if we've consumed
1938 the entire input section. Hopefully we'll get valid info from
1939 the other of .debug_frame/.eh_frame. */
1941 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1951 complaint (&symfile_complaints
,
1952 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1953 unit
->dwarf_frame_section
->owner
->filename
,
1954 unit
->dwarf_frame_section
->name
);
1958 complaint (&symfile_complaints
,
1959 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1960 unit
->dwarf_frame_section
->owner
->filename
,
1961 unit
->dwarf_frame_section
->name
);
1965 complaint (&symfile_complaints
,
1966 _("Corrupt data in %s:%s"),
1967 unit
->dwarf_frame_section
->owner
->filename
,
1968 unit
->dwarf_frame_section
->name
);
1976 /* FIXME: kettenis/20030504: This still needs to be integrated with
1977 dwarf2read.c in a better way. */
1979 /* Imported from dwarf2read.c. */
1980 extern asection
*dwarf_frame_section
;
1981 extern asection
*dwarf_eh_frame_section
;
1983 /* Imported from dwarf2read.c. */
1984 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1987 dwarf2_build_frame_info (struct objfile
*objfile
)
1989 struct comp_unit
*unit
;
1990 gdb_byte
*frame_ptr
;
1992 /* Build a minimal decoding of the DWARF2 compilation unit. */
1993 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
1994 sizeof (struct comp_unit
));
1995 unit
->abfd
= objfile
->obfd
;
1996 unit
->objfile
= objfile
;
2000 /* First add the information from the .eh_frame section. That way,
2001 the FDEs from that section are searched last. */
2002 if (dwarf_eh_frame_section
)
2004 asection
*got
, *txt
;
2007 unit
->dwarf_frame_buffer
= dwarf2_read_section (objfile
,
2008 dwarf_eh_frame_section
);
2010 unit
->dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
2011 unit
->dwarf_frame_section
= dwarf_eh_frame_section
;
2013 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2014 that is used for the i386/amd64 target, which currently is
2015 the only target in GCC that supports/uses the
2016 DW_EH_PE_datarel encoding. */
2017 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
2019 unit
->dbase
= got
->vma
;
2021 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2023 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
2025 unit
->tbase
= txt
->vma
;
2027 frame_ptr
= unit
->dwarf_frame_buffer
;
2028 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2029 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1);
2032 if (dwarf_frame_section
)
2035 unit
->dwarf_frame_buffer
= dwarf2_read_section (objfile
,
2036 dwarf_frame_section
);
2037 unit
->dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
2038 unit
->dwarf_frame_section
= dwarf_frame_section
;
2040 frame_ptr
= unit
->dwarf_frame_buffer
;
2041 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
2042 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0);
2046 /* Provide a prototype to silence -Wmissing-prototypes. */
2047 void _initialize_dwarf2_frame (void);
2050 _initialize_dwarf2_frame (void)
2052 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
2053 dwarf2_frame_objfile_data
= register_objfile_data ();