unittests/DebugInfo/LogicalView/DWARFReaderTest.cpp - llvm-project/llvm - Git at Google

 //===- llvm/unittest/DebugInfo/LogicalView/DWARFReaderTest.cpp ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
 #include "llvm/DebugInfo/LogicalView/LVReaderHandler.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/COM.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Testing/Support/Error.h"

 #include "gtest/gtest.h"

 using namespace llvm;
 using namespace llvm::logicalview;

 extern const char *TestMainArgv0;

 namespace {

 const char *DwarfClang = "test-dwarf-clang.o";
 // Two compile units: one declares `extern int foo_printf(const char *, ...);`
 // and another one that defines the function.
 const char *DwarfClangUnspecParams = "test-dwarf-clang-unspec-params.elf";
 const char *DwarfClangModule = "test-dwarf-clang-module.o";
 const char *DwarfGcc = "test-dwarf-gcc.o";

 // Helper function to get the first compile unit.
 LVScopeCompileUnit *getFirstCompileUnit(LVScopeRoot *Root) {
   EXPECT_NE(Root, nullptr);
   const LVScopes *CompileUnits = Root->getScopes();
   EXPECT_NE(CompileUnits, nullptr);
   EXPECT_GT(CompileUnits->size(), 0u);

   LVScopes::const_iterator Iter = CompileUnits->begin();
   EXPECT_NE(Iter, nullptr);
   LVScopeCompileUnit *CompileUnit = static_cast<LVScopeCompileUnit *>(*Iter);
   EXPECT_NE(CompileUnit, nullptr);
   return CompileUnit;
 }

 // Helper function to create a reader.
 std::unique_ptr<LVReader> createReader(LVReaderHandler &ReaderHandler,
                                        SmallString<128> &InputsDir,
                                        StringRef Filename) {
   SmallString<128> ObjectName(InputsDir);
   llvm::sys::path::append(ObjectName, Filename);

   Expected<std::unique_ptr<LVReader>> ReaderOrErr =
       ReaderHandler.createReader(std::string(ObjectName));
   EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
   std::unique_ptr<LVReader> Reader = std::move(*ReaderOrErr);
   EXPECT_NE(Reader, nullptr);
   return Reader;
 }

 // Check the logical elements basic properties.
 void checkElementProperties(LVReader *Reader) {
   LVScopeRoot *Root = Reader->getScopesRoot();
   LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

   EXPECT_EQ(Root->getFileFormatName(), "elf64-x86-64");
   EXPECT_EQ(Root->getName(), DwarfClang);

   EXPECT_EQ(CompileUnit->getBaseAddress(), 0u);
   EXPECT_TRUE(CompileUnit->getProducer().starts_with("clang"));
   EXPECT_EQ(CompileUnit->getName(), "test.cpp");
   LVSourceLanguage Language = CompileUnit->getSourceLanguage();
   EXPECT_TRUE(Language.isValid());
   EXPECT_EQ(Language, LVSourceLanguage::DW_LANG_C_plus_plus_14);
   EXPECT_EQ(Language.getName(), "DW_LANG_C_plus_plus_14");

   EXPECT_EQ(CompileUnit->lineCount(), 0u);
   EXPECT_EQ(CompileUnit->scopeCount(), 1u);
   EXPECT_EQ(CompileUnit->symbolCount(), 0u);
   EXPECT_EQ(CompileUnit->typeCount(), 7u);
   EXPECT_EQ(CompileUnit->rangeCount(), 1u);

   const LVLocations *Ranges = CompileUnit->getRanges();
   ASSERT_NE(Ranges, nullptr);
   ASSERT_EQ(Ranges->size(), 1u);
   LVLocations::const_iterator IterLocation = Ranges->begin();
   LVLocation *Location = (*IterLocation);
   EXPECT_STREQ(Location->getIntervalInfo().c_str(),
                "{Range} Lines 2:9 [0x0000000000:0x000000003a]");

   LVRange RangeList;
   CompileUnit->getRanges(RangeList);

   const LVRangeEntries &RangeEntries = RangeList.getEntries();
   ASSERT_EQ(RangeEntries.size(), 2u);
   LVRangeEntries::const_iterator IterRanges = RangeEntries.cbegin();
   LVRangeEntry RangeEntry = *IterRanges;
   EXPECT_EQ(RangeEntry.lower(), 0u);
   EXPECT_EQ(RangeEntry.upper(), 0x3au);
   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
   EXPECT_EQ(RangeEntry.scope()->getName(), "test.cpp");
   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x0bu);

   ++IterRanges;
   RangeEntry = *IterRanges;
   EXPECT_EQ(RangeEntry.lower(), 0x1cu);
   EXPECT_EQ(RangeEntry.upper(), 0x2fu);
   EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
   EXPECT_EQ(RangeEntry.scope()->getName(), "foo::?");
   EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x71u);

   const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
   ASSERT_EQ(PublicNames.size(), 1u);
   LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
   LVScope *Function = (*IterNames).first;
   EXPECT_EQ(Function->getName(), "foo");
   EXPECT_EQ(Function->getLineNumber(), 2u);
   LVNameInfo NameInfo = (*IterNames).second;
   EXPECT_EQ(NameInfo.first, 0u);
   EXPECT_EQ(NameInfo.second, 0x3au);

   // Lines (debug and assembler) for 'foo'.
   const LVLines *Lines = Function->getLines();
   ASSERT_NE(Lines, nullptr);
   ASSERT_EQ(Lines->size(), 0x12u);

   // Check size of types in CompileUnit.
   const LVTypes *Types = CompileUnit->getTypes();
   ASSERT_NE(Types, nullptr);
   EXPECT_EQ(Types->size(), 7u);

   const auto BoolType = llvm::find_if(
       *Types, [](const LVElement *elt) { return elt->getName() == "bool"; });
   ASSERT_NE(BoolType, Types->end());
   const auto IntType = llvm::find_if(
       *Types, [](const LVElement *elt) { return elt->getName() == "int"; });
   ASSERT_NE(IntType, Types->end());
   EXPECT_EQ(static_cast<LVType *>(*BoolType)->getBitSize(), 8u);
   EXPECT_EQ(static_cast<LVType *>(*BoolType)->getStorageSizeInBytes(), 1u);
   EXPECT_EQ(static_cast<LVType *>(*IntType)->getBitSize(), 32u);
   EXPECT_EQ(static_cast<LVType *>(*IntType)->getStorageSizeInBytes(), 4u);
 }

 // Check proper handling of DW_AT_unspecified_parameters in
 // LVScope::addMissingElements().
 void checkUnspecifiedParameters(LVReader *Reader) {
   LVScopeRoot *Root = Reader->getScopesRoot();
   LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

   EXPECT_EQ(Root->getFileFormatName(), "elf64-x86-64");
   EXPECT_EQ(Root->getName(), DwarfClangUnspecParams);

   const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
   ASSERT_EQ(PublicNames.size(), 1u);

   LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
   LVScope *Function = (*IterNames).first;
   EXPECT_EQ(Function->getName(), "foo_printf");
   const LVElements *Elements = Function->getChildren();
   ASSERT_NE(Elements, nullptr);
   // foo_printf is a variadic function whose prototype is
   // `int foo_printf(const char *, ...)`, where the '...' is represented by a
   // DW_TAG_unspecified_parameters, i.e. we expect to find at least one child
   // for which getIsUnspecified() returns true.
   EXPECT_TRUE(llvm::any_of(*Elements, [](const LVElement *elt) {
     return elt->getIsSymbol() &&
            static_cast<const LVSymbol *>(elt)->getIsUnspecified();
   }));
 }

 // Check the basic properties on parsed DW_TAG_module.
 void checkScopeModule(LVReader *Reader) {
   LVScopeRoot *Root = Reader->getScopesRoot();
   LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

   EXPECT_EQ(Root->getFileFormatName(), "Mach-O 64-bit x86-64");
   EXPECT_EQ(Root->getName(), DwarfClangModule);

   ASSERT_NE(CompileUnit->getChildren(), nullptr);
   LVElement *FirstChild = *(CompileUnit->getChildren()->begin());
   EXPECT_EQ(FirstChild->getIsScope(), 1);
   LVScopeModule *Module = static_cast<LVScopeModule *>(FirstChild);
   EXPECT_EQ(Module->getIsModule(), 1);
   EXPECT_EQ(Module->getName(), "DebugModule");
 }

 // Check the logical elements selection.
 void checkElementSelection(LVReader *Reader) {
   LVScopeRoot *Root = Reader->getScopesRoot();
   LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

   // Get the matched elements.
   LVElements MatchedElements = CompileUnit->getMatchedElements();
   std::map<LVOffset, LVElement *> MapElements;
   for (LVElement *Element : MatchedElements)
     MapElements[Element->getOffset()] = Element;
   ASSERT_EQ(MapElements.size(), 0xeu);

   LVElement *Element = MapElements[0x000000004b]; // 'foo'
   ASSERT_NE(Element, nullptr);
   EXPECT_NE(Element->getName().find("foo"), StringRef::npos);
   EXPECT_EQ(Element->getIsScope(), 1);

   Element = MapElements[0x00000000c0]; // 'CONSTANT'
   ASSERT_NE(Element, nullptr);
   EXPECT_NE(Element->getName().find("CONSTANT"), StringRef::npos);
   EXPECT_EQ(Element->getIsSymbol(), 1);

   Element = MapElements[0x000000002d]; // 'INTPTR'
   ASSERT_NE(Element, nullptr);
   EXPECT_NE(Element->getName().find("INTPTR"), StringRef::npos);
   EXPECT_EQ(Element->getIsType(), 1);

   Element = MapElements[0x00000000af]; // 'INTEGER'
   ASSERT_NE(Element, nullptr);
   EXPECT_NE(Element->getName().find("INTEGER"), StringRef::npos);
   EXPECT_EQ(Element->getIsType(), 1);

   Element = MapElements[0x000000000f]; // 'movl	%edx, %eax'
   ASSERT_NE(Element, nullptr);
   EXPECT_NE(Element->getName().find("movl"), StringRef::npos);
   EXPECT_EQ(Element->getIsLine(), 1);

   // Get the parents for the matched elements.
   LVScopes MatchedScopes = CompileUnit->getMatchedScopes();
   std::set<LVOffset> SetScopes;
   for (LVScope *Scope : MatchedScopes)
     SetScopes.insert(Scope->getOffset());
   std::set<LVOffset>::iterator Iter;
   ASSERT_EQ(SetScopes.size(), 3u);

   Iter = SetScopes.find(0x000000000b); // CompileUnit <- 'foo'
   EXPECT_NE(Iter, SetScopes.end());
   Iter = SetScopes.find(0x000000009e); // Function <- 'movl	%edx, %eax'
   EXPECT_NE(Iter, SetScopes.end());
   Iter = SetScopes.find(0x000000009e); // LexicalScope <- 'INTEGER'
   EXPECT_NE(Iter, SetScopes.end());
 }

 // Check the logical elements comparison.
 void checkElementComparison(LVReader *Reference, LVReader *Target) {
   LVCompare Compare(nulls());
   Error Err = Compare.execute(Reference, Target);
   ASSERT_THAT_ERROR(std::move(Err), Succeeded());

   // Get comparison table.
   LVPassTable PassTable = Compare.getPassTable();
   ASSERT_EQ(PassTable.size(), 5u);

   LVReader *Reader;
   LVElement *Element;
   LVComparePass Pass;

   // Reference: Missing Variable 'CONSTANT'
   std::tie(Reader, Element, Pass) = PassTable[0];
   ASSERT_NE(Reader, nullptr);
   ASSERT_NE(Element, nullptr);
   EXPECT_EQ(Reader, Reference);
   EXPECT_EQ(Element->getLevel(), 4u);
   EXPECT_EQ(Element->getLineNumber(), 5u);
   EXPECT_EQ(Element->getName(), "CONSTANT");
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Reference: Missing TypeDefinition 'INTEGER'
   std::tie(Reader, Element, Pass) = PassTable[1];
   ASSERT_NE(Reader, nullptr);
   ASSERT_NE(Element, nullptr);
   EXPECT_EQ(Reader, Reference);
   EXPECT_EQ(Element->getLevel(), 3u);
   EXPECT_EQ(Element->getLineNumber(), 4u);
   EXPECT_EQ(Element->getName(), "INTEGER");
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Reference: Missing DebugLine
   std::tie(Reader, Element, Pass) = PassTable[2];
   ASSERT_NE(Reader, nullptr);
   ASSERT_NE(Element, nullptr);
   EXPECT_EQ(Reader, Reference);
   EXPECT_EQ(Element->getLevel(), 3u);
   EXPECT_EQ(Element->getLineNumber(), 8u);
   EXPECT_EQ(Element->getName(), "");
   EXPECT_EQ(Pass, LVComparePass::Missing);

   // Target: Added Variable 'CONSTANT'
   std::tie(Reader, Element, Pass) = PassTable[3];
   ASSERT_NE(Reader, nullptr);
   ASSERT_NE(Element, nullptr);
   EXPECT_EQ(Reader, Target);
   EXPECT_EQ(Element->getLevel(), 4u);
   EXPECT_EQ(Element->getLineNumber(), 5u);
   EXPECT_EQ(Element->getName(), "CONSTANT");
   EXPECT_EQ(Pass, LVComparePass::Added);

   // Target: Added TypeDefinition 'INTEGER'
   std::tie(Reader, Element, Pass) = PassTable[4];
   ASSERT_NE(Reader, nullptr);
   ASSERT_NE(Element, nullptr);
   EXPECT_EQ(Reader, Target);
   EXPECT_EQ(Element->getLevel(), 4u);
   EXPECT_EQ(Element->getLineNumber(), 4u);
   EXPECT_EQ(Element->getName(), "INTEGER");
   EXPECT_EQ(Pass, LVComparePass::Added);
 }

 // Logical elements properties.
 void elementProperties(SmallString<128> &InputsDir) {
   // Reader options.
   LVOptions ReaderOptions;
   ReaderOptions.setAttributeOffset();
   ReaderOptions.setAttributeFormat();
   ReaderOptions.setAttributeFilename();
   ReaderOptions.setAttributeProducer();
   ReaderOptions.setAttributePublics();
   ReaderOptions.setAttributeRange();
   ReaderOptions.setAttributeLanguage();
   ReaderOptions.setAttributeLocation();
   ReaderOptions.setAttributeInserted();
   ReaderOptions.setAttributeSize();
   ReaderOptions.setPrintAll();
   ReaderOptions.resolveDependencies();

   std::vector<std::string> Objects;
   ScopedPrinter W(outs());
   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);

   // Check logical elements properties.
   std::unique_ptr<LVReader> Reader =
       createReader(ReaderHandler, InputsDir, DwarfClang);
   checkElementProperties(Reader.get());

   Reader = createReader(ReaderHandler, InputsDir, DwarfClangUnspecParams);
   checkUnspecifiedParameters(Reader.get());

   Reader = createReader(ReaderHandler, InputsDir, DwarfClangModule);
   checkScopeModule(Reader.get());
 }

 // Logical elements selection.
 void elementSelection(SmallString<128> &InputsDir) {
   // Reader options.
   LVOptions ReaderOptions;
   ReaderOptions.setAttributeOffset();
   ReaderOptions.setPrintAll();

   ReaderOptions.setSelectIgnoreCase();
   ReaderOptions.setSelectUseRegex();

   ReaderOptions.setReportList(); // Matched elements.
   ReaderOptions.setReportView(); // Parents for matched elements.

   // Add patterns.
   ReaderOptions.Select.Generic.insert("foo");
   ReaderOptions.Select.Generic.insert("movl[ \t]?%");
   ReaderOptions.Select.Generic.insert("INT[a-z]*");
   ReaderOptions.Select.Generic.insert("CONSTANT");

   ReaderOptions.resolveDependencies();

   std::vector<std::string> Objects;
   ScopedPrinter W(outs());
   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);

   // Check logical elements selection.
   std::unique_ptr<LVReader> Reader =
       createReader(ReaderHandler, InputsDir, DwarfGcc);
   checkElementSelection(Reader.get());
 }

 // Compare logical elements.
 void compareElements(SmallString<128> &InputsDir) {
   // Reader options.
   LVOptions ReaderOptions;
   ReaderOptions.setAttributeOffset();
   ReaderOptions.setPrintLines();
   ReaderOptions.setPrintSymbols();
   ReaderOptions.setPrintTypes();
   ReaderOptions.setCompareLines();
   ReaderOptions.setCompareSymbols();
   ReaderOptions.setCompareTypes();

   ReaderOptions.resolveDependencies();

   std::vector<std::string> Objects;
   ScopedPrinter W(outs());
   LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);

   // Check logical comparison.
   std::unique_ptr<LVReader> Reference =
       createReader(ReaderHandler, InputsDir, DwarfClang);
   std::unique_ptr<LVReader> Target =
       createReader(ReaderHandler, InputsDir, DwarfGcc);
   checkElementComparison(Reference.get(), Target.get());
 }

 TEST(LogicalViewTest, DWARFReader) {
   // Initialize targets and assembly printers/parsers.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   InitializeAllDisassemblers();

   llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);

   // This test requires a x86-registered-target.
   Triple TT;
   TT.setArch(Triple::x86_64);
   TT.setVendor(Triple::UnknownVendor);
   TT.setOS(Triple::UnknownOS);

   std::string TargetLookupError;
   if (!TargetRegistry::lookupTarget(TT, TargetLookupError))
     GTEST_SKIP();

   SmallString<128> InputsDir = unittest::getInputFileDirectory(TestMainArgv0);

   // Logical elements general properties and selection.
   elementProperties(InputsDir);
   elementSelection(InputsDir);

   // Compare logical elements.
   compareElements(InputsDir);
 }

 } // namespace
	//===- llvm/unittest/DebugInfo/LogicalView/DWARFReaderTest.cpp ------------===//
	//
	// 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
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
	#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
	#include "llvm/DebugInfo/LogicalView/LVReaderHandler.h"
	#include "llvm/MC/TargetRegistry.h"
	#include "llvm/Support/COM.h"
	#include "llvm/Support/InitLLVM.h"
	#include "llvm/Support/ScopedPrinter.h"
	#include "llvm/Support/TargetSelect.h"
	#include "llvm/Support/ToolOutputFile.h"
	#include "llvm/Testing/Support/Error.h"

	#include "gtest/gtest.h"

	using namespace llvm;
	using namespace llvm::logicalview;

	extern const char *TestMainArgv0;

	namespace {

	const char *DwarfClang = "test-dwarf-clang.o";
	// Two compile units: one declares `extern int foo_printf(const char *, ...);`
	// and another one that defines the function.
	const char *DwarfClangUnspecParams = "test-dwarf-clang-unspec-params.elf";
	const char *DwarfClangModule = "test-dwarf-clang-module.o";
	const char *DwarfGcc = "test-dwarf-gcc.o";

	// Helper function to get the first compile unit.
	LVScopeCompileUnit getFirstCompileUnit(LVScopeRoot Root) {
	EXPECT_NE(Root, nullptr);
	const LVScopes *CompileUnits = Root->getScopes();
	EXPECT_NE(CompileUnits, nullptr);
	EXPECT_GT(CompileUnits->size(), 0u);

	LVScopes::const_iterator Iter = CompileUnits->begin();
	EXPECT_NE(Iter, nullptr);
	LVScopeCompileUnit CompileUnit = static_cast<LVScopeCompileUnit >(*Iter);
	EXPECT_NE(CompileUnit, nullptr);
	return CompileUnit;
	}

	// Helper function to create a reader.
	std::unique_ptr<LVReader> createReader(LVReaderHandler &ReaderHandler,
	SmallString<128> &InputsDir,
	StringRef Filename) {
	SmallString<128> ObjectName(InputsDir);
	llvm::sys::path::append(ObjectName, Filename);

	Expected<std::unique_ptr<LVReader>> ReaderOrErr =
	ReaderHandler.createReader(std::string(ObjectName));
	EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
	std::unique_ptr<LVReader> Reader = std::move(*ReaderOrErr);
	EXPECT_NE(Reader, nullptr);
	return Reader;
	}

	// Check the logical elements basic properties.
	void checkElementProperties(LVReader *Reader) {
	LVScopeRoot *Root = Reader->getScopesRoot();
	LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

	EXPECT_EQ(Root->getFileFormatName(), "elf64-x86-64");
	EXPECT_EQ(Root->getName(), DwarfClang);

	EXPECT_EQ(CompileUnit->getBaseAddress(), 0u);
	EXPECT_TRUE(CompileUnit->getProducer().starts_with("clang"));
	EXPECT_EQ(CompileUnit->getName(), "test.cpp");
	LVSourceLanguage Language = CompileUnit->getSourceLanguage();
	EXPECT_TRUE(Language.isValid());
	EXPECT_EQ(Language, LVSourceLanguage::DW_LANG_C_plus_plus_14);
	EXPECT_EQ(Language.getName(), "DW_LANG_C_plus_plus_14");

	EXPECT_EQ(CompileUnit->lineCount(), 0u);
	EXPECT_EQ(CompileUnit->scopeCount(), 1u);
	EXPECT_EQ(CompileUnit->symbolCount(), 0u);
	EXPECT_EQ(CompileUnit->typeCount(), 7u);
	EXPECT_EQ(CompileUnit->rangeCount(), 1u);

	const LVLocations *Ranges = CompileUnit->getRanges();
	ASSERT_NE(Ranges, nullptr);
	ASSERT_EQ(Ranges->size(), 1u);
	LVLocations::const_iterator IterLocation = Ranges->begin();
	LVLocation Location = (IterLocation);
	EXPECT_STREQ(Location->getIntervalInfo().c_str(),
	"{Range} Lines 2:9 [0x0000000000:0x000000003a]");

	LVRange RangeList;
	CompileUnit->getRanges(RangeList);

	const LVRangeEntries &RangeEntries = RangeList.getEntries();
	ASSERT_EQ(RangeEntries.size(), 2u);
	LVRangeEntries::const_iterator IterRanges = RangeEntries.cbegin();
	LVRangeEntry RangeEntry = *IterRanges;
	EXPECT_EQ(RangeEntry.lower(), 0u);
	EXPECT_EQ(RangeEntry.upper(), 0x3au);
	EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
	EXPECT_EQ(RangeEntry.scope()->getName(), "test.cpp");
	EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x0bu);

	++IterRanges;
	RangeEntry = *IterRanges;
	EXPECT_EQ(RangeEntry.lower(), 0x1cu);
	EXPECT_EQ(RangeEntry.upper(), 0x2fu);
	EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0u);
	EXPECT_EQ(RangeEntry.scope()->getName(), "foo::?");
	EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x71u);

	const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
	ASSERT_EQ(PublicNames.size(), 1u);
	LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
	LVScope Function = (IterNames).first;
	EXPECT_EQ(Function->getName(), "foo");
	EXPECT_EQ(Function->getLineNumber(), 2u);
	LVNameInfo NameInfo = (*IterNames).second;
	EXPECT_EQ(NameInfo.first, 0u);
	EXPECT_EQ(NameInfo.second, 0x3au);

	// Lines (debug and assembler) for 'foo'.
	const LVLines *Lines = Function->getLines();
	ASSERT_NE(Lines, nullptr);
	ASSERT_EQ(Lines->size(), 0x12u);

	// Check size of types in CompileUnit.
	const LVTypes *Types = CompileUnit->getTypes();
	ASSERT_NE(Types, nullptr);
	EXPECT_EQ(Types->size(), 7u);

	const auto BoolType = llvm::find_if(
	Types, [](const LVElement elt) { return elt->getName() == "bool"; });
	ASSERT_NE(BoolType, Types->end());
	const auto IntType = llvm::find_if(
	Types, [](const LVElement elt) { return elt->getName() == "int"; });
	ASSERT_NE(IntType, Types->end());
	EXPECT_EQ(static_cast<LVType >(BoolType)->getBitSize(), 8u);
	EXPECT_EQ(static_cast<LVType >(BoolType)->getStorageSizeInBytes(), 1u);
	EXPECT_EQ(static_cast<LVType >(IntType)->getBitSize(), 32u);
	EXPECT_EQ(static_cast<LVType >(IntType)->getStorageSizeInBytes(), 4u);
	}

	// Check proper handling of DW_AT_unspecified_parameters in
	// LVScope::addMissingElements().
	void checkUnspecifiedParameters(LVReader *Reader) {
	LVScopeRoot *Root = Reader->getScopesRoot();
	LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

	EXPECT_EQ(Root->getFileFormatName(), "elf64-x86-64");
	EXPECT_EQ(Root->getName(), DwarfClangUnspecParams);

	const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
	ASSERT_EQ(PublicNames.size(), 1u);

	LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
	LVScope Function = (IterNames).first;
	EXPECT_EQ(Function->getName(), "foo_printf");
	const LVElements *Elements = Function->getChildren();
	ASSERT_NE(Elements, nullptr);
	// foo_printf is a variadic function whose prototype is
	// `int foo_printf(const char *, ...)`, where the '...' is represented by a
	// DW_TAG_unspecified_parameters, i.e. we expect to find at least one child
	// for which getIsUnspecified() returns true.
	EXPECT_TRUE(llvm::any_of(Elements, [](const LVElement elt) {
	return elt->getIsSymbol() &&
	static_cast<const LVSymbol *>(elt)->getIsUnspecified();
	}));
	}

	// Check the basic properties on parsed DW_TAG_module.
	void checkScopeModule(LVReader *Reader) {
	LVScopeRoot *Root = Reader->getScopesRoot();
	LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

	EXPECT_EQ(Root->getFileFormatName(), "Mach-O 64-bit x86-64");
	EXPECT_EQ(Root->getName(), DwarfClangModule);

	ASSERT_NE(CompileUnit->getChildren(), nullptr);
	LVElement FirstChild = (CompileUnit->getChildren()->begin());
	EXPECT_EQ(FirstChild->getIsScope(), 1);
	LVScopeModule Module = static_cast<LVScopeModule >(FirstChild);
	EXPECT_EQ(Module->getIsModule(), 1);
	EXPECT_EQ(Module->getName(), "DebugModule");
	}

	// Check the logical elements selection.
	void checkElementSelection(LVReader *Reader) {
	LVScopeRoot *Root = Reader->getScopesRoot();
	LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);

	// Get the matched elements.
	LVElements MatchedElements = CompileUnit->getMatchedElements();
	std::map<LVOffset, LVElement *> MapElements;
	for (LVElement *Element : MatchedElements)
	MapElements[Element->getOffset()] = Element;
	ASSERT_EQ(MapElements.size(), 0xeu);

	LVElement *Element = MapElements[0x000000004b]; // 'foo'
	ASSERT_NE(Element, nullptr);
	EXPECT_NE(Element->getName().find("foo"), StringRef::npos);
	EXPECT_EQ(Element->getIsScope(), 1);

	Element = MapElements[0x00000000c0]; // 'CONSTANT'
	ASSERT_NE(Element, nullptr);
	EXPECT_NE(Element->getName().find("CONSTANT"), StringRef::npos);
	EXPECT_EQ(Element->getIsSymbol(), 1);

	Element = MapElements[0x000000002d]; // 'INTPTR'
	ASSERT_NE(Element, nullptr);
	EXPECT_NE(Element->getName().find("INTPTR"), StringRef::npos);
	EXPECT_EQ(Element->getIsType(), 1);

	Element = MapElements[0x00000000af]; // 'INTEGER'
	ASSERT_NE(Element, nullptr);
	EXPECT_NE(Element->getName().find("INTEGER"), StringRef::npos);
	EXPECT_EQ(Element->getIsType(), 1);

	Element = MapElements[0x000000000f]; // 'movl %edx, %eax'
	ASSERT_NE(Element, nullptr);
	EXPECT_NE(Element->getName().find("movl"), StringRef::npos);
	EXPECT_EQ(Element->getIsLine(), 1);

	// Get the parents for the matched elements.
	LVScopes MatchedScopes = CompileUnit->getMatchedScopes();
	std::set<LVOffset> SetScopes;
	for (LVScope *Scope : MatchedScopes)
	SetScopes.insert(Scope->getOffset());
	std::set<LVOffset>::iterator Iter;
	ASSERT_EQ(SetScopes.size(), 3u);

	Iter = SetScopes.find(0x000000000b); // CompileUnit <- 'foo'
	EXPECT_NE(Iter, SetScopes.end());
	Iter = SetScopes.find(0x000000009e); // Function <- 'movl %edx, %eax'
	EXPECT_NE(Iter, SetScopes.end());
	Iter = SetScopes.find(0x000000009e); // LexicalScope <- 'INTEGER'
	EXPECT_NE(Iter, SetScopes.end());
	}

	// Check the logical elements comparison.
	void checkElementComparison(LVReader Reference, LVReader Target) {
	LVCompare Compare(nulls());
	Error Err = Compare.execute(Reference, Target);
	ASSERT_THAT_ERROR(std::move(Err), Succeeded());

	// Get comparison table.
	LVPassTable PassTable = Compare.getPassTable();
	ASSERT_EQ(PassTable.size(), 5u);

	LVReader *Reader;
	LVElement *Element;
	LVComparePass Pass;

	// Reference: Missing Variable 'CONSTANT'
	std::tie(Reader, Element, Pass) = PassTable[0];
	ASSERT_NE(Reader, nullptr);
	ASSERT_NE(Element, nullptr);
	EXPECT_EQ(Reader, Reference);
	EXPECT_EQ(Element->getLevel(), 4u);
	EXPECT_EQ(Element->getLineNumber(), 5u);
	EXPECT_EQ(Element->getName(), "CONSTANT");
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Reference: Missing TypeDefinition 'INTEGER'
	std::tie(Reader, Element, Pass) = PassTable[1];
	ASSERT_NE(Reader, nullptr);
	ASSERT_NE(Element, nullptr);
	EXPECT_EQ(Reader, Reference);
	EXPECT_EQ(Element->getLevel(), 3u);
	EXPECT_EQ(Element->getLineNumber(), 4u);
	EXPECT_EQ(Element->getName(), "INTEGER");
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Reference: Missing DebugLine
	std::tie(Reader, Element, Pass) = PassTable[2];
	ASSERT_NE(Reader, nullptr);
	ASSERT_NE(Element, nullptr);
	EXPECT_EQ(Reader, Reference);
	EXPECT_EQ(Element->getLevel(), 3u);
	EXPECT_EQ(Element->getLineNumber(), 8u);
	EXPECT_EQ(Element->getName(), "");
	EXPECT_EQ(Pass, LVComparePass::Missing);

	// Target: Added Variable 'CONSTANT'
	std::tie(Reader, Element, Pass) = PassTable[3];
	ASSERT_NE(Reader, nullptr);
	ASSERT_NE(Element, nullptr);
	EXPECT_EQ(Reader, Target);
	EXPECT_EQ(Element->getLevel(), 4u);
	EXPECT_EQ(Element->getLineNumber(), 5u);
	EXPECT_EQ(Element->getName(), "CONSTANT");
	EXPECT_EQ(Pass, LVComparePass::Added);

	// Target: Added TypeDefinition 'INTEGER'
	std::tie(Reader, Element, Pass) = PassTable[4];
	ASSERT_NE(Reader, nullptr);
	ASSERT_NE(Element, nullptr);
	EXPECT_EQ(Reader, Target);
	EXPECT_EQ(Element->getLevel(), 4u);
	EXPECT_EQ(Element->getLineNumber(), 4u);
	EXPECT_EQ(Element->getName(), "INTEGER");
	EXPECT_EQ(Pass, LVComparePass::Added);
	}

	// Logical elements properties.
	void elementProperties(SmallString<128> &InputsDir) {
	// Reader options.
	LVOptions ReaderOptions;
	ReaderOptions.setAttributeOffset();
	ReaderOptions.setAttributeFormat();
	ReaderOptions.setAttributeFilename();
	ReaderOptions.setAttributeProducer();
	ReaderOptions.setAttributePublics();
	ReaderOptions.setAttributeRange();
	ReaderOptions.setAttributeLanguage();
	ReaderOptions.setAttributeLocation();
	ReaderOptions.setAttributeInserted();
	ReaderOptions.setAttributeSize();
	ReaderOptions.setPrintAll();
	ReaderOptions.resolveDependencies();

	std::vector<std::string> Objects;
	ScopedPrinter W(outs());
	LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);

	// Check logical elements properties.
	std::unique_ptr<LVReader> Reader =
	createReader(ReaderHandler, InputsDir, DwarfClang);
	checkElementProperties(Reader.get());

	Reader = createReader(ReaderHandler, InputsDir, DwarfClangUnspecParams);
	checkUnspecifiedParameters(Reader.get());

	Reader = createReader(ReaderHandler, InputsDir, DwarfClangModule);
	checkScopeModule(Reader.get());
	}

	// Logical elements selection.
	void elementSelection(SmallString<128> &InputsDir) {
	// Reader options.
	LVOptions ReaderOptions;
	ReaderOptions.setAttributeOffset();
	ReaderOptions.setPrintAll();

	ReaderOptions.setSelectIgnoreCase();
	ReaderOptions.setSelectUseRegex();

	ReaderOptions.setReportList(); // Matched elements.
	ReaderOptions.setReportView(); // Parents for matched elements.

	// Add patterns.
	ReaderOptions.Select.Generic.insert("foo");
	ReaderOptions.Select.Generic.insert("movl[ \t]?%");
	ReaderOptions.Select.Generic.insert("INT[a-z]*");
	ReaderOptions.Select.Generic.insert("CONSTANT");

	ReaderOptions.resolveDependencies();

	std::vector<std::string> Objects;
	ScopedPrinter W(outs());
	LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);

	// Check logical elements selection.
	std::unique_ptr<LVReader> Reader =
	createReader(ReaderHandler, InputsDir, DwarfGcc);
	checkElementSelection(Reader.get());
	}

	// Compare logical elements.
	void compareElements(SmallString<128> &InputsDir) {
	// Reader options.
	LVOptions ReaderOptions;
	ReaderOptions.setAttributeOffset();
	ReaderOptions.setPrintLines();
	ReaderOptions.setPrintSymbols();
	ReaderOptions.setPrintTypes();
	ReaderOptions.setCompareLines();
	ReaderOptions.setCompareSymbols();
	ReaderOptions.setCompareTypes();

	ReaderOptions.resolveDependencies();

	std::vector<std::string> Objects;
	ScopedPrinter W(outs());
	LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);

	// Check logical comparison.
	std::unique_ptr<LVReader> Reference =
	createReader(ReaderHandler, InputsDir, DwarfClang);
	std::unique_ptr<LVReader> Target =
	createReader(ReaderHandler, InputsDir, DwarfGcc);
	checkElementComparison(Reference.get(), Target.get());
	}

	TEST(LogicalViewTest, DWARFReader) {
	// Initialize targets and assembly printers/parsers.
	llvm::InitializeAllTargetInfos();
	llvm::InitializeAllTargetMCs();
	InitializeAllDisassemblers();

	llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);

	// This test requires a x86-registered-target.
	Triple TT;
	TT.setArch(Triple::x86_64);
	TT.setVendor(Triple::UnknownVendor);
	TT.setOS(Triple::UnknownOS);

	std::string TargetLookupError;
	if (!TargetRegistry::lookupTarget(TT, TargetLookupError))
	GTEST_SKIP();

	SmallString<128> InputsDir = unittest::getInputFileDirectory(TestMainArgv0);

	// Logical elements general properties and selection.
	elementProperties(InputsDir);
	elementSelection(InputsDir);

	// Compare logical elements.
	compareElements(InputsDir);
	}

	} // namespace