| //===-- LVCompare.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 |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This implements the LVCompare class. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/DebugInfo/LogicalView/Core/LVCompare.h" |
| #include "llvm/DebugInfo/LogicalView/Core/LVOptions.h" |
| #include "llvm/DebugInfo/LogicalView/Core/LVReader.h" |
| #include <tuple> |
| |
| using namespace llvm; |
| using namespace llvm::logicalview; |
| |
| #define DEBUG_TYPE "Compare" |
| |
| namespace { |
| |
| enum class LVCompareItem { Scope, Symbol, Type, Line, Total }; |
| enum class LVCompareIndex { Header, Expected, Missing, Added }; |
| using LVCompareEntry = std::tuple<const char *, unsigned, unsigned, unsigned>; |
| using LVCompareInfo = std::map<LVCompareItem, LVCompareEntry>; |
| LVCompareInfo Results = { |
| {LVCompareItem::Line, LVCompareEntry("Lines", 0, 0, 0)}, |
| {LVCompareItem::Scope, LVCompareEntry("Scopes", 0, 0, 0)}, |
| {LVCompareItem::Symbol, LVCompareEntry("Symbols", 0, 0, 0)}, |
| {LVCompareItem::Type, LVCompareEntry("Types", 0, 0, 0)}, |
| {LVCompareItem::Total, LVCompareEntry("Total", 0, 0, 0)}}; |
| static LVCompareInfo::iterator IterTotal = Results.end(); |
| |
| constexpr unsigned getHeader() { |
| return static_cast<unsigned>(LVCompareIndex::Header); |
| } |
| constexpr unsigned getExpected() { |
| return static_cast<unsigned>(LVCompareIndex::Expected); |
| } |
| constexpr unsigned getMissing() { |
| return static_cast<unsigned>(LVCompareIndex::Missing); |
| } |
| constexpr unsigned getAdded() { |
| return static_cast<unsigned>(LVCompareIndex::Added); |
| } |
| |
| LVCompare *CurrentComparator = nullptr; |
| |
| void zeroResults() { |
| // In case the same reader instance is used. |
| for (LVCompareInfo::reference Entry : Results) { |
| std::get<getExpected()>(Entry.second) = 0; |
| std::get<getMissing()>(Entry.second) = 0; |
| std::get<getAdded()>(Entry.second) = 0; |
| } |
| IterTotal = Results.find(LVCompareItem::Total); |
| assert(IterTotal != Results.end()); |
| } |
| |
| LVCompareInfo::iterator getResultsEntry(LVElement *Element) { |
| LVCompareItem Kind; |
| if (Element->getIsLine()) |
| Kind = LVCompareItem::Line; |
| else if (Element->getIsScope()) |
| Kind = LVCompareItem::Scope; |
| else if (Element->getIsSymbol()) |
| Kind = LVCompareItem::Symbol; |
| else |
| Kind = LVCompareItem::Type; |
| |
| // Used to update the expected, missing or added entry for the given kind. |
| LVCompareInfo::iterator Iter = Results.find(Kind); |
| assert(Iter != Results.end()); |
| return Iter; |
| } |
| |
| void updateExpected(LVElement *Element) { |
| LVCompareInfo::iterator Iter = getResultsEntry(Element); |
| // Update total for expected. |
| ++std::get<getExpected()>(IterTotal->second); |
| // Update total for specific element kind. |
| ++std::get<getExpected()>(Iter->second); |
| } |
| |
| void updateMissingOrAdded(LVElement *Element, LVComparePass Pass) { |
| LVCompareInfo::iterator Iter = getResultsEntry(Element); |
| if (Pass == LVComparePass::Missing) { |
| ++std::get<getMissing()>(IterTotal->second); |
| ++std::get<getMissing()>(Iter->second); |
| } else { |
| ++std::get<getAdded()>(IterTotal->second); |
| ++std::get<getAdded()>(Iter->second); |
| } |
| } |
| |
| } // namespace |
| |
| LVCompare &LVCompare::getInstance() { |
| static LVCompare DefaultComparator(outs()); |
| return CurrentComparator ? *CurrentComparator : DefaultComparator; |
| } |
| |
| void LVCompare::setInstance(LVCompare *Comparator) { |
| CurrentComparator = Comparator; |
| } |
| |
| LVCompare::LVCompare(raw_ostream &OS) : OS(OS) { |
| PrintLines = options().getPrintLines(); |
| PrintSymbols = options().getPrintSymbols(); |
| PrintTypes = options().getPrintTypes(); |
| PrintScopes = |
| options().getPrintScopes() || PrintLines || PrintSymbols || PrintTypes; |
| } |
| |
| Error LVCompare::execute(LVReader *ReferenceReader, LVReader *TargetReader) { |
| setInstance(this); |
| // In the case of added elements, the 'Reference' reader will be modified; |
| // those elements will be added to it. Update the current reader instance. |
| LVReader::setInstance(ReferenceReader); |
| |
| auto PrintHeader = [this](LVScopeRoot *LHS, LVScopeRoot *RHS) { |
| LLVM_DEBUG({ |
| dbgs() << "[Reference] " << LHS->getName() << "\n" |
| << "[Target] " << RHS->getName() << "\n"; |
| }); |
| OS << "\nReference: " << formattedName(LHS->getName()) << "\n" |
| << "Target: " << formattedName(RHS->getName()) << "\n"; |
| }; |
| |
| // We traverse the given scopes tree ('Reference' and 'Target') twice. |
| // The first time we look for missing items from the 'Reference' and the |
| // second time we look for items added to the 'Target'. |
| // The comparison test includes the name, lexical level, type, source |
| // location, etc. |
| LVScopeRoot *ReferenceRoot = ReferenceReader->getScopesRoot(); |
| LVScopeRoot *TargetRoot = TargetReader->getScopesRoot(); |
| ReferenceRoot->setIsInCompare(); |
| TargetRoot->setIsInCompare(); |
| |
| // Reset possible previous results. |
| zeroResults(); |
| |
| if (options().getCompareContext()) { |
| // Perform a logical view comparison as a whole unit. We start at the |
| // root reference; at each scope an equal test is applied to its children. |
| // If a difference is found, the current path is marked as missing. |
| auto CompareViews = [this](LVScopeRoot *LHS, LVScopeRoot *RHS) -> Error { |
| LHS->markMissingParents(RHS, /*TraverseChildren=*/true); |
| if (LHS->getIsMissingLink() && options().getReportAnyView()) { |
| // As we are printing a missing tree, enable formatting. |
| options().setPrintFormatting(); |
| OS << "\nMissing Tree:\n"; |
| if (Error Err = LHS->doPrint(/*Split=*/false, /*Match=*/false, |
| /*Print=*/true, OS)) |
| return Err; |
| options().resetPrintFormatting(); |
| } |
| |
| return Error::success(); |
| }; |
| |
| // If the user has requested printing details for the comparison, we |
| // disable the indentation and the added/missing tags ('+'/'-'), as the |
| // details are just a list of elements. |
| options().resetPrintFormatting(); |
| |
| PrintHeader(ReferenceRoot, TargetRoot); |
| Reader = ReferenceReader; |
| if (Error Err = CompareViews(ReferenceRoot, TargetRoot)) |
| return Err; |
| FirstMissing = true; |
| ReferenceRoot->report(LVComparePass::Missing); |
| |
| PrintHeader(TargetRoot, ReferenceRoot); |
| Reader = TargetReader; |
| if (Error Err = CompareViews(TargetRoot, ReferenceRoot)) |
| return Err; |
| FirstMissing = true; |
| TargetRoot->report(LVComparePass::Added); |
| |
| options().setPrintFormatting(); |
| |
| // Display a summary with the elements missing and/or added. |
| printSummary(); |
| } else { |
| // Perform logical elements comparison. An equal test is apply to each |
| // element. If a difference is found, the reference element is marked as |
| // 'missing'. |
| // The final comparison result will show the 'Reference' scopes tree, |
| // having both missing and added elements. |
| using LVScopeLink = std::map<LVScope *, LVScope *>; |
| LVScopeLink ScopeLinks; |
| auto CompareReaders = [&](LVReader *LHS, LVReader *RHS, LVElements &Set, |
| LVComparePass Pass) -> Error { |
| auto FindMatch = [&](auto &References, auto &Targets, |
| const char *Category) -> Error { |
| LVElements Elements; |
| for (LVElement *Reference : References) { |
| // Report elements that can be printed; ignore logical elements that |
| // have qualifiers. |
| if (Reference->getIncludeInPrint()) { |
| if (Pass == LVComparePass::Missing) |
| updateExpected(Reference); |
| Reference->setIsInCompare(); |
| LVElement *CurrentTarget = nullptr; |
| if (std::any_of(Targets.begin(), Targets.end(), |
| [&](auto Target) -> bool { |
| CurrentTarget = Target; |
| return Reference->equals(Target); |
| })) { |
| if (Pass == LVComparePass::Missing && Reference->getIsScope()) { |
| // If the elements being compared are scopes and are a match, |
| // they are recorded, to be used when creating the augmented |
| // tree, as insertion points for the "added" items. |
| ScopeLinks.emplace(static_cast<LVScope *>(CurrentTarget), |
| static_cast<LVScope *>(Reference)); |
| } |
| } else { |
| // Element is missing or added. |
| Pass == LVComparePass::Missing ? Reference->setIsMissing() |
| : Reference->setIsAdded(); |
| Elements.push_back(Reference); |
| updateMissingOrAdded(Reference, Pass); |
| // Record missing/added element. |
| addPassEntry(Reader, Reference, Pass); |
| } |
| } |
| } |
| if (Pass == LVComparePass::Added) |
| // Record all the current missing elements for this category. |
| Set.insert(Set.end(), Elements.begin(), Elements.end()); |
| if (options().getReportList()) { |
| if (Elements.size()) { |
| OS << "\n(" << Elements.size() << ") " |
| << (Pass == LVComparePass::Missing ? "Missing" : "Added") << " " |
| << Category << ":\n"; |
| for (const LVElement *Element : Elements) { |
| if (Error Err = Element->doPrint(/*Split=*/false, /*Match=*/false, |
| /*Print=*/true, OS)) |
| return Err; |
| } |
| } |
| } |
| |
| return Error::success(); |
| }; |
| |
| // First compare the scopes, so they will be inserted at the front of |
| // the missing elements list. When they are moved, their children are |
| // moved as well and no additional work is required. |
| if (options().getCompareScopes()) |
| if (Error Err = FindMatch(LHS->getScopes(), RHS->getScopes(), "Scopes")) |
| return Err; |
| if (options().getCompareSymbols()) |
| if (Error Err = |
| FindMatch(LHS->getSymbols(), RHS->getSymbols(), "Symbols")) |
| return Err; |
| if (options().getCompareTypes()) |
| if (Error Err = FindMatch(LHS->getTypes(), RHS->getTypes(), "Types")) |
| return Err; |
| if (options().getCompareLines()) |
| if (Error Err = FindMatch(LHS->getLines(), RHS->getLines(), "Lines")) |
| return Err; |
| |
| return Error::success(); |
| }; |
| |
| // If the user has requested printing details for the comparison, we |
| // disable the indentation and the added/missing tags ('+'/'-'), as the |
| // details are just a list of elements. |
| options().resetPrintFormatting(); |
| |
| PrintHeader(ReferenceRoot, TargetRoot); |
| // Include the root in the expected count. |
| updateExpected(ReferenceRoot); |
| |
| LVElements ElementsToAdd; |
| Reader = ReferenceReader; |
| if (Error Err = CompareReaders(ReferenceReader, TargetReader, ElementsToAdd, |
| LVComparePass::Missing)) |
| return Err; |
| Reader = TargetReader; |
| if (Error Err = CompareReaders(TargetReader, ReferenceReader, ElementsToAdd, |
| LVComparePass::Added)) |
| return Err; |
| |
| LLVM_DEBUG({ |
| dbgs() << "\nReference/Target Scope links:\n"; |
| for (LVScopeLink::const_reference Entry : ScopeLinks) |
| dbgs() << "Source: " << hexSquareString(Entry.first->getOffset()) << " " |
| << "Destination: " << hexSquareString(Entry.second->getOffset()) |
| << "\n"; |
| dbgs() << "\n"; |
| }); |
| |
| // Add the 'missing' elements from the 'Target' into the 'Reference'. |
| // First insert the missing scopes, as they include any missing children. |
| LVScope *Parent = nullptr; |
| for (LVElement *Element : ElementsToAdd) { |
| LLVM_DEBUG({ |
| dbgs() << "Element to Insert: " << hexSquareString(Element->getOffset()) |
| << ", Parent: " |
| << hexSquareString(Element->getParentScope()->getOffset()) |
| << "\n"; |
| }); |
| // Skip already inserted elements. They were inserted, if their parents |
| // were missing. When inserting them, all the children are moved. |
| if (Element->getHasMoved()) |
| continue; |
| |
| // We need to find an insertion point in the reference scopes tree. |
| Parent = Element->getParentScope(); |
| if (ScopeLinks.find(Parent) != ScopeLinks.end()) { |
| LVScope *InsertionPoint = ScopeLinks[Parent]; |
| LLVM_DEBUG({ |
| dbgs() << "Inserted at: " |
| << hexSquareString(InsertionPoint->getOffset()) << "\n"; |
| }); |
| if (Parent->removeElement(Element)) { |
| // Be sure we have a current compile unit. |
| getReader().setCompileUnit(InsertionPoint->getCompileUnitParent()); |
| InsertionPoint->addElement(Element); |
| Element->updateLevel(InsertionPoint, /*Moved=*/true); |
| } |
| } |
| } |
| |
| options().setPrintFormatting(); |
| |
| // Display the augmented reference scopes tree. |
| if (options().getReportAnyView()) |
| if (Error Err = ReferenceReader->doPrint()) |
| return Err; |
| |
| LLVM_DEBUG({ |
| dbgs() << "\nModified Reference Reader"; |
| if (Error Err = ReferenceReader->doPrint()) |
| return Err; |
| dbgs() << "\nModified Target Reader"; |
| if (Error Err = TargetReader->doPrint()) |
| return Err; |
| }); |
| |
| // Display a summary with the elements missing and/or added. |
| printSummary(); |
| } |
| |
| return Error::success(); |
| } |
| |
| void LVCompare::printCurrentStack() { |
| for (const LVScope *Scope : ScopeStack) { |
| Scope->printAttributes(OS); |
| OS << Scope->lineNumberAsString(/*ShowZero=*/true) << " " << Scope->kind() |
| << " " << formattedName(Scope->getName()) << "\n"; |
| } |
| } |
| |
| void LVCompare::printItem(LVElement *Element, LVComparePass Pass) { |
| // Record expected, missing, added. |
| updateExpected(Element); |
| updateMissingOrAdded(Element, Pass); |
| |
| // Record missing/added element. |
| if (Element->getIsMissing()) |
| addPassEntry(Reader, Element, Pass); |
| |
| if ((!PrintLines && Element->getIsLine()) || |
| (!PrintScopes && Element->getIsScope()) || |
| (!PrintSymbols && Element->getIsSymbol()) || |
| (!PrintTypes && Element->getIsType())) |
| return; |
| |
| if (Element->getIsMissing()) { |
| if (FirstMissing) { |
| OS << "\n"; |
| FirstMissing = false; |
| } |
| |
| StringRef Kind = Element->kind(); |
| StringRef Name = |
| Element->getIsLine() ? Element->getPathname() : Element->getName(); |
| StringRef Status = (Pass == LVComparePass::Missing) ? "Missing" : "Added"; |
| OS << Status << " " << Kind << " '" << Name << "'"; |
| if (Element->getLineNumber() > 0) |
| OS << " at line " << Element->getLineNumber(); |
| OS << "\n"; |
| |
| if (options().getReportList()) { |
| printCurrentStack(); |
| Element->printAttributes(OS); |
| OS << Element->lineNumberAsString(/*ShowZero=*/true) << " " << Kind << " " |
| << Name << "\n"; |
| } |
| } |
| } |
| |
| void LVCompare::printSummary() const { |
| if (!options().getPrintSummary()) |
| return; |
| std::string Separator = std::string(40, '-'); |
| auto PrintSeparator = [&]() { OS << Separator << "\n"; }; |
| auto PrintHeadingRow = [&](const char *T, const char *U, const char *V, |
| const char *W) { |
| OS << format("%-9s%9s %9s %9s\n", T, U, V, W); |
| }; |
| auto PrintDataRow = [&](const char *T, unsigned U, unsigned V, unsigned W) { |
| OS << format("%-9s%9d %9d %9d\n", T, U, V, W); |
| }; |
| |
| OS << "\n"; |
| PrintSeparator(); |
| PrintHeadingRow("Element", "Expected", "Missing", "Added"); |
| PrintSeparator(); |
| for (LVCompareInfo::reference Entry : Results) { |
| if (Entry.first == LVCompareItem::Total) |
| PrintSeparator(); |
| PrintDataRow(std::get<getHeader()>(Entry.second), |
| std::get<getExpected()>(Entry.second), |
| std::get<getMissing()>(Entry.second), |
| std::get<getAdded()>(Entry.second)); |
| } |
| } |
| |
| void LVCompare::print(raw_ostream &OS) const { OS << "LVCompare\n"; } |
