LLVM  8.0.0svn
DWARFVerifier.h
Go to the documentation of this file.
1 //===- DWARFVerifier.h ----------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
11 #define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
12 
18 
19 #include <cstdint>
20 #include <map>
21 #include <set>
22 
23 namespace llvm {
24 class raw_ostream;
25 struct DWARFAttribute;
26 class DWARFContext;
27 class DWARFDie;
28 class DWARFUnit;
29 class DWARFCompileUnit;
30 class DWARFDataExtractor;
31 class DWARFDebugAbbrev;
32 class DataExtractor;
33 struct DWARFSection;
34 
35 /// A class that verifies DWARF debug information given a DWARF Context.
37 public:
38  /// A class that keeps the address range information for a single DIE.
39  struct DieRangeInfo {
41 
42  /// Sorted DWARFAddressRanges.
43  std::vector<DWARFAddressRange> Ranges;
44 
45  /// Sorted DWARFAddressRangeInfo.
46  std::set<DieRangeInfo> Children;
47 
48  DieRangeInfo() = default;
49  DieRangeInfo(DWARFDie Die) : Die(Die) {}
50 
51  /// Used for unit testing.
52  DieRangeInfo(std::vector<DWARFAddressRange> Ranges)
53  : Ranges(std::move(Ranges)) {}
54 
55  typedef std::vector<DWARFAddressRange>::const_iterator
57  typedef std::set<DieRangeInfo>::const_iterator die_range_info_iterator;
58 
59  /// Inserts the address range. If the range overlaps with an existing
60  /// range, the range is *not* added and an iterator to the overlapping
61  /// range is returned.
62  ///
63  /// This is used for finding overlapping ranges within the same DIE.
65 
66  /// Finds an address range in the sorted vector of ranges.
68  auto Begin = Ranges.begin();
69  auto End = Ranges.end();
70  auto Iter = std::upper_bound(Begin, End, R);
71  if (Iter != Begin)
72  --Iter;
73  return Iter;
74  }
75 
76  /// Inserts the address range info. If any of its ranges overlaps with a
77  /// range in an existing range info, the range info is *not* added and an
78  /// iterator to the overlapping range info.
79  ///
80  /// This is used for finding overlapping children of the same DIE.
81  die_range_info_iterator insert(const DieRangeInfo &RI);
82 
83  /// Return true if ranges in this object contains all ranges within RHS.
84  bool contains(const DieRangeInfo &RHS) const;
85 
86  /// Return true if any range in this object intersects with any range in
87  /// RHS.
88  bool intersects(const DieRangeInfo &RHS) const;
89  };
90 
91 private:
92  raw_ostream &OS;
93  DWARFContext &DCtx;
94  DIDumpOptions DumpOpts;
95  /// A map that tracks all references (converted absolute references) so we
96  /// can verify each reference points to a valid DIE and not an offset that
97  /// lies between to valid DIEs.
98  std::map<uint64_t, std::set<uint32_t>> ReferenceToDIEOffsets;
99  uint32_t NumDebugLineErrors = 0;
100 
101  raw_ostream &error() const;
102  raw_ostream &warn() const;
103  raw_ostream &note() const;
104  raw_ostream &dump(const DWARFDie &Die, unsigned indent = 0) const;
105 
106  /// Verifies the abbreviations section.
107  ///
108  /// This function currently checks that:
109  /// --No abbreviation declaration has more than one attributes with the same
110  /// name.
111  ///
112  /// \param Abbrev Pointer to the abbreviations section we are verifying
113  /// Abbrev can be a pointer to either .debug_abbrev or debug_abbrev.dwo.
114  ///
115  /// \returns The number of errors that occurred during verification.
116  unsigned verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev);
117 
118  /// Verifies the header of a unit in a .debug_info or .debug_types section.
119  ///
120  /// This function currently checks for:
121  /// - Unit is in 32-bit DWARF format. The function can be modified to
122  /// support 64-bit format.
123  /// - The DWARF version is valid
124  /// - The unit type is valid (if unit is in version >=5)
125  /// - The unit doesn't extend beyond the containing section
126  /// - The address size is valid
127  /// - The offset in the .debug_abbrev section is valid
128  ///
129  /// \param DebugInfoData The section data
130  /// \param Offset A reference to the offset start of the unit. The offset will
131  /// be updated to point to the next unit in the section
132  /// \param UnitIndex The index of the unit to be verified
133  /// \param UnitType A reference to the type of the unit
134  /// \param isUnitDWARF64 A reference to a flag that shows whether the unit is
135  /// in 64-bit format.
136  ///
137  /// \returns true if the header is verified successfully, false otherwise.
138  bool verifyUnitHeader(const DWARFDataExtractor DebugInfoData,
139  uint32_t *Offset, unsigned UnitIndex, uint8_t &UnitType,
140  bool &isUnitDWARF64);
141 
142  /// Verifies the header of a unit in a .debug_info or .debug_types section.
143  ///
144  /// This function currently verifies:
145  /// - The debug info attributes.
146  /// - The debug info form=s.
147  /// - The presence of a root DIE.
148  /// - That the root DIE is a unit DIE.
149  /// - If a unit type is provided, that the unit DIE matches the unit type.
150  /// - The DIE ranges.
151  /// - That call site entries are only nested within subprograms with a
152  /// DW_AT_call attribute.
153  ///
154  /// \param Unit The DWARF Unit to verify.
155  ///
156  /// \returns The number of errors that occurred during verification.
157  unsigned verifyUnitContents(DWARFUnit &Unit);
158 
159  /// Verifies the unit headers and contents in a .debug_info or .debug_types
160  /// section.
161  ///
162  /// \param S The DWARF Section to verify.
163  /// \param SectionKind The object-file section kind that S comes from.
164  ///
165  /// \returns The number of errors that occurred during verification.
166  unsigned verifyUnitSection(const DWARFSection &S,
168 
169  /// Verifies that a call site entry is nested within a subprogram with a
170  /// DW_AT_call attribute.
171  ///
172  /// \returns Number of errors that occurred during verification.
173  unsigned verifyDebugInfoCallSite(const DWARFDie &Die);
174 
175  /// Verify that all Die ranges are valid.
176  ///
177  /// This function currently checks for:
178  /// - cases in which lowPC >= highPC
179  ///
180  /// \returns Number of errors that occurred during verification.
181  unsigned verifyDieRanges(const DWARFDie &Die, DieRangeInfo &ParentRI);
182 
183  /// Verifies the attribute's DWARF attribute and its value.
184  ///
185  /// This function currently checks for:
186  /// - DW_AT_ranges values is a valid .debug_ranges offset
187  /// - DW_AT_stmt_list is a valid .debug_line offset
188  ///
189  /// \param Die The DWARF DIE that owns the attribute value
190  /// \param AttrValue The DWARF attribute value to check
191  ///
192  /// \returns NumErrors The number of errors occurred during verification of
193  /// attributes' values in a unit
194  unsigned verifyDebugInfoAttribute(const DWARFDie &Die,
195  DWARFAttribute &AttrValue);
196 
197  /// Verifies the attribute's DWARF form.
198  ///
199  /// This function currently checks for:
200  /// - All DW_FORM_ref values that are CU relative have valid CU offsets
201  /// - All DW_FORM_ref_addr values have valid section offsets
202  /// - All DW_FORM_strp values have valid .debug_str offsets
203  ///
204  /// \param Die The DWARF DIE that owns the attribute value
205  /// \param AttrValue The DWARF attribute value to check
206  ///
207  /// \returns NumErrors The number of errors occurred during verification of
208  /// attributes' forms in a unit
209  unsigned verifyDebugInfoForm(const DWARFDie &Die, DWARFAttribute &AttrValue);
210 
211  /// Verifies the all valid references that were found when iterating through
212  /// all of the DIE attributes.
213  ///
214  /// This function will verify that all references point to DIEs whose DIE
215  /// offset matches. This helps to ensure if a DWARF link phase moved things
216  /// around, that it doesn't create invalid references by failing to relocate
217  /// CU relative and absolute references.
218  ///
219  /// \returns NumErrors The number of errors occurred during verification of
220  /// references for the .debug_info and .debug_types sections
221  unsigned verifyDebugInfoReferences();
222 
223  /// Verify the DW_AT_stmt_list encoding and value and ensure that no
224  /// compile units that have the same DW_AT_stmt_list value.
225  void verifyDebugLineStmtOffsets();
226 
227  /// Verify that all of the rows in the line table are valid.
228  ///
229  /// This function currently checks for:
230  /// - addresses within a sequence that decrease in value
231  /// - invalid file indexes
232  void verifyDebugLineRows();
233 
234  /// Verify that an Apple-style accelerator table is valid.
235  ///
236  /// This function currently checks that:
237  /// - The fixed part of the header fits in the section
238  /// - The size of the section is as large as what the header describes
239  /// - There is at least one atom
240  /// - The form for each atom is valid
241  /// - The tag for each DIE in the table is valid
242  /// - The buckets have a valid index, or they are empty
243  /// - Each hashdata offset is valid
244  /// - Each DIE is valid
245  ///
246  /// \param AccelSection pointer to the section containing the acceleration table
247  /// \param StrData pointer to the string section
248  /// \param SectionName the name of the table we're verifying
249  ///
250  /// \returns The number of errors occurred during verification
251  unsigned verifyAppleAccelTable(const DWARFSection *AccelSection,
252  DataExtractor *StrData,
253  const char *SectionName);
254 
255  unsigned verifyDebugNamesCULists(const DWARFDebugNames &AccelTable);
256  unsigned verifyNameIndexBuckets(const DWARFDebugNames::NameIndex &NI,
257  const DataExtractor &StrData);
258  unsigned verifyNameIndexAbbrevs(const DWARFDebugNames::NameIndex &NI);
259  unsigned verifyNameIndexAttribute(const DWARFDebugNames::NameIndex &NI,
260  const DWARFDebugNames::Abbrev &Abbr,
262  unsigned verifyNameIndexEntries(const DWARFDebugNames::NameIndex &NI,
264  unsigned verifyNameIndexCompleteness(const DWARFDie &Die,
265  const DWARFDebugNames::NameIndex &NI);
266 
267  /// Verify that the DWARF v5 accelerator table is valid.
268  ///
269  /// This function currently checks that:
270  /// - Headers individual Name Indices fit into the section and can be parsed.
271  /// - Abbreviation tables can be parsed and contain valid index attributes
272  /// with correct form encodings.
273  /// - The CU lists reference existing compile units.
274  /// - The buckets have a valid index, or they are empty.
275  /// - All names are reachable via the hash table (they have the correct hash,
276  /// and the hash is in the correct bucket).
277  /// - Information in the index entries is complete (all required entries are
278  /// present) and consistent with the debug_info section DIEs.
279  ///
280  /// \param AccelSection section containing the acceleration table
281  /// \param StrData string section
282  ///
283  /// \returns The number of errors occurred during verification
284  unsigned verifyDebugNames(const DWARFSection &AccelSection,
285  const DataExtractor &StrData);
286 
287 public:
290  : OS(S), DCtx(D), DumpOpts(std::move(DumpOpts)) {}
291  /// Verify the information in any of the following sections, if available:
292  /// .debug_abbrev, debug_abbrev.dwo
293  ///
294  /// Any errors are reported to the stream that was this object was
295  /// constructed with.
296  ///
297  /// \returns true if .debug_abbrev and .debug_abbrev.dwo verify successfully,
298  /// false otherwise.
299  bool handleDebugAbbrev();
300 
301  /// Verify the information in the .debug_info and .debug_types sections.
302  ///
303  /// Any errors are reported to the stream that this object was
304  /// constructed with.
305  ///
306  /// \returns true if all sections verify successfully, false otherwise.
307  bool handleDebugInfo();
308 
309  /// Verify the information in the .debug_line section.
310  ///
311  /// Any errors are reported to the stream that was this object was
312  /// constructed with.
313  ///
314  /// \returns true if the .debug_line verifies successfully, false otherwise.
315  bool handleDebugLine();
316 
317  /// Verify the information in accelerator tables, if they exist.
318  ///
319  /// Any errors are reported to the stream that was this object was
320  /// constructed with.
321  ///
322  /// \returns true if the existing Apple-style accelerator tables verify
323  /// successfully, false otherwise.
324  bool handleAccelTables();
325 };
326 
327 static inline bool operator<(const DWARFVerifier::DieRangeInfo &LHS,
328  const DWARFVerifier::DieRangeInfo &RHS) {
329  return std::tie(LHS.Ranges, LHS.Die) < std::tie(RHS.Ranges, RHS.Die);
330 }
331 
332 } // end namespace llvm
333 
334 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buck...
Definition: AccelTable.h:199
bool handleDebugLine()
Verify the information in the .debug_line section.
#define error(X)
Abbreviation describing the encoding of Name Index entries.
bool handleDebugInfo()
Verify the information in the .debug_info and .debug_types sections.
Definition: BitVector.h:938
Index attribute and its encoding.
std::set< DieRangeInfo > Children
Sorted DWARFAddressRangeInfo.
Definition: DWARFVerifier.h:46
std::vector< DWARFAddressRange > Ranges
Sorted DWARFAddressRanges.
Definition: DWARFVerifier.h:43
Encapsulates a DWARF attribute value and all of the data required to describe the attribute value...
Represents a single accelerator table within the Dwarf 5 .debug_names section.
Container for dump options that control which debug information will be dumped.
Definition: DIContext.h:154
address_range_iterator findRange(const DWARFAddressRange &R) const
Finds an address range in the sorted vector of ranges.
Definition: DWARFVerifier.h:67
Utility class that carries the DWARF compile/type unit and the debug info entry in an object...
Definition: DWARFDie.h:43
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
DWARFSectionKind
bool handleDebugAbbrev()
Verify the information in any of the following sections, if available: .debug_abbrev, debug_abbrev.dwo.
A class that keeps the address range information for a single DIE.
Definition: DWARFVerifier.h:39
bool contains(const DieRangeInfo &RHS) const
Return true if ranges in this object contains all ranges within RHS.
DieRangeInfo(std::vector< DWARFAddressRange > Ranges)
Used for unit testing.
Definition: DWARFVerifier.h:52
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:23
std::vector< DWARFAddressRange >::const_iterator address_range_iterator
Definition: DWARFVerifier.h:56
UnitType
Constants for unit types in DWARF v5.
Definition: Dwarf.h:327
A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for...
.debug_names section consists of one or more units.
A single entry in the Name Table (Dwarf 5 sect.
address_range_iterator insert(const DWARFAddressRange &R)
Inserts the address range.
DWARFContext This data structure is the top level entity that deals with dwarf debug information pars...
Definition: DWARFContext.h:59
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
bool intersects(const DieRangeInfo &RHS) const
Return true if any range in this object intersects with any range in RHS.
A class that verifies DWARF debug information given a DWARF Context.
Definition: DWARFVerifier.h:36
DWARFVerifier(raw_ostream &S, DWARFContext &D, DIDumpOptions DumpOpts=DIDumpOptions::getForSingleDIE())
bool handleAccelTables()
Verify the information in accelerator tables, if they exist.
std::set< DieRangeInfo >::const_iterator die_range_info_iterator
Definition: DWARFVerifier.h:57
static DIDumpOptions getForSingleDIE()
Return default option set for printing a single DIE without children.
Definition: DIContext.h:168
auto upper_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range))
Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1151
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:326
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46