[obj2yaml] Add support for dumping the .debug_addr(v5) section.

[Higuoxing]

Summary

This patch adds support for dumping the .debug_addr(v5) section to
obj2yaml.

[grimar]

llvm/lib/DebugInfo/DWARF/DWARFDebugAddr.cpp

187 ↗

(On Diff #291510)

All these getters are short. I'd just implement them in the header file.

llvm/test/tools/obj2yaml/ELF/DWARF/debug-addr.yaml

183

a->an

208

I wonder if instead we should just provide a section description with an arbitrary unsupported content.
E.g:

Sections:
  - Name: .debug_addr
    Content: "AABBCC"

225

I'd probably use

Sections:
  - Name: .debug_addr
    Size: 0

It is a bit more straighforward way to describe an empty section and still
allows to observe obj2yaml produce an DWARF entry instead of a section declaration.

llvm/tools/obj2yaml/dwarf2yaml.cpp

78

I think you can avoid having Entries and insert directly to SegAddrPairs?

80

You can avoid copying a vector with

Y.DebugAddr = std::move(AddrTables);

[jhenderson]

llvm/test/tools/obj2yaml/ELF/DWARF/debug-addr.yaml

8

Any reason you have separate variables for the two address sizes? As far as I can see, they are identical always.

9

This is more robust against other data being emitted in the future causing failures, in my opinion.

10–14

I found the naming scheme of these variables a bit confusing, as I was trying to match up "12" with the value "14", when really you meant "length one-two". I'd just go with LENGTH1 and LENGTH2 etc, i.e. the number of times the value is reused is irrelevant to the naming in this contaxt, at least.

83

Nit: here and below.

184

I think this is a little cleaner English.

[Higuoxing]

Address review comments.

Thanks for reviewing!

llvm/test/tools/obj2yaml/ELF/DWARF/debug-addr.yaml

8

Oh, sorry. I should use one address size here.

[MaskRay]

llvm/tools/obj2yaml/dwarf2yaml.cpp

60

Delete DiscardError

62

extractV5(..., consumeError)

64

[Higuoxing]

Address comments.

Thanks!

[jhenderson]

LGTM, thanks!

llvm/tools/obj2yaml/dwarf2yaml.cpp

62

Nice suggestion!

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugAddr.h

public:
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {}) const;
 
   /// Return the address based on a given index.
   Expected<uint64_t> getAddrEntry(uint32_t Index) const;
 
   /// Return the full length of this table, including the length field.
   /// Return None if the length cannot be identified reliably.
   Optional<uint64_t> getFullLength() const;
+
+  /// Return the DWARF format of this table.
+  dwarf::DwarfFormat getFormat() const { return Format; }
+
+  /// Return the length of this table.
+  uint64_t getLength() const { return Length; }
+
+  /// Return the version of this table.
+  uint16_t getVersion() const { return Version; }
+
+  /// Return the address size of this table.
+  uint8_t getAddressSize() const { return AddrSize; }
+
+  /// Return the segment selector size of this table.
+  uint8_t getSegmentSelectorSize() const { return SegSize; }
+
+  /// Return the parsed addresses of this table.
+  ArrayRef<uint64_t> getAddressEntries() const { return Addrs; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFDEBUGADDR_H

llvm/test/tools/obj2yaml/ELF/DWARF/debug-addr.yaml

+## Test how we dump the .debug_addr section.
+
+## a) Dumping address tables from various object files.
+
+## Dumping address tables from a little endian 64-bit object file.
+# RUN: yaml2obj --docnum=1 %s -DADDRESS=0xFFFFFFFFFFFFFFFF \
+# RUN:   -DADDRSIZE=4 | obj2yaml | \
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections: \
+# RUN:     -DLENGTH1=0x0000000000000014 \
+# RUN:     -DADDRSIZE1=0x08             \
+# RUN:     -DADDR=0xFFFFFFFFFFFFFFFF    \
+# RUN:     -DLENGTH2=0x000000000000000C \
+# RUN:     -DADDRSIZE2=0x04
+
+## Dumping address tables from a big endian 64-bit object file.
+# RUN: yaml2obj --docnum=1 %s -DENDIAN=MSB -DADDRESS=0xFFFFFFFFFFFFFFFF \
+# RUN:   -DADDRSIZE=4 | obj2yaml | \
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections: \
+# RUN:     -DLENGTH1=0x0000000000000014 \
+# RUN:     -DADDRSIZE1=0x08             \
+# RUN:     -DADDR=0xFFFFFFFFFFFFFFFF    \
+# RUN:     -DLENGTH2=0x000000000000000C \
+# RUN:     -DADDRSIZE2=0x04
+
+## Dumping address tables from a little endian 32-bit object file.
+# RUN: yaml2obj --docnum=1 %s -DBITS=32 -DADDRESS=0xFFFFFFFF \
+# RUN:   -DADDRSIZE=8 | obj2yaml | \
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections: \
+# RUN:     -DLENGTH1=0x000000000000000C \
+# RUN:     -DADDRSIZE1=0x04             \
+# RUN:     -DADDR=0x00000000FFFFFFFF    \
+# RUN:     -DLENGTH2=0x0000000000000014 \
+# RUN:     -DADDRSIZE2=0x08
+
+## Dumping address tables from a big endian 32-bit object file.
+# RUN: yaml2obj --docnum=1 %s -DBITS=32 -DENDIAN=MSB -DADDRESS=0xFFFFFFFF \
+# RUN:   -DADDRSIZE=8 | obj2yaml | \
+# RUN:   FileCheck %s --check-prefix=BASIC --implicit-check-not=Sections: \
+# RUN:     -DLENGTH1=0x000000000000000C \
+# RUN:     -DADDRSIZE1=0x04             \
+# RUN:     -DADDR=0x00000000FFFFFFFF    \
+# RUN:     -DLENGTH2=0x0000000000000014 \
+# RUN:     -DADDRSIZE2=0x08
+
+#      BASIC: DWARF:
+# BASIC-NEXT:   debug_addr:
+# BASIC-NEXT:     - Length:      [[LENGTH1]]
+# BASIC-NEXT:       Version:     0x0005
+# BASIC-NEXT:       AddressSize: [[ADDRSIZE1]]
+# BASIC-NEXT:       Entries:
+# BASIC-NEXT:         - Address: 0x0000000000001234
+# BASIC-NEXT:         - Address: 0x0000000000005678
+# BASIC-NEXT:     - Format:      DWARF64
+# BASIC-NEXT:       Length:      [[LENGTH1]]
+# BASIC-NEXT:       Version:     0x0005
+# BASIC-NEXT:       AddressSize: [[ADDRSIZE1]]
+# BASIC-NEXT:       Entries:
+# BASIC-NEXT:         - Address: 0x0000000000001234
+# BASIC-NEXT:         - Address: [[ADDR]]
+# BASIC-NEXT:     - Length:      [[LENGTH2]]
+# BASIC-NEXT:       Version:     0x0005
+# BASIC-NEXT:       AddressSize: [[ADDRSIZE2]]
+# BASIC-NEXT:       Entries:
+# BASIC-NEXT:         - Address: 0x0000000000001234
+# BASIC-NEXT:         - Address: 0x0000000000005678
+# BASIC-NEXT:     - Format:      DWARF64
+# BASIC-NEXT:       Length:      [[LENGTH2]]
+# BASIC-NEXT:       Version:     0x0005
+# BASIC-NEXT:       AddressSize: [[ADDRSIZE2]]
+# BASIC-NEXT:       Entries:
+# BASIC-NEXT:         - Address: 0x0000000000001234
+# BASIC-NEXT:         - Address: 0x0000000000005678
+# BASIC-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS[[BITS=64]]
+  Data:  ELFDATA2[[ENDIAN=LSB]]
+  Type:  ET_EXEC
+DWARF:
+  debug_addr:
+    ## A DWARF32 address table.
+    - Version:     5
+      Entries:
+        - Address: 0x1234
+        - Address: 0x5678
+    ## A DWARF64 address table.
+    - Format:      DWARF64
+      Version:     5
+      Entries:
+        - Address: 0x1234
+        - Address: [[ADDRESS]]
+    ## A DWARF32 address table with a mutable address size.
+    - Version:     5
+      AddressSize: [[ADDRSIZE]]
+      Entries:
+        - Address: 0x1234
+        - Address: 0x5678
+    ## A DWARF64 address table with a mutable address size.
+    - Format:      DWARF64
+      Version:     5
+      AddressSize: [[ADDRSIZE]]
+      Entries:
+        - Address: 0x1234
+        - Address: 0x5678
+
+## b) Test dumping a .debug_addr section whose section header properties are
+## overridden.
+
+## Override the sh_type field.
+# RUN: yaml2obj --docnum=2 %s -DTYPE=SHT_STRTAB | obj2yaml | \
+# RUN:   FileCheck %s -DTYPE=SHT_STRTAB --check-prefix=COMMON
+
+## Override the sh_flags field.
+# RUN: yaml2obj --docnum=2 %s -DFLAGS='[ SHF_ALLOC ]' | obj2yaml | \
+# RUN:   FileCheck %s -DTYPE=SHT_PROGBITS --check-prefixes=COMMON,FLAGS
+
+## Override the sh_link field.
+# RUN: yaml2obj --docnum=2 %s -DLINK=.sec | obj2yaml | \
+# RUN:   FileCheck %s -DTYPE=SHT_PROGBITS --check-prefixes=COMMON,LINK
+
+## Override the sh_addr field.
+# RUN: yaml2obj --docnum=2 %s -DADDRESS=0x2020 | obj2yaml | \
+# RUN:   FileCheck %s -DTYPE=SHT_PROGBITS --check-prefixes=COMMON,ADDR
+
+## Override the sh_addralign field.
+# RUN: yaml2obj --docnum=2 %s -DADDRALIGN=3 | obj2yaml | \
+# RUN:   FileCheck %s -DTYPE=SHT_PROGBITS --check-prefixes=COMMON,ADDRALIGN
+
+## Override the sh_entsize field.
+# RUN: yaml2obj --docnum=2 %s -DENTSIZE=3 | obj2yaml | \
+# RUN:   FileCheck %s -DTYPE=SHT_PROGBITS --check-prefixes=COMMON,ENTSIZE
+
+## Override the sh_info field.
+# RUN: yaml2obj --docnum=2 %s -DINFO=3 | obj2yaml | \
+# RUN:   FileCheck %s -DTYPE=SHT_PROGBITS --check-prefixes=COMMON,INFO
+
+#         COMMON: Sections:
+#    COMMON-NEXT:   - Name:         .debug_addr
+#    COMMON-NEXT:     Type:         [[TYPE]]
+#     FLAGS-NEXT:     Flags:        [ SHF_ALLOC ]
+#      LINK-NEXT:     Link:         .sec
+#      ADDR-NEXT:     Address:      0x0000000000002020
+# ADDRALIGN-NEXT:     AddressAlign: 0x0000000000000003
+#   ENTSIZE-NEXT:     EntSize:      0x0000000000000003
+#      INFO-NEXT:     Info:         0x0000000000000003
+#    COMMON-NEXT:   - Name:         .sec
+#    COMMON-NEXT:     Type:         SHT_PROGBITS
+#    COMMON-NEXT: DWARF:
+#    COMMON-NEXT:   debug_addr:
+#    COMMON-NEXT:     - Length:      0x0000000000000014
+#    COMMON-NEXT:       Version:     0x0005
+#    COMMON-NEXT:       AddressSize: 0x08
+#    COMMON-NEXT:       Entries:
+#    COMMON-NEXT:         - Address: 0x0000000000001234
+#    COMMON-NEXT:         - Address: 0x0000000000005678
+#    COMMON-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:         .debug_addr
+    Type:         [[TYPE=SHT_PROGBITS]]
+    Flags:        [[FLAGS=<none>]]
+    Link:         [[LINK='']]
+    EntSize:      [[ENTSIZE=<none>]]
+    Info:         [[INFO=<none>]]
+    AddressAlign: [[ADDRALIGN=0]]
+    Address:      [[ADDRESS=<none>]]
+  - Name:         .sec
+    Type:         SHT_PROGBITS
+DWARF:
+  debug_addr:
+    - Version: 5
+      Entries:
+        - Address: 0x1234
+        - Address: 0x5678
+
+## c) Test dumping an address table whose version isn't 5.
+## This causes the DWARF parser to fail to parse it and we will dump it as a raw
+## content section.
+
+# RUN: yaml2obj --docnum=3 %s -DCONTENT="AABBCC" | obj2yaml | \
+# RUN:   FileCheck %s --check-prefix=RAW --implicit-check-not=DWARF:
+
+#      RAW: Sections:
+# RAW-NEXT:   - Name:         .debug_addr
+# RAW-NEXT:     Type:         SHT_PROGBITS
+# RAW-NEXT:     AddressAlign: 0x0000000000000001
+# RAW-NEXT:     Content:      AABBCC
+# RAW-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:         .debug_addr
+    Type:         SHT_PROGBITS
+    AddressAlign: 1
+    Size:         [[SIZE=<none>]]
+    Content:      [[CONTENT=<none>]]
+
+## d) Test dumping an empty .debug_addr section.
+
+# RUN: yaml2obj --docnum=3 %s -DSIZE=0 | obj2yaml | \
+# RUN:   FileCheck %s --check-prefix=EMPTY --implicit-check-not=Sections:
+
+#      EMPTY: DWARF:
+# EMPTY-NEXT:   debug_addr: []
+# EMPTY-NEXT: ...

llvm/tools/obj2yaml/dwarf2yaml.cpp

 //===------ dwarf2yaml.cpp - obj2yaml conversion tool -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
 
 #include <algorithm>
for (auto AbbrvDeclSet : *AbbrevSetPtr) {
         }
         Y.DebugAbbrev.back().ID = AbbrevTableID++;
         Y.DebugAbbrev.back().Table.push_back(Abbrv);
       }
     }
   }
 }
 
+Error dumpDebugAddr(DWARFContext &DCtx, DWARFYAML::Data &Y) {
+  DWARFDebugAddrTable AddrTable;
+  DWARFDataExtractor AddrData(DCtx.getDWARFObj(),
+                              DCtx.getDWARFObj().getAddrSection(),
+                              DCtx.isLittleEndian(), /*AddrSize=*/0);
+  std::vector<DWARFYAML::AddrTableEntry> AddrTables;
+  uint64_t Offset = 0;
+  while (AddrData.isValidOffset(Offset)) {
+    // We ignore any errors that don't prevent parsing the section, since we can
+    // still represent such sections.
+    if (Error Err = AddrTable.extractV5(AddrData, &Offset, /*CUAddrSize=*/0,
+                                        consumeError))
+      return Err;
+    AddrTables.emplace_back();
+    for (uint64_t Addr : AddrTable.getAddressEntries()) {
+      // Currently, the parser doesn't support parsing an address table with non
+      // linear addresses (segment_selector_size != 0). The segment selectors
+      // are specified to be zero.
+      AddrTables.back().SegAddrPairs.push_back(
+          {/*SegmentSelector=*/0, /*Address=*/Addr});
+    }
+
+    AddrTables.back().Format = AddrTable.getFormat();
+    AddrTables.back().Length = AddrTable.getLength();
+    AddrTables.back().Version = AddrTable.getVersion();
+    AddrTables.back().AddrSize = AddrTable.getAddressSize();
+    AddrTables.back().SegSelectorSize = AddrTable.getSegmentSelectorSize();
+  }
+  Y.DebugAddr = std::move(AddrTables);
+  return Error::success();
+}
+
 Error dumpDebugStrings(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   DataExtractor StrData = DCtx.getStringExtractor();
   uint64_t Offset = 0;
   std::vector<StringRef> DebugStr;
   Error Err = Error::success();
   while (StrData.isValidOffset(Offset)) {
     const char *CStr = StrData.getCStr(&Offset, &Err);
     if (Err)

llvm/tools/obj2yaml/elf2yaml.cpp

if (ELFYAML::RawContentSection *RawSec =
       cantFail(std::move(Err));
 
       if (RawSec->Name == ".debug_aranges")
         Err = dumpDebugARanges(*DWARFCtx.get(), DWARF);
       else if (RawSec->Name == ".debug_str")
         Err = dumpDebugStrings(*DWARFCtx.get(), DWARF);
       else if (RawSec->Name == ".debug_ranges")
         Err = dumpDebugRanges(*DWARFCtx.get(), DWARF);
+      else if (RawSec->Name == ".debug_addr")
+        Err = dumpDebugAddr(*DWARFCtx.get(), DWARF);
       else
         continue;
 
       // If the DWARF section cannot be successfully parsed, emit raw content
       // instead of an entry in the DWARF section of the YAML.
       if (Err)
         consumeError(std::move(Err));
       else

llvm/tools/obj2yaml/obj2yaml.h

 namespace llvm {
 class DWARFContext;
 namespace DWARFYAML {
 struct Data;
 }
 }
 
 void dumpDebugAbbrev(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
+llvm::Error dumpDebugAddr(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 llvm::Error dumpDebugARanges(llvm::DWARFContext &DCtx,
                              llvm::DWARFYAML::Data &Y);
 void dumpDebugPubSections(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 void dumpDebugInfo(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 void dumpDebugLines(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 llvm::Error dumpDebugRanges(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 llvm::Error dumpDebugStrings(llvm::DWARFContext &DCtx,
                              llvm::DWARFYAML::Data &Y);
 
 #endif