[llvm] Prevent duplicate files in debug line header in dwarf 5: another attempt

[tamur]

Summary

Another attempt to land the changes in debug line header to prevent duplicate files in Dwarf 5. I rolled back my previous commit because of a mistake in generating the object file in a test. Meanwhile, I addressed some offline comments and changed the implementation; the largest difference is that MCDwarfLineTableHeader does not keep DwarfVersion but gets it as a parameter. I also merged the patch to fix two lld tests that will strt to fail into this patch.

Original Commit: https://reviews.llvm.org/D59515

Original Message:
Motivation: In previous dwarf versions, file name indexes started from 1, and the primary source file was not explicit. Dwarf 5 standard (6.2.4) prescribes the primary source file to be explicitly given an entry with an index number 0.

The current implementation honors the specification by just duplicating the main source file, once with index number 0, and later maybe with another index number. While this is compliant with the letter of the standard, the duplication causes problems for consumers of this information such as lldb. (Some files are duplicated, where only some of them have a line table although all refer to the same file)

With this change, dwarf 5 debug line section files always start from 0, and the zeroth entry is not duplicated whenever possible. This requires different handling of dwarf 4 and dwarf 5 during generation (e.g. when a function returns an index zero for a file name, it signals an error in dwarf 4, but not in dwarf 5) However, I think the minor complication is worth it, because it enables all consumers (lldb, gdb, dwarfdump, objdump, and so on) to treat all files in the file name list homogenously.

[MaskRay]

llvm/include/llvm/MC/MCDwarf.h

44–51

Should the comment be updated as well?

[MaskRay]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

1013

For DWARF<5, if we make FileNames[0] a placeholder (i.e. waste the first entry), would that make the logic simpler? e.g. we may not need the two functions.

[tamur]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

1013

Prologue.FileNames is public and is referred from outside. I don't want to change Prologue.FileNames implementation for Dwarf 4; that entails changing those clients and results in a larger patch. Alternatively, this patch is minimal and deals with 'dirty' stuff in a small, private method.

[MaskRay]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

1013

Thinking it more. Dispatching on DwarfVersion >= 5 looks better to me.

[echristo]

OK, this code could use some work, but not for you to refactor it more than you already have.

One change: Please change your use of MCContext in the patch with an unsigned DwarfVersion and pass that down instead. There is, sadly, nothing else that can be minimized by passing the context and it's just a little more confusing. Conveniently you can get the version anywhere you were getting the context so it should be a mechanical change.

LGTM with that change. Feel free to commit without uploading another version at that point.

Thanks!

-eric

lld/test/ELF/debug-line-obj.s

 .text
 .file  "test.cpp"
 .section  .text._Z3barv,"ax",@progbits
 .globl  _Z3barv
 .type  _Z3barv,@function
 _Z3barv:
 .Lfunc_begin0:
   .file  0 "/path" "test.cpp" md5 0x9ff11a8404ab4d032ee2dd4f5f8c4140
-  .file  1 "test.cpp" md5 0x9ff11a8404ab4d032ee2dd4f5f8c4140
-  .loc  1 2 0                   # test.cpp:2:0
-  .loc  1 2 20 prologue_end     # test.cpp:2:20
+  .loc  0 2 0                   # test.cpp:2:0
+  .loc  0 2 20 prologue_end     # test.cpp:2:20
   callq  _Z3foov
-  .loc  1 2 13 is_stmt 0        # test.cpp:2:13
+  .loc  0 2 13 is_stmt 0        # test.cpp:2:13
 .Lfunc_end0:
 .size  _Z3barv, .Lfunc_end0-_Z3barv
                                         # -- End function
 .section  .text._Z3bazv,"ax",@progbits
 .globl  _Z3bazv                 # -- Begin function _Z3bazv
   .type  _Z3bazv,@function
 _Z3bazv:                                # @_Z3bazv
 .Lfunc_begin1:
-  .loc  1 3 0 is_stmt 1         # test.cpp:3:0
-  .loc  1 3 20 prologue_end     # test.cpp:3:20
+  .loc  0 3 0 is_stmt 1         # test.cpp:3:0
+  .loc  0 3 20 prologue_end     # test.cpp:3:20
   callq  _Z3foov
-  .loc  1 3 13 is_stmt 0        # test.cpp:3:13
+  .loc  0 3 13 is_stmt 0        # test.cpp:3:13
 .Lfunc_end1:
   .size  _Z3bazv, .Lfunc_end1-_Z3bazv
 
 .section  .debug_str,"MS",@progbits,1
 .Linfo_string0:
   .asciz  "stub"
 
 .section  .debug_str_offsets,"",@progbits

lld/test/ELF/debug-line-str.s

 
 .text
 .file "test.cpp"
 .globl main
 .type main,@function
 main:
 .Lfunc_begin0:
  .file 0 "/home/path" "test.cpp" md5 0x8ed32099ab837bd13543fd3e8102739f
- .file 1 "test.cpp" md5 0x8ed32099ab837bd13543fd3e8102739f
- .loc 1 3 10 prologue_end
+ .loc 0 3 10 prologue_end
  jmp _Z3foov
 .Lfunc_end0:
 
 .Lstr_offsets_base0:
 .section .debug_str,"MS",@progbits,1
  .asciz "stub"
 
 .section .debug_str_offsets,"",@progbits

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

struct LineTable {
     uint32_t lookupAddress(object::SectionedAddress Address) const;
 
     bool lookupAddressRange(object::SectionedAddress Address, uint64_t Size,
                             std::vector<uint32_t> &Result) const;
 
     bool hasFileAtIndex(uint64_t FileIndex) const;
 
     /// Extracts filename by its index in filename table in prologue.
+    /// In Dwarf 4, the files are 1-indexed and the current compilation file
+    /// name is not represented in the list. In Dwarf 5, the files are
+    /// 0-indexed and the primary source file has the index 0.
     /// Returns true on success.
     bool getFileNameByIndex(uint64_t FileIndex, const char *CompDir,
                             DILineInfoSpecifier::FileLineInfoKind Kind,
                             std::string &Result) const;
 
     /// Fills the Result argument with the file and line information
     /// corresponding to Address. Returns true on success.
     bool getFileLineInfoForAddress(object::SectionedAddress Address,
struct LineTable {
     using SequenceVector = std::vector<Sequence>;
     using SequenceIter = SequenceVector::const_iterator;
 
     struct Prologue Prologue;
     RowVector Rows;
     SequenceVector Sequences;
 
   private:
+    const llvm::DWARFDebugLine::FileNameEntry &
+    getFileNameEntry(uint64_t Index) const;
     uint32_t findRowInSeq(const DWARFDebugLine::Sequence &Seq,
                           object::SectionedAddress Address) const;
     Optional<StringRef>
     getSourceByIndex(uint64_t FileIndex,
                      DILineInfoSpecifier::FileLineInfoKind Kind) const;
 
     uint32_t lookupAddressImpl(object::SectionedAddress Address) const;
 

llvm/include/llvm/MC/MCDwarf.h

 class MCDwarfLineStr;
 class MCObjectStreamer;
 class MCStreamer;
 class MCSymbol;
 class raw_ostream;
 class SMLoc;
 class SourceMgr;
 
-/// Instances of this class represent the name of the dwarf
-/// .file directive and its associated dwarf file number in the MC file,
-/// and MCDwarfFile's are created and uniqued by the MCContext class where
-/// the file number for each is its index into the vector of DwarfFiles (note
-/// index 0 is not used and not a valid dwarf file number).
+/// Instances of this class represent the name of the dwarf .file directive and
+/// its associated dwarf file number in the MC file. MCDwarfFile's are created
+/// and uniqued by the MCContext class. In Dwarf 4 file numbers start from 1;
+/// i.e. the entry with file number 1 is the first element in the vector of
+/// DwarfFiles and there is no MCDwarfFile with file number 0. In Dwarf 5 file
+/// numbers start from 0, with the MCDwarfFile with file number 0 being the
+/// primary source file, and file numbers correspond to their index in the
+/// vector.
 struct MCDwarfFile {
   // The base name of the file without its directory path.
   std::string Name;
 
   // The index into the list of directory names for this file name.
   unsigned DirIndex;
 
   /// The MD5 checksum, if there is one. Non-owning pointer to data allocated
private:
   bool HasAnyMD5 = false;
 
 public:
   MCDwarfLineTableHeader() = default;
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 Optional<MD5::MD5Result> Checksum,
                                 Optional<StringRef> &Source,
+                                const MCContext &MCContext,
                                 unsigned FileNumber = 0);
   std::pair<MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        Optional<MCDwarfLineStr> &LineStr) const;
   std::pair<MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        ArrayRef<char> SpecialOpcodeLengths,
        Optional<MCDwarfLineStr> &LineStr) const;
   void resetMD5Usage() {
     HasAllMD5 = true;
     HasAnyMD5 = false;
   }
   void trackMD5Usage(bool MD5Used) {
     HasAllMD5 &= MD5Used;
     HasAnyMD5 |= MD5Used;
   }
   bool isMD5UsageConsistent() const {
     return MCDwarfFiles.empty() || (HasAllMD5 == HasAnyMD5);
   }
 
+  void setRootFile(StringRef Directory, StringRef FileName,
+                   Optional<MD5::MD5Result> Checksum,
+                   Optional<StringRef> Source) {
+    CompilationDir = Directory;
+    RootFile.Name = FileName;
+    RootFile.DirIndex = 0;
+    RootFile.Checksum = Checksum;
+    RootFile.Source = Source;
+    trackMD5Usage(Checksum.hasValue());
+    HasSource = Source.hasValue();
+  }
+
 private:
   void emitV2FileDirTables(MCStreamer *MCOS) const;
   void emitV5FileDirTables(MCStreamer *MCOS, Optional<MCDwarfLineStr> &LineStr,
                            StringRef CtxCompilationDir) const;
 };
 
 class MCDwarfDwoLineTable {
   MCDwarfLineTableHeader Header;
+  bool HasSplitLineTable = false;
 
 public:
   void maybeSetRootFile(StringRef Directory, StringRef FileName,
-                        Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
+                        Optional<MD5::MD5Result> Checksum,
+                        Optional<StringRef> Source) {
     if (!Header.RootFile.Name.empty())
       return;
-    Header.CompilationDir = Directory;
-    Header.RootFile.Name = FileName;
-    Header.RootFile.DirIndex = 0;
-    Header.RootFile.Checksum = Checksum;
-    Header.RootFile.Source = Source;
-    Header.trackMD5Usage(Checksum.hasValue());
-    Header.HasSource = Source.hasValue();
+    Header.setRootFile(Directory, FileName, Checksum, Source);
   }
 
   unsigned getFile(StringRef Directory, StringRef FileName,
-                   Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
-    return cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source));
+                   Optional<MD5::MD5Result> Checksum, const MCContext &MCContext,
+                   Optional<StringRef> Source) {
+    HasSplitLineTable = true;
+    return cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source,
+                                      MCContext));
   }
 
   void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
             MCSection *Section) const;
 };
 
 class MCDwarfLineTable {
   MCDwarfLineTableHeader Header;
   MCLineSection MCLineSections;
 
 public:
   // This emits the Dwarf file and the line tables for all Compile Units.
   static void Emit(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params);
 
   // This emits the Dwarf file and the line tables for a given Compile Unit.
   void EmitCU(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params,
               Optional<MCDwarfLineStr> &LineStr) const;
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 Optional<MD5::MD5Result> Checksum,
                                 Optional<StringRef> Source,
+                                const MCContext &MCContext,
                                 unsigned FileNumber = 0);
   unsigned getFile(StringRef &Directory, StringRef &FileName,
                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> &Source,
-                   unsigned FileNumber = 0) {
+                   const MCContext &MCContext, unsigned FileNumber = 0) {
     return cantFail(tryGetFile(Directory, FileName, Checksum, Source,
-                               FileNumber));
+                               MCContext, FileNumber));
   }
 
   void setRootFile(StringRef Directory, StringRef FileName,
                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
     Header.CompilationDir = Directory;
     Header.RootFile.Name = FileName;
     Header.RootFile.DirIndex = 0;
     Header.RootFile.Checksum = Checksum;

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
   if (!SplitLineTable)
     return getCU().getOrCreateSourceID(File);
   if (!UsedLineTable) {
     UsedLineTable = true;
     // This is a split type unit that needs a line table.
     addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
   }
   return SplitLineTable->getFile(File->getDirectory(), File->getFilename(),
-                                 getMD5AsBytes(File), File->getSource());
+                                 getMD5AsBytes(File), Asm->OutContext,
+                                 File->getSource());
 }
 
 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
   if (DD->getDwarfVersion() >= 5) {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
     addUInt(Die, dwarf::DW_FORM_addrx, DD->getAddressPool().getIndex(Sym));
     return;
   }
void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
   Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
 }
 
 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
   if (Line == 0)
     return;
 
   unsigned FileID = getOrCreateSourceID(File);
-  assert(FileID && "Invalid file id");
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 }
 
 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
   assert(V);
 
   addSourceLine(Die, V->getLine(), V->getFile());

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

while (SeqPos != LastSeq && SeqPos->LowPC < EndAddr) {
 
     ++SeqPos;
   }
 
   return true;
 }
 
 bool DWARFDebugLine::LineTable::hasFileAtIndex(uint64_t FileIndex) const {
+  uint16_t DwarfVersion = Prologue.getVersion();
+  assert(DwarfVersion != 0 && "LineTable has no dwarf version information");
+  if (DwarfVersion >= 5)
+    return FileIndex < Prologue.FileNames.size();
   return FileIndex != 0 && FileIndex <= Prologue.FileNames.size();
 }
 
+const llvm::DWARFDebugLine::FileNameEntry &
+DWARFDebugLine::LineTable::getFileNameEntry(uint64_t Index) const {
+  uint16_t DwarfVersion = Prologue.getVersion();
+  assert(DwarfVersion != 0 && "LineTable has no dwarf version information");
+  // Unlike previous versions, in Dwarf 5 the file names is 0-indexed.
+  if (DwarfVersion >= 5)
+    return Prologue.FileNames[Index];
+  else
+    return Prologue.FileNames[Index - 1];
+}
+
 Optional<StringRef> DWARFDebugLine::LineTable::getSourceByIndex(uint64_t FileIndex,
                                                                 FileLineInfoKind Kind) const {
   if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
     return None;
-  const FileNameEntry &Entry = Prologue.FileNames[FileIndex - 1];
+  const FileNameEntry &Entry = getFileNameEntry(FileIndex);
   if (Optional<const char *> source = Entry.Source.getAsCString())
     return StringRef(*source);
   return None;
 }
 
 static bool isPathAbsoluteOnWindowsOrPosix(const Twine &Path) {
   // Debug info can contain paths from any OS, not necessarily
   // an OS we're currently running on. Moreover different compilation units can
   // be compiled on different operating systems and linked together later.
   return sys::path::is_absolute(Path, sys::path::Style::posix) ||
          sys::path::is_absolute(Path, sys::path::Style::windows);
 }
 
 bool DWARFDebugLine::LineTable::getFileNameByIndex(uint64_t FileIndex,
                                                    const char *CompDir,
                                                    FileLineInfoKind Kind,
                                                    std::string &Result) const {
   if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
     return false;
-  const FileNameEntry &Entry = Prologue.FileNames[FileIndex - 1];
+  const FileNameEntry &Entry = getFileNameEntry(FileIndex);
   StringRef FileName = Entry.Name.getAsCString().getValue();
   if (Kind != FileLineInfoKind::AbsoluteFilePath ||
       isPathAbsoluteOnWindowsOrPosix(FileName)) {
     Result = FileName;
     return true;
   }
 
   SmallString<16> FilePath;

llvm/lib/MC/MCAsmStreamer.cpp

 Expected<unsigned> MCAsmStreamer::tryEmitDwarfFileDirective(
     unsigned FileNo, StringRef Directory, StringRef Filename,
     Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source, unsigned CUID) {
   assert(CUID == 0 && "multiple CUs not supported by MCAsmStreamer");
 
   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
   unsigned NumFiles = Table.getMCDwarfFiles().size();
   Expected<unsigned> FileNoOrErr =
-      Table.tryGetFile(Directory, Filename, Checksum, Source, FileNo);
+      Table.tryGetFile(Directory, Filename, Checksum, Source, getContext(),
+                       FileNo);
   if (!FileNoOrErr)
     return FileNoOrErr.takeError();
   FileNo = FileNoOrErr.get();
   if (NumFiles == Table.getMCDwarfFiles().size())
     return FileNo;
 
   SmallString<128> Str;
   raw_svector_ostream OS1(Str);

llvm/lib/MC/MCContext.cpp

 /// allocated file number is returned.  The file numbers may be in any order.
 Expected<unsigned> MCContext::getDwarfFile(StringRef Directory,
                                            StringRef FileName,
                                            unsigned FileNumber,
                                            Optional<MD5::MD5Result> Checksum,
                                            Optional<StringRef> Source,
                                            unsigned CUID) {
   MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
-  return Table.tryGetFile(Directory, FileName, Checksum, Source, FileNumber);
+  return Table.tryGetFile(Directory, FileName, Checksum, Source, *this,
+                          FileNumber);
 }
 
 /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
 /// currently is assigned and false otherwise.
 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
   const MCDwarfLineTable &LineTable = getMCDwarfLineTable(CUID);
   if (FileNumber == 0)
-    return getDwarfVersion() >= 5 && LineTable.hasRootFile();
+    return getDwarfVersion() >= 5;
   if (FileNumber >= LineTable.getMCDwarfFiles().size())
     return false;
 
   return !LineTable.getMCDwarfFiles()[FileNumber].Name.empty();
 }
 
 /// Remove empty sections from SectionsForRanges, to avoid generating
 /// useless debug info for them.

llvm/lib/MC/MCDwarf.cpp

void MCDwarfLineTable::Emit(MCObjectStreamer *MCOS,
   }
 
   if (LineStr)
     LineStr->emitSection(MCOS);
 }
 
 void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
                                MCSection *Section) const {
-  if (Header.MCDwarfFiles.empty())
+  if (!HasSplitLineTable)
     return;
   Optional<MCDwarfLineStr> NoLineStr(None);
   MCOS.SwitchSection(Section);
   MCOS.EmitLabel(Header.Emit(&MCOS, Params, None, NoLineStr).second);
 }
 
 std::pair<MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS,
   // of this section (that was used in a previous expression).
   MCOS->EmitLabel(LineEndSym);
 }
 
 Expected<unsigned> MCDwarfLineTable::tryGetFile(StringRef &Directory,
                                                 StringRef &FileName,
                                                 Optional<MD5::MD5Result> Checksum,
                                                 Optional<StringRef> Source,
+                                                const MCContext &MCContext,
                                                 unsigned FileNumber) {
-  return Header.tryGetFile(Directory, FileName, Checksum, Source, FileNumber);
+  return Header.tryGetFile(Directory, FileName, Checksum, Source, MCContext,
+                           FileNumber);
+}
+
+bool isRootFile(const MCDwarfFile &RootFile, StringRef &Directory,
+                StringRef &FileName, Optional<MD5::MD5Result> Checksum) {
+  if (RootFile.Name.empty() || RootFile.Name != FileName.data())
+    return false;
+  return RootFile.Checksum == Checksum;
 }
 
 Expected<unsigned>
 MCDwarfLineTableHeader::tryGetFile(StringRef &Directory,
                                    StringRef &FileName,
                                    Optional<MD5::MD5Result> Checksum,
                                    Optional<StringRef> &Source,
+                                   const MCContext &MCContext,
                                    unsigned FileNumber) {
   if (Directory == CompilationDir)
     Directory = "";
   if (FileName.empty()) {
     FileName = "<stdin>";
     Directory = "";
   }
   assert(!FileName.empty());
   // Keep track of whether any or all files have an MD5 checksum.
   // If any files have embedded source, they all must.
   if (MCDwarfFiles.empty()) {
     trackMD5Usage(Checksum.hasValue());
     HasSource = (Source != None);
   }
+  if (isRootFile(RootFile, Directory, FileName, Checksum) &&
+      MCContext.getDwarfVersion() >= 5)
+    return 0;
   if (FileNumber == 0) {
     // File numbers start with 1 and/or after any file numbers
     // allocated by inline-assembler .file directives.
     FileNumber = MCDwarfFiles.empty() ? 1 : MCDwarfFiles.size();
     SmallString<256> Buffer;
     auto IterBool = SourceIdMap.insert(
         std::make_pair((Directory + Twine('\0') + FileName).toStringRef(Buffer),
                        FileNumber));

llvm/test/MC/ARM/dwarf-asm-multiple-sections.s

 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 5 -fdebug-compilation-dir=/tmp
 // RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF -check-prefix DWARF45 %s
 // RUN: llvm-dwarfdump --debug-line %t | FileCheck -check-prefix DWARF-DL -check-prefix DWARF-DL-5 -DDWVER=5 -DDWFILE=0 %s
 // RUN: llvm-objdump -r %t | FileCheck -check-prefix RELOC -check-prefix RELOC5 %s
-// RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -fdebug-compilation-dir=/tmp
+// RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 4 -fdebug-compilation-dir=/tmp
 // RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF -check-prefix DWARF45 %s
-// RUN: llvm-dwarfdump --debug-line %t | FileCheck -check-prefix DWARF-DL -DDWVER=4 -DDWFILE=1 %s
+// RUN: llvm-dwarfdump --debug-line %t | FileCheck -check-prefix DWARF-DL -check-prefix DWARF-DL-4 -DDWVER=4 -DDWFILE=1 %s
 // RUN: llvm-objdump -r %t | FileCheck -check-prefix RELOC -check-prefix RELOC4 %s
 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 3 -fdebug-compilation-dir=/tmp
 // RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF -check-prefix DWARF3 %s
 // RUN: llvm-dwarfdump --debug-line %t | FileCheck -check-prefix DWARF-DL -DDWVER=3 -DDWFILE=1 %s
 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 2 2>&1 | FileCheck -check-prefix VERSION %s
 // RUN: not llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 1 2>&1 | FileCheck -check-prefix DWARF1 %s
 // RUN: not llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -dwarf-version 6 2>&1 | FileCheck -check-prefix DWARF6 %s
   .section .text, "ax"

 
 
 // DWARF-DL: .debug_line contents:
 // DWARF-DL: version: [[DWVER]]
 // DWARF-DL-5:    address_size: 4
 // DWARF-DL-5:    include_directories[  0] = "/tmp"
 // DWARF-DL:      file_names[  [[DWFILE]]]:
 // DWARF-DL:      name: "{{(<stdin>|-)}}"
-// DWARF-DL:      0x0000000000000000     17      0      1   0   0  is_stmt
-// DWARF-DL-NEXT: 0x0000000000000004     17      0      1   0   0  is_stmt end_sequence
-// DWARF-DL-NEXT: 0x0000000000000000     21      0      1   0   0  is_stmt
-// DWARF-DL-NEXT: 0x0000000000000004     21      0      1   0   0  is_stmt end_sequence
+// DWARF-DL-5:      0x0000000000000000     17      0      0   0   0  is_stmt
+// DWARF-DL-5-NEXT: 0x0000000000000004     17      0      0   0   0  is_stmt end_sequence
+// DWARF-DL-5-NEXT: 0x0000000000000000     21      0      0   0   0  is_stmt
+// DWARF-DL-5-NEXT: 0x0000000000000004     21      0      0   0   0  is_stmt end_sequence
+// DWARF-DL-4:      0x0000000000000000     17      0      1   0   0  is_stmt
+// DWARF-DL-4-NEXT: 0x0000000000000004     17      0      1   0   0  is_stmt end_sequence
+// DWARF-DL-4-NEXT: 0x0000000000000000     21      0      1   0   0  is_stmt
+// DWARF-DL-4-NEXT: 0x0000000000000004     21      0      1   0   0  is_stmt end_sequence
 
 
 // DWARF: .debug_ranges contents:
 // DWARF: 00000000 ffffffff 00000000
 // DWARF: 00000000 00000000 00000004
 // DWARF: 00000000 ffffffff 00000000
 // DWARF: 00000000 00000000 00000004
 // DWARF: 00000000 <End of list>

llvm/test/MC/ELF/debug-mixed-md5.ll

 ; RUN: %llc_dwarf -filetype=asm -dwarf-version=5 %s -o - | FileCheck %s -check-prefix=ASM
 ; RUN: %llc_dwarf -filetype=obj -dwarf-version=5 %s -o - | llvm-dwarfdump -debug-line - | FileCheck %s -check-prefix=OBJ
 ; ASM: .file 0 "{{.+}}" md5
-; ASM: .file 1 "{{.+}}" md5
-; ASM: .file 2 "t1.cpp"
+; ASM: .file 1 "t1.cpp"
 ; ASM-NOT: md5
 ; OBJ: file_names[ 0]:
 ; OBJ-NOT: md5
 ;
 ; Generated from this source (see PR37623):
 ;
 ; #define a(...) template __VA_ARGS__;
 ; template <class> class b {};

llvm/test/MC/ELF/dwarf-file0.s

 # CHECK-NOT:   include_directories
 # CHECK-4-NOT: file_names[ 0]
 # CHECK-5:     file_names[ 0]:
 # CHECK-5-NEXT: name: "root.cpp"
 # CHECK-5-NEXT: dir_index: 0
 # CHECK:       file_names[ 1]:
 # CHECK-NEXT:  name: "header.h"
 # CHECK-NEXT:  dir_index: 1
-# CHECK:       file_names[ 2]:
-# CHECK-NEXT:  name: "root.cpp"
+# CHECK-4:     file_names[ 2]:
+# CHECK-4-NEXT: name: "root.cpp"
 # CHECK-4-NEXT: dir_index: 2
-# CHECK-5-NEXT: dir_index: 0
 
 # ASM-NOT: .file
 # ASM-5:   .file 0 "/test" "root.cpp"
 # ASM:     .file 1 "/include" "header.h"
 # ASM-4:   .file 2 "/test" "root.cpp"
-# ASM-5:   .file 2 "root.cpp"
 # ASM-NOT: .file
 
 # WARN:      file 0 not supported prior to DWARF-5
 # WARN-NEXT: .file 0
 # WARN-NEXT: ^

llvm/test/tools/llvm-objdump/X86/function-sections-line-numbers.s

# CHECK-NOT: test.cpp:1
   .file "test.cpp"
   .section  .text._Z2f1v,"ax",@progbits
   .globl  _Z2f1v                  # -- Begin function _Z2f1v
   .p2align  4, 0x90
   .type _Z2f1v,@function
 _Z2f1v:                                 # @_Z2f1v
 .Lfunc_begin0:
   .file 0 "/home/avl" "test.cpp" md5 0xefae234cc05b45384d782316d3a5d338
-  .file  1 "test.cpp" md5 0xefae234cc05b45384d782316d3a5d338
-  .loc  1 1 0                   # test.cpp:1:0
+  .loc  0 1 0                   # test.cpp:1:0
   .cfi_startproc
 # %bb.0:                                # %entry
   pushq %rbp
   .cfi_def_cfa_offset 16
   .cfi_offset %rbp, -16
   movq  %rsp, %rbp
   .cfi_def_cfa_register %rbp
 .Ltmp0:
-  .loc  1 1 12 prologue_end     # test.cpp:1:12
+  .loc  0 1 12 prologue_end     # test.cpp:1:12
   popq  %rbp
   .cfi_def_cfa %rsp, 8
   retq
 .Ltmp1:
 .Lfunc_end0:
   .size _Z2f1v, .Lfunc_end0-_Z2f1v
   .cfi_endproc
                                         # -- End function
   .section  .text._Z2f2v,"ax",@progbits
   .globl  _Z2f2v                  # -- Begin function _Z2f2v
   .p2align  4, 0x90
   .type _Z2f2v,@function
 _Z2f2v:                                 # @_Z2f2v
 .Lfunc_begin1:
-  .loc  1 2 0                   # test.cpp:2:0
+  .loc  0 2 0                   # test.cpp:2:0
   .cfi_startproc
 # %bb.0:                                # %entry
   pushq %rbp
   .cfi_def_cfa_offset 16
   .cfi_offset %rbp, -16
   movq  %rsp, %rbp
   .cfi_def_cfa_register %rbp
 .Ltmp2:
-  .loc  1 2 12 prologue_end     # test.cpp:2:12
+  .loc  0 2 12 prologue_end     # test.cpp:2:12
   popq  %rbp
   .cfi_def_cfa %rsp, 8
   retq
 .Ltmp3:
 .Lfunc_end1:
   .size _Z2f2v, .Lfunc_end1-_Z2f2v
   .cfi_endproc
                                         # -- End function