1 /* Stack unwinding code based on dwarf2 frame info for GDB, the GNU debugger.
3 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
5 Contributed by Jiri Smid, SuSE Labs.
6 Based on code written by Daniel Berlin (dan@dberlin.org).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
31 #include "elf/dwarf2.h"
34 #include "dwarf2cfi.h"
35 #include "gdb_assert.h"
37 /* Common Information Entry - holds information that is shared among many
41 /* Offset of this unit in .debug_frame or .eh_frame. */
44 /* A null-terminated string that identifies the augmentation to this CIE or
45 to the FDEs that use it. */
48 /* A constant that is factored out of all advance location instructions. */
49 unsigned int code_align
;
51 /* A constant that is factored out of all offset instructions. */
54 /* A constant that indicates which regiter represents the return address
58 /* Indicates how addresses are encoded. */
59 unsigned char addr_encoding
;
61 /* Pointer and length of the cie program. */
63 unsigned int data_length
;
65 struct objfile
*objfile
;
68 struct cie_unit
*next
;
71 /* Frame Description Entry. */
74 /* Address of the first location associated with this entry. */
75 CORE_ADDR initial_location
;
77 /* Length of program section described by this entry. */
78 CORE_ADDR address_range
;
80 /* Pointer to asociated CIE. */
81 struct cie_unit
*cie_ptr
;
83 /* Pointer and length of the cie program. */
85 unsigned int data_length
;
90 struct fde_unit
**array
;
95 struct frame_state_reg
116 /* Each register save state can be described in terms of a CFA slot,
117 another register, or a location expression. */
118 struct frame_state_regs
120 struct frame_state_reg
*reg
;
122 /* Used to implement DW_CFA_remember_state. */
123 struct frame_state_regs
*prev
;
127 /* The CFA can be described in terms of a reg+offset or a
128 location expression. */
131 unsigned char *cfa_exp
;
140 /* The PC described by the current frame state. */
143 /* The information we care about from the CIE/FDE. */
145 unsigned int code_align
;
146 unsigned char retaddr_column
;
147 unsigned char addr_encoding
;
149 struct objfile
*objfile
;
154 PE_absptr
= DW_EH_PE_absptr
,
155 PE_pcrel
= DW_EH_PE_pcrel
,
156 PE_textrel
= DW_EH_PE_textrel
,
157 PE_datarel
= DW_EH_PE_datarel
,
158 PE_funcrel
= DW_EH_PE_funcrel
161 #define UNWIND_CONTEXT(fi) ((struct context *) (deprecated_get_frame_context (fi)))
164 static struct cie_unit
*cie_chunks
;
165 static struct fde_array fde_chunks
;
166 /* Obstack for allocating temporary storage used during unwind operations. */
167 static struct obstack unwind_tmp_obstack
;
169 extern file_ptr dwarf_frame_offset
;
170 extern unsigned int dwarf_frame_size
;
171 extern file_ptr dwarf_eh_frame_offset
;
172 extern unsigned int dwarf_eh_frame_size
;
173 extern asection
*dwarf_frame_section
;
174 extern asection
*dwarf_eh_frame_section
;
178 extern char *dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
179 unsigned int size
, asection
*sectp
);
181 static struct fde_unit
*fde_unit_alloc (void);
182 static struct cie_unit
*cie_unit_alloc (void);
183 static void fde_chunks_need_space ();
185 static void unwind_tmp_obstack_init ();
186 static void unwind_tmp_obstack_free ();
188 static unsigned int read_1u (bfd
*abfd
, char **p
);
189 static int read_1s (bfd
*abfd
, char **p
);
190 static unsigned int read_2u (bfd
*abfd
, char **p
);
191 static int read_2s (bfd
*abfd
, char **p
);
192 static unsigned int read_4u (bfd
*abfd
, char **p
);
193 static int read_4s (bfd
*abfd
, char **p
);
194 static ULONGEST
read_8u (bfd
*abfd
, char **p
);
195 static LONGEST
read_8s (bfd
*abfd
, char **p
);
197 static ULONGEST
read_uleb128 (bfd
*abfd
, char **p
);
198 static LONGEST
read_sleb128 (bfd
*abfd
, char **p
);
199 static CORE_ADDR
read_pointer (bfd
*abfd
, char **p
);
200 static CORE_ADDR
read_encoded_pointer (bfd
*abfd
, char **p
,
201 unsigned char encoding
);
202 static enum ptr_encoding
pointer_encoding (unsigned char encoding
,
203 struct objfile
*objfile
);
205 static LONGEST
read_initial_length (bfd
*abfd
, char *buf
, int *bytes_read
);
206 static ULONGEST
read_length (bfd
*abfd
, char *buf
, int *bytes_read
,
209 static int is_cie (ULONGEST cie_id
, int dwarf64
);
210 static int compare_fde_unit (const void *a
, const void *b
);
211 void dwarf2_build_frame_info (struct objfile
*objfile
);
213 static void execute_cfa_program (struct objfile
*objfile
, char *insn_ptr
,
214 char *insn_end
, struct context
*context
,
215 struct frame_state
*fs
);
216 static struct fde_unit
*get_fde_for_addr (CORE_ADDR pc
);
217 static void frame_state_for (struct context
*context
, struct frame_state
*fs
);
218 static void get_reg (char *reg
, struct context
*context
, int regnum
);
219 static CORE_ADDR
execute_stack_op (struct objfile
*objfile
,
220 char *op_ptr
, char *op_end
,
221 struct context
*context
,
223 static void update_context (struct context
*context
, struct frame_state
*fs
,
227 /* Memory allocation functions. */
228 static struct fde_unit
*
229 fde_unit_alloc (void)
231 struct fde_unit
*fde
;
233 fde
= (struct fde_unit
*) xmalloc (sizeof (struct fde_unit
));
234 memset (fde
, 0, sizeof (struct fde_unit
));
238 static struct cie_unit
*
239 cie_unit_alloc (void)
241 struct cie_unit
*cie
;
243 cie
= (struct cie_unit
*) xmalloc (sizeof (struct cie_unit
));
244 memset (cie
, 0, sizeof (struct cie_unit
));
249 fde_chunks_need_space (void)
251 if (fde_chunks
.elems
< fde_chunks
.array_size
)
253 fde_chunks
.array_size
=
254 fde_chunks
.array_size
? 2 * fde_chunks
.array_size
: 1024;
256 xrealloc (fde_chunks
.array
,
257 sizeof (struct fde_unit
) * fde_chunks
.array_size
);
260 /* Alocate a new `struct context' on temporary obstack. */
264 struct context
*context
;
266 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
268 context
= (struct context
*) obstack_alloc (&unwind_tmp_obstack
,
269 sizeof (struct context
));
270 memset (context
, 0, sizeof (struct context
));
271 context
->reg
= (struct context_reg
*) obstack_alloc (&unwind_tmp_obstack
,
273 memset (context
->reg
, 0, regs_size
);
277 /* Alocate a new `struct frame_state' on temporary obstack. */
279 frame_state_alloc (void)
281 struct frame_state
*fs
;
283 int regs_size
= sizeof (struct frame_state_reg
) * NUM_REGS
;
285 fs
= (struct frame_state
*) obstack_alloc (&unwind_tmp_obstack
,
286 sizeof (struct frame_state
));
287 memset (fs
, 0, sizeof (struct frame_state
));
289 (struct frame_state_reg
*) obstack_alloc (&unwind_tmp_obstack
, regs_size
);
290 memset (fs
->regs
.reg
, 0, regs_size
);
295 unwind_tmp_obstack_init (void)
297 obstack_init (&unwind_tmp_obstack
);
301 unwind_tmp_obstack_free (void)
303 obstack_free (&unwind_tmp_obstack
, NULL
);
304 unwind_tmp_obstack_init ();
308 context_cpy (struct context
*dst
, struct context
*src
)
310 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
311 struct context_reg
*dreg
;
313 /* Since `struct context' contains a pointer to an array with
314 register values, make sure we end up with a copy of that array,
315 and not with a copy of the pointer to that array. */
319 memcpy (dst
->reg
, src
->reg
, regs_size
);
323 read_1u (bfd
*abfd
, char **p
)
327 ret
= bfd_get_8 (abfd
, (bfd_byte
*) * p
);
333 read_1s (bfd
*abfd
, char **p
)
337 ret
= bfd_get_signed_8 (abfd
, (bfd_byte
*) * p
);
343 read_2u (bfd
*abfd
, char **p
)
347 ret
= bfd_get_16 (abfd
, (bfd_byte
*) * p
);
353 read_2s (bfd
*abfd
, char **p
)
357 ret
= bfd_get_signed_16 (abfd
, (bfd_byte
*) * p
);
363 read_4u (bfd
*abfd
, char **p
)
367 ret
= bfd_get_32 (abfd
, (bfd_byte
*) * p
);
373 read_4s (bfd
*abfd
, char **p
)
377 ret
= bfd_get_signed_32 (abfd
, (bfd_byte
*) * p
);
383 read_8u (bfd
*abfd
, char **p
)
387 ret
= bfd_get_64 (abfd
, (bfd_byte
*) * p
);
393 read_8s (bfd
*abfd
, char **p
)
397 ret
= bfd_get_signed_64 (abfd
, (bfd_byte
*) * p
);
403 read_uleb128 (bfd
*abfd
, char **p
)
414 byte
= bfd_get_8 (abfd
, (bfd_byte
*) * p
);
416 ret
|= ((unsigned long) (byte
& 127) << shift
);
417 if ((byte
& 128) == 0)
427 read_sleb128 (bfd
*abfd
, char **p
)
430 int i
, shift
, size
, num_read
;
440 byte
= bfd_get_8 (abfd
, (bfd_byte
*) * p
);
442 ret
|= ((long) (byte
& 127) << shift
);
444 if ((byte
& 128) == 0)
449 if ((shift
< size
) && (byte
& 0x40))
451 ret
|= -(1 << shift
);
457 read_pointer (bfd
*abfd
, char **p
)
459 switch (TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
)
462 return read_4u (abfd
, p
);
464 return read_8u (abfd
, p
);
467 ("dwarf cfi error: unsupported target address length [in module %s]",
468 bfd_get_filename (abfd
));
472 /* Read the appropriate amount of data from *P and return the
473 resulting value based on ENCODING, which the calling function must
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 [in module %s]",
516 bfd_get_filename (abfd
));
522 /* The variable 'encoding' carries three different flags:
523 - encoding & 0x0f : size of the address (handled in read_encoded_pointer())
524 - encoding & 0x70 : type (absolute, relative, ...)
525 - encoding & 0x80 : indirect flag (DW_EH_PE_indirect == 0x80). */
527 pointer_encoding (unsigned char encoding
, struct objfile
*objfile
)
531 if (encoding
& DW_EH_PE_indirect
)
533 ("CFI: Unsupported pointer encoding: DW_EH_PE_indirect [in module %s]",
536 switch (encoding
& 0x70)
538 case DW_EH_PE_absptr
:
540 case DW_EH_PE_textrel
:
541 case DW_EH_PE_datarel
:
542 case DW_EH_PE_funcrel
:
543 ret
= encoding
& 0x70;
546 internal_error (__FILE__
, __LINE__
,
547 "CFI: unknown pointer encoding [in module %s]",
554 read_initial_length (bfd
*abfd
, char *buf
, int *bytes_read
)
558 ret
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
560 if (ret
== 0xffffffff)
562 ret
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
574 read_length (bfd
*abfd
, char *buf
, int *bytes_read
, int dwarf64
)
579 return read_8u (abfd
, &buf
);
584 return read_4u (abfd
, &buf
);
589 execute_cfa_program (struct objfile
*objfile
, char *insn_ptr
, char *insn_end
,
590 struct context
*context
, struct frame_state
*fs
)
592 struct frame_state_regs
*unused_rs
= NULL
;
594 /* Don't allow remember/restore between CIE and FDE programs. */
595 fs
->regs
.prev
= NULL
;
597 while (insn_ptr
< insn_end
&& fs
->pc
< context
->ra
)
599 unsigned char insn
= *insn_ptr
++;
600 ULONGEST reg
, uoffset
;
603 if (insn
& DW_CFA_advance_loc
)
604 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
605 else if (insn
& DW_CFA_offset
)
608 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
609 offset
= (long) uoffset
*fs
->data_align
;
610 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
611 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
613 else if (insn
& DW_CFA_restore
)
616 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
622 fs
->pc
= read_encoded_pointer (objfile
->obfd
, &insn_ptr
,
625 if (pointer_encoding (fs
->addr_encoding
, objfile
) != PE_absptr
)
627 ("CFI: DW_CFA_set_loc uses relative addressing [in module %s]",
632 case DW_CFA_advance_loc1
:
633 fs
->pc
+= read_1u (objfile
->obfd
, &insn_ptr
);
635 case DW_CFA_advance_loc2
:
636 fs
->pc
+= read_2u (objfile
->obfd
, &insn_ptr
);
638 case DW_CFA_advance_loc4
:
639 fs
->pc
+= read_4u (objfile
->obfd
, &insn_ptr
);
642 case DW_CFA_offset_extended
:
643 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
644 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
645 offset
= (long) uoffset
*fs
->data_align
;
646 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
647 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
650 case DW_CFA_restore_extended
:
651 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
652 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
655 case DW_CFA_undefined
:
656 case DW_CFA_same_value
:
660 case DW_CFA_register
:
663 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
664 reg2
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
665 fs
->regs
.reg
[reg
].how
= REG_SAVED_REG
;
666 fs
->regs
.reg
[reg
].loc
.reg
= reg2
;
670 case DW_CFA_remember_state
:
672 struct frame_state_regs
*new_rs
;
676 unused_rs
= unused_rs
->prev
;
679 new_rs
= xmalloc (sizeof (struct frame_state_regs
));
682 fs
->regs
.prev
= new_rs
;
686 case DW_CFA_restore_state
:
688 struct frame_state_regs
*old_rs
= fs
->regs
.prev
;
690 old_rs
->prev
= unused_rs
;
696 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
697 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
699 fs
->cfa_offset
= uoffset
;
700 fs
->cfa_how
= CFA_REG_OFFSET
;
703 case DW_CFA_def_cfa_register
:
704 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
706 fs
->cfa_how
= CFA_REG_OFFSET
;
709 case DW_CFA_def_cfa_offset
:
710 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
711 fs
->cfa_offset
= uoffset
;
714 case DW_CFA_def_cfa_expression
:
715 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
716 fs
->cfa_exp
= insn_ptr
;
717 fs
->cfa_how
= CFA_EXP
;
721 case DW_CFA_expression
:
722 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
723 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
724 fs
->regs
.reg
[reg
].how
= REG_SAVED_EXP
;
725 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
729 /* From the 2.1 draft. */
730 case DW_CFA_offset_extended_sf
:
731 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
732 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
733 offset
*= fs
->data_align
;
734 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
735 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
738 case DW_CFA_def_cfa_sf
:
739 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
740 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
741 fs
->cfa_offset
= offset
;
743 fs
->cfa_how
= CFA_REG_OFFSET
;
746 case DW_CFA_def_cfa_offset_sf
:
747 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
748 fs
->cfa_offset
= uoffset
;
749 /* cfa_how deliberately not set. */
752 case DW_CFA_GNU_window_save
:
753 /* ??? Hardcoded for SPARC register window configuration. */
754 for (reg
= 16; reg
< 32; ++reg
)
756 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
757 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * sizeof (void *);
761 case DW_CFA_GNU_args_size
:
762 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
763 context
->args_size
= uoffset
;
766 case DW_CFA_GNU_negative_offset_extended
:
767 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
768 older PowerPC code. */
769 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
770 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
771 offset
= (long) uoffset
*fs
->data_align
;
772 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
773 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
778 ("dwarf cfi error: unknown cfa instruction %d [in module %s]",
779 insn
, objfile
->name
);
784 static struct fde_unit
*
785 get_fde_for_addr (CORE_ADDR pc
)
788 struct fde_unit
*fde
= NULL
;
790 hi
= fde_chunks
.elems
;
794 size_t i
= (lo
+ hi
) / 2;
795 fde
= fde_chunks
.array
[i
];
796 if (pc
< fde
->initial_location
)
798 else if (pc
>= fde
->initial_location
+ fde
->address_range
)
807 frame_state_for (struct context
*context
, struct frame_state
*fs
)
809 struct fde_unit
*fde
;
810 struct cie_unit
*cie
;
812 context
->args_size
= 0;
815 fde
= get_fde_for_addr (context
->ra
- 1);
820 fs
->pc
= fde
->initial_location
;
822 gdb_assert (fde
->cie_ptr
!= NULL
);
826 fs
->code_align
= cie
->code_align
;
827 fs
->data_align
= cie
->data_align
;
828 fs
->retaddr_column
= cie
->ra
;
829 fs
->addr_encoding
= cie
->addr_encoding
;
830 fs
->objfile
= cie
->objfile
;
832 execute_cfa_program (cie
->objfile
, cie
->data
,
833 cie
->data
+ cie
->data_length
, context
, fs
);
834 execute_cfa_program (cie
->objfile
, fde
->data
,
835 fde
->data
+ fde
->data_length
, context
, fs
);
839 get_reg (char *reg
, struct context
*context
, int regnum
)
841 switch (context
->reg
[regnum
].how
)
843 case REG_CTX_UNSAVED
:
844 deprecated_read_register_gen (regnum
, reg
);
846 case REG_CTX_SAVED_OFFSET
:
847 target_read_memory (context
->cfa
+ context
->reg
[regnum
].loc
.offset
,
848 reg
, REGISTER_RAW_SIZE (regnum
));
850 case REG_CTX_SAVED_REG
:
851 deprecated_read_register_gen (context
->reg
[regnum
].loc
.reg
, reg
);
853 case REG_CTX_SAVED_ADDR
:
854 target_read_memory (context
->reg
[regnum
].loc
.addr
,
855 reg
, REGISTER_RAW_SIZE (regnum
));
858 memcpy (reg
, &context
->reg
[regnum
].loc
.addr
,
859 REGISTER_RAW_SIZE (regnum
));
862 internal_error (__FILE__
, __LINE__
, "get_reg: unknown register rule");
866 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
867 onto the stack to start. */
869 execute_stack_op (struct objfile
*objfile
,
870 char *op_ptr
, char *op_end
, struct context
*context
,
873 CORE_ADDR stack
[64]; /* ??? Assume this is enough. */
879 while (op_ptr
< op_end
)
881 enum dwarf_location_atom op
= *op_ptr
++;
920 result
= op
- DW_OP_lit0
;
924 result
= read_pointer (objfile
->obfd
, &op_ptr
);
928 result
= read_1u (objfile
->obfd
, &op_ptr
);
931 result
= read_1s (objfile
->obfd
, &op_ptr
);
934 result
= read_2u (objfile
->obfd
, &op_ptr
);
937 result
= read_2s (objfile
->obfd
, &op_ptr
);
940 result
= read_4u (objfile
->obfd
, &op_ptr
);
943 result
= read_4s (objfile
->obfd
, &op_ptr
);
946 result
= read_8u (objfile
->obfd
, &op_ptr
);
949 result
= read_8s (objfile
->obfd
, &op_ptr
);
952 result
= read_uleb128 (objfile
->obfd
, &op_ptr
);
955 result
= read_sleb128 (objfile
->obfd
, &op_ptr
);
990 get_reg ((char *) &result
, context
, op
- DW_OP_reg0
);
993 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
994 get_reg ((char *) &result
, context
, reg
);
1029 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1030 get_reg ((char *) &result
, context
, op
- DW_OP_breg0
);
1034 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
1035 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1036 get_reg ((char *) &result
, context
, reg
);
1042 internal_error (__FILE__
, __LINE__
,
1043 "execute_stack_op error [in module %s]",
1045 result
= stack
[stack_elt
- 1];
1049 if (--stack_elt
< 0)
1050 internal_error (__FILE__
, __LINE__
,
1051 "execute_stack_op error [in module %s]",
1057 if (offset
>= stack_elt
- 1)
1058 internal_error (__FILE__
, __LINE__
,
1059 "execute_stack_op error [in module %s]",
1061 result
= stack
[stack_elt
- 1 - offset
];
1066 internal_error (__FILE__
, __LINE__
,
1067 "execute_stack_op error [in module %s]",
1069 result
= stack
[stack_elt
- 2];
1074 CORE_ADDR t1
, t2
, t3
;
1077 internal_error (__FILE__
, __LINE__
,
1078 "execute_stack_op error [in module %s]",
1080 t1
= stack
[stack_elt
- 1];
1081 t2
= stack
[stack_elt
- 2];
1082 t3
= stack
[stack_elt
- 3];
1083 stack
[stack_elt
- 1] = t2
;
1084 stack
[stack_elt
- 2] = t3
;
1085 stack
[stack_elt
- 3] = t1
;
1090 case DW_OP_deref_size
:
1094 case DW_OP_plus_uconst
:
1095 /* Unary operations. */
1096 if (--stack_elt
< 0)
1097 internal_error (__FILE__
, __LINE__
,
1098 "execute_stack_op error [in module %s]",
1100 result
= stack
[stack_elt
];
1106 int len
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
;
1107 if (len
!= 4 && len
!= 8)
1108 internal_error (__FILE__
, __LINE__
,
1109 "execute_stack_op error [in module %s]",
1111 result
= read_memory_unsigned_integer (result
, len
);
1115 case DW_OP_deref_size
:
1117 int len
= *op_ptr
++;
1118 if (len
!= 1 && len
!= 2 && len
!= 4 && len
!= 8)
1119 internal_error (__FILE__
, __LINE__
,
1120 "execute_stack_op error [in module %s]",
1122 result
= read_memory_unsigned_integer (result
, len
);
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__
,
1162 "execute_stack_op error [in module %s]",
1164 second
= stack
[stack_elt
];
1165 first
= stack
[stack_elt
+ 1];
1170 result
= second
& first
;
1173 result
= (LONGEST
) second
/ (LONGEST
) first
;
1176 result
= second
- first
;
1179 result
= (LONGEST
) second
% (LONGEST
) first
;
1182 result
= second
* first
;
1185 result
= second
| first
;
1188 result
= second
+ first
;
1191 result
= second
<< first
;
1194 result
= second
>> first
;
1197 result
= (LONGEST
) second
>> first
;
1200 result
= second
^ first
;
1203 result
= (LONGEST
) first
<= (LONGEST
) second
;
1206 result
= (LONGEST
) first
>= (LONGEST
) second
;
1209 result
= (LONGEST
) first
== (LONGEST
) second
;
1212 result
= (LONGEST
) first
< (LONGEST
) second
;
1215 result
= (LONGEST
) first
> (LONGEST
) second
;
1218 result
= (LONGEST
) first
!= (LONGEST
) second
;
1222 ("execute_stack_op: Unknown DW_OP_ value [in module %s]",
1230 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1235 if (--stack_elt
< 0)
1236 internal_error (__FILE__
, __LINE__
,
1237 "execute_stack_op error [in module %s]",
1239 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1240 if (stack
[stack_elt
] != 0)
1248 internal_error (__FILE__
, __LINE__
,
1249 "execute_stack_op error [in module %s]",
1253 /* Most things push a result value. */
1254 if ((size_t) stack_elt
>= sizeof (stack
) / sizeof (*stack
))
1255 internal_error (__FILE__
, __LINE__
,
1256 "execute_stack_op error [in module %s]",
1258 stack
[++stack_elt
] = result
;
1262 /* We were executing this program to get a value. It should be
1264 if (--stack_elt
< 0)
1265 internal_error (__FILE__
, __LINE__
,
1266 "execute_stack_op error [in module %s]", objfile
->name
);
1267 return stack
[stack_elt
];
1271 update_context (struct context
*context
, struct frame_state
*fs
, int chain
)
1273 struct context
*orig_context
;
1277 unwind_tmp_obstack_init ();
1279 orig_context
= context_alloc ();
1280 context_cpy (orig_context
, context
);
1282 /* Compute this frame's CFA. */
1283 switch (fs
->cfa_how
)
1285 case CFA_REG_OFFSET
:
1286 get_reg ((char *) &cfa
, context
, fs
->cfa_reg
);
1287 cfa
+= fs
->cfa_offset
;
1291 /* ??? No way of knowing what register number is the stack pointer
1292 to do the same sort of handling as above. Assume that if the
1293 CFA calculation is so complicated as to require a stack program
1294 that this will not be a problem. */
1296 char *exp
= fs
->cfa_exp
;
1299 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1300 cfa
= (CORE_ADDR
) execute_stack_op (fs
->objfile
, exp
,
1301 exp
+ len
, context
, 0);
1310 orig_context
->cfa
= cfa
;
1312 /* Compute the addresses of all registers saved in this frame. */
1313 for (i
= 0; i
< NUM_REGS
; ++i
)
1314 switch (fs
->regs
.reg
[i
].how
)
1319 context
->reg
[i
].how
= REG_CTX_VALUE
;
1320 context
->reg
[i
].loc
.addr
= cfa
;
1323 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1325 case REG_SAVED_OFFSET
:
1326 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1327 context
->reg
[i
].loc
.offset
= fs
->regs
.reg
[i
].loc
.offset
;
1330 switch (orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].how
)
1332 case REG_CTX_UNSAVED
:
1333 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1335 case REG_CTX_SAVED_OFFSET
:
1336 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1337 context
->reg
[i
].loc
.offset
= orig_context
->cfa
- context
->cfa
+
1338 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.offset
;
1340 case REG_CTX_SAVED_REG
:
1341 context
->reg
[i
].how
= REG_CTX_SAVED_REG
;
1342 context
->reg
[i
].loc
.reg
=
1343 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.reg
;
1345 case REG_CTX_SAVED_ADDR
:
1346 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1347 context
->reg
[i
].loc
.addr
=
1348 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.addr
;
1351 internal_error (__FILE__
, __LINE__
, "bad switch 0x%02X",
1352 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].how
);
1357 char *exp
= fs
->regs
.reg
[i
].loc
.exp
;
1361 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1362 val
= execute_stack_op (fs
->objfile
, exp
, exp
+ len
,
1364 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1365 context
->reg
[i
].loc
.addr
= val
;
1369 internal_error (__FILE__
, __LINE__
, "bad switch 0x%02X",
1370 fs
->regs
.reg
[i
].how
);
1372 get_reg ((char *) &context
->ra
, context
, fs
->retaddr_column
);
1373 unwind_tmp_obstack_free ();
1377 is_cie (ULONGEST cie_id
, int dwarf64
)
1379 return dwarf64
? (cie_id
== 0xffffffffffffffff) : (cie_id
== 0xffffffff);
1383 compare_fde_unit (const void *a
, const void *b
)
1385 struct fde_unit
**first
, **second
;
1386 first
= (struct fde_unit
**) a
;
1387 second
= (struct fde_unit
**) b
;
1388 if ((*first
)->initial_location
> (*second
)->initial_location
)
1390 else if ((*first
)->initial_location
< (*second
)->initial_location
)
1396 /* Build the cie_chunks and fde_chunks tables from informations
1397 found in .debug_frame and .eh_frame sections. */
1398 /* We can handle both of these sections almost in the same way, however there
1399 are some exceptions:
1400 - CIE ID is -1 in debug_frame, but 0 in eh_frame
1401 - eh_frame may contain some more information that are used only by gcc
1402 (eg. personality pointer, LSDA pointer, ...). Most of them we can ignore.
1403 - In debug_frame FDE's item cie_id contains offset of it's parent CIE.
1404 In eh_frame FDE's item cie_id is a relative pointer to the parent CIE.
1405 Anyway we don't need to bother with this, because we are smart enough
1406 to keep the pointer to the parent CIE of oncomming FDEs in 'last_cie'.
1407 - Although debug_frame items can contain Augmentation as well as
1408 eh_frame ones, I have never seen them non-empty. Thus only in eh_frame
1409 we can encounter for example non-absolute pointers (Aug. 'R').
1412 parse_frame_info (struct objfile
*objfile
, file_ptr frame_offset
,
1413 unsigned int frame_size
, asection
*frame_section
,
1416 bfd
*abfd
= objfile
->obfd
;
1417 asection
*curr_section_ptr
;
1420 char *frame_buffer
= NULL
;
1421 char *curr_section_name
, *aug_data
;
1422 struct cie_unit
*last_cie
= NULL
;
1423 int last_dup_fde
= 0;
1425 CORE_ADDR curr_section_vma
= 0;
1427 unwind_tmp_obstack_init ();
1429 frame_buffer
= dwarf2_read_section (objfile
, frame_offset
, frame_size
,
1432 start
= frame_buffer
;
1433 end
= frame_buffer
+ frame_size
;
1435 curr_section_name
= eh_frame
? ".eh_frame" : ".debug_frame";
1436 curr_section_ptr
= bfd_get_section_by_name (abfd
, curr_section_name
);
1437 if (curr_section_ptr
)
1438 curr_section_vma
= curr_section_ptr
->vma
;
1444 unsigned long length
;
1446 ULONGEST unit_offset
= start
- frame_buffer
;
1447 int bytes_read
, dwarf64
;
1450 length
= read_initial_length (abfd
, start
, &bytes_read
);
1451 start
+= bytes_read
;
1452 dwarf64
= (bytes_read
== 12);
1453 block_end
= start
+ length
;
1461 cie_id
= read_length (abfd
, start
, &bytes_read
, dwarf64
);
1462 start
+= bytes_read
;
1464 if ((eh_frame
&& cie_id
== 0) || is_cie (cie_id
, dwarf64
))
1466 struct cie_unit
*cie
= cie_unit_alloc ();
1469 cie
->objfile
= objfile
;
1470 cie
->next
= cie_chunks
;
1473 cie
->objfile
= objfile
;
1475 cie
->offset
= unit_offset
;
1477 start
++; /* version */
1479 cie
->augmentation
= aug
= start
;
1480 while (*start
++); /* Skips last NULL as well */
1482 cie
->code_align
= read_uleb128 (abfd
, &start
);
1483 cie
->data_align
= read_sleb128 (abfd
, &start
);
1484 cie
->ra
= read_1u (abfd
, &start
);
1487 z Indicates that a uleb128 is present to size the
1488 augmentation section.
1489 L Indicates the encoding (and thus presence) of
1490 an LSDA pointer in the FDE augmentation.
1491 R Indicates a non-default pointer encoding for
1493 P Indicates the presence of an encoding + language
1494 personality routine in the CIE augmentation.
1496 [This info comes from GCC's dwarf2out.c]
1500 aug_len
= read_uleb128 (abfd
, &start
);
1507 cie
->data_length
= block_end
- cie
->data
;
1509 while (*aug
!= '\0')
1511 if (aug
[0] == 'e' && aug
[1] == 'h')
1513 aug_data
+= sizeof (void *);
1516 else if (aug
[0] == 'R')
1517 cie
->addr_encoding
= *aug_data
++;
1518 else if (aug
[0] == 'P')
1520 CORE_ADDR pers_addr
;
1523 pers_addr_enc
= *aug_data
++;
1524 /* We don't need pers_addr value and so we
1525 don't care about it's encoding. */
1526 pers_addr
= read_encoded_pointer (abfd
, &aug_data
,
1529 else if (aug
[0] == 'L' && eh_frame
)
1533 /* Perhaps we should save this to CIE for later use?
1534 Do we need it for something in GDB? */
1535 lsda_addr_enc
= *aug_data
++;
1538 warning ("CFI warning: unknown augmentation \"%c\""
1540 "\t%s", aug
[0], curr_section_name
,
1549 struct fde_unit
*fde
;
1550 struct cie_unit
*cie
;
1554 /* We assume that debug_frame is in order
1555 CIE,FDE,CIE,FDE,FDE,... and thus the CIE for this FDE
1556 should be stored in last_cie pointer. If not, we'll
1557 try to find it by the older way. */
1562 warning ("CFI: last_cie == NULL. "
1563 "Perhaps a malformed %s section in '%s'...?\n",
1564 curr_section_name
, objfile
->name
);
1569 if (cie
->objfile
== objfile
)
1573 (unit_offset
+ bytes_read
- cie_id
)))
1575 if (!eh_frame
&& (cie
->offset
== cie_id
))
1582 error ("CFI: can't find CIE pointer [in module %s]",
1583 bfd_get_filename (abfd
));
1586 init_loc
= read_encoded_pointer (abfd
, &start
,
1587 cie
->addr_encoding
);
1589 switch (pointer_encoding (cie
->addr_encoding
, objfile
))
1594 /* start-frame_buffer gives offset from
1595 the beginning of actual section. */
1596 init_loc
+= curr_section_vma
+ start
- frame_buffer
;
1599 warning ("CFI: Unsupported pointer encoding [in module %s]",
1600 bfd_get_filename (abfd
));
1603 /* For relocatable objects we must add an offset telling
1604 where the section is actually mapped in the memory. */
1605 init_loc
+= ANOFFSET (objfile
->section_offsets
,
1606 SECT_OFF_TEXT (objfile
));
1608 /* If we have both .debug_frame and .eh_frame present in
1609 a file, we must eliminate duplicate FDEs. For now we'll
1610 run through all entries in fde_chunks and check it one
1611 by one. Perhaps in the future we can implement a faster
1612 searching algorithm. */
1613 /* eh_frame==2 indicates, that this file has an already
1614 parsed .debug_frame too. When eh_frame==1 it means, that no
1615 .debug_frame is present and thus we don't need to check for
1616 duplicities. eh_frame==0 means, that we parse .debug_frame
1617 and don't need to care about duplicate FDEs, because
1618 .debug_frame is parsed first. */
1620 for (i
= 0; eh_frame
== 2 && i
< fde_chunks
.elems
; i
++)
1622 /* We assume that FDEs in .debug_frame and .eh_frame
1623 have the same order (if they are present, of course).
1624 If we find a duplicate entry for one FDE and save
1625 it's index to last_dup_fde it's very likely, that
1626 we'll find an entry for the following FDE right after
1627 the previous one. Thus in many cases we'll run this
1629 last_dup_fde
= (last_dup_fde
+ i
) % fde_chunks
.elems
;
1630 if (fde_chunks
.array
[last_dup_fde
]->initial_location
1638 /* Allocate a new entry only if this FDE isn't a duplicate of
1639 something we have already seen. */
1642 fde_chunks_need_space ();
1643 fde
= fde_unit_alloc ();
1645 fde_chunks
.array
[fde_chunks
.elems
++] = fde
;
1647 fde
->initial_location
= init_loc
;
1648 fde
->address_range
= read_encoded_pointer (abfd
, &start
,
1654 /* Here we intentionally ignore augmentation data
1655 from FDE, because we don't need them. */
1656 if (cie
->augmentation
[0] == 'z')
1657 start
+= read_uleb128 (abfd
, &start
);
1660 fde
->data_length
= block_end
- start
;
1665 qsort (fde_chunks
.array
, fde_chunks
.elems
,
1666 sizeof (struct fde_unit
*), compare_fde_unit
);
1670 /* We must parse both .debug_frame section and .eh_frame because
1671 * not all frames must be present in both of these sections. */
1673 dwarf2_build_frame_info (struct objfile
*objfile
)
1675 int after_debug_frame
= 0;
1677 /* If we have .debug_frame then the parser is called with
1678 eh_frame==0 for .debug_frame and eh_frame==2 for .eh_frame,
1679 otherwise it's only called once for .eh_frame with argument
1682 if (dwarf_frame_offset
)
1684 parse_frame_info (objfile
, dwarf_frame_offset
,
1685 dwarf_frame_size
, dwarf_frame_section
,
1686 0 /* = debug_frame */ );
1687 after_debug_frame
= 1;
1690 if (dwarf_eh_frame_offset
)
1691 parse_frame_info (objfile
, dwarf_eh_frame_offset
, dwarf_eh_frame_size
,
1692 dwarf_eh_frame_section
,
1693 1 /* = eh_frame */ + after_debug_frame
);
1696 /* Return the frame address. */
1700 struct context
*context
;
1701 struct frame_state
*fs
;
1704 unwind_tmp_obstack_init ();
1706 context
= context_alloc ();
1707 fs
= frame_state_alloc ();
1709 context
->ra
= read_pc () + 1;
1711 frame_state_for (context
, fs
);
1712 update_context (context
, fs
, 0);
1716 unwind_tmp_obstack_free ();
1721 /* Store the frame address. This function is not used. */
1724 cfi_write_fp (CORE_ADDR val
)
1726 struct context
*context
;
1727 struct frame_state
*fs
;
1729 unwind_tmp_obstack_init ();
1731 context
= context_alloc ();
1732 fs
= frame_state_alloc ();
1734 context
->ra
= read_pc () + 1;
1736 frame_state_for (context
, fs
);
1738 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1740 val
-= fs
->cfa_offset
;
1741 deprecated_write_register_gen (fs
->cfa_reg
, (char *) &val
);
1744 warning ("Can't write fp.");
1746 unwind_tmp_obstack_free ();
1749 /* Restore the machine to the state it had before the current frame
1752 cfi_pop_frame (struct frame_info
*fi
)
1754 char *regbuf
= alloca (MAX_REGISTER_RAW_SIZE
);
1757 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1759 get_reg (regbuf
, UNWIND_CONTEXT (fi
), regnum
);
1760 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), regbuf
,
1761 REGISTER_RAW_SIZE (regnum
));
1763 write_register (PC_REGNUM
, UNWIND_CONTEXT (fi
)->ra
);
1765 flush_cached_frames ();
1768 /* Determine the address of the calling function's frame. */
1770 cfi_frame_chain (struct frame_info
*fi
)
1772 struct context
*context
;
1773 struct frame_state
*fs
;
1776 unwind_tmp_obstack_init ();
1778 context
= context_alloc ();
1779 fs
= frame_state_alloc ();
1780 context_cpy (context
, UNWIND_CONTEXT (fi
));
1782 /* outermost frame */
1783 if (context
->ra
== 0)
1785 unwind_tmp_obstack_free ();
1789 frame_state_for (context
, fs
);
1790 update_context (context
, fs
, 1);
1793 unwind_tmp_obstack_free ();
1798 /* Sets the pc of the frame. */
1800 cfi_init_frame_pc (int fromleaf
, struct frame_info
*fi
)
1802 if (get_next_frame (fi
))
1805 /* FIXME: cagney/2002-12-04: This is straight wrong. It's
1806 assuming that the PC is CORE_ADDR (a host quantity) in size. */
1807 get_reg ((void *) &pc
, UNWIND_CONTEXT (get_next_frame (fi
)), PC_REGNUM
);
1814 /* Initialize unwind context informations of the frame. */
1816 cfi_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1818 struct frame_state
*fs
;
1820 unwind_tmp_obstack_init ();
1822 fs
= frame_state_alloc ();
1823 deprecated_set_frame_context (fi
,
1824 frame_obstack_zalloc (sizeof
1826 UNWIND_CONTEXT (fi
)->reg
=
1827 frame_obstack_zalloc (sizeof (struct context_reg
) * NUM_REGS
);
1828 memset (UNWIND_CONTEXT (fi
)->reg
, 0,
1829 sizeof (struct context_reg
) * NUM_REGS
);
1831 if (get_next_frame (fi
))
1833 context_cpy (UNWIND_CONTEXT (fi
), UNWIND_CONTEXT (get_next_frame (fi
)));
1834 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1835 update_context (UNWIND_CONTEXT (fi
), fs
, 1);
1839 UNWIND_CONTEXT (fi
)->ra
= get_frame_pc (fi
) + 1;
1840 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1841 update_context (UNWIND_CONTEXT (fi
), fs
, 0);
1844 unwind_tmp_obstack_free ();
1847 /* Obtain return address of the frame. */
1849 cfi_get_ra (struct frame_info
*fi
)
1851 return UNWIND_CONTEXT (fi
)->ra
;
1854 /* Find register number REGNUM relative to FRAME and put its
1855 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
1856 was optimized out (and thus can't be fetched). If the variable
1857 was fetched from memory, set *ADDRP to where it was fetched from,
1858 otherwise it was fetched from a register.
1860 The argument RAW_BUFFER must point to aligned memory. */
1862 cfi_get_saved_register (char *raw_buffer
,
1865 struct frame_info
*frame
,
1866 int regnum
, enum lval_type
*lval
)
1868 if (!target_has_registers
)
1869 error ("No registers.");
1871 /* Normal systems don't optimize out things with register numbers. */
1872 if (optimized
!= NULL
)
1875 if (addrp
) /* default assumption: not found in memory */
1878 if (!get_next_frame (frame
))
1880 deprecated_read_register_gen (regnum
, raw_buffer
);
1882 *lval
= lval_register
;
1884 *addrp
= REGISTER_BYTE (regnum
);
1888 frame
= get_next_frame (frame
);
1889 switch (UNWIND_CONTEXT (frame
)->reg
[regnum
].how
)
1891 case REG_CTX_UNSAVED
:
1892 deprecated_read_register_gen (regnum
, raw_buffer
);
1895 if (optimized
!= NULL
)
1898 case REG_CTX_SAVED_OFFSET
:
1899 target_read_memory (UNWIND_CONTEXT (frame
)->cfa
+
1900 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
,
1901 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1903 *lval
= lval_memory
;
1906 UNWIND_CONTEXT (frame
)->cfa
+
1907 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
;
1909 case REG_CTX_SAVED_REG
:
1910 deprecated_read_register_gen (UNWIND_CONTEXT (frame
)->reg
[regnum
].
1911 loc
.reg
, raw_buffer
);
1913 *lval
= lval_register
;
1916 REGISTER_BYTE (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
);
1918 case REG_CTX_SAVED_ADDR
:
1919 target_read_memory (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1920 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1922 *lval
= lval_memory
;
1924 *addrp
= UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
;
1927 memcpy (raw_buffer
, &UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1928 REGISTER_RAW_SIZE (regnum
));
1931 if (optimized
!= NULL
)
1935 internal_error (__FILE__
, __LINE__
,
1936 "cfi_get_saved_register: unknown register rule 0x%02X",
1937 UNWIND_CONTEXT (frame
)->reg
[regnum
].how
);
1942 /* Return the register that the function uses for a frame pointer,
1943 plus any necessary offset to be applied to the register before
1944 any frame pointer offsets. */
1946 cfi_virtual_frame_pointer (CORE_ADDR pc
, int *frame_reg
,
1947 LONGEST
* frame_offset
)
1949 struct context
*context
;
1950 struct frame_state
*fs
;
1952 unwind_tmp_obstack_init ();
1954 context
= context_alloc ();
1955 fs
= frame_state_alloc ();
1957 context
->ra
= read_pc () + 1;
1959 frame_state_for (context
, fs
);
1961 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1963 *frame_reg
= fs
->cfa_reg
;
1964 *frame_offset
= fs
->cfa_offset
;
1967 error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1969 unwind_tmp_obstack_free ();