Debian Codegraph @

llvm-project/llvm/unittests/DebugInfo/LogicalView/ELFReaderTest.cpp

raw
1 //===- llvm/unittest/DebugInfo/LogicalView/ELFReaderTest.cpp --------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
10 #include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
11 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
12 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
13 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
14 #include "llvm/DebugInfo/LogicalView/LVReaderHandler.h"
15 #include "llvm/MC/TargetRegistry.h"
16 #include "llvm/Support/COM.h"
17 #include "llvm/Support/InitLLVM.h"
18 #include "llvm/Support/ScopedPrinter.h"
19 #include "llvm/Support/TargetSelect.h"
20 #include "llvm/Support/ToolOutputFile.h"
21 #include "llvm/Testing/Support/Error.h"
22
23 #include "gtest/gtest.h"
24
25 using namespace llvm;
26 using namespace llvm::logicalview;
27
28 extern const char *TestMainArgv0;
29
30 namespace {
31
32 const char *DwarfClang = "test-dwarf-clang.o";
33 const char *DwarfGcc = "test-dwarf-gcc.o";
34
35 // Helper function to get the first compile unit.
36 LVScopeCompileUnit *getFirstCompileUnit(LVScopeRoot *Root) {
37 EXPECT_NE(Root, nullptr);
38 const LVScopes *CompileUnits = Root->getScopes();
39 EXPECT_NE(CompileUnits, nullptr);
40 EXPECT_EQ(CompileUnits->size(), 1u);
41
42 LVScopes::const_iterator Iter = CompileUnits->begin();
43 EXPECT_NE(Iter, nullptr);
44 LVScopeCompileUnit *CompileUnit = static_cast<LVScopeCompileUnit *>(*Iter);
45 EXPECT_NE(CompileUnit, nullptr);
46 return CompileUnit;
47 }
48
49 // Helper function to create a reader.
50 LVReader *createReader(LVReaderHandler &ReaderHandler,
51 SmallString<128> &InputsDir, StringRef Filename) {
52 SmallString<128> ObjectName(InputsDir);
53 llvm::sys::path::append(ObjectName, Filename);
54
55 Expected<LVReader *> ReaderOrErr =
56 ReaderHandler.createReader(std::string(ObjectName));
57 EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
58 LVReader *Reader = *ReaderOrErr;
59 EXPECT_NE(Reader, nullptr);
60 return Reader;
61 }
62
63 // Check the logical elements basic properties.
64 void checkElementProperties(LVReader *Reader) {
65 LVScopeRoot *Root = Reader->getScopesRoot();
66 LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);
67
68 EXPECT_EQ(Root->getFileFormatName(), "elf64-x86-64");
69 EXPECT_EQ(Root->getName(), DwarfClang);
70
71 EXPECT_EQ(CompileUnit->getBaseAddress(), 0u);
72 EXPECT_TRUE(CompileUnit->getProducer().startswith("clang"));
73 EXPECT_EQ(CompileUnit->getName(), "test.cpp");
74
75 EXPECT_EQ(CompileUnit->lineCount(), 0u);
76 EXPECT_EQ(CompileUnit->scopeCount(), 1u);
77 EXPECT_EQ(CompileUnit->symbolCount(), 0u);
78 EXPECT_EQ(CompileUnit->typeCount(), 7u);
79 EXPECT_EQ(CompileUnit->rangeCount(), 1u);
80
81 const LVLocations *Ranges = CompileUnit->getRanges();
82 ASSERT_NE(Ranges, nullptr);
83 ASSERT_EQ(Ranges->size(), 1u);
84 LVLocations::const_iterator IterLocation = Ranges->begin();
85 LVLocation *Location = (*IterLocation);
86 EXPECT_STREQ(Location->getIntervalInfo().c_str(),
87 "{Range} Lines 2:9 [0x0000000000:0x000000003a]");
88
89 LVRange RangeList;
90 CompileUnit->getRanges(RangeList);
91
92 const LVRangeEntries &RangeEntries = RangeList.getEntries();
93 ASSERT_EQ(RangeEntries.size(), 2u);
94 LVRangeEntries::const_iterator IterRanges = RangeEntries.cbegin();
95 LVRangeEntry RangeEntry = *IterRanges;
96 EXPECT_EQ(RangeEntry.lower(), 0u);
97 EXPECT_EQ(RangeEntry.upper(), 0x3au);
98 EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
99 EXPECT_EQ(RangeEntry.scope()->getName(), "test.cpp");
100 EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x0bu);
101
102 ++IterRanges;
103 RangeEntry = *IterRanges;
104 EXPECT_EQ(RangeEntry.lower(), 0x1cu);
105 EXPECT_EQ(RangeEntry.upper(), 0x2fu);
106 EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
107 EXPECT_EQ(RangeEntry.scope()->getName(), "foo::?");
108 EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x71u);
109
110 const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
111 ASSERT_EQ(PublicNames.size(), 1u);
112 LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
113 LVScope *Function = (*IterNames).first;
114 EXPECT_EQ(Function->getName(), "foo");
115 EXPECT_EQ(Function->getLineNumber(), 2u);
116 LVNameInfo NameInfo = (*IterNames).second;
117 EXPECT_EQ(NameInfo.first, 0u);
118 EXPECT_EQ(NameInfo.second, 0x3au);
119
120 // Lines (debug and assembler) for 'foo'.
121 const LVLines *Lines = Function->getLines();
122 ASSERT_NE(Lines, nullptr);
123 ASSERT_EQ(Lines->size(), 0x12u);
124 }
125
126 // Check the logical elements selection.
127 void checkElementSelection(LVReader *Reader) {
128 LVScopeRoot *Root = Reader->getScopesRoot();
129 LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);
130
131 // Get the matched elements.
132 LVElements MatchedElements = CompileUnit->getMatchedElements();
133 std::map<LVOffset, LVElement *> MapElements;
134 for (LVElement *Element : MatchedElements)
135 MapElements[Element->getOffset()] = Element;
136 ASSERT_EQ(MapElements.size(), 0xeu);
137
138 LVElement *Element = MapElements[0x000000004b]; // 'foo'
139 ASSERT_NE(Element, nullptr);
140 EXPECT_NE(Element->getName().find("foo"), StringRef::npos);
141 EXPECT_EQ(Element->getIsScope(), 1);
142
143 Element = MapElements[0x00000000c0]; // 'CONSTANT'
144 ASSERT_NE(Element, nullptr);
145 EXPECT_NE(Element->getName().find("CONSTANT"), StringRef::npos);
146 EXPECT_EQ(Element->getIsSymbol(), 1);
147
148 Element = MapElements[0x000000002d]; // 'INTPTR'
149 ASSERT_NE(Element, nullptr);
150 EXPECT_NE(Element->getName().find("INTPTR"), StringRef::npos);
151 EXPECT_EQ(Element->getIsType(), 1);
152
153 Element = MapElements[0x00000000af]; // 'INTEGER'
154 ASSERT_NE(Element, nullptr);
155 EXPECT_NE(Element->getName().find("INTEGER"), StringRef::npos);
156 EXPECT_EQ(Element->getIsType(), 1);
157
158 Element = MapElements[0x000000000f]; // 'movl %edx, %eax'
159 ASSERT_NE(Element, nullptr);
160 EXPECT_NE(Element->getName().find("movl"), StringRef::npos);
161 EXPECT_EQ(Element->getIsLine(), 1);
162
163 // Get the parents for the matched elements.
164 LVScopes MatchedScopes = CompileUnit->getMatchedScopes();
165 std::set<LVOffset> SetScopes;
166 for (LVScope *Scope : MatchedScopes)
167 SetScopes.insert(Scope->getOffset());
168 std::set<LVOffset>::iterator Iter;
169 ASSERT_EQ(SetScopes.size(), 3u);
170
171 Iter = SetScopes.find(0x000000000b); // CompileUnit <- 'foo'
172 EXPECT_NE(Iter, SetScopes.end());
173 Iter = SetScopes.find(0x000000009e); // Function <- 'movl %edx, %eax'
174 EXPECT_NE(Iter, SetScopes.end());
175 Iter = SetScopes.find(0x000000009e); // LexicalScope <- 'INTEGER'
176 EXPECT_NE(Iter, SetScopes.end());
177 }
178
179 // Check the logical elements comparison.
180 void checkElementComparison(LVReader *Reference, LVReader *Target) {
181 LVCompare Compare(nulls());
182 Error Err = Compare.execute(Reference, Target);
183 ASSERT_THAT_ERROR(std::move(Err), Succeeded());
184
185 // Get comparison table.
186 LVPassTable PassTable = Compare.getPassTable();
187 ASSERT_EQ(PassTable.size(), 5u);
188
189 LVReader *Reader;
190 LVElement *Element;
191 LVComparePass Pass;
192
193 // Reference: Missing Variable 'CONSTANT'
194 std::tie(Reader, Element, Pass) = PassTable[0];
195 ASSERT_NE(Reader, nullptr);
196 ASSERT_NE(Element, nullptr);
197 EXPECT_EQ(Reader, Reference);
198 EXPECT_EQ(Element->getLevel(), 4u);
199 EXPECT_EQ(Element->getLineNumber(), 5u);
200 EXPECT_EQ(Element->getName(), "CONSTANT");
201 EXPECT_EQ(Pass, LVComparePass::Missing);
202
203 // Reference: Missing TypeDefinition 'INTEGER'
204 std::tie(Reader, Element, Pass) = PassTable[1];
205 ASSERT_NE(Reader, nullptr);
206 ASSERT_NE(Element, nullptr);
207 EXPECT_EQ(Reader, Reference);
208 EXPECT_EQ(Element->getLevel(), 3u);
209 EXPECT_EQ(Element->getLineNumber(), 4u);
210 EXPECT_EQ(Element->getName(), "INTEGER");
211 EXPECT_EQ(Pass, LVComparePass::Missing);
212
213 // Reference: Missing DebugLine
214 std::tie(Reader, Element, Pass) = PassTable[2];
215 ASSERT_NE(Reader, nullptr);
216 ASSERT_NE(Element, nullptr);
217 EXPECT_EQ(Reader, Reference);
218 EXPECT_EQ(Element->getLevel(), 3u);
219 EXPECT_EQ(Element->getLineNumber(), 8u);
220 EXPECT_EQ(Element->getName(), "");
221 EXPECT_EQ(Pass, LVComparePass::Missing);
222
223 // Target: Added Variable 'CONSTANT'
224 std::tie(Reader, Element, Pass) = PassTable[3];
225 ASSERT_NE(Reader, nullptr);
226 ASSERT_NE(Element, nullptr);
227 EXPECT_EQ(Reader, Target);
228 EXPECT_EQ(Element->getLevel(), 4u);
229 EXPECT_EQ(Element->getLineNumber(), 5u);
230 EXPECT_EQ(Element->getName(), "CONSTANT");
231 EXPECT_EQ(Pass, LVComparePass::Added);
232
233 // Target: Added TypeDefinition 'INTEGER'
234 std::tie(Reader, Element, Pass) = PassTable[4];
235 ASSERT_NE(Reader, nullptr);
236 ASSERT_NE(Element, nullptr);
237 EXPECT_EQ(Reader, Target);
238 EXPECT_EQ(Element->getLevel(), 4u);
239 EXPECT_EQ(Element->getLineNumber(), 4u);
240 EXPECT_EQ(Element->getName(), "INTEGER");
241 EXPECT_EQ(Pass, LVComparePass::Added);
242 }
243
244 // Logical elements properties.
245 void elementProperties(SmallString<128> &InputsDir) {
246 // Reader options.
247 LVOptions ReaderOptions;
248 ReaderOptions.setAttributeOffset();
249 ReaderOptions.setAttributeFormat();
250 ReaderOptions.setAttributeFilename();
251 ReaderOptions.setAttributeProducer();
252 ReaderOptions.setAttributePublics();
253 ReaderOptions.setAttributeRange();
254 ReaderOptions.setAttributeLocation();
255 ReaderOptions.setPrintAll();
256 ReaderOptions.resolveDependencies();
257
258 std::vector<std::string> Objects;
259 ScopedPrinter W(outs());
260 LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
261
262 // Check logical elements properties.
263 LVReader *Reader = createReader(ReaderHandler, InputsDir, DwarfClang);
264 checkElementProperties(Reader);
265 ReaderHandler.deleteReader(Reader);
266 }
267
268 // Logical elements selection.
269 void elementSelection(SmallString<128> &InputsDir) {
270 // Reader options.
271 LVOptions ReaderOptions;
272 ReaderOptions.setAttributeOffset();
273 ReaderOptions.setPrintAll();
274
275 ReaderOptions.setSelectIgnoreCase();
276 ReaderOptions.setSelectUseRegex();
277
278 ReaderOptions.setReportList(); // Matched elements.
279 ReaderOptions.setReportView(); // Parents for matched elements.
280
281 // Add patterns.
282 ReaderOptions.Select.Generic.insert("foo");
283 ReaderOptions.Select.Generic.insert("movl[ \t]?%");
284 ReaderOptions.Select.Generic.insert("INT[a-z]*");
285 ReaderOptions.Select.Generic.insert("CONSTANT");
286
287 ReaderOptions.resolveDependencies();
288
289 std::vector<std::string> Objects;
290 ScopedPrinter W(outs());
291 LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
292
293 // Check logical elements selection.
294 LVReader *Reader = createReader(ReaderHandler, InputsDir, DwarfGcc);
295 checkElementSelection(Reader);
296 ReaderHandler.deleteReader(Reader);
297 }
298
299 // Compare logical elements.
300 void compareElements(SmallString<128> &InputsDir) {
301 // Reader options.
302 LVOptions ReaderOptions;
303 ReaderOptions.setAttributeOffset();
304 ReaderOptions.setPrintLines();
305 ReaderOptions.setPrintSymbols();
306 ReaderOptions.setPrintTypes();
307 ReaderOptions.setCompareLines();
308 ReaderOptions.setCompareSymbols();
309 ReaderOptions.setCompareTypes();
310
311 ReaderOptions.resolveDependencies();
312
313 std::vector<std::string> Objects;
314 ScopedPrinter W(outs());
315 LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
316
317 // Check logical comparison.
318 LVReader *Reference = createReader(ReaderHandler, InputsDir, DwarfClang);
319 LVReader *Target = createReader(ReaderHandler, InputsDir, DwarfGcc);
320 checkElementComparison(Reference, Target);
321 ReaderHandler.deleteReader(Reference);
322 ReaderHandler.deleteReader(Target);
323 }
324
325 TEST(LogicalViewTest, ELFReader) {
326 // Initialize targets and assembly printers/parsers.
327 llvm::InitializeAllTargetInfos();
328 llvm::InitializeAllTargetMCs();
329 InitializeAllDisassemblers();
330
331 llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
332
333 // This test requires a x86-registered-target.
334 Triple TT;
335 TT.setArch(Triple::x86_64);
336 TT.setVendor(Triple::UnknownVendor);
337 TT.setOS(Triple::UnknownOS);
338
339 std::string TargetLookupError;
340 if (!TargetRegistry::lookupTarget(std::string(TT.str()), TargetLookupError))
341 return;
342
343 SmallString<128> InputsDir = unittest::getInputFileDirectory(TestMainArgv0);
344
345 // Logical elements general properties and selection.
346 elementProperties(InputsDir);
347 elementSelection(InputsDir);
348
349 // Compare logical elements.
350 compareElements(InputsDir);
351 }
352
353 } // namespace