1 /* Subroutines needed for unwinding stack frames for exception handling. */
2 /* Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Jason Merrill <jason@cygnus.com>.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combine
21 GNU CC is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with GNU CC; see the file COPYING. If not, write to
28 the Free Software Foundation, 59 Temple Place - Suite 330,
29 Boston, MA 02111-1307, USA. */
35 #define NO_BASE_OF_ENCODED_VALUE
36 #include "unwind-pe.h"
37 #include "unwind-dw2-fde.h"
40 /* The unseen_objects list contains objects that have been registered
41 but not yet categorized in any way. The seen_objects list has had
42 it's pc_begin and count fields initialized at minimum, and is sorted
43 by decreasing value of pc_begin. */
44 static struct object
*unseen_objects
;
45 static struct object
*seen_objects
;
47 #ifdef __GTHREAD_MUTEX_INIT
48 static __gthread_mutex_t object_mutex
= __GTHREAD_MUTEX_INIT
;
50 static __gthread_mutex_t object_mutex
;
53 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION
55 init_object_mutex (void)
57 __GTHREAD_MUTEX_INIT_FUNCTION (&object_mutex
);
61 init_object_mutex_once (void)
63 static __gthread_once_t once
= __GTHREAD_ONCE_INIT
;
64 __gthread_once (&once
, init_object_mutex
);
67 #define init_object_mutex_once()
70 /* Called from crtbegin.o to register the unwind info for an object. */
73 __register_frame_info_bases (void *begin
, struct object
*ob
,
74 void *tbase
, void *dbase
)
76 ob
->pc_begin
= (void *)-1;
81 ob
->s
.b
.encoding
= DW_EH_PE_omit
;
83 init_object_mutex_once ();
84 __gthread_mutex_lock (&object_mutex
);
86 ob
->next
= unseen_objects
;
89 __gthread_mutex_unlock (&object_mutex
);
93 __register_frame_info (void *begin
, struct object
*ob
)
95 __register_frame_info_bases (begin
, ob
, 0, 0);
99 __register_frame (void *begin
)
101 struct object
*ob
= (struct object
*) malloc (sizeof (struct object
));
102 __register_frame_info (begin
, ob
);
105 /* Similar, but BEGIN is actually a pointer to a table of unwind entries
106 for different translation units. Called from the file generated by
110 __register_frame_info_table_bases (void *begin
, struct object
*ob
,
111 void *tbase
, void *dbase
)
113 ob
->pc_begin
= (void *)-1;
118 ob
->s
.b
.from_array
= 1;
119 ob
->s
.b
.encoding
= DW_EH_PE_omit
;
121 init_object_mutex_once ();
122 __gthread_mutex_lock (&object_mutex
);
124 ob
->next
= unseen_objects
;
127 __gthread_mutex_unlock (&object_mutex
);
131 __register_frame_info_table (void *begin
, struct object
*ob
)
133 __register_frame_info_table_bases (begin
, ob
, 0, 0);
137 __register_frame_table (void *begin
)
139 struct object
*ob
= (struct object
*) malloc (sizeof (struct object
));
140 __register_frame_info_table (begin
, ob
);
143 /* Called from crtbegin.o to deregister the unwind info for an object. */
144 /* ??? Glibc has for a while now exported __register_frame_info and
145 __deregister_frame_info. If we call __register_frame_info_bases
146 from crtbegin (wherein it is declared weak), and this object does
147 not get pulled from libgcc.a for other reasons, then the
148 invocation of __deregister_frame_info will be resolved from glibc.
149 Since the registration did not happen there, we'll abort.
151 Therefore, declare a new deregistration entry point that does the
152 exact same thing, but will resolve to the same library as
153 implements __register_frame_info_bases. */
156 __deregister_frame_info_bases (void *begin
)
159 struct object
*ob
= 0;
161 init_object_mutex_once ();
162 __gthread_mutex_lock (&object_mutex
);
164 for (p
= &unseen_objects
; *p
; p
= &(*p
)->next
)
165 if ((*p
)->u
.single
== begin
)
172 for (p
= &seen_objects
; *p
; p
= &(*p
)->next
)
173 if ((*p
)->s
.b
.sorted
)
175 if ((*p
)->u
.sort
->orig_data
== begin
)
185 if ((*p
)->u
.single
== begin
)
193 __gthread_mutex_unlock (&object_mutex
);
197 __gthread_mutex_unlock (&object_mutex
);
202 __deregister_frame_info (void *begin
)
204 return __deregister_frame_info_bases (begin
);
208 __deregister_frame (void *begin
)
210 free (__deregister_frame_info (begin
));
214 /* Like base_of_encoded_value, but take the base from a struct object
215 instead of an _Unwind_Context. */
218 base_from_object (unsigned char encoding
, struct object
*ob
)
220 if (encoding
== DW_EH_PE_omit
)
223 switch (encoding
& 0x70)
225 case DW_EH_PE_absptr
:
227 case DW_EH_PE_aligned
:
230 case DW_EH_PE_textrel
:
231 return (_Unwind_Ptr
) ob
->tbase
;
232 case DW_EH_PE_datarel
:
233 return (_Unwind_Ptr
) ob
->dbase
;
238 /* Return the FDE pointer encoding from the CIE. */
239 /* ??? This is a subset of extract_cie_info from unwind-dw2.c. */
242 get_cie_encoding (struct dwarf_cie
*cie
)
244 const unsigned char *aug
, *p
;
247 aug
= cie
->augmentation
;
249 return DW_EH_PE_absptr
;
251 p
= aug
+ strlen (aug
) + 1; /* Skip the augmentation string. */
252 p
= read_uleb128 (p
, &dummy
); /* Skip code alignment. */
253 p
= read_sleb128 (p
, &dummy
); /* Skip data alignment. */
254 p
++; /* Skip return address column. */
256 aug
++; /* Skip 'z' */
257 p
= read_uleb128 (p
, &dummy
); /* Skip augmentation length. */
260 /* This is what we're looking for. */
263 /* Personality encoding and pointer. */
264 else if (*aug
== 'P')
266 /* ??? Avoid dereferencing indirect pointers, since we're
267 faking the base address. Gotta keep DW_EH_PE_aligned
269 p
= read_encoded_value_with_base (*p
& 0x7F, 0, p
+ 1, &dummy
);
272 else if (*aug
== 'L')
274 /* Otherwise end of string, or unknown augmentation. */
276 return DW_EH_PE_absptr
;
282 get_fde_encoding (struct dwarf_fde
*f
)
284 return get_cie_encoding (get_cie (f
));
288 /* Sorting an array of FDEs by address.
289 (Ideally we would have the linker sort the FDEs so we don't have to do
290 it at run time. But the linkers are not yet prepared for this.) */
292 /* Comparison routines. Three variants of increasing complexity. */
295 fde_unencoded_compare (struct object
*ob
__attribute__((unused
)),
298 return *(saddr
*)x
->pc_begin
- *(saddr
*)y
->pc_begin
;
302 fde_single_encoding_compare (struct object
*ob
, fde
*x
, fde
*y
)
304 _Unwind_Ptr base
, x_ptr
, y_ptr
;
306 base
= base_from_object (ob
->s
.b
.encoding
, ob
);
307 read_encoded_value_with_base (ob
->s
.b
.encoding
, base
, x
->pc_begin
, &x_ptr
);
308 read_encoded_value_with_base (ob
->s
.b
.encoding
, base
, y
->pc_begin
, &y_ptr
);
310 return x_ptr
- y_ptr
;
314 fde_mixed_encoding_compare (struct object
*ob
, fde
*x
, fde
*y
)
316 int x_encoding
, y_encoding
;
317 _Unwind_Ptr x_ptr
, y_ptr
;
319 x_encoding
= get_fde_encoding (x
);
320 read_encoded_value_with_base (x_encoding
, base_from_object (x_encoding
, ob
),
321 x
->pc_begin
, &x_ptr
);
323 y_encoding
= get_fde_encoding (y
);
324 read_encoded_value_with_base (y_encoding
, base_from_object (y_encoding
, ob
),
325 y
->pc_begin
, &y_ptr
);
327 return x_ptr
- y_ptr
;
330 typedef saddr (*fde_compare_t
) (struct object
*, fde
*, fde
*);
333 /* This is a special mix of insertion sort and heap sort, optimized for
334 the data sets that actually occur. They look like
335 101 102 103 127 128 105 108 110 190 111 115 119 125 160 126 129 130.
336 I.e. a linearly increasing sequence (coming from functions in the text
337 section), with additionally a few unordered elements (coming from functions
338 in gnu_linkonce sections) whose values are higher than the values in the
339 surrounding linear sequence (but not necessarily higher than the values
340 at the end of the linear sequence!).
341 The worst-case total run time is O(N) + O(n log (n)), where N is the
342 total number of FDEs and n is the number of erratic ones. */
344 struct fde_accumulator
346 struct fde_vector
*linear
;
347 struct fde_vector
*erratic
;
351 start_fde_sort (struct fde_accumulator
*accu
, size_t count
)
357 size
= sizeof (struct fde_vector
) + sizeof (fde
*) * count
;
358 if ((accu
->linear
= (struct fde_vector
*) malloc (size
)))
360 accu
->linear
->count
= 0;
361 if ((accu
->erratic
= (struct fde_vector
*) malloc (size
)))
362 accu
->erratic
->count
= 0;
370 fde_insert (struct fde_accumulator
*accu
, fde
*this_fde
)
373 accu
->linear
->array
[accu
->linear
->count
++] = this_fde
;
376 /* Split LINEAR into a linear sequence with low values and an erratic
377 sequence with high values, put the linear one (of longest possible
378 length) into LINEAR and the erratic one into ERRATIC. This is O(N).
380 Because the longest linear sequence we are trying to locate within the
381 incoming LINEAR array can be interspersed with (high valued) erratic
382 entries. We construct a chain indicating the sequenced entries.
383 To avoid having to allocate this chain, we overlay it onto the space of
384 the ERRATIC array during construction. A final pass iterates over the
385 chain to determine what should be placed in the ERRATIC array, and
386 what is the linear sequence. This overlay is safe from aliasing. */
389 fde_split (struct object
*ob
, fde_compare_t fde_compare
,
390 struct fde_vector
*linear
, struct fde_vector
*erratic
)
393 size_t count
= linear
->count
;
394 fde
**chain_end
= &marker
;
397 /* This should optimize out, but it is wise to make sure this assumption
398 is correct. Should these have different sizes, we cannot cast between
399 them and the overlaying onto ERRATIC will not work. */
400 if (sizeof (fde
*) != sizeof (fde
**))
403 for (i
= 0; i
< count
; i
++)
407 for (probe
= chain_end
;
408 probe
!= &marker
&& fde_compare (ob
, linear
->array
[i
], *probe
) < 0;
411 chain_end
= (fde
**)erratic
->array
[probe
- linear
->array
];
412 erratic
->array
[probe
- linear
->array
] = NULL
;
414 erratic
->array
[i
] = (fde
*)chain_end
;
415 chain_end
= &linear
->array
[i
];
418 /* Each entry in LINEAR which is part of the linear sequence we have
419 discovered will correspond to a non-NULL entry in the chain we built in
420 the ERRATIC array. */
421 for (i
= j
= k
= 0; i
< count
; i
++)
422 if (erratic
->array
[i
])
423 linear
->array
[j
++] = linear
->array
[i
];
425 erratic
->array
[k
++] = linear
->array
[i
];
430 /* This is O(n log(n)). BSD/OS defines heapsort in stdlib.h, so we must
431 use a name that does not conflict. */
434 frame_heapsort (struct object
*ob
, fde_compare_t fde_compare
,
435 struct fde_vector
*erratic
)
437 /* For a description of this algorithm, see:
438 Samuel P. Harbison, Guy L. Steele Jr.: C, a reference manual, 2nd ed.,
440 fde
** a
= erratic
->array
;
441 /* A portion of the array is called a "heap" if for all i>=0:
442 If i and 2i+1 are valid indices, then a[i] >= a[2i+1].
443 If i and 2i+2 are valid indices, then a[i] >= a[2i+2]. */
444 #define SWAP(x,y) do { fde * tmp = x; x = y; y = tmp; } while (0)
445 size_t n
= erratic
->count
;
451 /* Invariant: a[m..n-1] is a heap. */
453 for (i
= m
; 2*i
+1 < n
; )
456 && fde_compare (ob
, a
[2*i
+2], a
[2*i
+1]) > 0
457 && fde_compare (ob
, a
[2*i
+2], a
[i
]) > 0)
459 SWAP (a
[i
], a
[2*i
+2]);
462 else if (fde_compare (ob
, a
[2*i
+1], a
[i
]) > 0)
464 SWAP (a
[i
], a
[2*i
+1]);
473 /* Invariant: a[0..n-1] is a heap. */
476 for (i
= 0; 2*i
+1 < n
; )
479 && fde_compare (ob
, a
[2*i
+2], a
[2*i
+1]) > 0
480 && fde_compare (ob
, a
[2*i
+2], a
[i
]) > 0)
482 SWAP (a
[i
], a
[2*i
+2]);
485 else if (fde_compare (ob
, a
[2*i
+1], a
[i
]) > 0)
487 SWAP (a
[i
], a
[2*i
+1]);
497 /* Merge V1 and V2, both sorted, and put the result into V1. */
499 fde_merge (struct object
*ob
, fde_compare_t fde_compare
,
500 struct fde_vector
*v1
, struct fde_vector
*v2
)
511 fde2
= v2
->array
[i2
];
512 while (i1
> 0 && fde_compare (ob
, v1
->array
[i1
-1], fde2
) > 0)
514 v1
->array
[i1
+i2
] = v1
->array
[i1
-1];
517 v1
->array
[i1
+i2
] = fde2
;
519 v1
->count
+= v2
->count
;
524 end_fde_sort (struct object
*ob
, struct fde_accumulator
*accu
, size_t count
)
526 fde_compare_t fde_compare
;
528 if (accu
->linear
&& accu
->linear
->count
!= count
)
531 if (ob
->s
.b
.mixed_encoding
)
532 fde_compare
= fde_mixed_encoding_compare
;
533 else if (ob
->s
.b
.encoding
== DW_EH_PE_absptr
)
534 fde_compare
= fde_unencoded_compare
;
536 fde_compare
= fde_single_encoding_compare
;
540 fde_split (ob
, fde_compare
, accu
->linear
, accu
->erratic
);
541 if (accu
->linear
->count
+ accu
->erratic
->count
!= count
)
543 frame_heapsort (ob
, fde_compare
, accu
->erratic
);
544 fde_merge (ob
, fde_compare
, accu
->linear
, accu
->erratic
);
545 free (accu
->erratic
);
549 /* We've not managed to malloc an erratic array,
550 so heap sort in the linear one. */
551 frame_heapsort (ob
, fde_compare
, accu
->linear
);
556 /* Update encoding, mixed_encoding, and pc_begin for OB for the
557 fde array beginning at THIS_FDE. Return the number of fdes
558 encountered along the way. */
561 classify_object_over_fdes (struct object
*ob
, fde
*this_fde
)
563 struct dwarf_cie
*last_cie
= 0;
565 int encoding
= DW_EH_PE_absptr
;
566 _Unwind_Ptr base
= 0;
568 for (; this_fde
->length
!= 0; this_fde
= next_fde (this_fde
))
570 struct dwarf_cie
*this_cie
;
571 _Unwind_Ptr mask
, pc_begin
;
574 if (this_fde
->CIE_delta
== 0)
577 /* Determine the encoding for this FDE. Note mixed encoded
578 objects for later. */
579 this_cie
= get_cie (this_fde
);
580 if (this_cie
!= last_cie
)
583 encoding
= get_cie_encoding (this_cie
);
584 base
= base_from_object (encoding
, ob
);
585 if (ob
->s
.b
.encoding
== DW_EH_PE_omit
)
586 ob
->s
.b
.encoding
= encoding
;
587 else if (ob
->s
.b
.encoding
!= encoding
)
588 ob
->s
.b
.mixed_encoding
= 1;
591 read_encoded_value_with_base (encoding
, base
, this_fde
->pc_begin
,
594 /* Take care to ignore link-once functions that were removed.
595 In these cases, the function address will be NULL, but if
596 the encoding is smaller than a pointer a true NULL may not
597 be representable. Assume 0 in the representable bits is NULL. */
598 mask
= size_of_encoded_value (encoding
);
599 if (mask
< sizeof (void *))
600 mask
= (1L << (mask
<< 3)) - 1;
604 if ((pc_begin
& mask
) == 0)
608 if ((void *)pc_begin
< ob
->pc_begin
)
609 ob
->pc_begin
= (void *)pc_begin
;
616 add_fdes (struct object
*ob
, struct fde_accumulator
*accu
, fde
*this_fde
)
618 struct dwarf_cie
*last_cie
= 0;
619 int encoding
= ob
->s
.b
.encoding
;
620 _Unwind_Ptr base
= base_from_object (ob
->s
.b
.encoding
, ob
);
622 for (; this_fde
->length
!= 0; this_fde
= next_fde (this_fde
))
624 struct dwarf_cie
*this_cie
;
627 if (this_fde
->CIE_delta
== 0)
630 if (ob
->s
.b
.mixed_encoding
)
632 /* Determine the encoding for this FDE. Note mixed encoded
633 objects for later. */
634 this_cie
= get_cie (this_fde
);
635 if (this_cie
!= last_cie
)
638 encoding
= get_cie_encoding (this_cie
);
639 base
= base_from_object (encoding
, ob
);
643 if (encoding
== DW_EH_PE_absptr
)
645 if (*(_Unwind_Ptr
*)this_fde
->pc_begin
== 0)
650 _Unwind_Ptr pc_begin
, mask
;
652 read_encoded_value_with_base (encoding
, base
, this_fde
->pc_begin
,
655 /* Take care to ignore link-once functions that were removed.
656 In these cases, the function address will be NULL, but if
657 the encoding is smaller than a pointer a true NULL may not
658 be representable. Assume 0 in the representable bits is NULL. */
659 mask
= size_of_encoded_value (encoding
);
660 if (mask
< sizeof (void *))
661 mask
= (1L << (mask
<< 3)) - 1;
665 if ((pc_begin
& mask
) == 0)
669 fde_insert (accu
, this_fde
);
673 /* Set up a sorted array of pointers to FDEs for a loaded object. We
674 count up the entries before allocating the array because it's likely to
675 be faster. We can be called multiple times, should we have failed to
676 allocate a sorted fde array on a previous occasion. */
679 init_object (struct object
* ob
)
681 struct fde_accumulator accu
;
684 count
= ob
->s
.b
.count
;
687 if (ob
->s
.b
.from_array
)
689 fde
**p
= ob
->u
.array
;
690 for (count
= 0; *p
; ++p
)
691 count
+= classify_object_over_fdes (ob
, *p
);
694 count
= classify_object_over_fdes (ob
, ob
->u
.single
);
696 /* The count field we have in the main struct object is somewhat
697 limited, but should suffice for virtually all cases. If the
698 counted value doesn't fit, re-write a zero. The worst that
699 happens is that we re-count next time -- admittedly non-trivial
700 in that this implies some 2M fdes, but at least we function. */
701 ob
->s
.b
.count
= count
;
702 if (ob
->s
.b
.count
!= count
)
706 if (!start_fde_sort (&accu
, count
))
709 if (ob
->s
.b
.from_array
)
712 for (p
= ob
->u
.array
; *p
; ++p
)
713 add_fdes (ob
, &accu
, *p
);
716 add_fdes (ob
, &accu
, ob
->u
.single
);
718 end_fde_sort (ob
, &accu
, count
);
720 /* Save the original fde pointer, since this is the key by which the
721 DSO will deregister the object. */
722 accu
.linear
->orig_data
= ob
->u
.single
;
723 ob
->u
.sort
= accu
.linear
;
728 /* A linear search through a set of FDEs for the given PC. This is
729 used when there was insufficient memory to allocate and sort an
733 linear_search_fdes (struct object
*ob
, fde
*this_fde
, void *pc
)
735 struct dwarf_cie
*last_cie
= 0;
736 int encoding
= ob
->s
.b
.encoding
;
737 _Unwind_Ptr base
= base_from_object (ob
->s
.b
.encoding
, ob
);
739 for (; this_fde
->length
!= 0; this_fde
= next_fde (this_fde
))
741 struct dwarf_cie
*this_cie
;
742 _Unwind_Ptr pc_begin
, pc_range
;
745 if (this_fde
->CIE_delta
== 0)
748 if (ob
->s
.b
.mixed_encoding
)
750 /* Determine the encoding for this FDE. Note mixed encoded
751 objects for later. */
752 this_cie
= get_cie (this_fde
);
753 if (this_cie
!= last_cie
)
756 encoding
= get_cie_encoding (this_cie
);
757 base
= base_from_object (encoding
, ob
);
761 if (encoding
== DW_EH_PE_absptr
)
763 pc_begin
= ((_Unwind_Ptr
*)this_fde
->pc_begin
)[0];
764 pc_range
= ((_Unwind_Ptr
*)this_fde
->pc_begin
)[1];
773 p
= read_encoded_value_with_base (encoding
, base
,
774 this_fde
->pc_begin
, &pc_begin
);
775 read_encoded_value_with_base (encoding
& 0x0F, 0, p
, &pc_range
);
777 /* Take care to ignore link-once functions that were removed.
778 In these cases, the function address will be NULL, but if
779 the encoding is smaller than a pointer a true NULL may not
780 be representable. Assume 0 in the representable bits is NULL. */
781 mask
= size_of_encoded_value (encoding
);
782 if (mask
< sizeof (void *))
783 mask
= (1L << (mask
<< 3)) - 1;
787 if ((pc_begin
& mask
) == 0)
791 if ((_Unwind_Ptr
)pc
- pc_begin
< pc_range
)
798 /* Binary search for an FDE containing the given PC. Here are three
799 implementations of increasing complexity. */
802 binary_search_unencoded_fdes (struct object
*ob
, void *pc
)
804 struct fde_vector
*vec
= ob
->u
.sort
;
807 for (lo
= 0, hi
= vec
->count
; lo
< hi
; )
809 size_t i
= (lo
+ hi
) / 2;
810 fde
*f
= vec
->array
[i
];
814 pc_begin
= ((void **)f
->pc_begin
)[0];
815 pc_range
= ((uaddr
*)f
->pc_begin
)[1];
819 else if (pc
>= pc_begin
+ pc_range
)
829 binary_search_single_encoding_fdes (struct object
*ob
, void *pc
)
831 struct fde_vector
*vec
= ob
->u
.sort
;
832 int encoding
= ob
->s
.b
.encoding
;
833 _Unwind_Ptr base
= base_from_object (encoding
, ob
);
836 for (lo
= 0, hi
= vec
->count
; lo
< hi
; )
838 size_t i
= (lo
+ hi
) / 2;
839 fde
*f
= vec
->array
[i
];
840 _Unwind_Ptr pc_begin
, pc_range
;
843 p
= read_encoded_value_with_base (encoding
, base
, f
->pc_begin
,
845 read_encoded_value_with_base (encoding
& 0x0F, 0, p
, &pc_range
);
847 if ((_Unwind_Ptr
)pc
< pc_begin
)
849 else if ((_Unwind_Ptr
)pc
>= pc_begin
+ pc_range
)
859 binary_search_mixed_encoding_fdes (struct object
*ob
, void *pc
)
861 struct fde_vector
*vec
= ob
->u
.sort
;
864 for (lo
= 0, hi
= vec
->count
; lo
< hi
; )
866 size_t i
= (lo
+ hi
) / 2;
867 fde
*f
= vec
->array
[i
];
868 _Unwind_Ptr pc_begin
, pc_range
;
872 encoding
= get_fde_encoding (f
);
873 p
= read_encoded_value_with_base (encoding
,
874 base_from_object (encoding
, ob
),
875 f
->pc_begin
, &pc_begin
);
876 read_encoded_value_with_base (encoding
& 0x0F, 0, p
, &pc_range
);
878 if ((_Unwind_Ptr
)pc
< pc_begin
)
880 else if ((_Unwind_Ptr
)pc
>= pc_begin
+ pc_range
)
890 search_object (struct object
* ob
, void *pc
)
892 /* If the data hasn't been sorted, try to do this now. We may have
893 more memory available than last time we tried. */
894 if (! ob
->s
.b
.sorted
)
898 /* Despite the above comment, the normal reason to get here is
899 that we've not processed this object before. A quick range
900 check is in order. */
901 if (pc
< ob
->pc_begin
)
907 if (ob
->s
.b
.mixed_encoding
)
908 return binary_search_mixed_encoding_fdes (ob
, pc
);
909 else if (ob
->s
.b
.encoding
== DW_EH_PE_absptr
)
910 return binary_search_unencoded_fdes (ob
, pc
);
912 return binary_search_single_encoding_fdes (ob
, pc
);
916 /* Long slow labourious linear search, cos we've no memory. */
917 if (ob
->s
.b
.from_array
)
920 for (p
= ob
->u
.array
; *p
; p
++)
922 fde
*f
= linear_search_fdes (ob
, *p
, pc
);
929 return linear_search_fdes (ob
, ob
->u
.single
, pc
);
934 _Unwind_Find_FDE (void *pc
, struct dwarf_eh_bases
*bases
)
939 init_object_mutex_once ();
940 __gthread_mutex_lock (&object_mutex
);
942 /* Linear search through the classified objects, to find the one
943 containing the pc. Note that pc_begin is sorted decending, and
944 we expect objects to be non-overlapping. */
945 for (ob
= seen_objects
; ob
; ob
= ob
->next
)
946 if (pc
>= ob
->pc_begin
)
948 f
= search_object (ob
, pc
);
954 /* Classify and search the objects we've not yet processed. */
955 while ((ob
= unseen_objects
))
959 unseen_objects
= ob
->next
;
960 f
= search_object (ob
, pc
);
962 /* Insert the object into the classified list. */
963 for (p
= &seen_objects
; *p
; p
= &(*p
)->next
)
964 if ((*p
)->pc_begin
< ob
->pc_begin
)
974 __gthread_mutex_unlock (&object_mutex
);
980 bases
->tbase
= ob
->tbase
;
981 bases
->dbase
= ob
->dbase
;
983 encoding
= ob
->s
.b
.encoding
;
984 if (ob
->s
.b
.mixed_encoding
)
985 encoding
= get_fde_encoding (f
);
986 read_encoded_value_with_base (encoding
, base_from_object (encoding
, ob
),
987 f
->pc_begin
, (_Unwind_Ptr
*)&bases
->func
);