[llvm-dwarfdump] --show-sources option to show all sources

[mysterymath]

Summary

This option allows printing all sources used by an object file.

[phosek]

While this information can be extracted out of the existing llvm-dwarfdump output, it requires additional post-processing. This became so common in our project that we have implemented a custom Go-based tool for that purpose, but that has other downsides such as the lack of DWARF5 support. I think that supporting this option directly in llvm-dwarfdump might be generally useful and it doesn't add a lot of complexity. I'm open to suggestions for how to improve the output.

[dblaikie]

Sounds alright - few things could be simplified, etc.

llvm/test/tools/llvm-dwarfdump/X86/sources.s

12–58 ↗

(On Diff #291746)

Maybe simplify the functions (to something like simple void/do-nothing functions) to reduce the length of the assembly, no need for types.

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

485

Could use std::move(FullPath) here, if you like, but hardly critical.

488

Could use llvm::sort here

[jhenderson]

Please add the new option to the Command Guide documentation.

llvm/test/tools/llvm-dwarfdump/X86/sources.s

8 ↗

(On Diff #291833)

You can probably dramatically simplify this code by changing to use yaml2obj. I believe that ELF yaml2obj DWARF support is sufficiently powerful now to achieve this. @Higuoxing may be able to provide more information on this, as he did the work recently there. See also llvm/test/tools/yaml2obj/ELF/DWARF/debug-line.yaml for an example input.

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

I think we need testing for multiple CUs. The current test only checks a single one. This might go against the yaml2obj usage suggested above though (@Higuoxing, is there support for multiple tables in .debug_line yet?).

479

Not that it likely is going to matter in any practical situation, but this should probably be uint64_t technically - the FileNames are set via LEB128 values (see e.g. DW_LNS_set_file) and thus technically have no upper bound in size from the file format. I won't fight too hard for this if you don't want to though.

490

768

Not related to this patch, or even something you should do yourself. More idle musing - as llvm-dwarfdump starts gaining moreof these options, it feels like it should be able to do multiple at once (e.g. allow llvm-dwarfdump --show-sources --show-section-sizes).

[Higuoxing]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

is there support for multiple tables in .debug_line yet?

Yes, yaml2obj supports emitting multiple line tables. I'm able to help craft these test cases.

---

It looks that LT isn't checked. If a compilation unit doesn't have an associated line table, llvm-dwarfdump --show-sources will crash.

const auto *LT = DICtx.getLineTableForUnit(CU.get()); // Can be a null pointer.
for (uint32_t I = 1; I <= LT->Prologue.FileNames.size(); ++I) {
                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  ...
}

We can reproduce it using the following test case.

$ yaml2obj %s | llvm-dwarfdump --show-sources -

--- !ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_EXEC
  Machine: EM_X86_64
DWARF:
  debug_info:
    - Version: 4

[jhenderson]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

Nice catch! In fact, do we really need to use the CUs at all for this? Could we not just iterate over all line tables? That would allow this to work when there is no .debug_info data too (which the DWARF spec implies is permitted).

[probinson]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

I don't know how carefully the spec says it is permitted, but certainly I've heard committee members talk about stripping everything but .debug_line (and with v5, .debug_line_str) from an object file.

In DWARF v4, technically the primary source file & compilation dir could be omitted from the line table, although in practice I think that never happens. In v5 the primary source file & dir are supposed to be explicit in the line table, so I think ignoring .debug_info ought to be okay in general.

[phosek]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

@jhenderson is there an API to iterate over all line tables? I searched through LLVM but haven't found anything.

[jhenderson]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

I thought there was, but having taking a look, I don't know of an interface that allows you to simply iterate over all line tables without parsing all of them.

Certainly you can iterate over all the line tables by parsing them in order by using the SectionParser class of DWARFDebugLine.h. I'm not sure if that's exactly the right way forward here though, since I suspect by this point the DWARFContext may have already done (some of) the parsing (I haven't dug into the code to confirm either way).

There's also getOrParseLineTable, which takes an offset, Context and DWARFDataExtractor and gives you back the line table at that offset, which may or may not have already been parsed (it will return the cached version if it has been). You'd need to then use the length field within the line table to identify the next offset to use. Maybe a new function could sit on top of that to give you the ability to iterate over them, and only parse the ones that haven't been already? Alternatively, you could modify the SectionParser class to cache the parsed line tables so that it doesn't matter if you try to reparse them later.

[Higuoxing]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

I think you are able to iterate over line tables via the following code snippets.

DWARFDataExtractor LineData(DICtx.getDWARFObj(),
                            DICtx.getDWARFObj().getLineSection(),
                            DICtx.isLittleEndian(), 0);
DWARFDebugLine::SectionParser Parser(LineData, DICtx,
                                     DICtx.normal_units());
while (!Parser.done()) {
  DWARFDebugLine::LineTable LT = Parser.parseNext(
    RecoverableErrorHandler,
    UnrecoverableErrorHandler);
  // Dump file names with paths.
  ...
}

479

I'm not sure if the for-loop should start from 0. The DWARFv5 spec says:

In DWARF Version 5, the current compilation file name is explicitly present and has index 0.

[phosek]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

Thanks, I tried that which made me realize that without CU, we don't have the comp_dir, is that something we care about?

[Higuoxing]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

I have no idea. Perhaps @jhenderson and @dblaikie can help us?

[jhenderson]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

Ah, that's a good point. I think having the compilation directory is useful, but perhaps not a deal breaker. In other words, if it would be clean to do, I'd think the behaviour could be:

1. If .debug_line only is present, print just the names assuming some reasonable assumption about the compilation dir (e.g. the working directory/empty string/"." etc).
2. If both are present, use the one specified in the CU.

I'm very much open to other thoughts though. I feel like this option could be useful without .debug_info being present, but I don't know how much of a common case that actually is.

[dblaikie]

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

478

The question is how to iterate over line tables (rather than over CUs and retrieving their line tables)? But you don't want all the parsed data, just the file and line tables?

Yeah, looks like the nearest tool available is DWARFDebugLine::SectionParser but, as noted it does seem to do all the parsing up-front. I wouldn't be averse to/would generally encourage refactorings that make APIs like this lazier - parses maybe just a bit of the line table header, then returns - then you can query it for files, directories, and line table entries as desired. Those queries can fail, of course (since parsing hasn't been done up-front), so the query APIs should reflect that possibility.

Such refactoring can/should be done separately, with new test cases added - perhaps using unit tests, where, say, a line table with a valid directory list exists, but with invalid data after that - by lazy parsing, it should be possible to query just the directory table without ever reaching the invalid data/getting any errors. Similarly - the ability to minimal-parse one line table and jump to the next one immediately - skipping over some invalidity in the first line table without errors because it's never queried in detail, etc.

I made some fixes along these lines to loclist and rnglist parsing in the last week or so for a variety of reasons, for instance.

[mysterymath]

Taking over this change from phosek, upon request.

Updated implementation to slurp all available path information from CU
filename, CU include dir, and debug line info.

Pull from file index 0 if valid, otherwise start at 1.

Updated tests to use yaml2obj.

[jhenderson]

I think your test cases need extending with multiple source names per input, and also what happens if you specify multiple input files (I believe llvm-dwarfdump handles that, but I might be mistaken).

This new option still needs adding to the CommandGuide documentation at llvm/docs/CommandGuide/llvm-dwarfdump.rst.

llvm/test/tools/llvm-dwarfdump/X86/sources.test

2–4

Up to you, but I have a personal preference for this formatting, as it indicates on each line that there is a continuation involved, starting with a new command.

Also, I personally prefer it if tests create objects on disk rather than passing them via stdin. This is because it's easier to directly inspect the binary if there's a problem with the test. Otherwise, you have to (temporarily) modify the test to force it to dump it.

Same comments apply elsewhere.

6

You could simplify this an similar patterns by dropping "CHECK" from the prefix name.

This will also match "foobarname.csnfdssfnfjds" which probably isn't the intent. I think as you're testing a new dumping option, you should add the following options to the FileCheck command (also applies below):

--match-full-lines
--implicit-check-not={{.}}

The former effectively wraps the check pattern with {{^}} and {{$}}. If there's any whitespace involved, you can also add --strict-whitespace although I don't think there is here? The second option ensures that only the checked output is emitted and nothing else at all. This ensures there's no output before or after the checked pattern on different lines.

32

If you are expecting no output, I'd use count 0 instead of FileCheck here as it's stricter. Should this case print a warning though?

93

This is a good example of something that will pass spuriously without --match-full-lines, since comp/dir/abs/name.c will be successfully matched by it.

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

482–483

I'm not sure I see testing that exercises both sides of each of the two ternaries in this loop.

491–493

I don't believe that there's a test case for the case where an absolute path hasn't been produced?

503

Don't use auto unless the type is obvious from the immediate context (e.g. it's already specified on the line due to a case): https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable

506–507

This last part of the sentence is garbled.

508

Too much auto.

515

The statement isn't correct though: filenames are included in the DWARF line table v4 and earlier... (although not explicitly the compilation directory).

528–529

I'm not convinced that the bit in parentheses is correct, based on the earlier conversation in this review. I don't think it's particularly useful information either.

536

You need a test case to show that this is set by parsing failures in the line table.

552

Too much auto and unnecessary "const &" (StringRef is designed to be trivially copyable).

[mysterymath]

Address review comments.

[mysterymath]

Apologies for the long delay; this change slipped my mind for a bit.

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

491–493

Removed the check here; this was to avoid mixing relative and absolute paths from the CU and line table. But, now that we either get all names from the line table or just the name from the CU, this is no longer an issue.

503

This appears to be one of the cases mentioned as an exception: where the underlying type is abstracted away.

I did a quick scan though usages of DICtx.compile_units(); all but two use (const auto &CU).
The two exceptions use (const std::unique_ptr<DwarfUnit> &CU), but given the context, it seems like the correct type should be DWARFUnitVector::UnitVector::const_reference.

506–507

Fixed; sorry about that.

515

You're right; this simplifies things quite a bit. I've changed this to only add the name if the linetable is missing; otherwise we can get everything from the linetable.

[jhenderson]

llvm/docs/CommandGuide/llvm-dwarfdump.rst

123–126

Options should be in alphabetical order, so this needs moving above --statistics.

llvm/test/tools/llvm-dwarfdump/X86/sources.test

2–4

You missed the space indentation I included in my suggested edit.

8

Should this be CU-NAME-NEXT:?

47–51

1. According to the LLVM style guide, errors and warnings shouldn't have a trailing full stop.
2. I'm assuming that the {{.*}} is the file name? If so, you can leverage the FileCheck -D option to check it explicitly:

# RUN: FileCheck -DFILE=%t.comp-dir.err ...
# CU-COMP-DIR: warning: [[FILE]]: ...

88–90

For FileCheck commands, it's fine to pipe stdin directly to the command, rather than going via an intermediate file.

135

You can leverage yaml2obj's -D option much in the same manner as the FileCheck one above to avoid the need for two (or more) near-identical blocks of YAML, e.g. to provide the file names in posix and windows formats. There may well be other cases within your tests that are similar.

400–401

Similar to the above comment about piping, pipe the output directly to count here.

In general, the rule I follow is: is the output a binary file or similar? If so, stick it in a file. Otherwise, pipe it.

421

Check the error message.

[mysterymath]

Address review comments.

llvm/test/tools/llvm-dwarfdump/X86/sources.test

2–4

Not sure what you mean here; I'm seeing three space indentation from the colon in RUN: in both the code and your suggested edit.

[jhenderson]

llvm/test/tools/llvm-dwarfdump/X86/sources.test

2–4

Sorry misread the test before (I thought FileCheck was still being passed input by pipe, which it wasn't in that iteration). Latest bit looks good.

349

Usually when we're just checking an error or warning message, we use 2>&1 to combine stderr and stdout, rather than checking the two separately. This is especially relevant here, because you do the --implicit-check-not check.

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

482–483

Did this get addressed (it might have done, but I don't have time to dig into the test coverage)?

[mysterymath]

Add dwarfv5 test and use 2>&1 for error checking.

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

482–483

The second ternary is covered by the %t.no-filenames.o test, but it looks like I missed the first one when I was picking this patch back up.

The alternative case of the first ternary can only be triggered in DWARFv5, but it looks like yaml2obj doesn't fully support it for line tables yet. I've added a test through using a compiled object file for this case, with a TODO to use yaml2obj.

[jhenderson]

LGTM

[mysterymath]

Accomodate Windows path separators in test.

llvm/docs/CommandGuide/llvm-dwarfdump.rst

.. option:: -r <N>, --recurse-depth=<N>
 
             When displaying debug info entries, only show children to a maximum
             depth of <N>.
 
 .. option:: --show-section-sizes
 
             Show the sizes of all debug sections, expressed in bytes.
 
+.. option:: --show-sources
+
+            Print all source files mentioned in the debug information. Absolute
+            paths are given whenever possible.
+
 .. option:: --statistics
 
             Collect debug info quality metrics and print the results
             as machine-readable single-line JSON output. The output
             format is described in the section below (:ref:`stats-format`).
 
 .. option:: --summarize-types
 
             Abbreviate the description of type unit entries.
 
 .. option:: -x, --regex
 
             Treat any <name> strings as regular expressions when searching
             with :option:`--name`. If :option:`--ignore-case` is also specified,
             the regular expression becomes case-insensitive.
 
 .. option:: -u, --uuid
 

llvm/test/tools/llvm-dwarfdump/X86/sources.test

+# RUN: yaml2obj --docnum=1 %s -o %t.name.o
+# RUN: llvm-dwarfdump --show-sources %t.name.o | \
+# RUN:   FileCheck --check-prefix=CU-NAME --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# CU-NAME:      first.c
+# CU-NAME-NEXT: second.c
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+  debug_info:
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr: first.c
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr: second.c
+
+# RUN: yaml2obj --docnum=2 %s -o %t.comp-dir.o
+# RUN: llvm-dwarfdump --show-sources %t.comp-dir.o 2>&1 | \
+# RUN:   FileCheck -DFILE=%t.comp-dir.o --check-prefix=CU-COMP-DIR \
+# RUN:     --match-full-lines --implicit-check-not={{.}} %s
+
+# CU-COMP-DIR:      warning: [[FILE]]: missing name for compilation unit
+# CU-COMP-DIR-NEXT: warning: [[FILE]]: missing name for compilation unit
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_comp_dir
+            Form:      DW_FORM_string
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_comp_dir
+            Form:      DW_FORM_string
+  debug_info:
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr: /comp/first
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr: /comp/second
+
+# RUN: yaml2obj --docnum=3 \
+# RUN:   -DFIRST_NAME=first.c -DFIRST_COMP_DIR=/comp/first \
+# RUN:   -DSECOND_NAME=second.c -DSECOND_COMP_DIR=/comp/second \
+# RUN:   -o %t.comp-dir-rel-name.o %s
+# RUN: llvm-dwarfdump --show-sources %t.comp-dir-rel-name.o | \
+# RUN:   FileCheck --check-prefix=CU-COMP-DIR-REL-NAME --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# CU-COMP-DIR-REL-NAME:      /comp/first[[SEP:[/\\]]]first.c
+# CU-COMP-DIR-REL-NAME-NEXT: /comp/second[[SEP]]second.c
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_comp_dir
+            Form:      DW_FORM_string
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_name
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_comp_dir
+            Form:      DW_FORM_string
+  debug_info:
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr: [[FIRST_NAME]]
+           - CStr: [[FIRST_COMP_DIR]]
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr: [[SECOND_NAME]]
+           - CStr: [[SECOND_COMP_DIR]]
+
+# RUN: yaml2obj --docnum=3 -o %t.comp-dir-abs-name-posix.o \
+# RUN:   -DFIRST_NAME=/abs/first.c -DFIRST_COMP_DIR=/comp/dir \
+# RUN:   -DSECOND_NAME=/abs/second.c -DSECOND_COMP_DIR=/comp/dir \
+# RUN:   %s
+# RUN: llvm-dwarfdump --show-sources %t.comp-dir-abs-name-posix.o | \
+# RUN:   FileCheck --check-prefix=CU-COMP-DIR-ABS-NAME-POSIX \
+# RUN:     --match-full-lines --implicit-check-not={{.}} %s
+
+# CU-COMP-DIR-ABS-NAME-POSIX:      /abs/first.c
+# CU-COMP-DIR-ABS-NAME-POSIX-NEXT: /abs/second.c
+
+# RUN: yaml2obj --docnum=3 -o %t.comp-dir-abs-name-windows.o \
+# RUN:   -DFIRST_NAME='C:\abs\first.c' -DFIRST_COMP_DIR='C:\comp\dir' \
+# RUN:   -DSECOND_NAME='C:\abs\second.c' -DSECOND_COMP_DIR='C:\comp\dir' \
+# RUN:   %s
+# RUN: llvm-dwarfdump --show-sources %t.comp-dir-abs-name-windows.o | \
+# RUN:   FileCheck --check-prefix=CU-COMP-DIR-ABS-NAME-WINDOWS \
+# RUN:     --match-full-lines --implicit-check-not={{.}} %s
+
+# CU-COMP-DIR-ABS-NAME-WINDOWS:      C:\abs\first.c
+# CU-COMP-DIR-ABS-NAME-WINDOWS-NEXT: C:\abs\second.c
+
+# RUN: yaml2obj --docnum=4 %s -o %t.line-table-abs.o
+# RUN: llvm-dwarfdump --show-sources %t.line-table-abs.o | \
+# RUN:   FileCheck --check-prefix=LINE-TABLE-ABS --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# LINE-TABLE-ABS:      /comp/first[[SEP:[/\\]]]first.c
+# LINE-TABLE-ABS-NEXT: /comp/second[[SEP]]second.c
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+DWARF:
+  debug_line:
+    - Version:       4
+      MinInstLength: 1
+      MaxOpsPerInst: 1
+      DefaultIsStmt: 1
+      LineBase:      0
+      LineRange:     0
+      OpcodeBase:    1
+      IncludeDirs:   [/comp/first]
+      Files:
+        - Name:    first.c
+          DirIdx:  1
+          ModTime: 0
+          Length:  0
+    - Version:       4
+      MinInstLength: 1
+      MaxOpsPerInst: 1
+      DefaultIsStmt: 1
+      LineBase:      0
+      LineRange:     0
+      OpcodeBase:    1
+      IncludeDirs:   [/comp/second]
+      Files:
+        - Name:    second.c
+          DirIdx:  1
+          ModTime: 0
+          Length:  0
+
+# RUN: yaml2obj --docnum=5 %s -o %t.line-table-rel.o
+# RUN: llvm-dwarfdump --show-sources %t.line-table-rel.o | \
+# RUN:   FileCheck --check-prefix=LINE-TABLE-REL --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# LINE-TABLE-REL:      first.c
+# LINE-TABLE-REL-NEXT: second.c
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+DWARF:
+  debug_line:
+    - Version:       4
+      MinInstLength: 1
+      MaxOpsPerInst: 1
+      DefaultIsStmt: 1
+      LineBase:      0
+      LineRange:     0
+      OpcodeBase:    1
+      Files:
+        - Name:    first.c
+          DirIdx:  0
+          ModTime: 0
+          Length:  0
+    - Version:       4
+      MinInstLength: 1
+      MaxOpsPerInst: 1
+      DefaultIsStmt: 1
+      LineBase:      0
+      LineRange:     0
+      OpcodeBase:    1
+      Files:
+        - Name:    second.c
+          DirIdx:  0
+          ModTime: 0
+          Length:  0
+
+# RUN: yaml2obj --docnum=6 %s -o %t.cu-line-table.o
+# RUN: llvm-dwarfdump --show-sources %t.cu-line-table.o | \
+# RUN:   FileCheck --check-prefix=CU-LINE-TABLE --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# CU-LINE-TABLE:      /first[[SEP:[/\\]]]first[[SEP]]first.c
+# CU-LINE-TABLE-NEXT: /second[[SEP]]second[[SEP]]second.c
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+DWARF:
+  debug_abbrev:
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_comp_dir
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_stmt_list
+            Form:      DW_FORM_sec_offset
+    - Table:
+      - Code:     1
+        Tag:      DW_TAG_compile_unit
+        Children: DW_CHILDREN_no
+        Attributes:
+          - Attribute: DW_AT_comp_dir
+            Form:      DW_FORM_string
+          - Attribute: DW_AT_stmt_list
+            Form:      DW_FORM_sec_offset
+  debug_info:
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr:  /first
+           - Value: 0
+    - Version: 4
+      Entries:
+        - AbbrCode: 1
+          Values:
+           - CStr:  /second
+           - Value: 0x23
+  debug_line:
+    - Version:       4
+      MinInstLength: 1
+      MaxOpsPerInst: 1
+      DefaultIsStmt: 1
+      LineBase:      0
+      LineRange:     0
+      OpcodeBase:    1
+      IncludeDirs:   [first]
+      Files:
+        - Name:    first.c
+          DirIdx:  1
+          ModTime: 0
+          Length:  0
+    - Version:       4
+      MinInstLength: 1
+      MaxOpsPerInst: 1
+      DefaultIsStmt: 1
+      LineBase:      0
+      LineRange:     0
+      OpcodeBase:    1
+      IncludeDirs:   [second]
+      Files:
+        - Name:    second.c
+          DirIdx:  1
+          ModTime: 0
+          Length:  0
+
+# RUN: llvm-dwarfdump --show-sources %t.line-table-rel.o %t.cu-line-table.o | \
+# RUN:   FileCheck --check-prefix=MULTIPLE-FILES --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# MULTIPLE-FILES:      first.c
+# MULTIPLE-FILES-NEXT: second.c
+# MULTIPLE-FILES-NEXT: /first[[SEP:[/\\]]]first[[SEP]]first.c
+# MULTIPLE-FILES-NEXT: /second[[SEP]]second[[SEP]]second.c
+
+# RUN: yaml2obj --docnum=7 %s -o %t.no-filenames.o
+# RUN: llvm-dwarfdump --show-sources %t.no-filenames.o | count 0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+DWARF:
+  debug_line:
+    - Version:       4
+      MinInstLength: 1
+      MaxOpsPerInst: 1
+      DefaultIsStmt: 1
+      LineBase:      0
+      LineRange:     0
+      OpcodeBase:    1
+      IncludeDirs:   []
+
+# TODO: Use yaml2obj for this test once it supports DWARFv5 line tables.
+# RUN: echo '.file 0 "/dir" "dwarfv5.c"' | \
+# RUN:   llvm-mc -g -dwarf-version=5 -triple x86_64-pc-linux -filetype=obj \
+# RUN:     -o %t.dwarfv5.o
+# RUN: llvm-dwarfdump --show-sources %t.dwarfv5.o | \
+# RUN:   FileCheck --check-prefix=DWARFV5 --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# DWARFV5: /dir{{[/\\]}}dwarfv5.c
+
+# RUN: llvm-mc -triple x86_64-pc-linux %S/Inputs/debug_line_malformed.s \
+# RUN:   -filetype=obj -o %t.malformed.o
+# RUN: not llvm-dwarfdump --show-sources %t.malformed.o 2>&1 | \
+# RUN:   FileCheck --check-prefix=MALFORMED --match-full-lines \
+# RUN:     --implicit-check-not={{.}} %s
+
+# MALFORMED: error: parsing line table prologue at offset 0x00000048: unsupported version 0

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 #include "llvm/Object/Archive.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 
 using namespace llvm;
static cl::opt<bool>
     Statistics("statistics",
                cl::desc("Emit JSON-formatted debug info quality metrics."),
                cat(DwarfDumpCategory));
 static cl::opt<bool>
     ShowSectionSizes("show-section-sizes",
                      cl::desc("Show the sizes of all debug sections, "
                               "expressed in bytes."),
                      cat(DwarfDumpCategory));
+static cl::opt<bool>
+    ShowSources("show-sources",
+                cl::desc("Show the sources across all compilation units."),
+                cat(DwarfDumpCategory));
 static opt<bool> Verify("verify", desc("Verify the DWARF debug info."),
                         cat(DwarfDumpCategory));
 static opt<bool> Quiet("quiet", desc("Use with -verify to not emit to STDOUT."),
                        cat(DwarfDumpCategory));
 static opt<bool> DumpUUID("uuid", desc("Show the UUID for each architecture."),
                           cat(DwarfDumpCategory));
 static alias DumpUUIDAlias("u", desc("Alias for --uuid."), aliasopt(DumpUUID),
                            cl::NotHidden);
static bool lookup(ObjectFile &Obj, DWARFContext &DICtx, uint64_t Address,
   // object::SectionedAddress::UndefSection works for only absolute addresses.
   if (DILineInfo LineInfo = DICtx.getLineInfoForAddress(
           {Lookup, object::SectionedAddress::UndefSection}))
     LineInfo.dump(OS);
 
   return true;
 }
 
+// Collect all sources referenced from the given line table, scoped to the given
+// CU compilation directory.
+static bool collectLineTableSources(const DWARFDebugLine::LineTable &LT,
+                                    StringRef CompDir,
+                                    std::vector<std::string> &Sources) {
+  bool Result = true;
+  llvm::Optional<uint64_t> LastIndex = LT.getLastValidFileIndex();
+  for (uint64_t I = LT.hasFileAtIndex(0) ? 0 : 1,
+                E = LastIndex ? *LastIndex + 1 : 0;
+       I < E; ++I) {
+    std::string Path;
+    Result &= LT.getFileNameByIndex(
+        I, CompDir, DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
+        Path);
+    Sources.push_back(std::move(Path));
+  }
+  return Result;
+}
+
+static bool collectObjectSources(ObjectFile &Obj, DWARFContext &DICtx,
+                                 const Twine &Filename, raw_ostream &OS) {
+  bool Result = true;
+  std::vector<std::string> Sources;
+
+  bool HasCompileUnits = false;
+  for (const auto &CU : DICtx.compile_units()) {
+    HasCompileUnits = true;
+    // Extract paths from the line table for this CU. This allows combining the
+    // compilation directory with the line information, in case both the include
+    // directory and file names in the line table are relative.
+    const DWARFDebugLine::LineTable *LT = DICtx.getLineTableForUnit(CU.get());
+    StringRef CompDir = CU->getCompilationDir();
+    if (LT) {
+      Result &= collectLineTableSources(*LT, CompDir, Sources);
+    } else {
+      // Since there's no line table for this CU, collect the name from the CU
+      // itself.
+      const char *Name = CU->getUnitDIE().getShortName();
+      if (!Name) {
+        WithColor::warning()
+            << Filename << ": missing name for compilation unit\n";
+        continue;
+      }
+      SmallString<64> AbsName;
+      if (sys::path::is_relative(Name, sys::path::Style::posix) &&
+          sys::path::is_relative(Name, sys::path::Style::windows))
+        AbsName = CompDir;
+      sys::path::append(AbsName, Name);
+      Sources.push_back(std::string(AbsName));
+    }
+  }
+
+  if (!HasCompileUnits) {
+    // Since there's no compile units available, walk the line tables and
+    // extract out any referenced paths.
+    DWARFDataExtractor LineData(DICtx.getDWARFObj(),
+                                DICtx.getDWARFObj().getLineSection(),
+                                DICtx.isLittleEndian(), 0);
+    DWARFDebugLine::SectionParser Parser(LineData, DICtx, DICtx.normal_units());
+    while (!Parser.done()) {
+      const auto RecoverableErrorHandler = [&](Error Err) {
+        Result = false;
+        WithColor::defaultErrorHandler(std::move(Err));
+      };
+      void (*UnrecoverableErrorHandler)(Error Err) = error;
+
+      DWARFDebugLine::LineTable LT =
+          Parser.parseNext(RecoverableErrorHandler, UnrecoverableErrorHandler);
+      Result &= collectLineTableSources(LT, /*CompDir=*/"", Sources);
+    }
+  }
+
+  // Dedup and order the sources.
+  llvm::sort(Sources.begin(), Sources.end());
+  Sources.erase(std::unique(Sources.begin(), Sources.end()), Sources.end());
+
+  for (StringRef Name : Sources)
+    OS << Name << "\n";
+  return Result;
+}
+
 static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                            const Twine &Filename, raw_ostream &OS) {
   logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(),
                         Filename.str() + ": ");
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
if (Verify) {
     for (auto Object : Objects)
       Success &= handleFile(Object, verifyObjectFile, OutputFile.os());
   } else if (Statistics) {
     for (auto Object : Objects)
       Success &= handleFile(Object, collectStatsForObjectFile, OutputFile.os());
   } else if (ShowSectionSizes) {
     for (auto Object : Objects)
       Success &= handleFile(Object, collectObjectSectionSizes, OutputFile.os());
+  } else if (ShowSources) {
+    for (auto Object : Objects)
+      Success &= handleFile(Object, collectObjectSources, OutputFile.os());
   } else {
     for (auto Object : Objects)
       Success &= handleFile(Object, dumpObjectFile, OutputFile.os());
   }
 
   return Success ? EXIT_SUCCESS : EXIT_FAILURE;
 }