1 /* Subroutines needed for unwinding stack frames for exception handling. */
2 /* Copyright (C) 1997-2020 Free Software Foundation, Inc.
3 Contributed by Jason Merrill <jason@cygnus.com>.
5 This file is part of the GNU C Library.
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
12 The GNU C Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public
18 License along with the GNU C Library; if not, see
19 <https://www.gnu.org/licenses/>. */
22 # include <shlib-compat.h>
25 #if !defined _LIBC || SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2_5)
30 #include <libc-lock.h>
33 #define NO_BASE_OF_ENCODED_VALUE
34 #include <unwind-pe.h>
35 #include <unwind-dw2-fde.h>
37 #ifndef _Unwind_Find_FDE
42 #define NO_BASE_OF_ENCODED_VALUE
43 #include "unwind-pe.h"
44 #include "unwind-dw2-fde.h"
49 /* The unseen_objects list contains objects that have been registered
50 but not yet categorized in any way. The seen_objects list has had
51 it's pc_begin and count fields initialized at minimum, and is sorted
52 by decreasing value of pc_begin. */
53 static struct object
*unseen_objects
;
54 static struct object
*seen_objects
;
58 __libc_lock_define_initialized (static, object_mutex
)
59 #define init_object_mutex_once()
60 #define __gthread_mutex_lock(m) __libc_lock_lock (*(m))
61 #define __gthread_mutex_unlock(m) __libc_lock_unlock (*(m))
63 void __register_frame_info_bases (void *begin
, struct object
*ob
,
64 void *tbase
, void *dbase
);
65 hidden_proto (__register_frame_info_bases
)
66 void __register_frame_info_table_bases (void *begin
,
68 void *tbase
, void *dbase
);
69 hidden_proto (__register_frame_info_table_bases
)
70 void *__deregister_frame_info_bases (void *begin
);
71 hidden_proto (__deregister_frame_info_bases
)
75 #ifdef __GTHREAD_MUTEX_INIT
76 static __gthread_mutex_t object_mutex
= __GTHREAD_MUTEX_INIT
;
78 static __gthread_mutex_t object_mutex
;
81 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION
83 init_object_mutex (void)
85 __GTHREAD_MUTEX_INIT_FUNCTION (&object_mutex
);
89 init_object_mutex_once (void)
91 static __gthread_once_t once
= __GTHREAD_ONCE_INIT
;
92 __gthread_once (&once
, init_object_mutex
);
95 #define init_object_mutex_once()
100 /* Called from crtbegin.o to register the unwind info for an object. */
103 __register_frame_info_bases (void *begin
, struct object
*ob
,
104 void *tbase
, void *dbase
)
106 /* If .eh_frame is empty, don't register at all. */
107 if (*(uword
*) begin
== 0)
110 ob
->pc_begin
= (void *)-1;
113 ob
->u
.single
= begin
;
115 ob
->s
.b
.encoding
= DW_EH_PE_omit
;
116 #ifdef DWARF2_OBJECT_END_PTR_EXTENSION
120 init_object_mutex_once ();
121 __gthread_mutex_lock (&object_mutex
);
123 ob
->next
= unseen_objects
;
126 __gthread_mutex_unlock (&object_mutex
);
128 hidden_def (__register_frame_info_bases
)
131 __register_frame_info (void *begin
, struct object
*ob
)
133 __register_frame_info_bases (begin
, ob
, 0, 0);
137 __register_frame (void *begin
)
141 /* If .eh_frame is empty, don't register at all. */
142 if (*(uword
*) begin
== 0)
145 ob
= (struct object
*) malloc (sizeof (struct object
));
146 __register_frame_info_bases (begin
, ob
, 0, 0);
149 /* Similar, but BEGIN is actually a pointer to a table of unwind entries
150 for different translation units. Called from the file generated by
154 __register_frame_info_table_bases (void *begin
, struct object
*ob
,
155 void *tbase
, void *dbase
)
157 ob
->pc_begin
= (void *)-1;
162 ob
->s
.b
.from_array
= 1;
163 ob
->s
.b
.encoding
= DW_EH_PE_omit
;
165 init_object_mutex_once ();
166 __gthread_mutex_lock (&object_mutex
);
168 ob
->next
= unseen_objects
;
171 __gthread_mutex_unlock (&object_mutex
);
173 hidden_def (__register_frame_info_table_bases
)
176 __register_frame_info_table (void *begin
, struct object
*ob
)
178 __register_frame_info_table_bases (begin
, ob
, 0, 0);
182 __register_frame_table (void *begin
)
184 struct object
*ob
= (struct object
*) malloc (sizeof (struct object
));
185 __register_frame_info_table_bases (begin
, ob
, 0, 0);
188 /* Called from crtbegin.o to deregister the unwind info for an object. */
189 /* ??? Glibc has for a while now exported __register_frame_info and
190 __deregister_frame_info. If we call __register_frame_info_bases
191 from crtbegin (wherein it is declared weak), and this object does
192 not get pulled from libgcc.a for other reasons, then the
193 invocation of __deregister_frame_info will be resolved from glibc.
194 Since the registration did not happen there, we'll abort.
196 Therefore, declare a new deregistration entry point that does the
197 exact same thing, but will resolve to the same library as
198 implements __register_frame_info_bases. */
201 __deregister_frame_info_bases (void *begin
)
204 struct object
*ob
= 0;
205 struct fde_vector
*tofree
= NULL
;
207 /* If .eh_frame is empty, we haven't registered. */
208 if (*(uword
*) begin
== 0)
211 init_object_mutex_once ();
212 __gthread_mutex_lock (&object_mutex
);
214 for (p
= &unseen_objects
; *p
; p
= &(*p
)->next
)
215 if ((*p
)->u
.single
== begin
)
222 for (p
= &seen_objects
; *p
; p
= &(*p
)->next
)
223 if ((*p
)->s
.b
.sorted
)
225 if ((*p
)->u
.sort
->orig_data
== begin
)
235 if ((*p
)->u
.single
== begin
)
243 __gthread_mutex_unlock (&object_mutex
);
247 __gthread_mutex_unlock (&object_mutex
);
251 hidden_def (__deregister_frame_info_bases
)
254 __deregister_frame_info (void *begin
)
256 return __deregister_frame_info_bases (begin
);
260 __deregister_frame (void *begin
)
262 /* If .eh_frame is empty, we haven't registered. */
263 if (*(uword
*) begin
!= 0)
264 free (__deregister_frame_info_bases (begin
));
268 /* Like base_of_encoded_value, but take the base from a struct object
269 instead of an _Unwind_Context. */
272 base_from_object (unsigned char encoding
, struct object
*ob
)
274 if (encoding
== DW_EH_PE_omit
)
277 switch (encoding
& 0x70)
279 case DW_EH_PE_absptr
:
281 case DW_EH_PE_aligned
:
284 case DW_EH_PE_textrel
:
285 return (_Unwind_Ptr
) ob
->tbase
;
286 case DW_EH_PE_datarel
:
287 return (_Unwind_Ptr
) ob
->dbase
;
292 /* Return the FDE pointer encoding from the CIE. */
293 /* ??? This is a subset of extract_cie_info from unwind-dw2.c. */
296 get_cie_encoding (struct dwarf_cie
*cie
)
298 const unsigned char *aug
, *p
;
303 aug
= cie
->augmentation
;
305 return DW_EH_PE_absptr
;
307 /* Skip the augmentation string. */
308 p
= aug
+ strlen ((const char *) aug
) + 1;
309 p
= read_uleb128 (p
, &utmp
); /* Skip code alignment. */
310 p
= read_sleb128 (p
, &stmp
); /* Skip data alignment. */
311 p
++; /* Skip return address column. */
313 aug
++; /* Skip 'z' */
314 p
= read_uleb128 (p
, &utmp
); /* Skip augmentation length. */
317 /* This is what we're looking for. */
320 /* Personality encoding and pointer. */
321 else if (*aug
== 'P')
323 /* ??? Avoid dereferencing indirect pointers, since we're
324 faking the base address. Gotta keep DW_EH_PE_aligned
326 p
= read_encoded_value_with_base (*p
& 0x7F, 0, p
+ 1, &dummy
);
329 else if (*aug
== 'L')
331 /* Otherwise end of string, or unknown augmentation. */
333 return DW_EH_PE_absptr
;
339 get_fde_encoding (struct dwarf_fde
*f
)
341 return get_cie_encoding (get_cie (f
));
345 /* Sorting an array of FDEs by address.
346 (Ideally we would have the linker sort the FDEs so we don't have to do
347 it at run time. But the linkers are not yet prepared for this.) */
349 /* Return the Nth pc_begin value from FDE x. */
351 static inline _Unwind_Ptr
352 get_pc_begin (fde
*x
, size_t n
)
355 memcpy (&p
, x
->pc_begin
+ n
* sizeof (_Unwind_Ptr
), sizeof (_Unwind_Ptr
));
359 /* Comparison routines. Three variants of increasing complexity. */
362 fde_unencoded_compare (struct object
*ob
__attribute__((unused
)),
365 _Unwind_Ptr x_ptr
= get_pc_begin (x
, 0);
366 _Unwind_Ptr y_ptr
= get_pc_begin (y
, 0);
376 fde_single_encoding_compare (struct object
*ob
, fde
*x
, fde
*y
)
378 _Unwind_Ptr base
, x_ptr
, y_ptr
;
380 base
= base_from_object (ob
->s
.b
.encoding
, ob
);
381 read_encoded_value_with_base (ob
->s
.b
.encoding
, base
, x
->pc_begin
, &x_ptr
);
382 read_encoded_value_with_base (ob
->s
.b
.encoding
, base
, y
->pc_begin
, &y_ptr
);
392 fde_mixed_encoding_compare (struct object
*ob
, fde
*x
, fde
*y
)
394 int x_encoding
, y_encoding
;
395 _Unwind_Ptr x_ptr
, y_ptr
;
397 x_encoding
= get_fde_encoding (x
);
398 read_encoded_value_with_base (x_encoding
, base_from_object (x_encoding
, ob
),
399 x
->pc_begin
, &x_ptr
);
401 y_encoding
= get_fde_encoding (y
);
402 read_encoded_value_with_base (y_encoding
, base_from_object (y_encoding
, ob
),
403 y
->pc_begin
, &y_ptr
);
412 typedef int (*fde_compare_t
) (struct object
*, fde
*, fde
*);
415 /* This is a special mix of insertion sort and heap sort, optimized for
416 the data sets that actually occur. They look like
417 101 102 103 127 128 105 108 110 190 111 115 119 125 160 126 129 130.
418 I.e. a linearly increasing sequence (coming from functions in the text
419 section), with additionally a few unordered elements (coming from functions
420 in gnu_linkonce sections) whose values are higher than the values in the
421 surrounding linear sequence (but not necessarily higher than the values
422 at the end of the linear sequence!).
423 The worst-case total run time is O(N) + O(n log (n)), where N is the
424 total number of FDEs and n is the number of erratic ones. */
426 struct fde_accumulator
428 struct fde_vector
*linear
;
429 struct fde_vector
*erratic
;
433 start_fde_sort (struct fde_accumulator
*accu
, size_t count
)
439 size
= sizeof (struct fde_vector
) + sizeof (fde
*) * count
;
440 if ((accu
->linear
= (struct fde_vector
*) malloc (size
)))
442 accu
->linear
->count
= 0;
443 if ((accu
->erratic
= (struct fde_vector
*) malloc (size
)))
444 accu
->erratic
->count
= 0;
452 fde_insert (struct fde_accumulator
*accu
, fde
*this_fde
)
455 accu
->linear
->array
[accu
->linear
->count
++] = this_fde
;
458 /* Split LINEAR into a linear sequence with low values and an erratic
459 sequence with high values, put the linear one (of longest possible
460 length) into LINEAR and the erratic one into ERRATIC. This is O(N).
462 Because the longest linear sequence we are trying to locate within the
463 incoming LINEAR array can be interspersed with (high valued) erratic
464 entries. We construct a chain indicating the sequenced entries.
465 To avoid having to allocate this chain, we overlay it onto the space of
466 the ERRATIC array during construction. A final pass iterates over the
467 chain to determine what should be placed in the ERRATIC array, and
468 what is the linear sequence. This overlay is safe from aliasing. */
471 fde_split (struct object
*ob
, fde_compare_t fde_compare
,
472 struct fde_vector
*linear
, struct fde_vector
*erratic
)
475 size_t count
= linear
->count
;
476 fde
**chain_end
= &marker
;
479 /* This should optimize out, but it is wise to make sure this assumption
480 is correct. Should these have different sizes, we cannot cast between
481 them and the overlaying onto ERRATIC will not work. */
482 if (sizeof (fde
*) != sizeof (fde
**))
485 for (i
= 0; i
< count
; i
++)
489 for (probe
= chain_end
;
490 probe
!= &marker
&& fde_compare (ob
, linear
->array
[i
], *probe
) < 0;
493 chain_end
= (fde
**) erratic
->array
[probe
- linear
->array
];
494 erratic
->array
[probe
- linear
->array
] = NULL
;
496 erratic
->array
[i
] = (fde
*) chain_end
;
497 chain_end
= &linear
->array
[i
];
500 /* Each entry in LINEAR which is part of the linear sequence we have
501 discovered will correspond to a non-NULL entry in the chain we built in
502 the ERRATIC array. */
503 for (i
= j
= k
= 0; i
< count
; i
++)
504 if (erratic
->array
[i
])
505 linear
->array
[j
++] = linear
->array
[i
];
507 erratic
->array
[k
++] = linear
->array
[i
];
512 /* This is O(n log(n)). BSD/OS defines heapsort in stdlib.h, so we must
513 use a name that does not conflict. */
516 frame_heapsort (struct object
*ob
, fde_compare_t fde_compare
,
517 struct fde_vector
*erratic
)
519 /* For a description of this algorithm, see:
520 Samuel P. Harbison, Guy L. Steele Jr.: C, a reference manual, 2nd ed.,
522 fde
** a
= erratic
->array
;
523 /* A portion of the array is called a "heap" if for all i>=0:
524 If i and 2i+1 are valid indices, then a[i] >= a[2i+1].
525 If i and 2i+2 are valid indices, then a[i] >= a[2i+2]. */
526 #define SWAP(x,y) do { fde * tmp = x; x = y; y = tmp; } while (0)
527 size_t n
= erratic
->count
;
533 /* Invariant: a[m..n-1] is a heap. */
535 for (i
= m
; 2*i
+1 < n
; )
538 && fde_compare (ob
, a
[2*i
+2], a
[2*i
+1]) > 0
539 && fde_compare (ob
, a
[2*i
+2], a
[i
]) > 0)
541 SWAP (a
[i
], a
[2*i
+2]);
544 else if (fde_compare (ob
, a
[2*i
+1], a
[i
]) > 0)
546 SWAP (a
[i
], a
[2*i
+1]);
555 /* Invariant: a[0..n-1] is a heap. */
558 for (i
= 0; 2*i
+1 < n
; )
561 && fde_compare (ob
, a
[2*i
+2], a
[2*i
+1]) > 0
562 && fde_compare (ob
, a
[2*i
+2], a
[i
]) > 0)
564 SWAP (a
[i
], a
[2*i
+2]);
567 else if (fde_compare (ob
, a
[2*i
+1], a
[i
]) > 0)
569 SWAP (a
[i
], a
[2*i
+1]);
579 /* Merge V1 and V2, both sorted, and put the result into V1. */
581 fde_merge (struct object
*ob
, fde_compare_t fde_compare
,
582 struct fde_vector
*v1
, struct fde_vector
*v2
)
594 fde2
= v2
->array
[i2
];
595 while (i1
> 0 && fde_compare (ob
, v1
->array
[i1
-1], fde2
) > 0)
597 v1
->array
[i1
+i2
] = v1
->array
[i1
-1];
600 v1
->array
[i1
+i2
] = fde2
;
603 v1
->count
+= v2
->count
;
608 end_fde_sort (struct object
*ob
, struct fde_accumulator
*accu
, size_t count
)
610 fde_compare_t fde_compare
;
612 if (accu
->linear
->count
!= count
)
615 if (ob
->s
.b
.mixed_encoding
)
616 fde_compare
= fde_mixed_encoding_compare
;
617 else if (ob
->s
.b
.encoding
== DW_EH_PE_absptr
)
618 fde_compare
= fde_unencoded_compare
;
620 fde_compare
= fde_single_encoding_compare
;
624 fde_split (ob
, fde_compare
, accu
->linear
, accu
->erratic
);
625 if (accu
->linear
->count
+ accu
->erratic
->count
!= count
)
627 frame_heapsort (ob
, fde_compare
, accu
->erratic
);
628 fde_merge (ob
, fde_compare
, accu
->linear
, accu
->erratic
);
629 free (accu
->erratic
);
633 /* We've not managed to malloc an erratic array,
634 so heap sort in the linear one. */
635 frame_heapsort (ob
, fde_compare
, accu
->linear
);
640 /* Update encoding, mixed_encoding, and pc_begin for OB for the
641 fde array beginning at THIS_FDE. Return the number of fdes
642 encountered along the way. */
645 classify_object_over_fdes (struct object
*ob
, fde
*this_fde
)
647 struct dwarf_cie
*last_cie
= 0;
649 int encoding
= DW_EH_PE_absptr
;
650 _Unwind_Ptr base
= 0;
652 for (; ! last_fde (ob
, this_fde
); this_fde
= next_fde (this_fde
))
654 struct dwarf_cie
*this_cie
;
655 _Unwind_Ptr mask
, pc_begin
;
658 if (this_fde
->CIE_delta
== 0)
661 /* Determine the encoding for this FDE. Note mixed encoded
662 objects for later. */
663 this_cie
= get_cie (this_fde
);
664 if (this_cie
!= last_cie
)
667 encoding
= get_cie_encoding (this_cie
);
668 base
= base_from_object (encoding
, ob
);
669 if (ob
->s
.b
.encoding
== DW_EH_PE_omit
)
670 ob
->s
.b
.encoding
= encoding
;
671 else if (ob
->s
.b
.encoding
!= encoding
)
672 ob
->s
.b
.mixed_encoding
= 1;
675 read_encoded_value_with_base (encoding
, base
, this_fde
->pc_begin
,
678 /* Take care to ignore link-once functions that were removed.
679 In these cases, the function address will be NULL, but if
680 the encoding is smaller than a pointer a true NULL may not
681 be representable. Assume 0 in the representable bits is NULL. */
682 mask
= size_of_encoded_value (encoding
);
683 if (mask
< sizeof (void *))
684 mask
= (1L << (mask
<< 3)) - 1;
688 if ((pc_begin
& mask
) == 0)
692 if ((void *) pc_begin
< ob
->pc_begin
)
693 ob
->pc_begin
= (void *) pc_begin
;
700 add_fdes (struct object
*ob
, struct fde_accumulator
*accu
, fde
*this_fde
)
702 struct dwarf_cie
*last_cie
= 0;
703 int encoding
= ob
->s
.b
.encoding
;
704 _Unwind_Ptr base
= base_from_object (ob
->s
.b
.encoding
, ob
);
706 for (; ! last_fde (ob
, this_fde
); this_fde
= next_fde (this_fde
))
708 struct dwarf_cie
*this_cie
;
711 if (this_fde
->CIE_delta
== 0)
714 if (ob
->s
.b
.mixed_encoding
)
716 /* Determine the encoding for this FDE. Note mixed encoded
717 objects for later. */
718 this_cie
= get_cie (this_fde
);
719 if (this_cie
!= last_cie
)
722 encoding
= get_cie_encoding (this_cie
);
723 base
= base_from_object (encoding
, ob
);
727 if (encoding
== DW_EH_PE_absptr
)
729 if (get_pc_begin (this_fde
, 0) == 0)
734 _Unwind_Ptr pc_begin
, mask
;
736 read_encoded_value_with_base (encoding
, base
, this_fde
->pc_begin
,
739 /* Take care to ignore link-once functions that were removed.
740 In these cases, the function address will be NULL, but if
741 the encoding is smaller than a pointer a true NULL may not
742 be representable. Assume 0 in the representable bits is NULL. */
743 mask
= size_of_encoded_value (encoding
);
744 if (mask
< sizeof (void *))
745 mask
= (1L << (mask
<< 3)) - 1;
749 if ((pc_begin
& mask
) == 0)
753 fde_insert (accu
, this_fde
);
757 /* Set up a sorted array of pointers to FDEs for a loaded object. We
758 count up the entries before allocating the array because it's likely to
759 be faster. We can be called multiple times, should we have failed to
760 allocate a sorted fde array on a previous occasion. */
763 init_object (struct object
* ob
)
765 struct fde_accumulator accu
;
768 count
= ob
->s
.b
.count
;
771 if (ob
->s
.b
.from_array
)
773 fde
**p
= ob
->u
.array
;
774 for (count
= 0; *p
; ++p
)
775 count
+= classify_object_over_fdes (ob
, *p
);
778 count
= classify_object_over_fdes (ob
, ob
->u
.single
);
780 /* The count field we have in the main struct object is somewhat
781 limited, but should suffice for virtually all cases. If the
782 counted value doesn't fit, re-write a zero. The worst that
783 happens is that we re-count next time -- admittedly non-trivial
784 in that this implies some 2M fdes, but at least we function. */
785 ob
->s
.b
.count
= count
;
786 if (ob
->s
.b
.count
!= count
)
790 if (!start_fde_sort (&accu
, count
))
793 if (ob
->s
.b
.from_array
)
796 for (p
= ob
->u
.array
; *p
; ++p
)
797 add_fdes (ob
, &accu
, *p
);
800 add_fdes (ob
, &accu
, ob
->u
.single
);
802 end_fde_sort (ob
, &accu
, count
);
804 /* Save the original fde pointer, since this is the key by which the
805 DSO will deregister the object. */
806 accu
.linear
->orig_data
= ob
->u
.single
;
807 ob
->u
.sort
= accu
.linear
;
812 /* A linear search through a set of FDEs for the given PC. This is
813 used when there was insufficient memory to allocate and sort an
817 linear_search_fdes (struct object
*ob
, fde
*this_fde
, void *pc
)
819 struct dwarf_cie
*last_cie
= 0;
820 int encoding
= ob
->s
.b
.encoding
;
821 _Unwind_Ptr base
= base_from_object (ob
->s
.b
.encoding
, ob
);
823 for (; ! last_fde (ob
, this_fde
); this_fde
= next_fde (this_fde
))
825 struct dwarf_cie
*this_cie
;
826 _Unwind_Ptr pc_begin
, pc_range
;
829 if (this_fde
->CIE_delta
== 0)
832 if (ob
->s
.b
.mixed_encoding
)
834 /* Determine the encoding for this FDE. Note mixed encoded
835 objects for later. */
836 this_cie
= get_cie (this_fde
);
837 if (this_cie
!= last_cie
)
840 encoding
= get_cie_encoding (this_cie
);
841 base
= base_from_object (encoding
, ob
);
845 if (encoding
== DW_EH_PE_absptr
)
847 pc_begin
= get_pc_begin (this_fde
, 0);
848 pc_range
= get_pc_begin (this_fde
, 1);
855 const unsigned char *p
;
857 p
= read_encoded_value_with_base (encoding
, base
,
858 this_fde
->pc_begin
, &pc_begin
);
859 read_encoded_value_with_base (encoding
& 0x0F, 0, p
, &pc_range
);
861 /* Take care to ignore link-once functions that were removed.
862 In these cases, the function address will be NULL, but if
863 the encoding is smaller than a pointer a true NULL may not
864 be representable. Assume 0 in the representable bits is NULL. */
865 mask
= size_of_encoded_value (encoding
);
866 if (mask
< sizeof (void *))
867 mask
= (1L << (mask
<< 3)) - 1;
871 if ((pc_begin
& mask
) == 0)
875 if ((_Unwind_Ptr
) pc
- pc_begin
< pc_range
)
882 /* Binary search for an FDE containing the given PC. Here are three
883 implementations of increasing complexity. */
886 binary_search_unencoded_fdes (struct object
*ob
, void *pc
)
888 struct fde_vector
*vec
= ob
->u
.sort
;
891 for (lo
= 0, hi
= vec
->count
; lo
< hi
; )
893 size_t i
= (lo
+ hi
) / 2;
894 fde
*f
= vec
->array
[i
];
898 pc_begin
= (void *) get_pc_begin (f
, 0);
899 pc_range
= (uaddr
) get_pc_begin (f
, 1);
903 else if (pc
>= pc_begin
+ pc_range
)
913 binary_search_single_encoding_fdes (struct object
*ob
, void *pc
)
915 struct fde_vector
*vec
= ob
->u
.sort
;
916 int encoding
= ob
->s
.b
.encoding
;
917 _Unwind_Ptr base
= base_from_object (encoding
, ob
);
920 for (lo
= 0, hi
= vec
->count
; lo
< hi
; )
922 size_t i
= (lo
+ hi
) / 2;
923 fde
*f
= vec
->array
[i
];
924 _Unwind_Ptr pc_begin
, pc_range
;
925 const unsigned char *p
;
927 p
= read_encoded_value_with_base (encoding
, base
, f
->pc_begin
,
929 read_encoded_value_with_base (encoding
& 0x0F, 0, p
, &pc_range
);
931 if ((_Unwind_Ptr
) pc
< pc_begin
)
933 else if ((_Unwind_Ptr
) pc
>= pc_begin
+ pc_range
)
943 binary_search_mixed_encoding_fdes (struct object
*ob
, void *pc
)
945 struct fde_vector
*vec
= ob
->u
.sort
;
948 for (lo
= 0, hi
= vec
->count
; lo
< hi
; )
950 size_t i
= (lo
+ hi
) / 2;
951 fde
*f
= vec
->array
[i
];
952 _Unwind_Ptr pc_begin
, pc_range
;
953 const unsigned char *p
;
956 encoding
= get_fde_encoding (f
);
957 p
= read_encoded_value_with_base (encoding
,
958 base_from_object (encoding
, ob
),
959 f
->pc_begin
, &pc_begin
);
960 read_encoded_value_with_base (encoding
& 0x0F, 0, p
, &pc_range
);
962 if ((_Unwind_Ptr
) pc
< pc_begin
)
964 else if ((_Unwind_Ptr
) pc
>= pc_begin
+ pc_range
)
974 search_object (struct object
* ob
, void *pc
)
976 /* If the data hasn't been sorted, try to do this now. We may have
977 more memory available than last time we tried. */
978 if (! ob
->s
.b
.sorted
)
982 /* Despite the above comment, the normal reason to get here is
983 that we've not processed this object before. A quick range
984 check is in order. */
985 if (pc
< ob
->pc_begin
)
991 if (ob
->s
.b
.mixed_encoding
)
992 return binary_search_mixed_encoding_fdes (ob
, pc
);
993 else if (ob
->s
.b
.encoding
== DW_EH_PE_absptr
)
994 return binary_search_unencoded_fdes (ob
, pc
);
996 return binary_search_single_encoding_fdes (ob
, pc
);
1000 /* Long slow labourious linear search, cos we've no memory. */
1001 if (ob
->s
.b
.from_array
)
1004 for (p
= ob
->u
.array
; *p
; p
++)
1006 fde
*f
= linear_search_fdes (ob
, *p
, pc
);
1013 return linear_search_fdes (ob
, ob
->u
.single
, pc
);
1018 _Unwind_Find_FDE (void *pc
, struct dwarf_eh_bases
*bases
)
1023 init_object_mutex_once ();
1024 __gthread_mutex_lock (&object_mutex
);
1026 /* Linear search through the classified objects, to find the one
1027 containing the pc. Note that pc_begin is sorted descending, and
1028 we expect objects to be non-overlapping. */
1029 for (ob
= seen_objects
; ob
; ob
= ob
->next
)
1030 if (pc
>= ob
->pc_begin
)
1032 f
= search_object (ob
, pc
);
1038 /* Classify and search the objects we've not yet processed. */
1039 while ((ob
= unseen_objects
))
1043 unseen_objects
= ob
->next
;
1044 f
= search_object (ob
, pc
);
1046 /* Insert the object into the classified list. */
1047 for (p
= &seen_objects
; *p
; p
= &(*p
)->next
)
1048 if ((*p
)->pc_begin
< ob
->pc_begin
)
1058 __gthread_mutex_unlock (&object_mutex
);
1065 bases
->tbase
= ob
->tbase
;
1066 bases
->dbase
= ob
->dbase
;
1068 encoding
= ob
->s
.b
.encoding
;
1069 if (ob
->s
.b
.mixed_encoding
)
1070 encoding
= get_fde_encoding (f
);
1071 read_encoded_value_with_base (encoding
, base_from_object (encoding
, ob
),
1072 f
->pc_begin
, &func
);
1073 bases
->func
= (void *) func
;