[ObjectYAML][DWARF] Let the target address size be inferred from FileHeader.

[Higuoxing]

Summary

This patch adds a new field bool Is64bit in DWARFYAML::Data to indicate the address size of target. It's helpful for inferring the AddrSize in some DWARF sections.

[Higuoxing]

• magic of 64-bit target in Mach-O can be MH_CIGM_64 as well.

[grimar]

It looks reasonable to me.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

149

I'd suggest to do in the next way:

uint8_t AddrSize;
if (DebugRanges.AddrSize)
  AddrSize = *DebugRanges.AddrSize;
else
  AddrSize = DI.Is64bit ? 8 : 4;

llvm/lib/ObjectYAML/MachOYAML.cpp

111

I am not an expert in MachO, but should MachO::FAT_MAGIC_64 and MachO::FAT_CIGAM_64 also be tested?

[Higuoxing]

Address comment.

Thanks for reviewing!

llvm/lib/ObjectYAML/MachOYAML.cpp

111

The Fat binary format has its own unique tag

--- !fat-mach-o

I think we don't need to worry about it here.

[MaskRay]

LGTM. Looks reasonable.

llvm/include/llvm/ObjectYAML/DWARFYAML.h

 struct RangeEntry {
   llvm::yaml::Hex64 LowOffset;
   llvm::yaml::Hex64 HighOffset;
 };
 
 /// Class that describes a single range list inside the .debug_ranges section.
 struct Ranges {
   Optional<llvm::yaml::Hex64> Offset;
-  llvm::yaml::Hex8 AddrSize;
+  Optional<llvm::yaml::Hex8> AddrSize;
   std::vector<RangeEntry> Entries;
 };
 
 struct PubEntry {
   llvm::yaml::Hex32 DieOffset;
   llvm::yaml::Hex8 Descriptor;
   StringRef Name;
 };
struct LineTable {
   std::vector<uint8_t> StandardOpcodeLengths;
   std::vector<StringRef> IncludeDirs;
   std::vector<File> Files;
   std::vector<LineTableOpcode> Opcodes;
 };
 
 struct Data {
   bool IsLittleEndian;
+  bool Is64bit;
   std::vector<Abbrev> AbbrevDecls;
   std::vector<StringRef> DebugStrings;
   std::vector<ARange> ARanges;
   std::vector<Ranges> DebugRanges;
   Optional<PubSection> PubNames;
   Optional<PubSection> PubTypes;
 
   Optional<PubSection> GNUPubNames;

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;
+  uint8_t TargetAddrSize = DI.Is64bit ? 8 : 4;
   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) + ")");
     if (DebugRanges.Offset)
       ZeroFillBytes(OS, *DebugRanges.Offset - CurrOffset);
+
+    uint8_t AddrSize =
+        DebugRanges.AddrSize ? (uint8_t)*DebugRanges.AddrSize : TargetAddrSize;
     for (auto Entry : DebugRanges.Entries) {
-      writeVariableSizedInteger(Entry.LowOffset, DebugRanges.AddrSize, OS,
+      writeVariableSizedInteger(Entry.LowOffset, AddrSize, OS,
                                 DI.IsLittleEndian);
-      writeVariableSizedInteger(Entry.HighOffset, DebugRanges.AddrSize, OS,
+      writeVariableSizedInteger(Entry.HighOffset, AddrSize, OS,
                                 DI.IsLittleEndian);
     }
-    ZeroFillBytes(OS, DebugRanges.AddrSize * 2);
+    ZeroFillBytes(OS, AddrSize * 2);
     ++EntryIndex;
   }
 
   return Error::success();
 }
 
 Error DWARFYAML::emitPubSection(raw_ostream &OS,
                                 const DWARFYAML::PubSection &Sect,

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.mapOptional("Offset", DebugRanges.Offset);
-  IO.mapRequired("AddrSize", DebugRanges.AddrSize);
+  IO.mapOptional("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)
     IO.mapRequired("Descriptor", Entry.Descriptor);

llvm/lib/ObjectYAML/ELFYAML.cpp

void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("SectionHeaderTable", Object.SectionHeaders);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.mapOptional("DWARF", Object.DWARF);
-  if (Object.DWARF)
+  if (Object.DWARF) {
     Object.DWARF->IsLittleEndian =
         Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
+    Object.DWARF->Is64bit =
+        Object.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
+  }
   IO.setContext(nullptr);
 }
 
 void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,
                                                    ELFYAML::LinkerOption &Opt) {
   assert(IO.getContext() && "The IO context is not initialized");
   IO.mapRequired("Name", Opt.Key);
   IO.mapRequired("Value", Opt.Value);

llvm/lib/ObjectYAML/MachOYAML.cpp

if (!IO.getContext()) {
     IO.setContext(&Object);
   }
   IO.mapTag("!mach-o", true);
   IO.mapOptional("IsLittleEndian", Object.IsLittleEndian,
                  sys::IsLittleEndianHost);
   Object.DWARF.IsLittleEndian = Object.IsLittleEndian;
 
   IO.mapRequired("FileHeader", Object.Header);
+  Object.DWARF.Is64bit = Object.Header.magic == MachO::MH_MAGIC_64;
   IO.mapOptional("LoadCommands", Object.LoadCommands);
   if(!Object.LinkEdit.isEmpty() || !IO.outputting())
     IO.mapOptional("LinkEditData", Object.LinkEdit);
 
   if(!Object.DWARF.isEmpty() || !IO.outputting())
     IO.mapOptional("DWARF", Object.DWARF);
 
   if (IO.getContext() == &Object)
     IO.setContext(nullptr);

llvm/test/tools/obj2yaml/macho-DWARF-debug-ranges.yaml

- Code:            0x00000003
         - Attribute:       DW_AT_name
           Form:            DW_FORM_strp
         - Attribute:       DW_AT_low_pc
           Form:            DW_FORM_addr
         - Attribute:       DW_AT_high_pc
           Form:            DW_FORM_addr
   debug_ranges:
     - Offset:          0x00000000
-      AddrSize:        0x08
       Entries:
         - LowOffset:       0x0000000000000000
           HighOffset:      0x0000000000000020
         - LowOffset:       0x0000000000000000
           HighOffset:      0x0000000000000030
         - LowOffset:       0xFFFFFFFFFFFFFFFF
           HighOffset:      0x0000000000001000
         - LowOffset:       0x0000000000000000

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

- AddrSize: 0x04
         - LowOffset:  0x00000010
           HighOffset: 0x00000020
         - LowOffset:  0x00000030
           HighOffset: 0x00000040
         - LowOffset:  0xffffffff
           HighOffset: 0x00000010
         - LowOffset:  0x00000000
           HighOffset: 0x00000000
-    - AddrSize: 0x08
-      Entries:
+    - Entries:
         - LowOffset:  0x0000000000000010
           HighOffset: 0x0000000000000020
         - LowOffset:  0x0000000000000030
           HighOffset: 0x0000000000000040
         - LowOffset:  0xffffffffffffffff
           HighOffset: 0x0000000000000010
         - LowOffset:  0x0000000000000000
           HighOffset: 0x0000000000000000
FileHeader:
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .debug_ranges
     Type: SHT_PROGBITS
     Size: 0x10
 DWARF:
   debug_ranges:
-    - AddrSize: 0x08
-      Entries:
+    - 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:
-    - AddrSize: 0x08
-      Entries:
+    - 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
 # RUN: llvm-readelf --sections %t6.o | FileCheck %s --check-prefix=OVERRIDDEN
- 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:
-    - AddrSize: 0x08
-      Entries:
+    - 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:
   debug_ranges:
-    - AddrSize: 0x08
-      Entries:
+    - 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=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:
-    - AddrSize: 0x08
-      Entries:
+    - Entries:
         - LowOffset:  0x01
           HighOffset: 0x02
     - Offset:   0x1F ## Must be greater than or equal to 0x20.
-      AddrSize: 0x08
       Entries:
         - LowOffset:  0x01
           HighOffset: 0x02