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
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- DWARFUnitIndex.h -----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_DWARF_DWARFUNITINDEX_H
#define LLVM_DEBUGINFO_DWARF_DWARFUNITINDEX_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include <cstdint>
#include <memory>
namespace llvm {
class raw_ostream;
class DataExtractor;
/// The enum of section identifiers to be used in internal interfaces.
///
/// Pre-standard implementation of package files defined a number of section
/// identifiers with values that clash definitions in the DWARFv5 standard.
/// See https://gcc.gnu.org/wiki/DebugFissionDWP and Section 7.3.5.3 in DWARFv5.
///
/// The following identifiers are the same in the proposal and in DWARFv5:
/// - DW_SECT_INFO = 1 (.debug_info.dwo)
/// - DW_SECT_ABBREV = 3 (.debug_abbrev.dwo)
/// - DW_SECT_LINE = 4 (.debug_line.dwo)
/// - DW_SECT_STR_OFFSETS = 6 (.debug_str_offsets.dwo)
///
/// The following identifiers are defined only in DWARFv5:
/// - DW_SECT_LOCLISTS = 5 (.debug_loclists.dwo)
/// - DW_SECT_RNGLISTS = 8 (.debug_rnglists.dwo)
///
/// The following identifiers are defined only in the GNU proposal:
/// - DW_SECT_TYPES = 2 (.debug_types.dwo)
/// - DW_SECT_LOC = 5 (.debug_loc.dwo)
/// - DW_SECT_MACINFO = 7 (.debug_macinfo.dwo)
///
/// DW_SECT_MACRO for the .debug_macro.dwo section is defined in both standards,
/// but with different values, 8 in GNU and 7 in DWARFv5.
///
/// This enum defines constants to represent the identifiers of both sets.
/// For DWARFv5 ones, the values are the same as defined in the standard.
/// For pre-standard ones that correspond to sections being deprecated in
/// DWARFv5, the values are chosen arbitrary and a tag "_EXT_" is added to
/// the names.
///
/// The enum is for internal use only. The user should not expect the values
/// to correspond to any input/output constants. Special conversion functions,
/// serializeSectionKind() and deserializeSectionKind(), should be used for
/// the translation.
enum DWARFSectionKind {
/// Denotes a value read from an index section that does not correspond
/// to any of the supported standards.
DW_SECT_EXT_unknown = 0,
#define HANDLE_DW_SECT(ID, NAME) DW_SECT_##NAME = ID,
#include "llvm/BinaryFormat/Dwarf.def"
DW_SECT_EXT_TYPES = 2,
DW_SECT_EXT_LOC = 9,
DW_SECT_EXT_MACINFO = 10,
};
inline const char *toString(DWARFSectionKind Kind) {
switch (Kind) {
case DW_SECT_EXT_unknown:
return "Unknown DW_SECT value 0";
#define STRINGIZE(X) #X
#define HANDLE_DW_SECT(ID, NAME) \
case DW_SECT_##NAME: \
return "DW_SECT_" STRINGIZE(NAME);
#include "llvm/BinaryFormat/Dwarf.def"
case DW_SECT_EXT_TYPES:
return "DW_SECT_TYPES";
case DW_SECT_EXT_LOC:
return "DW_SECT_LOC";
case DW_SECT_EXT_MACINFO:
return "DW_SECT_MACINFO";
}
llvm_unreachable("unknown DWARFSectionKind");
}
/// Convert the internal value for a section kind to an on-disk value.
///
/// The conversion depends on the version of the index section.
/// IndexVersion is expected to be either 2 for pre-standard GNU proposal
/// or 5 for DWARFv5 package file.
uint32_t serializeSectionKind(DWARFSectionKind Kind, unsigned IndexVersion);
/// Convert a value read from an index section to the internal representation.
///
/// The conversion depends on the index section version, which is expected
/// to be either 2 for pre-standard GNU proposal or 5 for DWARFv5 package file.
DWARFSectionKind deserializeSectionKind(uint32_t Value, unsigned IndexVersion);
class DWARFUnitIndex {
struct Header {
uint32_t Version;
uint32_t NumColumns;
uint32_t NumUnits;
uint32_t NumBuckets = 0;
bool parse(DataExtractor IndexData, uint64_t *OffsetPtr);
void dump(raw_ostream &OS) const;
};
public:
class Entry {
public:
class SectionContribution {
private:
uint64_t Offset;
uint64_t Length;
public:
SectionContribution() : Offset(0), Length(0) {}
SectionContribution(uint64_t Offset, uint64_t Length)
: Offset(Offset), Length(Length) {}
void setOffset(uint64_t Value) { Offset = Value; }
void setLength(uint64_t Value) { Length = Value; }
uint64_t getOffset() const { return Offset; }
uint64_t getLength() const { return Length; }
uint32_t getOffset32() const { return (uint32_t)Offset; }
uint32_t getLength32() const { return (uint32_t)Length; }
};
private:
const DWARFUnitIndex *Index;
uint64_t Signature;
std::unique_ptr<SectionContribution[]> Contributions;
friend class DWARFUnitIndex;
public:
const SectionContribution *getContribution(DWARFSectionKind Sec) const;
const SectionContribution *getContribution() const;
SectionContribution &getContribution();
const SectionContribution *getContributions() const {
return Contributions.get();
}
uint64_t getSignature() const { return Signature; }
bool isValid() { return Index; }
};
private:
struct Header Header;
DWARFSectionKind InfoColumnKind;
int InfoColumn = -1;
std::unique_ptr<DWARFSectionKind[]> ColumnKinds;
// This is a parallel array of section identifiers as they read from the input
// file. The mapping from raw values to DWARFSectionKind is not revertable in
// case of unknown identifiers, so we keep them here.
std::unique_ptr<uint32_t[]> RawSectionIds;
std::unique_ptr<Entry[]> Rows;
mutable std::vector<Entry *> OffsetLookup;
static StringRef getColumnHeader(DWARFSectionKind DS);
bool parseImpl(DataExtractor IndexData);
public:
DWARFUnitIndex(DWARFSectionKind InfoColumnKind)
: InfoColumnKind(InfoColumnKind) {}
explicit operator bool() const { return Header.NumBuckets; }
bool parse(DataExtractor IndexData);
void dump(raw_ostream &OS) const;
uint32_t getVersion() const { return Header.Version; }
const Entry *getFromOffset(uint64_t Offset) const;
const Entry *getFromHash(uint64_t Offset) const;
ArrayRef<DWARFSectionKind> getColumnKinds() const {
return ArrayRef(ColumnKinds.get(), Header.NumColumns);
}
ArrayRef<Entry> getRows() const {
return ArrayRef(Rows.get(), Header.NumBuckets);
}
MutableArrayRef<Entry> getMutableRows() {
return MutableArrayRef(Rows.get(), Header.NumBuckets);
}
};
} // end namespace llvm
#endif // LLVM_DEBUGINFO_DWARF_DWARFUNITINDEX_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
