[yaml2obj][test] Move tests to binary format specific subdirectories

[MaskRay]

Summary

Create COFF/, ELF/, and Minidump and move tests there.

Also

• Rename *.test to *.yaml
• For yaml2obj RUN lines, use -o %t instead of > %t for consistency. We still have tests that check stdout is the default output, e.g. multi-doc.test
• Update tests to consistently use ## for comments. # is for RUN and CHECK lines.
• Merge symboless-relocation.yaml and invalid-symboless-relocation.yaml to ELF/relocation-implicit-symbol-index.test

[jhenderson]

Mostly looks fine to me.

llvm/test/tools/yaml2obj/ELF/symbol-index-invalid.yaml

1–2

Maybe add "in a symbol".

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

2

Delete "the".

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

2

Delete "the".

llvm/test/tools/yaml2obj/empty-symbols.yaml

10

I might be misreading the intent of the comment, but I think there's value in testing:

Symbols:

distinctly from

Symbols: []

In other words, can yaml2obj handle it with/without the [].

[MaskRay]

Address review comments

llvm/test/tools/yaml2obj/empty-symbols.yaml

10

We probably don't have other tests that check Symbols: with the value omitted now.

Added it back with a comment.

[grimar]

Nice cleanup! I've found only a single minor nit.

llvm/test/tools/yaml2obj/ELF/empty-symbols.yaml

10

# -> ##

[jhenderson]

LGTM, with one suggestion.

llvm/test/tools/yaml2obj/ELF/empty-symbols.yaml

10

This phrasing sounds a bit clunky to me. How about "... but here we show that the value can be omitted."

[MaskRay]

Address review comments

llvm/test/tools/yaml2obj/COFF/basic-arm64.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --file-headers %t | FileCheck %s
 # RUN: obj2yaml %t | FileCheck %s --check-prefix=ROUNDTRIP
 
 # CHECK: OptionalHeaderSize: 240
 
 # ROUNDTRIP: VirtualAddress:  4096
 # ROUNDTRIP: VirtualAddress:  8192
 # ROUNDTRIP: VirtualAddress:  12288
 
 --- !COFF
-OptionalHeader:  
+OptionalHeader:
   AddressOfEntryPoint: 4096
   ImageBase:       1073741824
   SectionAlignment: 4096
   FileAlignment:   512
   MajorOperatingSystemVersion: 6
   MinorOperatingSystemVersion: 0
   MajorImageVersion: 0
   MinorImageVersion: 0
   MajorSubsystemVersion: 6
   MinorSubsystemVersion: 0
   Subsystem:       IMAGE_SUBSYSTEM_WINDOWS_CUI
   DLLCharacteristics: [ IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE ]
   SizeOfStackReserve: 1048576
   SizeOfStackCommit: 4096
   SizeOfHeapReserve: 1048576
   SizeOfHeapCommit: 4096
-  ExportTable:     
+  ExportTable:
     RelativeVirtualAddress: 0
     Size:            0
-  ImportTable:     
+  ImportTable:
     RelativeVirtualAddress: 0
     Size:            0
-  ResourceTable:   
+  ResourceTable:
     RelativeVirtualAddress: 0
     Size:            0
-  ExceptionTable:  
+  ExceptionTable:
     RelativeVirtualAddress: 12288
     Size:            8
-  CertificateTable: 
+  CertificateTable:
     RelativeVirtualAddress: 0
     Size:            0
-  BaseRelocationTable: 
+  BaseRelocationTable:
     RelativeVirtualAddress: 0
     Size:            0
-  Debug:           
+  Debug:
     RelativeVirtualAddress: 0
     Size:            0
-  Architecture:    
+  Architecture:
     RelativeVirtualAddress: 0
     Size:            0
-  GlobalPtr:       
+  GlobalPtr:
     RelativeVirtualAddress: 0
     Size:            0
-  TlsTable:        
+  TlsTable:
     RelativeVirtualAddress: 0
     Size:            0
-  LoadConfigTable: 
+  LoadConfigTable:
     RelativeVirtualAddress: 0
     Size:            0
-  BoundImport:     
+  BoundImport:
     RelativeVirtualAddress: 0
     Size:            0
-  IAT:             
+  IAT:
     RelativeVirtualAddress: 0
     Size:            0
-  DelayImportDescriptor: 
+  DelayImportDescriptor:
     RelativeVirtualAddress: 0
     Size:            0
-  ClrRuntimeHeader: 
+  ClrRuntimeHeader:
     RelativeVirtualAddress: 0
     Size:            0
-header:          
+header:
   Machine:         IMAGE_FILE_MACHINE_ARM64
   Characteristics: [ IMAGE_FILE_EXECUTABLE_IMAGE, IMAGE_FILE_LARGE_ADDRESS_AWARE ]
-sections:        
+sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
     VirtualAddress:  4096
     VirtualSize:     4
     SectionData:     C0035FD6
   - Name:            .rdata
     Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
     VirtualAddress:  8192

llvm/test/tools/yaml2obj/COFF/invalid-alignment.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 ## CHECK: error: section alignment is too large
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: []
 sections:
   - Name:            '.text'
     Characteristics: []
     SectionData:     00
     Alignment:       16384
-symbols:
+symbols: []

llvm/test/tools/yaml2obj/COFF/symbol-index.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -r %t | FileCheck %s --check-prefix=RELOCS
 # RUN: obj2yaml %t | FileCheck %s --check-prefix=YAML
 
 # RELOCS:      Relocations [
 # RELOCS-NEXT:   Section (1) .text {
 # RELOCS-NEXT:     0x3 IMAGE_REL_AMD64_REL32 .rdata (0)
 # RELOCS-NEXT:     0xA IMAGE_REL_AMD64_REL32 .rdata (1)
 # RELOCS-NEXT:     0x11 IMAGE_REL_AMD64_REL32 foo (2)
 # RELOCS-NEXT:   }
 # RELOCS-NEXT: ]
 
-# Check that we usually output relocations with SymbolName.
-# For relocations with a non-unique symbol name, output
-# SymbolTableIndex instead.
+## Check that we usually output relocations with SymbolName.
+## For relocations with a non-unique symbol name, output
+## SymbolTableIndex instead.
 
-# YAML:          Relocations:     
+# YAML:          Relocations:
 # YAML-NEXT:       - VirtualAddress:  3
 # YAML-NEXT:         SymbolTableIndex: 0
 # YAML-NEXT:         Type:            IMAGE_REL_AMD64_REL32
 # YAML-NEXT:       - VirtualAddress:  10
 # YAML-NEXT:         SymbolTableIndex: 1
 # YAML-NEXT:         Type:            IMAGE_REL_AMD64_REL32
 # YAML-NEXT:       - VirtualAddress:  17
 # YAML-NEXT:         SymbolName:      foo
 # YAML-NEXT:         Type:            IMAGE_REL_AMD64_REL32
 
 --- !COFF
-header:          
+header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: [  ]
-sections:        
+sections:
   - Name:            .text
     Characteristics: [  ]
     Alignment:       4
     SectionData:     488B0500000000488B0500000000488B0500000000
-    Relocations:     
+    Relocations:
       - VirtualAddress:  3
         SymbolTableIndex: 0
         Type:            IMAGE_REL_AMD64_REL32
       - VirtualAddress:  10
         SymbolTableIndex: 1
         Type:            IMAGE_REL_AMD64_REL32
       - VirtualAddress:  17
         SymbolName:      foo
         Type:            IMAGE_REL_AMD64_REL32
   - Name:            .rdata
     Characteristics: [  ]
     Alignment:       1
     SectionData:     '00'
   - Name:            .rdata
     Characteristics: [  ]
     Alignment:       1
     SectionData:     '01'
-symbols:         
+symbols:
   - Name:            .rdata
     Value:           0
     SectionNumber:   2
     SimpleType:      IMAGE_SYM_TYPE_NULL
     ComplexType:     IMAGE_SYM_DTYPE_NULL
     StorageClass:    IMAGE_SYM_CLASS_STATIC
   - Name:            .rdata
     Value:           0

llvm/test/tools/yaml2obj/ELF/abiversion.yaml

+## Check we are able to parse/emit the ABI version with yaml2obj/obj2yaml.
+
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --file-headers %t | FileCheck %s --check-prefix=FROMYAML
 # RUN: obj2yaml %t | FileCheck %s --check-prefix=TOYAML
 
-## Check we are able to parse/emit the ABI version with yaml2obj/obj2yaml.
-
 # FROMYAML: ABIVersion: 5
 # TOYAML:   ABIVersion: 0x05
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
   ABIVersion:      0x05

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 | llvm-readobj --file-headers - | FileCheck %s --check-prefix BE64
 # RUN: yaml2obj %s --docnum=3 | llvm-readobj --file-headers - | FileCheck %s --check-prefix LE32
 # RUN: yaml2obj %s --docnum=4 | llvm-readobj --file-headers - | FileCheck %s --check-prefix BE32
 
 # 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)
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS64
   Data: ELFDATA2LSB
   Type: ET_EXEC
   Machine: EM_X86_64
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS64
   Data: ELFDATA2MSB
   Type: ET_EXEC
   Machine: EM_PPC64
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS32
   Data: ELFDATA2LSB
   Type: ET_EXEC
   Machine: EM_386
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS32
   Data: ELFDATA2MSB
   Type: ET_EXEC
   Machine: EM_PPC

llvm/test/tools/yaml2obj/ELF/comdat-broken-info.yaml

 ## Check we are able to produce an SHT_GROUP section with a custom Info value (12345).
 
 # RUN: yaml2obj %s -o %t1
 # RUN: llvm-readobj --sections %t1 | FileCheck %s
 
 --- !ELF
 FileHeader:
   Class:               ELFCLASS64
   Data:                ELFDATA2LSB
   Type:                ET_REL
   Machine:             EM_X86_64
 Sections:
   - Name:              .group
     Type:              SHT_GROUP
     Info:              12345
     Members:
       - SectionOrType: GRP_COMDAT
 
 # CHECK:      Name: .group
 # CHECK-NEXT: Type: SHT_GROUP
 # CHECK-NEXT: Flags [
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size:
 # CHECK-NEXT: Link:
 # CHECK-NEXT: Info: 12345
 
 ## Check we report multiple errors when multiple unknown symbols are referenced by SHT_GROUP sections.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=ERR
 
 # ERR: error: unknown symbol referenced: 'foo' by YAML section '.group1'
 # ERR: error: unknown symbol referenced: 'bar' by YAML section '.group2'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .group1
     Type: SHT_GROUP
     Info: foo
     Members:
       - SectionOrType: GRP_COMDAT
   - Name: .group2
     Type: SHT_GROUP
     Info: bar
     Members:
       - SectionOrType: GRP_COMDAT

llvm/test/tools/yaml2obj/ELF/comdat-broken-members.yaml

 ## Check we report an error when SHT_GROUP references an unknown section in its member list.
 
 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 # CHECK: error: unknown section referenced: '.foo' by YAML section '.group'
 # CHECK: error: unknown section referenced: '.bar' by YAML section '.group'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .group
     Type: SHT_GROUP
     Members:
       - SectionOrType: GRP_COMDAT
       - SectionOrType: .foo
       - SectionOrType: .bar

llvm/test/tools/yaml2obj/ELF/comdat-broken.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections --elf-section-groups %t | FileCheck %s
 
 --- !ELF
 FileHeader:
   Class:               ELFCLASS64
   Data:                ELFDATA2LSB
   Type:                ET_REL
   Machine:             EM_X86_64
 Sections:
   - Name:              .group
     Type:              SHT_GROUP
     Info:              foo
     Members:
       - SectionOrType: 0xFF
       - SectionOrType: 3
 Symbols:
   - Name:    foo
   - Binding: STB_GLOBAL
 
 ## Check we are able to produce SHT_GROUP section with a custom Type (0xFF).
 # CHECK:       Groups {
 # CHECK-NEXT:   Group {
 # CHECK-NEXT:     Name: .group
 # CHECK-NEXT:     Index: 1
 # CHECK-NEXT:     Link: 2
 # CHECK-NEXT:     Info: 1
 # CHECK-NEXT:     Type: COMDAT (0xFF)
 # CHECK-NEXT:     Signature: foo
 # CHECK-NEXT:     Section(s) in group [
 # CHECK-NEXT:       .strtab (3)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml

 ## Here we check that we are able to define sections with a type of "Fill".
 ## Fills are custom pieces of data that can be placed anywhere just like normal
 ## output sections, but they are not real output sections and you'll never see them in
 ## the section headers.
 
 ## Check we can create named and unnamed fills and use "Pattern" and "Size" fields
 ## to describe the data emitted.
 ## Check the data emitted and how it affects regular sections offsets.
 ## Check that the "Name" field is optional for fills.
 ## Check that "Size" can be greater than or equal to the pattern data size.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --sections --headers %t1 | FileCheck %s --check-prefix=BASIC
 
 # BASIC:        Number of section headers: 5
 # BASIC:        Section Headers:
 # BASIC-NEXT:   [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
 # BASIC-NEXT:   [ 0]           NULL     0000000000000000 000000 000000 00     0   0  0
 # BASIC-NEXT:   [ 1] .foo      PROGBITS 0000000000000000 000043 000002 00     0   0  0
 # BASIC-NEXT:   [ 2] .bar      PROGBITS 0000000000000000 000049 000001 00     0   0  0
 # BASIC-NEXT:   [ 3] .strtab   STRTAB   0000000000000000 00004b 000001 00     0   0  1
 # BASIC-NEXT:   [ 4] .shstrtab STRTAB   0000000000000000 00004c 00001d 00     0   0  1
 
 ## The fill we dump starts at (offset of .foo - 3), which is (0x43 - 3) = 0x40.
 # RUN: od -t x1 -v -j 0x40 -N 11 %t1 | FileCheck %s --ignore-case --check-prefix=DATA
 # DATA: aa bb aa 11 22 cc dd cc dd ff ee
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Pattern: "AABB"
     Size:    0x3
   - Name:    .foo
     Type:    SHT_PROGBITS
     Content: "1122"
   - Type:    Fill
     Name:    unusedName
     Pattern: "CCDD"
     Size:    4
   - Name:    .bar
     Type:    SHT_PROGBITS
     Content: "FF"
   - Type:    Fill
     Pattern: "EE"
     Size:    1
 
 ## Check we can have no explicit regular sections in the YAML description, and can
 ## describe the content with the use of fills only.
 ## Check that "Size" can be less than the pattern data size.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf --sections --headers %t2 | FileCheck %s --check-prefix=NOSECTIONS
 
 ## The fill we dump starts at (offset of .strtab - 3 - 2), which is (0x45 - 5) = 0x40.
 # RUN: od -t x1 -v -j 0x40 -N 6 %t2 | FileCheck %s --ignore-case --check-prefix=NOSECTIONS-DATA
 
 # NOSECTIONS:      Number of section headers: 3
 # NOSECTIONS:      Section Headers:
 # NOSECTIONS-NEXT:  [Nr] Name      Type   Address          Off    Size   ES Flg Lk Inf Al
 # NOSECTIONS-NEXT:  [ 0]           NULL   0000000000000000 000000 000000 00     0   0  0
 # NOSECTIONS-NEXT:  [ 1] .strtab   STRTAB 0000000000000000 000045 000001 00     0   0  1
 # NOSECTIONS-NEXT:  [ 2] .shstrtab STRTAB 0000000000000000 000046 000013 00     0   0  1
 
 ## .strtab that follows fills starts at 0x46 and always has a null character at the begining.
 # NOSECTIONS-DATA: aa bb cc dd ee 00
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Pattern: "AABBCCFF"
     Size:    0x3
   - Type:    Fill
     Pattern: "DDEEFF"
     Size:    0x2
 
 ## Check we can use named fills when describing program headers.
 ## Check that fills consume the file size and therefore affect the p_filesz fields of segments.
 ## Check that the fill does not affect the p_align field of the segment.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readelf --sections --program-headers %t3 | FileCheck %s --check-prefix=PHDR
 
 # PHDR: [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf  Al
 # PHDR: [ 0]           NULL     0000000000000000 000000 000000 00      0   0  0
 # PHDR: [ 1] .bar      PROGBITS 0000000000000100 0000c0 000005 00      0   0  2
 # PHDR: [ 2] .strtab   STRTAB   0000000000000000 00010a 000001 00      0   0  1
 # PHDR: [ 3] .shstrtab STRTAB   0000000000000000 00010b 000018 00      0   0  1
 
 # PHDR: Program Headers:
 # PHDR:   Type      Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
 # PHDR:   LOAD      0x0000b0 0x0000000000000100 0x0000000000000100 0x00005a 0x00005a     0x2
 # PHDR:   GNU_RELRO 0x0000c5 0x0000000000000105 0x0000000000000105 0x000045 0x000045     0x1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Name:    fill1
     Pattern: ""
     Size:    0x10
   - Name:         .bar
     Type:         SHT_PROGBITS
     Size:         0x5
     Address:      0x100
     AddressAlign: 2
   - Type:    Fill
     Name:    fill2
     Pattern: ""
     Size:    0x45
 ProgramHeaders:
   - Type:  PT_LOAD
     VAddr: 0x100
     PAddr: 0x100
     Sections:
       - Section: fill1
       - Section: .bar
       - Section: fill2
   - Type:  PT_GNU_RELRO
     VAddr: 0x105
     PAddr: 0x105
     Sections:
       - Section: fill2
 
 ## Check that the "Pattern" field is not mandatory.
 # RUN: yaml2obj --docnum=4 2>&1 -o %t4 %s
 # RUN: llvm-readelf --sections %t4 | FileCheck %s --check-prefix=NOPATTERN
 
 ## The fill we dump starts at (offset of .strtab - 1 - 3 - 1), which is (0x45 - 5) = 0x40.
 # RUN: od -t x1 -v -j 0x40 -N 5 %t4 | FileCheck %s --ignore-case --check-prefix=NOPATTERN-DATA
 
 # NOPATTERN: [Nr] Name    Type   Address          Off
 # NOPATTERN: [ 1] .strtab STRTAB 0000000000000000 000045
 
 # NOPATTERN-DATA: aa 00 00 00 bb
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Size:    0x1
     Pattern: "AA"
   - Type: Fill
     Size: 0x3
   - Type:    Fill
     Size:    0x1
     Pattern: "BB"
 
 ## Check that the "Size" field is mandatory.
 # RUN: not yaml2obj --docnum=5 2>&1 %s | FileCheck %s --check-prefix=NOSIZE
 
 ## NOSIZE: error: missing required key 'Size'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Pattern: "00"
 
 ## Check that fills are not allowed to have duplicate names.
 # RUN: not yaml2obj --docnum=6 2>&1 %s | FileCheck %s --check-prefix=UNIQUE-NAME
 
 # UNIQUE-NAME: error: repeated section/fill name: 'foo' at YAML section/fill number 2
 # UNIQUE-NAME: error: repeated section/fill name: 'foo' at YAML section/fill number 3
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Name:    foo
     Pattern: "00"
     Size:    1
   - Type:    Fill
     Name:    foo
     Pattern: "00"
     Size:    1
   - Name: foo
     Type: SHT_PROGBITS
 
 ## Check that "Pattern" can be empty, when "Size" is zero.
 # RUN: yaml2obj --docnum=7 2>&1 %s -o %t7
 # RUN: llvm-readelf --sections %t7 | FileCheck %s --check-prefix=NOOP
 
 # NOOP: [Nr] Name  Type     Address          Off
 # NOOP: [ 1] begin PROGBITS 0000000000000000 000040
 # NOOP: [ 2] end   PROGBITS 0000000000000000 000041
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: begin
     Type: SHT_PROGBITS
     Size: 1
   - Type:    Fill
     Pattern: ""
     Size:    0
   - Name: end
     Type: SHT_PROGBITS
     Size: 1
 
 ## Check that we can have an empty "Pattern", but have non-zero "Size".
 ## In this case we emit Size number of zeroes to the output.
 
 # RUN: yaml2obj --docnum=8 2>&1 -o %t8 %s
 # RUN: llvm-readelf --sections %t8 | FileCheck %s --check-prefix=EMPTY-PATTERN
 
 ## The fill we dump starts at (offset of .strtab - 1 - 3 - 1), which is (0x45 - 5) = 0x40.
 # RUN: od -t x1 -v -j 0x40 -N 5 %t8 | FileCheck %s --ignore-case --check-prefix=EMPTY-PATTERN-DATA
 
 # EMPTY-PATTERN:      Section Headers:
 # EMPTY-PATTERN-NEXT:  [Nr] Name    Type   Address          Off    Size   ES Flg Lk Inf Al
 # EMPTY-PATTERN-NEXT:  [ 0]         NULL   0000000000000000 000000 000000 00     0   0  0
 # EMPTY-PATTERN-NEXT:  [ 1] .strtab STRTAB 0000000000000000 000045 000001 00     0   0  1
 
 # EMPTY-PATTERN-DATA: aa 00 00 00 bb
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Pattern: "AA"
     Size:    0x1
   - Type:    Fill
     Size:    3
     Pattern: ""
   - Type:    Fill
     Pattern: "BB"
     Size:    0x1
 
 ## Check that "Size" can't be 0, when "Pattern" is not empty.
 # RUN: not yaml2obj --docnum=9 2>&1 %s | FileCheck %s --check-prefix=ZERO-SIZE-ERR
 
 # ZERO-SIZE-ERR: error: "Size" can't be 0 when "Pattern" is not empty
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Pattern: "00"
     Size:    0
 
 ## Check we report an error when a program header references
 ## an unknown section or fill and have at least one Fill defined.
 
 # RUN: not yaml2obj --docnum=10 2>&1 %s | FileCheck %s --check-prefix=UNKNOWN-ERR
 # UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by program header
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Type:    Fill
     Pattern: ""
     Size:    0
 ProgramHeaders:
   - Type: PT_LOAD
     Sections:
       - Section: fill

llvm/test/tools/yaml2obj/ELF/custom-null-section.yaml

 ## In this test we check that can redefine the null section in the YAML.
 
 ## Test the default output first.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --sections %t1 | FileCheck %s --check-prefix=DEFAULT
 
 # DEFAULT:      Section Headers:
 # DEFAULT-NEXT:  [Nr] Name      Type   Address          Off    Size   ES Flg Lk Inf Al
 # DEFAULT-NEXT:  [ 0]           NULL   0000000000000000 000000 000000 00 0   0  0
 # DEFAULT-NEXT:  [ 1] .strtab   STRTAB 0000000000000000 000040 000001 00 0   0  1
 # DEFAULT-NEXT:  [ 2] .shstrtab STRTAB 0000000000000000 000041 000013 00 0   0  1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 
 ## Now define a SHT_NULL section with fields all zeroed.
 ## In this case it is equal to the section created by default.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf --sections %t2 | FileCheck %s --check-prefix=DEFAULT
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type:         SHT_NULL
     Name:         ''
     Flags:        [ ]
     AddressAlign: 0x0
     Size:         0x0
     EntSize:      0x0
     Link:         0
     Info:         0
     Address:      0x0
 
 ## Check we can redefine fields of the first SHT_NULL section.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readelf --sections %t3 | FileCheck %s --check-prefix=REDEFINE
 
 # REDEFINE:      Section Headers:
 # REDEFINE-NEXT:  [Nr] Name Type Address          Off    Size   ES Flg Lk Inf Al
 # REDEFINE-NEXT:  [ 0] .foo NULL 0000000000000006 000000 000002 03   A 4   5  1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type:         SHT_NULL
     Name:         .foo
     Flags:        [ SHF_ALLOC ]
     AddressAlign: 0x1
     Size:         0x2
     EntSize:      0x3
     Link:         4
     Info:         5
     Address:      0x6
 
 ## Check that file size does not change if we redefine the Size
 ## of the first SHT_NULL section.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: ls -l %t3 | tr -s ' ' | cut -d ' ' -f 5 > %t.txt
 # RUN: ls -l %t4 | tr -s ' ' | cut -d ' ' -f 5 >> %t.txt
 # RUN: FileCheck %s --input-file=%t.txt --check-prefix=SIZE
 
 # SIZE: [[FILESIZE:.*]]
 # SIZE: [[FILESIZE]]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type:         SHT_NULL
     Name:         .foo
     Flags:        [ SHF_ALLOC ]
     AddressAlign: 0x1
     Size:         0xFFFF
     EntSize:      0x3
     Link:         4
     Info:         5
     Address:      0x6
 
 ## Check we are still able to describe other sections too.
 
 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: llvm-readelf --sections %t5 | FileCheck %s --check-prefix=OTHER-SECTION
 
 # OTHER-SECTION:      Section Headers:
 # OTHER-SECTION-NEXT:   [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
 # OTHER-SECTION-NEXT:   [ 0]           NULL     0000000000000000 000000 000000 00 0   0  0
 # OTHER-SECTION-NEXT:   [ 1] foo       PROGBITS 0000000000000000 000040 000000 00 0   0  0
 # OTHER-SECTION-NEXT:   [ 2] .strtab   STRTAB   0000000000000000 000040 000001 00 0   0  1
 # OTHER-SECTION-NEXT:   [ 3] .shstrtab STRTAB   0000000000000000 000041 000017 00 0   0  1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type:         SHT_NULL
     Name:         ''
     Flags:        [ ]
     AddressAlign: 0x0
     Size:         0x0
     EntSize:      0x0
     Link:         0
   - Type: SHT_PROGBITS
     Name: 'foo'
 
 ## Check we report an error if null section sh_link field refers to an unknown section.
 
 # RUN: not yaml2obj --docnum=6 %s -o %t6 2>&1 | FileCheck %s --check-prefix=CASE4
 
 # CASE4: error: unknown section referenced: '.foo' by YAML section ''
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type: SHT_NULL
     Link: .foo
 
 ## Check that null section fields are set to zero, if they are unspecified.
 
 # RUN: yaml2obj --docnum=7 %s -o %t7
 # RUN: llvm-readelf --sections %t7 | FileCheck %s --check-prefix=DEFAULT
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type: SHT_NULL
 
 ## Check we do not crash if we have more than one SHT_NULL section.
 
 # RUN: yaml2obj --docnum=8 %s -o %t8
 # RUN: llvm-readelf --sections %t8 | FileCheck %s --check-prefix=MULTIPLE
 
 # MULTIPLE:      Section Headers:
 # MULTIPLE-NEXT:  [Nr] Name Type Address          Off    Size   ES Flg Lk Inf Al
 # MULTIPLE-NEXT:  [ 0]      NULL 0000000000000000 000000 000000 00 0   0  0
 # MULTIPLE-NEXT:  [ 1] .foo NULL 0000000000000123 000040 000020 10 A   1  2   0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type: SHT_NULL
   - Type:    SHT_NULL
     Name:    .foo
     Flags:   [ SHF_ALLOC ]
     Size:    0x20
     EntSize: 0x10
     Link:    1
     Info:    2
     Address: 0x123
 
 ## Check we can override the sh_offset/sh_size fields of the first SHT_NULL section if requested.
 
 # RUN: yaml2obj --docnum=9 %s -o %t9
 # RUN: llvm-readelf --sections %t9 | FileCheck %s --check-prefix=OVERRIDE
 
 # OVERRIDE:      Section Headers:
 # OVERRIDE-NEXT:  [Nr] Name Type Address          Off    Size   ES Flg Lk Inf Al
 # OVERRIDE-NEXT:  [ 0]      NULL 0000000000000000 000007 000008 00   0 0  0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type:     SHT_NULL
     Size:     0x2
     ShOffset: 0x7
     ShSize:   0x8

llvm/test/tools/yaml2obj/ELF/duplicate-section-names.yaml

- Name: .group
     Members:
       - SectionOrType: GRP_COMDAT
       - SectionOrType: .text.foo
   - Name: .text.foo
     Type: SHT_PROGBITS
   - Name: '.group [1]'
     Type: SHT_GROUP
     Info: 'foo [1]'
-    Members:         
+    Members:
       - SectionOrType: GRP_COMDAT
       - SectionOrType: '.text.foo [1]'
   - Name: '.text.foo [1]'
     Type: SHT_PROGBITS
 Symbols:
   - Name:    foo
     Section: .text.foo
   - Name:    'foo [1]'
     Section: '.text.foo [1]'

llvm/test/tools/yaml2obj/ELF/duplicate-symbol-names.yaml

 ## Check that yaml2obj is able to produce an object from YAML
 ## containing symbols with duplicate names (but different name suffixes).
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj -t %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1: Name: localfoo (1)
 # CASE1: Name: localfoo (1)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name: localfoo
   - Name: 'localfoo [1]'
 
 ## Check that yaml2obj reports an error when we have
 ## symbols with equal names and suffixes.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1| FileCheck %s --check-prefix=CASE2
 # CASE2-COUNT-2: error: repeated symbol name: 'localfoo [1]'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name: 'localfoo [1]'
   - Name: 'localfoo [1]'
   - Name: 'localfoo [1]'
 
 ## Check that yaml2obj reports an error when we have
 ## symbols without suffixes in the names and their
 ## names are equal.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1| FileCheck %s --check-prefix=CASE3
 # CASE3: error: repeated symbol name: 'localfoo'
 # CASE3: error: repeated symbol name: 'localfoo'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name: localfoo
   - Name: localfoo
   - Name: localfoo
 
 ## Check that yaml2obj can produce correct relocations that
 ## reference symbols with name suffixes.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj -r --expand-relocs %t4 | FileCheck %s --check-prefix=CASE4
 
 # CASE4:      Relocations [
 # CASE4-NEXT:   Section {{.*}} .rela.text {
 # CASE4-NEXT:     Relocation {
 # CASE4-NEXT:       Offset: 0x0
 # CASE4-NEXT:       Type: R_X86_64_NONE
 # CASE4-NEXT:       Symbol: foo (1)
 # CASE4-NEXT:       Addend: 0x0
 # CASE4-NEXT:     }
 # CASE4-NEXT:     Relocation {
 # CASE4-NEXT:       Offset: 0x1
 # CASE4-NEXT:       Type: R_X86_64_NONE
 # CASE4-NEXT:       Symbol: foo (2)
 # CASE4-NEXT:       Addend: 0x0
 # CASE4-NEXT:     }
 # CASE4-NEXT:   }
 # CASE4-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .text
     Type: SHT_PROGBITS
   - Name: .rela.text
     Type: SHT_RELA
     Info: .text
     Link: .symtab
     Relocations:
       - Offset: 0x0
         Type:   R_X86_64_NONE
         Symbol: foo
       - Offset: 0x1
         Type:   R_X86_64_NONE
         Symbol: 'foo [1]'
 Symbols:
   - Name: foo
   - Name: 'foo [1]'

llvm/test/tools/yaml2obj/ELF/dynamic-relocations.yaml

 ## Show that yaml2obj uses the correct set of symbols for relocation sections
 ## referencing the dynamic symbol table.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf -r %t | FileCheck %s
 
 # CHECK:      Relocation section '.rela.dyn' at offset {{.*}} contains 2 entries:
 # CHECK-NEXT:     Offset             Info             Type      Symbol's Value  Symbol's Name
 # CHECK-NEXT: 0000000000000000  0000000100000000 R_X86_64_NONE 0000000012345678 dynamic
 # CHECK-NEXT: 0000000000000008  0000000200000000 R_X86_64_NONE 0000000087654321 both
 # CHECK-EMPTY:
 # CHECK-NEXT: Relocation section '.rela.data' at offset {{.*}} contains 2 entries:
 # CHECK-NEXT:     Offset             Info             Type      Symbol's Value  Symbol's Name
 # CHECK-NEXT: 0000000000000010  0000000200000000 R_X86_64_NONE 0000000011223344 static
 # CHECK-NEXT: 0000000000000018  0000000100000000 R_X86_64_NONE 0000000088776655 both
 
 !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .data
     Type: SHT_PROGBITS
   - Name: .rela.dyn
     Type: SHT_REL
     Link: .dynsym
     Info: .data
     Relocations:
       - Offset: 0
         Type: R_X86_64_NONE
         Symbol: dynamic
       - Offset: 8
         Type: R_X86_64_NONE
         Symbol: both
   - Name: .rela.data
     Type: SHT_REL
     Link: .symtab
     Info: .data
     Relocations:
       - Offset: 16
         Type: R_X86_64_NONE
         Symbol: static
       - Offset: 24
         Type: R_X86_64_NONE
         Symbol: both
 Symbols:
     - Name: both
       Section: .data
       Value: 0x88776655
       Binding: STB_GLOBAL
     - Name: static
       Section: .data
       Value: 0x11223344
       Binding: STB_GLOBAL
 DynamicSymbols:
     - Name: dynamic
       Section: .data
       Value: 0x12345678
       Binding: STB_GLOBAL
     - Name: both
       Section: .data
       Value: 0x87654321
       Binding: STB_GLOBAL

llvm/test/tools/yaml2obj/ELF/dynamic-section-i386.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj %t --dynamic-table | FileCheck %s
 
 ## Check we write a valid .dynamic section values when emiting a 32-bit object.
 
 # CHECK:      DynamicSection [ (2 entries)
 # CHECK-NEXT:   Tag        Type                 Name/Value
 # CHECK-NEXT:   0x0000000A STRSZ                1 (bytes)
 # CHECK-NEXT:   0x00000000 NULL                 0x0
 # CHECK-NEXT: ]
 
 !ELF
 FileHeader:
   Class:           ELFCLASS32
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_386
 Sections:
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000000008
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_STRSZ
         Value:           0x0000000000000001
       - Tag:             DT_NULL
         Value:           0x0000000000000000
 ProgramHeaders:
   - Type: PT_LOAD
     Flags: [ PF_R ]
     VAddr: 0x0000
     PAddr: 0x0000
     Align: 8
     Sections:
       - Section: .dynamic
   - Type: PT_DYNAMIC
     Flags: [ PF_X, PF_R ]
     VAddr: 0x0008
     PAddr: 0x0008
     Sections:
       - Section: .dynamic

llvm/test/tools/yaml2obj/ELF/dynamic-section-raw-content.yaml

-# Show that yaml2obj can handle a dynamic section with raw content instead of
-# entries. Also show that it rejects raw content when entries are also provided.
+## Show that yaml2obj can handle a dynamic section with raw content instead of
+## entries. Also show that it rejects raw content when entries are also provided.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj -x .dynamic --sections %t1 | FileCheck %s --check-prefix=RAW
 
 # RAW:      Name: .dynamic
 # RAW-NEXT: Type: SHT_DYNAMIC
 # RAW-NEXT: Flags [
 # RAW-NEXT: ]

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

-# Ensures that dynamic section has sh_entsize correctly set
+## Ensures that dynamic section has sh_entsize correctly set.
+
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=SECTION
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Flags: [ SHF_ALLOC, SHF_WRITE ]
 
 # SECTION: Name: .dynamic
 # SECTION: EntrySize: 16

llvm/test/tools/yaml2obj/ELF/dynamic-symbols.yaml

 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj --dyn-symbols %t2 2>&1 | FileCheck -DFILE=%t2 %s --check-prefix=NUM
 
 # NUM:      Name: foo
 # NUM:      Section:
 # NUM-SAME: .data (0x1)
 
 # NUM:      Name: bar
-# NUM:      Section: 
+# NUM:      Section:
 # NUM-SAME: .strtab (0x2)
 
 # NUM:      Name: zed
 # NUM: warning: '[[FILE]]': invalid section index: 255
-# NUM:      Section: 
+# NUM:      Section:
 # NUM-SAME: <?> (0xFF)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64

llvm/test/tools/yaml2obj/ELF/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 for .dynsym.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --implicit-check-not=error --check-prefix=CASE2
 
 # CASE2: yaml2obj: 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
   - Name: .dynsym2
     Type: SHT_DYNSYM
     Size: 0x100
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
 
 ## Specifying both `Content` and symbols at the same time is not allowed for .dynsym.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --implicit-check-not=error --check-prefix=CASE3
 
 # CASE3: yaml2obj: 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"
   - Name: .dynsym2
     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: 0x40
 # CASE4-NEXT: Size: 2
 # CASE4-NEXT: Link: 0
 # CASE4-NEXT: Info: 1
 # 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"
 
 ## 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: 0x40
 # CASE5-NEXT: Size: 5
 # CASE5-NEXT: Link: 0
 # CASE5-NEXT: Info: 1
 # 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
 
 ## 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: 0x40
 # CASE6-NEXT: Size: 4
 # CASE6-NEXT: Link: 0
 # CASE6-NEXT: Info: 1
 # 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
 
 ## 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: 0x40
 # CASE7-NEXT:  Size: 2
 # CASE7-NEXT:  Link: 0
 # CASE7-NEXT:  Info: 1
 # 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

llvm/test/tools/yaml2obj/ELF/dynsymtab-shlink.yaml

 ## For implicit dynamic symbol table sections, `Link` field can also
 ## be specified in YAML. Here we test the behavior in different cases.
 
 ## Check we are able to set Link = 0 for .dynsym explicitly.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj %t1 -S | FileCheck %s --check-prefix=CASE1
 
 # CASE1: Name: .dynsym
 # CASE1: Link:
 # CASE1-SAME: 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
     Link: 0
 
 ## Check that by default .dynsym will be linked to .dynstr
 ## if the latter exists.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj %t2 -S | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      .dynsym
 # CASE2:      Link:
 # CASE2-SAME: 2
 # CASE2:      Index: 2
 # CASE2-NEXT: Name: .dynstr
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
   - Name: .dynstr
     Type: SHT_STRTAB
 
 ## Even if .dynstr exists, we can explicitly link .dynsym
 ## to another section.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readobj %t3 -S | FileCheck %s --check-prefix=CASE3
 
 # CASE3:      .dynsym
 # CASE3:      Link:
 # CASE3-SAME: 3
 # CASE3:      Index: 3
 # CASE3-NEXT: Name: .foo
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
     Link: 3
   - Name: .dynstr
     Type: SHT_STRTAB
   - Name: .foo
     Type: SHT_PROGBITS
 
 ## Check we can use a section name as a Link value for .dynsym.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj %t4 -S | FileCheck %s --check-prefix=CASE4
 
 # CASE4:      .dynsym
 # CASE4:      Link:
 # CASE4-SAME: 2
 # CASE4:      Index: 2
 # CASE4-NEXT: Name: .foo
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
     Link: .foo
   - Name: .foo
     Type: SHT_PROGBITS

llvm/test/tools/yaml2obj/ELF/emachine.yaml

 ## Test how the Machine YAML field can be used to set the e_machine ELF header field.
 
 ## Test we can use an arbitrary value.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf %t1 --file-headers | FileCheck %s --check-prefix=UNKNOWN
 
 # UNKNOWN: Machine: 1234
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: 0x1234
 
 ## Test we can't use a number that doesn't fit into 2 bytes.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=ERR
 
 # ERR: error: out of range hex16 number
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: 0x12345
 
 ## Test we can use a known named constant.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readelf %t3 --file-headers | FileCheck %s --check-prefix=NONE
 
 # NONE: Machine: None
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: EM_NONE
 
 ## Test we can't use an unknown string constant.
 
 # RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=ERR2
 
 # ERR2: error: invalid hex16 number
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: EM_UNKNOWN_FOO

llvm/test/tools/yaml2obj/ELF/empty-symbols.yaml

+## Ensure yaml2obj doesn't error on empty optional mappings, such as Symbols
+# RUN: yaml2obj %s -o /dev/null
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+# We usually express this as `Symbols: []` but we are testing omitted value here.
+Symbols:

llvm/test/tools/yaml2obj/ELF/ent-size.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   OSABI:           ELFOSABI_FREEBSD
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Type:            SHT_PROGBITS
     Name:            .strings
     Flags:           [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
     AddressAlign:    0x04
     Content:         "FFFFFFFFFFFFFFFF"
     EntSize:         0x1
   - Name:            .mydynamic
     Type:            SHT_DYNAMIC
     EntSize:         0x0
 
 
 ## Check we were able to set entry size for .strings and .mydynamic
 # CHECK:       Name: .strings
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:     SHF_MERGE
 # CHECK-NEXT:     SHF_STRINGS
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Address:
 # CHECK-NEXT:   Offset:
 # CHECK-NEXT:   Size:
 # CHECK-NEXT:   Link:
 # CHECK-NEXT:   Info:
 # CHECK-NEXT:   AddressAlignment:
 # CHECK-NEXT:   EntrySize: 1
 # CHECK-NEXT: }
 # CHECK:        Name: .mydynamic
 # CHECK-NEXT:   Type: SHT_DYNAMIC
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Address:
 # CHECK-NEXT:   Offset:
 # CHECK-NEXT:   Size:
 # CHECK-NEXT:   Link:
 # CHECK-NEXT:   Info:
 # CHECK-NEXT:   AddressAlignment:
 # CHECK-NEXT:   EntrySize: 0
 # CHECK-NEXT: }

llvm/test/tools/yaml2obj/ELF/explicit-dynsym-no-dynstr.yaml

 ## Check we do not crash/assert when .dynsym is specified
 ## explicitly, but .dynstr is not present.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf --section-headers %t | FileCheck %s
 
 ## Check that .dynsym has Link field set to 0.
 
 # CHECK:      Section Headers:
 # CHECK-NEXT:  [Nr] Name    Type   Address          Off    Size   ES Flg Lk
 # CHECK-NEXT:  [ 0]         NULL   0000000000000000 000000 000000 00 0   0
 # CHECK-NEXT:  [ 1] .dynsym DYNSYM 0000000000000000 000040 000018 18 A   0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM

llvm/test/tools/yaml2obj/ELF/gnu-hash-section.yaml

 ## Check how yaml2obj produces SHT_GNU_HASH sections.
 
 ## Check we can describe a SHT_GNU_HASH section using the "Content" tag.
 ## Check we set sh_link to index of the .dynsym by default.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Name: .gnu.hash
 # CONTENT-NEXT: Type: SHT_GNU_HASH
 # CONTENT-NEXT: Flags [
 # CONTENT-NEXT: ]
 # CONTENT-NEXT: Address: 0x0
 # CONTENT-NEXT: Offset: 0x40
 # CONTENT-NEXT: Size: 3
 # CONTENT-NEXT: Link: 4
 # CONTENT-NEXT: Info: 0
 # CONTENT-NEXT: AddressAlignment: 0
 # CONTENT-NEXT: EntrySize: 0
 # CONTENT-NEXT: SectionData (
 # CONTENT-NEXT:   0000: 001122 |
 # CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Content: "001122"
 ## Used to trigger .dynsym creation.
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
 
 ## Check we can use "Header", "BloomFilter", "HashBuckets" and "HashValues" keys to describe
 ## the hash section. Check we can set sh_link to any arbitrary value. Check both ELFCLASS32 and 64 bit output.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=CONTENT32
 # RUN: llvm-readobj --sections --section-data %t3 | FileCheck %s --check-prefix=CONTENT64
 
 # CONTENT32:      Name: .gnu.hash
 # CONTENT32-NEXT: Type: SHT_GNU_HASH
 # CONTENT32-NEXT: Flags [
 # CONTENT32-NEXT:   SHF_ALLOC
 # CONTENT32-NEXT: ]
 # CONTENT32-NEXT: Address: 0x0
 # CONTENT32-NEXT: Offset: 0x34
 # CONTENT32-NEXT: Size: 52
 # CONTENT32-NEXT: Link: 254
 # CONTENT32-NEXT: Info: 0
 # CONTENT32-NEXT: AddressAlignment: 0
 # CONTENT32-NEXT: EntrySize: 0
 # CONTENT32-NEXT: SectionData (
 # CONTENT32-NEXT:   0000: 03000000 01000000 02000000 02000000 |
 # CONTENT32-NEXT:   0010: 03000000 04000000 05000000 06000000 |
 # CONTENT32-NEXT:   0020: 07000000 08000000 09000000 0A000000 |
 # CONTENT32-NEXT:   0030: 0B000000                            |
 # CONTENT32-NEXT: )
 
 # CONTENT64:      Name: .gnu.hash
 # CONTENT64-NEXT: Type: SHT_GNU_HASH
 # CONTENT64-NEXT: Flags [
 # CONTENT64-NEXT:   SHF_ALLOC
 # CONTENT64-NEXT: ]
 # CONTENT64-NEXT: Address: 0x0
 # CONTENT64-NEXT: Offset: 0x40
 # CONTENT64-NEXT: Size: 60
 # CONTENT64-NEXT: Link: 254
 # CONTENT64-NEXT: Info: 0
 # CONTENT64-NEXT: AddressAlignment: 0
 # CONTENT64-NEXT: EntrySize: 0
 # CONTENT64-NEXT: SectionData (
 # CONTENT64-NEXT:   0000: 03000000 01000000 02000000 02000000 |
 # CONTENT64-NEXT:   0010: 03000000 00000000 04000000 00000000 |
 # CONTENT64-NEXT:   0020: 05000000 06000000 07000000 08000000 |
 # CONTENT64-NEXT:   0030: 09000000 0A000000 0B000000          |
 # CONTENT64-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x1
       Shift2: 0x2
     BloomFilter: [0x3, 0x4]
     HashBuckets: [0x5, 0x6, 0x7]
     HashValues:  [0x8, 0x9, 0xA, 0xB]
     Link: 0xFE
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x1
       Shift2: 0x2
     BloomFilter: [0x3, 0x4]
     HashBuckets: [0x5, 0x6, 0x7]
     HashValues:  [0x8, 0x9, 0xA, 0xB]
     Link: 0xFE
 
 ## Check we only can use "Header", "BloomFilter", "HashBuckets" and "HashValues" together.
 
 # RUN: not yaml2obj --docnum=4 %s -o %t4 2>&1 | FileCheck %s --check-prefix=ERR
 # RUN: not yaml2obj --docnum=5 %s -o %t5 2>&1 | FileCheck %s --check-prefix=ERR
 # RUN: not yaml2obj --docnum=6 %s -o %t6 2>&1 | FileCheck %s --check-prefix=ERR
 # RUN: not yaml2obj --docnum=7 %s -o %t7 2>&1 | FileCheck %s --check-prefix=ERR
 
 # ERR: error: "Header", "BloomFilter", "HashBuckets" and "HashValues" must be used together
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash.no.header
     Type:  SHT_GNU_HASH
     BloomFilter: []
     HashBuckets: []
     HashValues: []
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash.no.bloomfilter
     Type:  SHT_GNU_HASH
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     HashBuckets: []
     HashValues: []
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash.no.nobuckets
     Type:  SHT_GNU_HASH
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: []
     HashValues: []
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash.no.novalues
     Type:  SHT_GNU_HASH
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: []
     HashBuckets: []
 
 ## Check that "SymNdx" and "Shift2" fields are mandatory when we specify the "Header".
 
 # RUN: not yaml2obj --docnum=8 %s -o %t8 2>&1 | FileCheck %s --check-prefix=ERR2
 # ERR2: error: missing required key 'SymNdx'
 
 # RUN: not yaml2obj --docnum=9 %s -o %t9 2>&1 | FileCheck %s --check-prefix=ERR3
 # ERR3: error: missing required key 'Shift2'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Header:
       Shift2: 0x0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Header:
       SymNdx: 0x0
 
 ## Either "Content" or "Header", "BloomFilter", "HashBuckets" and "HashBuckets" must be
 ## specified when declaring a SHT_GNU_HASH section.
 
 # RUN: not yaml2obj --docnum=10 %s -o %t10 2>&1 | FileCheck %s --check-prefix=NOKEYS
 
 # NOKEYS: error: either "Content" or "Header", "BloomFilter", "HashBuckets" and "HashBuckets" must be specified
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
 
 ## Test that "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with "Content".
 
 # RUN: not yaml2obj --docnum=11 %s -o %t11 2>&1 | FileCheck %s --check-prefix=TOGETHER
 
 # TOGETHER: error: "Header", "BloomFilter", "HashBuckets" and "HashValues" can't be used together with "Content"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Content: ""
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: []
     HashBuckets: []
     HashValues:  []
 
 ## Test we can override the number of buckets and the number of words in the Bloom filter
 ## using the "NBuckets" and "Shift2" keys.
 
 # RUN: yaml2obj --docnum=12 %s -o %t12
 # RUN: llvm-readobj --sections --section-data %t12 | FileCheck %s --check-prefix=OVERRIDE-CONTENT
 
 # OVERRIDE-CONTENT:      Name: .gnu.hash
 # OVERRIDE-CONTENT:      SectionData (
 # OVERRIDE-CONTENT-NEXT:   0000: 01000000 02000000 03000000 04000000  |
 # OVERRIDE-CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
 Sections:
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Header:
       NBuckets:  0x1
       SymNdx:    0x2
       MaskWords: 0x3
       Shift2:    0x4
     BloomFilter: []
     HashBuckets: []
     HashValues:  []

llvm/test/tools/yaml2obj/ELF/gnu-unique-symbols.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --symbols %t | FileCheck %s
 
 ## Check yaml2obj is able to create the STB_GNU_UNIQUE symbol.
 
 # CHECK:        Name: foo
 # CHECK-NEXT:   Value:
 # CHECK-NEXT:   Size:
 # CHECK-NEXT:   Binding: Unique
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   OSABI:     ELFOSABI_GNU
   Type:      ET_REL
   Machine:   EM_X86_64
 Symbols:
   - Name:    foo
     Type:    STT_OBJECT
     Binding: STB_GNU_UNIQUE

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

 ## Check how yaml2obj produces SHT_HASH sections.
 
 ## Check we can describe a SHT_HASH section using the "Content" tag.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Name: .hash
 # CONTENT-NEXT: Type: SHT_HASH
 # CONTENT-NEXT: Flags [
 # CONTENT-NEXT: ]
 # CONTENT-NEXT: Address: 0x0
 # CONTENT-NEXT: Offset: 0x44
 # CONTENT-NEXT: Size: 20
 # CONTENT-NEXT: Link: 1
 # CONTENT-NEXT: Info: 0
 # CONTENT-NEXT: AddressAlignment: 0
 # CONTENT-NEXT: EntrySize: 0
 # CONTENT-NEXT: SectionData (
 # CONTENT-NEXT:   0000: 01000000 02000000 03000000 04000000
 # CONTENT-NEXT:   0010: 05000000
 # CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
 ## SHT_HASH is linked to dynamic symbol table by default.
   - Name: .dynsym
     Type: SHT_DYNSYM
   - Name:    .hash
     Type:    SHT_HASH
     Content: '0100000002000000030000000400000005000000'
 
 ## Check we can describe a SHT_HASH section using "Bucket" and "Chain" tags.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj --sections --section-data %t2 | FileCheck %s --check-prefix=BUCKET-CHAIN
 
 # BUCKET-CHAIN:      Name: .hash
 # BUCKET-CHAIN:      Size:
 # BUCKET-CHAIN-SAME: 28
 # BUCKET-CHAIN:      Link:
 # BUCKET-CHAIN-SAME: 0
 # BUCKET-CHAIN:      SectionData (
 # BUCKET-CHAIN-NEXT:   0000: 02000000 03000000 01000000 02000000  |
 # BUCKET-CHAIN-NEXT:   0010: 03000000 04000000 05000000           |
 # BUCKET-CHAIN-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:   .hash
     Type:   SHT_HASH
     Bucket: [ 1, 2 ]
     Chain:  [ 3, 4, 5 ]
 
 ## Check we can't use "Content" and "Bucket" tags together.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-BUCKET
 
 # CONTENT-BUCKET: "Bucket" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:   .hash
     Type:   SHT_HASH
     Bucket: [ 1 ]
     Content: '00'
 
 ## Check we can't use "Content" and "Chain" tags together.
 
 # RUN: not yaml2obj --docnum=4 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-CHAIN
 
 # CONTENT-CHAIN: "Chain" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:   .hash
     Type:   SHT_HASH
     Chain:  [ 1 ]
     Content: '00'
 
 ## Check we can't use "Bucket" without "Chain".
 
 # RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=NO-BUCKET-OR-CHAIN
 
 # NO-BUCKET-OR-CHAIN: error: "Bucket" and "Chain" must be used together
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:   .hash
     Type:   SHT_HASH
     Bucket: [ 1 ]
 
 ## Check we can't use "Chain" without "Bucket".
 
 # RUN: not yaml2obj --docnum=6 %s 2>&1 | FileCheck %s --check-prefix=NO-BUCKET-OR-CHAIN
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:  .hash
     Type:  SHT_HASH
     Chain: [ 1 ]
 
 ## Check we report an error if neither "Bucket", "Chain" nor "Content" were set.
 
 # RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
 
 # NO-TAGS: error: one of "Content", "Size", "Bucket" or "Chain" must be specified
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:  .hash
     Type:  SHT_HASH
 
 ## Check we can set any sh_link value with use of the "Link" tag.
 
 # RUN: yaml2obj --docnum=8 %s -o %t8
 # RUN: llvm-readobj --sections %t8 | FileCheck %s --check-prefix=LINK
 
 # LINK:      Name: .hash1
 # LINK:      Link:
 # LINK-SAME: 123
 
 # LINK:      Name: .hash2
 # LINK:      Link:
 # LINK-SAME: 1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name: .hash1
     Type: SHT_HASH
     Content: ""
     Link: 123
   - Name: .hash2
     Type: SHT_HASH
     Content: ""
     Link: .hash1
 ## SHT_HASH is linked to dynamic symbol table by default if it exists.
   - Name: .dynsym
     Type: SHT_DYNSYM
 
 ## Check we can use only "Size" to create a SHT_HASH section.
 
 # RUN: yaml2obj --docnum=9 %s -o %t9
 # RUN: llvm-readobj --sections --section-data %t9 | FileCheck %s --check-prefix=SIZE
 
 # SIZE:      Name: .hash
 # 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: .hash
     Type: SHT_HASH
     Size: 0x11
 
 ## Check we can use "Size" and "Content" together to create a SHT_HASH section.
 
 # RUN: yaml2obj --docnum=10 %s -o %t10
 # RUN: llvm-readobj --sections --section-data %t10 | FileCheck %s --check-prefix=SIZE-CONTENT
 
 # SIZE-CONTENT:      Name: .hash
 # 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: .hash
     Type: SHT_HASH
     Size: 0x5
     Content: "112233"
 
 ## Check that when "Size" and "Content" are used together, the size
 ## must be greater than or equal to the content size.
 
 # RUN: not yaml2obj --docnum=11 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
 
 # SIZE-CONTENT-ERR: error: "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: .hash
     Type: SHT_HASH
     Size: 0x1
     Content: "1122"
 
 ## Check we can't use "Size" and "Bucket" tags together.
 
 # RUN: not yaml2obj --docnum=12 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-BUCKET
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .hash
     Type: SHT_HASH
     Size: 0x1
     Bucket: [ 1 ]
 
 ## Check we can't use "Size" and "Chain" tags together.
 
 # RUN: not yaml2obj --docnum=13 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-CHAIN
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .hash
     Type: SHT_HASH
     Size: 0x1
     Chain: [ 1 ]

llvm/test/tools/yaml2obj/ELF/header-elfdatanone.yaml

 ## We have a YAML file describing an invalid data type.
 ## Check we are able to produce the invalid binary.
 
 # RUN: yaml2obj %s -o %t.o
 
 ## Check that EI_DATA field is ELFDATANONE(0)
 # RUN:   od -b %t.o +5 | FileCheck %s
 # CHECK: 0000005 000
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATANONE
   Type:            ET_REL
   Machine:         EM_X86_64

llvm/test/tools/yaml2obj/ELF/header-sh-fields.yaml

 ## In this test case we check that we can override the default values for
 ## e_shentsize, e_shoff, e_shnum and e_shstrndx fields in the YAML.
 
 ## First we check the default values.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --file-headers %t1 | FileCheck %s --check-prefix=DEFAULT
 
 # DEFAULT:   Start of section headers:          88 (bytes into file)
 # DEFAULT:   Size of section headers:           64 (bytes)
 # DEFAULT:   Number of section headers:         3
 # DEFAULT:   Section header string table index: 2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 
 ## Override 3 fields: e_shoff, e_shnum and e_shstrndx. Check the output.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf --file-headers %t2 | FileCheck %s --check-prefix=CUSTOM
 
 # CUSTOM: Start of section headers:          2 (bytes into file)
 # CUSTOM: Size of section headers:           64 (bytes)
 # CUSTOM: Number of section headers:         3
 # CUSTOM: Section header string table index: 4
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
   SHEntSize: 64
   SHOff:     2
   SHNum:     3
   SHStrNdx:  4
 
 ## Finally, we use the same YAML as above, but set e_shentsize to 1.
 ## Check the result using raw output from 'od' because llvm-readelf
 ## is unable to dump such headers.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: od -A n -t x1 -v -j 0x3a -N 1 %t3 | FileCheck %s --check-prefix=NEWSIZE
 # RUN: od -A n -t x1 -v -j 0x3a -N 1 %t2 | FileCheck %s --check-prefix=OLDSIZE
 # NEWSIZE: 01
 # OLDSIZE: 40
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
   SHEntSize: 1
   SHOff:     2
   SHNum:     3
   SHStrNdx:  4

llvm/test/tools/yaml2obj/ELF/implicit-sections-addr.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s
 
 ## Check yaml2obj does not ignore the address of the
 ## explicitly listed .dynstr, .dynsym, .strtab
 ## and .symtab sections.
 
 # CHECK:      Name: .dynstr
 # CHECK-NEXT: Type: SHT_STRTAB
 # CHECK-NEXT: Flags [
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address: 0x1000
 
 # CHECK:      Name: .dynsym
 # CHECK-NEXT:  Type: SHT_DYNSYM
 # CHECK-NEXT:  Flags [
 # CHECK-NEXT:    SHF_ALLOC
 # CHECK-NEXT:  ]
 # CHECK-NEXT:  Address: 0x2000
 
 # CHECK:      Name: .strtab
 # CHECK-NEXT:  Type: SHT_STRTAB
 # CHECK-NEXT:  Flags [
 # CHECK-NEXT:  ]
 # CHECK-NEXT:  Address: 0x3000
 
 # CHECK:      Name: .symtab
 # CHECK-NEXT:  Type: SHT_SYMTAB
 # CHECK-NEXT:  Flags [
 # CHECK-NEXT:  ]
 # CHECK-NEXT:  Address: 0x4000
 
 !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Flags:   [ SHF_ALLOC ]
     Address: 0x1000
   - Name:    .dynsym
     Type:    SHT_DYNSYM
     Flags:   [ SHF_ALLOC ]
     Address: 0x2000
   - Name:    .strtab
     Type:    SHT_STRTAB
     Address: 0x3000
   - Name:    .symtab
     Type:    SHT_SYMTAB
     Address: 0x4000
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL

llvm/test/tools/yaml2obj/ELF/implicit-sections-info.yaml

 ## Check the values of sh_info fields set by default for
 ## explicitly listed .dynstr, .dynsym, .strtab and .symtab
 ## sections.
 ##
 ## For symbol table sections, sh_info has a value which is
 ## one greater than the symbol table index of the last
 ## local symbol.
 ##
 ## sh_info isn't set for string table sections.
 
 # RUN: yaml2obj --docnum=1 %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      Name: .symtab
 # CASE1:      Info:
 # CASE1-SAME: 2
 # CASE1:      Name: .strtab
 # CASE1:      Info:
 # CASE1-SAME: 0
 # CASE1:      Name: .dynsym
 # CASE1:      Info:
 # CASE1-SAME: 1
 # CASE1:      Name: .dynstr
 # CASE1:      Info:
 # CASE1-SAME: 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .symtab
     Type:  SHT_SYMTAB
   - Name:  .strtab
     Type:  SHT_STRTAB
   - Name:  .dynsym
     Type:  SHT_DYNSYM
   - Name:  .dynstr
     Type:  SHT_STRTAB
 Symbols:
   - Name:    local
   - Name:    global1
     Binding: STB_GLOBAL
 DynamicSymbols:
   - Name:    global2
     Binding: STB_GLOBAL
 
 ## In the case when these sections are not defined in YAML, the
 ## behavior is the same as when we define them, but do not set the Info.
 
 # RUN: yaml2obj --docnum=2 %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=CASE1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Symbols:
   - Name:    local
   - Name:    global1
     Binding: STB_GLOBAL
 DynamicSymbols:
   - Name:    global2
     Binding: STB_GLOBAL
 
 ## Check we are able to set any sh_info explicitly.
 
 # RUN: yaml2obj --docnum=3 %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Name: .dynstr
 # CASE2:      Info:
 # CASE2-SAME: 10
 # CASE2:      Name: .dynsym
 # CASE2:      Info:
 # CASE2-SAME: 11
 # CASE2:      Name: .strtab
 # CASE2:      Info:
 # CASE2-SAME: 12
 # CASE2:      Name: .symtab
 # CASE2:      Info:
 # CASE2-SAME: 13
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .dynstr
     Type:  SHT_STRTAB
     Info:  10
   - Name:  .dynsym
     Type:  SHT_DYNSYM
     Info:  11
   - Name:  .strtab
     Type:  SHT_STRTAB
     Info:  12
   - Name:  .symtab
     Type:  SHT_SYMTAB
     Info:  13
 Symbols:
   - Name:    local
   - Name:    global1
     Binding: STB_GLOBAL
 DynamicSymbols:
   - Name:    global2
     Binding: STB_GLOBAL

llvm/test/tools/yaml2obj/ELF/implicit-sections-types.yaml

 ## Here we check the types set for implicit sections
 ## in different cases.
 
 ## Check the types set by default in case sections were implicitly
 ## added and not described in the YAML.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj -S %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      Name: .symtab
 # CASE1-NEXT: Type: SHT_SYMTAB
 # CASE1:      Name: .strtab
 # CASE1-NEXT: Type: SHT_STRTAB
 # CASE1:      Name: .shstrtab
 # CASE1-NEXT: Type: SHT_STRTAB
 # CASE1:      Name: .dynsym
 # CASE1-NEXT: Type: SHT_DYNSYM
 # CASE1:      Name: .dynstr
 # CASE1-NEXT: Type: SHT_STRTAB
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 ## Needed to force the creation of the .symtab.
 Symbols: []
 ## Needed to force the creation of the .dynsym and .dynstr.
 DynamicSymbols:
   - Name:    foo
   - Binding: STB_GLOBAL
 
 ## Check we can set any arbitrary types when describing sections
 ## that are usually implicit.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj -S %t2 | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Name: .symtab
 # CASE2-NEXT: Type: SHT_DYNAMIC
 # CASE2:      Name: .strtab
 # CASE2-NEXT: Type: SHT_RELA
 # CASE2:      Name: .shstrtab
 # CASE2-NEXT: Type: SHT_PROGBITS
 # CASE2:      Name: .dynsym
 # CASE2-NEXT: Type: SHT_NOTE
 # CASE2:      Name: .dynstr
 # CASE2-NEXT: Type: SHT_NOBITS
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_DYNAMIC
   - Name: .strtab
     Type: SHT_RELA
   - Name: .shstrtab
     Type: SHT_PROGBITS
   - Name: .dynsym
     Type: SHT_NOTE
     Size: 0
   - Name: .dynstr
     Type: SHT_NOBITS
 ## Needed to set the proper content size for .symtab, so
 ## that llvm-readobj can dump this section.
 Symbols:
   - Name: foo

llvm/test/tools/yaml2obj/ELF/implicit-sections.yaml

 ## Check the section header properties of ".dynsym",
 ## ".dynstr", ".symtab", ".strtab", ".shstrtab".
 ## These sections sections are usually added implicitly,
 ## but here we add them explicitly in YAML and verify.
 ## We check their order matches YAML and that file offset is
 ## ascending. This is a natural default behavior.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf -S %t1 | FileCheck %s
 
 # CHECK:      Section Headers:
 # CHECK-NEXT:  [Nr] Name      Type     Address          Off    Size
 # CHECK-NEXT:  [ 0]           NULL     0000000000000000 000000 000000
 # CHECK-NEXT:  [ 1] .dynstr   STRTAB   0000000000000100 000040 000009
 # CHECK-NEXT:  [ 2] .dynsym   DYNSYM   0000000000000150 000049 000030
 # CHECK-NEXT:  [ 3] .symtab   SYMTAB   0000000000000000 000079 000018
 # CHECK-NEXT:  [ 4] .strtab   STRTAB   0000000000000000 000091 000001
 # CHECK-NEXT:  [ 5] .shstrtab STRTAB   0000000000000000 000092 000035
 # CHECK-NEXT:  [ 6] .text.foo PROGBITS 0000000000000200 0000c7 000000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Address: 0x100
   - Name:    .dynsym
     Type:    SHT_DYNSYM
     Address: 0x150
   - Name:    .symtab
     Type:    SHT_SYMTAB
   - Name:    .strtab
     Type:    SHT_STRTAB
   - Name:    .shstrtab
     Type:    SHT_STRTAB
   - Name:    .text.foo
     Type:    SHT_PROGBITS
     Address: 0x200
 ## Symbol is required for the .dynsym to be generated.
 DynamicSymbols:
   - Name:    _Z3fooi
     Binding: STB_GLOBAL
 
 ## Check that yaml2obj creates empty .dynstr and .dynsym sections for
 ## the case when no dynamic symbols were specified and Content wasn't set,
 ## but the sections were explicitly listed. Check their VAs are correct.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf -S %t2 | FileCheck %s --check-prefix=NODYNSYM
 
 # NODYNSYM:      Section Headers:
 # NODYNSYM-NEXT: [Nr] Name      Type      Address          Off    Size
 # NODYNSYM-NEXT: [ 0]           NULL      0000000000000000 000000 000000
 # NODYNSYM-NEXT: [ 1] .dynstr   STRTAB    0000000000000100 000040 000001
 # NODYNSYM-NEXT: [ 2] .dynsym   DYNSYM    0000000000000150 000041 000018
 # NODYNSYM-NEXT: [ 3] .symtab   SYMTAB    0000000000000000 000059 000018
 # NODYNSYM-NEXT: [ 4] .strtab   STRTAB    0000000000000000 000071 000001
 # NODYNSYM-NEXT: [ 5] .shstrtab STRTAB    0000000000000000 000072 000035
 # NODYNSYM-NEXT: [ 6] .text.foo PROGBITS  0000000000000200 0000a7 000000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Address: 0x100
   - Name:    .dynsym
     Type:    SHT_DYNSYM
     Address: 0x150
   - Name:    .symtab
     Type:    SHT_SYMTAB
   - Name:    .strtab
     Type:    SHT_STRTAB
   - Name:    .shstrtab
     Type:    SHT_STRTAB
   - Name:    .text.foo
     Type:    SHT_PROGBITS
     Address: 0x200
 
 ## Check we don't add a symbol table when no "Symbols" key is specified.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readelf -S %t3 | FileCheck /dev/null --implicit-check-not=.symtab
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 
 ## Check we add a symbol table when "Symbols" key is specified.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readelf -S %t4 | FileCheck %s --check-prefix=SYMTAB
 
 # SYMTAB: .symtab
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Symbols: []

llvm/test/tools/yaml2obj/ELF/invalid-docnum.yaml

 ## Test that an error is reported when a docnum is specified, which is
 ## greater than the number of YAML inputs in the file.
 
 # RUN: not yaml2obj %s --docnum=3 2>&1 | FileCheck %s
 # CHECK: yaml2obj: error: cannot find the 3rd document
 
 # RUN: not yaml2obj %s --docnum=76768677 2>&1 | FileCheck %s --check-prefix=TWO
 # TWO: yaml2obj: error: cannot find the 76768677th document
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64

llvm/test/tools/yaml2obj/ELF/linker-options.yaml

- Name: .linker-options
     Options:
       - Value: value
 
 ## Check we can't use both "Options" and "Content" together.
 
 # RUN: not yaml2obj %s --docnum=4 2>&1 | FileCheck %s --check-prefix=BOTH
 
 # BOTH: error: "Options" and "Content" can't be used together
- 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .linker-options

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

 ## Check how yaml2obj produces SHT_LLVM_ADDRSIG sections.
 
 ## Check we can describe SHT_LLVM_ADDRSIG using the "Symbols" tag. We can define
 ## symbols either using names or indexes.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=SYMBOLS
 
 # SYMBOLS:      Section {
 # SYMBOLS:        Index: 1
 # SYMBOLS-NEXT:   Name: .llvm_addrsig
 # SYMBOLS-NEXT:   Type: SHT_LLVM_ADDRSIG
 # SYMBOLS-NEXT:   Flags [
 # SYMBOLS-NEXT:   ]
 # SYMBOLS-NEXT:   Address: 0x0
 # SYMBOLS-NEXT:   Offset: 0x40
 # SYMBOLS-NEXT:   Size: 4
 # SYMBOLS-NEXT:   Link: 2
 # SYMBOLS-NEXT:   Info: 0
 # SYMBOLS-NEXT:   AddressAlignment: 0
 # SYMBOLS-NEXT:   EntrySize: 0
 # SYMBOLS-NEXT:   SectionData (
 # SYMBOLS-NEXT:     0000: 01020102
 # SYMBOLS-NEXT:   )
 # SYMBOLS-NEXT: }
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Symbols:
       - Name: foo
       - Name: bar
       - Index: 1
       - Index: 2
 Symbols:
   - Name:    foo
     Type:    STT_FUNC
     Binding: STB_GLOBAL
   - Name:    bar
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 
 ## We can't specify both "Index" and "Name" when defining a symbol.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=INDEX-NAME
 
 # INDEX-NAME: error: "Index" and "Name" cannot be used together when defining a symbol
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Symbols:
       - Name: foo
         Index: 1
 Symbols:
   - Name:    foo
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 
 ## Check we report an error if an unknown symbol is referenced in the
 ## SHT_LLVM_ADDRSIG section description.
 
 # RUN: not yaml2obj --docnum=3 %s 2>&1 | FileCheck %s --check-prefix=SYMBOL-UNKNOWN
 
 # SYMBOL-UNKNOWN: error: unknown symbol referenced: 'foo' by YAML section '.llvm_addrsig'
 # SYMBOL-UNKNOWN: error: unknown symbol referenced: 'bar' by YAML section '.llvm_addrsig'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Symbols:
       - Name: foo
       - Name: bar
 
 ## Check we can specify any arbitrary symbol indices.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj --sections --section-data %t4 | FileCheck %s --check-prefix=SYMBOL-INDEX
 
 # SYMBOL-INDEX:      Type: SHT_LLVM_ADDRSIG
 # SYMBOL-INDEX:      SectionData (
 # SYMBOL-INDEX-NEXT:   0000: 00FF01C4 E6888901 FFFFFFFF 0F
 # SYMBOL-INDEX-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Symbols:
       - Index: 0
       - Index: 255
       - Index: 0x11223344
 ## 0xFFFFFFFF is a maximum allowed index value.
       - Index: 0xFFFFFFFF
 
 ## Check that the maximum symbol index size is 32 bits.
 
 # RUN: not yaml2obj --docnum=5 %s 2>&1 | FileCheck %s --check-prefix=SYMBOL-INDEX-OVERFLOW
 
 # SYMBOL-INDEX-OVERFLOW: error: out of range hex32 number
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Symbols:
       - Index: 0x1122334455
 
 ## Check we can use the "Content" tag to specify any data for SHT_LLVM_ADDRSIG sections.
 
 # RUN: yaml2obj --docnum=6 %s -o %t6
 # RUN: llvm-readobj --sections --section-data %t6 | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      Type: SHT_LLVM_ADDRSIG
 # CONTENT:      Size:
 # CONTENT-SAME: 5
 # CONTENT:      SectionData (
 # CONTENT-NEXT:   0000: 11223344 55
 # CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Content: "1122334455"
 
 ## Either "Content" or "Symbols" must be specifed for SHT_LLVM_ADDRSIG sections.
 
 # RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=NO-TAGS
 
 # NO-TAGS: error: one of "Content", "Size" or "Symbols" must be specified
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
 
 ## "Content" and "Symbols" cannot be used together to describe the SHT_LLVM_ADDRSIG section.
 
 # RUN: not yaml2obj --docnum=8 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-SYMBOLS
 
 # CONTENT-SYMBOLS: "Symbols" cannot be used with "Content" or "Size"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Content: ""
     Symbols:
 
 ## Check we can set an arbitrary sh_link value for SHT_LLVM_ADDRSIG sections.
 
 # RUN: yaml2obj --docnum=9 %s -o %t9
 # RUN: llvm-readobj --sections %t9 | FileCheck %s --check-prefix=LINK
 
 # LINK:      Name: .llvm_addrsig
 # LINK:      Link:
 # LINK-SAME:       123{{$}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Link: 123
     Content: ""
 
 ## Check we can use only "Size" to create a SHT_LLVM_ADDRSIG section.
 
 # RUN: yaml2obj --docnum=10 %s -o %t10
 # RUN: llvm-readobj --sections --section-data %t10 | FileCheck %s --check-prefix=SIZE
 
 # SIZE:      Name: .llvm_addrsig
 # 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: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Size: 0x11
 
 ## Check we can use "Size" and "Content" together to create a SHT_LLVM_ADDRSIG section.
 
 # RUN: yaml2obj --docnum=11 %s -o %t11
 # RUN: llvm-readobj --sections --section-data %t11 | FileCheck %s --check-prefix=SIZE-CONTENT
 
 # SIZE-CONTENT:      Name: .llvm_addrsig_sizegr
 # SIZE-CONTENT:      Size:
 # SIZE-CONTENT-SAME: 5
 # SIZE-CONTENT:      SectionData (
 # SIZE-CONTENT-NEXT:  0000: 11223300 00 |
 # SIZE-CONTENT-NEXT: )
 
 # SIZE-CONTENT:      Name: .llvm_addrsig_sizeeq
 # SIZE-CONTENT:      Size:
 # SIZE-CONTENT-SAME: 3
 # SIZE-CONTENT:      SectionData (
 # SIZE-CONTENT-NEXT:  0000: 112233 |
 # SIZE-CONTENT-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig_sizegr
     Type: SHT_LLVM_ADDRSIG
     Size: 0x5
     Content: "112233"
   - Name: .llvm_addrsig_sizeeq
     Type: SHT_LLVM_ADDRSIG
     Size: 0x3
     Content: "112233"
 
 ## Check that when "Size" and "Content" are used together, the size
 ## must be greater than or equal to the content size.
 
 # RUN: not yaml2obj --docnum=12 %s 2>&1 | FileCheck %s --check-prefix=SIZE-CONTENT-ERR
 
 # SIZE-CONTENT-ERR: error: "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: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Size: 0x1
     Content: "1122"
 
 ## Check we can't use "Size" and "Symbols" tags together.
 
 # RUN: not yaml2obj --docnum=13 %s 2>&1 | FileCheck %s --check-prefix=CONTENT-SYMBOLS
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Size: 0x1
     Symbols: [ ]

llvm/test/tools/yaml2obj/ELF/local-symbols.yaml

-# Check we correctly set the sh_info field of .symtab section.
-# A symbol table section's sh_info section header member holds
-# the symbol table index for the first non-local symbol.
+## Check we correctly set the sh_info field of .symtab section.
+## A symbol table section's sh_info section header member holds
+## the symbol table index for the first non-local symbol.
 
 # RUN: yaml2obj -docnum=1 %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s --check-prefix=ONE
 # ONE: Name: .symtab
 # ONE: Info: 2
 
 --- !ELF
 FileHeader:

llvm/test/tools/yaml2obj/ELF/no-phdrs.yaml

 ## Check that e_phoff and e_phentsize are set to 0 when there are no
 ## program headers.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --file-headers %t | FileCheck %s
 
 # CHECK: ProgramHeaderOffset: 0x0{{$}}
 # CHECK: ProgramHeaderEntrySize: 0{{$}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64

llvm/test/tools/yaml2obj/ELF/override-shname.yaml

 ## Check we are able to set a custom sh_name field for different sections
 ## and that doing this does not affect the names stored in the string table.
 
 # RUN: yaml2obj %s -o %t1
 # RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s
 
 # CHECK:      Index: 1
 # CHECK-NEXT: Name:{{.* }}(1)
 # CHECK:      Index: 2
 # CHECK-NEXT: Name:{{.* }}(2)
 # CHECK:      Index: 3
 # CHECK-NEXT: Name:{{.* }}(3)
 # CHECK:      Index: 4
 # CHECK-NEXT: Name:{{.* }}(4)
 # CHECK:      Index: 5
 # CHECK-NEXT: Name:{{.* }}(5)
 # CHECK:      Index: 6
 # CHECK-NEXT: Name:{{.* }}(6)
 # CHECK:      Index: 7
 # CHECK-NEXT: Name:{{.* }}(7)
 # CHECK:      Index: 8
 # CHECK-NEXT: Name:{{.* }}(8)
 # CHECK:      Index: 9
 # CHECK-NEXT: Name:{{.* }}(9)
 # CHECK:      Index: 10
 # CHECK-NEXT: Name:{{.* }}(10)
 # CHECK:      Index: 11
 # CHECK-NEXT: Name:{{.* }}(11)
 
 # CHECK:      Name: .shstrtab
 # CHECK:      SectionData (
 # CHECK-NEXT:  |..nobits..regula|
 # CHECK-NEXT:  |r..gnu.version_r|
 # CHECK-NEXT:  |..group..gnu.ver|
 # CHECK-NEXT:  |sion..dynsym..gn|
 # CHECK-NEXT:  |u.version_d..dyn|
 # CHECK-NEXT:  |amic..shstrtab..|
 # CHECK-NEXT:  |strtab..symtab..|
 # CHECK-NEXT:  |rela.|
 # CHECK-NEXT: )
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
     ShName: 0x000000001
   - Name: .symtab
     Type: SHT_SYMTAB
     ShName: 0x000000002
   - Name: .dynamic
     Type: SHT_DYNAMIC
     ShName: 0x000000003
   - Name: .rela
     Type: SHT_RELA
     ShName: 0x000000004
   - Name: .nobits
     Type: SHT_NOBITS
     ShName: 0x000000005
   - Name: .group
     Type: SHT_GROUP
     ShName: 0x000000006
     Members:
   - Name: .gnu.version
     Type: SHT_GNU_versym
     Entries: [ ]
     ShName: 0x000000007
   - Name: .gnu.version_r
     Type: SHT_GNU_verneed
     Info: 0x0000000000000001
     ShName: 0x000000008
     Dependencies:
   - Name: .gnu.version_d
     Type: SHT_GNU_verdef
     Info: 0x0000000000000001
     ShName: 0x000000009
     Entries:
   - Name: .regular
     Type: SHT_PROGBITS
     ShName: 0x00000000A
   - Name: .strtab
     Type: SHT_STRTAB
     ShName: 0x00000000B

llvm/test/tools/yaml2obj/ELF/override-shoffset.yaml

 ## Check we are able to set custom sh_offset field
 ## for different sections.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --sections %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      Section Headers:
 # CASE1-NEXT:  [Nr] Name           Type     Address Off
 # CASE1-NEXT:  [ 0]                NULL     {{.*}}  000000
 # CASE1-NEXT:  [ 1] .dynsym        DYNSYM   {{.*}}  000001
 # CASE1-NEXT:  [ 2] .symtab        SYMTAB   {{.*}}  000002
 # CASE1-NEXT:  [ 3] .dynamic       DYNAMIC  {{.*}}  000003
 # CASE1-NEXT:  [ 4] .rela          RELA     {{.*}}  000004
 # CASE1-NEXT:  [ 5] .nobits        NOBITS   {{.*}}  000005
 # CASE1-NEXT:  [ 6] .group         GROUP    {{.*}}  000006
 # CASE1-NEXT:  [ 7] .gnu.version   VERSYM   {{.*}}  000007
 # CASE1-NEXT:  [ 8] .gnu.version_r VERNEED  {{.*}}  000008
 # CASE1-NEXT:  [ 9] .gnu.version_d VERDEF   {{.*}}  000009
 # CASE1-NEXT:  [10] .regular       PROGBITS {{.*}}  00000a
 # CASE1-NEXT:  [11] .strtab        STRTAB   {{.*}}  00000b
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM
     ShOffset: 0x000000001
   - Name: .symtab
     Type: SHT_SYMTAB
     ShOffset: 0x000000002
   - Name: .dynamic
     Type: SHT_DYNAMIC
     ShOffset: 0x000000003
   - Name: .rela
     Type: SHT_RELA
     ShOffset: 0x000000004
   - Name: .nobits
     Type: SHT_NOBITS
     ShOffset: 0x000000005
   - Name: .group
     Type: SHT_GROUP
     ShOffset: 0x000000006
     Members:
   - Name: .gnu.version
     Type: SHT_GNU_versym
     Entries: [ ]
     ShOffset: 0x000000007
   - Name: .gnu.version_r
     Type: SHT_GNU_verneed
     Info: 0x0000000000000001
     ShOffset: 0x000000008
     Dependencies:
   - Name: .gnu.version_d
     Type: SHT_GNU_verdef
     Info: 0x0000000000000001
     ShOffset: 0x000000009
     Entries:
   - Name: .regular
     Type: SHT_PROGBITS
     ShOffset: 0x00000000A
   - Name: .strtab
     Type: SHT_STRTAB
     ShOffset: 0x00000000B
 
 ## Here we check that defining ShOffset does not actually change
 ## the offset at which section data is placed and also does
 ## not affect file size.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: od -t x1 -v %t2 > %t.txt
 # RUN: od -t x1 -v %t3 >> %t.txt
 # RUN: FileCheck %s --input-file=%t.txt --ignore-case --check-prefix=CASE2
 
 # CASE2: [[OFFSET:.*]] fe fe fe fe fe fe fe fe
 # CASE2: [[FILESIZE:.*]]{{$}}
 # CASE2: [[OFFSET]] fe fe fe fe fe fe fe fe
 # CASE2: [[FILESIZE]]{{$}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
     Content: "fefefefefefefefe"
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
     ShOffset: 0xFFFF0000
     Content: "fefefefefefefefe"

llvm/test/tools/yaml2obj/ELF/override-shsize.yaml

 ## Check we are able to set custom sh_size field
 ## for different sections.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --sections %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      Section Headers:
-# CASE1-NEXT:  [Nr] Name           Type     Address          Off    Size  
+# CASE1-NEXT:  [Nr] Name           Type     Address          Off    Size
 # CASE1-NEXT:  [ 0]                NULL     0000000000000000 000000 000000
 # CASE1-NEXT:  [ 1] .dynsym        DYNSYM   0000000000000000 000040 000001
 # CASE1-NEXT:  [ 2] .symtab        SYMTAB   0000000000000000 000058 000002
 # CASE1-NEXT:  [ 3] .dynamic       DYNAMIC  0000000000000000 000070 000003
 # CASE1-NEXT:  [ 4] .rela          RELA     0000000000000000 000070 000004
 # CASE1-NEXT:  [ 5] .nobits        NOBITS   0000000000000000 000070 000005
 # CASE1-NEXT:  [ 6] .group         GROUP    0000000000000000 000070 000006
 # CASE1-NEXT:  [ 7] .gnu.version   VERSYM   0000000000000000 000070 000007

llvm/test/tools/yaml2obj/ELF/program-header-align.yaml

 ## Test the p_align field of a program header can be set explicitly or inferred
 ## from the maximum alignment of contained sections.
 
 ## Explicit Align has priority over section alignments.
 
 # RUN: yaml2obj --docnum=1 %s -o %t
 # RUN: llvm-readobj -l %t | FileCheck %s
 # CHECK:      ProgramHeader {
 # CHECK-NOT:  ProgramHeader {
 # CHECK:        Alignment: 16
 # CHECK-NEXT: }
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_NONE
 Sections:
   - Name:         .tdata
     Type:         SHT_PROGBITS
     AddressAlign: 4
   - Name:         .tbss
     Type:         SHT_NOBITS
     AddressAlign: 64
 ProgramHeaders:
   - Type:  PT_TLS
     Align: 16
     Sections:
       - Section: .tdata
       - Section: .tbss
 
 ## If Align is not specified, p_align is inferred from the maximum alignment
 ## of contained sections.
 
 # RUN: yaml2obj --docnum=2 %s -o %t
 # RUN: llvm-readobj -l %t | FileCheck %s
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_NONE
 Sections:
   - Name:         .text
     Type:         SHT_PROGBITS
     AddressAlign: 4
   - Name:         .text.hot
     Type:         SHT_PROGBITS
     AddressAlign: 16
 ProgramHeaders:
   - Type: PT_LOAD
     Sections:
       - Section: .text
       - Section: .text.hot

llvm/test/tools/yaml2obj/ELF/program-header-nobits.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -l %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Content:         "00000000"
   - Name:            .after
     Type:            SHT_NOBITS
     Flags:           [ SHF_ALLOC ]
     Size:            64
 ProgramHeaders:
   - Type: PT_LOAD
     Flags: [ PF_R ]
     Sections:
       - Section: .data
       - Section: .after
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
 #CHECK-NEXT:    Offset:
 #CHECK-NEXT:    VirtualAddress:
 #CHECK-NEXT:    PhysicalAddress:
 #CHECK-NEXT:    FileSize: 4
 #CHECK-NEXT:    MemSize: 68
 #CHECK-NEXT:    Flags [
 #CHECK-NEXT:      PF_R
 #CHECK-NEXT:    ]
 #CHECK-NEXT:    Alignment:
 #CHECK-NEXT:  }
 #CHECK-NEXT:]

llvm/test/tools/yaml2obj/ELF/program-header-size-offset.yaml

-# Show that yaml2obj properly emits program headers with explicit file size,
-# memory size and offset parameters.
+## Show that yaml2obj properly emits program headers with explicit file size,
+## memory size and offset parameters.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj %t --program-headers | FileCheck %s
 
 # CHECK: ProgramHeaders [
 # CHECK:    Offset: 0x1234
 # CHECK:    FileSize: 1111
 # CHECK:    MemSize: 9999

llvm/test/tools/yaml2obj/ELF/program-header.yaml

 # RUN: yaml2obj --docnum=1 %s -o %t
 # RUN: llvm-readobj -l %t | FileCheck %s
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x0000000000001000
     Content:         "00000000"
   - Name:            .init
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         "00000000"
     AddressAlign:    0x0000000000000010
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Content:         "00000000"
     AddressAlign:    0x0000000000001000
 ProgramHeaders:
   - Type: PT_LOAD
     Flags: [ PF_X, PF_R ]
     VAddr: 0xAAAA1000
     PAddr: 0xFFFF1000
     Sections:
       - Section: .text
       - Section: .init
   - Type: PT_LOAD
     Flags: [ PF_R ]
     VAddr: 0xAAAA2000
     PAddr: 0xFFFF2000
     Sections:
       - Section: .data
   - Type: PT_GNU_EH_FRAME
   - Type: PT_GNU_STACK
   - Type: PT_GNU_RELRO
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:   ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
 #CHECK-NEXT:    Offset: 0x1000
 #CHECK-NEXT:    VirtualAddress: 0xAAAA1000
 #CHECK-NEXT:    PhysicalAddress: 0xFFFF1000
 #CHECK-NEXT:    FileSize: 20
 #CHECK-NEXT:    MemSize: 20
 #CHECK-NEXT:    Flags [
 #CHECK-NEXT:      PF_R
 #CHECK-NEXT:      PF_X
 #CHECK-NEXT:    ]
 #CHECK-NEXT:    Alignment: 4096
 #CHECK-NEXT:  }
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
 #CHECK-NEXT:    Offset: 0x2000
 #CHECK-NEXT:    VirtualAddress: 0xAAAA2000
 #CHECK-NEXT:    PhysicalAddress: 0xFFFF2000
 #CHECK-NEXT:    FileSize: 4
 #CHECK-NEXT:    MemSize: 4
 #CHECK-NEXT:    Flags [
 #CHECK-NEXT:      PF_R
 #CHECK-NEXT:    ]
 #CHECK-NEXT:    Alignment: 4096
 #CHECK-NEXT:  }
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_GNU_EH_FRAME (0x6474E550)
 #CHECK:       }
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_GNU_STACK (0x6474E551)
 #CHECK:       }
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_GNU_RELRO (0x6474E552)
 #CHECK:       }
 #CHECK-NEXT:]
 
 ## Check we do not allow referencing sections that do not exist.
 # RUN: not yaml2obj --docnum=2 %s -o %t 2>&1 | FileCheck %s --check-prefix=ERR
 
 # ERR: error: unknown section or fill referenced: '.foo' by program header
 # ERR: error: unknown section or fill referenced: '.bar' by program header
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 ProgramHeaders:
   - Type: PT_LOAD
     Sections:
       - Section: .foo
       - Section: .bar

llvm/test/tools/yaml2obj/ELF/reloc-sec-info.yaml

 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --sections %t1 | FileCheck %s
 
 # CHECK:      Name: .rela.text
 # CHECK-NEXT: Type: SHT_RELA
 # CHECK-NEXT: Flags [
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size:
 # CHECK-NEXT: Link:
 # CHECK-NEXT: Info: 12345
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:            .rela.text
     Type:            SHT_RELA
     Info:            12345
     Relocations:
 
 ## Check we report an error when a relocation section references an unknown section via its Info field.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --implicit-check-not=error --check-prefix=ERR
 
 # ERR: error: unknown section referenced: '.unknown1' by YAML section '.foo'
 # ERR: error: unknown section referenced: '.unknown2' by YAML section '.bar'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_RELA
     Info: .unknown1
     Relocations:
   - Name: .bar
     Type: SHT_RELA
     Info: .unknown2
     Relocations:
   - Name: .zed
     Type: SHT_RELA
     Info: 0xFF
     Relocations:

llvm/test/tools/yaml2obj/ELF/relocation-explicit-symbol-index.yaml

-# Test that a relocation's symbol can be an integer.
-# RUN: yaml2obj %s > %t
-# LLVM tools (both llvm-readobj and llvm-objdump) reject relocations with
-# invalid symbol indexes, so inspect the hex contents instead.
+## Test that a relocation's symbol can be an integer (symbol index).
+
+# RUN: yaml2obj %s -o %t
+## LLVM tools (both llvm-readobj and llvm-objdump) reject relocations with
+## invalid symbol indexes, so inspect the hex contents instead.
 # RUN: llvm-readobj -x .rela.text %t | FileCheck %s
 
 # CHECK:      Hex dump of section '.rela.text':
 # CHECK-NEXT: 0x00000000 00000000 00000000 02000000 42000000
 #                               Symbol index 0x42 --^
 # CHECK-NEXT: 0x00000010 00000000 00000000 00000000 00000000
 # CHECK-NEXT: 0x00000020 02000000 01000000 00000000 00000000
 #             Symbol index 0x01 --^

llvm/test/tools/yaml2obj/ELF/relocation-implicit-symbol-index.yaml

-# This test succeeds but produces an invalid relocation. This test
-# documents this behavoir.
-# RUN: yaml2obj %s > %t
+## If "Symbol" is not specified for a relocation, the symbol index is assumed to be 0.
+
+# RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -r %t | FileCheck %s
 
+# CHECK:     Relocations [
+# CHECK-NEXT:  Section (2) .rel.text {
+# CHECK-NEXT:    0x1000 R_X86_64_RELATIVE - 0x0
+# CHECK-NEXT:    0x1001 R_X86_64_PC32 - 0x0
+# CHECK-NEXT:  }
+# CHECK-NEXT:]
+
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         "00000000"
   - Name:            .rel.text
     Type:            SHT_REL
     Info:            .text
     Relocations:
       - Offset: 0x1000
+        Type:   R_X86_64_RELATIVE
+      ## R_X86_64_PC32 should have a non-zero symbol index but we don't error.
+      - Offset: 0x1001
         Type:   R_X86_64_PC32
-
-#CHECK:     Relocations [
-#CHECK-NEXT:  Section (2) .rel.text {
-#CHECK-NEXT:    0x1000 R_X86_64_PC32 - 0x0
-#CHECK-NEXT:  }
-#CHECK-NEXT:]

llvm/test/tools/yaml2obj/ELF/relocation-missing-symbol.yaml

 ## Show that yaml2obj rejects a symbol reference from a relocation if the symbol
 ## does not exist.
 
 # RUN: not yaml2obj %s -o %t 2>&1 | FileCheck %s
 
 ## Check we are able to report multiple errors.
 
 # CHECK: error: unknown symbol referenced: 'does_not_exist1' by YAML section '.rela.text'
 # CHECK: error: unknown symbol referenced: 'does_not_exist2' by YAML section '.rela.text'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .text
     Type: SHT_PROGBITS
   - Name: .rela.text
     Type: SHT_RELA
     Info: .text
     Link: .symtab
     Relocations:
       - Type: R_X86_64_PC32
         Offset: 0
         Symbol: does_not_exist1
       - Type: R_X86_64_PC32
         Offset: 0
         Symbol: does_not_exist2

llvm/test/tools/yaml2obj/ELF/relocation-unsupported-machine.yaml

 ## Show that yaml2obj is able to write relocations for an unknown e_machine properly.
 
 # RUN: yaml2obj %s -o %t1
 # RUN: llvm-readelf %t1 --relocations | FileCheck %s
 
 # CHECK: Relocation section '.rela.text' at offset 0x40 contains 2 entries:
 # CHECK:      Offset            Info             Type    Symbol's Value  Symbol's Name + Addend
 # CHECK-NEXT: 0000000000000001  0000000000000002 Unknown                                 0
 # CHECK-NEXT: 0000000000000003  0000000000000004 Unknown                                 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: 0x1234
 Sections:
   - Name: .rela.text
     Type: SHT_RELA
     Relocations:
       - Offset: 0x1
         Type:   0x2
       - Offset: 0x3
         Type:   0x4

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

 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --sections %t1 | FileCheck %s
 
 # CHECK:      Name: .text
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT:   SHF_EXECINSTR
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size:
 # CHECK-NEXT: Link: 12345
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Link:            12345
 
 ## Check we report an error when an unknown section is referenced via a Link field.
 
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=ERR
 
 # ERR: error: unknown section referenced: '.unknown1' by YAML section '.foo'
 # ERR: error: unknown section referenced: '.unknown2' by YAML section '.bar'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
     Link: .unknown1
   - Name: .bar
     Type: SHT_PROGBITS
     Link: .unknown2
 
 ## Check we link SHT_GROUP to a symbol table by default if it exists.
 ## Also, check we can set an arbitrary value for sh_link.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readobj --sections %t3 | FileCheck %s --check-prefix=GROUP-LINK
 
 # GROUP-LINK:      Name: .group1
 # GROUP-LINK:      Link:
 # GROUP-LINK-SAME:       3
 
 # GROUP-LINK:      Name: .group2
 # GROUP-LINK:      Link:
 # GROUP-LINK-SAME:       255
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .group1
     Type: SHT_GROUP
     Members:
   - Name: .group2
     Type: SHT_GROUP
     Link: 0xFF
     Members:
 Symbols: []
 
 ## Check we set SHT_GROUP's link value to 0 when there is no symbol table.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj --sections %t4 | FileCheck %s --check-prefix=GROUP-LINK-NOSYMTAB
 
 # GROUP-LINK-NOSYMTAB:      Name: .group
 # GROUP-LINK-NOSYMTAB:      Link:
 # GROUP-LINK-NOSYMTAB-SAME:       0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .group
     Type: SHT_GROUP
     Members:

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

-# Ensures that implicitly added sections can be ordered within Sections.
+## Ensures that implicitly added sections can be ordered within Sections.
+
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC

llvm/test/tools/yaml2obj/ELF/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: 0x40
 # 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: 0x40
 # 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: 0x40
 # 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: 0x40
 # CASE5-NEXT: Size: 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 
 # RUN: not yaml2obj --docnum=7 %s 2>&1 | FileCheck %s --check-prefix=ERR2
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data: ELFDATA2LSB
   Type: ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .data
     Type: SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Content: 0000000000000000
     Size: 2
 
 # ERR2:      error: Section size must be greater than or equal to the content size
 # ERR2-NEXT: - Name: .data
 # ERR2-NEXT:   ^
 # ERR2-NEXT: error: failed to parse YAML input

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

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s
 
 # CHECK: Name: enum
 # CHECK: Type: SHT_PROGBITS
 # CHECK: Name: machine-specific
 # CHECK: Type: SHT_X86_64_UNWIND
 # CHECK: Name: hex
 # CHECK: Type: Unknown (0xABCD)
 # CHECK: Name: decimal
 # CHECK: Type: Unknown (0x4D2)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name:  enum
     Type:  SHT_PROGBITS
   - Name:  machine-specific
     Type:  SHT_X86_64_UNWIND
   - Name:  hex
     Type:  0xabcd
   - Name:  decimal
     Type:  1234

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

-# Ensure yaml2obj doesn't crash on unnamed sections
+## Check that "Name" defaults to an empty string.
+
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC

llvm/test/tools/yaml2obj/ELF/sh-addralign.yaml

 ## Check that yaml2obj takes in account section AddressAlign field.
 
-# RUN: yaml2obj %s > %t
+# RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -S %t | FileCheck %s
 
 # CHECK:      Section {
 # CHECK:        Index:
 # CHECK:        Name: .data
 # CHECK-NEXT:   Type: SHT_PROGBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:   ]

llvm/test/tools/yaml2obj/ELF/sht-symtab-shndx.yaml

 Sections:
   - Name: bar
     Type: SHT_PROGBITS
 Symbols:
   - Type:  STT_SECTION
     Index: SHN_XINDEX
 
 ## Check that yaml2obj keeps the SHT_SYMTAB_SHNDX section in the output
-## even when symbol's section index value is low enough to not require the extended symtab. 
+## even when symbol's section index value is low enough to not require the extended symtab.
 ## Also, check that symbols in .symtab still have the SHN_XINDEX index.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj --sections --symbols --section-data 2>&1 %t2 | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Section {
 # CASE2:       Name: .symtab_shndx (1)
 # CASE2-NEXT:  Type: SHT_SYMTAB_SHNDX (0x12)

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

 ## Check how yaml2obj produces .stack_sizes sections.
 
 ## Test the following cases when the .stack_sizes Content field is specified:
 ## 1) We can produce a .stack_sizes section from a description with
 ##    a valid section content.
 ## 2) We can produce an incorrect .stack_sizes section from a description with
 ##    a broken (truncated) section content.
 ## 3) We can produce an empty .stack_sizes section from a description with
 ##    empty section content.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s
 
 ## Case 1: valid content.
 # CHECK:      Section {
 # CHECK:        Index: 1
 # CHECK-NEXT:   Name: .stack_sizes (1)
 # CHECK-NEXT:   Type: SHT_PROGBITS (0x1)
 # CHECK-NEXT:   Flags [ (0x0)
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Address: 0x0
 # CHECK-NEXT:   Offset: 0x40
 # CHECK-NEXT:   Size: 9
 # CHECK-NEXT:   Link: 0
 # CHECK-NEXT:   Info: 0
 # CHECK-NEXT:   AddressAlignment: 0
 # CHECK-NEXT:   EntrySize: 0
 # CHECK-NEXT:   SectionData (
 # CHECK-NEXT:     0000: 10000000 00000000 20
 # CHECK-NEXT:   )
 # CHECK-NEXT: }
 
 ## Case 2: truncated content.
 # CHECK:      Name: .stack_sizes
 # CHECK:      Size:
 # CHECK-SAME: 8
 # CHECK:      SectionData (
 # CHECK-NEXT:  0000: 10000000 00000000
 
 ## Case 3: empty content.
 # CHECK:      Name: .stack_sizes
 # CHECK:      Size:
 # CHECK-SAME: 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
 ## Valid.
   - Name:    '.stack_sizes [1]'
     Type:    SHT_PROGBITS
     Content: "100000000000000020"
 ## Truncated.
   - Name:    '.stack_sizes [2]'
     Type:    SHT_PROGBITS
     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
 
 # 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 (
 # ENTRIES-BE64-BOTH-NEXT:  0000: 00000000 00000010 20000000 00000000 |
 # ENTRIES-BE64-BOTH-NEXT:  0010: 3040
 
 # ENTRIES-LE32-BOTH:      Name: .stack_sizes
 # ENTRIES-LE32-BOTH:      SectionData (
 # ENTRIES-LE32-BOTH-NEXT:  0000: 10000000 20300000 0040 |
 
 # ENTRIES-BE32-BOTH:      Name: .stack_sizes
 # ENTRIES-BE32-BOTH:      SectionData (
 # ENTRIES-BE32-BOTH-NEXT:  0000: 00000010 20000000 3040 |
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   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:   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
 
 # 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
 
 # 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
 
 # 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
 
 # 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
 
 # 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
 
 # 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
 
 # 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
 
 # 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: 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 (
 # UNIQUE-NEXT:   0000: 30000000 00000000 40 |
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    '.stack_sizes [1]'
     Type:    SHT_PROGBITS
     Entries:
       - Address: 0x10
         Size:    0x20
   - Name:    '.stack_sizes [2]'
     Type:    SHT_PROGBITS
     Entries:
       - Address: 0x30
         Size:    0x40

llvm/test/tools/yaml2obj/ELF/strtab-implicit-sections-flags.yaml

 ## For implicit string table sections, the `Flags` field can also
 ## be specified in YAML. Here we test the behavior in different cases.
 
 ## When flags are not explicitly specified, yaml2obj assigns no flags
 ## for .strtab and the SHF_ALLOC flag for .dynstr by default.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj %t1 -S | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      Name: .strtab
 # CASE1-NEXT: Type: SHT_STRTAB
 # CASE1-NEXT: Flags [
 # CASE1-NEXT: ]
 # CASE1:      Name: .dynstr
 # CASE1-NEXT: Type: SHT_STRTAB
 # CASE1-NEXT: Flags [
 # CASE1-NEXT:   SHF_ALLOC
 # CASE1-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .strtab
     Type:    SHT_STRTAB
   - Name:    .dynstr
     Type:    SHT_STRTAB
 
 ## Check we can set arbitrary flags for .strtab/.dynstr.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj %t2 -S | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Name: .strtab
 # CASE2-NEXT: Type: SHT_STRTAB
 # CASE2-NEXT: Flags [
 # CASE2-NEXT:   SHF_ALLOC
 # CASE2-NEXT:   SHF_STRINGS
 # CASE2-NEXT: ]
 # CASE2:      Name: .dynstr
 # CASE2-NEXT: Type: SHT_STRTAB
 # CASE2-NEXT: Flags [
 # CASE2-NEXT:   SHF_STRINGS
 # CASE2-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .strtab
     Type:  SHT_STRTAB
     Flags: [ SHF_ALLOC, SHF_STRINGS ]
   - Name:  .dynstr
     Type:  SHT_STRTAB
     Flags: [ SHF_STRINGS ]
 
 ## Check no flags are set by default for .strtab when it is not
 ## described in the YAML.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readobj %t3 -S | FileCheck %s --check-prefix=CASE3
 
 # CASE3:      Name: .strtab
 # CASE3-NEXT: Type: SHT_STRTAB
 # CASE3-NEXT: Flags [
 # CASE3-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64

llvm/test/tools/yaml2obj/ELF/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: 0x40
 # 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: 0x40
 # 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: 0x40
 # 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: 0x40
 # 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/test/tools/yaml2obj/ELF/symbol-binding.yaml

 ## Check we can set different bindings for symbols.
 
 # RUN: yaml2obj %s | llvm-readobj --symbols - | FileCheck %s
 
 !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name:    local_symbol
     Type:    STT_OBJECT
     Binding: STB_LOCAL
   - Name:    global_symbol
     Type:    STT_OBJECT
     Binding: STB_GLOBAL
   - Name:    weak_symbol
     Type:    STT_OBJECT
     Binding: STB_WEAK
 
 # CHECK: Symbol {
 # CHECK:   Name:  (0)
 # CHECK: Symbol {
 # CHECK:   Name: local_symbol
 # CHECK:   Binding: Local
 # CHECK: Symbol {
 # CHECK:   Name: global_symbol
 # CHECK:   Binding: Global
 # CHECK: Symbol {
 # CHECK:   Name: weak_symbol
 # CHECK:   Binding: Weak

llvm/test/tools/yaml2obj/ELF/symbol-index-invalid.yaml

-# This test insures that the user cannot have both an Index and a Section field.
+## Check that "Index" and "Section" cannot be used together in a symbol.
+
 # RUN: not yaml2obj %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64

llvm/test/tools/yaml2obj/ELF/symbol-index.yaml

-# RUN: yaml2obj %s > %t
+# RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf -s %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
   - Name: .text
     Type: SHT_PROGBITS
 Symbols:
   - Name:     absolute1
     Index:    SHN_ABS
     Value:    0x1234
     Binding:  STB_GLOBAL
   - Name:     absolute2
     Index:    0xfff1
     Value:    0x4321
     Binding:  STB_GLOBAL
   - Name:     common1
     Index:    SHN_COMMON
-    Binding:  STB_GLOBAL 
+    Binding:  STB_GLOBAL
   - Name:     common2
     Index:    0xfff2
-    Binding:  STB_GLOBAL 
+    Binding:  STB_GLOBAL
   - Name:     good
     Index:    0x1
     Binding:  STB_GLOBAL
   - Name:     bad
     Index:    0x42
     Binding:  STB_GLOBAL
   - Name:     undef1
     Index:    SHN_UNDEF

llvm/test/tools/yaml2obj/ELF/symbol-name.yaml

 ## Check we are able to use integers as both
 ## symbol name indices (st_name values) and symbol names.
 # RUN: yaml2obj --docnum=1 %s > %t
 # RUN: llvm-readobj --symbols %t | FileCheck %s
 
 # CHECK: Name: test (1)
 # CHECK: Name: test (1)
 # CHECK: Name: est (2)
 # CHECK: Name: 1 (8)
 # CHECK: Name: 2 (6)
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
 Symbols:
   - Name:      test
   - NameIndex: 1
   - NameIndex: 2
   - Name:      1
   - Name:      2
 
 ## Check we do not allow specifying both Name and NameIndex at once.
 # RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=ERR
 # ERR: error: Name and NameIndex cannot both be specified for Symbol
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
 Symbols:
   - Name:      foo
     NameIndex: 0

llvm/test/tools/yaml2obj/ELF/symbol-stother.yaml

 ## Test how yaml2obj sets the value of a symbol's st_other fields.
 
 ## Show that yaml2obj reports an error when using an STO_* flag that belongs
 ## to a different machine type to what is specified by the YAML.
 
 # RUN: not yaml2obj --docnum=1 2>&1 %s | FileCheck %s --check-prefix=ERR
 # ERR: error: an unknown value is used for symbol's 'Other' field: STO_MIPS_OPTIONAL
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_386
 Symbols:
   - Name:  foo
     Other: [ STO_MIPS_OPTIONAL ]
 
 ## Test that STO_* can be used with their correct machine type.
 ## We use the same YAML as above, but with a change of machine type.
 
 # RUN: yaml2obj --docnum=2 %s > %t2
 # RUN: llvm-readobj --symbols %t2 | FileCheck %s --check-prefix=USE-OTHER
 
 # USE-OTHER:      Name: foo
 # USE-OTHER:      Other [ (0x4)
 # USE-OTHER-NEXT:   STO_MIPS_OPTIONAL (0x4)
 # USE-OTHER-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_MIPS
 Symbols:
   - Name:  foo
     Other: [ STO_MIPS_OPTIONAL ]
 
 ## Test that we can mix named and unnamed constants and set
 ## st_other to any arbitrary value.
 
 # RUN: yaml2obj --docnum=3 %s > %t3
 # RUN: llvm-readobj --symbols %t3 | FileCheck %s --check-prefix=VALUE
 
 # VALUE:      Name: foo
 # VALUE:      Other [
 # VALUE-SAME: (0x4)
 
 # VALUE:      Name: bar
 # VALUE:      Other [
 # VALUE-SAME: (0x7)
 
 # VALUE:      Name: zed
 # VALUE:      Other [
 # VALUE-SAME: (0xFF)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_MIPS
 Symbols:
   - Name:  foo
     Other: [ 0x4 ]
   - Name:  bar
     Other: [ STV_PROTECTED, 4 ]
   - Name:  zed
     Other: [ STV_PROTECTED, STO_MIPS_OPTIONAL, 0xf8 ]

llvm/test/tools/yaml2obj/ELF/symbol-type.yaml

-# RUN: yaml2obj %s > %t
+# RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --symbols %t | FileCheck %s
 
 # CHECK: Name: notype
 # CHECK: Type: None
 # CHECK: Name: normal_type
 # CHECK: Type: Object
 # CHECK: Name: .text
 # CHECK: Type: Section
FileHeader:
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name: .text
     Type: SHT_PROGBITS
 Symbols:
   - Name:    notype
     Type:    STT_NOTYPE
-    Binding: STB_GLOBAL 
+    Binding: STB_GLOBAL
   - Name:    normal_type
     Type:    STT_OBJECT
     Binding: STB_GLOBAL
   - Name:    .text
     Type:    STT_SECTION
     Binding: STB_GLOBAL
   - Name:    known_hex
     Type:    0x1

llvm/test/tools/yaml2obj/ELF/symbol-visibility.yaml

 ## Check yaml2obj is able to parse the Visibility field and produce the output.
 
 # RUN: yaml2obj %s | llvm-readobj --symbols - | FileCheck --check-prefix OBJ %s
 
 # OBJ:      Symbol {
 # OBJ:        Name: default1
 # OBJ-NEXT:   Value: 0x0
 # OBJ-NEXT:   Size: 0
 # OBJ-NEXT:   Binding: Local (0x0)
 # OBJ-NEXT:   Type: None (0x0)
 # OBJ-NEXT:   Other: 0
 # OBJ-NEXT:   Section: Undefined (0x0)
 # OBJ-NEXT: }
 # OBJ-NEXT: Symbol {
 # OBJ-NEXT:   Name: default2
 # OBJ-NEXT:   Value: 0x0
 # OBJ-NEXT:   Size: 0
 # OBJ-NEXT:   Binding: Local (0x0)
 # OBJ-NEXT:   Type: None (0x0)
 # OBJ-NEXT:   Other: 0
 # OBJ-NEXT:   Section: Undefined (0x0)
 # OBJ-NEXT: }
 # OBJ-NEXT: Symbol {
 # OBJ-NEXT:   Name: internal
 # OBJ-NEXT:   Value: 0x0
 # OBJ-NEXT:   Size: 0
 # OBJ-NEXT:   Binding: Local (0x0)
 # OBJ-NEXT:   Type: None (0x0)
 # OBJ-NEXT:   Other [ (0x1)
 # OBJ-NEXT:     STV_INTERNAL (0x1)
 # OBJ-NEXT:   ]
 # OBJ-NEXT:   Section: Undefined (0x0)
 # OBJ-NEXT: }
 # OBJ-NEXT: Symbol {
 # OBJ-NEXT:   Name: hidden
 # OBJ-NEXT:   Value: 0x0
 # OBJ-NEXT:   Size: 0
 # OBJ-NEXT:   Binding: Local (0x0)
 # OBJ-NEXT:   Type: None (0x0)
 # OBJ-NEXT:   Other [ (0x2)
 # OBJ-NEXT:     STV_HIDDEN (0x2)
 # OBJ-NEXT:   ]
 # OBJ-NEXT:   Section: Undefined (0x0)
 # OBJ-NEXT: }
 # OBJ-NEXT: Symbol {
 # OBJ-NEXT:   Name: protected
 # OBJ-NEXT:   Value: 0x0
 # OBJ-NEXT:   Size: 0
 # OBJ-NEXT:   Binding: Local (0x0)
 # OBJ-NEXT:   Type: None (0x0)
 # OBJ-NEXT:   Other [ (0x3)
 # OBJ-NEXT:     STV_PROTECTED (0x3)
 # OBJ-NEXT:   ]
 # OBJ-NEXT:   Section: Undefined (0x0)
 # OBJ-NEXT: }
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name:  default1
   - Name:  default2
     Other: [ STV_DEFAULT ]
   - Name:  internal
     Other: [ STV_INTERNAL ]
   - Name:  hidden
     Other: [ STV_HIDDEN ]
   - Name:  protected
     Other: [ STV_PROTECTED ]

llvm/test/tools/yaml2obj/ELF/symbols-binding-order.yaml

 ## Check we allow placing local symbols after global to
 ## .symtab and .dynsym. This allows us to produce broken outputs.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf --symbols %t | FileCheck %s
 
 # CHECK:      Symbol table '.dynsym' contains 3 entries:
 # CHECK-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
 # CHECK-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
 # CHECK-NEXT:      1: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND dynamicGlobal
 # CHECK-NEXT:      2: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND dynamicLocal
 
 # CHECK:      Symbol table '.symtab' contains 3 entries:
 # CHECK-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
 # CHECK-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
 # CHECK-NEXT:      1: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND staticGlobal
 # CHECK-NEXT:      2: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND staticLocal
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Symbols:
   - Name:    staticGlobal
     Binding: STB_GLOBAL
   - Name:    staticLocal
     Binding: STB_LOCAL
 DynamicSymbols:
   - Name:    dynamicGlobal
     Binding: STB_GLOBAL
   - Name:    dynamicLocal
     Binding: STB_LOCAL

llvm/test/tools/yaml2obj/ELF/symtab-implicit-sections-flags.yaml

 ## For implicit symbol table sections, the `Flags` field can also
 ## be specified in YAML. Here we test the behavior in different cases.
 
 ## When flags are not explicitly specified, yaml2obj assigns no flags
 ## for .symtab and the SHF_ALLOC flag for .dynsym by default.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj %t1 -S | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      Name: .symtab
 # CASE1-NEXT: Type: SHT_SYMTAB
 # CASE1-NEXT: Flags [
 # CASE1-NEXT: ]
 # CASE1:      Name: .dynsym
 # CASE1-NEXT: Type: SHT_DYNSYM
 # CASE1-NEXT: Flags [
 # CASE1-NEXT:   SHF_ALLOC
 # CASE1-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_SYMTAB
   - Name: .dynsym
     Type: SHT_DYNSYM
 
 ## Check we can set arbitrary flags for .symtab/.dynsym.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj %t2 -S | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Name: .symtab
 # CASE2-NEXT: Type: SHT_SYMTAB
 # CASE2-NEXT: Flags [
 # CASE2-NEXT:   SHF_ALLOC
 # CASE2-NEXT:   SHF_STRINGS
 # CASE2-NEXT: ]
 # CASE2:      Name: .dynsym
 # CASE2-NEXT: Type: SHT_DYNSYM
 # CASE2-NEXT: Flags [
 # CASE2-NEXT:   SHF_STRINGS
 # CASE2-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:  .symtab
     Type:  SHT_SYMTAB
     Flags: [ SHF_ALLOC, SHF_STRINGS ]
   - Name:  .dynsym
     Type:  SHT_DYNSYM
     Flags: [ SHF_STRINGS ]
 
 ## Check no flags are set by default for .symtab when it is not
 ## described in the YAML.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readobj %t3 -S | FileCheck %s --check-prefix=CASE3
 
 # CASE3:      Name: .symtab
 # CASE3-NEXT: Type: SHT_SYMTAB
 # CASE3-NEXT: Flags [
 # CASE3-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Symbols: []

llvm/test/tools/yaml2obj/ELF/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: 0x40
 # CASE4-NEXT: Size: 2
 # CASE4-NEXT: Link: 2
 # CASE4-NEXT: Info: 1
 # 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: 0x40
 # CASE5-NEXT: Size: 5
 # CASE5-NEXT: Link: 2
 # CASE5-NEXT: Info: 1
 # 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: 0x40
 # CASE6-NEXT: Size: 4
 # CASE6-NEXT: Link: 2
 # CASE6-NEXT: Info: 1
 # 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: 0x40
 # CASE7-NEXT:  Size: 2
 # CASE7-NEXT:  Link: 2
 # CASE7-NEXT:  Info: 1
 # 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/test/tools/yaml2obj/ELF/symtab-shinfo.yaml

 # CHECK-NEXT: Flags [
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size:
 # CHECK-NEXT: Link:
 # CHECK-NEXT: Info: 26
- 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .symtab

llvm/test/tools/yaml2obj/ELF/symtab-shlink.yaml

 ## For implicit symbol table sections, `Link` field can also
 ## be specified in YAML. Here we test the behavior in different cases.
 
 ## Check we are able to set Link = 0 for .symtab explicitly.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj %t1 -S | FileCheck %s --check-prefix=CASE1
 
 # CASE1: Name: .symtab
 # CASE1: Link:
 # CASE1-SAME: 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_SYMTAB
     Link: 0
 
 ## Check that by default .symtab will be linked with .strtab.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj %t2 -S | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      .symtab
 # CASE2:      Link:
 # CASE2-SAME: 2
 # CASE2:      Index: 2
 # CASE2-NEXT: Name: .strtab
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_SYMTAB
 
 ## Even if .strtab is defined in YAML, we can explicitly link .symtab
 ## to another section.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readobj %t3 -S | FileCheck %s --check-prefix=CASE3
 
 # CASE3:      .symtab
 # CASE3:      Link:
 # CASE3-SAME: 3
 # CASE3:      Index: 3
 # CASE3-NEXT: Name: .foo
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_SYMTAB
     Link: 3
   - Name: .strtab
     Type: SHT_STRTAB
   - Name: .foo
     Type: SHT_PROGBITS
 
 ## Check we can use a section name as a Link value for .symtab.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj %t4 -S | FileCheck %s --check-prefix=CASE4
 
 # CASE4:      .symtab
 # CASE4:      Link:
 # CASE4-SAME: 2
 # CASE4:      Index: 2
 # CASE4-NEXT: Name: .foo
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_SYMTAB
     Link: .foo
   - Name: .foo
     Type: SHT_PROGBITS

llvm/test/tools/yaml2obj/ELF/symtab-shtype.yaml

 ## Check we dont crash when .symtab has type different from SHT_SYMTAB.
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj --sections %t | FileCheck %s
 
 # CHECK:      Name: .symtab
 # CHECK-NEXT: Type: SHT_DYNAMIC
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .symtab
     Type: SHT_DYNAMIC
 Symbols:
   - Name:    foo
     Binding: STB_GLOBAL

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

+## Check we are able to handle SHT_GNU_verdef sections.
+
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -V %t | FileCheck %s
 
-# Check we are able to handle the SHT_GNU_verdef sections.
-
 # CHECK:      VersionDefinitions [
 # CHECK-NEXT:   Definition {
 # CHECK-NEXT:     Version: 1
 # CHECK-NEXT:     Flags: Base
 # CHECK-NEXT:     Index: 1
 # CHECK-NEXT:     Hash: 170240160
 # CHECK-NEXT:     Name: dso.so.0
 # CHECK-NEXT:   }

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

+## Check we are able to handle SHT_GNU_verneed sections.
+
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -V %t | FileCheck %s
 
-# Check we are able to handle the SHT_GNU_verneed sections.
-
 # CHECK:      VersionRequirements [
 # CHECK-NEXT:   Dependency {
 # CHECK-NEXT:     Version: 1
 # CHECK-NEXT:     Count: 2
 # CHECK-NEXT:     FileName: dso.so.0
 # CHECK-NEXT:     Entries [
 # CHECK-NEXT:       Entry {
 # CHECK-NEXT:         Hash: 1937

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

- Name:            .gnu.version_r
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000200250
     Link:            .dynstr
     AddressAlign:    0x0000000000000004
     Info:            0x0000000000000001
     Dependencies:
       - Version:         1
         File:            dso.so.0
-        Entries:         
+        Entries:
           - Name:            v1
             Hash:            1937
             Flags:           0
             Other:           3
           - Name:            v2
             Hash:            1938
             Flags:           0
             Other:           4

llvm/test/tools/yaml2obj/Minidump/exception-missing-parameter.yaml

 # RUN: not yaml2obj %s -o /dev/null 2>&1 | FileCheck %s
 
 ## Test that we report an error for an ExceptionStream where the specified
 ## number of parameters is greater than the number of ExceptionInformation
 ## elements listed.
 
 --- !minidump
 Streams:
   - Type:            Exception
     Thread ID:  0x7
     Exception Record:
       Exception Code:  0x23
       Exception Flags: 0x5
       Exception Record: 0x0102030405060708
       Exception Address: 0x0a0b0c0d0e0f1011
       Number of Parameters: 4
       Parameter 0: 0x99
       Parameter 1: 0x23
       Parameter 2: 0x42
 # CHECK: error: missing required key 'Parameter 3'
     Thread Context:  3DeadBeefDefacedABadCafe)");

llvm/test/tools/yaml2obj/Minidump/raw-stream-small-size.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 --- !minidump
 Streams:
   - Type:            LinuxAuxv
     Size:            7
     Content:         DEADBEEFBAADF00D
 
 # CHECK: Stream size must be greater or equal to the content size

llvm/test/tools/yaml2obj/Minidump/systeminfo-other-long.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  PPC
     Platform ID:     Linux
     CPU:
       Features:        000102030405060708090a0b0c0d0e0f0
 
 
 # CHECK: String too long
 # CHECK-NEXT: Features:        000102030405060708090a0b0c0d0e0f0

llvm/test/tools/yaml2obj/Minidump/systeminfo-other-not-hex.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  PPC
     Platform ID:     Linux
     CPU:
       Features:        000102030405060708090a0b0c0d0e0g
 
 
 # CHECK: Invalid hex digit in input
 # CHECK-NEXT: Features:        000102030405060708090a0b0c0d0e0g

llvm/test/tools/yaml2obj/Minidump/systeminfo-other-short.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  PPC
     Platform ID:     Linux
     CPU:
       Features:        000102030405060708090a0b0c0d0e0
 
 
 # CHECK: String too short
 # CHECK-NEXT: Features:        000102030405060708090a0b0c0d0e0

llvm/test/tools/yaml2obj/Minidump/systeminfo-x86-long.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  X86
     Platform ID:     Linux
     CPU:
       Vendor ID:       LLVMLLVMLLVML
       Version Info:    0x01020304
       Feature Info:    0x05060708
       AMD Extended Features: 0x09000102
 
 # CHECK: String too long
 # CHECK-NEXT: Vendor ID:       LLVMLLVMLLVML

llvm/test/tools/yaml2obj/Minidump/systeminfo-x86-short.yaml

 # RUN: not yaml2obj %s 2>&1 | FileCheck %s
 
 --- !minidump
 Streams:
   - Type:            SystemInfo
     Processor Arch:  X86
     Platform ID:     Linux
     CPU:
       Vendor ID:       LLVMLLVMLLV
       Version Info:    0x01020304
       Feature Info:    0x05060708
       AMD Extended Features: 0x09000102
 
 # CHECK: String too short
 # CHECK-NEXT: Vendor ID:       LLVMLLVMLLV

llvm/test/tools/yaml2obj/empty-symbols.yaml

-# Ensure yaml2obj doesn't error on empty optional mappings, such as Symbols
-# RUN: yaml2obj %s -o %t
-
-!ELF
-FileHeader:
-  Class:           ELFCLASS64
-  Data:            ELFDATA2LSB
-  Type:            ET_DYN
-  Machine:         EM_X86_64
-Symbols:

llvm/test/tools/yaml2obj/invalid-output-file.yaml

 # RUN: not yaml2obj -o %p/path/does/not/exist 2>&1 | FileCheck %s
 
-# Don't check the OS-dependent message "No such file or directory".
+## Don't check the OS-dependent message "No such file or directory".
 # CHECK: yaml2obj: error: failed to open '{{.*}}/path/does/not/exist': {{.*}}

llvm/test/tools/yaml2obj/multi-doc.yaml

 ## Check we are able to have multiple YAMLs in a file and switch between
 ## them using --docnum=x option.
 
 # RUN: yaml2obj -docnum=1 %s \
 # RUN:   | llvm-readobj --symbols - | FileCheck -check-prefix=DOC1 %s
 # RUN: yaml2obj -docnum=2 %s \
 # RUN:   | llvm-readobj --symbols - | FileCheck -check-prefix=DOC2 %s
 # RUN: yaml2obj -docnum=3 %s \
 # RUN:   | llvm-readobj --symbols - | FileCheck -check-prefix=DOC3 %s
 # RUN: yaml2obj -docnum=4 %s \
 # RUN:   | llvm-readobj --symbols - | FileCheck -check-prefix=DOC4 %s
 # RUN: not yaml2obj -docnum=5 %s 2>&1 \
 # RUN:   | FileCheck -check-prefix=DOC5 %s
 
 # DOC1: Name: _sym1
 # DOC2: Name: _sym2
 # DOC3: Name: _sym3
 # DOC4: Name: _sym4
 # DOC5: error: cannot find the 5th document
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS32
   Data: ELFDATA2LSB
   Type: ET_REL
   Machine: EM_MIPS
   Flags: [EF_MIPS_CPIC]
 Symbols:
 - Name: _sym1
 
 --- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS32
   Data: ELFDATA2LSB
   Type: ET_REL
   Machine: EM_386
 Symbols:
 - Name: _sym2
 
 --- !COFF
 header:
   Machine: IMAGE_FILE_MACHINE_I386
   Characteristics: [ IMAGE_FILE_DEBUG_STRIPPED ]
 
 sections:
   - Name: .text
     Alignment: 16
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE,
                        IMAGE_SCN_MEM_READ ]
     SectionData: "00000000"
 symbols:
   - Name: .text
     Value: 0
     SectionNumber: 1
     SimpleType: IMAGE_SYM_TYPE_NULL
     ComplexType: IMAGE_SYM_DTYPE_NULL
     StorageClass: IMAGE_SYM_CLASS_STATIC
     SectionDefinition:
       Length:          36
       NumberOfRelocations: 3
       NumberOfLinenumbers: 0
       CheckSum:        0
       Number:          1
   - Name: _sym3
     Value: 0
     SectionNumber: 0
     SimpleType: IMAGE_SYM_TYPE_NULL
     ComplexType: IMAGE_SYM_DTYPE_NULL
     StorageClass: IMAGE_SYM_CLASS_EXTERNAL
 
 --- !COFF
 header:
   Machine: IMAGE_FILE_MACHINE_I386
   Characteristics: [ IMAGE_FILE_DEBUG_STRIPPED ]
 
 sections:
   - Name: .text
     Alignment: 16
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE,
                        IMAGE_SCN_MEM_READ ]
     SectionData: "00000000"
 symbols:
   - Name: .text
     Value: 0
     SectionNumber: 1
     SimpleType: IMAGE_SYM_TYPE_NULL
     ComplexType: IMAGE_SYM_DTYPE_NULL
     StorageClass: IMAGE_SYM_CLASS_STATIC
     SectionDefinition:
       Length:          36
       NumberOfRelocations: 3
       NumberOfLinenumbers: 0
       CheckSum:        0
       Number:          1
   - Name: _sym4
     Value: 0
     SectionNumber: 0
     SimpleType: IMAGE_SYM_TYPE_NULL
     ComplexType: IMAGE_SYM_DTYPE_NULL
     StorageClass: IMAGE_SYM_CLASS_EXTERNAL

llvm/test/tools/yaml2obj/symboless-relocation.yaml

-# Just make sure this isn't an error even though it has no Symbol
-# RUN: yaml2obj %s
-
-!ELF
-FileHeader:
-  Class:           ELFCLASS64
-  Data:            ELFDATA2LSB
-  Type:            ET_EXEC
-  Machine:         EM_X86_64
-Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Content:         "00000000"
-  - Name:            .rel.text
-    Type:            SHT_REL
-    Info:            .text
-    Relocations:
-      - Offset: 0x1000
-        Type:   R_X86_64_RELATIVE