[ObjectYAML][DWARF] Make the `PubSection` optional.

[Higuoxing]

Summary

This patch helps make the PubSection optional in the DWARF structure.

[jhenderson]

LGTM, once one comment is addressed.

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

3

perhaps change this line to "section in object files from the DWARF entry of Mach-O YAML inputs".

[grimar]

llvm/lib/ObjectYAML/MachOEmitter.cpp

299

I think you should do this:

...
} else if (0 == strncmp(&Sec.sectname[0], "__debug_pubnames", 16) {
  if (Obj.DWARF.PubNames)
    DWARFYAML::EmitPubSection(OS, *Obj.DWARF.PubNames,  Obj.IsLittleEndian);
} else
....

Otherwise the code will continue doing strncmp for the following else branches, what is
probably not the desired flow.

llvm/tools/obj2yaml/dwarf2yaml.cpp

149

Thoughts (not for this patch):

Looking on this, I seems it would be better to change the dumpPubSection to
something like:

static DWARFYAML::PubSection dumpPubSection(DWARFContext &DCtx, DWARFSection Section, bool IsGNU);

It should simplify the code here and also will allow to switch to return Expected<DWARFYAML::PubSection> later.

[Higuoxing]

llvm/lib/ObjectYAML/MachOEmitter.cpp

299

Got it! Thanks for the suggestion!

llvm/tools/obj2yaml/dwarf2yaml.cpp

149

Thanks! I will do it later.

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 
 struct PubSection {
   InitialLength Length;
   uint16_t Version;
   uint32_t UnitOffset;
   uint32_t UnitSize;
   bool IsGNUStyle = false;
   std::vector<PubEntry> Entries;
+
+  PubSection() = default;
+  PubSection(bool IsGNUStyle) : IsGNUStyle(IsGNUStyle) {}
 };
 
 struct FormValue {
   llvm::yaml::Hex64 Value;
   StringRef CStr;
   std::vector<llvm::yaml::Hex8> BlockData;
 };
 

 };
 
 struct Data {
   bool IsLittleEndian;
   std::vector<Abbrev> AbbrevDecls;
   std::vector<StringRef> DebugStrings;
   std::vector<ARange> ARanges;
   std::vector<Ranges> DebugRanges;
-  PubSection PubNames;
-  PubSection PubTypes;
+  Optional<PubSection> PubNames;
+  Optional<PubSection> PubTypes;
 
-  PubSection GNUPubNames;
-  PubSection GNUPubTypes;
+  Optional<PubSection> GNUPubNames;
+  Optional<PubSection> GNUPubTypes;
 
   std::vector<Unit> CompileUnits;
 
   std::vector<LineTable> DebugLines;
 
   bool isEmpty() const;
 
   SetVector<StringRef> getUsedSectionNames() const;

llvm/lib/ObjectYAML/DWARFYAML.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ObjectYAML/DWARFYAML.h"
 
 namespace llvm {
 
 bool DWARFYAML::Data::isEmpty() const {
   return DebugStrings.empty() && AbbrevDecls.empty() && ARanges.empty() &&
-         DebugRanges.empty() && PubNames.Entries.empty() &&
-         PubTypes.Entries.empty() && GNUPubNames.Entries.empty() &&
-         GNUPubTypes.Entries.empty() && CompileUnits.empty() &&
-         DebugLines.empty();
+         DebugRanges.empty() && !PubNames && !PubTypes && !GNUPubNames &&
+         !GNUPubTypes && CompileUnits.empty() && DebugLines.empty();
 }
 
 SetVector<StringRef> DWARFYAML::Data::getUsedSectionNames() const {
   SetVector<StringRef> SecNames;
   if (!DebugStrings.empty())
     SecNames.insert("debug_str");
   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);
-  if (!DWARF.PubNames.Entries.empty() || !IO.outputting())
-    IO.mapOptional("debug_pubnames", DWARF.PubNames);
-  if (!DWARF.PubTypes.Entries.empty() || !IO.outputting())
-    IO.mapOptional("debug_pubtypes", DWARF.PubTypes);
-  if (!DWARF.GNUPubNames.Entries.empty() || !IO.outputting())
-    IO.mapOptional("debug_gnu_pubnames", DWARF.GNUPubNames);
-  if (!DWARF.GNUPubTypes.Entries.empty() || !IO.outputting())
-    IO.mapOptional("debug_gnu_pubtypes", DWARF.GNUPubTypes);
   IO.mapOptional("debug_info", DWARF.CompileUnits);
   IO.mapOptional("debug_line", DWARF.DebugLines);
   IO.setContext(&oldContext);
 }
 
 void MappingTraits<DWARFYAML::Abbrev>::mapping(IO &IO,
                                                DWARFYAML::Abbrev &Abbrev) {
   IO.mapRequired("Code", Abbrev.Code);

llvm/lib/ObjectYAML/MachOEmitter.cpp

case MachO::LC_SEGMENT_64:
             DWARFYAML::EmitDebugStr(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_abbrev", 16)) {
             DWARFYAML::EmitDebugAbbrev(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_aranges", 16)) {
             DWARFYAML::EmitDebugAranges(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_ranges", 16)) {
             DWARFYAML::EmitDebugRanges(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubnames", 16)) {
-            DWARFYAML::EmitPubSection(OS, Obj.DWARF.PubNames,
+            if (Obj.DWARF.PubNames)
+              DWARFYAML::EmitPubSection(OS, *Obj.DWARF.PubNames,
                                         Obj.IsLittleEndian);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubtypes", 16)) {
-            DWARFYAML::EmitPubSection(OS, Obj.DWARF.PubTypes,
+            if (Obj.DWARF.PubTypes)
+              DWARFYAML::EmitPubSection(OS, *Obj.DWARF.PubTypes,
                                         Obj.IsLittleEndian);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_info", 16)) {
             DWARFYAML::EmitDebugInfo(OS, Obj.DWARF);
           } else if (0 == strncmp(&Sec.sectname[0], "__debug_line", 16)) {
             DWARFYAML::EmitDebugLine(OS, Obj.DWARF);
           }
 
           continue;
         }

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

+## This file contains test cases for generating .debug_pubnames/.debug_pubtypes
+## section in object files from the DWARF entry of Mach-O YAML inputs
+
+## a) Test that yaml2obj emits the .debug_pubnames and .debug_pubtypes sections and
+## obj2yaml converts them back.
+
 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 
 --- !mach-o
 FileHeader:      
   magic:           0xFEEDFACF
   cputype:         0x01000007
   cpusubtype:      0x00000003
   filetype:        0x0000000A

 #CHECK:     UnitOffset:      0
 #CHECK:     UnitSize:        121
 #CHECK:     Entries:         
 #CHECK:       - DieOffset:       0x00000060
 #CHECK:         Name:            int
 #CHECK:       - DieOffset:       0x00000071
 #CHECK:         Name:            char
 #CHECK: ...
+
+## b) Test that yaml2obj will not emit the .debug_pubnames/.debug_pubtypes section's
+## contents, if the "debug_pubnames"/"debug_pubtypes" entry doesn't exist in the
+## "DWARF" entry.
+
+# RUN: yaml2obj --docnum=2 %s | obj2yaml | FileCheck %s --check-prefix=EMPTY
+
+#      EMPTY: Sections:
+# EMPTY-NEXT:   - sectname:        __debug_pubnames
+# EMPTY-NEXT:     segname:         __DWARF
+# EMPTY-NEXT:     addr:            0x0000000000000000
+# EMPTY-NEXT:     size:            0
+# EMPTY-NEXT:     offset:          0x00000000
+# EMPTY-NEXT:     align:           0
+# EMPTY-NEXT:     reloff:          0x00000000
+# EMPTY-NEXT:     nreloc:          0
+# EMPTY-NEXT:     flags:           0x00000000
+# EMPTY-NEXT:     reserved1:       0x00000000
+# EMPTY-NEXT:     reserved2:       0x00000000
+# EMPTY-NEXT:     reserved3:       0x00000000
+# EMPTY-NEXT:     content:         ''
+# EMPTY-NEXT:   - sectname:        __debug_pubtypes
+# EMPTY-NEXT:     segname:         __DWARF
+# EMPTY-NEXT:     addr:            0x0000000000000000
+# EMPTY-NEXT:     size:            0
+# EMPTY-NEXT:     offset:          0x00000720
+# EMPTY-NEXT:     align:           0
+# EMPTY-NEXT:     reloff:          0x00000000
+# EMPTY-NEXT:     nreloc:          0
+# EMPTY-NEXT:     flags:           0x00000000
+# EMPTY-NEXT:     reserved1:       0x00000000
+# EMPTY-NEXT:     reserved2:       0x00000000
+# EMPTY-NEXT:     reserved3:       0x00000000
+# EMPTY-NEXT:     content:         ''
+# EMPTY-NEXT: ...
+
+--- !mach-o
+FileHeader:
+  magic:      0xFEEDFACF
+  cputype:    0x01000007
+  cpusubtype: 0x00000003
+  filetype:   0x0000000A
+  ncmds:      1
+  sizeofcmds: 1800
+  flags:      0x00000000
+  reserved:   0x00000000
+LoadCommands:
+  - cmd:      LC_SEGMENT_64
+    cmdsize:  232
+    segname:  __DWARF
+    vmaddr:   0x00000000
+    vmsize:   0x00000000
+    fileoff:  0
+    filesize: 0
+    maxprot:  0
+    initprot: 0
+    nsects:   2
+    flags:    0
+    Sections:
+      - sectname:  __debug_pubnames
+        segname:   __DWARF
+        addr:      0x0000000000000000
+        size:      0
+        offset:    0x00000000
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+      - sectname:  __debug_pubtypes
+        segname:   __DWARF
+        addr:      0x0000000000000000
+        size:      0
+        offset:    0x00000720
+        align:     0
+        reloff:    0x00000000
+        nreloc:    0
+        flags:     0x00000000
+        reserved1: 0x00000000
+        reserved2: 0x00000000
+        reserved3: 0x00000000
+DWARF:

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 "Error.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.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>
 
 using namespace llvm;
 
 void dumpInitialLength(DataExtractor &Data, uint64_t &Offset,
                        DWARFYAML::InitialLength &InitialLength) {
if (Y.IsGNUStyle)
       NewEntry.Descriptor = PubSectionData.getU8(&Offset);
     NewEntry.Name = PubSectionData.getCStr(&Offset);
     Y.Entries.push_back(NewEntry);
   }
 }
 
 void dumpDebugPubSections(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   const DWARFObject &D = DCtx.getDWARFObj();
-  Y.PubNames.IsGNUStyle = false;
-  dumpPubSection(DCtx, Y.PubNames, D.getPubnamesSection());
 
-  Y.PubTypes.IsGNUStyle = false;
-  dumpPubSection(DCtx, Y.PubTypes, D.getPubtypesSection());
-
-  Y.GNUPubNames.IsGNUStyle = true;
-  dumpPubSection(DCtx, Y.GNUPubNames, D.getGnuPubnamesSection());
-
-  Y.GNUPubTypes.IsGNUStyle = true;
-  dumpPubSection(DCtx, Y.GNUPubTypes, D.getGnuPubtypesSection());
+  const DWARFSection PubNames = D.getPubnamesSection();
+  if (!PubNames.Data.empty()) {
+    Y.PubNames.emplace(/*IsGNUStyle=*/false);
+    dumpPubSection(DCtx, *Y.PubNames, PubNames);
+  }
+
+  const DWARFSection PubTypes = D.getPubtypesSection();
+  if (!PubTypes.Data.empty()) {
+    Y.PubTypes.emplace(/*IsGNUStyle=*/false);
+    dumpPubSection(DCtx, *Y.PubTypes, PubTypes);
+  }
+
+  const DWARFSection GNUPubNames = D.getGnuPubnamesSection();
+  if (!GNUPubNames.Data.empty()) {
+    // TODO: Test dumping .debug_gnu_pubnames section.
+    Y.GNUPubNames.emplace(/*IsGNUStyle=*/true);
+    dumpPubSection(DCtx, *Y.GNUPubNames, GNUPubNames);
+  }
+
+  const DWARFSection GNUPubTypes = D.getGnuPubtypesSection();
+  if (!GNUPubTypes.Data.empty()) {
+    // TODO: Test dumping .debug_gnu_pubtypes section.
+    Y.GNUPubTypes.emplace(/*IsGNUStyle=*/true);
+    dumpPubSection(DCtx, *Y.GNUPubTypes, GNUPubTypes);
+  }
 }
 
 void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   for (const auto &CU : DCtx.compile_units()) {
     DWARFYAML::Unit NewUnit;
     NewUnit.Length.setLength(CU->getLength());
     NewUnit.Version = CU->getVersion();
     if(NewUnit.Version >= 5)