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
|
/* Copyright (C) 2007-2010 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** This program 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.
*/
/*
* Contains declarations of types, constants and structures
* describing DWARF format.
*/
#ifndef ELFF_DWARF_DEFS_H_
#define ELFF_DWARF_DEFS_H_
#include "dwarf.h"
#include "elf_defs.h"
/* DWARF structures are packed to 1 byte. */
#define ELFF_PACKED __attribute__ ((packed))
/*
* Helper types for misc. DWARF variables.
*/
/* Type for DWARF abbreviation number. */
typedef uint32_t Dwarf_AbbrNum;
/* Type for DWARF tag ID. */
typedef uint16_t Dwarf_Tag;
/* Type for DWARF attribute ID. */
typedef uint16_t Dwarf_At;
/* Type for DWARF form ID. */
typedef uint16_t Dwarf_Form;
/* Type for offset in 32-bit DWARF. */
typedef uint32_t Dwarf32_Off;
/* Type for offset in 64-bit DWARF. */
typedef uint64_t Dwarf64_Off;
/* Enumerates types of values, obtained during DWARF attribute decoding. */
typedef enum DwarfValueType {
/* Undefined */
DWARF_VALUE_UNKNOWN = 1,
/* uint8_t */
DWARF_VALUE_U8,
/* int8_t */
DWARF_VALUE_S8,
/* uint16_t */
DWARF_VALUE_U16,
/* int16_t */
DWARF_VALUE_S16,
/* uint32_t */
DWARF_VALUE_U32,
/* int32_t */
DWARF_VALUE_S32,
/* uint64_t */
DWARF_VALUE_U64,
/* int64_t */
DWARF_VALUE_S64,
/* const char* */
DWARF_VALUE_STR,
/* 32-bit address */
DWARF_VALUE_PTR32,
/* 64-bit address */
DWARF_VALUE_PTR64,
/* Dwarf_Block */
DWARF_VALUE_BLOCK,
} DwarfValueType;
/* Describes block of data, stored directly in the mapped .debug_info
* section. This type is used to represent an attribute encoded with
* DW_FORM_block# form.
*/
typedef struct Dwarf_Block {
/* Pointer to the block data inside mapped .debug_info section. */
const void* block_ptr;
/* Byte size of the block data. */
Elf_Word block_size;
} Dwarf_Block;
/* Describes a value, obtained from the mapped .debug_info section
* during DWARF attribute decoding.
*/
typedef struct Dwarf_Value {
/* Unites all possible data types for the value.
* See DwarfValueType for the list of types.
*/
union {
Elf_Byte u8;
Elf_Sbyte s8;
Elf_Half u16;
Elf_Shalf s16;
Elf_Word u32;
Elf_Sword s32;
Elf_Xword u64;
Elf_Sxword s64;
Elf_Word ptr32;
Elf_Xword ptr64;
const char* str;
Dwarf_Block block;
};
/* Value type (defines which variable in the union abowe
* contains the value).
*/
DwarfValueType type;
/* Number of bytes that encode this value in .debug_info section
* of ELF file.
*/
Elf_Word encoded_size;
} Dwarf_Value;
/* DWARF's LEB128 data type. LEB128 is defined as:
* Variable Length Data. "Little Endian Base 128" (LEB128) numbers. LEB128 is
* a scheme for encoding integers densely that exploits the assumption that
* most integers are small in magnitude. (This encoding is equally suitable
* whether the target machine architecture represents data in big-endian or
* littleendian order. It is "little endian" only in the sense that it avoids
* using space to represent the "big" end of an unsigned integer, when the big
* end is all zeroes or sign extension bits).
*
* Unsigned LEB128 numbers are encoded as follows: start at the low order end
* of an unsigned integer and chop it into 7-bit chunks. Place each chunk into
* the low order 7 bits of a byte. Typically, several of the high order bytes
* will be zero; discard them. Emit the remaining bytes in a stream, starting
* with the low order byte; set the high order bit on each byte except the last
* emitted byte. The high bit of zero on the last byte indicates to the decoder
* that it has encountered the last byte. The integer zero is a special case,
* consisting of a single zero byte.
*
* The encoding for signed LEB128 numbers is similar, except that the criterion
* for discarding high order bytes is not whether they are zero, but whether
* they consist entirely of sign extension bits. Consider the 32-bit integer
* -2. The three high level bytes of the number are sign extension, thus LEB128
* would represent it as a single byte containing the low order 7 bits, with
* the high order bit cleared to indicate the end of the byte stream. Note that
* there is nothing within the LEB128 representation that indicates whether an
* encoded number is signed or unsigned. The decoder must know what type of
* number to expect.
*
* NOTE: It's assumed that LEB128 will not contain encodings for integers,
* larger than 64 bit.
*/
typedef struct ELFF_PACKED Dwarf_Leb128 {
/* Beginning of the LEB128 block. */
Elf_Byte val;
/* Pulls actual value, encoded with this LEB128 block.
* Param:
* value - Upon return will contain value, encoded with this LEB128 block.
* sign - If true, the caller expects the LEB128 to contain a signed
* integer, otherwise, caller expects an unsigned integer value to be
* encoded with this LEB128 block.
*/
void get_common(Dwarf_Value* value, bool sign) const {
value->u64 = 0;
/* Integer zero is a special case. */
if (val == 0) {
value->type = sign ? DWARF_VALUE_S32 : DWARF_VALUE_U32;
value->encoded_size = 1;
return;
}
/* We've got to reconstruct the integer. */
value->type = DWARF_VALUE_UNKNOWN;
value->encoded_size = 0;
/* Byte by byte loop though the LEB128, reconstructing the integer from
* 7-bits chunks. Byte with 8-th bit set to zero indicates the end
* of the LEB128 block. For signed integers, 7-th bit of the last LEB128
* byte controls the sign. If 7-th bit of the last LEB128 byte is set,
* the integer is negative. If 7-th bit of the last LEB128 byte is not
* set, the integer is positive.
*/
const Elf_Byte* cur = &val;
Elf_Word shift = 0;
while ((*cur & 0x80) != 0) {
value->u64 |= (static_cast<Elf_Xword>(*cur) & 0x7F) << shift;
shift += 7;
value->encoded_size++;
cur++;
}
value->u64 |= (static_cast<Elf_Xword>(*cur) & 0x7F) << shift;
value->encoded_size++;
/* LEB128 format doesn't carry any info of the sizeof of the integer it
* represents. We well guess it, judging by the highest bit set in the
* reconstucted integer.
*/
if ((value->u64 & 0xFFFFFFFF00000000LL) == 0) {
/* 32-bit integer. */
if (sign) {
value->type = DWARF_VALUE_S32;
if (((*cur) & 0x40) != 0) {
// Value is negative.
value->u64 |= - (1 << (shift + 7));
} else if ((value->u32 & 0x80000000) != 0) {
// Make sure we don't report negative value in this case.
value->type = DWARF_VALUE_S64;
}
} else {
value->type = DWARF_VALUE_U32;
}
} else {
/* 64-bit integer. */
if (sign) {
value->type = DWARF_VALUE_S64;
if (((*cur) & 0x40) != 0) {
// Value is negative.
value->u64 |= - (1 << (shift + 7));
}
} else {
value->type = DWARF_VALUE_U64;
}
}
}
/* Pulls actual unsigned value, encoded with this LEB128 block.
* See get_common() for more info.
* Param:
* value - Upon return will contain unsigned value, encoded with
* this LEB128 block.
*/
void get_unsigned(Dwarf_Value* value) const {
get_common(value, false);
}
/* Pulls actual signed value, encoded with this LEB128 block.
* See get_common() for more info.
* Param:
* value - Upon return will contain signed value, encoded with
* this LEB128 block.
*/
void get_signed(Dwarf_Value* value) const {
get_common(value, true);
}
/* Pulls LEB128 value, advancing past this LEB128 block.
* See get_common() for more info.
* Return:
* Pointer to the byte past this LEB128 block.
*/
const void* process(Dwarf_Value* value, bool sign) const {
get_common(value, sign);
return INC_CPTR(&val, value->encoded_size);
}
/* Pulls LEB128 unsigned value, advancing past this LEB128 block.
* See process() for more info.
*/
const void* process_unsigned(Dwarf_Value* value) const {
return process(value, false);
}
/* Pulls LEB128 signed value, advancing past this LEB128 block.
* See process() for more info.
*/
const void* process_signed(Dwarf_Value* value) const {
return process(value, true);
}
} Dwarf_Leb128;
/* DIE attribute descriptor in the .debug_abbrev section.
* Attribute descriptor contains two LEB128 values. First one provides
* attribute ID (one of DW_AT_XXX values), and the second one provides
* format (one of DW_FORMAT_XXX values), in which attribute value is
* encoded in the .debug_info section of the ELF file.
*/
typedef struct ELFF_PACKED Dwarf_Abbr_AT {
/* Attribute ID (DW_AT_XXX).
* Attribute format (DW_FORMAT_XXX) follows immediately.
*/
Dwarf_Leb128 at;
/* Checks if this is a separator descriptor.
* Zero is an invalid attribute ID, indicating the end of attribute
* list for the current DIE.
*/
bool is_separator() const {
return at.val == 0;
}
/* Pulls attribute data, advancing past this descriptor.
* Param:
* at_value - Upon return contains attribute value of this descriptor.
* form - Upon return contains form value of this descriptor.
* Return:
* Pointer to the byte past this descriptor block (usually, next
* attribute decriptor).
*/
const Dwarf_Abbr_AT* process(Dwarf_At* at_value, Dwarf_Form* form) const {
if (is_separator()) {
/* Size of separator descriptor is always 2 bytes. */
*at_value = 0;
*form = 0;
return INC_CPTR_T(Dwarf_Abbr_AT, &at.val, 2);
}
Dwarf_Value val;
/* Process attribute ID. */
const Dwarf_Leb128* next =
reinterpret_cast<const Dwarf_Leb128*>(at.process_unsigned(&val));
*at_value = val.u16;
/* Follow with processing the form. */
next = reinterpret_cast<const Dwarf_Leb128*>(next->process_unsigned(&val));
*form = val.u16;
return reinterpret_cast<const Dwarf_Abbr_AT*>(next);
}
} Dwarf_Abbr_AT;
/* DIE abbreviation descriptor in the .debug_abbrev section.
* DIE abbreviation descriptor contains three parameters. The first one is a
* LEB128 value, that encodes 1 - based abbreviation descriptor number.
* Abbreviation descriptor numbers seems to be always in sequential order, and
* are counted on per-compilation unit basis. I.e. abbreviation number for the
* first DIE abbreviation descriptor of each compilation unit is always 1.
*
* Besides abbreviation number, DIE abbreviation descriptor contains two more
* values. The first one (after abbr_num) is a LEB128 value containing DIE's
* tag value, and the second one is one byte flag specifying whether or not
* the DIE contains any cildren.
*
* This descriptor is immediately followed by a list of attribute descriptors
* (see Dwarf_Abbr_AT) for the DIE represented by this abbreviation descriptor.
*/
typedef struct ELFF_PACKED Dwarf_Abbr_DIE {
/* 1 - based abbreviation number for the DIE. */
Dwarf_Leb128 abbr_num;
/* Gets abbreviation number for this descriptor. */
Dwarf_AbbrNum get_abbr_num() const {
Dwarf_Value val;
abbr_num.get_unsigned(&val);
return val.u16;
}
/* Gets DIE tag for this descriptor. */
Dwarf_Tag get_tag() const {
Dwarf_Tag tag;
process(NULL, &tag);
return tag;
}
/* Pulls DIE abbreviation descriptor data, advancing past this descriptor.
* Param:
* abbr_index - Upon return contains abbreviation number for this
* descriptor. This parameter can be NULL, if the caller is not interested
* in this value.
* tag - Upon return contains tag of the DIE for this descriptor. This
* parameter can be NULL, if the caller is not interested in this value.
* form - Upon return contains form of the DIE for this descriptor.
* Return:
* Pointer to the list of attribute descriptors for the DIE.
*/
const Dwarf_Abbr_AT* process(Dwarf_AbbrNum* abbr_index,
Dwarf_Tag* tag) const {
Dwarf_Value val;
const Dwarf_Leb128* next =
reinterpret_cast<const Dwarf_Leb128*>(abbr_num.process_unsigned(&val));
if (abbr_index != NULL) {
*abbr_index = val.u32;
}
/* Next one is a "tag". */
next = reinterpret_cast<const Dwarf_Leb128*>(next->process_unsigned(&val));
if (tag != NULL) {
*tag = val.u16;
}
/* Next one is a "has children" one byte flag. We're not interested in it,
* so jump to the list of attribute descriptors that immediately follows
* this DIE descriptor. */
return INC_CPTR_T(Dwarf_Abbr_AT, next, 1);
}
} Dwarf_Abbr_DIE;
/* DIE descriptor in the .debug_info section.
* DIE descriptor contains one LEB128-encoded value, containing DIE's
* abbreviation descriptor number in the .debug_abbrev section.
*
* DIE descriptor is immediately followed by the list of DIE attribute values,
* format of wich is defined by the list of attribute descriptors in the
* .debug_abbrev section, that immediately follow the DIE attribute descriptor,
* addressed by this descriptor's abbr_num LEB128.
*/
typedef struct ELFF_PACKED Dwarf_DIE {
/* 1 - based index of DIE abbreviation descriptor (Dwarf_Abbr_DIE) for this
* DIE in the .debug_abbrev section.
*
* NOTE: DIE abbreviation descriptor indexes are tied to the compilation
* unit. In other words, each compilation unit restarts counting DIE
* abbreviation descriptors from 1.
*
* NOTE: Zero is invalid value for this field, indicating that this DIE is a
* separator (usually it ends a list of "child" DIEs)
*/
Dwarf_Leb128 abbr_num;
/* Checks if this is a separator DIE. */
bool is_separator() const {
return abbr_num.val == 0;
}
/* Gets (1 - based) abbreviation number for this DIE. */
Dwarf_AbbrNum get_abbr_num() const {
Dwarf_Value val;
abbr_num.get_unsigned(&val);
return val.u16;
}
/* Pulls DIE information, advancing past this descriptor to DIE attributes.
* Param:
* abbr_num - Upon return contains abbreviation number for this DIE. This
* parameter can be NULL, if the caller is not interested in this value.
* Return:
* Pointer to the byte past this descriptor (the list of DIE attributes).
*/
const Elf_Byte* process(Dwarf_AbbrNum* abbr_number) const {
if (is_separator()) {
if (abbr_number != NULL) {
*abbr_number = 0;
}
// Size of a separator DIE is 1 byte.
return INC_CPTR_T(Elf_Byte, &abbr_num.val, 1);
}
Dwarf_Value val;
const void* ret = abbr_num.process_unsigned(&val);
if (abbr_number != NULL) {
*abbr_number = val.u32;
}
return reinterpret_cast<const Elf_Byte*>(ret);
}
} Dwarf_DIE;
/*
* Variable size headers.
* When encoding size value in DWARF, the first 32 bits of a "size" header
* define header type. If first 32 bits of the header contain 0xFFFFFFFF
* value, this is 64-bit size header with the following 64 bits encoding
* the size. Otherwise, if first 32 bits are not 0xFFFFFFFF, they contain
* 32-bit size value.
*/
/* Size header for 32-bit DWARF. */
typedef struct ELFF_PACKED Dwarf32_SizeHdr {
/* Size value. */
Elf_Word size;
} Dwarf32_SizeHdr;
/* Size header for 64-bit DWARF. */
typedef struct ELFF_PACKED Dwarf64_SizeHdr {
/* Size selector. For 64-bit DWARF this field is set to 0xFFFFFFFF */
Elf_Word size_selector;
/* Actual size value. */
Elf_Xword size;
} Dwarf64_SizeHdr;
/* Compilation unit header in the .debug_info section.
* Template param:
* Dwarf_SizeHdr - Type for the header's size field. Must be Dwarf32_SizeHdr
* for 32-bit DWARF, or Dwarf64_SizeHdr for 64-bit DWARF.
* Elf_Off - Type for abbrev_offset field. Must be Elf_Word for for 32-bit
* DWARF, or Elf_Xword for 64-bit DWARF.
*/
template <typename Dwarf_SizeHdr, typename Elf_Off>
struct ELFF_PACKED Dwarf_CUHdr {
/* Size of the compilation unit data in .debug_info section. */
Dwarf_SizeHdr size_hdr;
/* Compilation unit's DWARF version stamp. */
Elf_Half version;
/* Relative (to the beginning of .debug_abbrev section data) offset of the
* beginning of abbreviation sequence for this compilation unit.
*/
Elf_Off abbrev_offset;
/* Pointer size for this compilation unit (should be 4, or 8). */
Elf_Byte address_size;
};
/* Compilation unit header in the .debug_info section for 32-bit DWARF. */
typedef Dwarf_CUHdr<Dwarf32_SizeHdr, Elf_Word> Dwarf32_CUHdr;
/* Compilation unit header in the .debug_info section for 64-bit DWARF. */
typedef Dwarf_CUHdr<Dwarf64_SizeHdr, Elf_Xword> Dwarf64_CUHdr;
/* CU STMTL header in the .debug_line section.
* Template param:
* Dwarf_SizeHdr - Type for the header's size field. Must be Dwarf32_SizeHdr
* for 32-bit DWARF, or Dwarf64_SizeHdr for 64-bit DWARF.
* Elf_Size - Type for header_length field. Must be Elf_Word for for 32-bit
* DWARF, or Elf_Xword for 64-bit DWARF.
*/
template <typename Dwarf_SizeHdr, typename Elf_Size>
struct ELFF_PACKED Dwarf_STMTLHdr {
/* The size in bytes of the line number information for this compilation
* unit, not including the unit_length field itself. */
Dwarf_SizeHdr unit_length;
/* A version number. This number is specific to the line number information
* and is independent of the DWARF version number. */
Elf_Half version;
/* The number of bytes following the header_length field to the beginning of
* the first byte of the line number program itself. In the 32-bit DWARF
* format, this is a 4-byte unsigned length; in the 64-bit DWARF format,
* this field is an 8-byte unsigned length. */
Elf_Size header_length;
/* The size in bytes of the smallest target machine instruction. Line number
* program opcodes that alter the address register first multiply their
* operands by this value. */
Elf_Byte min_instruction_len;
/* The initial value of the is_stmt register. */
Elf_Byte default_is_stmt;
/* This parameter affects the meaning of the special opcodes. */
Elf_Sbyte line_base;
/* This parameter affects the meaning of the special opcodes. */
Elf_Byte line_range;
/* The number assigned to the first special opcode. */
Elf_Byte opcode_base;
/* This is first opcode in an array specifying the number of LEB128 operands
* for each of the standard opcodes. The first element of the array
* corresponds to the opcode whose value is 1, and the last element
* corresponds to the opcode whose value is opcode_base - 1. By increasing
* opcode_base, and adding elements to this array, new standard opcodes can
* be added, while allowing consumers who do not know about these new opcodes
* to be able to skip them. NOTE: this array points to the mapped
* .debug_line section. */
Elf_Byte standard_opcode_lengths;
};
/* CU STMTL header in the .debug_line section for 32-bit DWARF. */
typedef Dwarf_STMTLHdr<Dwarf32_SizeHdr, Elf_Word> Dwarf32_STMTLHdr;
/* CU STMTL header in the .debug_line section for 64-bit DWARF. */
typedef Dwarf_STMTLHdr<Dwarf64_SizeHdr, Elf_Xword> Dwarf64_STMTLHdr;
/* Source file descriptor in the .debug_line section.
* Descriptor begins with zero-terminated file name, followed by an ULEB128,
* encoding directory index in the list of included directories, followed by
* an ULEB12, encoding file modification time, followed by an ULEB12, encoding
* file size.
*/
typedef struct ELFF_PACKED Dwarf_STMTL_FileDesc {
/* Zero-terminated file name. */
char file_name[1];
/* Checks of this descriptor ends the list. */
bool is_last_entry() const {
return file_name[0] == '\0';
}
/* Gets file name. */
const char* get_file_name() const {
return file_name;
}
/* Processes this descriptor, advancing to the next one.
* Param:
* dir_index - Upon return contains index of the parent directory in the
* list of included directories. Can be NULL if caller is not interested
* in this value.
* Return:
* Pointer to the next source file descriptor in the list.
*/
const Dwarf_STMTL_FileDesc* process(Elf_Word* dir_index) const {
if (is_last_entry()) {
return this;
}
/* First parameter: include directory index. */
Dwarf_Value tmp;
const Dwarf_Leb128* leb =
INC_CPTR_T(Dwarf_Leb128, file_name, strlen(file_name) + 1);
leb = reinterpret_cast<const Dwarf_Leb128*>(leb->process_unsigned(&tmp));
if (dir_index != NULL) {
*dir_index = tmp.u32;
}
/* Process file time. */
leb = reinterpret_cast<const Dwarf_Leb128*>(leb->process_unsigned(&tmp));
/* Process file size. */
return reinterpret_cast<const Dwarf_STMTL_FileDesc*>(leb->process_unsigned(&tmp));
}
/* Gets directory index for this descriptor. */
Elf_Word get_dir_index() const {
assert(!is_last_entry());
if (is_last_entry()) {
return 0;
}
/* Get directory index. */
Dwarf_Value ret;
const Dwarf_Leb128* leb =
INC_CPTR_T(Dwarf_Leb128, file_name, strlen(file_name) + 1);
leb->process_unsigned(&ret);
return ret.u32;
}
} Dwarf_STMTL_FileDesc;
/* Encapsulates a DIE attribute, collected during ELF file parsing.
*/
class DIEAttrib {
public:
/* Constructs DIEAttrib intance. */
DIEAttrib()
: at_(0),
form_(0) {
value_.type = DWARF_VALUE_UNKNOWN;
}
/* Destructs DIEAttrib intance. */
~DIEAttrib() {
}
/* Gets DWARF attribute ID (DW_AT_Xxx) for this property. */
Dwarf_At at() const {
return at_;
}
/* Gets DWARF form ID (DW_FORM_Xxx) for this property. */
Dwarf_Form form() const {
return form_;
}
/* Gets value of this property. */
const Dwarf_Value* value() const {
return &value_;
}
/* Value of this property. */
Dwarf_Value value_;
/* DWARF attribute ID (DW_AT_Xxx) for this property. */
Dwarf_At at_;
/* DWARF form ID (DW_FORM_Xxx) for this property. */
Dwarf_Form form_;
};
/* Parse tag context.
* This structure is used as an ELF file parsing parameter, limiting collected
* DIEs by the list of tags.
*/
typedef struct DwarfParseContext {
/* Zero-terminated list of tags to collect DIEs for. If this field is NULL,
* DIEs for all tags will be collected during the parsing. */
const Dwarf_Tag* tags;
} DwarfParseContext;
/* Checks if a DIE with the given tag should be collected during the parsing.
* Param:
* parse_context - Parse context to check the tag against. This parameter can
* be NULL, indicating that all tags should be collected.
* tag - Tag to check.
* Return:
* true if a DIE with the given tag should be collected during the parsing,
* or false, if the DIE should not be collected.
*/
static inline bool
collect_die(const DwarfParseContext* parse_context, Dwarf_Tag tag) {
if (parse_context == NULL || parse_context->tags == NULL) {
return true;
}
for (const Dwarf_Tag* tags = parse_context->tags; *tags != 0; tags++) {
if (*tags == tag) {
return true;
}
}
return false;
}
/* Encapsulates an array of Dwarf_Abbr_DIE pointers, cached for a compilation
* unit. Although Dwarf_Abbr_DIE descriptors in the .debug_abbrev section of
* the ELF file seems to be always in sequential order, DIE descriptors may
* reference them randomly. So, to provide better performance, we will cache
* all Dwarf_Abbr_DIE pointers, that were found for each DIE. Since all of the
* Dwarf_Abbr_DIE are sequential, an array is the best way to cache them.
*
* NOTE: Objects of this class are instantiated one per each CU, as all DIE
* abbreviation numberation is restarted from 1 for each new CU.
*/
class DwarfAbbrDieArray {
public:
/* Constructs DwarfAbbrDieArray instance.
* Most of the CUs don't have too many unique Dwarf_Abbr_DIEs, so, in order
* to decrease the amount of memory allocation calls, we will preallocate
* a relatively small array for them along with the instance of this class,
* hopping, that all Dwarf_Abbr_DIEs for the CU will fit into it.
*/
DwarfAbbrDieArray()
: count_(0),
array_size_(ELFF_ARRAY_SIZE(small_array_)),
array_(&small_array_[0]) {
}
/* Destructs DwarfAbbrDieArray instance. */
~DwarfAbbrDieArray() {
if (array_ != &small_array_[0]) {
delete[] array_;
}
}
/* Adds new entry to the array
* Param:
* abbr - New entry to add.
* num - Abbreviation number for the adding entry.
* NOTE: before adding, this method will verify that descriptor for the
* given abbreviation number has not been cached yet.
* NOTE: due to the nature of this array, entries MUST be added strictly
* in sequential order.
* Return:
* true on success, false on failure.
*/
bool add(const Dwarf_Abbr_DIE* abbr, Dwarf_AbbrNum num) {
assert(num != 0);
if (num == 0) {
// Zero is illegal DIE abbreviation number.
_set_errno(EINVAL);
return false;
}
if (num <= count_) {
// Already cached.
return true;
}
// Enforce strict sequential order.
assert(num == (count_ + 1));
if (num != (count_ + 1)) {
_set_errno(EINVAL);
return false;
}
if (num >= array_size_) {
/* Expand the array. Make it 64 entries bigger than adding entry number.
* NOTE: that we don't check for an overflow here, since we secured
* ourselves from that by enforcing strict sequential order. So, an
* overflow may happen iff number of entries cached in this array is
* close to 4G, which is a) totally unreasonable, and b) we would die
* long before this amount of entries is cached.
*/
Dwarf_AbbrNum new_size = num + 64;
// Reallocate.
const Dwarf_Abbr_DIE** new_array = new const Dwarf_Abbr_DIE*[new_size];
assert(new_array != NULL);
if (new_array == NULL) {
_set_errno(ENOMEM);
return false;
}
memcpy(new_array, array_, count_ * sizeof(const Dwarf_Abbr_DIE*));
if (array_ != &small_array_[0]) {
delete[] array_;
}
array_ = new_array;
array_size_ = new_size;
}
// Abbreviation numbers are 1-based.
array_[num - 1] = abbr;
count_++;
return true;
}
/* Adds new entry to the array
* Param:
* abbr - New entry to add.
* Return:
* true on success, false on failure.
*/
bool add(const Dwarf_Abbr_DIE* abbr) {
return add(abbr, abbr->get_abbr_num());
}
/* Gets an entry from the array
* Param:
* num - 1-based index of an entry to get.
* Return:
* Entry on success, or NULL if num exceeds the number of entries
* contained in the array.
*/
const Dwarf_Abbr_DIE* get(Dwarf_AbbrNum num) const {
assert(num != 0 && num <= count_);
if (num != 0 && num <= count_) {
return array_[num - 1];
} else {
_set_errno(EINVAL);
return NULL;
}
}
/* Caches Dwarf_Abbr_DIEs into this array up to the requested number.
* NOTE: This method cannot be called on an empty array. Usually, first
* entry is inserted into this array when CU object is initialized.
* Param:
* num - Entry number to cache entries up to.
* Return:
* Last cached entry (actually, an entry for the 'num' index).
*/
const Dwarf_Abbr_DIE* cache_to(Dwarf_AbbrNum num) {
/* Last cached DIE abbreviation. We always should have cached at least one
* abbreviation for the CU DIE itself, added via "add" method when CU
* object was initialized. */
const Dwarf_Abbr_DIE* cur_abbr = get(count_);
assert(cur_abbr != NULL);
if (cur_abbr == NULL) {
return NULL;
}
/* Starting with the last cached DIE abbreviation, loop through the
* remaining DIE abbreviations in the .debug_abbrev section of the
* mapped ELF file, caching them until we reach the requested
* abbreviation descriptor number. Normally, the very next DIE
* abbreviation will stop the loop. */
while (num > count_) {
Dwarf_AbbrNum abbr_num;
Dwarf_Tag tmp2;
Dwarf_Form tmp3;
Dwarf_At tmp4;
/* Process all AT abbreviations for the current DIE entry, reaching next
* DIE abbreviation. */
const Dwarf_Abbr_AT* abbr_at = cur_abbr->process(&abbr_num, &tmp2);
while (!abbr_at->is_separator()) {
abbr_at = abbr_at->process(&tmp4, &tmp3);
}
// Next DIE abbreviation is right after the separator AT abbreviation.
cur_abbr = reinterpret_cast<const Dwarf_Abbr_DIE*>
(abbr_at->process(&tmp4, &tmp3));
if (!add(cur_abbr)) {
return NULL;
}
}
return array_[num - 1];
}
/* Empties array and frees allocations. */
void empty() {
if (array_ != &small_array_[0]) {
delete[] array_;
array_ = &small_array_[0];
array_size_ = sizeof(small_array_) / sizeof(small_array_[0]);
}
count_ = 0;
}
protected:
/* Array, preallocated in anticipation of relatively small number of
* DIE abbreviations in compilation unit. */
const Dwarf_Abbr_DIE* small_array_[64];
/* Array of Dwarf_Abbr_DIE pointers, cached for a compilation unit. */
const Dwarf_Abbr_DIE** array_;
/* Current size of the array. */
Dwarf_AbbrNum array_size_;
/* Number of entries, cached in the array. */
Dwarf_AbbrNum count_;
};
/* Encapsulates a state machine for the "Line Number Program", that is run
* on data conained in the mapped .debug_line section.
*/
class DwarfStateMachine {
public:
/* Constructs DwarfStateMachine instance.
* Param:
* set_is_stmt - Matches value of default_is_stmt field in the STMTL header.
* see Dwarf_STMTL_HdrXX.
*/
explicit DwarfStateMachine(bool set_is_stmt)
: address_(0),
file_(1),
line_(1),
column_(0),
discriminator_(0),
is_stmt_(set_is_stmt),
basic_block_(false),
end_sequence_(false),
prologue_end_(false),
epilogue_begin_(false),
isa_(0),
set_file_info_(NULL) {
}
/* Destructs DwarfStateMachine instance. */
~DwarfStateMachine() {
}
/* Resets the state to default.
* Param:
* set_is_stmt - Matches value of default_is_stmt field in the STMTL header.
* see Dwarf_STMTL_HdrXX.
*/
void reset(bool set_is_stmt) {
address_ = 0;
file_ = 1;
line_ = 1;
column_ = 0;
discriminator_ = 0;
is_stmt_ = set_is_stmt;
basic_block_ = false;
end_sequence_ = false;
prologue_end_ = false;
epilogue_begin_ = false;
isa_ = 0;
set_file_info_ = NULL;
}
/*
* Machine state.
*/
/* Current address (current PC value). */
Elf_Xword address_;
/* Current index of source file descriptor. */
Elf_Word file_;
/* Current line in the current source file. */
Elf_Word line_;
/* Current column. */
Elf_Word column_;
/* Current discriminator value. */
Elf_Word discriminator_;
/* Current STMT flag. */
bool is_stmt_;
/* Current basic block flag. */
bool basic_block_;
/* Current end of sequence flag. */
bool end_sequence_;
/* Current end of prologue flag. */
bool prologue_end_;
/* Current epilogue begin flag. */
bool epilogue_begin_;
/* Current ISA value. */
Elf_Word isa_;
/* Current value for explicitly set current source file descriptor.
* If not NULL, this descriptor has priority over the descriptor, addressed
* by the file_ member of this class. */
const Dwarf_STMTL_FileDesc* set_file_info_;
};
/* Checks if given tag belongs to a routine. */
static inline bool
dwarf_tag_is_routine(Dwarf_Tag tag) {
return tag == DW_TAG_inlined_subroutine ||
tag == DW_TAG_subprogram ||
tag == DW_AT_main_subprogram;
}
/* Checks if given tag belongs to a compilation unit. */
static inline bool
dwarf_tag_is_cu(Dwarf_Tag tag) {
return tag == DW_TAG_compile_unit ||
tag == DW_TAG_partial_unit;
}
#endif // ELFF_DWARF_DEFS_H_
|