[llvm-debuginfo-analyzer] 07 - Compare elements

[CarlosAlbertoEnciso]

Summary

LLVM debug information visual analyzer

For more information, see the RFC https://discourse.llvm.org/t/llvm-dev-rfc-llvm-dva-debug-information-visual-analyzer/62570

Patches:
01 - Interval Tree
02 - Driver and Documentation
03 - Logical Elements
04 - Locations and Ranges
05 - Select Elements
06 - Warning and Internal Options
07 - Compare Elements
08 - ELF Reader
09 - CodeView Reader
10 - Smart Pointers

This is a high level summary of the changes in this patch.

Compare elements

• Support for logical elements comparison. See '--compare' options.

[psamolysov]

Good job! I have a few most stylistic only comments here. What I would like to discuss with the other reviewers: should an assert be used in every function that accepts an argument by pointer and dereferences the pointer or calls functions on it (so, dereferences it too)? My personal opinion: yes but there can be other opinions too, so I do not insist.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

29

Either the class should be marked as final or has a virtual destructor.

63

I see a call to this static member function in the LVCompare::execute only. Could the static member function be private or protected?

73

emplace_back creates the instance of the LVPassEntry class in place.

llvm/lib/DebugInfo/LogicalView/Core/LVCompare.cpp

68

213–215

288

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

877–878

Could the method just return the inverted if's condition instead of using the if statement?

884

Is Entry a reference to a pointer?

1061

I believe this is a good idea to always use assert on a pointer if there is a dereference of or call a method of in the function to be sure the pointer is not null. The LLVM Coding Standards guideline recommends to use asserts liberally: "Check all of your preconditions and assumptions, you never know when a bug (not necessarily even yours) might be caught early by an assertion, which reduces debugging time dramatically."

1783–1784

Just a nit. What about to combine the conditions together by &&? I personally think it would be more readable than nested if statements.

1808–1809

Just a nit. What about to combine the conditions together by &&? I personally think it would be more readable than nested if statements.

1939–1940

Just a nit. What about to combine the conditions together by &&? I personally think it would be more readable than nested if statements.

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

363–364

Just a nit. What about to combine the conditions together by &&? I personally think it would be more readable than nested if statements.

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

518–521

I believe this if statement can be converted to return of the inverted condition.

llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp

69

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

29

Added final.

63

Marking setInstance as private.

73

Replaced with emplace_back.

llvm/lib/DebugInfo/LogicalView/Core/LVCompare.cpp

68

Nice change.

213–215

Replaced with emplace.

288

Nice change.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

1783–1784

Replaced the nested if with a combined conditions &&.

1808–1809

Replaced the nested if with a combined conditions &&.

1939–1940

Replaced the nested if with a combined conditions &&.

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

363–364

Replaced the nested if with a combined conditions &&.

llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp

69

Changed to use the non-throwing overload.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

877–878

Eliminated the if and return an inverted condition.

884

Your change is correct.

1061

Very good point.
Added assert(Scopes && "Scopes must not be nullptr"); in few other places as well.

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

518–521

Very good simplification.

[CarlosAlbertoEnciso]

• Addressed the reviewer’s feedback.
• Tool renamed as: llvm-debuginfo-analyzer.

[CarlosAlbertoEnciso]

For the problems described in https://github.com/llvm/llvm-project/issues/57040:

• Add additional debugging traces.

[CarlosAlbertoEnciso]

Ping.

[probinson]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

36

37

76

Returning a std::vector by value seems inefficient.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVElement.h

345

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

277–307

No need to repeat public:

290

Does this comment apply to all the methods in this block of code? It seems like not, in which case it would be good to put a blank line before the declarations that it does not apply to. (Or even better, comments for each of the other methods!)

[probinson]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

63

No need to repeat public:

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

349

The comment does not describe the second overload; put in a blank line, or preferably a comment for the second one.

652

Comment does not apply to the second overload.

695

Comment does not apply to the second overload.

736

Comment does not apply to the second overload.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

162–184

no need to keep repeating public:

177

Comment does not apply to the second overload.
Also curious that this time the second overload is static when for other classes it is not.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVType.h

132

Comment does not apply to the second overload.
Which is also static ?

llvm/lib/DebugInfo/LogicalView/Core/LVCompare.cpp

36

These appear to be global functions; constexpr implies inline but not static.
They should be static or inside the anonymous namespace.

49

CurrentComparator is a global variable, not even inside any namespace. Could it be a static member inside LVCompare?

llvm/lib/DebugInfo/LogicalView/Core/LVLine.cpp

78

if (!Targets)
  return nullptr;

allows the rest of the function to be less indented.

103

Could this method be marked const ?

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

833

Can reduce indentation by starting with

if (!Targets)
  return nullptr;

868

907

Could simplify slightly by starting with

if (!(References && Targets))
  return;

924

If you don't simplify as suggested above, this if needs braces around the for per LLVM style.

973

Could this method be marked const ?

1054

This sequence looks a bit strange; if neither one is named, compare the filenames? If that's correct maybe the comment should say "file name" instead of "full name"?

1060

The name equals implies a straightforward equality test, which is not really what this method does. In fact it's a little hard for me to describe what it does... looks through a given set of Scopes to find one that equals the current Scope? So maybe findEqualScope would be a better name?

1061

When pointers cannot be null it's usually better practice to pass a reference instead. I understand that this would be a fairly extensive API change, so I won't insist.

1315–1331

Not sure what "Notify the Reader if element comparison" means. It looks like what the code does is "Notify the Reader of the new element."

1813

Same comment as LVScopeAggregate::equals

1882

Same comment as LVScopeAggregate::equals

1945

Same comment as LVScopeAggregate::equals

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

285

Could simplify/reduce indentation by starting with

if (!(References && Targets))
  return;

311

Could reduce indentation by starting with

if (!Targets)
  return nullptr;

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

175

Could simplify by doing this first:

if (!(References && Targets))
  return;

201

Reduce indentation with

if (!Targets)
  return nullptr;

llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp

70

Use ASSERT_NE so the test will abort if allocation fails.

[CarlosAlbertoEnciso]

Update patch due to changes in previous patches.

[CarlosAlbertoEnciso]

Updated patch due to changes in previous patches.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

36

Changed.

37

Changed.

63

Removed redundant public:.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVElement.h

345

Changed to virtual void report(LVComparePass Pass) {}

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

277–307

Removed redundant public:.

290

Added comments to each method.

349

Added comment to second method.

652

Added comment to second method.

695

Added comment to second method.

736

Added comment to second method.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

162–184

Remove redundand public:.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

177

Added comments to second method.

All bool equals(const LVAbc *References, const LVAbc *Targets) methods in all the classes are static.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVType.h

132

Added comment to second method.

All bool equals(const LVAbc *References, const LVAbc *Targets) methods in all the classes are static.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

868

Moved the comment to the include file and changed the comment.

1060

• Renamed method to findEqualScope.
• Added comment to method declarations.

// For the given 'Scopes' returns a scope that is logically equal
// to the current scope; otherwise 'nullptr'.

1813

• Renamed method to findEqualScope.
• Added comment to method declarations.

// For the given 'Scopes' returns a scope that is logically equal
// to the current scope; otherwise 'nullptr'.

1882

• Renamed method to findEqualScope.
• Added comment to method declarations.

// For the given 'Scopes' returns a scope that is logically equal
// to the current scope; otherwise 'nullptr'.

1945

• Renamed method to findEqualScope.
• Added comment to method declarations.

// For the given 'Scopes' returns a scope that is logically equal
// to the current scope; otherwise 'nullptr'.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVLine.cpp

78

Changed.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

833

Changed.

907

Changed to your suggestion.
Removed the extra check condition.

924

Changed to the previous suggestion.

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

285

Changed to your suggestion.
Removed the extra check condition.

311

Changed.

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

175

Changed to your suggestion.
Removed the extra check condition.

201

Changed.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Core/LVCompare.cpp

36

Moved to the anonymous namespace.

49

Moved to the anonymous namespace.

llvm/lib/DebugInfo/LogicalView/Core/LVLine.cpp

103

The method is static.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

973

The method is static.

1061

Good point. Added to the improvements list.

1315–1331

During comparison notify the Reader of the new element.
`

llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp

70

ASSERT_NE can be used only inside functions that don't return a value.

See https://google.github.io/googletest/advanced.html#assertion-placement

The one constraint is that assertions that generate a fatal failure (FAIL* and ASSERT_*) can only be used in void-returning functions.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

76

Good point. Changed.

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

1054

The sequence is correct. That covers the case of unnamed union/struct/class, We use the filename index to determine if they are the same.
Added // In the case of unnamed union/structure/class compare the file name.

[CarlosAlbertoEnciso]

Updated patch to address reviews from @probinson.

[probinson]

LGTM

[psamolysov]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

76

What about to add & after const in method declaration to make the method callable on lvalues only? If a method that returns a reference is callable on an rvalue ("temporary"), a returned reference can become dangling immediately after destroying the temporary.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

76

Nice suggestion. Changed to

const LVPassTable &getPassTable() const & { return PassTable; }

[CarlosAlbertoEnciso]

@psamolysov , @probinson Thanks very much for all your valuable reviews.

[CarlosAlbertoEnciso]

The following patch fixed some buildbot sanitizer issues: https://reviews.llvm.org/D136593

[kda]

In D125782#3879032, @CarlosAlbertoEnciso wrote:

The following patch fixed some buildbot sanitizer issues: https://reviews.llvm.org/D136593

It does not seem to have fixed them all...

https://lab.llvm.org/buildbot/#/builders/168
https://lab.llvm.org/buildbot/#/builders/5/builds/28512

These are still broken claiming this target is the trouble:

Failed Tests (1):
  LLVM-Unit :: DebugInfo/LogicalView/./DebugInfoLogicalViewTests/8/15

Appears to be a leak:

==1565271==ERROR: LeakSanitizer: detected memory leaks
Direct leak of 208 byte(s) in 1 object(s) allocated from:
    #0 0x56055b3457fd in operator new(unsigned long, std::nothrow_t const&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/compiler-rt/lib/asan/asan_new_delete.cpp:101:3
    #1 0x56055b38aaf1 in llvm::logicalview::LVScopeFunction* (anonymous namespace)::ReaderTestCompare::create<llvm::logicalview::LVScopeFunction, void (llvm::logicalview::LVScope::*)()>(void (llvm::logicalview::LVScope::*)()) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp:68:18
    #2 0x56055b3812fa in (anonymous namespace)::ReaderTestCompare::createElements() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp:142:7
    #3 0x56055b3794ae in (anonymous namespace)::LogicalViewTest_CompareElements_Test::TestBody() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp:437:21
    #4 0x56055b63dd6c in HandleExceptionsInMethodIfSupported<testing::Test, void> /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc
    #5 0x56055b63dd6c in testing::Test::Run() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:2508:5
    #6 0x56055b64052c in testing::TestInfo::Run() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:2684:11
    #7 0x56055b64192f in testing::TestSuite::Run() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:2816:28
    #8 0x56055b66c6b1 in testing::internal::UnitTestImpl::RunAllTests() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:5338:44
    #9 0x56055b66b3c1 in HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool> /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc
    #10 0x56055b66b3c1 in testing::UnitTest::Run() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/src/gtest.cc:4925:10
    #11 0x56055b62164a in RUN_ALL_TESTS /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/googletest/include/gtest/gtest.h:2472:46
    #12 0x56055b62164a in main /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/utils/unittest/UnitTestMain/TestMain.cpp:55:10
    #13 0x7f066136ed8f  (/lib/x86_64-linux-gnu/libc.so.6+0x29d8f) (BuildId: 69389d485a9793dbe873f0ea2c93e02efaa9aa3d)

[CarlosAlbertoEnciso]

In D125782#3879682, @kda wrote:

In D125782#3879032, @CarlosAlbertoEnciso wrote:

The following patch fixed some buildbot sanitizer issues: https://reviews.llvm.org/D136593

It does not seem to have fixed them all...

https://lab.llvm.org/buildbot/#/builders/168
https://lab.llvm.org/buildbot/#/builders/5/builds/28512

@kda Commited the fix. Sorry for any inconvenience.

[kda]

These are still broken claiming this target is the trouble:

Failed Tests (1):
  LLVM-Unit :: DebugInfo/LogicalView/./DebugInfoLogicalViewTests/8/15

Appears to be a leak:

Some of it can be cleaned up by deleting CompileUnit, but there is other issues: see comment in test source.

The memory ownership model is pretty unusual here. It seems that this would benefit from more use of unique_ptr to automate ownership (destruction).
Without a fix, this will probably need to be rolled back.

llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp

211

In the case of line 437 (below), FunctionTwo is unowned and is not deleted.
I don't know if it is even used when IsTarget is false, but it is allocated and is a leak.

I see this behavior repeated for IsReference.

[CarlosAlbertoEnciso]

In D125782#3880212, @kda wrote:

Some of it can be cleaned up by deleting CompileUnit, but there is other issues: see comment in test source.

The memory leak is caused by those Child that are not added to a Parent. The other allocated items are removed when the Reader is destroyed.

The memory ownership model is pretty unusual here. It seems that this would benefit from more use of unique_ptr to automate ownership (destruction).

One of the areas discussed in the reviews for the tool llvm-debuginfo-analyzer is the use unique_ptr, which will be addressed once all the patches are commited.

Without a fix, this will probably need to be rolled back.

For these builds
https://lab.llvm.org/buildbot/#/builders/168
https://lab.llvm.org/buildbot/#/builders/5/builds/28512
the issues are in stage2/asan check

With the fix
https://lab.llvm.org/buildbot/#/builders/168/builds/9681
https://lab.llvm.org/buildbot/#/builders/5/builds/28517
the step stage2/asan check passed.

https://lab.llvm.org/buildbot/#/builders/5/builds/28517 - SUCCESS.

[kda]

Looking better already:
https://lab.llvm.org/buildbot/#/builders/168/builds/9681

Thank you.

[CarlosAlbertoEnciso]

In D125782#3880529, @kda wrote:

Looking better already:
https://lab.llvm.org/buildbot/#/builders/168/builds/9681

Thank you.

You're welcome.

llvm/include/llvm/DebugInfo/LogicalView/Core/LVCompare.h

+//===-- LVCompare.h ---------------------------------------------*- C++ -*-===//
+//
+// 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 file defines the LVCompare class, which is used to describe a logical
+// view comparison.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVCOMPARE_H
+#define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVCOMPARE_H
+
+#include "llvm/DebugInfo/LogicalView/Core/LVObject.h"
+
+namespace llvm {
+namespace logicalview {
+
+class LVReader;
+
+// Record the elements missing or added and their compare pass.
+using LVPassEntry = std::tuple<LVReader *, LVElement *, LVComparePass>;
+using LVPassTable = std::vector<LVPassEntry>;
+
+class LVCompare final {
+  raw_ostream &OS;
+  LVScopes ScopeStack;
+
+  // As the comparison is performed twice (by exchanging the reference
+  // and target readers) the element missing/added status does specify
+  // the comparison pass.
+  // By recording each missing/added elements along with its pass, it
+  // allows checking which elements were missing/added during each pass.
+  LVPassTable PassTable;
+
+  // Reader used on the LHS of the comparison.
+  // In the 'Missing' pass, it points to the reference reader.
+  // In the 'Added' pass it points to the target reader.
+  LVReader *Reader = nullptr;
+
+  bool FirstMissing = true;
+  bool PrintLines = false;
+  bool PrintScopes = false;
+  bool PrintSymbols = false;
+  bool PrintTypes = false;
+
+  static void setInstance(LVCompare *Compare);
+
+  void printCurrentStack();
+  void printSummary() const;
+
+public:
+  LVCompare() = delete;
+  LVCompare(raw_ostream &OS);
+  LVCompare(const LVCompare &) = delete;
+  LVCompare &operator=(const LVCompare &) = delete;
+  ~LVCompare() = default;
+
+  static LVCompare &getInstance();
+
+  // Scopes stack used during the missing/added reporting.
+  void push(LVScope *Scope) { ScopeStack.push_back(Scope); }
+  void pop() { ScopeStack.pop_back(); }
+
+  // Perform comparison between the 'Reference' and 'Target' scopes tree.
+  Error execute(LVReader *ReferenceReader, LVReader *TargetReader);
+
+  void addPassEntry(LVReader *Reader, LVElement *Element, LVComparePass Pass) {
+    PassTable.emplace_back(Reader, Element, Pass);
+  }
+  const LVPassTable &getPassTable() const & { return PassTable; }
+
+  void printItem(LVElement *Element, LVComparePass Pass);
+  void print(raw_ostream &OS) const;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  void dump() const { print(dbgs()); }
+#endif
+};
+
+inline LVCompare &getComparator() { return LVCompare::getInstance(); }
+
+} // end namespace logicalview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVCOMPARE_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVElement.h

public:
   // The following functions 'resolve' some of their properties, such as
   // name, references, parents, extra information based on the element kind.
   virtual void resolve();
   virtual void resolveExtra() {}
   virtual void resolveName();
   virtual void resolveReferences() {}
   void resolveParents();
 
+  bool referenceMatch(const LVElement *Element) const;
+
+  // Returns true if current element is logically equal to the given 'Element'.
+  bool equals(const LVElement *Element) const;
+
+  // Report the current element as missing or added during comparison.
+  virtual void report(LVComparePass Pass) {}
+
   static LVElementDispatch &getDispatch() { return Dispatch; }
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVELEMENT_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLine.h

 using LVLineRequest = std::vector<LVLineGetFunction>;
 
 // Class to represent a logical line.
 class LVLine : public LVElement {
   // Typed bitvector with kinds for this line.
   LVProperties<LVLineKind> Kinds;
   static LVLineDispatch Dispatch;
 
+  // Find the current line in the given 'Targets'.
+  LVLine *findIn(const LVLines *Targets) const;
+
 public:
   LVLine() : LVElement(LVSubclassID::LV_LINE) {
     setIsLine();
     setIncludeInPrint();
   }
   LVLine(const LVLine &) = delete;
   LVLine &operator=(const LVLine &) = delete;
   virtual ~LVLine() = default;
public:
   // Line number for display; in the case of Inlined Functions, we use the
   // DW_AT_call_line attribute; otherwise use DW_AT_decl_line attribute.
   std::string lineNumberAsString(bool ShowZero = false) const override {
     return lineAsString(getLineNumber(), getDiscriminator(), ShowZero);
   }
 
   static LVLineDispatch &getDispatch() { return Dispatch; }
 
+  // Iterate through the 'References' set and check that all its elements
+  // are present in the 'Targets' set. For a missing element, mark its
+  // parents as missing.
+  static void markMissingParents(const LVLines *References,
+                                 const LVLines *Targets);
+
+  // Returns true if current line is logically equal to the given 'Line'.
+  virtual bool equals(const LVLine *Line) const;
+
+  // Returns true if the given 'References' are logically equal to the
+  // given 'Targets'.
+  static bool equals(const LVLines *References, const LVLines *Targets);
+
+  // Report the current line as missing or added during comparison.
+  void report(LVComparePass Pass) override;
+
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
 #endif
 };
 
public:
 
   // Access DW_LNE_set_discriminator attribute.
   uint32_t getDiscriminator() const override { return Discriminator; }
   void setDiscriminator(uint32_t Value) override {
     Discriminator = Value;
     setIsDiscriminator();
   }
 
+  // Returns true if current line is logically equal to the given 'Line'.
+  bool equals(const LVLine *Line) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent an assembler line extracted from the text section.
 class LVLineAssembler final : public LVLine {
 public:
   LVLineAssembler() : LVLine() { setIsLineAssembler(); }
   LVLineAssembler(const LVLineAssembler &) = delete;
   LVLineAssembler &operator=(const LVLineAssembler &) = delete;
   ~LVLineAssembler() = default;
 
   // Print blanks as the line number.
   std::string noLineAsString(bool ShowZero) const override {
     return std::string(8, ' ');
   };
 
+  // Returns true if current line is logically equal to the given 'Line'.
+  bool equals(const LVLine *Line) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLINE_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVObject.h

 using LVSymbols = SmallVector<LVSymbol *, 8>;
 using LVTypes = SmallVector<LVType *, 8>;
 
 using LVOffsets = SmallVector<LVOffset, 8>;
 
 const LVAddress MaxAddress = std::numeric_limits<uint64_t>::max();
 
 enum class LVBinaryType { NONE, ELF, COFF };
+enum class LVComparePass { Missing, Added };
 
 // Validate functions.
 using LVValidLocation = bool (LVLocation::*)();
 
 // Keep counters of objects.
 struct LVCounter {
   unsigned Lines = 0;
   unsigned Scopes = 0;
#endif
   // aggregated scopes, compile unit, functions and namespaces.
   virtual Error doPrint(bool Split, bool Match, bool Print, raw_ostream &OS,
                         bool Full = true) const;
   void printAttributes(raw_ostream &OS, bool Full = true) const;
   void printAttributes(raw_ostream &OS, bool Full, StringRef Name,
                        LVObject *Parent, StringRef Value,
                        bool UseQuotes = false, bool PrintRef = false) const;
 
+  // Mark branch as missing (current element and parents).
+  void markBranchAsMissing();
+
   // Prints the common information for an object (name, type, etc).
   virtual void print(raw_ostream &OS, bool Full = true) const;
   // Prints additional information for an object, depending on its kind
   // (class attributes, debug ranges, files, directories, etc).
   virtual void printExtra(raw_ostream &OS, bool Full = true) const {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   virtual void dump() const { print(dbgs()); }

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

class LVReader {
 
   // Context used by '--output=split' command line option.
   LVSplitContext SplitContext;
 
   // Compile Units DIE Offset => Scope.
   using LVCompileUnits = std::map<LVOffset, LVScopeCompileUnit *>;
   LVCompileUnits CompileUnits;
 
+  // Added elements to be used during elements comparison.
+  LVLines Lines;
+  LVScopes Scopes;
+  LVSymbols Symbols;
+  LVTypes Types;
+
   // Create split folder.
   Error createSplitFolder();
   bool OutputSplit = false;
 
 protected:
   LVScopeRoot *Root = nullptr;
   std::string InputFilename;
   std::string FileFormatName;
public:
 
   virtual bool isSystemEntry(LVElement *Element, StringRef Name = {}) {
     return false;
   };
 
   // Access to split context.
   LVSplitContext &getSplitContext() { return SplitContext; }
 
+  // In the case of element comparison, register that added element.
+  void notifyAddedElement(LVLine *Line) {
+    if (!options().getCompareContext() && options().getCompareLines())
+      Lines.push_back(Line);
+  }
+  void notifyAddedElement(LVScope *Scope) {
+    if (!options().getCompareContext() && options().getCompareScopes())
+      Scopes.push_back(Scope);
+  }
+  void notifyAddedElement(LVSymbol *Symbol) {
+    if (!options().getCompareContext() && options().getCompareSymbols())
+      Symbols.push_back(Symbol);
+  }
+  void notifyAddedElement(LVType *Type) {
+    if (!options().getCompareContext() && options().getCompareTypes())
+      Types.push_back(Type);
+  }
+
+  const LVLines &getLines() const { return Lines; }
+  const LVScopes &getScopes() const { return Scopes; }
+  const LVSymbols &getSymbols() const { return Symbols; }
+  const LVTypes &getTypes() const { return Types; }
+
   // Conditions to print an object.
   bool doPrintLine(const LVLine *Line) const {
     return patterns().printElement(Line);
   }
   bool doPrintLocation(const LVLocation *Location) const {
     return patterns().printObject(Location);
   }
   bool doPrintScope(const LVScope *Scope) const {

llvm/include/llvm/DebugInfo/LogicalView/Core/LVScope.h

void calculateCoverage() {
     float CoveragePercentage = 0;
     LVLocation::calculateCoverage(Ranges, CoverageFactor, CoveragePercentage);
   }
 
   // Decide if the scope will be printed, using some conditions given by:
   // only-globals, only-locals, a-pattern.
   bool resolvePrinting() const;
 
+  // Find the current scope in the given 'Targets'.
+  LVScope *findIn(const LVScopes *Targets) const;
+
   // Traverse the scope parent tree, executing the given callback function
   // on each scope.
   void traverseParents(LVScopeGetFunction GetFunction,
                        LVScopeSetFunction SetFunction);
 
 protected:
   // Types, Symbols, Scopes, Lines, Locations in this scope.
   LVAutoTypes *Types = nullptr;
public:
   void sort();
 
   // Get template parameter types.
   bool getTemplateParameterTypes(LVTypes &Params);
 
   // DW_AT_specification, DW_AT_abstract_origin, DW_AT_extension.
   virtual LVScope *getReference() const { return nullptr; }
 
+  LVScope *getCompileUnitParent() const override {
+    return LVElement::getCompileUnitParent();
+  }
+
   // Follow a chain of references given by DW_AT_abstract_origin and/or
   // DW_AT_specification and update the scope name.
   StringRef resolveReferencesChain();
 
   bool removeElement(LVElement *Element) override;
   void updateLevel(LVScope *Parent, bool Moved) override;
 
   void resolve() override;
   void resolveName() override;
   void resolveReferences() override;
 
   // Return the chain of parents as a string.
   void getQualifiedName(std::string &QualifiedName) const;
   // Encode the template arguments.
   void encodeTemplateArguments(std::string &Name) const;
   void encodeTemplateArguments(std::string &Name, const LVTypes *Types) const;
 
   void resolveElements();
 
+  // Iterate through the 'References' set and check that all its elements
+  // are present in the 'Targets' set. For a missing element, mark its
+  // parents as missing.
+  static void markMissingParents(const LVScopes *References,
+                                 const LVScopes *Targets,
+                                 bool TraverseChildren);
+
+  // Checks if the current scope is contained within the target scope.
+  // Depending on the result, the callback may be performed.
+  virtual void markMissingParents(const LVScope *Target, bool TraverseChildren);
+
+  // Returns true if the current scope and the given 'Scope' have the
+  // same number of children.
+  virtual bool equalNumberOfChildren(const LVScope *Scope) const;
+
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  virtual bool equals(const LVScope *Scope) const;
+
+  // Returns true if the given 'References' are logically equal to the
+  // given 'Targets'.
+  static bool equals(const LVScopes *References, const LVScopes *Targets);
+
+  // For the given 'Scopes' returns a scope that is logically equal
+  // to the current scope; otherwise 'nullptr'.
+  virtual LVScope *findEqualScope(const LVScopes *Scopes) const;
+
+  // Report the current scope as missing or added during comparison.
+  void report(LVComparePass Pass) override;
+
   static LVScopeDispatch &getDispatch() { return Dispatch; }
 
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
   virtual void printWarnings(raw_ostream &OS, bool Full = true) const {}
   virtual void printMatchedElements(raw_ostream &OS, bool UseMatchedElements) {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
public:
 
   StringRef getEncodedArgs() const override {
     return getStringPool().getString(EncodedArgsIndex);
   }
   void setEncodedArgs(StringRef EncodedArgs) override {
     EncodedArgsIndex = getStringPool().getIndex(EncodedArgs);
   }
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
+  // For the given 'Scopes' returns a scope that is logically equal
+  // to the current scope; otherwise 'nullptr'.
+  LVScope *findEqualScope(const LVScopes *Scopes) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF Template alias.
 class LVScopeAlias final : public LVScope {
 public:
   LVScopeAlias() : LVScope() {
     setIsTemplateAlias();
     setIsTemplate();
   }
   LVScopeAlias(const LVScopeAlias &) = delete;
   LVScopeAlias &operator=(const LVScopeAlias &) = delete;
   ~LVScopeAlias() = default;
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF array (DW_TAG_array_type).
 class LVScopeArray final : public LVScope {
 public:
   LVScopeArray() : LVScope() { setIsArray(); }
   LVScopeArray(const LVScopeArray &) = delete;
   LVScopeArray &operator=(const LVScopeArray &) = delete;
   ~LVScopeArray() = default;
 
   void resolveExtra() override;
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF Compilation Unit (CU).
 class LVScopeCompileUnit final : public LVScope {
   // Names (files and directories) used by the Compile Unit.
   std::vector<size_t> Filenames;
 
public:
   // Values are used by '--summary' option (allocated).
   void increment(LVLine *Line);
   void increment(LVScope *Scope);
   void increment(LVSymbol *Symbol);
   void increment(LVType *Type);
 
   // A new element has been added to the scopes tree. Take the following steps:
   // Increase the added element counters, for printing summary.
-  // Notify the Reader if element comparison.
+  // During comparison notify the Reader of the new element.
   void addedElement(LVLine *Line);
   void addedElement(LVScope *Scope);
   void addedElement(LVSymbol *Symbol);
   void addedElement(LVType *Type);
 
   void addSize(LVScope *Scope, LVOffset Lower, LVOffset Upper);
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
   void printWarnings(raw_ostream &OS, bool Full = true) const override;
   void printMatchedElements(raw_ostream &OS, bool UseMatchedElements) override;
 };
 
 // Class to represent a DWARF enumerator (DW_TAG_enumeration_type).
 class LVScopeEnumeration final : public LVScope {
 public:
   LVScopeEnumeration() : LVScope() { setIsEnumeration(); }
   LVScopeEnumeration(const LVScopeEnumeration &) = delete;
   LVScopeEnumeration &operator=(const LVScopeEnumeration &) = delete;
   ~LVScopeEnumeration() = default;
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF formal parameter pack
 // (DW_TAG_GNU_formal_parameter_pack).
 class LVScopeFormalPack final : public LVScope {
 public:
   LVScopeFormalPack() : LVScope() { setIsTemplatePack(); }
   LVScopeFormalPack(const LVScopeFormalPack &) = delete;
   LVScopeFormalPack &operator=(const LVScopeFormalPack &) = delete;
   ~LVScopeFormalPack() = default;
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF Function.
 class LVScopeFunction : public LVScope {
   LVScope *Reference = nullptr; // DW_AT_specification, DW_AT_abstract_origin.
   size_t LinkageNameIndex = 0;  // Function DW_AT_linkage_name attribute.
   size_t EncodedArgsIndex = 0;  // Template encoded arguments.
public:
   }
   size_t getLinkageNameIndex() const override { return LinkageNameIndex; }
 
   void setName(StringRef ObjectName) override;
 
   void resolveExtra() override;
   void resolveReferences() override;
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
+  // For the given 'Scopes' returns a scope that is logically equal
+  // to the current scope; otherwise 'nullptr'.
+  LVScope *findEqualScope(const LVScopes *Scopes) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF inlined function.
 class LVScopeFunctionInlined final : public LVScopeFunction {
   size_t CallFilenameIndex = 0;
   uint32_t CallLineNumber = 0;
   uint32_t Discriminator = 0;
public:
   // Line number for display; in the case of Inlined Functions, we use the
   // DW_AT_call_line attribute; otherwise use DW_AT_decl_line attribute.
   std::string lineNumberAsString(bool ShowZero = false) const override {
     return lineAsString(getCallLineNumber(), getDiscriminator(), ShowZero);
   }
 
   void resolveExtra() override;
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
+  // For the given 'Scopes' returns a scope that is logically equal
+  // to the current scope; otherwise 'nullptr'.
+  LVScope *findEqualScope(const LVScopes *Scopes) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF subroutine type.
 class LVScopeFunctionType final : public LVScopeFunction {
 public:
   LVScopeFunctionType() : LVScopeFunction() { setIsFunctionType(); }
   LVScopeFunctionType(const LVScopeFunctionType &) = delete;
public:
   void setReference(LVScope *Scope) override {
     Reference = Scope;
     setHasReference();
   }
   void setReference(LVElement *Element) override {
     setReference(static_cast<LVScope *>(Element));
   }
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
+  // For the given 'Scopes' returns a scope that is logically equal
+  // to the current scope; otherwise 'nullptr'.
+  LVScope *findEqualScope(const LVScopes *Scopes) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent the binary file being analyzed.
 class LVScopeRoot final : public LVScope {
   size_t FileFormatNameIndex = 0;
 
 public:
   LVScopeRoot() : LVScope() { setIsRoot(); }
   LVScopeRoot(const LVScopeRoot &) = delete;
   LVScopeRoot &operator=(const LVScopeRoot &) = delete;
   ~LVScopeRoot() = default;
 
   StringRef getFileFormatName() const {
     return getStringPool().getString(FileFormatNameIndex);
   }
   void setFileFormatName(StringRef FileFormatName) {
     FileFormatNameIndex = getStringPool().getIndex(FileFormatName);
   }
 
   // Process the collected location, ranges and calculate coverage.
   void processRangeInformation();
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
   Error doPrintMatches(bool Split, raw_ostream &OS,
                        bool UseMatchedElements) const;
 };
 
 // Class to represent a DWARF template parameter pack
 // (DW_TAG_GNU_template_parameter_pack).
 class LVScopeTemplatePack final : public LVScope {
 public:
   LVScopeTemplatePack() : LVScope() { setIsTemplatePack(); }
   LVScopeTemplatePack(const LVScopeTemplatePack &) = delete;
   LVScopeTemplatePack &operator=(const LVScopeTemplatePack &) = delete;
   ~LVScopeTemplatePack() = default;
 
+  // Returns true if current scope is logically equal to the given 'Scope'.
+  bool equals(const LVScope *Scope) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

class LVSymbol final : public LVElement {
   // Coverage factor in units (bytes).
   unsigned CoverageFactor = 0;
   float CoveragePercentage = 0;
 
   // Add a location gap into the location list.
   LVAutoLocations::iterator addLocationGap(LVAutoLocations::iterator Pos,
                                            LVAddress LowPC, LVAddress HighPC);
 
+  // Find the current symbol in the given 'Targets'.
+  LVSymbol *findIn(const LVSymbols *Targets) const;
+
 public:
   LVSymbol() : LVElement(LVSubclassID::LV_SYMBOL) {
     setIsSymbol();
     setIncludeInPrint();
   }
   LVSymbol(const LVSymbol &) = delete;
   LVSymbol &operator=(const LVSymbol &) = delete;
   ~LVSymbol() { delete Locations; }
public:
   // Follow a chain of references given by DW_AT_abstract_origin and/or
   // DW_AT_specification and update the symbol name.
   StringRef resolveReferencesChain();
 
   void resolveName() override;
   void resolveReferences() override;
 
   static LVSymbolDispatch &getDispatch() { return Dispatch; }
 
+  static bool parametersMatch(const LVSymbols *References,
+                              const LVSymbols *Targets);
+
+  static void getParameters(const LVSymbols *Symbols, LVSymbols *Parameters);
+
+  // Iterate through the 'References' set and check that all its elements
+  // are present in the 'Targets' set. For a missing element, mark its
+  // parents as missing.
+  static void markMissingParents(const LVSymbols *References,
+                                 const LVSymbols *Targets);
+
+  // Returns true if current type is logically equal to the given 'Symbol'.
+  bool equals(const LVSymbol *Symbol) const;
+
+  // Returns true if the given 'References' are logically equal to the
+  // given 'Targets'.
+  static bool equals(const LVSymbols *References, const LVSymbols *Targets);
+
+  // Report the current symbol as missing or added during comparison.
+  void report(LVComparePass Pass) override;
+
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
 #endif
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSYMBOL_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVType.h

 class LVType : public LVElement {
   enum class Property { IsSubrangeCount, LastEntry };
 
   // Typed bitvector with kinds and properties for this type.
   LVProperties<LVTypeKind> Kinds;
   LVProperties<Property> Properties;
   static LVTypeDispatch Dispatch;
 
+  // Find the current type in the given 'Targets'.
+  LVType *findIn(const LVTypes *Targets) const;
+
 public:
   LVType() : LVElement(LVSubclassID::LV_TYPE) { setIsType(); }
   LVType(const LVType &) = delete;
   LVType &operator=(const LVType &) = delete;
   virtual ~LVType() = default;
 
   static bool classof(const LVElement *Element) {
     return Element->getSubclassID() == LVSubclassID::LV_TYPE;
public:
   virtual LVElement *getUnderlyingType() { return nullptr; }
   virtual void setUnderlyingType(LVElement *Element) {}
 
   void resolveName() override;
   void resolveReferences() override;
 
   static LVTypeDispatch &getDispatch() { return Dispatch; }
 
+  static bool parametersMatch(const LVTypes *References,
+                              const LVTypes *Targets);
+
+  static void getParameters(const LVTypes *Types, LVTypes *TypesParam,
+                            LVScopes *ScopesParam);
+
+  // Iterate through the 'References' set and check that all its elements
+  // are present in the 'Targets' set. For a missing element, mark its
+  // parents as missing.
+  static void markMissingParents(const LVTypes *References,
+                                 const LVTypes *Targets);
+
+  // Returns true if current type is logically equal to the given 'Type'.
+  virtual bool equals(const LVType *Type) const;
+
+  // Returns true if the given 'References' are logically equal to the
+  // given 'Targets'.
+  static bool equals(const LVTypes *References, const LVTypes *Targets);
+
+  // Report the current type as missing or added during comparison.
+  void report(LVComparePass Pass) override;
+
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const override { print(dbgs()); }
 #endif
 };
 
public:
   ~LVTypeDefinition() = default;
 
   // Return the underlying type for a type definition.
   LVElement *getUnderlyingType() override;
   void setUnderlyingType(LVElement *Element) override { setType(Element); }
 
   void resolveExtra() override;
 
+  // Returns true if current type is logically equal to the given 'Type'.
+  bool equals(const LVType *Type) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DW_TAG_enumerator.
 class LVTypeEnumerator final : public LVType {
   // Index in the String pool representing any initial value.
   size_t ValueIndex = 0;
 
public:
   std::string getValue() const override {
     return std::string(getStringPool().getString(ValueIndex));
   }
   void setValue(StringRef Value) override {
     ValueIndex = getStringPool().getIndex(Value);
   }
   size_t getValueIndex() const override { return ValueIndex; }
 
+  // Returns true if current type is logically equal to the given 'Type'.
+  bool equals(const LVType *Type) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent DW_TAG_imported_module / DW_TAG_imported_declaration.
 class LVTypeImport final : public LVType {
 public:
   LVTypeImport() : LVType() { setIncludeInPrint(); }
   LVTypeImport(const LVTypeImport &) = delete;
   LVTypeImport &operator=(const LVTypeImport &) = delete;
   ~LVTypeImport() = default;
 
+  // Returns true if current type is logically equal to the given 'Type'.
+  bool equals(const LVType *Type) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DWARF Template parameter holder (type or param).
 class LVTypeParam final : public LVType {
   // Index in the String pool representing any initial value.
   size_t ValueIndex = 0;
 
public:
   void setValue(StringRef Value) override {
     ValueIndex = getStringPool().getIndex(Value);
   }
   size_t getValueIndex() const override { return ValueIndex; }
 
   // Encode the specific template argument.
   void encodeTemplateArgument(std::string &Name) const override;
 
+  // Returns true if current type is logically equal to the given 'Type'.
+  bool equals(const LVType *Type) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 // Class to represent a DW_TAG_subrange_type.
 class LVTypeSubrange final : public LVType {
   // Values describing the subrange bounds.
   int64_t LowerBound = 0; // DW_AT_lower_bound or DW_AT_count value.
   int64_t UpperBound = 0; // DW_AT_upper_bound value.
public:
   }
   void setBounds(unsigned Lower, unsigned Upper) override {
     LowerBound = Lower;
     UpperBound = Upper;
   }
 
   void resolveExtra() override;
 
+  // Returns true if current type is logically equal to the given 'Type'.
+  bool equals(const LVType *Type) const override;
+
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVTYPE_H

llvm/lib/DebugInfo/LogicalView/CMakeLists.txt

 macro(add_lv_impl_folder group)
   list(APPEND LV_IMPL_SOURCES ${ARGN})
   source_group(${group} FILES ${ARGN})
 endmacro()
 
 add_lv_impl_folder(Core
+  Core/LVCompare.cpp
   Core/LVElement.cpp
   Core/LVLine.cpp
   Core/LVLocation.cpp
   Core/LVObject.cpp
   Core/LVOptions.cpp
   Core/LVRange.cpp
   Core/LVReader.cpp
   Core/LVScope.cpp

llvm/lib/DebugInfo/LogicalView/Core/LVCompare.cpp

+//===-- 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"; }

llvm/lib/DebugInfo/LogicalView/Core/LVElement.cpp

void LVElement::resolveQualifiedName() {
   LLVM_DEBUG({
     dbgs() << "Offset: " << hexSquareString(getOffset())
            << ", Kind: " << formattedKind(kind())
            << ", Name: " << formattedName(getName())
            << ", QualifiedName: " << formattedName(Name) << "\n";
   });
 }
 
+bool LVElement::referenceMatch(const LVElement *Element) const {
+  return (getHasReference() && Element->getHasReference()) ||
+         (!getHasReference() && !Element->getHasReference());
+}
+
+bool LVElement::equals(const LVElement *Element) const {
+  // The minimum factors that must be the same for an equality are:
+  // line number, level, name, qualified name and filename.
+  LLVM_DEBUG({
+    dbgs() << "\n[Element::equals]\n";
+    if (options().getAttributeOffset()) {
+      dbgs() << "Reference: " << hexSquareString(getOffset()) << "\n";
+      dbgs() << "Target   : " << hexSquareString(Element->getOffset()) << "\n";
+    }
+    dbgs() << "Reference: "
+           << "Kind = " << formattedKind(kind()) << ", "
+           << "Name = " << formattedName(getName()) << ", "
+           << "Qualified = " << formattedName(getQualifiedName()) << "\n"
+           << "Target   : "
+           << "Kind = " << formattedKind(Element->kind()) << ", "
+           << "Name = " << formattedName(Element->getName()) << ", "
+           << "Qualified = " << formattedName(Element->getQualifiedName())
+           << "\n"
+           << "Reference: "
+           << "NameIndex = " << getNameIndex() << ", "
+           << "QualifiedNameIndex = " << getQualifiedNameIndex() << ", "
+           << "FilenameIndex = " << getFilenameIndex() << "\n"
+           << "Target   : "
+           << "NameIndex = " << Element->getNameIndex() << ", "
+           << "QualifiedNameIndex = " << Element->getQualifiedNameIndex()
+           << ", "
+           << "FilenameIndex = " << Element->getFilenameIndex() << "\n";
+  });
+  if ((getLineNumber() != Element->getLineNumber()) ||
+      (getLevel() != Element->getLevel()))
+    return false;
+
+  if ((getQualifiedNameIndex() != Element->getQualifiedNameIndex()) ||
+      (getNameIndex() != Element->getNameIndex()) ||
+      (getFilenameIndex() != Element->getFilenameIndex()))
+    return false;
+
+  if (!getType() && !Element->getType())
+    return true;
+  if (getType() && Element->getType())
+    return getType()->equals(Element->getType());
+  return false;
+}
+
 // Print the FileName Index.
 void LVElement::printFileIndex(raw_ostream &OS, bool Full) const {
   if (options().getPrintFormatting() && options().getAttributeAnySource() &&
       getFilenameIndex()) {
 
     // Check if there is a change in the File ID sequence.
     size_t Index = getFilenameIndex();
     if (options().changeFilenameIndex(Index)) {

llvm/lib/DebugInfo/LogicalView/Core/LVLine.cpp

 //===-- LVLine.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 LVLine class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 #define DEBUG_TYPE "Line"
 
 namespace {

 // String used as padding for printing elements with no line number.
 std::string LVLine::noLineAsString(bool ShowZero) const {
   if (options().getInternalNone())
     return LVObject::noLineAsString(ShowZero);
   return (ShowZero || options().getAttributeZero()) ? ("    0   ")
                                                     : ("    -   ");
 }
 
+void LVLine::markMissingParents(const LVLines *References,
+                                const LVLines *Targets) {
+  if (!(References && Targets))
+    return;
+
+  LLVM_DEBUG({
+    dbgs() << "\n[LVLine::markMissingParents]\n";
+    for (const LVLine *Reference : *References)
+      dbgs() << "References: "
+             << "Kind = " << formattedKind(Reference->kind()) << ", "
+             << "Line = " << Reference->getLineNumber() << "\n";
+    for (const LVLine *Target : *Targets)
+      dbgs() << "Targets   : "
+             << "Kind = " << formattedKind(Target->kind()) << ", "
+             << "Line = " << Target->getLineNumber() << "\n";
+  });
+
+  for (LVLine *Reference : *References) {
+    LLVM_DEBUG({
+      dbgs() << "Search Reference: Line = " << Reference->getLineNumber()
+             << "\n";
+    });
+    if (!Reference->findIn(Targets))
+      Reference->markBranchAsMissing();
+  }
+}
+
+LVLine *LVLine::findIn(const LVLines *Targets) const {
+  if (!Targets)
+    return nullptr;
+
+  LLVM_DEBUG({
+    dbgs() << "\n[LVLine::findIn]\n"
+           << "Reference: "
+           << "Level = " << getLevel() << ", "
+           << "Kind = " << formattedKind(kind()) << ", "
+           << "Line = " << getLineNumber() << "\n";
+    for (const LVLine *Target : *Targets)
+      dbgs() << "Target   : "
+             << "Level = " << Target->getLevel() << ", "
+             << "Kind = " << formattedKind(Target->kind()) << ", "
+             << "Line = " << Target->getLineNumber() << "\n";
+  });
+
+  for (LVLine *Line : *Targets)
+    if (equals(Line))
+      return Line;
+
+  return nullptr;
+}
+
+bool LVLine::equals(const LVLine *Line) const {
+  return LVElement::equals(Line);
+}
+
+bool LVLine::equals(const LVLines *References, const LVLines *Targets) {
+  if (!References && !Targets)
+    return true;
+  if (References && Targets && References->size() == Targets->size()) {
+    for (const LVLine *Reference : *References)
+      if (!Reference->findIn(Targets))
+        return false;
+    return true;
+  }
+  return false;
+}
+
+void LVLine::report(LVComparePass Pass) {
+  getComparator().printItem(this, Pass);
+}
+
 void LVLine::print(raw_ostream &OS, bool Full) const {
   if (getReader().doPrintLine(this)) {
     getReaderCompileUnit()->incrementPrintedLines();
     LVElement::print(OS, Full);
     printExtra(OS, Full);
   }
 }
 
std::string LVLineDebug::statesInfo(bool Formatted) const {
   if (getIsNeverStepInto()) {
     Stream << Separator << "{" << KindNeverStepInto << "}";
     Separator = " ";
   }
 
   return String;
 }
 
+bool LVLineDebug::equals(const LVLine *Line) const {
+  if (!LVLine::equals(Line))
+    return false;
+  return getFilenameIndex() == Line->getFilenameIndex();
+}
+
 void LVLineDebug::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind());
 
   if (options().getAttributeQualifier()) {
     // The qualifier includes the states information and the source filename
     // that contains the line element.
     OS << statesInfo(/*Formatted=*/true);
     OS << " " << formattedName(getPathname());
   }
   OS << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // Assembler line extracted from the ELF .text section.
 //===----------------------------------------------------------------------===//
+bool LVLineAssembler::equals(const LVLine *Line) const {
+  return LVLine::equals(Line);
+}
+
 void LVLineAssembler::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind());
   OS << " " << formattedName(getName());
   OS << "\n";
 }

llvm/lib/DebugInfo/LogicalView/Core/LVObject.cpp

void LVObject::setParent(LVScope *Scope) {
   Parent.Scope = Scope;
   setLevel(Scope->getLevel() + 1);
 }
 void LVObject::setParent(LVSymbol *Symbol) {
   Parent.Symbol = Symbol;
   setLevel(Symbol->getLevel() + 1);
 }
 
+void LVObject::markBranchAsMissing() {
+  // Mark the current object as 'missing'; then traverse the parents chain
+  // marking them as 'special missing' to indicate a missing branch. They
+  // can not be marked as missing, because will generate incorrect reports.
+  LVObject *Parent = this;
+  Parent->setIsMissing();
+  while (Parent) {
+    Parent->setIsMissingLink();
+    Parent = Parent->getParent();
+  }
+}
+
 Error LVObject::doPrint(bool Split, bool Match, bool Print, raw_ostream &OS,
                         bool Full) const {
   print(OS, Full);
   return Error::success();
 }
 
 void LVObject::printAttributes(raw_ostream &OS, bool Full, StringRef Name,
                                LVObject *Parent, StringRef Value,
else
     OS << Value << "\n";
 }
 
 void LVObject::printAttributes(raw_ostream &OS, bool Full) const {
 #ifndef NDEBUG
   if (options().getInternalID())
     OS << hexSquareString(getID());
 #endif
+  if (options().getCompareExecute() &&
+      (options().getAttributeAdded() || options().getAttributeMissing()))
+    OS << (getIsAdded() ? '+' : getIsMissing() ? '-' : ' ');
   if (options().getAttributeOffset())
     OS << hexSquareString(getOffset());
   if (options().getAttributeLevel()) {
     std::stringstream Stream;
     Stream.str(std::string());
     Stream << "[" << std::setfill('0') << std::setw(3) << getLevel() << "]";
     std::string TheLevel(Stream.str());
     OS << TheLevel;

llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp

if (options().getReportExecute()) {
 
     return Error::success();
   }
 
   return printScopes();
 }
 
 Error LVReader::printScopes() {
-  if (bool DoPrint = options().getPrintExecute()) {
+  if (bool DoPrint =
+          (options().getPrintExecute() || options().getComparePrint())) {
     if (Error Err = createSplitFolder())
       return Err;
 
     // Start printing from the root.
     bool DoMatch = options().getSelectGenericPattern() ||
                    options().getSelectGenericKind() ||
                    options().getSelectOffsetPattern();
     return Root->doPrint(OutputSplit, DoMatch, DoPrint, OS);

llvm/lib/DebugInfo/LogicalView/Core/LVScope.cpp

 //===-- LVScope.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 LVScope class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLocation.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVRange.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
 
 using namespace llvm;
if (ParentRanges)
       for (const LVLocation *Location : *ParentRanges)
         if (Location->getLowerAddress() <= Address)
           return Parent;
     Parent = Parent->getParentScope();
   }
   return Parent;
 }
 
+LVScope *LVScope::findIn(const LVScopes *Targets) const {
+  if (!Targets)
+    return nullptr;
+
+  // In the case of overloaded functions, sometimes the DWARF used to
+  // describe them, does not give suficient information. Try to find a
+  // perfect match or mark them as possible conflicts.
+  LVScopes Candidates;
+  for (LVScope *Target : *Targets)
+    if (LVScope::equals(Target))
+      Candidates.push_back(Target);
+
+  LLVM_DEBUG({
+    if (!Candidates.empty()) {
+      dbgs() << "\n[LVScope::findIn]\n"
+             << "Reference: "
+             << "Offset = " << hexSquareString(getOffset()) << ", "
+             << "Level = " << getLevel() << ", "
+             << "Kind = " << formattedKind(kind()) << ", "
+             << "Name = " << formattedName(getName()) << "\n";
+      for (const LVScope *Candidate : Candidates)
+        dbgs() << "Candidate: "
+               << "Offset = " << hexSquareString(Candidate->getOffset()) << ", "
+               << "Level = " << Candidate->getLevel() << ", "
+               << "Kind = " << formattedKind(Candidate->kind()) << ", "
+               << "Name = " << formattedName(Candidate->getName()) << "\n";
+    }
+  });
+
+  if (!Candidates.empty())
+    return (Candidates.size() == 1)
+               ? (equals(Candidates[0]) ? Candidates[0] : nullptr)
+               : findEqualScope(&Candidates);
+
+  return nullptr;
+}
+
+bool LVScope::equalNumberOfChildren(const LVScope *Scope) const {
+  // Same number of children. Take into account which elements are requested
+  // to be included in the comparison.
+  return !(
+      (options().getCompareScopes() && scopeCount() != Scope->scopeCount()) ||
+      (options().getCompareSymbols() &&
+       symbolCount() != Scope->symbolCount()) ||
+      (options().getCompareTypes() && typeCount() != Scope->typeCount()) ||
+      (options().getCompareLines() && lineCount() != Scope->lineCount()));
+}
+
+void LVScope::markMissingParents(const LVScope *Target, bool TraverseChildren) {
+  auto SetCompareState = [&](auto *Container) {
+    if (Container)
+      for (auto *Entry : *Container)
+        Entry->setIsInCompare();
+  };
+  SetCompareState(Types);
+  SetCompareState(Symbols);
+  SetCompareState(Lines);
+  SetCompareState(Scopes);
+
+  // At this point, we are ready to start comparing the current scope, once
+  // the compare bits have been set.
+  if (options().getCompareTypes() && getTypes() && Target->getTypes())
+    LVType::markMissingParents(getTypes(), Target->getTypes());
+  if (options().getCompareSymbols() && getSymbols() && Target->getSymbols())
+    LVSymbol::markMissingParents(getSymbols(), Target->getSymbols());
+  if (options().getCompareLines() && getLines() && Target->getLines())
+    LVLine::markMissingParents(getLines(), Target->getLines());
+  if (getScopes() && Target->getScopes())
+    LVScope::markMissingParents(getScopes(), Target->getScopes(),
+                                TraverseChildren);
+}
+
+void LVScope::markMissingParents(const LVScopes *References,
+                                 const LVScopes *Targets,
+                                 bool TraverseChildren) {
+  if (!(References && Targets))
+    return;
+
+  LLVM_DEBUG({
+    dbgs() << "\n[LVScope::markMissingParents]\n";
+    for (const LVScope *Reference : *References)
+      dbgs() << "References: "
+             << "Offset = " << hexSquareString(Reference->getOffset()) << ", "
+             << "Level = " << Reference->getLevel() << ", "
+             << "Kind = " << formattedKind(Reference->kind()) << ", "
+             << "Name = " << formattedName(Reference->getName()) << "\n";
+    for (const LVScope *Target : *Targets)
+      dbgs() << "Targets   : "
+             << "Offset = " << hexSquareString(Target->getOffset()) << ", "
+             << "Level = " << Target->getLevel() << ", "
+             << "Kind = " << formattedKind(Target->kind()) << ", "
+             << "Name = " << formattedName(Target->getName()) << "\n";
+  });
+
+  for (LVScope *Reference : *References) {
+    // Don't process 'Block' scopes, as we can't identify them.
+    if (Reference->getIsBlock() || Reference->getIsGeneratedName())
+      continue;
+
+    LLVM_DEBUG({
+      dbgs() << "\nSearch Reference: "
+             << "Offset = " << hexSquareString(Reference->getOffset()) << " "
+             << "Name = " << formattedName(Reference->getName()) << "\n";
+    });
+    LVScope *Target = Reference->findIn(Targets);
+    if (Target) {
+      LLVM_DEBUG({
+        dbgs() << "\nFound Target: "
+               << "Offset = " << hexSquareString(Target->getOffset()) << " "
+               << "Name = " << formattedName(Target->getName()) << "\n";
+      });
+      if (TraverseChildren)
+        Reference->markMissingParents(Target, TraverseChildren);
+    } else {
+      LLVM_DEBUG({
+        dbgs() << "Missing Reference: "
+               << "Offset = " << hexSquareString(Reference->getOffset()) << " "
+               << "Name = " << formattedName(Reference->getName()) << "\n";
+      });
+      Reference->markBranchAsMissing();
+    }
+  }
+}
+
+bool LVScope::equals(const LVScope *Scope) const {
+  if (!LVElement::equals(Scope))
+    return false;
+  // For lexical scopes, check if their parents are the same.
+  if (getIsLexicalBlock() && Scope->getIsLexicalBlock())
+    return getParentScope()->equals(Scope->getParentScope());
+  return true;
+}
+
+LVScope *LVScope::findEqualScope(const LVScopes *Scopes) const {
+  assert(Scopes && "Scopes must not be nullptr");
+  for (LVScope *Scope : *Scopes)
+    if (equals(Scope))
+      return Scope;
+  return nullptr;
+}
+
+bool LVScope::equals(const LVScopes *References, const LVScopes *Targets) {
+  if (!References && !Targets)
+    return true;
+  if (References && Targets && References->size() == Targets->size()) {
+    for (const LVScope *Reference : *References)
+      if (!Reference->findIn(Targets))
+        return false;
+    return true;
+  }
+  return false;
+}
+
+void LVScope::report(LVComparePass Pass) {
+  getComparator().printItem(this, Pass);
+  getComparator().push(this);
+  if (Children)
+    for (LVElement *Element : *Children)
+      Element->report(Pass);
+
+  if (Lines)
+    for (LVLine *Line : *Lines)
+      Line->report(Pass);
+  getComparator().pop();
+}
+
 void LVScope::printActiveRanges(raw_ostream &OS, bool Full) const {
   if (options().getPrintFormatting() && options().getAttributeRange() &&
       Ranges) {
     for (const LVLocation *Location : *Ranges)
       Location->print(OS, Full);
   }
 }
 
void LVScope::printExtra(raw_ostream &OS, bool Full) const {
   // Print any active ranges.
   if (Full && getIsBlock())
     printActiveRanges(OS, Full);
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF Union/Structure/Class.
 //===----------------------------------------------------------------------===//
+bool LVScopeAggregate::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+
+  if (!equalNumberOfChildren(Scope))
+    return false;
+
+  // Check if the parameters match in the case of templates.
+  if (!LVType::parametersMatch(getTypes(), Scope->getTypes()))
+    return false;
+
+  if (!isNamed() && !Scope->isNamed())
+    // In the case of unnamed union/structure/class compare the file name.
+    if (getFilenameIndex() != Scope->getFilenameIndex())
+      return false;
+
+  return true;
+}
+
+LVScope *LVScopeAggregate::findEqualScope(const LVScopes *Scopes) const {
+  assert(Scopes && "Scopes must not be nullptr");
+  for (LVScope *Scope : *Scopes)
+    if (equals(Scope))
+      return Scope;
+  return nullptr;
+}
+
 void LVScopeAggregate::printExtra(raw_ostream &OS, bool Full) const {
   LVScope::printExtra(OS, Full);
   if (Full) {
     if (getIsTemplateResolved())
       printEncodedArgs(OS, Full);
     LVScope *Reference = getReference();
     if (Reference)
       Reference->printReference(OS, Full, const_cast<LVScopeAggregate *>(this));
   }
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF Template alias.
 //===----------------------------------------------------------------------===//
+bool LVScopeAlias::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+  return equalNumberOfChildren(Scope);
+}
+
 void LVScopeAlias::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << formattedName(getName()) << " -> "
      << typeOffsetAsString()
      << formattedNames(getTypeQualifiedName(), typeAsString()) << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF array (DW_TAG_array_type).
else {
         ArrayInfo << "[" << UpperBound + 1 << "]";
     }
   }
 
   // Update the scope name, to reflect the encoded subranges.
   setName(ArrayInfo.str());
 }
 
+bool LVScopeArray::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+
+  if (!equalNumberOfChildren(Scope))
+    return false;
+
+  // Despite the arrays are encoded, to reflect the dimensions, we have to
+  // check the subranges, in order to determine if they are the same.
+  if (!LVType::equals(getTypes(), Scope->getTypes()))
+    return false;
+
+  return true;
+}
+
 void LVScopeArray::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << typeOffsetAsString()
      << formattedName(getName()) << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // An object file (single or multiple CUs).
 //===----------------------------------------------------------------------===//

 }
 
 StringRef LVScopeCompileUnit::getFilename(size_t Index) const {
   if (Index <= 0 || Index > Filenames.size())
     return StringRef();
   return getStringPool().getString(Filenames[Index - 1]);
 }
 
+bool LVScopeCompileUnit::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+
+  return getNameIndex() == Scope->getNameIndex();
+}
+
 void LVScopeCompileUnit::incrementPrintedLines() {
   options().getSelectExecute() ? ++Found.Lines : ++Printed.Lines;
 }
 void LVScopeCompileUnit::incrementPrintedScopes() {
   options().getSelectExecute() ? ++Found.Scopes : ++Printed.Scopes;
 }
 void LVScopeCompileUnit::incrementPrintedSymbols() {
   options().getSelectExecute() ? ++Found.Symbols : ++Printed.Symbols;

 }
 void LVScopeCompileUnit::increment(LVType *Type) {
   if (Type->getIncludeInPrint())
     ++Allocated.Types;
 }
 
 // A new element has been added to the scopes tree. Take the following steps:
 // Increase the added element counters, for printing summary.
-void LVScopeCompileUnit::addedElement(LVLine *Line) { increment(Line); }
-void LVScopeCompileUnit::addedElement(LVScope *Scope) { increment(Scope); }
-void LVScopeCompileUnit::addedElement(LVSymbol *Symbol) { increment(Symbol); }
-void LVScopeCompileUnit::addedElement(LVType *Type) { increment(Type); }
+// During comparison notify the Reader of the new element.
+void LVScopeCompileUnit::addedElement(LVLine *Line) {
+  increment(Line);
+  getReader().notifyAddedElement(Line);
+}
+void LVScopeCompileUnit::addedElement(LVScope *Scope) {
+  increment(Scope);
+  getReader().notifyAddedElement(Scope);
+}
+void LVScopeCompileUnit::addedElement(LVSymbol *Symbol) {
+  increment(Symbol);
+  getReader().notifyAddedElement(Symbol);
+}
+void LVScopeCompileUnit::addedElement(LVType *Type) {
+  increment(Type);
+  getReader().notifyAddedElement(Type);
+}
 
 // Record unsuported DWARF tags.
 void LVScopeCompileUnit::addDebugTag(dwarf::Tag Target, LVOffset Offset) {
   addItem<LVTagOffsetsMap, LVOffsetList, dwarf::Tag, LVOffset>(&DebugTags,
                                                                Target, Offset);
 }
 
 // Record elements with invalid offsets.
if (Full) {
     printLocalNames(OS, Full);
     printActiveRanges(OS, Full);
   }
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF enumeration (DW_TAG_enumeration_type).
 //===----------------------------------------------------------------------===//
+bool LVScopeEnumeration::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+  return equalNumberOfChildren(Scope);
+}
+
 void LVScopeEnumeration::printExtra(raw_ostream &OS, bool Full) const {
   // Print the full type name.
   OS << formattedKind(kind()) << " " << (getIsEnumClass() ? "class " : "")
      << formattedName(getName());
   if (getHasType())
     OS << " -> " << typeOffsetAsString()
        << formattedNames(getTypeQualifiedName(), typeAsString());
   OS << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF formal parameter pack (DW_TAG_GNU_formal_parameter_pack).
 //===----------------------------------------------------------------------===//
+bool LVScopeFormalPack::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+  return equalNumberOfChildren(Scope);
+}
+
 void LVScopeFormalPack::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << formattedName(getName()) << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF function.
 //===----------------------------------------------------------------------===//
 void LVScopeFunction::resolveReferences() {

 }
 
 void LVScopeFunction::resolveExtra() {
   // Check if we need to encode the template arguments.
   if (getIsTemplate())
     resolveTemplate();
 }
 
+bool LVScopeFunction::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+
+  // When comparing logical elements, ignore any difference in the children.
+  if (options().getCompareContext() && !equalNumberOfChildren(Scope))
+    return false;
+
+  // Check if the linkage name matches.
+  if (getLinkageNameIndex() != Scope->getLinkageNameIndex())
+    return false;
+
+  // Check if the parameters match in the case of templates.
+  if (!LVType::parametersMatch(getTypes(), Scope->getTypes()))
+    return false;
+
+  // Check if the arguments match.
+  if (!LVSymbol::parametersMatch(getSymbols(), Scope->getSymbols()))
+    return false;
+
+  // Check if the lines match.
+  if (options().getCompareLines() &&
+      !LVLine::equals(getLines(), Scope->getLines()))
+    return false;
+
+  // Check if any reference is the same.
+  if (!referenceMatch(Scope))
+    return false;
+
+  if (getReference() && !getReference()->equals(Scope->getReference()))
+    return false;
+
+  return true;
+}
+
+LVScope *LVScopeFunction::findEqualScope(const LVScopes *Scopes) const {
+  assert(Scopes && "Scopes must not be nullptr");
+  // Go through candidates and try to find a best match.
+  for (LVScope *Scope : *Scopes)
+    // Match arguments, children, lines, references.
+    if (equals(Scope))
+      return Scope;
+  return nullptr;
+}
+
 void LVScopeFunction::printExtra(raw_ostream &OS, bool Full) const {
   LVScope *Reference = getReference();
 
   // Inline attributes based on the reference element.
   uint32_t InlineCode =
       Reference ? Reference->getInlineCode() : getInlineCode();
 
   // Accessibility depends on the parent (class, structure).

 // DWARF inlined function (DW_TAG_inlined_function).
 //===----------------------------------------------------------------------===//
 void LVScopeFunctionInlined::resolveExtra() {
   // Check if we need to encode the template arguments.
   if (getIsTemplate())
     resolveTemplate();
 }
 
+bool LVScopeFunctionInlined::equals(const LVScope *Scope) const {
+  if (!LVScopeFunction::equals(Scope))
+    return false;
+
+  // Check if any reference is the same.
+  if (getHasDiscriminator() && Scope->getHasDiscriminator())
+    if (getDiscriminator() != Scope->getDiscriminator())
+      return false;
+
+  // Check the call site information.
+  if (getCallFilenameIndex() != Scope->getCallFilenameIndex() ||
+      getCallLineNumber() != Scope->getCallLineNumber())
+    return false;
+
+  return true;
+}
+
+LVScope *LVScopeFunctionInlined::findEqualScope(const LVScopes *Scopes) const {
+  return LVScopeFunction::findEqualScope(Scopes);
+}
+
 void LVScopeFunctionInlined::printExtra(raw_ostream &OS, bool Full) const {
   LVScopeFunction::printExtra(OS, Full);
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF subroutine type.
 //===----------------------------------------------------------------------===//
 // Resolve a Subroutine Type (Callback).
void LVScopeFunctionType::resolveExtra() {
 
   // Update the scope name, to reflect the encoded parameters.
   setName(Name.c_str());
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF namespace (DW_TAG_namespace).
 //===----------------------------------------------------------------------===//
+bool LVScopeNamespace::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+
+  if (!equalNumberOfChildren(Scope))
+    return false;
+
+  // Check if any reference is the same.
+  if (!referenceMatch(Scope))
+    return false;
+
+  if (getReference() && !getReference()->equals(Scope->getReference()))
+    return false;
+
+  return true;
+}
+
+LVScope *LVScopeNamespace::findEqualScope(const LVScopes *Scopes) const {
+  assert(Scopes && "Scopes must not be nullptr");
+  // Go through candidates and try to find a best match.
+  for (LVScope *Scope : *Scopes)
+    if (equals(Scope))
+      return Scope;
+  return nullptr;
+}
+
 void LVScopeNamespace::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << formattedName(getName()) << "\n";
 
   // Print any active ranges.
   if (Full) {
     printActiveRanges(OS, Full);
 
     if (LVScope *Reference = getReference())
if (Scopes)
     for (LVScope *Scope : *Scopes) {
       LVScopeCompileUnit *CompileUnit =
           static_cast<LVScopeCompileUnit *>(Scope);
       getReader().setCompileUnit(CompileUnit);
       CompileUnit->processRangeLocationCoverage();
     }
 }
 
+bool LVScopeRoot::equals(const LVScope *Scope) const {
+  return LVScope::equals(Scope);
+}
+
 void LVScopeRoot::print(raw_ostream &OS, bool Full) const {
   OS << "\nLogical View:\n";
   LVScope::print(OS, Full);
 }
 
 void LVScopeRoot::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << formattedName(getName()) << "";
   if (options().getAttributeFormat())
Error LVScopeRoot::doPrintMatches(bool Split, raw_ostream &OS,
   }
 
   return Error::success();
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF template parameter pack (DW_TAG_GNU_template_parameter_pack).
 //===----------------------------------------------------------------------===//
+bool LVScopeTemplatePack::equals(const LVScope *Scope) const {
+  if (!LVScope::equals(Scope))
+    return false;
+  return equalNumberOfChildren(Scope);
+}
+
 void LVScopeTemplatePack::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << formattedName(getName()) << "\n";
 }

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

 //===-- LVSymbol.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 LVSymbol class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLocation.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 #define DEBUG_TYPE "Symbol"
StringRef LVSymbol::resolveReferencesChain() {
   // If the symbol have a DW_AT_specification or DW_AT_abstract_origin,
   // follow the chain to resolve the name from those references.
   if (getHasReference() && !isNamed())
     setName(getReference()->resolveReferencesChain());
 
   return getName();
 }
 
+void LVSymbol::markMissingParents(const LVSymbols *References,
+                                  const LVSymbols *Targets) {
+  if (!(References && Targets))
+    return;
+
+  LLVM_DEBUG({
+    dbgs() << "\n[LVSymbol::markMissingParents]\n";
+    for (const LVSymbol *Reference : *References)
+      dbgs() << "References: "
+             << "Kind = " << formattedKind(Reference->kind()) << ", "
+             << "Name = " << formattedName(Reference->getName()) << "\n";
+    for (const LVSymbol *Target : *Targets)
+      dbgs() << "Targets   : "
+             << "Kind = " << formattedKind(Target->kind()) << ", "
+             << "Name = " << formattedName(Target->getName()) << "\n";
+  });
+
+  for (LVSymbol *Reference : *References) {
+    LLVM_DEBUG({
+      dbgs() << "Search Reference: Name = "
+             << formattedName(Reference->getName()) << "\n";
+    });
+    if (!Reference->findIn(Targets))
+      Reference->markBranchAsMissing();
+  }
+}
+
+LVSymbol *LVSymbol::findIn(const LVSymbols *Targets) const {
+  if (!Targets)
+    return nullptr;
+
+  LLVM_DEBUG({
+    dbgs() << "\n[LVSymbol::findIn]\n"
+           << "Reference: "
+           << "Level = " << getLevel() << ", "
+           << "Kind = " << formattedKind(kind()) << ", "
+           << "Name = " << formattedName(getName()) << "\n";
+    for (const LVSymbol *Target : *Targets)
+      dbgs() << "Target   : "
+             << "Level = " << Target->getLevel() << ", "
+             << "Kind = " << formattedKind(Target->kind()) << ", "
+             << "Name = " << formattedName(Target->getName()) << "\n";
+  });
+
+  for (LVSymbol *Target : *Targets)
+    if (equals(Target))
+      return Target;
+
+  return nullptr;
+}
+
+// Check for a match on the arguments of a function.
+bool LVSymbol::parametersMatch(const LVSymbols *References,
+                               const LVSymbols *Targets) {
+  if (!References && !Targets)
+    return true;
+  if (References && Targets) {
+    LVSymbols ReferenceParams;
+    getParameters(References, &ReferenceParams);
+    LVSymbols TargetParams;
+    getParameters(Targets, &TargetParams);
+    return LVSymbol::equals(&ReferenceParams, &TargetParams);
+  }
+  return false;
+}
+
+// Return the symbols which are parameters.
+void LVSymbol::getParameters(const LVSymbols *Symbols, LVSymbols *Parameters) {
+  if (Symbols)
+    for (LVSymbol *Symbol : *Symbols)
+      if (Symbol->getIsParameter())
+        Parameters->push_back(Symbol);
+}
+
+bool LVSymbol::equals(const LVSymbol *Symbol) const {
+  if (!LVElement::equals(Symbol))
+    return false;
+
+  // Check if any reference is the same.
+  if (!referenceMatch(Symbol))
+    return false;
+
+  if (getReference() && !getReference()->equals(Symbol->getReference()))
+    return false;
+
+  return true;
+}
+
+bool LVSymbol::equals(const LVSymbols *References, const LVSymbols *Targets) {
+  if (!References && !Targets)
+    return true;
+  if (References && Targets && References->size() == Targets->size()) {
+    for (const LVSymbol *Reference : *References)
+      if (!Reference->findIn(Targets))
+        return false;
+    return true;
+  }
+  return false;
+}
+
+void LVSymbol::report(LVComparePass Pass) {
+  getComparator().printItem(this, Pass);
+}
+
 void LVSymbol::printLocations(raw_ostream &OS, bool Full) const {
   if (Locations)
     for (const LVLocation *Location : *Locations)
       Location->printRaw(OS, Full);
 }
 
 void LVSymbol::print(raw_ostream &OS, bool Full) const {
   if (getIncludeInPrint() && getReader().doPrintSymbol(this)) {

llvm/lib/DebugInfo/LogicalView/Core/LVType.cpp

 //===-- LVType.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 LVType class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/LogicalView/Core/LVType.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
 
 using namespace llvm;
 using namespace llvm::logicalview;
 
 #define DEBUG_TYPE "Type"
 

 }
 
 StringRef LVType::resolveReferencesChain() {
   // The types do not have a DW_AT_specification or DW_AT_abstract_origin
   // reference. Just return the type name.
   return getName();
 }
 
+void LVType::markMissingParents(const LVTypes *References,
+                                const LVTypes *Targets) {
+  if (!(References && Targets))
+    return;
+
+  LLVM_DEBUG({
+    dbgs() << "\n[LVType::markMissingParents]\n";
+    for (const LVType *Reference : *References)
+      dbgs() << "References: "
+             << "Kind = " << formattedKind(Reference->kind()) << ", "
+             << "Name = " << formattedName(Reference->getName()) << "\n";
+    for (const LVType *Target : *Targets)
+      dbgs() << "Targets   : "
+             << "Kind = " << formattedKind(Target->kind()) << ", "
+             << "Name = " << formattedName(Target->getName()) << "\n";
+  });
+
+  for (LVType *Reference : *References) {
+    LLVM_DEBUG({
+      dbgs() << "Search Reference: Name = "
+             << formattedName(Reference->getName()) << "\n";
+    });
+    if (!Reference->findIn(Targets))
+      Reference->markBranchAsMissing();
+  }
+}
+
+LVType *LVType::findIn(const LVTypes *Targets) const {
+  if (!Targets)
+    return nullptr;
+
+  LLVM_DEBUG({
+    dbgs() << "\n[LVType::findIn]\n"
+           << "Reference: "
+           << "Level = " << getLevel() << ", "
+           << "Kind = " << formattedKind(kind()) << ", "
+           << "Name = " << formattedName(getName()) << "\n";
+    for (const LVType *Target : *Targets)
+      dbgs() << "Target   : "
+             << "Level = " << Target->getLevel() << ", "
+             << "Kind = " << formattedKind(Target->kind()) << ", "
+             << "Name = " << formattedName(Target->getName()) << "\n";
+  });
+
+  for (LVType *Target : *Targets)
+    if (equals(Target))
+      return Target;
+
+  return nullptr;
+}
+
+// Check for a match on the arguments of a function.
+bool LVType::parametersMatch(const LVTypes *References,
+                             const LVTypes *Targets) {
+  if (!References && !Targets)
+    return true;
+  if (References && Targets) {
+    LVTypes ReferenceTypes;
+    LVScopes ReferenceScopes;
+    getParameters(References, &ReferenceTypes, &ReferenceScopes);
+    LVTypes TargetTypes;
+    LVScopes TargetScopes;
+    getParameters(Targets, &TargetTypes, &TargetScopes);
+    if (!LVType::equals(&ReferenceTypes, &TargetTypes) ||
+        !LVScope::equals(&ReferenceScopes, &TargetScopes))
+      return false;
+    return true;
+  }
+  return false;
+}
+
+// Return the types which are parameters.
+void LVType::getParameters(const LVTypes *Types, LVTypes *TypesParam,
+                           LVScopes *ScopesParam) {
+  if (!Types)
+    return;
+
+  // During a compare task, the template parameters are expanded to
+  // point to their real types, to avoid compare conflicts.
+  for (LVType *Type : *Types) {
+    if (!Type->getIsTemplateParam())
+      continue;
+    if (options().getAttributeArgument()) {
+      LVScope *Scope = nullptr;
+      if (Type->getIsKindType())
+        Type = Type->getTypeAsType();
+      else {
+        if (Type->getIsKindScope()) {
+          Scope = Type->getTypeAsScope();
+          Type = nullptr;
+        }
+      }
+      Type ? TypesParam->push_back(Type) : ScopesParam->push_back(Scope);
+    } else
+      TypesParam->push_back(Type);
+  }
+}
+
+bool LVType::equals(const LVType *Type) const {
+  return LVElement::equals(Type);
+}
+
+bool LVType::equals(const LVTypes *References, const LVTypes *Targets) {
+  if (!References && !Targets)
+    return true;
+  if (References && Targets && References->size() == Targets->size()) {
+    for (const LVType *Reference : *References)
+      if (!Reference->findIn(Targets))
+        return false;
+    return true;
+  }
+  return false;
+}
+
+void LVType::report(LVComparePass Pass) {
+  getComparator().printItem(this, Pass);
+}
+
 void LVType::print(raw_ostream &OS, bool Full) const {
   if (getIncludeInPrint() &&
       (getIsReference() || getReader().doPrintType(this))) {
     getReaderCompileUnit()->incrementPrintedTypes();
     LVElement::print(OS, Full);
     printExtra(OS, Full);
   }
 }
void LVTypeDefinition::resolveExtra() {
   // For the case of typedef'd anonymous structures:
   //   typedef struct { ... } Name;
   // Propagate the typedef name to the anonymous structure.
   LVScope *Aggregate = getTypeAsScope();
   if (Aggregate && Aggregate->getIsAnonymous())
     Aggregate->setName(getName());
 }
 
+bool LVTypeDefinition::equals(const LVType *Type) const {
+  return LVType::equals(Type);
+}
+
 void LVTypeDefinition::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << formattedName(getName()) << " -> "
      << typeOffsetAsString()
      << formattedName((getType() ? getType()->getName() : "")) << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF enumerator (DW_TAG_enumerator).
 //===----------------------------------------------------------------------===//
+bool LVTypeEnumerator::equals(const LVType *Type) const {
+  return LVType::equals(Type);
+}
+
 void LVTypeEnumerator::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " '" << getName()
      << "' = " << formattedName(getValue()) << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF import (DW_TAG_imported_module / DW_TAG_imported_declaration).
 //===----------------------------------------------------------------------===//
+bool LVTypeImport::equals(const LVType *Type) const {
+  return LVType::equals(Type);
+}
+
 void LVTypeImport::printExtra(raw_ostream &OS, bool Full) const {
   std::string Attributes =
       formatAttributes(virtualityString(), accessibilityString());
 
   OS << formattedKind(kind()) << " " << typeOffsetAsString() << Attributes
      << formattedName((getType() ? getType()->getName() : "")) << "\n";
 }
 
if (getIsKindType()) {
         }
       }
     }
   } else
     // Template value parameter or template template parameter.
     Name.append(getValue());
 }
 
+bool LVTypeParam::equals(const LVType *Type) const {
+  if (!LVType::equals(Type))
+    return false;
+
+  // Checks the kind of template argument.
+  if (getIsTemplateTypeParam() && Type->getIsTemplateTypeParam())
+    return getType()->equals(Type->getType());
+
+  if ((getIsTemplateValueParam() && Type->getIsTemplateValueParam()) ||
+      (getIsTemplateTemplateParam() && Type->getIsTemplateTemplateParam()))
+    return getValueIndex() == Type->getValueIndex();
+
+  return false;
+}
+
 void LVTypeParam::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " " << formattedName(getName()) << " -> "
      << typeOffsetAsString();
 
   // Depending on the type of parameter, the print includes different
   // information: type, value or reference to a template.
   if (getIsTemplateTypeParam()) {
     OS << formattedNames(getTypeQualifiedName(), getTypeName()) << "\n";
if (getIsSubrangeCount())
     raw_string_ostream(String) << "[" << getCount() << "]";
   else
     raw_string_ostream(String)
         << "[" << getLowerBound() << ".." << getUpperBound() << "]";
 
   setName(String);
 }
 
+bool LVTypeSubrange::equals(const LVType *Type) const {
+  if (!LVType::equals(Type))
+    return false;
+
+  return getTypeName() == Type->getTypeName() && getName() == Type->getName();
+}
+
 void LVTypeSubrange::printExtra(raw_ostream &OS, bool Full) const {
   OS << formattedKind(kind()) << " -> " << typeOffsetAsString()
      << formattedName(getTypeName()) << " " << formattedName(getName()) << "\n";
 }

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoLogicalView
   )
 
 add_llvm_unittest(DebugInfoLogicalViewTests
   CommandLineOptionsTest.cpp
+  CompareElementsTest.cpp
   SelectElementsTest.cpp
   LocationRangesTest.cpp
   LogicalElementsTest.cpp
   StringPoolTest.cpp
   WarningInternalTest.cpp
   )
 
 target_link_libraries(DebugInfoLogicalViewTests PRIVATE LLVMTestingSupport)

llvm/unittests/DebugInfo/LogicalView/CompareElementsTest.cpp

+//===- llvm/unittest/DebugInfo/LogicalView/CompareElementsTest.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/LVReader.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Testing/Support/Error.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::logicalview;
+
+namespace {
+
+//===----------------------------------------------------------------------===//
+// Basic Reader functionality.
+class ReaderTestCompare : public LVReader {
+public:
+  // Types.
+  LVType *IntegerType = nullptr;
+  LVType *UnsignedType = nullptr;
+  LVType *GlobalType = nullptr;
+  LVType *LocalType = nullptr;
+  LVType *NestedType = nullptr;
+  LVTypeDefinition *TypeDefinitionOne = nullptr;
+  LVTypeDefinition *TypeDefinitionTwo = nullptr;
+  LVTypeEnumerator *EnumeratorOne = nullptr;
+  LVTypeEnumerator *EnumeratorTwo = nullptr;
+
+  // Scopes.
+  LVScope *NestedScope = nullptr;
+  LVScope *InnerScope = nullptr;
+  LVScopeAggregate *Aggregate = nullptr;
+  LVScopeEnumeration *Enumeration = nullptr;
+  LVScopeFunction *FunctionOne = nullptr;
+  LVScopeFunction *FunctionTwo = nullptr;
+  LVScopeNamespace *Namespace = nullptr;
+
+  // Symbols.
+  LVSymbol *GlobalVariable = nullptr;
+  LVSymbol *LocalVariable = nullptr;
+  LVSymbol *ClassMember = nullptr;
+  LVSymbol *NestedVariable = nullptr;
+  LVSymbol *ParameterOne = nullptr;
+  LVSymbol *ParameterTwo = nullptr;
+
+  // Lines.
+  LVLine *LineOne = nullptr;
+  LVLine *LineTwo = nullptr;
+  LVLine *LineThree = nullptr;
+
+protected:
+  void add(LVScope *Parent, LVElement *Element);
+  template <typename T, typename F> T *create(F Function) {
+    // 'Function' will update a specific kind of the logical element to
+    // have the ability of kind selection.
+    T *Element = new (std::nothrow) T();
+    EXPECT_NE(Element, nullptr);
+    (Element->*Function)();
+    return Element;
+  }
+  void set(LVElement *Element, StringRef Name, LVOffset Offset,
+           uint32_t LineNumber = 0, LVElement *Type = nullptr);
+
+public:
+  ReaderTestCompare(ScopedPrinter &W) : LVReader("", "", W) {
+    setInstance(this);
+  }
+
+  Error createScopes() { return LVReader::createScopes(); }
+  Error printScopes() { return LVReader::printScopes(); }
+
+  void createElements();
+  void addElements(bool IsReference, bool IsTarget);
+  void initElements();
+};
+
+// Helper function to add a logical element to a given scope.
+void ReaderTestCompare::add(LVScope *Parent, LVElement *Child) {
+  Parent->addElement(Child);
+  EXPECT_EQ(Child->getParent(), Parent);
+  EXPECT_EQ(Child->getLevel(), Parent->getLevel() + 1);
+}
+
+// Helper function to set the initial values for a given logical element.
+void ReaderTestCompare::set(LVElement *Element, StringRef Name, LVOffset Offset,
+                            uint32_t LineNumber, LVElement *Type) {
+  Element->setName(Name);
+  Element->setOffset(Offset);
+  Element->setLineNumber(LineNumber);
+  Element->setType(Type);
+}
+
+//===----------------------------------------------------------------------===//
+// Create the logical elements.
+void ReaderTestCompare::createElements() {
+  // Create scope root.
+  Error Err = createScopes();
+  ASSERT_THAT_ERROR(std::move(Err), Succeeded());
+  Root = getScopesRoot();
+  EXPECT_NE(Root, nullptr);
+
+  // Create the logical types.
+  IntegerType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
+  UnsignedType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
+  GlobalType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
+  LocalType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
+  NestedType = create<LVType, LVTypeSetFunction>(&LVType::setIsBase);
+  EnumeratorOne =
+      create<LVTypeEnumerator, LVTypeSetFunction>(&LVType::setIsEnumerator);
+  EnumeratorTwo =
+      create<LVTypeEnumerator, LVTypeSetFunction>(&LVType::setIsEnumerator);
+  TypeDefinitionOne =
+      create<LVTypeDefinition, LVTypeSetFunction>(&LVType::setIsTypedef);
+  TypeDefinitionTwo =
+      create<LVTypeDefinition, LVTypeSetFunction>(&LVType::setIsTypedef);
+
+  // Create the logical scopes.
+  NestedScope =
+      create<LVScope, LVScopeSetFunction>(&LVScope::setIsLexicalBlock);
+  InnerScope = create<LVScope, LVScopeSetFunction>(&LVScope::setIsLexicalBlock);
+  Aggregate =
+      create<LVScopeAggregate, LVScopeSetFunction>(&LVScope::setIsAggregate);
+  CompileUnit = create<LVScopeCompileUnit, LVScopeSetFunction>(
+      &LVScope::setIsCompileUnit);
+  Enumeration = create<LVScopeEnumeration, LVScopeSetFunction>(
+      &LVScope::setIsEnumeration);
+  FunctionOne =
+      create<LVScopeFunction, LVScopeSetFunction>(&LVScope::setIsFunction);
+  FunctionTwo =
+      create<LVScopeFunction, LVScopeSetFunction>(&LVScope::setIsFunction);
+  Namespace =
+      create<LVScopeNamespace, LVScopeSetFunction>(&LVScope::setIsNamespace);
+
+  // Create the logical symbols.
+  GlobalVariable =
+      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
+  LocalVariable =
+      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
+  ClassMember = create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsMember);
+  NestedVariable =
+      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsVariable);
+  ParameterOne =
+      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsParameter);
+  ParameterTwo =
+      create<LVSymbol, LVSymbolSetFunction>(&LVSymbol::setIsParameter);
+
+  // Create the logical lines.
+  LineOne = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
+  LineTwo = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
+  LineThree = create<LVLine, LVLineSetFunction>(&LVLine::setIsLineDebug);
+}
+
+// Reference Reader:              Target Reader:
+// ----------------------         ----------------------
+// Root                           Root
+//   CompileUnit                    CompileUnit
+//     IntegerType                    IntegerType
+//     UnsignedType                   UnsignedType
+//     FunctionOne                    FunctionOne
+//       ParameterOne                   ParameterOne
+//       LocalVariable                  ---
+//       LocalType                      LocalType
+//       LineOne                        LineOne
+//       NestedScope                    NestedScope
+//         NestedVariable                 NestedVariable
+//         NestedType                     NestedType
+//         LineTwo                        ---
+//         InnerScope                     InnerScope
+//           ---                            LineThree
+//     ---                            FunctionTwo
+//     ---                              ParameterTwo
+//     GlobalVariable                 GlobalVariable
+//     GlobalType                     GlobalType
+//     Namespace                      Namespace
+//       Aggregate                      Aggregate
+//         ClassMember                    ClassMember
+//       Enumeration                    Enumeration
+//         EnumeratorOne                  EnumeratorOne
+//         EnumeratorTwo                  EnumeratorTwo
+//       TypeDefinitionOne              ---
+//       ---                            TypeDefinitionTwo
+
+// Create the logical view adding the created logical elements.
+void ReaderTestCompare::addElements(bool IsReference, bool IsTarget) {
+  Root->setName(IsReference ? "Reference-Reader" : "Target-Reader");
+
+  auto Insert = [&](bool Insert, auto *Parent, auto *Child) {
+    if (Insert)
+      add(Parent, Child);
+  };
+
+  setCompileUnit(CompileUnit);
+  add(Root, CompileUnit);
+
+  // Add elements to CompileUnit.
+  Insert(true, CompileUnit, IntegerType);
+  Insert(true, CompileUnit, UnsignedType);
+  Insert(true, CompileUnit, FunctionOne);
+  Insert(IsTarget, CompileUnit, FunctionTwo);
+  Insert(true, CompileUnit, GlobalVariable);
+  Insert(true, CompileUnit, GlobalType);
+  Insert(true, CompileUnit, Namespace);
+
+  // Add elements to Namespace.
+  Insert(true, Namespace, Aggregate);
+  Insert(true, Namespace, Enumeration);
+  Insert(IsReference, Namespace, TypeDefinitionOne);
+  Insert(IsTarget, Namespace, TypeDefinitionTwo);
+
+  // Add elements to FunctionOne.
+  Insert(true, FunctionOne, ParameterOne);
+  Insert(IsReference, FunctionOne, LocalVariable);
+  Insert(true, FunctionOne, LocalType);
+  Insert(true, FunctionOne, LineOne);
+  Insert(true, FunctionOne, NestedScope);
+
+  // Add elements to FunctionTwo.
+  Insert(IsTarget, FunctionTwo, ParameterTwo);
+
+  // Add elements to NestedScope.
+  Insert(true, NestedScope, NestedVariable);
+  Insert(true, NestedScope, NestedType);
+  Insert(IsReference, NestedScope, LineTwo);
+  Insert(true, NestedScope, InnerScope);
+
+  // Add elements to Enumeration.
+  Insert(true, Enumeration, EnumeratorOne);
+  Insert(true, Enumeration, EnumeratorTwo);
+
+  // Add elements to Aggregate.
+  Insert(true, Aggregate, ClassMember);
+
+  Insert(IsTarget, InnerScope, LineThree);
+}
+
+// Set initial values to logical elements.
+void ReaderTestCompare::initElements() {
+  setFilename("LogicalElements.obj");
+
+  Root->setFileFormatName("FileFormat");
+
+  // Types.
+  set(IntegerType, "int", 0x1000);
+  set(UnsignedType, "unsigned", 0x1010);
+  set(GlobalType, "GlobalType", 0x1020, 1020);
+  set(LocalType, "LocalType", 0x1030, 1030);
+  set(NestedType, "NestedType", 0x1040, 1040);
+
+  set(TypeDefinitionOne, "INTEGER", 0x1050, 1050, IntegerType);
+  set(TypeDefinitionTwo, "INT", 0x1060, 1060, TypeDefinitionOne);
+
+  set(EnumeratorOne, "One", 0x1070, 1070);
+  EnumeratorOne->setValue("Blue");
+
+  set(EnumeratorTwo, "Two", 0x1080, 1080);
+  EnumeratorTwo->setValue("Red");
+
+  // Scopes.
+  set(Aggregate, "Class", 0x2000, 2000);
+  set(Enumeration, "Colors", 0x2010, 2010);
+  set(FunctionOne, "FunctionOne", 0x2020, 2020, GlobalType);
+  set(FunctionTwo, "FunctionTwo", 0x2030, 2030, GlobalType);
+  set(Namespace, "Namespace", 0x2040, 2040);
+  set(NestedScope, "", 0x2050, 2050);
+  set(InnerScope, "", 0x2060, 2060);
+  set(CompileUnit, "test.cpp", 0x2070, 2070);
+
+  // Symbols.
+  set(GlobalVariable, "GlobalVariable", 0x3000, 3000);
+  set(LocalVariable, "LocalVariable", 0x3010, 3010, UnsignedType);
+  set(ClassMember, "ClassMember", 0x3020, 3020, IntegerType);
+  set(ParameterOne, "ParameterOne", 0x3030, 3030, UnsignedType);
+  set(ParameterTwo, "ParameterTwo", 0x3040, 3040, UnsignedType);
+  set(NestedVariable, "NestedVariable", 0x3050, 3050);
+
+  // Lines.
+  set(LineOne, "", 0x4000, 4000);
+  set(LineTwo, "", 0x4010, 4010);
+  set(LineThree, "", 0x4020, 4020);
+}
+
+// Compare the logical views.
+void compareReadersViews(ReaderTestCompare *ReferenceReader,
+                         ReaderTestCompare *TargetReader) {
+  LVCompare Compare(nulls());
+  Error Err = Compare.execute(ReferenceReader, TargetReader);
+  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 'FunctionOne'
+  std::tie(Reader, Element, Pass) = PassTable[0];
+  EXPECT_EQ(Reader, ReferenceReader);
+  EXPECT_EQ(Element, ReferenceReader->FunctionOne);
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Reference: Missing 'TypeDefinitionOne'
+  std::tie(Reader, Element, Pass) = PassTable[1];
+  EXPECT_EQ(Reader, ReferenceReader);
+  EXPECT_EQ(Element, ReferenceReader->TypeDefinitionOne);
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Target: Added 'FunctionOne'
+  std::tie(Reader, Element, Pass) = PassTable[2];
+  EXPECT_EQ(Reader, TargetReader);
+  EXPECT_EQ(Element, TargetReader->FunctionOne);
+  EXPECT_EQ(Pass, LVComparePass::Added);
+
+  // Target: Added 'FunctionTwo'
+  std::tie(Reader, Element, Pass) = PassTable[3];
+  EXPECT_EQ(Reader, TargetReader);
+  EXPECT_EQ(Element, TargetReader->FunctionTwo);
+  EXPECT_EQ(Pass, LVComparePass::Added);
+
+  // Target: Added 'TypeDefinitionTwo'
+  std::tie(Reader, Element, Pass) = PassTable[4];
+  EXPECT_EQ(Reader, TargetReader);
+  EXPECT_EQ(Element, TargetReader->TypeDefinitionTwo);
+  EXPECT_EQ(Pass, LVComparePass::Added);
+}
+
+// Compare the logical elements.
+void compareReadersElements(ReaderTestCompare *ReferenceReader,
+                            ReaderTestCompare *TargetReader) {
+  LVCompare Compare(nulls());
+  Error Err = Compare.execute(ReferenceReader, TargetReader);
+  ASSERT_THAT_ERROR(std::move(Err), Succeeded());
+
+  // Get comparison table.
+  LVPassTable PassTable = Compare.getPassTable();
+  ASSERT_EQ(PassTable.size(), 7u);
+
+  LVReader *Reader;
+  LVElement *Element;
+  LVComparePass Pass;
+
+  // Reference: Missing 'LocalVariable'
+  std::tie(Reader, Element, Pass) = PassTable[0];
+  EXPECT_EQ(Reader, ReferenceReader);
+  EXPECT_EQ(Element, ReferenceReader->LocalVariable);
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Reference: Missing 'TypeDefinitionOne'
+  std::tie(Reader, Element, Pass) = PassTable[1];
+  EXPECT_EQ(Reader, ReferenceReader);
+  EXPECT_EQ(Element, ReferenceReader->TypeDefinitionOne);
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Reference: Missing 'LineTwo'
+  std::tie(Reader, Element, Pass) = PassTable[2];
+  EXPECT_EQ(Reader, ReferenceReader);
+  EXPECT_EQ(Element, ReferenceReader->LineTwo);
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Target: Added 'FunctionTwo'
+  std::tie(Reader, Element, Pass) = PassTable[3];
+  EXPECT_EQ(Reader, TargetReader);
+  EXPECT_EQ(Element, TargetReader->FunctionTwo);
+  EXPECT_EQ(Pass, LVComparePass::Added);
+
+  // Target: Added 'ParameterTwo'
+  std::tie(Reader, Element, Pass) = PassTable[4];
+  EXPECT_EQ(Reader, TargetReader);
+  EXPECT_EQ(Element, TargetReader->ParameterTwo);
+  EXPECT_EQ(Pass, LVComparePass::Added);
+
+  // Target: Added 'TypeDefinitionTwo'
+  std::tie(Reader, Element, Pass) = PassTable[5];
+  EXPECT_EQ(Reader, TargetReader);
+  EXPECT_EQ(Element, TargetReader->TypeDefinitionTwo);
+  EXPECT_EQ(Pass, LVComparePass::Added);
+
+  // Target: Added 'LineThree'
+  std::tie(Reader, Element, Pass) = PassTable[6];
+  EXPECT_EQ(Reader, TargetReader);
+  EXPECT_EQ(Element, TargetReader->LineThree);
+  EXPECT_EQ(Pass, LVComparePass::Added);
+}
+
+TEST(LogicalViewTest, CompareElements) {
+  ScopedPrinter W(outs());
+
+  // Reader options.
+  LVOptions ReaderOptions;
+  ReaderOptions.setCompareLines();
+  ReaderOptions.setCompareScopes();
+  ReaderOptions.setCompareSymbols();
+  ReaderOptions.setCompareTypes();
+
+  // The next set-ups are very similar. The only difference is the
+  // comparison type, which must be set before the readers are created.
+  //   Views: setCompareContext()
+  //   Elements: resetCompareContext()
+  {
+    // Compare the logical views as whole unit (--compare-context).
+    ReaderOptions.setCompareContext();
+    ReaderOptions.resolveDependencies();
+    options().setOptions(&ReaderOptions);
+
+    ReaderTestCompare ReferenceReader(W);
+    ReferenceReader.createElements();
+    ReferenceReader.addElements(/*IsReference=*/true, /*IsTarget=*/false);
+    ReferenceReader.initElements();
+
+    ReaderTestCompare TargetReader(W);
+    TargetReader.createElements();
+    TargetReader.addElements(/*IsReference=*/false, /*IsTarget=*/true);
+    TargetReader.initElements();
+
+    compareReadersViews(&ReferenceReader, &TargetReader);
+  }
+  {
+    // Compare the logical elements.
+    ReaderOptions.resetCompareContext();
+    ReaderOptions.resolveDependencies();
+    options().setOptions(&ReaderOptions);
+
+    ReaderTestCompare ReferenceReader(W);
+    ReferenceReader.createElements();
+    ReferenceReader.addElements(/*IsReference=*/true, /*IsTarget=*/false);
+    ReferenceReader.initElements();
+
+    ReaderTestCompare TargetReader(W);
+    TargetReader.createElements();
+    TargetReader.addElements(/*IsReference=*/false, /*IsTarget=*/true);
+    TargetReader.initElements();
+
+    compareReadersElements(&ReferenceReader, &TargetReader);
+  }
+}
+
+} // namespace