mirrored from git://gcc.gnu.org/git/gcc.git
-
Notifications
You must be signed in to change notification settings - Fork 4.5k
/
Copy pathunwind-dw2-fde.c
1274 lines (1092 loc) · 32.6 KB
/
unwind-dw2-fde.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Subroutines needed for unwinding stack frames for exception handling. */
/* Copyright (C) 1997-2023 Free Software Foundation, Inc.
Contributed by Jason Merrill <jason@cygnus.com>.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#ifndef _Unwind_Find_FDE
#include "tconfig.h"
#include "tsystem.h"
#include "coretypes.h"
#include "tm.h"
#include "libgcc_tm.h"
#include "dwarf2.h"
#include "unwind.h"
#define NO_BASE_OF_ENCODED_VALUE
#include "unwind-pe.h"
#include "unwind-dw2-fde.h"
#include "gthr.h"
#else
#if (defined(__GTHREAD_MUTEX_INIT) || defined(__GTHREAD_MUTEX_INIT_FUNCTION)) \
&& defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
#define ATOMIC_FDE_FAST_PATH 1
#endif
#endif
typedef __UINTPTR_TYPE__ uintptr_type;
#ifdef ATOMIC_FDE_FAST_PATH
#include "unwind-dw2-btree.h"
static struct btree registered_frames;
static bool in_shutdown;
static void
release_registered_frames (void) __attribute__ ((destructor));
static void
release_registered_frames (void)
{
/* Release the b-tree and all frames. Frame releases that happen later are
* silently ignored */
btree_destroy (®istered_frames);
in_shutdown = true;
}
static void
get_pc_range (const struct object *ob, uintptr_type *range);
#else
/* Without fast path frame deregistration must always succeed. */
static const int in_shutdown = 0;
/* The unseen_objects list contains objects that have been registered
but not yet categorized in any way. The seen_objects list has had
its pc_begin and count fields initialized at minimum, and is sorted
by decreasing value of pc_begin. */
static struct object *unseen_objects;
static struct object *seen_objects;
#endif
#ifdef __GTHREAD_MUTEX_INIT
static __gthread_mutex_t object_mutex = __GTHREAD_MUTEX_INIT;
#define init_object_mutex_once()
#else
#ifdef __GTHREAD_MUTEX_INIT_FUNCTION
static __gthread_mutex_t object_mutex;
static void
init_object_mutex (void)
{
__GTHREAD_MUTEX_INIT_FUNCTION (&object_mutex);
}
static void
init_object_mutex_once (void)
{
static __gthread_once_t once = __GTHREAD_ONCE_INIT;
__gthread_once (&once, init_object_mutex);
}
#else
/* ??? Several targets include this file with stubbing parts of gthr.h
and expect no locking to be done. */
#define init_object_mutex_once()
static __gthread_mutex_t object_mutex;
#endif
#endif
/* Called from crtbegin.o to register the unwind info for an object. */
void
__register_frame_info_bases (const void *begin, struct object *ob,
void *tbase, void *dbase)
{
/* If .eh_frame is empty, don't register at all. */
if ((const uword *) begin == 0 || *(const uword *) begin == 0)
return;
ob->pc_begin = (void *)-1;
ob->tbase = tbase;
ob->dbase = dbase;
ob->u.single = begin;
ob->s.i = 0;
ob->s.b.encoding = DW_EH_PE_omit;
#ifdef DWARF2_OBJECT_END_PTR_EXTENSION
ob->fde_end = NULL;
#endif
#ifdef ATOMIC_FDE_FAST_PATH
// Register the object itself to know the base pointer on deregistration.
btree_insert (®istered_frames, (uintptr_type) begin, 1, ob);
// Register the frame in the b-tree
uintptr_type range[2];
get_pc_range (ob, range);
btree_insert (®istered_frames, range[0], range[1] - range[0], ob);
#else
init_object_mutex_once ();
__gthread_mutex_lock (&object_mutex);
ob->next = unseen_objects;
unseen_objects = ob;
__gthread_mutex_unlock (&object_mutex);
#endif
}
void
__register_frame_info (const void *begin, struct object *ob)
{
__register_frame_info_bases (begin, ob, 0, 0);
}
void
__register_frame (void *begin)
{
struct object *ob;
/* If .eh_frame is empty, don't register at all. */
if (*(uword *) begin == 0)
return;
ob = malloc (sizeof (struct object));
__register_frame_info (begin, ob);
}
/* Similar, but BEGIN is actually a pointer to a table of unwind entries
for different translation units. Called from the file generated by
collect2. */
void
__register_frame_info_table_bases (void *begin, struct object *ob,
void *tbase, void *dbase)
{
ob->pc_begin = (void *)-1;
ob->tbase = tbase;
ob->dbase = dbase;
ob->u.array = begin;
ob->s.i = 0;
ob->s.b.from_array = 1;
ob->s.b.encoding = DW_EH_PE_omit;
#ifdef ATOMIC_FDE_FAST_PATH
// Register the object itself to know the base pointer on deregistration.
btree_insert (®istered_frames, (uintptr_type) begin, 1, ob);
// Register the frame in the b-tree
uintptr_type range[2];
get_pc_range (ob, range);
btree_insert (®istered_frames, range[0], range[1] - range[0], ob);
#else
init_object_mutex_once ();
__gthread_mutex_lock (&object_mutex);
ob->next = unseen_objects;
unseen_objects = ob;
__gthread_mutex_unlock (&object_mutex);
#endif
}
void
__register_frame_info_table (void *begin, struct object *ob)
{
__register_frame_info_table_bases (begin, ob, 0, 0);
}
void
__register_frame_table (void *begin)
{
struct object *ob = malloc (sizeof (struct object));
__register_frame_info_table (begin, ob);
}
/* Called from crtbegin.o to deregister the unwind info for an object. */
/* ??? Glibc has for a while now exported __register_frame_info and
__deregister_frame_info. If we call __register_frame_info_bases
from crtbegin (wherein it is declared weak), and this object does
not get pulled from libgcc.a for other reasons, then the
invocation of __deregister_frame_info will be resolved from glibc.
Since the registration did not happen there, we'll die.
Therefore, declare a new deregistration entry point that does the
exact same thing, but will resolve to the same library as
implements __register_frame_info_bases. */
void *
__deregister_frame_info_bases (const void *begin)
{
struct object *ob = 0;
/* If .eh_frame is empty, we haven't registered. */
if ((const uword *) begin == 0 || *(const uword *) begin == 0)
return ob;
#ifdef ATOMIC_FDE_FAST_PATH
// Find the originally registered object to get the base pointer.
ob = btree_remove (®istered_frames, (uintptr_type) begin);
// Remove the corresponding PC range.
if (ob)
{
uintptr_type range[2];
get_pc_range (ob, range);
if (range[0] != range[1])
btree_remove (®istered_frames, range[0]);
}
// Deallocate the sort array if any.
if (ob && ob->s.b.sorted)
{
free (ob->u.sort);
}
#else
init_object_mutex_once ();
__gthread_mutex_lock (&object_mutex);
struct object **p;
for (p = &unseen_objects; *p ; p = &(*p)->next)
if ((*p)->u.single == begin)
{
ob = *p;
*p = ob->next;
goto out;
}
for (p = &seen_objects; *p ; p = &(*p)->next)
if ((*p)->s.b.sorted)
{
if ((*p)->u.sort->orig_data == begin)
{
ob = *p;
*p = ob->next;
free (ob->u.sort);
goto out;
}
}
else
{
if ((*p)->u.single == begin)
{
ob = *p;
*p = ob->next;
goto out;
}
}
out:
__gthread_mutex_unlock (&object_mutex);
#endif
// If we didn't find anything in the lookup data structures then they
// were either already destroyed or we tried to remove an empty range.
gcc_assert (in_shutdown || ob);
return (void *) ob;
}
void *
__deregister_frame_info (const void *begin)
{
return __deregister_frame_info_bases (begin);
}
void
__deregister_frame (void *begin)
{
/* If .eh_frame is empty, we haven't registered. */
if (*(uword *) begin != 0)
free (__deregister_frame_info (begin));
}
/* Like base_of_encoded_value, but take the base from a struct object
instead of an _Unwind_Context. */
static _Unwind_Ptr
base_from_object (unsigned char encoding, const struct object *ob)
{
if (encoding == DW_EH_PE_omit)
return 0;
switch (encoding & 0x70)
{
case DW_EH_PE_absptr:
case DW_EH_PE_pcrel:
case DW_EH_PE_aligned:
return 0;
case DW_EH_PE_textrel:
return (_Unwind_Ptr) ob->tbase;
case DW_EH_PE_datarel:
return (_Unwind_Ptr) ob->dbase;
default:
gcc_unreachable ();
}
}
/* Return the FDE pointer encoding from the CIE. */
/* ??? This is a subset of extract_cie_info from unwind-dw2.c. */
static int
get_cie_encoding (const struct dwarf_cie *cie)
{
const unsigned char *aug, *p;
_Unwind_Ptr dummy;
_uleb128_t utmp;
_sleb128_t stmp;
aug = cie->augmentation;
p = aug + strlen ((const char *)aug) + 1; /* Skip the augmentation string. */
if (__builtin_expect (cie->version >= 4, 0))
{
if (p[0] != sizeof (void *) || p[1] != 0)
return DW_EH_PE_omit; /* We are not prepared to handle unexpected
address sizes or segment selectors. */
p += 2; /* Skip address size and segment size. */
}
if (aug[0] != 'z')
return DW_EH_PE_absptr;
p = read_uleb128 (p, &utmp); /* Skip code alignment. */
p = read_sleb128 (p, &stmp); /* Skip data alignment. */
if (cie->version == 1) /* Skip return address column. */
p++;
else
p = read_uleb128 (p, &utmp);
aug++; /* Skip 'z' */
p = read_uleb128 (p, &utmp); /* Skip augmentation length. */
while (1)
{
/* This is what we're looking for. */
if (*aug == 'R')
return *p;
/* Personality encoding and pointer. */
else if (*aug == 'P')
{
/* ??? Avoid dereferencing indirect pointers, since we're
faking the base address. Gotta keep DW_EH_PE_aligned
intact, however. */
p = read_encoded_value_with_base (*p & 0x7F, 0, p + 1, &dummy);
}
/* LSDA encoding. */
else if (*aug == 'L')
p++;
/* aarch64 b-key pointer authentication. */
else if (*aug == 'B')
p++;
/* Otherwise end of string, or unknown augmentation. */
else
return DW_EH_PE_absptr;
aug++;
}
}
static inline int
get_fde_encoding (const struct dwarf_fde *f)
{
return get_cie_encoding (get_cie (f));
}
/* Sorting an array of FDEs by address.
(Ideally we would have the linker sort the FDEs so we don't have to do
it at run time. But the linkers are not yet prepared for this.) */
/* Comparison routines. Three variants of increasing complexity. */
static int
fde_unencoded_compare (struct object *ob __attribute__((unused)),
const fde *x, const fde *y)
{
_Unwind_Ptr x_ptr, y_ptr;
memcpy (&x_ptr, x->pc_begin, sizeof (_Unwind_Ptr));
memcpy (&y_ptr, y->pc_begin, sizeof (_Unwind_Ptr));
if (x_ptr > y_ptr)
return 1;
if (x_ptr < y_ptr)
return -1;
return 0;
}
static int
fde_single_encoding_compare (struct object *ob, const fde *x, const fde *y)
{
_Unwind_Ptr base, x_ptr, y_ptr;
base = base_from_object (ob->s.b.encoding, ob);
read_encoded_value_with_base (ob->s.b.encoding, base, x->pc_begin, &x_ptr);
read_encoded_value_with_base (ob->s.b.encoding, base, y->pc_begin, &y_ptr);
if (x_ptr > y_ptr)
return 1;
if (x_ptr < y_ptr)
return -1;
return 0;
}
static int
fde_mixed_encoding_compare (struct object *ob, const fde *x, const fde *y)
{
int x_encoding, y_encoding;
_Unwind_Ptr x_ptr, y_ptr;
x_encoding = get_fde_encoding (x);
read_encoded_value_with_base (x_encoding, base_from_object (x_encoding, ob),
x->pc_begin, &x_ptr);
y_encoding = get_fde_encoding (y);
read_encoded_value_with_base (y_encoding, base_from_object (y_encoding, ob),
y->pc_begin, &y_ptr);
if (x_ptr > y_ptr)
return 1;
if (x_ptr < y_ptr)
return -1;
return 0;
}
typedef int (*fde_compare_t) (struct object *, const fde *, const fde *);
// The extractor functions compute the pointer values for a block of
// fdes. The block processing hides the call overhead.
static void
fde_unencoded_extract (struct object *ob __attribute__ ((unused)),
_Unwind_Ptr *target, const fde **x, int count)
{
for (int index = 0; index < count; ++index)
memcpy (target + index, x[index]->pc_begin, sizeof (_Unwind_Ptr));
}
static void
fde_single_encoding_extract (struct object *ob, _Unwind_Ptr *target,
const fde **x, int count)
{
_Unwind_Ptr base;
base = base_from_object (ob->s.b.encoding, ob);
for (int index = 0; index < count; ++index)
read_encoded_value_with_base (ob->s.b.encoding, base, x[index]->pc_begin,
target + index);
}
static void
fde_mixed_encoding_extract (struct object *ob, _Unwind_Ptr *target,
const fde **x, int count)
{
for (int index = 0; index < count; ++index)
{
int encoding = get_fde_encoding (x[index]);
read_encoded_value_with_base (encoding, base_from_object (encoding, ob),
x[index]->pc_begin, target + index);
}
}
typedef void (*fde_extractor_t) (struct object *, _Unwind_Ptr *, const fde **,
int);
// Data is is sorted using radix sort if possible, using an temporary
// auxiliary data structure of the same size as the input. When running
// out of memory do in-place heap sort.
struct fde_accumulator
{
struct fde_vector *linear;
struct fde_vector *aux;
};
static inline int
start_fde_sort (struct fde_accumulator *accu, size_t count)
{
size_t size;
if (! count)
return 0;
size = sizeof (struct fde_vector) + sizeof (const fde *) * count;
if ((accu->linear = malloc (size)))
{
accu->linear->count = 0;
if ((accu->aux = malloc (size)))
accu->aux->count = 0;
return 1;
}
else
return 0;
}
static inline void
fde_insert (struct fde_accumulator *accu, const fde *this_fde)
{
if (accu->linear)
accu->linear->array[accu->linear->count++] = this_fde;
}
#define SWAP(x,y) do { const fde * tmp = x; x = y; y = tmp; } while (0)
/* Convert a semi-heap to a heap. A semi-heap is a heap except possibly
for the first (root) node; push it down to its rightful place. */
static void
frame_downheap (struct object *ob, fde_compare_t fde_compare, const fde **a,
int lo, int hi)
{
int i, j;
for (i = lo, j = 2*i+1;
j < hi;
j = 2*i+1)
{
if (j+1 < hi && fde_compare (ob, a[j], a[j+1]) < 0)
++j;
if (fde_compare (ob, a[i], a[j]) < 0)
{
SWAP (a[i], a[j]);
i = j;
}
else
break;
}
}
/* This is O(n log(n)). BSD/OS defines heapsort in stdlib.h, so we must
use a name that does not conflict. */
static void
frame_heapsort (struct object *ob, fde_compare_t fde_compare,
struct fde_vector *erratic)
{
/* For a description of this algorithm, see:
Samuel P. Harbison, Guy L. Steele Jr.: C, a reference manual, 2nd ed.,
p. 60-61. */
const fde ** a = erratic->array;
/* A portion of the array is called a "heap" if for all i>=0:
If i and 2i+1 are valid indices, then a[i] >= a[2i+1].
If i and 2i+2 are valid indices, then a[i] >= a[2i+2]. */
size_t n = erratic->count;
int m;
/* Expand our heap incrementally from the end of the array, heapifying
each resulting semi-heap as we go. After each step, a[m] is the top
of a heap. */
for (m = n/2-1; m >= 0; --m)
frame_downheap (ob, fde_compare, a, m, n);
/* Shrink our heap incrementally from the end of the array, first
swapping out the largest element a[0] and then re-heapifying the
resulting semi-heap. After each step, a[0..m) is a heap. */
for (m = n-1; m >= 1; --m)
{
SWAP (a[0], a[m]);
frame_downheap (ob, fde_compare, a, 0, m);
}
#undef SWAP
}
// Radix sort data in V1 using V2 as aux memory. Runtime O(n).
static inline void
fde_radixsort (struct object *ob, fde_extractor_t fde_extractor,
struct fde_vector *v1, struct fde_vector *v2)
{
#define FANOUTBITS 8
#define FANOUT (1 << FANOUTBITS)
#define BLOCKSIZE 128
const unsigned rounds
= (__CHAR_BIT__ * sizeof (_Unwind_Ptr) + FANOUTBITS - 1) / FANOUTBITS;
const fde **a1 = v1->array, **a2 = v2->array;
_Unwind_Ptr ptrs[BLOCKSIZE + 1];
unsigned n = v1->count;
for (unsigned round = 0; round != rounds; ++round)
{
unsigned counts[FANOUT] = {0};
unsigned violations = 0;
// Count the number of elements per bucket and check if we are already
// sorted.
_Unwind_Ptr last = 0;
for (unsigned i = 0; i < n;)
{
unsigned chunk = ((n - i) <= BLOCKSIZE) ? (n - i) : BLOCKSIZE;
fde_extractor (ob, ptrs + 1, a1 + i, chunk);
ptrs[0] = last;
for (unsigned j = 0; j < chunk; ++j)
{
unsigned b = (ptrs[j + 1] >> (round * FANOUTBITS)) & (FANOUT - 1);
counts[b]++;
// Use summation instead of an if to eliminate branches.
violations += ptrs[j + 1] < ptrs[j];
}
i += chunk;
last = ptrs[chunk];
}
// Stop if we are already sorted.
if (!violations)
{
break;
}
// Compute the prefix sum.
unsigned sum = 0;
for (unsigned i = 0; i != FANOUT; ++i)
{
unsigned s = sum;
sum += counts[i];
counts[i] = s;
}
// Place all elements.
for (unsigned i = 0; i < n;)
{
unsigned chunk = ((n - i) <= BLOCKSIZE) ? (n - i) : BLOCKSIZE;
fde_extractor (ob, ptrs, a1 + i, chunk);
for (unsigned j = 0; j < chunk; ++j)
{
unsigned b = (ptrs[j] >> (round * FANOUTBITS)) & (FANOUT - 1);
a2[counts[b]++] = a1[i + j];
}
i += chunk;
}
// Swap a1 and a2.
const fde **tmp = a1;
a1 = a2;
a2 = tmp;
}
#undef BLOCKSIZE
#undef FANOUT
#undef FANOUTBITS
// The data is in a1 now, move in place if needed.
if (a1 != v1->array)
memcpy (v1->array, a1, sizeof (const fde *) * n);
}
static inline void
end_fde_sort (struct object *ob, struct fde_accumulator *accu, size_t count)
{
gcc_assert (!accu->linear || accu->linear->count == count);
if (accu->aux)
{
fde_extractor_t fde_extractor;
if (ob->s.b.mixed_encoding)
fde_extractor = fde_mixed_encoding_extract;
else if (ob->s.b.encoding == DW_EH_PE_absptr)
fde_extractor = fde_unencoded_extract;
else
fde_extractor = fde_single_encoding_extract;
fde_radixsort (ob, fde_extractor, accu->linear, accu->aux);
free (accu->aux);
}
else
{
fde_compare_t fde_compare;
if (ob->s.b.mixed_encoding)
fde_compare = fde_mixed_encoding_compare;
else if (ob->s.b.encoding == DW_EH_PE_absptr)
fde_compare = fde_unencoded_compare;
else
fde_compare = fde_single_encoding_compare;
/* We've not managed to malloc an aux array,
so heap sort in the linear one. */
frame_heapsort (ob, fde_compare, accu->linear);
}
}
/* Inspect the fde array beginning at this_fde. This
function can be used either in query mode (RANGE is
not null, OB is const), or in update mode (RANGE is
null, OB is modified). In query mode the function computes
the range of PC values and stores it in RANGE. In
update mode it updates encoding, mixed_encoding, and pc_begin
for OB. Return the number of fdes encountered along the way. */
static size_t
classify_object_over_fdes (struct object *ob, const fde *this_fde,
uintptr_type *range)
{
const struct dwarf_cie *last_cie = 0;
size_t count = 0;
int encoding = DW_EH_PE_absptr;
_Unwind_Ptr base = 0;
for (; ! last_fde (ob, this_fde); this_fde = next_fde (this_fde))
{
const struct dwarf_cie *this_cie;
_Unwind_Ptr mask, pc_begin;
/* Skip CIEs. */
if (this_fde->CIE_delta == 0)
continue;
/* Determine the encoding for this FDE. Note mixed encoded
objects for later. */
this_cie = get_cie (this_fde);
if (this_cie != last_cie)
{
last_cie = this_cie;
encoding = get_cie_encoding (this_cie);
if (encoding == DW_EH_PE_omit)
return -1;
base = base_from_object (encoding, ob);
if (!range)
{
if (ob->s.b.encoding == DW_EH_PE_omit)
ob->s.b.encoding = encoding;
else if (ob->s.b.encoding != encoding)
ob->s.b.mixed_encoding = 1;
}
}
const unsigned char *p;
p = read_encoded_value_with_base (encoding, base, this_fde->pc_begin,
&pc_begin);
/* Take care to ignore link-once functions that were removed.
In these cases, the function address will be NULL, but if
the encoding is smaller than a pointer a true NULL may not
be representable. Assume 0 in the representable bits is NULL. */
mask = size_of_encoded_value (encoding);
if (mask < sizeof (void *))
mask = (((_Unwind_Ptr) 1) << (mask << 3)) - 1;
else
mask = -1;
if ((pc_begin & mask) == 0)
continue;
count += 1;
if (range)
{
_Unwind_Ptr pc_range, pc_end;
read_encoded_value_with_base (encoding & 0x0F, 0, p, &pc_range);
pc_end = pc_begin + pc_range;
if ((!range[0]) && (!range[1]))
{
range[0] = pc_begin;
range[1] = pc_end;
}
else
{
if (pc_begin < range[0])
range[0] = pc_begin;
if (pc_end > range[1])
range[1] = pc_end;
}
}
else
{
if ((void *) pc_begin < ob->pc_begin)
ob->pc_begin = (void *) pc_begin;
}
}
return count;
}
static void
add_fdes (struct object *ob, struct fde_accumulator *accu, const fde *this_fde)
{
const struct dwarf_cie *last_cie = 0;
int encoding = ob->s.b.encoding;
_Unwind_Ptr base = base_from_object (ob->s.b.encoding, ob);
for (; ! last_fde (ob, this_fde); this_fde = next_fde (this_fde))
{
const struct dwarf_cie *this_cie;
/* Skip CIEs. */
if (this_fde->CIE_delta == 0)
continue;
if (ob->s.b.mixed_encoding)
{
/* Determine the encoding for this FDE. Note mixed encoded
objects for later. */
this_cie = get_cie (this_fde);
if (this_cie != last_cie)
{
last_cie = this_cie;
encoding = get_cie_encoding (this_cie);
base = base_from_object (encoding, ob);
}
}
if (encoding == DW_EH_PE_absptr)
{
_Unwind_Ptr ptr;
memcpy (&ptr, this_fde->pc_begin, sizeof (_Unwind_Ptr));
if (ptr == 0)
continue;
}
else
{
_Unwind_Ptr pc_begin, mask;
read_encoded_value_with_base (encoding, base, this_fde->pc_begin,
&pc_begin);
/* Take care to ignore link-once functions that were removed.
In these cases, the function address will be NULL, but if
the encoding is smaller than a pointer a true NULL may not
be representable. Assume 0 in the representable bits is NULL. */
mask = size_of_encoded_value (encoding);
if (mask < sizeof (void *))
mask = (((_Unwind_Ptr) 1) << (mask << 3)) - 1;
else
mask = -1;
if ((pc_begin & mask) == 0)
continue;
}
fde_insert (accu, this_fde);
}
}
/* Set up a sorted array of pointers to FDEs for a loaded object. We
count up the entries before allocating the array because it's likely to
be faster. We can be called multiple times, should we have failed to
allocate a sorted fde array on a previous occasion. */
static inline void
init_object (struct object* ob)
{
struct fde_accumulator accu;
size_t count;
count = ob->s.b.count;
if (count == 0)
{
if (ob->s.b.from_array)
{
fde **p = ob->u.array;
for (count = 0; *p; ++p)
{
size_t cur_count = classify_object_over_fdes (ob, *p, NULL);
if (cur_count == (size_t) -1)
goto unhandled_fdes;
count += cur_count;
}
}
else
{
count = classify_object_over_fdes (ob, ob->u.single, NULL);
if (count == (size_t) -1)
{
static const fde terminator;
unhandled_fdes:
ob->s.i = 0;
ob->s.b.encoding = DW_EH_PE_omit;
ob->u.single = &terminator;
return;
}
}
/* The count field we have in the main struct object is somewhat
limited, but should suffice for virtually all cases. If the
counted value doesn't fit, re-write a zero. The worst that
happens is that we re-count next time -- admittedly non-trivial
in that this implies some 2M fdes, but at least we function. */
ob->s.b.count = count;
if (ob->s.b.count != count)
ob->s.b.count = 0;
}
if (!start_fde_sort (&accu, count))
return;
if (ob->s.b.from_array)
{
fde **p;
for (p = ob->u.array; *p; ++p)
add_fdes (ob, &accu, *p);
}
else
add_fdes (ob, &accu, ob->u.single);
end_fde_sort (ob, &accu, count);
/* Save the original fde pointer, since this is the key by which the
DSO will deregister the object. */
accu.linear->orig_data = ob->u.single;
ob->u.sort = accu.linear;
#ifdef ATOMIC_FDE_FAST_PATH
// We must update the sorted bit with an atomic operation
struct object tmp;
tmp.s.b = ob->s.b;
tmp.s.b.sorted = 1;
__atomic_store (&(ob->s.b), &(tmp.s.b), __ATOMIC_RELEASE);
#else
ob->s.b.sorted = 1;
#endif
}
#ifdef ATOMIC_FDE_FAST_PATH
/* Get the PC range for lookup */
static void
get_pc_range (const struct object *ob, uintptr_type *range)
{
// It is safe to cast to non-const object* here as
// classify_object_over_fdes does not modify ob in query mode.
struct object *ncob = (struct object *) (uintptr_type) ob;
range[0] = range[1] = 0;
if (ob->s.b.sorted)
{
classify_object_over_fdes (ncob, ob->u.sort->orig_data, range);
}
else if (ob->s.b.from_array)
{
fde **p = ob->u.array;
for (; *p; ++p)
classify_object_over_fdes (ncob, *p, range);
}
else
{
classify_object_over_fdes (ncob, ob->u.single, range);
}
}
#endif
/* A linear search through a set of FDEs for the given PC. This is
used when there was insufficient memory to allocate and sort an
array. */
static const fde *
linear_search_fdes (struct object *ob, const fde *this_fde, void *pc)
{
const struct dwarf_cie *last_cie = 0;
int encoding = ob->s.b.encoding;
_Unwind_Ptr base = base_from_object (ob->s.b.encoding, ob);
for (; ! last_fde (ob, this_fde); this_fde = next_fde (this_fde))
{
const struct dwarf_cie *this_cie;
_Unwind_Ptr pc_begin, pc_range;
/* Skip CIEs. */
if (this_fde->CIE_delta == 0)
continue;
if (ob->s.b.mixed_encoding)
{
/* Determine the encoding for this FDE. Note mixed encoded
objects for later. */
this_cie = get_cie (this_fde);
if (this_cie != last_cie)
{
last_cie = this_cie;
encoding = get_cie_encoding (this_cie);
base = base_from_object (encoding, ob);
}
}
if (encoding == DW_EH_PE_absptr)
{