1 /* Frame unwinder for frames with DWARF Call Frame Information.
3 Copyright 2003 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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "dwarf2expr.h"
26 #include "elf/dwarf2.h"
28 #include "frame-base.h"
29 #include "frame-unwind.h"
36 #include "gdb_assert.h"
37 #include "gdb_string.h"
39 #include "complaints.h"
40 #include "dwarf2-frame.h"
42 /* Call Frame Information (CFI). */
44 /* Common Information Entry (CIE). */
48 /* Offset into the .debug_frame section where this CIE was found.
49 Used to identify this CIE. */
52 /* Constant that is factored out of all advance location
54 ULONGEST code_alignment_factor
;
56 /* Constants that is factored out of all offset instructions. */
57 LONGEST data_alignment_factor
;
59 /* Return address column. */
60 ULONGEST return_address_register
;
62 /* Instruction sequence to initialize a register set. */
63 unsigned char *initial_instructions
;
66 /* Encoding of addresses. */
67 unsigned char encoding
;
69 /* True if a 'z' augmentation existed. */
70 unsigned char saw_z_augmentation
;
72 struct dwarf2_cie
*next
;
75 /* Frame Description Entry (FDE). */
79 /* CIE for this FDE. */
80 struct dwarf2_cie
*cie
;
82 /* First location associated with this FDE. */
83 CORE_ADDR initial_location
;
85 /* Number of bytes of program instructions described by this FDE. */
86 CORE_ADDR address_range
;
88 /* Instruction sequence. */
89 unsigned char *instructions
;
92 struct dwarf2_fde
*next
;
95 static struct dwarf2_fde
*dwarf2_frame_find_fde (CORE_ADDR
*pc
);
98 /* Structure describing a frame state. */
100 struct dwarf2_frame_state
102 /* Each register save state can be described in terms of a CFA slot,
103 another register, or a location expression. */
104 struct dwarf2_frame_state_reg_info
106 struct dwarf2_frame_state_reg
124 /* Used to implement DW_CFA_remember_state. */
125 struct dwarf2_frame_state_reg_info
*prev
;
130 unsigned char *cfa_exp
;
137 /* The PC described by the current frame state. */
140 /* Initial register set from the CIE.
141 Used to implement DW_CFA_restore. */
142 struct dwarf2_frame_state_reg_info initial
;
144 /* The information we care about from the CIE. */
147 ULONGEST retaddr_column
;
150 /* Store the length the expression for the CFA in the `cfa_reg' field,
151 which is unused in that case. */
152 #define cfa_exp_len cfa_reg
154 /* Assert that the register set RS is large enough to store NUM_REGS
155 columns. If necessary, enlarge the register set. */
158 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info
*rs
,
161 size_t size
= sizeof (struct dwarf2_frame_state_reg
);
163 if (num_regs
<= rs
->num_regs
)
166 rs
->reg
= (struct dwarf2_frame_state_reg
*)
167 xrealloc (rs
->reg
, num_regs
* size
);
169 /* Initialize newly allocated registers. */
170 memset (rs
->reg
+ rs
->num_regs
, 0, (num_regs
- rs
->num_regs
) * size
);
171 rs
->num_regs
= num_regs
;
174 /* Copy the register columns in register set RS into newly allocated
175 memory and return a pointer to this newly created copy. */
177 static struct dwarf2_frame_state_reg
*
178 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info
*rs
)
180 size_t size
= rs
->num_regs
* sizeof (struct dwarf2_frame_state_reg_info
);
181 struct dwarf2_frame_state_reg
*reg
;
183 reg
= (struct dwarf2_frame_state_reg
*) xmalloc (size
);
184 memcpy (reg
, rs
->reg
, size
);
189 /* Release the memory allocated to register set RS. */
192 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info
*rs
)
196 dwarf2_frame_state_free_regs (rs
->prev
);
203 /* Release the memory allocated to the frame state FS. */
206 dwarf2_frame_state_free (void *p
)
208 struct dwarf2_frame_state
*fs
= p
;
210 dwarf2_frame_state_free_regs (fs
->initial
.prev
);
211 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
212 xfree (fs
->initial
.reg
);
213 xfree (fs
->regs
.reg
);
218 /* Helper functions for execute_stack_op. */
221 read_reg (void *baton
, int reg
)
223 struct frame_info
*next_frame
= (struct frame_info
*) baton
;
227 regnum
= DWARF2_REG_TO_REGNUM (reg
);
229 buf
= (char *) alloca (register_size (current_gdbarch
, regnum
));
230 frame_unwind_register (next_frame
, regnum
, buf
);
231 return extract_typed_address (buf
, builtin_type_void_data_ptr
);
235 read_mem (void *baton
, char *buf
, CORE_ADDR addr
, size_t len
)
237 read_memory (addr
, buf
, len
);
241 no_get_frame_base (void *baton
, unsigned char **start
, size_t *length
)
243 internal_error (__FILE__
, __LINE__
,
244 "Support for DW_OP_fbreg is unimplemented");
248 no_get_tls_address (void *baton
, CORE_ADDR offset
)
250 internal_error (__FILE__
, __LINE__
,
251 "Support for DW_OP_GNU_push_tls_address is unimplemented");
255 execute_stack_op (unsigned char *exp
, ULONGEST len
,
256 struct frame_info
*next_frame
, CORE_ADDR initial
)
258 struct dwarf_expr_context
*ctx
;
261 ctx
= new_dwarf_expr_context ();
262 ctx
->baton
= next_frame
;
263 ctx
->read_reg
= read_reg
;
264 ctx
->read_mem
= read_mem
;
265 ctx
->get_frame_base
= no_get_frame_base
;
266 ctx
->get_tls_address
= no_get_tls_address
;
268 dwarf_expr_push (ctx
, initial
);
269 dwarf_expr_eval (ctx
, exp
, len
);
270 result
= dwarf_expr_fetch (ctx
, 0);
273 result
= read_reg (next_frame
, result
);
275 free_dwarf_expr_context (ctx
);
282 execute_cfa_program (unsigned char *insn_ptr
, unsigned char *insn_end
,
283 struct frame_info
*next_frame
,
284 struct dwarf2_frame_state
*fs
)
286 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
289 while (insn_ptr
< insn_end
&& fs
->pc
<= pc
)
291 unsigned char insn
= *insn_ptr
++;
295 if ((insn
& 0xc0) == DW_CFA_advance_loc
)
296 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
297 else if ((insn
& 0xc0) == DW_CFA_offset
)
300 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
301 offset
= utmp
* fs
->data_align
;
302 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
303 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
304 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
306 else if ((insn
& 0xc0) == DW_CFA_restore
)
308 gdb_assert (fs
->initial
.reg
);
310 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
311 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
318 fs
->pc
= dwarf2_read_address (insn_ptr
, insn_end
, &bytes_read
);
319 insn_ptr
+= bytes_read
;
322 case DW_CFA_advance_loc1
:
323 utmp
= extract_unsigned_integer (insn_ptr
, 1);
324 fs
->pc
+= utmp
* fs
->code_align
;
327 case DW_CFA_advance_loc2
:
328 utmp
= extract_unsigned_integer (insn_ptr
, 2);
329 fs
->pc
+= utmp
* fs
->code_align
;
332 case DW_CFA_advance_loc4
:
333 utmp
= extract_unsigned_integer (insn_ptr
, 4);
334 fs
->pc
+= utmp
* fs
->code_align
;
338 case DW_CFA_offset_extended
:
339 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
340 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
341 offset
= utmp
* fs
->data_align
;
342 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
343 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
344 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
347 case DW_CFA_restore_extended
:
348 gdb_assert (fs
->initial
.reg
);
349 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
350 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
351 fs
->regs
.reg
[reg
] = fs
->initial
.reg
[reg
];
354 case DW_CFA_undefined
:
355 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
356 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
357 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
360 case DW_CFA_same_value
:
361 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
362 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
363 fs
->regs
.reg
[reg
].how
= REG_UNMODIFIED
;
366 case DW_CFA_register
:
367 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
368 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
369 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
370 fs
->regs
.reg
[reg
].loc
.reg
= utmp
;
373 case DW_CFA_remember_state
:
375 struct dwarf2_frame_state_reg_info
*new_rs
;
377 new_rs
= XMALLOC (struct dwarf2_frame_state_reg_info
);
379 fs
->regs
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
380 fs
->regs
.prev
= new_rs
;
384 case DW_CFA_restore_state
:
386 struct dwarf2_frame_state_reg_info
*old_rs
= fs
->regs
.prev
;
390 xfree (fs
->regs
.reg
);
397 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
398 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
399 fs
->cfa_offset
= utmp
;
400 fs
->cfa_how
= CFA_REG_OFFSET
;
403 case DW_CFA_def_cfa_register
:
404 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_reg
);
405 fs
->cfa_how
= CFA_REG_OFFSET
;
408 case DW_CFA_def_cfa_offset
:
409 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_offset
);
410 /* cfa_how deliberately not set. */
413 case DW_CFA_def_cfa_expression
:
414 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &fs
->cfa_exp_len
);
415 fs
->cfa_exp
= insn_ptr
;
416 fs
->cfa_how
= CFA_EXP
;
417 insn_ptr
+= fs
->cfa_exp_len
;
420 case DW_CFA_expression
:
421 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, ®
);
422 dwarf2_frame_state_alloc_regs (&fs
->regs
, reg
+ 1);
423 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
424 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
425 fs
->regs
.reg
[reg
].exp_len
= utmp
;
426 fs
->regs
.reg
[reg
].how
= REG_SAVED_EXP
;
433 case DW_CFA_GNU_args_size
:
435 insn_ptr
= read_uleb128 (insn_ptr
, insn_end
, &utmp
);
439 internal_error (__FILE__
, __LINE__
, "Unknown CFI encountered.");
444 /* Don't allow remember/restore between CIE and FDE programs. */
445 dwarf2_frame_state_free_regs (fs
->regs
.prev
);
446 fs
->regs
.prev
= NULL
;
449 struct dwarf2_frame_cache
451 /* DWARF Call Frame Address. */
454 /* Saved registers, indexed by GDB register number, not by DWARF
456 struct dwarf2_frame_state_reg
*reg
;
459 static struct dwarf2_frame_cache
*
460 dwarf2_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
462 struct cleanup
*old_chain
;
463 int num_regs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
464 struct dwarf2_frame_cache
*cache
;
465 struct dwarf2_frame_state
*fs
;
466 struct dwarf2_fde
*fde
;
472 /* Allocate a new cache. */
473 cache
= FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache
);
474 cache
->reg
= FRAME_OBSTACK_CALLOC (num_regs
, struct dwarf2_frame_state_reg
);
476 /* Allocate and initialize the frame state. */
477 fs
= XMALLOC (struct dwarf2_frame_state
);
478 memset (fs
, 0, sizeof (struct dwarf2_frame_state
));
479 old_chain
= make_cleanup (dwarf2_frame_state_free
, fs
);
483 Note that if NEXT_FRAME is never supposed to return (i.e. a call
484 to abort), the compiler might optimize away the instruction at
485 NEXT_FRAME's return address. As a result the return address will
486 point at some random instruction, and the CFI for that
487 instruction is probably wortless to us. GCC's unwinder solves
488 this problem by substracting 1 from the return address to get an
489 address in the middle of a presumed call instruction (or the
490 instruction in the associated delay slot). This should only be
491 done for "normal" frames and not for resume-type frames (signal
492 handlers, sentinel frames, dummy frames).
494 frame_unwind_address_in_block does just this.
496 It's not clear how reliable the method is though - there is the
497 potential for the register state pre-call being different to that
499 fs
->pc
= frame_unwind_address_in_block (next_frame
);
501 /* Find the correct FDE. */
502 fde
= dwarf2_frame_find_fde (&fs
->pc
);
503 gdb_assert (fde
!= NULL
);
505 /* Extract any interesting information from the CIE. */
506 fs
->data_align
= fde
->cie
->data_alignment_factor
;
507 fs
->code_align
= fde
->cie
->code_alignment_factor
;
508 fs
->retaddr_column
= fde
->cie
->return_address_register
;
510 /* First decode all the insns in the CIE. */
511 execute_cfa_program (fde
->cie
->initial_instructions
,
512 fde
->cie
->end
, next_frame
, fs
);
514 /* Save the initialized register set. */
515 fs
->initial
= fs
->regs
;
516 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
518 /* Then decode the insns in the FDE up to our target PC. */
519 execute_cfa_program (fde
->instructions
, fde
->end
, next_frame
, fs
);
521 /* Caclulate the CFA. */
525 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
526 cache
->cfa
+= fs
->cfa_offset
;
531 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
, next_frame
, 0);
535 internal_error (__FILE__
, __LINE__
, "Unknown CFA rule.");
538 /* Save the register info in the cache. */
539 for (reg
= 0; reg
< fs
->regs
.num_regs
; reg
++)
543 /* Skip the return address column. */
544 if (reg
== fs
->retaddr_column
)
545 /* NOTE: cagney/2003-06-07: Is this right? What if the
546 RETADDR_COLUM corresponds to a real register (and, worse,
547 that isn't the PC_REGNUM)? I'm guessing that the PC_REGNUM
548 further down is trying to handle this. That can't be right
549 though - PC_REGNUM may not be valid (it can be -ve). I
550 think, instead when RETADDR_COLUM isn't a real register, it
551 should map itself onto frame_pc_unwind. */
554 /* Use the GDB register number as index. */
555 regnum
= DWARF2_REG_TO_REGNUM (reg
);
557 if (regnum
>= 0 && regnum
< num_regs
)
558 cache
->reg
[regnum
] = fs
->regs
.reg
[reg
];
561 /* Store the location of the return addess. If the return address
562 column (adjusted) is not the same as gdb's PC_REGNUM, then this
563 implies a copy from the ra column register. */
564 if (fs
->retaddr_column
< fs
->regs
.num_regs
565 && fs
->regs
.reg
[fs
->retaddr_column
].how
!= REG_UNSAVED
)
567 /* See comment above about a possibly -ve PC_REGNUM. If this
568 assertion fails, it's a problem with this code and not the
570 gdb_assert (PC_REGNUM
>= 0);
571 cache
->reg
[PC_REGNUM
] = fs
->regs
.reg
[fs
->retaddr_column
];
575 reg
= DWARF2_REG_TO_REGNUM (fs
->retaddr_column
);
576 if (reg
!= PC_REGNUM
)
578 /* See comment above about PC_REGNUM being -ve. If this
579 assertion fails, it's a problem with this code and not
581 gdb_assert (PC_REGNUM
>= 0);
582 cache
->reg
[PC_REGNUM
].loc
.reg
= reg
;
583 cache
->reg
[PC_REGNUM
].how
= REG_SAVED_REG
;
587 do_cleanups (old_chain
);
594 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
595 struct frame_id
*this_id
)
597 struct dwarf2_frame_cache
*cache
=
598 dwarf2_frame_cache (next_frame
, this_cache
);
600 (*this_id
) = frame_id_build (cache
->cfa
, frame_func_unwind (next_frame
));
604 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
605 int regnum
, int *optimizedp
,
606 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
607 int *realnump
, void *valuep
)
609 struct dwarf2_frame_cache
*cache
=
610 dwarf2_frame_cache (next_frame
, this_cache
);
612 switch (cache
->reg
[regnum
].how
)
619 if (regnum
== SP_REGNUM
)
621 /* GCC defines the CFA as the value of the stack pointer
622 just before the call instruction is executed. Do other
623 compilers use the same definition? */
624 /* DWARF V3 Draft 7 p102: Typically, the CFA is defined to
625 be the value of the stack pointer at the call site in the
626 previous frame (which may be different from its value on
627 entry to the current frame). */
628 /* DWARF V3 Draft 7 p103: The first column of the rules
629 defines the rule which computes the CFA value; it may be
630 either a register and a signed offset that are added
631 together or a DWARF expression that is evaluated. */
632 /* FIXME: cagney/2003-07-07: I don't understand this. The
633 CFI info should have provided unwind information for the
634 SP register and then pointed ->cfa_reg at it, not the
635 reverse. Assuming that SP_REGNUM is !-ve, there is a
636 very real posibility that CFA is an offset from some
637 other register, having nothing to do with the unwound SP
642 /* Store the value. */
643 store_typed_address (valuep
, builtin_type_void_data_ptr
,
649 /* In some cases, for example %eflags on the i386, we have
650 to provide a sane value, even though this register wasn't
651 saved. Assume we can get it from NEXT_FRAME. */
652 frame_unwind_register (next_frame
, regnum
, valuep
);
656 case REG_SAVED_OFFSET
:
658 *lvalp
= lval_memory
;
659 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
663 /* Read the value in from memory. */
664 read_memory (*addrp
, valuep
,
665 register_size (current_gdbarch
, regnum
));
670 regnum
= DWARF2_REG_TO_REGNUM (cache
->reg
[regnum
].loc
.reg
);
671 frame_register_unwind (next_frame
, regnum
,
672 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
677 *lvalp
= lval_memory
;
678 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
679 cache
->reg
[regnum
].exp_len
,
680 next_frame
, cache
->cfa
);
684 /* Read the value in from memory. */
685 read_memory (*addrp
, valuep
,
686 register_size (current_gdbarch
, regnum
));
691 frame_register_unwind (next_frame
, regnum
,
692 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
696 internal_error (__FILE__
, __LINE__
, "Unknown register rule.");
700 static const struct frame_unwind dwarf2_frame_unwind
=
703 dwarf2_frame_this_id
,
704 dwarf2_frame_prev_register
707 const struct frame_unwind
*
708 dwarf2_frame_sniffer (struct frame_info
*next_frame
)
710 /* Grab an address that is guarenteed to reside somewhere within the
711 function. frame_pc_unwind(), for a no-return next function, can
712 end up returning something past the end of this function's body. */
713 CORE_ADDR block_addr
= frame_unwind_address_in_block (next_frame
);
714 if (dwarf2_frame_find_fde (&block_addr
))
715 return &dwarf2_frame_unwind
;
721 /* There is no explicitly defined relationship between the CFA and the
722 location of frame's local variables and arguments/parameters.
723 Therefore, frame base methods on this page should probably only be
724 used as a last resort, just to avoid printing total garbage as a
725 response to the "info frame" command. */
728 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
730 struct dwarf2_frame_cache
*cache
=
731 dwarf2_frame_cache (next_frame
, this_cache
);
736 static const struct frame_base dwarf2_frame_base
=
738 &dwarf2_frame_unwind
,
739 dwarf2_frame_base_address
,
740 dwarf2_frame_base_address
,
741 dwarf2_frame_base_address
744 const struct frame_base
*
745 dwarf2_frame_base_sniffer (struct frame_info
*next_frame
)
747 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
748 if (dwarf2_frame_find_fde (&pc
))
749 return &dwarf2_frame_base
;
754 /* A minimal decoding of DWARF2 compilation units. We only decode
755 what's needed to get to the call frame information. */
759 /* Keep the bfd convenient. */
762 struct objfile
*objfile
;
764 /* Linked list of CIEs for this object. */
765 struct dwarf2_cie
*cie
;
767 /* Address size for this unit - from unit header. */
768 unsigned char addr_size
;
770 /* Pointer to the .debug_frame section loaded into memory. */
771 char *dwarf_frame_buffer
;
773 /* Length of the loaded .debug_frame section. */
774 unsigned long dwarf_frame_size
;
776 /* Pointer to the .debug_frame section. */
777 asection
*dwarf_frame_section
;
779 /* Base for DW_EH_PE_datarel encodings. */
784 read_1_byte (bfd
*bfd
, char *buf
)
786 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
790 read_4_bytes (bfd
*abfd
, char *buf
)
792 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
796 read_8_bytes (bfd
*abfd
, char *buf
)
798 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
802 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
805 unsigned int num_read
;
815 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
818 result
|= ((byte
& 0x7f) << shift
);
823 *bytes_read_ptr
= num_read
;
829 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
833 unsigned int num_read
;
842 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
845 result
|= ((byte
& 0x7f) << shift
);
850 if ((shift
< 32) && (byte
& 0x40))
851 result
|= -(1 << shift
);
853 *bytes_read_ptr
= num_read
;
859 read_initial_length (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
863 result
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
864 if (result
== 0xffffffff)
866 result
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
867 *bytes_read_ptr
= 12;
876 /* Pointer encoding helper functions. */
878 /* GCC supports exception handling based on DWARF2 CFI. However, for
879 technical reasons, it encodes addresses in its FDE's in a different
880 way. Several "pointer encodings" are supported. The encoding
881 that's used for a particular FDE is determined by the 'R'
882 augmentation in the associated CIE. The argument of this
883 augmentation is a single byte.
885 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
886 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
887 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
888 address should be interpreted (absolute, relative to the current
889 position in the FDE, ...). Bit 7, indicates that the address
890 should be dereferenced. */
893 encoding_for_size (unsigned int size
)
898 return DW_EH_PE_udata2
;
900 return DW_EH_PE_udata4
;
902 return DW_EH_PE_udata8
;
904 internal_error (__FILE__
, __LINE__
, "Unsupported address size");
909 size_of_encoded_value (unsigned char encoding
)
911 if (encoding
== DW_EH_PE_omit
)
914 switch (encoding
& 0x07)
916 case DW_EH_PE_absptr
:
917 return TYPE_LENGTH (builtin_type_void_data_ptr
);
918 case DW_EH_PE_udata2
:
920 case DW_EH_PE_udata4
:
922 case DW_EH_PE_udata8
:
925 internal_error (__FILE__
, __LINE__
, "Invalid or unsupported encoding");
930 read_encoded_value (struct comp_unit
*unit
, unsigned char encoding
,
931 char *buf
, unsigned int *bytes_read_ptr
)
935 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
937 if (encoding
& DW_EH_PE_indirect
)
938 internal_error (__FILE__
, __LINE__
,
939 "Unsupported encoding: DW_EH_PE_indirect");
941 switch (encoding
& 0x70)
943 case DW_EH_PE_absptr
:
947 base
= bfd_get_section_vma (unit
->bfd
, unit
->dwarf_frame_section
);
948 base
+= (buf
- unit
->dwarf_frame_buffer
);
950 case DW_EH_PE_datarel
:
954 internal_error (__FILE__
, __LINE__
, "Invalid or unsupported encoding");
957 if ((encoding
& 0x0f) == 0x00)
958 encoding
|= encoding_for_size (TYPE_LENGTH(builtin_type_void_data_ptr
));
960 switch (encoding
& 0x0f)
962 case DW_EH_PE_udata2
:
964 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
965 case DW_EH_PE_udata4
:
967 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
968 case DW_EH_PE_udata8
:
970 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
971 case DW_EH_PE_sdata2
:
973 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
974 case DW_EH_PE_sdata4
:
976 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
977 case DW_EH_PE_sdata8
:
979 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
981 internal_error (__FILE__
, __LINE__
, "Invalid or unsupported encoding");
986 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
987 That's why we use a simple linked list here. */
989 static struct dwarf2_cie
*
990 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
992 struct dwarf2_cie
*cie
= unit
->cie
;
996 if (cie
->cie_pointer
== cie_pointer
)
1006 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1008 cie
->next
= unit
->cie
;
1012 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1013 inital location associated with it into *PC. */
1015 static struct dwarf2_fde
*
1016 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1018 struct objfile
*objfile
;
1020 ALL_OBJFILES (objfile
)
1022 struct dwarf2_fde
*fde
;
1025 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1027 fde
= objfile
->sym_private
;
1030 if (*pc
>= fde
->initial_location
+ offset
1031 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1033 *pc
= fde
->initial_location
+ offset
;
1045 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1047 fde
->next
= unit
->objfile
->sym_private
;
1048 unit
->objfile
->sym_private
= fde
;
1051 #ifdef CC_HAS_LONG_LONG
1052 #define DW64_CIE_ID 0xffffffffffffffffULL
1054 #define DW64_CIE_ID ~0
1057 static char *decode_frame_entry (struct comp_unit
*unit
, char *start
,
1060 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1061 the next byte to be processed. */
1063 decode_frame_entry_1 (struct comp_unit
*unit
, char *start
, int eh_frame_p
)
1067 unsigned int bytes_read
;
1070 ULONGEST cie_pointer
;
1074 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1078 /* Are we still within the section? */
1079 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1085 /* Distinguish between 32 and 64-bit encoded frame info. */
1086 dwarf64_p
= (bytes_read
== 12);
1088 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1092 cie_id
= DW64_CIE_ID
;
1098 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1103 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1107 if (cie_pointer
== cie_id
)
1109 /* This is a CIE. */
1110 struct dwarf2_cie
*cie
;
1113 /* Record the offset into the .debug_frame section of this CIE. */
1114 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1116 /* Check whether we've already read it. */
1117 if (find_cie (unit
, cie_pointer
))
1120 cie
= (struct dwarf2_cie
*)
1121 obstack_alloc (&unit
->objfile
->psymbol_obstack
,
1122 sizeof (struct dwarf2_cie
));
1123 cie
->initial_instructions
= NULL
;
1124 cie
->cie_pointer
= cie_pointer
;
1126 /* The encoding for FDE's in a normal .debug_frame section
1127 depends on the target address size as specified in the
1128 Compilation Unit Header. */
1129 cie
->encoding
= encoding_for_size (unit
->addr_size
);
1131 /* Check version number. */
1132 if (read_1_byte (unit
->abfd
, buf
) != DW_CIE_VERSION
)
1136 /* Interpret the interesting bits of the augmentation. */
1138 buf
= augmentation
+ strlen (augmentation
) + 1;
1140 /* The GCC 2.x "eh" augmentation has a pointer immediately
1141 following the augmentation string, so it must be handled
1143 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1146 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1150 cie
->code_alignment_factor
=
1151 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1154 cie
->data_alignment_factor
=
1155 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1158 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1161 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1162 if (cie
->saw_z_augmentation
)
1166 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1170 cie
->initial_instructions
= buf
+ length
;
1174 while (*augmentation
)
1176 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1177 if (*augmentation
== 'L')
1184 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1185 else if (*augmentation
== 'R')
1187 cie
->encoding
= *buf
++;
1191 /* "P" indicates a personality routine in the CIE augmentation. */
1192 else if (*augmentation
== 'P')
1195 buf
+= size_of_encoded_value (*buf
++);
1199 /* Otherwise we have an unknown augmentation.
1200 Bail out unless we saw a 'z' prefix. */
1203 if (cie
->initial_instructions
== NULL
)
1206 /* Skip unknown augmentations. */
1207 buf
= cie
->initial_instructions
;
1212 cie
->initial_instructions
= buf
;
1215 add_cie (unit
, cie
);
1219 /* This is a FDE. */
1220 struct dwarf2_fde
*fde
;
1222 /* In an .eh_frame section, the CIE pointer is the delta between the
1223 address within the FDE where the CIE pointer is stored and the
1224 address of the CIE. Convert it to an offset into the .eh_frame
1228 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1229 cie_pointer
-= (dwarf64_p
? 8 : 4);
1232 /* In either case, validate the result is still within the section. */
1233 if (cie_pointer
>= unit
->dwarf_frame_size
)
1236 fde
= (struct dwarf2_fde
*)
1237 obstack_alloc (&unit
->objfile
->psymbol_obstack
,
1238 sizeof (struct dwarf2_fde
));
1239 fde
->cie
= find_cie (unit
, cie_pointer
);
1240 if (fde
->cie
== NULL
)
1242 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1244 fde
->cie
= find_cie (unit
, cie_pointer
);
1247 gdb_assert (fde
->cie
!= NULL
);
1249 fde
->initial_location
=
1250 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1253 fde
->address_range
=
1254 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1257 /* A 'z' augmentation in the CIE implies the presence of an
1258 augmentation field in the FDE as well. The only thing known
1259 to be in here at present is the LSDA entry for EH. So we
1260 can skip the whole thing. */
1261 if (fde
->cie
->saw_z_augmentation
)
1265 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1266 buf
+= bytes_read
+ length
;
1271 fde
->instructions
= buf
;
1274 add_fde (unit
, fde
);
1280 /* Read a CIE or FDE in BUF and decode it. */
1282 decode_frame_entry (struct comp_unit
*unit
, char *start
, int eh_frame_p
)
1284 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1287 ptrdiff_t start_offset
;
1291 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1295 /* We have corrupt input data of some form. */
1297 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1298 and mismatches wrt padding and alignment of debug sections. */
1299 /* Note that there is no requirement in the standard for any
1300 alignment at all in the frame unwind sections. Testing for
1301 alignment before trying to interpret data would be incorrect.
1303 However, GCC traditionally arranged for frame sections to be
1304 sized such that the FDE length and CIE fields happen to be
1305 aligned (in theory, for performance). This, unfortunately,
1306 was done with .align directives, which had the side effect of
1307 forcing the section to be aligned by the linker.
1309 This becomes a problem when you have some other producer that
1310 creates frame sections that are not as strictly aligned. That
1311 produces a hole in the frame info that gets filled by the
1314 The GCC behaviour is arguably a bug, but it's effectively now
1315 part of the ABI, so we're now stuck with it, at least at the
1316 object file level. A smart linker may decide, in the process
1317 of compressing duplicate CIE information, that it can rewrite
1318 the entire output section without this extra padding. */
1320 start_offset
= start
- unit
->dwarf_frame_buffer
;
1321 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1323 start
+= 4 - (start_offset
& 3);
1324 workaround
= ALIGN4
;
1327 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1329 start
+= 8 - (start_offset
& 7);
1330 workaround
= ALIGN8
;
1334 /* Nothing left to try. Arrange to return as if we've consumed
1335 the entire input section. Hopefully we'll get valid info from
1336 the other of .debug_frame/.eh_frame. */
1338 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1348 complaint (&symfile_complaints
,
1349 "Corrupt data in %s:%s; align 4 workaround apparently succeeded",
1350 unit
->dwarf_frame_section
->owner
->filename
,
1351 unit
->dwarf_frame_section
->name
);
1355 complaint (&symfile_complaints
,
1356 "Corrupt data in %s:%s; align 8 workaround apparently succeeded",
1357 unit
->dwarf_frame_section
->owner
->filename
,
1358 unit
->dwarf_frame_section
->name
);
1362 complaint (&symfile_complaints
,
1363 "Corrupt data in %s:%s",
1364 unit
->dwarf_frame_section
->owner
->filename
,
1365 unit
->dwarf_frame_section
->name
);
1374 /* FIXME: kettenis/20030504: This still needs to be integrated with
1375 dwarf2read.c in a better way. */
1377 /* Imported from dwarf2read.c. */
1378 extern file_ptr dwarf_frame_offset
;
1379 extern unsigned int dwarf_frame_size
;
1380 extern asection
*dwarf_frame_section
;
1381 extern file_ptr dwarf_eh_frame_offset
;
1382 extern unsigned int dwarf_eh_frame_size
;
1383 extern asection
*dwarf_eh_frame_section
;
1385 /* Imported from dwarf2read.c. */
1386 extern char *dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
1387 unsigned int size
, asection
*sectp
);
1390 dwarf2_build_frame_info (struct objfile
*objfile
)
1392 struct comp_unit unit
;
1395 /* Build a minimal decoding of the DWARF2 compilation unit. */
1396 unit
.abfd
= objfile
->obfd
;
1397 unit
.objfile
= objfile
;
1398 unit
.addr_size
= objfile
->obfd
->arch_info
->bits_per_address
/ 8;
1401 /* First add the information from the .eh_frame section. That way,
1402 the FDEs from that section are searched last. */
1403 if (dwarf_eh_frame_offset
)
1408 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1409 dwarf_eh_frame_offset
,
1410 dwarf_eh_frame_size
,
1411 dwarf_eh_frame_section
);
1413 unit
.dwarf_frame_size
= dwarf_eh_frame_size
;
1414 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1416 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1417 that for the i386/amd64 target, which currently is the only
1418 target in GCC that supports/uses the DW_EH_PE_datarel
1420 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
1422 unit
.dbase
= got
->vma
;
1424 frame_ptr
= unit
.dwarf_frame_buffer
;
1425 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1426 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
1429 if (dwarf_frame_offset
)
1432 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1435 dwarf_frame_section
);
1436 unit
.dwarf_frame_size
= dwarf_frame_size
;
1437 unit
.dwarf_frame_section
= dwarf_frame_section
;
1439 frame_ptr
= unit
.dwarf_frame_buffer
;
1440 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1441 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);