[DWARFYAML] Implement the .debug_str_offsets section.

[Higuoxing]

Summary

This patch helps add support for emitting the .debug_str_offsets section
to yaml2elf.

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

434

A thought I've just had: what do you think should happen if a user specifies a 64-bit-using value for DWARF32? This may apply in one or two other places too.

I don't have any particular opinions here. Just wondering if you've considered it at all.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str-offsets.yaml

47–48

I'd explicitly use the full 4 bytes here (and 8 bytes in the DWARF64 version).

99

Perhaps omit Offsets entirely here.

121

Perhaps it would be worth a test case for there being no tables at all, i.e:

DWARF:
  debug_str_offsets: []

I'd expect an empty section to be emitted in this case.

This might also be a missing test case in some (most?) of the other sections.

[Higuoxing]

Address comments.

llvm/lib/ObjectYAML/DWARFEmitter.cpp

434

Just wondering if you've considered it at all.

Yes, I've considered it before.

At first, It seemed to me that the format should be inferred from the content. When the length is greater than UINT32_MAX or the offset is greater than UINT32_MAX, the DWARF64 should be specified automatically. However, this approach makes our implementation complicated. Besides, DWARF32 is the most commonly used format. I think it's not a good approach.

Another approach is to check whether the integer is able to be encoded using the given size and warn the user about it.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str-offsets.yaml

121

Yes, this test is missing in other tests. I'll add them. Thanks!

[jhenderson]

llvm/lib/ObjectYAML/DWARFEmitter.cpp

434

My instinct is to do nothing at all for now. If people find it causing problems, it's functionality that could be added later. I wouldn't bother with the warning - in most cases, people will never see the warning, due to yaml2obj being run as part of lit tests.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str-offsets.yaml

47–48

I meant something like 0x12345678 and 0x87654321, i.e. so that all the bytes contain non-zero.

122

Hmmm... I would expect the section header to be emitted, but for the section to be empty in this context.

[Higuoxing]

Address comments.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str-offsets.yaml

122

Oh, I misunderstood it. We can wrap std::vector<StringOffsetsTable> with an additional Optional layer (Optional<std::vector<StringOffsetsTable>>). We can add it for other DWARF sections as well.

[jhenderson]

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str-offsets.yaml

125–133

I don't think you need to check the whole section header table in this case. Probably sufficient is just checking the .debug_str_offsets line. It might make more sense to use llvm-readobj style in that case.

[Higuoxing]

Address comments.

Thanks for reviewing!

[jhenderson]

LGTM.

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str-offsets.yaml

125–129

Nice solution!

llvm/include/llvm/ObjectYAML/DWARFEmitter.h

 
 Error emitDebugAranges(raw_ostream &OS, const Data &DI);
 Error emitDebugRanges(raw_ostream &OS, const Data &DI);
 Error emitPubSection(raw_ostream &OS, const PubSection &Sect,
                      bool IsLittleEndian, bool IsGNUPubSec = false);
 Error emitDebugInfo(raw_ostream &OS, const Data &DI);
 Error emitDebugLine(raw_ostream &OS, const Data &DI);
 Error emitDebugAddr(raw_ostream &OS, const Data &DI);
+Error emitDebugStrOffsets(raw_ostream &OS, const Data &DI);
 
 Expected<StringMap<std::unique_ptr<MemoryBuffer>>>
 emitDebugSections(StringRef YAMLString, bool ApplyFixups = false,
                   bool IsLittleEndian = sys::IsLittleEndianHost);
 } // end namespace DWARFYAML
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_DWARFEMITTER_H

llvm/include/llvm/ObjectYAML/DWARFYAML.h

struct AddrTableEntry {
   dwarf::DwarfFormat Format;
   Optional<yaml::Hex64> Length;
   yaml::Hex16 Version;
   Optional<yaml::Hex8> AddrSize;
   yaml::Hex8 SegSelectorSize;
   std::vector<SegAddrPair> SegAddrPairs;
 };
 
+struct StringOffsetsTable {
+  dwarf::DwarfFormat Format;
+  Optional<yaml::Hex64> Length;
+  yaml::Hex16 Version;
+  yaml::Hex16 Padding;
+  std::vector<yaml::Hex64> Offsets;
+};
+
 struct Data {
   bool IsLittleEndian;
   bool Is64BitAddrSize;
   std::vector<Abbrev> AbbrevDecls;
   std::vector<StringRef> DebugStrings;
+  Optional<std::vector<StringOffsetsTable>> DebugStrOffsets;
   std::vector<ARange> ARanges;
   std::vector<Ranges> DebugRanges;
   std::vector<AddrTableEntry> DebugAddr;
   Optional<PubSection> PubNames;
   Optional<PubSection> PubTypes;
 
   Optional<PubSection> GNUPubNames;
   Optional<PubSection> GNUPubTypes;

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::SegAddrPair)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AddrTableEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::StringOffsetsTable)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<DWARFYAML::Data> {
   static void mapping(IO &IO, DWARFYAML::Data &DWARF);
 };
 

 template <> struct MappingTraits<DWARFYAML::SegAddrPair> {
   static void mapping(IO &IO, DWARFYAML::SegAddrPair &SegAddrPair);
 };
 
 template <> struct MappingTraits<DWARFYAML::AddrTableEntry> {
   static void mapping(IO &IO, DWARFYAML::AddrTableEntry &AddrTable);
 };
 
+template <> struct MappingTraits<DWARFYAML::StringOffsetsTable> {
+  static void mapping(IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable);
+};
+
 template <> struct MappingTraits<DWARFYAML::InitialLength> {
   static void mapping(IO &IO, DWARFYAML::InitialLength &DWARF);
 };
 
 template <> struct ScalarEnumerationTraits<dwarf::DwarfFormat> {
   static void enumeration(IO &IO, dwarf::DwarfFormat &Format) {
     IO.enumCase(Format, "DWARF32", dwarf::DWARF32);
     IO.enumCase(Format, "DWARF64", dwarf::DWARF64);

llvm/lib/ObjectYAML/DWARFEmitter.cpp

for (const SegAddrPair &Pair : TableEntry.SegAddrPairs) {
                                    "unable to write debug_addr address: %s",
                                    toString(std::move(Err)).c_str());
     }
   }
 
   return Error::success();
 }
 
+Error DWARFYAML::emitDebugStrOffsets(raw_ostream &OS, const Data &DI) {
+  assert(DI.DebugStrOffsets && "unexpected emitDebugStrOffsets() call");
+  for (const DWARFYAML::StringOffsetsTable &Table : *DI.DebugStrOffsets) {
+    uint64_t Length;
+    if (Table.Length)
+      Length = *Table.Length;
+    else
+      // sizeof(version) + sizeof(padding) = 4
+      Length =
+          4 + Table.Offsets.size() * (Table.Format == dwarf::DWARF64 ? 8 : 4);
+
+    writeInitialLength(Table.Format, Length, OS, DI.IsLittleEndian);
+    writeInteger((uint16_t)Table.Version, OS, DI.IsLittleEndian);
+    writeInteger((uint16_t)Table.Padding, OS, DI.IsLittleEndian);
+
+    for (uint64_t Offset : Table.Offsets) {
+      cantFail(writeVariableSizedInteger(Offset,
+                                         Table.Format == dwarf::DWARF64 ? 8 : 4,
+                                         OS, DI.IsLittleEndian));
+    }
+  }
+
+  return Error::success();
+}
+
 using EmitFuncType = Error (*)(raw_ostream &, const DWARFYAML::Data &);
 
 static Error
 emitDebugSectionImpl(const DWARFYAML::Data &DI, EmitFuncType EmitFunc,
                      StringRef Sec,
                      StringMap<std::unique_ptr<MemoryBuffer>> &OutputBuffers) {
   std::string Data;
   raw_string_ostream DebugInfoStream(Data);

llvm/lib/ObjectYAML/DWARFYAML.cpp

SetVector<StringRef> DWARFYAML::Data::getUsedSectionNames() const {
   if (PubNames)
     SecNames.insert("debug_pubnames");
   if (PubTypes)
     SecNames.insert("debug_pubtypes");
   if (GNUPubNames)
     SecNames.insert("debug_gnu_pubnames");
   if (GNUPubTypes)
     SecNames.insert("debug_gnu_pubtypes");
+  if (DebugStrOffsets)
+    SecNames.insert("debug_str_offsets");
   return SecNames;
 }
 
 namespace yaml {
 
 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.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);
   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);
+  IO.mapOptional("debug_str_offsets", DWARF.DebugStrOffsets);
   IO.setContext(OldContext);
 }
 
 void MappingTraits<DWARFYAML::Abbrev>::mapping(IO &IO,
                                                DWARFYAML::Abbrev &Abbrev) {
   IO.mapOptional("Code", Abbrev.Code);
   IO.mapRequired("Tag", Abbrev.Tag);
   IO.mapRequired("Children", Abbrev.Children);
void MappingTraits<DWARFYAML::AddrTableEntry>::mapping(
   IO.mapOptional("Format", AddrTable.Format, dwarf::DWARF32);
   IO.mapOptional("Length", AddrTable.Length);
   IO.mapRequired("Version", AddrTable.Version);
   IO.mapOptional("AddressSize", AddrTable.AddrSize);
   IO.mapOptional("SegmentSelectorSize", AddrTable.SegSelectorSize, 0);
   IO.mapOptional("Entries", AddrTable.SegAddrPairs);
 }
 
+void MappingTraits<DWARFYAML::StringOffsetsTable>::mapping(
+    IO &IO, DWARFYAML::StringOffsetsTable &StrOffsetsTable) {
+  IO.mapOptional("Format", StrOffsetsTable.Format, dwarf::DWARF32);
+  IO.mapOptional("Length", StrOffsetsTable.Length);
+  IO.mapOptional("Version", StrOffsetsTable.Version, 5);
+  IO.mapOptional("Padding", StrOffsetsTable.Padding, 0);
+  IO.mapOptional("Offsets", StrOffsetsTable.Offsets);
+}
+
 void MappingTraits<DWARFYAML::InitialLength>::mapping(
     IO &IO, DWARFYAML::InitialLength &InitialLength) {
   IO.mapRequired("TotalLength", InitialLength.TotalLength);
   if (InitialLength.isDWARF64())
     IO.mapRequired("TotalLength64", InitialLength.TotalLength64);
 }
 
 } // end namespace yaml
 
 } // end namespace llvm

llvm/lib/ObjectYAML/ELFEmitter.cpp

Expected<uint64_t> emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name,
   else if (Name == ".debug_pubtypes")
     Err = DWARFYAML::emitPubSection(*OS, *DWARF.PubTypes, DWARF.IsLittleEndian);
   else if (Name == ".debug_gnu_pubnames")
     Err = DWARFYAML::emitPubSection(*OS, *DWARF.GNUPubNames,
                                     DWARF.IsLittleEndian, /*IsGNUStyle=*/true);
   else if (Name == ".debug_gnu_pubtypes")
     Err = DWARFYAML::emitPubSection(*OS, *DWARF.GNUPubTypes,
                                     DWARF.IsLittleEndian, /*IsGNUStyle=*/true);
+  else if (Name == ".debug_str_offsets")
+    Err = DWARFYAML::emitDebugStrOffsets(*OS, DWARF);
   else
     llvm_unreachable("unexpected emitDWARF() call");
 
   if (Err)
     return std::move(Err);
 
   return CBA.tell() - BeginOffset;
 }

llvm/test/tools/yaml2obj/ELF/DWARF/debug-str-offsets.yaml

+## Test that yaml2obj emits a .debug_str_offsets section when requested.
+
+## a) Generate and verify a little endian .debug_str_offsets section.
+
+# RUN: yaml2obj -DENDIAN=ELFDATA2LSB --docnum=1 %s -o %t1.le.o
+# RUN: llvm-readobj --sections --section-data %t1.le.o | \
+# RUN:   FileCheck -DSIZE=48 -DADDRALIGN=1 %s --check-prefixes=SHDR,DWARF-LE
+
+#          SHDR: Index: 1
+#     SHDR-NEXT: Name: .debug_str_offsets (1)
+#     SHDR-NEXT: Type: SHT_PROGBITS (0x1)
+#     SHDR-NEXT: Flags [ (0x0)
+#     SHDR-NEXT: ]
+#     SHDR-NEXT: Address: 0x0
+#     SHDR-NEXT: Offset: 0x40
+#     SHDR-NEXT: Size: [[SIZE]]
+#     SHDR-NEXT: Link: 0
+#     SHDR-NEXT: Info: 0
+#     SHDR-NEXT: AddressAlignment: [[ADDRALIGN]]
+#     SHDR-NEXT: EntrySize: 0
+# DWARF-LE-NEXT: SectionData (
+# DWARF-LE-NEXT:   0000: 0C000000 05000000 78563412 21436587  |........xV4.!Ce.|
+##                       ^-------                             unit_length (4-byte)
+##                                ^---                        version (2-byte)
+##                                    ^---                    padding (2-byte)
+##                                         ^-------           offsets[0] (4-byte)
+##                                                  ^-------  offsets[1] (4-byte)
+# DWARF-LE-NEXT:   0010: FFFFFFFF 14000000 00000000 05000000  |................|
+##                       ^-------------------------           unit_length (12-byte)
+##                                                  ^---      version (2-byte)
+##                                                      ^---  padding (2-byte)
+# DWARF-LE-NEXT:   0020: F0DEBC9A 78563412 89674523 01EFCDAB  |....xV4..gE#....|
+##                       ^----------------                    offsets[0] (8-byte)
+##                                         ^----------------  offsets[1] (8-byte)
+# DWARF-LE-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    [[ENDIAN]]
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_str_offsets:
+    - Offsets:
+        - 0x12345678
+        - 0x87654321
+    - Format: DWARF64
+      Offsets:
+        - 0x123456789abcdef0
+        - 0xabcdef0123456789
+
+## b) Generate and verify a big endian .debug_str_offsets section.
+
+# RUN: yaml2obj -DENDIAN=ELFDATA2MSB --docnum=1 %s -o %t1.be.o
+# RUN: llvm-readobj --sections --section-data %t1.be.o | \
+# RUN:   FileCheck -DSIZE=48 -DADDRALIGN=1 %s --check-prefixes=SHDR,DWARF-BE
+
+# DWARF-BE-NEXT: SectionData (
+# DWARF-BE-NEXT:   0000: 0000000C 00050000 12345678 87654321  |.........4Vx.eC!|
+##                       ^-------                             unit_length (4-byte)
+##                                ^---                        version (2-byte)
+##                                    ^---                    padding (2-byte)
+##                                         ^-------           offsets[0] (4-byte)
+##                                                  ^-------  offsets[1] (4-byte)
+# DWARF-BE-NEXT:   0010: FFFFFFFF 00000000 00000014 00050000  |................|
+##                       ^-------------------------           unit_length (12-byte)
+##                                                  ^---      version (2-byte)
+##                                                      ^---  padding (2-byte)
+# DWARF-BE-NEXT:   0020: 12345678 9ABCDEF0 ABCDEF01 23456789  |.4Vx........#Eg.|
+##                       ^----------------                    offsets[0] (8-byte)
+##                                         ^----------------  offsets[1] (8-byte)
+# DWARF-BE-NEXT: )
+
+## c) Test that the length, version and padding fields can be overwritten.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2.o
+# RUN: llvm-readelf --hex-dump=.debug_str_offsets %t2.o | \
+# RUN:   FileCheck %s --check-prefix=OVERWRITE
+
+#      OVERWRITE: Hex dump of section '.debug_str_offsets':
+# OVERWRITE-NEXT: 0x00000000 34120000 06001200                   4.......
+##                           ^-------                            unit_length (4-byte)
+##                                    ^---                       version (2-byte)
+##                                        ^---                   padding (2-bye)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_str_offsets:
+    - Length:  0x1234
+      Version: 6
+      Padding: 0x12
+
+## d) Test that an empty 'Offsets' field is allowed.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3.o
+# RUN: llvm-readelf --hex-dump=.debug_str_offsets %t3.o | \
+# RUN:   FileCheck %s --check-prefix=EMPTY-OFFSETS
+
+#      EMPTY-OFFSETS: Hex dump of section '.debug_str_offsets':
+# EMPTY-OFFSETS-NEXT: 0x00000000 04000000 05000000                   ........
+##                               ^-------                            unit_length (4-byte)
+##                                        ^---                       version (2-byte)
+##                                            ^---                   padding (2-byte)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_str_offsets:
+    - Offsets: []
+
+## e) Test that the .debug_str_offsets section header is emitted if the "debug_str_offsets" is empty.
+
+# RUN: yaml2obj --docnum=4 %s -o %t4.o
+# RUN: llvm-readobj --sections --section-data %t4.o | \
+# RUN:   FileCheck -DSIZE=0 -DADDRALIGN=1 %s --check-prefixes=SHDR,EMPTY-CONTENT
+
+# EMPTY-CONTENT-NEXT: SectionData (
+# EMPTY-CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+DWARF:
+  debug_str_offsets: []
+
+## f) Generate the .debug_str_offsets section from raw section content.
+
+# RUN: yaml2obj --docnum=5 %s -o %t5.o
+# RUN: llvm-readobj --sections --section-data %t5.o | \
+# RUN:   FileCheck %s -DADDRALIGN=0 -DSIZE=3 --check-prefixes=SHDR,ARBITRARY-CONTENT
+
+#      ARBITRARY-CONTENT: SectionData (
+# ARBITRARY-CONTENT-NEXT:   0000: 112233
+# ARBITRARY-CONTENT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .debug_str_offsets
+    Type:    SHT_PROGBITS
+    Content: "112233"
+
+## g) Generate the .debug_str_offsets section when the "Size" is specified.
+
+# RUN: yaml2obj --docnum=6 %s -o %t6.o
+# RUN: llvm-readelf --hex-dump=.debug_str_offsets %t6.o | \
+# RUN:   FileCheck %s --check-prefix=SIZE
+
+#       SIZE: Hex dump of section '.debug_str_offsets':
+#  SIZE-NEXT: 0x00000000 00000000 00000000 00000000 00000000 ................
+# SIZE-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name: .debug_str_offsets
+    Type: SHT_PROGBITS
+    Size: 0x10
+
+## h) Test that yaml2obj emits an error message when both the "Size" and the
+## "debug_str_offsets" entry are specified at the same time.
+
+# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=ERROR
+
+# ERROR: yaml2obj: error: cannot specify section '.debug_str_offsets' contents in the 'DWARF' entry and the 'Content' or 'Size' in the 'Sections' entry at the same time
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name: .debug_str_offsets
+    Type: SHT_PROGBITS
+    Size: 0x10
+DWARF:
+  debug_str_offsets:
+    - Offsets: []
+
+## i) Test that yaml2obj emits an error message when both the "Content" and the
+## "debug_str_offsets" entry are specified at the same time.
+
+# RUN: not yaml2obj --docnum=8 %s 2>&1 | FileCheck %s --check-prefix=ERROR
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:    .debug_str_offsets
+    Type:    SHT_PROGBITS
+    Content: "00"
+DWARF:
+  debug_str_offsets:
+    - Offsets: []
+
+## j) Test that all the properties can be overridden by the section header when
+## the "debug_str_offsets" entry doesn't exist.
+
+# RUN: yaml2obj --docnum=9 %s -o %t9.o
+# RUN: llvm-readelf --sections %t9.o | FileCheck %s --check-prefix=OVERRIDDEN
+
+#      OVERRIDDEN: [Nr] Name               Type   Address          Off    Size   ES Flg Lk Inf Al
+#      OVERRIDDEN: [ 1] .debug_str_offsets STRTAB 0000000000002020 000050 000008 01   A  2   1  2
+# OVERRIDDEN-NEXT: [ 2] .sec               STRTAB 0000000000000000 000058 000000 00      0   0  0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_str_offsets
+    Type:         SHT_STRTAB  ## SHT_PROGBITS by default.
+    Flags:        [SHF_ALLOC] ## 0 by default.
+    Link:         .sec        ## 0 by default.
+    EntSize:      1           ## 0 by default.
+    Info:         1           ## 0 by default.
+    AddressAlign: 2           ## 0 by default.
+    Address:      0x2020      ## 0x00 by default.
+    Offset:       0x50        ## 0x40 for the first section.
+    Size:         0x08        ## Set the "Size" so that we can reuse the check tag "OVERRIDDEN".
+  - Name:         .sec        ## Linked by .debug_str_offsets.
+    Type:         SHT_STRTAB
+
+## k) Test that all the properties can be overridden by the section header when
+## the "debug_str_offsets" entry exists.
+
+# RUN: yaml2obj --docnum=10 %s -o %t10.o
+# RUN: llvm-readelf --sections %t10.o | FileCheck %s --check-prefix=OVERRIDDEN
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64
+Sections:
+  - Name:         .debug_str_offsets
+    Type:         SHT_STRTAB  ## SHT_PROGBITS by default.
+    Flags:        [SHF_ALLOC] ## 0 by default.
+    Link:         .sec        ## 0 by default.
+    EntSize:      1           ## 0 by default.
+    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_str_offsets.
+    Type:         SHT_STRTAB
+DWARF:
+  debug_str_offsets:
+    - Offsets: []