[Object] Change ELFObjectFile<ELFT>::getFileFormatName() to use BFD names

[MaskRay]

Summary

Follow-up for D74433

What the function returns are almost standard BFD names, except that "ELF" is
in uppercase instead of lowercase.

This patch changes "ELF" to "elf" and changes ARM/AArch64 to use their BFD names.
MIPS and PPC64 have endianness differences as well, but this patch does not intend to address them.

Advantages:

• llvm-objdump: the "file format " line matches GNU objdump on ARM/AArch64 objects
• "file format " line can be extracted and fed into llvm-objcopy -O literally. (https://github.com/ClangBuiltLinux/linux/issues/779 has such a use case)

Affected tools: llvm-readobj, llvm-objdump, llvm-dwarfdump, MCJIT (internal implementation detail, not exposed)

[MaskRay]

elfnn-riscv -> elfnn-littleriscv

[jhenderson]

Seems reasonable to me. LGTM.

lld/test/ELF/basic-ppc.s

12

Whilst you're modifying this line, would you mind lining it up with the line below?

lld/test/ELF/basic-ppc64.s

17

Ditto.

[MaskRay]

Address comments

lld/test/ELF/basic-ppc.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc-unknown-freebsd %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-readobj --file-headers --sections --section-data -l %t | FileCheck %s
 
 # exits with return code 42 on FreeBSD
 .text
  li      0,1
  li      3,1
  sc
 
-// CHECK: Format: ELF32-ppc
+// CHECK:      Format: elf32-powerpc
 // CHECK-NEXT: Arch: powerpc
 // CHECK-NEXT: AddressSize: 32bit
 // CHECK-NEXT: LoadName:
 // CHECK-NEXT: ElfHeader {
 // CHECK-NEXT:   Ident {
 // CHECK-NEXT:     Magic: (7F 45 4C 46)
 // CHECK-NEXT:     Class: 32-bit (0x1)
 // CHECK-NEXT:     DataEncoding: BigEndian (0x2)

lld/test/ELF/basic-ppc64.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 # RUN: ld.lld --hash-style=sysv -discard-all -shared %t.o -o %t.so
 # RUN: llvm-readobj --file-headers --sections --section-data -l %t.so | FileCheck --check-prefixes=CHECK,LE %s
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 # RUN: ld.lld --hash-style=sysv -discard-all -shared %t.o -o %t.so
 # RUN: llvm-readobj --file-headers --sections --section-data -l %t.so | FileCheck --check-prefixes=CHECK,BE %s
 
 .abiversion 2
 # Exits with return code 55 on linux.
 .text
   li 0,1
   li 3,55
   sc
 
-// CHECK:Format: ELF64-ppc64
+// CHECK:      Format: elf64-powerpc
 // LE-NEXT:    Arch: powerpc64le
 // BE-NEXT:    Arch: powerpc64{{$}}
 // CHECK-NEXT: AddressSize: 64bit
 // CHECK-NEXT: LoadName:
 // CHECK-NEXT: ElfHeader {
 // CHECK-NEXT:  Ident {
 // CHECK-NEXT:    Magic: (7F 45 4C 46)
 // CHECK-NEXT:    Class: 64-bit (0x2)

lld/test/ELF/format-binary.test

 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: Absolute
 # CHECK-NEXT:   }
 
 # RUN: echo 'OUTPUT_FORMAT(elf64-x86-64)' > %t.script
 # RUN: ld.lld -b binary %t.binary -T %t.script -o %t.out
 # RUN: llvm-readobj %t.out -sections -section-data -symbols | FileCheck -check-prefix=X86-64 %s
 
-# X86-64: Format: ELF64-x86-64
+# X86-64: Format: elf64-x86-64
 
 # RUN: echo 'OUTPUT_FORMAT("elf64-x86-64")' > %t.script
 # RUN: ld.lld -b binary %t.binary -T %t.script -o %t.out
 # RUN: llvm-readobj %t.out -sections -section-data -symbols | FileCheck -check-prefix=X86-64-in-quotes %s
 
-# X86-64-in-quotes: Format: ELF64-x86-64
+# X86-64-in-quotes: Format: elf64-x86-64

lld/test/ELF/gnu-hash-table.s

 # EMPTY-NEXT:   First Hashed Symbol Index: 2
 # EMPTY-NEXT:   Num Mask Words: 1
 # EMPTY-NEXT:   Shift Count: 26
 # EMPTY-NEXT:   Bloom Filter: [0x0]
 # EMPTY-NEXT:   Buckets: [0]
 # EMPTY-NEXT:   Values: []
 # EMPTY-NEXT: }
 
-# I386:      Format: ELF32-i386
+# I386:      Format: elf32-i386
 # I386:      Arch: i386
 # I386:      AddressSize: 32bit
 # I386:      Sections [
 # I386:          Name: .gnu.hash
 # I386-NEXT:     Type: SHT_GNU_HASH
 # I386-NEXT:     Flags [
 # I386-NEXT:       SHF_ALLOC
 # I386-NEXT:     ]

 # I386-NEXT:   First Hashed Symbol Index: 4
 # I386-NEXT:   Num Mask Words: 1
 # I386-NEXT:   Shift Count: 26
 # I386-NEXT:   Bloom Filter: [0x4000204]
 # I386-NEXT:   Buckets: [4]
 # I386-NEXT:   Values: [0xB8860BA, 0xB887389]
 # I386-NEXT: }
 
-# X86_64:      Format: ELF64-x86-64
+# X86_64:      Format: elf64-x86-64
 # X86_64:      Arch: x86_64
 # X86_64:      AddressSize: 64bit
 # X86_64:      Sections [
 # X86_64:          Name: .gnu.hash
 # X86_64-NEXT:     Type: SHT_GNU_HASH
 # X86_64-NEXT:     Flags [
 # X86_64-NEXT:       SHF_ALLOC
 # X86_64-NEXT:     ]

 # X86_64-NEXT:   First Hashed Symbol Index: 4
 # X86_64-NEXT:   Num Mask Words: 1
 # X86_64-NEXT:   Shift Count: 26
 # X86_64-NEXT:   Bloom Filter: [0x400000000000204]
 # X86_64-NEXT:   Buckets: [4]
 # X86_64-NEXT:   Values: [0xB8860BA, 0xB887389]
 # X86_64-NEXT: }
 
-# PPC64:      Format: ELF64-ppc64
+# PPC64:      Format: elf64-powerpc
 # PPC64:      Arch: powerpc64
 # PPC64:      AddressSize: 64bit
 # PPC64:      Sections [
 # PPC64:          Name: .gnu.hash
 # PPC64-NEXT:     Type: SHT_GNU_HASH
 # PPC64-NEXT:     Flags [
 # PPC64-NEXT:       SHF_ALLOC
 # PPC64-NEXT:     ]

lld/test/ELF/linkerscript/linker-script-in-search-path.s

 # REQUIRES: x86
 # Check that we fall back to search paths if a linker script was not found
 # This behaviour matches ld.bfd and various projects appear to rely on this
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: rm -rf %t.dir && mkdir -p %t.dir
 # RUN: echo 'OUTPUT("%t.out")' > %t.dir/script
 # RUN: ld.lld -T%t.dir/script %t.o
 # RUN: llvm-readobj %t.out | FileCheck %s
-# CHECK: Format: ELF64-x86-64
+# CHECK: Format: elf64-x86-64
 
 # If the linker script specified with -T is missing we should emit an error
 # RUN: not ld.lld -Tscript %t.o 2>&1 | FileCheck %s -check-prefix ERROR
 # ERROR: error: cannot find linker script {{.*}}script
 
 # But if it exists in the search path we should fall back to that instead:
 # RUN: rm %t.out
 # RUN: ld.lld -L %t.dir -Tscript %t.o
 # RUN: llvm-readobj %t.out | FileCheck %s

lld/test/ELF/lto/lto-start.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld %t.o -o %t2
 ; RUN: llvm-readobj --symbols %t2 | FileCheck %s
 
-; CHECK:      Format: ELF64-x86-64
+; CHECK:      Format: elf64-x86-64
 ; CHECK-NEXT: Arch: x86_64
 ; CHECK-NEXT: AddressSize: 64bit
 
 ; CHECK:      Name: _start
 ; CHECK-NEXT: Value:
 ; CHECK-NEXT: Size: 1
 ; CHECK-NEXT: Binding: Global
 ; CHECK-NEXT: Type: Function

lld/test/ELF/lto/obj-path.ll

 ; RUN: llvm-readobj -h %t4.o2 | FileCheck %s -check-prefix=ELF2
 ; RUN: llvm-nm %t4.o1 2>&1 | FileCheck %s -check-prefix=NM1
 ; RUN: llvm-nm %t4.o2 2>&1 | FileCheck %s -check-prefix=NM2
 
 ; CHECK:      T f
 ; CHECK-NEXT: T g
 
 ; NM1: T f
-; ELF1: Format: ELF64-x86-64
+; ELF1: Format: elf64-x86-64
 
 ; NM2: T g
-; ELF2: Format: ELF64-x86-64
+; ELF2: Format: elf64-x86-64
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @g(...)
 
 define void @f() {
 entry:
   call void (...) @g()
   ret void
 }

lld/test/ELF/lto/thinlto-debug-fission.ll

 ; REQUIRES: x86
 
 ; RUN: opt %s -o %t1.o
 ; RUN: rm -rf %t.dir
 
 ; Test to ensure that --plugin-opt=dwo_dir=$DIR creates .dwo files under $DIR
 ; RUN: ld.lld --plugin-opt=dwo_dir=%t.dir -shared %t1.o -o /dev/null
 ; RUN: llvm-readobj -h %t.dir/0.dwo | FileCheck %s
 
-; CHECK: Format: ELF64-x86-64
+; CHECK: Format: elf64-x86-64
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @g(...)
 
 define void @f() {
 entry:
   call void (...) @g()
   ret void
 }

lld/test/ELF/lto/thinlto-obj-path.ll

 ; REQUIRES: x86
 
 ; RUN: opt -module-summary %s -o %t1.o
 ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
 
 ; Test to ensure that thinlto-index-only with obj-path creates the file.
 ; RUN: rm -f %t4.o
 ; RUN: ld.lld --plugin-opt=thinlto-index-only --plugin-opt=obj-path=%t4.o -shared %t1.o %t2.o -o /dev/null
 ; RUN: llvm-readobj -h %t4.o | FileCheck %s
 ; RUN: llvm-nm %t4.o 2>&1 | count 0
 
 ; Check that this also works without the --plugin-opt= prefix.
 ; RUN: rm -f %t4.o
 ; RUN: ld.lld -thinlto-index-only -lto-obj-path=%t4.o -shared %t1.o %t2.o -o /dev/null
 ; RUN: llvm-readobj -h %t4.o | FileCheck %s
 
-; CHECK: Format: ELF64-x86-64
+; CHECK: Format: elf64-x86-64
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @g(...)
 
 define void @f() {
 entry:
   call void (...) @g()
   ret void
 }

lld/test/ELF/relocatable-empty-archive.s

 # REQUIRES: x86
 # RUN: rm -f %t.a
 # RUN: llvm-ar rc %t.a
 # RUN: ld.lld -m elf_x86_64 %t.a -o %t -r
 # RUN: llvm-readobj --file-headers %t | FileCheck %s
 
-# CHECK: Format: ELF64-x86-64
+# CHECK: Format: elf64-x86-64
 # CHECK: Arch: x86_64
 # CHECK: AddressSize: 64bit
 # CHECK: Type: Relocatable

lld/test/ELF/relocatable.s

 # CHECKTEXT-NEXT: b: c7 04 25 00 00 00 00 07 00 00 00 movl $7, 0
 # CHECKTEXT:      <foo>:
 # CHECKTEXT-NEXT: 20: c7 04 25 00 00 00 00 01 00 00 00 movl $1, 0
 # CHECKTEXT-NEXT: 2b: c7 04 25 00 00 00 00 02 00 00 00 movl $2, 0
 # CHECKTEXT:      <bar>:
 # CHECKTEXT-NEXT: 40: c7 04 25 00 00 00 00 08 00 00 00 movl $8, 0
 # CHECKTEXT-NEXT: 4b: c7 04 25 00 00 00 00 09 00 00 00 movl $9, 0
 
-# CHECKEXE:       Format: ELF64-x86-64
+# CHECKEXE:       Format: elf64-x86-64
 # CHECKEXE-NEXT:  Arch: x86_64
 # CHECKEXE-NEXT:  AddressSize: 64bit
 # CHECKEXE-NEXT:  LoadName:
 # CHECKEXE-NEXT:  ElfHeader {
 # CHECKEXE-NEXT:    Ident {
 # CHECKEXE-NEXT:      Magic: (7F 45 4C 46)
 # CHECKEXE-NEXT:      Class: 64-bit
 # CHECKEXE-NEXT:      DataEncoding: LittleEndian

llvm/include/llvm/Object/ELFObjectFile.h

 
 template <class ELFT>
 StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
   switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
   case ELF::ELFCLASS32:
     switch (EF.getHeader()->e_machine) {
     case ELF::EM_386:
-      return "ELF32-i386";
+      return "elf32-i386";
     case ELF::EM_IAMCU:
-      return "ELF32-iamcu";
+      return "elf32-iamcu";
     case ELF::EM_X86_64:
-      return "ELF32-x86-64";
+      return "elf32-x86-64";
     case ELF::EM_ARM:
-      return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
+      return (IsLittleEndian ? "elf32-littlearm" : "elf32-bigarm");
     case ELF::EM_AVR:
-      return "ELF32-avr";
+      return "elf32-avr";
     case ELF::EM_HEXAGON:
-      return "ELF32-hexagon";
+      return "elf32-hexagon";
     case ELF::EM_LANAI:
-      return "ELF32-lanai";
+      return "elf32-lanai";
     case ELF::EM_MIPS:
-      return "ELF32-mips";
+      return "elf32-mips";
     case ELF::EM_MSP430:
-      return "ELF32-msp430";
+      return "elf32-msp430";
     case ELF::EM_PPC:
-      return "ELF32-ppc";
+      return "elf32-powerpc";
     case ELF::EM_RISCV:
-      return "ELF32-riscv";
+      return "elf32-littleriscv";
     case ELF::EM_SPARC:
     case ELF::EM_SPARC32PLUS:
-      return "ELF32-sparc";
+      return "elf32-sparc";
     case ELF::EM_AMDGPU:
-      return "ELF32-amdgpu";
+      return "elf32-amdgpu";
     default:
-      return "ELF32-unknown";
+      return "elf32-unknown";
     }
   case ELF::ELFCLASS64:
     switch (EF.getHeader()->e_machine) {
     case ELF::EM_386:
-      return "ELF64-i386";
+      return "elf64-i386";
     case ELF::EM_X86_64:
-      return "ELF64-x86-64";
+      return "elf64-x86-64";
     case ELF::EM_AARCH64:
-      return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big");
+      return (IsLittleEndian ? "elf64-littleaarch64" : "elf64-bigaarch64");
     case ELF::EM_PPC64:
-      return "ELF64-ppc64";
+      return "elf64-powerpc";
     case ELF::EM_RISCV:
-      return "ELF64-riscv";
+      return "elf64-littleriscv";
     case ELF::EM_S390:
-      return "ELF64-s390";
+      return "elf64-s390";
     case ELF::EM_SPARCV9:
-      return "ELF64-sparc";
+      return "elf64-sparc";
     case ELF::EM_MIPS:
-      return "ELF64-mips";
+      return "elf64-mips";
     case ELF::EM_AMDGPU:
-      return "ELF64-amdgpu";
+      return "elf64-amdgpu";
     case ELF::EM_BPF:
-      return "ELF64-BPF";
+      return "elf64-bpf";
     default:
-      return "ELF64-unknown";
+      return "elf64-unknown";
     }
   default:
     // FIXME: Proper error handling.
     report_fatal_error("Invalid ELFCLASS!");
   }
 }
 
 template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

if (Arch == Triple::UnknownArch ||
     IsMipsN64ABI = false;
     return;
   }
   if (auto *E = dyn_cast<ELFObjectFileBase>(&Obj)) {
     unsigned AbiVariant = E->getPlatformFlags();
     IsMipsO32ABI = AbiVariant & ELF::EF_MIPS_ABI_O32;
     IsMipsN32ABI = AbiVariant & ELF::EF_MIPS_ABI2;
   }
-  IsMipsN64ABI = Obj.getFileFormatName().equals("ELF64-mips");
+  IsMipsN64ABI = Obj.getFileFormatName().equals("elf64-mips");
 }
 
 // Return the .TOC. section and offset.
 Error RuntimeDyldELF::findPPC64TOCSection(const ELFObjectFileBase &Obj,
                                           ObjSectionToIDMap &LocalSections,
                                           RelocationValueRef &Rel) {
   // Set a default SectionID in case we do not find a TOC section below.
   // This may happen for references to TOC base base (sym@toc, .odp

llvm/test/CodeGen/AArch64/arm64-simplest-elf.ll

 ; RUN: llc -mtriple=arm64-linux-gnu < %s | FileCheck %s
 ; RUN: llc -mtriple=arm64-linux-gnu -filetype=obj < %s | llvm-objdump - -r -d --triple=arm64-linux-gnu | FileCheck --check-prefix=CHECK-ELF %s
 
 define void @foo() nounwind {
   ret void
 }
 
   ; Check source looks ELF-like: no leading underscore, comments with //
 ; CHECK: foo: // @foo
 ; CHECK:     ret
 
   ; Similarly make sure ELF output works and is vaguely sane: aarch64 target
   ; machine with correct section & symbol names.
-; CHECK-ELF: file format elf64-aarch64
+; CHECK-ELF: file format elf64-littleaarch64
 
 ; CHECK-ELF: Disassembly of section .text
 ; CHECK-ELF-LABEL: <foo>:
 ; CHECK-ELF:    ret

llvm/test/CodeGen/AMDGPU/elf.ll

 ; RUN: llc < %s -march=amdgcn -verify-machineinstrs -filetype=obj | llvm-readobj -S --symbols --file-headers - | FileCheck --check-prefix=ELF %s
 ; RUN: llc < %s -march=amdgcn -verify-machineinstrs -o - | FileCheck --check-prefix=CONFIG --check-prefix=TYPICAL %s
 ; RUN: llc < %s -march=amdgcn -mcpu=tonga -mattr=-flat-for-global -verify-machineinstrs -filetype=obj | llvm-readobj -S --symbols --file-headers - | FileCheck --check-prefix=ELF %s
 ; RUN: llc < %s -march=amdgcn -mcpu=tonga -mattr=-flat-for-global -verify-machineinstrs -o - | FileCheck --check-prefix=CONFIG --check-prefix=TONGA %s
 ; RUN: llc < %s -march=amdgcn -mcpu=carrizo -mattr=-flat-for-global -verify-machineinstrs -filetype=obj | llvm-readobj -S --symbols --file-headers - | FileCheck --check-prefix=ELF %s
 ; RUN: llc < %s -march=amdgcn -mcpu=carrizo -mattr=-flat-for-global -verify-machineinstrs -o - | FileCheck --check-prefix=CONFIG --check-prefix=TYPICAL %s
 
 ; Test that we don't try to produce a COFF file on windows
 ; RUN: llc < %s -mtriple=amdgcn-pc-mingw -verify-machineinstrs -filetype=obj | llvm-readobj -S --symbols --file-headers - | FileCheck --check-prefix=ELF %s
 
-; ELF: Format: ELF64-amdgpu
+; ELF: Format: elf64-amdgpu
 ; ELF: OS/ABI: SystemV (0x0)
 ; ELF: Machine: EM_AMDGPU (0xE0)
 ; ELF: Name: .AMDGPU.config
 ; ELF: Type: SHT_PROGBITS
 
 ; ELF: Symbol {
 ; ELF: Name: test
 ; ELF: Binding: Global

llvm/test/CodeGen/AMDGPU/elf.r600.ll

 ; RUN: llc < %s -march=r600 -mcpu=redwood -filetype=obj | llvm-readobj -S - | FileCheck --check-prefix=ELF %s
 ; RUN: llc < %s -march=r600 -mcpu=redwood -o - | FileCheck --check-prefix=CONFIG %s
 
-; ELF: Format: ELF32-amdgpu
+; ELF: Format: elf32-amdgpu
 ; ELF: Name: .AMDGPU.config
 
 ; CONFIG: .section .AMDGPU.config
 ; CONFIG-NEXT: .long   166100
 ; CONFIG-NEXT: .long   2
 ; CONFIG-NEXT: .long   165900
 ; CONFIG-NEXT: .long   0
 define amdgpu_kernel void @test(float addrspace(1)* %out, i32 %p) {
    %i = add i32 %p, 2
    %r = bitcast i32 %i to float
    store float %r, float addrspace(1)* %out
    ret void
 }

llvm/test/DebugInfo/AArch64/big-endian-dump.ll

 ; RUN: llc -O0 -filetype=obj -mtriple=aarch64_be-none-linux < %s | llvm-dwarfdump - | FileCheck %s
 
-; CHECK: file format ELF64-aarch64-big
+; CHECK: file format elf64-bigaarch64
 
 target datalayout = "E-m:e-i64:64-i128:128-n32:64-S128"
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 !llvm.ident = !{!5}
 
 !0 = !{i32 786449, !1, i32 12, !"clang version 3.6.0 ", i1 false, !"", i32 0, !2, !2, !2, !2, !2, !"", i32 1} ; [ DW_TAG_compile_unit ] [/a/empty.c] [DW_LANG_C99]
 !1 = !{!"empty.c", !"/a"}
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 1}
 !5 = !{!"clang version 3.6.0 "}

llvm/test/DebugInfo/AArch64/little-endian-dump.ll

 ; RUN: llc -O0 -filetype=obj -mtriple=aarch64-none-linux < %s | llvm-dwarfdump - | FileCheck %s
 
-; CHECK: file format ELF64-aarch64-little
+; CHECK: file format elf64-littleaarch64
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 !llvm.ident = !{!5}
 
 !0 = !{i32 786449, !1, i32 12, !"clang version 3.6.0 ", i1 false, !"", i32 0, !2, !2, !2, !2, !2, !"", i32 1} ; [ DW_TAG_compile_unit ] [/a/empty.c] [DW_LANG_C99]
 !1 = !{!"empty.c", !"/a"}
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 1}
 !5 = !{!"clang version 3.6.0 "}

llvm/test/DebugInfo/ARM/big-endian-dump.ll

 ; RUN: llc -O0 -filetype=obj -mtriple=armeb-none-linux < %s | llvm-dwarfdump - | FileCheck %s
 
-; CHECK: file format ELF32-arm-big
+; CHECK: file format elf32-bigarm
 
 target datalayout = "E-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5, !6}
 !llvm.ident = !{!7}
 
 !0 = !{i32 786449, !1, i32 12, !"clang version 3.6.0 ", i1 false, !"", i32 0, !2, !2, !2, !2, !2, !"", i32 1} ; [ DW_TAG_compile_unit ] [/a/empty.c] [DW_LANG_C99]
 !1 = !{!"empty.c", !"/a"}
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 1}
 !5 = !{i32 1, !"wchar_size", i32 4}
 !6 = !{i32 1, !"min_enum_size", i32 4}
 !7 = !{!"clang version 3.6.0 "}

llvm/test/DebugInfo/ARM/little-endian-dump.ll

 ; RUN: llc -O0 -filetype=obj -mtriple=arm-none-linux < %s | llvm-dwarfdump - | FileCheck %s
 
-; CHECK: file format ELF32-arm-little
+; CHECK: file format elf32-littlearm
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5, !6}
 !llvm.ident = !{!7}
 
 !0 = !{i32 786449, !1, i32 12, !"clang version 3.6.0 ", i1 false, !"", i32 0, !2, !2, !2, !2, !2, !"", i32 1} ; [ DW_TAG_compile_unit ] [/a/empty.c] [DW_LANG_C99]
 !1 = !{!"empty.c", !"/a"}
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 4}
 !4 = !{i32 2, !"Debug Info Version", i32 1}
 !5 = !{i32 1, !"wchar_size", i32 4}
 !6 = !{i32 1, !"min_enum_size", i32 4}
 !7 = !{!"clang version 3.6.0 "}

llvm/test/DebugInfo/Sparc/gnu-window-save.ll

 ; RUN: llc -filetype=obj -O0 < %s -mtriple sparc64-unknown-linux-gnu | llvm-dwarfdump -v - | FileCheck %s --check-prefix=SPARC64
 ; RUN: llc -filetype=obj -O0 < %s -mtriple sparc-unknown-linux-gnu   | llvm-dwarfdump -v - | FileCheck %s --check-prefix=SPARC32
 
 ; Check for DW_CFA_GNU_Window_save in debug_frame. Also, Ensure that relocations
 ; are performed correctly in debug_info.
 
-; SPARC64: file format ELF64-sparc
+; SPARC64: file format elf64-sparc
 
 ; SPARC64: .debug_info
 ; SPARC64:      DW_TAG_compile_unit
 ; SPARC64:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x{{[0-9,A-F,a-f]+}}] = "hello.c")
 ; SPARC64:      DW_TAG_subprogram
 ; SPARC64:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x{{[0-9,A-F,a-f]+}}] = "main")
 ; SPARC64:      DW_TAG_base_type
 ; SPARC64:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x{{[0-9,A-F,a-f]+}}] = "int")
 
 ; SPARC64: .debug_frame
 ; SPARC64:      DW_CFA_def_cfa_register
 ; SPARC64-NEXT: DW_CFA_GNU_window_save
 ; SPARC64-NEXT: DW_CFA_register
 
 
-; SPARC32: file format ELF32-sparc
+; SPARC32: file format elf32-sparc
 
 ; SPARC32: .debug_info
 ; SPARC32:      DW_TAG_compile_unit
 ; SPARC32:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x{{[0-9,A-F,a-f]+}}] = "hello.c")
 ; SPARC32:      DW_TAG_subprogram
 ; SPARC32:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x{{[0-9,A-F,a-f]+}}] = "main")
 ; SPARC32:      DW_TAG_base_type
 ; SPARC32:        DW_AT_name [DW_FORM_strp] ( .debug_str[0x{{[0-9,A-F,a-f]+}}] = "int")

llvm/test/MC/ARM/dwarf-asm-no-code.s

 // RUN: llvm-mc < %s -triple=armv7-linux-gnueabi -filetype=obj -o %t -g -fdebug-compilation-dir=/tmp
 // RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF %s
 // RUN: llvm-objdump -r %t | FileCheck --check-prefix=RELOC %s
 
 // If there is no code in an assembly file, no debug info is produced
 
 .section .data, "aw"
 a:
 .long 42
 
-// DWARF: ELF32-arm-little
+// DWARF: elf32-littlearm
 // DWARF-NOT: contents:
 // DWARF: .debug_line contents:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_info]:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_aranges]:

llvm/test/MC/AVR/dwarf-asm-no-code.s

 // RUN: llvm-mc < %s -triple=avr -filetype=obj -o %t -g -fdebug-compilation-dir=/tmp
 // RUN: llvm-dwarfdump -v %t | FileCheck -check-prefix DWARF %s
 // RUN: llvm-objdump -r %t | FileCheck --check-prefix=RELOC %s
 
 // If there is no code in an assembly file, no debug info is produced
 
 .section .data, "aw"
 a:
 .long 42
 
-// DWARF: ELF32-avr
+// DWARF: elf32-avr
 // DWARF-NOT: contents:
 // DWARF: .debug_line contents:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_info]:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
 
 // RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_aranges]:

llvm/test/MC/AsmParser/non-english-characters.s

 # RUN: llvm-mc -triple i386-linux-gnu -filetype=obj -o %t \
 # RUN:   %S/Inputs/non-english-characters-comments.s
 # RUN: llvm-readobj %t | FileCheck %s
-# CHECK: Format: ELF32-i386
+# CHECK: Format: elf32-i386
 
 # RUN: not llvm-mc -triple i386-linux-gnu -filetype=obj -o %t \
 # RUN:   %S/Inputs/non-english-characters-section-name.s 2>&1 | \
 # RUN:     FileCheck %s --check-prefix=ERR
 # ERR: invalid character in input

llvm/test/MC/ELF/empty.s

 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -S | FileCheck %s
 // RUN: llvm-mc -filetype=obj -triple x86_64-apple-darwin14.0.0-elf %s -o - | llvm-readobj -S | FileCheck %s -check-prefix=DARWIN
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-win32-elf %s -o - | llvm-readobj -S | FileCheck %s -check-prefix=WINDOWS
 
 // Check that we can create ELF files for darwin/windows, even though
 // it is not the default file format.
 
-// DARWIN:       Format: ELF64-x86-64
-// WINDOWS:      Format: ELF64-x86-64
+// DARWIN:       Format: elf64-x86-64
+// WINDOWS:      Format: elf64-x86-64
 // DARWIN-NEXT:  Arch: x86_64
 // WINDOWS-NEXT: Arch: x86_64
 
 // Test that we create text by default. Also test that symtab and strtab are
 // listed.
 
 // CHECK:        Section {
 // CHECK:          Name: .strtab

llvm/test/MC/ELF/relocation-386.s

 // RUN: llvm-mc -filetype=obj -triple i386-pc-linux-gnu %s -relax-relocations=false -o - | llvm-readobj -r  | FileCheck  %s --check-prefix=CHECK --check-prefix=I386
 // RUN: llvm-mc -filetype=obj -triple i386-pc-elfiamcu %s -relax-relocations=false  -o - | llvm-readobj -r  | FileCheck  %s --check-prefix=CHECK --check-prefix=IAMCU
 
 // Test that we produce the correct relocation types and that the relocations
 // correctly point to the section or the symbol.
 
-// IAMCU: Format: ELF32-iamcu
-// I386: Format: ELF32-i386
+// IAMCU: Format: elf32-iamcu
+// I386: Format: elf32-i386
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section {{.*}} .rel.text {
 // CHECK-NEXT:     0x2          R_386_GOTOFF     .Lfoo 0x0
 // CHECK-NEXT:     0x{{[^ ]+}}  R_386_PLT32      bar2 0x0
 // CHECK-NEXT:     0x{{[^ ]+}}  R_386_GOTPC      _GLOBAL_OFFSET_TABLE_ 0x0
 // Relocation 3 (bar3@GOTOFF) is done with symbol 7 (bss)
 // CHECK-NEXT:     0x{{[^ ]+}}  R_386_GOTOFF     .bss 0x0
 // Relocation 4 (bar2@GOT) is of type R_386_GOT32

llvm/test/MC/Hexagon/basic.ll

 ;; RUN: llc -mtriple=hexagon-unknown-elf -filetype=obj %s -o - \
 ;; RUN: | llvm-readobj -h -r | FileCheck -check-prefix=OBJ %s
 
-; OBJ: Format: ELF32-hexagon
+; OBJ: Format: elf32-hexagon
 ; OBJ: Arch: hexagon
 ; OBJ: AddressSize: 32bit
 ; OBJ: Machine: EM_HEXAGON (0xA4)

llvm/test/MC/RISCV/elf-header.s

 # RUN: llvm-mc %s -filetype=obj -triple=riscv32 | llvm-readobj -h \
 # RUN:     | FileCheck -check-prefix=RV32 %s
 # RUN: llvm-mc %s -filetype=obj -triple=riscv64 | llvm-readobj -h \
 # RUN:     | FileCheck -check-prefix=RV64 %s
 
-# RV32: Format: ELF32-riscv
+# RV32: Format: elf32-littleriscv
 # RV32: Arch: riscv32
 # RV32: AddressSize: 32bit
 # RV32: ElfHeader {
 # RV32:   Ident {
 # RV32:     Magic: (7F 45 4C 46)
 # RV32:     Class: 32-bit (0x1)
 # RV32:     DataEncoding: LittleEndian (0x1)
 # RV32:     FileVersion: 1
 # RV32:     OS/ABI: SystemV (0x0)
 # RV32:     ABIVersion: 0
 # RV32:   }
 # RV32:   Type: Relocatable (0x1)
 # RV32:   Machine: EM_RISCV (0xF3)
 # RV32:   Version: 1
 # RV32:   Flags [ (0x0)
 # RV32:   ]
 # RV32: }
 
-# RV64: Format: ELF64-riscv
+# RV64: Format: elf64-littleriscv
 # RV64: Arch: riscv64
 # RV64: AddressSize: 64bit
 # RV64: ElfHeader {
 # RV64:   Ident {
 # RV64:     Magic: (7F 45 4C 46)
 # RV64:     Class: 64-bit (0x2)
 # RV64:     DataEncoding: LittleEndian (0x1)
 # RV64:     FileVersion: 1

llvm/test/MC/Sparc/sparc-relocations.s

 ! RUN: llvm-mc %s -arch=sparcv9 -show-encoding | FileCheck %s
 ! RUN: llvm-mc %s -arch=sparcv9 -filetype=obj | llvm-readobj -r | FileCheck %s --check-prefix=CHECK-OBJ
 
-        ! CHECK-OBJ: Format: ELF64-sparc
+        ! CHECK-OBJ: Format: elf64-sparc
         ! CHECK-OBJ: Relocations [
         ! CHECK-OBJ: 0x{{[0-9,A-F]+}} R_SPARC_WDISP30 foo
         ! CHECK-OBJ: 0x{{[0-9,A-F]+}} R_SPARC_LO10 sym
         ! CHECK-OBJ: 0x{{[0-9,A-F]+}} R_SPARC_HI22 sym
         ! CHECK-OBJ: 0x{{[0-9,A-F]+}} R_SPARC_H44 sym
         ! CHECK-OBJ: 0x{{[0-9,A-F]+}} R_SPARC_M44 sym
         ! CHECK-OBJ: 0x{{[0-9,A-F]+}} R_SPARC_L44 sym
         ! CHECK-OBJ: 0x{{[0-9,A-F]+}} R_SPARC_HH22 sym

llvm/test/Object/AMDGPU/elf32-unknown.yaml

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -S --file-headers %t.o | FileCheck %s
 
-# CHECK: Format: ELF32-amdgpu
+# CHECK: Format: elf32-amdgpu
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_AMDGPU

llvm/test/Object/AMDGPU/elf64-unknown.yaml

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -S --file-headers %t.o | FileCheck %s
 
-# CHECK: Format: ELF64-amdgpu
+# CHECK: Format: elf64-amdgpu
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_AMDGPU

llvm/test/Object/invalid-alignment.test

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -r %t.o 2>&1 | FileCheck %s
 
-# CHECK:      Format: ELF64-x86-64
+# CHECK:      Format: elf64-x86-64
 # CHECK-NEXT: Arch: x86_64
 # CHECK-NEXT: AddressSize: 64bit
 # CHECK-NEXT: LoadName:
 # CHECK-NEXT: Relocations [
 # CHECK-NEXT:   Section (2) .rela.foo {
 # CHECK-NEXT:     0x0 R_X86_64_NONE - 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

llvm/test/ThinLTO/X86/empty-module.ll

 ; RUN: opt -module-summary -o %t.bc %s
 
 ; RUN: rm -f %t2.0
 ; RUN: llvm-lto2 run  %t.bc -r %t.bc,foo,pl -o %t2 -thinlto-distributed-indexes
 ; RUN: llvm-readobj -h %t2.0 | FileCheck %s
 ; RUN: llvm-nm %t2.0 2>&1 | count 0
 
-; CHECK: Format: ELF64-x86-64
+; CHECK: Format: elf64-x86-64
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo = ifunc i32 (i32), i64 ()* @foo_ifunc
 
 define internal i64 @foo_ifunc() {
 entry:
   ret i64 0
 }

llvm/test/tools/gold/X86/thinlto.ll

 ; RUN:    --plugin-opt=thinlto-index-only \
 ; RUN:    --plugin-opt=obj-path=%t5.o \
 ; RUN:    -shared %t.o %t2.o -o %t4
 ; RUN: llvm-readobj -h %t5.o | FileCheck %s --check-prefix=FORMAT
 ; RUN: llvm-nm %t5.o 2>&1 | count 0
 
 ; NM: T f
 ; NM2: T {{f|g}}
-; FORMAT: Format: ELF64-x86-64
+; FORMAT: Format: elf64-x86-64
 
 ; The backend index for this module contains summaries from itself and
 ; Inputs/thinlto.ll, as it imports from the latter.
 ; BACKEND1: <MODULE_STRTAB_BLOCK
 ; BACKEND1-NEXT: <ENTRY {{.*}} record string = '{{.*}}/test/tools/gold/X86/Output/thinlto.ll.tmp{{.*}}.o'
 ; BACKEND1-NEXT: <ENTRY {{.*}} record string = '{{.*}}/test/tools/gold/X86/Output/thinlto.ll.tmp{{.*}}.o'
 ; BACKEND1-NEXT: </MODULE_STRTAB_BLOCK
 ; BACKEND1-NEXT: <GLOBALVAL_SUMMARY_BLOCK

llvm/test/tools/llvm-objcopy/ELF/binary-output-target.test

 
 # RUN: llvm-objcopy -I binary -O elf32-sparc %t.txt %t.sparc.o
 # RUN: llvm-readobj --file-headers %t.sparc.o | FileCheck %s --check-prefixes=CHECK,BE,SPARC,32
 
 # RUN: llvm-objcopy -I binary -O elf32-sparcel %t.txt %t.sparcel.o
 # RUN: llvm-readobj --file-headers %t.sparcel.o | FileCheck %s --check-prefixes=CHECK,LE,SPARCEL,32
 
 # CHECK: Format:
-# 32-SAME:      ELF32-
-# 64-SAME:      ELF64-
-# AARCH64-SAME: aarch64-little
-# ARM-SAME:     arm-little
+# 32-SAME:      elf32-
+# 64-SAME:      elf64-
+# AARCH64-SAME: littleaarch64
+# ARM-SAME:     littlearm
 # I386-SAME:    i386
 # MIPS-SAME:    mips{{$}}
 # RISCV32-SAME: riscv{{$}}
 # RISCV64-SAME: riscv{{$}}
-# PPC-SAME:     ppc{{$}}
-# PPC64le-SAME: ppc64
+# PPC-SAME:     powerpc{{$}}
+# PPC64le-SAME: powerpc{{$}}
 # SPARC-SAME:   sparc
 # SPARCEL-SAME: sparc
 # X86-64-SAME:  x86-64
 
 # AARCH64-NEXT: Arch: aarch64
 # ARM-NEXT:     Arch: arm
 # I386-NEXT:    Arch: i386
 # MIPS-NEXT:    Arch: mips{{$}}

llvm/test/tools/llvm-objcopy/ELF/cross-arch-headers.test

- Name:     foo
     Binding:  STB_GLOBAL
   - Name:     bar
     Type:     STT_OBJECT
     Section:  .data
     Value:    0xabcd
     Binding:  STB_GLOBAL
 
 # CHECK: Format:
-# 32-SAME:      ELF32-
-# 64-SAME:      ELF64-
+# 32-SAME:      elf32-
+# 64-SAME:      elf64-
 # I386-SAME:    i386
 # IAMCU-SAME:   iamcu
 # AARCH-SAME:   aarch64
-# ARM-SAME:     arm-little
+# ARM-SAME:     littlearm
 # MIPS-SAME:    mips
-# PPC-SAME:     ppc{{$}}
-# PPC64BE-SAME: ppc64{{$}}
-# PPC64LE-SAME: ppc64{{$}}
+# PPC-SAME:     powerpc{{$}}
+# PPC64BE-SAME: powerpc{{$}}
+# PPC64LE-SAME: powerpc{{$}}
 # RISCV32-SAME: riscv{{$}}
 # RISCV64-SAME: riscv{{$}}
 # SPARC-SAME:   sparc
 # X86-64-SAME:  x86-64
 # DEFAULT-SAME: unknown
 
 # I386-NEXT:     Arch: i386
 # IAMCU-NEXT:    Arch: i386

llvm/test/tools/llvm-objcopy/ELF/many-sections.test

 RUN: %python %p/../Inputs/ungzip.py %p/Inputs/many-sections.o.gz > %t
 RUN: llvm-objcopy %t %t2
 RUN: llvm-readobj --file-headers %t2 | FileCheck --check-prefix=EHDR %s
 RUN: llvm-readobj --sections %t2 | FileCheck --check-prefix=SECS %s
 RUN: llvm-readobj --symbols %t2 | grep "Symbol {" | wc -l | FileCheck --check-prefix=SYMS %s
 RUN: llvm-readobj --symbols %t2 | FileCheck %s --check-prefix=SYM_SEC_IDS
 
-EHDR:      Format: ELF64-x86-64
+EHDR:      Format: elf64-x86-64
 EHDR-NEXT: Arch: x86_64
 EHDR-NEXT: AddressSize: 64bit
 EHDR-NEXT: LoadName:
 EHDR-NEXT: ElfHeader {
 EHDR-NEXT:   Ident {
 EHDR-NEXT:     Magic: (7F 45 4C 46)
 EHDR-NEXT:     Class: 64-bit (0x2)
 EHDR-NEXT:     DataEncoding: LittleEndian (0x1)

llvm/test/tools/llvm-readobj/ELF/all.test

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -a %t.o | FileCheck %s --check-prefix LLVM-ALL
 # RUN: llvm-readobj --all %t.o | FileCheck %s --check-prefix LLVM-ALL
 
-# LLVM-ALL: Format: ELF32-i386
+# LLVM-ALL: Format: elf32-i386
 # LLVM-ALL: Arch: i386
 # LLVM-ALL: AddressSize: 32bit
 # LLVM-ALL: LoadName:
 # LLVM-ALL: ElfHeader {
 # LLVM-ALL: Sections [
 # LLVM-ALL: ProgramHeaders [
 # LLVM-ALL: Relocations [
 # LLVM-ALL: EHFrameHeader {

llvm/test/tools/llvm-readobj/ELF/amdgpu-elf-definitions.test

 RUN: llvm-readobj --file-headers -l -S --symbols %p/Inputs/trivial.obj.elf-amdhsa-gfx803 | FileCheck %s
 
-CHECK: Format: ELF64-amdgpu
+CHECK: Format: elf64-amdgpu
 CHECK: Arch: unknown
 CHECK: ElfHeader {
 CHECK:   Ident {
 CHECK:     OS/ABI: AMDGPU_HSA (0x40)
 CHECK:     ABIVersion: 0
 CHECK:   }
 CHECK:   Machine: EM_AMDGPU (0xE0)
 CHECK: }

llvm/test/tools/llvm-readobj/ELF/basic.test

 ## Test the case where no switches are specified.
 
 # RUN: yaml2obj %s -o %t.trivial.obj.elf-x86-64
 # RUN: llvm-readobj %t.trivial.obj.elf-x86-64 | FileCheck --check-prefix=HEADER %s
 # RUN: llvm-readelf %t.trivial.obj.elf-x86-64 | FileCheck --check-prefix=NO-OUTPUT --allow-empty %s
 
 # HEADER: File: {{.*}}trivial.obj.elf-x86-64
-# HEADER: Format: ELF64-x86-64
+# HEADER: Format: elf64-x86-64
 # HEADER: Arch: x86_64
 # HEADER: AddressSize: 64bit
 
 # NO-OUTPUT-NOT: {{.}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64

llvm/test/tools/llvm-readobj/ELF/dynamic-no-pt-dynamic.test

 ## Show that dumping occurs even if there is no PT_DYNAMIC header.
 ## This is inconsistent with the GNU behavior, but seems to be more reasonable.
 # RUN: yaml2obj %s -o %t.no-phdr
 # RUN: llvm-readobj --dynamic-table %t.no-phdr | FileCheck %s --check-prefix=LLVM
 # RUN: llvm-readelf --dynamic-table %t.no-phdr | FileCheck %s --check-prefix=GNU
 
 # LLVM:      File: {{.*}}.no-phdr
-# LLVM-NEXT: Format: ELF64-x86-64
+# LLVM-NEXT: Format: elf64-x86-64
 # LLVM-NEXT: Arch: x86_64
 # LLVM-NEXT: AddressSize: 64bit
 # LLVM-NEXT: LoadName:{{ *}}
 # LLVM-NEXT: DynamicSection [ (1 entries)
 # LLVM-NEXT:   Tag                Type Name/Value
 # LLVM-NEXT:   0x0000000000000000 NULL 0x0
 # LLVM-NEXT: ]
 

llvm/test/tools/llvm-readobj/ELF/file-headers.test

 # RUN: yaml2obj %s --docnum=1 -o %t.i386
 # RUN: llvm-readobj -h %t.i386 | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.i386 --check-prefix I386
 # RUN: llvm-readobj --file-header %t.i386 | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.i386 --check-prefix I386
 # RUN: llvm-readobj --file-headers %t.i386 | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.i386 --check-prefix I386
 
 #      I386:File: [[FILE]]
-# I386-NEXT:Format: ELF32-i386
+# I386-NEXT:Format: elf32-i386
 # I386-NEXT:Arch: i386
 # I386-NEXT:AddressSize: 32bit
 # I386-NEXT:LoadName: <Not found>
 # I386-NEXT:ElfHeader {
 # I386-NEXT:  Ident {
 # I386-NEXT:    Magic: (7F 45 4C 46)
 # I386-NEXT:    Class: 32-bit (0x1)
 # I386-NEXT:    DataEncoding: LittleEndian (0x1)

 # RUN: llvm-readobj -h %t.x86-64 \
 # RUN:  | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.x86-64 --check-prefix X86-64
 # RUN: llvm-readobj --file-header %t.x86-64 \
 # RUN:  | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.x86-64 --check-prefix X86-64
 # RUN: llvm-readobj --file-headers %t.x86-64 \
 # RUN:  | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.x86-64 --check-prefix X86-64
 
 #      X86-64:File: [[FILE]]
-# X86-64-NEXT:Format: ELF64-x86-64
+# X86-64-NEXT:Format: elf64-x86-64
 # X86-64-NEXT:Arch: x86_64
 # X86-64-NEXT:AddressSize: 64bit
 # X86-64-NEXT:LoadName: <Not found>
 # X86-64-NEXT:ElfHeader {
 # X86-64-NEXT:  Ident {
 # X86-64-NEXT:    Magic: (7F 45 4C 46)
 # X86-64-NEXT:    Class: 64-bit (0x2)
 # X86-64-NEXT:    DataEncoding: LittleEndian (0x1)

 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: EM_LANAI
 
 #      LANAI:File: [[FILE]]
-# LANAI-NEXT:Format: ELF32-lanai
+# LANAI-NEXT:Format: elf32-lanai
 # LANAI-NEXT:Arch: lanai
 # LANAI-NEXT:AddressSize: 32bit
 # LANAI-NEXT:LoadName: <Not found>
 # LANAI-NEXT:ElfHeader {
 # LANAI-NEXT:  Ident {
 # LANAI-NEXT:    Magic: (7F 45 4C 46)
 # LANAI-NEXT:    Class: 32-bit (0x1)
 # LANAI-NEXT:    DataEncoding: BigEndian (0x2)

llvm/test/tools/llvm-readobj/ELF/loadname.test

 ## Check we are able to dump library soname properly.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj %t.o | FileCheck %s --check-prefix LLVM
 # RUN: llvm-readelf --dynamic-table %t.o | FileCheck %s --check-prefix GNU
 
-# LLVM:      Format: ELF64-x86-64
+# LLVM:      Format: elf64-x86-64
 # LLVM-NEXT: Arch: x86_64
 # LLVM-NEXT: AddressSize: 64bit
 # LLVM-NEXT: LoadName: test.so
 
 # GNU:       Dynamic section at offset 0x80 contains 4 entries:
 # GNU-NEXT:   Tag                Type     Name/Value
 # GNU-NEXT:   0x0000000000000005 (STRTAB) 0x0
 # GNU-NEXT:   0x000000000000000a (STRSZ)  7 (bytes)

llvm/test/tools/llvm-readobj/ELF/no-action.test

 ## Show the behavior of llvm-readobj/llvm-readelf when no operations are requested.
 
 ## Check the behavior on ET_EXEC input.
 
 # RUN: yaml2obj --docnum=1 %s -o %t.exe
 # RUN: llvm-readobj %t.exe | FileCheck %s -DFILE=%t.exe --check-prefix LLVM
 # RUN: llvm-readelf %t.exe | FileCheck %s -DFILE=%t.exe --check-prefix GNU --allow-empty
 
 # LLVM: File: [[FILE]]
-# LLVM: Format: ELF64-x86-64
+# LLVM: Format: elf64-x86-64
 # LLVM: Arch: x86_64
 # LLVM: AddressSize: 64bit
 # LLVM: LoadName: <Not found>{{$}}
 # LLVM-EMPTY:
 # LLVM-NOT: {{.}}
 
 # GNU-NOT: {{.}}
 

llvm/test/tools/llvm-readobj/ELF/ppc64-glink.test

 # Check DT_PPC64_GLINK dynamic tag.
 
 RUN: llvm-readobj --dynamic-table %p/Inputs/ppc64.exe | FileCheck %s
 
-CHECK: Format: ELF64-ppc64
+CHECK: Format: elf64-powerpc
 CHECK: Arch: powerpc64le
 CHECK: AddressSize: 64bit
 
 CHECK:      DynamicSection [ (25 entries)
 CHECK-NEXT:   Tag                Type                 Name/Value
 CHECK:        0x0000000070000000 PPC64_GLINK          0x10000830

llvm/test/tools/llvm-readobj/ELF/program-headers.test

 # ELF-X86-64-NEXT:     ]
 # ELF-X86-64-NEXT:     Alignment: 8
 # ELF-X86-64-NEXT:   }
 # ELF-X86-64-NEXT: ]
 
 # RUN: llvm-readobj -l %p/../../../Object/Inputs/program-headers.mips \
 # RUN:     | FileCheck %s -check-prefix ELF-MIPS
 
-# ELF-MIPS:      Format: ELF32-mips
+# ELF-MIPS:      Format: elf32-mips
 # ELF-MIPS-NEXT: Arch: mips
 # ELF-MIPS-NEXT: AddressSize: 32bit
 # ELF-MIPS-NEXT: LoadName:
 # ELF-MIPS-NEXT: ProgramHeaders [
 # ELF-MIPS-NEXT:   ProgramHeader {
 # ELF-MIPS-NEXT:     Type: PT_MIPS_ABIFLAGS (0x70000003)
 # ELF-MIPS-NEXT:     Offset: 0x98
 # ELF-MIPS-NEXT:     VirtualAddress: 0x400098

 # ELF-MIPS-NEXT:     ]
 # ELF-MIPS-NEXT:     Alignment: 65536
 # ELF-MIPS-NEXT:   }
 # ELF-MIPS-NEXT: ]
 
 # RUN: llvm-readobj -l %p/../../../Object/Inputs/program-headers.mips64 \
 # RUN:     | FileCheck %s -check-prefix ELF-MIPS64
 
-# ELF-MIPS64:      Format: ELF64-mips
+# ELF-MIPS64:      Format: elf64-mips
 # ELF-MIPS64-NEXT: Arch: mips64
 # ELF-MIPS64-NEXT: AddressSize: 64bit
 # ELF-MIPS64-NEXT: LoadName:
 # ELF-MIPS64-NEXT: ProgramHeaders [
 # ELF-MIPS64-NEXT:   ProgramHeader {
 # ELF-MIPS64-NEXT:     Type: PT_LOAD (0x1)
 # ELF-MIPS64-NEXT:     Offset: 0x0
 # ELF-MIPS64-NEXT:     VirtualAddress: 0x120000000

llvm/test/tools/llvm-readobj/archive.test

 ## Show that dumping operations apply to all members in an archive.
 
 # RUN: rm -f %t.a
 # RUN: rm -rf %t.dir
 # RUN: mkdir -p %t.dir
 # RUN: yaml2obj --docnum=1 %s -o %t.dir/trivial.obj.elf-x86-64
 # RUN: yaml2obj --docnum=2 %s -o %t.dir/trivial.obj.elf-i386
 # RUN: yaml2obj --docnum=3 %s -o %t.dir/trivial.obj.coff-arm
 
 # RUN: llvm-ar rc %t.a %t.dir/trivial.obj.elf-x86-64 %t.dir/trivial.obj.elf-i386 %t.dir/trivial.obj.coff-arm
 # RUN: llvm-readobj --all %t.a | FileCheck %s -DARFILE="%t.a" --check-prefixes=HEADER,LLVM,COFF
 # RUN: llvm-readelf --all %t.a | FileCheck %s -DARFILE="%t.a" --check-prefixes=HEADER,GNU,COFF
 
 # LLVM: {{^$}}
 # LLVM-NEXT: File: [[ARFILE]](trivial.obj.elf-x86-64)
-# LLVM: Format: ELF64-x86-64
+# LLVM: Format: elf64-x86-64
 # LLVM: ElfHeader {
 # LLVM:   Machine: EM_X86_64
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 # LLVM: Notes [
 # LLVM: ]
 # LLVM: StackSizes [
 # LLVM: ]
 
 # GNU: {{^$}}
 # GNU-NEXT: File: [[ARFILE]](trivial.obj.elf-x86-64)
 # GNU: ELF Header:
 # GNU:   Machine: Advanced Micro Devices X86-64
 # GNU: Section Headers:
 # GNU: There are no section groups in this file.
 
 # LLVM-EMPTY:
 # LLVM-NEXT: File: [[ARFILE]](trivial.obj.elf-i386)
-# LLVM: Format: ELF32-i386
+# LLVM: Format: elf32-i386
 # LLVM: ElfHeader {
 # LLVM:   Machine: EM_386
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 # LLVM: Notes [
 # LLVM: ]
 # LLVM: StackSizes [

llvm/test/tools/llvm-readobj/thin-archive.test

 # RUN: rm -f %t.a
 # RUN: rm -rf %t
 # RUN: mkdir -p %t
 # RUN: yaml2obj --docnum=1 %s -o %t/1.o
 # RUN: yaml2obj --docnum=2 %s -o %t/2.o
 # RUN: yaml2obj --docnum=3 %s -o %t/3.o
 # RUN: llvm-ar rcT %t.a %t/1.o %t/2.o %t/3.o
 
 # Test that basic dumping works for all members.
 # RUN: llvm-readobj --all %t.a | FileCheck %s --check-prefixes=LLVM,COFF
 # RUN: llvm-readelf --all %t.a | FileCheck %s --check-prefixes=GNU,COFF
 
 # LLVM: File: {{.*}}1.o
-# LLVM: Format: ELF64-x86-64
+# LLVM: Format: elf64-x86-64
 # LLVM: ElfHeader {
 # LLVM:   SectionHeaderCount: 3
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 
 # GNU: ELF Header:
 # GNU:   Number of section headers: 3
 # GNU: Section Headers:
 
 # LLVM: File: {{.*}}2.o
-# LLVM: Format: ELF32-i386
+# LLVM: Format: elf32-i386
 # LLVM: ElfHeader {
 # LLVM:   SectionHeaderCount: 4
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 
 # GNU: ELF Header:
 # GNU:   Number of section headers: 4
 # GNU: Section Headers:
 
 # LLVM: File: {{.*}}3.o
 # LLVM: Format: COFF-ARM
 # COFF: ImageFileHeader {
 # COFF: Sections [
 # COFF: Relocations [
 # COFF: Symbols [
 
 # Overwrite one of the members with a member of a different size to show that
 # the size field in the member header is not relevant.
 # RUN: rm -f %t/2.o
 # RUN: cp %t/1.o %t/2.o
 # RUN: llvm-readobj --file-headers %t.a | FileCheck %s --check-prefix=RESIZED
 
 # RESIZED: File: {{.*}}1.o
-# RESIZED: Format: ELF64-x86-64
+# RESIZED: Format: elf64-x86-64
 # RESIZED: File: {{.*}}2.o
-# RESIZED: Format: ELF64-x86-64
+# RESIZED: Format: elf64-x86-64
 
 # Remove the second member and show that the first can still be dumped, but that the last isn't.
 # RUN: rm %t/2.o
 # RUN: not llvm-readobj --file-headers %t.a 2> %t.err | FileCheck %s --check-prefix=MISSING
 # RUN: FileCheck %s --check-prefix=ERR --input-file=%t.err
 
 # MISSING:     File: {{.*}}1.o
-# MISSING:     Format: ELF64-x86-64
+# MISSING:     Format: elf64-x86-64
 # MISSING-NOT: File: {{.*}}3.o
 # ERR: error: '{{.*}}.a': '{{.*}}2.o': {{[Nn]}}o such file or directory
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL