DWZ 01/07: Support reading section ".gnu_debugaltlink"

[jankratochvil]

Summary

All DWZ patches are also applied in: git clone -b dwz git://git.jankratochvil.net/lldb

[clayborg]

Just move the eSectionTypeDWARFGNUDebugAltLink enumerator to the end of the enum and this is good to go.

include/lldb/lldb-enumerations.h

647 ↗

(On Diff #124294)

Since this enumeration is in the public API, it should be added to the end of the enum. Anyone that builds a new liblldb.so and then uses it with an binary compiled before could run into issues. But I noticed eSectionTypeDWARFDebugCuIndex was added in the middle in August, but we need to avoid these kinds of API issues, so lets add this to the end just to be safe.

[jankratochvil]

It is now reworked without FileOffset and the remapping to unique DIE offsets for each DW_TAG_partial_unit inclusion by DW_TAG_imported_unit, as discussed in: https://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180409/040324.html

[labath]

Could you add a "section type" line in the dumpModules in lldb-test.cpp. Then we can write a test for this. (not that this is a extremely dangerous change, but it seems a shame not to test it when it is so easy).

[jankratochvil]

Implemented that section type line in the dumpModules in lldb-test.cpp.

[labath]

Thanks, that's great, but I don't see you using that functionality to test the debug-alt-link classification (I guess I wasn't clear about that, but that is the reason why I asked you to add it). Could you add a test with the new section as well?

[jankratochvil]

Added lit/Modules/dwarf-gnu-debugaltlink.yaml. I do not see its test success anywhere but when I make it fail I see its failure in make check-lldb stdout/stderr. Curiously its simulated failure does not appear in make check-lit.

[labath]

Awesome, thanks. I think we can get this one out of the way.

In D40468#1080136, @jankratochvil wrote:

Added lit/Modules/dwarf-gnu-debugaltlink.yaml. I do not see its test success anywhere but when I make it fail I see its failure in make check-lldb stdout/stderr.

That's supposed to happen. To see passing tests you need to run lit in the verbose mode.

Curiously its simulated failure does not appear in make check-lit.

check-lit is a lit-selftest. This test should not be run as a part of that. Did you perhaps mean check-lldb-lit (which should probably be removed because it's now practically an alias for check-lldb)?

[jankratochvil]

In D40468#1080751, @labath wrote:

Awesome, thanks. I think we can get this one out of the way.

Thanks, I will check it in next days.

check-lit is a lit-selftest. This test should not be run as a part of that. Did you perhaps mean check-lldb-lit (which should probably be removed because it's now practically an alias for check-lldb)?

Yes, I was wrongly running check-lit instead of check-lldb-lit, thanks for the correction.

lldb/trunk/include/lldb/Core/Section.h

public:
   bool IsDescendant(const Section *section);
 
   const ConstString &GetName() const { return m_name; }
 
   bool Slide(lldb::addr_t slide_amount, bool slide_children);
 
   lldb::SectionType GetType() const { return m_type; }
 
+  const char *GetTypeAsCString() const;
+
   lldb::SectionSP GetParent() const { return m_parent_wp.lock(); }
 
   bool IsThreadSpecific() const { return m_thread_specific; }
 
   void SetIsThreadSpecific(bool b) { m_thread_specific = b; }
 
   //------------------------------------------------------------------
   /// Get the permissions as OR'ed bits from lldb::Permissions

lldb/trunk/include/lldb/lldb-enumerations.h

enum SectionType {
   eSectionTypeEHFrame,
   eSectionTypeARMexidx,
   eSectionTypeARMextab,
   eSectionTypeCompactUnwind, // compact unwind section in Mach-O,
                              // __TEXT,__unwind_info
   eSectionTypeGoSymtab,
   eSectionTypeAbsoluteAddress, // Dummy section for symbols with absolute
                                // address
+  eSectionTypeDWARFGNUDebugAltLink,
   eSectionTypeOther
 };
 
 FLAGS_ENUM(EmulateInstructionOptions){
     eEmulateInstructionOptionNone = (0u),
     eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
     eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
 

lldb/trunk/lit/Modules/build-id-case.yaml

 # RUN: mkdir -p %t/.build-id/1b
 # RUN: yaml2obj %s > %t/.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug
 # RUN: cd %t
 # RUN: llvm-objcopy --strip-all --add-gnu-debuglink=.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug %t/.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug %t/stripped.out
 # RUN: lldb-test module-sections %t/stripped.out | FileCheck %s
 
 # CHECK: Name: .debug_frame
+# CHECK-NEXT: Type: dwarf-frame
 # CHECK-NEXT: VM size: 0
 # CHECK-NEXT: File size: 8
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC

lldb/trunk/lit/Modules/compressed-sections.yaml

- Name:            .hello_elf
     Flags:           [ SHF_COMPRESSED ]
     Content:         010000000800000001000000789c5330700848286898000009c802c1
   - Name:            .bogus
     Type:            SHT_PROGBITS
     Flags:           [ SHF_COMPRESSED ]
     Content:         deadbeefbaadf00d
 
 # CHECK: Name: .hello_elf
+# CHECK-NEXT: Type: regular
 # CHECK-NEXT: VM size: 0
 # CHECK-NEXT: File size: 28
 # CHECK-NEXT: Data:
 # CHECK-NEXT: 20304050 60708090
 
 # CHECK: Name: .bogus
+# CHECK-NEXT: Type: regular
 # CHECK-NEXT: VM size: 0
 # CHECK-NEXT: File size: 8
 # CHECK-NEXT: Data:
 # CHECK-NEXT: DEADBEEF BAADF00D

lldb/trunk/lit/Modules/dwarf-gnu-debugaltlink.yaml

+# RUN: yaml2obj %s > %t
+# RUN: lldb-test module-sections %t | FileCheck %s
+
+# CHECK: Name: .gnu_debugaltlink
+# CHECK-NEXT: Type: dwarf-gnu-debugaltlink
+# CHECK-NEXT: VM size: 0
+# CHECK-NEXT: File size: 8
+
+--- !ELF
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+  Entry:           0x00000000000007A0
+Sections:        
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         DEADBEEFBAADF00D
+  - Name:            .gnu_debugaltlink
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         DEADBEEFBAADF00D
+...

lldb/trunk/source/Core/Section.cpp

 #include <utility>    // for distance
 
 namespace lldb_private {
 class DataExtractor;
 }
 using namespace lldb;
 using namespace lldb_private;
 
-static const char *GetSectionTypeAsCString(lldb::SectionType sect_type) {
-  switch (sect_type) {
+const char *Section::GetTypeAsCString() const {
+  switch (m_type) {
   case eSectionTypeInvalid:
     return "invalid";
   case eSectionTypeCode:
     return "code";
   case eSectionTypeContainer:
     return "container";
   case eSectionTypeData:
     return "data";
const char *Section::GetTypeAsCString() const {
   case eSectionTypeARMextab:
     return "ARM.extab";
   case eSectionTypeCompactUnwind:
     return "compact-unwind";
   case eSectionTypeGoSymtab:
     return "go-symtab";
   case eSectionTypeAbsoluteAddress:
     return "absolute";
+  case eSectionTypeDWARFGNUDebugAltLink:
+    return "dwarf-gnu-debugaltlink";
   case eSectionTypeOther:
     return "regular";
   }
   return "unknown";
 }
 
 Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file,
                  user_id_t sect_id, const ConstString &name,
if (a_module_sp == b_module_sp) {
     else
       return 1; // We already know the modules aren't equal
   }
 }
 
 void Section::Dump(Stream *s, Target *target, uint32_t depth) const {
   //    s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
   s->Indent();
-  s->Printf("0x%8.8" PRIx64 " %-16s ", GetID(),
-            GetSectionTypeAsCString(m_type));
+  s->Printf("0x%8.8" PRIx64 " %-16s ", GetID(), GetTypeAsCString());
   bool resolved = true;
   addr_t addr = LLDB_INVALID_ADDRESS;
 
   if (GetByteSize() == 0)
     s->Printf("%39s", "");
   else {
     if (target)
       addr = GetLoadBaseAddress(target);

lldb/trunk/source/Expression/IRExecutionUnit.cpp

bool IRExecutionUnit::CommitOneAllocation(lldb::ProcessSP &process_sp,
   case lldb::eSectionTypeDWARFDebugPubTypes:
   case lldb::eSectionTypeDWARFDebugRanges:
   case lldb::eSectionTypeDWARFDebugStr:
   case lldb::eSectionTypeDWARFDebugStrOffsets:
   case lldb::eSectionTypeDWARFAppleNames:
   case lldb::eSectionTypeDWARFAppleTypes:
   case lldb::eSectionTypeDWARFAppleNamespaces:
   case lldb::eSectionTypeDWARFAppleObjC:
+  case lldb::eSectionTypeDWARFGNUDebugAltLink:
     error.Clear();
     break;
   default:
     const bool zero_memory = false;
     record.m_process_address =
         Malloc(record.m_size, record.m_alignment, record.m_permissions,
                eAllocationPolicyProcessOnly, zero_memory, error);
     break;

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

for (SectionHeaderCollIter I = m_section_headers.begin();
       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_eh_frame(".eh_frame");
       static ConstString g_sect_name_arm_exidx(".ARM.exidx");
       static ConstString g_sect_name_arm_extab(".ARM.extab");
       static ConstString g_sect_name_go_symtab(".gosymtab");
+      static ConstString g_sect_name_dwarf_gnu_debugaltlink(".gnu_debugaltlink");
 
       SectionType sect_type = eSectionTypeOther;
 
       bool is_thread_specific = false;
 
       if (name == g_sect_name_text)
         sect_type = eSectionTypeCode;
       else if (name == g_sect_name_data)
for (SectionHeaderCollIter I = m_section_headers.begin();
       else if (name == g_sect_name_eh_frame)
         sect_type = eSectionTypeEHFrame;
       else if (name == g_sect_name_arm_exidx)
         sect_type = eSectionTypeARMexidx;
       else if (name == g_sect_name_arm_extab)
         sect_type = eSectionTypeARMextab;
       else if (name == g_sect_name_go_symtab)
         sect_type = eSectionTypeGoSymtab;
+      else if (name == g_sect_name_dwarf_gnu_debugaltlink)
+        sect_type = eSectionTypeDWARFGNUDebugAltLink;
 
       const uint32_t permissions =
           ((header.sh_flags & SHF_ALLOC) ? ePermissionsReadable : 0u) |
           ((header.sh_flags & SHF_WRITE) ? ePermissionsWritable : 0u) |
           ((header.sh_flags & SHF_EXECINSTR) ? ePermissionsExecutable : 0u);
       switch (header.sh_type) {
       case SHT_SYMTAB:
         assert(sect_type == eSectionTypeOther);

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (symbol) {
           case eSectionTypeDWARFDebugPubTypes:
           case eSectionTypeDWARFDebugRanges:
           case eSectionTypeDWARFDebugStr:
           case eSectionTypeDWARFDebugStrOffsets:
           case eSectionTypeDWARFAppleNames:
           case eSectionTypeDWARFAppleTypes:
           case eSectionTypeDWARFAppleNamespaces:
           case eSectionTypeDWARFAppleObjC:
+          case eSectionTypeDWARFGNUDebugAltLink:
             return eAddressClassDebug;
 
           case eSectionTypeEHFrame:
           case eSectionTypeARMexidx:
           case eSectionTypeARMextab:
           case eSectionTypeCompactUnwind:
             return eAddressClassRuntime;
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   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_apple_names_data();
   const lldb_private::DWARFDataExtractor &get_apple_types_data();
   const lldb_private::DWARFDataExtractor &get_apple_namespaces_data();
   const lldb_private::DWARFDataExtractor &get_apple_objc_data();
+  const lldb_private::DWARFDataExtractor &get_gnu_debugaltlink();
 
   DWARFDebugAbbrev *DebugAbbrev();
 
   const DWARFDebugAbbrev *DebugAbbrev() const;
 
   DWARFDebugInfo *DebugInfo();
 
   const DWARFDebugInfo *DebugInfo() const;
protected:
   DWARFDataSegment m_data_debug_loc;
   DWARFDataSegment m_data_debug_ranges;
   DWARFDataSegment m_data_debug_str;
   DWARFDataSegment m_data_debug_str_offsets;
   DWARFDataSegment m_data_apple_names;
   DWARFDataSegment m_data_apple_types;
   DWARFDataSegment m_data_apple_namespaces;
   DWARFDataSegment m_data_apple_objc;
+  DWARFDataSegment m_data_gnu_debugaltlink;
 
   // The unique pointer items below are generated on demand if and when someone
   // accesses
   // them through a non const version of this class.
   std::unique_ptr<DWARFDebugAbbrev> m_abbr;
   std::unique_ptr<DWARFDebugInfo> m_info;
   std::unique_ptr<DWARFDebugLine> m_line;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_names_ap;

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

const DWARFDataExtractor &SymbolFileDWARF::get_apple_namespaces_data() {
   return GetCachedSectionData(eSectionTypeDWARFAppleNamespaces,
                               m_data_apple_namespaces);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_apple_objc_data() {
   return GetCachedSectionData(eSectionTypeDWARFAppleObjC, m_data_apple_objc);
 }
 
+const DWARFDataExtractor &SymbolFileDWARF::get_gnu_debugaltlink() {
+  return GetCachedSectionData(eSectionTypeDWARFGNUDebugAltLink,
+                              m_data_gnu_debugaltlink);
+}
+
 DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
   if (m_abbr.get() == NULL) {
     const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data();
     if (debug_abbrev_data.GetByteSize() > 0) {
       m_abbr.reset(new DWARFDebugAbbrev());
       if (m_abbr.get())
         m_abbr->Parse(debug_abbrev_data);
     }

lldb/trunk/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

if (dsym_fspec) {
           static const SectionType g_sections[] = {
               eSectionTypeDWARFDebugAbbrev,   eSectionTypeDWARFDebugAddr,
               eSectionTypeDWARFDebugAranges,  eSectionTypeDWARFDebugCuIndex,
               eSectionTypeDWARFDebugFrame,    eSectionTypeDWARFDebugInfo,
               eSectionTypeDWARFDebugLine,     eSectionTypeDWARFDebugLoc,
               eSectionTypeDWARFDebugMacInfo,  eSectionTypeDWARFDebugPubNames,
               eSectionTypeDWARFDebugPubTypes, eSectionTypeDWARFDebugRanges,
               eSectionTypeDWARFDebugStr,      eSectionTypeDWARFDebugStrOffsets,
-              eSectionTypeELFSymbolTable,
+              eSectionTypeELFSymbolTable,     eSectionTypeDWARFGNUDebugAltLink,
           };
           for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]);
                ++idx) {
             SectionType section_type = g_sections[idx];
             SectionSP section_sp(
                 objfile_section_list->FindSectionByType(section_type, true));
             if (section_sp) {
               SectionSP module_section_sp(

lldb/trunk/source/Symbol/ObjectFile.cpp

if (symbol) {
           case eSectionTypeDWARFDebugPubTypes:
           case eSectionTypeDWARFDebugRanges:
           case eSectionTypeDWARFDebugStr:
           case eSectionTypeDWARFDebugStrOffsets:
           case eSectionTypeDWARFAppleNames:
           case eSectionTypeDWARFAppleTypes:
           case eSectionTypeDWARFAppleNamespaces:
           case eSectionTypeDWARFAppleObjC:
+          case eSectionTypeDWARFGNUDebugAltLink:
             return eAddressClassDebug;
           case eSectionTypeEHFrame:
           case eSectionTypeARMexidx:
           case eSectionTypeARMextab:
           case eSectionTypeCompactUnwind:
             return eAddressClassRuntime;
           case eSectionTypeELFSymbolTable:
           case eSectionTypeELFDynamicSymbols:

lldb/trunk/tools/lldb-test/lldb-test.cpp

for (const auto &File : opts::module::InputFilenames) {
     size_t Count = Sections->GetNumSections(0);
     Printer.formatLine("Showing {0} sections", Count);
     for (size_t I = 0; I < Count; ++I) {
       AutoIndent Indent(Printer, 2);
       auto S = Sections->GetSectionAtIndex(I);
       assert(S);
       Printer.formatLine("Index: {0}", I);
       Printer.formatLine("Name: {0}", S->GetName().GetStringRef());
+      Printer.formatLine("Type: {0}", S->GetTypeAsCString());
       Printer.formatLine("VM size: {0}", S->GetByteSize());
       Printer.formatLine("File size: {0}", S->GetFileSize());
 
       if (opts::module::SectionContents) {
         DataExtractor Data;
         S->GetSectionData(Data);
         ArrayRef<uint8_t> Bytes = {Data.GetDataStart(), Data.GetDataEnd()};
         Printer.formatBinary("Data: ", Bytes, 0);