[DWARFYAML][debug_ranges] Make the "Offset" field optional.

[Higuoxing]

Summary

Before this patch, we have to calculate the offset for the current range list entry. This patch helps make the "Offset" field optional.

[Higuoxing]

Add assert(*DebugRanges.Offset >= CurrOffset).

[Higuoxing]

Update.

[jhenderson]

You should also have a test case either in this test or D81217 that shows what happens when you use an offset that is either higher than where you are already, or lower.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

145–147

I don't think this wants to be an assert - it should be an error, right? If you specify a lower offset than the current position (e.g. 0 for the second set), you want an error since you can't place it there.

[Higuoxing]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

145–147

Yes, I think it should be an error as well. Currently, DWARFYAML doesn't support error handling. If we change one void EmitXXXSection() to Error EmitXXXSection(), we should change them all. Can I do it in a follow-up patch?

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

145–147

Oh, I missed that there's an assertion in this area already. Yes, leaving it to a follow-up is fine, but please add a FIXME note in this patch.

[Higuoxing]

I will wait until DWARFYAML supports error handling.

[Higuoxing]

Add one test case when we try to assign an offset that is greater than the number of bytes written already.

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

144–146

Can ZeroFillBytes cope with a size of zero? If so, this can be simplified to simply:

if (DebugRanges.Offset)
  ZeroFillBytes(OS, *DebugRanges.Offset - CurrOffset);

[Higuoxing]

• Address comment.
• Add one more testcase when we try to assign an offset that is equal to the number of bytes written.

[jhenderson]

LGTM, thanks!

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 /// within a range list in the .debug_ranges section.
 struct RangeEntry {
   llvm::yaml::Hex64 LowOffset;
   llvm::yaml::Hex64 HighOffset;
 };
 
 /// Class that describes a single range list inside the .debug_ranges section.
 struct Ranges {
-  llvm::yaml::Hex64 Offset;
+  Optional<llvm::yaml::Hex64> Offset;
   llvm::yaml::Hex8 AddrSize;
   std::vector<RangeEntry> Entries;
 };
 
 struct PubEntry {
   llvm::yaml::Hex32 DieOffset;
   llvm::yaml::Hex8 Descriptor;
   StringRef Name;

llvm/lib/ObjectYAML/DWARFEmitter.cpp

Error DWARFYAML::emitDebugAranges(raw_ostream &OS, const DWARFYAML::Data &DI) {
   return Error::success();
 }
 
 Error DWARFYAML::emitDebugRanges(raw_ostream &OS, const DWARFYAML::Data &DI) {
   const size_t RangesOffset = OS.tell();
   uint64_t EntryIndex = 0;
   for (auto DebugRanges : DI.DebugRanges) {
     const size_t CurrOffset = OS.tell() - RangesOffset;
-    if ((uint64_t)DebugRanges.Offset < CurrOffset)
+    if (DebugRanges.Offset && (uint64_t)*DebugRanges.Offset < CurrOffset)
       return createStringError(errc::invalid_argument,
                                "'Offset' for 'debug_ranges' with index " +
                                    Twine(EntryIndex) +
                                    " must be greater than or equal to the "
                                    "number of bytes written already (0x" +
                                    Twine::utohexstr(CurrOffset) + ")");
-    if (DebugRanges.Offset > CurrOffset)
-      ZeroFillBytes(OS, DebugRanges.Offset - CurrOffset);
+    if (DebugRanges.Offset)
+      ZeroFillBytes(OS, *DebugRanges.Offset - CurrOffset);
     for (auto Entry : DebugRanges.Entries) {
       writeVariableSizedInteger(Entry.LowOffset, DebugRanges.AddrSize, OS,
                                 DI.IsLittleEndian);
       writeVariableSizedInteger(Entry.HighOffset, DebugRanges.AddrSize, OS,
                                 DI.IsLittleEndian);
     }
     ZeroFillBytes(OS, DebugRanges.AddrSize * 2);
     ++EntryIndex;
   }
 

llvm/lib/ObjectYAML/DWARFYAML.cpp

 void MappingTraits<DWARFYAML::RangeEntry>::mapping(
     IO &IO, DWARFYAML::RangeEntry &Descriptor) {
   IO.mapRequired("LowOffset", Descriptor.LowOffset);
   IO.mapRequired("HighOffset", Descriptor.HighOffset);
 }
 
 void MappingTraits<DWARFYAML::Ranges>::mapping(IO &IO,
                                                DWARFYAML::Ranges &DebugRanges) {
-  IO.mapRequired("Offset", DebugRanges.Offset);
+  IO.mapOptional("Offset", DebugRanges.Offset);
   IO.mapRequired("AddrSize", DebugRanges.AddrSize);
   IO.mapRequired("Entries", DebugRanges.Entries);
 }
 
 void MappingTraits<DWARFYAML::PubEntry>::mapping(IO &IO,
                                                  DWARFYAML::PubEntry &Entry) {
   IO.mapRequired("DieOffset", Entry.DieOffset);
   if (reinterpret_cast<DWARFYAML::PubSection *>(IO.getContext())->IsGNUStyle)

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

 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    [[ENDIAN]]
   Type:    ET_EXEC
   Machine: EM_X86_64
 DWARF:
   debug_ranges:
-    - Offset:   0
-      AddrSize: 0x04
+    - AddrSize: 0x04
       Entries:
         - LowOffset:  0x00000010
           HighOffset: 0x00000020
         - LowOffset:  0x00000030
           HighOffset: 0x00000040
         - LowOffset:  0xffffffff
           HighOffset: 0x00000010
         - LowOffset:  0x00000000
           HighOffset: 0x00000000
-    - Offset:   40
-      AddrSize: 0x08
+    - AddrSize: 0x08
       Entries:
         - LowOffset:  0x0000000000000010
           HighOffset: 0x0000000000000020
         - LowOffset:  0x0000000000000030
           HighOffset: 0x0000000000000040
         - LowOffset:  0xffffffffffffffff
           HighOffset: 0x0000000000000010
         - LowOffset:  0x0000000000000000
FileHeader:
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .debug_ranges
     Type: SHT_PROGBITS
     Size: 0x10
 DWARF:
   debug_ranges:
-    - Offset:   0
-      AddrSize: 0x08
+    - AddrSize: 0x08
       Entries:
         - LowOffset:  0x0000000000000001
           HighOffset: 0x0000000000000002
 
 ## e) Test that yaml2obj emits an error message when both the "Content" and the
 ## "debug_ranges" entry are specified at the same time.
 
 # RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=ERROR
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .debug_ranges
     Type:    SHT_PROGBITS
     Content: "00"
 DWARF:
   debug_ranges:
-    - Offset:   0
-      AddrSize: 0x08
+    - AddrSize: 0x08
       Entries:
         - LowOffset:  0x0000000000000001
           HighOffset: 0x0000000000000002
 
 ## f) Test that all the properties can be overridden by the section header when
 ## the "debug_ranges" entry doesn't exist.
 
 # RUN: yaml2obj --docnum=6 %s -o %t6.o
- Name:         .debug_ranges
     Info:         1           # 0 by default.
     AddressAlign: 2           # 1 by default.
     Address:      0x2020      # 0x00 by default.
     Offset:       0x50        # 0x40 for the first section.
   - Name:         .sec        # Linked by .debug_ranges.
     Type:         SHT_STRTAB
 DWARF:
   debug_ranges:
-    - Offset:   0
-      AddrSize: 0x08
+    - AddrSize: 0x08
       Entries:
         - LowOffset:  0x0000000000000001
           HighOffset: 0x0000000000000002
 
 ## h) Test that yaml2obj will not generate the .debug_ranges section when the "DWARF" entry
 ## exists but the "debug_ranges" entry doesn't exist in the "DWARF" entry or the "Sections" entry.
 
 # RUN: yaml2obj --docnum=8 %s -o %t8.o
 # RUN: llvm-readelf --sections %t8.o | FileCheck /dev/null --implicit-check-not=.debug_ranges
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 DWARF:
 
-## i) Test that yaml2obj emits an error message if we try to assign an invalid offset to an
+## i) Test that yaml2obj automatically pads zeros if we try to assign an offset that
+## is greater than or equal to the number of bytes written already.
+
+# RUN: yaml2obj --docnum=9 %s -o %t9.o
+# RUN: llvm-readelf --hex-dump=.debug_ranges %t9.o | FileCheck %s --check-prefix=PADDED
+
+#      PADDED: Hex dump of section '.debug_ranges':
+# PADDED-NEXT: 0x00000000 01000000 00000000 02000000 00000000
+##                        |                 |
+##                        |                 +---------------- HighOffset (8-byte) 0x02
+##                        +---------------- LowOffset (8-byte) 0x01
+##
+# PADDED-NEXT: 0x00000010 00000000 00000000 00000000 00000000
+##                        |
+##                        +---------------------------------- Terminating Entry (16-byte) 0x00
+##
+# PADDED-NEXT: 0x00000020 00010000 00000000 00020000 00000000
+##                        |  |                 |
+##                        |  |                 +------------- HighOffset (8-byte) 0x02
+##                        |  +----------------- LowOffset (8-byte) 0x01
+##                        +- Padded zeros (1-byte) 0x00
+##
+# PADDED-NEXT: 0x00000030 00000000 00000000 00000000 00000000
+##                        | |
+##                        | +-------------------------------- Terminating Entry (16-byte) 0x00
+##                        +- higher byte(s) of HighOffset
+##
+# PADDED-NEXT: 0x00000040 00010000 00000000 00020000 00000000
+##                        | |                 |
+##                        | |                 +-------------- HighOffset (8-byte) 0x02
+##                        | +----------------- LowOffset (8-byte) 0x01
+##                        +- the last byte of terminating entry.
+##
+# PADDED-NEXT: 0x00000050 00000000 00000000 00000000 00000000
+##                        | |
+##                        | +-------------------------------- Terminating Entry (16-byte) 0x00
+##                        +- higher byte(s) of HighOffset
+##
+# PADDED-NEXT: 0x00000060 00
+##                        |
+##                        +- the last byte of terminating entry.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_ranges:
+    - AddrSize: 0x08
+      Entries:
+        - LowOffset:  0x01
+          HighOffset: 0x02
+    - Offset:   0x21  ## There are 0x20 bytes before this entry.
+      AddrSize: 0x08
+      Entries:
+        - LowOffset:  0x01
+          HighOffset: 0x02
+    - Offset:   0x41  ## There are 0x41 bytes before this entry.
+      AddrSize: 0x08
+      Entries:
+        - LowOffset:  0x01
+          HighOffset: 0x02
+
+## j) Test that yaml2obj emits an error message if we try to assign an invalid offset to an
 ## entry of the '.debug_ranges' section.
 
-# RUN: not yaml2obj --docnum=9 %s -o %t9.o 2>&1 | FileCheck %s --check-prefix=INVALID-OFFSET
+# RUN: not yaml2obj --docnum=10 %s -o %t10.o 2>&1 | FileCheck %s --check-prefix=INVALID-OFFSET
 
 # INVALID-OFFSET: yaml2obj: error: 'Offset' for 'debug_ranges' with index 1 must be greater than or equal to the number of bytes written already (0x20)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 DWARF:
   debug_ranges:
-    - Offset:   0x00
-      AddrSize: 0x08
+    - AddrSize: 0x08
       Entries:
         - LowOffset:  0x01
           HighOffset: 0x02
     - Offset:   0x1F ## Must be greater than or equal to 0x20.
       AddrSize: 0x08
       Entries:
         - LowOffset:  0x01
           HighOffset: 0x02