[yaml2obj] Support -D EI_DATA=

[MaskRay]

Summary

Usage:

yaml2obj -D EI_DATA=ELFDATA2LSB a.yaml | file - # ELF 32-bit LSB relocatable
yaml2obj -D EI_DATA=ELFDATA2MSB a.yaml | file - # ELF 32-bit MSB relocatable

[merge_guards_bot]

Unit tests: pass. 62380 tests passed, 0 failed and 839 were skipped.

clang-tidy: fail. clang-tidy found 0 errors and 6 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 
 template <>
 struct ScalarEnumerationContextTraits<ELFYAML::ELF_ELFCLASS, ELFYAML::Object> {
   static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value,
                           ELFYAML::Object &Ctx);
 };
 
 template <>
-struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
-  static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
+struct ScalarEnumerationContextTraits<ELFYAML::ELF_ELFDATA, ELFYAML::Object> {
+  static void enumeration(IO &io, ELFYAML::ELF_ELFDATA &Value,
+                          ELFYAML::Object &Ctx);
 };
 
 template <>
 struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
   static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
 };
 
 template <>

llvm/lib/ObjectYAML/ELFYAML.cpp

#define ECase(X)                                                               \
 
   // Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
   // here.
   ECase(ELFCLASS32);
   ECase(ELFCLASS64);
 #undef ECase
 }
 
-void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
-    IO &IO, ELFYAML::ELF_ELFDATA &Value) {
-#define ECase(X) IO.enumCase(Value, #X, ELF::X)
+void ScalarEnumerationContextTraits<ELFYAML::ELF_ELFDATA, ELFYAML::Object>::
+    enumeration(IO &io, ELFYAML::ELF_ELFDATA &Value, ELFYAML::Object &Ctx) {
+  Optional<StringRef> OverriddenStr;
+  auto It = Ctx.Overridden.find("EI_DATA");
+  if (It != Ctx.Overridden.end() && !io.outputting()) {
+    OverriddenStr = It->second;
+    Ctx.SeenOverridden.insert("EI_DATA");
+  }
+
+#define ECase(X)                                                               \
+  if (!OverriddenStr)                                                          \
+    io.enumCase(Value, #X, ELF::X);                                            \
+  else if (*OverriddenStr == #X) {                                             \
+    Value = ELF::X;                                                            \
+    io.matchEnumFallback();                                                    \
+    return;                                                                    \
+  }
+
   // ELFDATANONE is an invalid data encoding, but we accept it because
   // we want to be able to produce invalid binaries for the tests.
   ECase(ELFDATANONE);
   ECase(ELFDATA2LSB);
   ECase(ELFDATA2MSB);
 #undef ECase
 }
 
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
   BCase(ODDSPREG);
 #undef BCase
 }
 
 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                                  ELFYAML::FileHeader &FileHdr) {
   auto &Ctx = *static_cast<ELFYAML::Object *>(IO.getContext());
   IO.mapRequired("Class", FileHdr.Class, Ctx);
-  IO.mapRequired("Data", FileHdr.Data);
+  IO.mapRequired("Data", FileHdr.Data, Ctx);
   IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
   IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
   IO.mapRequired("Type", FileHdr.Type);
   IO.mapRequired("Machine", FileHdr.Machine, Ctx);
   IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
   IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
 
   IO.mapOptional("SHEntSize", FileHdr.SHEntSize);

llvm/test/tools/obj2yaml/relr-section.yaml

 ## Test how we dump SHT_RELR sections for 32 and 64-bit targets.
 
 ## Test we use the "Entries" property when it is possible do
 ## dump values correctly.
 
 # RUN: yaml2obj --docnum=1 %s -o %t.64le
 # RUN: obj2yaml %t.64le | FileCheck %s --check-prefix=ELF64LE
-# RUN: yaml2obj --docnum=2 %s -o %t.32le
+# RUN: yaml2obj --docnum=1 -D EI_CLASS=ELFCLASS32 %s -o %t.32le
 # RUN: obj2yaml %t.32le | FileCheck %s --check-prefix=ELF32LE
-# RUN: yaml2obj --docnum=3 %s -o %t.64be
+# RUN: yaml2obj --docnum=1 -D EI_DATA=ELFDATA2MSB %s -o %t.64be
 # RUN: obj2yaml %t.64be | FileCheck %s --check-prefix=ELF64BE
-# RUN: yaml2obj --docnum=4 %s -o %t.32be
+# RUN: yaml2obj --docnum=1 -D EI_CLASS=ELFCLASS32 -D EI_DATA=ELFDATA2MSB %s -o %t.32be
 # RUN: obj2yaml %t.32be | FileCheck %s --check-prefix=ELF32BE
 
 # ELF64LE:      Sections:
 # ELF64LE-NEXT:   - Name:    .relr.dyn
 # ELF64LE-NEXT:     Type:    SHT_RELR
 # ELF64LE-NEXT:     EntSize: 0x0000000000000008
 # ELF64LE-NEXT:     Entries: [ 0x8877665544332211 ]
 
FileHeader:
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .relr.dyn
     Type: SHT_RELR
     Content: "1122334455667788"
 
---- !ELF
-FileHeader:
-  Class:   ELFCLASS32
-  Data:    ELFDATA2LSB
-  Type:    ET_DYN
-  Machine: EM_386
-Sections:
-  - Name: .relr.dyn
-    Type: SHT_RELR
-    Content: "1122334455667788"
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2MSB
-  Type:    ET_DYN
-  Machine: EM_X86_64
-Sections:
-  - Name: .relr.dyn
-    Type: SHT_RELR
-    Content: "1122334455667788"
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS32
-  Data:    ELFDATA2MSB
-  Type:    ET_DYN
-  Machine: EM_386
-Sections:
-  - Name: .relr.dyn
-    Type: SHT_RELR
-    Content: "1122334455667788"
-
 ## Test we use the "Content" property when a SHT_RELR section is truncated.
 
-# RUN: yaml2obj --docnum=5 %s -o %t.content
+# RUN: yaml2obj --docnum=2 %s -o %t.content
 # RUN: obj2yaml %t.content | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      - Name:    .relr.dyn
 # CONTENT-NEXT:   Type:    SHT_RELR
 # CONTENT-NEXT:   EntSize: 0x0000000000000008
 # CONTENT-NEXT:   Content: '11223344556677'
 
 --- !ELF

llvm/test/tools/yaml2obj/ELF/class-endianness.yaml

 ## Check we can produce 32/64 bits outputs with a different endianness.
 
 # RUN: yaml2obj %s --docnum=1 | llvm-readobj --file-headers - | FileCheck %s --check-prefix LE64
 # RUN: yaml2obj %s --docnum=2 -D EI_CLASS=ELFCLASS64 | llvm-readobj --file-headers - | FileCheck %s --check-prefix BE64
 # RUN: yaml2obj %s --docnum=1 -D EI_CLASS=ELFCLASS32 | llvm-readobj --file-headers - | FileCheck %s --check-prefix LE32
 # RUN: yaml2obj %s --docnum=2 | llvm-readobj --file-headers - | FileCheck %s --check-prefix BE32
 
+# RUN: yaml2obj %s --docnum=1 -D EI_DATA=ELFDATA2MSB | llvm-readobj --file-headers - | FileCheck %s --check-prefix BE64
+# RUN: yaml2obj %s --docnum=2 -D EI_DATA=ELFDATA2LSB | llvm-readobj --file-headers - | FileCheck %s --check-prefix LE32
+
 # LE64:      Class: 64-bit (0x2)
 # LE64-NEXT: DataEncoding: LittleEndian (0x1)
 
 # BE64:      Class: 64-bit (0x2)
 # BE64-NEXT: DataEncoding: BigEndian (0x2)
 
 # LE32:      Class: 32-bit (0x1)
 # LE32-NEXT: DataEncoding: LittleEndian (0x1)
 
 # BE32:      Class: 32-bit (0x1)
 # BE32-NEXT: DataEncoding: BigEndian (0x2)
 
 # RUN: not yaml2obj --docnum=1 -D EI_CLASS=invalid %s 2>&1 | FileCheck --check-prefix=BAD %s
 
 # BAD: error: unknown enumerated scalar
 
+# RUN: not yaml2obj --docnum=1 -D EI_DATA=invalid %s 2>&1 | FileCheck --check-prefix=BAD %s
+
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS64
   Data: ELFDATA2LSB
   Type: ET_EXEC
   Machine: EM_X86_64
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS32
   Data: ELFDATA2MSB
   Type: ET_EXEC
   Machine: EM_PPC

llvm/test/tools/yaml2obj/ELF/relr-section.yaml

 # LE64-NEXT: Info: 0
 # LE64-NEXT: AddressAlignment: 0
 # LE64-NEXT: EntrySize: 8
 # LE64-NEXT: SectionData (
 # LE64-NEXT:   0000: DDCCBBAA 00000000 2211FFEE 00000000
 # LE64-NEXT:   0010: 66554433 00000010 AA998877 00000010
 # LE64-NEXT: )
 
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_DYN
-  Machine: EM_X86_64
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-## Set an arbitrary flag to demonstrate flags are set when requested.
-    Flags:   [ SHF_ALLOC ]
-    Entries: [ 0x00000000AABBCCDD, 0x00000000EEFF1122,
-               0x1000000033445566, 0x10000000778899AA ]
-
 ## Test that the content of SHT_RELR sections for 64-bit big endian targets is correct.
-# RUN: yaml2obj --docnum=2 %s -o %t.be64
+# RUN: yaml2obj --docnum=1 -D EI_DATA=ELFDATA2MSB %s -o %t.be64
 # RUN: llvm-readobj --sections --section-data %t.be64 | FileCheck %s --check-prefix=BE64
 
 # BE64:      Name: .relr.dyn
 # BE64:      SectionData (
 # BE64-NEXT:   0000: 00000000 AABBCCDD 00000000 EEFF1122
 # BE64-NEXT:   0010: 10000000 33445566 10000000 778899AA
 # BE64-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
-  Data:    ELFDATA2MSB
+  Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
 ## Set an arbitrary flag to demonstrate flags are set when requested.
     Flags:   [ SHF_ALLOC ]
     Entries: [ 0x00000000AABBCCDD, 0x00000000EEFF1122,
                0x1000000033445566, 0x10000000778899AA ]
 
 ## Test that the content of SHT_RELR sections for 32-bit little endian targets is correct.
-# RUN: yaml2obj --docnum=3 %s -o %t.le32
+# RUN: yaml2obj --docnum=2 %s -o %t.le32
 # RUN: llvm-readobj --sections --section-data %t.le32 | FileCheck %s --check-prefix=LE32
 
 # LE32:      Name: .relr.dyn
 # LE32-NEXT: Type: SHT_RELR
 # LE32-NEXT: Flags [
 # LE32-NEXT:   SHF_ALLOC
 # LE32-NEXT: ]
 # LE32-NEXT: Address: 0x0
 # LE32-NEXT: Offset: 0x34
 # LE32-NEXT: Size: 16
 # LE32-NEXT: Link: 0
 # LE32-NEXT: Info: 0
 # LE32-NEXT: AddressAlignment: 0
 # LE32-NEXT: EntrySize: 4
 # LE32-NEXT: SectionData (
 # LE32-NEXT:   0000: DDCCBBAA BBAAFFEE BBAAFFEE BCAAFFEE
 # LE32-NEXT: )
 
---- !ELF
-FileHeader:
-  Class:   ELFCLASS32
-  Data:    ELFDATA2LSB
-  Type:    ET_DYN
-  Machine: EM_386
-Sections:
-  - Name:    .relr.dyn
-    Type:    SHT_RELR
-## Set an arbitrary flag to demonstrate flags are set when requested.
-    Flags:   [ SHF_ALLOC ]
-    Entries: [ 0xAABBCCDD, 0xEEFFAABB,
-               0xEEFFAABB, 0xEEFFAABC ]
-
 ## Test that the content of SHT_RELR sections for 32-bit big endian targets is correct.
-# RUN: yaml2obj --docnum=4 %s -o %t.be32
+# RUN: yaml2obj --docnum=2 -D EI_DATA=ELFDATA2MSB %s -o %t.be32
 # RUN: llvm-readobj --sections --section-data %t.be32 | FileCheck %s --check-prefix=BE32
 
 # BE32:      Name: .relr.dyn
 # BE32:      SectionData (
 # BE32-NEXT:   0000: AABBCCDD EEFFAABB EEFFAABB EEFFAABC  |
 # BE32-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
-  Data:    ELFDATA2MSB
+  Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
 ## Set an arbitrary flag to demonstrate flags are set when requested.
     Flags:   [ SHF_ALLOC ]
     Entries: [ 0xAABBCCDD, 0xEEFFAABB,
                0xEEFFAABB, 0xEEFFAABC ]
 
 ## Test we can use "Content" to describe SHT_RELR section.
-# RUN: yaml2obj --docnum=5 %s -o %t.content
+# RUN: yaml2obj --docnum=3 %s -o %t.content
 # RUN: llvm-readobj --sections --section-data %t.content | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Name: .relr.dyn
 # CONTENT:      SectionData (
 # CONTENT-NEXT:   0000: 112233 |
 # CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
     Content: "112233"
 
 ## Check we are able to set an arbitrary sh_entsize.
-# RUN: yaml2obj --docnum=6 %s -o %t.entsize
+# RUN: yaml2obj --docnum=4 %s -o %t.entsize
 # RUN: llvm-readelf --sections %t.entsize | FileCheck %s --check-prefix=ENTSIZE
 
 # ENTSIZE: [Nr] Name      Type Address  Off    Size   ES
 # ENTSIZE: [ 1] .relr.dyn RELR 00000000 000034 000001 34
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
     EntSize: 0x34
     Content: "12"
 
 ## Test we can't use 64-bit offsets/bitmaps when creating a 32-bit object.
-# RUN: yaml2obj --docnum=7 %s -o %t.nottoolarge
+# RUN: yaml2obj --docnum=5 %s -o %t.nottoolarge
 # RUN: llvm-readobj --sections --section-data %t.nottoolarge | FileCheck %s --check-prefix=NOT-TOO-LARGE
 
 # NOT-TOO-LARGE:      Name: .relr.dyn
 # NOT-TOO-LARGE:      SectionData (
 # NOT-TOO-LARGE-NEXT:   0000: FFFFFFFF
 # NOT-TOO-LARGE-NEXT: )
 
-# RUN: not yaml2obj --docnum=8 %s 2>&1 | FileCheck %s --check-prefix=TOO-LARGE
+# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=TOO-LARGE
 # TOO-LARGE: error: .relr.dyn: the value is too large for 32-bits: 0x100000000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
FileHeader:
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
     Entries: [ 0x0000000100000000 ]
 
 ## Test we can't specify "Entries" and "Content" properties at the same time.
-# RUN: not yaml2obj --docnum=9 %s 2>&1 | FileCheck %s --check-prefix=BOTH
+# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=BOTH
 
 # BOTH: error: "Entries" and "Content" can't be used together
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
     Entries: [ 0x0 ]
     Content: "00"

llvm/test/tools/yaml2obj/ELF/stack-sizes.yaml

- Name:    '.stack_sizes [2]'
     Content: "1000000000000000"
 ## Empty.
   - Name:    '.stack_sizes [3]'
     Type:    SHT_PROGBITS
     Content: ""
 
 ## Check we can describe .stack_sizes section using <address, size> pairs.
 
-# RUN: yaml2obj --docnum=2 %s -o %t2
-# RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=ENTRIES-LE64-BOTH
-# RUN: yaml2obj --docnum=3 %s -o %t3
-# RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=ENTRIES-BE64-BOTH
-# RUN: yaml2obj --docnum=4 %s -o %t4
-# RUN: llvm-readobj --sections --section-data %t4 | FileCheck %s --check-prefix=ENTRIES-LE32-BOTH
-# RUN: yaml2obj --docnum=5 %s -o %t5
-# RUN: llvm-readobj --sections --section-data %t5 | FileCheck %s --check-prefix=ENTRIES-BE32-BOTH
+# RUN: yaml2obj --docnum=2 %s -o %t2.le64
+# RUN: llvm-readobj --sections --section-data %t2.le64 | FileCheck %s --check-prefix=ENTRIES-LE64-BOTH
+# RUN: yaml2obj --docnum=2 -D EI_DATA=ELFDATA2MSB %s -o %t2.be64
+# RUN: llvm-readobj --sections --section-data %t2.be64 | FileCheck %s --check-prefix=ENTRIES-BE64-BOTH
+# RUN: yaml2obj --docnum=2 -D EI_CLASS=ELFCLASS32 %s -o %t2.le32
+# RUN: llvm-readobj --sections --section-data %t2.le32 | FileCheck %s --check-prefix=ENTRIES-LE32-BOTH
+# RUN: yaml2obj --docnum=2 -D EI_CLASS=ELFCLASS32 -D EI_DATA=ELFDATA2MSB %s -o %t2.be32
+# RUN: llvm-readobj --sections --section-data %t2.be32 | FileCheck %s --check-prefix=ENTRIES-BE32-BOTH
 
 # ENTRIES-LE64-BOTH:      Name: .stack_sizes
 # ENTRIES-LE64-BOTH:      SectionData (
 # ENTRIES-LE64-BOTH-NEXT:  0000: 10000000 00000000 20300000 00000000 |
 # ENTRIES-LE64-BOTH-NEXT:  0010: 0040                                |
 
 # ENTRIES-BE64-BOTH:      Name: .stack_sizes
 # ENTRIES-BE64-BOTH:      SectionData (
Sections:
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Entries:
       - Address: 0x10
         Size:    0x20
       - Address: 0x30
         Size:    0x40
 
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2MSB
-  Type:    ET_EXEC
-  Machine: EM_X86_64
-Sections:
-  - Name:    .stack_sizes
-    Type:    SHT_PROGBITS
-    Entries:
-      - Address: 0x10
-        Size:    0x20
-      - Address: 0x30
-        Size:    0x40
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS32
-  Data:    ELFDATA2LSB
-  Type:    ET_EXEC
-  Machine: EM_386
-Sections:
-  - Name:    .stack_sizes
-    Type:    SHT_PROGBITS
-    Entries:
-      - Address: 0x10
-        Size:    0x20
-      - Address: 0x30
-        Size:    0x40
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS32
-  Data:    ELFDATA2MSB
-  Type:    ET_EXEC
-  Machine: EM_386
-Sections:
-  - Name:    .stack_sizes
-    Type:    SHT_PROGBITS
-    Entries:
-      - Address: 0x10
-        Size:    0x20
-      - Address: 0x30
-        Size:    0x40
-
 ## Check we can omit the "Address" tag. In this case the address will be zero.
 
-# RUN: yaml2obj --docnum=6 %s -o %t6
-# RUN: llvm-readobj --sections --section-data %t6 | FileCheck %s --check-prefix=ENTRIES-NOADDR
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=ENTRIES-NOADDR
 
 # ENTRIES-NOADDR:      Name: .stack_sizes
 # ENTRIES-NOADDR:      SectionData (
 # ENTRIES-NOADDR-NEXT:  0000: 00000000 00000000 10000000 00000000 |
 # ENTRIES-NOADDR-NEXT:  0010: 0020                                |
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Entries:
        - Size: 0x10
        - Size: 0x20
 
 ## Check that "Size" tag is mandatory when we describe .stack_sizes using "Entries".
 
-# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-NOSIZE
+# RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-NOSIZE
 
 # ENTRIES-NOSIZE: error: missing required key 'Size'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Entries:
        - Address: 0x10
 
 ## Check we can't use both "Content" and "Entries" tags at the same time.
 
-# RUN: not yaml2obj --docnum=8 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-AND-CONTENT
+# RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-AND-CONTENT
 
 # ENTRIES-AND-CONTENT: error: .stack_sizes: Content and Entries cannot be used together
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Content: "00"
     Entries:
       - Address: 0x10
         Size:    0x20
 
 ## Check we must specify either "Content", "Entries" or "Size" tag when describing .stack_sizes.
 
-# RUN: not yaml2obj --docnum=9 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
+# RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
 
 # NO-TAGS: .stack_sizes: one of Content, Entries and Size must be specified
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .stack_sizes
     Type: SHT_PROGBITS
 
 ## Check we can't use both "Size" and "Entries" tags at the same time.
 
-# RUN: not yaml2obj --docnum=10 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-AND-SIZE
+# RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=ENTRIES-AND-SIZE
 
 # ENTRIES-AND-SIZE: .stack_sizes: Size and Entries cannot be used together
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .stack_sizes
     Type: SHT_PROGBITS
     Size: 0x1
     Entries:
       - Address: 0x10
         Size:    0x20
 
 ## Check we can use only "Size" to create .stack_sizes section.
 
-# RUN: yaml2obj --docnum=11 %s -o %t11
-# RUN: llvm-readobj --sections --section-data %t11 | FileCheck %s --check-prefix=SIZE
+# RUN: yaml2obj --docnum=8 %s -o %t8
+# RUN: llvm-readobj --sections --section-data %t8 | FileCheck %s --check-prefix=SIZE
 
 # SIZE:      Name: .stack_sizes
 # SIZE:      Size:
 # SIZE-SAME: 17
 # SIZE:      SectionData (
 # SIZE-NEXT:  0000: 00000000 00000000 00000000 00000000  |
 # SIZE-NEXT:  0010: 00                                   |
 # SIZE-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .stack_sizes
     Type: SHT_PROGBITS
     Size: 0x11
 
 ## Check we can use "Size" and "Content" together to create .stack_sizes section.
 
-# RUN: yaml2obj --docnum=12 %s -o %t12
-# RUN: llvm-readobj --sections --section-data %t12 | FileCheck %s --check-prefix=SIZE-CONTENT
+# RUN: yaml2obj --docnum=9 %s -o %t9
+# RUN: llvm-readobj --sections --section-data %t9 | FileCheck %s --check-prefix=SIZE-CONTENT
 
 # SIZE-CONTENT:      Name: .stack_sizes
 # SIZE-CONTENT:      Size:
 # SIZE-CONTENT-SAME: 5
 # SIZE-CONTENT:      SectionData (
 # SIZE-CONTENT-NEXT:  0000: 11223300 00 |
 # SIZE-CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .stack_sizes
     Type: SHT_PROGBITS
     Size: 0x5
     Content: "112233"
 
-# RUN: not yaml2obj --docnum=13 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
+# RUN: not yaml2obj --docnum=10 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
 
 # SIZE-CONTENT-ERR: error: .stack_sizes: Size must be greater than or equal to the content size
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .stack_sizes
     Type: SHT_PROGBITS
     Size: 0x1
     Content: "1122"
 
 ## Check we can describe multiple .stack_sizes sections using unique suffixes.
 
-# RUN: yaml2obj --docnum=14 %s -o %t11
+# RUN: yaml2obj --docnum=11 %s -o %t11
 # RUN: llvm-readobj --sections --section-data %t11 | FileCheck %s --check-prefix=UNIQUE
 
 # UNIQUE:      Name: .stack_sizes
 # UNIQUE:      SectionData (
 # UNIQUE-NEXT:   0000: 10000000 00000000 20 |
 
 # UNIQUE:      Name: .stack_sizes
 # UNIQUE:      SectionData (