1 //===- DWARFVerifier.cpp --------------------------------------------------===//
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 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
11 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
12 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
13 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
14 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
15 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
16 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
17 #include "llvm/Support/raw_ostream.h"
18 #include <map>
19 #include <set>
20 #include <vector>
21 
22 using namespace llvm;
23 using namespace dwarf;
24 using namespace object;
25 
26 void DWARFVerifier::verifyDebugInfoAttribute(const DWARFDie &Die,
27                                              DWARFAttribute &AttrValue) {
28   const auto Attr = AttrValue.Attr;
29   switch (Attr) {
30   case DW_AT_ranges:
31     // Make sure the offset in the DW_AT_ranges attribute is valid.
32     if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
33       if (*SectionOffset >= DCtx.getRangeSection().Data.size()) {
34         ++NumDebugInfoErrors;
35         OS << "error: DW_AT_ranges offset is beyond .debug_ranges "
36               "bounds:\n";
37         Die.dump(OS, 0);
38         OS << "\n";
39       }
40     } else {
41       ++NumDebugInfoErrors;
42       OS << "error: DIE has invalid DW_AT_ranges encoding:\n";
43       Die.dump(OS, 0);
44       OS << "\n";
45     }
46     break;
47   case DW_AT_stmt_list:
48     // Make sure the offset in the DW_AT_stmt_list attribute is valid.
49     if (auto SectionOffset = AttrValue.Value.getAsSectionOffset()) {
50       if (*SectionOffset >= DCtx.getLineSection().Data.size()) {
51         ++NumDebugInfoErrors;
52         OS << "error: DW_AT_stmt_list offset is beyond .debug_line "
53               "bounds: "
54            << format("0x%08" PRIx32, *SectionOffset) << "\n";
55         Die.dump(OS, 0);
56         OS << "\n";
57       }
58     } else {
59       ++NumDebugInfoErrors;
60       OS << "error: DIE has invalid DW_AT_stmt_list encoding:\n";
61       Die.dump(OS, 0);
62       OS << "\n";
63     }
64     break;
65 
66   default:
67     break;
68   }
69 }
70 
71 void DWARFVerifier::verifyDebugInfoForm(const DWARFDie &Die,
72                                         DWARFAttribute &AttrValue) {
73   const auto Form = AttrValue.Value.getForm();
74   switch (Form) {
75   case DW_FORM_ref1:
76   case DW_FORM_ref2:
77   case DW_FORM_ref4:
78   case DW_FORM_ref8:
79   case DW_FORM_ref_udata: {
80     // Verify all CU relative references are valid CU offsets.
81     Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
82     assert(RefVal);
83     if (RefVal) {
84       auto DieCU = Die.getDwarfUnit();
85       auto CUSize = DieCU->getNextUnitOffset() - DieCU->getOffset();
86       auto CUOffset = AttrValue.Value.getRawUValue();
87       if (CUOffset >= CUSize) {
88         ++NumDebugInfoErrors;
89         OS << "error: " << FormEncodingString(Form) << " CU offset "
90            << format("0x%08" PRIx32, CUOffset)
91            << " is invalid (must be less than CU size of "
92            << format("0x%08" PRIx32, CUSize) << "):\n";
93         Die.dump(OS, 0);
94         OS << "\n";
95       } else {
96         // Valid reference, but we will verify it points to an actual
97         // DIE later.
98         ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
99       }
100     }
101     break;
102   }
103   case DW_FORM_ref_addr: {
104     // Verify all absolute DIE references have valid offsets in the
105     // .debug_info section.
106     Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
107     assert(RefVal);
108     if (RefVal) {
109       if (*RefVal >= DCtx.getInfoSection().Data.size()) {
110         ++NumDebugInfoErrors;
111         OS << "error: DW_FORM_ref_addr offset beyond .debug_info "
112               "bounds:\n";
113         Die.dump(OS, 0);
114         OS << "\n";
115       } else {
116         // Valid reference, but we will verify it points to an actual
117         // DIE later.
118         ReferenceToDIEOffsets[*RefVal].insert(Die.getOffset());
119       }
120     }
121     break;
122   }
123   case DW_FORM_strp: {
124     auto SecOffset = AttrValue.Value.getAsSectionOffset();
125     assert(SecOffset); // DW_FORM_strp is a section offset.
126     if (SecOffset && *SecOffset >= DCtx.getStringSection().size()) {
127       ++NumDebugInfoErrors;
128       OS << "error: DW_FORM_strp offset beyond .debug_str bounds:\n";
129       Die.dump(OS, 0);
130       OS << "\n";
131     }
132     break;
133   }
134   default:
135     break;
136   }
137 }
138 
139 void DWARFVerifier::verifyDebugInfoReferences() {
140   // Take all references and make sure they point to an actual DIE by
141   // getting the DIE by offset and emitting an error
142   OS << "Verifying .debug_info references...\n";
143   for (auto Pair : ReferenceToDIEOffsets) {
144     auto Die = DCtx.getDIEForOffset(Pair.first);
145     if (Die)
146       continue;
147     ++NumDebugInfoErrors;
148     OS << "error: invalid DIE reference " << format("0x%08" PRIx64, Pair.first)
149        << ". Offset is in between DIEs:\n";
150     for (auto Offset : Pair.second) {
151       auto ReferencingDie = DCtx.getDIEForOffset(Offset);
152       ReferencingDie.dump(OS, 0);
153       OS << "\n";
154     }
155     OS << "\n";
156   }
157 }
158 
159 bool DWARFVerifier::handleDebugInfo() {
160   NumDebugInfoErrors = 0;
161   OS << "Verifying .debug_info...\n";
162   for (const auto &CU : DCtx.compile_units()) {
163     unsigned NumDies = CU->getNumDIEs();
164     for (unsigned I = 0; I < NumDies; ++I) {
165       auto Die = CU->getDIEAtIndex(I);
166       const auto Tag = Die.getTag();
167       if (Tag == DW_TAG_null)
168         continue;
169       for (auto AttrValue : Die.attributes()) {
170         verifyDebugInfoAttribute(Die, AttrValue);
171         verifyDebugInfoForm(Die, AttrValue);
172       }
173     }
174   }
175   verifyDebugInfoReferences();
176   return NumDebugInfoErrors == 0;
177 }
178 
179 void DWARFVerifier::verifyDebugLineStmtOffsets() {
180   std::map<uint64_t, DWARFDie> StmtListToDie;
181   for (const auto &CU : DCtx.compile_units()) {
182     auto Die = CU->getUnitDIE();
183     // Get the attribute value as a section offset. No need to produce an
184     // error here if the encoding isn't correct because we validate this in
185     // the .debug_info verifier.
186     auto StmtSectionOffset = toSectionOffset(Die.find(DW_AT_stmt_list));
187     if (!StmtSectionOffset)
188       continue;
189     const uint32_t LineTableOffset = *StmtSectionOffset;
190     auto LineTable = DCtx.getLineTableForUnit(CU.get());
191     if (LineTableOffset < DCtx.getLineSection().Data.size()) {
192       if (!LineTable) {
193         ++NumDebugLineErrors;
194         OS << "error: .debug_line[" << format("0x%08" PRIx32, LineTableOffset)
195            << "] was not able to be parsed for CU:\n";
196         Die.dump(OS, 0);
197         OS << '\n';
198         continue;
199       }
200     } else {
201       // Make sure we don't get a valid line table back if the offset is wrong.
202       assert(LineTable == nullptr);
203       // Skip this line table as it isn't valid. No need to create an error
204       // here because we validate this in the .debug_info verifier.
205       continue;
206     }
207     auto Iter = StmtListToDie.find(LineTableOffset);
208     if (Iter != StmtListToDie.end()) {
209       ++NumDebugLineErrors;
210       OS << "error: two compile unit DIEs, "
211          << format("0x%08" PRIx32, Iter->second.getOffset()) << " and "
212          << format("0x%08" PRIx32, Die.getOffset())
213          << ", have the same DW_AT_stmt_list section offset:\n";
214       Iter->second.dump(OS, 0);
215       Die.dump(OS, 0);
216       OS << '\n';
217       // Already verified this line table before, no need to do it again.
218       continue;
219     }
220     StmtListToDie[LineTableOffset] = Die;
221   }
222 }
223 
224 void DWARFVerifier::verifyDebugLineRows() {
225   for (const auto &CU : DCtx.compile_units()) {
226     auto Die = CU->getUnitDIE();
227     auto LineTable = DCtx.getLineTableForUnit(CU.get());
228     // If there is no line table we will have created an error in the
229     // .debug_info verifier or in verifyDebugLineStmtOffsets().
230     if (!LineTable)
231       continue;
232     uint32_t MaxFileIndex = LineTable->Prologue.FileNames.size();
233     uint64_t PrevAddress = 0;
234     uint32_t RowIndex = 0;
235     for (const auto &Row : LineTable->Rows) {
236       if (Row.Address < PrevAddress) {
237         ++NumDebugLineErrors;
238         OS << "error: .debug_line["
239            << format("0x%08" PRIx32,
240                      *toSectionOffset(Die.find(DW_AT_stmt_list)))
241            << "] row[" << RowIndex
242            << "] decreases in address from previous row:\n";
243 
244         DWARFDebugLine::Row::dumpTableHeader(OS);
245         if (RowIndex > 0)
246           LineTable->Rows[RowIndex - 1].dump(OS);
247         Row.dump(OS);
248         OS << '\n';
249       }
250 
251       if (Row.File > MaxFileIndex) {
252         ++NumDebugLineErrors;
253         OS << "error: .debug_line["
254            << format("0x%08" PRIx32,
255                      *toSectionOffset(Die.find(DW_AT_stmt_list)))
256            << "][" << RowIndex << "] has invalid file index " << Row.File
257            << " (valid values are [1," << MaxFileIndex << "]):\n";
258         DWARFDebugLine::Row::dumpTableHeader(OS);
259         Row.dump(OS);
260         OS << '\n';
261       }
262       if (Row.EndSequence)
263         PrevAddress = 0;
264       else
265         PrevAddress = Row.Address;
266       ++RowIndex;
267     }
268   }
269 }
270 
271 bool DWARFVerifier::handleDebugLine() {
272   NumDebugLineErrors = 0;
273   OS << "Verifying .debug_line...\n";
274   verifyDebugLineStmtOffsets();
275   verifyDebugLineRows();
276   return NumDebugLineErrors == 0;
277 }
278