[lldb/DWARF] Support the debug_str_offsets section in dwp files

[labath]

Summary

In dwp files a constant (from the debug_cu_index section) needs to be
added to each reference into the debug_str_offsets section.

I've tried to implement this to roughly match the llvm flow: I've
changed the DWARFormValue to stop resolving the indirect string
references directly -- instead, it calls into DWARFUnit, which resolves
this for it (similar to how it already resolves indirect range and
location list references). I've also done a small refactor of the string
offset base computation code in DWARFUnit in order to make it easier to
access the debug_cu_index base offset.

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

void DWARFFormValue::Dump(Stream &s) const {
   if (unit_relative_offset) {
     assert(m_unit); // Unit 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_unit->GetOffset());
   }
 }
 
 const char *DWARFFormValue::AsCString() const {
-  SymbolFileDWARF &symbol_file = m_unit->GetSymbolFileDWARF();
+  DWARFContext &context = m_unit->GetSymbolFileDWARF().GetDWARFContext();
 
-  if (m_form == DW_FORM_string) {
+  if (m_form == DW_FORM_string)
     return m_value.value.cstr;
-  } else if (m_form == DW_FORM_strp) {
-    return symbol_file.GetDWARFContext().getOrLoadStrData().PeekCStr(
-        m_value.value.uval);
-  } else if (m_form == DW_FORM_GNU_str_index) {
-    uint32_t index_size = 4;
-    lldb::offset_t offset = m_value.value.uval * index_size;
-    dw_offset_t str_offset =
-        symbol_file.GetDWARFContext().getOrLoadStrOffsetsData().GetMaxU64(
-            &offset, index_size);
-    return symbol_file.GetDWARFContext().getOrLoadStrData().PeekCStr(
-        str_offset);
-  }
+  if (m_form == DW_FORM_strp)
+    return context.getOrLoadStrData().PeekCStr(m_value.value.uval);
 
-  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.
-    uint32_t indexSize = 4;
-    lldb::offset_t offset =
-        m_unit->GetStrOffsetsBase() + m_value.value.uval * indexSize;
-    dw_offset_t strOffset =
-        symbol_file.GetDWARFContext().getOrLoadStrOffsetsData().GetMaxU64(
-            &offset, indexSize);
-    return symbol_file.GetDWARFContext().getOrLoadStrData().PeekCStr(strOffset);
+  if (m_form == DW_FORM_GNU_str_index || 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) {
+
+    llvm::Optional<uint64_t> offset =
+        m_unit->GetStringOffsetSectionItem(m_value.value.uval);
+    if (!offset)
+      return nullptr;
+    return context.getOrLoadStrData().PeekCStr(*offset);
   }
 
   if (m_form == DW_FORM_line_strp)
-    return symbol_file.GetDWARFContext().getOrLoadLineStrData().PeekCStr(
-        m_value.value.uval);
+    return context.getOrLoadLineStrData().PeekCStr(m_value.value.uval);
 
   return nullptr;
 }
 
 dw_addr_t DWARFFormValue::Address() const {
   SymbolFileDWARF &symbol_file = m_unit->GetSymbolFileDWARF();
 
   if (m_form == DW_FORM_addr)

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

 
 public:
   dw_offset_t GetOffset() const { return m_offset; }
   uint16_t GetVersion() const { return m_version; }
   uint16_t GetAddressByteSize() const { return m_addr_size; }
   dw_offset_t GetLength() const { return m_length; }
   dw_offset_t GetAbbrOffset() const { return m_abbr_offset; }
   uint8_t GetUnitType() const { return m_unit_type; }
+  const llvm::DWARFUnitIndex::Entry *GetIndexEntry() const {
+    return m_index_entry;
+  }
   uint64_t GetTypeHash() const { return m_type_hash; }
   dw_offset_t GetTypeOffset() const { return m_type_offset; }
   bool IsTypeUnit() const {
     return m_unit_type == DW_UT_type || m_unit_type == DW_UT_split_type;
   }
   uint32_t GetNextUnitOffset() const { return m_offset + m_length + 4; }
 
   static llvm::Expected<DWARFUnitHeader>
die_iterator_range dies() {
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
   DIERef::Section GetDebugSection() const { return m_section; }
 
   uint8_t GetUnitType() const { return m_header.GetUnitType(); }
   bool IsTypeUnit() const { return m_header.IsTypeUnit(); }
 
+  llvm::Optional<uint64_t> GetStringOffsetSectionItem(uint32_t index) const;
+
   /// Return a list of address ranges resulting from a (possibly encoded)
   /// range list starting at a given offset in the appropriate ranges section.
   llvm::Expected<DWARFRangeList> FindRnglistFromOffset(dw_offset_t offset);
 
   /// Return a list of address ranges retrieved from an encoded range
   /// list whose offset is found via a table lookup given an index (DWARF v5
   /// and later).
   llvm::Expected<DWARFRangeList> FindRnglistFromIndex(uint32_t index);
protected:
   bool m_is_dwo;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();
 
   void AddUnitDIE(const DWARFDebugInfoEntry &cu_die);
+  void SetDwoStrOffsetsBase();
 
   void ComputeCompDirAndGuessPathStyle();
   void ComputeAbsolutePath();
 
   DISALLOW_COPY_AND_ASSIGN(DWARFUnit);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 }
 
 // This is used when a split dwarf is enabled.
 // A skeleton compilation unit may contain the DW_AT_str_offsets_base attribute
 // that points to the first string offset of the CU contribution to the
 // .debug_str_offsets. At the same time, the corresponding split debug unit also
 // may use DW_FORM_strx* forms pointing to its own .debug_str_offsets.dwo and
 // for that case, we should find the offset (skip the section header).
-static void SetDwoStrOffsetsBase(DWARFUnit *dwo_cu) {
+void DWARFUnit::SetDwoStrOffsetsBase() {
   lldb::offset_t baseOffset = 0;
 
+  if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) {
+    if (const auto *contribution = entry->getOffset(llvm::DW_SECT_STR_OFFSETS))
+      baseOffset = contribution->Offset;
+    else
+      return;
+  }
+
+  if (GetVersion() >= 5) {
     const DWARFDataExtractor &strOffsets =
-      dwo_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadStrOffsetsData();
+        GetSymbolFileDWARF().GetDWARFContext().getOrLoadStrOffsetsData();
     uint64_t length = strOffsets.GetU32(&baseOffset);
     if (length == 0xffffffff)
       length = strOffsets.GetU64(&baseOffset);
 
     // Check version.
     if (strOffsets.GetU16(&baseOffset) < 5)
       return;
 
     // Skip padding.
     baseOffset += 2;
+  }
 
-  dwo_cu->SetStrOffsetsBase(baseOffset);
+  SetStrOffsetsBase(baseOffset);
 }
 
 // m_die_array_mutex must be already held as read/write.
 void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) {
   llvm::Optional<uint64_t> addr_base, gnu_addr_base, ranges_base,
       gnu_ranges_base;
 
   DWARFAttributes attributes;
case DW_AT_GNU_addr_base:
       gnu_addr_base = form_value.Unsigned();
       break;
     case DW_AT_GNU_ranges_base:
       gnu_ranges_base = form_value.Unsigned();
       break;
     }
   }
 
-  if (m_is_dwo)
+  if (m_is_dwo) {
+    SetDwoStrOffsetsBase();
     return;
+  }
 
   std::shared_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf.GetDwoSymbolFileForCompileUnit(*this, cu_die);
   if (!dwo_symbol_file)
     return;
 
   uint64_t main_dwo_id =
       cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_dwo_id, 0);
else if (dwo_symbol_file->GetDWARFContext()
     dwo_cu->SetRangesBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
 
   if (GetVersion() >= 5 &&
       dwo_symbol_file->GetDWARFContext().getOrLoadLocListsData().GetByteSize() >
           0)
     dwo_cu->SetLoclistsBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
   dwo_cu->SetBaseAddress(GetBaseAddress());
 
-  for (size_t i = 0; i < dwo_symbol_file->DebugInfo()->GetNumUnits(); ++i) {
-    DWARFUnit *unit = dwo_symbol_file->DebugInfo()->GetUnitAtIndex(i);
-    SetDwoStrOffsetsBase(unit);
-  }
   m_dwo = std::shared_ptr<DWARFUnit>(std::move(dwo_symbol_file), dwo_cu);
 }
 
 DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) {
   if (DIE()) {
     const DWARFDebugAranges &func_aranges = GetFunctionAranges();
 
     // Re-check the aranges auto pointer contents in case it was created above
case llvm::dwarf::DW_UT_split_compile:
     return 20;
   case llvm::dwarf::DW_UT_type:
   case llvm::dwarf::DW_UT_split_type:
     return GetVersion() < 5 ? 23 : 24;
   }
   llvm_unreachable("invalid UnitType.");
 }
 
+llvm::Optional<uint64_t>
+DWARFUnit::GetStringOffsetSectionItem(uint32_t index) const {
+  offset_t offset = GetStrOffsetsBase() + index * 4;
+  return m_dwarf.GetDWARFContext().getOrLoadStrOffsetsData().GetU32(&offset);
+}
+
 llvm::Expected<DWARFRangeList>
 DWARFUnit::FindRnglistFromOffset(dw_offset_t offset) {
   if (GetVersion() <= 4) {
     const DWARFDebugRanges *debug_ranges = m_dwarf.GetDebugRanges();
     if (!debug_ranges)
       return llvm::make_error<llvm::object::GenericBinaryError>(
           "No debug_ranges section");
     DWARFRangeList ranges;

lldb/test/Shell/SymbolFile/DWARF/dwp.s

 # REQUIRES: x86
 
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t --defsym MAIN=0
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t.dwp --defsym DWP=0
 # RUN: %lldb %t -o "target variable A" -b | FileCheck %s
 # RUN: lldb-test symbols %t | FileCheck %s --check-prefix=SYMBOLS
 
-# CHECK: (int) A = 0
-# CHECK: (int) A = 1
-# CHECK: (int) A = 2
-# CHECK: (int) A = 3
+# CHECK: (INT0) A = 0
+# CHECK: (INT1) A = 1
+# CHECK: (INT2) A = 2
+# CHECK: (INT3) A = 3
 
 # SYMBOLS:      Compile units:
 # SYMBOLS-NEXT: CompileUnit{0x00000000}, language = "unknown", file = '0.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x0
 # SYMBOLS-NEXT: CompileUnit{0x00000001}, language = "unknown", file = '1.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x1
 # SYMBOLS-NEXT: CompileUnit{0x00000002}, language = "unknown", file = '2.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x2
.Ldebug_info_end\I:
         .quad   A\I
 .endr
 .endif
 
 .ifdef DWP
 # This deliberately excludes compile unit 4 to check test the case of a missing
 # split unit.
 .irpc I,0123
+        .section        .debug_str.dwo,"e",@progbits
+.Lstr\I:
+        .byte   'I', 'N', 'T', '0'+\I, 0
+
+        .section        .debug_str_offsets.dwo,"e",@progbits
+.Lstr_offsets\I:
+        .long   .Lstr\I-.debug_str.dwo
+.Lstr_offsets_end\I:
+
         .section        .debug_abbrev.dwo,"e",@progbits
 .Labbrev\I:
         .byte   \I*10+1                 # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit
         .byte   1                       # DW_CHILDREN_yes
         .byte   37                      # DW_AT_producer
         .byte   8                       # DW_FORM_string
         .byte   3                       # DW_AT_name
.Labbrev\I:
         .byte   2                       # DW_AT_location
         .byte   24                      # DW_FORM_exprloc
         .byte   0                       # EOM(1)
         .byte   0                       # EOM(2)
         .byte   \I*10+3                 # Abbreviation Code
         .byte   36                      # DW_TAG_base_type
         .byte   0                       # DW_CHILDREN_no
         .byte   3                       # DW_AT_name
-        .byte   14                      # DW_FORM_string
+        .byte   8                       # DW_FORM_string
         .byte   62                      # DW_AT_encoding
         .byte   11                      # DW_FORM_data1
         .byte   11                      # DW_AT_byte_size
         .byte   11                      # DW_FORM_data1
         .byte   0                       # EOM(1)
         .byte   0                       # EOM(2)
+        .byte   \I*10+4                 # Abbreviation Code
+        .byte   22                      # DW_TAG_typedef
+        .byte   0                       # DW_CHILDREN_no
+        .byte   3                       # DW_AT_name
+        .uleb128 0x1f02                 # DW_FORM_GNU_str_index
+        .byte   73                      # DW_AT_type
+        .byte   19                      # DW_FORM_ref4
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
         .byte   0                       # EOM(3)
 .Labbrev_end\I:
 
         .section        .debug_info.dwo,"e",@progbits
 .Lcu_begin\I:
         .long   .Ldebug_info_end\I-.Ldebug_info_start\I # Length of Unit
 .Ldebug_info_start\I:
         .short  4                       # DWARF version number
         .long   0                       # Offset Into Abbrev. Section
         .byte   8                       # Address Size (in bytes)
         .byte   \I*10+1                 # Abbrev DW_TAG_compile_unit
         .asciz  "Hand-written DWARF"    # DW_AT_producer
         .byte   '0'+\I, '.', 'c', 0     # DW_AT_name
         .byte   \I*10+2                 # Abbrev DW_TAG_variable
         .asciz  "A"                     # DW_AT_name
-        .long   .Ltype\I-.Lcu_begin\I   # DW_AT_type
+        .long   .Ltypedef\I-.Lcu_begin\I# DW_AT_type
         .byte   2                       # DW_AT_location
         .byte   0xfb                    # DW_OP_GNU_addr_index
         .byte   \I
+.Ltypedef\I:
+        .byte   \I*10+4                 # Abbrev DW_TAG_typedef
+        .byte   0                       # DW_AT_name
+        .long   .Ltype\I-.Lcu_begin\I   # DW_AT_type
 .Ltype\I:
         .byte   \I*10+3                 # Abbrev DW_TAG_base_type
         .asciz  "int"                   # DW_AT_name
         .byte   5                       # DW_AT_encoding
         .byte   4                       # DW_AT_byte_size
         .byte   0                       # End Of Children Mark
 .Ldebug_info_end\I:
 .endr
 
         .section        .debug_cu_index,"e",@progbits
         .short  2                       # DWARF version number
         .short  0                       # Reserved
-        .long   2                       # Section count
+        .long   3                       # Section count
         .long   4                       # Unit count
         .long   8                       # Slot count
 
         .quad   0, 1, 2, 3, 0, 0, 0, 0  # Hash table
         .long   1, 2, 3, 4, 0, 0, 0, 0  # Index table
 
-        .long   1, 3                    # DW_SECT_INFO, DW_SECT_ABBREV
+        .long   1                       # DW_SECT_INFO
+        .long   3                       # DW_SECT_ABBREV
+        .long   6                       # DW_SECT_STR_OFFSETS
 
 .irpc I,0123
         .long .Lcu_begin\I-.debug_info.dwo
         .long .Labbrev\I-.debug_abbrev.dwo
+        .long .Lstr_offsets\I-.debug_str_offsets.dwo
 .endr
 .irpc I,0123
         .long .Ldebug_info_end\I-.Lcu_begin\I
         .long .Labbrev_end\I-.Labbrev\I
+        .long .Lstr_offsets_end\I-.Lstr_offsets\I
 .endr
 
 .endif