[DWARF] Regularize dumping strings from line tables.

[probinson]

Summary

The major visible difference here is that in line-table dumps,
directory and file names are wrapped in double-quotes; previously,
directory names got single quotes and file names were not quoted at
all.
(I know there have been changes lately to make dwarfdump more like Darwin's. I hope this change isn't an issue.)

The improvement in this patch is that when a DWARF v5 line table
header has indirect strings, in a verbose dump these will all have
their section[offset] printed as well as the name itself. This
matches the format used for dumping strings in the .debug_info
section.

[JDevlieghere]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

443

Maybe add a comment here that says that if we execute this path we know we're in verbose mode. Alternatively we could add the DumpOptions as an additional default argument but I don't think that's worth it here.

[probinson]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

443

There is a comment to that effect elsewhere, which is why I knew this call should use verbose mode. The line table dumping is weird that way. But a comment here as well would make sense.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

553

Might be worth saving the CStr upfront/above, rather than having to go through the process of pulling it out of the DWARFFormValue 7 lines later down here?

927

Should this remain as a StringRef & the 'if' clause following be changed to contain the 'getAsCString().getValue()' part?

llvm/test/DebugInfo/X86/dwarfdump-header.s

327–328

Should this print as ".debug_line_str"?

[probinson]

Address review comments.

[probinson]

@JDevlieghere are the quoted file/directory names compatible (enough) with Darwin's dwarfdump? I know you were working to make them compatible (although maybe it was mostly command-line compatible).

llvm/test/DebugInfo/X86/dwarfdump-header.s

327–328

No, this is correct. The referenced string section depends on the form, not on the section where the reference is made.
This test uses FORM_strp in the directory table and FORM_line_strp in the file table, to verify correct printing for both cases. In practice I wouldn't expect a producer to mix-n-match like this, but for a test it seemed like a good idea.

[JDevlieghere]

In D42802#995611, @probinson wrote:

@JDevlieghere are the quoted file/directory names compatible (enough) with Darwin's dwarfdump? I know you were working to make them compatible (although maybe it was mostly command-line compatible).

Indeed, I'm mainly concerned with command line interface and feature parity. Having similar output is nice, but it shouldn't hold us back from making improvements like this. Thanks for checking!

[JDevlieghere]

LGTM!

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

 class DWARFUnit;
 class raw_ostream;
 
 class DWARFDebugLine {
 public:
   struct FileNameEntry {
     FileNameEntry() = default;
 
-    StringRef Name;
+    DWARFFormValue Name;
     uint64_t DirIdx = 0;
     uint64_t ModTime = 0;
     uint64_t Length = 0;
     MD5::MD5Result Checksum;
   };
 
   struct Prologue {
     Prologue();
struct Prologue {
     int8_t LineBase;
     /// This parameter affects the meaning of the special opcodes. See below.
     uint8_t LineRange;
     /// The number assigned to the first special opcode.
     uint8_t OpcodeBase;
     /// For v5, whether filename entries provide an MD5 checksum.
     bool HasMD5;
     std::vector<uint8_t> StandardOpcodeLengths;
-    std::vector<StringRef> IncludeDirectories;
+    std::vector<DWARFFormValue> IncludeDirectories;
     std::vector<FileNameEntry> FileNames;
 
     const DWARFFormParams getFormParams() const { return FormParams; }
     uint16_t getVersion() const { return FormParams.Version; }
     uint8_t getAddressSize() const { return FormParams.AddrSize; }
     bool isDWARF64() const { return FormParams.Format == dwarf::DWARF64; }
 
     uint32_t sizeofTotalLength() const { return isDWARF64() ? 12 : 4; }
uint32_t getStatementTableLength() const {
       return TotalLength + sizeofTotalLength() - getLength();
     }
 
     int32_t getMaxLineIncrementForSpecialOpcode() const {
       return LineBase + (int8_t)LineRange - 1;
     }
 
     void clear();
-    void dump(raw_ostream &OS) const;
+    void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     bool parse(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
                const DWARFContext &Ctx, const DWARFUnit *U = nullptr);
   };
 
   /// Standard .debug_line state machine structure.
   struct Row {
     explicit Row(bool DefaultIsStmt = false);
 
bool getFileNameByIndex(uint64_t FileIndex, const char *CompDir,
                             std::string &Result) const;
 
     /// Fills the Result argument with the file and line information
     /// corresponding to Address. Returns true on success.
     bool getFileLineInfoForAddress(uint64_t Address, const char *CompDir,
                                    DILineInfoSpecifier::FileLineInfoKind Kind,
                                    DILineInfo &Result) const;
 
-    void dump(raw_ostream &OS) const;
+    void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     void clear();
 
     /// Parse prologue and all rows.
     bool parse(DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
                const DWARFContext &Ctx, const DWARFUnit *U,
                raw_ostream *OS = nullptr);
 
     using RowVector = std::vector<Row>;

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

while (Offset < LineData.getData().size()) {
       // Verbose dumping is done during parsing and not on the intermediate
       // representation.
       OS << "debug_line[" << format("0x%8.8x", Offset) << "]\n";
       unsigned OldOffset = Offset;
       if (DumpOpts.Verbose) {
         LineTable.parse(LineData, &Offset, *this, U, &OS);
       } else {
         LineTable.parse(LineData, &Offset, *this, U);
-        LineTable.dump(OS);
+        LineTable.dump(OS, DIDumpOptions());
       }
       // Check for unparseable prologue, to avoid infinite loops.
       if (OldOffset == Offset)
         break;
     }
   }
 
   if (shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine,
                  DObj->getLineDWOSection().Data)) {
     LineToUnitMap LineToUnit =
         buildLineToUnitMap(dwo_compile_units(), dwo_type_unit_sections());
     unsigned Offset = 0;
     DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(),
                                 isLittleEndian(), 0);
     while (Offset < LineData.getData().size()) {
       DWARFUnit *U = nullptr;
       auto It = LineToUnit.find(Offset);
       if (It != LineToUnit.end())
         U = It->second;
       DWARFDebugLine::LineTable LineTable;
       unsigned OldOffset = Offset;
       if (!LineTable.Prologue.parse(LineData, &Offset, *this, U))
         break;
       if (!DumpOffset || OldOffset == *DumpOffset)
-        LineTable.dump(OS);
+        LineTable.dump(OS, DumpOpts);
     }
   }
 
   if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex,
                  DObj->getCUIndexSection())) {
     getCUIndex().dump(OS);
   }
 

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

void DWARFDebugLine::Prologue::clear() {
   OpcodeBase = 0;
   FormParams = DWARFFormParams({0, 0, DWARF32});
   HasMD5 = false;
   StandardOpcodeLengths.clear();
   IncludeDirectories.clear();
   FileNames.clear();
 }
 
-void DWARFDebugLine::Prologue::dump(raw_ostream &OS) const {
+void DWARFDebugLine::Prologue::dump(raw_ostream &OS,
+                                    DIDumpOptions DumpOptions) const {
   OS << "Line table prologue:\n"
      << format("    total_length: 0x%8.8" PRIx64 "\n", TotalLength)
      << format("         version: %u\n", getVersion());
   if (getVersion() >= 5)
     OS << format("    address_size: %u\n", getAddressSize())
        << format(" seg_select_size: %u\n", SegSelectorSize);
   OS << format(" prologue_length: 0x%8.8" PRIx64 "\n", PrologueLength)
      << format(" min_inst_length: %u\n", MinInstLength)
      << format(getVersion() >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
      << format(" default_is_stmt: %u\n", DefaultIsStmt)
      << format("       line_base: %i\n", LineBase)
      << format("      line_range: %u\n", LineRange)
      << format("     opcode_base: %u\n", OpcodeBase);
 
   for (uint32_t I = 0; I != StandardOpcodeLengths.size(); ++I)
     OS << format("standard_opcode_lengths[%s] = %u\n",
                  LNStandardString(I + 1).data(), StandardOpcodeLengths[I]);
 
   if (!IncludeDirectories.empty()) {
     // DWARF v5 starts directory indexes at 0.
     uint32_t DirBase = getVersion() >= 5 ? 0 : 1;
-    for (uint32_t I = 0; I != IncludeDirectories.size(); ++I)
-      OS << format("include_directories[%3u] = '", I + DirBase)
-         << IncludeDirectories[I] << "'\n";
+    for (uint32_t I = 0; I != IncludeDirectories.size(); ++I) {
+      OS << format("include_directories[%3u] = ", I + DirBase);
+      IncludeDirectories[I].dump(OS, DumpOptions);
+      OS << '\n';
+    }
   }
 
   if (!FileNames.empty()) {
     if (HasMD5)
       OS << "                Dir  MD5 Checksum                     File Name\n"
          << "                ---- -------------------------------- -----------"
             "---------------\n";
     else
       OS << "                Dir  Mod Time   File Len   File Name\n"
          << "                ---- ---------- ---------- -----------"
             "----------------\n";
     for (uint32_t I = 0; I != FileNames.size(); ++I) {
       const FileNameEntry &FileEntry = FileNames[I];
       OS << format("file_names[%3u] %4" PRIu64 " ", I + 1, FileEntry.DirIdx);
       if (HasMD5)
         OS << FileEntry.Checksum.digest();
       else
         OS << format("0x%8.8" PRIx64 " 0x%8.8" PRIx64, FileEntry.ModTime,
                      FileEntry.Length);
-      OS << ' ' << FileEntry.Name << '\n';
+      OS << ' ';
+      FileEntry.Name.dump(OS, DumpOptions);
+      OS << '\n';
     }
   }
 }
 
 // Parse v2-v4 directory and file tables.
 static void
 parseV2DirFileTables(const DWARFDataExtractor &DebugLineData,
                      uint32_t *OffsetPtr, uint64_t EndPrologueOffset,
-                     std::vector<StringRef> &IncludeDirectories,
+                     std::vector<DWARFFormValue> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   while (*OffsetPtr < EndPrologueOffset) {
     StringRef S = DebugLineData.getCStrRef(OffsetPtr);
     if (S.empty())
       break;
-    IncludeDirectories.push_back(S);
+    DWARFFormValue Dir(dwarf::DW_FORM_string);
+    Dir.setPValue(S.data());
+    IncludeDirectories.push_back(Dir);
   }
 
   while (*OffsetPtr < EndPrologueOffset) {
     StringRef Name = DebugLineData.getCStrRef(OffsetPtr);
     if (Name.empty())
       break;
     DWARFDebugLine::FileNameEntry FileEntry;
-    FileEntry.Name = Name;
+    FileEntry.Name.setForm(dwarf::DW_FORM_string);
+    FileEntry.Name.setPValue(Name.data());
     FileEntry.DirIdx = DebugLineData.getULEB128(OffsetPtr);
     FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr);
     FileEntry.Length = DebugLineData.getULEB128(OffsetPtr);
     FileNames.push_back(FileEntry);
   }
 }
 
 // Parse v5 directory/file entry content descriptions.
parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
   return HasPath ? Descriptors : ContentDescriptors();
 }
 
 static bool
 parseV5DirFileTables(const DWARFDataExtractor &DebugLineData,
                      uint32_t *OffsetPtr, uint64_t EndPrologueOffset,
                      const DWARFFormParams &FormParams, const DWARFContext &Ctx,
                      const DWARFUnit *U, bool &HasMD5,
-                     std::vector<StringRef> &IncludeDirectories,
+                     std::vector<DWARFFormValue> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   // Get the directory entry description.
   ContentDescriptors DirDescriptors =
       parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset, nullptr);
   if (DirDescriptors.empty())
     return false;
 
   // Get the directory entries, according to the format described above.
   int DirEntryCount = DebugLineData.getU8(OffsetPtr);
   for (int I = 0; I != DirEntryCount; ++I) {
     if (*OffsetPtr >= EndPrologueOffset)
       return false;
     for (auto Descriptor : DirDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
       switch (Descriptor.Type) {
       case DW_LNCT_path:
         if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
           return false;
-        IncludeDirectories.push_back(Value.getAsCString().getValue());
+        IncludeDirectories.push_back(Value);
         break;
       default:
         if (!Value.skipValue(DebugLineData, OffsetPtr, FormParams))
           return false;
       }
     }
   }
 
if (*OffsetPtr >= EndPrologueOffset)
       return false;
     DWARFDebugLine::FileNameEntry FileEntry;
     for (auto Descriptor : FileDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
       if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
         return false;
       switch (Descriptor.Type) {
       case DW_LNCT_path:
-        FileEntry.Name = Value.getAsCString().getValue();
+        FileEntry.Name = Value;
         break;
       case DW_LNCT_directory_index:
         FileEntry.DirIdx = Value.getAsUnsignedConstant().getValue();
         break;
       case DW_LNCT_timestamp:
         FileEntry.ModTime = Value.getAsUnsignedConstant().getValue();
         break;
       case DW_LNCT_size:
void DWARFDebugLine::Sequence::reset() {
   HighPC = 0;
   FirstRowIndex = 0;
   LastRowIndex = 0;
   Empty = true;
 }
 
 DWARFDebugLine::LineTable::LineTable() { clear(); }
 
-void DWARFDebugLine::LineTable::dump(raw_ostream &OS) const {
-  Prologue.dump(OS);
+void DWARFDebugLine::LineTable::dump(raw_ostream &OS,
+                                     DIDumpOptions DumpOptions) const {
+  Prologue.dump(OS, DumpOptions);
   OS << '\n';
 
   if (!Rows.empty()) {
     Row::dumpTableHeader(OS);
     for (const Row &R : Rows) {
       R.dump(OS);
     }
   }
bool DWARFDebugLine::LineTable::parse(DWARFDataExtractor &DebugLineData,
   clear();
 
   if (!Prologue.parse(DebugLineData, OffsetPtr, Ctx, U)) {
     // Restore our offset and return false to indicate failure!
     *OffsetPtr = DebugLineOffset;
     return false;
   }
 
-  if (OS)
-    Prologue.dump(*OS);
+  if (OS) {
+    DIDumpOptions DumpOptions;
+    DumpOptions.Verbose = true;
+    Prologue.dump(*OS, DumpOptions);
+  }
 
   const uint32_t EndOffset =
       DebugLineOffset + Prologue.TotalLength + Prologue.sizeofTotalLength();
 
   // See if we should tell the data extractor the address size.
   if (DebugLineData.getAddressSize() == 0)
     DebugLineData.setAddressSize(Prologue.getAddressSize());
   else
if (Opcode == 0) {
         // ignored for file names that represent full path names.
         //
         // The files are numbered, starting at 1, in the order in which they
         // appear; the names in the prologue come before names defined by
         // the DW_LNE_define_file instruction. These numbers are used in the
         // the file register of the state machine.
         {
           FileNameEntry FileEntry;
-          FileEntry.Name = DebugLineData.getCStr(OffsetPtr);
+          FileEntry.Name.setForm(dwarf::DW_FORM_string);
+          FileEntry.Name.setPValue(DebugLineData.getCStr(OffsetPtr));
           FileEntry.DirIdx = DebugLineData.getULEB128(OffsetPtr);
           FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr);
           FileEntry.Length = DebugLineData.getULEB128(OffsetPtr);
           Prologue.FileNames.push_back(FileEntry);
           if (OS)
-            *OS << " (" << FileEntry.Name.str()
+            *OS << " (" << FileEntry.Name.getAsCString().getValue()
                 << ", dir=" << FileEntry.DirIdx << ", mod_time="
                 << format("(0x%16.16" PRIx64 ")", FileEntry.ModTime)
                 << ", length=" << FileEntry.Length << ")";
         }
         break;
 
       case DW_LNE_set_discriminator:
         State.Row.Discriminator = DebugLineData.getULEB128(OffsetPtr);

 
 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];
-  StringRef FileName = Entry.Name;
+  StringRef FileName = Entry.Name.getAsCString().getValue();
   if (Kind != FileLineInfoKind::AbsoluteFilePath ||
       sys::path::is_absolute(FileName)) {
     Result = FileName;
     return true;
   }
 
   SmallString<16> FilePath;
   uint64_t IncludeDirIndex = Entry.DirIdx;
-  StringRef IncludeDir;
+  DWARFFormValue IncludeDir;
   // Be defensive about the contents of Entry.
   if (IncludeDirIndex > 0 &&
       IncludeDirIndex <= Prologue.IncludeDirectories.size())
     IncludeDir = Prologue.IncludeDirectories[IncludeDirIndex - 1];
+  else {
+    IncludeDir.setForm(dwarf::DW_FORM_string);
+    IncludeDir.setPValue("");
+  }
 
   // We may still need to append compilation directory of compile unit.
   // We know that FileName is not absolute, the only way to have an
   // absolute path at this point would be if IncludeDir is absolute.
   if (CompDir && Kind == FileLineInfoKind::AbsoluteFilePath &&
-      sys::path::is_relative(IncludeDir))
+      sys::path::is_relative(IncludeDir.getAsCString().getValue()))
     sys::path::append(FilePath, CompDir);
 
   // sys::path::append skips empty strings.
-  sys::path::append(FilePath, IncludeDir, FileName);
+  sys::path::append(FilePath, IncludeDir.getAsCString().getValue(), FileName);
   Result = FilePath.str();
   return true;
 }
 
 bool DWARFDebugLine::LineTable::getFileLineInfoForAddress(
     uint64_t Address, const char *CompDir, FileLineInfoKind Kind,
     DILineInfo &Result) const {
   // Get the index of row we're looking for in the line table.

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   case DW_FORM_GNU_str_index:
   case DW_FORM_GNU_strp_alt:
     return (FC == FC_String);
   default:
     break;
   }
   // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
   // Don't check for DWARF version here, as some producers may still do this
-  // by mistake. Also accept DW_FORM_strp since this is .debug_str section
-  // offset.
+  // by mistake. Also accept DW_FORM_[line_]strp since these are
+  // .debug_[line_]str section offsets.
   return (Form == DW_FORM_data4 || Form == DW_FORM_data8 ||
-          Form == DW_FORM_strp) &&
+          Form == DW_FORM_strp || Form == DW_FORM_line_strp) &&
          FC == FC_SectionOffset;
 }
 
 bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
                                   uint32_t *OffsetPtr, DWARFFormParams FP,
                                   const DWARFContext *Ctx,
                                   const DWARFUnit *CU) {
   if (!Ctx && CU)
void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   case DW_FORM_udata:
     OS << Value.uval;
     break;
   case DW_FORM_strp:
     if (DumpOpts.Verbose)
       OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)UValue);
     dumpString(OS);
     break;
+  case DW_FORM_line_strp:
+    if (DumpOpts.Verbose)
+      OS << format(" .debug_line_str[0x%8.8x] = ", (uint32_t)UValue);
+    dumpString(OS);
+    break;
   case DW_FORM_strx:
   case DW_FORM_strx1:
   case DW_FORM_strx2:
   case DW_FORM_strx3:
   case DW_FORM_strx4:
   case DW_FORM_GNU_str_index:
     if (DumpOpts.Verbose)
       OS << format(" indexed (%8.8x) string = ", (uint32_t)UValue);

llvm/test/CodeGen/BPF/dwarfdump.ll

 !21 = !{!"int", !22, i64 0}
 !22 = !{!"omnipotent char", !23, i64 0}
 !23 = !{!"Simple C/C++ TBAA"}
 !24 = !DILocation(line: 5, column: 27, scope: !2)
 !25 = !DILocation(line: 7, column: 27, scope: !2)
 !26 = !DILocation(line: 7, column: 17, scope: !2)
 !27 = !DILocation(line: 9, column: 9, scope: !2)
 
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 testprog.c
+; CHECK: file_names[  1]    0 0x00000000 0x00000000 "testprog.c"
 ; CHECK: 0x0000000000000000      2
 ; CHECK: 0x0000000000000020      7

llvm/test/CodeGen/Generic/dwarf-md5.ll

 ; RUN: %llc_dwarf -dwarf-version 5 -filetype=obj -o %t5.o %s
 ; RUN: llvm-dwarfdump -debug-line %t5.o | FileCheck %s --check-prefix=OBJ-5
 
 ; FIXME: Need to convey the MD5 for the primary source file.
 ; ASM: .file 1 ".{{/|\\\\}}t1.h" md5 "11111111111111111111111111111111"
 ; ASM: .file 2 ".{{/|\\\\}}t2.h" md5 "22222222222222222222222222222222"
 
 ; OBJ-4: Dir Mod Time File Len File Name
-; OBJ-4: file_names[ 1] 1 0x00000000 0x00000000 t1.h
-; OBJ-4: file_names[ 2] 1 0x00000000 0x00000000 t2.h
+; OBJ-4: file_names[ 1] 1 0x00000000 0x00000000 "t1.h"
+; OBJ-4: file_names[ 2] 1 0x00000000 0x00000000 "t2.h"
 
 ; OBJ-5: Dir MD5 Checksum File Name
-; OBJ-5: file_names[ 1] 1 11111111111111111111111111111111 t1.h
-; OBJ-5: file_names[ 2] 1 22222222222222222222222222222222 t2.h
+; OBJ-5: file_names[ 1] 1 11111111111111111111111111111111 "t1.h"
+; OBJ-5: file_names[ 2] 1 22222222222222222222222222222222 "t2.h"
 
 ; ModuleID = 't.c'
 source_filename = "t.c"
 
 @t1 = global i32 1, align 4, !dbg !0
 @t2 = global i32 0, align 4, !dbg !6
 
 !llvm.dbg.cu = !{!2}

llvm/test/CodeGen/X86/dwarf-comp-dir.ll

 !3 = !DIFile(filename: "empty.c", directory: "/home/nlewycky")
 !4 = !DIFile(filename: "empty.c", directory: "/home/nlewycky")
 !6 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", line: 1, size: 8, align: 8, file: !4, elements: !2, identifier: "_ZTS3foo")
 !7 = !{!6}
 
 ; The important part of the following check is that dir = #0.
 ;                        Dir  Mod Time   File Len   File Name
 ;                        ---- ---------- ---------- ---------------------------
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 empty.c
+; CHECK: file_names[  1]    0 0x00000000 0x00000000 "empty.c"
 !5 = !{i32 1, !"Debug Info Version", i32 3}

llvm/test/DebugInfo/AMDGPU/dwarfdump-relocs.ll

 ; RUN: llc -O0 -mtriple=amdgcn--amdhsa -mcpu=fiji -verify-machineinstrs -filetype=obj < %s | llvm-dwarfdump -v - 2>&1 | FileCheck %s
 
 ; LLVM IR generated with the following command and OpenCL source:
 ;
 ; $clang -cl-std=CL2.0 -g -O0 -target amdgcn-amd-amdhsa -S -emit-llvm <path-to-file>
 ;
 ; kernel void kernel1(global int *A) {
 ;   *A = 11;
 ; }
 ;
 ; kernel void kernel2(global int *B) {
 ;   *B = 12;
 ; }
 
 ; CHECK-NOT: failed to compute relocation
-; CHECK: file_names[  1] 0 0x00000000 0x00000000 dwarfdump-relocs.cl
+; CHECK: file_names[  1] 0 0x00000000 0x00000000 "dwarfdump-relocs.cl"
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 define amdgpu_kernel void @kernel1(i32 addrspace(1)* %A) !dbg !7 {
 entry:
   %A.addr = alloca i32 addrspace(1)*, align 4
   store i32 addrspace(1)* %A, i32 addrspace(1)** %A.addr, align 4
   call void @llvm.dbg.declare(metadata i32 addrspace(1)** %A.addr, metadata !16, metadata !17), !dbg !18

llvm/test/DebugInfo/Generic/lto-comp-dir.ll

 ; REQUIRES: object-emission
 
 ; RUN: %llc_dwarf < %s -filetype=obj | llvm-dwarfdump -debug-line - | FileCheck %s
 ; RUN: %llc_dwarf < %s -filetype=asm | FileCheck --check-prefix=ASM %s
 
 ; If multiple line tables are emitted, one per CU, those line tables can
 ; unambiguously rely on the comp_dir of their owning CU and use directory '0'
 ; to refer to it.
 
 ; CHECK: .debug_line contents:
 ; CHECK-NEXT: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NOT: include_directories
-; CHECK: file_names[   1]   0 {{.*}} a.cpp
+; CHECK: file_names[   1]   0 {{.*}} "a.cpp"
 ; CHECK-NOT: file_names
 
 ; CHECK: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NOT: include_directories
-; CHECK: file_names[   1]   0 {{.*}} b.cpp
+; CHECK: file_names[   1]   0 {{.*}} "b.cpp"
 ; CHECK-NOT: file_names
 
 ; However, if a single line table is emitted and shared between CUs, the
 ; comp_dir is ambiguous and relying on it would lead to different path
 ; interpretations depending on which CU lead to the table - so ensure that
 ; full paths are always emitted in this case, never comp_dir relative.
 
 ; ASM: .file   1 "/tmp/dbginfo/a{{[/\\]+}}a.cpp"

llvm/test/DebugInfo/X86/dwarfdump-header-64.s

 # CHECK-LABEL: .debug_line contents:
 # CHECK: Line table prologue:
 # CHECK: total_length: 0x00000050
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: prologue_length: 0x00000044
 # CHECK: max_ops_per_inst: 1
-# CHECK: include_directories[  0] = 'Directory5a'
-# CHECK: include_directories[  1] = 'Directory5b'
+# CHECK: include_directories[  0] = .debug_str[0x00000028] = "Directory5a"
+# CHECK: include_directories[  1] = .debug_str[0x00000034] = "Directory5b"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  1]    0 0x00000051 0x00000052 File5a{{$}}
-# CHECK: file_names[  2]    1 0x00000053 0x00000054 File5b{{$}}
+# CHECK: file_names[  1]    0 0x00000051 0x00000052 "File5a"
+# CHECK: file_names[  2]    1 0x00000053 0x00000054 "File5b"
 # CHECK-NOT: file_names

llvm/test/DebugInfo/X86/dwarfdump-header.s

LH_4_header_end:
         # Line number program, which is empty.
 LH_4_end:
 
 # CHECK: Line table prologue:
 # CHECK: version: 4
 # CHECK-NOT: address_size
 # CHECK-NOT: seg_select_size
 # CHECK: max_ops_per_inst: 1
-# CHECK: include_directories[  1] = 'Directory4a'
-# CHECK: include_directories[  2] = 'Directory4b'
+# CHECK: include_directories[  1] = "Directory4a"
+# CHECK: include_directories[  2] = "Directory4b"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  1]    1 0x00000041 0x00000042 File4a{{$}}
-# CHECK: file_names[  2]    0 0x00000043 0x00000044 File4b{{$}}
+# CHECK: file_names[  1]    1 0x00000041 0x00000042 "File4a"
+# CHECK: file_names[  2]    0 0x00000043 0x00000044 "File4b"
 # CHECK-NOT: file_names
 
 # DWARF v5 line-table header.
 LH_5_start:
         .long   LH_5_end-LH_5_version   # Length of Unit
 LH_5_version:
         .short  5               # DWARF version number
         .byte   8               # Address Size
LH_5_header_end:
         # Line number program, which is empty.
 LH_5_end:
 
 # CHECK: Line table prologue:
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: max_ops_per_inst: 1
-# CHECK: include_directories[  0] = 'Directory5a'
-# CHECK: include_directories[  1] = 'Directory5b'
+# CHECK: include_directories[  0] = .debug_str[0x00000045] = "Directory5a"
+# CHECK: include_directories[  1] = .debug_str[0x00000051] = "Directory5b"
 # CHECK-NOT: include_directories
 # CHECK: MD5 Checksum
-# CHECK: file_names[  1]    0 00112233445566778899aabbccddeeff File5a{{$}}
-# CHECK: file_names[  2]    1 ffeeddccbbaa99887766554433221100 File5b{{$}}
+# CHECK: file_names[  1]    0 00112233445566778899aabbccddeeff .debug_line_str[0x00000000] = "File5a"
+# CHECK: file_names[  2]    1 ffeeddccbbaa99887766554433221100 .debug_line_str[0x00000007] = "File5b"
 # CHECK-NOT: file_names
 
         .section .debug_line_str,"MS",@progbits,1
 lstr_LT_5a:
         .asciz "File5a"
 lstr_LT_5b:
         .asciz "File5b"
 
dwo_LH_5_header_end:
         # Line number program, which is empty.
 dwo_LH_5_end:
 
 # CHECK: Line table prologue:
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: max_ops_per_inst: 1
-# CHECK: include_directories[  0] = 'DWODirectory5a'
-# CHECK: include_directories[  1] = 'DWODirectory5b'
+# CHECK: include_directories[  0] = .debug_str[0x0000003d] = "DWODirectory5a"
+# CHECK: include_directories[  1] = .debug_str[0x0000004c] = "DWODirectory5b"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  1]    0 0x00000015 0x00000025 DWOFile5a{{$}}
-# CHECK: file_names[  2]    1 0x00000035 0x00000045 DWOFile5b{{$}}
+# CHECK: file_names[  1]    0 0x00000015 0x00000025 "DWOFile5a"
+# CHECK: file_names[  2]    1 0x00000035 0x00000045 "DWOFile5b"
 # CHECK-NOT: file_names

llvm/test/DebugInfo/X86/dwarfdump-line-dwo.s

 LH_1_header_end:
         # Line number program, which is empty.
 LH_1_end:
 
 # PART1:      Line table prologue:
 # PART1-NEXT: total_length: 0x0000002e
 # PART1-NEXT: version: 4
 # PART1-NEXT: prologue_length: 0x00000028
-# PART1:      include_directories[  1] = 'Directory1'
-# PART1:      file_names[  1] {{.*}} File1
+# PART1:      include_directories[  1] = "Directory1"
+# PART1:      file_names[  1] {{.*}} "File1"
 
 # Second line table.
 LH_2_start:
         .long   LH_2_end-LH_2_version   # Length of Unit
 LH_2_version:
         .short  4               # DWARF version number
         .long   LH_2_header_end-LH_2_params     # Length of Prologue
 LH_2_params:
LH_2_header_end:
         # Line number program, which is empty.
 LH_2_end:
 
 # PART2:      Line table prologue:
 # PART2-NEXT: total_length: 0x00000028
 # PART2-NEXT: version: 4
 # PART2-NEXT: prologue_length: 0x00000022
 # PART2-NOT:  prologue:
-# PART2:      include_directories[  1] = 'Dir2'
-# PART2:      file_names[  1] {{.*}} File2
+# PART2:      include_directories[  1] = "Dir2"
+# PART2:      file_names[  1] {{.*}} "File2"
 # PART2-NOT:  prologue:

llvm/test/DebugInfo/X86/dwarfdump-line-only.s

 ls_F1:  .asciz "File1"
 ls_F2:  .asciz "File2"
 
 # CHECK: Line table prologue:
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: max_ops_per_inst: 1
-# CHECK: include_directories[  0] = 'Directory1'
-# CHECK: include_directories[  1] = 'Directory2'
+# CHECK: include_directories[  0] = .debug_str[0x00000000] = "Directory1"
+# CHECK: include_directories[  1] = .debug_str[0x0000000b] = "Directory2"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  1]    1 0x00000051 0x00000052 File1{{$}}
-# CHECK: file_names[  2]    0 0x00000053 0x00000054 File2{{$}}
+# CHECK: file_names[  1]    1 0x00000051 0x00000052 .debug_line_str[0x00000000] = "File1"
+# CHECK: file_names[  2]    0 0x00000053 0x00000054 .debug_line_str[0x00000006] = "File2"
 # CHECK-NOT: file_names
 # CHECK: 0x0000000000000000 {{.*}} is_stmt end_sequence

llvm/test/DebugInfo/X86/generate-odr-hash.ll

 ; CHECK-NOT: DW_AT_name
 ; CHECK-NOT: DW_AT_GNU_odr_signature
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"a"
 
 ; CHECK-LABEL: .debug_line contents:
 ; CHECK: Line table prologue
 ; CHECK-NOT: file_names[
-; SINGLE: file_names{{.*}} bar.h
-; CHECK: file_names{{.*}} bar.cpp
+; SINGLE: file_names{{.*}} "bar.h"
+; CHECK: file_names{{.*}} "bar.cpp"
 ; CHECK-NOT: file_names[
 
 ; FISSION: .debug_line.dwo contents:
 ; CHECK-NOT: .debug_line.dwo contents:
 ; FISSION: Line table prologue
 ; FISSION: opcode_base: 1
 ; FISSION-NOT: standard_opcode_lengths
 ; FISSION-NOT: include_directories
 ; FISSION-NOT: file_names[
-; FISSION: file_names{{.*}} bar.h
-; FISSION: file_names{{.*}} bar.cpp
+; FISSION: file_names{{.*}} "bar.h"
+; FISSION: file_names{{.*}} "bar.cpp"
 ; FISSION-NOT: file_names[
 
 ; CHECK-LABEL: .debug_str contents:
 
 ; Use the unit size as a rough hash/identifier for the unit we're dealing with
 ; it happens to be unambiguous at the moment, but it's hardly ideal.
 ; CHECK-LABEL: .debug_pubtypes contents:
 ; Don't emit pubtype entries for type DIEs in the compile unit that just indirect to a type unit.

llvm/test/DebugInfo/X86/stmt-list-multiple-compile-units.ll

 ; CHECK: DW_AT_low_pc [DW_FORM_addr]            (0x0000000000000010)
 ; CHECK: DW_AT_high_pc [DW_FORM_data4]          (0x00000009)
 
 
 ; CHECK: .debug_line contents:
 ; CHECK-NEXT: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NEXT: total_length: 0x00000038
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 simple.c
+; CHECK: file_names[  1]    0 0x00000000 0x00000000 "simple.c"
 ; CHECK: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NEXT: total_length: 0x00000039
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 simple2.c
+; CHECK: file_names[  1]    0 0x00000000 0x00000000 "simple2.c"
 ; CHECK-NOT: file_names
 
 ; DWARF3: .debug_info contents:
 ; DWARF3: DW_TAG_compile_unit
 ; DWARF3: DW_AT_stmt_list [DW_FORM_data4]    (0x00000000)
 
 ; DWARF3: DW_TAG_compile_unit
 ; DWARF3: DW_AT_stmt_list [DW_FORM_data4]   (0x0000003c)
 
 
 ; DWARF3: .debug_line contents:
 ; DWARF3-NEXT: debug_line[{{.*}}]
 ; DWARF3-NEXT: Line table prologue:
 ; DWARF3-NEXT: total_length: 0x00000038
-; DWARF3: file_names[  1]    0 0x00000000 0x00000000 simple.c
+; DWARF3: file_names[  1]    0 0x00000000 0x00000000 "simple.c"
 ; DWARF3: debug_line[{{.*}}]
 ; DWARF3-NEXT: Line table prologue:
 ; DWARF3-NEXT: total_length: 0x00000039
-; DWARF3: file_names[  1]    0 0x00000000 0x00000000 simple2.c
+; DWARF3: file_names[  1]    0 0x00000000 0x00000000 "simple2.c"
 ; DWARF3-NOT: file_names
 
 ; PR15408
 ; ASM: Lcu_begin0:
 ; ASM-NOT: Lcu_begin
 ; ASM: Lset[[LT:[0-9]+]] = Lline_table_start0-Lsection_line ## DW_AT_stmt_list
 ; ASM-NEXT: .long   Lset[[LT]]
 ; ASM: Lcu_begin1:

llvm/test/DebugInfo/debugmacinfo.test

 TEST_MACINFO:   DW_MACINFO_start_file - lineno: 2 filenum: 3
 TEST_MACINFO:     DW_MACINFO_undef - lineno: 4 macro: M1
 TEST_MACINFO:     DW_MACINFO_define - lineno: 5 macro: M1 NewValue1
 TEST_MACINFO:   DW_MACINFO_end_file
 TEST_MACINFO:   DW_MACINFO_define - lineno: 3 macro: M2(x,y) ((x)+(y)* Value2)
 TEST_MACINFO: DW_MACINFO_end_file
 
 TEST_LINE: .debug_line contents:
-TEST_LINE: file_names[  1]    0 0x00000000 0x00000000 dwarfdump-macro.cc
-TEST_LINE: file_names[  2]    1 0x00000000 0x00000000 dwarfdump-macro-cmd.h
-TEST_LINE: file_names[  3]    0 0x00000000 0x00000000 dwarfdump-macro.h
+TEST_LINE: file_names[  1]    0 0x00000000 0x00000000 "dwarfdump-macro.cc"
+TEST_LINE: file_names[  2]    1 0x00000000 0x00000000 "dwarfdump-macro-cmd.h"
+TEST_LINE: file_names[  3]    0 0x00000000 0x00000000 "dwarfdump-macro.h"

llvm/test/Linker/subprogram-linkonce-weak.ll

 ; DWWL:         DW_AT_decl_file {{.*}}"/path/to/dir{{/|\\}}bar.c"
 ; DWWL:         DW_AT_decl_line {{.*}}(11)
 ; DWWL:         DW_TAG_inlined_subroutine
 ; DWWL:           DW_AT_abstract_origin
 
 ; DW-LABEL:   .debug_line contents:
 ; Check that we have the right things in the line table as well.
 
-; DWLW-LABEL: file_names[{{ *}}1]{{.*}} bar.c
+; DWLW-LABEL: file_names[{{ *}}1]{{.*}} "bar.c"
 ; DWLW:        2 0 1 0 0 is_stmt prologue_end
-; DWLW-LABEL: file_names[{{ *}}1]{{.*}} foo.c
+; DWLW-LABEL: file_names[{{ *}}1]{{.*}} "foo.c"
 ; DWLW:       52 0 1 0 0 is_stmt prologue_end
 ; DWLW-NOT:                      prologue_end
 
-; DWWL-LABEL: file_names[{{ *}}1]{{.*}} foo.c
+; DWWL-LABEL: file_names[{{ *}}1]{{.*}} "foo.c"
 ; DWWL:       52 0 1 0 0 is_stmt prologue_end
-; DWWL-LABEL: file_names[{{ *}}1]{{.*}} bar.c
+; DWWL-LABEL: file_names[{{ *}}1]{{.*}} "bar.c"
 ; DWWL:        2 0 1 0 0 is_stmt prologue_end
 ; DWWL-NOT:                      prologue_end

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

 // DWARF-NEXT: Address Range Header: length = 0x00000024, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x04, seg_size = 0x00
 // DWARF-NEXT: [0x00000000, 0x00000004)
 // DWARF-NEXT: [0x00000000, 0x00000004)
 
 
 // DWARF-DL: .debug_line contents:
 // DWARF-DL: version: [[DWVER]]
 // DWARF-DL-5:    address_size: 4
-// DWARF-DL-5:    include_directories[  0] = ''
-// DWARF-DL:      file_names[  1] {{.*}} <stdin>
+// DWARF-DL-5:    include_directories[  0] = ""
+// DWARF-DL:      file_names[  1] {{.*}} "<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: .debug_ranges contents:
 // DWARF: 00000000 ffffffff 00000000

llvm/test/MC/ELF/debug-md5.s

 // RUN: llvm-mc -triple x86_64-unknown-unknown -dwarf-version 5 -filetype=obj %s -o -| llvm-dwarfdump --debug-line - | FileCheck %s
 
         .file 1 "dir1/foo"   md5 "00112233445566778899aabbccddeeff"
         .file 2 "dir2" "bar" md5 "ffeeddccbbaa99887766554433221100"
         .loc 1 1 0
         nop
         .loc 2 1 0
         nop
 
 # CHECK: debug_line[0x00000000]
 # CHECK: version: 5
-# CHECK: include_directories[ 0] = ''
-# CHECK: include_directories[ 1] = 'dir1'
-# CHECK: include_directories[ 2] = 'dir2'
+# CHECK: include_directories[ 0] = ""
+# CHECK: include_directories[ 1] = "dir1"
+# CHECK: include_directories[ 2] = "dir2"
 # CHECK-NOT: include_directories
 # CHECK: Dir MD5 Checksum File Name
-# CHECK: file_names[ 1] 1 00112233445566778899aabbccddeeff foo
-# CHECK: file_names[ 2] 2 ffeeddccbbaa99887766554433221100 bar
+# CHECK: file_names[ 1] 1 00112233445566778899aabbccddeeff "foo"
+# CHECK: file_names[ 2] 2 ffeeddccbbaa99887766554433221100 "bar"

llvm/test/MC/MachO/gen-dwarf-cpp.s

 // RUN: llvm-mc -g -triple i386-apple-darwin10 %s -filetype=obj -o %t
 // RUN: llvm-dwarfdump -debug-line %t | FileCheck %s
 
 # 100 "t.s" 1
 .globl _bar
 _bar:
   movl  $0, %eax
 # 3 "inc/g.s"
   movl  $0, %eax
 L1: leave
 # 42 "t.s"
   ret
 
 // rdar://9275556
 
 // We check that the source name "t.s" is picked up
-// CHECK: include_directories[  1] = '{{.*[/\\]}}test{{[/\\]}}MC{{[/\\]}}MachO'
-// CHECK: include_directories[  2] = 'inc'
+// CHECK: include_directories[  1] = "{{.*[/\\]}}test{{[/\\]}}MC{{[/\\]}}MachO"
+// CHECK: include_directories[  2] = "inc"
 // CHECK:                 Dir  Mod Time   File Len   File Name
 // CHECK:                 ---- ---------- ---------- ---------------------------
-// CHECK: file_names[  1]    1 0x00000000 0x00000000 gen-dwarf-cpp.s
-// CHECK: file_names[  2]    0 0x00000000 0x00000000 t.s
-// CHECK: file_names[  3]    2 0x00000000 0x00000000 g.s
+// CHECK: file_names[  1]    1 0x00000000 0x00000000 "gen-dwarf-cpp.s"
+// CHECK: file_names[  2]    0 0x00000000 0x00000000 "t.s"
+// CHECK: file_names[  3]    2 0x00000000 0x00000000 "g.s"
 // CHECK-NOT: file_names
 
 // We check that the source line number 100 is picked up before the "movl"
 // CHECK: Address            Line   Column File   ISA Discriminator Flags
 // CHECK: ------------------ ------ ------ ------ --- ------------- -------------
 // CHECK: 0x0000000000000000    102      0      2   0             0  is_stmt

llvm/test/MC/MachO/gen-dwarf-macro-cpp.s

 // RUN: llvm-mc -g -triple i386-apple-darwin10 %s -filetype=obj -o %t
 // RUN: llvm-dwarfdump -debug-line %t | FileCheck %s
 
 # 1 "foo.S" 2
 .macro switcher
         ljmp *0x38(%ecx)
 .endmacro
         switcher NaClSwitchNoSSE, 0
 
 // PR14264 was a crash in the code caused by the .macro not handled correctly
 // rdar://12637628
 
 // We check that the source name "foo.S" is picked up
 // CHECK:                 Dir  Mod Time   File Len   File Name
 // CHECK:                 ---- ---------- ---------- ---------------------------
-// CHECK: file_names[  1]    1 0x00000000 0x00000000 gen-dwarf-macro-cpp.s
-// CHECK: file_names[  2]    0 0x00000000 0x00000000 foo.S
+// CHECK: file_names[  1]    1 0x00000000 0x00000000 "gen-dwarf-macro-cpp.s"
+// CHECK: file_names[  2]    0 0x00000000 0x00000000 "foo.S"

llvm/test/MC/MachO/gen-dwarf.s

 // CHECK: standard_opcode_lengths[DW_LNS_const_add_pc] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_fixed_advance_pc] = 1
 // CHECK: standard_opcode_lengths[DW_LNS_set_prologue_end] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_set_epilogue_begin] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_set_isa] = 1
 // We don't check include_directories as it has a temp path
 // CHECK:                 Dir  Mod Time   File Len   File Name
 // CHECK:                 ---- ---------- ---------- ---------------------------
-// CHECK: file_names[  1]    1 0x00000000 0x00000000 gen-dwarf.s
+// CHECK: file_names[  1]    1 0x00000000 0x00000000 "gen-dwarf.s"
 
 // CHECK: Address            Line   Column File   ISA Discriminator Flags
 // CHECK: ------------------ ------ ------ ------ --- ------------- -------------
 // CHECK: 0x0000000000000000      6      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000005      7      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000006      8      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000007     11      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000008     11      0      1   0             0  is_stmt end_sequence

llvm/test/tools/dsymutil/X86/basic-linking-x86.test

 CHECK-NEXT:[0x0000000100000f20, 0x0000000100000f37)
 CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000126, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT:[0x0000000100000f40, 0x0000000100000f84)
 CHECK-NEXT:[0x0000000100000f90, 0x0000000100000fa9)
 
 CHECK: .debug_line contents:
 CHECK:                Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic1.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic1.c"
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000ea0     23      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000eb6     24      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000ec4     24      0      1   0             0  is_stmt end_sequence
 
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic2.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic2.c"
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000ed0     19      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000ee2     20      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f19     20      0      1   0             0  is_stmt end_sequence
 CHECK-NEXT: 0x0000000100000f20     14      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f24     15      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f37     15      0      1   0             0  is_stmt end_sequence
 
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic3.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic3.c"
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f40     16      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f4b     17      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f58     18      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f6c     19      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f7b     20      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f84     20      0      1   0             0  is_stmt end_sequence

llvm/test/tools/dsymutil/X86/basic-lto-dw4-linking-x86.test

 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000077, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f87)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000011b, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 CHECK: .debug_line contents:
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic1.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic1.c"
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f40     26      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f44     27     10      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f49     27      3      1   0             0
 CHECK-NEXT: 0x0000000100000f4b     27      3      1   0             0  end_sequence
 
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic2.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic2.c"
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f50     19      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f54     20     18      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f5a     20     17      1   0             0
 CHECK-NEXT: 0x0000000100000f5c     20     10      1   0             0
 CHECK-NEXT: 0x0000000100000f61     15     10      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f70     20     23      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f74     20     36      1   0             0
 CHECK-NEXT: 0x0000000100000f83     20     31      1   0             0
 CHECK-NEXT: 0x0000000100000f85     20      3      1   0             0
 CHECK-NEXT: 0x0000000100000f87     20      3      1   0             0  end_sequence
 
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic3.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic3.c"
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f90     16      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f94     12     10      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f9a     17      7      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f9f     12     10      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fa7     20      1      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fa9     19     18      1   0             0  is_stmt

llvm/test/tools/dsymutil/X86/basic-lto-linking-x86.test

 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f89)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000013a, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 
 CHECK: .debug_line contents
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic1.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic1.c"
 CHECK: 0x0000000100000f40     23      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f44     24      0      1   0             0  is_stmt prologue_end
 CHECK: 0x0000000100000f4b     24      0      1   0             0  is_stmt end_sequence
 
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic2.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic2.c"
 CHECK: 0x0000000100000f50     19      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f54     20      0      1   0             0  is_stmt prologue_end
 CHECK: 0x0000000100000f63     15      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f72     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f89     20      0      1   0             0  is_stmt end_sequence
 
 CHECK:                 Dir  Mod Time   File Len   File Name
 CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 basic3.c
+CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic3.c"
 CHECK: 0x0000000100000f90     16      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f94     12      0      1   0             0  is_stmt prologue_end
 CHECK: 0x0000000100000f9a     17      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f9f     12      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fa7     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fa9     19      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fb2     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fb4     20      0      1   0             0  is_stmt end_sequence