[LLDB] - Improved DWARF5 support.

[grimar]

Summary

This patch improves the support of DWARF5 by lldb.

Imagine we have the following code,
(compiled with clang++ test.cpp -g -o test -gdwarf-5):

struct XXX {
  int A;
};

int main() {
  XXX Obj;
  Obj.A = 1;
  return Obj.A;
}

Without this patch when lldb stops on a breakpoint or dump variables
the output is:

(lldb) b main
warning: (x86_64) /home/umb/tests_2018/95_lldb/repro/dwarf5_nosplit/test unsupported DW_FORM value: 0x25
Breakpoint 1: where = test`main, address = 0x0000000000400550
(lldb) run
Process 5589 launched: '/home/umb/tests_2018/95_lldb/repro/dwarf5_nosplit/test' (x86_64)
Process 5589 stopped
* thread #1, name = 'test', stop reason = breakpoint 1.1
    frame #0: 0x0000000000400550 test`main
test`main:
->  0x400550 <+0>:  pushq  %rbp
    0x400551 <+1>:  movq   %rsp, %rbp
    0x400554 <+4>:  movl   $0x0, -0x4(%rbp)
    0x40055b <+11>: movl   $0x1, -0x8(%rbp)
(lldb) script
Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
>>> print lldb.frame.GetVariables(True, True, True, True)
<empty> lldb.SBValueList()

Note that it complains about unknown forms,
there is no code source lines and output from the print
call is empty.

With the patch applied output becomes:

umb@umb-virtual-machine:~/LLVM/build_lldb/bin$ ./lldb ~/tests_2018/95_lldb/repro/dwarf5_nosplit/test
(lldb) target create "/home/umb/tests_2018/95_lldb/repro/dwarf5_nosplit/test"
Current executable set to '/home/umb/tests_2018/95_lldb/repro/dwarf5_nosplit/test' (x86_64).
(lldb) b main
Breakpoint 1: where = test`main + 11 at test.cpp:7, address = 0x000000000040055b
(lldb) run
Process 63624 launched: '/home/umb/tests_2018/95_lldb/repro/dwarf5_nosplit/test' (x86_64)
Process 63624 stopped
* thread #1, name = 'test', stop reason = breakpoint 1.1
    frame #0: 0x000000000040055b test`main at test.cpp:7
   4   	
   5   	int main() {
   6   	  XXX Obj;
-> 7   	  Obj.A = 1;
   8   	
   9   	  return Obj.A;
   10  	}
(lldb) script
Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
>>> print lldb.frame.GetVariables(True, True, True, True)
(XXX) Obj = (A = 0)

Note there is no test case yet, I am going to add it to this revision soon.
This is my first patch for lldb and I did not yet learn how to write the
test for the code written.
I would be happy to see any comments/suggestions.

[grimar]

• Minor cosmetic cleanup.

[clayborg]

Nice patch! A few minor fixes, see inlined comments.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

78

Rename to GetHeaderByteSize() and do:

uint32_t DWARFCompileUnit::GetHeaderByteSize() {
  if (m_version < 5)
    return m_is_dwarf64 ? 23 : 11;
  switch (m_unit_type) {
    case llvm::dwarf::DW_UT_compile:
    case llvm::dwarf::DW_UT_partial:
      return 12;
    case llvm::dwarf::DW_UT_skeleton:
    case llvm::dwarf::DW_UT_split_compile:
      return 20;
    case llvm::dwarf::DW_UT_type:
    case llvm::dwarf::DW_UT_split_type:
      return 24;
  }
  llvm_unreachable("invalid UnitType.");
}

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

38–42

Move this to .cpp file and inline contents of GetDWARF5HeaderSize() into the the body of the function.

45

Remove this

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

442

"dirCount" is documented in the DWARF 5 spec to be a "ubyte" not a ULEB128

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

557–558

Revert signature and get info form m_cu. There are no other calls to AsCString() that manually specify a different symbol file and 64 bit value.

613–616

Remove this as there are no other calls to AsCString() that manually specify a different symbol file and 64 bit value.

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

77

This doesn't seem to be needed in this patch? The SymbolFileDWARF and Is64Bit can be grabbed from the m_cu

[grimar]

Thanks for the review, Greg! I'll address your comments and add the test case when it will be ready. Hope soon.

[grimar]

• Addressed review comments.
• Added test case.
• Minor cosmetic changes.

[grimar]

Will reupload.

[clayborg]

Patch looks good. A few fixes mentioned in inlined comments. And I am unsure how the test suite will run with various compilers if they don't support the -gdwarf-5 flag. We might need to run obj2yaml on a binary and then yaml2obj it for the test to ensure we can run the test. We might be able to just symbolicate a few addresses in the test instead of requiring us to run something.

include/lldb/lldb-enumerations.h

674

Add this after the eSectionTypeOther for backward compatibility.

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

442

We might verify that this is indeed correct by looking at compiler sources. Seems weird to limit dirs to 255

[grimar]

In D51935#1232195, @clayborg wrote:

Patch looks good. A few fixes mentioned in inlined comments. And I am unsure how the test suite will run with various compilers if they don't support the -gdwarf-5 flag. We might need to run obj2yaml on a binary and then yaml2obj it for the test to ensure we can run the test. We might be able to just symbolicate a few addresses in the test instead of requiring us to run something.

What about using the llvm-mc? I can convert c++ code to the assembler I think.
I'll try to investigate this problem tomorrow. Maybe we can just turn this test off somehow for that case.

[clayborg]

In D51935#1232203, @grimar wrote:

In D51935#1232195, @clayborg wrote:

Patch looks good. A few fixes mentioned in inlined comments. And I am unsure how the test suite will run with various compilers if they don't support the -gdwarf-5 flag. We might need to run obj2yaml on a binary and then yaml2obj it for the test to ensure we can run the test. We might be able to just symbolicate a few addresses in the test instead of requiring us to run something.

What about using the llvm-mc? I can convert c++ code to the assembler I think.
I'll try to investigate this problem tomorrow. Maybe we can just turn this test off somehow for that case.

Yeah, we want a test that goes along with this feature, but not sure how to test "does my compiler support this flag" in the test suite without reverting to llvm-mc or obj2yaml/yaml2obj

[probinson]

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

442

The directory count is a ULEB not a ubyte.

[grimar]

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

442

Oops. My mistake here, my initial version which used uleb128 was correct, but I looked at the wrong place too in the dwarf5 spec after that.

[grimar]

• Addressed comments.
• Changed test case to use yaml2obj.

[clayborg]

Thanks for doing all requested changes! Looks great.

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

442

I incorrectly skimmed the DWARF 5 spec and looked at "directory_entry_format_count (ubyte)" and missed that this was for the directory entry format count... directories_count is indeed ULEB128.

include/lldb/lldb-enumerations.h

enum SectionType {
   eSectionTypeCompactUnwind, // compact unwind section in Mach-O,
                              // __TEXT,__unwind_info
   eSectionTypeGoSymtab,
   eSectionTypeAbsoluteAddress, // Dummy section for symbols with absolute
                                // address
   eSectionTypeDWARFGNUDebugAltLink,
   eSectionTypeDWARFDebugTypes, // DWARF .debug_types section
   eSectionTypeDWARFDebugNames, // DWARF v5 .debug_names
+  eSectionTypeDWARFDebugLineStr, // DWARF v5 .debug_line_str
   eSectionTypeOther
 };
 
 FLAGS_ENUM(EmulateInstructionOptions){
     eEmulateInstructionOptionNone = (0u),
     eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
     eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
 

source/Core/Section.cpp

const char *Section::GetTypeAsCString() const {
   case eSectionTypeDWARFDebugCuIndex:
     return "dwarf-cu-index";
   case eSectionTypeDWARFDebugFrame:
     return "dwarf-frame";
   case eSectionTypeDWARFDebugInfo:
     return "dwarf-info";
   case eSectionTypeDWARFDebugLine:
     return "dwarf-line";
+  case eSectionTypeDWARFDebugLineStr:
+    return "dwarf-line-str";
   case eSectionTypeDWARFDebugLoc:
     return "dwarf-loc";
   case eSectionTypeDWARFDebugMacInfo:
     return "dwarf-macinfo";
   case eSectionTypeDWARFDebugMacro:
     return "dwarf-macro";
   case eSectionTypeDWARFDebugPubNames:
     return "dwarf-pubnames";

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

for (SectionHeaderCollIter I = m_section_headers.begin();
       static ConstString g_sect_name_tbss(".tbss");
       static ConstString g_sect_name_dwarf_debug_abbrev(".debug_abbrev");
       static ConstString g_sect_name_dwarf_debug_addr(".debug_addr");
       static ConstString g_sect_name_dwarf_debug_aranges(".debug_aranges");
       static ConstString g_sect_name_dwarf_debug_cu_index(".debug_cu_index");
       static ConstString g_sect_name_dwarf_debug_frame(".debug_frame");
       static ConstString g_sect_name_dwarf_debug_info(".debug_info");
       static ConstString g_sect_name_dwarf_debug_line(".debug_line");
+      static ConstString g_sect_name_dwarf_debug_line_str(".debug_line_str");
       static ConstString g_sect_name_dwarf_debug_loc(".debug_loc");
       static ConstString g_sect_name_dwarf_debug_macinfo(".debug_macinfo");
       static ConstString g_sect_name_dwarf_debug_macro(".debug_macro");
       static ConstString g_sect_name_dwarf_debug_names(".debug_names");
       static ConstString g_sect_name_dwarf_debug_pubnames(".debug_pubnames");
       static ConstString g_sect_name_dwarf_debug_pubtypes(".debug_pubtypes");
       static ConstString g_sect_name_dwarf_debug_ranges(".debug_ranges");
       static ConstString g_sect_name_dwarf_debug_str(".debug_str");
       static ConstString g_sect_name_dwarf_debug_str_offsets(
           ".debug_str_offsets");
       static ConstString g_sect_name_dwarf_debug_abbrev_dwo(
           ".debug_abbrev.dwo");
       static ConstString g_sect_name_dwarf_debug_info_dwo(".debug_info.dwo");
       static ConstString g_sect_name_dwarf_debug_line_dwo(".debug_line.dwo");
+      static ConstString g_sect_name_dwarf_debug_line_str_dwo(".debug_line_str.dwo");
       static ConstString g_sect_name_dwarf_debug_macro_dwo(".debug_macro.dwo");
       static ConstString g_sect_name_dwarf_debug_loc_dwo(".debug_loc.dwo");
       static ConstString g_sect_name_dwarf_debug_str_dwo(".debug_str.dwo");
       static ConstString g_sect_name_dwarf_debug_str_offsets_dwo(
           ".debug_str_offsets.dwo");
       static ConstString g_sect_name_dwarf_debug_types(".debug_types");
       static ConstString g_sect_name_eh_frame(".eh_frame");
       static ConstString g_sect_name_arm_exidx(".ARM.exidx");
for (SectionHeaderCollIter I = m_section_headers.begin();
       else if (name == g_sect_name_dwarf_debug_cu_index)
         sect_type = eSectionTypeDWARFDebugCuIndex;
       else if (name == g_sect_name_dwarf_debug_frame)
         sect_type = eSectionTypeDWARFDebugFrame;
       else if (name == g_sect_name_dwarf_debug_info)
         sect_type = eSectionTypeDWARFDebugInfo;
       else if (name == g_sect_name_dwarf_debug_line)
         sect_type = eSectionTypeDWARFDebugLine;
+      else if (name == g_sect_name_dwarf_debug_line_str)
+        sect_type = eSectionTypeDWARFDebugLineStr;
       else if (name == g_sect_name_dwarf_debug_loc)
         sect_type = eSectionTypeDWARFDebugLoc;
       else if (name == g_sect_name_dwarf_debug_macinfo)
         sect_type = eSectionTypeDWARFDebugMacInfo;
       else if (name == g_sect_name_dwarf_debug_macro)
         sect_type = eSectionTypeDWARFDebugMacro;
       else if (name == g_sect_name_dwarf_debug_names)
         sect_type = eSectionTypeDWARFDebugNames;
for (SectionHeaderCollIter I = m_section_headers.begin();
       else if (name == g_sect_name_dwarf_debug_str_offsets)
         sect_type = eSectionTypeDWARFDebugStrOffsets;
       else if (name == g_sect_name_dwarf_debug_abbrev_dwo)
         sect_type = eSectionTypeDWARFDebugAbbrev;
       else if (name == g_sect_name_dwarf_debug_info_dwo)
         sect_type = eSectionTypeDWARFDebugInfo;
       else if (name == g_sect_name_dwarf_debug_line_dwo)
         sect_type = eSectionTypeDWARFDebugLine;
+      else if (name == g_sect_name_dwarf_debug_line_str_dwo)
+        sect_type = eSectionTypeDWARFDebugLineStr;
       else if (name == g_sect_name_dwarf_debug_macro_dwo)
         sect_type = eSectionTypeDWARFDebugMacro;
       else if (name == g_sect_name_dwarf_debug_loc_dwo)
         sect_type = eSectionTypeDWARFDebugLoc;
       else if (name == g_sect_name_dwarf_debug_str_dwo)
         sect_type = eSectionTypeDWARFDebugStr;
       else if (name == g_sect_name_dwarf_debug_str_offsets_dwo)
         sect_type = eSectionTypeDWARFDebugStrOffsets;

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

public:
   const lldb_private::DWARFDataExtractor &GetData() const override;
 
   //------------------------------------------------------------------
   /// Get the size in bytes of the header.
   ///
   /// @return
   ///     Byte size of the compile unit header
   //------------------------------------------------------------------
   uint32_t GetHeaderByteSize() const override {
+    if (m_version >= 5)
+        return GetDWARF5HeaderSize(m_unit_type);
     return m_is_dwarf64 ? 23 : 11;
   }
 
 private:
+  static uint32_t GetDWARF5HeaderSize(uint8_t unitType);
+
   DWARFCompileUnit(SymbolFileDWARF *dwarf2Data);
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

DWARFUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
   cu_sp->m_offset = *offset_ptr;
 
   if (debug_info.ValidOffset(*offset_ptr)) {
     dw_offset_t abbr_offset;
     const DWARFDebugAbbrev *abbr = dwarf2Data->DebugAbbrev();
     cu_sp->m_length = debug_info.GetDWARFInitialLength(offset_ptr);
     cu_sp->m_is_dwarf64 = debug_info.IsDWARF64();
     cu_sp->m_version = debug_info.GetU16(offset_ptr);
+
+    if (cu_sp->m_version == 5) {
+      cu_sp->m_unit_type = debug_info.GetU8(offset_ptr);
+      cu_sp->m_addr_size = debug_info.GetU8(offset_ptr);
+      abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
+
+      if (cu_sp->m_unit_type == llvm::dwarf::DW_UT_skeleton)
+        cu_sp->m_dwo_id = debug_info.GetU64(offset_ptr);
+    } else {
       abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
       cu_sp->m_addr_size = debug_info.GetU8(offset_ptr);
+    }
 
     bool length_OK =
         debug_info.ValidOffset(cu_sp->GetNextCompileUnitOffset() - 1);
     bool version_OK = SymbolFileDWARF::SupportedVersion(cu_sp->m_version);
     bool abbr_offset_OK =
         dwarf2Data->get_debug_abbrev_data().ValidOffset(abbr_offset);
     bool addr_size_OK = (cu_sp->m_addr_size == 4) || (cu_sp->m_addr_size == 8);
 

 void DWARFCompileUnit::Dump(Stream *s) const {
   s->Printf("0x%8.8x: Compile Unit: length = 0x%8.8x, version = 0x%4.4x, "
             "abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "
             "{0x%8.8x})\n",
             m_offset, m_length, m_version, GetAbbrevOffset(), m_addr_size,
             GetNextCompileUnitOffset());
 }
 
+uint32_t DWARFCompileUnit::GetDWARF5HeaderSize(uint8_t unitType) {
+  switch (unitType) {
+  case llvm::dwarf::DW_UT_compile:
+  case llvm::dwarf::DW_UT_partial:
+    return 12;
+  case llvm::dwarf::DW_UT_skeleton:
+  case llvm::dwarf::DW_UT_split_compile:
+    return 20;
+  case llvm::dwarf::DW_UT_type:
+  case llvm::dwarf::DW_UT_split_type:
+    return 24;
+  }
+  llvm_unreachable("invalid UnitType.");
+}
 
 const lldb_private::DWARFDataExtractor &DWARFCompileUnit::GetData() const {
   return m_dwarf->get_debug_info_data();
 }

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

for (i = 0; i < numAttributes; ++i) {
           case DW_FORM_flag_present:
             form_size = 0;
             break;
 
           // 1 byte values
           case DW_FORM_data1:
           case DW_FORM_flag:
           case DW_FORM_ref1:
+          case DW_FORM_strx1:
             form_size = 1;
             break;
 
           // 2 byte values
           case DW_FORM_data2:
           case DW_FORM_ref2:
+          case DW_FORM_strx2:
             form_size = 2;
             break;
 
+          case DW_FORM_strx3:
+            form_size = 3;
+            break;
+
           // 4 byte values
           case DW_FORM_data4:
           case DW_FORM_ref4:
+          case DW_FORM_strx4:
             form_size = 4;
             break;
 
           // 8 byte values
           case DW_FORM_data8:
           case DW_FORM_ref8:
           case DW_FORM_ref_sig8:
             form_size = 8;
             break;
 
           // signed or unsigned LEB 128 values
           case DW_FORM_sdata:
           case DW_FORM_udata:
           case DW_FORM_ref_udata:
           case DW_FORM_GNU_addr_index:
           case DW_FORM_GNU_str_index:
+          case DW_FORM_strx:
             debug_info_data.Skip_LEB128(&offset);
             break;
 
           case DW_FORM_indirect:
             form_is_indirect = true;
             form = debug_info_data.GetULEB128(&offset);
             break;
 

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.h

 #include <string>
 #include <vector>
 
 #include "lldb/lldb-private.h"
 
 #include "DWARFDataExtractor.h"
 #include "DWARFDefines.h"
 
+#include "llvm/Support/MD5.h"
+
+class DWARFUnit;
 class SymbolFileDWARF;
 
 //----------------------------------------------------------------------
 // DWARFDebugLine
 //----------------------------------------------------------------------
 class DWARFDebugLine {
 public:
   //------------------------------------------------------------------
   // FileNameEntry
   //------------------------------------------------------------------
   struct FileNameEntry {
     FileNameEntry() : name(nullptr), dir_idx(0), mod_time(0), length(0) {}
 
     const char *name;
     dw_sleb128_t dir_idx;
     dw_sleb128_t mod_time;
     dw_sleb128_t length;
+    llvm::MD5::MD5Result Checksum;
   };
 
   //------------------------------------------------------------------
   // Prologue
   //------------------------------------------------------------------
   struct Prologue {
 
     Prologue()
         : total_length(0), version(0), prologue_length(0), min_inst_length(0),
           default_is_stmt(0), line_base(0), line_range(0), opcode_base(0),
           standard_opcode_lengths(), include_directories(), file_names() {}
 
     typedef std::shared_ptr<Prologue> shared_ptr;
 
     uint32_t total_length; // The size in bytes of the statement information for
                            // this compilation unit (not including the
                            // total_length field itself).
     uint16_t
         version; // Version identifier for the statement information format.
+
+    uint8_t address_size;
+    uint8_t segment_selector_size;
+
     uint32_t prologue_length; // The number of bytes following the
                               // prologue_length field to the beginning of the
                               // first byte of the statement program itself.
     uint8_t min_inst_length; // The size in bytes of the smallest target machine
                              // instruction. Statement program opcodes that
                              // alter the address register first multiply their
                              // operands by this value.
     uint8_t maximum_operations_per_instruction; // New in DWARF4. The maximum
static bool DumpLineTableRows(
       lldb_private::Log *log, SymbolFileDWARF *dwarf2Data,
       dw_offset_t line_offset =
           DW_INVALID_OFFSET); // If line_offset is invalid, dump everything
   static bool
   ParseSupportFiles(const lldb::ModuleSP &module_sp,
                     const lldb_private::DWARFDataExtractor &debug_line_data,
                     const lldb_private::FileSpec &cu_comp_dir,
                     dw_offset_t stmt_list,
-                    lldb_private::FileSpecList &support_files);
+                    lldb_private::FileSpecList &support_files, DWARFUnit *dwarf_cu);
   static bool
   ParsePrologue(const lldb_private::DWARFDataExtractor &debug_line_data,
-                lldb::offset_t *offset_ptr, Prologue *prologue);
+                lldb::offset_t *offset_ptr, Prologue *prologue, DWARFUnit *CU = nullptr);
   static bool
   ParseStatementTable(const lldb_private::DWARFDataExtractor &debug_line_data,
                       lldb::offset_t *offset_ptr, State::Callback callback,
-                      void *userData);
+                      void *userData, DWARFUnit *dwarf_cu);
   static dw_offset_t
   DumpStatementTable(lldb_private::Log *log,
                      const lldb_private::DWARFDataExtractor &debug_line_data,
                      const dw_offset_t line_offset);
   static dw_offset_t
   DumpStatementOpcodes(lldb_private::Log *log,
                        const lldb_private::DWARFDataExtractor &debug_line_data,
                        const dw_offset_t line_offset, uint32_t flags);
   static bool
   ParseStatementTable(const lldb_private::DWARFDataExtractor &debug_line_data,
-                      lldb::offset_t *offset_ptr, LineTable *line_table);
+                      lldb::offset_t *offset_ptr, LineTable *line_table, DWARFUnit *dwarf_cu);
   static void Parse(const lldb_private::DWARFDataExtractor &debug_line_data,
                     DWARFDebugLine::State::Callback callback, void *userData);
   //  static void AppendLineTableData(const DWARFDebugLine::Prologue* prologue,
   //  const DWARFDebugLine::Row::collection& state_coll, const uint32_t
   //  addr_size, BinaryStreamBuf &debug_line_data);
 
   DWARFDebugLine() : m_lineTableMap() {}
 

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

void DWARFDebugLine::Parse(const DWARFDataExtractor &debug_line_data) {
   lldb::offset_t offset = 0;
   LineTable::shared_ptr line_table_sp(new LineTable);
   while (debug_line_data.ValidOffset(offset)) {
     const lldb::offset_t debug_line_offset = offset;
 
     if (line_table_sp.get() == NULL)
       break;
 
-    if (ParseStatementTable(debug_line_data, &offset, line_table_sp.get())) {
+    if (ParseStatementTable(debug_line_data, &offset, line_table_sp.get(), nullptr)) {
       // Make sure we don't don't loop infinitely
       if (offset <= debug_line_offset)
         break;
       // DEBUG_PRINTF("m_lineTableMap[0x%8.8x] = line_table_sp\n",
       // debug_line_offset);
       m_lineTableMap[debug_line_offset] = line_table_sp;
       line_table_sp.reset(new LineTable);
     } else
if (debug_line_data.ValidOffset(debug_line_offset)) {
     lldb::offset_t offset = debug_line_offset;
     log->Printf("--------------------------------------------------------------"
                 "--------\n"
                 "debug_line[0x%8.8x]\n"
                 "--------------------------------------------------------------"
                 "--------\n",
                 debug_line_offset);
 
-    if (ParseStatementTable(debug_line_data, &offset, DumpStateToFile, log))
+    if (ParseStatementTable(debug_line_data, &offset, DumpStateToFile, log, nullptr))
       return offset;
     else
       return debug_line_offset + 1; // Skip to next byte in .debug_line section
   }
 
   return DW_INVALID_OFFSET;
 }
 

 // prologue is parsed and every time a new row is to be added to the line
 // table.
 //----------------------------------------------------------------------
 void DWARFDebugLine::Parse(const DWARFDataExtractor &debug_line_data,
                            DWARFDebugLine::State::Callback callback,
                            void *userData) {
   lldb::offset_t offset = 0;
   if (debug_line_data.ValidOffset(offset)) {
-    if (!ParseStatementTable(debug_line_data, &offset, callback, userData))
+    if (!ParseStatementTable(debug_line_data, &offset, callback, userData, nullptr))
       ++offset; // Skip to next byte in .debug_line section
   }
 }
 
+namespace {
+struct EntryDescriptor {
+  dw_sleb128_t code;
+  dw_sleb128_t form;
+};
+
+static std::vector<EntryDescriptor>
+ReadDescriptors(const DWARFDataExtractor &debug_line_data,
+                lldb::offset_t *offset_ptr) {
+  std::vector<EntryDescriptor> ret;
+  uint8_t n = debug_line_data.GetU8(offset_ptr);
+  for (uint8_t i = 0; i < n; ++i) {
+    EntryDescriptor ent;
+    ent.code = debug_line_data.GetULEB128(offset_ptr);
+    ent.form = debug_line_data.GetULEB128(offset_ptr);
+    ret.push_back(ent);
+  }
+  return ret;
+}
+} // namespace
+
 //----------------------------------------------------------------------
 // DWARFDebugLine::ParsePrologue
 //----------------------------------------------------------------------
 bool DWARFDebugLine::ParsePrologue(const DWARFDataExtractor &debug_line_data,
                                    lldb::offset_t *offset_ptr,
-                                   Prologue *prologue) {
+                                   Prologue *prologue, DWARFUnit *dwarf_cu) {
   const lldb::offset_t prologue_offset = *offset_ptr;
 
   // DEBUG_PRINTF("0x%8.8x: ParsePrologue()\n", *offset_ptr);
 
   prologue->Clear();
   uint32_t i;
   const char *s;
   prologue->total_length = debug_line_data.GetDWARFInitialLength(offset_ptr);
   prologue->version = debug_line_data.GetU16(offset_ptr);
-  if (prologue->version < 2 || prologue->version > 4)
+  if (prologue->version < 2 || prologue->version > 5)
     return false;
 
+  if (prologue->version >= 5) {
+    prologue->address_size = debug_line_data.GetU8(offset_ptr);
+    prologue->segment_selector_size = debug_line_data.GetU8(offset_ptr);
+  }
+
   prologue->prologue_length = debug_line_data.GetDWARFOffset(offset_ptr);
   const lldb::offset_t end_prologue_offset =
       prologue->prologue_length + *offset_ptr;
   prologue->min_inst_length = debug_line_data.GetU8(offset_ptr);
   if (prologue->version >= 4)
     prologue->maximum_operations_per_instruction =
         debug_line_data.GetU8(offset_ptr);
   else
     prologue->maximum_operations_per_instruction = 1;
   prologue->default_is_stmt = debug_line_data.GetU8(offset_ptr);
   prologue->line_base = debug_line_data.GetU8(offset_ptr);
   prologue->line_range = debug_line_data.GetU8(offset_ptr);
   prologue->opcode_base = debug_line_data.GetU8(offset_ptr);
 
   prologue->standard_opcode_lengths.reserve(prologue->opcode_base - 1);
 
   for (i = 1; i < prologue->opcode_base; ++i) {
     uint8_t op_len = debug_line_data.GetU8(offset_ptr);
     prologue->standard_opcode_lengths.push_back(op_len);
   }
 
+  if (prologue->version >= 5) {
+    std::vector<EntryDescriptor> dirEntryFormatV =
+        ReadDescriptors(debug_line_data, offset_ptr);
+    uint8_t dirCount = debug_line_data.GetULEB128(offset_ptr);
+    for (int i = 0; i < dirCount; ++i) {
+      for (EntryDescriptor &ent : dirEntryFormatV) {
+        DWARFFormValue value(dwarf_cu, ent.form);
+        if (ent.code != DW_LNCT_path) {
+          if (!value.SkipValue(debug_line_data, offset_ptr))
+            return false;
+          continue;
+        }
+
+        if (!value.ExtractValue(debug_line_data, offset_ptr))
+          return false;
+        prologue->include_directories.push_back(value.AsCString());
+      }
+    }
+
+    std::vector<EntryDescriptor> filesEntryFormatV =
+        ReadDescriptors(debug_line_data, offset_ptr);
+    llvm::DenseSet<std::pair<uint64_t, uint64_t>> seen;
+    uint8_t n = debug_line_data.GetULEB128(offset_ptr);
+    for (int i = 0; i < n; ++i) {
+      FileNameEntry entry;
+      for (EntryDescriptor &p : filesEntryFormatV) {
+        DWARFFormValue value(dwarf_cu, p.form);
+        if (!value.ExtractValue(debug_line_data, offset_ptr))
+          return false;
+
+        switch (p.code) {
+        case DW_LNCT_path:
+          entry.name = value.AsCString();
+          break;
+        case DW_LNCT_directory_index:
+          entry.dir_idx = value.Unsigned();
+          break;
+        case DW_LNCT_timestamp:
+          entry.mod_time = value.Unsigned();
+          break;
+        case DW_LNCT_size:
+          entry.length = value.Unsigned();
+          break;
+        case DW_LNCT_MD5:
+          assert(value.Unsigned() == 16);
+          std::uninitialized_copy_n(value.BlockData(), 16,
+                                    entry.Checksum.Bytes.begin());
+          break;
+        default:
+          break;
+        }
+      }
+
+      if (seen.insert(entry.Checksum.words()).second)
+        prologue->file_names.push_back(entry);
+    }
+  } else {
     while (*offset_ptr < end_prologue_offset) {
       s = debug_line_data.GetCStr(offset_ptr);
       if (s && s[0])
         prologue->include_directories.push_back(s);
       else
         break;
     }
 
     while (*offset_ptr < end_prologue_offset) {
       const char *name = debug_line_data.GetCStr(offset_ptr);
       if (name && name[0]) {
         FileNameEntry fileEntry;
         fileEntry.name = name;
         fileEntry.dir_idx = debug_line_data.GetULEB128(offset_ptr);
         fileEntry.mod_time = debug_line_data.GetULEB128(offset_ptr);
         fileEntry.length = debug_line_data.GetULEB128(offset_ptr);
         prologue->file_names.push_back(fileEntry);
       } else
         break;
     }
+  }
 
   // XXX GNU as is broken for 64-Bit DWARF
   if (*offset_ptr != end_prologue_offset) {
     Host::SystemLog(Host::eSystemLogWarning,
                     "warning: parsing line table prologue at 0x%8.8" PRIx64
                     " should have ended at 0x%8.8" PRIx64
                     " but it ended at 0x%8.8" PRIx64 "\n",
                     prologue_offset, end_prologue_offset, *offset_ptr);
   }
   return end_prologue_offset;
 }
 
 bool DWARFDebugLine::ParseSupportFiles(
     const lldb::ModuleSP &module_sp, const DWARFDataExtractor &debug_line_data,
     const lldb_private::FileSpec &cu_comp_dir, dw_offset_t stmt_list,
-    FileSpecList &support_files) {
+    FileSpecList &support_files, DWARFUnit *dwarf_cu) {
   lldb::offset_t offset = stmt_list;
 
   Prologue prologue;
-  if (!ParsePrologue(debug_line_data, &offset, &prologue)) {
+  if (!ParsePrologue(debug_line_data, &offset, &prologue, dwarf_cu)) {
     Host::SystemLog(Host::eSystemLogError, "error: parsing line table prologue "
                                            "at 0x%8.8x (parsing ended around "
                                            "0x%8.8" PRIx64 "\n",
                     stmt_list, offset);
     return false;
   }
 
   FileSpec file_spec;

 // ParseStatementTable
 //
 // Parse a single line table (prologue and all rows) and call the callback
 // function once for the prologue (row in state will be zero) and each time a
 // row is to be added to the line table.
 //----------------------------------------------------------------------
 bool DWARFDebugLine::ParseStatementTable(
     const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
-    DWARFDebugLine::State::Callback callback, void *userData) {
+    DWARFDebugLine::State::Callback callback, void *userData, DWARFUnit *dwarf_cu) {
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_LINE));
   Prologue::shared_ptr prologue(new Prologue());
 
   const dw_offset_t debug_line_offset = *offset_ptr;
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "DWARFDebugLine::ParseStatementTable (.debug_line[0x%8.8x])",
       debug_line_offset);
 
-  if (!ParsePrologue(debug_line_data, offset_ptr, prologue.get())) {
+  if (!ParsePrologue(debug_line_data, offset_ptr, prologue.get(), dwarf_cu)) {
     if (log)
       log->Error("failed to parse DWARF line table prologue");
     // Restore our offset and return false to indicate failure!
     *offset_ptr = debug_line_offset;
     return false;
   }
 
   if (log)

 //----------------------------------------------------------------------
 // ParseStatementTable
 //
 // Parse a line table at offset and populate the LineTable class with the
 // prologue and all rows.
 //----------------------------------------------------------------------
 bool DWARFDebugLine::ParseStatementTable(
     const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
-    LineTable *line_table) {
+    LineTable *line_table, DWARFUnit *dwarf_cu) {
   return ParseStatementTable(debug_line_data, offset_ptr,
-                             ParseStatementTableCallback, line_table);
+                             ParseStatementTableCallback, line_table, dwarf_cu);
 }
 
 inline bool DWARFDebugLine::Prologue::IsValid() const {
   return SymbolFileDWARF::SupportedVersion(version);
 }
 
 //----------------------------------------------------------------------
 // DWARFDebugLine::Prologue::Dump

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

 //===-- DWARFFormValue.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFFormValue_h_
 #define SymbolFileDWARF_DWARFFormValue_h_
 
 #include "DWARFDataExtractor.h"
 #include <stddef.h> // for NULL
 
 class DWARFUnit;
+class SymbolFileDWARF;
 
 class DWARFFormValue {
 public:
   typedef struct ValueTypeTag {
     ValueTypeTag() : value(), data(NULL) { value.uval = 0; }
 
     union {
       uint64_t uval;
public:
   uint64_t Reference() const;
   uint64_t Reference(dw_offset_t offset) const;
   bool Boolean() const { return m_value.value.uval != 0; }
   uint64_t Unsigned() const { return m_value.value.uval; }
   void SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
   int64_t Signed() const { return m_value.value.sval; }
   void SetSigned(int64_t sval) { m_value.value.sval = sval; }
   const char *AsCString() const;
+  const char *AsCString(SymbolFileDWARF *Dwarf, bool Is64Bit) const;
   dw_addr_t Address() const;
   bool IsValid() const { return m_form != 0; }
   bool SkipValue(const lldb_private::DWARFDataExtractor &debug_info_data,
                  lldb::offset_t *offset_ptr) const;
   static bool SkipValue(const dw_form_t form,
                         const lldb_private::DWARFDataExtractor &debug_info_data,
                         lldb::offset_t *offset_ptr, const DWARFUnit *cu);
   static bool IsBlockForm(const dw_form_t form);

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

case DW_FORM_data2:
       m_value.value.uval = data.GetU16(offset_ptr);
       break;
     case DW_FORM_data4:
       m_value.value.uval = data.GetU32(offset_ptr);
       break;
     case DW_FORM_data8:
       m_value.value.uval = data.GetU64(offset_ptr);
       break;
+    case DW_FORM_data16:
+      m_value.value.uval = 16;
+      is_block = true;
+      break;
     case DW_FORM_string:
       m_value.value.cstr = data.GetCStr(offset_ptr);
       break;
     case DW_FORM_exprloc:
     case DW_FORM_block:
       m_value.value.uval = data.GetULEB128(offset_ptr);
       is_block = true;
       break;
     case DW_FORM_block1:
       m_value.value.uval = data.GetU8(offset_ptr);
       is_block = true;
       break;
     case DW_FORM_data1:
       m_value.value.uval = data.GetU8(offset_ptr);
       break;
     case DW_FORM_flag:
       m_value.value.uval = data.GetU8(offset_ptr);
       break;
     case DW_FORM_sdata:
       m_value.value.sval = data.GetSLEB128(offset_ptr);
       break;
     case DW_FORM_strp:
+    case DW_FORM_line_strp:
       assert(m_cu);
       m_value.value.uval =
           data.GetMaxU64(offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
       break;
+    case DW_FORM_strx:
+      m_value.value.uval = data.GetULEB128(offset_ptr);
+      break;
+    case DW_FORM_strx1:
+      m_value.value.uval = data.GetU8(offset_ptr);
+      break;
+    case DW_FORM_strx2:
+      m_value.value.uval = data.GetU16(offset_ptr);
+      break;
+    case DW_FORM_strx3:
+      m_value.value.uval = data.GetMaxU64(offset_ptr, 3);
+      break;
+    case DW_FORM_strx4:
+      m_value.value.uval = data.GetU32(offset_ptr);
+      break;
     //  case DW_FORM_APPLE_db_str:
     case DW_FORM_udata:
       m_value.value.uval = data.GetULEB128(offset_ptr);
       break;
     case DW_FORM_ref_addr:
       assert(m_cu);
       ref_addr_size = 4;
       if (m_cu->GetVersion() <= 2)
else
       ref_addr_size = cu->IsDWARF64() ? 8 : 4;
     *offset_ptr += ref_addr_size;
     return true;
 
   // 0 bytes values (implied from DW_FORM)
   case DW_FORM_flag_present:
     return true;
 
     // 1 byte values
     case DW_FORM_data1:
     case DW_FORM_flag:
     case DW_FORM_ref1:
+    case DW_FORM_strx1:
       *offset_ptr += 1;
       return true;
 
     // 2 byte values
     case DW_FORM_data2:
     case DW_FORM_ref2:
+    case DW_FORM_strx2:
       *offset_ptr += 2;
       return true;
 
+    // 3 byte values
+    case DW_FORM_strx3:
+      *offset_ptr += 3;
+      return true;
+
     // 32 bit for DWARF 32, 64 for DWARF 64
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
       assert(cu);
       *offset_ptr += (cu->IsDWARF64() ? 8 : 4);
       return true;
 
     // 4 byte values
     case DW_FORM_data4:
     case DW_FORM_ref4:
+    case DW_FORM_strx4:
       *offset_ptr += 4;
       return true;
 
     // 8 byte values
     case DW_FORM_data8:
     case DW_FORM_ref8:
     case DW_FORM_ref_sig8:
       *offset_ptr += 8;
       return true;
 
     // signed or unsigned LEB 128 values
     case DW_FORM_sdata:
     case DW_FORM_udata:
     case DW_FORM_ref_udata:
     case DW_FORM_GNU_addr_index:
     case DW_FORM_GNU_str_index:
+    case DW_FORM_strx:
       debug_info_data.Skip_LEB128(offset_ptr);
       return true;
 
   case DW_FORM_indirect: {
     dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr);
     return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr,
                                      cu);
   }
 
   default:
void DWARFFormValue::Dump(Stream &s) const {
 
   if (cu_relative_offset) {
     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
                   // unit relative or we will get this wrong
     s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_cu->GetOffset());
   }
 }
 
-const char *DWARFFormValue::AsCString() const {
-  SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
-
+const char *DWARFFormValue::AsCString(SymbolFileDWARF *symbol_file,
+                                      bool is64Bit) const {
   if (m_form == DW_FORM_string) {
     return m_value.value.cstr;
   } else if (m_form == DW_FORM_strp) {
     if (!symbol_file)
       return nullptr;
 
     return symbol_file->get_debug_str_data().PeekCStr(m_value.value.uval);
   } else if (m_form == DW_FORM_GNU_str_index) {
     if (!symbol_file)
       return nullptr;
 
-    uint32_t index_size = m_cu->IsDWARF64() ? 8 : 4;
+    uint32_t index_size = is64Bit ? 8 : 4;
     lldb::offset_t offset = m_value.value.uval * index_size;
     dw_offset_t str_offset =
         symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset,
                                                             index_size);
     return symbol_file->get_debug_str_data().PeekCStr(str_offset);
   }
+
+  if (m_form == DW_FORM_strx || m_form == DW_FORM_strx1 ||
+      m_form == DW_FORM_strx2 || m_form == DW_FORM_strx3 ||
+      m_form == DW_FORM_strx4) {
+
+    // The same code as above.
+    if (!symbol_file)
+      return nullptr;
+
+    lldb::offset_t baseOffset = 0;
+    const DWARFDataExtractor &strOffsets =
+        symbol_file->get_debug_str_offsets_data();
+    uint64_t length = strOffsets.GetU32(&baseOffset);
+    if (length == 0xffffffff)
+      length = strOffsets.GetU64(&baseOffset);
+
+    // Check version.
+    if (strOffsets.GetU16(&baseOffset) < 5)
+      return nullptr;
+
+    // Skip padding.
+    baseOffset += 2;
+
+    uint32_t indexSize = is64Bit ? 8 : 4;
+    lldb::offset_t offset = baseOffset + m_value.value.uval * indexSize;
+    dw_offset_t strOffset =
+        symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset, indexSize);
+    return symbol_file->get_debug_str_data().PeekCStr(strOffset);
+  }
+
+  if (m_form == DW_FORM_line_strp)
+    return symbol_file->get_debug_line_str_data().PeekCStr(m_value.value.uval);
+
   return nullptr;
 }
 
+const char *DWARFFormValue::AsCString() const {
+  return AsCString(m_cu->GetSymbolFileDWARF(), m_cu->IsDWARF64());
+}
+
 dw_addr_t DWARFFormValue::Address() const {
   SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
 
   if (m_form == DW_FORM_addr)
     return Unsigned();
 
   assert(m_cu);
   assert(m_form == DW_FORM_GNU_addr_index);
switch (form) {
     case DW_FORM_ref_udata:
     case DW_FORM_indirect:
     case DW_FORM_sec_offset:
     case DW_FORM_exprloc:
     case DW_FORM_flag_present:
     case DW_FORM_ref_sig8:
     case DW_FORM_GNU_str_index:
     case DW_FORM_GNU_addr_index:
-      return true;
+
+    case DW_FORM_strx:
+    case DW_FORM_strx1:
+    case DW_FORM_strx2:
+    case DW_FORM_strx3:
+    case DW_FORM_strx4:
+      return true;
+
     default:
       break;
   }
   return false;
 }

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

protected:
   llvm::sys::RWMutex m_first_die_mutex;
   // A table similar to the .debug_aranges table, but this one points to the
   // exact DW_TAG_subprogram DIEs
   std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap;
   dw_addr_t m_base_addr = 0;
   dw_offset_t m_length = 0;
   uint16_t m_version = 0;
   uint8_t m_addr_size = 0;
+  uint8_t m_unit_type = 0;
+  uint64_t m_dwo_id = 0;
   DWARFProducer m_producer = eProducerInvalid;
   uint32_t m_producer_version_major = 0;
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
   lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
   bool m_is_dwarf64 = false;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   dw_addr_t m_addr_base = 0;   // Value of DW_AT_addr_base

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

void DebugNamesDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
   }
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
     ConstString name, DWARFDebugInfo &info,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
     std::vector<DWARFDIE> &dies) {
 
-  m_fallback.GetFunctions(name, info, parent_decl_ctx, name_type_mask, dies);
+  std::vector<DWARFDIE> V;
+  m_fallback.GetFunctions(name, info, parent_decl_ctx, name_type_mask, V);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     Tag tag = entry.tag();
     if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
       continue;
 
     if (DIERef ref = ToDIERef(entry))
       ProcessFunctionDIE(name.GetStringRef(), ref, info, parent_decl_ctx,
-                         name_type_mask, dies);
+                         name_type_mask, V);
   }
+
+  std::set<DWARFDebugInfoEntry *> Set;
+  for (DWARFDIE Die : V)
+    if (Set.insert(Die.GetDIE()).second)
+      dies.push_back(Die);
 }
 
 void DebugNamesDWARFIndex::GetFunctions(const RegularExpression &regex,
                                         DIEArray &offsets) {
   m_fallback.GetFunctions(regex, offsets);
 
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   uint32_t GetPluginVersion() override;
 
   const lldb_private::DWARFDataExtractor &get_debug_abbrev_data();
   const lldb_private::DWARFDataExtractor &get_debug_addr_data();
   const lldb_private::DWARFDataExtractor &get_debug_aranges_data();
   const lldb_private::DWARFDataExtractor &get_debug_frame_data();
   const lldb_private::DWARFDataExtractor &get_debug_info_data();
   const lldb_private::DWARFDataExtractor &get_debug_line_data();
+  const lldb_private::DWARFDataExtractor &get_debug_line_str_data();
   const lldb_private::DWARFDataExtractor &get_debug_macro_data();
   const lldb_private::DWARFDataExtractor &get_debug_loc_data();
   const lldb_private::DWARFDataExtractor &get_debug_ranges_data();
   const lldb_private::DWARFDataExtractor &get_debug_str_data();
   const lldb_private::DWARFDataExtractor &get_debug_str_offsets_data();
   const lldb_private::DWARFDataExtractor &get_debug_types_data();
   const lldb_private::DWARFDataExtractor &get_apple_names_data();
   const lldb_private::DWARFDataExtractor &get_apple_types_data();
protected:
   lldb_private::DWARFDataExtractor m_dwarf_data;
 
   DWARFDataSegment m_data_debug_abbrev;
   DWARFDataSegment m_data_debug_addr;
   DWARFDataSegment m_data_debug_aranges;
   DWARFDataSegment m_data_debug_frame;
   DWARFDataSegment m_data_debug_info;
   DWARFDataSegment m_data_debug_line;
+  DWARFDataSegment m_data_debug_line_str;
   DWARFDataSegment m_data_debug_macro;
   DWARFDataSegment m_data_debug_loc;
   DWARFDataSegment m_data_debug_ranges;
   DWARFDataSegment m_data_debug_str;
   DWARFDataSegment m_data_debug_str_offsets;
   DWARFDataSegment m_data_debug_types;
   DWARFDataSegment m_data_apple_names;
   DWARFDataSegment m_data_apple_types;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
     }
   }
 
   m_index = llvm::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
                                                 DebugInfo());
 }
 
 bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
-  return version == 2 || version == 3 || version == 4;
+  return version >= 2 && version <= 5;
 }
 
 uint32_t SymbolFileDWARF::CalculateAbilities() {
   uint32_t abilities = 0;
   if (m_obj_file != NULL) {
     const Section *section = NULL;
     const SectionList *section_list = m_obj_file->GetSectionList();
     if (section_list == NULL)

 const DWARFDataExtractor &SymbolFileDWARF::get_debug_info_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugInfo, m_data_debug_info);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_line_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugLine, m_data_debug_line);
 }
 
+const DWARFDataExtractor &SymbolFileDWARF::get_debug_line_str_data() {
+ return GetCachedSectionData(eSectionTypeDWARFDebugLineStr, m_data_debug_line_str);
+}
+
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_macro_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugMacro, m_data_debug_macro);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_loc_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugLoc, m_data_debug_loc);
 }
 
if (cu_die) {
       const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
           DW_AT_stmt_list, DW_INVALID_OFFSET);
       if (stmt_list != DW_INVALID_OFFSET) {
         // All file indexes in DWARF are one based and a file of index zero is
         // supposed to be the compile unit itself.
         support_files.Append(*sc.comp_unit);
         return DWARFDebugLine::ParseSupportFiles(
             sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir,
-            stmt_list, support_files);
+            stmt_list, support_files, dwarf_cu);
       }
     }
   }
   return false;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitIsOptimized(
     const lldb_private::SymbolContext &sc) {
if (dwarf_cu_die) {
           default:
             info.addr_mask = ~((lldb::addr_t)0);
             break;
           }
 
           lldb::offset_t offset = cu_line_offset;
           DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset,
                                               ParseDWARFLineTableCallback,
-                                              &info);
+                                              &info, dwarf_cu);
           SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
           if (debug_map_symfile) {
             // We have an object file that has a line table with addresses that
             // are not linked. We need to link the line table and convert the
             // addresses that are relative to the .o file into addresses for
             // the main executable.
             sc.comp_unit->SetLineTable(
                 debug_map_symfile->LinkOSOLineTable(this, line_table_ap.get()));

source/Symbol/ObjectFile.cpp

if (symbol) {
           case eSectionTypeDebug:
           case eSectionTypeDWARFDebugAbbrev:
           case eSectionTypeDWARFDebugAddr:
           case eSectionTypeDWARFDebugAranges:
           case eSectionTypeDWARFDebugCuIndex:
           case eSectionTypeDWARFDebugFrame:
           case eSectionTypeDWARFDebugInfo:
           case eSectionTypeDWARFDebugLine:
+          case eSectionTypeDWARFDebugLineStr:
           case eSectionTypeDWARFDebugLoc:
           case eSectionTypeDWARFDebugMacInfo:
           case eSectionTypeDWARFDebugMacro:
           case eSectionTypeDWARFDebugNames:
           case eSectionTypeDWARFDebugPubNames:
           case eSectionTypeDWARFDebugPubTypes:
           case eSectionTypeDWARFDebugRanges:
           case eSectionTypeDWARFDebugStr: