[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 ↗

(On Diff #203362)

greater -> greater than

24 ↗

(On Diff #203362)

and the -> and that the

26 ↗

(On Diff #203362)

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 ↗

(On Diff #203362)

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

83 ↗

(On Diff #203362)

What is the bit in brackets referring to?

103–105 ↗

(On Diff #203362)

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 ↗

(On Diff #203362)

or -> nor

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

4 ↗

(On Diff #203362)

for string -> for a string

5 ↗

(On Diff #203362)

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

26 ↗

(On Diff #203362)

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

27 ↗

(On Diff #203362)

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

52 ↗

(On Diff #203362)

Remove "along"

76 ↗

(On Diff #203362)

remove "or equal to"

76–77 ↗

(On Diff #203362)

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

Remove the bit in parentheses.

101–102 ↗

(On Diff #203362)

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

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

5 ↗

(On Diff #203362)

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

63 ↗

(On Diff #203362)

emit the custom -> emit custom

82 ↗

(On Diff #203362)

Ditto

85 ↗

(On Diff #203362)

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 ↗

(On Diff #203362)

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

tools/yaml2obj/yaml2elf.cpp

403 ↗

(On Diff #203362)

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

[grimar]

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

83 ↗

(On Diff #203362)

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 ↗

(On Diff #203362)

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

Oh, indeed. I'll fix.

tools/yaml2obj/yaml2elf.cpp

403 ↗

(On Diff #203362)

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 ↗

(On Diff #203362)

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 ↗

(On Diff #203362)

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

105 ↗

(On Diff #203542)

after content specified -> after the specified content

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

98 ↗

(On Diff #203542)

Same as above.

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

127 ↗

(On Diff #203542)

See above.

[grimar]

• Addressed review comments.

[jhenderson]

Looks like you missed some comments?

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

105 ↗

(On Diff #203542)

This hasn't been done?

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

98 ↗

(On Diff #203542)

Ditto

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

127 ↗

(On Diff #203542)

Ditto

[grimar]

• Addressed review comments.

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

105 ↗

(On Diff #203542)

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

[jhenderson]

LGTM.

llvm/trunk/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;
   }
 };

llvm/trunk/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();
-  return "Section size must be greater or equal to the content size";
+  if (!RawSection)
+    return {};
+  if (RawSection->Size && RawSection->Content &&
+      (uint64_t)(*RawSection->Size) < RawSection->Content->binary_size())
+    return "Section size must be greater than 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)),

llvm/trunk/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

llvm/trunk/test/Object/yaml2obj-elf-section-invalid-size.yaml

- Name: .text
     AddressAlign: 2
 
   - Name: .data
     Type: SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Content: 0000000000000000
     Size: 2
 
-# CHECK: YAML:17:5: error: Section size must be greater or equal to the content size
+# CHECK: YAML:17:5: error: Section size must be greater than or equal to the content size
 # CHECK-NEXT: - Name: .data
 # CHECK-NEXT:   ^
 # CHECK-NEXT: yaml2obj: Failed to parse YAML file!

llvm/trunk/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

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

+## For implicit dynamic 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 a dynamic symbol table section,
+## yaml2obj writes the default content.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readelf %t1 --dyn-symbols | FileCheck %s --check-prefix=CASE1
+
+# CASE1:      Symbol table '.dynsym' 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  GLOBAL DEFAULT  UND foo
+# CASE1-EMPTY:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+DynamicSymbols:
+  - Name:    foo
+    Binding: STB_GLOBAL
+
+## Specifying both `Size` and symbols at the same time is not allowed.
+# RUN: not yaml2obj --docnum=2 %s -o %t2 2>&1 | FileCheck %s --check-prefix=CASE2
+
+# CASE2: error: Cannot specify both `Size` and `DynamicSymbols` for symbol table section '.dynsym'.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+    Size: 0x100
+DynamicSymbols:
+  - Name:    foo
+    Binding: STB_GLOBAL
+
+## Specifying both `Content` and symbols at the same time is not allowed.
+# RUN: not yaml2obj --docnum=3 %s -o %t3 2>&1 | FileCheck %s --check-prefix=CASE3
+
+# CASE3: error: Cannot specify both `Content` and `DynamicSymbols` for symbol table section '.dynsym'.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+    Content: "00"
+DynamicSymbols:
+  - Name:    foo
+    Binding: STB_GLOBAL
+
+## Check we can use just `Content` to emit custom data in the symbol table section.
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      Name: .dynsym
+# CASE4-NEXT: Type: SHT_DYNSYM
+# CASE4-NEXT: Flags [
+# CASE4-NEXT:   SHF_ALLOC
+# CASE4-NEXT: ]
+# CASE4-NEXT: Address: 0x0
+# CASE4-NEXT: Offset: 0x1C0
+# CASE4-NEXT: Size: 2
+# CASE4-NEXT: Link: 2
+# CASE4-NEXT: Info: 0
+# CASE4-NEXT: AddressAlignment: 0
+# CASE4-NEXT: EntrySize: 24
+# CASE4-NEXT: SectionData (
+# CASE4-NEXT:   0000: 0123
+# CASE4-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+    Content: "0123"
+## TODO: .dynstr here is needed to set a proper Link for .dynsym.
+## Without this, llvm-readobj reports an error.
+## See https://bugs.llvm.org/show_bug.cgi?id=42215.
+  - Name: .dynstr
+    Type: SHT_STRTAB
+    Content: "00"
+
+## Check we can use just `Size` to emit custom data filled with zeroes
+## in the symbol table section.
+# RUN: yaml2obj --docnum=5 %s -o %t5
+# RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE5
+
+# CASE5:      Name: .dynsym
+# CASE5-NEXT: Type: SHT_DYNSYM
+# CASE5-NEXT: Flags [
+# CASE5-NEXT:   SHF_ALLOC
+# CASE5-NEXT: ]
+# CASE5-NEXT: Address: 0x0
+# CASE5-NEXT: Offset: 0x1C0
+# CASE5-NEXT: Size: 5
+# CASE5-NEXT: Link: 2
+# CASE5-NEXT: Info: 0
+# CASE5-NEXT: AddressAlignment: 0
+# CASE5-NEXT: EntrySize: 24
+# CASE5-NEXT: SectionData (
+# CASE5-NEXT:   0000: 00000000 00
+# CASE5-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+    Size: 5
+## TODO: .dynstr here is needed to set a proper Link for .dynsym.
+## Without this, llvm-readobj reports an error.
+## See https://bugs.llvm.org/show_bug.cgi?id=42215.
+  - Name: .dynstr
+    Type: SHT_STRTAB
+    Content: "00"
+
+## Check we can specify both `Size` and `Content` when size is greater
+## than content size. In this case zeroes are added as padding
+## after after the specified content.
+
+# RUN: yaml2obj --docnum=6 %s -o %t6
+# RUN: llvm-readobj %t6 --section-data -S | FileCheck %s --check-prefix=CASE6
+
+# CASE6:      Name: .dynsym
+# CASE6-NEXT: Type: SHT_DYNSYM
+# CASE6-NEXT: Flags [
+# CASE6-NEXT:   SHF_ALLOC
+# CASE6-NEXT: ]
+# CASE6-NEXT: Address: 0x0
+# CASE6-NEXT: Offset: 0x1C0
+# CASE6-NEXT: Size: 4
+# CASE6-NEXT: Link: 2
+# CASE6-NEXT: Info: 0
+# CASE6-NEXT: AddressAlignment: 0
+# CASE6-NEXT: EntrySize: 24
+# CASE6-NEXT: SectionData (
+# CASE6-NEXT:   0000: 01230000
+# CASE6-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+    Content: "0123"
+    Size: 4
+## TODO: .dynstr here is needed to set a proper Link for .dynsym.
+## Without this, llvm-readobj reports an error.
+## See https://bugs.llvm.org/show_bug.cgi?id=42215.
+  - Name: .dynstr
+    Type: SHT_STRTAB
+    Content: "00"
+
+## Check we can specify both `Size` and `Content` when size is
+## equal to content size.
+
+# RUN: yaml2obj --docnum=7 %s -o %t7
+# RUN: llvm-readobj --section-data -S %t7 | FileCheck %s --check-prefix=CASE7
+
+# CASE7:       Name: .dynsym
+# CASE7-NEXT:  Type: SHT_DYNSYM
+# CASE7-NEXT:  Flags [
+# CASE7-NEXT:    SHF_ALLOC
+# CASE7-NEXT:  ]
+# CASE7-NEXT:  Address: 0x0
+# CASE7-NEXT:  Offset: 0x1C0
+# CASE7-NEXT:  Size: 2
+# CASE7-NEXT:  Link: 2
+# CASE7-NEXT:  Info: 0
+# CASE7-NEXT:  AddressAlignment: 0
+# CASE7-NEXT:  EntrySize: 24
+# CASE7-NEXT:  SectionData (
+# CASE7-NEXT:    0000: 0123
+# CASE7-NEXT:  )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+    Content: "0123"
+    Size: 2
+## TODO: .dynstr here is needed to set a proper Link for .dynsym.
+## Without this, llvm-readobj reports an error.
+## See https://bugs.llvm.org/show_bug.cgi?id=42215.
+  - Name: .dynstr
+    Type: SHT_STRTAB
+    Content: "00"

llvm/trunk/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 %t1 2>&1 | FileCheck %s --check-prefix=ERR
+# ERR: error: Section size must be greater than 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
+## that the output section has a correct size value.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-readobj --section-data -S %t2 | 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
+# CASE2-NEXT: Link: 0
+# CASE2-NEXT: Info: 0
+# CASE2-NEXT: AddressAlignment: 0
+# CASE2-NEXT: EntrySize: 0
+# CASE2-NEXT: SectionData (
+# CASE2-NEXT:   0000: FF
+# CASE2-NEXT: )
+
+--- !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 %t3
+# RUN: llvm-readobj --section-data -S %t3 | 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 %t4
+# RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE3
+
+# CASE3:      Name: .foo
+# CASE3-NEXT: Type: SHT_PROGBITS
+# CASE3-NEXT: Flags [
+# CASE3-NEXT: ]
+# CASE3-NEXT: Address: 0x0
+# CASE3-NEXT: Offset: 0x180
+# CASE3-NEXT: Size: 1
+# CASE3-NEXT: Link: 0
+# CASE3-NEXT: Info: 0
+# CASE3-NEXT: AddressAlignment: 0
+# CASE3-NEXT: EntrySize: 0
+# CASE3-NEXT: SectionData (
+# CASE3-NEXT:   0000: 00
+# CASE3-NEXT: )
+
+--- !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 content size. In this case zeroes are added as padding
+## after the specified content.
+
+# RUN: yaml2obj --docnum=5 %s -o %t5
+# RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      Name: .foo
+# CASE4-NEXT: Type: SHT_PROGBITS
+# CASE4-NEXT: Flags [
+# CASE4-NEXT: ]
+# CASE4-NEXT: Address: 0x0
+# CASE4-NEXT: Offset: 0x180
+# CASE4-NEXT: Size: 3
+# CASE4-NEXT: Link: 0
+# CASE4-NEXT: Info: 0
+# CASE4-NEXT: AddressAlignment: 0
+# CASE4-NEXT: EntrySize: 0
+# CASE4-NEXT: SectionData (
+# CASE4-NEXT:   0000: FF0000
+# CASE4-NEXT: )
+
+--- !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 emit an empty section if neither 'Content' nor 'Size' were set.
+
+# RUN: yaml2obj --docnum=6 %s -o %t6
+# RUN: llvm-readobj %t6 --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

llvm/trunk/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 a string table section,
+## yaml2obj writes the default content.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-objdump %t1 -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 to override the
+## implicit string table data. The content is filled with zeroes in this case.
+
+# RUN: yaml2obj --docnum=2 %s -o %t2
+# RUN: llvm-readobj --section-data -S %t2 | FileCheck %s --check-prefix=CASE2
+
+# CASE2:      Name: .strtab
+# CASE2-NEXT: Type: SHT_STRTAB
+# CASE2-NEXT: Flags [
+# CASE2-NEXT: ]
+# CASE2-NEXT: Address: 0x0
+# CASE2-NEXT: Offset: 0x140
+# CASE2-NEXT: Size: 2
+# CASE2-NEXT: Link: 0
+# CASE2-NEXT: Info: 0
+# CASE2-NEXT: AddressAlignment: 0
+# CASE2-NEXT: EntrySize: 0
+# CASE2-NEXT: SectionData (
+# CASE2-NEXT:   0000: 0000
+# CASE2-NEXT: )
+
+--- !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 to override the
+## implicit string table data.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readobj --section-data -S %t3 | FileCheck %s --check-prefix=CASE3
+
+# CASE3:      Name: .strtab
+# CASE3-NEXT: Type: SHT_STRTAB
+# CASE3-NEXT: Flags [
+# CASE3-NEXT: ]
+# CASE3-NEXT: Address: 0x0
+# CASE3-NEXT: Offset: 0x140
+# CASE3-NEXT: Size: 2
+# CASE3-NEXT: Link: 0
+# CASE3-NEXT: Info: 0
+# CASE3-NEXT: AddressAlignment: 0
+# CASE3-NEXT: EntrySize: 0
+# CASE3-NEXT: SectionData (
+# CASE3-NEXT:   0000: 0102
+# CASE3-NEXT: )
+
+--- !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 content size. In this case zeroes are
+## added as padding after the specified content.
+
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      Name: .strtab
+# CASE4-NEXT: Type: SHT_STRTAB
+# CASE4-NEXT: Flags [
+# CASE4-NEXT: ]
+# CASE4-NEXT: Address: 0x0
+# CASE4-NEXT: Offset: 0x140
+# CASE4-NEXT: Size: 3
+# CASE4-NEXT: Link: 0
+# CASE4-NEXT: Info: 0
+# CASE4-NEXT: AddressAlignment: 0
+# CASE4-NEXT: EntrySize: 0
+# CASE4-NEXT: SectionData (
+# CASE4-NEXT:   0000: 010200
+# CASE4-NEXT: )
+
+--- !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 equal to content size.
+
+# RUN: yaml2obj --docnum=5 %s -o %t5
+# RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE5
+
+# CASE5:      Name: .strtab
+# CASE5-NEXT: Type: SHT_STRTAB
+# CASE5-NEXT: Flags [ (0x0)
+# CASE5-NEXT: ]
+# CASE5-NEXT: Address: 0x0
+# CASE5-NEXT: Offset: 0x140
+# CASE5-NEXT: Size: 2
+# CASE5-NEXT: Link: 0
+# CASE5-NEXT: Info: 0
+# CASE5-NEXT: AddressAlignment: 0
+# CASE5-NEXT: EntrySize: 0
+# CASE5-NEXT: SectionData (
+# CASE5-NEXT:   0000: 0102
+# CASE5-NEXT: )
+
+--- !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

llvm/trunk/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 a symbol table section,
+## yaml2obj writes the default content.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readelf %t1 -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 %t2 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 %t3 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 custom data in the symbol table section.
+# RUN: yaml2obj --docnum=4 %s -o %t4
+# RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE4
+
+# CASE4:      Name: .symtab
+# CASE4-NEXT: Type: SHT_SYMTAB
+# CASE4-NEXT: Flags [ (0x0)
+# CASE4-NEXT: ]
+# CASE4-NEXT: Address: 0x0
+# CASE4-NEXT: Offset: 0x140
+# CASE4-NEXT: Size: 2
+# CASE4-NEXT: Link: 2
+# CASE4-NEXT: Info: 0
+# CASE4-NEXT: AddressAlignment: 0
+# CASE4-NEXT: EntrySize: 24
+# CASE4-NEXT: SectionData (
+# CASE4-NEXT:   0000: 0123
+# CASE4-NEXT: )
+
+--- !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 custom data filled with zeroes
+## in the symbol table section.
+# RUN: yaml2obj --docnum=5 %s -o %t5
+# RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE5
+
+# CASE5:      Name: .symtab (19)
+# CASE5-NEXT: Type: SHT_SYMTAB (0x2)
+# CASE5-NEXT: Flags [ (0x0)
+# CASE5-NEXT: ]
+# CASE5-NEXT: Address: 0x0
+# CASE5-NEXT: Offset: 0x140
+# CASE5-NEXT: Size: 5
+# CASE5-NEXT: Link: 2
+# CASE5-NEXT: Info: 0
+# CASE5-NEXT: AddressAlignment: 0
+# CASE5-NEXT: EntrySize: 24
+# CASE5-NEXT: SectionData (
+# CASE5-NEXT:   0000: 00000000 00
+# CASE5-NEXT: )
+
+--- !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 content size. In this case zeroes are added as padding
+## after the specified content.
+
+# RUN: yaml2obj --docnum=6 %s -o %t6
+# RUN: llvm-readobj %t6 --section-data -S | FileCheck %s --check-prefix=CASE6
+
+# CASE6:      Name: .symtab
+# CASE6-NEXT: Type: SHT_SYMTAB
+# CASE6-NEXT: Flags [
+# CASE6-NEXT: ]
+# CASE6-NEXT: Address: 0x0
+# CASE6-NEXT: Offset: 0x140
+# CASE6-NEXT: Size: 4
+# CASE6-NEXT: Link: 2
+# CASE6-NEXT: Info: 0
+# CASE6-NEXT: AddressAlignment: 0
+# CASE6-NEXT: EntrySize: 24
+# CASE6-NEXT: SectionData (
+# CASE6-NEXT:   0000: 01230000
+# CASE6-NEXT: )
+
+--- !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
+## equal to content size.
+
+# RUN: yaml2obj --docnum=7 %s -o %t7
+# RUN: llvm-readobj --section-data -S %t7 | FileCheck %s --check-prefix=CASE7
+
+# CASE7:       Name: .symtab
+# CASE7-NEXT:  Type: SHT_SYMTAB
+# CASE7-NEXT:  Flags [
+# CASE7-NEXT:  ]
+# CASE7-NEXT:  Address: 0x0
+# CASE7-NEXT:  Offset: 0x140
+# CASE7-NEXT:  Size: 2
+# CASE7-NEXT:  Link: 2
+# CASE7-NEXT:  Info: 0
+# CASE7-NEXT:  AddressAlignment: 0
+# CASE7-NEXT:  EntrySize: 24
+# CASE7-NEXT:  SectionData (
+# CASE7-NEXT:    0000: 0123
+# CASE7-NEXT:  )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .symtab
+    Type: SHT_SYMTAB
+    Content: "0123"
+    Size: 2

llvm/trunk/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>();
 

llvm/trunk/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) {
+  size_t ContentSize = 0;
+  if (RawSec.Content) {
+    RawSec.Content->writeAsBinary(OS);
+    ContentSize = RawSec.Content->binary_size();
+  }
+
+  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;
 
   // When we describe the .dynsym section in the document explicitly, it is
   // allowed to omit the "DynamicSymbols" tag. In this case .dynstr is not added
   // implicitly and we should be able to leave the Link zeroed if .dynstr is not
   // defined.
   unsigned Link = 0;
   if (IsStatic)
     Link = SN2I.get(".strtab");
   else
     SN2I.lookup(".dynstr", Link);
   SHeader.sh_link = Link;
 
   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);