1 /* Subroutines needed for unwinding stack frames for exception handling. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
4 Contributed by Jason Merrill <jason@cygnus.com>.
6 This file is part of GNU CC.
8 GNU CC 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, or (at your option)
13 GNU CC 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 GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* As a special exception, if you link this library with other files,
24 some of which are compiled with GCC, to produce an executable,
25 this library does not by itself cause the resulting executable
26 to be covered by the GNU General Public License.
27 This exception does not however invalidate any other reasons why
28 the executable file might be covered by the GNU General Public License. */
30 /* It is incorrect to include config.h here, because this file is being
31 compiled for the target, and hence definitions concerning only the host
36 /* We disable this when inhibit_libc, so that gcc can still be built without
37 needing header files first. */
38 /* ??? This is not a good solution, since prototypes may be required in
39 some cases for correct code. See also libgcc2.c. */
41 /* fixproto guarantees these system headers exist. */
48 #ifdef DWARF2_UNWIND_INFO
49 #include "gansidecl.h"
55 #ifdef __GTHREAD_MUTEX_INIT
56 static __gthread_mutex_t object_mutex = __GTHREAD_MUTEX_INIT;
58 static __gthread_mutex_t object_mutex;
61 /* Don't use `fancy_abort' here even if config.h says to use it. */
66 /* Some types used by the DWARF 2 spec. */
68 typedef int sword __attribute__ ((mode (SI)));
69 typedef unsigned int uword __attribute__ ((mode (SI)));
70 typedef unsigned int uaddr __attribute__ ((mode (pointer)));
71 typedef int saddr __attribute__ ((mode (pointer)));
72 typedef unsigned char ubyte;
75 CIE - Common Information Element
76 FDE - Frame Descriptor Element
78 There is one per function, and it describes where the function code
79 is located, and what the register lifetimes and stack layout are
82 The data structures are defined in the DWARF specfication, although
83 not in a very readable way (see LITERATURE).
85 Every time an exception is thrown, the code needs to locate the FDE
86 for the current function, and starts to look for exception regions
87 from that FDE. This works in a two-level search:
88 a) in a linear search, find the shared image (i.e. DLL) containing
90 b) using the FDE table for that shared object, locate the FDE using
91 binary search (which requires the sorting). */
93 /* The first few fields of a CIE. The CIE_id field is 0 for a CIE,
94 to distinguish it from a valid FDE. FDEs are aligned to an addressing
95 unit boundary, but the fields within are unaligned. */
101 char augmentation[0];
102 } __attribute__ ((packed, aligned (__alignof__ (void *))));
104 /* The first few fields of an FDE. */
111 } __attribute__ ((packed, aligned (__alignof__ (void *))));
113 typedef struct dwarf_fde fde;
115 /* Objects to be searched for frame unwind info. */
117 static struct object *objects;
119 /* The information we care about from a CIE. */
129 /* The current unwind state, plus a saved copy for DW_CFA_remember_state. */
131 struct frame_state_internal
133 struct frame_state s;
134 struct frame_state_internal *saved_state;
137 /* This is undefined below if we need it to be an actual function. */
138 #define init_object_mutex_once()
141 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION
143 /* Helper for init_object_mutex_once. */
146 init_object_mutex (void)
148 __GTHREAD_MUTEX_INIT_FUNCTION (&object_mutex);
151 /* Call this to arrange to initialize the object mutex. */
153 #undef init_object_mutex_once
155 init_object_mutex_once (void)
157 static __gthread_once_t once = __GTHREAD_ONCE_INIT;
158 __gthread_once (&once, init_object_mutex);
161 #endif /* __GTHREAD_MUTEX_INIT_FUNCTION */
162 #endif /* __GTHREADS */
164 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
165 by R, and return the new value of BUF. */
168 decode_uleb128 (unsigned char *buf, unsigned *r)
175 unsigned byte = *buf++;
176 result |= (byte & 0x7f) << shift;
177 if ((byte & 0x80) == 0)
185 /* Decode the signed LEB128 constant at BUF into the variable pointed to
186 by R, and return the new value of BUF. */
189 decode_sleb128 (unsigned char *buf, int *r)
198 result |= (byte & 0x7f) << shift;
200 if ((byte & 0x80) == 0)
203 if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
204 result |= - (1 << shift);
210 /* Read unaligned data from the instruction buffer. */
214 unsigned b2 __attribute__ ((mode (HI)));
215 unsigned b4 __attribute__ ((mode (SI)));
216 unsigned b8 __attribute__ ((mode (DI)));
217 } __attribute__ ((packed));
219 read_pointer (void *p)
220 { union unaligned *up = p; return up->p; }
221 static inline unsigned
223 { return *(unsigned char *)p; }
224 static inline unsigned
226 { union unaligned *up = p; return up->b2; }
227 static inline unsigned
229 { union unaligned *up = p; return up->b4; }
230 static inline unsigned long
232 { union unaligned *up = p; return up->b8; }
234 /* Ordering function for FDEs. Functions can't overlap, so we just compare
235 their starting addresses. */
238 fde_compare (fde *x, fde *y)
240 return (saddr)x->pc_begin - (saddr)y->pc_begin;
243 /* Return the address of the FDE after P. */
248 return (fde *)(((char *)p) + p->length + sizeof (p->length));
251 /* Sorting an array of FDEs by address.
252 (Ideally we would have the linker sort the FDEs so we don't have to do
253 it at run time. But the linkers are not yet prepared for this.) */
255 /* This is a special mix of insertion sort and heap sort, optimized for
256 the data sets that actually occur. They look like
257 101 102 103 127 128 105 108 110 190 111 115 119 125 160 126 129 130.
258 I.e. a linearly increasing sequence (coming from functions in the text
259 section), with additionally a few unordered elements (coming from functions
260 in gnu_linkonce sections) whose values are higher than the values in the
261 surrounding linear sequence (but not necessarily higher than the values
262 at the end of the linear sequence!).
263 The worst-case total run time is O(N) + O(n log (n)), where N is the
264 total number of FDEs and n is the number of erratic ones. */
266 typedef struct fde_vector
272 typedef struct fde_accumulator
279 start_fde_sort (fde_accumulator *accu, size_t count)
281 accu->linear.array = (fde **) malloc (sizeof (fde *) * count);
282 accu->erratic.array = (fde **) malloc (sizeof (fde *) * count);
283 accu->linear.count = 0;
284 accu->erratic.count = 0;
288 fde_insert (fde_accumulator *accu, fde *this_fde)
290 accu->linear.array[accu->linear.count++] = this_fde;
293 /* Split LINEAR into a linear sequence with low values and an erratic
294 sequence with high values, put the linear one (of longest possible
295 length) into LINEAR and the erratic one into ERRATIC. This is O(N). */
297 fde_split (fde_vector *linear, fde_vector *erratic)
299 size_t count = linear->count;
300 size_t linear_max = (size_t) -1;
301 size_t previous_max[count];
304 for (i = 0; i < count; i++)
308 && fde_compare (linear->array[i], linear->array[j]) < 0;
311 erratic->array[erratic->count++] = linear->array[j];
312 linear->array[j] = (fde *) NULL;
318 for (i = 0, j = 0; i < count; i++)
319 if (linear->array[i] != (fde *) NULL)
320 linear->array[j++] = linear->array[i];
324 /* This is O(n log(n)). BSD/OS defines heapsort in stdlib.h, so we must
325 use a name that does not conflict. */
327 frame_heapsort (fde_vector *erratic)
329 /* For a description of this algorithm, see:
330 Samuel P. Harbison, Guy L. Steele Jr.: C, a reference manual, 2nd ed.,
332 fde ** a = erratic->array;
333 /* A portion of the array is called a "heap" if for all i>=0:
334 If i and 2i+1 are valid indices, then a[i] >= a[2i+1].
335 If i and 2i+2 are valid indices, then a[i] >= a[2i+2]. */
336 #define SWAP(x,y) do { fde * tmp = x; x = y; y = tmp; } while (0)
337 size_t n = erratic->count;
343 /* Invariant: a[m..n-1] is a heap. */
345 for (i = m; 2*i+1 < n; )
348 && fde_compare (a[2*i+2], a[2*i+1]) > 0
349 && fde_compare (a[2*i+2], a[i]) > 0)
351 SWAP (a[i], a[2*i+2]);
354 else if (fde_compare (a[2*i+1], a[i]) > 0)
356 SWAP (a[i], a[2*i+1]);
365 /* Invariant: a[0..n-1] is a heap. */
368 for (i = 0; 2*i+1 < n; )
371 && fde_compare (a[2*i+2], a[2*i+1]) > 0
372 && fde_compare (a[2*i+2], a[i]) > 0)
374 SWAP (a[i], a[2*i+2]);
377 else if (fde_compare (a[2*i+1], a[i]) > 0)
379 SWAP (a[i], a[2*i+1]);
389 /* Merge V1 and V2, both sorted, and put the result into V1. */
391 fde_merge (fde_vector *v1, const fde_vector *v2)
402 fde2 = v2->array[i2];
403 while (i1 > 0 && fde_compare (v1->array[i1-1], fde2) > 0)
405 v1->array[i1+i2] = v1->array[i1-1];
408 v1->array[i1+i2] = fde2;
410 v1->count += v2->count;
415 end_fde_sort (fde_accumulator *accu, size_t count)
417 if (accu->linear.count != count)
419 fde_split (&accu->linear, &accu->erratic);
420 if (accu->linear.count + accu->erratic.count != count)
422 frame_heapsort (&accu->erratic);
423 fde_merge (&accu->linear, &accu->erratic);
424 free (accu->erratic.array);
425 return accu->linear.array;
429 count_fdes (fde *this_fde)
433 for (count = 0; this_fde->length != 0; this_fde = next_fde (this_fde))
435 /* Skip CIEs and linked once FDE entries. */
436 if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0)
446 add_fdes (fde *this_fde, fde_accumulator *accu, void **beg_ptr, void **end_ptr)
448 void *pc_begin = *beg_ptr;
449 void *pc_end = *end_ptr;
451 for (; this_fde->length != 0; this_fde = next_fde (this_fde))
453 /* Skip CIEs and linked once FDE entries. */
454 if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0)
457 fde_insert (accu, this_fde);
459 if (this_fde->pc_begin < pc_begin)
460 pc_begin = this_fde->pc_begin;
461 if (this_fde->pc_begin + this_fde->pc_range > pc_end)
462 pc_end = this_fde->pc_begin + this_fde->pc_range;
469 /* Set up a sorted array of pointers to FDEs for a loaded object. We
470 count up the entries before allocating the array because it's likely to
474 frame_init (struct object* ob)
477 fde_accumulator accu;
478 void *pc_begin, *pc_end;
482 fde **p = ob->fde_array;
483 for (count = 0; *p; ++p)
484 count += count_fdes (*p);
487 count = count_fdes (ob->fde_begin);
491 start_fde_sort (&accu, count);
492 pc_begin = (void*)(uaddr)-1;
497 fde **p = ob->fde_array;
499 add_fdes (*p, &accu, &pc_begin, &pc_end);
502 add_fdes (ob->fde_begin, &accu, &pc_begin, &pc_end);
504 ob->fde_array = end_fde_sort (&accu, count);
505 ob->pc_begin = pc_begin;
509 /* Return a pointer to the FDE for the function containing PC. */
517 init_object_mutex_once ();
518 __gthread_mutex_lock (&object_mutex);
520 for (ob = objects; ob; ob = ob->next)
522 if (ob->pc_begin == 0)
524 if (pc >= ob->pc_begin && pc < ob->pc_end)
528 __gthread_mutex_unlock (&object_mutex);
533 /* Standard binary search algorithm. */
534 for (lo = 0, hi = ob->count; lo < hi; )
536 size_t i = (lo + hi) / 2;
537 fde *f = ob->fde_array[i];
539 if (pc < f->pc_begin)
541 else if (pc >= f->pc_begin + f->pc_range)
550 static inline struct dwarf_cie *
553 return ((void *)&f->CIE_delta) - f->CIE_delta;
556 /* Extract any interesting information from the CIE for the translation
557 unit F belongs to. */
560 extract_cie_info (fde *f, struct cie_info *c)
565 c->augmentation = get_cie (f)->augmentation;
567 if (strcmp (c->augmentation, "") != 0
568 && strcmp (c->augmentation, "eh") != 0
569 && c->augmentation[0] != 'z')
572 p = c->augmentation + strlen (c->augmentation) + 1;
574 if (strcmp (c->augmentation, "eh") == 0)
576 c->eh_ptr = read_pointer (p);
577 p += sizeof (void *);
582 p = decode_uleb128 (p, &c->code_align);
583 p = decode_sleb128 (p, &c->data_align);
584 c->ra_regno = *(unsigned char *)p++;
586 /* If the augmentation starts with 'z', we now see the length of the
587 augmentation fields. */
588 if (c->augmentation[0] == 'z')
590 p = decode_uleb128 (p, &i);
597 /* Decode one instruction's worth of DWARF 2 call frame information.
598 Used by __frame_state_for. Takes pointers P to the instruction to
599 decode, STATE to the current register unwind information, INFO to the
600 current CIE information, and PC to the current PC value. Returns a
601 pointer to the next instruction. */
604 execute_cfa_insn (void *p, struct frame_state_internal *state,
605 struct cie_info *info, void **pc)
607 unsigned insn = *(unsigned char *)p++;
611 if (insn & DW_CFA_advance_loc)
612 *pc += ((insn & 0x3f) * info->code_align);
613 else if (insn & DW_CFA_offset)
616 p = decode_uleb128 (p, &offset);
617 offset *= info->data_align;
618 state->s.saved[reg] = REG_SAVED_OFFSET;
619 state->s.reg_or_offset[reg] = offset;
621 else if (insn & DW_CFA_restore)
624 state->s.saved[reg] = REG_UNSAVED;
629 *pc = read_pointer (p);
630 p += sizeof (void *);
632 case DW_CFA_advance_loc1:
633 *pc += read_1byte (p);
636 case DW_CFA_advance_loc2:
637 *pc += read_2byte (p);
640 case DW_CFA_advance_loc4:
641 *pc += read_4byte (p);
645 case DW_CFA_offset_extended:
646 p = decode_uleb128 (p, ®);
647 p = decode_uleb128 (p, &offset);
648 offset *= info->data_align;
649 state->s.saved[reg] = REG_SAVED_OFFSET;
650 state->s.reg_or_offset[reg] = offset;
652 case DW_CFA_restore_extended:
653 p = decode_uleb128 (p, ®);
654 state->s.saved[reg] = REG_UNSAVED;
657 case DW_CFA_undefined:
658 case DW_CFA_same_value:
662 case DW_CFA_register:
665 p = decode_uleb128 (p, ®);
666 p = decode_uleb128 (p, ®2);
667 state->s.saved[reg] = REG_SAVED_REG;
668 state->s.reg_or_offset[reg] = reg2;
673 p = decode_uleb128 (p, ®);
674 p = decode_uleb128 (p, &offset);
675 state->s.cfa_reg = reg;
676 state->s.cfa_offset = offset;
678 case DW_CFA_def_cfa_register:
679 p = decode_uleb128 (p, ®);
680 state->s.cfa_reg = reg;
682 case DW_CFA_def_cfa_offset:
683 p = decode_uleb128 (p, &offset);
684 state->s.cfa_offset = offset;
687 case DW_CFA_remember_state:
689 struct frame_state_internal *save =
690 (struct frame_state_internal *)
691 malloc (sizeof (struct frame_state_internal));
692 memcpy (save, state, sizeof (struct frame_state_internal));
693 state->saved_state = save;
696 case DW_CFA_restore_state:
698 struct frame_state_internal *save = state->saved_state;
699 memcpy (state, save, sizeof (struct frame_state_internal));
704 /* FIXME: Hardcoded for SPARC register window configuration. */
705 case DW_CFA_GNU_window_save:
706 for (reg = 16; reg < 32; ++reg)
708 state->s.saved[reg] = REG_SAVED_OFFSET;
709 state->s.reg_or_offset[reg] = (reg - 16) * sizeof (void *);
713 case DW_CFA_GNU_args_size:
714 p = decode_uleb128 (p, &offset);
715 state->s.args_size = offset;
724 /* Called from crtbegin.o to register the unwind info for an object. */
727 __register_frame_info (void *begin, struct object *ob)
729 ob->fde_begin = begin;
731 ob->pc_begin = ob->pc_end = 0;
735 init_object_mutex_once ();
736 __gthread_mutex_lock (&object_mutex);
741 __gthread_mutex_unlock (&object_mutex);
745 __register_frame (void *begin)
747 struct object *ob = (struct object *) malloc (sizeof (struct object));
748 __register_frame_info (begin, ob);
751 /* Similar, but BEGIN is actually a pointer to a table of unwind entries
752 for different translation units. Called from the file generated by
756 __register_frame_info_table (void *begin, struct object *ob)
758 ob->fde_begin = begin;
759 ob->fde_array = begin;
761 ob->pc_begin = ob->pc_end = 0;
764 init_object_mutex_once ();
765 __gthread_mutex_lock (&object_mutex);
770 __gthread_mutex_unlock (&object_mutex);
774 __register_frame_table (void *begin)
776 struct object *ob = (struct object *) malloc (sizeof (struct object));
777 __register_frame_info_table (begin, ob);
780 /* Called from crtbegin.o to deregister the unwind info for an object. */
783 __deregister_frame_info (void *begin)
787 init_object_mutex_once ();
788 __gthread_mutex_lock (&object_mutex);
793 if ((*p)->fde_begin == begin)
795 struct object *ob = *p;
798 /* If we've run init_frame for this object, free the FDE array. */
800 free (ob->fde_array);
802 __gthread_mutex_unlock (&object_mutex);
808 __gthread_mutex_unlock (&object_mutex);
813 __deregister_frame (void *begin)
815 free (__deregister_frame_info (begin));
818 /* Called from __throw to find the registers to restore for a given
819 PC_TARGET. The caller should allocate a local variable of `struct
820 frame_state' (declared in frame.h) and pass its address to STATE_IN. */
823 __frame_state_for (void *pc_target, struct frame_state *state_in)
826 void *insn, *end, *pc;
827 struct cie_info info;
828 struct frame_state_internal state;
830 f = find_fde (pc_target);
834 insn = extract_cie_info (f, &info);
838 memset (&state, 0, sizeof (state));
839 state.s.retaddr_column = info.ra_regno;
840 state.s.eh_ptr = info.eh_ptr;
842 /* First decode all the insns in the CIE. */
843 end = next_fde ((fde*) get_cie (f));
845 insn = execute_cfa_insn (insn, &state, &info, 0);
847 insn = ((fde *)f) + 1;
849 if (info.augmentation[0] == 'z')
852 insn = decode_uleb128 (insn, &i);
856 /* Then the insns in the FDE up to our target PC. */
859 while (insn < end && pc <= pc_target)
860 insn = execute_cfa_insn (insn, &state, &info, &pc);
862 memcpy (state_in, &state.s, sizeof (state.s));
865 #endif /* DWARF2_UNWIND_INFO */