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
->gdbarch
= get_frame_arch (this_frame
);
352 ctx
->addr_size
= addr_size
;
353 ctx
->baton
= this_frame
;
354 ctx
->read_reg
= read_reg
;
355 ctx
->read_mem
= read_mem
;
356 ctx
->get_frame_base
= no_get_frame_base
;
357 ctx
->get_tls_address
= no_get_tls_address
;
359 dwarf_expr_push (ctx
, initial
);
360 dwarf_expr_eval (ctx
, exp
, len
);
361 result
= dwarf_expr_fetch (ctx
, 0);
364 result
= read_reg (this_frame
, result
);
366 free_dwarf_expr_context (ctx
);
373 execute_cfa_program (struct dwarf2_fde
*fde
, gdb_byte
*insn_ptr
,
374 gdb_byte
*insn_end
, struct frame_info
*this_frame
,
375 struct dwarf2_frame_state
*fs
)
377 int eh_frame_p
= fde
->eh_frame_p
;
378 CORE_ADDR pc
= get_frame_pc (this_frame
);
380 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
382 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
384 gdb_byte insn
= *insn_ptr
++;
388 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
389 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
390 else if ((insn
& 0xc0) == DW_CFA_offset
)
393 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
394 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
395 offset
= utmp
* fs
->data_align
;
396 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
397 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
398 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
400 else if ((insn
& 0xc0) == DW_CFA_restore
)
403 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
410 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
411 fde
->cie
->addr_size
, insn_ptr
,
412 &bytes_read
, fde
->initial_location
);
413 /* Apply the objfile offset for relocatable objects. */
414 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
415 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
416 insn_ptr
+= bytes_read
;
419 case DW_CFA_advance_loc1
:
420 utmp
= extract_unsigned_integer (insn_ptr
, 1);
421 fs
->pc
+= utmp
* fs
->code_align
;
424 case DW_CFA_advance_loc2
:
425 utmp
= extract_unsigned_integer (insn_ptr
, 2);
426 fs
->pc
+= utmp
* fs
->code_align
;
429 case DW_CFA_advance_loc4
:
430 utmp
= extract_unsigned_integer (insn_ptr
, 4);
431 fs
->pc
+= utmp
* fs
->code_align
;
435 case DW_CFA_offset_extended
:
436 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
437 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
438 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
439 offset
= utmp
* fs
->data_align
;
440 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
441 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
442 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
445 case DW_CFA_restore_extended
:
446 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
447 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
450 case DW_CFA_undefined
:
451 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
452 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
453 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
454 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
457 case DW_CFA_same_value
:
458 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
459 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
460 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
461 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
464 case DW_CFA_register
:
465 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
466 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
467 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
468 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
469 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
470 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
471 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
474 case DW_CFA_remember_state
:
476 struct dwarf2_frame_state_reg_info
*new_rs
;
478 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
480 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
481 fs
->regs
.prev
= new_rs
;
485 case DW_CFA_restore_state
:
487 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
491 complaint (&symfile_complaints
, _("\
492 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs
->pc
));
496 xfree (fs
->regs
.reg
);
504 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
505 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
507 if (fs
->armcc_cfa_offsets_sf
)
508 utmp
*= fs
->data_align
;
510 fs
->cfa_offset
= utmp
;
511 fs
->cfa_how
= CFA_REG_OFFSET
;
514 case DW_CFA_def_cfa_register
:
515 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
516 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
518 fs
->cfa_how
= CFA_REG_OFFSET
;
521 case DW_CFA_def_cfa_offset
:
522 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
524 if (fs
->armcc_cfa_offsets_sf
)
525 utmp
*= fs
->data_align
;
527 fs
->cfa_offset
= utmp
;
528 /* cfa_how deliberately not set. */
534 case DW_CFA_def_cfa_expression
:
535 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_exp_len
);
536 fs
->cfa_exp
= insn_ptr
;
537 fs
->cfa_how
= CFA_EXP
;
538 insn_ptr
+= fs
->cfa_exp_len
;
541 case DW_CFA_expression
:
542 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
543 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
544 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
545 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
546 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
547 fs
->regs
.reg
[reg
].exp_len
= utmp
;
548 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
552 case DW_CFA_offset_extended_sf
:
553 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
554 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
555 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
556 offset
*= fs
->data_align
;
557 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
558 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
559 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
562 case DW_CFA_val_offset
:
563 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
564 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
565 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
566 offset
= utmp
* fs
->data_align
;
567 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
568 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
571 case DW_CFA_val_offset_sf
:
572 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
573 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
574 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
575 offset
*= fs
->data_align
;
576 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
577 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
580 case DW_CFA_val_expression
:
581 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
582 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
583 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
584 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
585 fs
->regs
.reg
[reg
].exp_len
= utmp
;
586 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
590 case DW_CFA_def_cfa_sf
:
591 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
592 fs
->cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
, fs
->cfa_reg
,
594 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
595 fs
->cfa_offset
= offset
* fs
->data_align
;
596 fs
->cfa_how
= CFA_REG_OFFSET
;
599 case DW_CFA_def_cfa_offset_sf
:
600 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
601 fs
->cfa_offset
= offset
* fs
->data_align
;
602 /* cfa_how deliberately not set. */
605 case DW_CFA_GNU_window_save
:
606 /* This is SPARC-specific code, and contains hard-coded
607 constants for the register numbering scheme used by
608 GCC. Rather than having a architecture-specific
609 operation that's only ever used by a single
610 architecture, we provide the implementation here.
611 Incidentally that's what GCC does too in its
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 THIS_FRAME is a signal trampoline. */
668 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
670 /* Convert .eh_frame register number to DWARF register number, or
671 adjust .debug_frame register number. */
672 int (*adjust_regnum
) (struct gdbarch
*, int, int);
675 /* Default architecture-specific register state initialization
679 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
680 struct dwarf2_frame_state_reg
*reg
,
681 struct frame_info
*this_frame
)
683 /* If we have a register that acts as a program counter, mark it as
684 a destination for the return address. If we have a register that
685 serves as the stack pointer, arrange for it to be filled with the
686 call frame address (CFA). The other registers are marked as
689 We copy the return address to the program counter, since many
690 parts in GDB assume that it is possible to get the return address
691 by unwinding the program counter register. However, on ISA's
692 with a dedicated return address register, the CFI usually only
693 contains information to unwind that return address register.
695 The reason we're treating the stack pointer special here is
696 because in many cases GCC doesn't emit CFI for the stack pointer
697 and implicitly assumes that it is equal to the CFA. This makes
698 some sense since the DWARF specification (version 3, draft 8,
701 "Typically, the CFA is defined to be the value of the stack
702 pointer at the call site in the previous frame (which may be
703 different from its value on entry to the current frame)."
705 However, this isn't true for all platforms supported by GCC
706 (e.g. IBM S/390 and zSeries). Those architectures should provide
707 their own architecture-specific initialization function. */
709 if (regnum
== gdbarch_pc_regnum (gdbarch
))
710 reg
->how
= DWARF2_FRAME_REG_RA
;
711 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
712 reg
->how
= DWARF2_FRAME_REG_CFA
;
715 /* Return a default for the architecture-specific operations. */
718 dwarf2_frame_init (struct obstack
*obstack
)
720 struct dwarf2_frame_ops
*ops
;
722 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
723 ops
->init_reg
= dwarf2_frame_default_init_reg
;
727 /* Set the architecture-specific register state initialization
728 function for GDBARCH to INIT_REG. */
731 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
732 void (*init_reg
) (struct gdbarch
*, int,
733 struct dwarf2_frame_state_reg
*,
734 struct frame_info
*))
736 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
738 ops
->init_reg
= init_reg
;
741 /* Pre-initialize the register state REG for register REGNUM. */
744 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
745 struct dwarf2_frame_state_reg
*reg
,
746 struct frame_info
*this_frame
)
748 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
750 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
753 /* Set the architecture-specific signal trampoline recognition
754 function for GDBARCH to SIGNAL_FRAME_P. */
757 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
758 int (*signal_frame_p
) (struct gdbarch
*,
759 struct frame_info
*))
761 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
763 ops
->signal_frame_p
= signal_frame_p
;
766 /* Query the architecture-specific signal frame recognizer for
770 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
771 struct frame_info
*this_frame
)
773 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
775 if (ops
->signal_frame_p
== NULL
)
777 return ops
->signal_frame_p (gdbarch
, this_frame
);
780 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
784 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
785 int (*adjust_regnum
) (struct gdbarch
*,
788 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
790 ops
->adjust_regnum
= adjust_regnum
;
793 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
797 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
799 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
801 if (ops
->adjust_regnum
== NULL
)
803 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
807 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
808 struct dwarf2_fde
*fde
)
810 static const char *arm_idents
[] = {
811 "ARM C Compiler, ADS",
812 "Thumb C Compiler, ADS",
813 "ARM C++ Compiler, ADS",
814 "Thumb C++ Compiler, ADS",
815 "ARM/Thumb C/C++ Compiler, RVCT"
821 s
= find_pc_symtab (fs
->pc
);
822 if (s
== NULL
|| s
->producer
== NULL
)
825 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
826 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
828 if (fde
->cie
->version
== 1)
829 fs
->armcc_cfa_offsets_sf
= 1;
831 if (fde
->cie
->version
== 1)
832 fs
->armcc_cfa_offsets_reversed
= 1;
834 /* The reversed offset problem is present in some compilers
835 using DWARF3, but it was eventually fixed. Check the ARM
836 defined augmentations, which are in the format "armcc" followed
837 by a list of one-character options. The "+" option means
838 this problem is fixed (no quirk needed). If the armcc
839 augmentation is missing, the quirk is needed. */
840 if (fde
->cie
->version
== 3
841 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
842 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
843 fs
->armcc_cfa_offsets_reversed
= 1;
850 struct dwarf2_frame_cache
852 /* DWARF Call Frame Address. */
855 /* Set if the return address column was marked as undefined. */
856 int undefined_retaddr
;
858 /* Saved registers, indexed by GDB register number, not by DWARF
860 struct dwarf2_frame_state_reg
*reg
;
862 /* Return address register. */
863 struct dwarf2_frame_state_reg retaddr_reg
;
865 /* Target address size in bytes. */
869 static struct dwarf2_frame_cache
*
870 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
872 struct cleanup
*old_chain
;
873 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
874 const int num_regs
= gdbarch_num_regs (gdbarch
)
875 + gdbarch_num_pseudo_regs (gdbarch
);
876 struct dwarf2_frame_cache
*cache
;
877 struct dwarf2_frame_state
*fs
;
878 struct dwarf2_fde
*fde
;
883 /* Allocate a new cache. */
884 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
885 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
887 /* Allocate and initialize the frame state. */
888 fs
= XMALLOC (struct dwarf2_frame_state
);
889 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
890 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
894 Note that if the next frame is never supposed to return (i.e. a call
895 to abort), the compiler might optimize away the instruction at
896 its return address. As a result the return address will
897 point at some random instruction, and the CFI for that
898 instruction is probably worthless to us. GCC's unwinder solves
899 this problem by substracting 1 from the return address to get an
900 address in the middle of a presumed call instruction (or the
901 instruction in the associated delay slot). This should only be
902 done for "normal" frames and not for resume-type frames (signal
903 handlers, sentinel frames, dummy frames). The function
904 get_frame_address_in_block does just this. It's not clear how
905 reliable the method is though; there is the potential for the
906 register state pre-call being different to that on return. */
907 fs
->pc
= get_frame_address_in_block (this_frame
);
909 /* Find the correct FDE. */
910 fde
= dwarf2_frame_find_fde (&fs
->pc
);
911 gdb_assert (fde
!= NULL
);
913 /* Extract any interesting information from the CIE. */
914 fs
->data_align
= fde
->cie
->data_alignment_factor
;
915 fs
->code_align
= fde
->cie
->code_alignment_factor
;
916 fs
->retaddr_column
= fde
->cie
->return_address_register
;
917 cache
->addr_size
= fde
->cie
->addr_size
;
919 /* Check for "quirks" - known bugs in producers. */
920 dwarf2_frame_find_quirks (fs
, fde
);
922 /* First decode all the insns in the CIE. */
923 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
924 fde
->cie
->end
, this_frame
, fs
);
926 /* Save the initialized register set. */
927 fs
->initial
= fs
->regs
;
928 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
930 /* Then decode the insns in the FDE up to our target PC. */
931 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, this_frame
, fs
);
933 /* Calculate the CFA. */
937 cache
->cfa
= read_reg (this_frame
, fs
->cfa_reg
);
938 if (fs
->armcc_cfa_offsets_reversed
)
939 cache
->cfa
-= fs
->cfa_offset
;
941 cache
->cfa
+= fs
->cfa_offset
;
946 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
,
947 cache
->addr_size
, this_frame
, 0);
951 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
954 /* Initialize the register state. */
958 for (regnum
= 0; regnum
< num_regs
; regnum
++)
959 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
962 /* Go through the DWARF2 CFI generated table and save its register
963 location information in the cache. Note that we don't skip the
964 return address column; it's perfectly all right for it to
965 correspond to a real register. If it doesn't correspond to a
966 real register, or if we shouldn't treat it as such,
967 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
968 the range [0, gdbarch_num_regs). */
970 int column
; /* CFI speak for "register number". */
972 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
974 /* Use the GDB register number as the destination index. */
975 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
977 /* If there's no corresponding GDB register, ignore it. */
978 if (regnum
< 0 || regnum
>= num_regs
)
981 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
982 of all debug info registers. If it doesn't, complain (but
983 not too loudly). It turns out that GCC assumes that an
984 unspecified register implies "same value" when CFI (draft
985 7) specifies nothing at all. Such a register could equally
986 be interpreted as "undefined". Also note that this check
987 isn't sufficient; it only checks that all registers in the
988 range [0 .. max column] are specified, and won't detect
989 problems when a debug info register falls outside of the
990 table. We need a way of iterating through all the valid
991 DWARF2 register numbers. */
992 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
994 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
995 complaint (&symfile_complaints
, _("\
996 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
997 gdbarch_register_name (gdbarch
, regnum
),
1001 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1005 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1006 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1010 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1012 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1013 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1015 struct dwarf2_frame_state_reg
*retaddr_reg
=
1016 &fs
->regs
.reg
[fs
->retaddr_column
];
1018 /* It seems rather bizarre to specify an "empty" column as
1019 the return adress column. However, this is exactly
1020 what GCC does on some targets. It turns out that GCC
1021 assumes that the return address can be found in the
1022 register corresponding to the return address column.
1023 Incidentally, that's how we should treat a return
1024 address column specifying "same value" too. */
1025 if (fs
->retaddr_column
< fs
->regs
.num_regs
1026 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1027 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1029 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1030 cache
->reg
[regnum
] = *retaddr_reg
;
1032 cache
->retaddr_reg
= *retaddr_reg
;
1036 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1038 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1039 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1043 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1044 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1051 if (fs
->retaddr_column
< fs
->regs
.num_regs
1052 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1053 cache
->undefined_retaddr
= 1;
1055 do_cleanups (old_chain
);
1057 *this_cache
= cache
;
1062 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1063 struct frame_id
*this_id
)
1065 struct dwarf2_frame_cache
*cache
=
1066 dwarf2_frame_cache (this_frame
, this_cache
);
1068 if (cache
->undefined_retaddr
)
1071 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1074 static struct value
*
1075 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1078 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1079 struct dwarf2_frame_cache
*cache
=
1080 dwarf2_frame_cache (this_frame
, this_cache
);
1084 switch (cache
->reg
[regnum
].how
)
1086 case DWARF2_FRAME_REG_UNDEFINED
:
1087 /* If CFI explicitly specified that the value isn't defined,
1088 mark it as optimized away; the value isn't available. */
1089 return frame_unwind_got_optimized (this_frame
, regnum
);
1091 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1092 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1093 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1095 case DWARF2_FRAME_REG_SAVED_REG
:
1097 = gdbarch_dwarf2_reg_to_regnum (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1098 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1100 case DWARF2_FRAME_REG_SAVED_EXP
:
1101 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1102 cache
->reg
[regnum
].exp_len
,
1103 cache
->addr_size
, this_frame
, cache
->cfa
);
1104 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1106 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1107 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1108 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1110 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1111 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1112 cache
->reg
[regnum
].exp_len
,
1113 cache
->addr_size
, this_frame
, cache
->cfa
);
1114 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1116 case DWARF2_FRAME_REG_UNSPECIFIED
:
1117 /* GCC, in its infinite wisdom decided to not provide unwind
1118 information for registers that are "same value". Since
1119 DWARF2 (3 draft 7) doesn't define such behavior, said
1120 registers are actually undefined (which is different to CFI
1121 "undefined"). Code above issues a complaint about this.
1122 Here just fudge the books, assume GCC, and that the value is
1123 more inner on the stack. */
1124 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1126 case DWARF2_FRAME_REG_SAME_VALUE
:
1127 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1129 case DWARF2_FRAME_REG_CFA
:
1130 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1132 case DWARF2_FRAME_REG_CFA_OFFSET
:
1133 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1134 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1136 case DWARF2_FRAME_REG_RA_OFFSET
:
1137 addr
= cache
->reg
[regnum
].loc
.offset
;
1138 regnum
= gdbarch_dwarf2_reg_to_regnum
1139 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1140 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1141 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1143 case DWARF2_FRAME_REG_FN
:
1144 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1147 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1152 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1153 struct frame_info
*this_frame
, void **this_cache
)
1155 /* Grab an address that is guarenteed to reside somewhere within the
1156 function. get_frame_pc(), with a no-return next function, can
1157 end up returning something past the end of this function's body.
1158 If the frame we're sniffing for is a signal frame whose start
1159 address is placed on the stack by the OS, its FDE must
1160 extend one byte before its start address or we could potentially
1161 select the FDE of the previous function. */
1162 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1163 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1167 /* On some targets, signal trampolines may have unwind information.
1168 We need to recognize them so that we set the frame type
1171 if (fde
->cie
->signal_frame
1172 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1174 return self
->type
== SIGTRAMP_FRAME
;
1176 return self
->type
!= SIGTRAMP_FRAME
;
1179 static const struct frame_unwind dwarf2_frame_unwind
=
1182 dwarf2_frame_this_id
,
1183 dwarf2_frame_prev_register
,
1185 dwarf2_frame_sniffer
1188 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1191 dwarf2_frame_this_id
,
1192 dwarf2_frame_prev_register
,
1194 dwarf2_frame_sniffer
1197 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1200 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1202 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1203 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1207 /* There is no explicitly defined relationship between the CFA and the
1208 location of frame's local variables and arguments/parameters.
1209 Therefore, frame base methods on this page should probably only be
1210 used as a last resort, just to avoid printing total garbage as a
1211 response to the "info frame" command. */
1214 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1216 struct dwarf2_frame_cache
*cache
=
1217 dwarf2_frame_cache (this_frame
, this_cache
);
1222 static const struct frame_base dwarf2_frame_base
=
1224 &dwarf2_frame_unwind
,
1225 dwarf2_frame_base_address
,
1226 dwarf2_frame_base_address
,
1227 dwarf2_frame_base_address
1230 const struct frame_base
*
1231 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1233 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1234 if (dwarf2_frame_find_fde (&block_addr
))
1235 return &dwarf2_frame_base
;
1240 const struct objfile_data
*dwarf2_frame_objfile_data
;
1243 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1245 return bfd_get_8 (abfd
, buf
);
1249 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1251 return bfd_get_32 (abfd
, buf
);
1255 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1257 return bfd_get_64 (abfd
, buf
);
1261 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1264 unsigned int num_read
;
1274 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1277 result
|= ((byte
& 0x7f) << shift
);
1280 while (byte
& 0x80);
1282 *bytes_read_ptr
= num_read
;
1288 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1292 unsigned int num_read
;
1301 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1304 result
|= ((byte
& 0x7f) << shift
);
1307 while (byte
& 0x80);
1309 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1310 result
|= -(((LONGEST
)1) << shift
);
1312 *bytes_read_ptr
= num_read
;
1318 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1322 result
= bfd_get_32 (abfd
, buf
);
1323 if (result
== 0xffffffff)
1325 result
= bfd_get_64 (abfd
, buf
+ 4);
1326 *bytes_read_ptr
= 12;
1329 *bytes_read_ptr
= 4;
1335 /* Pointer encoding helper functions. */
1337 /* GCC supports exception handling based on DWARF2 CFI. However, for
1338 technical reasons, it encodes addresses in its FDE's in a different
1339 way. Several "pointer encodings" are supported. The encoding
1340 that's used for a particular FDE is determined by the 'R'
1341 augmentation in the associated CIE. The argument of this
1342 augmentation is a single byte.
1344 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1345 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1346 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1347 address should be interpreted (absolute, relative to the current
1348 position in the FDE, ...). Bit 7, indicates that the address
1349 should be dereferenced. */
1352 encoding_for_size (unsigned int size
)
1357 return DW_EH_PE_udata2
;
1359 return DW_EH_PE_udata4
;
1361 return DW_EH_PE_udata8
;
1363 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1368 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1369 int ptr_len
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
,
1370 CORE_ADDR func_base
)
1375 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1377 if (encoding
& DW_EH_PE_indirect
)
1378 internal_error (__FILE__
, __LINE__
,
1379 _("Unsupported encoding: DW_EH_PE_indirect"));
1381 *bytes_read_ptr
= 0;
1383 switch (encoding
& 0x70)
1385 case DW_EH_PE_absptr
:
1388 case DW_EH_PE_pcrel
:
1389 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1390 base
+= (buf
- unit
->dwarf_frame_buffer
);
1392 case DW_EH_PE_datarel
:
1395 case DW_EH_PE_textrel
:
1398 case DW_EH_PE_funcrel
:
1401 case DW_EH_PE_aligned
:
1403 offset
= buf
- unit
->dwarf_frame_buffer
;
1404 if ((offset
% ptr_len
) != 0)
1406 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1407 buf
+= *bytes_read_ptr
;
1411 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1414 if ((encoding
& 0x07) == 0x00)
1416 encoding
|= encoding_for_size (ptr_len
);
1417 if (bfd_get_sign_extend_vma (unit
->abfd
))
1418 encoding
|= DW_EH_PE_signed
;
1421 switch (encoding
& 0x0f)
1423 case DW_EH_PE_uleb128
:
1426 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1427 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1428 return base
+ value
;
1430 case DW_EH_PE_udata2
:
1431 *bytes_read_ptr
+= 2;
1432 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1433 case DW_EH_PE_udata4
:
1434 *bytes_read_ptr
+= 4;
1435 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1436 case DW_EH_PE_udata8
:
1437 *bytes_read_ptr
+= 8;
1438 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1439 case DW_EH_PE_sleb128
:
1442 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1443 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1444 return base
+ value
;
1446 case DW_EH_PE_sdata2
:
1447 *bytes_read_ptr
+= 2;
1448 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1449 case DW_EH_PE_sdata4
:
1450 *bytes_read_ptr
+= 4;
1451 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1452 case DW_EH_PE_sdata8
:
1453 *bytes_read_ptr
+= 8;
1454 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1456 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1461 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1462 That's why we use a simple linked list here. */
1464 static struct dwarf2_cie
*
1465 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1467 struct dwarf2_cie
*cie
= unit
->cie
;
1471 if (cie
->cie_pointer
== cie_pointer
)
1481 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1483 cie
->next
= unit
->cie
;
1488 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1489 inital location associated with it into *PC. */
1491 static struct dwarf2_fde
*
1492 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1494 struct objfile
*objfile
;
1496 ALL_OBJFILES (objfile
)
1498 struct dwarf2_fde
*fde
;
1501 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1505 gdb_assert (objfile
->section_offsets
);
1506 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1510 if (*pc
>= fde
->initial_location
+ offset
1511 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1513 *pc
= fde
->initial_location
+ offset
;
1525 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1527 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1528 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1531 #ifdef CC_HAS_LONG_LONG
1532 #define DW64_CIE_ID 0xffffffffffffffffULL
1534 #define DW64_CIE_ID ~0
1537 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1540 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1541 the next byte to be processed. */
1543 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1545 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1546 gdb_byte
*buf
, *end
;
1548 unsigned int bytes_read
;
1551 ULONGEST cie_pointer
;
1554 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1558 /* Are we still within the section? */
1559 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1565 /* Distinguish between 32 and 64-bit encoded frame info. */
1566 dwarf64_p
= (bytes_read
== 12);
1568 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1572 cie_id
= DW64_CIE_ID
;
1578 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1583 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1587 if (cie_pointer
== cie_id
)
1589 /* This is a CIE. */
1590 struct dwarf2_cie
*cie
;
1592 unsigned int cie_version
;
1594 /* Record the offset into the .debug_frame section of this CIE. */
1595 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1597 /* Check whether we've already read it. */
1598 if (find_cie (unit
, cie_pointer
))
1601 cie
= (struct dwarf2_cie
*)
1602 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1603 sizeof (struct dwarf2_cie
));
1604 cie
->initial_instructions
= NULL
;
1605 cie
->cie_pointer
= cie_pointer
;
1607 /* The encoding for FDE's in a normal .debug_frame section
1608 depends on the target address size. */
1609 cie
->encoding
= DW_EH_PE_absptr
;
1611 /* The target address size. For .eh_frame FDEs this is considered
1612 equal to the size of a target pointer. For .dwarf_frame FDEs,
1613 this is supposed to be the target address size from the associated
1614 CU header. FIXME: We do not have a good way to determine the
1615 latter. Always use the target pointer size for now. */
1616 cie
->addr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1618 /* We'll determine the final value later, but we need to
1619 initialize it conservatively. */
1620 cie
->signal_frame
= 0;
1622 /* Check version number. */
1623 cie_version
= read_1_byte (unit
->abfd
, buf
);
1624 if (cie_version
!= 1 && cie_version
!= 3)
1626 cie
->version
= cie_version
;
1629 /* Interpret the interesting bits of the augmentation. */
1630 cie
->augmentation
= augmentation
= (char *) buf
;
1631 buf
+= (strlen (augmentation
) + 1);
1633 /* Ignore armcc augmentations. We only use them for quirks,
1634 and that doesn't happen until later. */
1635 if (strncmp (augmentation
, "armcc", 5) == 0)
1636 augmentation
+= strlen (augmentation
);
1638 /* The GCC 2.x "eh" augmentation has a pointer immediately
1639 following the augmentation string, so it must be handled
1641 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1644 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1648 cie
->code_alignment_factor
=
1649 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1652 cie
->data_alignment_factor
=
1653 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1656 if (cie_version
== 1)
1658 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1662 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1664 cie
->return_address_register
1665 = dwarf2_frame_adjust_regnum (gdbarch
,
1666 cie
->return_address_register
,
1671 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1672 if (cie
->saw_z_augmentation
)
1676 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1680 cie
->initial_instructions
= buf
+ length
;
1684 while (*augmentation
)
1686 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1687 if (*augmentation
== 'L')
1694 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1695 else if (*augmentation
== 'R')
1697 cie
->encoding
= *buf
++;
1701 /* "P" indicates a personality routine in the CIE augmentation. */
1702 else if (*augmentation
== 'P')
1704 /* Skip. Avoid indirection since we throw away the result. */
1705 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1706 read_encoded_value (unit
, encoding
, cie
->addr_size
,
1707 buf
, &bytes_read
, 0);
1712 /* "S" indicates a signal frame, such that the return
1713 address must not be decremented to locate the call frame
1714 info for the previous frame; it might even be the first
1715 instruction of a function, so decrementing it would take
1716 us to a different function. */
1717 else if (*augmentation
== 'S')
1719 cie
->signal_frame
= 1;
1723 /* Otherwise we have an unknown augmentation. Assume that either
1724 there is no augmentation data, or we saw a 'z' prefix. */
1727 if (cie
->initial_instructions
)
1728 buf
= cie
->initial_instructions
;
1733 cie
->initial_instructions
= buf
;
1736 add_cie (unit
, cie
);
1740 /* This is a FDE. */
1741 struct dwarf2_fde
*fde
;
1743 /* In an .eh_frame section, the CIE pointer is the delta between the
1744 address within the FDE where the CIE pointer is stored and the
1745 address of the CIE. Convert it to an offset into the .eh_frame
1749 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1750 cie_pointer
-= (dwarf64_p
? 8 : 4);
1753 /* In either case, validate the result is still within the section. */
1754 if (cie_pointer
>= unit
->dwarf_frame_size
)
1757 fde
= (struct dwarf2_fde
*)
1758 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1759 sizeof (struct dwarf2_fde
));
1760 fde
->cie
= find_cie (unit
, cie_pointer
);
1761 if (fde
->cie
== NULL
)
1763 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1765 fde
->cie
= find_cie (unit
, cie_pointer
);
1768 gdb_assert (fde
->cie
!= NULL
);
1770 fde
->initial_location
=
1771 read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->addr_size
,
1772 buf
, &bytes_read
, 0);
1775 fde
->address_range
=
1776 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1777 fde
->cie
->addr_size
, buf
, &bytes_read
, 0);
1780 /* A 'z' augmentation in the CIE implies the presence of an
1781 augmentation field in the FDE as well. The only thing known
1782 to be in here at present is the LSDA entry for EH. So we
1783 can skip the whole thing. */
1784 if (fde
->cie
->saw_z_augmentation
)
1788 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1789 buf
+= bytes_read
+ length
;
1794 fde
->instructions
= buf
;
1797 fde
->eh_frame_p
= eh_frame_p
;
1799 add_fde (unit
, fde
);
1805 /* Read a CIE or FDE in BUF and decode it. */
1807 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1809 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1812 ptrdiff_t start_offset
;
1816 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1820 /* We have corrupt input data of some form. */
1822 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1823 and mismatches wrt padding and alignment of debug sections. */
1824 /* Note that there is no requirement in the standard for any
1825 alignment at all in the frame unwind sections. Testing for
1826 alignment before trying to interpret data would be incorrect.
1828 However, GCC traditionally arranged for frame sections to be
1829 sized such that the FDE length and CIE fields happen to be
1830 aligned (in theory, for performance). This, unfortunately,
1831 was done with .align directives, which had the side effect of
1832 forcing the section to be aligned by the linker.
1834 This becomes a problem when you have some other producer that
1835 creates frame sections that are not as strictly aligned. That
1836 produces a hole in the frame info that gets filled by the
1839 The GCC behaviour is arguably a bug, but it's effectively now
1840 part of the ABI, so we're now stuck with it, at least at the
1841 object file level. A smart linker may decide, in the process
1842 of compressing duplicate CIE information, that it can rewrite
1843 the entire output section without this extra padding. */
1845 start_offset
= start
- unit
->dwarf_frame_buffer
;
1846 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1848 start
+= 4 - (start_offset
& 3);
1849 workaround
= ALIGN4
;
1852 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1854 start
+= 8 - (start_offset
& 7);
1855 workaround
= ALIGN8
;
1859 /* Nothing left to try. Arrange to return as if we've consumed
1860 the entire input section. Hopefully we'll get valid info from
1861 the other of .debug_frame/.eh_frame. */
1863 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1873 complaint (&symfile_complaints
,
1874 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1875 unit
->dwarf_frame_section
->owner
->filename
,
1876 unit
->dwarf_frame_section
->name
);
1880 complaint (&symfile_complaints
,
1881 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1882 unit
->dwarf_frame_section
->owner
->filename
,
1883 unit
->dwarf_frame_section
->name
);
1887 complaint (&symfile_complaints
,
1888 _("Corrupt data in %s:%s"),
1889 unit
->dwarf_frame_section
->owner
->filename
,
1890 unit
->dwarf_frame_section
->name
);
1898 /* FIXME: kettenis/20030504: This still needs to be integrated with
1899 dwarf2read.c in a better way. */
1901 /* Imported from dwarf2read.c. */
1902 extern asection
*dwarf_frame_section
;
1903 extern asection
*dwarf_eh_frame_section
;
1905 /* Imported from dwarf2read.c. */
1906 extern gdb_byte
*dwarf2_read_section (struct objfile
*objfile
, asection
*sectp
);
1909 dwarf2_build_frame_info (struct objfile
*objfile
)
1911 struct comp_unit
*unit
;
1912 gdb_byte
*frame_ptr
;
1914 /* Build a minimal decoding of the DWARF2 compilation unit. */
1915 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
1916 sizeof (struct comp_unit
));
1917 unit
->abfd
= objfile
->obfd
;
1918 unit
->objfile
= objfile
;
1922 /* First add the information from the .eh_frame section. That way,
1923 the FDEs from that section are searched last. */
1924 if (dwarf_eh_frame_section
)
1926 asection
*got
, *txt
;
1929 unit
->dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1930 dwarf_eh_frame_section
);
1932 unit
->dwarf_frame_size
= bfd_get_section_size (dwarf_eh_frame_section
);
1933 unit
->dwarf_frame_section
= dwarf_eh_frame_section
;
1935 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1936 that is used for the i386/amd64 target, which currently is
1937 the only target in GCC that supports/uses the
1938 DW_EH_PE_datarel encoding. */
1939 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
1941 unit
->dbase
= got
->vma
;
1943 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1945 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
1947 unit
->tbase
= txt
->vma
;
1949 frame_ptr
= unit
->dwarf_frame_buffer
;
1950 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1951 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1);
1954 if (dwarf_frame_section
)
1957 unit
->dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1958 dwarf_frame_section
);
1959 unit
->dwarf_frame_size
= bfd_get_section_size (dwarf_frame_section
);
1960 unit
->dwarf_frame_section
= dwarf_frame_section
;
1962 frame_ptr
= unit
->dwarf_frame_buffer
;
1963 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1964 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0);
1968 /* Provide a prototype to silence -Wmissing-prototypes. */
1969 void _initialize_dwarf2_frame (void);
1972 _initialize_dwarf2_frame (void)
1974 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
1975 dwarf2_frame_objfile_data
= register_objfile_data ();