[ObjectYAML][DWARF] Implement the .debug_addr section.

[Higuoxing]

Summary

This patch implements the .debug_addr section.

[Higuoxing]

Remove #include <bits/stdint-uintn.h>

[Higuoxing]

Remove #include "llvm/Support/YAMLTraits".

[Higuoxing]

Merge D81542 to this patch.

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

66–71

If this function isn't dead already, we should probably aim to delete it with other changes.

77

(uint32_t)UINT32_MAX -> std::numeric_limits<uint32_t>::max()

357

I'd avoid this auto. It's not obvious what the type of DI.DebugAddr is. Same below.

369

writeVariableSizedInteger emits an assertion if you are writing values of size other than 1/2/4/8. You'll need to add an error check here for other sizes, or add some way of allowing writing of other sized integers. If you add an error check, you probably only want to trigger the check when there are one or more entries in the table, so that you can still have an invalid size without error if the table is empty.

llvm/lib/ObjectYAML/DWARFYAML.cpp

209

I would make SegmentSelectorSize optional, with a default case of 0. That is by far and away the most common case.

You could probably make AddrSize optional too, by referring to the ELF class (i.e. 64/32) if it is unspecified.

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

2

I'm out of time today, so will do a proper review of the tests either later or tomorrow.

156

You can probably get rid of the a1) etc bits. from these comments. If you want them for cross-referencing to the output check above, I'd just make them 1), 2) etc.

[grimar]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

73

I'd replace Format with Is64Bit and put it after IsLittleEndian.

81

It can be

if (Is64Bit)
  writeInteger((uint32_t)UINT32_MAX, OS, IsLittleEndian);
writeVariableSizedInteger(Length, Is64Bit ? 8 : 4, OS, IsLittleEndian);

357

Please do not use auto when the type us not obvious.

361

I'd simplify:

(uint64_t)*AddrTableEntry.Length : /*2 (version) + 1 (address size) + 1 (segment selector size) =*/ 4 +

370

no auto please

llvm/lib/ObjectYAML/DWARFYAML.cpp

205

Hmmm. I guess DWARF64 would be more common?

207

Should it be required? I guess we will be unable to change this value in the future here, because otherwise
our tests that do not specify it explicitly might start to fail. So I am not sure that we want a default value of 5 (or any default value).

[grimar]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

77

Or, perhaps:

writeVariableSizedInteger(UINT32_MAX, 4, OS, IsLittleEndian);

(A bit shorter)

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

73

Personally, I prefer explicitly using the Format here, if I'm honest. I think it's clearer than a boolean.

llvm/lib/ObjectYAML/DWARFYAML.cpp

205

You'd guess wrong :)

DWARF64 generation is only just starting to be supported in MC. DWARF32 is the "standard" format, and being more compact, is used, unless the DWARF section is too big to fit in the 32-bit format. That is very unlikely to ever happen in a current real-world case.

[Higuoxing]

Address comments.

[Higuoxing]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

66–71

Yes, it isn't dead already. I will propose to delete it in another patch.

73

Actually I want a variable like Is64bitTarget or Is64bitAddress in the DWARFYAML::Data structure like IsLittleEndian. With this, yaml2elf will be able to infer the AddrSize and SegmentSelectorSize below.

369

I want to do the error check in writeVariableSizedInteger in another patch.

Error Err = Error::success();
cantFail(Err);
for (const SegAddrPair& Pair : SegAddrPairs) {
  if (Seg.Size != 0) {
    Err = writeVariableSizedInteger();
    if (Err)
      return std::move(Err);
  }
  if (Addr.Size != 0) {
    Err = writeVariableSizedInteger();
    if (Err)
      return std::move(Err);
  }
}

What do you think of it?

llvm/lib/ObjectYAML/DWARFYAML.cpp

207

.debug_addr is new in DWARFv5, I am not sure if the version will be changed in DWARFv6? So I take your advice and change it to mapRequired() here :-)

209

I will make SegmentSelectorSize be 0 by default. As for the AddrSize, we have to add another field Is64bitTarget in the DWARFYAML::Data structure, I will make it optional in a separate patch.

[MaskRay]

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

26

The ASCII art appears to be too verbose.

[jhenderson]

Looks mostly fine to me. How are you ensuring your section data is actually correct? Are you just verifying it against the specification/using llvm-dwarfdump/something else?

llvm/lib/ObjectYAML/DWARFEmitter.cpp

369

Seems reasonable, and similar to what we did with .debug_ranges Offset before.

llvm/lib/ObjectYAML/DWARFYAML.cpp

207

Yeah, I'm inclined to be cautious on this one. We can discuss it with more developers in the future. The conclusion may be that having to explicitly specify the DWARF version in individual tables is annoying. Perhaps there could be a top-level DefaultVersion entry in the DWARF tag that says what version to assume when generating tables, if otherwise unspecified.

209

I still feel like there should be a way to use the file header data to infer the address, rather than needing an explicit field, but it's fine to wait to a subsequent patch for that.

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

26

Do you have a better suggestion for how to illustrate the section data without relying on llvm-dwarfdump (which in turn would be relying on yaml2obj in the future, and thus be circular logic)?

This is the same approach as has been taken in the other tests in this directory.

156

8 -> 4

235

Up to you, but I think it would make things a little less verbose in this test if you just left these all to be DWARF32, and add additional minimal test cases just showing the different behaviour for different DWARF formats, since the format only impacts the header fields.

244

You need a test case each for missing the version and address size fields.

[Higuoxing]

Address comments.

[Higuoxing]

In D81541#2086999, @jhenderson wrote:

Looks mostly fine to me. How are you ensuring your section data is actually correct? Are you just verifying it against the specification/using llvm-dwarfdump/something else?

Yes, I verify it using llvm-dwarfdump except segment. llvm-dwarfdump cannot parse segment in the .debug_addr section.

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

244

Version is a required field, do we still need to test it here?

[Higuoxing]

Rebase.

[jhenderson]

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

156

This comment is a bit stale, since on first glance, it looked like "are you missing the address?" before I realised that it's derived by default.

It might be best to update this comment to say something like "Show that the address size is derived from the file header." possibly in addition to other things, as you think are best. Same sort of comment below.

244

Right, but how do you show that Version is required? You need a test showing that it is, i.e. that you get an error message if the Version is unspecified.

[Higuoxing]

Address comments.

• Add one test case (g) for missing 'Version'.
• Add other common test cases.

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

244

I added one test case (g) for missing 'Version' :-)

[Higuoxing]

Remove one blank line in test cases.

[jhenderson]

LGTM, but please wait for others to confirm.

[grimar]

LGTM

llvm/lib/ObjectYAML/DWARFYAML.cpp

205

Ah, right. I think I read it as object format and not as dwarf format.

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

 Error emitDebugStr(raw_ostream &OS, const Data &DI);
 
 Error emitDebugAranges(raw_ostream &OS, const Data &DI);
 Error emitDebugRanges(raw_ostream &OS, const Data &DI);
 Error emitPubSection(raw_ostream &OS, const PubSection &Sect,
                      bool IsLittleEndian);
 Error emitDebugInfo(raw_ostream &OS, const Data &DI);
 Error emitDebugLine(raw_ostream &OS, const Data &DI);
+Error emitDebugAddr(raw_ostream &OS, const Data &DI);
 
 Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
 emitDebugSections(StringRef YAMLString, bool ApplyFixups = false,
                   bool IsLittleEndian = sys::IsLittleEndianHost);
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_DWARFEMITTER_H

llvm/include/llvm/ObjectYAML/DWARFYAML.h

struct LineTable {
   uint8_t LineRange;
   uint8_t OpcodeBase;
   std::vector<uint8_t> StandardOpcodeLengths;
   std::vector<StringRef> IncludeDirs;
   std::vector<File> Files;
   std::vector<LineTableOpcode> Opcodes;
 };
 
+struct SegAddrPair {
+  yaml::Hex64 Segment;
+  yaml::Hex64 Address;
+};
+
+struct AddrTableEntry {
+  dwarf::DwarfFormat Format;
+  Optional<yaml::Hex64> Length;
+  yaml::Hex16 Version;
+  Optional<yaml::Hex8> AddrSize;
+  yaml::Hex8 SegSelectorSize;
+  std::vector<SegAddrPair> SegAddrPairs;
+};
+
 struct Data {
   bool IsLittleEndian;
   bool Is64bit;
   std::vector<Abbrev> AbbrevDecls;
   std::vector<StringRef> DebugStrings;
   std::vector<ARange> ARanges;
   std::vector<Ranges> DebugRanges;
+  std::vector<AddrTableEntry> DebugAddr;
   Optional<PubSection> PubNames;
   Optional<PubSection> PubTypes;
 
   Optional<PubSection> GNUPubNames;
   Optional<PubSection> GNUPubTypes;
 
   std::vector<Unit> CompileUnits;
 

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Ranges)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::SegAddrPair)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AddrTableEntry)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<DWARFYAML::Data> {
   static void mapping(IO &IO, DWARFYAML::Data &DWARF);
 };
 

 template <> struct MappingTraits<DWARFYAML::LineTableOpcode> {
   static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode);
 };
 
 template <> struct MappingTraits<DWARFYAML::LineTable> {
   static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
 };
 
+template <> struct MappingTraits<DWARFYAML::SegAddrPair> {
+  static void mapping(IO &IO, DWARFYAML::SegAddrPair &SegAddrPair);
+};
+
+template <> struct MappingTraits<DWARFYAML::AddrTableEntry> {
+  static void mapping(IO &IO, DWARFYAML::AddrTableEntry &AddrTable);
+};
+
 template <> struct MappingTraits<DWARFYAML::InitialLength> {
   static void mapping(IO &IO, DWARFYAML::InitialLength &DWARF);
 };
 
 template <> struct ScalarEnumerationTraits<dwarf::DwarfFormat> {
   static void enumeration(IO &IO, dwarf::DwarfFormat &Format) {
     IO.enumCase(Format, "DWARF32", dwarf::DWARF32);
     IO.enumCase(Format, "DWARF64", dwarf::DWARF64);

llvm/lib/ObjectYAML/DWARFEmitter.cpp

 }
 
 static void ZeroFillBytes(raw_ostream &OS, size_t Size) {
   std::vector<uint8_t> FillData;
   FillData.insert(FillData.begin(), Size, 0);
   OS.write(reinterpret_cast<char *>(FillData.data()), Size);
 }
 
 static void writeInitialLength(const DWARFYAML::InitialLength &Length,
                                raw_ostream &OS, bool IsLittleEndian) {
   writeInteger((uint32_t)Length.TotalLength, OS, IsLittleEndian);
   if (Length.isDWARF64())
     writeInteger((uint64_t)Length.TotalLength64, OS, IsLittleEndian);
 }
 
+static void writeInitialLength(const dwarf::DwarfFormat Format,
+                               const uint64_t Length, raw_ostream &OS,
+                               bool IsLittleEndian) {
+  bool IsDWARF64 = Format == llvm::dwarf::DWARF64;
+  if (IsDWARF64)
+    writeVariableSizedInteger(dwarf::DW_LENGTH_DWARF64, 4, OS, IsLittleEndian);
+  writeVariableSizedInteger(Length, IsDWARF64 ? 8 : 4, OS, IsLittleEndian);
+}
+
 Error DWARFYAML::emitDebugStr(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (auto Str : DI.DebugStrings) {
     OS.write(Str.data(), Str.size());
     OS.write('\0');
   }
 
   return Error::success();
 }
for (auto Op : LineTable.Opcodes) {
         }
       }
     }
   }
 
   return Error::success();
 }
 
+Error DWARFYAML::emitDebugAddr(raw_ostream &OS, const Data &DI) {
+  uint8_t TargetAddrSize = DI.Is64bit ? 8 : 4;
+  for (const AddrTableEntry &TableEntry : DI.DebugAddr) {
+    uint8_t AddrSize =
+        TableEntry.AddrSize ? (uint8_t)*TableEntry.AddrSize : TargetAddrSize;
+    uint64_t Length = TableEntry.Length ? (uint64_t)*TableEntry.Length :
+                                        /*2 (version) + 1 (address_size) +
+                                           1 (segment_selector_size) =*/
+                          4 + (AddrSize + TableEntry.SegSelectorSize) *
+                                  TableEntry.SegAddrPairs.size();
+
+    writeInitialLength(TableEntry.Format, Length, OS, DI.IsLittleEndian);
+    writeInteger((uint16_t)TableEntry.Version, OS, DI.IsLittleEndian);
+    writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
+    writeInteger((uint8_t)TableEntry.SegSelectorSize, OS, DI.IsLittleEndian);
+
+    for (const SegAddrPair &Pair : TableEntry.SegAddrPairs) {
+      if (TableEntry.SegSelectorSize != 0)
+        writeVariableSizedInteger(Pair.Segment, TableEntry.SegSelectorSize, OS,
+                                  DI.IsLittleEndian);
+      if (AddrSize != 0)
+        writeVariableSizedInteger(Pair.Address, AddrSize, OS,
+                                  DI.IsLittleEndian);
+    }
+  }
+
+  return Error::success();
+}
+
 using EmitFuncType = Error (*)(raw_ostream &, const DWARFYAML::Data &);
 
 static Error
 emitDebugSectionImpl(const DWARFYAML::Data &DI, EmitFuncType EmitFunc,
                      StringRef Sec,
                      StringMap<std::unique_ptr<MemoryBuffer>> &OutputBuffers) {
   std::string Data;
   raw_string_ostream DebugInfoStream(Data);

llvm/lib/ObjectYAML/DWARFYAML.cpp

SetVector<StringRef> DWARFYAML::Data::getUsedSectionNames() const {
   if (!DebugStrings.empty())
     SecNames.insert("debug_str");
   if (!ARanges.empty())
     SecNames.insert("debug_aranges");
   if (!DebugRanges.empty())
     SecNames.insert("debug_ranges");
   if (!DebugLines.empty())
     SecNames.insert("debug_line");
+  if (!DebugAddr.empty())
+    SecNames.insert("debug_addr");
   return SecNames;
 }
 
 namespace yaml {
 
 void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   auto oldContext = IO.getContext();
   IO.setContext(&DWARF);
   IO.mapOptional("debug_str", DWARF.DebugStrings);
   IO.mapOptional("debug_abbrev", DWARF.AbbrevDecls);
   if (!DWARF.ARanges.empty() || !IO.outputting())
     IO.mapOptional("debug_aranges", DWARF.ARanges);
   if (!DWARF.DebugRanges.empty() || !IO.outputting())
     IO.mapOptional("debug_ranges", DWARF.DebugRanges);
   IO.mapOptional("debug_pubnames", DWARF.PubNames);
   IO.mapOptional("debug_pubtypes", DWARF.PubTypes);
   IO.mapOptional("debug_gnu_pubnames", DWARF.GNUPubNames);
   IO.mapOptional("debug_gnu_pubtypes", DWARF.GNUPubTypes);
   IO.mapOptional("debug_info", DWARF.CompileUnits);
   IO.mapOptional("debug_line", DWARF.DebugLines);
+  IO.mapOptional("debug_addr", DWARF.DebugAddr);
   IO.setContext(&oldContext);
 }
 
 void MappingTraits<DWARFYAML::Abbrev>::mapping(IO &IO,
                                                DWARFYAML::Abbrev &Abbrev) {
   IO.mapRequired("Code", Abbrev.Code);
   IO.mapRequired("Tag", Abbrev.Tag);
   IO.mapRequired("Children", Abbrev.Children);
void MappingTraits<DWARFYAML::LineTable>::mapping(
   IO.mapRequired("LineRange", LineTable.LineRange);
   IO.mapRequired("OpcodeBase", LineTable.OpcodeBase);
   IO.mapRequired("StandardOpcodeLengths", LineTable.StandardOpcodeLengths);
   IO.mapRequired("IncludeDirs", LineTable.IncludeDirs);
   IO.mapRequired("Files", LineTable.Files);
   IO.mapRequired("Opcodes", LineTable.Opcodes);
 }
 
+void MappingTraits<DWARFYAML::SegAddrPair>::mapping(
+    IO &IO, DWARFYAML::SegAddrPair &SegAddrPair) {
+  IO.mapOptional("Segment", SegAddrPair.Segment, 0);
+  IO.mapOptional("Address", SegAddrPair.Address, 0);
+}
+
+void MappingTraits<DWARFYAML::AddrTableEntry>::mapping(
+    IO &IO, DWARFYAML::AddrTableEntry &AddrTable) {
+  IO.mapOptional("Format", AddrTable.Format, dwarf::DWARF32);
+  IO.mapOptional("Length", AddrTable.Length);
+  IO.mapRequired("Version", AddrTable.Version);
+  IO.mapOptional("AddressSize", AddrTable.AddrSize);
+  IO.mapOptional("SegmentSelectorSize", AddrTable.SegSelectorSize, 0);
+  IO.mapOptional("Entries", AddrTable.SegAddrPairs);
+}
+
 void MappingTraits<DWARFYAML::InitialLength>::mapping(
     IO &IO, DWARFYAML::InitialLength &InitialLength) {
   IO.mapRequired("TotalLength", InitialLength.TotalLength);
   if (InitialLength.isDWARF64())
     IO.mapRequired("TotalLength64", InitialLength.TotalLength64);
 }
 
 } // end namespace yaml
 
 } // end namespace llvm

llvm/lib/ObjectYAML/ELFEmitter.cpp

Expected<uint64_t> emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name,
   if (Name == ".debug_str")
     Err = DWARFYAML::emitDebugStr(*OS, DWARF);
   else if (Name == ".debug_aranges")
     Err = DWARFYAML::emitDebugAranges(*OS, DWARF);
   else if (Name == ".debug_ranges")
     Err = DWARFYAML::emitDebugRanges(*OS, DWARF);
   else if (Name == ".debug_line")
     Err = DWARFYAML::emitDebugLine(*OS, DWARF);
+  else if (Name == ".debug_addr")
+    Err = DWARFYAML::emitDebugAddr(*OS, DWARF);
   else
     llvm_unreachable("unexpected emitDWARF() call");
 
   if (Err)
     return std::move(Err);
 
   return CBA.tell() - BeginOffset;
 }

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

+## Test that yaml2obj emits .debug_addr section.
+
+## a) Generate and verify a little endian DWARF32 .debug_addr section in a 64-bit object file.
+
+# RUN: yaml2obj --docnum=1 -DENDIAN=ELFDATA2LSB %s -o %t1.dwarf32.le.o
+# RUN: llvm-readobj --sections --section-data %t1.dwarf32.le.o | \
+# RUN:   FileCheck %s -DSIZE=264 -DADDRALIGN=1 --check-prefixes=SHDR,DWARF32-LE
+
+#            SHDR: Index: 1
+#       SHDR-NEXT: Name: .debug_addr (1)
+#       SHDR-NEXT: Type: SHT_PROGBITS (0x1)
+#       SHDR-NEXT: Flags [ (0x0)
+#       SHDR-NEXT: ]
+#       SHDR-NEXT: Address: 0x0
+#       SHDR-NEXT: Offset: 0x40
+#       SHDR-NEXT: Size: [[SIZE]]
+#       SHDR-NEXT: Link: 0
+#       SHDR-NEXT: Info: 0
+#       SHDR-NEXT: AddressAlignment: [[ADDRALIGN]]
+#       SHDR-NEXT: EntrySize: 0
+# DWARF32-LE-NEXT: SectionData (
+# DWARF32-LE-NEXT:   0000: 0C000000 05000400 34120000 78560000
+##                         |        |   | |  |        |
+##                         |        |   | |  |        +------- address (4-byte)
+##                         |        |   | |  +------- address (4-byte)
+##                         |        |   | +- segment_selector_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 1) unit_length (4-byte)
+##
+# DWARF32-LE-NEXT:   0010: 14000000 05000800 21430000 00000000
+##                         |        |   | |  |
+##                         |        |   | |  +---------------- address (8-byte)
+##                         |        |   | +- segment_selector_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 2) unit_length (4-byte)
+##
+# DWARF32-LE-NEXT:   0020: 65870000 00000000 0C000000 05000004
+##                         |                 |        |   | |
+##                         |                 |        |   | +- segment_selector_size (1-byte)
+##                         |                 |        |   +- address_size (1-byte)
+##                         |                 |        +--- version (2-byte)
+##                         |                 +------- 3) unit_length (4-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-LE-NEXT:   0030: 34120000 78560000 14000000 05000008
+##                         |        |        |        |   | |
+##                         |        |        |        |   | +- segment_selector_size (1-byte)
+##                         |        |        |        |   +- address_size (1-byte)
+##                         |        |        |        +--- version (2-byte)
+##                         |        |        +------- 4) unit_length (4-byte)
+##                         |        +------- segment (4-byte)
+##                         +------- segment (4-byte)
+##
+# DWARF32-LE-NEXT:   0040: 21430000 00000000 65870000 00000000
+##                         |                 |
+##                         |                 +---------------- segment (8-byte)
+##                         +---------------- segment (8-byte)
+##
+# DWARF32-LE-NEXT:   0050: 1C000000 05000404 34120000 78560000
+##                         |        |   | |  |        |
+##                         |        |   | |  |        +------- address (4-byte)
+##                         |        |   | |  +------- segment (4-byte)
+##                         |        |   | +- segment_selector_size (4-byte)
+##                         |        |   +- address_size (4-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 5) unit_length (4-byte)
+##
+# DWARF32-LE-NEXT:   0060: 21430000 00000000 00000000 21430000
+##                         |        |        |        |
+##                         |        |        |        +------- address (4-byte)
+##                         |        |        +------- segment (4-byte)
+##                         |        +------- address (4-byte)
+##                         +------- segment (4-byte)
+##
+# DWARF32-LE-NEXT:   0070: 34000000 05000808 34120000 00000000
+##                         |        |   | |  |
+##                         |        |   | |  +---------------- segment (8-byte)
+##                         |        |   | +- segment_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 6) unit_length (4-byte)
+##
+# DWARF32-LE-NEXT:   0080: 78560000 00000000 21430000 00000000
+##                         |                 |
+##                         |                 +---------------- segment (8-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-LE-NEXT:   0090: 00000000 00000000 00000000 00000000
+##                         |                 +---------------- segment (8-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-LE-NEXT:   00A0: 21430000 00000000 28000000 05000408
+##                         |                 |        |   | |
+##                         |                 |        |   | +- segment_size (1-byte)
+##                         |                 |        |   +- address_size (1-byte)
+##                         |                 |        +--- version (2-byte)
+##                         |                 +------- 7) unit_length (4-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-LE-NEXT:   00B0: 34120000 00000000 78560000 21430000
+##                         |                 |        |
+##                         |                 |        +------- segment (8-byte)
+##                         |                 +------- address (4-byte)
+##                         +---------------- segment (8-byte)
+##
+# DWARF32-LE-NEXT:   00C0: 00000000 00000000 00000000 00000000
+##                         |        |        +---------------- segment (8-byte)
+##                         |        +------- address (4-btye)
+##                         +------- higher 4-byte of segment
+##
+# DWARF32-LE-NEXT:   00D0: 21430000 28000000 05000804 34120000
+##                         |        |        |   | |  +------- segment (4-byte)
+##                         |        |        |   | +- segment_size (1-byte)
+##                         |        |        |   +- address_size (1-byte)
+##                         |        |        +--- version (2-byte)
+##                         |        +------- 8) unit_length (4-byte)
+##                         +------- address (4-byte)
+##
+# DWARF32-LE-NEXT:   00E0: 78560000 00000000 21430000 00000000
+##                         |                 |        |
+##                         |                 |        +------- address (8-byte)
+##                         |                 +------- segment (4-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-LE-NEXT:   00F0: 00000000 00000000 21430000 00000000
+##                         |        |        |
+##                         |        |        +---------------- address (8-byte)
+##                         |        +------- segment (4-byte)
+##                         +------- higher 4-byte of address
+##
+# DWARF32-LE-NEXT:   0100: 34120000 02000400
+##                         |        |   | |
+##                         |        |   | +- segment_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 9) unit_length (4-byte)
+# DWARF32-LE-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    [[ENDIAN]]
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_addr:
+    ## 1) Only address (4-byte) exists.
+    - Version:     5
+      AddressSize: 0x04
+      Entries:
+        - Address: 0x1234
+        - Address: 0x5678
+    ## 2) Only address (8-byte) exists.
+    - Version: 5
+      Entries:
+        - Address: 0x4321
+        - Address: 0x8765
+    ## 3) Only segment (4-byte) exists.
+    - Version:             5
+      AddressSize:         0x00
+      SegmentSelectorSize: 0x04
+      Entries:
+        - Segment: 0x1234
+        - Segment: 0x5678
+    ## 4) Only segment (8-byte) exists.
+    - Version:             5
+      AddressSize:         0x00
+      SegmentSelectorSize: 0x08
+      Entries:
+        - Segment: 0x4321
+        - Segment: 0x8765
+    ## 5) Both address (4-byte) and segment (4-byte) exist.
+    - Version:             5
+      AddressSize:         0x04
+      SegmentSelectorSize: 0x04
+      Entries:
+        - Segment: 0x1234
+          Address: 0x5678
+        - Segment: 0x4321
+          ## Segment exists, while address takes the default value 0x00.
+        - Address: 0x4321
+          ## Address exists, while segment takes the default value 0x00.
+    ## 6) Both address (8-byte) and segment (8-byte) exist.
+    - Version:             5
+      SegmentSelectorSize: 0x08
+      Entries:
+        - Segment: 0x1234
+          Address: 0x5678
+        - Segment: 0x4321
+          ## Segment exists, while address takes the default value 0x00.
+        - Address: 0x4321
+          ## Address exists, while segment takes the default value 0x00.
+    ## 7) Both address (4-byte) and segment (8-byte) exist.
+    - Version:             5
+      AddressSize:         0x04
+      SegmentSelectorSize: 0x08
+      Entries:
+        - Segment: 0x1234
+          Address: 0x5678
+        - Segment: 0x4321
+          ## Segment exists, while address takes the default value 0x00.
+        - Address: 0x4321
+          ## Address exists, while segment takes the default value 0x00.
+    ## 8) Both address (8-byte) and segment (4-byte) exist.
+    - Version:             5
+      SegmentSelectorSize: 0x04
+      Entries:
+        - Segment: 0x1234
+          Address: 0x5678
+        - Segment: 0x4321
+          ## Segment exists, while address takes the default value 0x00.
+        - Address: 0x4321
+          ## Address exists, while segment takes the default value 0x00.
+    ## 9) Explicitly assign a value to 'Length'.
+    - Length:              0x1234
+      Version:             0x02
+      AddressSize:         0x04
+      SegmentSelectorSize: 0x00
+      Entries:             []
+
+## b) Generate and verify a big endian DWARF32 .debug_addr section.
+
+# RUN: yaml2obj --docnum=1 -DENDIAN=ELFDATA2MSB %s -o %t1.dwarf32.be.o
+# RUN: llvm-readobj --sections --section-data %t1.dwarf32.be.o | \
+# RUN:   FileCheck %s -DSIZE=264 -DADDRALIGN=1 --check-prefixes=SHDR,DWARF32-BE
+
+# DWARF32-BE-NEXT: SectionData (
+# DWARF32-BE-NEXT:   0000: 0000000C 00050400 00001234 00005678
+##                         |        |   | |  |        |
+##                         |        |   | |  |        +------- address (4-byte)
+##                         |        |   | |  +------- address (4-byte)
+##                         |        |   | +- segment_selector_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 1) unit_length (4-byte)
+##
+# DWARF32-BE-NEXT:   0010: 00000014 00050800 00000000 00004321
+##                         |        |   | |  |
+##                         |        |   | |  +---------------- address (8-byte)
+##                         |        |   | +- segment_selector_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 2) unit_length (4-byte)
+##
+# DWARF32-BE-NEXT:   0020: 00000000 00008765 0000000C 00050004
+##                         |                 |        |   | |
+##                         |                 |        |   | +- segment_selector_size (1-byte)
+##                         |                 |        |   +- address_size (1-byte)
+##                         |                 |        +--- version (2-byte)
+##                         |                 +------- 3) unit_length (4-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-BE-NEXT:   0030: 00001234 00005678 00000014 00050008
+##                         |        |        |        |   | |
+##                         |        |        |        |   | +- segment_selector_size (1-byte)
+##                         |        |        |        |   +- address_size (1-byte)
+##                         |        |        |        +--- version (2-byte)
+##                         |        |        +------- 4) unit_length (4-byte)
+##                         |        +------- segment (4-byte)
+##                         +------- segment (4-byte)
+##
+# DWARF32-BE-NEXT:   0040: 00000000 00004321 00000000 00008765
+##                         |                 |
+##                         |                 +---------------- segment (8-byte)
+##                         +---------------- segment (8-byte)
+##
+# DWARF32-BE-NEXT:   0050: 0000001C 00050404 00001234 00005678
+##                         |        |   | |  |        |
+##                         |        |   | |  |        +------- address (4-byte)
+##                         |        |   | |  +------- segment (4-byte)
+##                         |        |   | +- segment_selector_size (4-byte)
+##                         |        |   +- address_size (4-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 5) unit_length (4-byte)
+##
+# DWARF32-BE-NEXT:   0060: 00004321 00000000 00000000 00004321
+##                         |        |        |        |
+##                         |        |        |        +------- address (4-byte)
+##                         |        |        +------- segment (4-byte)
+##                         |        +------- address (4-byte)
+##                         +------- segment (4-byte)
+##
+# DWARF32-BE-NEXT:   0070: 00000034 00050808 00000000 00001234
+##                         |        |   | |  |
+##                         |        |   | |  +---------------- segment (8-byte)
+##                         |        |   | +- segment_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 6) unit_length (4-byte)
+##
+# DWARF32-BE-NEXT:   0080: 00000000 00005678 00000000 00004321
+##                         |                 |
+##                         |                 +---------------- segment (8-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-BE-NEXT:   0090: 00000000 00000000 00000000 00000000
+##                         |                 |
+##                         |                 +---------------- segment (8-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-BE-NEXT:   00A0: 00000000 00004321 00000028 00050408
+##                         |                 |        |   | |
+##                         |                 |        |   | +- segment_size (1-byte)
+##                         |                 |        |   +- address_size (1-byte)
+##                         |                 |        +--- version (2-byte)
+##                         |                 +------- 7) unit_length (4-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-BE-NEXT:   00B0: 00000000 00001234 00005678 00000000
+##                         |                 |        |
+##                         |                 |        +------- segment (8-byte)
+##                         |                 +------- address (4-byte)
+##                         +---------------- segment (8-byte)
+##
+# DWARF32-BE-NEXT:   00C0: 00004321 00000000 00000000 00000000
+##                         |        |        |
+##                         |        |        +---------------- segment (8-byte)
+##                         |        +------- address (4-btye)
+##                         +------- lower 4-byte of segment
+##
+# DWARF32-BE-NEXT:   00D0: 00004321 00000028 00050804 00001234
+##                         |        |        |   | |  |
+##                         |        |        |   | |  +------- segment (4-byte)
+##                         |        |        |   | +- segment_size (1-byte)
+##                         |        |        |   +- address_size (1-byte)
+##                         |        |        +--- version (2-byte)
+##                         |        +------- 8) unit_length (4-byte)
+##                         +------- address (4-byte)
+##
+# DWARF32-BE-NEXT:   00E0: 00000000 00005678 00004321 00000000
+##                         |                 |        |
+##                         |                 |        +------- address (8-byte)
+##                         |                 +------- segment (4-byte)
+##                         +---------------- address (8-byte)
+##
+# DWARF32-BE-NEXT:   00F0: 00000000 00000000 00000000 00004321
+##                         |        |        |
+##                         |        |        +---------------- address (8-byte)
+##                         |        +------- segment (4-byte)
+##                         +------- lower 4-byte of address
+##
+# DWARF32-BE-NEXT:   0100: 00001234 00020400
+##                         |        |   | |
+##                         |        |   | +- segment_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- 9) unit_length (4-byte)
+# DWARF32-BE-NEXT: )
+
+## c) Generate and verify a little endian DWARF64 .debug_addr section.
+
+# RUN: yaml2obj --docnum=2 -DENDIAN=ELFDATA2LSB %s -o %t2.dwarf64.le.o
+# RUN: llvm-readobj --sections --section-data %t2.dwarf64.le.o | \
+# RUN:   FileCheck %s -DSIZE=56 -DADDRALIGN=1 --check-prefixes=SHDR,DWARF64-LE
+
+# DWARF64-LE-NEXT: SectionData (
+# DWARF64-LE-NEXT:   0000: FFFFFFFF 0C000000 00000000 05000400
+##                         |                          |   | |
+##                         |                          |   | +- segment_selector_size (1-byte)
+##                         |                          |   +- address_size (1-byte)
+##                         |                          +--- version (2-byte)
+##                         +------------------------- unit_length (12-byte)
+##
+# DWARF64-LE-NEXT:   0010: 34120000 78560000 FFFFFFFF 14000000
+##                         |        |        |
+##                         |        |        +---------------- unit_length (12-byte)
+##                         |        +------- address (4-byte)
+##                         +------- address (4-byte)
+##
+# DWARF64-LE-NEXT:   0020: 00000000 05000800 21430000 00000000
+##                         |        |   | |  |
+##                         |        |   | |  +---------------- address (8-byte)
+##                         |        |   | +- segment_selector_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- last 4-byte of unit_length
+##
+# DWARF64-LE-NEXT:   0030: 65870000 00000000
+##                         |
+##                         +---------------- address (8-byte)
+# DWARF64-LE-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    [[ENDIAN]]
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_addr:
+    - Format:      DWARF64
+      Version:     5
+      AddressSize: 0x04
+      Entries:
+        - Address: 0x1234
+        - Address: 0x5678
+    - Format:   DWARF64
+      Version:  5
+      Entries:
+        - Address: 0x4321
+        - Address: 0x8765
+
+## d) Generate and verify a big endian DWARF64 .debug_addr section.
+
+# RUN: yaml2obj --docnum=2 -DENDIAN=ELFDATA2MSB %s -o %t2.dwarf64.be.o
+# RUN: llvm-readobj --sections --section-data %t2.dwarf64.be.o | \
+# RUN:   FileCheck %s -DSIZE=56 -DADDRALIGN=1 --check-prefixes=SHDR,DWARF64-BE
+
+# DWARF64-BE-NEXT: SectionData (
+# DWARF64-BE-NEXT:   0000: FFFFFFFF 00000000 0000000C 00050400
+##                         |                          |   | |
+##                         |                          |   | +- segment_selector_size (1-byte)
+##                         |                          |   +- address_size (1-byte)
+##                         |                          +--- version (2-byte)
+##                         +------------------------- unit_length (12-byte)
+##
+# DWARF64-BE-NEXT:   0010: 00001234 00005678 FFFFFFFF 00000000
+##                         |        |        |
+##                         |        |        +---------------- unit_length (12-byte)
+##                         |        +------- address (4-byte)
+##                         +------- address (4-byte)
+##
+# DWARF64-BE-NEXT:   0020: 00000014 00050800 00000000 00004321
+##                         |        |   | |  |
+##                         |        |   | |  +---------------- address (8-byte)
+##                         |        |   | +- segment_selector_size (1-byte)
+##                         |        |   +- address_size (1-byte)
+##                         |        +--- version (2-byte)
+##                         +------- last 4-byte of unit_length
+##
+# DWARF64-BE-NEXT:   0030: 00000000 00008765
+##                         |
+##                         +---------------- address (8-byte)
+# DWARF64-BE-NEXT: )