[DWARFYAML] Make the debug_ranges section optional.

[Higuoxing]

Summary

This patch makes the debug_ranges section optional. When we specify an
empty debug_ranges section, yaml2obj only emits the section header.

[jhenderson]

llvm/test/ObjectYAML/MachO/DWARF-debug_ranges.yaml

288

This test case doesn't feel like it really belongs as part of this patch. It should be its own patch, since it isn't to do with writing an empty .debug_ranges section, right?

292

Similar comment to D87261 - it might be worth adding a check that the DWARF tag doesn't appear in this case.

[Higuoxing]

Address review comments.

Thanks for reviewing!

llvm/test/ObjectYAML/MachO/DWARF-debug_ranges.yaml

288

Yes, it doesn't belong to this patch. I added it because I touched the parser in dwarf2yaml.cpp. When the parser fails the content in the DWARF tag should remain empty. I will add it in a follow-up patch.

[jhenderson]

LGTM.

[Higuoxing]

Rebase.

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 
 struct Data {
   bool IsLittleEndian;
   bool Is64BitAddrSize;
   std::vector<AbbrevTable> DebugAbbrev;
   Optional<std::vector<StringRef>> DebugStrings;
   Optional<std::vector<StringOffsetsTable>> DebugStrOffsets;
   Optional<std::vector<ARange>> DebugAranges;
-  std::vector<Ranges> DebugRanges;
+  Optional<std::vector<Ranges>> DebugRanges;
   Optional<std::vector<AddrTableEntry>> DebugAddr;
   Optional<PubSection> PubNames;
   Optional<PubSection> PubTypes;
 
   Optional<PubSection> GNUPubNames;
   Optional<PubSection> GNUPubTypes;
 
   std::vector<Unit> CompileUnits;

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) {
+  for (auto DebugRanges : *DI.DebugRanges) {
     const size_t CurrOffset = OS.tell() - RangesOffset;
     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) + ")");

llvm/lib/ObjectYAML/DWARFYAML.cpp

 }
 
 SetVector<StringRef> DWARFYAML::Data::getNonEmptySectionNames() const {
   SetVector<StringRef> SecNames;
   if (DebugStrings)
     SecNames.insert("debug_str");
   if (DebugAranges)
     SecNames.insert("debug_aranges");
-  if (!DebugRanges.empty())
+  if (DebugRanges)
     SecNames.insert("debug_ranges");
   if (!DebugLines.empty())
     SecNames.insert("debug_line");
   if (DebugAddr)
     SecNames.insert("debug_addr");
   if (!DebugAbbrev.empty())
     SecNames.insert("debug_abbrev");
   if (!CompileUnits.empty())

 
 void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
   void *OldContext = IO.getContext();
   DWARFYAML::DWARFContext DWARFCtx;
   IO.setContext(&DWARFCtx);
   IO.mapOptional("debug_str", DWARF.DebugStrings);
   IO.mapOptional("debug_abbrev", DWARF.DebugAbbrev);
   IO.mapOptional("debug_aranges", DWARF.DebugAranges);
-  if (!DWARF.DebugRanges.empty() || !IO.outputting())
-    IO.mapOptional("debug_ranges", DWARF.DebugRanges);
   IO.mapOptional("debug_pubnames", DWARF.PubNames);
   IO.mapOptional("debug_pubtypes", DWARF.PubTypes);
   DWARFCtx.IsGNUPubSec = true;
   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);

llvm/test/ObjectYAML/MachO/DWARF-debug_ranges.yaml

- Length:          82
         - AbbrCode:        0x00000002
           Values:
             - Value:           0x0000000000000021
             - Value:           0x0000000000001000
             - Value:           0x0000000000001000
         - AbbrCode:        0x00000000
           Values:          []
 ...
+
+## Test generating and dumping an empty __debug_ranges section.
+
+# RUN: yaml2obj --docnum=2 %s | obj2yaml | FileCheck %s --check-prefix=EMPTY
+
+#      EMPTY: DWARF:
+# EMPTY-NEXT:   debug_ranges:    []
+# EMPTY-NEXT: ...
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 232
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  152
+    segname:  __DWARF
+    vmaddr:   0x00
+    vmsize:   0x00
+    fileoff:  0x00
+    filesize: 0x00
+    maxprot:  0
+    initprot: 0
+    nsects:   1
+    flags:    0
+    Sections:
+      - sectname:  __debug_ranges
+        segname:   __DWARF
+        addr:      0x00
+        size:      [[SIZE=0]]
+        offset:    0x210
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+DWARF:
+  debug_ranges: []

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

FileHeader:
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 DWARF:
   debug_ranges:
     - AddrSize: 0x07
       Entries:
         - LowOffset:  0x1234
           HighOffset: 0x5678
+
+## l) Test that the .debug_ranges section header is emitted if the "debug_ranges"
+## entry is empty.
+
+# RUN: yaml2obj --docnum=12 %s -o %t12.o
+# RUN: llvm-readobj -S %t12.o | FileCheck -DSIZE=0 -DADDRALIGN=1 %s --check-prefix=DWARF-HEADER
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+DWARF:
+  debug_ranges: []

llvm/tools/obj2yaml/dwarf2yaml.cpp

else if (CUAddrSize != AddrSize)
       return createStringError(std::errc::invalid_argument,
                                "address sizes vary in different compile units");
   }
 
   DWARFDataExtractor Data(DCtx.getDWARFObj().getRangesSection().Data,
                           DCtx.isLittleEndian(), AddrSize);
   uint64_t Offset = 0;
   DWARFDebugRangeList DwarfRanges;
+  std::vector<DWARFYAML::Ranges> DebugRanges;
 
   while (Data.isValidOffset(Offset)) {
     DWARFYAML::Ranges YamlRanges;
     YamlRanges.Offset = Offset;
     YamlRanges.AddrSize = AddrSize;
     if (Error E = DwarfRanges.extract(Data, &Offset))
       return E;
     for (const auto &RLE : DwarfRanges.getEntries())
       YamlRanges.Entries.push_back({RLE.StartAddress, RLE.EndAddress});
-    Y.DebugRanges.push_back(std::move(YamlRanges));
+    DebugRanges.push_back(std::move(YamlRanges));
   }
+
+  Y.DebugRanges = DebugRanges;
   return ErrorSuccess();
 }
 
 static Optional<DWARFYAML::PubSection>
 dumpPubSection(const DWARFContext &DCtx, const DWARFSection &Section,
                bool IsGNUStyle) {
   DWARFYAML::PubSection Y;
   DWARFDataExtractor PubSectionData(DCtx.getDWARFObj(), Section,