forked from ianlancetaylor/libbacktrace
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathelf.c
4924 lines (4215 loc) · 127 KB
/
elf.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
/* elf.c -- Get debug data from an ELF file for backtraces.
Copyright (C) 2012-2021 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Google.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
(1) Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
(2) Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
(3) The name of the author may not be used to
endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE. */
#include "config.h"
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#ifdef HAVE_DL_ITERATE_PHDR
#ifdef HAVE_LINK_H
#include <link.h>
#endif
#ifdef HAVE_SYS_LINK_H
#include <sys/link.h>
#endif
#endif
#include "backtrace.h"
#include "internal.h"
#ifndef S_ISLNK
#ifndef S_IFLNK
#define S_IFLNK 0120000
#endif
#ifndef S_IFMT
#define S_IFMT 0170000
#endif
#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
#endif
#ifndef __GNUC__
#define __builtin_prefetch(p, r, l)
#define unlikely(x) (x)
#else
#define unlikely(x) __builtin_expect(!!(x), 0)
#endif
#if !defined(HAVE_DECL_STRNLEN) || !HAVE_DECL_STRNLEN
/* If strnlen is not declared, provide our own version. */
static size_t
xstrnlen (const char *s, size_t maxlen)
{
size_t i;
for (i = 0; i < maxlen; ++i)
if (s[i] == '\0')
break;
return i;
}
#define strnlen xstrnlen
#endif
#ifndef HAVE_LSTAT
/* Dummy version of lstat for systems that don't have it. */
static int
xlstat (const char *path ATTRIBUTE_UNUSED, struct stat *st ATTRIBUTE_UNUSED)
{
return -1;
}
#define lstat xlstat
#endif
#ifndef HAVE_READLINK
/* Dummy version of readlink for systems that don't have it. */
static ssize_t
xreadlink (const char *path ATTRIBUTE_UNUSED, char *buf ATTRIBUTE_UNUSED,
size_t bufsz ATTRIBUTE_UNUSED)
{
return -1;
}
#define readlink xreadlink
#endif
#ifndef HAVE_DL_ITERATE_PHDR
/* Dummy version of dl_iterate_phdr for systems that don't have it. */
#define dl_phdr_info x_dl_phdr_info
#define dl_iterate_phdr x_dl_iterate_phdr
struct dl_phdr_info
{
uintptr_t dlpi_addr;
const char *dlpi_name;
};
static int
dl_iterate_phdr (int (*callback) (struct dl_phdr_info *,
size_t, void *) ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED)
{
return 0;
}
#endif /* ! defined (HAVE_DL_ITERATE_PHDR) */
/* The configure script must tell us whether we are 32-bit or 64-bit
ELF. We could make this code test and support either possibility,
but there is no point. This code only works for the currently
running executable, which means that we know the ELF mode at
configure time. */
#if BACKTRACE_ELF_SIZE != 32 && BACKTRACE_ELF_SIZE != 64
#error "Unknown BACKTRACE_ELF_SIZE"
#endif
/* <link.h> might #include <elf.h> which might define our constants
with slightly different values. Undefine them to be safe. */
#undef EI_NIDENT
#undef EI_MAG0
#undef EI_MAG1
#undef EI_MAG2
#undef EI_MAG3
#undef EI_CLASS
#undef EI_DATA
#undef EI_VERSION
#undef ELF_MAG0
#undef ELF_MAG1
#undef ELF_MAG2
#undef ELF_MAG3
#undef ELFCLASS32
#undef ELFCLASS64
#undef ELFDATA2LSB
#undef ELFDATA2MSB
#undef EV_CURRENT
#undef ET_DYN
#undef EM_PPC64
#undef EF_PPC64_ABI
#undef SHN_LORESERVE
#undef SHN_XINDEX
#undef SHN_UNDEF
#undef SHT_PROGBITS
#undef SHT_SYMTAB
#undef SHT_STRTAB
#undef SHT_DYNSYM
#undef SHF_COMPRESSED
#undef STT_OBJECT
#undef STT_FUNC
#undef NT_GNU_BUILD_ID
#undef ELFCOMPRESS_ZLIB
/* Basic types. */
typedef uint16_t b_elf_half; /* Elf_Half. */
typedef uint32_t b_elf_word; /* Elf_Word. */
typedef int32_t b_elf_sword; /* Elf_Sword. */
#if BACKTRACE_ELF_SIZE == 32
typedef uint32_t b_elf_addr; /* Elf_Addr. */
typedef uint32_t b_elf_off; /* Elf_Off. */
typedef uint32_t b_elf_wxword; /* 32-bit Elf_Word, 64-bit ELF_Xword. */
#else
typedef uint64_t b_elf_addr; /* Elf_Addr. */
typedef uint64_t b_elf_off; /* Elf_Off. */
typedef uint64_t b_elf_xword; /* Elf_Xword. */
typedef int64_t b_elf_sxword; /* Elf_Sxword. */
typedef uint64_t b_elf_wxword; /* 32-bit Elf_Word, 64-bit ELF_Xword. */
#endif
/* Data structures and associated constants. */
#define EI_NIDENT 16
typedef struct {
unsigned char e_ident[EI_NIDENT]; /* ELF "magic number" */
b_elf_half e_type; /* Identifies object file type */
b_elf_half e_machine; /* Specifies required architecture */
b_elf_word e_version; /* Identifies object file version */
b_elf_addr e_entry; /* Entry point virtual address */
b_elf_off e_phoff; /* Program header table file offset */
b_elf_off e_shoff; /* Section header table file offset */
b_elf_word e_flags; /* Processor-specific flags */
b_elf_half e_ehsize; /* ELF header size in bytes */
b_elf_half e_phentsize; /* Program header table entry size */
b_elf_half e_phnum; /* Program header table entry count */
b_elf_half e_shentsize; /* Section header table entry size */
b_elf_half e_shnum; /* Section header table entry count */
b_elf_half e_shstrndx; /* Section header string table index */
} b_elf_ehdr; /* Elf_Ehdr. */
#define EI_MAG0 0
#define EI_MAG1 1
#define EI_MAG2 2
#define EI_MAG3 3
#define EI_CLASS 4
#define EI_DATA 5
#define EI_VERSION 6
#define ELFMAG0 0x7f
#define ELFMAG1 'E'
#define ELFMAG2 'L'
#define ELFMAG3 'F'
#define ELFCLASS32 1
#define ELFCLASS64 2
#define ELFDATA2LSB 1
#define ELFDATA2MSB 2
#define EV_CURRENT 1
#define ET_DYN 3
#define EM_PPC64 21
#define EF_PPC64_ABI 3
typedef struct {
b_elf_word sh_name; /* Section name, index in string tbl */
b_elf_word sh_type; /* Type of section */
b_elf_wxword sh_flags; /* Miscellaneous section attributes */
b_elf_addr sh_addr; /* Section virtual addr at execution */
b_elf_off sh_offset; /* Section file offset */
b_elf_wxword sh_size; /* Size of section in bytes */
b_elf_word sh_link; /* Index of another section */
b_elf_word sh_info; /* Additional section information */
b_elf_wxword sh_addralign; /* Section alignment */
b_elf_wxword sh_entsize; /* Entry size if section holds table */
} b_elf_shdr; /* Elf_Shdr. */
#define SHN_UNDEF 0x0000 /* Undefined section */
#define SHN_LORESERVE 0xFF00 /* Begin range of reserved indices */
#define SHN_XINDEX 0xFFFF /* Section index is held elsewhere */
#define SHT_PROGBITS 1
#define SHT_SYMTAB 2
#define SHT_STRTAB 3
#define SHT_DYNSYM 11
#define SHF_COMPRESSED 0x800
#if BACKTRACE_ELF_SIZE == 32
typedef struct
{
b_elf_word st_name; /* Symbol name, index in string tbl */
b_elf_addr st_value; /* Symbol value */
b_elf_word st_size; /* Symbol size */
unsigned char st_info; /* Symbol binding and type */
unsigned char st_other; /* Visibility and other data */
b_elf_half st_shndx; /* Symbol section index */
} b_elf_sym; /* Elf_Sym. */
#else /* BACKTRACE_ELF_SIZE != 32 */
typedef struct
{
b_elf_word st_name; /* Symbol name, index in string tbl */
unsigned char st_info; /* Symbol binding and type */
unsigned char st_other; /* Visibility and other data */
b_elf_half st_shndx; /* Symbol section index */
b_elf_addr st_value; /* Symbol value */
b_elf_xword st_size; /* Symbol size */
} b_elf_sym; /* Elf_Sym. */
#endif /* BACKTRACE_ELF_SIZE != 32 */
#define STT_OBJECT 1
#define STT_FUNC 2
typedef struct
{
uint32_t namesz;
uint32_t descsz;
uint32_t type;
char name[1];
} b_elf_note;
#define NT_GNU_BUILD_ID 3
#if BACKTRACE_ELF_SIZE == 32
typedef struct
{
b_elf_word ch_type; /* Compresstion algorithm */
b_elf_word ch_size; /* Uncompressed size */
b_elf_word ch_addralign; /* Alignment for uncompressed data */
} b_elf_chdr; /* Elf_Chdr */
#else /* BACKTRACE_ELF_SIZE != 32 */
typedef struct
{
b_elf_word ch_type; /* Compression algorithm */
b_elf_word ch_reserved; /* Reserved */
b_elf_xword ch_size; /* Uncompressed size */
b_elf_xword ch_addralign; /* Alignment for uncompressed data */
} b_elf_chdr; /* Elf_Chdr */
#endif /* BACKTRACE_ELF_SIZE != 32 */
#define ELFCOMPRESS_ZLIB 1
/* Names of sections, indexed by enum dwarf_section in internal.h. */
static const char * const dwarf_section_names[DEBUG_MAX] =
{
".debug_info",
".debug_line",
".debug_abbrev",
".debug_ranges",
".debug_str",
".debug_addr",
".debug_str_offsets",
".debug_line_str",
".debug_rnglists"
};
/* Information we gather for the sections we care about. */
struct debug_section_info
{
/* Section file offset. */
off_t offset;
/* Section size. */
size_t size;
/* Section contents, after read from file. */
const unsigned char *data;
/* Whether the SHF_COMPRESSED flag is set for the section. */
int compressed;
};
/* Information we keep for an ELF symbol. */
struct elf_symbol
{
/* The name of the symbol. */
const char *name;
/* The address of the symbol. */
uintptr_t address;
/* The size of the symbol. */
size_t size;
};
/* Information to pass to elf_syminfo. */
struct elf_syminfo_data
{
/* Symbols for the next module. */
struct elf_syminfo_data *next;
/* The ELF symbols, sorted by address. */
struct elf_symbol *symbols;
/* The number of symbols. */
size_t count;
};
/* A view that works for either a file or memory. */
struct elf_view
{
struct backtrace_view view;
int release; /* If non-zero, must call backtrace_release_view. */
};
/* Information about PowerPC64 ELFv1 .opd section. */
struct elf_ppc64_opd_data
{
/* Address of the .opd section. */
b_elf_addr addr;
/* Section data. */
const char *data;
/* Size of the .opd section. */
size_t size;
/* Corresponding section view. */
struct elf_view view;
};
/* Create a view of SIZE bytes from DESCRIPTOR/MEMORY at OFFSET. */
static int
elf_get_view (struct backtrace_state *state, int descriptor,
const unsigned char *memory, size_t memory_size, off_t offset,
uint64_t size, backtrace_error_callback error_callback,
void *data, struct elf_view *view)
{
if (memory == NULL)
{
view->release = 1;
return backtrace_get_view (state, descriptor, offset, size,
error_callback, data, &view->view);
}
else
{
if ((uint64_t) offset + size > (uint64_t) memory_size)
{
error_callback (data, "out of range for in-memory file", 0);
return 0;
}
view->view.data = (const void *) (memory + offset);
view->view.base = NULL;
view->view.len = size;
view->release = 0;
return 1;
}
}
/* Release a view read by elf_get_view. */
static void
elf_release_view (struct backtrace_state *state, struct elf_view *view,
backtrace_error_callback error_callback, void *data)
{
if (view->release)
backtrace_release_view (state, &view->view, error_callback, data);
}
/* Compute the CRC-32 of BUF/LEN. This uses the CRC used for
.gnu_debuglink files. */
static uint32_t
elf_crc32 (uint32_t crc, const unsigned char *buf, size_t len)
{
static const uint32_t crc32_table[256] =
{
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
0x2d02ef8d
};
const unsigned char *end;
crc = ~crc;
for (end = buf + len; buf < end; ++ buf)
crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
return ~crc;
}
/* Return the CRC-32 of the entire file open at DESCRIPTOR. */
static uint32_t
elf_crc32_file (struct backtrace_state *state, int descriptor,
backtrace_error_callback error_callback, void *data)
{
struct stat st;
struct backtrace_view file_view;
uint32_t ret;
if (fstat (descriptor, &st) < 0)
{
error_callback (data, "fstat", errno);
return 0;
}
if (!backtrace_get_view (state, descriptor, 0, st.st_size, error_callback,
data, &file_view))
return 0;
ret = elf_crc32 (0, (const unsigned char *) file_view.data, st.st_size);
backtrace_release_view (state, &file_view, error_callback, data);
return ret;
}
/* A dummy callback function used when we can't find a symbol
table. */
static void
elf_nosyms (struct backtrace_state *state ATTRIBUTE_UNUSED,
uintptr_t addr ATTRIBUTE_UNUSED,
backtrace_syminfo_callback callback ATTRIBUTE_UNUSED,
backtrace_error_callback error_callback, void *data)
{
error_callback (data, "no symbol table in ELF executable", -1);
}
/* A callback function used when we can't find any debug info. */
static int
elf_nodebug (struct backtrace_state *state, uintptr_t pc,
backtrace_full_callback callback,
backtrace_error_callback error_callback, void *data)
{
if (state->syminfo_fn != NULL && state->syminfo_fn != elf_nosyms)
{
struct backtrace_call_full bdata;
/* Fetch symbol information so that we can least get the
function name. */
bdata.full_callback = callback;
bdata.full_error_callback = error_callback;
bdata.full_data = data;
bdata.ret = 0;
state->syminfo_fn (state, pc, backtrace_syminfo_to_full_callback,
backtrace_syminfo_to_full_error_callback, &bdata);
return bdata.ret;
}
error_callback (data, "no debug info in ELF executable", -1);
return 0;
}
/* Compare struct elf_symbol for qsort. */
static int
elf_symbol_compare (const void *v1, const void *v2)
{
const struct elf_symbol *e1 = (const struct elf_symbol *) v1;
const struct elf_symbol *e2 = (const struct elf_symbol *) v2;
if (e1->address < e2->address)
return -1;
else if (e1->address > e2->address)
return 1;
else
return 0;
}
/* Compare an ADDR against an elf_symbol for bsearch. We allocate one
extra entry in the array so that this can look safely at the next
entry. */
static int
elf_symbol_search (const void *vkey, const void *ventry)
{
const uintptr_t *key = (const uintptr_t *) vkey;
const struct elf_symbol *entry = (const struct elf_symbol *) ventry;
uintptr_t addr;
addr = *key;
if (addr < entry->address)
return -1;
else if (addr >= entry->address + entry->size)
return 1;
else
return 0;
}
/* Initialize the symbol table info for elf_syminfo. */
static int
elf_initialize_syminfo (struct backtrace_state *state,
uintptr_t base_address,
const unsigned char *symtab_data, size_t symtab_size,
const unsigned char *strtab, size_t strtab_size,
backtrace_error_callback error_callback,
void *data, struct elf_syminfo_data *sdata,
struct elf_ppc64_opd_data *opd)
{
size_t sym_count;
const b_elf_sym *sym;
size_t elf_symbol_count;
size_t elf_symbol_size;
struct elf_symbol *elf_symbols;
size_t i;
unsigned int j;
sym_count = symtab_size / sizeof (b_elf_sym);
/* We only care about function symbols. Count them. */
sym = (const b_elf_sym *) symtab_data;
elf_symbol_count = 0;
for (i = 0; i < sym_count; ++i, ++sym)
{
int info;
info = sym->st_info & 0xf;
if ((info == STT_FUNC || info == STT_OBJECT)
&& sym->st_shndx != SHN_UNDEF)
++elf_symbol_count;
}
elf_symbol_size = elf_symbol_count * sizeof (struct elf_symbol);
elf_symbols = ((struct elf_symbol *)
backtrace_alloc (state, elf_symbol_size, error_callback,
data));
if (elf_symbols == NULL)
return 0;
sym = (const b_elf_sym *) symtab_data;
j = 0;
for (i = 0; i < sym_count; ++i, ++sym)
{
int info;
info = sym->st_info & 0xf;
if (info != STT_FUNC && info != STT_OBJECT)
continue;
if (sym->st_shndx == SHN_UNDEF)
continue;
if (sym->st_name >= strtab_size)
{
error_callback (data, "symbol string index out of range", 0);
backtrace_free (state, elf_symbols, elf_symbol_size, error_callback,
data);
return 0;
}
elf_symbols[j].name = (const char *) strtab + sym->st_name;
/* Special case PowerPC64 ELFv1 symbols in .opd section, if the symbol
is a function descriptor, read the actual code address from the
descriptor. */
if (opd
&& sym->st_value >= opd->addr
&& sym->st_value < opd->addr + opd->size)
elf_symbols[j].address
= *(const b_elf_addr *) (opd->data + (sym->st_value - opd->addr));
else
elf_symbols[j].address = sym->st_value;
elf_symbols[j].address += base_address;
elf_symbols[j].size = sym->st_size;
++j;
}
backtrace_qsort (elf_symbols, elf_symbol_count, sizeof (struct elf_symbol),
elf_symbol_compare);
sdata->next = NULL;
sdata->symbols = elf_symbols;
sdata->count = elf_symbol_count;
return 1;
}
/* Add EDATA to the list in STATE. */
static void
elf_add_syminfo_data (struct backtrace_state *state,
struct elf_syminfo_data *edata)
{
if (!state->threaded)
{
struct elf_syminfo_data **pp;
for (pp = (struct elf_syminfo_data **) (void *) &state->syminfo_data;
*pp != NULL;
pp = &(*pp)->next)
;
*pp = edata;
}
else
{
while (1)
{
struct elf_syminfo_data **pp;
pp = (struct elf_syminfo_data **) (void *) &state->syminfo_data;
while (1)
{
struct elf_syminfo_data *p;
p = backtrace_atomic_load_pointer (pp);
if (p == NULL)
break;
pp = &p->next;
}
if (__sync_bool_compare_and_swap (pp, NULL, edata))
break;
}
}
}
/* Return the symbol name and value for an ADDR. */
static void
elf_syminfo (struct backtrace_state *state, uintptr_t addr,
backtrace_syminfo_callback callback,
backtrace_error_callback error_callback ATTRIBUTE_UNUSED,
void *data)
{
struct elf_syminfo_data *edata;
struct elf_symbol *sym = NULL;
if (!state->threaded)
{
for (edata = (struct elf_syminfo_data *) state->syminfo_data;
edata != NULL;
edata = edata->next)
{
sym = ((struct elf_symbol *)
bsearch (&addr, edata->symbols, edata->count,
sizeof (struct elf_symbol), elf_symbol_search));
if (sym != NULL)
break;
}
}
else
{
struct elf_syminfo_data **pp;
pp = (struct elf_syminfo_data **) (void *) &state->syminfo_data;
while (1)
{
edata = backtrace_atomic_load_pointer (pp);
if (edata == NULL)
break;
sym = ((struct elf_symbol *)
bsearch (&addr, edata->symbols, edata->count,
sizeof (struct elf_symbol), elf_symbol_search));
if (sym != NULL)
break;
pp = &edata->next;
}
}
if (sym == NULL)
callback (data, addr, NULL, 0, 0);
else
callback (data, addr, sym->name, sym->address, sym->size);
}
/* Return whether FILENAME is a symlink. */
static int
elf_is_symlink (const char *filename)
{
struct stat st;
if (lstat (filename, &st) < 0)
return 0;
return S_ISLNK (st.st_mode);
}
/* Return the results of reading the symlink FILENAME in a buffer
allocated by backtrace_alloc. Return the length of the buffer in
*LEN. */
static char *
elf_readlink (struct backtrace_state *state, const char *filename,
backtrace_error_callback error_callback, void *data,
size_t *plen)
{
size_t len;
char *buf;
len = 128;
while (1)
{
ssize_t rl;
buf = backtrace_alloc (state, len, error_callback, data);
if (buf == NULL)
return NULL;
rl = readlink (filename, buf, len);
if (rl < 0)
{
backtrace_free (state, buf, len, error_callback, data);
return NULL;
}
if ((size_t) rl < len - 1)
{
buf[rl] = '\0';
*plen = len;
return buf;
}
backtrace_free (state, buf, len, error_callback, data);
len *= 2;
}
}
#define SYSTEM_BUILD_ID_DIR "/usr/lib/debug/.build-id/"
/* Open a separate debug info file, using the build ID to find it.
Returns an open file descriptor, or -1.
The GDB manual says that the only place gdb looks for a debug file
when the build ID is known is in /usr/lib/debug/.build-id. */
static int
elf_open_debugfile_by_buildid (struct backtrace_state *state,
const char *buildid_data, size_t buildid_size,
backtrace_error_callback error_callback,
void *data)
{
const char * const prefix = SYSTEM_BUILD_ID_DIR;
const size_t prefix_len = strlen (prefix);
const char * const suffix = ".debug";
const size_t suffix_len = strlen (suffix);
size_t len;
char *bd_filename;
char *t;
size_t i;
int ret;
int does_not_exist;
len = prefix_len + buildid_size * 2 + suffix_len + 2;
bd_filename = backtrace_alloc (state, len, error_callback, data);
if (bd_filename == NULL)
return -1;
t = bd_filename;
memcpy (t, prefix, prefix_len);
t += prefix_len;
for (i = 0; i < buildid_size; i++)
{
unsigned char b;
unsigned char nib;
b = (unsigned char) buildid_data[i];
nib = (b & 0xf0) >> 4;
*t++ = nib < 10 ? '0' + nib : 'a' + nib - 10;
nib = b & 0x0f;
*t++ = nib < 10 ? '0' + nib : 'a' + nib - 10;
if (i == 0)
*t++ = '/';
}
memcpy (t, suffix, suffix_len);
t[suffix_len] = '\0';
ret = backtrace_open (bd_filename, error_callback, data, &does_not_exist);
backtrace_free (state, bd_filename, len, error_callback, data);
/* gdb checks that the debuginfo file has the same build ID note.
That seems kind of pointless to me--why would it have the right
name but not the right build ID?--so skipping the check. */
return ret;
}
/* Try to open a file whose name is PREFIX (length PREFIX_LEN)
concatenated with PREFIX2 (length PREFIX2_LEN) concatenated with
DEBUGLINK_NAME. Returns an open file descriptor, or -1. */
static int
elf_try_debugfile (struct backtrace_state *state, const char *prefix,
size_t prefix_len, const char *prefix2, size_t prefix2_len,
const char *debuglink_name,
backtrace_error_callback error_callback, void *data)
{
size_t debuglink_len;
size_t try_len;
char *try;
int does_not_exist;
int ret;
debuglink_len = strlen (debuglink_name);
try_len = prefix_len + prefix2_len + debuglink_len + 1;
try = backtrace_alloc (state, try_len, error_callback, data);
if (try == NULL)
return -1;
memcpy (try, prefix, prefix_len);
memcpy (try + prefix_len, prefix2, prefix2_len);
memcpy (try + prefix_len + prefix2_len, debuglink_name, debuglink_len);
try[prefix_len + prefix2_len + debuglink_len] = '\0';
ret = backtrace_open (try, error_callback, data, &does_not_exist);
backtrace_free (state, try, try_len, error_callback, data);
return ret;
}
/* Find a separate debug info file, using the debuglink section data
to find it. Returns an open file descriptor, or -1. */
static int
elf_find_debugfile_by_debuglink (struct backtrace_state *state,
const char *filename,
const char *debuglink_name,
backtrace_error_callback error_callback,
void *data)
{
int ret;
char *alc;
size_t alc_len;
const char *slash;
int ddescriptor;
const char *prefix;
size_t prefix_len;
/* Resolve symlinks in FILENAME. Since FILENAME is fairly likely to
be /proc/self/exe, symlinks are common. We don't try to resolve
the whole path name, just the base name. */
ret = -1;
alc = NULL;
alc_len = 0;
while (elf_is_symlink (filename))
{
char *new_buf;
size_t new_len;
new_buf = elf_readlink (state, filename, error_callback, data, &new_len);
if (new_buf == NULL)
break;
if (new_buf[0] == '/')
filename = new_buf;
else
{
slash = strrchr (filename, '/');
if (slash == NULL)
filename = new_buf;
else
{
size_t clen;
char *c;
slash++;
clen = slash - filename + strlen (new_buf) + 1;
c = backtrace_alloc (state, clen, error_callback, data);
if (c == NULL)
goto done;