[DWARFYAML] Replace 'Format', 'Version', etc with 'FormParams'. NFC.

[Higuoxing]

Summary

This patch replaces 'Format', 'Version' fields, etc with 'FormParams' to
simplify codes.

[labath]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

346–348

I guess this would be Unit.FormParams.getDwarfOffsetByteSize()

[Higuoxing]

Address comments.

Thanks for reviewing!

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 
 /// Class that contains helpful context information when mapping YAML into DWARF
 /// data structures.
 struct DWARFContext {
   bool IsGNUPubSec = false;
 };
 
 struct Unit {
-  dwarf::DwarfFormat Format;
+  dwarf::FormParams FormParams;
   Optional<yaml::Hex64> Length;
-  uint16_t Version;
   llvm::dwarf::UnitType Type; // Added in DWARF 5
   yaml::Hex64 AbbrOffset;
-  uint8_t AddrSize;
   std::vector<Entry> Entries;
 };
 
 struct File {
   StringRef Name;
   uint64_t DirIdx;
   uint64_t ModTime;
   uint64_t Length;

llvm/lib/ObjectYAML/DWARFEmitter.cpp

if (IsGNUPubSec)
       writeInteger((uint8_t)Entry.Descriptor, OS, IsLittleEndian);
     OS.write(Entry.Name.data(), Entry.Name.size());
     OS.write('\0');
   }
 
   return Error::success();
 }
 
-static unsigned getOffsetSize(const DWARFYAML::Unit &Unit) {
-  return Unit.Format == dwarf::DWARF64 ? 8 : 4;
-}
-
-static unsigned getRefSize(const DWARFYAML::Unit &Unit) {
-  if (Unit.Version == 2)
-    return Unit.AddrSize;
-  return getOffsetSize(Unit);
-}
-
 static Expected<uint64_t> writeDIE(ArrayRef<DWARFYAML::Abbrev> AbbrevDecls,
                                    const DWARFYAML::Unit &Unit,
                                    const DWARFYAML::Entry &Entry,
                                    raw_ostream &OS, bool IsLittleEndian) {
   uint64_t EntryBegin = OS.tell();
   encodeULEB128(Entry.AbbrCode, OS);
   uint32_t AbbrCode = Entry.AbbrCode;
   if (AbbrCode == 0 || Entry.Values.empty())
for (; FormVal != Entry.Values.end() && AbbrForm != Abbrev.Attributes.end();
        ++FormVal, ++AbbrForm) {
     dwarf::Form Form = AbbrForm->Form;
     bool Indirect;
     do {
       Indirect = false;
       switch (Form) {
       case dwarf::DW_FORM_addr:
         // TODO: Test this error.
-        if (Error Err = writeVariableSizedInteger(FormVal->Value, Unit.AddrSize,
-                                                  OS, IsLittleEndian))
+        if (Error Err = writeVariableSizedInteger(
+                FormVal->Value, Unit.FormParams.AddrSize, OS, IsLittleEndian))
           return std::move(Err);
         break;
       case dwarf::DW_FORM_ref_addr:
         // TODO: Test this error.
         if (Error Err = writeVariableSizedInteger(
-                FormVal->Value, getRefSize(Unit), OS, IsLittleEndian))
+                FormVal->Value, Unit.FormParams.getRefAddrByteSize(), OS,
+                IsLittleEndian))
           return std::move(Err);
         break;
       case dwarf::DW_FORM_exprloc:
       case dwarf::DW_FORM_block:
         encodeULEB128(FormVal->BlockData.size(), OS);
         OS.write((const char *)FormVal->BlockData.data(),
                  FormVal->BlockData.size());
         break;
do {
         ++FormVal;
         break;
       case dwarf::DW_FORM_strp:
       case dwarf::DW_FORM_sec_offset:
       case dwarf::DW_FORM_GNU_ref_alt:
       case dwarf::DW_FORM_GNU_strp_alt:
       case dwarf::DW_FORM_line_strp:
       case dwarf::DW_FORM_strp_sup:
-        // TODO: Test this error.
-        if (Error Err = writeVariableSizedInteger(
-                FormVal->Value, getOffsetSize(Unit), OS, IsLittleEndian))
-          return std::move(Err);
+        cantFail(writeVariableSizedInteger(
+            FormVal->Value, Unit.FormParams.getDwarfOffsetByteSize(), OS,
+            IsLittleEndian));
         break;
       default:
         break;
       }
     } while (Indirect);
   }
 
   return OS.tell() - EntryBegin;
 }
 
 Error DWARFYAML::emitDebugInfo(raw_ostream &OS, const DWARFYAML::Data &DI) {
   for (const DWARFYAML::Unit &Unit : DI.CompileUnits) {
     uint64_t Length = 3; // sizeof(version) + sizeof(address_size)
-    Length += Unit.Version >= 5 ? 1 : 0; // sizeof(unit_type)
+    Length += Unit.FormParams.Version >= 5 ? 1 : 0; // sizeof(unit_type)
     Length +=
-        Unit.Format == dwarf::DWARF64 ? 8 : 4; // sizeof(debug_abbrev_offset)
+        Unit.FormParams.getDwarfOffsetByteSize(); // sizeof(debug_abbrev_offset)
 
     // Since the length of the current compilation unit is undetermined yet, we
     // firstly write the content of the compilation unit to a buffer to
     // calculate it and then serialize the buffer content to the actual output
     // stream.
     std::string EntryBuffer;
     raw_string_ostream EntryBufferOS(EntryBuffer);
 
     for (const DWARFYAML::Entry &Entry : Unit.Entries) {
       if (Expected<uint64_t> EntryLength = writeDIE(
               DI.AbbrevDecls, Unit, Entry, EntryBufferOS, DI.IsLittleEndian))
         Length += *EntryLength;
       else
         return EntryLength.takeError();
     }
 
     // If the length is specified in the YAML description, we use it instead of
     // the actual length.
     if (Unit.Length)
       Length = *Unit.Length;
 
-    writeInitialLength(Unit.Format, Length, OS, DI.IsLittleEndian);
-    writeInteger((uint16_t)Unit.Version, OS, DI.IsLittleEndian);
-    if (Unit.Version >= 5) {
+    writeInitialLength(Unit.FormParams.Format, Length, OS, DI.IsLittleEndian);
+    writeInteger((uint16_t)Unit.FormParams.Version, OS, DI.IsLittleEndian);
+    if (Unit.FormParams.Version >= 5) {
       writeInteger((uint8_t)Unit.Type, OS, DI.IsLittleEndian);
-      writeInteger((uint8_t)Unit.AddrSize, OS, DI.IsLittleEndian);
-      writeDWARFOffset(Unit.AbbrOffset, Unit.Format, OS, DI.IsLittleEndian);
+      writeInteger((uint8_t)Unit.FormParams.AddrSize, OS, DI.IsLittleEndian);
+      writeDWARFOffset(Unit.AbbrOffset, Unit.FormParams.Format, OS,
+                       DI.IsLittleEndian);
     } else {
-      writeDWARFOffset(Unit.AbbrOffset, Unit.Format, OS, DI.IsLittleEndian);
-      writeInteger((uint8_t)Unit.AddrSize, OS, DI.IsLittleEndian);
+      writeDWARFOffset(Unit.AbbrOffset, Unit.FormParams.Format, OS,
+                       DI.IsLittleEndian);
+      writeInteger((uint8_t)Unit.FormParams.AddrSize, OS, DI.IsLittleEndian);
     }
 
     OS.write(EntryBuffer.data(), EntryBuffer.size());
   }
 
   return Error::success();
 }
 
for (auto Op : LineTable.Opcodes) {
       if (Op.Opcode == 0) {
         encodeULEB128(Op.ExtLen, OS);
         writeInteger((uint8_t)Op.SubOpcode, OS, DI.IsLittleEndian);
         switch (Op.SubOpcode) {
         case dwarf::DW_LNE_set_address:
         case dwarf::DW_LNE_set_discriminator:
           // TODO: Test this error.
           if (Error Err = writeVariableSizedInteger(
-                  Op.Data, DI.CompileUnits[0].AddrSize, OS, DI.IsLittleEndian))
+                  Op.Data, DI.CompileUnits[0].FormParams.AddrSize, OS,
+                  DI.IsLittleEndian))
             return Err;
           break;
         case dwarf::DW_LNE_define_file:
           emitFileEntry(OS, Op.FileEntry);
           break;
         case dwarf::DW_LNE_end_sequence:
           break;
         default:

llvm/lib/ObjectYAML/DWARFYAML.cpp

void MappingTraits<DWARFYAML::PubSection>::mapping(
   IO.mapRequired("Length", Section.Length);
   IO.mapRequired("Version", Section.Version);
   IO.mapRequired("UnitOffset", Section.UnitOffset);
   IO.mapRequired("UnitSize", Section.UnitSize);
   IO.mapRequired("Entries", Section.Entries);
 }
 
 void MappingTraits<DWARFYAML::Unit>::mapping(IO &IO, DWARFYAML::Unit &Unit) {
-  IO.mapOptional("Format", Unit.Format, dwarf::DWARF32);
+  IO.mapOptional("Format", Unit.FormParams.Format, dwarf::DWARF32);
   IO.mapOptional("Length", Unit.Length);
-  IO.mapRequired("Version", Unit.Version);
-  if (Unit.Version >= 5)
+  IO.mapRequired("Version", Unit.FormParams.Version);
+  if (Unit.FormParams.Version >= 5)
     IO.mapRequired("UnitType", Unit.Type);
   IO.mapRequired("AbbrOffset", Unit.AbbrOffset);
-  IO.mapRequired("AddrSize", Unit.AddrSize);
+  IO.mapRequired("AddrSize", Unit.FormParams.AddrSize);
   IO.mapOptional("Entries", Unit.Entries);
 }
 
 void MappingTraits<DWARFYAML::Entry>::mapping(IO &IO, DWARFYAML::Entry &Entry) {
   IO.mapRequired("AbbrCode", Entry.AbbrCode);
   IO.mapRequired("Values", Entry.Values);
 }
 

llvm/tools/obj2yaml/dwarf2yaml.cpp

void dumpDebugPubSections(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   if (!GNUPubTypes.Data.empty())
     // TODO: Test dumping .debug_gnu_pubtypes section.
     Y.GNUPubTypes = dumpPubSection(DCtx, GNUPubTypes, /*IsGNUStyle=*/true);
 }
 
 void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) {
   for (const auto &CU : DCtx.compile_units()) {
     DWARFYAML::Unit NewUnit;
-    NewUnit.Format = CU->getFormat();
+    NewUnit.FormParams.Format = CU->getFormat();
     NewUnit.Length = CU->getLength();
-    NewUnit.Version = CU->getVersion();
-    if(NewUnit.Version >= 5)
+    NewUnit.FormParams.Version = CU->getVersion();
+    if (NewUnit.FormParams.Version >= 5)
       NewUnit.Type = (dwarf::UnitType)CU->getUnitType();
     NewUnit.AbbrOffset = CU->getAbbreviations()->getOffset();
-    NewUnit.AddrSize = CU->getAddressByteSize();
+    NewUnit.FormParams.AddrSize = CU->getAddressByteSize();
     for (auto DIE : CU->dies()) {
       DWARFYAML::Entry NewEntry;
       DataExtractor EntryData = CU->getDebugInfoExtractor();
       uint64_t offset = DIE.getOffset();
 
       assert(EntryData.isValidOffset(offset) && "Invalid DIE Offset");
       if (!EntryData.isValidOffset(offset))
         continue;