[yaml2obj/obj2yaml] - Make RawContentSection::Content and RawContentSection::Size optional

[grimar]

Summary

This is a follow-up for D62809.

Content and Size fields should be optional as was discussed in comments
of the D62809's thread. With that, we can describe a specific string table and
symbol table sections in a more correct way and also show appropriate errors.

The patch adds lots of test cases where the behavior is described in details.

[grimar]

• Minor cometic code change in writeRawSectionData.

[grimar]

• Use llvm-objdump -s instead of llvm-objdump -D for dumping sections content.

[jhenderson]

test/tools/yaml2obj/section-size-content.yaml

8

greater -> greater than

24

and the -> and that the

26

I've found it sometimes useful for each test case output to be a separate file i.e. use %t, %t2, %t3 etc instead of always %t.

82

In this case the zeroes padding is added -> In this case zeroes are added as padding

83

What is the bit in brackets referring to?

103–105

I think this case is the same as the --docnum=2 test case, right? You can use --section-data to get the section data if you want via llvm-readelf too.

125

or -> nor

test/tools/yaml2obj/strtab-implicit-sections-size-content.yaml

4

for string -> for a string

5

I think you can simplify this to "yaml2obj writes the default content."

26

remove "along" (probably should be "alone" but still not neeed).

27

"The content is filled with zeroes in this case."

52

Remove "along"

76

remove "or equal to"

76–77

"In this case zeroes are added as padding after the specified content"

Remove the bit in parentheses.

101–102

"when size is equal to content size." Then delete the rest of the comment.

test/tools/yaml2obj/symtab-implicit-sections-size-content.yaml

5

Same comments from the previous test apply here throughout this test.

63

emit the custom -> emit custom

82

Ditto

85

You should be able to use llvm-readelf --section-data or --hex-dump here and below rather than this to check the output.

104–106

See comments in previous test for this and next test case.

tools/yaml2obj/yaml2elf.cpp

403

You probably need some test cases for DynamicSymbols as well as static Symbols.

[grimar]

test/tools/yaml2obj/section-size-content.yaml

83

What is the bit in brackets referring to?

We have content of size 1 and Size == 3:

Content: "FF"
Size:    3

I.e. I check here that "we can specify both Size and Content when size is greater than...."

Since you've noticed (thanks!) that test below (--docnum=6) is actually a duplicate of --docnum=2,
I'll rewrite this comment.

103–105

I think this case is the same as the --docnum=2.

Oh, indeed. I'll fix.

tools/yaml2obj/yaml2elf.cpp

403

OK, I'll add.

Do you think it worth to add tests for other 2 string sections (.shstrtab, .dynstr) too?

[jhenderson]

tools/yaml2obj/yaml2elf.cpp

403

I was wondering this. Those use the same code paths as .strtab, I believe, and there is no differences in behaviour, I think? I don't think it hurts to explicitly test them though necessarily, but don't think it critical by any means.

[grimar]

tools/yaml2obj/yaml2elf.cpp

403

I was wondering this. Those use the same code paths as .strtab, I believe, and there is no differences in behaviour, I think?

Yes, the path is the same and the difference should be negligible. Probably no need to duplicate the existing large test case I think.

[grimar]

• Addressed review comments.

Upd: initially I wrote here that it depends on D63002 now,
but it wasn't true. A new test case added in the latest diff contains
the following TODO:

## TODO: .dynstr here is needed to set a proper Link for .dynsym.
## Otherwize llvm-readobj would report an error.
## We might want to fix llvm-readobj.

I had to add .dynstr because otherwise llvm-readobj does not want
to dump the object. (because .dynsym's Link field == 0).

Without .dynstr added this would depend on D63002.

I am going to investigate how much hard to fix the llvm-readobj.

[jhenderson]

test/tools/yaml2obj/dynsymtab-implicit-sections-size-content.yaml

5 ↗

(On Diff #203542)

Maybe worth explicitly saying "dynamic symbol table section"

98 ↗

(On Diff #203542)

As noted above, this deserves a reference to a bug that has been filed.

The comment needs some updates too:
Otherwize (should be Otherwise by the way) llvm-readobj would report -> Without this, llvm-readeobj reports...

136 ↗

(On Diff #203542)

Ditto.

145 ↗

(On Diff #203542)

after the specified content

177 ↗

(On Diff #203542)

See above.

217 ↗

(On Diff #203542)

See above.

test/tools/yaml2obj/section-size-content.yaml

106

after content specified -> after the specified content

test/tools/yaml2obj/strtab-implicit-sections-size-content.yaml

99

Same as above.

test/tools/yaml2obj/symtab-implicit-sections-size-content.yaml

128

See above.

[grimar]

• Addressed review comments.

[jhenderson]

Looks like you missed some comments?

test/tools/yaml2obj/section-size-content.yaml

106

This hasn't been done?

test/tools/yaml2obj/strtab-implicit-sections-size-content.yaml

99

Ditto

test/tools/yaml2obj/symtab-implicit-sections-size-content.yaml

128

Ditto

[grimar]

• Addressed review comments.

test/tools/yaml2obj/section-size-content.yaml

106

Searched for these wording in the wrong file it seeems. Sorry :(

[jhenderson]

LGTM.

include/llvm/ObjectYAML/ELFYAML.h

struct DynamicSection : Section {
   DynamicSection() : Section(SectionKind::Dynamic) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::Dynamic;
   }
 };
 
 struct RawContentSection : Section {
-  yaml::BinaryRef Content;
-  llvm::yaml::Hex64 Size;
+  Optional<yaml::BinaryRef> Content;
+  Optional<llvm::yaml::Hex64> Size;
   llvm::yaml::Hex64 Info;
 
   RawContentSection() : Section(SectionKind::RawContent) {}
 
   static bool classof(const Section *S) {
     return S->Kind == SectionKind::RawContent;
   }
 };

lib/ObjectYAML/ELFYAML.cpp

static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Entries", Section.Entries);
   IO.mapOptional("Content", Section.Content);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Content", Section.Content);
-  IO.mapOptional("Size", Section.Size, Hex64(Section.Content.binary_size()));
+  IO.mapOptional("Size", Section.Size);
   IO.mapOptional("Info", Section.Info, Hex64(0));
 }
 
 static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Size", Section.Size, Hex64(0));
 }
 
if (!IO.outputting())
       Section.reset(new ELFYAML::RawContentSection());
     sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
   }
 }
 
 StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
     IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
   const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
-  if (!RawSection || RawSection->Size >= RawSection->Content.binary_size())
-    return StringRef();
+  if (!RawSection)
+    return {};
+  if (RawSection->Size && RawSection->Content &&
+      (uint64_t)(*RawSection->Size) < RawSection->Content->binary_size())
     return "Section size must be greater or equal to the content size";
+  return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
         Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),

test/Object/obj2yaml.test

 ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
 ELF-MIPSEL-NEXT:       - Offset:          0x000000000000002C
 ELF-MIPSEL-NEXT:         Symbol:          SomeOtherFunction
 ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
 ELF-MIPSEL-NEXT:   - Name:            .data
 ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 ELF-MIPSEL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 ELF-MIPSEL-NEXT:     AddressAlign:    0x0000000000000004
-ELF-MIPSEL-NEXT:     Content:         ''
 ELF-MIPSEL-NEXT:   - Name:            .bss
 ELF-MIPSEL-NEXT:     Type:            SHT_NOBITS
 ELF-MIPSEL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 ELF-MIPSEL-NEXT:     AddressAlign:    0x0000000000000004
 ELF-MIPSEL-NEXT:     Size:            0x0000000000000004
 ELF-MIPSEL-NEXT:   - Name:            .mdebug.abi32
 ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 ELF-MIPSEL-NEXT:     AddressAlign:    0x0000000000000001
-ELF-MIPSEL-NEXT:     Content:         ''
 ELF-MIPSEL-NEXT:   - Name:            .rodata.str1.1
 ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 ELF-MIPSEL-NEXT:     Flags:           [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
 ELF-MIPSEL-NEXT:     AddressAlign:    0x0000000000000001
 ELF-MIPSEL-NEXT:     EntSize:         0x0000000000000001
 ELF-MIPSEL-NEXT:     Content:         48656C6C6F20576F726C640A00
 ELF-MIPSEL-NEXT:   - Name:            .reginfo
 ELF-MIPSEL-NEXT:     Type:            SHT_MIPS_REGINFO

 ELF-MIPS64EL-NEXT:   Type:            ET_REL
 ELF-MIPS64EL-NEXT:   Machine:         EM_MIPS
 ELF-MIPS64EL-NEXT:   Flags:           [ EF_MIPS_ARCH_3 ]
 ELF-MIPS64EL-NEXT: Sections:
 ELF-MIPS64EL-NEXT:   - Name:            .text
 ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS
 ELF-MIPS64EL-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 ELF-MIPS64EL-NEXT:     AddressAlign:    0x0000000000000010
-ELF-MIPS64EL-NEXT:     Content:         ''
 ELF-MIPS64EL-NEXT:   - Name:            .data
 ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS
 ELF-MIPS64EL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 ELF-MIPS64EL-NEXT:     AddressAlign:    0x0000000000000010
 ELF-MIPS64EL-NEXT:     Content:         '00000000000000000000000000000000'
 ELF-MIPS64EL-NEXT:   - Name:            .rela.data
 ELF-MIPS64EL-NEXT:     Type:            SHT_RELA
 ELF-MIPS64EL-NEXT:     Link:            .symtab

 ELF-MIPS64EL-NEXT:     Type:            SHT_MIPS_OPTIONS
 ELF-MIPS64EL-NEXT:     Flags:           [ SHF_ALLOC, SHF_MIPS_NOSTRIP ]
 ELF-MIPS64EL-NEXT:     AddressAlign:    0x0000000000000008
 ELF-MIPS64EL-NEXT:     EntSize:         0x0000000000000001
 ELF-MIPS64EL-NEXT:     Content:         '01280000000000000000000000000000000000000000000000000000000000000000000000000000'
 ELF-MIPS64EL-NEXT:   - Name:            .pdr
 ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS
 ELF-MIPS64EL-NEXT:     AddressAlign:    0x0000000000000004
-ELF-MIPS64EL-NEXT:     Content:         ''
 ELF-MIPS64EL-NEXT: Symbols:
 ELF-MIPS64EL-NEXT:     - Name:            .text
 ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 ELF-MIPS64EL-NEXT:       Section:         .text
 ELF-MIPS64EL-NEXT:     - Name:            .data
 ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 ELF-MIPS64EL-NEXT:       Section:         .data
 ELF-MIPS64EL-NEXT:     - Name:            .bss

 ELF-X86-64-NEXT:     Flags:           [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
 ELF-X86-64-NEXT:     Address:         0x0000000000000026
 ELF-X86-64-NEXT:     AddressAlign:    0x0000000000000001
 ELF-X86-64-NEXT:     Content:         48656C6C6F20576F726C642100
 ELF-X86-64-NEXT:   - Name:            .note.GNU-stack
 ELF-X86-64-NEXT:     Type:            SHT_PROGBITS
 ELF-X86-64-NEXT:     Address:         0x0000000000000033
 ELF-X86-64-NEXT:     AddressAlign:    0x0000000000000001
-ELF-X86-64-NEXT:     Content:         ''
 ELF-X86-64-NEXT:   - Name:            .rela.text
 ELF-X86-64-NEXT:     Type:            SHT_RELA
 ELF-X86-64-NEXT:     Address:         0x0000000000000038
 ELF-X86-64-NEXT:     Link:            .symtab
 ELF-X86-64-NEXT:     AddressAlign:    0x0000000000000008
 ELF-X86-64-NEXT:     EntSize:         0x0000000000000018
 ELF-X86-64-NEXT:     Info:            .text
 ELF-X86-64-NEXT:     Relocations:

 ELF-AVR-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 ELF-AVR-NEXT:     AddressAlign:    0x0000000000000002
 ELF-AVR-NEXT:     Content:         C20E0895
 ELF-AVR-NEXT:   - Name:            .data
 ELF-AVR-NEXT:     Type:            SHT_PROGBITS
 ELF-AVR-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 ELF-AVR-NEXT:     Address:         0x0000000000800060
 ELF-AVR-NEXT:     AddressAlign:    0x0000000000000001
-ELF-AVR-NEXT:     Content:         ''
 ELF-AVR-NEXT: Symbols:
 ELF-AVR-NEXT:     - Name:           .text
 ELF-AVR-NEXT:       Type:            STT_SECTION
 ELF-AVR-NEXT:       Section:         .text
 ELF-AVR-NEXT:     - Name:           .data
 ELF-AVR-NEXT:       Type:            STT_SECTION
 ELF-AVR-NEXT:       Section:         .data
 ELF-AVR-NEXT:       Value:           0x0000000000800060

 WASM-NEXT:       - Index:           1
 WASM:      ...
 
 
 ELF-X86-64-UNWIND:      - Name:            .eh_frame
 ELF-X86-64-UNWIND-NEXT:   Type:            SHT_X86_64_UNWIND
 ELF-X86-64-UNWIND-NEXT:   Flags:           [ SHF_ALLOC ]
 ELF-X86-64-UNWIND-NEXT:   AddressAlign:    0x0000000000000001
-ELF-X86-64-UNWIND-NEXT:   Content:         ''
 
 RUN: not obj2yaml %t.blah 2>&1 | FileCheck --check-prefix=ENOENT %s
 ENOENT: Error reading file: {{.*}}.blah: {{[Nn]}}o such file or directory

test/tools/obj2yaml/elf-shinfo.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 ## Check obj2yaml is able to dump sh_info field of a section.
 
 # CHECK:      - Name:            .test
 # CHECK-NEXT:   Type:            SHT_PROGBITS
-# CHECK-NEXT:   Content:         ''
 # CHECK-NEXT:   Info:            0x000000000000002A
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:            .test
     Type:            SHT_PROGBITS
     Info:            42

test/tools/yaml2obj/section-size-content.yaml

+## For regular sections, it is common to specify `Size` and/or `Content` fields in YAML.
+## Here we test the behavior in different cases.
+
+## In this case, we have both `Content` and `Size` fields specified and `Size`
+## is less than content size. Check we report an error.
+
+# RUN: not yaml2obj --docnum=1 %s -o %t 2>&1 | FileCheck %s --check-prefix=ERR
+# ERR: error: Section size must be greater or equal to the content size
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+    Content: "FF"
+    Size:    0
+
+## In this case, we have both `Content` and `Size` fields specified and
+## `Size` is equal to the content size. We check that this is allowed and
+## the output section has a correct size value.
+
+# RUN: yaml2obj --docnum=2 %s -o %t
+# RUN: llvm-readobj %t --sections | FileCheck %s --check-prefix=CASE2
+
+# CASE2:      Name: .foo
+# CASE2-NEXT: Type: SHT_PROGBITS
+# CASE2-NEXT: Flags [
+# CASE2-NEXT: ]
+# CASE2-NEXT: Address: 0x0
+# CASE2-NEXT: Offset: 0x180
+# CASE2-NEXT: Size: 1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+    Content: "FF"
+    Size:    1
+
+## Check we can specify only `Content`.
+
+# RUN: yaml2obj --docnum=3 %s -o %t
+# RUN: llvm-readobj %t --sections | FileCheck %s --check-prefix=CASE2
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+    Content: "FF"
+
+## Check we can specify only `Size`.
+
+# RUN: yaml2obj --docnum=4 %s -o %t
+# RUN: llvm-readobj %t --sections | FileCheck %s --check-prefix=CASE2
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Size: 1
+
+## Check we can specify both `Size` and `Content` when size is greater
+## than or equal to content size. In this case the zeroes padding is
+## added after content specified. (Check "greater then" case here).
+
+# RUN: yaml2obj --docnum=5 %s -o %t
+# RUN: llvm-objdump %t -s | FileCheck %s --check-prefix=CASE3
+
+# CASE3:      Contents of section .foo:
+# CASE3-NEXT:  0000 ff0000 ...
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+    Content: "FF"
+    Size:    3
+
+## Check we can specify both `Size` and `Content` when size is greater
+## than or equal to content size. In this case the zeroes padding is
+## added after content specified. (Check "equal" case here).
+
+# RUN: yaml2obj --docnum=6 %s -o %t
+# RUN: llvm-objdump %t -s | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      Contents of section .foo:
+# CASE4-NEXT:  0000 ff .
+ 
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+    Content: "FF"
+    Size:    1
+
+## Check we emit an empty section if neither 'Content' or 'Size' were set.
+
+# RUN: yaml2obj --docnum=7 %s -o %t
+# RUN: llvm-readobj %t --sections | FileCheck %s --check-prefix=CASE5
+
+# CASE5:      Name: .foo
+# CASE5-NEXT: Type: SHT_PROGBITS
+# CASE5-NEXT: Flags [
+# CASE5-NEXT: ]
+# CASE5-NEXT: Address: 0x0
+# CASE5-NEXT: Offset: 0x180
+# CASE5-NEXT: Size: 0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS

test/tools/yaml2obj/strtab-implicit-sections-size-content.yaml

+## For implicit string table sections, `Size` and/or `Content` fields can also
+## be specified in YAML. Here we test the behavior in different cases.
+
+## When no `Size` or `Content` is specified for string table section,
+## yaml2obj writes the default implicitly created string table as a content.
+
+# RUN: yaml2obj --docnum=1 %s -o %t
+# RUN: llvm-objdump %t -s | FileCheck %s --check-prefix=CASE1
+
+# CASE1:      Contents of section .strtab:
+# CASE1-NEXT:  0000 00666f6f 00 .foo.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .strtab
+    Type:    SHT_STRTAB
+## Used to trigger adding string `foo` to the string table section.
+Symbols:
+  - Name:    foo
+
+## For string table sections, `Size` can be used along to override the
+## implicit string table data. Content is filled by zeroes in this case.
+
+# RUN: yaml2obj --docnum=2 %s -o %t
+# RUN: llvm-objdump %t -s -h | FileCheck %s --check-prefix=CASE2
+
+# CASE2: Idx Name    Size
+# CASE2:   1 .strtab 00000002
+
+# CASE2:      Contents of section .strtab:
+# CASE2-NEXT:  0000 0000 ..
+ 
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .strtab
+    Type:    SHT_STRTAB
+    Size:    2
+## Used to trigger adding string `foo` to the string table section.
+Symbols:
+  - Name:    foo
+
+## For string table sections, `Content` can be used along to override the
+## implicit string table data.
+
+# RUN: yaml2obj --docnum=3 %s -o %t
+# RUN: llvm-objdump %t -s | FileCheck %s --check-prefix=CASE3
+
+# CASE3:      Contents of section .strtab:
+# CASE3-NEXT:  0000 0102 ..
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .strtab
+    Type:    SHT_STRTAB
+    Content: "0102"
+## Used to trigger adding string `foo` to the string table section.
+Symbols:
+  - Name:    foo
+
+## For string table sections, check we can specify both `Size` and `Content`
+## when size is greater than or equal to content size. In this case the zeroes
+## padding is added after content specified. (Check "greater then" case here)
+
+# RUN: yaml2obj --docnum=4 %s -o %t
+# RUN: llvm-objdump %t -s | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      Contents of section .strtab:
+# CASE4-NEXT:  0000 010200 ...
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .strtab
+    Type:    SHT_STRTAB
+    Content: "0102"
+    Size:    3
+## Used to trigger adding string `foo` to the string table section.
+Symbols:
+  - Name:    foo
+
+## For string table sections, check we can specify both `Size` and `Content`
+## when size is greater than or equal to content size. In this case the zeroes
+## padding is added after content specified. (Check "equal" case here)
+
+# RUN: yaml2obj --docnum=5 %s -o %t
+# RUN: llvm-objdump %t -s | FileCheck %s --check-prefix=CASE5
+
+# CASE5:      Contents of section .strtab:
+# CASE5-NEXT:  0000 0102 ..
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .strtab
+    Type:    SHT_STRTAB
+    Content: "0102"
+    Size:    2
+## Used to trigger adding string `foo` to the string table section.
+Symbols:
+  - Name:    foo

test/tools/yaml2obj/symtab-implicit-sections-size-content.yaml

+## For implicit symbol table sections, `Size` and/or `Content` fields can also
+## be specified in YAML. Here we test the behavior in different cases.
+
+## When no `Size` or `Content` is specified for symbol table section,
+## yaml2obj writes the default implicitly created symbol table as a content.
+# RUN: yaml2obj --docnum=1 %s -o %t
+# RUN: llvm-readelf %t -s | FileCheck %s --check-prefix=CASE1
+
+# CASE1:      Symbol table '.symtab' contains 2 entries:
+# CASE1-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
+# CASE1-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
+# CASE1-NEXT:      1: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND foo
+# CASE1-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+Symbols:
+  - Name: foo
+
+## Specifying both `Size` and symbols at the same time is not allowed.
+# RUN: not yaml2obj --docnum=2 %s -o %t 2>&1 | FileCheck %s --check-prefix=CASE2
+
+# CASE2: error: Cannot specify both `Size` and `Symbols` for symbol table section '.symtab'.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+    Size: 0x100
+Symbols:
+  - Name: foo
+
+## Specifying both `Content` and symbols at the same time is not allowed.
+# RUN: not yaml2obj --docnum=3 %s -o %t 2>&1 | FileCheck %s --check-prefix=CASE3
+
+# CASE3: error: Cannot specify both `Content` and `Symbols` for symbol table section '.symtab'.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+    Content: "00"
+Symbols:
+  - Name: foo
+
+## Check we can use just `Content` to emit the custom data in the symbol table section.
+# RUN: yaml2obj --docnum=4 %s -o %t
+# RUN: llvm-objdump %t -D | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      0000000000000000 .symtab:
+# CASE4-NEXT:  0: 01 23 addl %esp, (%rbx)
+# CASE4-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+    Content: "0123"
+
+## Check we can use just `Size` to emit the custom data filled with zeroes
+## in the symbol table section.
+# RUN: yaml2obj --docnum=5 %s -o %t
+# RUN: llvm-objdump %t -D | FileCheck %s --check-prefix=CASE5
+
+# CASE5:      0000000000000000 .symtab:
+# CASE5-NEXT:   0: 00 00 addb    %al, (%rax)
+# CASE5-NEXT:   2: 00 00 addb    %al, (%rax)
+# CASE5-NEXT:   4: 00    <unknown>
+# CASE5-EMPTY:
+ 
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+    Size: 5
+
+## Check we can specify both `Size` and `Content` when size is greater
+## than or equal to content size. In this case the zeroes padding is
+## added after content specified. (Check "greater then" case here).
+# RUN: yaml2obj --docnum=6 %s -o %t
+# RUN: llvm-objdump %t -D | FileCheck %s --check-prefix=CASE6
+
+# CASE6:      0000000000000000 .symtab:
+# CASE6-NEXT:  0: 01 23 addl %esp, (%rbx)
+# CASE6-NEXT:  2: 00 00 addb %al, (%rax)
+# CASE6-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+    Content: "0123"
+    Size: 4
+
+## Check we can specify both `Size` and `Content` when size is greater
+## than or equal to content size. In this case the zeroes padding is
+## added after content specified. (Check "equal" case here).
+
+# RUN: yaml2obj --docnum=7 %s -o %t
+# RUN: llvm-objdump %t -D | FileCheck %s --check-prefix=CASE7
+
+# CASE7:     0000000000000000 .symtab:
+# CASE7-NEXT:  0: 01 23 addl    %esp, (%rbx)
+# CASE7-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+    Content: "0123"
+    Size: 2

tools/obj2yaml/elf2yaml.cpp

ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::RawContentSection>();
 
   if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
 
   auto ContentOrErr = Obj.getSectionContents(Shdr);
   if (!ContentOrErr)
     return errorToErrorCode(ContentOrErr.takeError());
-  S->Content = yaml::BinaryRef(ContentOrErr.get());
-  S->Size = S->Content.binary_size();
+  ArrayRef<uint8_t> Content = *ContentOrErr;
+  if (!Content.empty())
+    S->Content = yaml::BinaryRef(Content);
   S->Info = Shdr->sh_info;
-
   return S.release();
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::NoBitsSection *>
 ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::NoBitsSection>();
 

tools/yaml2obj/yaml2elf.cpp

 
 static size_t findFirstNonGlobal(ArrayRef<ELFYAML::Symbol> Symbols) {
   for (size_t I = 0; I < Symbols.size(); ++I)
     if (Symbols[I].Binding.value != ELF::STB_LOCAL)
       return I;
   return Symbols.size();
 }
 
+static uint64_t writeRawSectionData(raw_ostream &OS,
+                                    const ELFYAML::RawContentSection &RawSec) {
+  if (RawSec.Content)
+    RawSec.Content->writeAsBinary(OS);
+
+  size_t ContentSize = RawSec.Content ? RawSec.Content->binary_size() : 0;
+  if (!RawSec.Size)
+    return ContentSize;
+
+  OS.write_zeros(*RawSec.Size - ContentSize);
+  return *RawSec.Size;
+}
+
 template <class ELFT>
 void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
                                              SymtabType STType,
                                              ContiguousBlobAccumulator &CBA,
                                              ELFYAML::Section *YAMLSec) {
-  zero(SHeader);
+
   bool IsStatic = STType == SymtabType::Static;
+  const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
+
+  ELFYAML::RawContentSection *RawSec =
+      dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
+  if (RawSec && !Symbols.empty() && (RawSec->Content || RawSec->Size)) {
+    if (RawSec->Content)
+      WithColor::error() << "Cannot specify both `Content` and " +
+                                (IsStatic ? Twine("`Symbols`")
+                                          : Twine("`DynamicSymbols`")) +
+                                " for symbol table section '"
+                         << RawSec->Name << "'.\n";
+    if (RawSec->Size)
+      WithColor::error() << "Cannot specify both `Size` and " +
+                                (IsStatic ? Twine("`Symbols`")
+                                          : Twine("`DynamicSymbols`")) +
+                                " for symbol table section '"
+                         << RawSec->Name << "'.\n";
+    exit(1);
+  }
+
+  zero(SHeader);
   SHeader.sh_name = DotShStrtab.getOffset(IsStatic ? ".symtab" : ".dynsym");
   SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
   SHeader.sh_link = IsStatic ? getDotStrTabSecNo() : getDotDynStrSecNo();
   if (!IsStatic)
     SHeader.sh_flags |= ELF::SHF_ALLOC;
 
-  // One greater than symbol table index of the last local symbol.
-  const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
-
   // If the symbol table section is explicitly described in the YAML
   // then we should set the fields requested.
-  ELFYAML::RawContentSection *RawSec =
-      dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
   SHeader.sh_info =
       RawSec ? (unsigned)RawSec->Info : findFirstNonGlobal(Symbols) + 1;
   SHeader.sh_entsize = (YAMLSec && YAMLSec->EntSize)
                            ? (uint64_t)(*YAMLSec->EntSize)
                            : sizeof(Elf_Sym);
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 8;
   SHeader.sh_addr = YAMLSec ? (uint64_t)YAMLSec->Address : 0;
 
-  if (RawSec && RawSec->Content.binary_size()) {
-    RawSec->Content.writeAsBinary(
-        CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
-    SHeader.sh_size = RawSec->Size;
-  } else {
-    std::vector<Elf_Sym> Syms;
-    {
-      // Ensure STN_UNDEF is present
-      Elf_Sym Sym;
-      zero(Sym);
-      Syms.push_back(Sym);
-    }
+  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  if (RawSec && (RawSec->Content || RawSec->Size)) {
+    assert(Symbols.empty());
+    SHeader.sh_size = writeRawSectionData(OS, *RawSec);
+    return;
+  }
+
 
-    addSymbols(Symbols, Syms, IsStatic ? DotStrtab : DotDynstr);
-
-    writeArrayData(
-        CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign),
-        makeArrayRef(Syms));
-    SHeader.sh_size = arrayDataSize(makeArrayRef(Syms));
-  }
-}
+  writeArrayData(OS, makeArrayRef(Syms));
 
 template <class ELFT>
 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                              StringTableBuilder &STB,
                                              ContiguousBlobAccumulator &CBA,
                                              ELFYAML::Section *YAMLSec) {
   zero(SHeader);
   SHeader.sh_name = DotShStrtab.getOffset(Name);
   SHeader.sh_type = ELF::SHT_STRTAB;
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
 
   ELFYAML::RawContentSection *RawSec =
       dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
-  if (RawSec && RawSec->Content.binary_size()) {
-    RawSec->Content.writeAsBinary(
-        CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
-    SHeader.sh_size = RawSec->Size;
+
+  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  if (RawSec && (RawSec->Content || RawSec->Size)) {
+    SHeader.sh_size = writeRawSectionData(OS, *RawSec);
   } else {
-    STB.write(
-        CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
+    STB.write(OS);
     SHeader.sh_size = STB.getSize();
   }
 
   if (YAMLSec && YAMLSec->EntSize)
     SHeader.sh_entsize = *YAMLSec->EntSize;
 
   // If .dynstr section is explicitly described in the YAML
   // then we want to use its section address.
for (const auto &Sym : Symbols) {
     Syms.push_back(Symbol);
   }
 }
 
 template <class ELFT>
 bool ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  assert(Section.Size >= Section.Content.binary_size() &&
-         "Section size and section content are inconsistent");
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-  Section.Content.writeAsBinary(OS);
-  OS.write_zeros(Section.Size - Section.Content.binary_size());
+  SHeader.sh_size = writeRawSectionData(OS, Section);
 
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else if (Section.Type == llvm::ELF::SHT_RELR)
     SHeader.sh_entsize = sizeof(Elf_Relr);
   else
     SHeader.sh_entsize = 0;
-  SHeader.sh_size = Section.Size;
   SHeader.sh_info = Section.Info;
   return true;
 }
 
 static bool isMips64EL(const ELFYAML::Object &Doc) {
   return Doc.Header.Machine == ELFYAML::ELF_EM(llvm::ELF::EM_MIPS) &&
          Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64) &&
          Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);