| 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 |