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. */
29 #include "elf/dwarf2.h"
32 #include "dwarf2cfi.h"
33 #include "gdb_assert.h"
35 /* Common Information Entry - holds information that is shared among many
39 /* Offset of this unit in .debug_frame or .eh_frame. */
42 /* A null-terminated string that identifies the augmentation to this CIE or
43 to the FDEs that use it. */
46 /* A constant that is factored out of all advance location instructions. */
47 unsigned int code_align
;
49 /* A constant that is factored out of all offset instructions. */
52 /* A constant that indicates which regiter represents the return address
56 /* Indicates how addresses are encoded. */
57 unsigned char addr_encoding
;
59 /* Pointer and length of the cie program. */
61 unsigned int data_length
;
63 struct objfile
*objfile
;
66 struct cie_unit
*next
;
69 /* Frame Description Entry. */
72 /* Address of the first location associated with this entry. */
73 CORE_ADDR initial_location
;
75 /* Length of program section described by this entry. */
76 CORE_ADDR address_range
;
78 /* Pointer to asociated CIE. */
79 struct cie_unit
*cie_ptr
;
81 /* Pointer and length of the cie program. */
83 unsigned int data_length
;
88 struct fde_unit
**array
;
105 REG_CTX_SAVED_OFFSET
,
113 /* This is the register and unwind state for a particular frame. */
116 struct context_reg
*reg
;
124 struct frame_state_reg
145 /* Each register save state can be described in terms of a CFA slot,
146 another register, or a location expression. */
147 struct frame_state_regs
149 struct frame_state_reg
*reg
;
151 /* Used to implement DW_CFA_remember_state. */
152 struct frame_state_regs
*prev
;
156 /* The CFA can be described in terms of a reg+offset or a
157 location expression. */
160 unsigned char *cfa_exp
;
169 /* The PC described by the current frame state. */
172 /* The information we care about from the CIE/FDE. */
174 unsigned int code_align
;
175 unsigned char retaddr_column
;
176 unsigned char addr_encoding
;
178 struct objfile
*objfile
;
183 PE_absptr
= DW_EH_PE_absptr
,
184 PE_pcrel
= DW_EH_PE_pcrel
,
185 PE_textrel
= DW_EH_PE_textrel
,
186 PE_datarel
= DW_EH_PE_datarel
,
187 PE_funcrel
= DW_EH_PE_funcrel
190 #define UNWIND_CONTEXT(fi) ((struct context *) (fi->context))
193 static struct cie_unit
*cie_chunks
;
194 static struct fde_array fde_chunks
;
195 /* Obstack for allocating temporary storage used during unwind operations. */
196 static struct obstack unwind_tmp_obstack
;
198 extern file_ptr dwarf_frame_offset
;
199 extern unsigned int dwarf_frame_size
;
200 extern file_ptr dwarf_eh_frame_offset
;
201 extern unsigned int dwarf_eh_frame_size
;
204 extern char *dwarf2_read_section (struct objfile
*objfile
, file_ptr offset
,
207 static struct fde_unit
*fde_unit_alloc (void);
208 static struct cie_unit
*cie_unit_alloc (void);
209 static void fde_chunks_need_space ();
211 static struct context
*context_alloc ();
212 static struct frame_state
*frame_state_alloc ();
213 static void unwind_tmp_obstack_init ();
214 static void unwind_tmp_obstack_free ();
215 static void context_cpy (struct context
*dst
, struct context
*src
);
217 static unsigned int read_1u (bfd
* abfd
, char **p
);
218 static int read_1s (bfd
* abfd
, char **p
);
219 static unsigned int read_2u (bfd
* abfd
, char **p
);
220 static int read_2s (bfd
* abfd
, char **p
);
221 static unsigned int read_4u (bfd
* abfd
, char **p
);
222 static int read_4s (bfd
* abfd
, char **p
);
223 static ULONGEST
read_8u (bfd
* abfd
, char **p
);
224 static LONGEST
read_8s (bfd
* abfd
, char **p
);
226 static ULONGEST
read_uleb128 (bfd
* abfd
, char **p
);
227 static LONGEST
read_sleb128 (bfd
* abfd
, char **p
);
228 static CORE_ADDR
read_pointer (bfd
* abfd
, char **p
);
229 static CORE_ADDR
read_encoded_pointer (bfd
* abfd
, char **p
,
230 unsigned char encoding
);
231 static enum ptr_encoding
pointer_encoding (unsigned char encoding
);
233 static LONGEST
read_initial_length (bfd
* abfd
, char *buf
, int *bytes_read
);
234 static ULONGEST
read_length (bfd
* abfd
, char *buf
, int *bytes_read
,
237 static int is_cie (ULONGEST cie_id
, int dwarf64
);
238 static int compare_fde_unit (const void *a
, const void *b
);
239 void dwarf2_build_frame_info (struct objfile
*objfile
);
241 static void execute_cfa_program (struct objfile
*objfile
, char *insn_ptr
,
242 char *insn_end
, struct context
*context
,
243 struct frame_state
*fs
);
244 static struct fde_unit
*get_fde_for_addr (CORE_ADDR pc
);
245 static void frame_state_for (struct context
*context
, struct frame_state
*fs
);
246 static void get_reg (char *reg
, struct context
*context
, int regnum
);
247 static CORE_ADDR
execute_stack_op (struct objfile
*objfile
,
248 char *op_ptr
, char *op_end
,
249 struct context
*context
,
251 static void update_context (struct context
*context
, struct frame_state
*fs
,
255 /* Memory allocation functions. */
256 static struct fde_unit
*
257 fde_unit_alloc (void)
259 struct fde_unit
*fde
;
261 fde
= (struct fde_unit
*) xmalloc (sizeof (struct fde_unit
));
262 memset (fde
, 0, sizeof (struct fde_unit
));
266 static struct cie_unit
*
267 cie_unit_alloc (void)
269 struct cie_unit
*cie
;
271 cie
= (struct cie_unit
*) xmalloc (sizeof (struct cie_unit
));
272 memset (cie
, 0, sizeof (struct cie_unit
));
277 fde_chunks_need_space (void)
279 if (fde_chunks
.elems
< fde_chunks
.array_size
)
281 fde_chunks
.array_size
=
282 fde_chunks
.array_size
? 2 * fde_chunks
.array_size
: 1024;
284 xrealloc (fde_chunks
.array
,
285 sizeof (struct fde_unit
) * fde_chunks
.array_size
);
288 /* Alocate a new `struct context' on temporary obstack. */
289 static struct context
*
292 struct context
*context
;
294 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
296 context
= (struct context
*) obstack_alloc (&unwind_tmp_obstack
,
297 sizeof (struct context
));
298 memset (context
, 0, sizeof (struct context
));
299 context
->reg
= (struct context_reg
*) obstack_alloc (&unwind_tmp_obstack
,
301 memset (context
->reg
, 0, regs_size
);
305 /* Alocate a new `struct frame_state' on temporary obstack. */
306 static struct frame_state
*
307 frame_state_alloc (void)
309 struct frame_state
*fs
;
311 int regs_size
= sizeof (struct frame_state_reg
) * NUM_REGS
;
313 fs
= (struct frame_state
*) obstack_alloc (&unwind_tmp_obstack
,
314 sizeof (struct frame_state
));
315 memset (fs
, 0, sizeof (struct frame_state
));
317 (struct frame_state_reg
*) obstack_alloc (&unwind_tmp_obstack
, regs_size
);
318 memset (fs
->regs
.reg
, 0, regs_size
);
323 unwind_tmp_obstack_init (void)
325 obstack_init (&unwind_tmp_obstack
);
329 unwind_tmp_obstack_free (void)
331 obstack_free (&unwind_tmp_obstack
, NULL
);
332 unwind_tmp_obstack_init ();
336 context_cpy (struct context
*dst
, struct context
*src
)
338 int regs_size
= sizeof (struct context_reg
) * NUM_REGS
;
339 struct context_reg
*dreg
;
341 /* Structure dst contains a pointer to an array of
342 * registers of a given frame as well as src does. This
343 * array was already allocated before dst was passed to
344 * context_cpy but the pointer to it was overriden by
345 * '*dst = *src' and the array was lost. This led to the
346 * situation, that we've had a copy of src placed in dst,
347 * but both of them pointed to the same regs array and
348 * thus we've sometimes blindly rewritten it. Now we save
349 * the pointer before copying src to dst, return it back
350 * after that and copy the registers into their new place
351 * finally. --- mludvig@suse.cz */
356 memcpy (dst
->reg
, src
->reg
, regs_size
);
360 read_1u (bfd
* abfd
, char **p
)
364 ret
= bfd_get_8 (abfd
, (bfd_byte
*) * p
);
370 read_1s (bfd
* abfd
, char **p
)
374 ret
= bfd_get_signed_8 (abfd
, (bfd_byte
*) * p
);
380 read_2u (bfd
* abfd
, char **p
)
384 ret
= bfd_get_16 (abfd
, (bfd_byte
*) * p
);
390 read_2s (bfd
* abfd
, char **p
)
394 ret
= bfd_get_signed_16 (abfd
, (bfd_byte
*) * p
);
400 read_4u (bfd
* abfd
, char **p
)
404 ret
= bfd_get_32 (abfd
, (bfd_byte
*) * p
);
410 read_4s (bfd
* abfd
, char **p
)
414 ret
= bfd_get_signed_32 (abfd
, (bfd_byte
*) * p
);
420 read_8u (bfd
* abfd
, char **p
)
424 ret
= bfd_get_64 (abfd
, (bfd_byte
*) * p
);
430 read_8s (bfd
* abfd
, char **p
)
434 ret
= bfd_get_signed_64 (abfd
, (bfd_byte
*) * p
);
440 read_uleb128 (bfd
* abfd
, char **p
)
451 byte
= bfd_get_8 (abfd
, (bfd_byte
*) * p
);
453 ret
|= ((unsigned long) (byte
& 127) << shift
);
454 if ((byte
& 128) == 0)
464 read_sleb128 (bfd
* abfd
, char **p
)
467 int i
, shift
, size
, num_read
;
477 byte
= bfd_get_8 (abfd
, (bfd_byte
*) * p
);
479 ret
|= ((long) (byte
& 127) << shift
);
481 if ((byte
& 128) == 0)
486 if ((shift
< size
) && (byte
& 0x40))
488 ret
|= -(1 << shift
);
494 read_pointer (bfd
* abfd
, char **p
)
496 switch (TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
)
499 return read_4u (abfd
, p
);
501 return read_8u (abfd
, p
);
503 error ("dwarf cfi error: unsupported target address length.");
507 /* This functions only reads appropriate amount of data from *p
508 * and returns the resulting value. Calling function must handle
509 * different encoding possibilities itself! */
511 read_encoded_pointer (bfd
* abfd
, char **p
, unsigned char encoding
)
515 switch (encoding
& 0x0f)
517 case DW_EH_PE_absptr
:
518 ret
= read_pointer (abfd
, p
);
521 case DW_EH_PE_uleb128
:
522 ret
= read_uleb128 (abfd
, p
);
524 case DW_EH_PE_sleb128
:
525 ret
= read_sleb128 (abfd
, p
);
528 case DW_EH_PE_udata2
:
529 ret
= read_2u (abfd
, p
);
531 case DW_EH_PE_udata4
:
532 ret
= read_4u (abfd
, p
);
534 case DW_EH_PE_udata8
:
535 ret
= read_8u (abfd
, p
);
538 case DW_EH_PE_sdata2
:
539 ret
= read_2s (abfd
, p
);
541 case DW_EH_PE_sdata4
:
542 ret
= read_4s (abfd
, p
);
544 case DW_EH_PE_sdata8
:
545 ret
= read_8s (abfd
, p
);
549 internal_error (__FILE__
, __LINE__
,
550 "read_encoded_pointer: unknown pointer encoding");
556 /* Variable 'encoding' carries 3 different flags:
557 * - encoding & 0x0f : size of the address (handled in read_encoded_pointer())
558 * - encoding & 0x70 : type (absolute, relative, ...)
559 * - encoding & 0x80 : indirect flag (DW_EH_PE_indirect == 0x80). */
561 pointer_encoding (unsigned char encoding
)
565 if (encoding
& DW_EH_PE_indirect
)
566 warning ("CFI: Unsupported pointer encoding: DW_EH_PE_indirect");
568 switch (encoding
& 0x70)
570 case DW_EH_PE_absptr
:
572 case DW_EH_PE_textrel
:
573 case DW_EH_PE_datarel
:
574 case DW_EH_PE_funcrel
:
575 ret
= encoding
& 0x70;
578 internal_error (__FILE__
, __LINE__
, "CFI: unknown pointer encoding");
584 read_initial_length (bfd
* abfd
, char *buf
, int *bytes_read
)
588 ret
= bfd_get_32 (abfd
, (bfd_byte
*) buf
);
590 if (ret
== 0xffffffff)
592 ret
= bfd_get_64 (abfd
, (bfd_byte
*) buf
+ 4);
604 read_length (bfd
* abfd
, char *buf
, int *bytes_read
, int dwarf64
)
609 return read_8u (abfd
, &buf
);
614 return read_4u (abfd
, &buf
);
619 execute_cfa_program (struct objfile
*objfile
, char *insn_ptr
, char *insn_end
,
620 struct context
*context
, struct frame_state
*fs
)
622 struct frame_state_regs
*unused_rs
= NULL
;
624 /* Don't allow remember/restore between CIE and FDE programs. */
625 fs
->regs
.prev
= NULL
;
627 while (insn_ptr
< insn_end
&& fs
->pc
< context
->ra
)
629 unsigned char insn
= *insn_ptr
++;
630 ULONGEST reg
, uoffset
;
633 if (insn
& DW_CFA_advance_loc
)
634 fs
->pc
+= (insn
& 0x3f) * fs
->code_align
;
635 else if (insn
& DW_CFA_offset
)
638 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
639 offset
= (long) uoffset
*fs
->data_align
;
640 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
641 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
643 else if (insn
& DW_CFA_restore
)
646 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
652 fs
->pc
= read_encoded_pointer (objfile
->obfd
, &insn_ptr
,
655 if (pointer_encoding (fs
->addr_encoding
) != PE_absptr
)
656 warning ("CFI: DW_CFA_set_loc uses relative addressing");
660 case DW_CFA_advance_loc1
:
661 fs
->pc
+= read_1u (objfile
->obfd
, &insn_ptr
);
663 case DW_CFA_advance_loc2
:
664 fs
->pc
+= read_2u (objfile
->obfd
, &insn_ptr
);
666 case DW_CFA_advance_loc4
:
667 fs
->pc
+= read_4u (objfile
->obfd
, &insn_ptr
);
670 case DW_CFA_offset_extended
:
671 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
672 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
673 offset
= (long) uoffset
*fs
->data_align
;
674 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
675 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
678 case DW_CFA_restore_extended
:
679 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
680 fs
->regs
.reg
[reg
].how
= REG_UNSAVED
;
683 case DW_CFA_undefined
:
684 case DW_CFA_same_value
:
688 case DW_CFA_register
:
691 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
692 reg2
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
693 fs
->regs
.reg
[reg
].how
= REG_SAVED_REG
;
694 fs
->regs
.reg
[reg
].loc
.reg
= reg2
;
698 case DW_CFA_remember_state
:
700 struct frame_state_regs
*new_rs
;
704 unused_rs
= unused_rs
->prev
;
707 new_rs
= xmalloc (sizeof (struct frame_state_regs
));
710 fs
->regs
.prev
= new_rs
;
714 case DW_CFA_restore_state
:
716 struct frame_state_regs
*old_rs
= fs
->regs
.prev
;
718 old_rs
->prev
= unused_rs
;
724 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
725 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
727 fs
->cfa_offset
= uoffset
;
728 fs
->cfa_how
= CFA_REG_OFFSET
;
731 case DW_CFA_def_cfa_register
:
732 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
734 fs
->cfa_how
= CFA_REG_OFFSET
;
737 case DW_CFA_def_cfa_offset
:
738 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
739 fs
->cfa_offset
= uoffset
;
742 case DW_CFA_def_cfa_expression
:
743 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
744 fs
->cfa_exp
= insn_ptr
;
745 fs
->cfa_how
= CFA_EXP
;
749 case DW_CFA_expression
:
750 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
751 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
752 fs
->regs
.reg
[reg
].how
= REG_SAVED_EXP
;
753 fs
->regs
.reg
[reg
].loc
.exp
= insn_ptr
;
757 /* From the 2.1 draft. */
758 case DW_CFA_offset_extended_sf
:
759 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
760 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
761 offset
*= fs
->data_align
;
762 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
763 fs
->regs
.reg
[reg
].loc
.offset
= offset
;
766 case DW_CFA_def_cfa_sf
:
767 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
768 offset
= read_sleb128 (objfile
->obfd
, &insn_ptr
);
769 fs
->cfa_offset
= offset
;
771 fs
->cfa_how
= CFA_REG_OFFSET
;
774 case DW_CFA_def_cfa_offset_sf
:
775 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
776 fs
->cfa_offset
= uoffset
;
777 /* cfa_how deliberately not set. */
780 case DW_CFA_GNU_window_save
:
781 /* ??? Hardcoded for SPARC register window configuration. */
782 for (reg
= 16; reg
< 32; ++reg
)
784 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
785 fs
->regs
.reg
[reg
].loc
.offset
= (reg
- 16) * sizeof (void *);
789 case DW_CFA_GNU_args_size
:
790 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
791 context
->args_size
= uoffset
;
794 case DW_CFA_GNU_negative_offset_extended
:
795 /* Obsoleted by DW_CFA_offset_extended_sf, but used by
796 older PowerPC code. */
797 reg
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
798 uoffset
= read_uleb128 (objfile
->obfd
, &insn_ptr
);
799 offset
= (long) uoffset
*fs
->data_align
;
800 fs
->regs
.reg
[reg
].how
= REG_SAVED_OFFSET
;
801 fs
->regs
.reg
[reg
].loc
.offset
= -offset
;
805 error ("dwarf cfi error: unknown cfa instruction %d.", insn
);
810 static struct fde_unit
*
811 get_fde_for_addr (CORE_ADDR pc
)
814 struct fde_unit
*fde
= NULL
;
816 hi
= fde_chunks
.elems
;
820 size_t i
= (lo
+ hi
) / 2;
821 fde
= fde_chunks
.array
[i
];
822 if (pc
< fde
->initial_location
)
824 else if (pc
>= fde
->initial_location
+ fde
->address_range
)
833 frame_state_for (struct context
*context
, struct frame_state
*fs
)
835 struct fde_unit
*fde
;
836 struct cie_unit
*cie
;
838 context
->args_size
= 0;
841 fde
= get_fde_for_addr (context
->ra
- 1);
846 fs
->pc
= fde
->initial_location
;
848 gdb_assert (fde
->cie_ptr
!= NULL
);
852 fs
->code_align
= cie
->code_align
;
853 fs
->data_align
= cie
->data_align
;
854 fs
->retaddr_column
= cie
->ra
;
855 fs
->addr_encoding
= cie
->addr_encoding
;
856 fs
->objfile
= cie
->objfile
;
858 execute_cfa_program (cie
->objfile
, cie
->data
,
859 cie
->data
+ cie
->data_length
, context
, fs
);
860 execute_cfa_program (cie
->objfile
, fde
->data
,
861 fde
->data
+ fde
->data_length
, context
, fs
);
865 get_reg (char *reg
, struct context
*context
, int regnum
)
867 switch (context
->reg
[regnum
].how
)
869 case REG_CTX_UNSAVED
:
870 read_register_gen (regnum
, reg
);
872 case REG_CTX_SAVED_OFFSET
:
873 target_read_memory (context
->cfa
+ context
->reg
[regnum
].loc
.offset
,
874 reg
, REGISTER_RAW_SIZE (regnum
));
876 case REG_CTX_SAVED_REG
:
877 read_register_gen (context
->reg
[regnum
].loc
.reg
, reg
);
879 case REG_CTX_SAVED_ADDR
:
880 target_read_memory (context
->reg
[regnum
].loc
.addr
,
881 reg
, REGISTER_RAW_SIZE (regnum
));
884 memcpy (reg
, &context
->reg
[regnum
].loc
.addr
,
885 REGISTER_RAW_SIZE (regnum
));
888 internal_error (__FILE__
, __LINE__
, "get_reg: unknown register rule");
892 /* Decode a DW_OP stack program. Return the top of stack. Push INITIAL
893 onto the stack to start. */
895 execute_stack_op (struct objfile
*objfile
,
896 char *op_ptr
, char *op_end
, struct context
*context
,
899 CORE_ADDR stack
[64]; /* ??? Assume this is enough. */
905 while (op_ptr
< op_end
)
907 enum dwarf_location_atom op
= *op_ptr
++;
946 result
= op
- DW_OP_lit0
;
950 result
= read_pointer (objfile
->obfd
, &op_ptr
);
954 result
= read_1u (objfile
->obfd
, &op_ptr
);
957 result
= read_1s (objfile
->obfd
, &op_ptr
);
960 result
= read_2u (objfile
->obfd
, &op_ptr
);
963 result
= read_2s (objfile
->obfd
, &op_ptr
);
966 result
= read_4u (objfile
->obfd
, &op_ptr
);
969 result
= read_4s (objfile
->obfd
, &op_ptr
);
972 result
= read_8u (objfile
->obfd
, &op_ptr
);
975 result
= read_8s (objfile
->obfd
, &op_ptr
);
978 result
= read_uleb128 (objfile
->obfd
, &op_ptr
);
981 result
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1016 get_reg ((char *) &result
, context
, op
- DW_OP_reg0
);
1019 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
1020 get_reg ((char *) &result
, context
, reg
);
1055 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1056 get_reg ((char *) &result
, context
, op
- DW_OP_breg0
);
1060 reg
= read_uleb128 (objfile
->obfd
, &op_ptr
);
1061 offset
= read_sleb128 (objfile
->obfd
, &op_ptr
);
1062 get_reg ((char *) &result
, context
, reg
);
1068 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1069 result
= stack
[stack_elt
- 1];
1073 if (--stack_elt
< 0)
1074 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1079 if (offset
>= stack_elt
- 1)
1080 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1081 result
= stack
[stack_elt
- 1 - offset
];
1086 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1087 result
= stack
[stack_elt
- 2];
1092 CORE_ADDR t1
, t2
, t3
;
1095 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1096 t1
= stack
[stack_elt
- 1];
1097 t2
= stack
[stack_elt
- 2];
1098 t3
= stack
[stack_elt
- 3];
1099 stack
[stack_elt
- 1] = t2
;
1100 stack
[stack_elt
- 2] = t3
;
1101 stack
[stack_elt
- 3] = t1
;
1106 case DW_OP_deref_size
:
1110 case DW_OP_plus_uconst
:
1111 /* Unary operations. */
1112 if (--stack_elt
< 0)
1113 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1114 result
= stack
[stack_elt
];
1120 int len
= TARGET_ADDR_BIT
/ TARGET_CHAR_BIT
;
1121 if (len
!= 4 && len
!= 8)
1122 internal_error (__FILE__
, __LINE__
,
1123 "execute_stack_op error");
1124 result
= read_memory_unsigned_integer (result
, len
);
1128 case DW_OP_deref_size
:
1130 int len
= *op_ptr
++;
1131 if (len
!= 1 && len
!= 2 && len
!= 4 && len
!=8)
1132 internal_error (__FILE__
, __LINE__
,
1133 "execute_stack_op error");
1134 result
= read_memory_unsigned_integer (result
, len
);
1148 case DW_OP_plus_uconst
:
1149 result
+= read_uleb128 (objfile
->obfd
, &op_ptr
);
1170 /* Binary operations. */
1171 CORE_ADDR first
, second
;
1172 if ((stack_elt
-= 2) < 0)
1173 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1174 second
= stack
[stack_elt
];
1175 first
= stack
[stack_elt
+ 1];
1180 result
= second
& first
;
1183 result
= (LONGEST
) second
/ (LONGEST
) first
;
1186 result
= second
- first
;
1189 result
= (LONGEST
) second
% (LONGEST
) first
;
1192 result
= second
* first
;
1195 result
= second
| first
;
1198 result
= second
+ first
;
1201 result
= second
<< first
;
1204 result
= second
>> first
;
1207 result
= (LONGEST
) second
>> first
;
1210 result
= second
^ first
;
1213 result
= (LONGEST
) first
<= (LONGEST
) second
;
1216 result
= (LONGEST
) first
>= (LONGEST
) second
;
1219 result
= (LONGEST
) first
== (LONGEST
) second
;
1222 result
= (LONGEST
) first
< (LONGEST
) second
;
1225 result
= (LONGEST
) first
> (LONGEST
) second
;
1228 result
= (LONGEST
) first
!= (LONGEST
) second
;
1231 error ("execute_stack_op: Unknown DW_OP_ value");
1238 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1243 if (--stack_elt
< 0)
1244 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1245 offset
= read_2s (objfile
->obfd
, &op_ptr
);
1246 if (stack
[stack_elt
] != 0)
1254 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1257 /* Most things push a result value. */
1258 if ((size_t) stack_elt
>= sizeof (stack
) / sizeof (*stack
))
1259 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1260 stack
[++stack_elt
] = result
;
1264 /* We were executing this program to get a value. It should be
1266 if (--stack_elt
< 0)
1267 internal_error (__FILE__
, __LINE__
, "execute_stack_op error");
1268 return stack
[stack_elt
];
1272 update_context (struct context
*context
, struct frame_state
*fs
, int chain
)
1274 struct context
*orig_context
;
1278 unwind_tmp_obstack_init ();
1280 orig_context
= context_alloc ();
1281 context_cpy (orig_context
, context
);
1283 /* Compute this frame's CFA. */
1284 switch (fs
->cfa_how
)
1286 case CFA_REG_OFFSET
:
1287 get_reg ((char *) &cfa
, context
, fs
->cfa_reg
);
1288 cfa
+= fs
->cfa_offset
;
1292 /* ??? No way of knowing what register number is the stack pointer
1293 to do the same sort of handling as above. Assume that if the
1294 CFA calculation is so complicated as to require a stack program
1295 that this will not be a problem. */
1297 char *exp
= fs
->cfa_exp
;
1300 len
= read_uleb128 (fs
->objfile
->obfd
, &exp
);
1301 cfa
= (CORE_ADDR
) execute_stack_op (fs
->objfile
, exp
,
1302 exp
+ len
, context
, 0);
1311 orig_context
->cfa
= cfa
;
1313 /* Compute the addresses of all registers saved in this frame. */
1314 for (i
= 0; i
< NUM_REGS
; ++i
)
1315 switch (fs
->regs
.reg
[i
].how
)
1320 context
->reg
[i
].how
= REG_CTX_VALUE
;
1321 context
->reg
[i
].loc
.addr
= cfa
;
1324 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1326 case REG_SAVED_OFFSET
:
1327 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1328 context
->reg
[i
].loc
.offset
= fs
->regs
.reg
[i
].loc
.offset
;
1331 switch (orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].how
)
1333 case REG_CTX_UNSAVED
:
1334 context
->reg
[i
].how
= REG_CTX_UNSAVED
;
1336 case REG_CTX_SAVED_OFFSET
:
1337 context
->reg
[i
].how
= REG_CTX_SAVED_OFFSET
;
1338 context
->reg
[i
].loc
.offset
= orig_context
->cfa
- context
->cfa
+
1339 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.offset
;
1341 case REG_CTX_SAVED_REG
:
1342 context
->reg
[i
].how
= REG_CTX_SAVED_REG
;
1343 context
->reg
[i
].loc
.reg
=
1344 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.reg
;
1346 case REG_CTX_SAVED_ADDR
:
1347 context
->reg
[i
].how
= REG_CTX_SAVED_ADDR
;
1348 context
->reg
[i
].loc
.addr
=
1349 orig_context
->reg
[fs
->regs
.reg
[i
].loc
.reg
].loc
.addr
;
1352 internal_error (__FILE__
, __LINE__
, "bad switch");
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");
1371 get_reg ((char *) &context
->ra
, context
, fs
->retaddr_column
);
1372 unwind_tmp_obstack_free ();
1376 is_cie (ULONGEST cie_id
, int dwarf64
)
1378 return dwarf64
? (cie_id
== 0xffffffffffffffff) : (cie_id
== 0xffffffff);
1382 compare_fde_unit (const void *a
, const void *b
)
1384 struct fde_unit
**first
, **second
;
1385 first
= (struct fde_unit
**) a
;
1386 second
= (struct fde_unit
**) b
;
1387 if ((*first
)->initial_location
> (*second
)->initial_location
)
1389 else if ((*first
)->initial_location
< (*second
)->initial_location
)
1395 /* Build the cie_chunks and fde_chunks tables from informations
1396 found in .debug_frame and .eh_frame sections. */
1397 /* We can handle both of these sections almost in the same way, however there
1398 are some exceptions:
1399 - CIE ID is -1 in debug_frame, but 0 in eh_frame
1400 - eh_frame may contain some more information that are used only by gcc
1401 (eg. personality pointer, LSDA pointer, ...). Most of them we can ignore.
1402 - In debug_frame FDE's item cie_id contains offset of it's parent CIE.
1403 In eh_frame FDE's item cie_id is a relative pointer to the parent CIE.
1404 Anyway we don't need to bother with this, because we are smart enough
1405 to keep the pointer to the parent CIE of oncomming FDEs in 'last_cie'.
1406 - Although debug_frame items can contain Augmentation as well as
1407 eh_frame ones, I have never seen them non-empty. Thus only in eh_frame
1408 we can encounter for example non-absolute pointers (Aug. 'R').
1411 parse_frame_info (struct objfile
*objfile
, file_ptr frame_offset
,
1412 unsigned int frame_size
, int eh_frame
)
1414 bfd
*abfd
= objfile
->obfd
;
1415 asection
*curr_section_ptr
;
1418 char *frame_buffer
= NULL
;
1419 char *curr_section_name
, *aug_data
;
1420 struct cie_unit
*last_cie
= NULL
;
1421 int last_dup_fde
= 0;
1423 CORE_ADDR curr_section_vma
= 0;
1425 unwind_tmp_obstack_init ();
1427 frame_buffer
= dwarf2_read_section (objfile
, frame_offset
, frame_size
);
1429 start
= frame_buffer
;
1430 end
= frame_buffer
+ frame_size
;
1432 curr_section_name
= eh_frame
? ".eh_frame" : ".debug_frame";
1433 curr_section_ptr
= bfd_get_section_by_name (abfd
, curr_section_name
);
1434 if (curr_section_ptr
)
1435 curr_section_vma
= curr_section_ptr
->vma
;
1441 unsigned long length
;
1443 ULONGEST unit_offset
= start
- frame_buffer
;
1444 int bytes_read
, dwarf64
;
1447 length
= read_initial_length (abfd
, start
, &bytes_read
);
1448 start
+= bytes_read
;
1449 dwarf64
= (bytes_read
== 12);
1450 block_end
= start
+ length
;
1458 cie_id
= read_length (abfd
, start
, &bytes_read
, dwarf64
);
1459 start
+= bytes_read
;
1461 if ((eh_frame
&& cie_id
== 0) || is_cie (cie_id
, dwarf64
))
1463 struct cie_unit
*cie
= cie_unit_alloc ();
1466 cie
->objfile
= objfile
;
1467 cie
->next
= cie_chunks
;
1470 cie
->objfile
= objfile
;
1472 cie
->offset
= unit_offset
;
1474 start
++; /* version */
1476 cie
->augmentation
= aug
= start
;
1477 while (*start
++); /* Skips last NULL as well */
1479 cie
->code_align
= read_uleb128 (abfd
, &start
);
1480 cie
->data_align
= read_sleb128 (abfd
, &start
);
1481 cie
->ra
= read_1u (abfd
, &start
);
1484 z Indicates that a uleb128 is present to size the
1485 augmentation section.
1486 L Indicates the encoding (and thus presence) of
1487 an LSDA pointer in the FDE augmentation.
1488 R Indicates a non-default pointer encoding for
1490 P Indicates the presence of an encoding + language
1491 personality routine in the CIE augmentation.
1493 [This info comes from GCC's dwarf2out.c]
1497 aug_len
= read_uleb128 (abfd
, &start
);
1504 cie
->data_length
= block_end
- cie
->data
;
1506 while (*aug
!= '\0')
1508 if (aug
[0] == 'e' && aug
[1] == 'h')
1510 aug_data
+= sizeof (void *);
1513 else if (aug
[0] == 'R')
1514 cie
->addr_encoding
= *aug_data
++;
1515 else if (aug
[0] == 'P')
1517 CORE_ADDR pers_addr
;
1520 pers_addr_enc
= *aug_data
++;
1521 /* We don't need pers_addr value and so we
1522 don't care about it's encoding. */
1523 pers_addr
= read_encoded_pointer (abfd
, &aug_data
,
1526 else if (aug
[0] == 'L' && eh_frame
)
1530 /* Perhaps we should save this to CIE for later use?
1531 Do we need it for something in GDB? */
1532 lsda_addr_enc
= *aug_data
++;
1535 warning ("CFI warning: unknown augmentation \"%c\""
1537 "\t%s", aug
[0], curr_section_name
,
1546 struct fde_unit
*fde
;
1547 struct cie_unit
*cie
;
1551 /* We assume that debug_frame is in order
1552 CIE,FDE,CIE,FDE,FDE,... and thus the CIE for this FDE
1553 should be stored in last_cie pointer. If not, we'll
1554 try to find it by the older way. */
1559 warning ("CFI: last_cie == NULL. "
1560 "Perhaps a malformed %s section in '%s'...?\n",
1561 curr_section_name
, objfile
->name
);
1566 if (cie
->objfile
== objfile
)
1570 (unit_offset
+ bytes_read
- cie_id
)))
1572 if (!eh_frame
&& (cie
->offset
== cie_id
))
1579 error ("CFI: can't find CIE pointer");
1582 init_loc
= read_encoded_pointer (abfd
, &start
,
1583 cie
->addr_encoding
);
1585 switch (pointer_encoding (cie
->addr_encoding
))
1590 /* start-frame_buffer gives offset from
1591 the beginning of actual section. */
1592 init_loc
+= curr_section_vma
+ start
- frame_buffer
;
1595 warning ("CFI: Unsupported pointer encoding\n");
1598 /* For relocatable objects we must add an offset telling
1599 where the section is actually mapped in the memory. */
1600 init_loc
+= ANOFFSET (objfile
->section_offsets
,
1601 SECT_OFF_TEXT (objfile
));
1603 /* If we have both .debug_frame and .eh_frame present in
1604 a file, we must eliminate duplicate FDEs. For now we'll
1605 run through all entries in fde_chunks and check it one
1606 by one. Perhaps in the future we can implement a faster
1607 searching algorithm. */
1608 /* eh_frame==2 indicates, that this file has an already
1609 parsed .debug_frame too. When eh_frame==1 it means, that no
1610 .debug_frame is present and thus we don't need to check for
1611 duplicities. eh_frame==0 means, that we parse .debug_frame
1612 and don't need to care about duplicate FDEs, because
1613 .debug_frame is parsed first. */
1615 for (i
= 0; eh_frame
== 2 && i
< fde_chunks
.elems
; i
++)
1617 /* We assume that FDEs in .debug_frame and .eh_frame
1618 have the same order (if they are present, of course).
1619 If we find a duplicate entry for one FDE and save
1620 it's index to last_dup_fde it's very likely, that
1621 we'll find an entry for the following FDE right after
1622 the previous one. Thus in many cases we'll run this
1624 last_dup_fde
= (last_dup_fde
+ i
) % fde_chunks
.elems
;
1625 if (fde_chunks
.array
[last_dup_fde
]->initial_location
1633 /* Allocate a new entry only if this FDE isn't a duplicate of
1634 something we have already seen. */
1637 fde_chunks_need_space ();
1638 fde
= fde_unit_alloc ();
1640 fde_chunks
.array
[fde_chunks
.elems
++] = fde
;
1642 fde
->initial_location
= init_loc
;
1643 fde
->address_range
= read_encoded_pointer (abfd
, &start
,
1649 /* Here we intentionally ignore augmentation data
1650 from FDE, because we don't need them. */
1651 if (cie
->augmentation
[0] == 'z')
1652 start
+= read_uleb128 (abfd
, &start
);
1655 fde
->data_length
= block_end
- start
;
1660 qsort (fde_chunks
.array
, fde_chunks
.elems
,
1661 sizeof (struct fde_unit
*), compare_fde_unit
);
1665 /* We must parse both .debug_frame section and .eh_frame because
1666 * not all frames must be present in both of these sections. */
1668 dwarf2_build_frame_info (struct objfile
*objfile
)
1670 int after_debug_frame
= 0;
1672 /* If we have .debug_frame then the parser is called with
1673 eh_frame==0 for .debug_frame and eh_frame==2 for .eh_frame,
1674 otherwise it's only called once for .eh_frame with argument
1677 if (dwarf_frame_offset
)
1679 parse_frame_info (objfile
, dwarf_frame_offset
,
1680 dwarf_frame_size
, 0 /* = debug_frame */ );
1681 after_debug_frame
= 1;
1684 if (dwarf_eh_frame_offset
)
1685 parse_frame_info (objfile
, dwarf_eh_frame_offset
, dwarf_eh_frame_size
,
1686 1 /* = eh_frame */ + after_debug_frame
);
1689 /* Return the frame address. */
1693 struct context
*context
;
1694 struct frame_state
*fs
;
1697 unwind_tmp_obstack_init ();
1699 context
= context_alloc ();
1700 fs
= frame_state_alloc ();
1702 context
->ra
= read_pc () + 1;
1704 frame_state_for (context
, fs
);
1705 update_context (context
, fs
, 0);
1709 unwind_tmp_obstack_free ();
1714 /* Store the frame address. This function is not used. */
1717 cfi_write_fp (CORE_ADDR val
)
1719 struct context
*context
;
1720 struct frame_state
*fs
;
1722 unwind_tmp_obstack_init ();
1724 context
= context_alloc ();
1725 fs
= frame_state_alloc ();
1727 context
->ra
= read_pc () + 1;
1729 frame_state_for (context
, fs
);
1731 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1733 val
-= fs
->cfa_offset
;
1734 write_register_gen (fs
->cfa_reg
, (char *) &val
);
1737 warning ("Can't write fp.");
1739 unwind_tmp_obstack_free ();
1742 /* Restore the machine to the state it had before the current frame
1745 cfi_pop_frame (struct frame_info
*fi
)
1747 char *regbuf
= alloca (MAX_REGISTER_RAW_SIZE
);
1750 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
1752 get_reg (regbuf
, UNWIND_CONTEXT (fi
), regnum
);
1753 write_register_bytes (REGISTER_BYTE (regnum
), regbuf
,
1754 REGISTER_RAW_SIZE (regnum
));
1756 write_register (PC_REGNUM
, UNWIND_CONTEXT (fi
)->ra
);
1758 flush_cached_frames ();
1761 /* Determine the address of the calling function's frame. */
1763 cfi_frame_chain (struct frame_info
*fi
)
1765 struct context
*context
;
1766 struct frame_state
*fs
;
1769 unwind_tmp_obstack_init ();
1771 context
= context_alloc ();
1772 fs
= frame_state_alloc ();
1773 context_cpy (context
, UNWIND_CONTEXT (fi
));
1775 /* outermost frame */
1776 if (context
->ra
== 0)
1778 unwind_tmp_obstack_free ();
1782 frame_state_for (context
, fs
);
1783 update_context (context
, fs
, 1);
1786 unwind_tmp_obstack_free ();
1791 /* Sets the pc of the frame. */
1793 cfi_init_frame_pc (int fromleaf
, struct frame_info
*fi
)
1796 get_reg ((char *) &(fi
->pc
), UNWIND_CONTEXT (fi
->next
), PC_REGNUM
);
1798 fi
->pc
= read_pc ();
1801 /* Initialize unwind context informations of the frame. */
1803 cfi_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
1805 struct frame_state
*fs
;
1807 unwind_tmp_obstack_init ();
1809 fs
= frame_state_alloc ();
1810 fi
->context
= frame_obstack_alloc (sizeof (struct context
));
1811 UNWIND_CONTEXT (fi
)->reg
=
1812 frame_obstack_alloc (sizeof (struct context_reg
) * NUM_REGS
);
1813 memset (UNWIND_CONTEXT (fi
)->reg
, 0,
1814 sizeof (struct context_reg
) * NUM_REGS
);
1818 context_cpy (UNWIND_CONTEXT (fi
), UNWIND_CONTEXT (fi
->next
));
1819 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1820 update_context (UNWIND_CONTEXT (fi
), fs
, 1);
1824 UNWIND_CONTEXT (fi
)->ra
= fi
->pc
+ 1;
1825 frame_state_for (UNWIND_CONTEXT (fi
), fs
);
1826 update_context (UNWIND_CONTEXT (fi
), fs
, 0);
1829 unwind_tmp_obstack_free ();
1832 /* Obtain return address of the frame. */
1834 cfi_get_ra (struct frame_info
*fi
)
1836 return UNWIND_CONTEXT (fi
)->ra
;
1839 /* Find register number REGNUM relative to FRAME and put its
1840 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
1841 was optimized out (and thus can't be fetched). If the variable
1842 was fetched from memory, set *ADDRP to where it was fetched from,
1843 otherwise it was fetched from a register.
1845 The argument RAW_BUFFER must point to aligned memory. */
1847 cfi_get_saved_register (char *raw_buffer
,
1850 struct frame_info
*frame
,
1851 int regnum
, enum lval_type
*lval
)
1853 if (!target_has_registers
)
1854 error ("No registers.");
1856 /* Normal systems don't optimize out things with register numbers. */
1857 if (optimized
!= NULL
)
1860 if (addrp
) /* default assumption: not found in memory */
1865 read_register_gen (regnum
, raw_buffer
);
1867 *lval
= lval_register
;
1869 *addrp
= REGISTER_BYTE (regnum
);
1873 frame
= frame
->next
;
1874 switch (UNWIND_CONTEXT (frame
)->reg
[regnum
].how
)
1876 case REG_CTX_UNSAVED
:
1877 read_register_gen (regnum
, raw_buffer
);
1880 if (optimized
!= NULL
)
1883 case REG_CTX_SAVED_OFFSET
:
1884 target_read_memory (UNWIND_CONTEXT (frame
)->cfa
+
1885 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
,
1886 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1888 *lval
= lval_memory
;
1891 UNWIND_CONTEXT (frame
)->cfa
+
1892 UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.offset
;
1894 case REG_CTX_SAVED_REG
:
1895 read_register_gen (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
,
1898 *lval
= lval_register
;
1901 REGISTER_BYTE (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.reg
);
1903 case REG_CTX_SAVED_ADDR
:
1904 target_read_memory (UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1905 raw_buffer
, REGISTER_RAW_SIZE (regnum
));
1907 *lval
= lval_memory
;
1909 *addrp
= UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
;
1912 memcpy (raw_buffer
, &UNWIND_CONTEXT (frame
)->reg
[regnum
].loc
.addr
,
1913 REGISTER_RAW_SIZE (regnum
));
1916 if (optimized
!= NULL
)
1920 internal_error (__FILE__
, __LINE__
,
1921 "cfi_get_saved_register: unknown register rule");
1926 /* Return the register that the function uses for a frame pointer,
1927 plus any necessary offset to be applied to the register before
1928 any frame pointer offsets. */
1930 cfi_virtual_frame_pointer (CORE_ADDR pc
, int *frame_reg
,
1931 LONGEST
* frame_offset
)
1933 struct context
*context
;
1934 struct frame_state
*fs
;
1936 unwind_tmp_obstack_init ();
1938 context
= context_alloc ();
1939 fs
= frame_state_alloc ();
1941 context
->ra
= read_pc () + 1;
1943 frame_state_for (context
, fs
);
1945 if (fs
->cfa_how
== CFA_REG_OFFSET
)
1947 *frame_reg
= fs
->cfa_reg
;
1948 *frame_offset
= fs
->cfa_offset
;
1951 error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1953 unwind_tmp_obstack_free ();