1 /* Stack unwinding code based on dwarf2 frame info for GDB, the GNU debugger.
2 Copyright 2001, 2002 Free Software Foundation, Inc.
3 Contributed by Jiri Smid, SuSE Labs.
4 Based on code written by Daniel Berlin (dan@dberlin.org).
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
28 #include "elf/dwarf2.h"
31 #include "dwarf2cfi.h"
33 /* Common Information Entry - holds information that is shared among many
37 /* Offset of this unit in dwarf_frame_buffer. */
40 /* A null-terminated string that identifies the augmentation to this CIE or
41 to the FDEs that use it. */
44 /* A constant that is factored out of all advance location instructions. */
45 unsigned int code_align
;
47 /* A constant that is factored out of all offset instructions. */
50 /* A constant that indicates which regiter represents the return address
54 /* Indicates how addresses are encoded. */
55 unsigned char addr_encoding
;
57 /* Pointer and length of the cie program. */
59 unsigned int data_length
;
61 struct objfile
*objfile
;
64 struct cie_unit
*next
;
67 /* Frame Description Entry. */
70 /* Address of the first location associated with this entry. */
71 CORE_ADDR initial_location
;
73 /* Length of program section described by this entry. */
74 CORE_ADDR address_range
;
76 /* Pointer to asociated CIE. */
77 struct cie_unit
*cie_ptr
;
79 /* Pointer and length of the cie program. */
81 unsigned int data_length
;
86 struct fde_unit
**array
;
103 REG_CTX_SAVED_OFFSET
,
111 /* This is the register and unwind state for a particular frame. */
114 struct context_reg
*reg
;
122 struct frame_state_reg
143 /* Each register save state can be described in terms of a CFA slot,
144 another register, or a location expression. */
145 struct frame_state_regs
147 struct frame_state_reg
*reg
;
149 /* Used to implement DW_CFA_remember_state. */
150 struct frame_state_regs
*prev
;
154 /* The CFA can be described in terms of a reg+offset or a
155 location expression. */
158 unsigned char *cfa_exp
;
167 /* The PC described by the current frame state. */
170 /* The information we care about from the CIE/FDE. */
172 unsigned int code_align
;
173 unsigned char retaddr_column
;
174 unsigned char addr_encoding
;
176 struct objfile
*objfile
;
179 #define UNWIND_CONTEXT(fi) ((struct context *) (fi->context))
182 static struct cie_unit
*cie_chunks
;
183 static struct fde_array fde_chunks
;
184 /* Obstack for allocating temporary storage used during unwind operations. */
185 static struct obstack unwind_tmp_obstack
;
187 extern file_ptr dwarf_frame_offset
;
188 extern unsigned int dwarf_frame_size
;
189 extern file_ptr dwarf_eh_frame_offset
;
190 extern unsigned int dwarf_eh_frame_size
;
192 static char *dwarf_frame_buffer
;
195 extern char *dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
198 static struct fde_unit
*fde_unit_alloc (void);
199 static struct cie_unit
*cie_unit_alloc (void);
200 static void fde_chunks_need_space ();
202 static struct context
*context_alloc ();
203 static struct frame_state
*frame_state_alloc ();
204 static void unwind_tmp_obstack_init ();
205 static void unwind_tmp_obstack_free ();
206 static void context_cpy (struct context
*dst
, struct context
*src
);
208 static unsigned int read_1u (bfd
*abfd
, char **p
);
209 static int read_1s (bfd
*abfd
, char **p
);
210 static unsigned int read_2u (bfd
*abfd
, char **p
);
211 static int read_2s (bfd
*abfd
, char **p
);
212 static unsigned int read_4u (bfd
*abfd
, char **p
);
213 static int read_4s (bfd
*abfd
, char **p
);
214 static ULONGEST
read_8u (bfd
*abfd
, char **p
);
215 static LONGEST
read_8s (bfd
*abfd
, char **p
);
217 static ULONGEST
read_uleb128 (bfd
*abfd
, char **p
);
218 static LONGEST
read_sleb128 (bfd
*abfd
, char **p
);
219 static CORE_ADDR
read_pointer (bfd
*abfd
, char **p
);
220 static CORE_ADDR
read_encoded_pointer (bfd
*abfd
, char **p
,
221 unsigned char encoding
);
223 static LONGEST
read_initial_length (bfd
*abfd
, char *buf
, int *bytes_read
);
224 static ULONGEST
read_length (bfd
*abfd
, char *buf
, int *bytes_read
,
227 static int is_cie (ULONGEST cie_id
, int dwarf64
);
228 static int compare_fde_unit (const void *a
, const void *b
);
229 void dwarf2_build_frame_info (struct objfile
*objfile
);
231 static void execute_cfa_program (struct objfile
*objfile
, char *insn_ptr
,
232 char *insn_end
, struct context
*context
,
233 struct frame_state
*fs
);
234 static struct fde_unit
*get_fde_for_addr (CORE_ADDR pc
);
235 static void frame_state_for (struct context
*context
, struct frame_state
*fs
);
236 static void get_reg (char *reg
, struct context
*context
, int regnum
);
237 static CORE_ADDR
execute_stack_op (struct objfile
*objfile
,
238 char *op_ptr
, char *op_end
,
239 struct context
*context
, CORE_ADDR initial
);
240 static void update_context (struct context
*context
, struct frame_state
*fs
,
244 /* Memory allocation functions. */
245 static struct fde_unit
*
246 fde_unit_alloc (void)
248 struct fde_unit
*fde
;
250 fde
= (struct fde_unit
*) xmalloc (sizeof (struct fde_unit
));
251 memset (fde
, 0, sizeof (struct fde_unit
));
255 static struct cie_unit
*
256 cie_unit_alloc (void)
258 struct cie_unit
*cie
;
260 cie
= (struct cie_unit
*) xmalloc (sizeof (struct cie_unit
));
261 memset (cie
, 0, sizeof (struct cie_unit
));
266 fde_chunks_need_space ()
268 if (fde_chunks
.elems
< fde_chunks
.array_size
)
270 fde_chunks
.array_size
=
271 fde_chunks
.array_size
? 2 * fde_chunks
.array_size
: 1024;
273 xrealloc (fde_chunks
.array
,
274 sizeof (struct fde_unit
) * fde_chunks
.array_size
);
277 /* Alocate a new `struct context' on temporary obstack. */
278 static struct context
*
281 struct context
*context
;
283 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
285 context
= (struct context
*) obstack_alloc (&unwind_tmp_obstack
,
286 sizeof (struct context
));
287 memset (context
, 0, sizeof (struct context
));
288 context
->reg
= (struct context_reg
*) obstack_alloc (&unwind_tmp_obstack
,
290 memset (context
->reg
, 0, regs_size
);
294 /* Alocate a new `struct frame_state' on temporary obstack. */
295 static struct frame_state
*
298 struct frame_state
*fs
;
300 int regs_size
= sizeof (struct frame_state_reg
) * NUM_REGS
;
302 fs
= (struct frame_state
*) obstack_alloc (&unwind_tmp_obstack
,
303 sizeof (struct frame_state
));
304 memset (fs
, 0, sizeof (struct frame_state
));
305 fs
->regs
.reg
= (struct frame_state_reg
*) obstack_alloc (&unwind_tmp_obstack
,
307 memset (fs
->regs
.reg
, 0, regs_size
);
312 unwind_tmp_obstack_init ()
314 obstack_init (&unwind_tmp_obstack
);
318 unwind_tmp_obstack_free ()
320 obstack_free (&unwind_tmp_obstack
, NULL
);
321 unwind_tmp_obstack_init ();
325 context_cpy (struct context
*dst
, struct context
*src
)
327 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
328 struct context_reg
*dreg
;
330 /* Structure dst contains a pointer to an array of
331 * registers of a given frame as well as src does. This
332 * array was already allocated before dst was passed to
333 * context_cpy but the pointer to it was overriden by
334 * '*dst = *src' and the array was lost. This led to the
335 * situation, that we've had a copy of src placed in dst,
336 * but both of them pointed to the same regs array and
337 * thus we've sometimes blindly rewritten it. Now we save
338 * the pointer before copying src to dst, return it back
339 * after that and copy the registers into their new place
340 * finally. --- mludvig@suse.cz */
345 memcpy (dst
->reg
, src
->reg
, regs_size
);
349 read_1u (bfd
*abfd
, char **p
)
353 ret
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
359 read_1s (bfd
*abfd
, char **p
)
363 ret
= bfd_get_signed_8 (abfd
, (bfd_byte
*) *p
);
369 read_2u (bfd
*abfd
, char **p
)
373 ret
= bfd_get_16 (abfd
, (bfd_byte
*) *p
);
379 read_2s (bfd
*abfd
, char **p
)
383 ret
= bfd_get_signed_16 (abfd
, (bfd_byte
*) *p
);
389 read_4u (bfd
*abfd
, char **p
)
393 ret
= bfd_get_32 (abfd
, (bfd_byte
*) *p
);
399 read_4s (bfd
*abfd
, char **p
)
403 ret
= bfd_get_signed_32 (abfd
, (bfd_byte
*) *p
);
409 read_8u (bfd
*abfd
, char **p
)
413 ret
= bfd_get_64 (abfd
, (bfd_byte
*) *p
);
419 read_8s (bfd
*abfd
, char **p
)
423 ret
= bfd_get_signed_64 (abfd
, (bfd_byte
*) *p
);
429 read_uleb128 (bfd
*abfd
, char **p
)
440 byte
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
442 ret
|= ((unsigned long) (byte
& 127) << shift
);
443 if ((byte
& 128) == 0)
453 read_sleb128 (bfd
*abfd
, char **p
)
456 int i
, shift
, size
, num_read
;
466 byte
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
468 ret
|= ((long) (byte
& 127) << shift
);
470 if ((byte
& 128) == 0)
475 if ((shift
< size
) && (byte
& 0x40))
477 ret
|= -(1 << shift
);
483 read_pointer (bfd
*abfd
, char **p
)
485 switch (TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
)
488 return read_4u (abfd
, p
);
490 return read_8u (abfd
, p
);
492 error ("dwarf cfi error: unsupported target address length.");
497 read_encoded_pointer (bfd
*abfd
, char **p
, unsigned char encoding
)
501 switch (encoding
& 0x0f)
503 case DW_EH_PE_absptr
:
504 ret
= read_pointer (abfd
, p
);
507 case DW_EH_PE_uleb128
:
508 ret
= read_uleb128 (abfd
, p
);
510 case DW_EH_PE_sleb128
:
511 ret
= read_sleb128 (abfd
, p
);
514 case DW_EH_PE_udata2
:
515 ret
= read_2u (abfd
, p
);
517 case DW_EH_PE_udata4
:
518 ret
= read_4u (abfd
, p
);
520 case DW_EH_PE_udata8
:
521 ret
= read_8u (abfd
, p
);
524 case DW_EH_PE_sdata2
:
525 ret
= read_2s (abfd
, p
);
527 case DW_EH_PE_sdata4
:
528 ret
= read_4s (abfd
, p
);
530 case DW_EH_PE_sdata8
:
531 ret
= read_8s (abfd
, p
);
535 internal_error (__FILE__
, __LINE__
,
536 "read_encoded_pointer: unknown pointer encoding");
540 switch (encoding
& 0xf0)
542 case DW_EH_PE_absptr
:
545 ret
+= (CORE_ADDR
) *p
;
547 case DW_EH_PE_textrel
:
548 case DW_EH_PE_datarel
:
549 case DW_EH_PE_funcrel
:
551 internal_error (__FILE__
, __LINE__
,
552 "read_encoded_pointer: unknown pointer encoding");
559 read_initial_length (bfd
* abfd
, char *buf
, int *bytes_read
)
563 ret
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
565 if (ret
== 0xffffffff)
567 ret
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
579 read_length (bfd
* abfd
, char *buf
, int *bytes_read
, int dwarf64
)
584 return read_8u (abfd
, &buf
);
589 return read_4u (abfd
, &buf
);
594 execute_cfa_program ( struct objfile
*objfile
, char *insn_ptr
, char *insn_end
,
595 struct context
*context
, struct frame_state
*fs
)
597 struct frame_state_regs
*unused_rs
= NULL
;
599 /* Don't allow remember/restore between CIE and FDE programs. */
600 fs
->regs
.prev
= NULL
;
602 while (insn_ptr
< insn_end
&& fs
->pc
< context
->ra
)
604 unsigned char insn
= *insn_ptr
++;
605 ULONGEST reg
, uoffset
;
608 if (insn
& DW_CFA_advance_loc
)
609 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
610 else if (insn
& DW_CFA_offset
)
613 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
614 offset
= (long) uoffset
* fs
->data_align
;
615 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
616 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
618 else if (insn
& DW_CFA_restore
)
621 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
627 fs
->pc
= read_encoded_pointer (objfile
->obfd
, &insn_ptr
,
631 case DW_CFA_advance_loc1
:
632 fs
->pc
+= read_1u (objfile
->obfd
, &insn_ptr
);
634 case DW_CFA_advance_loc2
:
635 fs
->pc
+= read_2u (objfile
->obfd
, &insn_ptr
);
637 case DW_CFA_advance_loc4
:
638 fs
->pc
+= read_4u (objfile
->obfd
, &insn_ptr
);
641 case DW_CFA_offset_extended
:
642 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
643 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
644 offset
= (long) uoffset
*fs
->data_align
;
645 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
646 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
649 case DW_CFA_restore_extended
:
650 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
651 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
654 case DW_CFA_undefined
:
655 case DW_CFA_same_value
:
659 case DW_CFA_register
:
662 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
663 reg2
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
664 fs
->regs
.reg
[reg
].how
= REG_SAVED_REG
;
665 fs
->regs
.reg
[reg
].loc
.reg
= reg2
;
669 case DW_CFA_remember_state
:
671 struct frame_state_regs
*new_rs
;
675 unused_rs
= unused_rs
->prev
;
678 new_rs
= xmalloc (sizeof (struct frame_state_regs
));
681 fs
->regs
.prev
= new_rs
;
685 case DW_CFA_restore_state
:
687 struct frame_state_regs
*old_rs
= fs
->regs
.prev
;
689 old_rs
->prev
= unused_rs
;
695 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
696 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
698 fs
->cfa_offset
= uoffset
;
699 fs
->cfa_how
= CFA_REG_OFFSET
;
702 case DW_CFA_def_cfa_register
:
703 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
705 fs
->cfa_how
= CFA_REG_OFFSET
;
708 case DW_CFA_def_cfa_offset
:
709 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
710 fs
->cfa_offset
= uoffset
;
713 case DW_CFA_def_cfa_expression
:
714 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
715 fs
->cfa_exp
= insn_ptr
;
716 fs
->cfa_how
= CFA_EXP
;
720 case DW_CFA_expression
:
721 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
722 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
723 fs
->regs
.reg
[reg
].how
= REG_SAVED_EXP
;
724 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
728 /* From the 2.1 draft. */
729 case DW_CFA_offset_extended_sf
:
730 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
731 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
732 offset
*= fs
->data_align
;
733 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
734 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
737 case DW_CFA_def_cfa_sf
:
738 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
739 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
740 fs
->cfa_offset
= offset
;
742 fs
->cfa_how
= CFA_REG_OFFSET
;
745 case DW_CFA_def_cfa_offset_sf
:
746 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
747 fs
->cfa_offset
= uoffset
;
748 /* cfa_how deliberately not set. */
751 case DW_CFA_GNU_window_save
:
752 /* ??? Hardcoded for SPARC register window configuration. */
753 for (reg
= 16; reg
< 32; ++reg
)
755 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
756 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * sizeof (void *);
760 case DW_CFA_GNU_args_size
:
761 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
762 context
->args_size
= uoffset
;
765 case DW_CFA_GNU_negative_offset_extended
:
766 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
767 older PowerPC code. */
768 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
769 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
770 offset
= (long) uoffset
*fs
->data_align
;
771 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
772 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
776 error ("dwarf cfi error: unknown cfa instruction %d.", insn
);
781 static struct fde_unit
*
782 get_fde_for_addr (CORE_ADDR pc
)
785 struct fde_unit
*fde
= NULL
;
787 hi
= fde_chunks
.elems
;
791 size_t i
= (lo
+ hi
) / 2;
792 fde
= fde_chunks
.array
[i
];
793 if (pc
< fde
->initial_location
)
795 else if (pc
>= fde
->initial_location
+ fde
->address_range
)
804 frame_state_for (struct context
*context
, struct frame_state
*fs
)
806 struct fde_unit
*fde
;
807 struct cie_unit
*cie
;
809 context
->args_size
= 0;
812 fde
= get_fde_for_addr (context
->ra
- 1);
817 fs
->pc
= fde
->initial_location
;
823 fs
->code_align
= cie
->code_align
;
824 fs
->data_align
= cie
->data_align
;
825 fs
->retaddr_column
= cie
->ra
;
826 fs
->addr_encoding
= cie
->addr_encoding
;
827 fs
->objfile
= cie
->objfile
;
829 execute_cfa_program (cie
->objfile
, cie
->data
,
830 cie
->data
+ cie
->data_length
, context
, fs
);
831 execute_cfa_program (cie
->objfile
, fde
->data
,
832 fde
->data
+ fde
->data_length
, context
, fs
);
835 internal_error (__FILE__
, __LINE__
,
836 "%s(): Internal error: fde->cie_ptr==NULL !",
841 get_reg (char *reg
, struct context
*context
, int regnum
)
843 switch (context
->reg
[regnum
].how
)
845 case REG_CTX_UNSAVED
:
846 read_register_gen (regnum
, reg
);
848 case REG_CTX_SAVED_OFFSET
:
849 target_read_memory (context
->cfa
+ context
->reg
[regnum
].loc
.offset
,
850 reg
, REGISTER_RAW_SIZE (regnum
));
852 case REG_CTX_SAVED_REG
:
853 read_register_gen (context
->reg
[regnum
].loc
.reg
, reg
);
855 case REG_CTX_SAVED_ADDR
:
856 target_read_memory (context
->reg
[regnum
].loc
.addr
,
857 reg
, REGISTER_RAW_SIZE (regnum
));
860 memcpy (reg
, &context
->reg
[regnum
].loc
.addr
,
861 REGISTER_RAW_SIZE (regnum
));
864 internal_error (__FILE__
, __LINE__
,
865 "get_reg: unknown register rule");
869 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
870 onto the stack to start. */
872 execute_stack_op (struct objfile
*objfile
,
873 char *op_ptr
, char *op_end
, struct context
*context
,
876 CORE_ADDR stack
[64]; /* ??? Assume this is enough. */
882 while (op_ptr
< op_end
)
884 enum dwarf_location_atom op
= *op_ptr
++;
923 result
= op
- DW_OP_lit0
;
927 result
= read_pointer (objfile
->obfd
, &op_ptr
);
931 result
= read_1u (objfile
->obfd
, &op_ptr
);
934 result
= read_1s (objfile
->obfd
, &op_ptr
);
937 result
= read_2u (objfile
->obfd
, &op_ptr
);
940 result
= read_2s (objfile
->obfd
, &op_ptr
);
943 result
= read_4u (objfile
->obfd
, &op_ptr
);
946 result
= read_4s (objfile
->obfd
, &op_ptr
);
949 result
= read_8u (objfile
->obfd
, &op_ptr
);
952 result
= read_8s (objfile
->obfd
, &op_ptr
);
955 result
= read_uleb128 (objfile
->obfd
, &op_ptr
);
958 result
= read_sleb128 (objfile
->obfd
, &op_ptr
);
993 get_reg ((char *) &result
, context
, op
- DW_OP_reg0
);
996 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
997 get_reg ((char *) &result
, context
, reg
);
1032 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1033 get_reg ((char *) &result
, context
, op
- DW_OP_breg0
);
1037 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
1038 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1039 get_reg ((char *) &result
, context
, reg
);
1045 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1046 result
= stack
[stack_elt
- 1];
1050 if (--stack_elt
< 0)
1051 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1056 if (offset
>= stack_elt
- 1)
1057 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1058 result
= stack
[stack_elt
- 1 - offset
];
1063 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1064 result
= stack
[stack_elt
- 2];
1069 CORE_ADDR t1
, t2
, t3
;
1072 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1073 t1
= stack
[stack_elt
- 1];
1074 t2
= stack
[stack_elt
- 2];
1075 t3
= stack
[stack_elt
- 3];
1076 stack
[stack_elt
- 1] = t2
;
1077 stack
[stack_elt
- 2] = t3
;
1078 stack
[stack_elt
- 3] = t1
;
1083 case DW_OP_deref_size
:
1087 case DW_OP_plus_uconst
:
1088 /* Unary operations. */
1089 if (--stack_elt
< 0)
1090 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1091 result
= stack
[stack_elt
];
1097 char *ptr
= (char *) result
;
1098 result
= read_pointer (objfile
->obfd
, &ptr
);
1102 case DW_OP_deref_size
:
1104 char *ptr
= (char *) result
;
1108 result
= read_1u (objfile
->obfd
, &ptr
);
1111 result
= read_2u (objfile
->obfd
, &ptr
);
1114 result
= read_4u (objfile
->obfd
, &ptr
);
1117 result
= read_8u (objfile
->obfd
, &ptr
);
1120 internal_error (__FILE__
, __LINE__
,
1121 "execute_stack_op error");
1136 case DW_OP_plus_uconst
:
1137 result
+= read_uleb128 (objfile
->obfd
, &op_ptr
);
1158 /* Binary operations. */
1159 CORE_ADDR first
, second
;
1160 if ((stack_elt
-= 2) < 0)
1161 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1162 second
= stack
[stack_elt
];
1163 first
= stack
[stack_elt
+ 1];
1168 result
= second
& first
;
1171 result
= (LONGEST
) second
/ (LONGEST
) first
;
1174 result
= second
- first
;
1177 result
= (LONGEST
) second
% (LONGEST
) first
;
1180 result
= second
* first
;
1183 result
= second
| first
;
1186 result
= second
+ first
;
1189 result
= second
<< first
;
1192 result
= second
>> first
;
1195 result
= (LONGEST
) second
>> first
;
1198 result
= second
^ first
;
1201 result
= (LONGEST
) first
<= (LONGEST
) second
;
1204 result
= (LONGEST
) first
>= (LONGEST
) second
;
1207 result
= (LONGEST
) first
== (LONGEST
) second
;
1210 result
= (LONGEST
) first
< (LONGEST
) second
;
1213 result
= (LONGEST
) first
> (LONGEST
) second
;
1216 result
= (LONGEST
) first
!= (LONGEST
) second
;
1218 default: /* This label is here just to avoid warning. */
1225 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1230 if (--stack_elt
< 0)
1231 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1232 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1233 if (stack
[stack_elt
] != 0)
1241 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1244 /* Most things push a result value. */
1245 if ((size_t) stack_elt
>= sizeof (stack
) / sizeof (*stack
))
1246 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1247 stack
[++stack_elt
] = result
;
1251 /* We were executing this program to get a value. It should be
1253 if (--stack_elt
< 0)
1254 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1255 return stack
[stack_elt
];
1259 update_context (struct context
*context
, struct frame_state
*fs
, int chain
)
1261 struct context
*orig_context
;
1265 unwind_tmp_obstack_init ();
1267 orig_context
= context_alloc ();
1268 context_cpy (orig_context
, context
);
1270 /* Compute this frame's CFA. */
1271 switch (fs
->cfa_how
)
1273 case CFA_REG_OFFSET
:
1274 get_reg ((char *) &cfa
, context
, fs
->cfa_reg
);
1275 cfa
+= fs
->cfa_offset
;
1279 /* ??? No way of knowing what register number is the stack pointer
1280 to do the same sort of handling as above. Assume that if the
1281 CFA calculation is so complicated as to require a stack program
1282 that this will not be a problem. */
1284 char *exp
= fs
->cfa_exp
;
1287 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1288 cfa
= (CORE_ADDR
) execute_stack_op (fs
->objfile
, exp
,
1289 exp
+ len
, context
, 0);
1298 orig_context
->cfa
= cfa
;
1300 /* Compute the addresses of all registers saved in this frame. */
1301 for (i
= 0; i
< NUM_REGS
; ++i
)
1302 switch (fs
->regs
.reg
[i
].how
)
1307 context
->reg
[i
].how
= REG_CTX_VALUE
;
1308 context
->reg
[i
].loc
.addr
= cfa
;
1311 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1313 case REG_SAVED_OFFSET
:
1314 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1315 context
->reg
[i
].loc
.offset
= fs
->regs
.reg
[i
].loc
.offset
;
1318 switch (orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].how
)
1320 case REG_CTX_UNSAVED
:
1321 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1323 case REG_CTX_SAVED_OFFSET
:
1324 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1325 context
->reg
[i
].loc
.offset
= orig_context
->cfa
- context
->cfa
+
1326 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.offset
;
1328 case REG_CTX_SAVED_REG
:
1329 context
->reg
[i
].how
= REG_CTX_SAVED_REG
;
1330 context
->reg
[i
].loc
.reg
=
1331 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.reg
;
1333 case REG_CTX_SAVED_ADDR
:
1334 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1335 context
->reg
[i
].loc
.addr
=
1336 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.addr
;
1338 internal_error (__FILE__
, __LINE__
,
1339 "%s: unknown register rule", __func__
);
1344 char *exp
= fs
->regs
.reg
[i
].loc
.exp
;
1348 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1349 val
= execute_stack_op (fs
->objfile
, exp
, exp
+ len
,
1351 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1352 context
->reg
[i
].loc
.addr
= val
;
1356 internal_error (__FILE__
, __LINE__
,
1357 "%s: unknown register rule", __func__
);
1359 get_reg ((char *) &context
->ra
, context
, fs
->retaddr_column
);
1360 unwind_tmp_obstack_free ();
1364 is_cie (ULONGEST cie_id
, int dwarf64
)
1366 return dwarf64
? (cie_id
== 0xffffffffffffffff) : (cie_id
== 0xffffffff);
1370 compare_fde_unit (const void *a
, const void *b
)
1372 struct fde_unit
**first
, **second
;
1373 first
= (struct fde_unit
**) a
;
1374 second
= (struct fde_unit
**) b
;
1375 if ((*first
)->initial_location
> (*second
)->initial_location
)
1377 else if ((*first
)->initial_location
< (*second
)->initial_location
)
1383 /* Build the cie_chunks and fde_chunks tables from informations
1384 in .debug_frame section. */
1386 dwarf2_build_frame_info (struct objfile
*objfile
)
1388 bfd
*abfd
= objfile
->obfd
;
1393 unwind_tmp_obstack_init ();
1395 dwarf_frame_buffer
= 0;
1397 if (dwarf_frame_offset
)
1399 dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1403 start
= dwarf_frame_buffer
;
1404 end
= dwarf_frame_buffer
+ dwarf_frame_size
;
1406 else if (dwarf_eh_frame_offset
)
1408 dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1409 dwarf_eh_frame_offset
,
1410 dwarf_eh_frame_size
);
1412 start
= dwarf_frame_buffer
;
1413 end
= dwarf_frame_buffer
+ dwarf_eh_frame_size
;
1422 unsigned long length
;
1424 ULONGEST unit_offset
= start
- dwarf_frame_buffer
;
1429 length
= read_initial_length (abfd
, start
, &bytes_read
);
1430 start
+= bytes_read
;
1431 dwarf64
= (bytes_read
== 12);
1432 block_end
= start
+ length
;
1434 cie_id
= read_length (abfd
, start
, &bytes_read
, dwarf64
);
1435 start
+= bytes_read
;
1437 if ((from_eh
&& cie_id
== 0) || is_cie (cie_id
, dwarf64
))
1439 struct cie_unit
*cie
= cie_unit_alloc ();
1442 cie
->objfile
= objfile
;
1443 cie
->next
= cie_chunks
;
1446 cie
->objfile
= objfile
;
1448 cie
->offset
= unit_offset
;
1450 start
++; /* version */
1452 cie
->augmentation
= aug
= start
;
1455 start
++; /* skip past NUL */
1457 cie
->code_align
= read_uleb128 (abfd
, &start
);
1458 cie
->data_align
= read_sleb128 (abfd
, &start
);
1459 cie
->ra
= read_1u (abfd
, &start
);
1463 int xtra
= read_uleb128 (abfd
, &start
);
1468 while (*aug
!= '\0')
1470 if (aug
[0] == 'e' && aug
[1] == 'h')
1472 start
+= sizeof (void *);
1475 else if (aug
[0] == 'R')
1477 cie
->addr_encoding
= *start
++;
1480 else if (aug
[0] == 'P')
1483 ptr
= read_encoded_pointer (abfd
, &start
,
1484 cie
->addr_encoding
);
1488 warning ("%s(): unknown augmentation", __func__
);
1492 cie
->data_length
= block_end
- start
;
1496 struct fde_unit
*fde
;
1497 struct cie_unit
*cie
;
1499 fde_chunks_need_space ();
1500 fde
= fde_unit_alloc ();
1502 fde_chunks
.array
[fde_chunks
.elems
++] = fde
;
1504 fde
->initial_location
= read_pointer (abfd
, &start
)
1505 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1506 fde
->address_range
= read_pointer (abfd
, &start
);
1511 if (cie
->objfile
== objfile
)
1513 if (from_eh
&& (cie
->offset
== (unit_offset
+ bytes_read
- cie_id
)))
1515 if (!from_eh
&& (cie
->offset
== cie_id
))
1523 error ("%s(): can't find CIE pointer", __func__
);
1526 if (cie
->augmentation
[0] == 'z')
1527 read_uleb128 (abfd
, &start
);
1530 fde
->data_length
= block_end
- start
;
1534 qsort (fde_chunks
.array
, fde_chunks
.elems
,
1535 sizeof (struct fde_unit
*), compare_fde_unit
);
1540 /* Return the frame address. */
1544 struct context
*context
;
1545 struct frame_state
*fs
;
1548 unwind_tmp_obstack_init ();
1550 context
= context_alloc ();
1551 fs
= frame_state_alloc ();
1553 context
->ra
= read_pc () + 1;
1555 frame_state_for (context
, fs
);
1556 update_context (context
, fs
, 0);
1560 unwind_tmp_obstack_free ();
1565 /* Store the frame address. This function is not used. */
1568 cfi_write_fp (CORE_ADDR val
)
1570 struct context
*context
;
1571 struct frame_state
*fs
;
1573 unwind_tmp_obstack_init ();
1575 context
= context_alloc ();
1576 fs
= frame_state_alloc ();
1578 context
->ra
= read_pc () + 1;
1580 frame_state_for (context
, fs
);
1582 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1584 val
-= fs
->cfa_offset
;
1585 write_register_gen (fs
->cfa_reg
, (char *) &val
);
1588 warning ("Can't write fp.");
1590 unwind_tmp_obstack_free ();
1593 /* Restore the machine to the state it had before the current frame
1596 cfi_pop_frame (struct frame_info
*fi
)
1598 char regbuf
[MAX_REGISTER_RAW_SIZE
];
1601 fi
= get_current_frame ();
1603 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1605 get_reg (regbuf
, UNWIND_CONTEXT (fi
), regnum
);
1606 write_register_bytes (REGISTER_BYTE (regnum
), regbuf
,
1607 REGISTER_RAW_SIZE (regnum
));
1609 write_register (PC_REGNUM
, UNWIND_CONTEXT (fi
)->ra
);
1611 flush_cached_frames ();
1614 /* Determine the address of the calling function's frame. */
1616 cfi_frame_chain (struct frame_info
*fi
)
1618 struct context
*context
;
1619 struct frame_state
*fs
;
1622 unwind_tmp_obstack_init ();
1624 context
= context_alloc ();
1625 fs
= frame_state_alloc ();
1626 context_cpy (context
, UNWIND_CONTEXT (fi
));
1628 /* outermost frame */
1629 if (context
->ra
== 0)
1631 unwind_tmp_obstack_free ();
1635 frame_state_for (context
, fs
);
1636 update_context (context
, fs
, 1);
1639 unwind_tmp_obstack_free ();
1644 /* Sets the pc of the frame. */
1646 cfi_init_frame_pc (int fromleaf
, struct frame_info
*fi
)
1649 get_reg ((char *) &(fi
->pc
), UNWIND_CONTEXT (fi
->next
), PC_REGNUM
);
1651 fi
->pc
= read_pc ();
1654 /* Initialize unwind context informations of the frame. */
1656 cfi_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1658 struct frame_state
*fs
;
1660 unwind_tmp_obstack_init ();
1662 fs
= frame_state_alloc ();
1663 fi
->context
= frame_obstack_alloc (sizeof (struct context
));
1664 UNWIND_CONTEXT (fi
)->reg
=
1665 frame_obstack_alloc (sizeof (struct context_reg
) * NUM_REGS
);
1666 memset (UNWIND_CONTEXT (fi
)->reg
, 0,
1667 sizeof (struct context_reg
) * NUM_REGS
);
1671 context_cpy (UNWIND_CONTEXT (fi
), UNWIND_CONTEXT (fi
->next
));
1672 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1673 update_context (UNWIND_CONTEXT (fi
), fs
, 1);
1677 UNWIND_CONTEXT (fi
)->ra
= fi
->pc
+ 1;
1678 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1679 update_context (UNWIND_CONTEXT (fi
), fs
, 0);
1682 unwind_tmp_obstack_free ();
1685 /* Obtain return address of the frame. */
1687 cfi_get_ra (struct frame_info
*fi
)
1689 return UNWIND_CONTEXT (fi
)->ra
;
1692 /* Find register number REGNUM relative to FRAME and put its
1693 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
1694 was optimized out (and thus can't be fetched). If the variable
1695 was fetched from memory, set *ADDRP to where it was fetched from,
1696 otherwise it was fetched from a register.
1698 The argument RAW_BUFFER must point to aligned memory. */
1700 cfi_get_saved_register (char *raw_buffer
,
1703 struct frame_info
*frame
,
1704 int regnum
, enum lval_type
*lval
)
1706 if (!target_has_registers
)
1707 error ("No registers.");
1709 /* Normal systems don't optimize out things with register numbers. */
1710 if (optimized
!= NULL
)
1713 if (addrp
) /* default assumption: not found in memory */
1718 read_register_gen (regnum
, raw_buffer
);
1720 *lval
= lval_register
;
1722 *addrp
= REGISTER_BYTE (regnum
);
1726 frame
= frame
->next
;
1727 switch (UNWIND_CONTEXT (frame
)->reg
[regnum
].how
)
1729 case REG_CTX_UNSAVED
:
1730 read_register_gen (regnum
, raw_buffer
);
1733 if (optimized
!= NULL
)
1736 case REG_CTX_SAVED_OFFSET
:
1737 target_read_memory (UNWIND_CONTEXT (frame
)->cfa
+
1738 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
,
1739 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1741 *lval
= lval_memory
;
1744 UNWIND_CONTEXT (frame
)->cfa
+
1745 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
;
1747 case REG_CTX_SAVED_REG
:
1748 read_register_gen (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
,
1751 *lval
= lval_register
;
1754 REGISTER_BYTE (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
);
1756 case REG_CTX_SAVED_ADDR
:
1757 target_read_memory (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1758 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1760 *lval
= lval_memory
;
1762 *addrp
= UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
;
1765 memcpy (raw_buffer
, &UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1766 REGISTER_RAW_SIZE (regnum
));
1769 if (optimized
!= NULL
)
1773 internal_error (__FILE__
, __LINE__
,
1774 "cfi_get_saved_register: unknown register rule");
1779 /* Return the register that the function uses for a frame pointer,
1780 plus any necessary offset to be applied to the register before
1781 any frame pointer offsets. */
1783 cfi_virtual_frame_pointer (CORE_ADDR pc
, int *frame_reg
,
1784 LONGEST
* frame_offset
)
1786 struct context
*context
;
1787 struct frame_state
*fs
;
1789 unwind_tmp_obstack_init ();
1791 context
= context_alloc ();
1792 fs
= frame_state_alloc ();
1794 context
->ra
= read_pc () + 1;
1796 frame_state_for (context
, fs
);
1798 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1800 *frame_reg
= fs
->cfa_reg
;
1801 *frame_offset
= fs
->cfa_offset
;
1804 error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1806 unwind_tmp_obstack_free ();