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_free ();
205 static void context_cpy (struct context
*dst
, struct context
*src
);
207 static unsigned int read_1u (bfd
*abfd
, char **p
);
208 static int read_1s (bfd
*abfd
, char **p
);
209 static unsigned int read_2u (bfd
*abfd
, char **p
);
210 static int read_2s (bfd
*abfd
, char **p
);
211 static unsigned int read_4u (bfd
*abfd
, char **p
);
212 static int read_4s (bfd
*abfd
, char **p
);
213 static ULONGEST
read_8u (bfd
*abfd
, char **p
);
214 static LONGEST
read_8s (bfd
*abfd
, char **p
);
216 static ULONGEST
read_uleb128 (bfd
*abfd
, char **p
);
217 static LONGEST
read_sleb128 (bfd
*abfd
, char **p
);
218 static CORE_ADDR
read_pointer (bfd
*abfd
, char **p
);
219 static CORE_ADDR
read_encoded_pointer (bfd
*abfd
, char **p
,
220 unsigned char encoding
);
222 static LONGEST
read_initial_length (bfd
*abfd
, char *buf
, int *bytes_read
);
223 static ULONGEST
read_length (bfd
*abfd
, char *buf
, int *bytes_read
,
226 static int is_cie (ULONGEST cie_id
, int dwarf64
);
227 static int compare_fde_unit (const void *a
, const void *b
);
228 void dwarf2_build_frame_info (struct objfile
*objfile
);
230 static void execute_cfa_program (struct objfile
*objfile
, char *insn_ptr
,
231 char *insn_end
, struct context
*context
,
232 struct frame_state
*fs
);
233 static struct fde_unit
*get_fde_for_addr (CORE_ADDR pc
);
234 static void frame_state_for (struct context
*context
, struct frame_state
*fs
);
235 static void get_reg (char *reg
, struct context
*context
, int regnum
);
236 static CORE_ADDR
execute_stack_op (struct objfile
*objfile
,
237 char *op_ptr
, char *op_end
,
238 struct context
*context
, CORE_ADDR initial
);
239 static void update_context (struct context
*context
, struct frame_state
*fs
,
243 /* Memory allocation functions. */
244 static struct fde_unit
*
245 fde_unit_alloc (void)
247 struct fde_unit
*fde
;
249 fde
= (struct fde_unit
*) xmalloc (sizeof (struct fde_unit
));
250 memset (fde
, 0, sizeof (struct fde_unit
));
254 static struct cie_unit
*
255 cie_unit_alloc (void)
257 struct cie_unit
*cie
;
259 cie
= (struct cie_unit
*) xmalloc (sizeof (struct cie_unit
));
260 memset (cie
, 0, sizeof (struct cie_unit
));
265 fde_chunks_need_space ()
267 if (fde_chunks
.elems
< fde_chunks
.array_size
)
269 fde_chunks
.array_size
=
270 fde_chunks
.array_size
? 2 * fde_chunks
.array_size
: 1024;
272 xrealloc (fde_chunks
.array
,
273 sizeof (struct fde_unit
) * fde_chunks
.array_size
);
276 /* Alocate a new `struct context' on temporary obstack. */
277 static struct context
*
280 struct context
*context
;
282 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
284 context
= (struct context
*) obstack_alloc (&unwind_tmp_obstack
,
285 sizeof (struct context
));
286 memset (context
, 0, sizeof (struct context
));
287 context
->reg
= (struct context_reg
*) obstack_alloc (&unwind_tmp_obstack
,
289 memset (context
->reg
, 0, regs_size
);
293 /* Alocate a new `struct frame_state' on temporary obstack. */
294 static struct frame_state
*
297 struct frame_state
*fs
;
299 int regs_size
= sizeof (struct frame_state_reg
) * NUM_REGS
;
301 fs
= (struct frame_state
*) obstack_alloc (&unwind_tmp_obstack
,
302 sizeof (struct frame_state
));
303 memset (fs
, 0, sizeof (struct frame_state
));
304 fs
->regs
.reg
= (struct frame_state_reg
*) obstack_alloc (&unwind_tmp_obstack
,
306 memset (fs
->regs
.reg
, 0, regs_size
);
311 unwind_tmp_obstack_free ()
313 obstack_free (&unwind_tmp_obstack
, NULL
);
314 obstack_init (&unwind_tmp_obstack
);
318 context_cpy (struct context
*dst
, struct context
*src
)
320 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
321 struct context_reg
*dreg
;
323 /* Structure dst contains a pointer to an array of
324 * registers of a given frame as well as src does. This
325 * array was already allocated before dst was passed to
326 * context_cpy but the pointer to it was overriden by
327 * '*dst = *src' and the array was lost. This led to the
328 * situation, that we've had a copy of src placed in dst,
329 * but both of them pointed to the same regs array and
330 * thus we've sometimes blindly rewritten it. Now we save
331 * the pointer before copying src to dst, return it back
332 * after that and copy the registers into their new place
333 * finally. --- mludvig@suse.cz */
338 memcpy (dst
->reg
, src
->reg
, regs_size
);
342 read_1u (bfd
*abfd
, char **p
)
346 ret
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
352 read_1s (bfd
*abfd
, char **p
)
356 ret
= bfd_get_signed_8 (abfd
, (bfd_byte
*) *p
);
362 read_2u (bfd
*abfd
, char **p
)
366 ret
= bfd_get_16 (abfd
, (bfd_byte
*) *p
);
372 read_2s (bfd
*abfd
, char **p
)
376 ret
= bfd_get_signed_16 (abfd
, (bfd_byte
*) *p
);
382 read_4u (bfd
*abfd
, char **p
)
386 ret
= bfd_get_32 (abfd
, (bfd_byte
*) *p
);
392 read_4s (bfd
*abfd
, char **p
)
396 ret
= bfd_get_signed_32 (abfd
, (bfd_byte
*) *p
);
402 read_8u (bfd
*abfd
, char **p
)
406 ret
= bfd_get_64 (abfd
, (bfd_byte
*) *p
);
412 read_8s (bfd
*abfd
, char **p
)
416 ret
= bfd_get_signed_64 (abfd
, (bfd_byte
*) *p
);
422 read_uleb128 (bfd
*abfd
, char **p
)
433 byte
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
435 ret
|= ((unsigned long) (byte
& 127) << shift
);
436 if ((byte
& 128) == 0)
446 read_sleb128 (bfd
*abfd
, char **p
)
449 int i
, shift
, size
, num_read
;
459 byte
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
461 ret
|= ((long) (byte
& 127) << shift
);
463 if ((byte
& 128) == 0)
468 if ((shift
< size
) && (byte
& 0x40))
470 ret
|= -(1 << shift
);
476 read_pointer (bfd
*abfd
, char **p
)
478 switch (TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
)
481 return read_4u (abfd
, p
);
483 return read_8u (abfd
, p
);
485 error ("dwarf cfi error: unsupported target address length.");
490 read_encoded_pointer (bfd
*abfd
, char **p
, unsigned char encoding
)
494 switch (encoding
& 0x0f)
496 case DW_EH_PE_absptr
:
497 ret
= read_pointer (abfd
, p
);
500 case DW_EH_PE_uleb128
:
501 ret
= read_uleb128 (abfd
, p
);
503 case DW_EH_PE_sleb128
:
504 ret
= read_sleb128 (abfd
, p
);
507 case DW_EH_PE_udata2
:
508 ret
= read_2u (abfd
, p
);
510 case DW_EH_PE_udata4
:
511 ret
= read_4u (abfd
, p
);
513 case DW_EH_PE_udata8
:
514 ret
= read_8u (abfd
, p
);
517 case DW_EH_PE_sdata2
:
518 ret
= read_2s (abfd
, p
);
520 case DW_EH_PE_sdata4
:
521 ret
= read_4s (abfd
, p
);
523 case DW_EH_PE_sdata8
:
524 ret
= read_8s (abfd
, p
);
528 internal_error (__FILE__
, __LINE__
,
529 "read_encoded_pointer: unknown pointer encoding");
533 switch (encoding
& 0xf0)
535 case DW_EH_PE_absptr
:
538 ret
+= (CORE_ADDR
) *p
;
540 case DW_EH_PE_textrel
:
541 case DW_EH_PE_datarel
:
542 case DW_EH_PE_funcrel
:
544 internal_error (__FILE__
, __LINE__
,
545 "read_encoded_pointer: unknown pointer encoding");
552 read_initial_length (bfd
* abfd
, char *buf
, int *bytes_read
)
556 ret
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
558 if (ret
== 0xffffffff)
560 ret
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
572 read_length (bfd
* abfd
, char *buf
, int *bytes_read
, int dwarf64
)
577 return read_8u (abfd
, &buf
);
582 return read_4u (abfd
, &buf
);
587 execute_cfa_program ( struct objfile
*objfile
, char *insn_ptr
, char *insn_end
,
588 struct context
*context
, struct frame_state
*fs
)
590 struct frame_state_regs
*unused_rs
= NULL
;
592 /* Don't allow remember/restore between CIE and FDE programs. */
593 fs
->regs
.prev
= NULL
;
595 while (insn_ptr
< insn_end
&& fs
->pc
< context
->ra
)
597 unsigned char insn
= *insn_ptr
++;
598 ULONGEST reg
, uoffset
;
601 if (insn
& DW_CFA_advance_loc
)
602 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
603 else if (insn
& DW_CFA_offset
)
606 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
607 offset
= (long) uoffset
* fs
->data_align
;
608 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
609 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
611 else if (insn
& DW_CFA_restore
)
614 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
620 fs
->pc
= read_encoded_pointer (objfile
->obfd
, &insn_ptr
,
624 case DW_CFA_advance_loc1
:
625 fs
->pc
+= read_1u (objfile
->obfd
, &insn_ptr
);
627 case DW_CFA_advance_loc2
:
628 fs
->pc
+= read_2u (objfile
->obfd
, &insn_ptr
);
630 case DW_CFA_advance_loc4
:
631 fs
->pc
+= read_4u (objfile
->obfd
, &insn_ptr
);
634 case DW_CFA_offset_extended
:
635 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
636 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
637 offset
= (long) uoffset
*fs
->data_align
;
638 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
639 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
642 case DW_CFA_restore_extended
:
643 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
644 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
647 case DW_CFA_undefined
:
648 case DW_CFA_same_value
:
652 case DW_CFA_register
:
655 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
656 reg2
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
657 fs
->regs
.reg
[reg
].how
= REG_SAVED_REG
;
658 fs
->regs
.reg
[reg
].loc
.reg
= reg2
;
662 case DW_CFA_remember_state
:
664 struct frame_state_regs
*new_rs
;
668 unused_rs
= unused_rs
->prev
;
671 new_rs
= xmalloc (sizeof (struct frame_state_regs
));
674 fs
->regs
.prev
= new_rs
;
678 case DW_CFA_restore_state
:
680 struct frame_state_regs
*old_rs
= fs
->regs
.prev
;
682 old_rs
->prev
= unused_rs
;
688 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
689 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
691 fs
->cfa_offset
= uoffset
;
692 fs
->cfa_how
= CFA_REG_OFFSET
;
695 case DW_CFA_def_cfa_register
:
696 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
698 fs
->cfa_how
= CFA_REG_OFFSET
;
701 case DW_CFA_def_cfa_offset
:
702 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
703 fs
->cfa_offset
= uoffset
;
706 case DW_CFA_def_cfa_expression
:
707 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
708 fs
->cfa_exp
= insn_ptr
;
709 fs
->cfa_how
= CFA_EXP
;
713 case DW_CFA_expression
:
714 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
715 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
716 fs
->regs
.reg
[reg
].how
= REG_SAVED_EXP
;
717 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
721 /* From the 2.1 draft. */
722 case DW_CFA_offset_extended_sf
:
723 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
724 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
725 offset
*= fs
->data_align
;
726 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
727 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
730 case DW_CFA_def_cfa_sf
:
731 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
732 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
733 fs
->cfa_offset
= offset
;
735 fs
->cfa_how
= CFA_REG_OFFSET
;
738 case DW_CFA_def_cfa_offset_sf
:
739 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
740 fs
->cfa_offset
= uoffset
;
741 /* cfa_how deliberately not set. */
744 case DW_CFA_GNU_window_save
:
745 /* ??? Hardcoded for SPARC register window configuration. */
746 for (reg
= 16; reg
< 32; ++reg
)
748 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
749 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * sizeof (void *);
753 case DW_CFA_GNU_args_size
:
754 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
755 context
->args_size
= uoffset
;
758 case DW_CFA_GNU_negative_offset_extended
:
759 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
760 older PowerPC code. */
761 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
762 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
763 offset
= (long) uoffset
*fs
->data_align
;
764 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
765 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
769 error ("dwarf cfi error: unknown cfa instruction %d.", insn
);
774 static struct fde_unit
*
775 get_fde_for_addr (CORE_ADDR pc
)
778 struct fde_unit
*fde
= NULL
;
780 hi
= fde_chunks
.elems
;
784 size_t i
= (lo
+ hi
) / 2;
785 fde
= fde_chunks
.array
[i
];
786 if (pc
< fde
->initial_location
)
788 else if (pc
>= fde
->initial_location
+ fde
->address_range
)
797 frame_state_for (struct context
*context
, struct frame_state
*fs
)
799 struct fde_unit
*fde
;
800 struct cie_unit
*cie
;
802 context
->args_size
= 0;
805 if ((fde
= get_fde_for_addr (context
->ra
- 1)) != NULL
)
807 fs
->pc
= fde
->initial_location
;
810 fs
->code_align
= cie
->code_align
;
811 fs
->data_align
= cie
->data_align
;
812 fs
->retaddr_column
= cie
->ra
;
813 fs
->addr_encoding
= cie
->addr_encoding
;
814 fs
->objfile
= cie
->objfile
;
816 execute_cfa_program (cie
->objfile
, cie
->data
,
817 cie
->data
+ cie
->data_length
, context
, fs
);
818 execute_cfa_program (cie
->objfile
, fde
->data
,
819 fde
->data
+ fde
->data_length
, context
, fs
);
824 get_reg (char *reg
, struct context
*context
, int regnum
)
826 switch (context
->reg
[regnum
].how
)
828 case REG_CTX_UNSAVED
:
829 read_register_gen (regnum
, reg
);
831 case REG_CTX_SAVED_OFFSET
:
832 target_read_memory (context
->cfa
+ context
->reg
[regnum
].loc
.offset
,
833 reg
, REGISTER_RAW_SIZE (regnum
));
835 case REG_CTX_SAVED_REG
:
836 read_register_gen (context
->reg
[regnum
].loc
.reg
, reg
);
838 case REG_CTX_SAVED_ADDR
:
839 target_read_memory (context
->reg
[regnum
].loc
.addr
,
840 reg
, REGISTER_RAW_SIZE (regnum
));
843 memcpy (reg
, &context
->reg
[regnum
].loc
.addr
,
844 REGISTER_RAW_SIZE (regnum
));
847 internal_error (__FILE__
, __LINE__
,
848 "get_reg: unknown register rule");
852 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
853 onto the stack to start. */
855 execute_stack_op (struct objfile
*objfile
,
856 char *op_ptr
, char *op_end
, struct context
*context
,
859 CORE_ADDR stack
[64]; /* ??? Assume this is enough. */
865 while (op_ptr
< op_end
)
867 enum dwarf_location_atom op
= *op_ptr
++;
868 ULONGEST result
, reg
;
905 result
= op
- DW_OP_lit0
;
909 result
= read_pointer (objfile
->obfd
, &op_ptr
);
913 result
= read_1u (objfile
->obfd
, &op_ptr
);
916 result
= read_1s (objfile
->obfd
, &op_ptr
);
919 result
= read_2u (objfile
->obfd
, &op_ptr
);
922 result
= read_2s (objfile
->obfd
, &op_ptr
);
925 result
= read_4u (objfile
->obfd
, &op_ptr
);
928 result
= read_4s (objfile
->obfd
, &op_ptr
);
931 result
= read_8u (objfile
->obfd
, &op_ptr
);
934 result
= read_8s (objfile
->obfd
, &op_ptr
);
937 result
= read_uleb128 (objfile
->obfd
, &op_ptr
);
940 result
= read_sleb128 (objfile
->obfd
, &op_ptr
);
975 get_reg ((char *) &result
, context
, op
- DW_OP_reg0
);
978 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
979 get_reg ((char *) &result
, context
, reg
);
1014 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1015 get_reg ((char *) &result
, context
, op
- DW_OP_breg0
);
1019 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
1020 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1021 get_reg ((char *) &result
, context
, reg
);
1027 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1028 result
= stack
[stack_elt
- 1];
1032 if (--stack_elt
< 0)
1033 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1038 if (offset
>= stack_elt
- 1)
1039 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1040 result
= stack
[stack_elt
- 1 - offset
];
1045 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1046 result
= stack
[stack_elt
- 2];
1051 CORE_ADDR t1
, t2
, t3
;
1054 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1055 t1
= stack
[stack_elt
- 1];
1056 t2
= stack
[stack_elt
- 2];
1057 t3
= stack
[stack_elt
- 3];
1058 stack
[stack_elt
- 1] = t2
;
1059 stack
[stack_elt
- 2] = t3
;
1060 stack
[stack_elt
- 3] = t1
;
1065 case DW_OP_deref_size
:
1069 case DW_OP_plus_uconst
:
1070 /* Unary operations. */
1071 if (--stack_elt
< 0)
1072 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1073 result
= stack
[stack_elt
];
1079 char *ptr
= (char *) result
;
1080 result
= read_pointer (objfile
->obfd
, &ptr
);
1084 case DW_OP_deref_size
:
1086 char *ptr
= (char *) result
;
1090 result
= read_1u (objfile
->obfd
, &ptr
);
1093 result
= read_2u (objfile
->obfd
, &ptr
);
1096 result
= read_4u (objfile
->obfd
, &ptr
);
1099 result
= read_8u (objfile
->obfd
, &ptr
);
1102 internal_error (__FILE__
, __LINE__
,
1103 "execute_stack_op error");
1118 case DW_OP_plus_uconst
:
1119 result
+= read_uleb128 (objfile
->obfd
, &op_ptr
);
1140 /* Binary operations. */
1141 CORE_ADDR first
, second
;
1142 if ((stack_elt
-= 2) < 0)
1143 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1144 second
= stack
[stack_elt
];
1145 first
= stack
[stack_elt
+ 1];
1150 result
= second
& first
;
1153 result
= (LONGEST
) second
/ (LONGEST
) first
;
1156 result
= second
- first
;
1159 result
= (LONGEST
) second
% (LONGEST
) first
;
1162 result
= second
* first
;
1165 result
= second
| first
;
1168 result
= second
+ first
;
1171 result
= second
<< first
;
1174 result
= second
>> first
;
1177 result
= (LONGEST
) second
>> first
;
1180 result
= second
^ first
;
1183 result
= (LONGEST
) first
<= (LONGEST
) second
;
1186 result
= (LONGEST
) first
>= (LONGEST
) second
;
1189 result
= (LONGEST
) first
== (LONGEST
) second
;
1192 result
= (LONGEST
) first
< (LONGEST
) second
;
1195 result
= (LONGEST
) first
> (LONGEST
) second
;
1198 result
= (LONGEST
) first
!= (LONGEST
) second
;
1200 default: /* This label is here just to avoid warning. */
1207 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1212 if (--stack_elt
< 0)
1213 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1214 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1215 if (stack
[stack_elt
] != 0)
1223 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1226 /* Most things push a result value. */
1227 if ((size_t) stack_elt
>= sizeof (stack
) / sizeof (*stack
))
1228 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1229 stack
[++stack_elt
] = result
;
1233 /* We were executing this program to get a value. It should be
1235 if (--stack_elt
< 0)
1236 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1237 return stack
[stack_elt
];
1241 update_context (struct context
*context
, struct frame_state
*fs
, int chain
)
1243 struct context
*orig_context
;
1247 orig_context
= context_alloc ();
1248 context_cpy (orig_context
, context
);
1249 /* Compute this frame's CFA. */
1250 switch (fs
->cfa_how
)
1252 case CFA_REG_OFFSET
:
1253 get_reg ((char *) &cfa
, context
, fs
->cfa_reg
);
1254 cfa
+= fs
->cfa_offset
;
1258 /* ??? No way of knowing what register number is the stack pointer
1259 to do the same sort of handling as above. Assume that if the
1260 CFA calculation is so complicated as to require a stack program
1261 that this will not be a problem. */
1263 char *exp
= fs
->cfa_exp
;
1266 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1267 cfa
= (CORE_ADDR
) execute_stack_op (fs
->objfile
, exp
,
1268 exp
+ len
, context
, 0);
1277 orig_context
->cfa
= cfa
;
1279 /* Compute the addresses of all registers saved in this frame. */
1280 for (i
= 0; i
< NUM_REGS
; ++i
)
1281 switch (fs
->regs
.reg
[i
].how
)
1286 context
->reg
[i
].how
= REG_CTX_VALUE
;
1287 context
->reg
[i
].loc
.addr
= cfa
;
1290 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1292 case REG_SAVED_OFFSET
:
1293 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1294 context
->reg
[i
].loc
.offset
= fs
->regs
.reg
[i
].loc
.offset
;
1297 switch (orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].how
)
1299 case REG_CTX_UNSAVED
:
1300 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1302 case REG_CTX_SAVED_OFFSET
:
1303 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1304 context
->reg
[i
].loc
.offset
= orig_context
->cfa
- context
->cfa
+
1305 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.offset
;
1307 case REG_CTX_SAVED_REG
:
1308 context
->reg
[i
].how
= REG_CTX_SAVED_REG
;
1309 context
->reg
[i
].loc
.reg
=
1310 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.reg
;
1312 case REG_CTX_SAVED_ADDR
:
1313 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1314 context
->reg
[i
].loc
.addr
=
1315 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.addr
;
1317 internal_error (__FILE__
, __LINE__
,
1318 "%s: unknown register rule", __func__
);
1323 char *exp
= fs
->regs
.reg
[i
].loc
.exp
;
1327 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1328 val
= execute_stack_op (fs
->objfile
, exp
, exp
+ len
,
1330 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1331 context
->reg
[i
].loc
.addr
= val
;
1335 internal_error (__FILE__
, __LINE__
,
1336 "%s: unknown register rule", __func__
);
1338 get_reg ((char *) &context
->ra
, context
, fs
->retaddr_column
);
1339 unwind_tmp_obstack_free ();
1343 is_cie (ULONGEST cie_id
, int dwarf64
)
1345 return dwarf64
? (cie_id
== 0xffffffffffffffff) : (cie_id
== 0xffffffff);
1349 compare_fde_unit (const void *a
, const void *b
)
1351 struct fde_unit
**first
, **second
;
1352 first
= (struct fde_unit
**) a
;
1353 second
= (struct fde_unit
**) b
;
1354 if ((*first
)->initial_location
> (*second
)->initial_location
)
1356 else if ((*first
)->initial_location
< (*second
)->initial_location
)
1362 /* Build the cie_chunks and fde_chunks tables from informations
1363 in .debug_frame section. */
1365 dwarf2_build_frame_info (struct objfile
*objfile
)
1367 bfd
*abfd
= objfile
->obfd
;
1371 obstack_init (&unwind_tmp_obstack
);
1373 dwarf_frame_buffer
= 0;
1375 if (dwarf_frame_offset
)
1377 dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1381 start
= dwarf_frame_buffer
;
1382 end
= dwarf_frame_buffer
+ dwarf_frame_size
;
1384 else if (dwarf_eh_frame_offset
)
1386 dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1387 dwarf_eh_frame_offset
,
1388 dwarf_eh_frame_size
);
1390 start
= dwarf_frame_buffer
;
1391 end
= dwarf_frame_buffer
+ dwarf_eh_frame_size
;
1398 unsigned long length
;
1400 ULONGEST unit_offset
= start
- dwarf_frame_buffer
;
1405 length
= read_initial_length (abfd
, start
, &bytes_read
);
1406 start
+= bytes_read
;
1407 dwarf64
= (bytes_read
== 12);
1408 block_end
= start
+ length
;
1410 cie_id
= read_length (abfd
, start
, &bytes_read
, dwarf64
);
1411 start
+= bytes_read
;
1413 if (is_cie (cie_id
, dwarf64
))
1415 struct cie_unit
*cie
= cie_unit_alloc ();
1418 cie
->objfile
= objfile
;
1419 cie
->next
= cie_chunks
;
1422 cie
->objfile
= objfile
;
1424 cie
->offset
= unit_offset
;
1426 start
++; /* version */
1428 cie
->augmentation
= aug
= start
;
1431 start
++; /* skip past NUL */
1433 cie
->code_align
= read_uleb128 (abfd
, &start
);
1434 cie
->data_align
= read_sleb128 (abfd
, &start
);
1435 cie
->ra
= read_1u (abfd
, &start
);
1439 int xtra
= read_uleb128 (abfd
, &start
);
1444 while (*aug
!= '\0')
1446 if (aug
[0] == 'e' && aug
[1] == 'h')
1448 start
+= sizeof (void *);
1451 else if (aug
[0] == 'R')
1453 cie
->addr_encoding
= *start
++;
1456 else if (aug
[0] == 'P')
1459 ptr
= read_encoded_pointer (abfd
, &start
,
1460 cie
->addr_encoding
);
1464 warning ("unknown augmentation");
1468 cie
->data_length
= block_end
- start
;
1472 struct fde_unit
*fde
;
1473 struct cie_unit
*cie
;
1475 fde_chunks_need_space ();
1476 fde
= fde_unit_alloc ();
1478 fde_chunks
.array
[fde_chunks
.elems
++] = fde
;
1479 fde
->initial_location
= read_pointer (abfd
, &start
);
1480 fde
->address_range
= read_pointer (abfd
, &start
);
1482 for (cie
= cie_chunks
;
1483 cie
&& (cie
->offset
!= cie_id
); cie
= cie
->next
);
1485 error ("dwarf cfi error: can't find CIE pointer");
1488 if (cie
->augmentation
[0] == 'z')
1489 read_uleb128 (abfd
, &start
);
1492 fde
->data_length
= block_end
- start
;
1496 qsort (fde_chunks
.array
, fde_chunks
.elems
,
1497 sizeof (struct fde_unit
*), compare_fde_unit
);
1502 /* Return the frame address. */
1506 struct context
*context
;
1507 struct frame_state
*fs
;
1510 context
= context_alloc ();
1511 fs
= frame_state_alloc ();
1513 context
->ra
= read_pc () + 1;
1515 frame_state_for (context
, fs
);
1516 update_context (context
, fs
, 0);
1519 unwind_tmp_obstack_free ();
1523 /* Store the frame address. This function is not used. */
1526 cfi_write_fp (CORE_ADDR val
)
1528 struct context
*context
;
1529 struct frame_state
*fs
;
1531 context
= context_alloc ();
1532 fs
= frame_state_alloc ();
1534 context
->ra
= read_pc () + 1;
1536 frame_state_for (context
, fs
);
1538 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1540 val
-= fs
->cfa_offset
;
1541 write_register_gen (fs
->cfa_reg
, (char *) &val
);
1544 warning ("Can't write fp.");
1546 unwind_tmp_obstack_free ();
1549 /* Restore the machine to the state it had before the current frame
1552 cfi_pop_frame (struct frame_info
*fi
)
1554 char regbuf
[MAX_REGISTER_RAW_SIZE
];
1557 fi
= get_current_frame ();
1559 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1561 get_reg (regbuf
, UNWIND_CONTEXT (fi
), regnum
);
1562 write_register_bytes (REGISTER_BYTE (regnum
), regbuf
,
1563 REGISTER_RAW_SIZE (regnum
));
1565 write_register (PC_REGNUM
, UNWIND_CONTEXT (fi
)->ra
);
1567 flush_cached_frames ();
1570 /* Determine the address of the calling function's frame. */
1572 cfi_frame_chain (struct frame_info
*fi
)
1574 struct context
*context
;
1575 struct frame_state
*fs
;
1578 context
= context_alloc ();
1579 fs
= frame_state_alloc ();
1580 context_cpy (context
, UNWIND_CONTEXT (fi
));
1582 /* outermost frame */
1583 if (context
->ra
== 0)
1585 unwind_tmp_obstack_free ();
1589 frame_state_for (context
, fs
);
1590 update_context (context
, fs
, 1);
1593 unwind_tmp_obstack_free ();
1598 /* Sets the pc of the frame. */
1600 cfi_init_frame_pc (int fromleaf
, struct frame_info
*fi
)
1603 get_reg ((char *) &(fi
->pc
), UNWIND_CONTEXT (fi
->next
), PC_REGNUM
);
1605 fi
->pc
= read_pc ();
1608 /* Initialize unwind context informations of the frame. */
1610 cfi_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1612 struct frame_state
*fs
;
1614 fs
= frame_state_alloc ();
1615 fi
->context
= frame_obstack_alloc (sizeof (struct context
));
1616 UNWIND_CONTEXT (fi
)->reg
=
1617 frame_obstack_alloc (sizeof (struct context_reg
) * NUM_REGS
);
1618 memset (UNWIND_CONTEXT (fi
)->reg
, 0,
1619 sizeof (struct context_reg
) * NUM_REGS
);
1623 context_cpy (UNWIND_CONTEXT (fi
), UNWIND_CONTEXT (fi
->next
));
1624 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1625 update_context (UNWIND_CONTEXT (fi
), fs
, 1);
1629 UNWIND_CONTEXT (fi
)->ra
= fi
->pc
+ 1;
1630 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1631 update_context (UNWIND_CONTEXT (fi
), fs
, 0);
1633 unwind_tmp_obstack_free ();
1636 /* Obtain return address of the frame. */
1638 cfi_get_ra (struct frame_info
*fi
)
1640 return UNWIND_CONTEXT (fi
)->ra
;
1643 /* Find register number REGNUM relative to FRAME and put its
1644 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
1645 was optimized out (and thus can't be fetched). If the variable
1646 was fetched from memory, set *ADDRP to where it was fetched from,
1647 otherwise it was fetched from a register.
1649 The argument RAW_BUFFER must point to aligned memory. */
1651 cfi_get_saved_register (char *raw_buffer
,
1654 struct frame_info
*frame
,
1655 int regnum
, enum lval_type
*lval
)
1657 if (!target_has_registers
)
1658 error ("No registers.");
1660 /* Normal systems don't optimize out things with register numbers. */
1661 if (optimized
!= NULL
)
1664 if (addrp
) /* default assumption: not found in memory */
1669 read_register_gen (regnum
, raw_buffer
);
1671 *lval
= lval_register
;
1673 *addrp
= REGISTER_BYTE (regnum
);
1677 frame
= frame
->next
;
1678 switch (UNWIND_CONTEXT (frame
)->reg
[regnum
].how
)
1680 case REG_CTX_UNSAVED
:
1681 read_register_gen (regnum
, raw_buffer
);
1684 if (optimized
!= NULL
)
1687 case REG_CTX_SAVED_OFFSET
:
1688 target_read_memory (UNWIND_CONTEXT (frame
)->cfa
+
1689 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
,
1690 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1692 *lval
= lval_memory
;
1695 UNWIND_CONTEXT (frame
)->cfa
+
1696 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
;
1698 case REG_CTX_SAVED_REG
:
1699 read_register_gen (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
,
1702 *lval
= lval_register
;
1705 REGISTER_BYTE (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
);
1707 case REG_CTX_SAVED_ADDR
:
1708 target_read_memory (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1709 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1711 *lval
= lval_memory
;
1713 *addrp
= UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
;
1716 memcpy (raw_buffer
, &UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1717 REGISTER_RAW_SIZE (regnum
));
1720 if (optimized
!= NULL
)
1724 internal_error (__FILE__
, __LINE__
,
1725 "cfi_get_saved_register: unknown register rule");
1730 /* Return the register that the function uses for a frame pointer,
1731 plus any necessary offset to be applied to the register before
1732 any frame pointer offsets. */
1734 cfi_virtual_frame_pointer (CORE_ADDR pc
, int *frame_reg
,
1735 LONGEST
* frame_offset
)
1737 struct context
*context
;
1738 struct frame_state
*fs
;
1740 context
= context_alloc ();
1741 fs
= frame_state_alloc ();
1743 context
->ra
= read_pc () + 1;
1745 frame_state_for (context
, fs
);
1747 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1749 *frame_reg
= fs
->cfa_reg
;
1750 *frame_offset
= fs
->cfa_offset
;
1753 error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1755 unwind_tmp_obstack_free ();