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 We don't do what GCC's does here (yet). It's not clear how
495 reliable the method is. There's also a problem with finding the
496 right FDE; see the comment in dwarf_frame_p. If dwarf_frame_p
497 selected this frame unwinder because it found the FDE for the
498 next function, using the adjusted return address might not yield
499 a FDE at all. The problem isn't specific to DWARF CFI; other
500 unwinders loose in similar ways. Therefore it's probably
501 acceptable to leave things slightly broken for now. */
502 fs
->pc
= frame_pc_unwind (next_frame
);
504 /* Find the correct FDE. */
505 fde
= dwarf2_frame_find_fde (&fs
->pc
);
506 gdb_assert (fde
!= NULL
);
508 /* Extract any interesting information from the CIE. */
509 fs
->data_align
= fde
->cie
->data_alignment_factor
;
510 fs
->code_align
= fde
->cie
->code_alignment_factor
;
511 fs
->retaddr_column
= fde
->cie
->return_address_register
;
513 /* First decode all the insns in the CIE. */
514 execute_cfa_program (fde
->cie
->initial_instructions
,
515 fde
->cie
->end
, next_frame
, fs
);
517 /* Save the initialized register set. */
518 fs
->initial
= fs
->regs
;
519 fs
->initial
.reg
= dwarf2_frame_state_copy_regs (&fs
->regs
);
521 /* Then decode the insns in the FDE up to our target PC. */
522 execute_cfa_program (fde
->instructions
, fde
->end
, next_frame
, fs
);
524 /* Caclulate the CFA. */
528 cache
->cfa
= read_reg (next_frame
, fs
->cfa_reg
);
529 cache
->cfa
+= fs
->cfa_offset
;
534 execute_stack_op (fs
->cfa_exp
, fs
->cfa_exp_len
, next_frame
, 0);
538 internal_error (__FILE__
, __LINE__
, "Unknown CFA rule.");
541 /* Save the register info in the cache. */
542 for (reg
= 0; reg
< fs
->regs
.num_regs
; reg
++)
546 /* Skip the return address column. */
547 if (reg
== fs
->retaddr_column
)
548 /* NOTE: cagney/2003-06-07: Is this right? What if the
549 RETADDR_COLUM corresponds to a real register (and, worse,
550 that isn't the PC_REGNUM)? I'm guessing that the PC_REGNUM
551 further down is trying to handle this. That can't be right
552 though - PC_REGNUM may not be valid (it can be -ve). I
553 think, instead when RETADDR_COLUM isn't a real register, it
554 should map itself onto frame_pc_unwind. */
557 /* Use the GDB register number as index. */
558 regnum
= DWARF2_REG_TO_REGNUM (reg
);
560 if (regnum
>= 0 && regnum
< num_regs
)
561 cache
->reg
[regnum
] = fs
->regs
.reg
[reg
];
564 /* Store the location of the return addess. If the return address
565 column (adjusted) is not the same as gdb's PC_REGNUM, then this
566 implies a copy from the ra column register. */
567 if (fs
->retaddr_column
< fs
->regs
.num_regs
568 && fs
->regs
.reg
[fs
->retaddr_column
].how
!= REG_UNSAVED
)
570 /* See comment above about a possibly -ve PC_REGNUM. If this
571 assertion fails, it's a problem with this code and not the
573 gdb_assert (PC_REGNUM
>= 0);
574 cache
->reg
[PC_REGNUM
] = fs
->regs
.reg
[fs
->retaddr_column
];
578 reg
= DWARF2_REG_TO_REGNUM (fs
->retaddr_column
);
579 if (reg
!= PC_REGNUM
)
581 /* See comment above about PC_REGNUM being -ve. If this
582 assertion fails, it's a problem with this code and not
584 gdb_assert (PC_REGNUM
>= 0);
585 cache
->reg
[PC_REGNUM
].loc
.reg
= reg
;
586 cache
->reg
[PC_REGNUM
].how
= REG_SAVED_REG
;
590 do_cleanups (old_chain
);
597 dwarf2_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
598 struct frame_id
*this_id
)
600 struct dwarf2_frame_cache
*cache
=
601 dwarf2_frame_cache (next_frame
, this_cache
);
603 (*this_id
) = frame_id_build (cache
->cfa
, frame_func_unwind (next_frame
));
607 dwarf2_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
608 int regnum
, int *optimizedp
,
609 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
610 int *realnump
, void *valuep
)
612 struct dwarf2_frame_cache
*cache
=
613 dwarf2_frame_cache (next_frame
, this_cache
);
615 switch (cache
->reg
[regnum
].how
)
622 if (regnum
== SP_REGNUM
)
624 /* GCC defines the CFA as the value of the stack pointer
625 just before the call instruction is executed. Do other
626 compilers use the same definition? */
627 /* DWARF V3 Draft 7 p102: Typically, the CFA is defined to
628 be the value of the stack pointer at the call site in the
629 previous frame (which may be different from its value on
630 entry to the current frame). */
631 /* DWARF V3 Draft 7 p103: The first column of the rules
632 defines the rule which computes the CFA value; it may be
633 either a register and a signed offset that are added
634 together or a DWARF expression that is evaluated. */
635 /* FIXME: cagney/2003-07-07: I don't understand this. The
636 CFI info should have provided unwind information for the
637 SP register and then pointed ->cfa_reg at it, not the
638 reverse. Assuming that SP_REGNUM is !-ve, there is a
639 very real posibility that CFA is an offset from some
640 other register, having nothing to do with the unwound SP
645 /* Store the value. */
646 store_typed_address (valuep
, builtin_type_void_data_ptr
,
652 /* In some cases, for example %eflags on the i386, we have
653 to provide a sane value, even though this register wasn't
654 saved. Assume we can get it from NEXT_FRAME. */
655 frame_unwind_register (next_frame
, regnum
, valuep
);
659 case REG_SAVED_OFFSET
:
661 *lvalp
= lval_memory
;
662 *addrp
= cache
->cfa
+ cache
->reg
[regnum
].loc
.offset
;
666 /* Read the value in from memory. */
667 read_memory (*addrp
, valuep
,
668 register_size (current_gdbarch
, regnum
));
673 regnum
= DWARF2_REG_TO_REGNUM (cache
->reg
[regnum
].loc
.reg
);
674 frame_register_unwind (next_frame
, regnum
,
675 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
680 *lvalp
= lval_memory
;
681 *addrp
= execute_stack_op (cache
->reg
[regnum
].loc
.exp
,
682 cache
->reg
[regnum
].exp_len
,
683 next_frame
, cache
->cfa
);
687 /* Read the value in from memory. */
688 read_memory (*addrp
, valuep
,
689 register_size (current_gdbarch
, regnum
));
694 frame_register_unwind (next_frame
, regnum
,
695 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
699 internal_error (__FILE__
, __LINE__
, "Unknown register rule.");
703 static const struct frame_unwind dwarf2_frame_unwind
=
706 dwarf2_frame_this_id
,
707 dwarf2_frame_prev_register
710 const struct frame_unwind
*
711 dwarf2_frame_p (CORE_ADDR pc
)
713 /* The way GDB works, this function can be called with PC just after
714 the last instruction of the function we're supposed to return the
715 unwind methods for. In that case we won't find the correct FDE;
716 instead we find the FDE for the next function, or we won't find
717 an FDE at all. There is a possible solution (see the comment in
718 dwarf2_frame_cache), GDB doesn't pass us enough information to
720 if (dwarf2_frame_find_fde (&pc
))
721 return &dwarf2_frame_unwind
;
727 /* There is no explicitly defined relationship between the CFA and the
728 location of frame's local variables and arguments/parameters.
729 Therefore, frame base methods on this page should probably only be
730 used as a last resort, just to avoid printing total garbage as a
731 response to the "info frame" command. */
734 dwarf2_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
736 struct dwarf2_frame_cache
*cache
=
737 dwarf2_frame_cache (next_frame
, this_cache
);
742 static const struct frame_base dwarf2_frame_base
=
744 &dwarf2_frame_unwind
,
745 dwarf2_frame_base_address
,
746 dwarf2_frame_base_address
,
747 dwarf2_frame_base_address
750 const struct frame_base
*
751 dwarf2_frame_base_p (CORE_ADDR pc
)
753 if (dwarf2_frame_find_fde (&pc
))
754 return &dwarf2_frame_base
;
759 /* A minimal decoding of DWARF2 compilation units. We only decode
760 what's needed to get to the call frame information. */
764 /* Keep the bfd convenient. */
767 struct objfile
*objfile
;
769 /* Linked list of CIEs for this object. */
770 struct dwarf2_cie
*cie
;
772 /* Address size for this unit - from unit header. */
773 unsigned char addr_size
;
775 /* Pointer to the .debug_frame section loaded into memory. */
776 char *dwarf_frame_buffer
;
778 /* Length of the loaded .debug_frame section. */
779 unsigned long dwarf_frame_size
;
781 /* Pointer to the .debug_frame section. */
782 asection
*dwarf_frame_section
;
784 /* Base for DW_EH_PE_datarel encodings. */
789 read_1_byte (bfd
*bfd
, char *buf
)
791 return bfd_get_8 (abfd
, (bfd_byte
*) buf
);
795 read_4_bytes (bfd
*abfd
, char *buf
)
797 return bfd_get_32 (abfd
, (bfd_byte
*) buf
);
801 read_8_bytes (bfd
*abfd
, char *buf
)
803 return bfd_get_64 (abfd
, (bfd_byte
*) buf
);
807 read_unsigned_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
810 unsigned int num_read
;
820 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
823 result
|= ((byte
& 0x7f) << shift
);
828 *bytes_read_ptr
= num_read
;
834 read_signed_leb128 (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
838 unsigned int num_read
;
847 byte
= bfd_get_8 (abfd
, (bfd_byte
*) buf
);
850 result
|= ((byte
& 0x7f) << shift
);
855 if ((shift
< 32) && (byte
& 0x40))
856 result
|= -(1 << shift
);
858 *bytes_read_ptr
= num_read
;
864 read_initial_length (bfd
*abfd
, char *buf
, unsigned int *bytes_read_ptr
)
868 result
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
869 if (result
== 0xffffffff)
871 result
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
872 *bytes_read_ptr
= 12;
881 /* Pointer encoding helper functions. */
883 /* GCC supports exception handling based on DWARF2 CFI. However, for
884 technical reasons, it encodes addresses in its FDE's in a different
885 way. Several "pointer encodings" are supported. The encoding
886 that's used for a particular FDE is determined by the 'R'
887 augmentation in the associated CIE. The argument of this
888 augmentation is a single byte.
890 The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
891 LEB128. This is encoded in bits 0, 1 and 2. Bit 3 encodes whether
892 the address is signed or unsigned. Bits 4, 5 and 6 encode how the
893 address should be interpreted (absolute, relative to the current
894 position in the FDE, ...). Bit 7, indicates that the address
895 should be dereferenced. */
898 encoding_for_size (unsigned int size
)
903 return DW_EH_PE_udata2
;
905 return DW_EH_PE_udata4
;
907 return DW_EH_PE_udata8
;
909 internal_error (__FILE__
, __LINE__
, "Unsupported address size");
914 size_of_encoded_value (unsigned char encoding
)
916 if (encoding
== DW_EH_PE_omit
)
919 switch (encoding
& 0x07)
921 case DW_EH_PE_absptr
:
922 return TYPE_LENGTH (builtin_type_void_data_ptr
);
923 case DW_EH_PE_udata2
:
925 case DW_EH_PE_udata4
:
927 case DW_EH_PE_udata8
:
930 internal_error (__FILE__
, __LINE__
, "Invalid or unsupported encoding");
935 read_encoded_value (struct comp_unit
*unit
, unsigned char encoding
,
936 char *buf
, unsigned int *bytes_read_ptr
)
940 /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
942 if (encoding
& DW_EH_PE_indirect
)
943 internal_error (__FILE__
, __LINE__
,
944 "Unsupported encoding: DW_EH_PE_indirect");
946 switch (encoding
& 0x70)
948 case DW_EH_PE_absptr
:
952 base
= bfd_get_section_vma (unit
->bfd
, unit
->dwarf_frame_section
);
953 base
+= (buf
- unit
->dwarf_frame_buffer
);
955 case DW_EH_PE_datarel
:
959 internal_error (__FILE__
, __LINE__
, "Invalid or unsupported encoding");
962 if ((encoding
& 0x0f) == 0x00)
963 encoding
|= encoding_for_size (TYPE_LENGTH(builtin_type_void_data_ptr
));
965 switch (encoding
& 0x0f)
967 case DW_EH_PE_udata2
:
969 return (base
+ bfd_get_16 (unit
->abfd
, (bfd_byte
*) buf
));
970 case DW_EH_PE_udata4
:
972 return (base
+ bfd_get_32 (unit
->abfd
, (bfd_byte
*) buf
));
973 case DW_EH_PE_udata8
:
975 return (base
+ bfd_get_64 (unit
->abfd
, (bfd_byte
*) buf
));
976 case DW_EH_PE_sdata2
:
978 return (base
+ bfd_get_signed_16 (unit
->abfd
, (bfd_byte
*) buf
));
979 case DW_EH_PE_sdata4
:
981 return (base
+ bfd_get_signed_32 (unit
->abfd
, (bfd_byte
*) buf
));
982 case DW_EH_PE_sdata8
:
984 return (base
+ bfd_get_signed_64 (unit
->abfd
, (bfd_byte
*) buf
));
986 internal_error (__FILE__
, __LINE__
, "Invalid or unsupported encoding");
991 /* GCC uses a single CIE for all FDEs in a .debug_frame section.
992 That's why we use a simple linked list here. */
994 static struct dwarf2_cie
*
995 find_cie (struct comp_unit
*unit
, ULONGEST cie_pointer
)
997 struct dwarf2_cie
*cie
= unit
->cie
;
1001 if (cie
->cie_pointer
== cie_pointer
)
1011 add_cie (struct comp_unit
*unit
, struct dwarf2_cie
*cie
)
1013 cie
->next
= unit
->cie
;
1017 /* Find the FDE for *PC. Return a pointer to the FDE, and store the
1018 inital location associated with it into *PC. */
1020 static struct dwarf2_fde
*
1021 dwarf2_frame_find_fde (CORE_ADDR
*pc
)
1023 struct objfile
*objfile
;
1025 ALL_OBJFILES (objfile
)
1027 struct dwarf2_fde
*fde
;
1030 offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1032 fde
= objfile
->sym_private
;
1035 if (*pc
>= fde
->initial_location
+ offset
1036 && *pc
< fde
->initial_location
+ offset
+ fde
->address_range
)
1038 *pc
= fde
->initial_location
+ offset
;
1050 add_fde (struct comp_unit
*unit
, struct dwarf2_fde
*fde
)
1052 fde
->next
= unit
->objfile
->sym_private
;
1053 unit
->objfile
->sym_private
= fde
;
1056 #ifdef CC_HAS_LONG_LONG
1057 #define DW64_CIE_ID 0xffffffffffffffffULL
1059 #define DW64_CIE_ID ~0
1062 static char *decode_frame_entry (struct comp_unit
*unit
, char *start
,
1065 /* Decode the next CIE or FDE. Return NULL if invalid input, otherwise
1066 the next byte to be processed. */
1068 decode_frame_entry_1 (struct comp_unit
*unit
, char *start
, int eh_frame_p
)
1072 unsigned int bytes_read
;
1075 ULONGEST cie_pointer
;
1079 length
= read_initial_length (unit
->abfd
, buf
, &bytes_read
);
1083 /* Are we still within the section? */
1084 if (end
> unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
)
1090 /* Distinguish between 32 and 64-bit encoded frame info. */
1091 dwarf64_p
= (bytes_read
== 12);
1093 /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs. */
1097 cie_id
= DW64_CIE_ID
;
1103 cie_pointer
= read_8_bytes (unit
->abfd
, buf
);
1108 cie_pointer
= read_4_bytes (unit
->abfd
, buf
);
1112 if (cie_pointer
== cie_id
)
1114 /* This is a CIE. */
1115 struct dwarf2_cie
*cie
;
1118 /* Record the offset into the .debug_frame section of this CIE. */
1119 cie_pointer
= start
- unit
->dwarf_frame_buffer
;
1121 /* Check whether we've already read it. */
1122 if (find_cie (unit
, cie_pointer
))
1125 cie
= (struct dwarf2_cie
*)
1126 obstack_alloc (&unit
->objfile
->psymbol_obstack
,
1127 sizeof (struct dwarf2_cie
));
1128 cie
->initial_instructions
= NULL
;
1129 cie
->cie_pointer
= cie_pointer
;
1131 /* The encoding for FDE's in a normal .debug_frame section
1132 depends on the target address size as specified in the
1133 Compilation Unit Header. */
1134 cie
->encoding
= encoding_for_size (unit
->addr_size
);
1136 /* Check version number. */
1137 if (read_1_byte (unit
->abfd
, buf
) != DW_CIE_VERSION
)
1141 /* Interpret the interesting bits of the augmentation. */
1143 buf
= augmentation
+ strlen (augmentation
) + 1;
1145 /* The GCC 2.x "eh" augmentation has a pointer immediately
1146 following the augmentation string, so it must be handled
1148 if (augmentation
[0] == 'e' && augmentation
[1] == 'h')
1151 buf
+= TYPE_LENGTH (builtin_type_void_data_ptr
);
1155 cie
->code_alignment_factor
=
1156 read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1159 cie
->data_alignment_factor
=
1160 read_signed_leb128 (unit
->abfd
, buf
, &bytes_read
);
1163 cie
->return_address_register
= read_1_byte (unit
->abfd
, buf
);
1166 cie
->saw_z_augmentation
= (*augmentation
== 'z');
1167 if (cie
->saw_z_augmentation
)
1171 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1175 cie
->initial_instructions
= buf
+ length
;
1179 while (*augmentation
)
1181 /* "L" indicates a byte showing how the LSDA pointer is encoded. */
1182 if (*augmentation
== 'L')
1189 /* "R" indicates a byte indicating how FDE addresses are encoded. */
1190 else if (*augmentation
== 'R')
1192 cie
->encoding
= *buf
++;
1196 /* "P" indicates a personality routine in the CIE augmentation. */
1197 else if (*augmentation
== 'P')
1200 buf
+= size_of_encoded_value (*buf
++);
1204 /* Otherwise we have an unknown augmentation.
1205 Bail out unless we saw a 'z' prefix. */
1208 if (cie
->initial_instructions
== NULL
)
1211 /* Skip unknown augmentations. */
1212 buf
= cie
->initial_instructions
;
1217 cie
->initial_instructions
= buf
;
1220 add_cie (unit
, cie
);
1224 /* This is a FDE. */
1225 struct dwarf2_fde
*fde
;
1227 /* In an .eh_frame section, the CIE pointer is the delta between the
1228 address within the FDE where the CIE pointer is stored and the
1229 address of the CIE. Convert it to an offset into the .eh_frame
1233 cie_pointer
= buf
- unit
->dwarf_frame_buffer
- cie_pointer
;
1234 cie_pointer
-= (dwarf64_p
? 8 : 4);
1237 /* In either case, validate the result is still within the section. */
1238 if (cie_pointer
>= unit
->dwarf_frame_size
)
1241 fde
= (struct dwarf2_fde
*)
1242 obstack_alloc (&unit
->objfile
->psymbol_obstack
,
1243 sizeof (struct dwarf2_fde
));
1244 fde
->cie
= find_cie (unit
, cie_pointer
);
1245 if (fde
->cie
== NULL
)
1247 decode_frame_entry (unit
, unit
->dwarf_frame_buffer
+ cie_pointer
,
1249 fde
->cie
= find_cie (unit
, cie_pointer
);
1252 gdb_assert (fde
->cie
!= NULL
);
1254 fde
->initial_location
=
1255 read_encoded_value (unit
, fde
->cie
->encoding
, buf
, &bytes_read
);
1258 fde
->address_range
=
1259 read_encoded_value (unit
, fde
->cie
->encoding
& 0x0f, buf
, &bytes_read
);
1262 /* A 'z' augmentation in the CIE implies the presence of an
1263 augmentation field in the FDE as well. The only thing known
1264 to be in here at present is the LSDA entry for EH. So we
1265 can skip the whole thing. */
1266 if (fde
->cie
->saw_z_augmentation
)
1270 length
= read_unsigned_leb128 (unit
->abfd
, buf
, &bytes_read
);
1271 buf
+= bytes_read
+ length
;
1276 fde
->instructions
= buf
;
1279 add_fde (unit
, fde
);
1285 /* Read a CIE or FDE in BUF and decode it. */
1287 decode_frame_entry (struct comp_unit
*unit
, char *start
, int eh_frame_p
)
1289 enum { NONE
, ALIGN4
, ALIGN8
, FAIL
} workaround
= NONE
;
1292 ptrdiff_t start_offset
;
1296 ret
= decode_frame_entry_1 (unit
, start
, eh_frame_p
);
1300 /* We have corrupt input data of some form. */
1302 /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1303 and mismatches wrt padding and alignment of debug sections. */
1304 /* Note that there is no requirement in the standard for any
1305 alignment at all in the frame unwind sections. Testing for
1306 alignment before trying to interpret data would be incorrect.
1308 However, GCC traditionally arranged for frame sections to be
1309 sized such that the FDE length and CIE fields happen to be
1310 aligned (in theory, for performance). This, unfortunately,
1311 was done with .align directives, which had the side effect of
1312 forcing the section to be aligned by the linker.
1314 This becomes a problem when you have some other producer that
1315 creates frame sections that are not as strictly aligned. That
1316 produces a hole in the frame info that gets filled by the
1319 The GCC behaviour is arguably a bug, but it's effectively now
1320 part of the ABI, so we're now stuck with it, at least at the
1321 object file level. A smart linker may decide, in the process
1322 of compressing duplicate CIE information, that it can rewrite
1323 the entire output section without this extra padding. */
1325 start_offset
= start
- unit
->dwarf_frame_buffer
;
1326 if (workaround
< ALIGN4
&& (start_offset
& 3) != 0)
1328 start
+= 4 - (start_offset
& 3);
1329 workaround
= ALIGN4
;
1332 if (workaround
< ALIGN8
&& (start_offset
& 7) != 0)
1334 start
+= 8 - (start_offset
& 7);
1335 workaround
= ALIGN8
;
1339 /* Nothing left to try. Arrange to return as if we've consumed
1340 the entire input section. Hopefully we'll get valid info from
1341 the other of .debug_frame/.eh_frame. */
1343 ret
= unit
->dwarf_frame_buffer
+ unit
->dwarf_frame_size
;
1353 complaint (&symfile_complaints
,
1354 "Corrupt data in %s:%s; align 4 workaround apparently succeeded",
1355 unit
->dwarf_frame_section
->owner
->filename
,
1356 unit
->dwarf_frame_section
->name
);
1360 complaint (&symfile_complaints
,
1361 "Corrupt data in %s:%s; align 8 workaround apparently succeeded",
1362 unit
->dwarf_frame_section
->owner
->filename
,
1363 unit
->dwarf_frame_section
->name
);
1367 complaint (&symfile_complaints
,
1368 "Corrupt data in %s:%s",
1369 unit
->dwarf_frame_section
->owner
->filename
,
1370 unit
->dwarf_frame_section
->name
);
1379 /* FIXME: kettenis/20030504: This still needs to be integrated with
1380 dwarf2read.c in a better way. */
1382 /* Imported from dwarf2read.c. */
1383 extern file_ptr dwarf_frame_offset
;
1384 extern unsigned int dwarf_frame_size
;
1385 extern asection
*dwarf_frame_section
;
1386 extern file_ptr dwarf_eh_frame_offset
;
1387 extern unsigned int dwarf_eh_frame_size
;
1388 extern asection
*dwarf_eh_frame_section
;
1390 /* Imported from dwarf2read.c. */
1391 extern char *dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
1392 unsigned int size
, asection
*sectp
);
1395 dwarf2_build_frame_info (struct objfile
*objfile
)
1397 struct comp_unit unit
;
1400 /* Build a minimal decoding of the DWARF2 compilation unit. */
1401 unit
.abfd
= objfile
->obfd
;
1402 unit
.objfile
= objfile
;
1403 unit
.addr_size
= objfile
->obfd
->arch_info
->bits_per_address
/ 8;
1406 /* First add the information from the .eh_frame section. That way,
1407 the FDEs from that section are searched last. */
1408 if (dwarf_eh_frame_offset
)
1413 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1414 dwarf_eh_frame_offset
,
1415 dwarf_eh_frame_size
,
1416 dwarf_eh_frame_section
);
1418 unit
.dwarf_frame_size
= dwarf_eh_frame_size
;
1419 unit
.dwarf_frame_section
= dwarf_eh_frame_section
;
1421 /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
1422 that for the i386/amd64 target, which currently is the only
1423 target in GCC that supports/uses the DW_EH_PE_datarel
1425 got
= bfd_get_section_by_name (unit
.abfd
, ".got");
1427 unit
.dbase
= got
->vma
;
1429 frame_ptr
= unit
.dwarf_frame_buffer
;
1430 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1431 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 1);
1434 if (dwarf_frame_offset
)
1437 unit
.dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1440 dwarf_frame_section
);
1441 unit
.dwarf_frame_size
= dwarf_frame_size
;
1442 unit
.dwarf_frame_section
= dwarf_frame_section
;
1444 frame_ptr
= unit
.dwarf_frame_buffer
;
1445 while (frame_ptr
< unit
.dwarf_frame_buffer
+ unit
.dwarf_frame_size
)
1446 frame_ptr
= decode_frame_entry (&unit
, frame_ptr
, 0);