[llvm-debuginfo-analyzer] 08 - ELF Reader

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

ELF Reader

• Support for ELF/DWARF.

[probinson]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVELFReader.h

38

This should be a local variable in the place where prettyPrintRegisterOp is called; it doesn't need to be a class member.

111

It seems strange to have "get" methods that don't return anything. Are there better names?

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

231

Parameters should be re-aligned to conform to formatting standard.

[probinson]

Done with code files, still need to do tests. But my laptop is about to have a forced reboot so I am submitting these comments now.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVELFReader.h

43

DummyDie is a placeholder used in only two places. It should be a local variable in those places, not a class member.

llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp

94

StringRef has a str() method that returns std::string so you can eliminate the local variable TheFilename.

107

ConvertedPath is already a std::string, no need to make a copy.

154

Unexpected file type is success?

172

The for and first if can be swapped.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

272

347

348

349

413

Maybe add a first line to the comment here, something like
// Here we add logical lines to the Instructions. Later on,
and then the comment about 'processLines()' has better context.

512

512

Have you thought about using std::merge to do this merging of two sorted containers? If that doesn't work, maybe refactor the three nested loops modeled on the example merge code sketched out here

601

Is TraverseLines really needed? If it is set to false only when you reach DebugLines->end() it seems like an unnecessary complication.

623

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

37

Maybe a comment here?

48

Isn't CurrentSymbol currently nullptr ?

440

FormValue and U are parameters, the lambda is using nothing else.

461

Any time lowpc == highpc it is an empty range. Linkers might fill in 1 for code that gets stripped, or they might fill in something else.

593

overrite should be override? or overwrite?

692

It looks like Upper will not include the size of the last child?

729

Maybe add a first line to the comment here, something like
// Here we collect logical debug lines in CULines. Later on,
and then the comment about 'processLines()' has better context.

795

If getFilename() returns a StringRef, you can do getFilename().str().c_str() and then don't need TheFilename.

862

"Deduct" means "subtract" which is not what you mean here.

958

This method doesn't "get" information in the usual sense (return it to the caller).
Maybe processLocationList ? Consistent with the lambda names in the implementation.

1049

Maybe processMemberLocation ?

1169

LVELFReader is used for MachO? I guess the differences are minimal because they both use DWARF. But probably should mention this in the comment at the top of the file.

1185

Is there a missing TODO here? The comment above talks about "unless you know" which implies there are cases where we could know. But this line is basically
if (IsSTAB) continue;
which could have been sooner, and simplify this bit here.

1215

1216

This implies that the tool can handle only linked executables? Not relocatable objects? maybe I knew that... but this requirement means it won't work for relocatable files compiled with -ffunction-sections.

[probinson]

Finished my review pass on this patch.

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/04-dwarf-missing-nested-enumerators.test

24

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/05-dwarf-incorrect-lexical-scope-variable.test

25

I'm not seeing a CodeView display in this test.

llvm/unittests/DebugInfo/LogicalView/ELFReaderTest.cpp

81

There are other ASSERT_* macros used in this function, so I don't think your concern is correct.

[CarlosAlbertoEnciso]

Update patch due to changes in previous patches.

[CarlosAlbertoEnciso]

Updated patch due to changes in previous patches.

[CarlosAlbertoEnciso]

Updated patch due to changes in previous patches.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/LVReaderHandler.h

40

Changed to Mach-O.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

272

Changed.

347

Changed.

348

Changed.

349

Changed.

413

Good point. Added your suggested comment.

623

Changed.

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

37

Added

// As the command line options did not specify a request to print
// logical symbols (--print=symbols or --print=all or --print=elements),
// skip its creation.

48

Yes. To simplify changed to

return nullptr;

593

Changed to override.

729

Added your suggested comment.

759

Changed.

760

Changed.

762

Changed.

// The 'prettyPrintRegisterOp' function uses the DWARFUnit to support
// DW_OP_regval_type. At this point we are operating on a logical view
// item, with no access to the underlying DWARF data used by LLVM.
// We do not support DW_OP_regval_type here.

1215

Changed.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

81

LVSectionIndex is the value returned by getIndex and it is the object section number (id).

https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Object/ObjectFile.h#L470

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/04-dwarf-missing-nested-enumerators.test

24

Changed.

; In the following logical views, we can see that the DWARF debug
; information generated by the Clang compiler does not include any
; references to the enumerators 'RED' and 'BLUE'. The DWARF generated
; by GCC, does include such references.

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/05-dwarf-incorrect-lexical-scope-variable.test

25

Changed

; In the following logical views, we can see that the DWARF debug
; information generated by the Clang compiler shows the variables
; 'Var_1' and 'Var_2' are at the same lexical scope (4) in the function
; 'InlineFuction'.
; The DWARF generated by GCC/Clang show those variables at the correct
; lexical scope: '3' and '4' respectively.

llvm/unittests/DebugInfo/LogicalView/ELFReaderTest.cpp

81

You are correct. Very good point.
I was confused with functions that return a value.
Changed other instances to use ASSERT_NE(cond1, nullptr);

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

152

You are correct. Marked LVBinaryReader destructor as virtual.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVELFReader.h

111

Renamed as processLocationMember.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

231

Applied correct alignment.

llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp

94

Nice suggestion. Removed TheFilename.

107

Removed TheFilename and changed to

return createStringError(errc::bad_file_descriptor,
                         "File '%s' does not exist.",
                         ConvertedPath.c_str());

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

795

Nice suggestion. Removed TheFilename.

862

Renamed as DeduceIncrementFileIndex.

958

Renamed as processLocationList.

1049

Renamed as processMemberLocation.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVELFReader.h

38

Changed DIDumpOptions DumpOpts; to a local variable.

43

Changed DWARFDie DummyDie; to a local variable.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

512

Changed.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

440

Good point. Changed.

[CarlosAlbertoEnciso]

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

261

The method is used only within the logical reader and always the parameter To corresponds to the binary file being analyzed, which already has any Windows backlashes converted for forward slashes. Moved the method to LVReader:

class LVReader {
  ...
protected:
  ...
  std::string createAlternativePath(StringRef From) {
    // During the reader initialization, any backslashes in 'InputFilename'
    // are converted to forward slashes.
    SmallString<128> Path;
    sys::path::append(Path, sys::path::Style::posix,
                      sys::path::parent_path(InputFilename),
                      sys::path::filename(sys::path::convert_to_slash(
                          From, sys::path::Style::windows)));
    return std::string(Path);
  }
  ...
};

llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp

154

Good finding. That should be an Error. For example:

llvm-debuginfo-analyzer resource-file.res --print=scopes

The file_magic::windows_resource is supported by LLVM but not by llvm-debuginfo-analyzer.
Adding an Error condition:

return createStringError(errc::not_supported,
                         "Binary object format in '%s' is not supported.",
                         Filename.str().c_str());

172

Nice point. Swapped.

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

461

You are correct. Changed.

1216

Changed.

[CarlosAlbertoEnciso]

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

173

Changed prettyPrintRegisterOp as a DWARFExpression static public member.

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

570

Added:

/// The \p AlternativeLocation specifies an alternative location to get
/// the DWARF context for the DWO object; this is the case when it has
/// been moved from its original location.

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

403

Short answer is no.

Both readers (ELF/CodeView) use the public names information to create the instructions (LVLineAssembler). Instead of relying on differents DWARF section names (.debug_pubnames, .debug_names) and formats (CodeView S_PUB32), the reader collects the needed information in LVELFReader::processOneDie for DWARF and LVSymbolVisitor::visitKnownRecord(CVSymbol &Record, ProcSym &Proc) for CodeView S_GPROC32, S_LPROC32, S_LPROC32_ID, S_GPROC32_ID records.

A future task can be to process the respective sections for DWARF (.debug_pubnames, .debug_names) and CodeView public symbol stream.

[CarlosAlbertoEnciso]

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

221

Good point. Added to list for later refactor.

• Use Optional<ValueType>.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

49

Good point. Added to list for later refactor.

152

Moved destructor to .cpp file close to createInstructions and getSectionRanges where the allocations are done.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

1429

Removed else after return.

1435

The problem is that both returned true values must be in the same scope as the Directory setting and there a missing return false for the case of DWARF >= 5.

bool DWARFDebugLine::LineTable::getDirectoryForEntry(
    const FileNameEntry &Entry, std::string &Directory) const {
  if (Prologue.getVersion() >= 5) {
    if (Entry.DirIdx < Prologue.IncludeDirectories.size()) {
      Directory =
          dwarf::toString(Prologue.IncludeDirectories[Entry.DirIdx], "");
      return true;
    }
    return false;
  }
  if (0 < Entry.DirIdx && Entry.DirIdx <= Prologue.IncludeDirectories.size()) {
    Directory =
        dwarf::toString(Prologue.IncludeDirectories[Entry.DirIdx - 1], "");
    return true;
  }
  return false;
}

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

692

I debugged the code using the following DWARF test case:

0x0000000b: DW_TAG_compile_unit
0x0000002d:   DW_TAG_variable
0x00000043:   DW_TAG_base_type
0x0000004a:   DW_TAG_variable
0x00000060:   DW_TAG_subprogram
0x00000077:   DW_TAG_subprogram
0x00000092:     DW_TAG_formal_parameter
0x000000a1:     DW_TAG_formal_parameter
0x000000b0:     NULL
0x000000b1:   DW_TAG_subprogram
0x000000cf:   DW_TAG_subprogram
0x000000f5:     DW_TAG_formal_parameter
0x00000103:     DW_TAG_formal_parameter
0x00000111:     DW_TAG_variable
0x00000120:     DW_TAG_variable
0x0000012f:     DW_TAG_lexical_block
0x00000140:       DW_TAG_variable
0x0000014f:       DW_TAG_variable
0x0000015e:       NULL
0x0000015f:     NULL
0x00000160:   DW_TAG_subprogram
0x00000186:     DW_TAG_formal_parameter
0x00000195:     NULL
0x00000196:   DW_TAG_subprogram
0x000001b8:     DW_TAG_formal_parameter
0x000001c7:     NULL
0x000001c8:   NULL

These are the Lower and Upper values for each logical scope, in the order they are recorded in the compile unit.

Offset                                  Lower   Upper
0x00000060:   DW_TAG_subprogram         0x060   0x077
0x00000077:   DW_TAG_subprogram         0x077   0x0b0
0x000000b1:   DW_TAG_subprogram         0x0b1   0x0cf
0x0000012f:     DW_TAG_lexical_block    0x12f   0x15e
0x000000cf:   DW_TAG_subprogram         0x0cf   0x15f
0x00000160:   DW_TAG_subprogram         0x160   0x195
0x00000196:   DW_TAG_subprogram         0x196   0x1c7
0x0000000b: DW_TAG_compile_unit         0x00b   0x1c8

Looking at that table, it seems that Upper is including the size of the last child.
May be I am missing something?

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

764

Good point. Removed if.

[probinson]

Please upload the revised patch for final approval.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

512

Thanks for mentioning std::merge and a possible model to refactor this method.

If is OK with you, I will differ the factoring for a later patch.
These are the cases to be considered during refactoring.

• Merge instructions for objects with no comdat functions.
• Merge instructions for objects with comdat functions.
• Merge instructions for a fully linked binary.
• Merge instructions when -ffunction-sections

601

for (LVLine *InstructionLine : InstructionLines) {
  if (TraverseLines) {
    while (Iter != DebugLines->end()) {
      if (InstructionAddress < DebugAddress) {
        ...
      }
    }
    if (Iter == DebugLines->end()) {
      TraverseLines = false;
      DebugLines->push_back(InstructionLine);
    }
  } else {
    DebugLines->push_back(InstructionLine);
  }
}

We are traversing the instructions and comparing the current InstructionAddress and DebugAddress. When we reach the end of the current DebugLines, we should stop any further comparison.
TraverseLines will indicate that the remaining Instructions must be added to the DebugLines.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

1169

Added at the top of the file:

// This implements the LVELFReader class.
// It supports ELF and Mach-O formats.

1185

Reprased the comment to:

// In the case of a Mach-O STAB symbol, get its section only if
// the STAB symbol's section field refers to a valid section index.
// Otherwise the symbol may error trying to load a section that
// does not exist.

As the method is used by ELF and Mach-O

if (Section == Obj.section_end())
      continue;

cover both cases.

1216

You are correct. The tool does not work for relocatable files compiled with -ffunction-sections.
I just tried that option and the tool generates incorrect instructions LVLineAssembler.
Added that support for a later patch.

[CarlosAlbertoEnciso]

Updated patch to address reviews from @probinson.

[probinson]

LGTM, although I did notice one comment from @psamolysov that had not been answered.

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

290

This comment hasn't been answered.

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

692

No, my misunderstanding.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

290

@psamolysov I am sorry for missing this comment. I will answer it once I finish with the 09-codeview-reader patch.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

692

Thanks

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

290

The best way to explain this code is by an example:

Using the LLVM 'count' testing tool executable
llvm-debuginfo-analyzer --print=lines,instructions count.exe

We traverse the collected public names to generate assembler instructions by calling createInstructions.

Collected public names: CompileUnit PublicNames

Range: [0x01400014c0:0x0140001760] Name: 'main' / ''
Range: [0x0140001820:0x0140001865] Name: '_vfprintf_l' / ''
Range: [0x0140001810:0x014000181a] Name: '__local_stdio_printf_options' / ''
Range: [0x0140001880:0x01400018f9] Name: 'fprintf' / ''

Code section information: SectionAddresses

[0x0140001000:0x0140008cdf] Size: 0x0000007cdf

While generating instructions for the public name main

'main' / 'main' Range: [0x01400014c0:0x0140001760]

Find an entry in SectionAddresses that contains its lower Address=0x01400014c0

Iter = SectionAddresses.lower_bound(Address);
if (Iter != SectionAddresses.begin())
  --Iter;

Iter is the end() iterator.
--Iter points to the entry: 0x0140001000 which is the object section that contains the code for main.

[CarlosAlbertoEnciso]

@psamolysov do you have any additional comments on this patch? I would like to land it. Thanks.

[psamolysov]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

290

Thank you for the great explanation. I've checked from some sources (answers on SO but not the standard, unfortunately) that doing -- for end() is ok for bidirectional iterators. If the container is empty, end() will be equal to begin() and your code won't do -- for the iterator. So, I have no concerns. Thank you very much for the application.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

290

Thanks for your very valuable feedback.

[CarlosAlbertoEnciso]

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

[omjavaid]

This appears to have broken LLVM buildbot clang-armv8-quick https://lab.llvm.org/buildbot/#/builders/245/builds/146

[omjavaid]

This patch has also broken LLVM buildbot clang-aarch64-quick https://lab.llvm.org/buildbot/#/builders/188/builds/21397

I have not reverted it yet as it is part of large patch series.

[CarlosAlbertoEnciso]

In D125783#3887541, @omjavaid wrote:

This patch has also broken LLVM buildbot clang-aarch64-quick https://lab.llvm.org/buildbot/#/builders/188/builds/21397

I have not reverted it yet as it is part of large patch series.

@omjavaid Basically the test cases are platform dependent (requires a x86-registered-target).
There are 12 cases that failed:
I have a fix for 11: include the line REQUIRES: x86-registered-target
Working in the fix for the remaining one. If in the next hour I can't fix it, I will disable the test cases.
I hope it is OK with you.
Thanks

[llvm-commits]

• msg-2958-164.txt163 BDownload

[CarlosAlbertoEnciso]

Landed a patch to check for the specific target.
https://reviews.llvm.org/D136825

[thakis]

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

9

See:

# Use for test binaries that call llvm::getInputFileDirectory(). Use of this
# is discouraged.
function(add_unittest_with_input_files test_suite test_name)

Any chance you could write this test without needing getInputFileDirectory()?

[thakis]

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

3

(alphabetize?)

[CarlosAlbertoEnciso]

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

3

There is only one remaining patch (09-codeview-reader) for the llvm-debuginfo-analyzer tool; it changes this file to include the CodeViewReaderTest.cpp.

I will address the (alphabetize?) issue in that patch.

9

There is only one remaining patch (09-codeview-reader) for the llvm-debuginfo-analyzer tool; it changes this file to include the CodeViewReaderTest.cpp which uses the getInputFileDirectory call.

I will explore the option to remove the call to getInputFileDirectory in that patch.

[CarlosAlbertoEnciso]

@jryans Thanks very much for reviewing the patches that fixed the test cases failures.

[kda]

This looks to have broken sanitizer Fast buildbot: https://lab.llvm.org/buildbot/#/builders/5/builds/28595

Also ASAN: https://lab.llvm.org/buildbot/#/builders/168/builds/9731

[vitalybuka]

==1211325==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 1440 byte(s) in 12 object(s) allocated from:
    #0 0x560d26e1e8cd in operator new(unsigned long) /b/sanitizer-x86_64-linux-fast/build/llvm-project/compiler-rt/lib/asan/asan_new_delete.cpp:95:3
    #1 0x560d275ff029 in llvm::logicalview::LVBinaryReader::createInstructions(llvm::logicalview::LVScope*, unsigned long, std::__1::pair<unsigned long, unsigned long> const&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp:424:31
    #2 0x560d27603fa6 in llvm::logicalview::LVBinaryReader::createInstructions() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp:498:21
    #3 0x560d275e05d8 in llvm::logicalview::LVELFReader::createScopes() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp:936:21
    #4 0x560d27522372 in llvm::logicalview::LVReader::doLoad() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/Core/LVReader.cpp:233:19
    #5 0x560d275be45e in llvm::logicalview::LVReaderHandler::createReader(llvm::StringRef, std::__1::vector<llvm::logicalview::LVReader*, std::__1::allocator<llvm::logicalview::LVReader*>>&, llvm::PointerUnion<llvm::object::ObjectFile*, llvm::pdb::PDBFile*>&, llvm::StringRef, llvm::StringRef) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp:60:18
    #6 0x560d275c36fe in llvm::logicalview::LVReaderHandler::handleObject(std::__1::vector<llvm::logicalview::LVReader*, std::__1::allocator<llvm::logicalview::LVReader*>>&, llvm::StringRef, llvm::object::Binary&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp:141:12
    #7 0x560d275c2951 in llvm::logicalview::LVReaderHandler::handleBuffer(std::__1::vector<llvm::logicalview::LVReader*, std::__1::allocator<llvm::logicalview::LVReader*>>&, llvm::StringRef, llvm::MemoryBufferRef, llvm::StringRef) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp:92:10
    #8 0x560d275c42fb in llvm::logicalview::LVReaderHandler::handleFile(std::__1::vector<llvm::logicalview::LVReader*, std::__1::allocator<llvm::logicalview::LVReader*>>&, llvm::StringRef, llvm::StringRef) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp:108:10
    #9 0x560d275bcf40 in createReader /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/DebugInfo/LogicalView/LVReaderHandler.h:78:12
    #10 0x560d275bcf40 in llvm::logicalview::LVReaderHandler::createReaders() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp:159:21
    #11 0x560d275bcad4 in llvm::logicalview::LVReaderHandler::process() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp:25:19
    #12 0x560d26e22f6c in main /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/tools/llvm-debuginfo-analyzer/llvm-debuginfo-analyzer.cpp:137:33
    #13 0x7fadb1ca7d8f  (/lib/x86_64-linux-gnu/libc.so.6+0x29d8f) (BuildId: 69389d485a9793dbe873f0ea2c93e02efaa9aa3d)

SUMMARY: AddressSanitizer: 1440 byte(s) leaked in 12 allocation(s).

[vitalybuka]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

384

Why this code does not use unique_ptr<> ?

[vitalybuka]

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

181

This code can be improved according to https://llvm.org/docs/ProgrammersManual.html#picking-the-right-data-structure-for-a-task

[CarlosAlbertoEnciso]

In D125783#3890698, @vitalybuka wrote:

==1211325==ERROR: LeakSanitizer: detected memory leaks
SUMMARY: AddressSanitizer: 1440 byte(s) leaked in 12 allocation(s).

@vitalybuka Thanks very for the additional information for the failure.

[CarlosAlbertoEnciso]

The following tests have been disabled for further investigation:

• tools/llvm-debuginfo-analyzer/DWARF/pr-incorrect-logical-instructions.test

https://reviews.llvm.org/rGd81725d2bc016b58cb9327910f7892a2d4ac53c1

sanitizer-x86_64-linux-fast
https://lab.llvm.org/buildbot/#/builders/5/builds/28595

sanitizer-x86_64-linux-bootstrap-asan
https://lab.llvm.org/buildbot/#/builders/168/builds/9731

ERROR: LeakSanitizer: detected memory leaks

• tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test

https://reviews.llvm.org/rG5193d0a4a305d0dc8d611ade9f059fe904cf6e99

clang-armv7-vfpv3-2stage
https://lab.llvm.org/buildbot/#/builders/182/builds/4232

clang-armv7-global-isel
https://lab.llvm.org/buildbot/#/builders/186/builds/9519

clang-armv7-2stage
https://lab.llvm.org/buildbot/#/builders/187/builds/9483

Unexpected test output

Expected:
 189 (100.00%) : [0x000000000b][001]    {CompileUnit}
 110 ( 58.20%) : [0x000000002a][002] 2    {Function}
  27 ( 14.29%) : [0x0000000071][003]        {Block}

Generated:
3432 (  0.00%) : [0x000000000b][001]    {CompileUnit}
3351 (  0.00%) : [0x000000002a][002] 2    {Function}
3234 (  0.00%) : [0x0000000071][003]        {Block}

[CarlosAlbertoEnciso]

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

181

Thanks for the link. Added to the list of improvements.
The list will be added as 'README.txt' in llvm\tools\llvm-debuginfo-analyzer

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

384

The memory management issue has been already discussed in the reviews and it would be addressed once the series of patches are landed.

[dblaikie]

A bit concerned about two things that happened here (though, apologies as I haven't otherwise been following the review):

1. disabling tests - generally code is reviewed with the tests, disabling the tests renders the review approval non-standing because the code is now not covered by tests. Usually the solution is to revert the patch while addressing issues like this.
2. code review feedback (such as memory allocation handling) being pushed back to some much later stage isn't usually the way we do things if it's reasonable observations about how things are done - postcommit (or, it sounds like precommit) feedback is to be addressed "There is a strong expectation that authors respond promptly to post-commit feedback and address it." (perhaps you could link to the other discussion on the raw new usage issue? Might help provide explanation for why it's not already addressed?)

I understand this is a complex/large patch series, but these are the sort of reasons they are generally discourageed - because it's expensive for both reviewers and authors to do quality review when lots of code is already written on top of the patches being reviewed (you get that pushback of "but if I fix this, all the other patches are broken/need fixes, and that's expensive").

[mgorny]

This is also broken on i386 (so perhaps on all 32-bit platforms?):

FAIL: LLVM :: tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test (40612 of 44599)
******************** TEST 'LLVM :: tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test' FAILED ********************
Script:
--
: 'RUN: at line 24';   /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm_build-abi_x86_32.x86/bin/llvm-debuginfo-analyzer --attribute=all                          --print=all                          /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/Inputs/test-dwarf-clang.o 2>&1 |  /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm_build-abi_x86_32.x86/bin/FileCheck --strict-whitespace -check-prefix=ONE /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test
--
Exit Code: 1

Command Output (stderr):
--
+ : 'RUN: at line 24'
+ /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm_build-abi_x86_32.x86/bin/FileCheck --strict-whitespace -check-prefix=ONE /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test
+ /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm_build-abi_x86_32.x86/bin/llvm-debuginfo-analyzer --attribute=all --print=all /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/Inputs/test-dwarf-clang.o
/var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test:103:20: error: ONE-NEXT: expected string not found in input
; ONE-NEXT:        189 (100.00%) : [0x000000000b][001]              {CompileUnit} 'test.cpp'
                   ^
<stdin>:75:13: note: scanning from here
Scope Sizes:
            ^
<stdin>:76:8: note: possible intended match here
       189 (  0.00%) : [0x000000000b][001]              {CompileUnit} 'test.cpp'
       ^

Input file: <stdin>
Check file: /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm/test/tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test

-dump-input=help explains the following input dump.

Input was:
<<<<<<
            .
            .
            .
           70: Types            5          5 
           71: Lines           25         25 
           72: ----------------------------- 
           73: Total           37         37 
           74:  
           75: Scope Sizes: 
next:103'0                 X error: no match found
           76:        189 (  0.00%) : [0x000000000b][001]              {CompileUnit} 'test.cpp' 
next:103'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
next:103'1            ?                                                                          possible intended match
           77:        110 ( -0.00%) : [0x000000002a][002]      2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int' 
next:103'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
           78:         27 (-26815615859885194199148049996411692254958731641184786755447122887443528060147093953603748596333806855380063716372972101707507765623893139892867298012168192.00%) : [0x0000000071][003]                  {Block} 
next:103'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
           79:  
next:103'0     ~
           80: Totals by lexical level: 
next:103'0     ~~~~~~~~~~~~~~~~~~~~~~~~~
           81: [001]:        189 (100.00%) 
next:103'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            .
            .
            .
>>>>>>

--

********************

[CarlosAlbertoEnciso]

In D125783#3894727, @mgorny wrote:

This is also broken on i386 (so perhaps on all 32-bit platforms?):

Input was:
           76:        189 (  0.00%) : [0x000000000b][001]              {CompileUnit} 'test.cpp' 
           77:        110 ( -0.00%) : [0x000000002a][002]      2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int' 
           78:         27 (-26815615859885194199148049996411692254958731641184786755447122887443528060147093953603748596333806855380063716372972101707507765623893139892867298012168192.00%) : [0x0000000071][003]                  {Block}

That failure is the same as the one detected on ARM: https://reviews.llvm.org/rG5193d0a4a305d0dc8d611ade9f059fe904cf6e99.

As you are building on i386, can I have the CMake configuration?
Locally I build on Ubuntu 20.04.5 LTS (64-bit). I can try to build a 32-bit version (LLVM_BUILD_32_BITS=on).
Thanks

[CarlosAlbertoEnciso]

In D125783#3893003, @dblaikie wrote:

A bit concerned about two things that happened here (though, apologies as I haven't otherwise been following the review):

Very much appreciated your input and I fully understand your concerns about code reviews and large/complex patches.

1. disabling tests - generally code is reviewed with the tests, disabling the tests renders the review approval non-standing because the code is now not covered by tests. Usually the solution is to revert the patch while addressing issues like this.

There are 2 specific cases that are failing:

• Memory leak detected by the sanitizers: tools/llvm-debuginfo-analyzer/DWARF/pr-incorrect-logical-instructions.test

Currently I am working on a fix which I hope to submit in the next couple of days.

• unexpected output: tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test

The test fails on some ARM configurations and i386 (32-bit) as reported by @mgorny.
From an early analysis based on the error, the code associated with --print=sizes fails.
I can enable the test and change --print=all which is equivalent to --print=elements,warnings,summary,sizes to elements,warnings,summary and open a GitHub issue.

2. code review feedback (such as memory allocation handling) being pushed back to some much later stage isn't usually the way we do things if it's reasonable observations about how things are done - postcommit (or, it sounds like precommit) feedback is to be addressed "There is a strong expectation that authors respond promptly to post-commit feedback and address it." (perhaps you could link to the other discussion on the raw new usage issue? Might help provide explanation for why it's not already addressed?)

We are fully aware of the issues related with the current memoy allocation and changing it to use smart pointers is a priority.
Based on your suggestion, I can create a GitHub issue to include all the information and add that link to each of the entries in the reviews that refer to the memory handling.

I understand this is a complex/large patch series, but these are the sort of reasons they are generally discourageed - because it's expensive for both reviewers and authors to do quality review when lots of code is already written on top of the patches being reviewed (you get that pushback of "but if I fix this, all the other patches are broken/need fixes, and that's expensive").

Thanks for your understanding on the nature of the patches.

[mgorny]

As you are building on i386, can I have the CMake configuration?

Just to be clear, I'm building 32-bit multilib on amd64. The full config we're using is:

cmake -C /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm_build-abi_x86_32.x86/gentoo_common_config.cmake -G Ninja -DCMAKE_INSTALL_PREFIX=/usr -DLLVM_APPEND_VC_REV=OFF -DCMAKE_INSTALL_PREFIX=/usr/lib/llvm/16 -DLLVM_LIBDIR_SUFFIX= -DBUILD_SHARED_LIBS=OFF -DLLVM_BUILD_LLVM_DYLIB=ON -DLLVM_LINK_LLVM_DYLIB=ON -DLLVM_DISTRIBUTION_COMPONENTS=LLVM;LTO;Remarks;llvm-config;cmake-exports;llvm-headers;LLVMDemangle;LLVMSupport;LLVMTableGen; -DLLVM_TARGETS_TO_BUILD= -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=SPIRV;X86;ARM;MSP430;SystemZ;Mips;AMDGPU;PowerPC;Sparc;M68k;CSKY;BPF;Hexagon;XCore;AVR;VE;WebAssembly;NVPTX;DirectX;Lanai;ARC;LoongArch;RISCV;AArch64 -DLLVM_BUILD_TESTS=yes -DLLVM_ENABLE_FFI=yes -DLLVM_ENABLE_LIBEDIT=yes -DLLVM_ENABLE_TERMINFO=yes -DLLVM_ENABLE_LIBXML2=yes -DLLVM_ENABLE_ASSERTIONS=no -DLLVM_ENABLE_LIBPFM=yes -DLLVM_ENABLE_EH=ON -DLLVM_ENABLE_RTTI=ON -DLLVM_ENABLE_Z3_SOLVER=yes -DLLVM_ENABLE_ZSTD=yes -DLLVM_HOST_TRIPLE=i686-pc-linux-gnu -DFFI_INCLUDE_DIR=/usr/lib/libffi/include  -DFFI_LIBRARY_DIR= -DLLVM_HAVE_LIBXAR=0 -DPython3_EXECUTABLE=/usr/bin/python3.11 -DOCAMLFIND=NO -DLLVM_VERSION_SUFFIX=gitc4a8f9ab -DLLVM_LIT_ARGS=-vv;-j;12 -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_TOOLCHAIN_FILE=/var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm_build-abi_x86_32.x86/gentoo_toolchain.cmake /var/tmp/portage/sys-devel/llvm-16.0.0_pre20221029/work/llvm

gentoo_common_config is:

set(CMAKE_GENTOO_BUILD ON CACHE BOOL "Indicate Gentoo package build")
set(LIB_SUFFIX  CACHE STRING "library path suffix" FORCE)
set(CMAKE_INSTALL_LIBDIR lib CACHE PATH "Output directory for libraries")
set(CMAKE_INSTALL_INFODIR "/usr/share/info" CACHE PATH "")
set(CMAKE_INSTALL_MANDIR "/usr/share/man" CACHE PATH "")
set(CMAKE_USER_MAKE_RULES_OVERRIDE "/var/tmp/portage/sys-devel/llvm-16.0.0_pre20221023/work/llvm_build-abi_x86_32.x86/gentoo_rules.cmake" CACHE FILEPATH "Gentoo override rules")
set(CMAKE_INSTALL_DOCDIR "/usr/share/doc/llvm-16.0.0_pre20221023" CACHE PATH "")
set(BUILD_SHARED_LIBS ON CACHE BOOL "")
set(CMAKE_INSTALL_ALWAYS 1)
set(CMAKE_ASM_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_ASM-ATT_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_Fortran_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "" CACHE STRING "")
set(CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "" CACHE STRING "")

gentoo_toolchain.cmake is:

set(CMAKE_ASM_COMPILER "x86_64-pc-linux-gnu-gcc;-m32 -mfpmath=sse")
set(CMAKE_ASM-ATT_COMPILER "x86_64-pc-linux-gnu-gcc;-m32 -mfpmath=sse")
set(CMAKE_C_COMPILER "x86_64-pc-linux-gnu-gcc;-m32 -mfpmath=sse")
set(CMAKE_CXX_COMPILER "x86_64-pc-linux-gnu-g++;-m32 -mfpmath=sse")
set(CMAKE_Fortran_COMPILER "x86_64-pc-linux-gnu-gfortran;-m32 -mfpmath=sse")
set(CMAKE_AR /usr/bin/x86_64-pc-linux-gnu-ar CACHE FILEPATH "Archive manager" FORCE)
set(CMAKE_RANLIB /usr/bin/x86_64-pc-linux-gnu-ranlib CACHE FILEPATH "Archive index generator" FORCE)
set(CMAKE_SYSTEM_PROCESSOR "i686")

But I can also reproduce in my working copy that's configured as:

CC=i686-pc-linux-gnu-gcc CXX=i686-pc-linux-gnu-g++ cmake ../llvm -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=MinSizeRel -DLLVM_TARGETS_TO_BUILD=X86 -DCLANG_ENABLE_ARCMT=OFF -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_CCACHE_BUILD=ON -DLLVM_ENABLE_PROJECTS='llvm' -DLLVM_BUILD_TESTS=OFF -DLLVM_HOST_TRIPLE=i686-pc-linux-gnu

where i686-pc-linux-gnu-* wrappers simply call the respective GCC executables with -m32.

[CarlosAlbertoEnciso]

In D125783#3896360, @mgorny wrote:

As you are building on i386, can I have the CMake configuration?

Just to be clear, I'm building 32-bit multilib on amd64.
But I can also reproduce in my working copy that's configured as:

CC=i686-pc-linux-gnu-gcc CXX=i686-pc-linux-gnu-g++ cmake ../llvm -G Ninja -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=MinSizeRel -DLLVM_TARGETS_TO_BUILD=X86 -DCLANG_ENABLE_ARCMT=OFF -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_CCACHE_BUILD=ON -DLLVM_ENABLE_PROJECTS='llvm' -DLLVM_BUILD_TESTS=OFF -DLLVM_HOST_TRIPLE=i686-pc-linux-gnu

where i686-pc-linux-gnu-* wrappers simply call the respective GCC executables with -m32.

@mgorny Thanks very much for the command lines.

[CarlosAlbertoEnciso]

After installing gcc-i686-linux-gnu and using

CC='/usr/bin/i686-linux-gnu-gcc -m32' CXX='/usr/bin/i686-linux-gnu-g++ -m32' cmake ../llvm -GNinja -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=MinSizeRel -DLLVM_TARGETS_TO_BUILD=X86 -DCLANG_ENABLE_ARCMT=OFF -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_CCACHE_BUILD=ON -DLLVM_ENABLE_PROJECTS="llvm" -DLLVM_BUILD_TESTS=OFF -DLLVM_HOST_TRIPLE=i686-pc-linux-gnu

I can reproduce the problem with

llvm-debuginfo-analyzer --attribute=offset,level --print=scopes,sizes ../llvm/test/tools/llvm-debuginfo-analyzer/DWARF/Inputs/test-dwarf-clang.o

Logical View:
[0x0000000000][000]           {File} 'test-dwarf-clang.o'

[0x000000000b][001]             {CompileUnit} 'test.cpp'
[0x000000002a][002]     2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int'
[0x0000000071][003]                 {Block}

Scope Sizes:
       189 (  0.00%) : [0x000000000b][001]             {CompileUnit} 'test.cpp'
       110 ( -0.00%) : [0x000000002a][002]     2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int'
        27 (-26815615859885194199148049996411692254958731641184786755447122887443528060147093953603748596333806855380063716372972101707507765623893139892867298012168192.00%) : [0x0000000071][003]                 {Block}

Totals by lexical level:
[001]:        189 (100.00%)
[002]:        110 ( 58.20%)
[003]:         27 ( 14.29%)

Expect output

Logical View:
[0x0000000000][000]           {File} 'test-dwarf-clang.o'

[0x000000000b][001]             {CompileUnit} 'test.cpp'
[0x000000002a][002]     2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int'
[0x0000000071][003]                 {Block}

Scope Sizes:
       189 (100.00%) : [0x000000000b][001]             {CompileUnit} 'test.cpp'
       110 ( 58.20%) : [0x000000002a][002]     2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int'
        27 ( 14.29%) : [0x0000000071][003]                 {Block}

Totals by lexical level:
[001]:        189 (100.00%)
[002]:        110 ( 58.20%)
[003]:         27 ( 14.29%)

[CarlosAlbertoEnciso]

The test case tools/llvm-debuginfo-analyzer/DWARF/pr-incorrect-logical-instructions.test was disabled due to memory leak detected by the sanitizers.

Uploaded patch for review: https://reviews.llvm.org/D137156 that fixes that issue and enables the test.

Failures before the patch:

sanitizer-x86_64-linux-fast: https://lab.llvm.org/buildbot/#/builders/5/builds/28595
sanitizer-x86_64-linux-bootstrap-asan: https://lab.llvm.org/buildbot/#/builders/168/builds/9731

Successful builds after the patch:
sanitizer-x86_64-linux-fast: https://lab.llvm.org/buildbot/#/builders/5/builds/28776
sanitizer-x86_64-linux-bootstrap-asan: https://lab.llvm.org/buildbot/#/builders/168/builds/9850

[CarlosAlbertoEnciso]

The test case tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test was disabled due to unexpected output:

Uploaded patch for review: https://reviews.llvm.org/D137242 that removes the option to print the sizes.

• The test now is enabled
• Creared https://github.com/llvm/llvm-project/issues/58758

[CarlosAlbertoEnciso]

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

3

An updated patch for 09-codeview-reader https://reviews.llvm.org/D125784 includes this change.

9

I was not able to rewrite the test without using getInputFileDirectory. Looked at other test cases that include a binary file and they use the same approach.

[thakis]

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

9

Any chance you could use a lit test instead of a unit test for this then?

[dblaikie]

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

9

Yeah, seems like either a lit test (if this library is predominantly/sufficiently exposed via a command line utility - we generally test via lit tests on that corresponding command line utility (eg: other libraries in lib/DebugInfo are tested via llvm-dwarfdump and llvm-symbolizer, mostly))

Alternatively, if there's nuanced uses of the library not readily accessible via the command line (or easier to test once at a lower layer) - like some parts of libDebugInfoDWARF - are tested via unit tests that generate the DWARF they're testing within the unit test, rather than depending on a checked in binary. (see DWARFGenerator usage in the unit tests fo rexamples of this)

[mgorny]

Submitted D137400 as the correct fix for 32-bit platforms. However, the code seems to mix integer types freely, so I suspect there could be more subtle breakage there.

[CarlosAlbertoEnciso]

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

384

@vitalybuka: A new patch has been uploaded that addresses the memory management issues: https://reviews.llvm.org/D137933 (10 Smart pointers). With that patch the tool uses only smart pointers.

[CarlosAlbertoEnciso]

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

9

Created https://reviews.llvm.org/D144857 that contains the README for the tool.

It contains notes collected during the development, review and test.
It describes limitations, know issues and future work.

The next patch will address the issue for the unit test.

[CarlosAlbertoEnciso]

https://reviews.llvm.org/D144857 added the README for the tool.

• Contains notes collected during the development, review and test.
• Describes limitations, know issues and future work.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

struct LineTable {
 
     /// Fills the Result argument with the file and line information
     /// corresponding to Address. Returns true on success.
     bool getFileLineInfoForAddress(object::SectionedAddress Address,
                                    const char *CompDir,
                                    DILineInfoSpecifier::FileLineInfoKind Kind,
                                    DILineInfo &Result) const;
 
+    /// Extracts directory name by its Entry in include directories table
+    /// in prologue. Returns true on success.
+    bool getDirectoryForEntry(const FileNameEntry &Entry,
+                              std::string &Directory) const;
+
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     void clear();
 
     /// Parse prologue and all rows.
     Error parse(DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
                 const DWARFContext &Ctx, const DWARFUnit *U,
                 function_ref<void(Error)> RecoverableErrorHandler,
                 raw_ostream *OS = nullptr, bool Verbose = false);

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

public:
   StringRef getData() const { return Data.getData(); }
 
 private:
   DataExtractor Data;
   uint8_t AddressSize;
   Optional<dwarf::DwarfFormat> Format;
 };
 
+bool prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
+                           DIDumpOptions DumpOpts, uint8_t Opcode,
+                           const uint64_t Operands[2], const MCRegisterInfo *MRI,
+                           bool isEH);
+
 inline bool operator==(const DWARFExpression::iterator &LHS,
                        const DWARFExpression::iterator &RHS) {
   return LHS.Expr == RHS.Expr && LHS.Offset == RHS.Offset;
 }
 }
 #endif

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
 
   DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
     extractDIEsIfNeeded(ExtractUnitDIEOnly);
     if (DieArray.empty())
       return DWARFDie();
     return DWARFDie(this, &DieArray[0]);
   }
 
-  DWARFDie getNonSkeletonUnitDIE(bool ExtractUnitDIEOnly = true) {
-    parseDWO();
-    if (DWO)
-      return DWO->getUnitDIE(ExtractUnitDIEOnly);
-    return getUnitDIE(ExtractUnitDIEOnly);
+  DWARFDie getNonSkeletonUnitDIE(bool ExtractUnitDIEOnly = true,
+                                 StringRef DWOAlternativeLocation = {}) {
+    parseDWO(DWOAlternativeLocation);
+    return DWO ? DWO->getUnitDIE(ExtractUnitDIEOnly)
+               : getUnitDIE(ExtractUnitDIEOnly);
   }
 
   const char *getCompilationDir();
   Optional<uint64_t> getDWOId() {
     extractDIEsIfNeeded(/*CUDieOnly*/ true);
     return getHeader().getDWOId();
   }
   void setDWOId(uint64_t NewID) { Header.setDWOId(NewID); }
private:
   /// extractDIEsToVector - Appends all parsed DIEs to a vector.
   void extractDIEsToVector(bool AppendCUDie, bool AppendNonCUDIEs,
                            std::vector<DWARFDebugInfoEntry> &DIEs) const;
 
   /// clearDIEs - Clear parsed DIEs to keep memory usage low.
   void clearDIEs(bool KeepCUDie);
 
   /// parseDWO - Parses .dwo file for current compile unit. Returns true if
   /// it was actually constructed.
-  bool parseDWO();
+  bool parseDWO(StringRef AlternativeLocation = {});
 };
 
 inline bool isCompileUnit(const std::unique_ptr<DWARFUnit> &U) {
   return !U->isTypeUnit();
 }
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFUNIT_H

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

 #ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLOCATION_H
 #define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLOCATION_H
 
 #include "llvm/DebugInfo/LogicalView/Core/LVObject.h"
 
 namespace llvm {
 namespace logicalview {
 
+using LVLineRange = std::pair<LVLine *, LVLine *>;
+
 // The DW_AT_data_member_location attribute is a simple member offset.
 const LVSmall LVLocationMemberOffset = 0;
 
 class LVOperation final {
   // To describe an operation:
   // OpCode
   // Operands[0]: First operand.
   // Operands[1]: Second operand.

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

 // Support for CodeView ModifierOptions::Unaligned.
 constexpr Tag DW_TAG_unaligned = Tag(dwarf::DW_TAG_hi_user + 1);
 } // namespace dwarf
 } // namespace llvm
 
 namespace llvm {
 namespace logicalview {
 
+using LVSectionIndex = uint64_t;
 using LVAddress = uint64_t;
 using LVHalf = uint16_t;
 using LVLevel = uint32_t;
 using LVOffset = uint64_t;
 using LVSigned = int64_t;
 using LVUnsigned = uint64_t;
 using LVSmall = uint8_t;
 

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVREADER_H
 #define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVREADER_H
 
 #include "llvm/DebugInfo/LogicalView/Core/LVOptions.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVRange.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <map>
 
 namespace llvm {
 namespace logicalview {
 
+constexpr LVSectionIndex UndefinedSectionIndex = 0;
+
 class LVScopeCompileUnit;
 class LVObject;
 
 class LVSplitContext final {
   std::unique_ptr<ToolOutputFile> OutputFile;
   std::string Location;
 
 public:

 protected:
   LVScopeRoot *Root = nullptr;
   std::string InputFilename;
   std::string FileFormatName;
   ScopedPrinter &W;
   raw_ostream &OS;
   LVScopeCompileUnit *CompileUnit = nullptr;
 
+  // Only for ELF format. The CodeView is handled in a different way.
+  LVSectionIndex DotTextSectionIndex = UndefinedSectionIndex;
+
   // Record Compilation Unit entry.
   void addCompileUnitOffset(LVOffset Offset, LVScopeCompileUnit *CompileUnit) {
     CompileUnits.emplace(Offset, CompileUnit);
   }
 
   // Create the Scope Root.
   virtual Error createScopes() {
     Root = new LVScopeRoot();
     Root->setName(getFilename());
     if (options().getAttributeFormat())
       Root->setFileFormatName(FileFormatName);
public:
   Error doPrint();
   Error doLoad();
 
   virtual std::string getRegisterName(LVSmall Opcode, uint64_t Operands[2]) {
     llvm_unreachable("Invalid instance reader.");
     return {};
   }
 
-  virtual bool isSystemEntry(LVElement *Element, StringRef Name = {}) {
+  LVSectionIndex getDotTextSectionIndex() const { return DotTextSectionIndex; }
+  virtual LVSectionIndex getSectionIndex(LVScope *Scope) {
+    return getDotTextSectionIndex();
+  }
+
+  virtual bool isSystemEntry(LVElement *Element, StringRef Name = {}) const {
     return false;
   };
 
   // Access to split context.
   LVSplitContext &getSplitContext() { return SplitContext; }
 
   // In the case of element comparison, register that added element.
   void notifyAddedElement(LVLine *Line) {

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

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H
 #define LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVSCOPE_H
 
 #include "llvm/DebugInfo/LogicalView/Core/LVElement.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVLocation.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVSort.h"
+#include "llvm/Object/ObjectFile.h"
 #include <list>
 #include <map>
 #include <set>
 
 namespace llvm {
 namespace logicalview {
 
+// Name address, Code size.
+using LVNameInfo = std::pair<LVAddress, uint64_t>;
+using LVPublicNames = std::map<LVScope *, LVNameInfo>;
+using LVPublicAddresses = std::map<LVAddress, LVNameInfo>;
+
 class LVRange;
 
 enum class LVScopeKind {
   IsAggregate,
   IsArray,
   IsBlock,
   IsCallSite,
   IsCatchBlock,
public:
   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;
 
+  // As the .debug_pubnames section has been removed in DWARF5, we have a
+  // similar functionality, which is used by the decoded functions. We use
+  // the low-pc and high-pc for those scopes that are marked as public, in
+  // order to support DWARF and CodeView.
+  LVPublicNames PublicNames;
+
   // Toolchain producer.
   size_t ProducerIndex = 0;
 
   // Compilation directory name.
   size_t CompilationDirectoryIndex = 0;
 
   // Keep record of elements. They are needed at the compilation unit level
   // to print the summary at the end of the printing.
   LVCounter Allocated;
   LVCounter Found;
   LVCounter Printed;
 
   // Elements that match a given command line pattern.
   LVElements MatchedElements;
   LVScopes MatchedScopes;
 
   // It records the mapping between logical lines representing a debug line
   // entry and its address in the text section. It is used to find a line
-  // giving its exact or closest address.
+  // giving its exact or closest address. To support comdat functions, all
+  // addresses for the same section are recorded in the same map.
   using LVAddressToLine = std::map<LVAddress, LVLine *>;
-  LVAddressToLine AddressToLine;
+  LVDoubleMap<LVSectionIndex, LVAddress, LVLine *> SectionMappings;
 
   // DWARF Tags (Tag, Element list).
   LVTagOffsetsMap DebugTags;
 
   // Offsets associated with objects being flagged as having invalid data
   // (ranges, locations, lines zero or coverages).
   LVOffsetElementMap WarningOffsets;
 
class LVScopeCompileUnit final : public LVScope {
   // Setting an initial size that will cover a very deep nested scopes.
   const size_t TotalInitialSize = 8;
   using LVTotalsEntry = std::pair<unsigned, float>;
   SmallVector<LVTotalsEntry> Totals;
   // Maximum seen lexical level. It is used to control how many entries
   // in the 'Totals' vector are valid values.
   LVLevel MaxSeenLevel = 0;
 
+  // Get the line located at the given address.
+  LVLine *lineLowerBound(LVAddress Address, LVScope *Scope) const;
+  LVLine *lineUpperBound(LVAddress Address, LVScope *Scope) const;
+
   void printScopeSize(LVScope *Scope, raw_ostream &OS);
   void printScopeSize(LVScope *Scope, raw_ostream &OS) const {
     (const_cast<LVScopeCompileUnit *>(this))->printScopeSize(Scope, OS);
   }
   void printTotals(raw_ostream &OS) const;
 
 protected:
   void printSizes(raw_ostream &OS) const override;
~LVScopeCompileUnit() {
     deleteList<LVOffsetLocationsMap>(InvalidRanges);
     deleteList<LVOffsetLinesMap>(LinesZero);
   }
 
   LVScope *getCompileUnitParent() const override {
     return static_cast<LVScope *>(const_cast<LVScopeCompileUnit *>(this));
   }
 
-  // Get the line located at the given address.
-  LVLine *lineLowerBound(LVAddress Address) const;
-  LVLine *lineUpperBound(LVAddress Address) const;
+  // Add line to address mapping.
+  void addMapping(LVLine *Line, LVSectionIndex SectionIndex);
+  LVLineRange lineRange(LVLocation *Location) const;
+
+  LVNameInfo NameNone = {UINT64_MAX, 0};
+  void addPublicName(LVScope *Scope, LVAddress LowPC, LVAddress HighPC) {
+    PublicNames.emplace(std::piecewise_construct, std::forward_as_tuple(Scope),
+                        std::forward_as_tuple(LowPC, HighPC - LowPC));
+  }
+  const LVNameInfo &findPublicName(LVScope *Scope) {
+    LVPublicNames::iterator Iter = PublicNames.find(Scope);
+    return (Iter != PublicNames.end()) ? Iter->second : NameNone;
+  }
+  const LVPublicNames &getPublicNames() const { return PublicNames; }
+
+  // The base address of the scope for any of the debugging information
+  // entries listed, is given by either the DW_AT_low_pc attribute or the
+  // first address in the first range entry in the list of ranges given by
+  // the DW_AT_ranges attribute.
+  LVAddress getBaseAddress() const {
+    return Ranges ? Ranges->front()->getLowerAddress() : 0;
+  }
 
   StringRef getCompilationDirectory() const {
     return getStringPool().getString(CompilationDirectoryIndex);
   }
   void setCompilationDirectory(StringRef CompilationDirectory) {
     CompilationDirectoryIndex = getStringPool().getIndex(CompilationDirectory);
   }
 

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

 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cctype>
+#include <map>
 #include <sstream>
 
 namespace llvm {
 namespace logicalview {
 
 // Utility class to help memory management and perform an automatic cleaning.
 template <typename T, unsigned N = 8>
 class LVAutoSmallVector : public SmallVector<T, N> {
template <typename MapType, typename ListType, typename KeyType,
           typename ValueType>
 void addItem(MapType *Map, KeyType Key, ValueType Value) {
   ListType *List = nullptr;
   typename MapType::const_iterator Iter = Map->find(Key);
   if (Iter != Map->end())
     List = Iter->second;
   else {
     List = new ListType();
     Map->emplace(Key, List);
   }
   List->push_back(Value);
 }
 
 // Delete the map contained list.
 template <typename MapType> void deleteList(MapType &Map) {
   for (typename MapType::const_reference Entry : Map)
     delete Entry.second;
 }
 
+// Double map data structure.
+template <typename FirstKeyType, typename SecondKeyType, typename ValueType>
+class LVDoubleMap {
+  static_assert(std::is_pointer<ValueType>::value,
+                "ValueType must be a pointer.");
+  using LVSecondMapType = std::map<SecondKeyType, ValueType>;
+  using LVFirstMapType = std::map<FirstKeyType, LVSecondMapType *>;
+  using LVValueTypes = std::vector<ValueType>;
+  LVFirstMapType FirstMap;
+
+public:
+  LVDoubleMap() = default;
+  ~LVDoubleMap() {
+    for (auto &Entry : FirstMap)
+      delete Entry.second;
+  }
+
+public:
+  void add(FirstKeyType FirstKey, SecondKeyType SecondKey, ValueType Value) {
+    LVSecondMapType *SecondMap = nullptr;
+    typename LVFirstMapType::iterator FirstIter = FirstMap.find(FirstKey);
+    if (FirstIter == FirstMap.end()) {
+      SecondMap = new LVSecondMapType();
+      FirstMap.emplace(FirstKey, SecondMap);
+    } else {
+      SecondMap = FirstIter->second;
+    }
+
+    assert(SecondMap && "SecondMap is null.");
+    if (SecondMap && SecondMap->find(SecondKey) == SecondMap->end())
+      SecondMap->emplace(SecondKey, Value);
+  }
+
+  LVSecondMapType *findMap(FirstKeyType FirstKey) const {
+    typename LVFirstMapType::const_iterator FirstIter = FirstMap.find(FirstKey);
+    if (FirstIter == FirstMap.end())
+      return nullptr;
+
+    LVSecondMapType *SecondMap = FirstIter->second;
+    return SecondMap;
+  }
+
+  ValueType find(FirstKeyType FirstKey, SecondKeyType SecondKey) const {
+    LVSecondMapType *SecondMap = findMap(FirstKey);
+    if (!SecondMap)
+      return nullptr;
+
+    typename LVSecondMapType::const_iterator SecondIter =
+        SecondMap->find(SecondKey);
+    return (SecondIter != SecondMap->end()) ? SecondIter->second : nullptr;
+  }
+
+  // Return a vector with all the 'ValueType' values.
+  LVValueTypes find() const {
+    LVValueTypes Values;
+    if (FirstMap.empty())
+      return Values;
+    for (typename LVFirstMapType::const_reference FirstEntry : FirstMap) {
+      LVSecondMapType *SecondMap = FirstEntry.second;
+      for (typename LVSecondMapType::const_reference SecondEntry : *SecondMap)
+        Values.push_back(SecondEntry.second);
+    }
+    return Values;
+  }
+};
+
 // Unified and flattened pathnames.
 std::string transformPath(StringRef Path);
 std::string flattenedFilePath(StringRef Path);
 
 inline std::string formattedKind(StringRef Kind) {
   return (Twine("{") + Twine(Kind) + Twine("}")).str();
 }
 
 inline std::string formattedName(StringRef Name) {
   return (Twine("'") + Twine(Name) + Twine("'")).str();
 }
 
 inline std::string formattedNames(StringRef Name1, StringRef Name2) {
   return (Twine("'") + Twine(Name1) + Twine(Name2) + Twine("'")).str();
 }
 
+// Return a pathname composed by: parent_path(To) / filename(From).
+// This is useful when a type server (PDB file associated with an object
+// file or a precompiled header file) has been moved from its original
+// location. That is the case when running regression tests.
+inline std::string createAlternativePath(StringRef To, StringRef From) {
+  // Convert any Windows backslashes into forward slashes to get the path.
+  std::string ConvertedPath =
+      sys::path::convert_to_slash(From, sys::path::Style::windows);
+  SmallString<128> Path;
+  sys::path::append(Path, sys::path::parent_path(To),
+                    sys::path::filename(ConvertedPath));
+  return std::string(Path);
+}
+
 // These are the values assigned to the debug location record IDs.
 // See DebugInfo/CodeView/CodeViewSymbols.def.
 // S_DEFRANGE                               0x113f
 // S_DEFRANGE_SUBFIELD                      0x1140
 // S_DEFRANGE_REGISTER                      0x1141
 // S_DEFRANGE_FRAMEPOINTER_REL              0x1142
 // S_DEFRANGE_SUBFIELD_REGISTER             0x1143
 // S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE   0x1144

llvm/include/llvm/DebugInfo/LogicalView/LVReaderHandler.h

+//===-- LVReaderHandler.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 class implements the Reader handler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVREADERHANDLER_H
+#define LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVREADERHANDLER_H
+
+#include "llvm/ADT/PointerUnion.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
+#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/MachOUniversal.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include <string>
+#include <vector>
+
+namespace llvm {
+namespace logicalview {
+
+using LVReaders = std::vector<LVReader *>;
+using ArgVector = std::vector<std::string>;
+using PdbOrObj = PointerUnion<object::ObjectFile *, pdb::PDBFile *>;
+
+// This class performs the following tasks:
+// - Creates a logical reader for every binary file in the command line,
+//   that parses the debug information and creates a high level logical
+//   view representation containing scopes, symbols, types and lines.
+// - Prints and compares the logical views.
+//
+// The supported binary formats are: ELF, MacOS and CodeView.
+class LVReaderHandler {
+  ArgVector &Objects;
+  ScopedPrinter &W;
+  raw_ostream &OS;
+  LVReaders TheReaders;
+
+  Error createReaders();
+  void destroyReaders();
+  Error printReaders();
+  Error compareReaders();
+
+  Error handleArchive(LVReaders &Readers, StringRef Filename,
+                      object::Archive &Arch);
+  Error handleBuffer(LVReaders &Readers, StringRef Filename,
+                     MemoryBufferRef Buffer, StringRef ExePath = {});
+  Error handleFile(LVReaders &Readers, StringRef Filename,
+                   StringRef ExePath = {});
+  Error handleMach(LVReaders &Readers, StringRef Filename,
+                   object::MachOUniversalBinary &Mach);
+  Error handleObject(LVReaders &Readers, StringRef Filename,
+                     object::Binary &Binary);
+
+  Error createReader(StringRef Filename, LVReaders &Readers, PdbOrObj &Input,
+                     StringRef FileFormatName, StringRef ExePath = {});
+
+public:
+  LVReaderHandler() = delete;
+  LVReaderHandler(ArgVector &Objects, ScopedPrinter &W,
+                  LVOptions &ReaderOptions)
+      : Objects(Objects), W(W), OS(W.getOStream()) {
+    setOptions(&ReaderOptions);
+  }
+  LVReaderHandler(const LVReaderHandler &) = delete;
+  LVReaderHandler &operator=(const LVReaderHandler &) = delete;
+  ~LVReaderHandler() { destroyReaders(); }
+
+  Error createReader(StringRef Filename, LVReaders &Readers) {
+    return handleFile(Readers, Filename);
+  }
+  Error process();
+
+  Expected<LVReader *> createReader(StringRef Pathname) {
+    LVReaders Readers;
+    if (Error Err = createReader(Pathname, Readers))
+      return std::move(Err);
+    return Readers[0];
+  }
+  void deleteReader(LVReader *Reader) {
+    delete Reader;
+  }
+
+public:
+  void print(raw_ostream &OS) const;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  void dump() const { print(dbgs()); }
+#endif
+};
+
+} // end namespace logicalview
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVREADERHANDLER_H

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h

+//===-- LVBinaryReader.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 LVBinaryReader class, which is used to describe a
+// binary reader.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVBINARYREADER_H
+#define LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVBINARYREADER_H
+
+#include "llvm/DebugInfo/LogicalView/Core/LVReader.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCDisassembler/MCDisassembler.h"
+#include "llvm/MC/MCInstPrinter.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Object/ObjectFile.h"
+
+namespace llvm {
+namespace logicalview {
+
+constexpr bool UpdateHighAddress = false;
+
+// Logical scope, Section address, Section index, IsComdat.
+struct LVSymbolTableEntry final {
+  LVScope *Scope = nullptr;
+  LVAddress Address = 0;
+  LVSectionIndex SectionIndex = 0;
+  bool IsComdat = false;
+  LVSymbolTableEntry() = default;
+  LVSymbolTableEntry(LVScope *Scope, LVAddress Address,
+                     LVSectionIndex SectionIndex, bool IsComdat)
+      : Scope(Scope), Address(Address), SectionIndex(SectionIndex),
+        IsComdat(IsComdat) {}
+};
+
+// Function names extracted from the object symbol table.
+class LVSymbolTable final {
+  using LVSymbolNames = std::map<std::string, LVSymbolTableEntry>;
+  LVSymbolNames SymbolNames;
+
+public:
+  LVSymbolTable() = default;
+
+  void add(StringRef Name, LVScope *Function, LVSectionIndex SectionIndex = 0);
+  void add(StringRef Name, LVAddress Address, LVSectionIndex SectionIndex,
+           bool IsComdat);
+  LVSectionIndex update(LVScope *Function);
+
+  const LVSymbolTableEntry &getEntry(StringRef Name);
+  LVAddress getAddress(StringRef Name);
+  LVSectionIndex getIndex(StringRef Name);
+  bool getIsComdat(StringRef Name);
+
+  void print(raw_ostream &OS);
+};
+
+class LVBinaryReader : public LVReader {
+  // Function names extracted from the object symbol table.
+  LVSymbolTable SymbolTable;
+
+  // Instruction lines for a logical scope. These instructions are fetched
+  // during its merge with the debug lines.
+  LVDoubleMap<LVSectionIndex, LVScope *, LVLines *> ScopeInstructions;
+
+  // Links the scope with its first assembler address line.
+  LVDoubleMap<LVSectionIndex, LVAddress, LVScope *> AssemblerMappings;
+
+  // Mapping from virtual address to section.
+  // The virtual address refers to the address where the section is loaded.
+  using LVSectionAddresses = std::map<LVSectionIndex, object::SectionRef>;
+  LVSectionAddresses SectionAddresses;
+
+  void addSectionAddress(const object::SectionRef &Section) {
+    if (SectionAddresses.find(Section.getAddress()) == SectionAddresses.end())
+      SectionAddresses.emplace(Section.getAddress(), Section);
+  }
+
+  // Scopes with ranges for current compile unit. It is used to find a line
+  // giving its exact or closest address. To support comdat functions, all
+  // addresses for the same section are recorded in the same map.
+  using LVSectionRanges = std::map<LVSectionIndex, LVRange *>;
+  LVSectionRanges SectionRanges;
+
+  // Image base and virtual address for Executable file.
+  uint64_t ImageBaseAddress = 0;
+  uint64_t VirtualAddress = 0;
+
+  // Object sections with machine code.
+  using LVSections = std::map<LVSectionIndex, object::SectionRef>;
+  LVSections Sections;
+
+protected:
+  // It contains the LVLineDebug elements representing the logical lines for
+  // the current compile unit, created by parsing the debug line section.
+  LVLines CULines;
+
+  std::unique_ptr<const MCRegisterInfo> MRI;
+  std::unique_ptr<const MCAsmInfo> MAI;
+  std::unique_ptr<const MCSubtargetInfo> STI;
+  std::unique_ptr<const MCInstrInfo> MII;
+  std::unique_ptr<const MCDisassembler> MD;
+  std::unique_ptr<MCContext> MC;
+  std::unique_ptr<MCInstPrinter> MIP;
+
+  // Loads all info for the architecture of the provided object file.
+  Error loadGenericTargetInfo(StringRef TheTriple, StringRef TheFeatures);
+
+  virtual void mapRangeAddress(const object::ObjectFile &Obj) {}
+  virtual void mapRangeAddress(const object::ObjectFile &Obj,
+                               const object::SectionRef &Section,
+                               bool IsComdat) {}
+
+  // Create a mapping from virtual address to section.
+  void mapVirtualAddress(const object::ObjectFile &Obj);
+  void mapVirtualAddress(const object::COFFObjectFile &COFFObj);
+
+  Expected<std::pair<LVSectionIndex, object::SectionRef>>
+  getSection(LVScope *Scope, LVAddress Address, LVSectionIndex SectionIndex);
+
+  void addSectionRange(LVSectionIndex SectionIndex, LVScope *Scope);
+  void addSectionRange(LVSectionIndex SectionIndex, LVScope *Scope,
+                       LVAddress LowerAddress, LVAddress UpperAddress);
+  LVRange *getSectionRanges(LVSectionIndex SectionIndex);
+
+  Error createInstructions();
+  Error createInstructions(LVScope *Function, LVSectionIndex SectionIndex);
+  Error createInstructions(LVScope *Function, LVSectionIndex SectionIndex,
+                           const LVNameInfo &NameInfo);
+
+  void processLines(LVLines *DebugLines, LVSectionIndex SectionIndex);
+  void processLines(LVLines *DebugLines, LVSectionIndex SectionIndex,
+                    LVScope *Function);
+
+public:
+  LVBinaryReader() = delete;
+  LVBinaryReader(StringRef Filename, StringRef FileFormatName, ScopedPrinter &W,
+                 LVBinaryType BinaryType)
+      : LVReader(Filename, FileFormatName, W, BinaryType) {}
+  LVBinaryReader(const LVBinaryReader &) = delete;
+  LVBinaryReader &operator=(const LVBinaryReader &) = delete;
+  ~LVBinaryReader() {
+    // Delete the containers created by 'createInstructions'.
+    std::vector<LVLines *> AllInstructionLines = ScopeInstructions.find();
+    for (LVLines *Entry : AllInstructionLines)
+      delete Entry;
+    for (LVSectionRanges::reference Entry : SectionRanges)
+      delete Entry.second;
+  }
+
+public:
+  void addToSymbolTable(StringRef Name, LVScope *Function,
+                        LVSectionIndex SectionIndex = 0);
+  void addToSymbolTable(StringRef Name, LVAddress Address,
+                        LVSectionIndex SectionIndex, bool IsComdat);
+  LVSectionIndex updateSymbolTable(LVScope *Function);
+
+  const LVSymbolTableEntry &getSymbolTableEntry(StringRef Name);
+  LVAddress getSymbolTableAddress(StringRef Name);
+  LVSectionIndex getSymbolTableIndex(StringRef Name);
+  bool getSymbolTableIsComdat(StringRef Name);
+
+  LVSectionIndex getSectionIndex(LVScope *Scope) override {
+    return Scope ? getSymbolTableIndex(Scope->getLinkageName())
+                 : DotTextSectionIndex;
+  }
+
+public:
+  void print(raw_ostream &OS) const;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  void dump() const { print(dbgs()); }
+#endif
+};
+
+} // end namespace logicalview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVBINARYREADER_H

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVELFReader.h

+//===-- LVELFReader.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 LVELFReader class, which is used to describe a
+// debug information (DWARF) reader.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVELFREADER_H
+#define LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVELFREADER_H
+
+#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h"
+#include <unordered_set>
+
+namespace llvm {
+namespace logicalview {
+
+class LVElement;
+class LVLine;
+class LVScopeCompileUnit;
+class LVSymbol;
+class LVType;
+
+using AttributeSpec = DWARFAbbreviationDeclaration::AttributeSpec;
+
+class LVELFReader final : public LVBinaryReader {
+  object::ObjectFile &Obj;
+
+  // The ELF reader does not use this container; it is defined only to
+  // call 'prettyPrintRegisterOp'.
+  DIDumpOptions DumpOpts;
+
+  // Indicates if ranges data are available; in the case of split DWARF any
+  // reference to ranges is valid only if the skeleton DIE has been loaded.
+  bool RangesDataAvailable = false;
+  DWARFDie DummyDie;
+  LVAddress CUBaseAddress = 0;
+  LVAddress CUHighAddress = 0;
+
+  // Current elements during the processing of a DIE.
+  LVElement *CurrentElement = nullptr;
+  LVScope *CurrentScope = nullptr;
+  LVSymbol *CurrentSymbol = nullptr;
+  LVType *CurrentType = nullptr;
+  LVOffset CurrentOffset = 0;
+  LVOffset CurrentEndOffset = 0;
+
+  // In DWARF v4, the files are 1-indexed.
+  // In DWARF v5, the files are 0-indexed.
+  // The ELF reader expects the indexes as 1-indexed.
+  bool IncrementFileIndex = false;
+
+  // Address ranges collected for current DIE.
+  std::vector<LVAddressRange> CurrentRanges;
+
+  // Symbols with locations for current compile unit.
+  LVSymbols SymbolsWithLocations;
+
+  // Global Offsets (Offset, Element).
+  LVOffsetElementMap GlobalOffsets;
+
+  // Low PC and High PC values for DIE being processed.
+  LVAddress CurrentLowPC = 0;
+  LVAddress CurrentHighPC = 0;
+  bool FoundLowPC = false;
+  bool FoundHighPC = false;
+
+  // Cross references (Elements).
+  using LVElementSet = std::unordered_set<LVElement *>;
+  using LVElementEntry = std::pair<LVElement *, LVElementSet>;
+  using LVElementReference = std::unordered_map<LVOffset, LVElementEntry>;
+  LVElementReference ElementTable;
+
+  Error loadTargetInfo(const object::ObjectFile &Obj);
+
+  void mapRangeAddress(const object::ObjectFile &Obj) override;
+
+  LVElement *createElement(dwarf::Tag Tag);
+  void traverseDieAndChildren(DWARFDie &DIE, LVScope *Parent,
+                              DWARFDie &SkeletonDie);
+  // Process the attributes for the given DIE.
+  LVScope *processOneDie(const DWARFDie &InputDIE, LVScope *Parent,
+                         DWARFDie &SkeletonDie);
+  void processOneAttribute(const DWARFDie &Die, LVOffset *OffsetPtr,
+                           const AttributeSpec &AttrSpec);
+  void createLineAndFileRecords(const DWARFDebugLine::LineTable *Lines);
+  void processLocationGaps();
+
+  // Add offset to global map.
+  void addGlobalOffset(LVOffset Offset) {
+    if (GlobalOffsets.find(Offset) == GlobalOffsets.end())
+      // Just associate the DIE offset with a null element, as we do not
+      // know if the referenced element has been created.
+      GlobalOffsets.emplace(Offset, nullptr);
+  }
+
+  // Remove offset from global map.
+  void removeGlobalOffset(LVOffset Offset) {
+    LVOffsetElementMap::iterator Iter = GlobalOffsets.find(Offset);
+    if (Iter != GlobalOffsets.end())
+      GlobalOffsets.erase(Iter);
+  }
+
+  // Get the location information for DW_AT_data_member_location.
+  void getLocationMember(dwarf::Attribute Attr, const DWARFFormValue &FormValue,
+                         const DWARFDie &Die, uint64_t OffsetOnEntry);
+  void getLocationList(dwarf::Attribute Attr, const DWARFFormValue &FormValue,
+                       const DWARFDie &Die, uint64_t OffsetOnEntry,
+                       bool CallSiteLocation = false);
+  void updateReference(dwarf::Attribute Attr, const DWARFFormValue &FormValue);
+
+  // Get an element given the DIE offset.
+  LVElement *getElementForOffset(LVOffset offset, LVElement *Element);
+
+protected:
+  Error createScopes() override;
+  void sortScopes() override;
+
+public:
+  LVELFReader() = delete;
+  LVELFReader(StringRef Filename, StringRef FileFormatName,
+              object::ObjectFile &Obj, ScopedPrinter &W)
+      : LVBinaryReader(Filename, FileFormatName, W, LVBinaryType::ELF),
+        Obj(Obj) {}
+  LVELFReader(const LVELFReader &) = delete;
+  LVELFReader &operator=(const LVELFReader &) = delete;
+  ~LVELFReader() = default;
+
+public:
+  LVAddress getCUBaseAddress() const { return CUBaseAddress; }
+  void setCUBaseAddress(LVAddress Address) { CUBaseAddress = Address; }
+  LVAddress getCUHighAddress() const { return CUHighAddress; }
+  void setCUHighAddress(LVAddress Address) { CUHighAddress = Address; }
+
+  const LVSymbols &GetSymbolsWithLocations() const {
+    return SymbolsWithLocations;
+  }
+
+  std::string getRegisterName(LVSmall Opcode, uint64_t Operands[2]) override;
+
+public:
+  void print(raw_ostream &OS) const;
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  void dump() const { print(dbgs()); }
+#endif
+};
+
+} // end namespace logicalview
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVELFREADER_H

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
     return false;
   Result.Line = Row.Line;
   Result.Column = Row.Column;
   Result.Discriminator = Row.Discriminator;
   Result.Source = getSourceByIndex(Row.File, Kind);
   return true;
 }
 
+bool DWARFDebugLine::LineTable::getDirectoryForEntry(
+    const FileNameEntry &Entry, std::string &Directory) const {
+  if (Prologue.getVersion() >= 5) {
+    if (Entry.DirIdx < Prologue.IncludeDirectories.size())
+      Directory =
+          dwarf::toString(Prologue.IncludeDirectories[Entry.DirIdx], "");
+    return true;
+  } else {
+    if (0 < Entry.DirIdx && Entry.DirIdx <= Prologue.IncludeDirectories.size())
+      Directory =
+          dwarf::toString(Prologue.IncludeDirectories[Entry.DirIdx - 1], "");
+    return true;
+  }
+  return false;
+}
+
 // We want to supply the Unit associated with a .debug_line[.dwo] table when
 // we dump it, if possible, but still dump the table even if there isn't a Unit.
 // Therefore, collect up handles on all the Units that point into the
 // line-table section.
 static DWARFDebugLine::SectionParser::LineToUnitMap
 buildLineToUnitMap(DWARFUnitVector::iterator_range Units) {
   DWARFDebugLine::SectionParser::LineToUnitMap LineToUnit;
   for (const auto &U : Units)

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

if (Die && Die.getTag() == dwarf::DW_TAG_base_type) {
     if (auto Name = dwarf::toString(Die.find(dwarf::DW_AT_name)))
       OS << " \"" << *Name << "\"";
   } else {
     OS << format(" <invalid base_type ref: 0x%" PRIx64 ">",
                  Operands[Operand]);
   }
 }
 
-static bool prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
+bool prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
                                   DIDumpOptions DumpOpts, uint8_t Opcode,
                                   const uint64_t Operands[2],
                                   const MCRegisterInfo *MRI, bool isEH) {
   if (!MRI)
     return false;
 
   uint64_t DwarfRegNum;
   unsigned OpNum = 0;
 
   if (Opcode == DW_OP_bregx || Opcode == DW_OP_regx ||
       Opcode == DW_OP_regval_type)

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

LocTable = std::make_unique<DWARFDebugLoc>(DWARFDataExtractor(
         isLittleEndian, getAddressByteSize()));
   }
 
   // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
   // skeleton CU DIE, so that DWARF users not aware of it are not broken.
   return Error::success();
 }
 
-bool DWARFUnit::parseDWO() {
+bool DWARFUnit::parseDWO(StringRef DWOAlternativeLocation) {
   if (IsDWO)
     return false;
   if (DWO.get())
     return false;
   DWARFDie UnitDie = getUnitDIE();
   if (!UnitDie)
     return false;
   auto DWOFileName = getVersion() >= 5
                          ? dwarf::toString(UnitDie.find(DW_AT_dwo_name))
                          : dwarf::toString(UnitDie.find(DW_AT_GNU_dwo_name));
   if (!DWOFileName)
     return false;
   auto CompilationDir = dwarf::toString(UnitDie.find(DW_AT_comp_dir));
   SmallString<16> AbsolutePath;
   if (sys::path::is_relative(*DWOFileName) && CompilationDir &&
       *CompilationDir) {
     sys::path::append(AbsolutePath, *CompilationDir);
   }
   sys::path::append(AbsolutePath, *DWOFileName);
   auto DWOId = getDWOId();
   if (!DWOId)
     return false;
   auto DWOContext = Context.getDWOContext(AbsolutePath);
+  if (!DWOContext) {
+    // Use the alternative location to get the DWARF context for the DWO object.
+    if (DWOAlternativeLocation.empty())
+      return false;
+    // If the alternative context does not correspond to the original DWO object
+    // (different hashes), the below 'getDWOCompileUnitForHash' call will catch
+    // the issue, with a returned null context.
+    DWOContext = Context.getDWOContext(DWOAlternativeLocation);
     if (!DWOContext)
       return false;
+  }
 
   DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId);
   if (!DWOCU)
     return false;
   DWO = std::shared_ptr<DWARFCompileUnit>(std::move(DWOContext), DWOCU);
   DWO->setSkeletonUnit(this);
   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
   if (AddrOffsetSectionBase)

llvm/lib/DebugInfo/LogicalView/CMakeLists.txt

add_lv_impl_folder(Core
   Core/LVReader.cpp
   Core/LVScope.cpp
   Core/LVSort.cpp
   Core/LVSupport.cpp
   Core/LVSymbol.cpp
   Core/LVType.cpp
   )
 
+add_lv_impl_folder(Readers
+  LVReaderHandler.cpp
+  Readers/LVBinaryReader.cpp
+  Readers/LVELFReader.cpp
+  )
+
 list(APPEND LIBLV_ADDITIONAL_HEADER_DIRS
   "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/LogicalView"
   "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/LogicalView/Core"
+  "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/LogicalView/Readers"
   )
 
 add_llvm_library(LLVMDebugInfoLogicalView
   ${LV_IMPL_SOURCES}
 
   ADDITIONAL_HEADER_DIRS
   ${LIBLV_ADDITIONAL_HEADER_DIRS}
   )

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

 
 void LVElement::printLinkageName(raw_ostream &OS, bool Full,
                                  LVElement *Parent) const {
   if (options().getPrintFormatting() && options().getAttributeLinkage()) {
     printAttributes(OS, Full, "{Linkage} ", Parent, getLinkageName(),
                     /*UseQuotes=*/true, /*PrintRef=*/false);
   }
 }
+
+void LVElement::printLinkageName(raw_ostream &OS, bool Full, LVElement *Parent,
+                                 LVScope *Scope) const {
+  if (options().getPrintFormatting() && options().getAttributeLinkage()) {
+    LVSectionIndex SectionIndex = getReader().getSectionIndex(Scope);
+    std::string Text = (Twine(" 0x") + Twine::utohexstr(SectionIndex) +
+                        Twine(" '") + Twine(getLinkageName()) + Twine("'"))
+                           .str();
+    printAttributes(OS, Full, "{Linkage} ", Parent, Text,
+                    /*UseQuotes=*/false, /*PrintRef=*/false);
+  }
+}

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

bool LVLocation::validateRanges() {
   // mapping in the current compile unit. Record those invalid ranges.
   // A valid range must meet the following conditions:
   // a) line(lopc) <= line(hipc)
   // b) line(lopc) and line(hipc) are valid.
 
   if (!hasAssociatedRange())
     return true;
 
-  LVScopeCompileUnit *Scope = getReader().getCompileUnit();
-  LVLine *LowLine = Scope->lineLowerBound(getLowerAddress());
-  LVLine *HighLine = Scope->lineUpperBound(getUpperAddress());
+  LVLineRange Range = getReaderCompileUnit()->lineRange(this);
+  LVLine *LowLine = Range.first;
+  LVLine *HighLine = Range.second;
   if (LowLine)
     setLowerLine(LowLine);
   else {
     setIsInvalidLower();
     return false;
   }
   if (HighLine)
     setUpperLine(HighLine);

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

if (options().getAttributeLocation()) {
 
     // Validate ranges associated with locations.
     if (RecordInvalid)
       for (LVLocation *Location : Locations)
         addInvalidLocation(Location);
   }
 }
 
-LVLine *LVScopeCompileUnit::lineLowerBound(LVAddress Address) const {
-  LVAddressToLine::const_iterator Iter = AddressToLine.lower_bound(Address);
-  return (Iter != AddressToLine.end()) ? Iter->second : nullptr;
+void LVScopeCompileUnit::addMapping(LVLine *Line, LVSectionIndex SectionIndex) {
+  LVAddress Address = Line->getOffset();
+  SectionMappings.add(SectionIndex, Address, Line);
 }
 
-LVLine *LVScopeCompileUnit::lineUpperBound(LVAddress Address) const {
-  if (AddressToLine.empty())
+LVLine *LVScopeCompileUnit::lineLowerBound(LVAddress Address,
+                                           LVScope *Scope) const {
+  LVSectionIndex SectionIndex = getReader().getSectionIndex(Scope);
+  LVAddressToLine *Map = SectionMappings.findMap(SectionIndex);
+  if (!Map || Map->empty())
     return nullptr;
-  LVAddressToLine::const_iterator Iter = AddressToLine.upper_bound(Address);
-  if (Iter != AddressToLine.begin())
+  LVAddressToLine::const_iterator Iter = Map->lower_bound(Address);
+  return (Iter != Map->end()) ? Iter->second : nullptr;
+}
+
+LVLine *LVScopeCompileUnit::lineUpperBound(LVAddress Address,
+                                           LVScope *Scope) const {
+  LVSectionIndex SectionIndex = getReader().getSectionIndex(Scope);
+  LVAddressToLine *Map = SectionMappings.findMap(SectionIndex);
+  if (!Map || Map->empty())
+    return nullptr;
+  LVAddressToLine::const_iterator Iter = Map->upper_bound(Address);
+  if (Iter != Map->begin())
     Iter = std::prev(Iter);
   return Iter->second;
 }
 
+LVLineRange LVScopeCompileUnit::lineRange(LVLocation *Location) const {
+  // The parent of a location can be a symbol or a scope.
+  LVElement *Element = Location->getParent();
+  LVScope *Parent = Element->getIsScope() ? static_cast<LVScope *>(Element)
+                                          : Element->getParentScope();
+  LVLine *LowLine = lineLowerBound(Location->getLowerAddress(), Parent);
+  LVLine *HighLine = lineUpperBound(Location->getUpperAddress(), Parent);
+  return LVLineRange(LowLine, HighLine);
+}
+
 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))
for (const std::string &Name : UniqueNames)
       OS << std::string(Indentation, ' ') << formattedKind(Kind) << " "
          << formattedName(Name) << "\n";
   };
 
   if (options().getAttributeDirectories())
     PrintNames(Option::Directory);
   if (options().getAttributeFiles())
     PrintNames(Option::File);
+  if (options().getAttributePublics()) {
+    StringRef Kind = "Public";
+    // The public names are indexed by 'LVScope *'. We want to print
+    // them by logical element address, to show the scopes layout.
+    using OffsetSorted = std::map<LVAddress, LVPublicNames::const_iterator>;
+    OffsetSorted SortedNames;
+    for (LVPublicNames::const_iterator Iter = PublicNames.begin();
+         Iter != PublicNames.end(); ++Iter)
+      SortedNames.emplace(Iter->first->getOffset(), Iter);
+
+    LVPublicNames::const_iterator Iter;
+    for (OffsetSorted::reference Entry : SortedNames) {
+      Iter = Entry.second;
+      OS << std::string(Indentation, ' ') << formattedKind(Kind) << " "
+         << formattedName((*Iter).first->getName());
+      if (options().getAttributeOffset()) {
+        LVAddress Address = (*Iter).second.first;
+        size_t Size = (*Iter).second.second;
+        OS << " [" << hexString(Address) << ":" << hexString(Address + Size)
+           << "]";
+      }
+      OS << "\n";
+    }
+  }
 }
 
 void LVScopeCompileUnit::printWarnings(raw_ostream &OS, bool Full) const {
   auto PrintHeader = [&](const char *Header) { OS << "\n" << Header << ":\n"; };
   auto PrintFooter = [&](auto &Set) {
     if (Set.empty())
       OS << "None\n";
   };
OS << formattedKind(kind()) << " " << Attributes << formattedName(getName())
      << discriminatorAsString() << " -> " << typeOffsetAsString()
      << formattedNames(getTypeQualifiedName(), typeAsString()) << "\n";
 
   // Print any active ranges.
   if (Full) {
     if (getIsTemplateResolved())
       printEncodedArgs(OS, Full);
     printActiveRanges(OS, Full);
+    if (getLinkageNameIndex())
+      printLinkageName(OS, Full, const_cast<LVScopeFunction *>(this),
+                       const_cast<LVScopeFunction *>(this));
     if (Reference)
       Reference->printReference(OS, Full, const_cast<LVScopeFunction *>(this));
   }
 }
 
 //===----------------------------------------------------------------------===//
 // DWARF inlined function (DW_TAG_inlined_function).
 //===----------------------------------------------------------------------===//

llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp

+//===-- LVReaderHandler.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 class implements the Reader Handler.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/LogicalView/LVReaderHandler.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
+#include "llvm/DebugInfo/LogicalView/Readers/LVELFReader.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::pdb;
+using namespace llvm::logicalview;
+
+#define DEBUG_TYPE "ReaderHandler"
+
+Error LVReaderHandler::process() {
+  if (Error Err = createReaders())
+    return Err;
+  if (Error Err = printReaders())
+    return Err;
+  if (Error Err = compareReaders())
+    return Err;
+
+  return Error::success();
+}
+
+void LVReaderHandler::destroyReaders() {
+  LLVM_DEBUG(dbgs() << "destroyReaders\n");
+  for (const LVReader *Reader : TheReaders)
+    delete Reader;
+}
+
+Error LVReaderHandler::createReader(StringRef Filename, LVReaders &Readers,
+                                    PdbOrObj &Input, StringRef FileFormatName,
+                                    StringRef ExePath) {
+  auto CreateOneReader = [&]() -> LVReader * {
+    if (Input.is<ObjectFile *>()) {
+      ObjectFile &Obj = *Input.get<ObjectFile *>();
+      if (Obj.isELF() || Obj.isMachO())
+        return new LVELFReader(Filename, FileFormatName, Obj, W);
+    }
+    return nullptr;
+  };
+
+  LVReader *Reader = CreateOneReader();
+  if (!Reader) {
+    std::string TheFilename(Filename);
+    return createStringError(errc::invalid_argument,
+                             "unable to create reader for: '%s'",
+                             TheFilename.c_str());
+  }
+
+  Readers.push_back(Reader);
+  return Reader->doLoad();
+}
+
+Error LVReaderHandler::handleArchive(LVReaders &Readers, StringRef Filename,
+                                     Archive &Arch) {
+  Error Err = Error::success();
+  std::string TheFilename(Filename);
+  for (const Archive::Child &Child : Arch.children(Err)) {
+    Expected<MemoryBufferRef> BuffOrErr = Child.getMemoryBufferRef();
+    if (Error Err = BuffOrErr.takeError())
+      return createStringError(errorToErrorCode(std::move(Err)), "%s",
+                               TheFilename.c_str());
+    Expected<StringRef> NameOrErr = Child.getName();
+    if (Error Err = NameOrErr.takeError())
+      return createStringError(errorToErrorCode(std::move(Err)), "%s",
+                               TheFilename.c_str());
+    std::string Name = (Filename + "(" + NameOrErr.get() + ")").str();
+    if (Error Err = handleBuffer(Readers, Name, BuffOrErr.get()))
+      return createStringError(errorToErrorCode(std::move(Err)), "%s",
+                               TheFilename.c_str());
+  }
+
+  return Error::success();
+}
+
+Error LVReaderHandler::handleBuffer(LVReaders &Readers, StringRef Filename,
+                                    MemoryBufferRef Buffer, StringRef ExePath) {
+  Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buffer);
+  if (errorToErrorCode(BinOrErr.takeError())) {
+    std::string TheFilename(Filename);
+    return createStringError(errc::not_supported,
+                             "Binary object format in '%s' is not supported.",
+                             TheFilename.c_str());
+  }
+  return handleObject(Readers, Filename, *BinOrErr.get());
+}
+
+Error LVReaderHandler::handleFile(LVReaders &Readers, StringRef Filename,
+                                  StringRef ExePath) {
+  // Convert any Windows backslashes into forward slashes to get the path.
+  std::string ConvertedPath =
+      sys::path::convert_to_slash(Filename, sys::path::Style::windows);
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BuffOrErr =
+      MemoryBuffer::getFileOrSTDIN(ConvertedPath);
+  if (BuffOrErr.getError()) {
+    std::string TheFilename(ConvertedPath);
+    return createStringError(errc::bad_file_descriptor,
+                             "File '%s' does not exist.", TheFilename.c_str());
+  }
+  std::unique_ptr<MemoryBuffer> Buffer = std::move(BuffOrErr.get());
+  return handleBuffer(Readers, ConvertedPath, *Buffer, ExePath);
+}
+
+Error LVReaderHandler::handleMach(LVReaders &Readers, StringRef Filename,
+                                  MachOUniversalBinary &Mach) {
+  for (const MachOUniversalBinary::ObjectForArch &ObjForArch : Mach.objects()) {
+    std::string ObjName = (Twine(Filename) + Twine("(") +
+                           Twine(ObjForArch.getArchFlagName()) + Twine(")"))
+                              .str();
+    if (Expected<std::unique_ptr<MachOObjectFile>> MachOOrErr =
+            ObjForArch.getAsObjectFile()) {
+      MachOObjectFile &Obj = **MachOOrErr;
+      PdbOrObj Input = &Obj;
+      if (Error Err =
+              createReader(Filename, Readers, Input, Obj.getFileFormatName()))
+        return Err;
+      continue;
+    } else
+      consumeError(MachOOrErr.takeError());
+    if (Expected<std::unique_ptr<Archive>> ArchiveOrErr =
+            ObjForArch.getAsArchive()) {
+      if (Error Err = handleArchive(Readers, ObjName, *ArchiveOrErr.get()))
+        return Err;
+      continue;
+    } else
+      consumeError(ArchiveOrErr.takeError());
+  }
+  return Error::success();
+}
+
+Error LVReaderHandler::handleObject(LVReaders &Readers, StringRef Filename,
+                                    Binary &Binary) {
+  if (PdbOrObj Input = dyn_cast<ObjectFile>(&Binary))
+    return createReader(Filename, Readers, Input,
+                        Input.get<ObjectFile *>()->getFileFormatName());
+
+  if (MachOUniversalBinary *Fat = dyn_cast<MachOUniversalBinary>(&Binary))
+    return handleMach(Readers, Filename, *Fat);
+
+  if (Archive *Arch = dyn_cast<Archive>(&Binary))
+    return handleArchive(Readers, Filename, *Arch);
+
+  return Error::success();
+}
+
+Error LVReaderHandler::createReaders() {
+  LLVM_DEBUG(dbgs() << "createReaders\n");
+  for (std::string &Object : Objects) {
+    LVReaders Readers;
+    if (Error Err = createReader(Object, Readers))
+      return Err;
+    TheReaders.insert(TheReaders.end(), Readers.begin(), Readers.end());
+  }
+
+  return Error::success();
+}
+
+Error LVReaderHandler::printReaders() {
+  LLVM_DEBUG(dbgs() << "printReaders\n");
+  for (LVReader *Reader : TheReaders)
+    if (options().getPrintExecute())
+      if (Error Err = Reader->doPrint())
+        return Err;
+
+  return Error::success();
+}
+
+Error LVReaderHandler::compareReaders() {
+  LLVM_DEBUG(dbgs() << "compareReaders\n");
+  size_t ReadersCount = TheReaders.size();
+  if (options().getCompareExecute() && ReadersCount >= 2) {
+    // If we have more than 2 readers, compare them by pairs.
+    size_t ViewPairs = ReadersCount / 2;
+    LVCompare Compare(OS);
+    for (size_t Pair = 0, Index = 0; Pair < ViewPairs; ++Pair) {
+      if (Error Err = Compare.execute(TheReaders[Index], TheReaders[Index + 1]))
+        return Err;
+      Index += 2;
+    }
+  }
+
+  return Error::success();
+}
+
+void LVReaderHandler::print(raw_ostream &OS) const { OS << "ReaderHandler\n"; }

llvm/lib/DebugInfo/LogicalView/Readers/LVBinaryReader.cpp

+//===-- LVBinaryReader.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 LVBinaryReader class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/LogicalView/Readers/LVBinaryReader.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/FormatAdapters.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace llvm;
+using namespace llvm::logicalview;
+
+#define DEBUG_TYPE "BinaryReader"
+
+// Function names extracted from the object symbol table.
+void LVSymbolTable::add(StringRef Name, LVScope *Function,
+                        LVSectionIndex SectionIndex) {
+  std::string SymbolName(Name);
+  if (SymbolNames.find(SymbolName) == SymbolNames.end()) {
+    SymbolNames.emplace(
+        std::piecewise_construct, std::forward_as_tuple(SymbolName),
+        std::forward_as_tuple(Function, 0, SectionIndex, false));
+  } else {
+    // Update a recorded entry with its logical scope and section index.
+    SymbolNames[SymbolName].Scope = Function;
+    if (SectionIndex)
+      SymbolNames[SymbolName].SectionIndex = SectionIndex;
+  }
+
+  if (Function && SymbolNames[SymbolName].IsComdat)
+    Function->setIsComdat();
+
+  LLVM_DEBUG({ print(dbgs()); });
+}
+
+void LVSymbolTable::add(StringRef Name, LVAddress Address,
+                        LVSectionIndex SectionIndex, bool IsComdat) {
+  std::string SymbolName(Name);
+  if (SymbolNames.find(SymbolName) == SymbolNames.end())
+    SymbolNames.emplace(
+        std::piecewise_construct, std::forward_as_tuple(SymbolName),
+        std::forward_as_tuple(nullptr, Address, SectionIndex, IsComdat));
+  else
+    // Update a recorded symbol name with its logical scope.
+    SymbolNames[SymbolName].Address = Address;
+
+  LVScope *Function = SymbolNames[SymbolName].Scope;
+  if (Function && IsComdat)
+    Function->setIsComdat();
+  LLVM_DEBUG({ print(dbgs()); });
+}
+
+LVSectionIndex LVSymbolTable::update(LVScope *Function) {
+  LVSectionIndex SectionIndex = getReader().getDotTextSectionIndex();
+  StringRef Name = Function->getLinkageName();
+  if (Name.empty())
+    Name = Function->getName();
+  std::string SymbolName(Name);
+
+  if (SymbolName.empty() || (SymbolNames.find(SymbolName) == SymbolNames.end()))
+    return SectionIndex;
+
+  // Update a recorded entry with its logical scope, only if the scope has
+  // ranges. That is the case when in DWARF there are 2 DIEs connected via
+  // the DW_AT_specification.
+  if (Function->getHasRanges()) {
+    SymbolNames[SymbolName].Scope = Function;
+    SectionIndex = SymbolNames[SymbolName].SectionIndex;
+  } else {
+    SectionIndex = UndefinedSectionIndex;
+  }
+
+  if (SymbolNames[SymbolName].IsComdat)
+    Function->setIsComdat();
+
+  LLVM_DEBUG({ print(dbgs()); });
+  return SectionIndex;
+}
+
+const LVSymbolTableEntry &LVSymbolTable::getEntry(StringRef Name) {
+  static LVSymbolTableEntry Empty = LVSymbolTableEntry();
+  LVSymbolNames::iterator Iter = SymbolNames.find(std::string(Name));
+  return Iter != SymbolNames.end() ? Iter->second : Empty;
+}
+LVAddress LVSymbolTable::getAddress(StringRef Name) {
+  LVSymbolNames::iterator Iter = SymbolNames.find(std::string(Name));
+  return Iter != SymbolNames.end() ? Iter->second.Address : 0;
+}
+LVSectionIndex LVSymbolTable::getIndex(StringRef Name) {
+  LVSymbolNames::iterator Iter = SymbolNames.find(std::string(Name));
+  return Iter != SymbolNames.end() ? Iter->second.SectionIndex
+                                   : getReader().getDotTextSectionIndex();
+}
+bool LVSymbolTable::getIsComdat(StringRef Name) {
+  LVSymbolNames::iterator Iter = SymbolNames.find(std::string(Name));
+  return Iter != SymbolNames.end() ? Iter->second.IsComdat : false;
+}
+
+void LVSymbolTable::print(raw_ostream &OS) {
+  OS << "Symbol Table\n";
+  for (LVSymbolNames::reference Entry : SymbolNames) {
+    LVSymbolTableEntry &SymbolName = Entry.second;
+    LVScope *Scope = SymbolName.Scope;
+    LVOffset Offset = Scope ? Scope->getOffset() : 0;
+    OS << "Index: " << hexValue(SymbolName.SectionIndex, 5)
+       << " Comdat: " << (SymbolName.IsComdat ? "Y" : "N")
+       << " Scope: " << hexValue(Offset)
+       << " Address: " << hexValue(SymbolName.Address)
+       << " Name: " << Entry.first << "\n";
+  }
+}
+
+void LVBinaryReader::addToSymbolTable(StringRef Name, LVScope *Function,
+                                      LVSectionIndex SectionIndex) {
+  SymbolTable.add(Name, Function, SectionIndex);
+}
+void LVBinaryReader::addToSymbolTable(StringRef Name, LVAddress Address,
+                                      LVSectionIndex SectionIndex,
+                                      bool IsComdat) {
+  SymbolTable.add(Name, Address, SectionIndex, IsComdat);
+}
+LVSectionIndex LVBinaryReader::updateSymbolTable(LVScope *Function) {
+  return SymbolTable.update(Function);
+}
+
+const LVSymbolTableEntry &LVBinaryReader::getSymbolTableEntry(StringRef Name) {
+  return SymbolTable.getEntry(Name);
+}
+LVAddress LVBinaryReader::getSymbolTableAddress(StringRef Name) {
+  return SymbolTable.getAddress(Name);
+}
+LVSectionIndex LVBinaryReader::getSymbolTableIndex(StringRef Name) {
+  return SymbolTable.getIndex(Name);
+}
+bool LVBinaryReader::getSymbolTableIsComdat(StringRef Name) {
+  return SymbolTable.getIsComdat(Name);
+}
+
+void LVBinaryReader::mapVirtualAddress(const object::ObjectFile &Obj) {
+  for (const object::SectionRef &Section : Obj.sections()) {
+    if (!Section.isText() || Section.isVirtual() || !Section.getSize())
+      continue;
+
+    // Record section information required for symbol resolution.
+    // Note: The section index returned by 'getIndex()' is one based.
+    Sections.emplace(Section.getIndex(), Section);
+    addSectionAddress(Section);
+
+    // Identify the ".text" section.
+    Expected<StringRef> SectionNameOrErr = Section.getName();
+    if (!SectionNameOrErr) {
+      consumeError(SectionNameOrErr.takeError());
+      continue;
+    }
+    if ((*SectionNameOrErr).equals(".text") ||
+        (*SectionNameOrErr).equals(".code"))
+      DotTextSectionIndex = Section.getIndex();
+  }
+
+  // Process the symbol table.
+  mapRangeAddress(Obj);
+
+  LLVM_DEBUG({
+    dbgs() << "\nSections Information:\n";
+    for (LVSections::reference Entry : Sections) {
+      LVSectionIndex SectionIndex = Entry.first;
+      const object::SectionRef Section = Entry.second;
+      Expected<StringRef> SectionNameOrErr = Section.getName();
+      if (!SectionNameOrErr)
+        consumeError(SectionNameOrErr.takeError());
+      dbgs() << "\nIndex: " << format_decimal(SectionIndex, 3)
+             << " Name: " << *SectionNameOrErr << "\n"
+             << "Size: " << hexValue(Section.getSize()) << "\n"
+             << "VirtualAddress: " << hexValue(VirtualAddress) << "\n"
+             << "SectionAddress: " << hexValue(Section.getAddress()) << "\n";
+    }
+    dbgs() << "\nObject Section Information:\n";
+    for (LVSectionAddresses::const_reference Entry : SectionAddresses)
+      dbgs() << "[" << hexValue(Entry.first) << ":"
+             << hexValue(Entry.first + Entry.second.getSize())
+             << "] Size: " << hexValue(Entry.second.getSize()) << "\n";
+  });
+}
+
+Error LVBinaryReader::loadGenericTargetInfo(StringRef TheTriple,
+                                            StringRef TheFeatures) {
+  std::string TargetLookupError;
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(std::string(TheTriple), TargetLookupError);
+  if (!TheTarget)
+    return createStringError(errc::invalid_argument, TargetLookupError.c_str());
+
+  // Register information.
+  MCRegisterInfo *RegisterInfo = TheTarget->createMCRegInfo(TheTriple);
+  if (!RegisterInfo)
+    return createStringError(errc::invalid_argument,
+                             "no register info for target " + TheTriple);
+  MRI.reset(RegisterInfo);
+
+  // Assembler properties and features.
+  MCTargetOptions MCOptions;
+  MCAsmInfo *AsmInfo(TheTarget->createMCAsmInfo(*MRI, TheTriple, MCOptions));
+  if (!AsmInfo)
+    return createStringError(errc::invalid_argument,
+                             "no assembly info for target " + TheTriple);
+  MAI.reset(AsmInfo);
+
+  // Target subtargets.
+  StringRef CPU;
+  MCSubtargetInfo *SubtargetInfo(
+      TheTarget->createMCSubtargetInfo(TheTriple, CPU, TheFeatures));
+  if (!SubtargetInfo)
+    return createStringError(errc::invalid_argument,
+                             "no subtarget info for target " + TheTriple);
+  STI.reset(SubtargetInfo);
+
+  // Instructions Info.
+  MCInstrInfo *InstructionInfo(TheTarget->createMCInstrInfo());
+  if (!InstructionInfo)
+    return createStringError(errc::invalid_argument,
+                             "no instruction info for target " + TheTriple);
+  MII.reset(InstructionInfo);
+
+  MC = std::make_unique<MCContext>(Triple(TheTriple), MAI.get(), MRI.get(),
+                                   STI.get());
+
+  // Assembler.
+  MCDisassembler *DisAsm(TheTarget->createMCDisassembler(*STI, *MC));
+  if (!DisAsm)
+    return createStringError(errc::invalid_argument,
+                             "no disassembler for target " + TheTriple);
+  MD.reset(DisAsm);
+
+  MCInstPrinter *InstructionPrinter(TheTarget->createMCInstPrinter(
+      Triple(TheTriple), AsmInfo->getAssemblerDialect(), *MAI, *MII, *MRI));
+  if (!InstructionPrinter)
+    return createStringError(errc::invalid_argument,
+                             "no target assembly language printer for target " +
+                                 TheTriple);
+  MIP.reset(InstructionPrinter);
+  InstructionPrinter->setPrintImmHex(true);
+
+  return Error::success();
+}
+
+Expected<std::pair<uint64_t, object::SectionRef>>
+LVBinaryReader::getSection(LVScope *Scope, LVAddress Address,
+                           LVSectionIndex SectionIndex) {
+  // Return the 'text' section with the code for this logical scope.
+  // COFF: SectionIndex is zero. Use 'SectionAddresses' data.
+  // ELF: SectionIndex is the section index in the file.
+  if (SectionIndex) {
+    LVSections::iterator Iter = Sections.find(SectionIndex);
+    if (Iter == Sections.end()) {
+      std::string TheFilename(Scope->getName());
+      return createStringError(errc::invalid_argument,
+                               "invalid section index for: '%s'",
+                               TheFilename.c_str());
+    }
+    const object::SectionRef Section = Iter->second;
+    return std::make_pair(Section.getAddress(), Section);
+  }
+
+  // Ensure a valid starting address for the public name's.
+  LVSectionAddresses::const_iterator Iter =
+      SectionAddresses.upper_bound(Address);
+  if (Iter == SectionAddresses.begin()) {
+    std::string TheFilename(Scope->getName());
+    return createStringError(errc::invalid_argument,
+                             "invalid section address for: '%s'",
+                             TheFilename.c_str());
+  }
+
+  // Get section that contains the code for this function.
+  Iter = SectionAddresses.lower_bound(Address);
+  if (Iter != SectionAddresses.begin())
+    --Iter;
+  return std::make_pair(Iter->first, Iter->second);
+}
+
+void LVBinaryReader::addSectionRange(LVSectionIndex SectionIndex,
+                                     LVScope *Scope) {
+  LVRange *ScopesWithRanges = getSectionRanges(SectionIndex);
+  ScopesWithRanges->addEntry(Scope);
+}
+
+void LVBinaryReader::addSectionRange(LVSectionIndex SectionIndex,
+                                     LVScope *Scope, LVAddress LowerAddress,
+                                     LVAddress UpperAddress) {
+  LVRange *ScopesWithRanges = getSectionRanges(SectionIndex);
+  ScopesWithRanges->addEntry(Scope, LowerAddress, UpperAddress);
+}
+
+LVRange *LVBinaryReader::getSectionRanges(LVSectionIndex SectionIndex) {
+  LVRange *Range = nullptr;
+  // Check if we already have a mapping for this section index.
+  LVSectionRanges::iterator IterSection = SectionRanges.find(SectionIndex);
+  if (IterSection == SectionRanges.end()) {
+    Range = new LVRange();
+    SectionRanges.emplace(SectionIndex, Range);
+  } else {
+    Range = IterSection->second;
+  }
+  assert(Range && "Range is null.");
+  return Range;
+}
+
+Error LVBinaryReader::createInstructions(LVScope *Scope,
+                                         LVSectionIndex SectionIndex,
+                                         const LVNameInfo &NameInfo) {
+  assert(Scope && "Scope is null.");
+
+  // Skip stripped functions.
+  if (Scope->getIsDiscarded())
+    return Error::success();
+
+  // Find associated address and size for the given function entry point.
+  LVAddress Address = NameInfo.first;
+  uint64_t Size = NameInfo.second;
+
+  LLVM_DEBUG({
+    dbgs() << "\nPublic Name instructions: '" << Scope->getName() << "' / '"
+           << Scope->getLinkageName() << "'\n";
+    dbgs() << "DIE Offset: " << hexValue(Scope->getOffset()) << " Range: ["
+           << hexValue(Address) << ":" << hexValue(Address + Size) << "]\n";
+  });
+
+  Expected<std::pair<uint64_t, const object::SectionRef>> SectionOrErr =
+      getSection(Scope, Address, SectionIndex);
+  if (!SectionOrErr)
+    return SectionOrErr.takeError();
+  const object::SectionRef Section = (*SectionOrErr).second;
+  uint64_t SectionAddress = (*SectionOrErr).first;
+
+  Expected<StringRef> SectionContentsOrErr = Section.getContents();
+  if (!SectionContentsOrErr)
+    return SectionOrErr.takeError();
+
+  // There are cases where the section size is smaller that the [LowPC,HighPC]
+  // range; it causes to decode invalid addresses. The recorded size in the
+  // logical scope is one less that the real size.
+  LLVM_DEBUG({
+    dbgs() << " Size: " << hexValue(Size)
+           << ", Section Size: " << hexValue(Section.getSize()) << "\n";
+  });
+  Size = std::min(Size + 1, Section.getSize());
+
+  ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(*SectionContentsOrErr);
+  uint64_t Offset = Address - SectionAddress;
+  uint8_t const *Begin = Bytes.data() + Offset;
+  uint8_t const *End = Bytes.data() + Offset + Size;
+
+  LLVM_DEBUG({
+    Expected<StringRef> SectionNameOrErr = Section.getName();
+    if (!SectionNameOrErr)
+      consumeError(SectionNameOrErr.takeError());
+    else
+      dbgs() << "Section Index: " << hexValue(Section.getIndex()) << " ["
+             << hexValue((uint64_t)Section.getAddress()) << ":"
+             << hexValue((uint64_t)Section.getAddress() + Section.getSize(), 10)
+             << "] Name: '" << *SectionNameOrErr << "'\n"
+             << "Begin: " << hexValue((uint64_t)Begin)
+             << ", End: " << hexValue((uint64_t)End) << "\n";
+  });
+
+  // Address for first instruction line.
+  LVAddress FirstAddress = Address;
+  LVLines *Instructions = new LVLines();
+
+  while (Begin < End) {
+    MCInst Instruction;
+    uint64_t BytesConsumed = 0;
+    SmallVector<char, 64> InsnStr;
+    raw_svector_ostream Annotations(InsnStr);
+    MCDisassembler::DecodeStatus const S =
+        MD->getInstruction(Instruction, BytesConsumed,
+                           ArrayRef<uint8_t>(Begin, End), Address, outs());
+    switch (S) {
+    case MCDisassembler::Fail:
+      LLVM_DEBUG({ dbgs() << "Invalid instruction\n"; });
+      if (BytesConsumed == 0)
+        // Skip invalid bytes
+        BytesConsumed = 1;
+      break;
+    case MCDisassembler::SoftFail:
+      LLVM_DEBUG({ dbgs() << "Potentially undefined instruction:"; });
+      LLVM_FALLTHROUGH;
+    case MCDisassembler::Success: {
+      std::string Buffer;
+      raw_string_ostream Stream(Buffer);
+      StringRef AnnotationsStr = Annotations.str();
+      MIP.get()->printInst(&Instruction, Address, AnnotationsStr, *STI, Stream);
+      LLVM_DEBUG({
+        std::string BufferCodes;
+        raw_string_ostream StreamCodes(BufferCodes);
+        StreamCodes << format_bytes(
+            ArrayRef<uint8_t>(Begin, Begin + BytesConsumed), None, 16, 16);
+        dbgs() << "[" << hexValue((uint64_t)Begin) << "] "
+               << "Size: " << format_decimal(BytesConsumed, 2) << " ("
+               << formatv("{0}",
+                          fmt_align(StreamCodes.str(), AlignStyle::Left, 32))
+               << ") " << hexValue((uint64_t)Address) << ": " << Stream.str()
+               << "\n";
+      });
+      // The 'processLines()' function will move each created logical line
+      // to its enclosing logical scope, using the debug ranges information
+      // and they will be released when its scope parent is deleted.
+      LVLineAssembler *Line = new LVLineAssembler();
+      Line->setAddress(Address);
+      Line->setName(StringRef(Stream.str()).trim());
+      Instructions->push_back(Line);
+      break;
+    }
+    }
+    Address += BytesConsumed;
+    Begin += BytesConsumed;
+  }
+
+  LLVM_DEBUG({
+    size_t Index = 0;
+    dbgs() << "\nAddress: " << hexValue(FirstAddress)
+           << format(" - Collected instructions lines: %d\n",
+                     Instructions->size());
+    for (const LVLine *Line : *Instructions)
+      dbgs() << format_decimal(++Index, 5) << ": "
+             << hexValue(Line->getOffset()) << ", (" << Line->getName()
+             << ")\n";
+  });
+
+  // The scope in the assembler names is linked to its own instructions.
+  ScopeInstructions.add(SectionIndex, Scope, Instructions);
+  AssemblerMappings.add(SectionIndex, FirstAddress, Scope);
+
+  return Error::success();
+}
+
+Error LVBinaryReader::createInstructions(LVScope *Function,
+                                         LVSectionIndex SectionIndex) {
+  if (!options().getPrintInstructions())
+    return Error::success();
+
+  LVNameInfo Name = CompileUnit->findPublicName(Function);
+  if (Name.first != LVAddress(UINT64_MAX))
+    return createInstructions(Function, SectionIndex, Name);
+
+  return Error::success();
+}
+
+Error LVBinaryReader::createInstructions() {
+  if (!options().getPrintInstructions())
+    return Error::success();
+
+  LLVM_DEBUG({
+    dbgs() << "\nPublic Names (Scope):\n";
+    for (LVPublicNames::const_reference Name : CompileUnit->getPublicNames()) {
+      LVScope *Scope = Name.first;
+      const LVNameInfo &NameInfo = Name.second;
+      LVAddress Address = NameInfo.first;
+      uint64_t Size = NameInfo.second;
+      dbgs() << "DIE Offset: " << hexValue(Scope->getOffset()) << " Range: ["
+             << hexValue(Address) << ":" << hexValue(Address + Size) << "] "
+             << "Name: '" << Scope->getName() << "' / '"
+             << Scope->getLinkageName() << "'\n";
+    }
+  });
+
+  // For each public name in the current compile unit, create the line
+  // records that represent the executable instructions.
+  for (LVPublicNames::const_reference Name : CompileUnit->getPublicNames()) {
+    LVScope *Scope = Name.first;
+    // The symbol table extracted from the object file always contains a
+    // non-empty name (linkage name). However, the logical scope does not
+    // guarantee to have a name for the linkage name (main is one case).
+    // For those cases, set the linkage name the same as the name.
+    if (!Scope->getLinkageNameIndex())
+      Scope->setLinkageName(Scope->getName());
+    LVSectionIndex SectionIndex = getSymbolTableIndex(Scope->getLinkageName());
+    if (Error Err = createInstructions(Scope, SectionIndex, Name.second))
+      return Err;
+  }
+
+  return Error::success();
+}
+
+// During the traversal of the debug information sections, we created the
+// logical lines representing the disassembled instructions from the text
+// section and the logical lines representing the line records from the
+// debug line section. Using the ranges associated with the logical scopes,
+// we will allocate those logical lines to their logical scopes.
+void LVBinaryReader::processLines(LVLines *DebugLines,
+                                  LVSectionIndex SectionIndex,
+                                  LVScope *Function) {
+  assert(DebugLines && "DebugLines is null.");
+
+  // Just return if this compilation unit does not have any line records
+  // and no instruction lines were created.
+  if (DebugLines->empty() && !options().getPrintInstructions())
+    return;
+
+  // Merge the debug lines and instruction lines using their text address;
+  // the logical line representing the debug line record is followed by the
+  // line(s) representing the disassembled instructions, whose addresses are
+  // equal or greater that the line address and less than the address of the
+  // next line record.
+  LLVM_DEBUG({
+    size_t Index = 1;
+    size_t PerLine = 4;
+    dbgs() << format("\nProcess debug lines: %d\n", DebugLines->size());
+    for (const LVLine *Line : *DebugLines) {
+      dbgs() << format_decimal(Index, 5) << ": " << hexValue(Line->getOffset())
+             << ", (" << Line->getLineNumber() << ")";
+      dbgs() << ((Index % PerLine) ? "  " : "\n");
+      ++Index;
+    }
+    dbgs() << ((Index % PerLine) ? "\n" : "");
+  });
+
+  bool TraverseLines = true;
+  LVLines::iterator Iter = DebugLines->begin();
+  while (TraverseLines && Iter != DebugLines->end()) {
+    uint64_t DebugAddress = (*Iter)->getAddress();
+
+    // Get the function with an entry point that matches this line and
+    // its associated assembler entries. In the case of COMDAT, the input
+    // 'Function' is not null. Use it to find its address ranges.
+    LVScope *Scope = Function;
+    if (!Function) {
+      Scope = AssemblerMappings.find(SectionIndex, DebugAddress);
+      if (!Scope) {
+        ++Iter;
+        continue;
+      }
+    }
+
+    // Get the associated instructions for the found 'Scope'.
+    LVLines InstructionLines;
+    LVLines *Lines = ScopeInstructions.find(SectionIndex, Scope);
+    if (Lines)
+      InstructionLines.append(std::move(*Lines));
+
+    LLVM_DEBUG({
+      size_t Index = 0;
+      dbgs() << format("\nProcess instructions lines: %d\n",
+                       InstructionLines.size());
+      for (const LVLine *Line : InstructionLines)
+        dbgs() << format_decimal(++Index, 5) << ": "
+               << hexValue(Line->getOffset()) << ", (" << Line->getName()
+               << ")\n";
+    });
+
+    // Continue with next debug line if there are not instructions lines.
+    if (InstructionLines.empty()) {
+      ++Iter;
+      continue;
+    }
+
+    for (LVLine *InstructionLine : InstructionLines) {
+      uint64_t InstructionAddress = InstructionLine->getAddress();
+      LLVM_DEBUG({
+        dbgs() << "Instruction address: " << hexValue(InstructionAddress)
+               << "\n";
+      });
+      if (TraverseLines) {
+        while (Iter != DebugLines->end()) {
+          DebugAddress = (*Iter)->getAddress();
+          LLVM_DEBUG({
+            bool IsDebug = (*Iter)->getIsLineDebug();
+            dbgs() << "Line " << (IsDebug ? "dbg:" : "ins:") << " ["
+                   << hexValue(DebugAddress) << "]";
+            if (IsDebug)
+              dbgs() << format(" %d", (*Iter)->getLineNumber());
+            dbgs() << "\n";
+          });
+          // Instruction address before debug line.
+          if (InstructionAddress < DebugAddress) {
+            LLVM_DEBUG({
+              dbgs() << "Inserted instruction address: "
+                     << hexValue(InstructionAddress) << " before line: "
+                     << format("%d", (*Iter)->getLineNumber()) << " ["
+                     << hexValue(DebugAddress) << "]\n";
+            });
+            Iter = DebugLines->insert(Iter, InstructionLine);
+            // The returned iterator points to the inserted instruction.
+            // Skip it and point to the line acting as reference.
+            ++Iter;
+            break;
+          }
+          ++Iter;
+        }
+        if (Iter == DebugLines->end()) {
+          // We have reached the end of the source lines and the current
+          // instruction line address is greater than the last source line.
+          TraverseLines = false;
+          DebugLines->push_back(InstructionLine);
+        }
+      } else {
+        DebugLines->push_back(InstructionLine);
+      }
+    }
+  }
+
+  LLVM_DEBUG({
+    dbgs() << format("Lines after merge: %d\n", DebugLines->size());
+    size_t Index = 0;
+    for (const LVLine *Line : *DebugLines) {
+      dbgs() << format_decimal(++Index, 5) << ": "
+             << hexValue(Line->getOffset()) << ", ("
+             << ((Line->getIsLineDebug())
+                     ? Line->lineNumberAsStringStripped(/*ShowZero=*/true)
+                     : Line->getName())
+             << ")\n";
+    }
+  });
+
+  // This compilation unit does not have line records. Traverse its scopes
+  // and take any collected instruction lines as the working set in order
+  // to move them to their associated scope.
+  if (DebugLines->empty()) {
+    if (const LVScopes *Scopes = CompileUnit->getScopes())
+      for (LVScope *Scope : *Scopes) {
+        LVLines *Lines = ScopeInstructions.find(SectionIndex, Scope);
+        if (Lines)
+          DebugLines->append(std::move(*Lines));
+      }
+  }
+
+  LVRange *ScopesWithRanges = getSectionRanges(SectionIndex);
+  ScopesWithRanges->startSearch();
+
+  // Process collected lines.
+  LVScope *Scope;
+  for (LVLine *Line : *DebugLines) {
+    // Using the current line address, get its associated lexical scope and
+    // add the line information to it.
+    Scope = ScopesWithRanges->getEntry(Line->getAddress());
+    if (!Scope) {
+      // If missing scope, use the compile unit.
+      Scope = CompileUnit;
+      LLVM_DEBUG({
+        dbgs() << "Adding line to CU: " << hexValue(Line->getOffset()) << ", ("
+               << ((Line->getIsLineDebug())
+                       ? Line->lineNumberAsStringStripped(/*ShowZero=*/true)
+                       : Line->getName())
+               << ")\n";
+      });
+    }
+
+    // Add line object to scope.
+    Scope->addElement(Line);
+
+    // Report any line zero.
+    if (options().getWarningLines() && Line->getIsLineDebug() &&
+        !Line->getLineNumber())
+      CompileUnit->addLineZero(Line);
+
+    // Some compilers generate ranges in the compile unit; other compilers
+    // only DW_AT_low_pc/DW_AT_high_pc. In order to correctly map global
+    // variables, we need to generate the map ranges for the compile unit.
+    // If we use the ranges stored at the scope level, there are cases where
+    // the address referenced by a symbol location, is not in the enclosing
+    // scope, but in an outer one. By using the ranges stored in the compile
+    // unit, we can catch all those addresses.
+    if (Line->getIsLineDebug())
+      CompileUnit->addMapping(Line, SectionIndex);
+
+    // Resolve any given pattern.
+    patterns().resolvePatternMatch(Line);
+  }
+
+  ScopesWithRanges->endSearch();
+}
+
+void LVBinaryReader::processLines(LVLines *DebugLines,
+                                  LVSectionIndex SectionIndex) {
+  assert(DebugLines && "DebugLines is null.");
+  if (DebugLines->empty() && !ScopeInstructions.findMap(SectionIndex))
+    return;
+
+  // If the Compile Unit does not contain comdat functions, use the whole
+  // set of debug lines, as the addresses don't have conflicts.
+  if (!CompileUnit->getHasComdatScopes()) {
+    processLines(DebugLines, SectionIndex, nullptr);
+    return;
+  }
+
+  // Find the indexes for the lines whose address is zero.
+  std::vector<size_t> AddressZero;
+  LVLines::iterator It =
+      std::find_if(std::begin(*DebugLines), std::end(*DebugLines),
+                   [](LVLine *Line) { return !Line->getAddress(); });
+  while (It != std::end(*DebugLines)) {
+    AddressZero.emplace_back(std::distance(std::begin(*DebugLines), It));
+    It = std::find_if(std::next(It), std::end(*DebugLines),
+                      [](LVLine *Line) { return !Line->getAddress(); });
+  }
+
+  // If the set of debug lines does not contain any line with address zero,
+  // use the whole set. It means we are dealing with an initialization
+  // section from a fully linked binary.
+  if (AddressZero.empty()) {
+    processLines(DebugLines, SectionIndex, nullptr);
+    return;
+  }
+
+  // The Compile unit contains comdat functions. Traverse the collected
+  // debug lines and identify logical groups based on their start and
+  // address. Each group starts with a zero address.
+  // Begin, End, Address, IsDone.
+  using LVBucket = std::tuple<size_t, size_t, LVAddress, bool>;
+  std::vector<LVBucket> Buckets;
+
+  LVAddress Address;
+  size_t Begin = 0;
+  size_t End = 0;
+  size_t Index = 0;
+  for (Index = 0; Index < AddressZero.size() - 1; ++Index) {
+    Begin = AddressZero[Index];
+    End = AddressZero[Index + 1] - 1;
+    Address = (*DebugLines)[End]->getAddress();
+    Buckets.emplace_back(Begin, End, Address, false);
+  }
+
+  // Add the last bucket.
+  if (Index) {
+    Begin = AddressZero[Index];
+    End = DebugLines->size() - 1;
+    Address = (*DebugLines)[End]->getAddress();
+    Buckets.emplace_back(Begin, End, Address, false);
+  }
+
+  LLVM_DEBUG({
+    dbgs() << "\nDebug Lines buckets: " << Buckets.size() << "\n";
+    for (LVBucket &Bucket : Buckets) {
+      dbgs() << "Begin: " << format_decimal(std::get<0>(Bucket), 5) << ", "
+             << "End: " << format_decimal(std::get<1>(Bucket), 5) << ", "
+             << "Address: " << hexValue(std::get<2>(Bucket)) << "\n";
+    }
+  });
+
+  // Traverse the sections and buckets looking for matches on the section
+  // sizes. In the unlikely event of different buckets with the same size
+  // process them in order and mark them as done.
+  LVLines Group;
+  for (LVSections::reference Entry : Sections) {
+    LVSectionIndex SectionIndex = Entry.first;
+    const object::SectionRef Section = Entry.second;
+    uint64_t Size = Section.getSize();
+    LLVM_DEBUG({
+      dbgs() << "\nSection Index: " << format_decimal(SectionIndex, 3)
+             << " , Section Size: " << hexValue(Section.getSize())
+             << " , Section Address: " << hexValue(Section.getAddress())
+             << "\n";
+    });
+
+    for (LVBucket &Bucket : Buckets) {
+      if (std::get<3>(Bucket))
+        // Already done for previous section.
+        continue;
+      if (Size == std::get<2>(Bucket)) {
+        // We have a match on the section size.
+        Group.clear();
+        LVLines::iterator IterStart = DebugLines->begin() + std::get<0>(Bucket);
+        LVLines::iterator IterEnd =
+            DebugLines->begin() + std::get<1>(Bucket) + 1;
+        for (LVLines::iterator Iter = IterStart; Iter < IterEnd; ++Iter)
+          Group.push_back(*Iter);
+        processLines(&Group, SectionIndex, /*Function=*/nullptr);
+        std::get<3>(Bucket) = true;
+        break;
+      }
+    }
+  }
+}
+
+void LVBinaryReader::print(raw_ostream &OS) const {
+  OS << "LVBinaryReader\n";
+  LLVM_DEBUG(dbgs() << "PrintReader\n");
+}

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

+//===-- LVELFReader.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 LVELFReader class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/LogicalView/Readers/LVELFReader.h"
+#include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
+#include "llvm/Object/Error.h"
+#include "llvm/Object/MachO.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::logicalview;
+
+#define DEBUG_TYPE "ElfReader"
+
+LVElement *LVELFReader::createElement(dwarf::Tag Tag) {
+  CurrentScope = nullptr;
+  CurrentSymbol = nullptr;
+  CurrentType = nullptr;
+  CurrentRanges.clear();
+
+  if (!options().getPrintSymbols()) {
+    switch (Tag) {
+    // Symbols.
+    case dwarf::DW_TAG_formal_parameter:
+    case dwarf::DW_TAG_unspecified_parameters:
+    case dwarf::DW_TAG_member:
+    case dwarf::DW_TAG_variable:
+    case dwarf::DW_TAG_inheritance:
+    case dwarf::DW_TAG_constant:
+    case dwarf::DW_TAG_call_site_parameter:
+    case dwarf::DW_TAG_GNU_call_site_parameter:
+      return CurrentSymbol;
+    default:
+      break;
+    }
+  }
+
+  switch (Tag) {
+  // Types.
+  case dwarf::DW_TAG_base_type:
+    CurrentType = new LVType();
+    CurrentType->setIsBase();
+    if (options().getAttributeBase())
+      CurrentType->setIncludeInPrint();
+    return CurrentType;
+  case dwarf::DW_TAG_const_type:
+    CurrentType = new LVType();
+    CurrentType->setIsConst();
+    CurrentType->setName("const");
+    return CurrentType;
+  case dwarf::DW_TAG_enumerator:
+    CurrentType = new LVTypeEnumerator();
+    return CurrentType;
+  case dwarf::DW_TAG_imported_declaration:
+    CurrentType = new LVTypeImport();
+    CurrentType->setIsImportDeclaration();
+    return CurrentType;
+  case dwarf::DW_TAG_imported_module:
+    CurrentType = new LVTypeImport();
+    CurrentType->setIsImportModule();
+    return CurrentType;
+  case dwarf::DW_TAG_pointer_type:
+    CurrentType = new LVType();
+    CurrentType->setIsPointer();
+    CurrentType->setName("*");
+    return CurrentType;
+  case dwarf::DW_TAG_ptr_to_member_type:
+    CurrentType = new LVType();
+    CurrentType->setIsPointerMember();
+    CurrentType->setName("*");
+    return CurrentType;
+  case dwarf::DW_TAG_reference_type:
+    CurrentType = new LVType();
+    CurrentType->setIsReference();
+    CurrentType->setName("&");
+    return CurrentType;
+  case dwarf::DW_TAG_restrict_type:
+    CurrentType = new LVType();
+    CurrentType->setIsRestrict();
+    CurrentType->setName("restrict");
+    return CurrentType;
+  case dwarf::DW_TAG_rvalue_reference_type:
+    CurrentType = new LVType();
+    CurrentType->setIsRvalueReference();
+    CurrentType->setName("&&");
+    return CurrentType;
+  case dwarf::DW_TAG_subrange_type:
+    CurrentType = new LVTypeSubrange();
+    return CurrentType;
+  case dwarf::DW_TAG_template_value_parameter:
+    CurrentType = new LVTypeParam();
+    CurrentType->setIsTemplateValueParam();
+    return CurrentType;
+  case dwarf::DW_TAG_template_type_parameter:
+    CurrentType = new LVTypeParam();
+    CurrentType->setIsTemplateTypeParam();
+    return CurrentType;
+  case dwarf::DW_TAG_GNU_template_template_param:
+    CurrentType = new LVTypeParam();
+    CurrentType->setIsTemplateTemplateParam();
+    return CurrentType;
+  case dwarf::DW_TAG_typedef:
+    CurrentType = new LVTypeDefinition();
+    return CurrentType;
+  case dwarf::DW_TAG_unspecified_type:
+    CurrentType = new LVType();
+    CurrentType->setIsUnspecified();
+    return CurrentType;
+  case dwarf::DW_TAG_volatile_type:
+    CurrentType = new LVType();
+    CurrentType->setIsVolatile();
+    CurrentType->setName("volatile");
+    return CurrentType;
+
+  // Symbols.
+  case dwarf::DW_TAG_formal_parameter:
+    CurrentSymbol = new LVSymbol();
+    CurrentSymbol->setIsParameter();
+    return CurrentSymbol;
+  case dwarf::DW_TAG_unspecified_parameters:
+    CurrentSymbol = new LVSymbol();
+    CurrentSymbol->setIsUnspecified();
+    CurrentSymbol->setName("...");
+    return CurrentSymbol;
+  case dwarf::DW_TAG_member:
+    CurrentSymbol = new LVSymbol();
+    CurrentSymbol->setIsMember();
+    return CurrentSymbol;
+  case dwarf::DW_TAG_variable:
+    CurrentSymbol = new LVSymbol();
+    CurrentSymbol->setIsVariable();
+    return CurrentSymbol;
+  case dwarf::DW_TAG_inheritance:
+    CurrentSymbol = new LVSymbol();
+    CurrentSymbol->setIsInheritance();
+    return CurrentSymbol;
+  case dwarf::DW_TAG_call_site_parameter:
+  case dwarf::DW_TAG_GNU_call_site_parameter:
+    CurrentSymbol = new LVSymbol();
+    CurrentSymbol->setIsCallSiteParameter();
+    return CurrentSymbol;
+  case dwarf::DW_TAG_constant:
+    CurrentSymbol = new LVSymbol();
+    CurrentSymbol->setIsConstant();
+    return CurrentSymbol;
+
+  // Scopes.
+  case dwarf::DW_TAG_catch_block:
+    CurrentScope = new LVScope();
+    CurrentScope->setIsCatchBlock();
+    return CurrentScope;
+  case dwarf::DW_TAG_lexical_block:
+    CurrentScope = new LVScope();
+    CurrentScope->setIsLexicalBlock();
+    return CurrentScope;
+  case dwarf::DW_TAG_try_block:
+    CurrentScope = new LVScope();
+    CurrentScope->setIsTryBlock();
+    return CurrentScope;
+  case dwarf::DW_TAG_compile_unit:
+  case dwarf::DW_TAG_skeleton_unit:
+    CurrentScope = new LVScopeCompileUnit();
+    CompileUnit = static_cast<LVScopeCompileUnit *>(CurrentScope);
+    return CurrentScope;
+  case dwarf::DW_TAG_inlined_subroutine:
+    CurrentScope = new LVScopeFunctionInlined();
+    return CurrentScope;
+  case dwarf::DW_TAG_namespace:
+    CurrentScope = new LVScopeNamespace();
+    return CurrentScope;
+  case dwarf::DW_TAG_template_alias:
+    CurrentScope = new LVScopeAlias();
+    return CurrentScope;
+  case dwarf::DW_TAG_array_type:
+    CurrentScope = new LVScopeArray();
+    return CurrentScope;
+  case dwarf::DW_TAG_call_site:
+  case dwarf::DW_TAG_GNU_call_site:
+    CurrentScope = new LVScopeFunction();
+    CurrentScope->setIsCallSite();
+    return CurrentScope;
+  case dwarf::DW_TAG_entry_point:
+    CurrentScope = new LVScopeFunction();
+    CurrentScope->setIsEntryPoint();
+    return CurrentScope;
+  case dwarf::DW_TAG_subprogram:
+    CurrentScope = new LVScopeFunction();
+    CurrentScope->setIsSubprogram();
+    return CurrentScope;
+  case dwarf::DW_TAG_subroutine_type:
+    CurrentScope = new LVScopeFunctionType();
+    return CurrentScope;
+  case dwarf::DW_TAG_label:
+    CurrentScope = new LVScopeFunction();
+    CurrentScope->setIsLabel();
+    return CurrentScope;
+  case dwarf::DW_TAG_class_type:
+    CurrentScope = new LVScopeAggregate();
+    CurrentScope->setIsClass();
+    return CurrentScope;
+  case dwarf::DW_TAG_structure_type:
+    CurrentScope = new LVScopeAggregate();
+    CurrentScope->setIsStructure();
+    return CurrentScope;
+  case dwarf::DW_TAG_union_type:
+    CurrentScope = new LVScopeAggregate();
+    CurrentScope->setIsUnion();
+    return CurrentScope;
+  case dwarf::DW_TAG_enumeration_type:
+    CurrentScope = new LVScopeEnumeration();
+    return CurrentScope;
+  case dwarf::DW_TAG_GNU_formal_parameter_pack:
+    CurrentScope = new LVScopeFormalPack();
+    return CurrentScope;
+  case dwarf::DW_TAG_GNU_template_parameter_pack:
+    CurrentScope = new LVScopeTemplatePack();
+    return CurrentScope;
+  default:
+    // Collect TAGs not implemented.
+    if (options().getInternalTag() && Tag)
+      CompileUnit->addDebugTag(Tag, CurrentOffset);
+    break;
+  }
+  return nullptr;
+}
+
+void LVELFReader::processOneAttribute(const DWARFDie &Die, LVOffset *OffsetPtr,
+                                      const AttributeSpec &AttrSpec) {
+  uint64_t OffsetOnEntry = *OffsetPtr;
+  DWARFUnit *U = Die.getDwarfUnit();
+  const DWARFFormValue &FormValue =
+      DWARFFormValue::createFromUnit(AttrSpec.Form, U, OffsetPtr);
+
+  // We are processing .debug_info section, implicit_const attribute
+  // values are not really stored here, but in .debug_abbrev section.
+  auto GetAsUnsignedConstant = [&]() -> int64_t {
+    return AttrSpec.isImplicitConst() ? AttrSpec.getImplicitConstValue()
+                                      : *FormValue.getAsUnsignedConstant();
+  };
+
+  auto GetFlag = [](const DWARFFormValue &FormValue) -> bool {
+    return FormValue.isFormClass(DWARFFormValue::FC_Flag);
+  };
+
+  auto GetBoundValue = [](const DWARFFormValue &FormValue) -> int64_t {
+    switch (FormValue.getForm()) {
+    case dwarf::DW_FORM_ref_addr:
+    case dwarf::DW_FORM_ref1:
+    case dwarf::DW_FORM_ref2:
+    case dwarf::DW_FORM_ref4:
+    case dwarf::DW_FORM_ref8:
+    case dwarf::DW_FORM_ref_udata:
+    case dwarf::DW_FORM_ref_sig8:
+      return *FormValue.getAsReferenceUVal();
+    case dwarf::DW_FORM_data1:
+    case dwarf::DW_FORM_flag:
+    case dwarf::DW_FORM_data2:
+    case dwarf::DW_FORM_data4:
+    case dwarf::DW_FORM_data8:
+    case dwarf::DW_FORM_udata:
+    case dwarf::DW_FORM_ref_sup4:
+    case dwarf::DW_FORM_ref_sup8:
+      return *FormValue.getAsUnsignedConstant();
+    case dwarf::DW_FORM_sdata:
+      return *FormValue.getAsSignedConstant();
+    default:
+      return 0;
+    }
+  };
+
+  LLVM_DEBUG({
+    dbgs() << "     " << hexValue(OffsetOnEntry)
+           << formatv(" {0}", AttrSpec.Attr) << "\n";
+  });
+
+  switch (AttrSpec.Attr) {
+  case dwarf::DW_AT_accessibility:
+    CurrentElement->setAccessibilityCode(*FormValue.getAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_artificial:
+    CurrentElement->setIsArtificial();
+    break;
+  case dwarf::DW_AT_bit_size:
+    CurrentElement->setBitSize(*FormValue.getAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_call_file:
+    CurrentElement->setCallFilenameIndex(GetAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_call_line:
+    CurrentElement->setCallLineNumber(IncrementFileIndex
+                                          ? GetAsUnsignedConstant() + 1
+                                          : GetAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_comp_dir:
+    CompileUnit->setCompilationDirectory(dwarf::toStringRef(FormValue));
+    break;
+  case dwarf::DW_AT_const_value:
+    if (FormValue.isFormClass(DWARFFormValue::FC_Block)) {
+      ArrayRef<uint8_t> Expr = *FormValue.getAsBlock();
+      // Store the expression as a hexadecimal string.
+      CurrentElement->setValue(
+          llvm::toHex(llvm::toStringRef(Expr), /*LowerCase=*/true));
+    } else if (FormValue.isFormClass(DWARFFormValue::FC_Constant)) {
+      // In the case of negative values, generate the string representation
+      // for a positive value prefixed with the negative sign.
+      if (FormValue.getForm() == dwarf::DW_FORM_sdata) {
+        std::stringstream Stream;
+        int64_t Value = *FormValue.getAsSignedConstant();
+        if (Value < 0) {
+          Stream << "-";
+          Value = std::abs(Value);
+        }
+        Stream << hexString(Value, 2);
+        CurrentElement->setValue(Stream.str());
+      } else
+        CurrentElement->setValue(
+            hexString(*FormValue.getAsUnsignedConstant(), 2));
+    } else
+      CurrentElement->setValue(dwarf::toStringRef(FormValue));
+    break;
+  case dwarf::DW_AT_count:
+    CurrentElement->setCount(*FormValue.getAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_decl_line:
+    CurrentElement->setLineNumber(GetAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_decl_file:
+    CurrentElement->setFilenameIndex(IncrementFileIndex
+                                         ? GetAsUnsignedConstant() + 1
+                                         : GetAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_enum_class:
+    if (GetFlag(FormValue))
+      CurrentElement->setIsEnumClass();
+    break;
+  case dwarf::DW_AT_external:
+    if (GetFlag(FormValue))
+      CurrentElement->setIsExternal();
+    break;
+  case dwarf::DW_AT_GNU_discriminator:
+    CurrentElement->setDiscriminator(*FormValue.getAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_inline:
+    CurrentElement->setInlineCode(*FormValue.getAsUnsignedConstant());
+    break;
+  case dwarf::DW_AT_lower_bound:
+    CurrentElement->setLowerBound(GetBoundValue(FormValue));
+    break;
+  case dwarf::DW_AT_name:
+    CurrentElement->setName(dwarf::toStringRef(FormValue));
+    break;
+  case dwarf::DW_AT_linkage_name:
+  case dwarf::DW_AT_MIPS_linkage_name:
+    CurrentElement->setLinkageName(dwarf::toStringRef(FormValue));
+    break;
+  case dwarf::DW_AT_producer:
+    if (options().getAttributeProducer())
+      CurrentElement->setProducer(dwarf::toStringRef(FormValue));
+    break;
+  case dwarf::DW_AT_upper_bound:
+    CurrentElement->setUpperBound(GetBoundValue(FormValue));
+    break;
+  case dwarf::DW_AT_virtuality:
+    CurrentElement->setVirtualityCode(*FormValue.getAsUnsignedConstant());
+    break;
+
+  case dwarf::DW_AT_abstract_origin:
+  case dwarf::DW_AT_call_origin:
+  case dwarf::DW_AT_extension:
+  case dwarf::DW_AT_import:
+  case dwarf::DW_AT_specification:
+  case dwarf::DW_AT_type:
+    updateReference(AttrSpec.Attr, FormValue);
+    break;
+
+  case dwarf::DW_AT_low_pc:
+    if (options().getGeneralCollectRanges()) {
+      FoundLowPC = true;
+      // For toolchains that support the removal of unused code, the linker
+      // marks functions that have been removed, by setting the value for the
+      // low_pc to the max address.
+      if (Optional<uint64_t> Value = FormValue.getAsAddress()) {
+        CurrentLowPC = Value.value();
+      } else {
+        uint64_t UValue = FormValue.getRawUValue();
+        if (U->getAddrOffsetSectionItem(UValue)) {
+          CurrentLowPC = *FormValue.getAsAddress();
+        } else {
+          FoundLowPC = false;
+          // We are dealing with an index into the .debug_addr section.
+          LLVM_DEBUG({
+            dbgs() << format("indexed (%8.8x) address = ", (uint32_t)UValue);
+          });
+        }
+      }
+      if (FoundLowPC) {
+        if (CurrentLowPC == MaxAddress)
+          CurrentElement->setIsDiscarded();
+        if (CurrentElement->isCompileUnit())
+          setCUBaseAddress(CurrentLowPC);
+      }
+    }
+    break;
+
+  case dwarf::DW_AT_high_pc:
+    if (options().getGeneralCollectRanges()) {
+      FoundHighPC = true;
+      if (Optional<uint64_t> Address = FormValue.getAsAddress())
+        // High PC is an address.
+        CurrentHighPC = *Address;
+      if (Optional<uint64_t> Offset = FormValue.getAsUnsignedConstant())
+        // High PC is an offset from LowPC.
+        CurrentHighPC = CurrentLowPC + *Offset;
+      // Store the real upper limit for the address range.
+      if (UpdateHighAddress && CurrentHighPC > 0)
+        --CurrentHighPC;
+      if (CurrentElement->isCompileUnit())
+        setCUHighAddress(CurrentHighPC);
+    }
+    break;
+
+  case dwarf::DW_AT_ranges:
+    if (RangesDataAvailable && options().getGeneralCollectRanges()) {
+      auto GetRanges = [&](const DWARFFormValue &FormValue,
+                           DWARFUnit *U) -> Expected<DWARFAddressRangesVector> {
+        if (FormValue.getForm() == dwarf::DW_FORM_rnglistx)
+          return U->findRnglistFromIndex(*FormValue.getAsSectionOffset());
+        return U->findRnglistFromOffset(*FormValue.getAsSectionOffset());
+      };
+      Expected<DWARFAddressRangesVector> RangesOrError =
+          GetRanges(FormValue, U);
+      if (!RangesOrError) {
+        LLVM_DEBUG({
+          std::string TheError(toString(RangesOrError.takeError()));
+          dbgs() << format("error decoding address ranges = ",
+                           TheError.c_str());
+        });
+        consumeError(RangesOrError.takeError());
+        break;
+      }
+      // The address ranges are absolute. There is no need to add any addend.
+      DWARFAddressRangesVector Ranges = RangesOrError.get();
+      for (DWARFAddressRange &Range : Ranges) {
+        // This seems to be a tombstone for empty ranges.
+        if (Range.LowPC == 1 && Range.HighPC == 1)
+          continue;
+        // Store the real upper limit for the address range.
+        if (UpdateHighAddress && Range.HighPC > 0)
+          --Range.HighPC;
+        // Add the pair of addresses.
+        CurrentScope->addObject(Range.LowPC, Range.HighPC);
+        // If the scope is the CU, do not update the ranges set.
+        if (!CurrentElement->isCompileUnit())
+          CurrentRanges.emplace_back(Range.LowPC, Range.HighPC);
+      }
+    }
+    break;
+
+  // Get the location list for the symbol.
+  case dwarf::DW_AT_data_member_location:
+    if (options().getAttributeAnyLocation())
+      getLocationMember(AttrSpec.Attr, FormValue, Die, OffsetOnEntry);
+    break;
+
+  // Get the location list for the symbol.
+  case dwarf::DW_AT_location:
+  case dwarf::DW_AT_string_length:
+  case dwarf::DW_AT_use_location:
+    if (options().getAttributeAnyLocation() && CurrentSymbol)
+      getLocationList(AttrSpec.Attr, FormValue, Die, OffsetOnEntry);
+    break;
+
+  case dwarf::DW_AT_call_data_value:
+  case dwarf::DW_AT_call_value:
+  case dwarf::DW_AT_GNU_call_site_data_value:
+  case dwarf::DW_AT_GNU_call_site_value:
+    if (options().getAttributeAnyLocation() && CurrentSymbol)
+      getLocationList(AttrSpec.Attr, FormValue, Die, OffsetOnEntry,
+                      /*CallSiteLocation=*/true);
+    break;
+
+  default:
+    break;
+  }
+}
+
+LVScope *LVELFReader::processOneDie(const DWARFDie &InputDIE, LVScope *Parent,
+                                    DWARFDie &SkeletonDie) {
+  // If the input DIE corresponds to the compile unit, it can be:
+  // a) Simple DWARF: a standard DIE. Ignore the skeleton DIE (is empty).
+  // b) Split DWARF: the DIE for the split DWARF. The skeleton is the DIE
+  //    for the skeleton DWARF. Process both DIEs.
+  const DWARFDie &DIE = SkeletonDie.isValid() ? SkeletonDie : InputDIE;
+  DWARFDataExtractor DebugInfoData =
+      DIE.getDwarfUnit()->getDebugInfoExtractor();
+  LVOffset Offset = DIE.getOffset();
+
+  // Reset values for the current DIE.
+  CurrentLowPC = 0;
+  CurrentHighPC = 0;
+  CurrentOffset = Offset;
+  CurrentEndOffset = 0;
+  FoundLowPC = false;
+  FoundHighPC = false;
+
+  // Process supported attributes.
+  if (DebugInfoData.isValidOffset(Offset)) {
+
+    LLVM_DEBUG({
+      dbgs() << "DIE: " << hexValue(Offset) << formatv(" {0}", DIE.getTag())
+             << "\n";
+    });
+
+    // Create the logical view element for the current DIE.
+    dwarf::Tag Tag = DIE.getTag();
+    CurrentElement = createElement(Tag);
+    if (!CurrentElement)
+      return CurrentScope;
+
+    CurrentElement->setTag(Tag);
+    CurrentElement->setOffset(Offset);
+
+    if (options().getAttributeAnySource() && CurrentElement->isCompileUnit())
+      addCompileUnitOffset(Offset,
+                           static_cast<LVScopeCompileUnit *>(CurrentElement));
+
+    // Insert the newly created element into the element symbol table. If the
+    // element is in the list, it means there are previously created elements
+    // referencing this element.
+    if (ElementTable.find(Offset) == ElementTable.end()) {
+      // No previous references to this offset.
+      ElementTable.emplace(
+          std::piecewise_construct, std::forward_as_tuple(Offset),
+          std::forward_as_tuple(CurrentElement, LVElementSet()));
+    } else {
+      // There are previous references to this element. We need to update the
+      // element and all the references pointing to this element.
+      LVElementEntry &Reference = ElementTable[Offset];
+      Reference.first = CurrentElement;
+      // Traverse the element set and update the elements (backtracking).
+      // Using the bit associated with 'type' or 'reference' allows us to set
+      // the correct target.
+      for (LVElement *Target : Reference.second)
+        Target->getHasReference() ? Target->setReference(CurrentElement)
+                                  : Target->setType(CurrentElement);
+      // Clear the pending elements.
+      Reference.second.clear();
+    }
+
+    // Add the current element to its parent as there are attributes
+    // (locations) that require the scope level.
+    if (CurrentScope)
+      Parent->addElement(CurrentScope);
+    else if (CurrentSymbol)
+      Parent->addElement(CurrentSymbol);
+    else if (CurrentType)
+      Parent->addElement(CurrentType);
+
+    // Process the attributes for the given DIE.
+    auto ProcessAttributes = [&](const DWARFDie &TheDIE,
+                                 DWARFDataExtractor &DebugData) {
+      CurrentEndOffset = Offset;
+      uint32_t abbrCode = DebugData.getULEB128(&CurrentEndOffset);
+      if (abbrCode) {
+        if (const DWARFAbbreviationDeclaration *AbbrevDecl =
+                TheDIE.getAbbreviationDeclarationPtr())
+          if (AbbrevDecl)
+            for (const DWARFAbbreviationDeclaration::AttributeSpec &AttrSpec :
+                 AbbrevDecl->attributes())
+              processOneAttribute(TheDIE, &CurrentEndOffset, AttrSpec);
+      }
+    };
+
+    ProcessAttributes(DIE, DebugInfoData);
+
+    // If the input DIE is for a compile unit, process its attributes in
+    // the case of split DWARF, to overrite any common attribute values.
+    if (SkeletonDie.isValid()) {
+      DWARFDataExtractor DebugInfoData =
+          InputDIE.getDwarfUnit()->getDebugInfoExtractor();
+      LVOffset Offset = InputDIE.getOffset();
+      if (DebugInfoData.isValidOffset(Offset))
+        ProcessAttributes(InputDIE, DebugInfoData);
+    }
+  }
+
+  if (CurrentScope) {
+    if (CurrentScope->getCanHaveRanges()) {
+      // If the scope has ranges, they are already added to the scope.
+      // Add any collected LowPC/HighPC values.
+      bool IsCompileUnit = CurrentScope->getIsCompileUnit();
+      if (FoundLowPC && FoundHighPC) {
+        CurrentScope->addObject(CurrentLowPC, CurrentHighPC);
+        if (!IsCompileUnit) {
+          // If the scope is a function, add it to the public names.
+          if ((options().getAttributePublics() ||
+               options().getPrintAnyLine()) &&
+              CurrentScope->getIsFunction() &&
+              !CurrentScope->getIsInlinedFunction())
+            CompileUnit->addPublicName(CurrentScope, CurrentLowPC,
+                                       CurrentHighPC);
+        }
+      }
+
+      // Look for scopes with ranges and no linkage name information that
+      // are referencing another scopes via DW_AT_specification. They are
+      // possible candidates for a comdat scope.
+      if (CurrentScope->getHasRanges() &&
+          !CurrentScope->getLinkageNameIndex() &&
+          CurrentScope->getHasReferenceSpecification()) {
+        // Get the linkage name in order to search for a possible comdat.
+        Optional<DWARFFormValue> LinkageDIE =
+            DIE.findRecursively(dwarf::DW_AT_linkage_name);
+        if (LinkageDIE.has_value()) {
+          StringRef Name(dwarf::toStringRef(LinkageDIE));
+          if (!Name.empty())
+            CurrentScope->setLinkageName(Name);
+        }
+      }
+
+      // If the current scope is in the 'LinkageNames' table, update its
+      // logical scope. For other scopes, always we will assume the default
+      // ".text" section index.
+      LVSectionIndex SectionIndex = updateSymbolTable(CurrentScope);
+      if (CurrentScope->getIsComdat())
+        CompileUnit->setHasComdatScopes();
+
+      // Update section index contained ranges.
+      if (SectionIndex) {
+        if (!CurrentRanges.empty()) {
+          for (LVAddressRange &Range : CurrentRanges)
+            addSectionRange(SectionIndex, CurrentScope, Range.first,
+                            Range.second);
+          CurrentRanges.clear();
+        }
+        // If the scope is the CU, do not update the ranges set.
+        if (FoundLowPC && FoundHighPC && !IsCompileUnit) {
+          addSectionRange(SectionIndex, CurrentScope, CurrentLowPC,
+                          CurrentHighPC);
+        }
+      }
+    }
+    // Mark member functions.
+    if (Parent->getIsAggregate())
+      CurrentScope->setIsMember();
+  }
+
+  // Keep track of symbols with locations.
+  if (options().getAttributeAnyLocation() && CurrentSymbol &&
+      CurrentSymbol->getHasLocation())
+    SymbolsWithLocations.push_back(CurrentSymbol);
+
+  // If we have template parameters, mark the parent as template.
+  if (CurrentType && CurrentType->getIsTemplateParam())
+    Parent->setIsTemplate();
+
+  return CurrentScope;
+}
+
+void LVELFReader::traverseDieAndChildren(DWARFDie &DIE, LVScope *Parent,
+                                         DWARFDie &SkeletonDie) {
+  // Process the current DIE.
+  LVScope *Scope = processOneDie(DIE, Parent, SkeletonDie);
+  if (Scope) {
+    LVOffset Lower = DIE.getOffset();
+    LVOffset Upper = CurrentEndOffset;
+    // Traverse the children chain.
+    DWARFDie Child = DIE.getFirstChild();
+    while (Child) {
+      traverseDieAndChildren(Child, Scope, DummyDie);
+      Upper = Child.getOffset();
+      Child = Child.getSibling();
+    }
+    // Calculate contributions to the debug info section.
+    if (options().getPrintSizes() && Upper)
+      CompileUnit->addSize(Scope, Lower, Upper);
+  }
+}
+
+void LVELFReader::processLocationGaps() {
+  if (options().getAttributeAnyLocation())
+    for (LVSymbol *Symbol : SymbolsWithLocations)
+      Symbol->fillLocationGaps();
+}
+
+void LVELFReader::createLineAndFileRecords(
+    const DWARFDebugLine::LineTable *Lines) {
+  if (!Lines)
+    return;
+
+  // Get the source filenames.
+  if (!Lines->Prologue.FileNames.empty())
+    for (const DWARFDebugLine::FileNameEntry &Entry :
+         Lines->Prologue.FileNames) {
+      std::string Directory;
+      if (Lines->getDirectoryForEntry(Entry, Directory))
+        Directory = transformPath(Directory);
+      if (Directory.empty())
+        Directory = std::string(CompileUnit->getCompilationDirectory());
+      std::string File = transformPath(dwarf::toStringRef(Entry.Name));
+      std::string String;
+      raw_string_ostream(String) << Directory << "/" << File;
+      CompileUnit->addFilename(String);
+    }
+
+  // In DWARF5 the file indexes start at 0;
+  bool IncrementIndex = Lines->Prologue.getVersion() >= 5;
+
+  // Get the source lines.
+  if ((options().getAttributeRange() || options().getPrintLines()) &&
+      Lines->Rows.size())
+    for (const DWARFDebugLine::Row &Row : Lines->Rows) {
+      // The 'processLines()' function will move each created logical line
+      // to its enclosing logical scope, using the debug ranges information
+      // and they will be released when its scope parent is deleted.
+      LVLineDebug *Line = new LVLineDebug();
+      CULines.push_back(Line);
+      Line->setAddress(Row.Address.Address);
+      Line->setFilename(
+          CompileUnit->getFilename(IncrementIndex ? Row.File + 1 : Row.File));
+      Line->setLineNumber(Row.Line);
+      if (Row.Discriminator)
+        Line->setDiscriminator(Row.Discriminator);
+      if (Row.IsStmt)
+        Line->setIsNewStatement();
+      if (Row.BasicBlock)
+        Line->setIsBasicBlock();
+      if (Row.EndSequence)
+        Line->setIsEndSequence();
+      if (Row.EpilogueBegin)
+        Line->setIsEpilogueBegin();
+      if (Row.PrologueEnd)
+        Line->setIsPrologueEnd();
+      LLVM_DEBUG({
+        dbgs() << "Address: " << hexValue(Line->getAddress())
+               << " Line: " << Line->lineNumberAsString(/*ShowZero=*/true)
+               << "\n";
+      });
+    }
+}
+
+std::string LVELFReader::getRegisterName(LVSmall Opcode, uint64_t Operands[2]) {
+  // The 'prettyPrintRegisterOp' function uses the DWARFUnit to access the
+  // offset and tag name. At this point we are operating on a logical view
+  // item, with no access to the underlying DWARF data used by LLVM.
+  // It does not support DW_OP_regval_type.
+  if (Opcode == dwarf::DW_OP_regval_type)
+    return {};
+  if ((Opcode >= dwarf::DW_OP_breg0 && Opcode <= dwarf::DW_OP_breg31) ||
+      (Opcode >= dwarf::DW_OP_reg0 && Opcode <= dwarf::DW_OP_reg31) ||
+      Opcode == dwarf::DW_OP_bregx || Opcode == dwarf::DW_OP_regx) {
+    std::string string;
+    raw_string_ostream Stream(string);
+    prettyPrintRegisterOp(/*U=*/nullptr, Stream, DumpOpts, Opcode, Operands,
+                          MRI.get(), /*isEH=*/false);
+    return Stream.str();
+  }
+  return {};
+}
+
+Error LVELFReader::createScopes() {
+  LLVM_DEBUG({
+    W.startLine() << "\n";
+    W.printString("File", Obj.getFileName().str());
+    W.printString("Format", FileFormatName);
+  });
+
+  if (Error Err = LVReader::createScopes())
+    return Err;
+
+  // As the DwarfContext object is valid only during the scopes creation,
+  // we need to create our own Target information, to be used during the
+  // logical view printing, in the case of instructions being requested.
+  std::unique_ptr<DWARFContext> DwarfContext = DWARFContext::create(Obj);
+  if (!DwarfContext) {
+    std::string TheFilename(getFilename());
+    return createStringError(errc::invalid_argument,
+                             "Could not create DWARF information: %s",
+                             TheFilename.c_str());
+  }
+
+  if (Error Err = loadTargetInfo(Obj))
+    return Err;
+
+  // Create a mapping for virtual addresses.
+  mapVirtualAddress(Obj);
+
+  // Select the correct compile unit range, depending if we are dealing with
+  // a standard or split DWARF object.
+  DWARFContext::compile_unit_range CompileUnits =
+      DwarfContext->getNumCompileUnits() ? DwarfContext->compile_units()
+                                         : DwarfContext->dwo_compile_units();
+  for (const std::unique_ptr<DWARFUnit> &CU : CompileUnits) {
+
+    // Deduction of index used for the line records.
+    //
+    // For the following test case: test.cpp
+    //  void foo(void ParamPtr) { }
+
+    // Both GCC and Clang generate DWARF-5 .debug_line layout.
+
+    // * GCC (GNU C++17 11.3.0) - All DW_AT_decl_file use index 1.
+    //
+    //   .debug_info:
+    //     format = DWARF32, version = 0x0005
+    //     DW_TAG_compile_unit
+    //       DW_AT_name ("test.cpp")
+    //       DW_TAG_subprogram ("foo")
+    //         DW_AT_decl_file (1)
+    //         DW_TAG_formal_parameter ("ParamPtr")
+    //           DW_AT_decl_file (1)
+    //   .debug_line:
+    //     Line table prologue: format (DWARF32), version (5)
+    //     include_directories[0] = "..."
+    //     file_names[0]: name ("test.cpp"), dir_index (0)
+    //     file_names[1]: name ("test.cpp"), dir_index (0)
+
+    // * Clang (14.0.6) - All DW_AT_decl_file use index 0.
+    //
+    //   .debug_info:
+    //     format = DWARF32, version = 0x0005
+    //     DW_AT_producer ("clang version 14.0.6")
+    //     DW_AT_name ("test.cpp")
+    //
+    //     DW_TAG_subprogram ("foo")
+    //       DW_AT_decl_file (0)
+    //       DW_TAG_formal_parameter ("ParamPtr")
+    //         DW_AT_decl_file (0)
+    //   .debug_line:
+    //     Line table prologue: format (DWARF32), version (5)
+    //     include_directories[0] = "..."
+    //     file_names[0]: name ("test.cpp"), dir_index (0)
+
+    // From DWARFDebugLine::getFileNameByIndex documentation:
+    //   In Dwarf 4, the files are 1-indexed.
+    //   In Dwarf 5, the files are 0-indexed.
+    // Additional discussions here:
+    // https://www.mail-archive.com/[e-mail]/msg00883.html
+
+    // The ELF Reader is expecting the files are 1-indexed, so using
+    // the .debug_line header information decide if the indexed require
+    // an internal adjustment.
+
+    // For the case of GCC (DWARF5), if the entries[0] and [1] are the
+    // same, do not perform any adjustment.
+    auto DeductIncrementFileIndex = [&]() -> bool {
+      if (CU->getVersion() < 5)
+        // DWARF-4 or earlier -> Don't increment index.
+        return false;
+
+      if (const DWARFDebugLine::LineTable *LT =
+              CU->getContext().getLineTableForUnit(CU.get())) {
+        // Check if there are at least 2 entries and if they are the same.
+        if (LT->hasFileAtIndex(0) && LT->hasFileAtIndex(1)) {
+          const DWARFDebugLine::FileNameEntry &EntryZero =
+              LT->Prologue.getFileNameEntry(0);
+          const DWARFDebugLine::FileNameEntry &EntryOne =
+              LT->Prologue.getFileNameEntry(1);
+          // Check directory indexes.
+          if (EntryZero.DirIdx != EntryOne.DirIdx)
+            // DWARF-5 -> Increment index.
+            return true;
+          // Check filename.
+          std::string FileZero;
+          std::string FileOne;
+          StringRef None;
+          LT->getFileNameByIndex(
+              0, None, DILineInfoSpecifier::FileLineInfoKind::RawValue,
+              FileZero);
+          LT->getFileNameByIndex(
+              1, None, DILineInfoSpecifier::FileLineInfoKind::RawValue,
+              FileOne);
+          return FileZero.compare(FileOne);
+        }
+      }
+
+      // DWARF-5 -> Increment index.
+      return true;
+    };
+    // The ELF reader expects the indexes as 1-indexed.
+    IncrementFileIndex = DeductIncrementFileIndex();
+
+    DWARFDie UnitDie = CU->getUnitDIE();
+    SmallString<16> DWOAlternativeLocation;
+    if (UnitDie) {
+      Optional<const char *> DWOFileName =
+          CU->getVersion() >= 5
+              ? dwarf::toString(UnitDie.find(dwarf::DW_AT_dwo_name))
+              : dwarf::toString(UnitDie.find(dwarf::DW_AT_GNU_dwo_name));
+      StringRef From(DWOFileName.has_value() ? DWOFileName.value() : "");
+      DWOAlternativeLocation = createAlternativePath(InputFilename, From);
+    }
+
+    // The current CU can be a normal compile unit (standard) or a skeleton
+    // compile unit (split). For both cases, the returned die, will be used
+    // to create the logical scopes.
+    DWARFDie CUDie = CU->getNonSkeletonUnitDIE(
+        /*ExtractUnitDIEOnly=*/false,
+        /*DWOAlternativeLocation=*/DWOAlternativeLocation);
+    if (!CUDie.isValid())
+      continue;
+
+    // The current unit corresponds to the .dwo file. We need to get the
+    // skeleton unit and query for any ranges that will enclose any ranges
+    // in the non-skeleton unit.
+    DWARFDie SkeletonDie =
+        CUDie.getDwarfUnit()->isDWOUnit() ? CU->getUnitDIE(false) : DummyDie;
+    // Disable the ranges processing if we have just a single .dwo object,
+    // as any DW_AT_ranges will access not available range information.
+    RangesDataAvailable =
+        (!CUDie.getDwarfUnit()->isDWOUnit() ||
+         (SkeletonDie.isValid() ? !SkeletonDie.getDwarfUnit()->isDWOUnit()
+                                : true));
+
+    traverseDieAndChildren(CUDie, Root, SkeletonDie);
+
+    createLineAndFileRecords(DwarfContext->getLineTableForUnit(CU.get()));
+    if (Error Err = createInstructions())
+      return Err;
+
+    // Process the compilation unit, as there are cases where enclosed
+    // functions have the same ranges values. Insert the compilation unit
+    // ranges at the end, to allow enclosing ranges to be first in the list.
+    LVSectionIndex SectionIndex = getSectionIndex(CompileUnit);
+    addSectionRange(SectionIndex, CompileUnit);
+    LVRange *ScopesWithRanges = getSectionRanges(SectionIndex);
+    ScopesWithRanges->sort();
+
+    processLines(&CULines, SectionIndex);
+    processLocationGaps();
+
+    // These are per compile unit.
+    ScopesWithRanges->clear();
+    SymbolsWithLocations.clear();
+    CULines.clear();
+  }
+
+  return Error::success();
+}
+
+// Get the location information for the associated attribute.
+void LVELFReader::getLocationList(dwarf::Attribute Attr,
+                                  const DWARFFormValue &FormValue,
+                                  const DWARFDie &Die, uint64_t OffsetOnEntry,
+                                  bool CallSiteLocation) {
+
+  auto ProcessLocationExpression = [&](const DWARFExpression &Expression) {
+    // DW_OP_const_type is variable-length and has 3
+    // operands. DWARFExpression thus far only supports 2.
+    uint64_t Operands[2] = {0};
+    for (const DWARFExpression::Operation &Op : Expression) {
+      DWARFExpression::Operation::Description Description = Op.getDescription();
+      for (unsigned Operand = 0; Operand < 2; ++Operand) {
+        if (Description.Op[Operand] == DWARFExpression::Operation::SizeNA)
+          break;
+        Operands[Operand] = Op.getRawOperand(Operand);
+      }
+      CurrentSymbol->addLocationOperands(Op.getCode(), Operands[0],
+                                         Operands[1]);
+    }
+  };
+
+  DWARFUnit *U = Die.getDwarfUnit();
+  DWARFContext &DwarfContext = U->getContext();
+  bool IsLittleEndian = DwarfContext.isLittleEndian();
+  if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
+      (DWARFAttribute::mayHaveLocationExpr(Attr) &&
+       FormValue.isFormClass(DWARFFormValue::FC_Exprloc))) {
+    ArrayRef<uint8_t> Expr = *FormValue.getAsBlock();
+    DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),
+                       IsLittleEndian, 0);
+    DWARFExpression Expression(Data, U->getAddressByteSize(),
+                               U->getFormParams().Format);
+
+    // Add location and operation entries.
+    CurrentSymbol->addLocation(Attr, /*LowPC=*/0, /*HighPC=*/-1,
+                               /*SectionOffset=*/0, OffsetOnEntry,
+                               CallSiteLocation);
+    ProcessLocationExpression(Expression);
+    return;
+  }
+
+  if (DWARFAttribute::mayHaveLocationList(Attr) &&
+      FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
+    uint64_t Offset = *FormValue.getAsSectionOffset();
+    if (FormValue.getForm() == dwarf::DW_FORM_loclistx) {
+      Optional<uint64_t> LoclistOffset = U->getLoclistOffset(Offset);
+      if (!LoclistOffset)
+        return;
+      Offset = *LoclistOffset;
+    }
+    uint64_t BaseAddr = 0;
+    if (Optional<SectionedAddress> BA = U->getBaseAddress())
+      BaseAddr = BA->Address;
+    LVAddress LowPC = 0;
+    LVAddress HighPC = 0;
+
+    auto ProcessLocationEntry = [&](const DWARFLocationEntry &Entry) {
+      if (Entry.Kind == dwarf::DW_LLE_base_address) {
+        BaseAddr = Entry.Value0;
+        return;
+      }
+      if (Entry.Kind == dwarf::DW_LLE_offset_pair) {
+        LowPC = BaseAddr + Entry.Value0;
+        HighPC = BaseAddr + Entry.Value1;
+        DWARFAddressRange Range{LowPC, HighPC, Entry.SectionIndex};
+        if (Range.SectionIndex == SectionedAddress::UndefSection)
+          Range.SectionIndex = Entry.SectionIndex;
+        DWARFLocationExpression Loc{Range, Entry.Loc};
+        DWARFDataExtractor Data(Loc.Expr, IsLittleEndian,
+                                U->getAddressByteSize());
+        DWARFExpression Expression(Data, U->getAddressByteSize());
+
+        // Store the real upper limit for the address range.
+        if (UpdateHighAddress && HighPC > 0)
+          --HighPC;
+        // Add location and operation entries.
+        CurrentSymbol->addLocation(Attr, LowPC, HighPC, Offset, OffsetOnEntry,
+                                   CallSiteLocation);
+        ProcessLocationExpression(Expression);
+      }
+    };
+    Error E = U->getLocationTable().visitLocationList(
+        &Offset, [&](const DWARFLocationEntry &E) {
+          ProcessLocationEntry(E);
+          return true;
+        });
+    if (E)
+      consumeError(std::move(E));
+  }
+}
+
+void LVELFReader::getLocationMember(dwarf::Attribute Attr,
+                                    const DWARFFormValue &FormValue,
+                                    const DWARFDie &Die,
+                                    uint64_t OffsetOnEntry) {
+  // Check if the value is an integer constant.
+  if (FormValue.isFormClass(DWARFFormValue::FC_Constant))
+    // Add a record to hold a constant as location.
+    CurrentSymbol->addLocationConstant(Attr, *FormValue.getAsUnsignedConstant(),
+                                       OffsetOnEntry);
+  else
+    // This is a a location description, or a reference to one.
+    getLocationList(Attr, FormValue, Die, OffsetOnEntry);
+}
+
+// Update the current element with the reference.
+void LVELFReader::updateReference(dwarf::Attribute Attr,
+                                  const DWARFFormValue &FormValue) {
+  // We are assuming that DW_AT_specification, DW_AT_abstract_origin,
+  // DW_AT_type and DW_AT_extension do not appear at the same time
+  // in the same DIE.
+  uint64_t Reference = *FormValue.getAsReference();
+  // Get target for the given reference, if already created.
+  LVElement *Target = getElementForOffset(Reference, CurrentElement);
+  // Check if we are dealing with cross CU references.
+  if (FormValue.getForm() == dwarf::DW_FORM_ref_addr) {
+    if (Target) {
+      // The global reference is ready. Mark it as global.
+      Target->setIsGlobalReference();
+      // Remove global reference from the unseen list.
+      removeGlobalOffset(Reference);
+    } else
+      // Record the unseen cross CU reference.
+      addGlobalOffset(Reference);
+  }
+
+  // At this point, 'Target' can be null, in the case of the target element
+  // not being seen. But the correct bit is set, to indicate that the target
+  // is being referenced by (abstract_origin, extension, specification) or
+  // (import, type).
+  // We must differentiate between the kind of reference. This is needed to
+  // complete inlined function instances with dropped abstract references,
+  // in order to facilitate a logical comparison.
+  switch (Attr) {
+  case dwarf::DW_AT_abstract_origin:
+  case dwarf::DW_AT_call_origin:
+    CurrentElement->setReference(Target);
+    CurrentElement->setHasReferenceAbstract();
+    break;
+  case dwarf::DW_AT_extension:
+    CurrentElement->setReference(Target);
+    CurrentElement->setHasReferenceExtension();
+    break;
+  case dwarf::DW_AT_specification:
+    CurrentElement->setReference(Target);
+    CurrentElement->setHasReferenceSpecification();
+    break;
+  case dwarf::DW_AT_import:
+  case dwarf::DW_AT_type:
+    CurrentElement->setType(Target);
+    break;
+  default:
+    break;
+  }
+}
+
+// Get an element given the DIE offset.
+LVElement *LVELFReader::getElementForOffset(LVOffset Offset,
+                                            LVElement *Element) {
+  LVElement *Target = nullptr;
+  // Search offset in the cross references.
+  LVElementReference::iterator Iter = ElementTable.find(Offset);
+  if (Iter == ElementTable.end())
+    // Reference to an unseen element.
+    ElementTable.emplace(std::piecewise_construct,
+                         std::forward_as_tuple(Offset),
+                         std::forward_as_tuple(nullptr, LVElementSet{Element}));
+  else {
+    // There are previous references to this element. We need to update the
+    // element and all the references pointing to this element.
+    LVElementEntry &Reference = Iter->second;
+    Target = Reference.first;
+    if (!Target)
+      // Add the element to the set.
+      Reference.second.insert(Element);
+  }
+  return Target;
+}
+
+Error LVELFReader::loadTargetInfo(const ObjectFile &Obj) {
+  // Detect the architecture from the object file. We usually don't need OS
+  // info to lookup a target and create register info.
+  Triple TT;
+  TT.setArch(Triple::ArchType(Obj.getArch()));
+  TT.setVendor(Triple::UnknownVendor);
+  TT.setOS(Triple::UnknownOS);
+
+  // Features to be passed to target/subtarget
+  SubtargetFeatures Features = Obj.getFeatures();
+
+  return loadGenericTargetInfo(TT.str(), Features.getString());
+}
+
+void LVELFReader::mapRangeAddress(const ObjectFile &Obj) {
+  for (auto Iter = Obj.symbol_begin(); Iter != Obj.symbol_end(); ++Iter) {
+    const SymbolRef &Symbol = *Iter;
+
+    Expected<SymbolRef::Type> TypeOrErr = Symbol.getType();
+    if (!TypeOrErr) {
+      consumeError(TypeOrErr.takeError());
+      continue;
+    }
+
+    // Process only symbols that represent a function.
+    SymbolRef::Type Type = *TypeOrErr;
+    if (Type != SymbolRef::ST_Function)
+      continue;
+
+    // Don't ask a Mach-O STAB symbol for its section unless you know that
+    // STAB symbol's section field refers to a valid section index. Otherwise
+    // the symbol may error trying to load a section that does not exist.
+    const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(&Obj);
+    bool IsSTAB = false;
+    if (MachO) {
+      DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
+      uint8_t NType =
+          (MachO->is64Bit() ? MachO->getSymbol64TableEntry(SymDRI).n_type
+                            : MachO->getSymbolTableEntry(SymDRI).n_type);
+      if (NType & MachO::N_STAB)
+        IsSTAB = true;
+    }
+
+    Expected<section_iterator> IterOrErr = Symbol.getSection();
+    if (!IterOrErr) {
+      consumeError(IterOrErr.takeError());
+      continue;
+    }
+    section_iterator Section = IsSTAB ? Obj.section_end() : *IterOrErr;
+    if (Section == Obj.section_end())
+      continue;
+
+    // Get the symbol value.
+    Expected<uint64_t> AddressOrErr = Symbol.getAddress();
+    if (!AddressOrErr) {
+      consumeError(AddressOrErr.takeError());
+      continue;
+    }
+    uint64_t Address = *AddressOrErr;
+
+    // Get symbol name.
+    StringRef Name;
+    Expected<StringRef> NameOrErr = Symbol.getName();
+    if (!NameOrErr) {
+      consumeError(NameOrErr.takeError());
+      continue;
+    }
+    Name = *NameOrErr;
+
+    // Check if the symbol is Comdat.
+    Expected<uint32_t> FlagsOrErr = Symbol.getFlags();
+    if (!FlagsOrErr) {
+      consumeError(FlagsOrErr.takeError());
+      continue;
+    }
+    uint32_t Flags = *FlagsOrErr;
+
+    // Mark the symbol as 'comdat' in any of the following cases:
+    // - Symbol has the SF_Weak or
+    // - Symbol section index different of the DotTextSectionIndex.
+    LVSectionIndex SectionIndex = Section->getIndex();
+    bool IsComdat =
+        (Flags & SymbolRef::SF_Weak) || (SectionIndex != DotTextSectionIndex);
+
+    // Record the symbol name (linkage) and its loading address.
+    addToSymbolTable(Name, Address, SectionIndex, IsComdat);
+  }
+}
+
+void LVELFReader::sortScopes() { Root->sort(); }
+
+void LVELFReader::print(raw_ostream &OS) const {
+  OS << "LVType\n";
+  LLVM_DEBUG(dbgs() << "CreateReaders\n");
+}

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-compare-logical-elements.test

+; Test case 1 - General options
+
+; test.cpp
+;  1  using INTPTR = const int *;
+;  2  int foo(INTPTR ParamPtr, unsigned ParamUnsigned, bool ParamBool) {
+;  3    if (ParamBool) {
+;  4      typedef int INTEGER;
+;  5      const INTEGER CONSTANT = 7;
+;  6      return CONSTANT;
+;  7    }
+;  8    return ParamUnsigned;
+;  9  }
+
+; Compare mode - Logical view.
+; The output shows in view form the 'missing (-), added (+)' elements,
+; giving more context by swapping the reference and target object files.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --compare=types \
+; RUN:                         --report=view \
+; RUN:                         --print=symbols,types \
+; RUN:                         %p/Inputs/test-dwarf-clang.o \
+; RUN:                         %p/Inputs/test-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Reference: 'test-dwarf-clang.o'
+; ONE-NEXT: Target:    'test-dwarf-gcc.o'
+; ONE-EMPTY:
+; ONE-NEXT: Logical View:
+; ONE-NEXT:  [000]           {File} 'test-dwarf-clang.o'
+; ONE-EMPTY:
+; ONE-NEXT:  [001]             {CompileUnit} 'test.cpp'
+; ONE-NEXT:  [002]     1         {TypeAlias} 'INTPTR' -> '* const int'
+; ONE-NEXT:  [002]     2         {Function} extern not_inlined 'foo' -> 'int'
+; ONE-NEXT:  [003]                 {Block}
+; ONE-NEXT:  [004]     5             {Variable} 'CONSTANT' -> 'const INTEGER'
+; ONE-NEXT: +[004]     4             {TypeAlias} 'INTEGER' -> 'int'
+; ONE-NEXT:  [003]     2           {Parameter} 'ParamBool' -> 'bool'
+; ONE-NEXT:  [003]     2           {Parameter} 'ParamPtr' -> 'INTPTR'
+; ONE-NEXT:  [003]     2           {Parameter} 'ParamUnsigned' -> 'unsigned int'
+; ONE-NEXT: -[003]     4           {TypeAlias} 'INTEGER' -> 'int'
+
+; Compare mode - Logical elements.
+; The output shows in tabular form the 'missing (-), added (+)' elements,
+; giving more context by swapping the reference and target object files.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --compare=types \
+; RUN:                         --report=list \
+; RUN:                         --print=symbols,types,summary \
+; RUN:                         %p/Inputs/test-dwarf-clang.o \
+; RUN:                         %p/Inputs/test-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Reference: 'test-dwarf-clang.o'
+; TWO-NEXT: Target:    'test-dwarf-gcc.o'
+; TWO-EMPTY:
+; TWO-NEXT: (1) Missing Types:
+; TWO-NEXT: -[003]     4     {TypeAlias} 'INTEGER' -> 'int'
+; TWO-EMPTY:
+; TWO-NEXT: (1) Added Types:
+; TWO-NEXT: +[004]     4     {TypeAlias} 'INTEGER' -> 'int'
+; TWO-EMPTY:
+; TWO-NEXT: ----------------------------------------
+; TWO-NEXT: Element   Expected    Missing      Added
+; TWO-NEXT: ----------------------------------------
+; TWO-NEXT: Scopes           4          0          0
+; TWO-NEXT: Symbols          0          0          0
+; TWO-NEXT: Types            2          1          1
+; TWO-NEXT: Lines            0          0          0
+; TWO-NEXT: ----------------------------------------
+; TWO-NEXT: Total            6          1          1
+
+; Changing the 'Reference' and 'Target' order:
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --compare=types \
+; RUN:                         --report=list \
+; RUN:                         --print=symbols,types,summary \
+; RUN:                         %p/Inputs/test-dwarf-gcc.o \
+; RUN:                         %p/Inputs/test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=THR %s
+
+; THR:      Reference: 'test-dwarf-gcc.o'
+; THR-NEXT: Target:    'test-dwarf-clang.o'
+; THR-EMPTY:
+; THR-NEXT: (1) Missing Types:
+; THR-NEXT: -[004]     4     {TypeAlias} 'INTEGER' -> 'int'
+; THR-EMPTY:
+; THR-NEXT: (1) Added Types:
+; THR-NEXT: +[003]     4     {TypeAlias} 'INTEGER' -> 'int'
+; THR-EMPTY:
+; THR-NEXT: ----------------------------------------
+; THR-NEXT: Element   Expected    Missing      Added
+; THR-NEXT: ----------------------------------------
+; THR-NEXT: Scopes           4          0          0
+; THR-NEXT: Symbols          0          0          0
+; THR-NEXT: Types            2          1          1
+; THR-NEXT: Lines            0          0          0
+; THR-NEXT: ----------------------------------------
+; THR-NEXT: Total            6          1          1

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-print-basic-details.test

+; Test case 1 - General options.
+
+; test.cpp
+;  1  using INTPTR = const int *;
+;  2  int foo(INTPTR ParamPtr, unsigned ParamUnsigned, bool ParamBool) {
+;  3    if (ParamBool) {
+;  4      typedef int INTEGER;
+;  5      const INTEGER CONSTANT = 7;
+;  6      return CONSTANT;
+;  7    }
+;  8    return ParamUnsigned;
+;  9  }
+
+; Print basic details.
+; The following command prints basic details for all the logical elements
+; sorted by the debug information internal offset; it includes its lexical
+; level and debug info format.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format \
+; RUN:                         --output-sort=offset \
+; RUN:                         --print=scopes,symbols,types,lines,instructions \
+; RUN:                         %p/Inputs/test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format \
+; RUN:                         --output-sort=offset \
+; RUN:                         --print=elements \
+; RUN:                         %p/Inputs/test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'test-dwarf-clang.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'test.cpp'
+; ONE-NEXT: [002]     2         {Function} extern not_inlined 'foo' -> 'int'
+; ONE-NEXT: [003]     2           {Parameter} 'ParamPtr' -> 'INTPTR'
+; ONE-NEXT: [003]     2           {Parameter} 'ParamUnsigned' -> 'unsigned int'
+; ONE-NEXT: [003]     2           {Parameter} 'ParamBool' -> 'bool'
+; ONE-NEXT: [003]                 {Block}
+; ONE-NEXT: [004]     5             {Variable} 'CONSTANT' -> 'const INTEGER'
+; ONE-NEXT: [004]     5             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl $0x7, -0x1c(%rbp)'
+; ONE-NEXT: [004]     6             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl $0x7, -0x4(%rbp)'
+; ONE-NEXT: [004]                   {Code} 'jmp  0x6'
+; ONE-NEXT: [004]     8             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl -0x14(%rbp), %eax'
+; ONE-NEXT: [003]     4           {TypeAlias} 'INTEGER' -> 'int'
+; ONE-NEXT: [003]     2           {Line}
+; ONE-NEXT: [003]                 {Code} 'pushq  %rbp'
+; ONE-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; ONE-NEXT: [003]                 {Code} 'movb %dl, %al'
+; ONE-NEXT: [003]                 {Code} 'movq %rdi, -0x10(%rbp)'
+; ONE-NEXT: [003]                 {Code} 'movl %esi, -0x14(%rbp)'
+; ONE-NEXT: [003]                 {Code} 'andb $0x1, %al'
+; ONE-NEXT: [003]                 {Code} 'movb %al, -0x15(%rbp)'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]                 {Code} 'testb  $0x1, -0x15(%rbp)'
+; ONE-NEXT: [003]                 {Code} 'je 0x13'
+; ONE-NEXT: [003]     8           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl %eax, -0x4(%rbp)'
+; ONE-NEXT: [003]     9           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %eax'
+; ONE-NEXT: [003]                 {Code} 'popq %rbp'
+; ONE-NEXT: [003]                 {Code} 'retq'
+; ONE-NEXT: [003]     9           {Line}
+; ONE-NEXT: [002]     1         {TypeAlias} 'INTPTR' -> '* const int'

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/01-dwarf-select-logical-elements.test

+; Test case 1 - General options
+
+; test.cpp
+;  1  using INTPTR = const int *;
+;  2  int foo(INTPTR ParamPtr, unsigned ParamUnsigned, bool ParamBool) {
+;  3    if (ParamBool) {
+;  4      typedef int INTEGER;
+;  5      const INTEGER CONSTANT = 7;
+;  6      return CONSTANT;
+;  7    }
+;  8    return ParamUnsigned;
+;  9  }
+
+; Select logical elements.
+; The following prints all 'instructions', 'symbols' and 'types' that
+; contain 'inte' or 'movl' in their names or types, using a tab layout
+; and given the number of matches.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --select-nocase --select-regex \
+; RUN:                         --select=INTe --select=movl \
+; RUN:                         --report=list \
+; RUN:                         --print=symbols,types,instructions,summary \
+; RUN:                         %p/Inputs/test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'test-dwarf-clang.o'
+; ONE-EMPTY:
+; ONE-NEXT: [001]           {CompileUnit} 'test.cpp'
+; ONE-NEXT: [004]           {Code} 'movl $0x7, -0x1c(%rbp)'
+; ONE-NEXT: [004]           {Code} 'movl $0x7, -0x4(%rbp)'
+; ONE-NEXT: [003]           {Code} 'movl %eax, -0x4(%rbp)'
+; ONE-NEXT: [003]           {Code} 'movl %esi, -0x14(%rbp)'
+; ONE-NEXT: [004]           {Code} 'movl -0x14(%rbp), %eax'
+; ONE-NEXT: [003]           {Code} 'movl -0x4(%rbp), %eax'
+; ONE-NEXT: [003]     4     {TypeAlias} 'INTEGER' -> 'int'
+; ONE-NEXT: [004]     5     {Variable} 'CONSTANT' -> 'const INTEGER'
+; ONE-EMPTY:
+; ONE-NEXT: -----------------------------
+; ONE-NEXT: Element      Total    Printed
+; ONE-NEXT: -----------------------------
+; ONE-NEXT: Scopes           3          0
+; ONE-NEXT: Symbols          4          1
+; ONE-NEXT: Types            2          1
+; ONE-NEXT: Lines           17          6
+; ONE-NEXT: -----------------------------
+; ONE-NEXT: Total           26          8
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --select-regex --select-nocase \
+; RUN:                         --select=INTe \
+; RUN:                         --report=list \
+; RUN:                         --print=symbols,types \
+; RUN:                         %p/Inputs/test-dwarf-clang.o \
+; RUN:                         %p/Inputs/test-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Logical View:
+; TWO-NEXT: [000]           {File} 'test-dwarf-clang.o'
+; TWO-EMPTY:
+; TWO-NEXT: [001]           {CompileUnit} 'test.cpp'
+; TWO-NEXT: [003]     4     {TypeAlias} 'INTEGER' -> 'int'
+; TWO-NEXT: [004]     5     {Variable} 'CONSTANT' -> 'const INTEGER'
+; TWO-EMPTY:
+; TWO-NEXT: Logical View:
+; TWO-NEXT: [000]           {File} 'test-dwarf-gcc.o'
+; TWO-EMPTY:
+; TWO-NEXT: [001]           {CompileUnit} 'test.cpp'
+; TWO-NEXT: [004]     4     {TypeAlias} 'INTEGER' -> 'int'
+; TWO-NEXT: [004]     5     {Variable} 'CONSTANT' -> 'const INTEGER'

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/02-dwarf-logical-lines.test

+; Test case 2 - Assembler instructions.
+
+; hello-world.cpp
+;  1  extern int printf(const char * format, ... );
+;  2
+;  3  int main()
+;  4  {
+;  5    printf("Hello, World\n");
+;  6    return 0;
+;  7  }
+
+; Logical lines.
+; The logical views shows the intermixed lines and assembler instructions,
+; allowing to compare the code generated by the different toolchains.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format,producer \
+; RUN:                         --print=lines,instructions \
+; RUN:                         %p/Inputs/hello-world-dwarf-clang.o \
+; RUN:                         %p/Inputs/hello-world-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'hello-world-dwarf-clang.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'hello-world.cpp'
+; ONE-NEXT: [002]               {Producer} 'clang version 15.0.0 {{.*}}'
+; ONE-NEXT: [002]     3         {Function} extern not_inlined 'main' -> 'int'
+; ONE-NEXT: [003]     4           {Line}
+; ONE-NEXT: [003]                 {Code} 'pushq  %rbp'
+; ONE-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; ONE-NEXT: [003]                 {Code} 'subq $0x10, %rsp'
+; ONE-NEXT: [003]                 {Code} 'movl $0x0, -0x4(%rbp)'
+; ONE-NEXT: [003]     5           {Line}
+; ONE-NEXT: [003]                 {Code} 'leaq (%rip), %rdi'
+; ONE-NEXT: [003]                 {Code} 'movb $0x0, %al'
+; ONE-NEXT: [003]                 {Code} 'callq  0x0'
+; ONE-NEXT: [003]     6           {Line}
+; ONE-NEXT: [003]                 {Code} 'xorl %eax, %eax'
+; ONE-NEXT: [003]                 {Code} 'addq $0x10, %rsp'
+; ONE-NEXT: [003]                 {Code} 'popq %rbp'
+; ONE-NEXT: [003]                 {Code} 'retq'
+; ONE-NEXT: [003]     6           {Line}
+; ONE-EMPTY:
+; ONE-NEXT: Logical View:
+; ONE-NEXT: [000]           {File} 'hello-world-dwarf-gcc.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'hello-world.cpp'
+; ONE-NEXT: [002]               {Producer} 'GNU C++14 10.3.0 {{.*}}'
+; ONE-NEXT: [002]     3         {Function} extern not_inlined 'main' -> 'int'
+; ONE-NEXT: [003]     4           {Line}
+; ONE-NEXT: [003]                 {Code} 'endbr64'
+; ONE-NEXT: [003]                 {Code} 'pushq  %rbp'
+; ONE-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; ONE-NEXT: [003]     5           {Line}
+; ONE-NEXT: [003]                 {Code} 'leaq (%rip), %rdi'
+; ONE-NEXT: [003]                 {Code} 'movl $0x0, %eax'
+; ONE-NEXT: [003]                 {Code} 'callq  0x0'
+; ONE-NEXT: [003]     6           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl $0x0, %eax'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'popq %rbp'
+; ONE-NEXT: [003]                 {Code} 'retq'
+; ONE-NEXT: [003]     7           {Line}

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/03-dwarf-incorrect-lexical-scope-typedef.test

+; Test case 3 - Incorrect lexical scope for typedef.
+
+; pr-44884.cpp
+;  1  int bar(float Input) { return (int)Input; }
+;  2
+;  3  unsigned foo(char Param) {
+;  4    typedef int INT;                // ** Definition for INT **
+;  5    INT Value = Param;
+;  6    {
+;  7      typedef float FLOAT;          // ** Definition for FLOAT **
+;  8      {
+;  9        FLOAT Added = Value + Param;
+; 10        Value = bar(Added);
+; 11      }
+; 12    }
+; 13    return Value + Param;
+; 14  }
+
+; The lines 4 and 7 contains 2 typedefs, defined at different lexical
+; scopes.
+
+; The above test is used to illustrates a scope issue found in the
+; Clang compiler.
+; PR44884: https://bugs.llvm.org/show_bug.cgi?id=44884
+; PR44229: https://github.com/llvm/llvm-project/issues/44229
+
+; In the following logical views, we can see that the Clang compiler
+; emits both typedefs at the same lexical scope (3), which is wrong.
+; GCC and MSVC emit correct lexical scope for both typedefs.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format,producer \
+; RUN:                         --output-sort=kind \
+; RUN:                         --print=symbols,types,lines \
+; RUN:                         %p/Inputs/pr-44884-dwarf-clang.o \
+; RUN:                         %p/Inputs/pr-44884-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'pr-44884-dwarf-clang.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'pr-44884.cpp'
+; ONE-NEXT: [002]               {Producer} 'clang version 15.0.0 {{.*}}'
+; ONE-NEXT: [002]     1         {Function} extern not_inlined 'bar' -> 'int'
+; ONE-NEXT: [003]     1           {Parameter} 'Input' -> 'float'
+; ONE-NEXT: [003]     1           {Line}
+; ONE-NEXT: [003]     1           {Line}
+; ONE-NEXT: [003]     1           {Line}
+; ONE-NEXT: [002]     3         {Function} extern not_inlined 'foo' -> 'unsigned int'
+; ONE-NEXT: [003]                 {Block}
+; ONE-NEXT: [004]     9             {Variable} 'Added' -> 'FLOAT'
+; ONE-NEXT: [004]     9             {Line}
+; ONE-NEXT: [004]     9             {Line}
+; ONE-NEXT: [004]     9             {Line}
+; ONE-NEXT: [004]     9             {Line}
+; ONE-NEXT: [004]     9             {Line}
+; ONE-NEXT: [004]    10             {Line}
+; ONE-NEXT: [004]    10             {Line}
+; ONE-NEXT: [004]    10             {Line}
+; ONE-NEXT: [004]    13             {Line}
+; ONE-NEXT: [003]     3           {Parameter} 'Param' -> 'char'
+; ONE-NEXT: [003]     7           {TypeAlias} 'FLOAT' -> 'float'
+; ONE-NEXT: [003]     4           {TypeAlias} 'INT' -> 'int'
+; ONE-NEXT: [003]     5           {Variable} 'Value' -> 'INT'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]     5           {Line}
+; ONE-NEXT: [003]     5           {Line}
+; ONE-NEXT: [003]    13           {Line}
+; ONE-NEXT: [003]    13           {Line}
+; ONE-NEXT: [003]    13           {Line}
+; ONE-NEXT: [003]    13           {Line}
+; ONE-EMPTY:
+; ONE-NEXT: Logical View:
+; ONE-NEXT: [000]           {File} 'pr-44884-dwarf-gcc.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'pr-44884.cpp'
+; ONE-NEXT: [002]               {Producer} 'GNU C++14 10.3.0 {{.*}}'
+; ONE-NEXT: [002]     1         {Function} extern not_inlined 'bar' -> 'int'
+; ONE-NEXT: [003]     1           {Parameter} 'Input' -> 'float'
+; ONE-NEXT: [003]     1           {Line}
+; ONE-NEXT: [003]     1           {Line}
+; ONE-NEXT: [003]     1           {Line}
+; ONE-NEXT: [002]     3         {Function} extern not_inlined 'foo' -> 'unsigned int'
+; ONE-NEXT: [003]                 {Block}
+; ONE-NEXT: [004]                   {Block}
+; ONE-NEXT: [005]     9               {Variable} 'Added' -> 'FLOAT'
+; ONE-NEXT: [005]     9               {Line}
+; ONE-NEXT: [005]     9               {Line}
+; ONE-NEXT: [005]     9               {Line}
+; ONE-NEXT: [005]    10               {Line}
+; ONE-NEXT: [005]    13               {Line}
+; ONE-NEXT: [004]     7             {TypeAlias} 'FLOAT' -> 'float'
+; ONE-NEXT: [003]     3           {Parameter} 'Param' -> 'char'
+; ONE-NEXT: [003]     4           {TypeAlias} 'INT' -> 'int'
+; ONE-NEXT: [003]     5           {Variable} 'Value' -> 'INT'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]     5           {Line}
+; ONE-NEXT: [003]    13           {Line}
+; ONE-NEXT: [003]    14           {Line}
+; ONE-NEXT: [003]    14           {Line}
+
+; Using the selection facilities, we can produce a simple tabular
+; output showing just the logical types that are 'Typedef'.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format \
+; RUN:                         --output-sort=name \
+; RUN:                         --select-types=Typedef \
+; RUN:                         --report=list \
+; RUN:                         --print=types \
+; RUN:                         %p/Inputs/pr-44884-*.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Logical View:
+; TWO-NEXT: [000]           {File} 'pr-44884-dwarf-clang.o' -> elf64-x86-64
+; TWO-EMPTY:
+; TWO-NEXT: [001]           {CompileUnit} 'pr-44884.cpp'
+; TWO-NEXT: [003]     7     {TypeAlias} 'FLOAT' -> 'float'
+; TWO-NEXT: [003]     4     {TypeAlias} 'INT' -> 'int'
+; TWO-EMPTY:
+; TWO-NEXT: Logical View:
+; TWO-NEXT: [000]           {File} 'pr-44884-dwarf-gcc.o' -> elf64-x86-64
+; TWO-EMPTY:
+; TWO-NEXT: [001]           {CompileUnit} 'pr-44884.cpp'
+; TWO-NEXT: [004]     7     {TypeAlias} 'FLOAT' -> 'float'
+; TWO-NEXT: [003]     4     {TypeAlias} 'INT' -> 'int'

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/04-dwarf-missing-nested-enumerators.test

+; Test case 4 - Missing nested enumerations.
+
+; pr-46466.cpp
+;   1  struct Struct {
+;   2    union Union {
+;   3      enum NestedEnum { RED, BLUE };
+;   4    };
+;   5    Union U;
+;   6  };
+;   7
+;   8  Struct S;
+;   9  int test() {
+;  10    return S.U.BLUE;
+;  11  }
+
+; The above test is used to illustrate a scope issue found in the Clang
+; compiler.
+; PR46466: https://bugs.llvm.org/show_bug.cgi?id=46466
+; PR45811: https://github.com/llvm/llvm-project/issues/45811
+
+; In the following logical views, we can see that the DWARF debug
+; information generated by the Clang compiler does not include any
+; references to the enumerators 'RED' and 'BLUE'. The DWARF generated
+; by GCC, CodeView generated by Clang and MSVC, it does include such
+; references.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format,producer \
+; RUN:                         --output-sort=name \
+; RUN:                         --print=symbols,types \
+; RUN:                         %p/Inputs/pr-46466-dwarf-clang.o \
+; RUN:                         %p/Inputs/pr-46466-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'pr-46466-dwarf-clang.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'pr-46466.cpp'
+; ONE-NEXT: [002]               {Producer} 'clang version 15.0.0 {{.*}}'
+; ONE-NEXT: [002]     8         {Variable} extern 'S' -> 'Struct'
+; ONE-NEXT: [002]     1         {Struct} 'Struct'
+; ONE-NEXT: [003]     5           {Member} public 'U' -> 'Union'
+; ONE-EMPTY:
+; ONE-NEXT: Logical View:
+; ONE-NEXT: [000]           {File} 'pr-46466-dwarf-gcc.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'pr-46466.cpp'
+; ONE-NEXT: [002]               {Producer} 'GNU C++14 10.3.0 {{.*}}'
+; ONE-NEXT: [002]     8         {Variable} extern 'S' -> 'Struct'
+; ONE-NEXT: [002]     1         {Struct} 'Struct'
+; ONE-NEXT: [003]     5           {Member} public 'U' -> 'Union'
+; ONE-NEXT: [003]     2           {Union} 'Union'
+; ONE-NEXT: [004]     3             {Enumeration} 'NestedEnum' -> 'unsigned int'
+; ONE-NEXT: [005]                     {Enumerator} 'BLUE' = '0x1'
+; ONE-NEXT: [005]                     {Enumerator} 'RED' = '0x0'
+
+; Using the selection facilities, we can produce a logical view
+; showing just the logical types that are 'Enumerator' and its
+; parents. The logical view is sorted by the types name.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format \
+; RUN:                         --output-sort=name \
+; RUN:                         --select-types=Enumerator \
+; RUN:                         --report=parents \
+; RUN:                         --print=types \
+; RUN:                         %p/Inputs/pr-46466-*.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Logical View:
+; TWO-NEXT: [000]           {File} 'pr-46466-dwarf-clang.o' -> elf64-x86-64
+; TWO-EMPTY:
+; TWO-NEXT: [001]             {CompileUnit} 'pr-46466.cpp'
+; TWO-EMPTY:
+; TWO-NEXT: Logical View:
+; TWO-NEXT: [000]           {File} 'pr-46466-dwarf-gcc.o' -> elf64-x86-64
+; TWO-EMPTY:
+; TWO-NEXT: [001]             {CompileUnit} 'pr-46466.cpp'
+; TWO-NEXT: [002]     1         {Struct} 'Struct'
+; TWO-NEXT: [003]     2           {Union} 'Union'
+; TWO-NEXT: [004]     3             {Enumeration} 'NestedEnum' -> 'unsigned int'
+; TWO-NEXT: [005]                     {Enumerator} 'BLUE' = '0x1'
+; TWO-NEXT: [005]                     {Enumerator} 'RED' = '0x0'
+
+; Using the selection facilities, we can produce a simple tabular output
+; including a summary for the logical types that are 'Enumerator'. The
+; logical view is sorted by the types name.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format \
+; RUN:                         --output-sort=name \
+; RUN:                         --select-types=Enumerator \
+; RUN:                         --print=types,summary \
+; RUN:                         %p/Inputs/pr-46466-*.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=THR %s
+
+; THR:      Logical View:
+; THR-NEXT: [000]           {File} 'pr-46466-dwarf-clang.o' -> elf64-x86-64
+; THR-EMPTY:
+; THR-NEXT: [001]           {CompileUnit} 'pr-46466.cpp'
+; THR-EMPTY:
+; THR-NEXT: -----------------------------
+; THR-NEXT: Element      Total    Printed
+; THR-NEXT: -----------------------------
+; THR-NEXT: Scopes           4          0
+; THR-NEXT: Symbols          0          0
+; THR-NEXT: Types            0          0
+; THR-NEXT: Lines            0          0
+; THR-NEXT: -----------------------------
+; THR-NEXT: Total            4          0
+; THR-EMPTY:
+; THR-NEXT: Logical View:
+; THR-NEXT: [000]           {File} 'pr-46466-dwarf-gcc.o' -> elf64-x86-64
+; THR-EMPTY:
+; THR-NEXT: [001]           {CompileUnit} 'pr-46466.cpp'
+; THR-NEXT: [005]           {Enumerator} 'BLUE' = '0x1'
+; THR-NEXT: [005]           {Enumerator} 'RED' = '0x0'
+; THR-EMPTY:
+; THR-NEXT: -----------------------------
+; THR-NEXT: Element      Total    Printed
+; THR-NEXT: -----------------------------
+; THR-NEXT: Scopes           5          0
+; THR-NEXT: Symbols          0          0
+; THR-NEXT: Types            2          2
+; THR-NEXT: Lines            0          0
+; THR-NEXT: -----------------------------
+; THR-NEXT: Total            7          2

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/05-dwarf-incorrect-lexical-scope-variable.test

+; Test case 5 - Incorrect lexical scope variable.
+
+; pr-43860.cpp
+;  1  #include "definitions.h"
+;  2  forceinline int InlineFunction(int Param) {
+;  3    int Var_1 = Param;
+;  4    {
+;  5      int Var_2 = Param + Var_1;
+;  6      Var_1 = Var_2;
+;  7    }
+;  8    return Var_1;
+;  9  }
+; 10
+; 11  int test(int Param_1, int Param_2) {
+; 12    int A = Param_1;
+; 13    A += InlineFunction(Param_2);
+; 14    return A;
+; 15  }
+
+; The above test is used to illustrate a variable issue found in the
+; Clang compiler.
+; PR43860: https://bugs.llvm.org/show_bug.cgi?id=43860
+; PR43205: https://github.com/llvm/llvm-project/issues/43205
+
+; In the following logical views, we can see that the CodeView debug
+; information generated by the Clang compiler shows the variables
+; 'Var_1' and 'Var_2' are at the same lexical scope (4) in the function
+; 'InlineFuction'.
+; The DWARF generated by GCC/Clang and CodeView generated by MSVC, show
+; those variables at the correct lexical scope: '3' and '4' respectively.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format,producer \
+; RUN:                         --output-sort=name \
+; RUN:                         --print=symbols \
+; RUN:                         %p/Inputs/pr-43860-dwarf-clang.o \
+; RUN:                         %p/Inputs/pr-43860-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'pr-43860-dwarf-clang.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'pr-43860.cpp'
+; ONE-NEXT: [002]               {Producer} 'clang version 15.0.0 {{.*}}'
+; ONE-NEXT: [002]     2         {Function} extern not_inlined 'InlineFunction' -> 'int'
+; ONE-NEXT: [003]                 {Block}
+; ONE-NEXT: [004]     5             {Variable} 'Var_2' -> 'int'
+; ONE-NEXT: [003]     2           {Parameter} 'Param' -> 'int'
+; ONE-NEXT: [003]     3           {Variable} 'Var_1' -> 'int'
+; ONE-NEXT: [002]    11         {Function} extern not_inlined 'test' -> 'int'
+; ONE-NEXT: [003]    12           {Variable} 'A' -> 'int'
+; ONE-NEXT: [003]    14           {InlinedFunction} not_inlined 'InlineFunction' -> 'int'
+; ONE-NEXT: [004]                   {Block}
+; ONE-NEXT: [005]                     {Variable} 'Var_2' -> 'int'
+; ONE-NEXT: [004]                   {Parameter} 'Param' -> 'int'
+; ONE-NEXT: [004]                   {Variable} 'Var_1' -> 'int'
+; ONE-NEXT: [003]    11           {Parameter} 'Param_1' -> 'int'
+; ONE-NEXT: [003]    11           {Parameter} 'Param_2' -> 'int'
+; ONE-EMPTY:
+; ONE-NEXT: Logical View:
+; ONE-NEXT: [000]           {File} 'pr-43860-dwarf-gcc.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'pr-43860.cpp'
+; ONE-NEXT: [002]               {Producer} 'GNU C++14 10.3.0 {{.*}}'
+; ONE-NEXT: [002]     2         {Function} extern declared_inlined 'InlineFunction' -> 'int'
+; ONE-NEXT: [003]                 {Block}
+; ONE-NEXT: [004]     5             {Variable} 'Var_2' -> 'int'
+; ONE-NEXT: [003]     2           {Parameter} 'Param' -> 'int'
+; ONE-NEXT: [003]     3           {Variable} 'Var_1' -> 'int'
+; ONE-NEXT: [002]    11         {Function} extern not_inlined 'test' -> 'int'
+; ONE-NEXT: [003]    12           {Variable} 'A' -> 'int'
+; ONE-NEXT: [003]    13           {InlinedFunction} declared_inlined 'InlineFunction' -> 'int'
+; ONE-NEXT: [004]                   {Block}
+; ONE-NEXT: [005]                     {Variable} 'Var_2' -> 'int'
+; ONE-NEXT: [004]                   {Parameter} 'Param' -> 'int'
+; ONE-NEXT: [004]                   {Variable} 'Var_1' -> 'int'
+; ONE-NEXT: [003]    11           {Parameter} 'Param_1' -> 'int'
+; ONE-NEXT: [003]    11           {Parameter} 'Param_2' -> 'int'
+
+; Using the selection facilities, we can produce a simple tabular output
+; showing just the logical elements that have in their name the 'var'
+; pattern. The logical view is sorted by the variables name.
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format \
+; RUN:                         --output-sort=name \
+; RUN:                         --select-regex --select-nocase \
+; RUN:                         --select=Var \
+; RUN:                         --report=list \
+; RUN:                         --print=symbols \
+; RUN:                         %p/Inputs/pr-43860-*.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Logical View:
+; TWO-NEXT: [000]           {File} 'pr-43860-dwarf-clang.o' -> elf64-x86-64
+; TWO-EMPTY:
+; TWO-NEXT: [001]           {CompileUnit} 'pr-43860.cpp'
+; TWO-NEXT: [004]           {Variable} 'Var_1' -> 'int'
+; TWO-NEXT: [003]     3     {Variable} 'Var_1' -> 'int'
+; TWO-NEXT: [005]           {Variable} 'Var_2' -> 'int'
+; TWO-NEXT: [004]     5     {Variable} 'Var_2' -> 'int'
+; TWO-EMPTY:
+; TWO-NEXT: Logical View:
+; TWO-NEXT: [000]           {File} 'pr-43860-dwarf-gcc.o' -> elf64-x86-64
+; TWO-EMPTY:
+; TWO-NEXT: [001]           {CompileUnit} 'pr-43860.cpp'
+; TWO-NEXT: [004]           {Variable} 'Var_1' -> 'int'
+; TWO-NEXT: [003]     3     {Variable} 'Var_1' -> 'int'
+; TWO-NEXT: [005]           {Variable} 'Var_2' -> 'int'
+; TWO-NEXT: [004]     5     {Variable} 'Var_2' -> 'int'

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/06-dwarf-full-logical-view.test

+; Test case 6 - Full logical view
+
+; test.cpp
+;  1  using INTPTR = const int *;
+;  2  int foo(INTPTR ParamPtr, unsigned ParamUnsigned, bool ParamBool) {
+;  3    if (ParamBool) {
+;  4      typedef int INTEGER;
+;  5      const INTEGER CONSTANT = 7;
+;  6      return CONSTANT;
+;  7    }
+;  8    return ParamUnsigned;
+;  9  }
+
+; Print low level details.
+; The following command prints low level information that includes
+; offsets within the debug information section, debug location
+; operands, linkage names, etc.
+
+; RUN: llvm-debuginfo-analyzer --attribute=all \
+; RUN:                         --print=all \
+; RUN:                         %p/Inputs/test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [0x0000000000][000]            {File} '{{.*}}test-dwarf-clang.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [0x000000000b][001]              {CompileUnit} 'test.cpp'
+; ONE-NEXT: [0x000000000b][002]                {Producer} 'clang version 15.0.0 {{.*}}'
+; ONE-NEXT:                                    {Directory} '/data/projects/tests/input/general'
+; ONE-NEXT:                                    {File} 'test.cpp'
+; ONE-NEXT:                                    {Public} 'foo' [0x0000000000:0x000000003a]
+; ONE-NEXT: [0x000000000b][002]                {Range} Lines 2:9 [0x0000000000:0x000000003a]
+; ONE-NEXT: [0x00000000bc][002]                {BaseType} 'bool'
+; ONE-NEXT: [0x0000000099][002]                {BaseType} 'int'
+; ONE-NEXT: [0x00000000b5][002]                {BaseType} 'unsigned int'
+; ONE-EMPTY:
+; ONE-NEXT: [0x00000000a0][002]   {Source} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x00000000a0][002]      1         {TypeAlias} 'INTPTR' -> [0x00000000ab]'* const int'
+; ONE-NEXT: [0x000000002a][002]      2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int'
+; ONE-NEXT: [0x000000002a][003]                  {Range} Lines 2:9 [0x0000000000:0x000000003a]
+; ONE-NEXT: [0x000000002a][003]                  {Linkage}  0x2 '_Z3fooPKijb'
+; ONE-NEXT: [0x0000000071][003]                  {Block}
+; ONE-NEXT: [0x0000000071][004]                    {Range} Lines 5:8 [0x000000001c:0x000000002f]
+; ONE-NEXT: [0x000000007e][004]      5             {Variable} 'CONSTANT' -> [0x00000000c3]'const INTEGER'
+; ONE-NEXT: [0x000000007e][005]                      {Coverage} 100.00%
+; ONE-NEXT: [0x000000007f][005]                      {Location}
+; ONE-NEXT: [0x000000007f][006]                        {Entry} fbreg -28
+; ONE-NEXT: [0x000000001c][004]      5             {Line} {NewStatement} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x000000001c][004]                    {Code} 'movl  $0x7, -0x1c(%rbp)'
+; ONE-NEXT: [0x0000000023][004]      6             {Line} {NewStatement} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x0000000023][004]                    {Code} 'movl  $0x7, -0x4(%rbp)'
+; ONE-NEXT: [0x000000002a][004]                    {Code} 'jmp 0x6'
+; ONE-NEXT: [0x000000002f][004]      8             {Line} {NewStatement} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x000000002f][004]                    {Code} 'movl  -0x14(%rbp), %eax'
+; ONE-NEXT: [0x0000000063][003]      2           {Parameter} 'ParamBool' -> [0x00000000bc]'bool'
+; ONE-NEXT: [0x0000000063][004]                    {Coverage} 100.00%
+; ONE-NEXT: [0x0000000064][004]                    {Location}
+; ONE-NEXT: [0x0000000064][005]                      {Entry} fbreg -21
+; ONE-NEXT: [0x0000000047][003]      2           {Parameter} 'ParamPtr' -> [0x00000000a0]'INTPTR'
+; ONE-NEXT: [0x0000000047][004]                    {Coverage} 100.00%
+; ONE-NEXT: [0x0000000048][004]                    {Location}
+; ONE-NEXT: [0x0000000048][005]                      {Entry} fbreg -16
+; ONE-NEXT: [0x0000000055][003]      2           {Parameter} 'ParamUnsigned' -> [0x00000000b5]'unsigned int'
+; ONE-NEXT: [0x0000000055][004]                    {Coverage} 100.00%
+; ONE-NEXT: [0x0000000056][004]                    {Location}
+; ONE-NEXT: [0x0000000056][005]                      {Entry} fbreg -20
+; ONE-NEXT: [0x000000008d][003]      4           {TypeAlias} 'INTEGER' -> [0x0000000099]'int'
+; ONE-NEXT: [0x0000000000][003]      2           {Line} {NewStatement} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x0000000000][003]                  {Code} 'pushq %rbp'
+; ONE-NEXT: [0x0000000001][003]                  {Code} 'movq  %rsp, %rbp'
+; ONE-NEXT: [0x0000000004][003]                  {Code} 'movb  %dl, %al'
+; ONE-NEXT: [0x0000000006][003]                  {Code} 'movq  %rdi, -0x10(%rbp)'
+; ONE-NEXT: [0x000000000a][003]                  {Code} 'movl  %esi, -0x14(%rbp)'
+; ONE-NEXT: [0x000000000d][003]                  {Code} 'andb  $0x1, %al'
+; ONE-NEXT: [0x000000000f][003]                  {Code} 'movb  %al, -0x15(%rbp)'
+; ONE-NEXT: [0x0000000012][003]      3           {Line} {NewStatement} {PrologueEnd} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x0000000012][003]                  {Code} 'testb $0x1, -0x15(%rbp)'
+; ONE-NEXT: [0x0000000016][003]                  {Code} 'je  0x13'
+; ONE-NEXT: [0x0000000032][003]      8           {Line} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x0000000032][003]                  {Code} 'movl  %eax, -0x4(%rbp)'
+; ONE-NEXT: [0x0000000035][003]      9           {Line} {NewStatement} '/data/projects/tests/input/general/test.cpp'
+; ONE-NEXT: [0x0000000035][003]                  {Code} 'movl  -0x4(%rbp), %eax'
+; ONE-NEXT: [0x0000000038][003]                  {Code} 'popq  %rbp'
+; ONE-NEXT: [0x0000000039][003]                  {Code} 'retq'
+; ONE-NEXT: [0x000000003a][003]      9           {Line} {NewStatement} {EndSequence} '/data/projects/tests/input/general/test.cpp'
+; ONE-EMPTY:
+; ONE-NEXT: -----------------------------
+; ONE-NEXT: Element      Total    Printed
+; ONE-NEXT: -----------------------------
+; ONE-NEXT: Scopes           3          3
+; ONE-NEXT: Symbols          4          4
+; ONE-NEXT: Types            5          5
+; ONE-NEXT: Lines           25         25
+; ONE-NEXT: -----------------------------
+; ONE-NEXT: Total           37         37
+; ONE-EMPTY:
+; ONE-NEXT: Scope Sizes:
+; ONE-NEXT:        189 (100.00%) : [0x000000000b][001]              {CompileUnit} 'test.cpp'
+; ONE-NEXT:        110 ( 58.20%) : [0x000000002a][002]      2         {Function} extern not_inlined 'foo' -> [0x0000000099]'int'
+; ONE-NEXT:         27 ( 14.29%) : [0x0000000071][003]                  {Block}
+; ONE-EMPTY:
+; ONE-NEXT: Totals by lexical level:
+; ONE-NEXT: [001]:        189 (100.00%)
+; ONE-NEXT: [002]:        110 ( 58.20%)
+; ONE-NEXT: [003]:         27 ( 14.29%)

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/pr-57040-ignored-DW_FORM_implicit_const.test

+; Ignored attributes with DW_FORM_implicit_const.
+; https://github.com/llvm/llvm-project/issues/57040
+
+; Output generated by g++ (Debian 11.3.0-3) 11.3.0
+
+; .debug_abbrev contents:
+; [1] DW_TAG_formal_parameter     DW_CHILDREN_no
+;         DW_AT_decl_file DW_FORM_implicit_const  1
+;         DW_AT_decl_line DW_FORM_implicit_const  2
+
+; [2] DW_TAG_typedef      DW_CHILDREN_no
+;         DW_AT_decl_file DW_FORM_implicit_const  1
+;         DW_AT_decl_line DW_FORM_data1
+
+; Attributes with DW_FORM_implicit_const being ignored by the ELFReader,
+; causing {Parameter} and {TypeAlias} to omit line numbers.
+
+; test.cpp
+;  1  using INTPTR = const int *;
+;  2  int foo(INTPTR ParamPtr, unsigned ParamUnsigned, bool ParamBool) {
+;  3    if (ParamBool) {
+;  4      typedef int INTEGER;
+;  5      const INTEGER CONSTANT = 7;
+;  6      return CONSTANT;
+;  7    }
+;  8    return ParamUnsigned;
+;  9  }
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format,producer \
+; RUN:                         --print=scopes,symbols,types \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'pr-57040-test-dwarf-clang.o' -> elf64-x86-64
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'test.cpp'
+; ONE-NEXT: [002]               {Producer} 'clang version 14.0.6'
+; ONE-NEXT: [002]     1         {TypeAlias} 'INTPTR' -> '* const int'
+; ONE-NEXT: [002]     2         {Function} extern not_inlined 'foo' -> 'int'
+; ONE-NEXT: [003]                 {Block}
+; ONE-NEXT: [004]     5             {Variable} 'CONSTANT' -> 'const INTEGER'
+; ONE-NEXT: [003]     2           {Parameter} 'ParamBool' -> 'bool'
+; ONE-NEXT: [003]     2           {Parameter} 'ParamPtr' -> 'INTPTR'
+; ONE-NEXT: [003]     2           {Parameter} 'ParamUnsigned' -> 'unsigned int'
+; ONE-NEXT: [003]     4           {TypeAlias} 'INTEGER' -> 'int'
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,format,producer \
+; RUN:                         --print=scopes,symbols,types \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Logical View:
+; TWO-NEXT: [000]           {File} 'pr-57040-test-dwarf-gcc.o' -> elf64-x86-64
+; TWO-EMPTY:
+; TWO-NEXT: [001]             {CompileUnit} 'test.cpp'
+; TWO-NEXT: [002]               {Producer} 'GNU C++17 11.3.0 {{.*}}'
+; TWO-NEXT: [002]     1         {TypeAlias} 'INTPTR' -> '* const int'
+; TWO-NEXT: [002]     2         {Function} extern not_inlined 'foo' -> 'int'
+; TWO-NEXT: [003]                 {Block}
+; TWO-NEXT: [004]     4             {TypeAlias} 'INTEGER' -> 'int'
+; TWO-NEXT: [004]     5             {Variable} 'CONSTANT' -> 'const INTEGER'
+; TWO-NEXT: [003]     2           {Parameter} 'ParamBool' -> 'bool'
+; TWO-NEXT: [003]     2           {Parameter} 'ParamPtr' -> 'INTPTR'
+; TWO-NEXT: [003]     2           {Parameter} 'ParamUnsigned' -> 'unsigned int'

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/pr-57040-incorrect-function-compare.test

+; Incorrect function matching during comparison.
+; https://github.com/llvm/llvm-project/issues/57040
+
+; Output generated by g++ (Debian 11.3.0-3) 11.3.0
+
+; .debug_info contents:
+; format = DWARF32, version = 0x0005, unit_type = DW_UT_compile
+;
+; DW_TAG_compile_unit
+;   DW_TAG_subprogram ("foo")
+;     DW_AT_decl_file (1)
+;
+;     DW_TAG_formal_parameter ("ParamPtr")
+;       DW_AT_decl_file (1)
+;
+; .debug_line contents:
+; Line table prologue:
+;           format: DWARF32, version: 5
+; include_directories[0] = "/usr/local/google/home/aheejin/test/llvm-dva"
+; file_names[0]: name: "test.cpp" dir_index: 0
+; file_names[1]: name: "test.cpp" dir_index: 0
+
+; The values for DW_AT_decl_file are 1-indexed.
+
+; test.cpp
+;  1  using INTPTR = const int *;
+;  2  int foo(INTPTR ParamPtr, unsigned ParamUnsigned, bool ParamBool) {
+;  3    if (ParamBool) {
+;  4      typedef int INTEGER;
+;  5      const INTEGER CONSTANT = 7;
+;  6      return CONSTANT;
+;  7    }
+;  8    return ParamUnsigned;
+;  9  }
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,producer \
+; RUN:                         --compare=types \
+; RUN:                         --report=view \
+; RUN:                         --print=symbols,types \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-clang.o \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Reference: 'pr-57040-test-dwarf-clang.o'
+; ONE-NEXT: Target:    'pr-57040-test-dwarf-gcc.o'
+; ONE-EMPTY:
+; ONE-NEXT: Logical View:
+; ONE-NEXT:  [000]           {File} 'pr-57040-test-dwarf-clang.o'
+; ONE-EMPTY:
+; ONE-NEXT:  [001]             {CompileUnit} 'test.cpp'
+; ONE-NEXT:  [002]               {Producer} 'clang version 14.0.6'
+; ONE-NEXT:  [002]     1         {TypeAlias} 'INTPTR' -> '* const int'
+; ONE-NEXT:  [002]     2         {Function} extern not_inlined 'foo' -> 'int'
+; ONE-NEXT:  [003]                 {Block}
+; ONE-NEXT:  [004]     5             {Variable} 'CONSTANT' -> 'const INTEGER'
+; ONE-NEXT: +[004]     4             {TypeAlias} 'INTEGER' -> 'int'
+; ONE-NEXT:  [003]     2           {Parameter} 'ParamBool' -> 'bool'
+; ONE-NEXT:  [003]     2           {Parameter} 'ParamPtr' -> 'INTPTR'
+; ONE-NEXT:  [003]     2           {Parameter} 'ParamUnsigned' -> 'unsigned int'
+; ONE-NEXT: -[003]     4           {TypeAlias} 'INTEGER' -> 'int'
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --compare=types \
+; RUN:                         --report=list \
+; RUN:                         --print=symbols,types,summary \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-clang.o \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-gcc.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Reference: 'pr-57040-test-dwarf-clang.o'
+; TWO-NEXT: Target:    'pr-57040-test-dwarf-gcc.o'
+; TWO-EMPTY:
+; TWO-NEXT: (1) Missing Types:
+; TWO-NEXT: -[003]     4     {TypeAlias} 'INTEGER' -> 'int'
+; TWO-EMPTY:
+; TWO-NEXT: (1) Added Types:
+; TWO-NEXT: +[004]     4     {TypeAlias} 'INTEGER' -> 'int'
+; TWO-EMPTY:
+; TWO-NEXT: ----------------------------------------
+; TWO-NEXT: Element   Expected    Missing      Added
+; TWO-NEXT: ----------------------------------------
+; TWO-NEXT: Scopes           4          0          0
+; TWO-NEXT: Symbols          0          0          0
+; TWO-NEXT: Types            2          1          1
+; TWO-NEXT: Lines            0          0          0
+; TWO-NEXT: ----------------------------------------
+; TWO-NEXT: Total            6          1          1
+
+; Changing the 'Reference' and 'Target' order:
+
+; RUN: llvm-debuginfo-analyzer --attribute=level,producer \
+; RUN:                         --compare=types \
+; RUN:                         --report=view \
+; RUN:                         --print=symbols,types \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-gcc.o \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=THR %s
+
+; THR:      Reference: 'pr-57040-test-dwarf-gcc.o'
+; THR-NEXT: Target:    'pr-57040-test-dwarf-clang.o'
+; THR-EMPTY:
+; THR-NEXT: Logical View:
+; THR-NEXT:  [000]           {File} 'pr-57040-test-dwarf-gcc.o'
+; THR-EMPTY:
+; THR-NEXT:  [001]             {CompileUnit} 'test.cpp'
+; THR-NEXT:  [002]               {Producer} 'GNU C++17 11.3.0 {{.*}}'
+; THR-NEXT:  [002]     1         {TypeAlias} 'INTPTR' -> '* const int'
+; THR-NEXT:  [002]     2         {Function} extern not_inlined 'foo' -> 'int'
+; THR-NEXT:  [003]                 {Block}
+; THR-NEXT: -[004]     4             {TypeAlias} 'INTEGER' -> 'int'
+; THR-NEXT:  [004]     5             {Variable} 'CONSTANT' -> 'const INTEGER'
+; THR-NEXT:  [003]     2           {Parameter} 'ParamBool' -> 'bool'
+; THR-NEXT:  [003]     2           {Parameter} 'ParamPtr' -> 'INTPTR'
+; THR-NEXT:  [003]     2           {Parameter} 'ParamUnsigned' -> 'unsigned int'
+; THR-NEXT: +[003]     4           {TypeAlias} 'INTEGER' -> 'int'
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --compare=types \
+; RUN:                         --report=list \
+; RUN:                         --print=symbols,types,summary \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-gcc.o \
+; RUN:                         %p/Inputs/pr-57040-test-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=FOU %s
+
+; FOU:      Reference: 'pr-57040-test-dwarf-gcc.o'
+; FOU-NEXT: Target:    'pr-57040-test-dwarf-clang.o'
+; FOU-EMPTY:
+; FOU-NEXT: (1) Missing Types:
+; FOU-NEXT: -[004]     4     {TypeAlias} 'INTEGER' -> 'int'
+; FOU-EMPTY:
+; FOU-NEXT: (1) Added Types:
+; FOU-NEXT: +[003]     4     {TypeAlias} 'INTEGER' -> 'int'
+; FOU-EMPTY:
+; FOU-NEXT: ----------------------------------------
+; FOU-NEXT: Element   Expected    Missing      Added
+; FOU-NEXT: ----------------------------------------
+; FOU-NEXT: Scopes           4          0          0
+; FOU-NEXT: Symbols          0          0          0
+; FOU-NEXT: Types            2          1          1
+; FOU-NEXT: Lines            0          0          0
+; FOU-NEXT: ----------------------------------------
+; FOU-NEXT: Total            6          1          1

llvm/test/tools/llvm-debuginfo-analyzer/DWARF/pr-incorrect-logical-instructions.test

+; * Added incorrect logical instructions for: --print=lines,instructions
+;   'bar' and 'foo' showing extra instruction from compiler generated functions:
+;   '_cxx_global_var_init' and '_GLOBAL_sub_l_suite_lexical_01.cpp'
+;
+; * Missing logical instructions for: --print=instructions
+;   Only 'foo' showing logical instructions.
+
+; pr-incorrect-instructions-dwarf-clang.cpp
+;  1 int ABCDE = 56; int XYZ = ABCDE * 65;
+;  2 int bar(int Param) {
+;  3   return Param + 999999 * Param - 66;
+;  4 }
+;  5
+;  6 int foo(int Param) {
+;  7   return Param - bar(Param) / Param * 66 + ABCDE; 
+;  8 }
+;  9
+; 10 int test(int P1) {
+; 11  int Local_1 = P1 - ABCDE;
+; 12  {
+; 13    int Local_A = 0;
+; 14    Local_A = P1 + foo(Local_1);
+; 15    ++Local_1;
+; 16  }
+; 17  return Local_1;
+; 18 }
+; 19
+; 20 int main() {
+; 21  return 0;
+; 22 }
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --print=lines,instructions \
+; RUN:                         %p/Inputs/pr-incorrect-instructions-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=ONE %s
+
+; ONE:      Logical View:
+; ONE-NEXT: [000]           {File} 'pr-incorrect-instructions-dwarf-clang.o'
+; ONE-EMPTY:
+; ONE-NEXT: [001]             {CompileUnit} 'pr-incorrect-instructions-dwarf-clang.cpp'
+; ONE-NEXT: [002]     2         {Function} extern not_inlined 'bar' -> 'int'
+; ONE-NEXT: [003]     2           {Line}
+; ONE-NEXT: [003]                 {Code} 'pushq  %rbp'
+; ONE-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; ONE-NEXT: [003]                 {Code} 'movl %edi, -0x4(%rbp)'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %eax'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]                 {Code} 'imull  $0xf423f, -0x4(%rbp), %ecx'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]                 {Code} 'addl %ecx, %eax'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]                 {Code} 'subl $0x42, %eax'
+; ONE-NEXT: [003]     3           {Line}
+; ONE-NEXT: [003]                 {Code} 'popq %rbp'
+; ONE-NEXT: [003]                 {Code} 'retq'
+; ONE-NEXT: [002]     6         {Function} extern not_inlined 'foo' -> 'int'
+; ONE-NEXT: [003]     6           {Line}
+; ONE-NEXT: [003]                 {Code} 'pushq  %rbp'
+; ONE-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; ONE-NEXT: [003]                 {Code} 'subq $0x10, %rsp'
+; ONE-NEXT: [003]                 {Code} 'movl %edi, -0x4(%rbp)'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %eax'
+; ONE-NEXT: [003]                 {Code} 'movl %eax, -0x8(%rbp)'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %edi'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'callq  0x0'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'cltd'
+; ONE-NEXT: [003]                 {Code} 'idivl  -0x4(%rbp)'
+; ONE-NEXT: [003]                 {Code} 'movl %eax, %ecx'
+; ONE-NEXT: [003]                 {Code} 'movl -0x8(%rbp), %eax'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'imull  $0x42, %ecx, %ecx'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'subl %ecx, %eax'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'addl (%rip), %eax'
+; ONE-NEXT: [003]     7           {Line}
+; ONE-NEXT: [003]                 {Code} 'addq $0x10, %rsp'
+; ONE-NEXT: [003]                 {Code} 'popq %rbp'
+; ONE-NEXT: [003]                 {Code} 'retq'
+; ONE-NEXT: [003]                 {Code} 'data16'
+; ONE-NEXT: [002]    10         {Function} extern not_inlined 'test' -> 'int'
+; ONE-NEXT: [003]                 {Block}
+; ONE-NEXT: [004]    13             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl $0x0, -0xc(%rbp)'
+; ONE-NEXT: [004]    14             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl -0x4(%rbp), %eax'
+; ONE-NEXT: [004]                   {Code} 'movl %eax, -0x10(%rbp)'
+; ONE-NEXT: [004]    14             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl -0x8(%rbp), %edi'
+; ONE-NEXT: [004]    14             {Line}
+; ONE-NEXT: [004]                   {Code} 'callq  0x0'
+; ONE-NEXT: [004]                   {Code} 'movl %eax, %ecx'
+; ONE-NEXT: [004]                   {Code} 'movl -0x10(%rbp), %eax'
+; ONE-NEXT: [004]    14             {Line}
+; ONE-NEXT: [004]                   {Code} 'addl %ecx, %eax'
+; ONE-NEXT: [004]    14             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl %eax, -0xc(%rbp)'
+; ONE-NEXT: [004]    15             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl -0x8(%rbp), %eax'
+; ONE-NEXT: [004]                   {Code} 'addl $0x1, %eax'
+; ONE-NEXT: [004]                   {Code} 'movl %eax, -0x8(%rbp)'
+; ONE-NEXT: [004]    17             {Line}
+; ONE-NEXT: [004]                   {Code} 'movl -0x8(%rbp), %eax'
+; ONE-NEXT: [003]    10           {Line}
+; ONE-NEXT: [003]                 {Code} 'pushq  %rbp'
+; ONE-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; ONE-NEXT: [003]                 {Code} 'subq $0x10, %rsp'
+; ONE-NEXT: [003]                 {Code} 'movl %edi, -0x4(%rbp)'
+; ONE-NEXT: [003]    11           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %eax'
+; ONE-NEXT: [003]    11           {Line}
+; ONE-NEXT: [003]                 {Code} 'subl (%rip), %eax'
+; ONE-NEXT: [003]    11           {Line}
+; ONE-NEXT: [003]                 {Code} 'movl %eax, -0x8(%rbp)'
+; ONE-NEXT: [003]    17           {Line}
+; ONE-NEXT: [003]                 {Code} 'addq $0x10, %rsp'
+; ONE-NEXT: [003]                 {Code} 'popq %rbp'
+; ONE-NEXT: [003]                 {Code} 'retq'
+; ONE-NEXT: [002]    20         {Function} extern not_inlined 'main' -> 'int'
+; ONE-NEXT: [003]    20           {Line}
+; ONE-NEXT: [003]                 {Code} 'pushq  %rbp'
+; ONE-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; ONE-NEXT: [003]                 {Code} 'movl $0x0, -0x4(%rbp)'
+; ONE-NEXT: [003]    21           {Line}
+; ONE-NEXT: [003]                 {Code} 'xorl %eax, %eax'
+; ONE-NEXT: [003]                 {Code} 'popq %rbp'
+; ONE-NEXT: [003]                 {Code} 'retq'
+; ONE-NEXT: [003]    21           {Line}
+
+; RUN: llvm-debuginfo-analyzer --attribute=level \
+; RUN:                         --print=instructions \
+; RUN:                         %p/Inputs/pr-incorrect-instructions-dwarf-clang.o 2>&1 | \
+; RUN: FileCheck --strict-whitespace -check-prefix=TWO %s
+
+; TWO:      Logical View:
+; TWO-NEXT: [000]           {File} 'pr-incorrect-instructions-dwarf-clang.o'
+; TWO-EMPTY:
+; TWO-NEXT: [001]             {CompileUnit} 'pr-incorrect-instructions-dwarf-clang.cpp'
+; TWO-NEXT: [002]     2         {Function} extern not_inlined 'bar' -> 'int'
+; TWO-NEXT: [003]                 {Code} 'pushq  %rbp'
+; TWO-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; TWO-NEXT: [003]                 {Code} 'movl %edi, -0x4(%rbp)'
+; TWO-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %eax'
+; TWO-NEXT: [003]                 {Code} 'imull  $0xf423f, -0x4(%rbp), %ecx'
+; TWO-NEXT: [003]                 {Code} 'addl %ecx, %eax'
+; TWO-NEXT: [003]                 {Code} 'subl $0x42, %eax'
+; TWO-NEXT: [003]                 {Code} 'popq %rbp'
+; TWO-NEXT: [003]                 {Code} 'retq'
+; TWO-NEXT: [002]     6         {Function} extern not_inlined 'foo' -> 'int'
+; TWO-NEXT: [003]                 {Code} 'pushq  %rbp'
+; TWO-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; TWO-NEXT: [003]                 {Code} 'subq $0x10, %rsp'
+; TWO-NEXT: [003]                 {Code} 'movl %edi, -0x4(%rbp)'
+; TWO-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %eax'
+; TWO-NEXT: [003]                 {Code} 'movl %eax, -0x8(%rbp)'
+; TWO-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %edi'
+; TWO-NEXT: [003]                 {Code} 'callq  0x0'
+; TWO-NEXT: [003]                 {Code} 'cltd'
+; TWO-NEXT: [003]                 {Code} 'idivl  -0x4(%rbp)'
+; TWO-NEXT: [003]                 {Code} 'movl %eax, %ecx'
+; TWO-NEXT: [003]                 {Code} 'movl -0x8(%rbp), %eax'
+; TWO-NEXT: [003]                 {Code} 'imull  $0x42, %ecx, %ecx'
+; TWO-NEXT: [003]                 {Code} 'subl %ecx, %eax'
+; TWO-NEXT: [003]                 {Code} 'addl (%rip), %eax'
+; TWO-NEXT: [003]                 {Code} 'addq $0x10, %rsp'
+; TWO-NEXT: [003]                 {Code} 'popq %rbp'
+; TWO-NEXT: [003]                 {Code} 'retq'
+; TWO-NEXT: [003]                 {Code} 'data16'
+; TWO-NEXT: [002]    10         {Function} extern not_inlined 'test' -> 'int'
+; TWO-NEXT: [003]                 {Block}
+; TWO-NEXT: [004]                   {Code} 'movl $0x0, -0xc(%rbp)'
+; TWO-NEXT: [004]                   {Code} 'movl -0x4(%rbp), %eax'
+; TWO-NEXT: [004]                   {Code} 'movl %eax, -0x10(%rbp)'
+; TWO-NEXT: [004]                   {Code} 'movl -0x8(%rbp), %edi'
+; TWO-NEXT: [004]                   {Code} 'callq  0x0'
+; TWO-NEXT: [004]                   {Code} 'movl %eax, %ecx'
+; TWO-NEXT: [004]                   {Code} 'movl -0x10(%rbp), %eax'
+; TWO-NEXT: [004]                   {Code} 'addl %ecx, %eax'
+; TWO-NEXT: [004]                   {Code} 'movl %eax, -0xc(%rbp)'
+; TWO-NEXT: [004]                   {Code} 'movl -0x8(%rbp), %eax'
+; TWO-NEXT: [004]                   {Code} 'addl $0x1, %eax'
+; TWO-NEXT: [004]                   {Code} 'movl %eax, -0x8(%rbp)'
+; TWO-NEXT: [004]                   {Code} 'movl -0x8(%rbp), %eax'
+; TWO-NEXT: [003]                 {Code} 'pushq  %rbp'
+; TWO-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; TWO-NEXT: [003]                 {Code} 'subq $0x10, %rsp'
+; TWO-NEXT: [003]                 {Code} 'movl %edi, -0x4(%rbp)'
+; TWO-NEXT: [003]                 {Code} 'movl -0x4(%rbp), %eax'
+; TWO-NEXT: [003]                 {Code} 'subl (%rip), %eax'
+; TWO-NEXT: [003]                 {Code} 'movl %eax, -0x8(%rbp)'
+; TWO-NEXT: [003]                 {Code} 'addq $0x10, %rsp'
+; TWO-NEXT: [003]                 {Code} 'popq %rbp'
+; TWO-NEXT: [003]                 {Code} 'retq'
+; TWO-NEXT: [002]    20         {Function} extern not_inlined 'main' -> 'int'
+; TWO-NEXT: [003]                 {Code} 'pushq  %rbp'
+; TWO-NEXT: [003]                 {Code} 'movq %rsp, %rbp'
+; TWO-NEXT: [003]                 {Code} 'movl $0x0, -0x4(%rbp)'
+; TWO-NEXT: [003]                 {Code} 'xorl %eax, %eax'
+; TWO-NEXT: [003]                 {Code} 'popq %rbp'
+; TWO-NEXT: [003]                 {Code} 'retq'

llvm/tools/llvm-debuginfo-analyzer/llvm-debuginfo-analyzer.cpp

 //===-- llvm-debuginfo-analyzer.cpp - LLVM Debug info analysis utility ---===//
 //
 // 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 program is a utility that displays the logical view for the debug
 // information.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Options.h"
 #include "llvm/DebugInfo/LogicalView/Core/LVOptions.h"
-#include "llvm/Object/Archive.h"
+#include "llvm/DebugInfo/LogicalView/LVReaderHandler.h"
 #include "llvm/Support/COM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
-#include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
 using namespace logicalview;
 using namespace cmdline;
 
 /// Create formatted StringError object.
 static StringRef ToolName = "llvm-debuginfo-analyzer";
 template <typename... Ts>
 static void error(std::error_code EC, char const *Fmt, const Ts &...Vals) {
   if (!EC)
     return;
   std::string Buffer;
   raw_string_ostream Stream(Buffer);
   Stream << format(Fmt, Vals...);
   WithColor::error(errs(), ToolName) << Stream.str() << "\n";
   exit(1);
 }
 
+static void error(Error EC) {
+  if (!EC)
+    return;
+  handleAllErrors(std::move(EC), [&](const ErrorInfoBase &EI) {
+    errs() << "\n";
+    WithColor::error(errs(), ToolName) << EI.message() << ".\n";
+    exit(1);
+  });
+}
+
 /// If the input path is a .dSYM bundle (as created by the dsymutil tool),
 /// replace it with individual entries for each of the object files inside the
 /// bundle otherwise return the input path.
 static std::vector<std::string> expandBundle(const std::string &InputPath) {
   std::vector<std::string> BundlePaths;
   SmallString<256> BundlePath(InputPath);
   // Normalize input path. This is necessary to accept `bundle.dSYM/`.
   sys::path::remove_dots(BundlePath);
int main(int argc, char **argv) {
   std::vector<std::string> Objects;
   for (const std::string &Filename : InputFilenames) {
     std::vector<std::string> Objs = expandBundle(Filename);
     Objects.insert(Objects.end(), Objs.begin(), Objs.end());
   }
 
   propagateOptions();
   ScopedPrinter W(OutputFile.os());
+  LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
 
   // Print the command line.
   if (options().getInternalCmdline()) {
     raw_ostream &Stream = W.getOStream();
     Stream << "\nCommand line:\n";
     for (int Index = 0; Index < argc; ++Index)
       Stream << "  " << argv[Index] << "\n";
     Stream << "\n";
   }
 
+  // Create readers and perform requested tasks on them.
+  if (Error Err = ReaderHandler.process())
+    error(std::move(Err));
+
   return EXIT_SUCCESS;
 }

llvm/unittests/DebugInfo/LogicalView/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  AllTargetsDescs
+  AllTargetsInfos
+  AllTargetsDisassemblers
   DebugInfoLogicalView
+  MCDisassembler
   )
 
-add_llvm_unittest(DebugInfoLogicalViewTests
+add_llvm_unittest_with_input_files(DebugInfoLogicalViewTests
   CommandLineOptionsTest.cpp
   CompareElementsTest.cpp
+  ELFReaderTest.cpp
   SelectElementsTest.cpp
   LocationRangesTest.cpp
   LogicalElementsTest.cpp
   StringPoolTest.cpp
   WarningInternalTest.cpp
   )
 
 target_link_libraries(DebugInfoLogicalViewTests PRIVATE LLVMTestingSupport)

llvm/unittests/DebugInfo/LogicalView/ELFReaderTest.cpp

+//===- llvm/unittest/DebugInfo/LogicalView/ELFReaderTest.cpp --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/LogicalView/Core/LVCompare.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVLine.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVScope.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVSymbol.h"
+#include "llvm/DebugInfo/LogicalView/Core/LVType.h"
+#include "llvm/DebugInfo/LogicalView/LVReaderHandler.h"
+#include "llvm/Support/COM.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Testing/Support/Error.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::logicalview;
+
+extern const char *TestMainArgv0;
+
+namespace {
+
+const char *DwarfClang = "test-dwarf-clang.o";
+const char *DwarfGcc = "test-dwarf-gcc.o";
+
+// Helper function to get the first compile unit.
+LVScopeCompileUnit *getFirstCompileUnit(LVScopeRoot *Root) {
+  EXPECT_NE(Root, nullptr);
+  const LVScopes *CompileUnits = Root->getScopes();
+  EXPECT_NE(CompileUnits, nullptr);
+  EXPECT_EQ(CompileUnits->size(), 1);
+
+  LVScopes::const_iterator Iter = CompileUnits->begin();
+  EXPECT_NE(Iter, nullptr);
+  LVScopeCompileUnit *CompileUnit = static_cast<LVScopeCompileUnit *>(*Iter);
+  EXPECT_NE(CompileUnit, nullptr);
+  return CompileUnit;
+}
+
+// Helper function to create a reader.
+LVReader *createReader(LVReaderHandler &ReaderHandler,
+                       SmallString<128> &InputsDir, StringRef Filename) {
+  SmallString<128> ObjectName(InputsDir);
+  llvm::sys::path::append(ObjectName, Filename);
+
+  Expected<LVReader *> ReaderOrErr =
+      ReaderHandler.createReader(std::string(ObjectName));
+  EXPECT_THAT_EXPECTED(ReaderOrErr, Succeeded());
+  LVReader *Reader = *ReaderOrErr;
+  EXPECT_NE(Reader, nullptr);
+  return Reader;
+}
+
+// Check the logical elements basic properties.
+void checkElementProperties(LVReader *Reader) {
+  LVScopeRoot *Root = Reader->getScopesRoot();
+  LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);
+
+  EXPECT_EQ(Root->getFileFormatName(), "elf64-x86-64");
+  EXPECT_EQ(Root->getName(), DwarfClang);
+
+  EXPECT_EQ(CompileUnit->getBaseAddress(), 0);
+  EXPECT_TRUE(CompileUnit->getProducer().startswith("clang"));
+  EXPECT_EQ(CompileUnit->getName(), "test.cpp");
+
+  EXPECT_EQ(CompileUnit->lineCount(), 0);
+  EXPECT_EQ(CompileUnit->scopeCount(), 1);
+  EXPECT_EQ(CompileUnit->symbolCount(), 0);
+  EXPECT_EQ(CompileUnit->typeCount(), 7);
+  EXPECT_EQ(CompileUnit->rangeCount(), 1);
+
+  const LVLocations *Ranges = CompileUnit->getRanges();
+  EXPECT_NE(Ranges, nullptr);
+  ASSERT_EQ(Ranges->size(), 1);
+  LVLocations::const_iterator IterLocation = Ranges->begin();
+  LVLocation *Location = (*IterLocation);
+  EXPECT_STREQ(Location->getIntervalInfo().c_str(),
+               "{Range} Lines 2:9 [0x0000000000:0x000000003a]");
+
+  LVRange RangeList;
+  CompileUnit->getRanges(RangeList);
+
+  const LVRangeEntries &RangeEntries = RangeList.getEntries();
+  ASSERT_EQ(RangeEntries.size(), 2);
+  LVRangeEntries::const_iterator IterRanges = RangeEntries.cbegin();
+  LVRangeEntry RangeEntry = *IterRanges;
+  EXPECT_EQ(RangeEntry.lower(), 0);
+  EXPECT_EQ(RangeEntry.upper(), 0x3a);
+  EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0);
+  EXPECT_EQ(RangeEntry.scope()->getName(), "test.cpp");
+  EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x0b);
+
+  ++IterRanges;
+  RangeEntry = *IterRanges;
+  EXPECT_EQ(RangeEntry.lower(), 0x1c);
+  EXPECT_EQ(RangeEntry.upper(), 0x2f);
+  EXPECT_EQ(RangeEntry.scope()->getLineNumber(), 0);
+  EXPECT_EQ(RangeEntry.scope()->getName(), "foo::?");
+  EXPECT_EQ(RangeEntry.scope()->getOffset(), 0x71);
+
+  const LVPublicNames &PublicNames = CompileUnit->getPublicNames();
+  ASSERT_EQ(PublicNames.size(), 1);
+  LVPublicNames::const_iterator IterNames = PublicNames.cbegin();
+  LVScope *Function = (*IterNames).first;
+  EXPECT_EQ(Function->getName(), "foo");
+  EXPECT_EQ(Function->getLineNumber(), 2);
+  LVNameInfo NameInfo = (*IterNames).second;
+  EXPECT_EQ(NameInfo.first, 0);
+  EXPECT_EQ(NameInfo.second, 0x3a);
+
+  // Lines (debug and assembler) for 'foo'.
+  const LVLines *Lines = Function->getLines();
+  EXPECT_NE(Lines, nullptr);
+  ASSERT_EQ(Lines->size(), 0x12);
+}
+
+// Check the logical elements selection.
+void checkElementSelection(LVReader *Reader) {
+  LVScopeRoot *Root = Reader->getScopesRoot();
+  LVScopeCompileUnit *CompileUnit = getFirstCompileUnit(Root);
+
+  // Get the matched elements.
+  LVElements MatchedElements = CompileUnit->getMatchedElements();
+  std::map<LVOffset, LVElement *> MapElements;
+  for (LVElement *Element : MatchedElements)
+    MapElements[Element->getOffset()] = Element;
+  ASSERT_EQ(MapElements.size(), 0xe);
+
+  LVElement *Element = MapElements[0x000000004b]; // 'foo'
+  EXPECT_NE(Element, nullptr);
+  EXPECT_NE(Element->getName().find("foo"), StringRef::npos);
+  EXPECT_EQ(Element->getIsScope(), 1);
+
+  Element = MapElements[0x00000000c0]; // 'CONSTANT'
+  EXPECT_NE(Element, nullptr);
+  EXPECT_NE(Element->getName().find("CONSTANT"), StringRef::npos);
+  EXPECT_EQ(Element->getIsSymbol(), 1);
+
+  Element = MapElements[0x000000002d]; // 'INTPTR'
+  EXPECT_NE(Element, nullptr);
+  EXPECT_NE(Element->getName().find("INTPTR"), StringRef::npos);
+  EXPECT_EQ(Element->getIsType(), 1);
+
+  Element = MapElements[0x00000000af]; // 'INTEGER'
+  EXPECT_NE(Element, nullptr);
+  EXPECT_NE(Element->getName().find("INTEGER"), StringRef::npos);
+  EXPECT_EQ(Element->getIsType(), 1);
+
+  Element = MapElements[0x000000000f]; // 'movl %edx, %eax'
+  EXPECT_NE(Element, nullptr);
+  EXPECT_NE(Element->getName().find("movl"), StringRef::npos);
+  EXPECT_EQ(Element->getIsLine(), 1);
+
+  // Get the parents for the matched elements.
+  LVScopes MatchedScopes = CompileUnit->getMatchedScopes();
+  std::set<LVOffset> SetScopes;
+  for (LVScope *Scope : MatchedScopes)
+    SetScopes.insert(Scope->getOffset());
+  std::set<LVOffset>::iterator Iter;
+  ASSERT_EQ(SetScopes.size(), 3);
+
+  Iter = SetScopes.find(0x000000000b); // CompileUnit <- 'foo'
+  EXPECT_NE(Iter, SetScopes.end());
+  Iter = SetScopes.find(0x000000009e); // Function <- 'movl  %edx, %eax'
+  EXPECT_NE(Iter, SetScopes.end());
+  Iter = SetScopes.find(0x000000009e); // LexicalScope <- 'INTEGER'
+  EXPECT_NE(Iter, SetScopes.end());
+}
+
+// Check the logical elements comparison.
+void checkElementComparison(LVReader *Reference, LVReader *Target) {
+  LVCompare Compare(nulls());
+  Error Err = Compare.execute(Reference, Target);
+  ASSERT_THAT_ERROR(std::move(Err), Succeeded());
+
+  // Get comparison table.
+  LVPassTable PassTable = Compare.getPassTable();
+  ASSERT_EQ(PassTable.size(), 5);
+
+  LVReader *Reader;
+  LVElement *Element;
+  LVComparePass Pass;
+
+  // Reference: Missing Variable 'CONSTANT'
+  std::tie(Reader, Element, Pass) = PassTable[0];
+  EXPECT_NE(Reader, nullptr);
+  EXPECT_NE(Element, nullptr);
+  EXPECT_EQ(Reader, Reference);
+  EXPECT_EQ(Element->getLevel(), 4);
+  EXPECT_EQ(Element->getLineNumber(), 5);
+  EXPECT_EQ(Element->getName(), "CONSTANT");
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Reference: Missing TypeDefinition 'INTEGER'
+  std::tie(Reader, Element, Pass) = PassTable[1];
+  EXPECT_NE(Reader, nullptr);
+  EXPECT_NE(Element, nullptr);
+  EXPECT_EQ(Reader, Reference);
+  EXPECT_EQ(Element->getLevel(), 3);
+  EXPECT_EQ(Element->getLineNumber(), 4);
+  EXPECT_EQ(Element->getName(), "INTEGER");
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Reference: Missing DebugLine
+  std::tie(Reader, Element, Pass) = PassTable[2];
+  EXPECT_NE(Reader, nullptr);
+  EXPECT_NE(Element, nullptr);
+  EXPECT_EQ(Reader, Reference);
+  EXPECT_EQ(Element->getLevel(), 3);
+  EXPECT_EQ(Element->getLineNumber(), 8);
+  EXPECT_EQ(Element->getName(), "");
+  EXPECT_EQ(Pass, LVComparePass::Missing);
+
+  // Target: Added Variable 'CONSTANT'
+  std::tie(Reader, Element, Pass) = PassTable[3];
+  EXPECT_NE(Reader, nullptr);
+  EXPECT_NE(Element, nullptr);
+  EXPECT_EQ(Reader, Target);
+  EXPECT_EQ(Element->getLevel(), 4);
+  EXPECT_EQ(Element->getLineNumber(), 5);
+  EXPECT_EQ(Element->getName(), "CONSTANT");
+  EXPECT_EQ(Pass, LVComparePass::Added);
+
+  // Target: Added TypeDefinition 'INTEGER'
+  std::tie(Reader, Element, Pass) = PassTable[4];
+  EXPECT_NE(Reader, nullptr);
+  EXPECT_NE(Element, nullptr);
+  EXPECT_EQ(Reader, Target);
+  EXPECT_EQ(Element->getLevel(), 4);
+  EXPECT_EQ(Element->getLineNumber(), 4);
+  EXPECT_EQ(Element->getName(), "INTEGER");
+  EXPECT_EQ(Pass, LVComparePass::Added);
+}
+
+// Logical elements properties.
+void elementProperties(SmallString<128> &InputsDir) {
+  // Reader options.
+  LVOptions ReaderOptions;
+  ReaderOptions.setAttributeOffset();
+  ReaderOptions.setAttributeFormat();
+  ReaderOptions.setAttributeFilename();
+  ReaderOptions.setAttributeProducer();
+  ReaderOptions.setAttributePublics();
+  ReaderOptions.setAttributeRange();
+  ReaderOptions.setAttributeLocation();
+  ReaderOptions.setPrintAll();
+  ReaderOptions.resolveDependencies();
+
+  std::vector<std::string> Objects;
+  ScopedPrinter W(outs());
+  LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
+
+  // Check logical elements properties.
+  LVReader *Reader = createReader(ReaderHandler, InputsDir, DwarfClang);
+  checkElementProperties(Reader);
+  ReaderHandler.deleteReader(Reader);
+}
+
+// Logical elements selection.
+void elementSelection(SmallString<128> &InputsDir) {
+  // Reader options.
+  LVOptions ReaderOptions;
+  ReaderOptions.setAttributeOffset();
+  ReaderOptions.setPrintAll();
+
+  ReaderOptions.setSelectIgnoreCase();
+  ReaderOptions.setSelectUseRegex();
+
+  ReaderOptions.setReportList(); // Matched elements.
+  ReaderOptions.setReportView(); // Parents for matched elements.
+
+  // Add patterns.
+  ReaderOptions.Select.Generic.insert("foo");
+  ReaderOptions.Select.Generic.insert("movl[ \t]?%");
+  ReaderOptions.Select.Generic.insert("INT[a-z]*");
+  ReaderOptions.Select.Generic.insert("CONSTANT");
+
+  ReaderOptions.resolveDependencies();
+
+  std::vector<std::string> Objects;
+  ScopedPrinter W(outs());
+  LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
+
+  // Check logical elements selection.
+  LVReader *Reader = createReader(ReaderHandler, InputsDir, DwarfGcc);
+  checkElementSelection(Reader);
+  ReaderHandler.deleteReader(Reader);
+}
+
+// Compare logical elements.
+void compareElements(SmallString<128> &InputsDir) {
+  // Reader options.
+  LVOptions ReaderOptions;
+  ReaderOptions.setAttributeOffset();
+  ReaderOptions.setPrintLines();
+  ReaderOptions.setPrintSymbols();
+  ReaderOptions.setPrintTypes();
+  ReaderOptions.setCompareLines();
+  ReaderOptions.setCompareSymbols();
+  ReaderOptions.setCompareTypes();
+
+  ReaderOptions.resolveDependencies();
+
+  std::vector<std::string> Objects;
+  ScopedPrinter W(outs());
+  LVReaderHandler ReaderHandler(Objects, W, ReaderOptions);
+
+  // Check logical comparison.
+  LVReader *Reference = createReader(ReaderHandler, InputsDir, DwarfClang);
+  LVReader *Target = createReader(ReaderHandler, InputsDir, DwarfGcc);
+  checkElementComparison(Reference, Target);
+  ReaderHandler.deleteReader(Reference);
+  ReaderHandler.deleteReader(Target);
+}
+
+TEST(LogicalViewTest, ELFReader) {
+  // Initialize targets and assembly printers/parsers.
+  llvm::InitializeAllTargetInfos();
+  llvm::InitializeAllTargetMCs();
+  InitializeAllDisassemblers();
+
+  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
+
+  SmallString<128> InputsDir = unittest::getInputFileDirectory(TestMainArgv0);
+
+  // Logical elements general properties and selection.
+  elementProperties(InputsDir);
+  elementSelection(InputsDir);
+
+  // Compare logical elements.
+  compareElements(InputsDir);
+}
+
+} // namespace