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
;
323 memcpy (dst
->reg
, src
->reg
, regs_size
);
328 read_1u (bfd
*abfd
, char **p
)
332 ret
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
338 read_1s (bfd
*abfd
, char **p
)
342 ret
= bfd_get_signed_8 (abfd
, (bfd_byte
*) *p
);
348 read_2u (bfd
*abfd
, char **p
)
352 ret
= bfd_get_16 (abfd
, (bfd_byte
*) *p
);
358 read_2s (bfd
*abfd
, char **p
)
362 ret
= bfd_get_signed_16 (abfd
, (bfd_byte
*) *p
);
368 read_4u (bfd
*abfd
, char **p
)
372 ret
= bfd_get_32 (abfd
, (bfd_byte
*) *p
);
378 read_4s (bfd
*abfd
, char **p
)
382 ret
= bfd_get_signed_32 (abfd
, (bfd_byte
*) *p
);
388 read_8u (bfd
*abfd
, char **p
)
392 ret
= bfd_get_64 (abfd
, (bfd_byte
*) *p
);
398 read_8s (bfd
*abfd
, char **p
)
402 ret
= bfd_get_signed_64 (abfd
, (bfd_byte
*) *p
);
408 read_uleb128 (bfd
*abfd
, char **p
)
419 byte
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
421 ret
|= ((unsigned long) (byte
& 127) << shift
);
422 if ((byte
& 128) == 0)
432 read_sleb128 (bfd
*abfd
, char **p
)
435 int i
, shift
, size
, num_read
;
445 byte
= bfd_get_8 (abfd
, (bfd_byte
*) *p
);
447 ret
|= ((long) (byte
& 127) << shift
);
449 if ((byte
& 128) == 0)
454 if ((shift
< size
) && (byte
& 0x40))
456 ret
|= -(1 << shift
);
462 read_pointer (bfd
*abfd
, char **p
)
464 switch (TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
)
467 return read_4u (abfd
, p
);
469 return read_8u (abfd
, p
);
471 error ("dwarf cfi error: unsupported target address length.");
476 read_encoded_pointer (bfd
*abfd
, char **p
, unsigned char encoding
)
480 switch (encoding
& 0x0f)
482 case DW_EH_PE_absptr
:
483 ret
= read_pointer (abfd
, p
);
486 case DW_EH_PE_uleb128
:
487 ret
= read_uleb128 (abfd
, p
);
489 case DW_EH_PE_sleb128
:
490 ret
= read_sleb128 (abfd
, p
);
493 case DW_EH_PE_udata2
:
494 ret
= read_2u (abfd
, p
);
496 case DW_EH_PE_udata4
:
497 ret
= read_4u (abfd
, p
);
499 case DW_EH_PE_udata8
:
500 ret
= read_8u (abfd
, p
);
503 case DW_EH_PE_sdata2
:
504 ret
= read_2s (abfd
, p
);
506 case DW_EH_PE_sdata4
:
507 ret
= read_4s (abfd
, p
);
509 case DW_EH_PE_sdata8
:
510 ret
= read_8s (abfd
, p
);
514 internal_error (__FILE__
, __LINE__
,
515 "read_encoded_pointer: unknown pointer encoding");
519 switch (encoding
& 0xf0)
521 case DW_EH_PE_absptr
:
524 ret
+= (CORE_ADDR
) *p
;
526 case DW_EH_PE_textrel
:
527 case DW_EH_PE_datarel
:
528 case DW_EH_PE_funcrel
:
530 internal_error (__FILE__
, __LINE__
,
531 "read_encoded_pointer: unknown pointer encoding");
538 read_initial_length (bfd
* abfd
, char *buf
, int *bytes_read
)
542 ret
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
544 if (ret
== 0xffffffff)
546 ret
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
558 read_length (bfd
* abfd
, char *buf
, int *bytes_read
, int dwarf64
)
563 return read_8u (abfd
, &buf
);
568 return read_4u (abfd
, &buf
);
573 execute_cfa_program ( struct objfile
*objfile
, char *insn_ptr
, char *insn_end
,
574 struct context
*context
, struct frame_state
*fs
)
576 struct frame_state_regs
*unused_rs
= NULL
;
578 /* Don't allow remember/restore between CIE and FDE programs. */
579 fs
->regs
.prev
= NULL
;
581 while (insn_ptr
< insn_end
&& fs
->pc
< context
->ra
)
583 unsigned char insn
= *insn_ptr
++;
584 ULONGEST reg
, uoffset
;
587 if (insn
& DW_CFA_advance_loc
)
588 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
589 else if (insn
& DW_CFA_offset
)
592 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
593 offset
= (long) uoffset
* fs
->data_align
;
594 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
595 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
597 else if (insn
& DW_CFA_restore
)
600 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
606 fs
->pc
= read_encoded_pointer (objfile
->obfd
, &insn_ptr
,
610 case DW_CFA_advance_loc1
:
611 fs
->pc
+= read_1u (objfile
->obfd
, &insn_ptr
);
613 case DW_CFA_advance_loc2
:
614 fs
->pc
+= read_2u (objfile
->obfd
, &insn_ptr
);
616 case DW_CFA_advance_loc4
:
617 fs
->pc
+= read_4u (objfile
->obfd
, &insn_ptr
);
620 case DW_CFA_offset_extended
:
621 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
622 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
623 offset
= (long) uoffset
*fs
->data_align
;
624 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
625 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
628 case DW_CFA_restore_extended
:
629 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
630 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
633 case DW_CFA_undefined
:
634 case DW_CFA_same_value
:
638 case DW_CFA_register
:
641 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
642 reg2
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
643 fs
->regs
.reg
[reg
].how
= REG_SAVED_REG
;
644 fs
->regs
.reg
[reg
].loc
.reg
= reg2
;
648 case DW_CFA_remember_state
:
650 struct frame_state_regs
*new_rs
;
654 unused_rs
= unused_rs
->prev
;
657 new_rs
= xmalloc (sizeof (struct frame_state_regs
));
660 fs
->regs
.prev
= new_rs
;
664 case DW_CFA_restore_state
:
666 struct frame_state_regs
*old_rs
= fs
->regs
.prev
;
668 old_rs
->prev
= unused_rs
;
674 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
675 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
677 fs
->cfa_offset
= uoffset
;
678 fs
->cfa_how
= CFA_REG_OFFSET
;
681 case DW_CFA_def_cfa_register
:
682 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
684 fs
->cfa_how
= CFA_REG_OFFSET
;
687 case DW_CFA_def_cfa_offset
:
688 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
689 fs
->cfa_offset
= uoffset
;
692 case DW_CFA_def_cfa_expression
:
693 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
694 fs
->cfa_exp
= insn_ptr
;
695 fs
->cfa_how
= CFA_EXP
;
699 case DW_CFA_expression
:
700 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
701 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
702 fs
->regs
.reg
[reg
].how
= REG_SAVED_EXP
;
703 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
707 /* From the 2.1 draft. */
708 case DW_CFA_offset_extended_sf
:
709 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
710 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
711 offset
*= fs
->data_align
;
712 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
713 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
716 case DW_CFA_def_cfa_sf
:
717 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
718 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
719 fs
->cfa_offset
= offset
;
721 fs
->cfa_how
= CFA_REG_OFFSET
;
724 case DW_CFA_def_cfa_offset_sf
:
725 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
726 fs
->cfa_offset
= uoffset
;
727 /* cfa_how deliberately not set. */
730 case DW_CFA_GNU_window_save
:
731 /* ??? Hardcoded for SPARC register window configuration. */
732 for (reg
= 16; reg
< 32; ++reg
)
734 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
735 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * sizeof (void *);
739 case DW_CFA_GNU_args_size
:
740 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
741 context
->args_size
= uoffset
;
744 case DW_CFA_GNU_negative_offset_extended
:
745 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
746 older PowerPC code. */
747 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
748 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
749 offset
= (long) uoffset
*fs
->data_align
;
750 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
751 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
755 error ("dwarf cfi error: unknown cfa instruction %d.", insn
);
760 static struct fde_unit
*
761 get_fde_for_addr (CORE_ADDR pc
)
764 struct fde_unit
*fde
= NULL
;
766 hi
= fde_chunks
.elems
;
770 size_t i
= (lo
+ hi
) / 2;
771 fde
= fde_chunks
.array
[i
];
772 if (pc
< fde
->initial_location
)
774 else if (pc
>= fde
->initial_location
+ fde
->address_range
)
783 frame_state_for (struct context
*context
, struct frame_state
*fs
)
785 struct fde_unit
*fde
;
786 struct cie_unit
*cie
;
788 context
->args_size
= 0;
791 if ((fde
= get_fde_for_addr (context
->ra
- 1)) != NULL
)
793 fs
->pc
= fde
->initial_location
;
796 fs
->code_align
= cie
->code_align
;
797 fs
->data_align
= cie
->data_align
;
798 fs
->retaddr_column
= cie
->ra
;
799 fs
->addr_encoding
= cie
->addr_encoding
;
800 fs
->objfile
= cie
->objfile
;
802 execute_cfa_program (cie
->objfile
, cie
->data
,
803 cie
->data
+ cie
->data_length
, context
, fs
);
804 execute_cfa_program (cie
->objfile
, fde
->data
,
805 fde
->data
+ fde
->data_length
, context
, fs
);
810 get_reg (char *reg
, struct context
*context
, int regnum
)
812 switch (context
->reg
[regnum
].how
)
814 case REG_CTX_UNSAVED
:
815 read_register_gen (regnum
, reg
);
817 case REG_CTX_SAVED_OFFSET
:
818 target_read_memory (context
->cfa
+ context
->reg
[regnum
].loc
.offset
,
819 reg
, REGISTER_RAW_SIZE (regnum
));
821 case REG_CTX_SAVED_REG
:
822 read_register_gen (context
->reg
[regnum
].loc
.reg
, reg
);
824 case REG_CTX_SAVED_ADDR
:
825 target_read_memory (context
->reg
[regnum
].loc
.addr
,
826 reg
, REGISTER_RAW_SIZE (regnum
));
829 memcpy (reg
, &context
->reg
[regnum
].loc
.addr
,
830 REGISTER_RAW_SIZE (regnum
));
833 internal_error (__FILE__
, __LINE__
,
834 "get_reg: unknown register rule");
838 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
839 onto the stack to start. */
841 execute_stack_op (struct objfile
*objfile
,
842 char *op_ptr
, char *op_end
, struct context
*context
,
845 CORE_ADDR stack
[64]; /* ??? Assume this is enough. */
851 while (op_ptr
< op_end
)
853 enum dwarf_location_atom op
= *op_ptr
++;
854 ULONGEST result
, reg
;
891 result
= op
- DW_OP_lit0
;
895 result
= read_pointer (objfile
->obfd
, &op_ptr
);
899 result
= read_1u (objfile
->obfd
, &op_ptr
);
902 result
= read_1s (objfile
->obfd
, &op_ptr
);
905 result
= read_2u (objfile
->obfd
, &op_ptr
);
908 result
= read_2s (objfile
->obfd
, &op_ptr
);
911 result
= read_4u (objfile
->obfd
, &op_ptr
);
914 result
= read_4s (objfile
->obfd
, &op_ptr
);
917 result
= read_8u (objfile
->obfd
, &op_ptr
);
920 result
= read_8s (objfile
->obfd
, &op_ptr
);
923 result
= read_uleb128 (objfile
->obfd
, &op_ptr
);
926 result
= read_sleb128 (objfile
->obfd
, &op_ptr
);
961 get_reg ((char *) &result
, context
, op
- DW_OP_reg0
);
964 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
965 get_reg ((char *) &result
, context
, reg
);
1000 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1001 get_reg ((char *) &result
, context
, op
- DW_OP_breg0
);
1005 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
1006 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1007 get_reg ((char *) &result
, context
, reg
);
1013 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1014 result
= stack
[stack_elt
- 1];
1018 if (--stack_elt
< 0)
1019 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1024 if (offset
>= stack_elt
- 1)
1025 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1026 result
= stack
[stack_elt
- 1 - offset
];
1031 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1032 result
= stack
[stack_elt
- 2];
1037 CORE_ADDR t1
, t2
, t3
;
1040 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1041 t1
= stack
[stack_elt
- 1];
1042 t2
= stack
[stack_elt
- 2];
1043 t3
= stack
[stack_elt
- 3];
1044 stack
[stack_elt
- 1] = t2
;
1045 stack
[stack_elt
- 2] = t3
;
1046 stack
[stack_elt
- 3] = t1
;
1051 case DW_OP_deref_size
:
1055 case DW_OP_plus_uconst
:
1056 /* Unary operations. */
1057 if (--stack_elt
< 0)
1058 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1059 result
= stack
[stack_elt
];
1065 char *ptr
= (char *) result
;
1066 result
= read_pointer (objfile
->obfd
, &ptr
);
1070 case DW_OP_deref_size
:
1072 char *ptr
= (char *) result
;
1076 result
= read_1u (objfile
->obfd
, &ptr
);
1079 result
= read_2u (objfile
->obfd
, &ptr
);
1082 result
= read_4u (objfile
->obfd
, &ptr
);
1085 result
= read_8u (objfile
->obfd
, &ptr
);
1088 internal_error (__FILE__
, __LINE__
,
1089 "execute_stack_op error");
1104 case DW_OP_plus_uconst
:
1105 result
+= read_uleb128 (objfile
->obfd
, &op_ptr
);
1126 /* Binary operations. */
1127 CORE_ADDR first
, second
;
1128 if ((stack_elt
-= 2) < 0)
1129 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1130 second
= stack
[stack_elt
];
1131 first
= stack
[stack_elt
+ 1];
1136 result
= second
& first
;
1139 result
= (LONGEST
) second
/ (LONGEST
) first
;
1142 result
= second
- first
;
1145 result
= (LONGEST
) second
% (LONGEST
) first
;
1148 result
= second
* first
;
1151 result
= second
| first
;
1154 result
= second
+ first
;
1157 result
= second
<< first
;
1160 result
= second
>> first
;
1163 result
= (LONGEST
) second
>> first
;
1166 result
= second
^ first
;
1169 result
= (LONGEST
) first
<= (LONGEST
) second
;
1172 result
= (LONGEST
) first
>= (LONGEST
) second
;
1175 result
= (LONGEST
) first
== (LONGEST
) second
;
1178 result
= (LONGEST
) first
< (LONGEST
) second
;
1181 result
= (LONGEST
) first
> (LONGEST
) second
;
1184 result
= (LONGEST
) first
!= (LONGEST
) second
;
1186 default: /* This label is here just to avoid warning. */
1193 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1198 if (--stack_elt
< 0)
1199 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1200 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1201 if (stack
[stack_elt
] != 0)
1209 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1212 /* Most things push a result value. */
1213 if ((size_t) stack_elt
>= sizeof (stack
) / sizeof (*stack
))
1214 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1215 stack
[++stack_elt
] = result
;
1219 /* We were executing this program to get a value. It should be
1221 if (--stack_elt
< 0)
1222 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1223 return stack
[stack_elt
];
1227 update_context (struct context
*context
, struct frame_state
*fs
, int chain
)
1229 struct context
*orig_context
;
1233 orig_context
= context_alloc ();
1234 context_cpy (orig_context
, context
);
1235 /* Compute this frame's CFA. */
1236 switch (fs
->cfa_how
)
1238 case CFA_REG_OFFSET
:
1239 get_reg ((char *) &cfa
, context
, fs
->cfa_reg
);
1240 cfa
+= fs
->cfa_offset
;
1244 /* ??? No way of knowing what register number is the stack pointer
1245 to do the same sort of handling as above. Assume that if the
1246 CFA calculation is so complicated as to require a stack program
1247 that this will not be a problem. */
1249 char *exp
= fs
->cfa_exp
;
1252 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1253 cfa
= (CORE_ADDR
) execute_stack_op (fs
->objfile
, exp
,
1254 exp
+ len
, context
, 0);
1263 orig_context
->cfa
= cfa
;
1265 /* Compute the addresses of all registers saved in this frame. */
1266 for (i
= 0; i
< NUM_REGS
; ++i
)
1267 switch (fs
->regs
.reg
[i
].how
)
1272 context
->reg
[i
].how
= REG_CTX_VALUE
;
1273 context
->reg
[i
].loc
.addr
= cfa
;
1276 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1278 case REG_SAVED_OFFSET
:
1279 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1280 context
->reg
[i
].loc
.offset
= fs
->regs
.reg
[i
].loc
.offset
;
1283 switch (orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].how
)
1285 case REG_CTX_UNSAVED
:
1286 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1288 case REG_CTX_SAVED_OFFSET
:
1289 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1290 context
->reg
[i
].loc
.offset
= orig_context
->cfa
- context
->cfa
+
1291 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.offset
;
1293 case REG_CTX_SAVED_REG
:
1294 context
->reg
[i
].how
= REG_CTX_SAVED_REG
;
1295 context
->reg
[i
].loc
.reg
=
1296 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.reg
;
1298 case REG_CTX_SAVED_ADDR
:
1299 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1300 context
->reg
[i
].loc
.addr
=
1301 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.addr
;
1303 internal_error (__FILE__
, __LINE__
,
1304 "cfi_update_context: unknown register rule");
1309 char *exp
= fs
->regs
.reg
[i
].loc
.exp
;
1313 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1314 val
= execute_stack_op (fs
->objfile
, exp
, exp
+ len
,
1316 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1317 context
->reg
[i
].loc
.addr
= val
;
1321 internal_error (__FILE__
, __LINE__
,
1322 "cfi_update_context: unknown register rule");
1325 get_reg ((char *) &context
->ra
, context
, fs
->retaddr_column
);
1326 unwind_tmp_obstack_free ();
1330 is_cie (ULONGEST cie_id
, int dwarf64
)
1332 return dwarf64
? (cie_id
== 0xffffffffffffffff) : (cie_id
== 0xffffffff);
1336 compare_fde_unit (const void *a
, const void *b
)
1338 struct fde_unit
**first
, **second
;
1339 first
= (struct fde_unit
**) a
;
1340 second
= (struct fde_unit
**) b
;
1341 if ((*first
)->initial_location
> (*second
)->initial_location
)
1343 else if ((*first
)->initial_location
< (*second
)->initial_location
)
1349 /* Build the cie_chunks and fde_chunks tables from informations
1350 in .debug_frame section. */
1352 dwarf2_build_frame_info (struct objfile
*objfile
)
1354 bfd
*abfd
= objfile
->obfd
;
1358 obstack_init (&unwind_tmp_obstack
);
1360 dwarf_frame_buffer
= 0;
1362 if (dwarf_frame_offset
)
1364 dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1368 start
= dwarf_frame_buffer
;
1369 end
= dwarf_frame_buffer
+ dwarf_frame_size
;
1371 else if (dwarf_eh_frame_offset
)
1373 dwarf_frame_buffer
= dwarf2_read_section (objfile
,
1374 dwarf_eh_frame_offset
,
1375 dwarf_eh_frame_size
);
1377 start
= dwarf_frame_buffer
;
1378 end
= dwarf_frame_buffer
+ dwarf_eh_frame_size
;
1385 unsigned long length
;
1387 ULONGEST unit_offset
= start
- dwarf_frame_buffer
;
1392 length
= read_initial_length (abfd
, start
, &bytes_read
);
1393 start
+= bytes_read
;
1394 dwarf64
= (bytes_read
== 12);
1395 block_end
= start
+ length
;
1397 cie_id
= read_length (abfd
, start
, &bytes_read
, dwarf64
);
1398 start
+= bytes_read
;
1400 if (is_cie (cie_id
, dwarf64
))
1402 struct cie_unit
*cie
= cie_unit_alloc ();
1405 cie
->objfile
= objfile
;
1406 cie
->next
= cie_chunks
;
1409 cie
->objfile
= objfile
;
1411 cie
->offset
= unit_offset
;
1413 start
++; /* version */
1415 cie
->augmentation
= aug
= start
;
1418 start
++; /* skip past NUL */
1420 cie
->code_align
= read_uleb128 (abfd
, &start
);
1421 cie
->data_align
= read_sleb128 (abfd
, &start
);
1422 cie
->ra
= read_1u (abfd
, &start
);
1426 int xtra
= read_uleb128 (abfd
, &start
);
1431 while (*aug
!= '\0')
1433 if (aug
[0] == 'e' && aug
[1] == 'h')
1435 start
+= sizeof (void *);
1438 else if (aug
[0] == 'R')
1440 cie
->addr_encoding
= *start
++;
1443 else if (aug
[0] == 'P')
1446 ptr
= read_encoded_pointer (abfd
, &start
,
1447 cie
->addr_encoding
);
1451 warning ("unknown augmentation");
1455 cie
->data_length
= block_end
- start
;
1459 struct fde_unit
*fde
;
1460 struct cie_unit
*cie
;
1462 fde_chunks_need_space ();
1463 fde
= fde_unit_alloc ();
1465 fde_chunks
.array
[fde_chunks
.elems
++] = fde
;
1466 fde
->initial_location
= read_pointer (abfd
, &start
);
1467 fde
->address_range
= read_pointer (abfd
, &start
);
1469 for (cie
= cie_chunks
;
1470 cie
&& (cie
->offset
!= cie_id
); cie
= cie
->next
);
1472 error ("dwarf cfi error: can't find CIE pointer");
1475 if (cie
->augmentation
[0] == 'z')
1476 read_uleb128 (abfd
, &start
);
1479 fde
->data_length
= block_end
- start
;
1483 qsort (fde_chunks
.array
, fde_chunks
.elems
,
1484 sizeof (struct fde_unit
*), compare_fde_unit
);
1489 /* Return the frame address. */
1493 struct context
*context
;
1494 struct frame_state
*fs
;
1497 context
= context_alloc ();
1498 fs
= frame_state_alloc ();
1500 context
->ra
= read_pc () + 1;
1502 frame_state_for (context
, fs
);
1503 update_context (context
, fs
, 0);
1506 unwind_tmp_obstack_free ();
1510 /* Store the frame address. This function is not used. */
1513 cfi_write_fp (CORE_ADDR val
)
1515 struct context
*context
;
1516 struct frame_state
*fs
;
1518 context
= context_alloc ();
1519 fs
= frame_state_alloc ();
1521 context
->ra
= read_pc () + 1;
1523 frame_state_for (context
, fs
);
1525 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1527 val
-= fs
->cfa_offset
;
1528 write_register_gen (fs
->cfa_reg
, (char *) &val
);
1531 warning ("Can't write fp.");
1533 unwind_tmp_obstack_free ();
1536 /* Restore the machine to the state it had before the current frame
1539 cfi_pop_frame (struct frame_info
*fi
)
1541 char regbuf
[MAX_REGISTER_RAW_SIZE
];
1544 fi
= get_current_frame ();
1546 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1548 get_reg (regbuf
, UNWIND_CONTEXT (fi
), regnum
);
1549 write_register_bytes (REGISTER_BYTE (regnum
), regbuf
,
1550 REGISTER_RAW_SIZE (regnum
));
1552 write_register (PC_REGNUM
, UNWIND_CONTEXT (fi
)->ra
);
1554 flush_cached_frames ();
1557 /* Determine the address of the calling function's frame. */
1559 cfi_frame_chain (struct frame_info
*fi
)
1561 struct context
*context
;
1562 struct frame_state
*fs
;
1565 context
= context_alloc ();
1566 fs
= frame_state_alloc ();
1567 context_cpy (context
, UNWIND_CONTEXT (fi
));
1569 /* outermost frame */
1570 if (context
->ra
== 0)
1572 unwind_tmp_obstack_free ();
1576 frame_state_for (context
, fs
);
1577 update_context (context
, fs
, 1);
1580 unwind_tmp_obstack_free ();
1584 /* Sets the pc of the frame. */
1586 cfi_init_frame_pc (int fromleaf
, struct frame_info
*fi
)
1589 get_reg ((char *) &(fi
->pc
), UNWIND_CONTEXT (fi
->next
), PC_REGNUM
);
1591 fi
->pc
= read_pc ();
1594 /* Initialize unwind context informations of the frame. */
1596 cfi_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1598 struct frame_state
*fs
;
1600 fs
= frame_state_alloc ();
1601 fi
->context
= frame_obstack_alloc (sizeof (struct context
));
1602 UNWIND_CONTEXT (fi
)->reg
=
1603 frame_obstack_alloc (sizeof (struct context_reg
) * NUM_REGS
);
1604 memset (UNWIND_CONTEXT (fi
)->reg
, 0,
1605 sizeof (struct context_reg
) * NUM_REGS
);
1609 context_cpy (UNWIND_CONTEXT (fi
), UNWIND_CONTEXT (fi
->next
));
1610 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1611 update_context (UNWIND_CONTEXT (fi
), fs
, 1);
1615 UNWIND_CONTEXT (fi
)->ra
= fi
->pc
+ 1;
1616 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1617 update_context (UNWIND_CONTEXT (fi
), fs
, 0);
1619 unwind_tmp_obstack_free ();
1622 /* Obtain return address of the frame. */
1624 cfi_get_ra (struct frame_info
*fi
)
1626 return UNWIND_CONTEXT (fi
)->ra
;
1629 /* Find register number REGNUM relative to FRAME and put its
1630 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
1631 was optimized out (and thus can't be fetched). If the variable
1632 was fetched from memory, set *ADDRP to where it was fetched from,
1633 otherwise it was fetched from a register.
1635 The argument RAW_BUFFER must point to aligned memory. */
1637 cfi_get_saved_register (char *raw_buffer
,
1640 struct frame_info
*frame
,
1641 int regnum
, enum lval_type
*lval
)
1643 if (!target_has_registers
)
1644 error ("No registers.");
1646 /* Normal systems don't optimize out things with register numbers. */
1647 if (optimized
!= NULL
)
1650 if (addrp
) /* default assumption: not found in memory */
1655 read_register_gen (regnum
, raw_buffer
);
1657 *lval
= lval_register
;
1659 *addrp
= REGISTER_BYTE (regnum
);
1663 frame
= frame
->next
;
1664 switch (UNWIND_CONTEXT (frame
)->reg
[regnum
].how
)
1666 case REG_CTX_UNSAVED
:
1667 read_register_gen (regnum
, raw_buffer
);
1670 if (optimized
!= NULL
)
1673 case REG_CTX_SAVED_OFFSET
:
1674 target_read_memory (UNWIND_CONTEXT (frame
)->cfa
+
1675 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
,
1676 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1678 *lval
= lval_memory
;
1681 UNWIND_CONTEXT (frame
)->cfa
+
1682 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
;
1684 case REG_CTX_SAVED_REG
:
1685 read_register_gen (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
,
1688 *lval
= lval_register
;
1691 REGISTER_BYTE (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
);
1693 case REG_CTX_SAVED_ADDR
:
1694 target_read_memory (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1695 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1697 *lval
= lval_memory
;
1699 *addrp
= UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
;
1702 memcpy (raw_buffer
, &UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1703 REGISTER_RAW_SIZE (regnum
));
1706 if (optimized
!= NULL
)
1710 internal_error (__FILE__
, __LINE__
,
1711 "cfi_get_saved_register: unknown register rule");
1716 /* Return the register that the function uses for a frame pointer,
1717 plus any necessary offset to be applied to the register before
1718 any frame pointer offsets. */
1720 cfi_virtual_frame_pointer (CORE_ADDR pc
, int *frame_reg
,
1721 LONGEST
* frame_offset
)
1723 struct context
*context
;
1724 struct frame_state
*fs
;
1726 context
= context_alloc ();
1727 fs
= frame_state_alloc ();
1729 context
->ra
= read_pc () + 1;
1731 frame_state_for (context
, fs
);
1733 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1735 *frame_reg
= fs
->cfa_reg
;
1736 *frame_offset
= fs
->cfa_offset
;
1739 error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1741 unwind_tmp_obstack_free ();