1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 Contributed by Mark Kettenis.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "dwarf2expr.h"
25 #include "elf/dwarf2.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "complaints.h"
40 #include "dwarf2-frame.h"
44 /* Call Frame Information (CFI). */
46 /* Common Information Entry (CIE). */
50 /* Computation Unit for this CIE. */
51 struct comp_unit
*unit
;
53 /* Offset into the .debug_frame section where this CIE was found.
54 Used to identify this CIE. */
57 /* Constant that is factored out of all advance location
59 ULONGEST code_alignment_factor
;
61 /* Constants that is factored out of all offset instructions. */
62 LONGEST data_alignment_factor
;
64 /* Return address column. */
65 ULONGEST return_address_register
;
67 /* Instruction sequence to initialize a register set. */
68 gdb_byte
*initial_instructions
;
71 /* Saved augmentation, in case it's needed later. */
74 /* Encoding of addresses. */
77 /* Target address size in bytes. */
80 /* True if a 'z' augmentation existed. */
81 unsigned char saw_z_augmentation
;
83 /* True if an 'S' augmentation existed. */
84 unsigned char signal_frame
;
86 /* The version recorded in the CIE. */
87 unsigned char version
;
89 struct dwarf2_cie
*next
;
92 /* Frame Description Entry (FDE). */
96 /* CIE for this FDE. */
97 struct dwarf2_cie
*cie
;
99 /* First location associated with this FDE. */
100 CORE_ADDR initial_location
;
102 /* Number of bytes of program instructions described by this FDE. */
103 CORE_ADDR address_range
;
105 /* Instruction sequence. */
106 gdb_byte
*instructions
;
109 /* True if this FDE is read from a .eh_frame instead of a .debug_frame
111 unsigned char eh_frame_p
;
113 struct dwarf2_fde
*next
;
116 /* A minimal decoding of DWARF2 compilation units. We only decode
117 what's needed to get to the call frame information. */
121 /* Keep the bfd convenient. */
124 struct objfile
*objfile
;
126 /* Linked list of CIEs for this object. */
127 struct dwarf2_cie
*cie
;
129 /* Pointer to the .debug_frame section loaded into memory. */
130 gdb_byte
*dwarf_frame_buffer
;
132 /* Length of the loaded .debug_frame section. */
133 bfd_size_type dwarf_frame_size
;
135 /* Pointer to the .debug_frame section. */
136 asection
*dwarf_frame_section
;
138 /* Base for DW_EH_PE_datarel encodings. */
141 /* Base for DW_EH_PE_textrel encodings. */
145 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
);
147 static int dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
,
150 static CORE_ADDR
read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
151 int ptr_len
, gdb_byte
*buf
,
152 unsigned int *bytes_read_ptr
,
153 CORE_ADDR func_base
);
156 /* Structure describing a frame state. */
158 struct dwarf2_frame_state
160 /* Each register save state can be described in terms of a CFA slot,
161 another register, or a location expression. */
162 struct dwarf2_frame_state_reg_info
164 struct dwarf2_frame_state_reg
*reg
;
176 /* Used to implement DW_CFA_remember_state. */
177 struct dwarf2_frame_state_reg_info
*prev
;
180 /* The PC described by the current frame state. */
183 /* Initial register set from the CIE.
184 Used to implement DW_CFA_restore. */
185 struct dwarf2_frame_state_reg_info initial
;
187 /* The information we care about from the CIE. */
190 ULONGEST retaddr_column
;
192 /* Flags for known producer quirks. */
194 /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
195 and DW_CFA_def_cfa_offset takes a factored offset. */
196 int armcc_cfa_offsets_sf
;
198 /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
199 the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
200 int armcc_cfa_offsets_reversed
;
203 /* Store the length the expression for the CFA in the `cfa_reg' field,
204 which is unused in that case. */
205 #define cfa_exp_len cfa_reg
207 /* Assert that the register set RS is large enough to store gdbarch_num_regs
208 columns. If necessary, enlarge the register set. */
211 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
214 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
216 if (num_regs
<= rs
->num_regs
)
219 rs
->reg
= (struct dwarf2_frame_state_reg
*)
220 xrealloc (rs
->reg
, num_regs
* size
);
222 /* Initialize newly allocated registers. */
223 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
224 rs
->num_regs
= num_regs
;
227 /* Copy the register columns in register set RS into newly allocated
228 memory and return a pointer to this newly created copy. */
230 static struct dwarf2_frame_state_reg
*
231 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
233 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg
);
234 struct dwarf2_frame_state_reg
*reg
;
236 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
237 memcpy (reg
, rs
->reg
, size
);
242 /* Release the memory allocated to register set RS. */
245 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
249 dwarf2_frame_state_free_regs (rs
->prev
);
256 /* Release the memory allocated to the frame state FS. */
259 dwarf2_frame_state_free (void *p
)
261 struct dwarf2_frame_state
*fs
= p
;
263 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
264 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
265 xfree (fs
->initial
.reg
);
266 xfree (fs
->regs
.reg
);
271 /* Helper functions for execute_stack_op. */
274 read_reg (void *baton
, int reg
)
276 struct frame_info
*this_frame
= (struct frame_info
*) baton
;
277 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
281 regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
);
283 buf
= alloca (register_size (gdbarch
, regnum
));
284 get_frame_register (this_frame
, regnum
, buf
);
286 /* Convert the register to an integer. This returns a LONGEST
287 rather than a CORE_ADDR, but unpack_pointer does the same thing
288 under the covers, and this makes more sense for non-pointer
289 registers. Maybe read_reg and the associated interfaces should
290 deal with "struct value" instead of CORE_ADDR. */
291 return unpack_long (register_type (gdbarch
, regnum
), buf
);
295 read_mem (void *baton
, gdb_byte
*buf
, CORE_ADDR addr
, size_t len
)
297 read_memory (addr
, buf
, len
);
301 no_get_frame_base (void *baton
, gdb_byte
**start
, size_t *length
)
303 internal_error (__FILE__
, __LINE__
,
304 _("Support for DW_OP_fbreg is unimplemented"));
308 no_get_tls_address (void *baton
, CORE_ADDR offset
)
310 internal_error (__FILE__
, __LINE__
,
311 _("Support for DW_OP_GNU_push_tls_address is unimplemented"));
314 /* Execute the required actions for both the DW_CFA_restore and
315 DW_CFA_restore_extended instructions. */
317 dwarf2_restore_rule (struct gdbarch
*gdbarch
, ULONGEST reg_num
,
318 struct dwarf2_frame_state
*fs
, int eh_frame_p
)
322 gdb_assert (fs
->initial
.reg
);
323 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg_num
, eh_frame_p
);
324 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
326 /* Check if this register was explicitly initialized in the
327 CIE initial instructions. If not, default the rule to
329 if (reg
< fs
->initial
.num_regs
)
330 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
332 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNSPECIFIED
;
334 if (fs
->regs
.reg
[reg
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
335 complaint (&symfile_complaints
, _("\
336 incomplete CFI data; DW_CFA_restore unspecified\n\
337 register %s (#%d) at 0x%s"),
338 gdbarch_register_name
339 (gdbarch
, gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
)),
340 gdbarch_dwarf2_reg_to_regnum (gdbarch
, reg
),
345 execute_stack_op (gdb_byte
*exp
, ULONGEST len
, int addr_size
,
346 struct frame_info
*this_frame
, CORE_ADDR initial
)
348 struct dwarf_expr_context
*ctx
;
351 ctx
= new_dwarf_expr_context ();
352 ctx
->gdbarch
= get_frame_arch (this_frame
);
353 ctx
->addr_size
= addr_size
;
354 ctx
->baton
= this_frame
;
355 ctx
->read_reg
= read_reg
;
356 ctx
->read_mem
= read_mem
;
357 ctx
->get_frame_base
= no_get_frame_base
;
358 ctx
->get_tls_address
= no_get_tls_address
;
360 dwarf_expr_push (ctx
, initial
);
361 dwarf_expr_eval (ctx
, exp
, len
);
362 result
= dwarf_expr_fetch (ctx
, 0);
365 result
= read_reg (this_frame
, result
);
367 free_dwarf_expr_context (ctx
);
374 execute_cfa_program (struct dwarf2_fde
*fde
, gdb_byte
*insn_ptr
,
375 gdb_byte
*insn_end
, struct frame_info
*this_frame
,
376 struct dwarf2_frame_state
*fs
)
378 int eh_frame_p
= fde
->eh_frame_p
;
379 CORE_ADDR pc
= get_frame_pc (this_frame
);
381 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
383 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
385 gdb_byte insn
= *insn_ptr
++;
389 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
390 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
391 else if ((insn
& 0xc0) == DW_CFA_offset
)
394 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
395 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
396 offset
= utmp
* fs
->data_align
;
397 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
398 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
399 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
401 else if ((insn
& 0xc0) == DW_CFA_restore
)
404 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
411 fs
->pc
= read_encoded_value (fde
->cie
->unit
, fde
->cie
->encoding
,
412 fde
->cie
->addr_size
, insn_ptr
,
413 &bytes_read
, fde
->initial_location
);
414 /* Apply the objfile offset for relocatable objects. */
415 fs
->pc
+= ANOFFSET (fde
->cie
->unit
->objfile
->section_offsets
,
416 SECT_OFF_TEXT (fde
->cie
->unit
->objfile
));
417 insn_ptr
+= bytes_read
;
420 case DW_CFA_advance_loc1
:
421 utmp
= extract_unsigned_integer (insn_ptr
, 1);
422 fs
->pc
+= utmp
* fs
->code_align
;
425 case DW_CFA_advance_loc2
:
426 utmp
= extract_unsigned_integer (insn_ptr
, 2);
427 fs
->pc
+= utmp
* fs
->code_align
;
430 case DW_CFA_advance_loc4
:
431 utmp
= extract_unsigned_integer (insn_ptr
, 4);
432 fs
->pc
+= utmp
* fs
->code_align
;
436 case DW_CFA_offset_extended
:
437 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
438 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
439 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
440 offset
= utmp
* fs
->data_align
;
441 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
442 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
443 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
446 case DW_CFA_restore_extended
:
447 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
448 dwarf2_restore_rule (gdbarch
, reg
, fs
, eh_frame_p
);
451 case DW_CFA_undefined
:
452 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
453 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
454 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
455 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_UNDEFINED
;
458 case DW_CFA_same_value
:
459 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
460 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
461 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
462 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAME_VALUE
;
465 case DW_CFA_register
:
466 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
467 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
468 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
469 utmp
= dwarf2_frame_adjust_regnum (gdbarch
, utmp
, eh_frame_p
);
470 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
471 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
472 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
475 case DW_CFA_remember_state
:
477 struct dwarf2_frame_state_reg_info
*new_rs
;
479 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
481 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
482 fs
->regs
.prev
= new_rs
;
486 case DW_CFA_restore_state
:
488 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
492 complaint (&symfile_complaints
, _("\
493 bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs
->pc
));
497 xfree (fs
->regs
.reg
);
505 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
506 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
508 if (fs
->armcc_cfa_offsets_sf
)
509 utmp
*= fs
->data_align
;
511 fs
->regs
.cfa_offset
= utmp
;
512 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
515 case DW_CFA_def_cfa_register
:
516 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
517 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
520 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
523 case DW_CFA_def_cfa_offset
:
524 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
526 if (fs
->armcc_cfa_offsets_sf
)
527 utmp
*= fs
->data_align
;
529 fs
->regs
.cfa_offset
= utmp
;
530 /* cfa_how deliberately not set. */
536 case DW_CFA_def_cfa_expression
:
537 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
,
538 &fs
->regs
.cfa_exp_len
);
539 fs
->regs
.cfa_exp
= insn_ptr
;
540 fs
->regs
.cfa_how
= CFA_EXP
;
541 insn_ptr
+= fs
->regs
.cfa_exp_len
;
544 case DW_CFA_expression
:
545 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
546 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
547 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
548 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
549 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
550 fs
->regs
.reg
[reg
].exp_len
= utmp
;
551 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_EXP
;
555 case DW_CFA_offset_extended_sf
:
556 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
557 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
558 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
559 offset
*= fs
->data_align
;
560 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
561 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
562 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
565 case DW_CFA_val_offset
:
566 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
567 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
568 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
569 offset
= utmp
* fs
->data_align
;
570 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
571 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
574 case DW_CFA_val_offset_sf
:
575 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
576 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
577 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
578 offset
*= fs
->data_align
;
579 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_OFFSET
;
580 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
583 case DW_CFA_val_expression
:
584 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
585 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
586 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
587 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
588 fs
->regs
.reg
[reg
].exp_len
= utmp
;
589 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_VAL_EXP
;
593 case DW_CFA_def_cfa_sf
:
594 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->regs
.cfa_reg
);
595 fs
->regs
.cfa_reg
= dwarf2_frame_adjust_regnum (gdbarch
,
598 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
599 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
600 fs
->regs
.cfa_how
= CFA_REG_OFFSET
;
603 case DW_CFA_def_cfa_offset_sf
:
604 insn_ptr
= read_sleb128 (insn_ptr
, insn_end
, &offset
);
605 fs
->regs
.cfa_offset
= offset
* fs
->data_align
;
606 /* cfa_how deliberately not set. */
609 case DW_CFA_GNU_window_save
:
610 /* This is SPARC-specific code, and contains hard-coded
611 constants for the register numbering scheme used by
612 GCC. Rather than having a architecture-specific
613 operation that's only ever used by a single
614 architecture, we provide the implementation here.
615 Incidentally that's what GCC does too in its
618 int size
= register_size (gdbarch
, 0);
619 dwarf2_frame_state_alloc_regs (&fs
->regs
, 32);
620 for (reg
= 8; reg
< 16; reg
++)
622 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_REG
;
623 fs
->regs
.reg
[reg
].loc
.reg
= reg
+ 16;
625 for (reg
= 16; reg
< 32; reg
++)
627 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
628 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * size
;
633 case DW_CFA_GNU_args_size
:
635 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
638 case DW_CFA_GNU_negative_offset_extended
:
639 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
640 reg
= dwarf2_frame_adjust_regnum (gdbarch
, reg
, eh_frame_p
);
641 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &offset
);
642 offset
*= fs
->data_align
;
643 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
644 fs
->regs
.reg
[reg
].how
= DWARF2_FRAME_REG_SAVED_OFFSET
;
645 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
649 internal_error (__FILE__
, __LINE__
, _("Unknown CFI encountered."));
654 /* Don't allow remember/restore between CIE and FDE programs. */
655 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
656 fs
->regs
.prev
= NULL
;
660 /* Architecture-specific operations. */
662 /* Per-architecture data key. */
663 static struct gdbarch_data
*dwarf2_frame_data
;
665 struct dwarf2_frame_ops
667 /* Pre-initialize the register state REG for register REGNUM. */
668 void (*init_reg
) (struct gdbarch
*, int, struct dwarf2_frame_state_reg
*,
669 struct frame_info
*);
671 /* Check whether the THIS_FRAME is a signal trampoline. */
672 int (*signal_frame_p
) (struct gdbarch
*, struct frame_info
*);
674 /* Convert .eh_frame register number to DWARF register number, or
675 adjust .debug_frame register number. */
676 int (*adjust_regnum
) (struct gdbarch
*, int, int);
679 /* Default architecture-specific register state initialization
683 dwarf2_frame_default_init_reg (struct gdbarch
*gdbarch
, int regnum
,
684 struct dwarf2_frame_state_reg
*reg
,
685 struct frame_info
*this_frame
)
687 /* If we have a register that acts as a program counter, mark it as
688 a destination for the return address. If we have a register that
689 serves as the stack pointer, arrange for it to be filled with the
690 call frame address (CFA). The other registers are marked as
693 We copy the return address to the program counter, since many
694 parts in GDB assume that it is possible to get the return address
695 by unwinding the program counter register. However, on ISA's
696 with a dedicated return address register, the CFI usually only
697 contains information to unwind that return address register.
699 The reason we're treating the stack pointer special here is
700 because in many cases GCC doesn't emit CFI for the stack pointer
701 and implicitly assumes that it is equal to the CFA. This makes
702 some sense since the DWARF specification (version 3, draft 8,
705 "Typically, the CFA is defined to be the value of the stack
706 pointer at the call site in the previous frame (which may be
707 different from its value on entry to the current frame)."
709 However, this isn't true for all platforms supported by GCC
710 (e.g. IBM S/390 and zSeries). Those architectures should provide
711 their own architecture-specific initialization function. */
713 if (regnum
== gdbarch_pc_regnum (gdbarch
))
714 reg
->how
= DWARF2_FRAME_REG_RA
;
715 else if (regnum
== gdbarch_sp_regnum (gdbarch
))
716 reg
->how
= DWARF2_FRAME_REG_CFA
;
719 /* Return a default for the architecture-specific operations. */
722 dwarf2_frame_init (struct obstack
*obstack
)
724 struct dwarf2_frame_ops
*ops
;
726 ops
= OBSTACK_ZALLOC (obstack
, struct dwarf2_frame_ops
);
727 ops
->init_reg
= dwarf2_frame_default_init_reg
;
731 /* Set the architecture-specific register state initialization
732 function for GDBARCH to INIT_REG. */
735 dwarf2_frame_set_init_reg (struct gdbarch
*gdbarch
,
736 void (*init_reg
) (struct gdbarch
*, int,
737 struct dwarf2_frame_state_reg
*,
738 struct frame_info
*))
740 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
742 ops
->init_reg
= init_reg
;
745 /* Pre-initialize the register state REG for register REGNUM. */
748 dwarf2_frame_init_reg (struct gdbarch
*gdbarch
, int regnum
,
749 struct dwarf2_frame_state_reg
*reg
,
750 struct frame_info
*this_frame
)
752 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
754 ops
->init_reg (gdbarch
, regnum
, reg
, this_frame
);
757 /* Set the architecture-specific signal trampoline recognition
758 function for GDBARCH to SIGNAL_FRAME_P. */
761 dwarf2_frame_set_signal_frame_p (struct gdbarch
*gdbarch
,
762 int (*signal_frame_p
) (struct gdbarch
*,
763 struct frame_info
*))
765 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
767 ops
->signal_frame_p
= signal_frame_p
;
770 /* Query the architecture-specific signal frame recognizer for
774 dwarf2_frame_signal_frame_p (struct gdbarch
*gdbarch
,
775 struct frame_info
*this_frame
)
777 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
779 if (ops
->signal_frame_p
== NULL
)
781 return ops
->signal_frame_p (gdbarch
, this_frame
);
784 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
788 dwarf2_frame_set_adjust_regnum (struct gdbarch
*gdbarch
,
789 int (*adjust_regnum
) (struct gdbarch
*,
792 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
794 ops
->adjust_regnum
= adjust_regnum
;
797 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
801 dwarf2_frame_adjust_regnum (struct gdbarch
*gdbarch
, int regnum
, int eh_frame_p
)
803 struct dwarf2_frame_ops
*ops
= gdbarch_data (gdbarch
, dwarf2_frame_data
);
805 if (ops
->adjust_regnum
== NULL
)
807 return ops
->adjust_regnum (gdbarch
, regnum
, eh_frame_p
);
811 dwarf2_frame_find_quirks (struct dwarf2_frame_state
*fs
,
812 struct dwarf2_fde
*fde
)
814 static const char *arm_idents
[] = {
815 "ARM C Compiler, ADS",
816 "Thumb C Compiler, ADS",
817 "ARM C++ Compiler, ADS",
818 "Thumb C++ Compiler, ADS",
819 "ARM/Thumb C/C++ Compiler, RVCT"
825 s
= find_pc_symtab (fs
->pc
);
826 if (s
== NULL
|| s
->producer
== NULL
)
829 for (i
= 0; i
< ARRAY_SIZE (arm_idents
); i
++)
830 if (strncmp (s
->producer
, arm_idents
[i
], strlen (arm_idents
[i
])) == 0)
832 if (fde
->cie
->version
== 1)
833 fs
->armcc_cfa_offsets_sf
= 1;
835 if (fde
->cie
->version
== 1)
836 fs
->armcc_cfa_offsets_reversed
= 1;
838 /* The reversed offset problem is present in some compilers
839 using DWARF3, but it was eventually fixed. Check the ARM
840 defined augmentations, which are in the format "armcc" followed
841 by a list of one-character options. The "+" option means
842 this problem is fixed (no quirk needed). If the armcc
843 augmentation is missing, the quirk is needed. */
844 if (fde
->cie
->version
== 3
845 && (strncmp (fde
->cie
->augmentation
, "armcc", 5) != 0
846 || strchr (fde
->cie
->augmentation
+ 5, '+') == NULL
))
847 fs
->armcc_cfa_offsets_reversed
= 1;
854 struct dwarf2_frame_cache
856 /* DWARF Call Frame Address. */
859 /* Set if the return address column was marked as undefined. */
860 int undefined_retaddr
;
862 /* Saved registers, indexed by GDB register number, not by DWARF
864 struct dwarf2_frame_state_reg
*reg
;
866 /* Return address register. */
867 struct dwarf2_frame_state_reg retaddr_reg
;
869 /* Target address size in bytes. */
873 static struct dwarf2_frame_cache
*
874 dwarf2_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
876 struct cleanup
*old_chain
;
877 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
878 const int num_regs
= gdbarch_num_regs (gdbarch
)
879 + gdbarch_num_pseudo_regs (gdbarch
);
880 struct dwarf2_frame_cache
*cache
;
881 struct dwarf2_frame_state
*fs
;
882 struct dwarf2_fde
*fde
;
887 /* Allocate a new cache. */
888 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
889 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
891 /* Allocate and initialize the frame state. */
892 fs
= XMALLOC (struct dwarf2_frame_state
);
893 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
894 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
898 Note that if the next frame is never supposed to return (i.e. a call
899 to abort), the compiler might optimize away the instruction at
900 its return address. As a result the return address will
901 point at some random instruction, and the CFI for that
902 instruction is probably worthless to us. GCC's unwinder solves
903 this problem by substracting 1 from the return address to get an
904 address in the middle of a presumed call instruction (or the
905 instruction in the associated delay slot). This should only be
906 done for "normal" frames and not for resume-type frames (signal
907 handlers, sentinel frames, dummy frames). The function
908 get_frame_address_in_block does just this. It's not clear how
909 reliable the method is though; there is the potential for the
910 register state pre-call being different to that on return. */
911 fs
->pc
= get_frame_address_in_block (this_frame
);
913 /* Find the correct FDE. */
914 fde
= dwarf2_frame_find_fde (&fs
->pc
);
915 gdb_assert (fde
!= NULL
);
917 /* Extract any interesting information from the CIE. */
918 fs
->data_align
= fde
->cie
->data_alignment_factor
;
919 fs
->code_align
= fde
->cie
->code_alignment_factor
;
920 fs
->retaddr_column
= fde
->cie
->return_address_register
;
921 cache
->addr_size
= fde
->cie
->addr_size
;
923 /* Check for "quirks" - known bugs in producers. */
924 dwarf2_frame_find_quirks (fs
, fde
);
926 /* First decode all the insns in the CIE. */
927 execute_cfa_program (fde
, fde
->cie
->initial_instructions
,
928 fde
->cie
->end
, this_frame
, fs
);
930 /* Save the initialized register set. */
931 fs
->initial
= fs
->regs
;
932 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
934 /* Then decode the insns in the FDE up to our target PC. */
935 execute_cfa_program (fde
, fde
->instructions
, fde
->end
, this_frame
, fs
);
937 /* Calculate the CFA. */
938 switch (fs
->regs
.cfa_how
)
941 cache
->cfa
= read_reg (this_frame
, fs
->regs
.cfa_reg
);
942 if (fs
->armcc_cfa_offsets_reversed
)
943 cache
->cfa
-= fs
->regs
.cfa_offset
;
945 cache
->cfa
+= fs
->regs
.cfa_offset
;
950 execute_stack_op (fs
->regs
.cfa_exp
, fs
->regs
.cfa_exp_len
,
951 cache
->addr_size
, this_frame
, 0);
955 internal_error (__FILE__
, __LINE__
, _("Unknown CFA rule."));
958 /* Initialize the register state. */
962 for (regnum
= 0; regnum
< num_regs
; regnum
++)
963 dwarf2_frame_init_reg (gdbarch
, regnum
, &cache
->reg
[regnum
], this_frame
);
966 /* Go through the DWARF2 CFI generated table and save its register
967 location information in the cache. Note that we don't skip the
968 return address column; it's perfectly all right for it to
969 correspond to a real register. If it doesn't correspond to a
970 real register, or if we shouldn't treat it as such,
971 gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
972 the range [0, gdbarch_num_regs). */
974 int column
; /* CFI speak for "register number". */
976 for (column
= 0; column
< fs
->regs
.num_regs
; column
++)
978 /* Use the GDB register number as the destination index. */
979 int regnum
= gdbarch_dwarf2_reg_to_regnum (gdbarch
, column
);
981 /* If there's no corresponding GDB register, ignore it. */
982 if (regnum
< 0 || regnum
>= num_regs
)
985 /* NOTE: cagney/2003-09-05: CFI should specify the disposition
986 of all debug info registers. If it doesn't, complain (but
987 not too loudly). It turns out that GCC assumes that an
988 unspecified register implies "same value" when CFI (draft
989 7) specifies nothing at all. Such a register could equally
990 be interpreted as "undefined". Also note that this check
991 isn't sufficient; it only checks that all registers in the
992 range [0 .. max column] are specified, and won't detect
993 problems when a debug info register falls outside of the
994 table. We need a way of iterating through all the valid
995 DWARF2 register numbers. */
996 if (fs
->regs
.reg
[column
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
998 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_UNSPECIFIED
)
999 complaint (&symfile_complaints
, _("\
1000 incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
1001 gdbarch_register_name (gdbarch
, regnum
),
1005 cache
->reg
[regnum
] = fs
->regs
.reg
[column
];
1009 /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1010 we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules. */
1014 for (regnum
= 0; regnum
< num_regs
; regnum
++)
1016 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
1017 || cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA_OFFSET
)
1019 struct dwarf2_frame_state_reg
*retaddr_reg
=
1020 &fs
->regs
.reg
[fs
->retaddr_column
];
1022 /* It seems rather bizarre to specify an "empty" column as
1023 the return adress column. However, this is exactly
1024 what GCC does on some targets. It turns out that GCC
1025 assumes that the return address can be found in the
1026 register corresponding to the return address column.
1027 Incidentally, that's how we should treat a return
1028 address column specifying "same value" too. */
1029 if (fs
->retaddr_column
< fs
->regs
.num_regs
1030 && retaddr_reg
->how
!= DWARF2_FRAME_REG_UNSPECIFIED
1031 && retaddr_reg
->how
!= DWARF2_FRAME_REG_SAME_VALUE
)
1033 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1034 cache
->reg
[regnum
] = *retaddr_reg
;
1036 cache
->retaddr_reg
= *retaddr_reg
;
1040 if (cache
->reg
[regnum
].how
== DWARF2_FRAME_REG_RA
)
1042 cache
->reg
[regnum
].loc
.reg
= fs
->retaddr_column
;
1043 cache
->reg
[regnum
].how
= DWARF2_FRAME_REG_SAVED_REG
;
1047 cache
->retaddr_reg
.loc
.reg
= fs
->retaddr_column
;
1048 cache
->retaddr_reg
.how
= DWARF2_FRAME_REG_SAVED_REG
;
1055 if (fs
->retaddr_column
< fs
->regs
.num_regs
1056 && fs
->regs
.reg
[fs
->retaddr_column
].how
== DWARF2_FRAME_REG_UNDEFINED
)
1057 cache
->undefined_retaddr
= 1;
1059 do_cleanups (old_chain
);
1061 *this_cache
= cache
;
1066 dwarf2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1067 struct frame_id
*this_id
)
1069 struct dwarf2_frame_cache
*cache
=
1070 dwarf2_frame_cache (this_frame
, this_cache
);
1072 if (cache
->undefined_retaddr
)
1075 (*this_id
) = frame_id_build (cache
->cfa
, get_frame_func (this_frame
));
1078 static struct value
*
1079 dwarf2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1082 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1083 struct dwarf2_frame_cache
*cache
=
1084 dwarf2_frame_cache (this_frame
, this_cache
);
1088 switch (cache
->reg
[regnum
].how
)
1090 case DWARF2_FRAME_REG_UNDEFINED
:
1091 /* If CFI explicitly specified that the value isn't defined,
1092 mark it as optimized away; the value isn't available. */
1093 return frame_unwind_got_optimized (this_frame
, regnum
);
1095 case DWARF2_FRAME_REG_SAVED_OFFSET
:
1096 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1097 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1099 case DWARF2_FRAME_REG_SAVED_REG
:
1101 = gdbarch_dwarf2_reg_to_regnum (gdbarch
, cache
->reg
[regnum
].loc
.reg
);
1102 return frame_unwind_got_register (this_frame
, regnum
, realnum
);
1104 case DWARF2_FRAME_REG_SAVED_EXP
:
1105 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1106 cache
->reg
[regnum
].exp_len
,
1107 cache
->addr_size
, this_frame
, cache
->cfa
);
1108 return frame_unwind_got_memory (this_frame
, regnum
, addr
);
1110 case DWARF2_FRAME_REG_SAVED_VAL_OFFSET
:
1111 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1112 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1114 case DWARF2_FRAME_REG_SAVED_VAL_EXP
:
1115 addr
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
1116 cache
->reg
[regnum
].exp_len
,
1117 cache
->addr_size
, this_frame
, cache
->cfa
);
1118 return frame_unwind_got_constant (this_frame
, regnum
, addr
);
1120 case DWARF2_FRAME_REG_UNSPECIFIED
:
1121 /* GCC, in its infinite wisdom decided to not provide unwind
1122 information for registers that are "same value". Since
1123 DWARF2 (3 draft 7) doesn't define such behavior, said
1124 registers are actually undefined (which is different to CFI
1125 "undefined"). Code above issues a complaint about this.
1126 Here just fudge the books, assume GCC, and that the value is
1127 more inner on the stack. */
1128 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1130 case DWARF2_FRAME_REG_SAME_VALUE
:
1131 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1133 case DWARF2_FRAME_REG_CFA
:
1134 return frame_unwind_got_address (this_frame
, regnum
, cache
->cfa
);
1136 case DWARF2_FRAME_REG_CFA_OFFSET
:
1137 addr
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
1138 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1140 case DWARF2_FRAME_REG_RA_OFFSET
:
1141 addr
= cache
->reg
[regnum
].loc
.offset
;
1142 regnum
= gdbarch_dwarf2_reg_to_regnum
1143 (gdbarch
, cache
->retaddr_reg
.loc
.reg
);
1144 addr
+= get_frame_register_unsigned (this_frame
, regnum
);
1145 return frame_unwind_got_address (this_frame
, regnum
, addr
);
1147 case DWARF2_FRAME_REG_FN
:
1148 return cache
->reg
[regnum
].loc
.fn (this_frame
, this_cache
, regnum
);
1151 internal_error (__FILE__
, __LINE__
, _("Unknown register rule."));
1156 dwarf2_frame_sniffer (const struct frame_unwind
*self
,
1157 struct frame_info
*this_frame
, void **this_cache
)
1159 /* Grab an address that is guarenteed to reside somewhere within the
1160 function. get_frame_pc(), with a no-return next function, can
1161 end up returning something past the end of this function's body.
1162 If the frame we're sniffing for is a signal frame whose start
1163 address is placed on the stack by the OS, its FDE must
1164 extend one byte before its start address or we could potentially
1165 select the FDE of the previous function. */
1166 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1167 struct dwarf2_fde
*fde
= dwarf2_frame_find_fde (&block_addr
);
1171 /* On some targets, signal trampolines may have unwind information.
1172 We need to recognize them so that we set the frame type
1175 if (fde
->cie
->signal_frame
1176 || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame
),
1178 return self
->type
== SIGTRAMP_FRAME
;
1180 return self
->type
!= SIGTRAMP_FRAME
;
1183 static const struct frame_unwind dwarf2_frame_unwind
=
1186 dwarf2_frame_this_id
,
1187 dwarf2_frame_prev_register
,
1189 dwarf2_frame_sniffer
1192 static const struct frame_unwind dwarf2_signal_frame_unwind
=
1195 dwarf2_frame_this_id
,
1196 dwarf2_frame_prev_register
,
1198 dwarf2_frame_sniffer
1201 /* Append the DWARF-2 frame unwinders to GDBARCH's list. */
1204 dwarf2_append_unwinders (struct gdbarch
*gdbarch
)
1206 frame_unwind_append_unwinder (gdbarch
, &dwarf2_frame_unwind
);
1207 frame_unwind_append_unwinder (gdbarch
, &dwarf2_signal_frame_unwind
);
1211 /* There is no explicitly defined relationship between the CFA and the
1212 location of frame's local variables and arguments/parameters.
1213 Therefore, frame base methods on this page should probably only be
1214 used as a last resort, just to avoid printing total garbage as a
1215 response to the "info frame" command. */
1218 dwarf2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1220 struct dwarf2_frame_cache
*cache
=
1221 dwarf2_frame_cache (this_frame
, this_cache
);
1226 static const struct frame_base dwarf2_frame_base
=
1228 &dwarf2_frame_unwind
,
1229 dwarf2_frame_base_address
,
1230 dwarf2_frame_base_address
,
1231 dwarf2_frame_base_address
1234 const struct frame_base
*
1235 dwarf2_frame_base_sniffer (struct frame_info
*this_frame
)
1237 CORE_ADDR block_addr
= get_frame_address_in_block (this_frame
);
1238 if (dwarf2_frame_find_fde (&block_addr
))
1239 return &dwarf2_frame_base
;
1244 const struct objfile_data
*dwarf2_frame_objfile_data
;
1247 read_1_byte (bfd
*abfd
, gdb_byte
*buf
)
1249 return bfd_get_8 (abfd
, buf
);
1253 read_4_bytes (bfd
*abfd
, gdb_byte
*buf
)
1255 return bfd_get_32 (abfd
, buf
);
1259 read_8_bytes (bfd
*abfd
, gdb_byte
*buf
)
1261 return bfd_get_64 (abfd
, buf
);
1265 read_unsigned_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1268 unsigned int num_read
;
1278 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1281 result
|= ((byte
& 0x7f) << shift
);
1284 while (byte
& 0x80);
1286 *bytes_read_ptr
= num_read
;
1292 read_signed_leb128 (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1296 unsigned int num_read
;
1305 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
1308 result
|= ((byte
& 0x7f) << shift
);
1311 while (byte
& 0x80);
1313 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1314 result
|= -(((LONGEST
)1) << shift
);
1316 *bytes_read_ptr
= num_read
;
1322 read_initial_length (bfd
*abfd
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
)
1326 result
= bfd_get_32 (abfd
, buf
);
1327 if (result
== 0xffffffff)
1329 result
= bfd_get_64 (abfd
, buf
+ 4);
1330 *bytes_read_ptr
= 12;
1333 *bytes_read_ptr
= 4;
1339 /* Pointer encoding helper functions. */
1341 /* GCC supports exception handling based on DWARF2 CFI. However, for
1342 technical reasons, it encodes addresses in its FDE's in a different
1343 way. Several "pointer encodings" are supported. The encoding
1344 that's used for a particular FDE is determined by the 'R'
1345 augmentation in the associated CIE. The argument of this
1346 augmentation is a single byte.
1348 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1349 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
1350 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
1351 address should be interpreted (absolute, relative to the current
1352 position in the FDE, ...). Bit 7, indicates that the address
1353 should be dereferenced. */
1356 encoding_for_size (unsigned int size
)
1361 return DW_EH_PE_udata2
;
1363 return DW_EH_PE_udata4
;
1365 return DW_EH_PE_udata8
;
1367 internal_error (__FILE__
, __LINE__
, _("Unsupported address size"));
1372 read_encoded_value (struct comp_unit
*unit
, gdb_byte encoding
,
1373 int ptr_len
, gdb_byte
*buf
, unsigned int *bytes_read_ptr
,
1374 CORE_ADDR func_base
)
1379 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1381 if (encoding
& DW_EH_PE_indirect
)
1382 internal_error (__FILE__
, __LINE__
,
1383 _("Unsupported encoding: DW_EH_PE_indirect"));
1385 *bytes_read_ptr
= 0;
1387 switch (encoding
& 0x70)
1389 case DW_EH_PE_absptr
:
1392 case DW_EH_PE_pcrel
:
1393 base
= bfd_get_section_vma (unit
->abfd
, unit
->dwarf_frame_section
);
1394 base
+= (buf
- unit
->dwarf_frame_buffer
);
1396 case DW_EH_PE_datarel
:
1399 case DW_EH_PE_textrel
:
1402 case DW_EH_PE_funcrel
:
1405 case DW_EH_PE_aligned
:
1407 offset
= buf
- unit
->dwarf_frame_buffer
;
1408 if ((offset
% ptr_len
) != 0)
1410 *bytes_read_ptr
= ptr_len
- (offset
% ptr_len
);
1411 buf
+= *bytes_read_ptr
;
1415 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1418 if ((encoding
& 0x07) == 0x00)
1420 encoding
|= encoding_for_size (ptr_len
);
1421 if (bfd_get_sign_extend_vma (unit
->abfd
))
1422 encoding
|= DW_EH_PE_signed
;
1425 switch (encoding
& 0x0f)
1427 case DW_EH_PE_uleb128
:
1430 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1431 *bytes_read_ptr
+= read_uleb128 (buf
, end_buf
, &value
) - buf
;
1432 return base
+ value
;
1434 case DW_EH_PE_udata2
:
1435 *bytes_read_ptr
+= 2;
1436 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
1437 case DW_EH_PE_udata4
:
1438 *bytes_read_ptr
+= 4;
1439 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
1440 case DW_EH_PE_udata8
:
1441 *bytes_read_ptr
+= 8;
1442 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
1443 case DW_EH_PE_sleb128
:
1446 gdb_byte
*end_buf
= buf
+ (sizeof (value
) + 1) * 8 / 7;
1447 *bytes_read_ptr
+= read_sleb128 (buf
, end_buf
, &value
) - buf
;
1448 return base
+ value
;
1450 case DW_EH_PE_sdata2
:
1451 *bytes_read_ptr
+= 2;
1452 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
1453 case DW_EH_PE_sdata4
:
1454 *bytes_read_ptr
+= 4;
1455 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
1456 case DW_EH_PE_sdata8
:
1457 *bytes_read_ptr
+= 8;
1458 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
1460 internal_error (__FILE__
, __LINE__
, _("Invalid or unsupported encoding"));
1465 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
1466 That's why we use a simple linked list here. */
1468 static struct dwarf2_cie
*
1469 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
1471 struct dwarf2_cie
*cie
= unit
->cie
;
1475 if (cie
->cie_pointer
== cie_pointer
)
1485 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1487 cie
->next
= unit
->cie
;
1492 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1493 inital location associated with it into *PC. */
1495 static struct dwarf2_fde
*
1496 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1498 struct objfile
*objfile
;
1500 ALL_OBJFILES (objfile
)
1502 struct dwarf2_fde
*fde
;
1505 fde
= objfile_data (objfile
, dwarf2_frame_objfile_data
);
1509 gdb_assert (objfile
->section_offsets
);
1510 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1514 if (*pc
>= fde
->initial_location
+ offset
1515 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1517 *pc
= fde
->initial_location
+ offset
;
1529 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1531 fde
->next
= objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
);
1532 set_objfile_data (unit
->objfile
, dwarf2_frame_objfile_data
, fde
);
1535 #ifdef CC_HAS_LONG_LONG
1536 #define DW64_CIE_ID 0xffffffffffffffffULL
1538 #define DW64_CIE_ID ~0
1541 static gdb_byte
*decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
,
1544 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1545 the next byte to be processed. */
1547 decode_frame_entry_1 (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1549 struct gdbarch
*gdbarch
= get_objfile_arch (unit
->objfile
);
1550 gdb_byte
*buf
, *end
;
1552 unsigned int bytes_read
;
1555 ULONGEST cie_pointer
;
1558 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1562 /* Are we still within the section? */
1563 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1569 /* Distinguish between 32 and 64-bit encoded frame info. */
1570 dwarf64_p
= (bytes_read
== 12);
1572 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1576 cie_id
= DW64_CIE_ID
;
1582 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1587 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1591 if (cie_pointer
== cie_id
)
1593 /* This is a CIE. */
1594 struct dwarf2_cie
*cie
;
1596 unsigned int cie_version
;
1598 /* Record the offset into the .debug_frame section of this CIE. */
1599 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1601 /* Check whether we've already read it. */
1602 if (find_cie (unit
, cie_pointer
))
1605 cie
= (struct dwarf2_cie
*)
1606 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1607 sizeof (struct dwarf2_cie
));
1608 cie
->initial_instructions
= NULL
;
1609 cie
->cie_pointer
= cie_pointer
;
1611 /* The encoding for FDE's in a normal .debug_frame section
1612 depends on the target address size. */
1613 cie
->encoding
= DW_EH_PE_absptr
;
1615 /* The target address size. For .eh_frame FDEs this is considered
1616 equal to the size of a target pointer. For .dwarf_frame FDEs,
1617 this is supposed to be the target address size from the associated
1618 CU header. FIXME: We do not have a good way to determine the
1619 latter. Always use the target pointer size for now. */
1620 cie
->addr_size
= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1622 /* We'll determine the final value later, but we need to
1623 initialize it conservatively. */
1624 cie
->signal_frame
= 0;
1626 /* Check version number. */
1627 cie_version
= read_1_byte (unit
->abfd
, buf
);
1628 if (cie_version
!= 1 && cie_version
!= 3)
1630 cie
->version
= cie_version
;
1633 /* Interpret the interesting bits of the augmentation. */
1634 cie
->augmentation
= augmentation
= (char *) buf
;
1635 buf
+= (strlen (augmentation
) + 1);
1637 /* Ignore armcc augmentations. We only use them for quirks,
1638 and that doesn't happen until later. */
1639 if (strncmp (augmentation
, "armcc", 5) == 0)
1640 augmentation
+= strlen (augmentation
);
1642 /* The GCC 2.x "eh" augmentation has a pointer immediately
1643 following the augmentation string, so it must be handled
1645 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1648 buf
+= gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1652 cie
->code_alignment_factor
=
1653 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1656 cie
->data_alignment_factor
=
1657 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1660 if (cie_version
== 1)
1662 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1666 cie
->return_address_register
= read_unsigned_leb128 (unit
->abfd
, buf
,
1668 cie
->return_address_register
1669 = dwarf2_frame_adjust_regnum (gdbarch
,
1670 cie
->return_address_register
,
1675 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1676 if (cie
->saw_z_augmentation
)
1680 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1684 cie
->initial_instructions
= buf
+ length
;
1688 while (*augmentation
)
1690 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1691 if (*augmentation
== 'L')
1698 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1699 else if (*augmentation
== 'R')
1701 cie
->encoding
= *buf
++;
1705 /* "P" indicates a personality routine in the CIE augmentation. */
1706 else if (*augmentation
== 'P')
1708 /* Skip. Avoid indirection since we throw away the result. */
1709 gdb_byte encoding
= (*buf
++) & ~DW_EH_PE_indirect
;
1710 read_encoded_value (unit
, encoding
, cie
->addr_size
,
1711 buf
, &bytes_read
, 0);
1716 /* "S" indicates a signal frame, such that the return
1717 address must not be decremented to locate the call frame
1718 info for the previous frame; it might even be the first
1719 instruction of a function, so decrementing it would take
1720 us to a different function. */
1721 else if (*augmentation
== 'S')
1723 cie
->signal_frame
= 1;
1727 /* Otherwise we have an unknown augmentation. Assume that either
1728 there is no augmentation data, or we saw a 'z' prefix. */
1731 if (cie
->initial_instructions
)
1732 buf
= cie
->initial_instructions
;
1737 cie
->initial_instructions
= buf
;
1740 add_cie (unit
, cie
);
1744 /* This is a FDE. */
1745 struct dwarf2_fde
*fde
;
1747 /* In an .eh_frame section, the CIE pointer is the delta between the
1748 address within the FDE where the CIE pointer is stored and the
1749 address of the CIE. Convert it to an offset into the .eh_frame
1753 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1754 cie_pointer
-= (dwarf64_p
? 8 : 4);
1757 /* In either case, validate the result is still within the section. */
1758 if (cie_pointer
>= unit
->dwarf_frame_size
)
1761 fde
= (struct dwarf2_fde
*)
1762 obstack_alloc (&unit
->objfile
->objfile_obstack
,
1763 sizeof (struct dwarf2_fde
));
1764 fde
->cie
= find_cie (unit
, cie_pointer
);
1765 if (fde
->cie
== NULL
)
1767 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1769 fde
->cie
= find_cie (unit
, cie_pointer
);
1772 gdb_assert (fde
->cie
!= NULL
);
1774 fde
->initial_location
=
1775 read_encoded_value (unit
, fde
->cie
->encoding
, fde
->cie
->addr_size
,
1776 buf
, &bytes_read
, 0);
1779 fde
->address_range
=
1780 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f,
1781 fde
->cie
->addr_size
, buf
, &bytes_read
, 0);
1784 /* A 'z' augmentation in the CIE implies the presence of an
1785 augmentation field in the FDE as well. The only thing known
1786 to be in here at present is the LSDA entry for EH. So we
1787 can skip the whole thing. */
1788 if (fde
->cie
->saw_z_augmentation
)
1792 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1793 buf
+= bytes_read
+ length
;
1798 fde
->instructions
= buf
;
1801 fde
->eh_frame_p
= eh_frame_p
;
1803 add_fde (unit
, fde
);
1809 /* Read a CIE or FDE in BUF and decode it. */
1811 decode_frame_entry (struct comp_unit
*unit
, gdb_byte
*start
, int eh_frame_p
)
1813 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1816 ptrdiff_t start_offset
;
1820 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1824 /* We have corrupt input data of some form. */
1826 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1827 and mismatches wrt padding and alignment of debug sections. */
1828 /* Note that there is no requirement in the standard for any
1829 alignment at all in the frame unwind sections. Testing for
1830 alignment before trying to interpret data would be incorrect.
1832 However, GCC traditionally arranged for frame sections to be
1833 sized such that the FDE length and CIE fields happen to be
1834 aligned (in theory, for performance). This, unfortunately,
1835 was done with .align directives, which had the side effect of
1836 forcing the section to be aligned by the linker.
1838 This becomes a problem when you have some other producer that
1839 creates frame sections that are not as strictly aligned. That
1840 produces a hole in the frame info that gets filled by the
1843 The GCC behaviour is arguably a bug, but it's effectively now
1844 part of the ABI, so we're now stuck with it, at least at the
1845 object file level. A smart linker may decide, in the process
1846 of compressing duplicate CIE information, that it can rewrite
1847 the entire output section without this extra padding. */
1849 start_offset
= start
- unit
->dwarf_frame_buffer
;
1850 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1852 start
+= 4 - (start_offset
& 3);
1853 workaround
= ALIGN4
;
1856 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1858 start
+= 8 - (start_offset
& 7);
1859 workaround
= ALIGN8
;
1863 /* Nothing left to try. Arrange to return as if we've consumed
1864 the entire input section. Hopefully we'll get valid info from
1865 the other of .debug_frame/.eh_frame. */
1867 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1877 complaint (&symfile_complaints
,
1878 _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1879 unit
->dwarf_frame_section
->owner
->filename
,
1880 unit
->dwarf_frame_section
->name
);
1884 complaint (&symfile_complaints
,
1885 _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1886 unit
->dwarf_frame_section
->owner
->filename
,
1887 unit
->dwarf_frame_section
->name
);
1891 complaint (&symfile_complaints
,
1892 _("Corrupt data in %s:%s"),
1893 unit
->dwarf_frame_section
->owner
->filename
,
1894 unit
->dwarf_frame_section
->name
);
1902 /* Imported from dwarf2read.c. */
1903 extern void dwarf2_get_section_info (struct objfile
*, const char *, asection
**,
1904 gdb_byte
**, bfd_size_type
*);
1907 dwarf2_build_frame_info (struct objfile
*objfile
)
1909 struct comp_unit
*unit
;
1910 gdb_byte
*frame_ptr
;
1912 /* Build a minimal decoding of the DWARF2 compilation unit. */
1913 unit
= (struct comp_unit
*) obstack_alloc (&objfile
->objfile_obstack
,
1914 sizeof (struct comp_unit
));
1915 unit
->abfd
= objfile
->obfd
;
1916 unit
->objfile
= objfile
;
1920 /* First add the information from the .eh_frame section. That way,
1921 the FDEs from that section are searched last. */
1922 dwarf2_get_section_info (objfile
, ".eh_frame",
1923 &unit
->dwarf_frame_section
,
1924 &unit
->dwarf_frame_buffer
,
1925 &unit
->dwarf_frame_size
);
1926 if (unit
->dwarf_frame_size
)
1928 asection
*got
, *txt
;
1931 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1932 that is used for the i386/amd64 target, which currently is
1933 the only target in GCC that supports/uses the
1934 DW_EH_PE_datarel encoding. */
1935 got
= bfd_get_section_by_name (unit
->abfd
, ".got");
1937 unit
->dbase
= got
->vma
;
1939 /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
1941 txt
= bfd_get_section_by_name (unit
->abfd
, ".text");
1943 unit
->tbase
= txt
->vma
;
1945 frame_ptr
= unit
->dwarf_frame_buffer
;
1946 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1947 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 1);
1950 dwarf2_get_section_info (objfile
, ".debug_frame",
1951 &unit
->dwarf_frame_section
,
1952 &unit
->dwarf_frame_buffer
,
1953 &unit
->dwarf_frame_size
);
1954 if (unit
->dwarf_frame_size
)
1958 frame_ptr
= unit
->dwarf_frame_buffer
;
1959 while (frame_ptr
< unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1960 frame_ptr
= decode_frame_entry (unit
, frame_ptr
, 0);
1964 /* Provide a prototype to silence -Wmissing-prototypes. */
1965 void _initialize_dwarf2_frame (void);
1968 _initialize_dwarf2_frame (void)
1970 dwarf2_frame_data
= gdbarch_data_register_pre_init (dwarf2_frame_init
);
1971 dwarf2_frame_objfile_data
= register_objfile_data ();