[obj2yaml] - Don't emit EM_NONE.

[grimar]

Summary

When ELF header's e_machine == 0, we emit:

Machine: EM_NONE

We can avoid doing this, because yaml2obj sets the
e_machine field to EM_NONE by default.

[jhenderson]

LGTM.

llvm/test/tools/obj2yaml/ELF/call-graph-profile-section.yaml

 
 ## Check how we handle broken cases.
 
 # RUN: yaml2obj --docnum=2 %s -o %t.invalid
 # RUN: obj2yaml %t.invalid | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      --- !ELF
 # INVALID-NEXT: FileHeader:
-# INVALID-NEXT:   Class:   ELFCLASS32
-# INVALID-NEXT:   Data:    ELFDATA2MSB
-# INVALID-NEXT:   Type:    ET_DYN
-# INVALID-NEXT:   Machine: EM_NONE
+# INVALID-NEXT:   Class: ELFCLASS32
+# INVALID-NEXT:   Data:  ELFDATA2MSB
+# INVALID-NEXT:   Type:  ET_DYN
 # INVALID-NEXT: Sections:
 # INVALID-NEXT:   - Name:    .empty
 # INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link:    .symtab
 # INVALID-NEXT:     EntSize: 0x0000000000000010
 # INVALID-NEXT:   - Name:    .multiple.16.valid
 # INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link:    .symtab

llvm/test/tools/obj2yaml/ELF/duplicate-symbol-and-section-names.yaml

 # CHECK: Name: localbar (
 # CHECK: Name: localbar (
 # CHECK: Name: localbar (
 
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      --- !ELF
 # CASE1-NEXT: FileHeader:
-# CASE1-NEXT:   Class:   ELFCLASS64
-# CASE1-NEXT:   Data:    ELFDATA2LSB
-# CASE1-NEXT:   Type:    ET_REL
-# CASE1-NEXT:   Machine: EM_NONE
+# CASE1-NEXT:   Class: ELFCLASS64
+# CASE1-NEXT:   Data:  ELFDATA2LSB
+# CASE1-NEXT:   Type:  ET_REL
 # CASE1-NEXT: Sections:
 # CASE1-NEXT:   - Name: .foo
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT:   - Name: '.foo (1)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT:   - Name: '.foo (2)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT:   - Name: .bar

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

 ## Check how obj2yaml dumps e_machine field.
 
 ## Check it dumps an unknown e_machine as a number.
 
-# RUN: yaml2obj --docnum=1 %s -o %t1
-# RUN: obj2yaml %t1 | FileCheck %s --check-prefix=UNKNOWN
+# RUN: yaml2obj -DMACHINE=0x1234 %s -o %t1
+# RUN: obj2yaml %t1 | FileCheck %s -DMACHINE=0x1234
 
-# UNKNOWN:      --- !ELF
-# UNKNOWN-NEXT: FileHeader:
-# UNKNOWN-NEXT:   Class:   ELFCLASS64
-# UNKNOWN-NEXT:   Data:    ELFDATA2MSB
-# UNKNOWN-NEXT:   Type:    ET_REL
-# UNKNOWN-NEXT:   Machine: 0x1234
+# CHECK:      --- !ELF
+# CHECK-NEXT: FileHeader:
+# CHECK-NEXT:   Class:   ELFCLASS64
+# CHECK-NEXT:   Data:    ELFDATA2MSB
+# CHECK-NEXT:   Type:    ET_REL
+# CHECK-NEXT:   Machine: [[MACHINE]]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
-  Machine: 0x1234
+  Machine: [[MACHINE]]
 
 ## Check it dumps a known e_machine value as an enum string.
 
-# RUN: yaml2obj --docnum=2 %s -o %t2
-# RUN: obj2yaml %t2 | FileCheck %s --check-prefix=KNOWN
+# RUN: yaml2obj %s -DMACHINE=0x1 -o %t2
+# RUN: obj2yaml %t2 | FileCheck %s -DMACHINE=EM_M32
 
-# KNOWN:      --- !ELF
-# KNOWN-NEXT: FileHeader:
-# KNOWN-NEXT:   Class:   ELFCLASS64
-# KNOWN-NEXT:   Data:    ELFDATA2MSB
-# KNOWN-NEXT:   Type:    ET_REL
-# KNOWN-NEXT:   Machine: EM_NONE
+## Check it doesn't dump e_machine when it is EM_NONE (0).
 
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2MSB
-  Type:    ET_REL
-  Machine: 0
+# RUN: yaml2obj %s -DMACHINE=0x0 -o %t3
+# RUN: obj2yaml %t3 | FileCheck %s --check-prefix=DEFAULT
+
+# DEFAULT:      --- !ELF
+# DEFAULT-NEXT: FileHeader:
+# DEFAULT-NEXT:   Class: ELFCLASS64
+# DEFAULT-NEXT:   Data:  ELFDATA2MSB
+# DEFAULT-NEXT:   Type:  ET_REL
+# DEFAULT-NEXT: ...

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

 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 ## Check obj2yaml is able to dump the STB_GNU_UNIQUE symbol.
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
-# CHECK-NEXT:   Class:     ELFCLASS64
-# CHECK-NEXT:   Data:      ELFDATA2LSB
-# CHECK-NEXT:   OSABI:     ELFOSABI_GNU
-# CHECK-NEXT:   Type:      ET_REL
-# CHECK-NEXT:   Machine:   EM_NONE
+# CHECK-NEXT:   Class: ELFCLASS64
+# CHECK-NEXT:   Data:  ELFDATA2LSB
+# CHECK-NEXT:   OSABI: ELFOSABI_GNU
+# CHECK-NEXT:   Type:  ET_REL
 # CHECK-NEXT: Symbols:
 # CHECK-NEXT:   - Name:    foo
 # CHECK-NEXT:     Type:    STT_OBJECT
 # CHECK-NEXT:     Binding: STB_GNU_UNIQUE
 # CHECK-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   OSABI: ELFOSABI_GNU
   Type:  ET_REL
 Symbols:
   - Name:    foo
     Type:    STT_OBJECT
     Binding: STB_GNU_UNIQUE

llvm/test/tools/obj2yaml/ELF/implicit-sections-order.yaml

 # RE-2-NEXT: [ 8] .strtab   STRTAB   0000000000004000 0000a5 000005 00   A 0   0  0
 # RE-NEXT:   [ 9] .foo.5    PROGBITS 0000000000000000 0000aa 000000 00     0   0  0
 # RE-1-NEXT: [10] .shstrtab STRTAB   0000000000005000 0000aa 000055 00     0   0  0
 # RE-2-NEXT: [10] .shstrtab STRTAB   0000000000005000 0000aa 000055 00   A 0   0  0
 # RE-NEXT:   [11] .foo.6    PROGBITS 0000000000000000 0000ff 000000 00     0   0  0
 
 # OUTPUT:      --- !ELF
 # OUTPUT-NEXT: FileHeader:
-# OUTPUT-NEXT:   Class:   ELFCLASS64
-# OUTPUT-NEXT:   Data:    ELFDATA2LSB
-# OUTPUT-NEXT:   Type:    ET_DYN
-# OUTPUT-NEXT:   Machine: EM_NONE
+# OUTPUT-NEXT:   Class: ELFCLASS64
+# OUTPUT-NEXT:   Data:  ELFDATA2LSB
+# OUTPUT-NEXT:   Type:  ET_DYN
 # OUTPUT-NEXT: Sections:
 # OUTPUT-NEXT:   - Name: .foo.1
 # OUTPUT-NEXT:     Type: SHT_PROGBITS
 # OUTPUT-NEXT:   - Name:    .dynsym
 # OUTPUT-NEXT:     Type:    SHT_DYNSYM
 # OUTPUT-NEXT:     Flags:   [ SHF_ALLOC ]
 # OUTPUT-NEXT:     Address: 0x0000000000001000
 # OUTPUT-NEXT:     Link:    .dynstr

 # RUN: yaml2obj %s -o %t2.so -D FLAG1="" -D FLAG2=SHF_ALLOC
 # RUN: llvm-readelf -S %t2.so | FileCheck %s --check-prefixes=RE,RE-2
 # RUN: obj2yaml %t2.so | FileCheck %s --check-prefix=OUTPUT2
 
 ## Check we explicitly declare only allocatable
 ## SHT_STRTAB/SHT_SYMTAB/SHT_DYNSYM sections.
 # OUTPUT2:      --- !ELF
 # OUTPUT2-NEXT: FileHeader:
-# OUTPUT2-NEXT:   Class:   ELFCLASS64
-# OUTPUT2-NEXT:   Data:    ELFDATA2LSB
-# OUTPUT2-NEXT:   Type:    ET_DYN
-# OUTPUT2-NEXT:   Machine: EM_NONE
+# OUTPUT2-NEXT:   Class: ELFCLASS64
+# OUTPUT2-NEXT:   Data:  ELFDATA2LSB
+# OUTPUT2-NEXT:   Type:  ET_DYN
 # OUTPUT2-NEXT: Sections:
 # OUTPUT2-NEXT:   - Name: .foo.1
 # OUTPUT2-NEXT:     Type: SHT_PROGBITS
 # OUTPUT2-NEXT:   - Name: .foo.2
 # OUTPUT2-NEXT:     Type: SHT_PROGBITS
 # OUTPUT2-NEXT:   - Name: .foo.3
 # OUTPUT2-NEXT:     Type: SHT_PROGBITS
 # OUTPUT2-NEXT:   - Name:    .symtab

llvm/test/tools/obj2yaml/ELF/invalid-section-name.yaml

 ## Check we do not crash/assert when dumping a broken section name.
 ## Here we replace the section name with a sequence of characters that
 ## are not representable as unsigned char.
 ## We used to assert for this case before. 
 
 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
-# CHECK-NEXT:   Class:   ELFCLASS64
-# CHECK-NEXT:   Data:    ELFDATA2LSB
-# CHECK-NEXT:   Type:    ET_REL
-# CHECK-NEXT:   Machine: EM_NONE
+# CHECK-NEXT:   Class: ELFCLASS64
+# CHECK-NEXT:   Data:  ELFDATA2LSB
+# CHECK-NEXT:   Type:  ET_REL
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Name: "{{.*}}"
 # CHECK-NEXT:     Type: SHT_PROGBITS
 # CHECK-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: foo
     Type: SHT_PROGBITS
   - Name: .shstrtab
     Type: SHT_STRTAB
     Content: "00FEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFE00"

llvm/test/tools/obj2yaml/ELF/no-symtab.yaml

 ## Check that obj2yaml doesn't create a "Symbols" tag for the objects
 ## without a symbol table.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=NOSYMTAB
 
 # NOSYMTAB:      --- !ELF
 # NOSYMTAB-NEXT:  FileHeader:
-# NOSYMTAB-NEXT:    Class:           ELFCLASS64
-# NOSYMTAB-NEXT:    Data:            ELFDATA2LSB
-# NOSYMTAB-NEXT:    Type:            ET_DYN
-# NOSYMTAB-NEXT:    Machine:         EM_NONE
+# NOSYMTAB-NEXT:    Class: ELFCLASS64
+# NOSYMTAB-NEXT:    Data:  ELFDATA2LSB
+# NOSYMTAB-NEXT:    Type:  ET_DYN
 # NOSYMTAB-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 
 ## Check that obj2yaml creates a "Symbols" tag for the objects
 ## that have a symbol table.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=SYMTAB
 
 # SYMTAB:      --- !ELF
 # SYMTAB-NEXT:  FileHeader:
-# SYMTAB-NEXT:   Class:   ELFCLASS64
-# SYMTAB-NEXT:   Data:    ELFDATA2LSB
-# SYMTAB-NEXT:   Type:    ET_DYN
-# SYMTAB-NEXT:   Machine: EM_NONE
+# SYMTAB-NEXT:   Class: ELFCLASS64
+# SYMTAB-NEXT:   Data:  ELFDATA2LSB
+# SYMTAB-NEXT:   Type:  ET_DYN
 # SYMTAB-NEXT:  Symbols: []
 # SYMTAB-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Symbols: []

llvm/test/tools/obj2yaml/ELF/null-section.yaml

 ## Check we are able to dump the SHT_NULL section at
 ## index 0 when it has custom section fields.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=FIRST-SEC
 
 # FIRST-SEC:      --- !ELF
 # FIRST-SEC-NEXT: FileHeader:
-# FIRST-SEC-NEXT:   Class:   ELFCLASS64
-# FIRST-SEC-NEXT:   Data:    ELFDATA2LSB
-# FIRST-SEC-NEXT:   Type:    ET_REL
-# FIRST-SEC-NEXT:   Machine: EM_NONE
+# FIRST-SEC-NEXT:   Class: ELFCLASS64
+# FIRST-SEC-NEXT:   Data:  ELFDATA2LSB
+# FIRST-SEC-NEXT:   Type:  ET_REL
 # FIRST-SEC-NEXT: Sections:
 # FIRST-SEC-NEXT:   - Type:         SHT_NULL
 # FIRST-SEC-NEXT:     Flags:        [ SHF_ALLOC ]
 # FIRST-SEC-NEXT:     Address:      0x0000000000000006
 # FIRST-SEC-NEXT:     Link:         .foo
 # FIRST-SEC-NEXT:     AddressAlign: 0x0000000000000003
 # FIRST-SEC-NEXT:     EntSize:      0x0000000000000005
 # FIRST-SEC-NEXT:     Size:         0x0000000000000004

 
 ## Check we are able to dump the SHT_NULL section with a non-zero index.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=SECOND-SEC
 
 # SECOND-SEC:      --- !ELF
 # SECOND-SEC-NEXT: FileHeader:
-# SECOND-SEC-NEXT:   Class:   ELFCLASS64
-# SECOND-SEC-NEXT:   Data:    ELFDATA2LSB
-# SECOND-SEC-NEXT:   Type:    ET_REL
-# SECOND-SEC-NEXT:   Machine: EM_NONE
+# SECOND-SEC-NEXT:   Class: ELFCLASS64
+# SECOND-SEC-NEXT:   Data:  ELFDATA2LSB
+# SECOND-SEC-NEXT:   Type:  ET_REL
 # SECOND-SEC-NEXT: Sections:
 # SECOND-SEC-NEXT:   - Name:         .foo
 # SECOND-SEC-NEXT:     Type:         SHT_PROGBITS
 # SECOND-SEC-NEXT:   - Type:         SHT_NULL
 # SECOND-SEC-NEXT:     Flags:        [ SHF_ALLOC ]
 # SECOND-SEC-NEXT:     Address:      0x0000000000000006
 # SECOND-SEC-NEXT:     Link:         .foo
 # SECOND-SEC-NEXT:     AddressAlign: 0x0000000000000003

 ## Check we do not dump the SHT_NULL section with index 0
 ## when it does not have any custom fields.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=NULL-SEC
 
 # NULL-SEC:      --- !ELF
 # NULL-SEC-NEXT: FileHeader:
-# NULL-SEC-NEXT:   Class:   ELFCLASS64
-# NULL-SEC-NEXT:   Data:    ELFDATA2LSB
-# NULL-SEC-NEXT:   Type:    ET_REL
-# NULL-SEC-NEXT:   Machine: EM_NONE
+# NULL-SEC-NEXT:   Class: ELFCLASS64
+# NULL-SEC-NEXT:   Data:  ELFDATA2LSB
+# NULL-SEC-NEXT:   Type:  ET_REL
 # NULL-SEC-NEXT: Sections:
 # NULL-SEC-NEXT:   - Name: .foo
 # NULL-SEC-NEXT:     Type: SHT_PROGBITS
 # NULL-SEC-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Type: SHT_NULL
   - Type: SHT_PROGBITS
     Name: .foo
 
 ## Check we dump SHT_NULL sections which are not at the beginning
 ## of the section list even if they don't have any non-null fields.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: obj2yaml %t4 | FileCheck %s --check-prefix=NULL-SEC-MIDDLE
 
 # NULL-SEC-MIDDLE:      --- !ELF
 # NULL-SEC-MIDDLE-NEXT: FileHeader:
-# NULL-SEC-MIDDLE-NEXT:   Class:   ELFCLASS64
-# NULL-SEC-MIDDLE-NEXT:   Data:    ELFDATA2LSB
-# NULL-SEC-MIDDLE-NEXT:   Type:    ET_REL
-# NULL-SEC-MIDDLE-NEXT:   Machine: EM_NONE
+# NULL-SEC-MIDDLE-NEXT:   Class: ELFCLASS64
+# NULL-SEC-MIDDLE-NEXT:   Data:  ELFDATA2LSB
+# NULL-SEC-MIDDLE-NEXT:   Type:  ET_REL
 # NULL-SEC-MIDDLE-NEXT: Sections:
 # NULL-SEC-MIDDLE-NEXT:   - Name: .foo
 # NULL-SEC-MIDDLE-NEXT:     Type: SHT_PROGBITS
 # NULL-SEC-MIDDLE-NEXT:   - Type: SHT_NULL
 # NULL-SEC-MIDDLE-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Type: SHT_PROGBITS
     Name: .foo
   - Type: SHT_NULL

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

 ## Check that obj2yaml is able to dump a normal object which
 ## contains the SHT_SYMTAB_SHNDX section and symbols with
 ## section index == SHN_XINDEX.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      --- !ELF
 # CASE1-NEXT: FileHeader:
-# CASE1-NEXT:   Class:   ELFCLASS64
-# CASE1-NEXT:   Data:    ELFDATA2LSB
-# CASE1-NEXT:   Type:    ET_REL
-# CASE1-NEXT:   Machine: EM_NONE
+# CASE1-NEXT:   Class: ELFCLASS64
+# CASE1-NEXT:   Data:  ELFDATA2LSB
+# CASE1-NEXT:   Type:  ET_REL
 # CASE1-NEXT: Sections:
 # CASE1-NEXT:   - Name:    bar
 # CASE1-NEXT:     Type:    SHT_PROGBITS
 # CASE1-NEXT:   - Name:    .symtab_shndx
 # CASE1-NEXT:     Type:    SHT_SYMTAB_SHNDX
 # CASE1-NEXT:     Link:    .symtab
 # CASE1-NEXT:     EntSize: 0x0000000000000004
 # CASE1-NEXT:     Entries: [ 0, 1, 2 ]

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

 ## Check how obj2yaml produces YAML .stack_sizes descriptions.
 
 ## Check that obj2yaml uses the "Entries" tag to describe a .stack_sizes section
 ## when it can extract <address, size> pairs.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
 
 # VALID:      --- !ELF
 # VALID-NEXT: FileHeader:
-# VALID-NEXT:   Class:   ELFCLASS64
-# VALID-NEXT:   Data:    ELFDATA2LSB
-# VALID-NEXT:   Type:    ET_EXEC
-# VALID-NEXT:   Machine: EM_NONE
+# VALID-NEXT:   Class: ELFCLASS64
+# VALID-NEXT:   Data:  ELFDATA2LSB
+# VALID-NEXT:   Type:  ET_EXEC
 # VALID-NEXT: Sections:
 # VALID-NEXT:   - Name: .stack_sizes
 # VALID-NEXT:     Type: SHT_PROGBITS
 # VALID-NEXT:     Entries:
 # VALID-NEXT:       - Address: 0x0000000000000010
 # VALID-NEXT:         Size:    0x0000000000000020
 # VALID-NEXT:       - Address: 0x0000000000000030
 # VALID-NEXT:         Size:    0x0000000000000040

 ## Check that obj2yaml uses the "Content" tag to describe a .stack_sizes section
 ## when it can't extract the entries, for example, when section data is truncated.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      --- !ELF
 # INVALID-NEXT: FileHeader:
-# INVALID-NEXT:   Class:   ELFCLASS64
-# INVALID-NEXT:   Data:    ELFDATA2LSB
-# INVALID-NEXT:   Type:    ET_EXEC
-# INVALID-NEXT:   Machine: EM_NONE
+# INVALID-NEXT:   Class: ELFCLASS64
+# INVALID-NEXT:   Data:  ELFDATA2LSB
+# INVALID-NEXT:   Type:  ET_EXEC
 # INVALID-NEXT: Sections:
 # INVALID-NEXT:   - Name:    .stack_sizes
 # INVALID-NEXT:     Type:    SHT_PROGBITS
 # INVALID-NEXT:     Content: '1000000000000000203000000000000000'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Content: "1000000000000000203000000000000000"
 
 ## Check obj2yaml can dump empty .stack_sizes.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=EMPTY
 
 # EMPTY:      --- !ELF
 # EMPTY-NEXT: FileHeader:
-# EMPTY-NEXT:   Class:   ELFCLASS64
-# EMPTY-NEXT:   Data:    ELFDATA2LSB
-# EMPTY-NEXT:   Type:    ET_EXEC
-# EMPTY-NEXT:   Machine: EM_NONE
+# EMPTY-NEXT:   Class: ELFCLASS64
+# EMPTY-NEXT:   Data:  ELFDATA2LSB
+# EMPTY-NEXT:   Type:  ET_EXEC
 # EMPTY-NEXT: Sections:
 # EMPTY-NEXT:   - Name:    .stack_sizes
 # EMPTY-NEXT:     Type:    SHT_PROGBITS
 # EMPTY-NEXT:     Content: ''
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Content: ""
 
 ## Check obj2yaml can dump multiple .stack_sizes.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: obj2yaml %t4 | FileCheck %s --check-prefix=MULTI
 
 # MULTI:      --- !ELF
 # MULTI-NEXT: FileHeader:
-# MULTI-NEXT:   Class:   ELFCLASS64
-# MULTI-NEXT:   Data:    ELFDATA2LSB
-# MULTI-NEXT:   Type:    ET_EXEC
-# MULTI-NEXT:   Machine: EM_NONE
+# MULTI-NEXT:   Class: ELFCLASS64
+# MULTI-NEXT:   Data:  ELFDATA2LSB
+# MULTI-NEXT:   Type:  ET_EXEC
 # MULTI-NEXT: Sections:
 # MULTI-NEXT:   - Name:    .stack_sizes
 # MULTI-NEXT:     Type:    SHT_PROGBITS
 # MULTI-NEXT:     Entries:
 # MULTI-NEXT:       - Address: 0x0000000000000010
 # MULTI-NEXT:         Size:    0x0000000000000020
 # MULTI-NEXT:       - Address: 0x0000000000000030
 # MULTI-NEXT:         Size:    0x0000000000000040

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

 ## Check obj2yaml is able to dump the Visibility field correctly.
 
 # RUN: yaml2obj %s | obj2yaml - | FileCheck %s
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
-# CHECK-NEXT:   Class:   ELFCLASS64
-# CHECK-NEXT:   Data:    ELFDATA2LSB
-# CHECK-NEXT:   Type:    ET_REL
-# CHECK-NEXT:   Machine: EM_NONE
+# CHECK-NEXT:   Class: ELFCLASS64
+# CHECK-NEXT:   Data:  ELFDATA2LSB
+# CHECK-NEXT:   Type:  ET_REL
 # CHECK-NEXT: Symbols:
 # CHECK-NEXT:   - Name: default
 # CHECK-NEXT:   - Name: internal
 # CHECK-NEXT:     Other: [ STV_INTERNAL ]
 # CHECK-NEXT:   - Name: hidden
 # CHECK-NEXT:     Other: [ STV_HIDDEN ]
 # CHECK-NEXT:   - Name: protected
 # CHECK-NEXT:     Other: [ STV_PROTECTED ]

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

 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 ## Check we are able to yamalize the SHT_GNU_versym section.
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
-# CHECK-NEXT:   Class:           ELFCLASS64
-# CHECK-NEXT:   Data:            ELFDATA2LSB
-# CHECK-NEXT:   Type:            ET_EXEC
-# CHECK-NEXT:   Machine:         EM_NONE
-# CHECK-NEXT:   Entry:           0x0000000000201000
+# CHECK-NEXT:   Class: ELFCLASS64
+# CHECK-NEXT:   Data:  ELFDATA2LSB
+# CHECK-NEXT:   Type:  ET_EXEC
+# CHECK-NEXT:   Entry: 0x0000000000201000
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Name:            .gnu.version
 # CHECK-NEXT:     Type:            SHT_GNU_versym
 # CHECK-NEXT:     Flags:           [ SHF_ALLOC ]
 # CHECK-NEXT:     Address:         0x0000000000200210
 # CHECK-NEXT:     Link:            .dynsym
 # CHECK-NEXT:     AddressAlign:    0x0000000000000002
 # CHECK-NEXT:     EntSize:         0x0000000000000002

llvm/tools/obj2yaml/elf2yaml.cpp

template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   // Dump header. We do not dump EPh* and ESh* fields. When not explicitly set,
   // the values are set by yaml2obj automatically and there is no need to dump
   // them here.
   Y->Header.Class = ELFYAML::ELF_ELFCLASS(Obj.getHeader().getFileClass());
   Y->Header.Data = ELFYAML::ELF_ELFDATA(Obj.getHeader().getDataEncoding());
   Y->Header.OSABI = Obj.getHeader().e_ident[ELF::EI_OSABI];
   Y->Header.ABIVersion = Obj.getHeader().e_ident[ELF::EI_ABIVERSION];
   Y->Header.Type = Obj.getHeader().e_type;
+  if (Obj.getHeader().e_machine != 0)
     Y->Header.Machine = ELFYAML::ELF_EM(Obj.getHeader().e_machine);
   Y->Header.Flags = Obj.getHeader().e_flags;
   Y->Header.Entry = Obj.getHeader().e_entry;
 
   // Dump sections
   auto SectionsOrErr = Obj.sections();
   if (!SectionsOrErr)
     return SectionsOrErr.takeError();
   Sections = *SectionsOrErr;