[DWARFYAML] Make the 'Length' field of the address range table optional.

[Higuoxing]

Summary

This patch makes the 'Length' field of the address range table optional.

[MaskRay]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

145

const uint64_t PaddedHeaderLength

149

You can move Length assignment above to the else branch.

[Higuoxing]

Address review comments.

Thanks for reviewing!

llvm/lib/ObjectYAML/DWARFEmitter.cpp

145

Done!

149

It's not easy to do that since the PaddedHeaderLength and HeaderLength is used below. If we move the length assignment above to the else branch, we might need to duplicate some logic.

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

147

Shouldn't there be a SegmentSelectorSize calculation here too? .debug_aranges defines how to actually use the property, so we should probably do the right calculation here.

149

I think @MaskRay is suggesting:

if (Range.Length) {
  Length = *Range.Length;
} else {
  Length += PaddedHeaderLength - HeaderLength;
  Length += AddrSize * 2 * (Range.Descriptors.size() + 1);
}

Since this if overrides Length, and there are no side effects to the += calculations before, there's no reason to do them at all in the if case.

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

514–515

You probably need a variation of this test with a different non-default address size (e.g. 8 for a 32-bit object), to show that the length accounts for the right size. Same applies for the segment selector size.

[Higuoxing]

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

514–515

Currently, yaml2obj doesn't support emitting the segment selector for the address range table. Shall I implement it before this patch?

[jhenderson]

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

514–515

No need to do it before unless you want to (this patch is more useful). You can add it afterwards - just make sure to fix this code path when you do!

[Higuoxing]

Address comments.

Thanks for reviewing!

[jhenderson]

LGTM.

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 
 struct ARangeDescriptor {
   llvm::yaml::Hex64 Address;
   uint64_t Length;
 };
 
 struct ARange {
   dwarf::DwarfFormat Format;
-  yaml::Hex64 Length;
+  Optional<yaml::Hex64> Length;
   uint16_t Version;
   yaml::Hex64 CuOffset;
   Optional<yaml::Hex8> AddrSize;
   yaml::Hex8 SegSize;
   std::vector<ARangeDescriptor> Descriptors;
 };
 
 /// Class that describes a range list entry, or a base address selection entry

llvm/lib/ObjectYAML/DWARFEmitter.cpp

Error DWARFYAML::emitDebugAbbrev(raw_ostream &OS, const DWARFYAML::Data &DI) {
   // of a 0 byte for the abbreviation code.
   OS.write_zeros(1);
 
   return Error::success();
 }
 
 Error DWARFYAML::emitDebugAranges(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (auto Range : DI.ARanges) {
-    auto HeaderStart = OS.tell();
-
     uint8_t AddrSize;
     if (Range.AddrSize)
       AddrSize = *Range.AddrSize;
     else
       AddrSize = DI.Is64BitAddrSize ? 8 : 4;
 
-    writeInitialLength(Range.Format, Range.Length, OS, DI.IsLittleEndian);
+    uint64_t Length = 4; // sizeof(version) 2 + sizeof(address_size) 1 +
+                         // sizeof(segment_selector_size) 1
+    Length +=
+        Range.Format == dwarf::DWARF64 ? 8 : 4; // sizeof(debug_info_offset)
+
+    uint64_t HeaderLength =
+        Length + (Range.Format == dwarf::DWARF64
+                      ? 12
+                      : 4); // sizeof(unit_header) = 12 (DWARF64) or 4 (DWARF32)
+
+    uint64_t PaddedHeaderLength = alignTo(HeaderLength, AddrSize * 2);
+    Length += PaddedHeaderLength - HeaderLength;
+    Length += AddrSize * 2 * (Range.Descriptors.size() + 1);
+
+    if (Range.Length)
+      Length = *Range.Length;
+
+    writeInitialLength(Range.Format, Length, OS, DI.IsLittleEndian);
     writeInteger((uint16_t)Range.Version, OS, DI.IsLittleEndian);
     writeDWARFOffset(Range.CuOffset, Range.Format, OS, DI.IsLittleEndian);
     writeInteger((uint8_t)AddrSize, OS, DI.IsLittleEndian);
     writeInteger((uint8_t)Range.SegSize, OS, DI.IsLittleEndian);
-
-    auto HeaderSize = OS.tell() - HeaderStart;
-    auto FirstDescriptor = alignTo(HeaderSize, AddrSize * 2);
-    ZeroFillBytes(OS, FirstDescriptor - HeaderSize);
+    ZeroFillBytes(OS, PaddedHeaderLength - HeaderLength);
 
     for (auto Descriptor : Range.Descriptors) {
       if (Error Err = writeVariableSizedInteger(Descriptor.Address, AddrSize,
                                                 OS, DI.IsLittleEndian))
         return createStringError(errc::not_supported,
                                  "unable to write debug_aranges address: %s",
                                  toString(std::move(Err)).c_str());
       cantFail(writeVariableSizedInteger(Descriptor.Length, AddrSize, OS,

llvm/lib/ObjectYAML/DWARFYAML.cpp

void MappingTraits<DWARFYAML::ARangeDescriptor>::mapping(
     IO &IO, DWARFYAML::ARangeDescriptor &Descriptor) {
   IO.mapRequired("Address", Descriptor.Address);
   IO.mapRequired("Length", Descriptor.Length);
 }
 
 void MappingTraits<DWARFYAML::ARange>::mapping(IO &IO,
                                                DWARFYAML::ARange &ARange) {
   IO.mapOptional("Format", ARange.Format, dwarf::DWARF32);
-  IO.mapRequired("Length", ARange.Length);
+  IO.mapOptional("Length", ARange.Length);
   IO.mapRequired("Version", ARange.Version);
   IO.mapRequired("CuOffset", ARange.CuOffset);
   IO.mapOptional("AddressSize", ARange.AddrSize);
   IO.mapOptional("SegmentSelectorSize", ARange.SegSize, 0);
   IO.mapRequired("Descriptors", ARange.Descriptors);
 }
 
 void MappingTraits<DWARFYAML::RangeEntry>::mapping(

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

 DWARF:
   debug_aranges:
     - Length:              0x2c
       Version:             2
       CuOffset:            0
       Descriptors:
         - Address: 0x1234
           Length:  0x1000
+
+## k) Test that yaml2obj is able to determine the correct length for the address range table
+## if the 'Length' field isn't specified.
+
+# RUN: yaml2obj --docnum=11 %s -o %t11.o
+# RUN: llvm-readelf --hex-dump=.debug_aranges %t11.o | \
+# RUN:   FileCheck %s --check-prefix=LENGTH
+
+#      LENGTH: Hex dump of section '.debug_aranges':
+# LENGTH-NEXT: 0x00000000 3c000000 02000000 00000800 00000000 <...............
+##                        ^-------                            unit_length (4-byte) 0x3c
+##                                 ^---                       version (2-byte)
+##                                     ^--------              debug_info_offset (4-byte)
+##                                              ^-            address_size (1-byte)
+##                                                ^-          segment_selector_size (1-byte)
+##                                                   ^------- padding (4-byte)
+# LENGTH-NEXT: 0x00000010 34120000 00000000 00100000 00000000 4...............
+##                        ^----------------                   address (8-byte)
+##                                          ^---------------- length (8-byte)
+# LENGTH-NEXT: 0x00000020 21430000 00000000 34120000 00000000 !C......4.......
+##                        ^----------------                   address (8-byte)
+##                                          ^---------------- length (4-byte)
+# LENGTH-NEXT: 0x00000030 00000000 00000000 00000000 00000000 ................
+##                        ^---------------------------------- terminating entry (16-byte)
+# LENGTH-NEXT: 0x00000040 ffffffff 34000000 00000000 02000000 ....4...........
+##                        ^-------------------------          unit_length (12-byte) 0x34
+##                                                   ^---     version (2-byte)
+##                                                       ^--- debug_info_offset
+# LENGTH-NEXT: 0x00000050 00000000 00000800 00000000 00000000 ................
+##                        -------------
+##                                     ^-                     address_size (1-byte)
+##                                       ^-                   segment_selector_size (1-byte)
+##                                          ^---------------- padding (8-byte)
+# LENGTH-NEXT: 0x00000060 34120000 00000000 21430000 00000000 4.......!C......
+##                        ^----------------                   address (8-byte)
+##                                          ^---------------- length (8-ybte)
+# LENGTH-NEXT: 0x00000070 00000000 00000000 00000000 00000000 ................
+##                        ^---------------------------------- terminating entry (16-byte)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_aranges:
+    - Version:  2
+      CuOffset: 0
+      Descriptors:
+        - Address: 0x1234
+          Length:  0x1000
+        - Address: 0x4321
+          Length:  0x1234
+    - Format:   DWARF64
+      Version:  2
+      CuOffset: 0
+      Descriptors:
+        - Address: 0x1234
+          Length:  0x4321