[ifs][elfabi] Merge llvm-ifs/elfabi tools

[haowei]

Summary

This change merges llvm-elfabi and llvm-ifs tools.

[haowei]

Rebase the change to resolve presubmit errors.

[phosek]

LGTM

clang/lib/Driver/ToolChains/InterfaceStubs.cpp

18

Ideally, this job would use the IFS library to construct .ifs or stub file directly without invoking an external tool. Can you please leave a TODO here along those lines?

llvm/tools/llvm-ifs/llvm-ifs.cpp

47–48

Ideally we would use OptTable for option parsing, can you please leave a TODO comment here along those lines?

264–265

415

No need for { and } here and below since each if has only one statement.

clang/cmake/caches/Fuchsia-stage2.cmake

 set(LLVM_TOOLCHAIN_TOOLS
   dsymutil
   llvm-ar
   llvm-cov
   llvm-cxxfilt
   llvm-dlltool
   llvm-dwarfdump
   llvm-dwp
-  llvm-elfabi
+  llvm-ifs
   llvm-gsymutil
   llvm-lib
   llvm-lipo
   llvm-mt
   llvm-nm
   llvm-objcopy
   llvm-objdump
   llvm-profdata

clang/lib/Driver/ToolChains/InterfaceStubs.cpp

 #include "CommonArgs.h"
 #include "clang/Driver/Compilation.h"
 #include "llvm/Support/Path.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace ifstool {
 void Merger::ConstructJob(Compilation &C, const JobAction &JA,
                           const InputInfo &Output, const InputInfoList &Inputs,
                           const llvm::opt::ArgList &Args,
                           const char *LinkingOutput) const {
   std::string Merger = getToolChain().GetProgramPath(getShortName());
   llvm::opt::ArgStringList CmdArgs;
-  CmdArgs.push_back("-action");
+  CmdArgs.push_back("--input-format=IFS");
   const bool WriteBin = !Args.getLastArg(options::OPT_emit_merged_ifs);
-  CmdArgs.push_back(WriteBin ? "write-bin" : "write-ifs");
+  CmdArgs.push_back(WriteBin ? "--output-format=ELF" : "--output-format=IFS");
   CmdArgs.push_back("-o");
 
   // Normally we want to write to a side-car file ending in ".ifso" so for
   // example if `clang -emit-interface-stubs -shared -o libhello.so` were
   // invoked then we would like to get libhello.so and libhello.ifso. If the
   // stdout stream is given as the output file (ie `-o -`), that is the one
   // exception where we will just append to the same filestream as the normal
   // output.

clang/test/InterfaceStubs/driver-test.c

 // REQUIRES: x86-registered-target
 // REQUIRES: shell
 
 // NOTE: -fno-integrated-cc1 has been added to work around an ASAN failure
 //       caused by in-process cc1 invocation. Clang InterfaceStubs is not the
 //       culprit, but Clang Interface Stubs' Driver pipeline setup uncovers an
 //       existing ASAN issue when invoking multiple normal cc1 jobs along with
 //       multiple Clang Interface Stubs cc1 jobs together.
 //       There is currently a discussion of this going on at:
 //         https://reviews.llvm.org/D69825
 // RUN: mkdir -p %t; cd %t
 // RUN: %clang -target x86_64-unknown-linux-gnu -x c -S \
 // RUN:   -fno-integrated-cc1 \
 // RUN: -emit-interface-stubs %s %S/object.c %S/weak.cpp && \
-// RUN: llvm-nm %t/a.out.ifso 2>&1 | FileCheck --check-prefix=CHECK-IFS %s
+// RUN: llvm-nm -D %t/a.out.ifso 2>&1 | FileCheck --check-prefix=CHECK-IFS %s
 
 // CHECK-IFS-DAG: data
 // CHECK-IFS-DAG: foo
 // CHECK-IFS-DAG: strongFunc
 // CHECK-IFS-DAG: weakFunc
 
 int foo(int bar) { return 42 + 1844; }

llvm/include/llvm/InterfaceStub/ELFObjHandler.h

 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Support/FileSystem.h"
 
 namespace llvm {
 
 class MemoryBuffer;
 
-namespace elfabi {
+namespace ifs {
 
 /// Attempt to read a binary ELF file from a MemoryBuffer.
 Expected<std::unique_ptr<IFSStub>> readELFFile(MemoryBufferRef Buf);
 
 /// Attempt to write a binary ELF stub.
 /// This function determines appropriate ELFType using the passed ELFTarget and
 /// then writes a binary ELF stub to a specified file path.
 ///
 /// @param FilePath File path for writing the ELF binary.
 /// @param Stub Source ELFStub to generate a binary ELF stub from.
 /// @param WriteIfChanged Whether or not to preserve timestamp if
 ///        the output stays the same.
 Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub,
                       bool WriteIfChanged = false);
 
-} // end namespace elfabi
+} // end namespace ifs
 } // end namespace llvm
 
 #endif // LLVM_INTERFACESTUB_ELFOBJHANDLER_H

llvm/include/llvm/InterfaceStub/IFSHandler.h

 #include <memory>
 
 namespace llvm {
 
 class raw_ostream;
 class Error;
 class StringRef;
 
-namespace elfabi {
+namespace ifs {
 
 struct IFSStub;
 
 const VersionTuple IFSVersionCurrent(3, 0);
 
 /// Attempts to read an IFS interface file from a StringRef buffer.
 Expected<std::unique_ptr<IFSStub>> readIFSFromBuffer(StringRef Buf);
 

 
 /// Strips target platform information from the text stub.
 void stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
                     bool StripEndianness, bool StripBitWidth);
 
 /// Parse llvm triple string into a IFSTarget struct.
 IFSTarget parseTriple(StringRef TripleStr);
 
-} // end namespace elfabi
+} // end namespace ifs
 } // end namespace llvm
 
 #endif // LLVM_INTERFACESTUB_IFSHANDLER_H

llvm/include/llvm/InterfaceStub/IFSStub.h

 #define LLVM_INTERFACESTUB_IFSSTUB_H
 
 #include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include <set>
 #include <vector>
 
 namespace llvm {
-namespace elfabi {
+namespace ifs {
 
 typedef uint16_t IFSArch;
 
 enum class IFSSymbolType {
   NoType,
   Object,
   Func,
   TLS,

 
 /// This function extracts symbol type from a symbol's st_info member and
 /// maps it to an IFSSymbolType enum.
 /// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
 /// Other symbol types are mapped to IFSSymbolType::Unknown.
 ///
 /// @param SymbolType Binary symbol st_info to extract symbol type from.
 IFSSymbolType convertELFSymbolTypeToIFS(uint8_t SymbolType);
-} // end namespace elfabi
+} // namespace ifs
 } // end namespace llvm
 
 #endif // LLVM_INTERFACESTUB_IFSSTUB_H

llvm/lib/InterfaceStub/ELFObjHandler.cpp

 using llvm::MemoryBufferRef;
 using llvm::object::ELFObjectFile;
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 namespace llvm {
-namespace elfabi {
+namespace ifs {
 
 // Simple struct to hold relevant .dynamic entries.
 struct DynamicEntries {
   uint64_t StrTabAddr = 0;
   uint64_t StrSize = 0;
   Optional<uint64_t> SONameOffset;
   std::vector<uint64_t> NeededLibNames;
   // Symbol table:
if (Stub.Target.Endianness == IFSEndiannessType::Little) {
       return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
     } else {
       return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
     }
   }
   llvm_unreachable("invalid binary output target");
 }
 
-} // namespace elfabi
+} // end namespace ifs
 } // end namespace llvm

llvm/lib/InterfaceStub/IFSHandler.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace llvm;
-using namespace llvm::elfabi;
+using namespace llvm::ifs;
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
 
 namespace llvm {
 namespace yaml {
 
 /// YAML traits for ELFSymbolType.
 template <> struct ScalarEnumerationTraits<IFSSymbolType> {
if (Line.startswith("Target:")) {
       if (Line == "Target:" || (Line.find("{") != Line.npos)) {
         return false;
       }
     }
   }
   return true;
 }
 
-Expected<std::unique_ptr<IFSStub>> elfabi::readIFSFromBuffer(StringRef Buf) {
+Expected<std::unique_ptr<IFSStub>> ifs::readIFSFromBuffer(StringRef Buf) {
   yaml::Input YamlIn(Buf);
   std::unique_ptr<IFSStubTriple> Stub(new IFSStubTriple());
   if (usesTriple(Buf)) {
     YamlIn >> *Stub;
   } else {
     YamlIn >> *static_cast<IFSStub *>(Stub.get());
   }
   if (std::error_code Err = YamlIn.error()) {
     return createStringError(Err, "YAML failed reading as IFS");
   }
 
-  if (Stub->IfsVersion > elfabi::IFSVersionCurrent)
+  if (Stub->IfsVersion > IFSVersionCurrent)
     return make_error<StringError>(
         "IFS version " + Stub->IfsVersion.getAsString() + " is unsupported.",
         std::make_error_code(std::errc::invalid_argument));
   if (Stub->Target.ArchString) {
     Stub->Target.Arch =
         ELF::convertArchNameToEMachine(Stub->Target.ArchString.getValue());
   }
   return std::move(Stub);
 }
 
-Error elfabi::writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub) {
+Error ifs::writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub) {
   yaml::Output YamlOut(OS, NULL, /*WrapColumn =*/0);
   std::unique_ptr<IFSStubTriple> CopyStub(new IFSStubTriple(Stub));
   if (Stub.Target.Arch) {
     CopyStub->Target.ArchString = std::string(
         ELF::convertEMachineToArchName(Stub.Target.Arch.getValue()));
   }
   IFSTarget Target = Stub.Target;
 
   if (CopyStub->Target.Triple ||
       (!CopyStub->Target.ArchString && !CopyStub->Target.Endianness &&
        !CopyStub->Target.BitWidth))
     YamlOut << *CopyStub;
   else
     YamlOut << *static_cast<IFSStub *>(CopyStub.get());
   return Error::success();
 }
 
-Error elfabi::overrideIFSTarget(IFSStub &Stub, Optional<IFSArch> OverrideArch,
-                                Optional<IFSEndiannessType> OverrideEndianness,
-                                Optional<IFSBitWidthType> OverrideBitWidth,
-                                Optional<std::string> OverrideTriple) {
+Error ifs::overrideIFSTarget(IFSStub &Stub, Optional<IFSArch> OverrideArch,
   std::error_code OverrideEC(1, std::generic_category());
   if (OverrideArch) {
     if (Stub.Target.Arch &&
         Stub.Target.Arch.getValue() != OverrideArch.getValue()) {
       return make_error<StringError>(
           "Supplied Arch conflicts with the text stub", OverrideEC);
     }
     Stub.Target.Arch = OverrideArch.getValue();
if (Stub.Target.Triple &&
       return make_error<StringError>(
           "Supplied Triple conflicts with the text stub", OverrideEC);
     }
     Stub.Target.Triple = OverrideTriple.getValue();
   }
   return Error::success();
 }
 
-Error elfabi::validateIFSTarget(IFSStub &Stub, bool ParseTriple) {
+Error ifs::validateIFSTarget(IFSStub &Stub, bool ParseTriple) {
   std::error_code ValidationEC(1, std::generic_category());
   if (Stub.Target.Triple) {
     if (Stub.Target.Arch || Stub.Target.BitWidth || Stub.Target.Endianness ||
         Stub.Target.ObjectFormat) {
       return make_error<StringError>(
           "Target triple cannot be used simultaneously with ELF target format",
           ValidationEC);
     }
if (!Stub.Target.Arch || !Stub.Target.BitWidth || !Stub.Target.Endianness) {
     if (!Stub.Target.Endianness) {
       return make_error<StringError>(
           "Endianness is not defined in the text stub", ValidationEC);
     }
   }
   return Error::success();
 }
 
-IFSTarget elfabi::parseTriple(StringRef TripleStr) {
+IFSTarget ifs::parseTriple(StringRef TripleStr) {
   Triple IFSTriple(TripleStr);
   IFSTarget RetTarget;
   // TODO: Implement a Triple Arch enum to e_machine map.
   switch (IFSTriple.getArch()) {
   case Triple::ArchType::aarch64:
     RetTarget.Arch = (IFSArch)ELF::EM_AARCH64;
     break;
   case Triple::ArchType::x86_64:
     RetTarget.Arch = (IFSArch)ELF::EM_X86_64;
     break;
   default:
     RetTarget.Arch = (IFSArch)ELF::EM_NONE;
   }
   RetTarget.Endianness = IFSTriple.isLittleEndian() ? IFSEndiannessType::Little
                                                     : IFSEndiannessType::Big;
   RetTarget.BitWidth =
       IFSTriple.isArch64Bit() ? IFSBitWidthType::IFS64 : IFSBitWidthType::IFS32;
   return RetTarget;
 }
 
-void elfabi::stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
-                            bool StripEndianness, bool StripBitWidth) {
+void ifs::stripIFSTarget(IFSStub &Stub, bool StripTriple, bool StripArch,
   if (StripTriple || StripArch) {
     Stub.Target.Arch.reset();
     Stub.Target.ArchString.reset();
   }
   if (StripTriple || StripEndianness) {
     Stub.Target.Endianness.reset();
   }
   if (StripTriple || StripBitWidth) {

llvm/lib/InterfaceStub/IFSStub.cpp

 //===- IFSStub.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===-----------------------------------------------------------------------===/
 
 #include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Error.h"
 
 using namespace llvm;
-using namespace llvm::elfabi;
+using namespace llvm::ifs;
 
 IFSStub::IFSStub(IFSStub const &Stub) {
   IfsVersion = Stub.IfsVersion;
   Target = Stub.Target;
   SoName = Stub.SoName;
   NeededLibs = Stub.NeededLibs;
   Symbols = Stub.Symbols;
 }

 bool IFSTarget::empty() {
   if (!Triple && !ObjectFormat && !Arch && !ArchString && !Endianness &&
       !BitWidth) {
     return true;
   }
   return false;
 }
 
-uint8_t elfabi::convertIFSBitWidthToELF(IFSBitWidthType BitWidth) {
+uint8_t ifs::convertIFSBitWidthToELF(IFSBitWidthType BitWidth) {
   return BitWidth == IFSBitWidthType::IFS32 ? ELF::ELFCLASS32 : ELF::ELFCLASS64;
 }
 
-uint8_t elfabi::convertIFSEndiannessToELF(IFSEndiannessType Endianness) {
+uint8_t ifs::convertIFSEndiannessToELF(IFSEndiannessType Endianness) {
   return Endianness == IFSEndiannessType::Little ? ELF::ELFDATA2LSB
                                                  : ELF::ELFDATA2MSB;
 }
 
-uint8_t elfabi::convertIFSSymbolTypeToELF(IFSSymbolType SymbolType) {
+uint8_t ifs::convertIFSSymbolTypeToELF(IFSSymbolType SymbolType) {
   switch (SymbolType) {
   case IFSSymbolType::Object:
     return ELF::STT_OBJECT;
   case IFSSymbolType::Func:
     return ELF::STT_FUNC;
   case IFSSymbolType::TLS:
     return ELF::STT_TLS;
   case IFSSymbolType::NoType:
   default:
     return ELF::STT_NOTYPE;
   }
 }
 
-IFSBitWidthType elfabi::convertELFBitWidthToIFS(uint8_t BitWidth) {
+IFSBitWidthType ifs::convertELFBitWidthToIFS(uint8_t BitWidth) {
   switch (BitWidth) {
   case ELF::ELFCLASS32:
     return IFSBitWidthType::IFS32;
   case ELF::ELFCLASS64:
     return IFSBitWidthType::IFS64;
   default:
     return IFSBitWidthType::Unknown;
   }
 }
 
-IFSEndiannessType elfabi::convertELFEndiannessToIFS(uint8_t Endianness) {
+IFSEndiannessType ifs::convertELFEndiannessToIFS(uint8_t Endianness) {
   switch (Endianness) {
   case ELF::ELFDATA2LSB:
     return IFSEndiannessType::Little;
   case ELF::ELFDATA2MSB:
     return IFSEndiannessType::Big;
   default:
     return IFSEndiannessType::Unknown;
   }
 }
 
-IFSSymbolType elfabi::convertELFSymbolTypeToIFS(uint8_t SymbolType) {
+IFSSymbolType ifs::convertELFSymbolTypeToIFS(uint8_t SymbolType) {
   SymbolType = SymbolType & 0xf;
   switch (SymbolType) {
   case ELF::STT_OBJECT:
     return IFSSymbolType::Object;
   case ELF::STT_FUNC:
     return IFSSymbolType::Func;
   case ELF::STT_TLS:
     return IFSSymbolType::TLS;
   case ELF::STT_NOTYPE:
     return IFSSymbolType::NoType;
   default:
     return IFSSymbolType::Unknown;
   }
 }

llvm/test/CMakeLists.txt

set(LLVM_TEST_DEPENDS
           llvm-cxxfilt
           llvm-cxxmap
           llvm-diff
           llvm-dis
           llvm-dlltool
           dsymutil
           llvm-dwarfdump
           llvm-dwp
-          llvm-elfabi
           llvm-exegesis
           llvm-extract
           llvm-gsymutil
           llvm-isel-fuzzer
           llvm-ifs
           llvm-install-name-tool
           llvm-jitlink
           llvm-lib

llvm/test/tools/llvm-ifs/binary-read-add-soname.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- --soname=best.so %t | FileCheck %s
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- --soname=best.so %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_AARCH64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-arch.test

 # RUN: yaml2obj --docnum=1 %s -o %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s -DTARGET="{ ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }"
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- --hint-ifs-target="x86_64-linux-gnu" %t | FileCheck %s -DTARGET="x86_64-linux-gnu"
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s -DTARGET="{ ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }"
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- --hint-ifs-target="x86_64-linux-gnu" %t | FileCheck %s -DTARGET="x86_64-linux-gnu"
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

 # CHECK-NEXT: IfsVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: Target: [[TARGET]]
 # CHECK-NEXT: Symbols: []
 # CHECK-NEXT: ...
 
 # HINTERR: error: Triple hint does not match the actual [[MSG]]
 
 # RUN: yaml2obj --docnum=1 %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe --hint-ifs-target="aarch64-linux-gnu" %t 2>&1 | FileCheck %s -DMSG=architecture --check-prefix=HINTERR
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe --hint-ifs-target="aarch64-linux-gnu" %t 2>&1 | FileCheck %s -DMSG=architecture --check-prefix=HINTERR
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2MSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
- Type:     PT_LOAD
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     Flags:    [ PF_X, PF_R ]
     VAddr:    0x0008
     FirstSec: .dynamic
     LastSec:  .dynamic
 
 # RUN: yaml2obj --docnum=2 %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe --hint-ifs-target="x86_64-unknown-linux-gnu" %t 2>&1 | FileCheck %s -DMSG="endianness" --check-prefix=HINTERR
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe --hint-ifs-target="x86_64-unknown-linux-gnu" %t 2>&1 | FileCheck %s -DMSG="endianness" --check-prefix=HINTERR
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS32
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
- Type:     PT_LOAD
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     Flags:    [ PF_X, PF_R ]
     VAddr:    0x0008
     FirstSec: .dynamic
     LastSec:  .dynamic
 
 # RUN: yaml2obj --docnum=3 %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe --hint-ifs-target="x86_64-unknown-linux-gnu" %t 2>&1 | FileCheck %s -DMSG="bit width" --check-prefix=HINTERR
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe --hint-ifs-target="x86_64-unknown-linux-gnu" %t 2>&1 | FileCheck %s -DMSG="bit width" --check-prefix=HINTERR

llvm/test/tools/llvm-ifs/binary-read-bad-soname.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-bad-vaddr.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-neededlibs-bad-offset.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-neededlibs.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-no-dt-strsz.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-no-dt-strtab.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-no-dynamic.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 
 # CHECK: No .dynamic section found

llvm/test/tools/llvm-ifs/binary-read-replace-soname.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s --check-prefix=ORIGINAL
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --soname=libbest.so --output=- %t | FileCheck %s --check-prefix=REPLACED
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s --check-prefix=ORIGINAL
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --soname=libbest.so --output=- %t | FileCheck %s --check-prefix=REPLACED
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-soname-no-null.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t.tbe %t 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-soname.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/test/tools/llvm-ifs/binary-read-syms-gnu-hash.test

-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %p/Inputs/gnu_hash.so | FileCheck %s
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %p/Inputs/gnu_hash.so | FileCheck %s
 
 # CHECK:      --- !ifs-v1
 # CHECK-NEXT: IfsVersion:      3.0
 # CHECK-NEXT: SoName:          libsomething.so
 # CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: NeededLibs:
 # CHECK-NEXT:   - libm.so.6
 # CHECK-NEXT:   - libc.so.6
 # CHECK-NEXT:   - ld-linux-x86-64.so.2
 # CHECK-NEXT: Symbols:
-# CHECK-NEXT:   - { Name: __gmon_start__, Type: NoType, Undefined: true, Weak: true }
+# CHECK-NEXT:   - { Name: AGlobalInteger, Type: Object, Size: 4 }
+# CHECK-NEXT:   - { Name: AThreadLocalLongInteger, Type: TLS, Size: 8 }
 # CHECK-NEXT:   - { Name: _ITM_deregisterTMCloneTable, Type: NoType, Undefined: true, Weak: true }
 # CHECK-NEXT:   - { Name: _ITM_registerTMCloneTable, Type: NoType, Undefined: true, Weak: true }
+# CHECK-NEXT:   - { Name: _Z11rotateArrayPii, Type: Func }
 # CHECK-NEXT:   - { Name: __cxa_finalize, Type: Func, Undefined: true, Weak: true }
+# CHECK-NEXT:   - { Name: __gmon_start__, Type: NoType, Undefined: true, Weak: true }
 # CHECK-NEXT:   - { Name: __tls_get_addr, Type: Func, Undefined: true }
-# CHECK-NEXT:   - { Name: _init, Type: Func }
 # CHECK-NEXT:   - { Name: _fini, Type: Func }
-# CHECK-NEXT:   - { Name: AGlobalInteger, Type: Object, Size: 4 }
-# CHECK-NEXT:   - { Name: AThreadLocalLongInteger, Type: TLS, Size: 8 }
-# CHECK-NEXT:   - { Name: _Z11rotateArrayPii, Type: Func }
+# CHECK-NEXT:   - { Name: _init, Type: Func }
 # CHECK-NEXT: ...

llvm/test/tools/llvm-ifs/binary-read-syms-sysv-hash.test

-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %p/Inputs/sysv_hash.so | FileCheck %s
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %p/Inputs/sysv_hash.so | FileCheck %s
 
 # CHECK:      --- !ifs-v1
 # CHECK-NEXT: IfsVersion:      3.0
 # CHECK-NEXT: SoName:          libsomething.so
 # CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: NeededLibs:
 # CHECK-NEXT:   - libm.so.6
 # CHECK-NEXT:   - libc.so.6
 # CHECK-NEXT:   - ld-linux-x86-64.so.2
 # CHECK-NEXT: Symbols:
-# CHECK-NEXT:   - { Name: __gmon_start__, Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   - { Name: _init, Type: Func }
-# CHECK-NEXT:   - { Name: _fini, Type: Func }
-# CHECK-NEXT:   - { Name: _ITM_deregisterTMCloneTable, Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   - { Name: _ITM_registerTMCloneTable, Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   - { Name: __cxa_finalize, Type: Func, Undefined: true, Weak: true }
 # CHECK-NEXT:   - { Name: AGlobalInteger, Type: Object, Size: 4 }
 # CHECK-NEXT:   - { Name: AThreadLocalLongInteger, Type: TLS, Size: 8 }
+# CHECK-NEXT:   - { Name: _ITM_deregisterTMCloneTable, Type: NoType, Undefined: true, Weak: true }
+# CHECK-NEXT:   - { Name: _ITM_registerTMCloneTable, Type: NoType, Undefined: true, Weak: true }
 # CHECK-NEXT:   - { Name: _Z11rotateArrayPii, Type: Func }
+# CHECK-NEXT:   - { Name: __cxa_finalize, Type: Func, Undefined: true, Weak: true }
+# CHECK-NEXT:   - { Name: __gmon_start__, Type: NoType, Undefined: true, Weak: true }
 # CHECK-NEXT:   - { Name: __tls_get_addr, Type: Func, Undefined: true }
+# CHECK-NEXT:   - { Name: _fini, Type: Func }
+# CHECK-NEXT:   - { Name: _init, Type: Func }
 # CHECK-NEXT: ...

llvm/test/tools/llvm-ifs/conflict-header-triple.ifs

-# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
+# RUN: not llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/object.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
-# CHECK-IFS: error: Interface Stub: Triple Mismatch.
+# CHECK-IFS: error: Interface Stub: Target Mismatch.
 # CHECK-IFS-NEXT: Filenames:
-# CHECK-IFS-NEXT: Triple Values: mips-unknown-linux x86_64-unknown-linux-gnu
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target:          mips-unknown-linux
 Symbols:
   - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/conflict-header-version.ifs

-# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
+# RUN: not llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/object.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
-# RUN: not llvm-ifs -action write-ifs -o - %s 2>&1 | \
+# RUN: not llvm-ifs --input-format=IFS --output-format=IFS -o - %s 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS2
 
 # CHECK-IFS: error: Interface Stub: IfsVersion Mismatch.
 # CHECK-IFS2: error: Interface Stub: Bad IfsVersion: 0.0, llvm-ifs supported version: 3.0.
 
 --- !ifs-v1
 IfsVersion:      0.0
 Target:          x86_64-unknown-linux-gnu
 Symbols:
   - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/conflict-size.ifs

-# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
+# RUN: not llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/object.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # Here we are testing to see if two symbols with identical names will fail to
 # merge in conflict due to mismatching sizes.
 # CHECK-IFS: error: Interface Stub: Size Mismatch for b.
 # CHECK-IFS-NEXT: Filename:
 # CHECK-IFS-NEXT: Size Values: 1 4
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: b, Type: Object, Size: 1 }
 ...

llvm/test/tools/llvm-ifs/conflict-type.ifs

-# RUN: not llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \
+# RUN: not llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/func.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # Here we are testing to see if two symbols with identical names will fail to
 # merge in conflict due to mismatched types.
 # CHECK-IFS: error: Interface Stub: Type Mismatch for a.
 # CHECK-IFS-NEXT: Filename:
 # CHECK-IFS-NEXT: Type Values: Object Func
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: a, Type: Object, Size: 1 }
 ...

llvm/test/tools/llvm-ifs/conflict-weak.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/func.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # CHECK-IFS: Symbols:
 # CHECK-IFS-NEXT: - { Name: a, Type: Func, Weak: true }
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: a, Type: Func, Weak: true }
 ...

llvm/test/tools/llvm-ifs/default-empty.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck --check-prefixes=CHECK-DEFAULT %s
-# RUN: llvm-ifs -action write-ifs -o - %s %S/weak.ifs | FileCheck --check-prefixes=CHECK-MERGE %s
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s | FileCheck --check-prefixes=CHECK-DEFAULT %s
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %S/weak.ifs %s | FileCheck --check-prefixes=CHECK-MERGE %s
 
 # CHECK-DEFAULT: --- !ifs-v1
 # CHECK-DEFAULT-NEXT: IfsVersion: 3.0
-# CHECK-DEFAULT-NEXT: Target:          ''
 # CHECK-DEFAULT-NEXT: Symbols:         []
 # CHECK-DEFAULT-NEXT: ...
 
 # CHECK-MERGE: --- !ifs-v1
 # CHECK-MERGE-NEXT: IfsVersion: 3.0
 # CHECK-MERGE-NEXT: Target: x86_64-unknown-linux-gnu
 # CHECK-MERGE-NEXT: Symbols:
 # CHECK-MERGE-DAG:  - { Name: _Z8weakFuncv, Type: Func, Weak: true }
 # CHECK-MERGE-DAG:  - { Name: _Z10strongFuncv, Type: Func }
 # CHECK-MERGE: ...
 
 --- !ifs-v1
 IfsVersion: 3.0
-Target:          ''
 Symbols:         []
 ...

llvm/test/tools/llvm-ifs/empty1.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s | FileCheck %s
 
 # CHECK: --- !ifs-v1
 # CHECK-NEXT: IfsVersion: 3.0
 # CHECK-NEXT: Target: x86_64-unknown-linux-gnu
 # CHECK-NEXT: Symbols: []
 # CHECK: ...
 
 --- !ifs-v1
 IfsVersion:      3.0
 Target:          x86_64-unknown-linux-gnu
 Symbols:         []
 ...

llvm/test/tools/llvm-ifs/empty2.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s | FileCheck %s
 
 # CHECK: --- !ifs-v1
 # CHECK-NEXT: IfsVersion: 3.0
 # CHECK-NEXT: Target: x86_64-unknown-linux-gnu
 # CHECK-NEXT: Symbols: []
 # CHECK: ...
 
 --- !ifs-v1
 IfsVersion:      3.0
 Target:          x86_64-unknown-linux-gnu
 Symbols:
 ...

llvm/test/tools/llvm-ifs/fail-file-open.test

-# RUN: not llvm-elfabi --output-format=IFS --output=%t.tbe %s.NotAFileInTestingDir 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --output-format=IFS --output=%t.tbe %s.NotAFileInTestingDir 2>&1 | FileCheck %s
 
-This file will not be read. An invalid file path is fed to llvm-elfabi.
+This file will not be read. An invalid file path is fed to llvm-ifs.
 
 # CHECK: error: Could not open `{{.*}}.NotAFileInTestingDir`

llvm/test/tools/llvm-ifs/fail-file-write-windows.test

 ## Test failing to write output file on windows platform.
 
 # REQUIRES: system-windows
 # RUN: touch %t.TestFile
 # RUN: chmod 400 %t.TestFile
-# RUN: not llvm-elfabi --output-format=ELF --output=%t.TestFile %s 2>&1 | FileCheck -DMSG=%errc_EACCES %s --check-prefix=ERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t.TestFile %s 2>&1 | FileCheck -DMSG=%errc_EACCES %s --check-prefix=ERR
 # RUN: chmod 777 %t.TestFile
 # RUN: rm -rf %t.TestFile
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 Symbols: []
 ...
 
 # ERR: error: [[MSG]]

llvm/test/tools/llvm-ifs/fail-file-write.test

 ## Test failing to write output file on non-windows platforms.
 
 # UNSUPPORTED: system-windows
 # RUN: rm -rf %t.TestDir
 # RUN: mkdir %t.TestDir
 # RUN: touch %t.TestDir/Output.TestFile
 # RUN: chmod 400 %t.TestDir
-# RUN: not llvm-elfabi --output-format=ELF --output=%t.TestDir/Output.TestFile %s 2>&1 | FileCheck -DMSG=%errc_EACCES %s --check-prefix=ERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t.TestDir/Output.TestFile %s 2>&1 | FileCheck -DMSG=%errc_EACCES %s --check-prefix=ERR
 # RUN: chmod 777 %t.TestDir
 # RUN: rm -rf %t.TestDir
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 Symbols: []
 ...
 
 # ERR: [[MSG]] when trying to open `{{.*}}.TestDir/Output.TestFile` for writing

llvm/test/tools/llvm-ifs/func.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs | \
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/object.ifs | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
-# RUN: llvm-ifs -action write-bin -o - %s %S/object.ifs | \
+# RUN: llvm-ifs --input-format=IFS --output-format=ELF -o - %s %S/object.ifs | \
 # RUN: llvm-readelf --all - | FileCheck %s --check-prefixes=CHECK-ELF
 
-# RUN: llvm-ifs -action write-bin -o - %s %S/object.ifs -use-interfacestub | \
-# RUN: llvm-readelf --all - | FileCheck %s --check-prefixes=CHECK-ELF
-
-# RUN: llvm-ifs -action write-bin -force-format TBD -o - %s %S/object.ifs | \
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS --strip-ifs-target -o %t.tbd %s %S/object.ifs
+# RUN: llvm-ifs --input-format=IFS --output-format=TBD --target=x86_64-apple-darwin -o - %t.tbd | \
 # RUN: FileCheck %s --check-prefixes=CHECK-DARWIN-TBD3
 
-# RUN: llvm-ifs -action write-ifs -o - %s %s | \
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s %s | \
 # RUN: FileCheck %s --check-prefixes=CHECK-MERGE-IFS
 
 # CHECK-IFS: --- !ifs-v1
 # CHECK-IFS-NEXT: IfsVersion: 3.0
 # CHECK-IFS-NEXT: Target:          x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: Symbols:
 # CHECK-IFS-DAG:   - { Name: a, Type: Func }
 # CHECK-IFS-DAG:   - { Name: b, Type: Object, Size: 4 }

llvm/test/tools/llvm-ifs/ifs-emits-current-version.test

-# RUN: llvm-elfabi --output-format=IFS --output=- %s | FileCheck %s
+# RUN: llvm-ifs --output-format=IFS --output=- %s | FileCheck %s
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 Symbols: []
 ...
 
 # As the tbe reader/writer is updated, update this check to ensure --emit-tbe
 # uses the latest tbe writer by default.
 
 # CHECK:      --- !ifs-v1
 # CHECK-NEXT: IfsVersion: 3.0

llvm/test/tools/llvm-ifs/ifs-read-basic.test

-# RUN: llvm-elfabi --output-format=IFS --output=- %s | FileCheck %s
+# RUN: llvm-ifs --output-format=IFS --output=- %s | FileCheck %s
 
 --- !ifs-v1
 SoName: somelib.so
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 Symbols:
   - { Name: foo, Type: Func }
   - { Name: bar, Type: Object, Size: 42 }
   - { Name: baz, Type: Object, Size: 8 }
   - { Name: not, Type: Object, Size: 128, Undefined: true }
   - { Name: nor, Type: Func, Undefined: true }
 ...
 
 # CHECK:      --- !ifs-v1
 # CHECK-NEXT: IfsVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: SoName: somelib.so
 # CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: Symbols:
-# CHECK-NEXT:   - { Name: foo, Type: Func }
 # CHECK-NEXT:   - { Name: bar, Type: Object, Size: 42 }
 # CHECK-NEXT:   - { Name: baz, Type: Object, Size: 8 }
-# CHECK-NEXT:   - { Name: not, Type: Object, Size: 128, Undefined: true }
+# CHECK-NEXT:   - { Name: foo, Type: Func }
 # CHECK-NEXT:   - { Name: nor, Type: Func, Undefined: true }
+# CHECK-NEXT:   - { Name: not, Type: Object, Size: 128, Undefined: true }
 # CHECK-NEXT: ...

llvm/test/tools/llvm-ifs/ios-tbd.ifs

-# RUN: llvm-ifs --action write-bin -force-format TBD -o - %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=TBD  -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        ios
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0

llvm/test/tools/llvm-ifs/macos-tbd.ifs

-# RUN: llvm-ifs --action write-bin -force-format TBD -o - %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=TBD -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        macosx
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0

llvm/test/tools/llvm-ifs/object-function-size-weak-combo.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
-# RUN: llvm-ifs -action write-bin -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
+# RUN: llvm-ifs --input-format=IFS --output-format=ELF -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
 # RUN: llvm-readelf --all - | FileCheck %s --check-prefixes=CHECK-ELF
 
 # CHECK-IFS: --- !ifs-v1
 # CHECK-IFS-NEXT: IfsVersion: 3.0
 # CHECK-IFS-NEXT: Target:          x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: Symbols:
 # CHECK-IFS-DAG:   - { Name: e,              Type: Object, Size: 8 }
 # CHECK-IFS-DAG:   - { Name: a,              Type: Func }

llvm/test/tools/llvm-ifs/object.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s | \
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
-# RUN: llvm-ifs -action write-bin -o - %s | \
+# RUN: llvm-ifs --input-format=IFS --output-format=ELF -o - %s | \
 # RUN: llvm-readelf --all - | FileCheck %s --check-prefixes=CHECK-ELF
 
 # CHECK-IFS: --- !ifs-v1
 # CHECK-IFS-NEXT: IfsVersion: 3.0
 # CHECK-IFS-NEXT: Target:          x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: Symbols:
 # CHECK-IFS-NEXT:   - { Name: b, Type: Object, Size: 4 }
 # CHECK-IFS-NEXT: ...

llvm/test/tools/llvm-ifs/preserve-dates-stub.test

 ## Test writing unchanged content to ELF Stub file with --write-if-changed flag.
 
-# RUN: llvm-elfabi --output-format=ELF --output=%t %s
+# RUN: llvm-ifs --output-format=ELF --output=%t %s
 # RUN: env TZ=GMT touch -m -t 197001010000 %t
-# RUN: llvm-elfabi --output-format=ELF --output=%t --write-if-changed %s
+# RUN: llvm-ifs --output-format=ELF --output=%t --write-if-changed %s
 # RUN: env TZ=GMT ls -l %t | FileCheck %s
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 NeededLibs:
   - libc.so.6
 Symbols:
   - { Name: bar, Type: Object, Size: 42 }
   - { Name: baz, Type: TLS, Size: 3 }
   - { Name: plus, Type: Func }
 ...
 
 # CHECK: {{[[:space:]]1970}}

llvm/test/tools/llvm-ifs/read-elf-dynsym.test

 ## Test reading ELF with .dynsym under the following conditions:
 ##  * Section headers are available.
 ##  * Section headers are stripped but there is a DT_GNU_HASH dynamic tag.
 ##  * Section headers are stripped but there is a DT_HASH dynamic tag.
 
-## Test if llvm-elfabi reads DT_SYMTAB size through section headers by puting the wrong terminator in DT_GNU_HASH.
+## Test if llvm-ifs reads DT_SYMTAB size through section headers by puting the wrong terminator in DT_GNU_HASH.
 # RUN: yaml2obj %s -o %tfull -DGNUHASHVALUE="[0x9]" -DTAG1="DT_GNU_HASH" -DVAL1="0xC00"
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %tfull | FileCheck %s
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %tfull | FileCheck %s
 
-## Test if llvm-elfabi fails to read DT_SYMTAB size through section headers when the value of sh_entsize is invalid.
+## Test if llvm-ifs fails to read DT_SYMTAB size through section headers when the value of sh_entsize is invalid.
 # RUN: yaml2obj %s -o %tfull -DGNUHASHVALUE="[0x9]" -DTAG1="DT_GNU_HASH" -DVAL1="0xC00" -DENTSIZE="0x19"
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=- %tfull 2>&1 | FileCheck %s --check-prefix=BADENTSIZE
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=- %tfull 2>&1 | FileCheck %s --check-prefix=BADENTSIZE
 
-## Test if llvm-elfabi reads DT_SYMTAB size through DT_GNU_HASH.
+## Test if llvm-ifs reads DT_SYMTAB size through DT_GNU_HASH.
 # RUN: yaml2obj %s -o %tw.gnu.hash -DGNUHASHVALUE="[0x8, 0x9]" -DTAG1="DT_GNU_HASH" -DVAL1="0xC00" -DNOHEADER="true"
-# RUN: llvm-elfabi --input-format=ELF --output-format=IFS --output=- %tw.gnu.hash | FileCheck %s
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=- %tw.gnu.hash | FileCheck %s
 
-## Test if llvm-elfabi fails to read DT_SYMTAB size through DT_GNU_HASH when there is no terminator.
+## Test if llvm-ifs fails to read DT_SYMTAB size through DT_GNU_HASH when there is no terminator.
 # RUN: yaml2obj %s -o %tw.gnu.hash -DGNUHASHVALUE="[0x8, 0xA]" -DTAG1="DT_GNU_HASH" -DVAL1="0xC00" -DNOHEADER="true"
-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=- %tw.gnu.hash  2>&1 | FileCheck %s --check-prefix=NOTERMINATOR
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=- %tw.gnu.hash  2>&1 | FileCheck %s --check-prefix=NOTERMINATOR
 
 # CHECK:      --- !ifs-v1
 # CHECK-NEXT: IfsVersion:      3.0
 # CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: Symbols:
-# CHECK-NEXT:   - { Name: foo, Type: Func, Undefined: true }
 # CHECK-NEXT:   - { Name: bar, Type: Object, Size: 0, Undefined: true }
+# CHECK-NEXT:   - { Name: foo, Type: Func, Undefined: true }
 # CHECK-NEXT: ...
 
 # BADENTSIZE: SHT_DYNSYM section has sh_size (72) % sh_entsize (25) that is not 0
 
 # NOTERMINATOR: error: no terminator found for GNU hash section before buffer end
 
 --- !ELF
 FileHeader:

llvm/test/tools/llvm-ifs/read-ifs-as-elf.test

-# RUN: not llvm-elfabi --input-format=ELF --output-format=IFS --output=%t %s 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --input-format=ELF --output-format=IFS --output=%t %s 2>&1 | FileCheck %s
 
 --- !ifs-v1
 SoName: somelib.so
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 Symbols:
   - { Name: foo, Type: Func }
   - { Name: bar, Type: Object, Size: 42 }
   - { Name: baz, Type: Object, Size: 8 }
   - { Name: not, Type: Object, Undefined: true, Size: 128 }
   - { Name: nor, Type: Func, Undefined: true }
 ...
 
 # CHECK: The file was not recognized as a valid object file
 # CHECK: No file readers succeeded reading `{{.*}}read-ifs-as-elf.test` (unsupported/malformed file?)

llvm/test/tools/llvm-ifs/read-ifs-as-ifs.test

-# RUN: llvm-elfabi --input-format=IFS --output-format=IFS --output=- %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS --output=- %s | FileCheck %s
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 Symbols: []
 ...
 
 # CHECK:      --- !ifs-v1
 # CHECK-NEXT: IfsVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: Symbols: []
 # CHECK-NEXT: ...

llvm/test/tools/llvm-ifs/read-ifs-with-bad-bitwidth.test

 ## Test reading TBE file with bad bit width.
 
-# RUN: not llvm-elfabi --output-format=IFS --output=- %s 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --output-format=IFS --output=- %s 2>&1 | FileCheck %s
 
 --- !ifs-v1
 SoName: somelib.so
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 65 }
 Symbols:
   - { Name: foo, Type: Func }
   - { Name: bar, Type: Object, Size: 42 }
   - { Name: baz, Type: Object, Size: 8 }
   - { Name: not, Type: Object, Size: 128, Undefined: true }
   - { Name: nor, Type: Func, Undefined: true }
 ...
 
 # CHECK:      YAML:8:74: error: Unsupported bit width

llvm/test/tools/llvm-ifs/read-ifs-with-bad-endianness.test

 ## Test reading TBE file with bad endianness.
 
-# RUN: not llvm-elfabi --output-format=IFS --output=- %s 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --output-format=IFS --output=- %s 2>&1 | FileCheck %s
 
 --- !ifs-v1
 SoName: somelib.so
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: lit, BitWidth: 64 }
 Symbols:
   - { Name: foo, Type: Func }
   - { Name: bar, Type: Object, Size: 42 }
   - { Name: baz, Type: Object, Size: 8 }
   - { Name: not, Type: Object, Size: 128, Undefined: true }
   - { Name: nor, Type: Func, Undefined: true }
 ...
 
 # CHECK:      YAML:8:56: error: Unsupported endianness

llvm/test/tools/llvm-ifs/read-unsupported-file.test

-# RUN: not llvm-elfabi --output-format=IFS --output=- %s 2>&1| FileCheck %s
+# RUN: not llvm-ifs --output-format=IFS --output=- %s 2>&1| FileCheck %s
 
-This is just some text that cannot be read by llvm-elfabi.
+This is just some text that cannot be read by llvm-ifs.
 
 # CHECK: The file was not recognized as a valid object file
 # CHECK: YAML failed reading as IFS
 # CHECK: No file readers succeeded reading `{{.*}}` (unsupported/malformed file?)

llvm/test/tools/llvm-ifs/strong.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s %S/strong.ifs | FileCheck %s --check-prefixes=CHECK-IFS
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/strong.ifs | FileCheck %s --check-prefixes=CHECK-IFS
 
 # CHECK-IFS: --- !ifs-v1
 # CHECK-IFS-NEXT: IfsVersion: 3.0
 # CHECK-IFS-NEXT: Target: x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: Symbols:
 # CHECK-IFS-DAG:   - { Name: _Z8weakFuncv, Type: Func }
 # CHECK-IFS: ...
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: _Z8weakFuncv, Type: Func }
 ...

llvm/test/tools/llvm-ifs/tvos-tbd.ifs

-# RUN: llvm-ifs --action write-bin -force-format TBD -o - %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=TBD -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        tvos
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0

llvm/test/tools/llvm-ifs/version-ok.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/object.ifs
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target:          x86_64-unknown-linux-gnu
 Symbols:
   - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/watchos-tbd.ifs

-# RUN: llvm-ifs --action write-bin -force-format TBD -o - %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=TBD -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        watchos
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0

llvm/test/tools/llvm-ifs/weak-mismatch.ifs

-# RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-size.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-SIZE
-# RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-type.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-TYPE
+# RUN: not llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/Inputs/strong-mismatch-size.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-SIZE
+# RUN: not llvm-ifs --input-format=IFS --output-format=IFS -o - %s %S/Inputs/strong-mismatch-type.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-TYPE
 
 # CHECK-SIZE: error: Interface Stub: Size Mismatch for foobar.
 # CHECK-SIZE-NEXT: Filename:
 # CHECK-SIZE-NEXT: Size Values: 1 2
 
 
 # CHECK-TYPE: error: Interface Stub: Type Mismatch for foobar.
 # CHECK-TYPE-NEXT: Filename:
 # CHECK-TYPE-NEXT: Type Values: Object Func
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: foobar, Type: Object, Size: 1, Weak: true }
 ...

llvm/test/tools/llvm-ifs/weak.ifs

-# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s --check-prefixes=CHECK-IFS
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS -o - %s | FileCheck %s --check-prefixes=CHECK-IFS
 
 # CHECK-IFS: --- !ifs-v1
 # CHECK-IFS-NEXT: IfsVersion: 3.0
 # CHECK-IFS-NEXT: Target: x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: Symbols:
 # CHECK-IFS-DAG:   - { Name: _Z8weakFuncv, Type: Func, Weak: true }
 # CHECK-IFS-DAG:   - { Name: _Z10strongFuncv, Type: Func }
 # CHECK-IFS: ...
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: _Z8weakFuncv, Type: Func, Weak: true }
   - { Name: _Z10strongFuncv, Type: Func }
 ...

llvm/test/tools/llvm-ifs/write-stub-no-nonlocal-symbol.test

 ## Test writing stub elf when symbol table contains no non-local symbol.
 
-# RUN: llvm-elfabi --output-format=ELF --output=%t %s
+# RUN: llvm-ifs --output-format=ELF --output=%t %s
 # RUN: llvm-readobj -S %t | FileCheck %s -DCLASS="64-bit (0x2)" -DDE="LittleEndian (0x1)" -DHS=64 -DPHES=56 -DSHES=64 -DDYNSYMAL=8 -DDYNSYMES=24 -DDYNAMICAL=8 -DDYNAMICES=16 -DDYNTABZ=000000000
 
 --- !ifs-v1
 IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 NeededLibs:
   - libc.so.6
 Symbols: []

llvm/test/tools/llvm-ifs/write-stub.test

 ## Test writing stub elf with minimal sections.
 
-# RUN: llvm-elfabi --output-format=ELF --output=%t.elf32l --arch=x86_64 --bitwidth=32 --endianness=little %s
+# RUN: llvm-ifs --output-format=ELF --output=%t.elf32l --arch=x86_64 --bitwidth=32 --endianness=little %s
 # RUN: llvm-readobj -h -S --string-dump .dynstr --string-dump .shstrtab --dyn-symbols --dynamic-table %t.elf32l | FileCheck %s -DCLASS="32-bit (0x1)" -DDE="LittleEndian (0x1)" -DHS=52 -DPHES=32 -DSHES=40 -DDYNSYMAL=4 -DDYNSYMES=16 -DDYNAMICAL=4 -DDYNAMICES=8 -DDYNTABZ=0
 
-# RUN: llvm-elfabi --output-format=ELF --output=%t.elf32b --arch=x86_64 --bitwidth=32 --endianness=big %s
+# RUN: llvm-ifs --output-format=ELF --output=%t.elf32b --arch=x86_64 --bitwidth=32 --endianness=big %s
 # RUN: llvm-readobj -h -S --string-dump .dynstr --string-dump .shstrtab --dyn-symbols --dynamic-table %t.elf32b | FileCheck %s -DCLASS="32-bit (0x1)" -DDE="BigEndian (0x2)" -DHS=52 -DPHES=32 -DSHES=40 -DDYNSYMAL=4 -DDYNSYMES=16 -DDYNAMICAL=4 -DDYNAMICES=8 -DDYNTABZ=0
 
-# RUN: llvm-elfabi --output-format=ELF --output=%t.elf64l --arch=x86_64 --bitwidth=64 --endianness=little %s
+# RUN: llvm-ifs --output-format=ELF --output=%t.elf64l --arch=x86_64 --bitwidth=64 --endianness=little %s
 # RUN: llvm-readobj -h -S --string-dump .dynstr --string-dump .shstrtab --dyn-symbols --dynamic-table %t.elf64l | FileCheck %s -DCLASS="64-bit (0x2)" -DDE="LittleEndian (0x1)" -DHS=64 -DPHES=56 -DSHES=64 -DDYNSYMAL=8 -DDYNSYMES=24 -DDYNAMICAL=8 -DDYNAMICES=16 -DDYNTABZ=000000000
 
-# RUN: llvm-elfabi --output-format=ELF --output=%t.elf64l --target=x86_64-linux-gnu %s
+# RUN: llvm-ifs --output-format=ELF --output=%t.elf64l --target=x86_64-linux-gnu %s
 # RUN: llvm-readobj -h -S --string-dump .dynstr --string-dump .shstrtab --dyn-symbols --dynamic-table %t.elf64l | FileCheck %s -DCLASS="64-bit (0x2)" -DDE="LittleEndian (0x1)" -DHS=64 -DPHES=56 -DSHES=64 -DDYNSYMAL=8 -DDYNSYMES=24 -DDYNAMICAL=8 -DDYNAMICES=16 -DDYNTABZ=000000000
 
-# RUN: llvm-elfabi --output-format=ELF --output=%t.elf64b --arch=x86_64 --bitwidth=64 --endianness=big %s
+# RUN: llvm-ifs --output-format=ELF --output=%t.elf64b --arch=x86_64 --bitwidth=64 --endianness=big %s
 # RUN: llvm-readobj -h -S --string-dump .dynstr --string-dump .shstrtab --dyn-symbols --dynamic-table %t.elf64b | FileCheck %s -DCLASS="64-bit (0x2)" -DDE="BigEndian (0x2)" -DHS=64 -DPHES=56 -DSHES=64 -DDYNSYMAL=8 -DDYNSYMES=24 -DDYNAMICAL=8 -DDYNAMICES=16 -DDYNTABZ=000000000
 
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --arch=x86_64 --bitwidth=64 --endianness=big --target=x86_64-linux-gnu %s 2>&1 | FileCheck %s --check-prefix=TRIPLEERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t --arch=x86_64 --bitwidth=64 --endianness=big --target=x86_64-linux-gnu %s 2>&1 | FileCheck %s --check-prefix=TRIPLEERR
 
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --bitwidth=64 --endianness=big %s 2>&1 | FileCheck %s -DMSG="Arch" --check-prefix=TARGETERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t --bitwidth=64 --endianness=big %s 2>&1 | FileCheck %s -DMSG="Arch" --check-prefix=TARGETERR
 
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --arch=x86_64 --endianness=big %s 2>&1 | FileCheck %s -DMSG="BitWidth" --check-prefix=TARGETERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t --arch=x86_64 --endianness=big %s 2>&1 | FileCheck %s -DMSG="BitWidth" --check-prefix=TARGETERR
 
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --arch=x86_64 --bitwidth=64 %s 2>&1 | FileCheck %s -DMSG="Endianness" --check-prefix=TARGETERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t --arch=x86_64 --bitwidth=64 %s 2>&1 | FileCheck %s -DMSG="Endianness" --check-prefix=TARGETERR
 
-# RUN: llvm-elfabi --output-format=IFS --output=%t.target --target=x86_64-linux-gnu %s
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --target=aarch64-linux-gnu %t.target 2>&1 | FileCheck %s -DMSG="Triple" --check-prefix=CONFLICTERR
+# RUN: llvm-ifs --output-format=IFS --output=%t.target --target=x86_64-linux-gnu %s
+# RUN: not llvm-ifs --output-format=ELF --output=%t --target=aarch64-linux-gnu %t.target 2>&1 | FileCheck %s -DMSG="Triple" --check-prefix=CONFLICTERR
 
-# RUN: llvm-elfabi --output-format=IFS --output=%t.target --arch=x86_64 --endianness=little --bitwidth=64 %s
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --arch=AArch64 %t.target 2>&1 | FileCheck %s -DMSG=Arch --check-prefix=CONFLICTERR
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --endianness=big %t.target 2>&1 | FileCheck %s -DMSG=Endianness --check-prefix=CONFLICTERR
-# RUN: not llvm-elfabi --output-format=ELF --output=%t --bitwidth=32 %t.target 2>&1 | FileCheck %s -DMSG=BitWidth --check-prefix=CONFLICTERR
+# RUN: llvm-ifs --output-format=IFS --output=%t.target --arch=x86_64 --endianness=little --bitwidth=64 %s
+# RUN: not llvm-ifs --output-format=ELF --output=%t --arch=AArch64 %t.target 2>&1 | FileCheck %s -DMSG=Arch --check-prefix=CONFLICTERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t --endianness=big %t.target 2>&1 | FileCheck %s -DMSG=Endianness --check-prefix=CONFLICTERR
+# RUN: not llvm-ifs --output-format=ELF --output=%t --bitwidth=32 %t.target 2>&1 | FileCheck %s -DMSG=BitWidth --check-prefix=CONFLICTERR
 
 --- !ifs-v1
 IfsVersion: 3.0
 NeededLibs:
   - libc.so.6
 Symbols:
   - { Name: bar, Type: Object, Size: 42 }
   - { Name: baz, Type: TLS, Size: 3 }

 # CHECK-NEXT: [     1] .dynstr
 # CHECK-NEXT: [     9] .dynsym
 # CHECK-NEXT: [    11] .dynamic
 # CHECK-NEXT: [    1a] .shstrtab
 
 # TRIPLEERR: error: Target triple cannot be used simultaneously with ELF target format
 # TARGETERR: error: [[MSG]] is not defined in the text stub
 # CONFLICTERR: error: Supplied [[MSG]] conflicts with the text stub
 No newline at end of file

llvm/tools/llvm-elfabi/CMakeLists.txt

-set(LLVM_LINK_COMPONENTS
-  BinaryFormat
-  InterfaceStub
-  Object
-  Support
-  TextAPI
-  )
-
-add_llvm_tool(llvm-elfabi
-  ErrorCollector.cpp
-  llvm-elfabi.cpp
-  )

llvm/tools/llvm-elfabi/llvm-elfabi.cpp

-//===- llvm-elfabi.cpp ----------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===-----------------------------------------------------------------------===/
-
-#include "ErrorCollector.h"
-#include "llvm/InterfaceStub/ELFObjHandler.h"
-#include "llvm/InterfaceStub/IFSHandler.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/FileOutputBuffer.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/WithColor.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string>
-
-namespace llvm {
-namespace elfabi {
-
-enum class FileFormat { IFS, ELF };
-
-} // namespace elfabi
-} // end namespace llvm
-
-using namespace llvm;
-using namespace llvm::elfabi;
-
-// Command line flags:
-cl::opt<std::string> InputFilePath(cl::Positional, cl::desc("input"),
-                                   cl::Required);
-cl::opt<FileFormat> InputFormat(
-    "input-format", cl::desc("Specify the input file format"),
-    cl::values(clEnumValN(FileFormat::IFS, "IFS", "Text based ELF stub file"),
-               clEnumValN(FileFormat::ELF, "ELF", "ELF object file")));
-cl::opt<FileFormat> OutputFormat(
-    "output-format", cl::desc("Specify the output file format"),
-    cl::values(clEnumValN(FileFormat::IFS, "IFS", "Text based ELF stub file"),
-               clEnumValN(FileFormat::ELF, "ELF", "ELF stub file")),
-    cl::Required);
-cl::opt<std::string> OptArch("arch",
-                             cl::desc("Specify the architecture, e.g. x86_64"));
-cl::opt<IFSBitWidthType> OptBitWidth(
-    "bitwidth", cl::desc("Specify the bit width"),
-    cl::values(clEnumValN(IFSBitWidthType::IFS32, "32", "32 bits"),
-               clEnumValN(IFSBitWidthType::IFS64, "64", "64 bits")));
-cl::opt<IFSEndiannessType> OptEndianness(
-    "endianness", cl::desc("Specify the endianness"),
-    cl::values(clEnumValN(IFSEndiannessType::Little, "little", "Little Endian"),
-               clEnumValN(IFSEndiannessType::Big, "big", "Big Endian")));
-cl::opt<std::string> OptTargetTriple(
-    "target", cl::desc("Specify the target triple, e.g. x86_64-linux-gnu"));
-cl::opt<std::string> OptTargetTripleHint(
-    "hint-ifs-target",
-    cl::desc("When --output-format is 'IFS', this flag will hint the expected "
-             "target triple for IFS output"));
-cl::opt<bool> StripIFSArch(
-    "strip-ifs-arch",
-    cl::desc("Strip target architecture information away from IFS output"));
-cl::opt<bool> StripIFSBitWidth(
-    "strip-ifs-bitwidth",
-    cl::desc("Strip target bit width information away from IFS output"));
-cl::opt<bool> StripIFSEndiannessWidth(
-    "strip-ifs-endianness",
-    cl::desc("Strip target endianness information away from IFS output"));
-cl::opt<bool> StripIFSTarget(
-    "strip-ifs-target",
-    cl::desc("Strip all target information away from IFS output"));
-cl::opt<std::string>
-    SOName("soname",
-           cl::desc("Manually set the DT_SONAME entry of any emitted files"),
-           cl::value_desc("name"));
-cl::opt<std::string> OutputFilePath("output", cl::desc("Output file"));
-cl::opt<bool> WriteIfChanged(
-    "write-if-changed",
-    cl::desc("Write the output file only if it is new or has changed."));
-
-/// writeIFS() writes a Text-Based ELF stub to a file using the latest version
-/// of the YAML parser.
-static Error writeIFS(StringRef FilePath, IFSStub &Stub) {
-  // Write IFS to memory first.
-  std::string IFSStr;
-  raw_string_ostream OutStr(IFSStr);
-  Error YAMLErr = writeIFSToOutputStream(OutStr, Stub);
-  if (YAMLErr)
-    return YAMLErr;
-  OutStr.flush();
-
-  if (WriteIfChanged) {
-    if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
-            MemoryBuffer::getFile(FilePath)) {
-      // Compare IFS output with existing IFS file.
-      // If IFS file unchanged, abort updating.
-      if ((*BufOrError)->getBuffer() == IFSStr)
-        return Error::success();
-    }
-  }
-  // Open IFS file for writing.
-  std::error_code SysErr;
-  raw_fd_ostream Out(FilePath, SysErr);
-  if (SysErr)
-    return createStringError(SysErr, "Couldn't open `%s` for writing",
-                             FilePath.data());
-  Out << IFSStr;
-  return Error::success();
-}
-
-/// readInputFile populates an IFSStub by attempting to read the
-/// input file using both the IFS and binary ELF parsers.
-static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
-  // Read in file.
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
-      MemoryBuffer::getFile(FilePath);
-  if (!BufOrError) {
-    return createStringError(BufOrError.getError(), "Could not open `%s`",
-                             FilePath.data());
-  }
-
-  std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
-  ErrorCollector EC(/*UseFatalErrors=*/false);
-
-  // First try to read as a binary (fails fast if not binary).
-  if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::ELF) {
-    Expected<std::unique_ptr<IFSStub>> StubFromELF =
-        readELFFile(FileReadBuffer->getMemBufferRef());
-    if (StubFromELF) {
-      return std::move(*StubFromELF);
-    }
-    EC.addError(StubFromELF.takeError(), "BinaryRead");
-  }
-
-  // Fall back to reading as a ifs.
-  if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::IFS) {
-    Expected<std::unique_ptr<IFSStub>> StubFromIFS =
-        readIFSFromBuffer(FileReadBuffer->getBuffer());
-    if (StubFromIFS) {
-      return std::move(*StubFromIFS);
-    }
-    EC.addError(StubFromIFS.takeError(), "YamlParse");
-  }
-
-  // If both readers fail, build a new error that includes all information.
-  EC.addError(createStringError(errc::not_supported,
-                                "No file readers succeeded reading `%s` "
-                                "(unsupported/malformed file?)",
-                                FilePath.data()),
-              "ReadInputFile");
-  EC.escalateToFatal();
-  return EC.makeError();
-}
-
-static void fatalError(Error Err) {
-  WithColor::defaultErrorHandler(std::move(Err));
-  exit(1);
-}
-
-int main(int argc, char *argv[]) {
-  // Parse arguments.
-  cl::ParseCommandLineOptions(argc, argv);
-  Expected<std::unique_ptr<IFSStub>> StubOrErr = readInputFile(InputFilePath);
-  if (!StubOrErr)
-    fatalError(StubOrErr.takeError());
-
-  std::unique_ptr<IFSStub> TargetStub = std::move(StubOrErr.get());
-
-  // Change SoName before emitting stubs.
-  if (SOName.getNumOccurrences() == 1)
-    TargetStub->SoName = SOName;
-  Optional<IFSArch> OverrideArch;
-  Optional<IFSEndiannessType> OverrideEndianness;
-  Optional<IFSBitWidthType> OverrideBitWidth;
-  Optional<std::string> OverrideTriple;
-  if (OptArch.getNumOccurrences() == 1) {
-    OverrideArch = ELF::convertArchNameToEMachine(OptArch.getValue());
-  }
-  if (OptEndianness.getNumOccurrences() == 1)
-    OverrideEndianness = OptEndianness.getValue();
-  if (OptBitWidth.getNumOccurrences() == 1)
-    OverrideBitWidth = OptBitWidth.getValue();
-  if (OptTargetTriple.getNumOccurrences() == 1)
-    OverrideTriple = OptTargetTriple.getValue();
-  Error OverrideError =
-      overrideIFSTarget(*TargetStub, OverrideArch, OverrideEndianness,
-                        OverrideBitWidth, OverrideTriple);
-  if (OverrideError)
-    fatalError(std::move(OverrideError));
-  switch (OutputFormat.getValue()) {
-  case FileFormat::IFS: {
-    TargetStub->IfsVersion = IFSVersionCurrent;
-    if (InputFormat.getValue() == FileFormat::ELF &&
-        OptTargetTripleHint.getNumOccurrences() == 1) {
-      std::error_code HintEC(1, std::generic_category());
-      IFSTarget HintTarget = parseTriple(OptTargetTripleHint);
-      if (TargetStub->Target.Arch.getValue() != HintTarget.Arch.getValue()) {
-        fatalError(make_error<StringError>(
-            "Triple hint does not match the actual architecture", HintEC));
-      }
-      if (TargetStub->Target.Endianness.getValue() !=
-          HintTarget.Endianness.getValue()) {
-        fatalError(make_error<StringError>(
-            "Triple hint does not match the actual endianness", HintEC));
-      }
-      if (TargetStub->Target.BitWidth.getValue() !=
-          HintTarget.BitWidth.getValue()) {
-        fatalError(make_error<StringError>(
-            "Triple hint does not match the actual bit width", HintEC));
-      }
-      stripIFSTarget(*TargetStub, true, false, false, false);
-      TargetStub->Target.Triple = OptTargetTripleHint.getValue();
-    } else {
-      stripIFSTarget(*TargetStub, StripIFSTarget, StripIFSArch,
-                     StripIFSEndiannessWidth, StripIFSBitWidth);
-    }
-    Error IFSWriteError = writeIFS(OutputFilePath.getValue(), *TargetStub);
-    if (IFSWriteError)
-      fatalError(std::move(IFSWriteError));
-    break;
-  }
-  case FileFormat::ELF: {
-    Error TargetError = validateIFSTarget(*TargetStub, true);
-    if (TargetError)
-      fatalError(std::move(TargetError));
-    Error BinaryWriteError =
-        writeBinaryStub(OutputFilePath, *TargetStub, WriteIfChanged);
-    if (BinaryWriteError)
-      fatalError(std::move(BinaryWriteError));
-    break;
-  }
-  }
-}

llvm/tools/llvm-ifs/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   InterfaceStub  
   Object
   Support
   TextAPI
   ObjectYAML
   )
 
 add_llvm_tool(llvm-ifs
+  ErrorCollector.cpp
   llvm-ifs.cpp
   )

llvm/tools/llvm-ifs/ErrorCollector.h

 /// errors as non-fatal. In this case, all Errors are consumed upon destruction.
 /// An ErrorCollector may be initially constructed (or escalated) such that
 /// errors are treated as fatal. This causes a crash if an attempt is made to
 /// delete the ErrorCollector when some Errors have not been retrieved via
 /// makeError().
 ///
 //===-----------------------------------------------------------------------===/
 
-#ifndef LLVM_TOOLS_ELFABI_ERRORCOLLECTOR_H
-#define LLVM_TOOLS_ELFABI_ERRORCOLLECTOR_H
+#ifndef LLVM_TOOLS_LLVM_IFS_ERRORCOLLECTOR_H
+#define LLVM_TOOLS_LLVM_IFS_ERRORCOLLECTOR_H
 
 #include "llvm/Support/Error.h"
 #include <vector>
 
 namespace llvm {
-namespace elfabi {
+namespace ifs {
 
 class ErrorCollector {
 public:
   /// Upon destruction, an ErrorCollector will crash if UseFatalErrors=true and
   /// there are remaining errors that haven't been fetched by makeError().
   ErrorCollector(bool UseFatalErrors = true) : ErrorsAreFatal(UseFatalErrors) {}
   // Don't allow copying.
   ErrorCollector(const ErrorCollector &Stub) = delete;
private:
   /// Dump output and crash.
   LLVM_ATTRIBUTE_NORETURN void fatalUnhandledError();
 
   bool ErrorsAreFatal;
   std::vector<Error> Errors;
   std::vector<std::string> Tags;
 };
 
-} // end namespace elfabi
+} // end namespace ifs
 } // end namespace llvm
 
-#endif // LLVM_TOOLS_ELFABI_ERRORCOLLECTOR_H
+#endif // LLVM_TOOLS_LLVM_IFS_ERRORCOLLECTOR_H

llvm/tools/llvm-ifs/ErrorCollector.cpp

 //===- ErrorCollector.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===-----------------------------------------------------------------------===/
 
 #include "ErrorCollector.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 using namespace llvm;
-using namespace llvm::elfabi;
+using namespace llvm::ifs;
 
 void ErrorCollector::escalateToFatal() { ErrorsAreFatal = true; }
 
 void ErrorCollector::addError(Error &&Err, StringRef Tag) {
   if (Err) {
     Errors.push_back(std::move(Err));
     Tags.push_back(Tag.str());
   }

llvm/tools/llvm-ifs/llvm-ifs.cpp

 //===- llvm-ifs.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===-----------------------------------------------------------------------===/
 
+#include "ErrorCollector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/InterfaceStub/ELFObjHandler.h"
 #include "llvm/InterfaceStub/IFSHandler.h"
 #include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/CommandLine.h"

 #include "llvm/TextAPI/MachO/TextAPIWriter.h"
 #include <set>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::yaml;
 using namespace llvm::MachO;
+using namespace llvm::ifs;
 
 #define DEBUG_TYPE "llvm-ifs"
 
 namespace {
-const VersionTuple IFSVersionCurrent(3, 0);
-} // end anonymous namespace
+const VersionTuple IfsVersionCurrent(3, 0);
 
-static cl::opt<std::string> Action("action", cl::desc("<llvm-ifs action>"),
-                                   cl::value_desc("write-ifs | write-bin"),
-                                   cl::init("write-ifs"));
-
-static cl::opt<std::string> ForceFormat("force-format",
-                                        cl::desc("<force object format>"),
-                                        cl::value_desc("ELF | TBD"),
-                                        cl::init(""));
+enum class FileFormat { IFS, ELF, TBD };
+} // end anonymous namespace
 
-static cl::list<std::string> InputFilenames(cl::Positional,
-                                            cl::desc("<input ifs files>"),
-                                            cl::ZeroOrMore);
-
-static cl::opt<std::string> OutputFilename("o", cl::desc("<output file>"),
-                                           cl::value_desc("path"));
-
-static cl::opt<bool> UseInterfaceStub(
-    "use-interfacestub",
-    cl::desc("Write output ELF file using latest InterfaceStub backend"),
-    cl::init(false));
-
-enum class IFSSymbolType {
-  NoType = 0,
-  Object,
-  Func,
-  // Type information is 4 bits, so 16 is safely out of range.
-  Unknown = 16,
-};
+// Command line flags:
+cl::list<std::string> InputFilePaths(cl::Positional, cl::desc("input"),
+cl::opt<FileFormat> InputFormat(
+    "input-format", cl::desc("Specify the input file format"),
+    cl::values(clEnumValN(FileFormat::IFS, "IFS", "Text based ELF stub file"),
+               clEnumValN(FileFormat::ELF, "ELF", "ELF object file")));
+cl::opt<FileFormat> OutputFormat(
+    "output-format", cl::desc("Specify the output file format"),
+    cl::values(clEnumValN(FileFormat::IFS, "IFS", "Text based ELF stub file"),
+               clEnumValN(FileFormat::ELF, "ELF", "ELF stub file"),
+               clEnumValN(FileFormat::TBD, "TBD", "Apple TBD text stub file")),
+    cl::Required);
+cl::opt<std::string> OptArch("arch",
+                             cl::desc("Specify the architecture, e.g. x86_64"));
+cl::opt<IFSBitWidthType> OptBitWidth(
+    "bitwidth", cl::desc("Specify the bit width"),
+    cl::values(clEnumValN(IFSBitWidthType::IFS32, "32", "32 bits"),
+               clEnumValN(IFSBitWidthType::IFS64, "64", "64 bits")));
+cl::opt<IFSEndiannessType> OptEndianness(
+    "endianness", cl::desc("Specify the endianness"),
+    cl::values(clEnumValN(IFSEndiannessType::Little, "little", "Little Endian"),
+               clEnumValN(IFSEndiannessType::Big, "big", "Big Endian")));
+cl::opt<std::string> OptTargetTriple(
+    "target", cl::desc("Specify the target triple, e.g. x86_64-linux-gnu"));
+cl::opt<std::string> OptTargetTripleHint(
+    "hint-ifs-target",
+    cl::desc("When --output-format is 'IFS', this flag will hint the expected "
+             "target triple for IFS output"));
+cl::opt<bool> StripIFSArch(
+    "strip-ifs-arch",
+    cl::desc("Strip target architecture information away from IFS output"));
+cl::opt<bool> StripIFSBitWidth(
+    "strip-ifs-bitwidth",
+    cl::desc("Strip target bit width information away from IFS output"));
+cl::opt<bool> StripIFSEndiannessWidth(
+    "strip-ifs-endianness",
+    cl::desc("Strip target endianness information away from IFS output"));
+cl::opt<bool> StripIFSTarget(
+    "strip-ifs-target",
+    cl::desc("Strip all target information away from IFS output"));
+cl::opt<std::string>
+    SoName("soname",
+           cl::desc("Manually set the DT_SONAME entry of any emitted files"),
+           cl::value_desc("name"));
+cl::opt<std::string> OutputFilePath("output", cl::desc("Output file"));
+cl::alias OutputFilePathA("o", cl::desc("Alias for --output"),
+                          cl::aliasopt(OutputFilePath));
+cl::opt<bool> WriteIfChanged(
+    "write-if-changed",
+    cl::desc("Write the output file only if it is new or has changed."));
 
 static std::string getTypeName(IFSSymbolType Type) {
   switch (Type) {
   case IFSSymbolType::NoType:
     return "NoType";
   case IFSSymbolType::Func:
     return "Func";
   case IFSSymbolType::Object:
     return "Object";
+  case IFSSymbolType::TLS:
+    return "TLS";
   case IFSSymbolType::Unknown:
     return "Unknown";
   }
   llvm_unreachable("Unexpected ifs symbol type.");
 }
 
-struct IFSSymbol {
-  IFSSymbol() = default;
-  IFSSymbol(std::string SymbolName) : Name(SymbolName) {}
-  std::string Name;
-  uint64_t Size;
-  IFSSymbolType Type;
-  bool Weak;
-  Optional<std::string> Warning;
-  bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; }
-};
-
-LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
-
-namespace llvm {
-namespace yaml {
-/// YAML traits for IFSSymbolType.
-template <> struct ScalarEnumerationTraits<IFSSymbolType> {
-  static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
-    IO.enumCase(SymbolType, "NoType", IFSSymbolType::NoType);
-    IO.enumCase(SymbolType, "Func", IFSSymbolType::Func);
-    IO.enumCase(SymbolType, "Object", IFSSymbolType::Object);
-    IO.enumCase(SymbolType, "Unknown", IFSSymbolType::Unknown);
-    // Treat other symbol types as noise, and map to Unknown.
-    if (!IO.outputting() && IO.matchEnumFallback())
-      SymbolType = IFSSymbolType::Unknown;
-  }
-};
-
-/// YAML traits for IFSSymbol.
-template <> struct MappingTraits<IFSSymbol> {
-  static void mapping(IO &IO, IFSSymbol &Symbol) {
-    IO.mapRequired("Name", Symbol.Name);
-    IO.mapRequired("Type", Symbol.Type);
-    // The need for symbol size depends on the symbol type.
-    if (Symbol.Type == IFSSymbolType::NoType)
-      IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
-    else if (Symbol.Type == IFSSymbolType::Func)
-      Symbol.Size = 0;
-    else
-      IO.mapRequired("Size", Symbol.Size);
-    IO.mapOptional("Weak", Symbol.Weak, false);
-    IO.mapOptional("Warning", Symbol.Warning);
-  }
-
-  // Compacts symbol information into a single line.
-  static const bool flow = true;
-};
-
-} // namespace yaml
-} // namespace llvm
-
-// A cumulative representation of ELF stubs.
-// Both textual and binary stubs will read into and write from this object.
-class IFSStub {
-  // TODO: Add support for symbol versioning.
-public:
-  VersionTuple IfsVersion;
-  std::string Triple;
-  std::string ObjectFileFormat;
-  Optional<std::string> SOName;
-  std::vector<std::string> NeededLibs;
-  std::vector<IFSSymbol> Symbols;
-
-  IFSStub() = default;
-  IFSStub(const IFSStub &Stub)
-      : IfsVersion(Stub.IfsVersion), Triple(Stub.Triple),
-        ObjectFileFormat(Stub.ObjectFileFormat), SOName(Stub.SOName),
-        NeededLibs(Stub.NeededLibs), Symbols(Stub.Symbols) {}
-  IFSStub(IFSStub &&Stub)
-      : IfsVersion(std::move(Stub.IfsVersion)), Triple(std::move(Stub.Triple)),
-        ObjectFileFormat(std::move(Stub.ObjectFileFormat)),
-        SOName(std::move(Stub.SOName)), NeededLibs(std::move(Stub.NeededLibs)),
-        Symbols(std::move(Stub.Symbols)) {}
-};
-
-namespace llvm {
-namespace yaml {
-/// YAML traits for IFSStub objects.
-template <> struct MappingTraits<IFSStub> {
-  static void mapping(IO &IO, IFSStub &Stub) {
-    if (!IO.mapTag("!ifs-v1", true))
-      IO.setError("Not a .ifs YAML file.");
-
-    auto OldContext = IO.getContext();
-    IO.setContext(&Stub);
-    IO.mapRequired("IfsVersion", Stub.IfsVersion);
-    IO.mapOptional("Target", Stub.Triple);
-    IO.mapOptional("SOName", Stub.SOName);
-    IO.mapOptional("NeededLibs", Stub.NeededLibs);
-    IO.mapRequired("Symbols", Stub.Symbols);
-    IO.setContext(&OldContext);
-  }
-};
-} // namespace yaml
-} // namespace llvm
-
 static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
   // Read in file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
-      MemoryBuffer::getFileOrSTDIN(FilePath);
-  if (!BufOrError)
+      MemoryBuffer::getFile(FilePath);
+  if (!BufOrError) {
     return createStringError(BufOrError.getError(), "Could not open `%s`",
                              FilePath.data());
+  }
 
   std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
-  yaml::Input YamlIn(FileReadBuffer->getBuffer());
-  std::unique_ptr<IFSStub> Stub(new IFSStub());
-  YamlIn >> *Stub;
-
-  if (std::error_code Err = YamlIn.error())
-    return createStringError(Err, "Failed reading Interface Stub File.");
-
-  if (Stub->IfsVersion > IFSVersionCurrent)
-    return make_error<StringError>(
-        "IFS version " + Stub->IfsVersion.getAsString() + " is unsupported.",
-        std::make_error_code(std::errc::invalid_argument));
+  ErrorCollector EC(/*UseFatalErrors=*/false);
+
+  // First try to read as a binary (fails fast if not binary).
+  if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::ELF) {
+    Expected<std::unique_ptr<IFSStub>> StubFromELF =
+        readELFFile(FileReadBuffer->getMemBufferRef());
+    if (StubFromELF) {
+      (*StubFromELF)->IfsVersion = IfsVersionCurrent;
+      return std::move(*StubFromELF);
+    }
+    EC.addError(StubFromELF.takeError(), "BinaryRead");
+  }
+
+  // Fall back to reading as a ifs.
+  if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::IFS) {
+    Expected<std::unique_ptr<IFSStub>> StubFromIFS =
+        readIFSFromBuffer(FileReadBuffer->getBuffer());
+    if (StubFromIFS) {
+      if ((*StubFromIFS)->IfsVersion > IfsVersionCurrent)
+        EC.addError(
+            createStringError(errc::not_supported,
+                              "IFS version " +
+                                  (*StubFromIFS)->IfsVersion.getAsString() +
+                                  " is unsupported."),
+            "ReadInputFile");
+      else
+        return std::move(*StubFromIFS);
+    } else {
+      EC.addError(StubFromIFS.takeError(), "YamlParse");
+    }
+  }
 
-  return std::move(Stub);
+  // If both readers fail, build a new error that includes all information.
+  EC.addError(createStringError(errc::not_supported,
+                                "No file readers succeeded reading `%s` "
+                                "(unsupported/malformed file?)",
+                                FilePath.data()),
+              "ReadInputFile");
+  EC.escalateToFatal();
+  return EC.makeError();
 }
 
 static int writeTbdStub(const Triple &T, const std::vector<IFSSymbol> &Symbols,
                         const StringRef Format, raw_ostream &Out) {
 
   auto PlatformKindOrError =
       [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformKind> {
     if (T.isMacOSX())
       return llvm::MachO::PlatformKind::macOS;
     if (T.isTvOS())
       return llvm::MachO::PlatformKind::tvOS;
     if (T.isWatchOS())
       return llvm::MachO::PlatformKind::watchOS;
     // Note: put isiOS last because tvOS and watchOS are also iOS according
     // to the Triple.
     if (T.isiOS())
       return llvm::MachO::PlatformKind::iOS;
 
-    // TODO: Add an option for ForceTriple, but keep ForceFormat for now.
-    if (ForceFormat == "TBD")
-      return llvm::MachO::PlatformKind::macOS;
-
     return createStringError(errc::not_supported, "Invalid Platform.\n");
   }(T);
 
   if (!PlatformKindOrError)
     return -1;
 
   PlatformKind Plat = PlatformKindOrError.get();
   TargetList Targets({Target(llvm::MachO::mapToArchitecture(T), Plat)});
static int writeTbdStub(const Triple &T, const std::vector<IFSSymbol> &Symbols,
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   if (Error Result = TextAPIWriter::writeToStream(OS, File))
     return -1;
   Out << OS.str();
   return 0;
 }
 
-static int writeElfStub(const Triple &T, const std::vector<IFSSymbol> &Symbols,
-                        const StringRef Format, raw_ostream &Out) {
-  SmallString<0> Storage;
-  Storage.clear();
-  raw_svector_ostream OS(Storage);
-
-  OS << "--- !ELF\n";
-  OS << "FileHeader:\n";
-  OS << "  Class:           ELFCLASS";
-  OS << (T.isArch64Bit() ? "64" : "32");
-  OS << "\n";
-  OS << "  Data:            ELFDATA2";
-  OS << (T.isLittleEndian() ? "LSB" : "MSB");
-  OS << "\n";
-  OS << "  Type:            ET_DYN\n";
-  OS << "  Machine:         "
-     << llvm::StringSwitch<llvm::StringRef>(T.getArchName())
-            .Case("x86_64", "EM_X86_64")
-            .Case("i386", "EM_386")
-            .Case("i686", "EM_386")
-            .Case("aarch64", "EM_AARCH64")
-            .Case("amdgcn", "EM_AMDGPU")
-            .Case("r600", "EM_AMDGPU")
-            .Case("arm", "EM_ARM")
-            .Case("thumb", "EM_ARM")
-            .Case("avr", "EM_AVR")
-            .Case("mips", "EM_MIPS")
-            .Case("mipsel", "EM_MIPS")
-            .Case("mips64", "EM_MIPS")
-            .Case("mips64el", "EM_MIPS")
-            .Case("msp430", "EM_MSP430")
-            .Case("ppc", "EM_PPC")
-            .Case("ppc64", "EM_PPC64")
-            .Case("ppc64le", "EM_PPC64")
-            .Case("x86", T.isOSIAMCU() ? "EM_IAMCU" : "EM_386")
-            .Case("x86_64", "EM_X86_64")
-            .Default("EM_NONE")
-     << "\nSections:"
-     << "\n  - Name:            .text"
-     << "\n    Type:            SHT_PROGBITS"
-     << "\n  - Name:            .data"
-     << "\n    Type:            SHT_PROGBITS"
-     << "\n  - Name:            .rodata"
-     << "\n    Type:            SHT_PROGBITS"
-     << "\nSymbols:\n";
-  for (const auto &Symbol : Symbols) {
-    OS << "  - Name:            " << Symbol.Name << "\n"
-       << "    Type:            STT_";
-    switch (Symbol.Type) {
-    default:
-    case IFSSymbolType::NoType:
-      OS << "NOTYPE";
-      break;
-    case IFSSymbolType::Object:
-      OS << "OBJECT";
-      break;
-    case IFSSymbolType::Func:
-      OS << "FUNC";
-      break;
-    }
-    OS << "\n    Section:         .text"
-       << "\n    Binding:         STB_" << (Symbol.Weak ? "WEAK" : "GLOBAL")
-       << "\n";
-  }
-  OS << "...\n";
-
-  std::string YamlStr = std::string(OS.str());
-
-  // Only or debugging. Not an offical format.
-  LLVM_DEBUG({
-    if (ForceFormat == "ELFOBJYAML") {
-      Out << YamlStr;
-      return 0;
-    }
-  });
-
-  yaml::Input YIn(YamlStr);
-  auto ErrHandler = [](const Twine &Msg) {
-    WithColor::error(errs(), "llvm-ifs") << Msg << "\n";
-  };
-  return convertYAML(YIn, Out, ErrHandler) ? 0 : 1;
-}
-
-static Error convertIFSStub(const IFSStub &IfsStub, elfabi::IFSStub &ElfStub) {
-  ElfStub.IfsVersion = IfsStub.IfsVersion;
-  ElfStub.SoName = IfsStub.SOName;
-  ElfStub.Target.Triple = IfsStub.Triple;
-  ElfStub.NeededLibs = IfsStub.NeededLibs;
-  for (const IFSSymbol &IfsSymbol : IfsStub.Symbols) {
-    elfabi::IFSSymbol ElfSymbol(IfsSymbol.Name);
-    switch (IfsSymbol.Type) {
-    case IFSSymbolType::Func:
-      ElfSymbol.Type = elfabi::IFSSymbolType::Func;
-      break;
-    case IFSSymbolType::NoType:
-      ElfSymbol.Type = elfabi::IFSSymbolType::NoType;
-      break;
-    case IFSSymbolType::Object:
-      ElfSymbol.Type = elfabi::IFSSymbolType::Object;
-      break;
-    default:
-      ElfSymbol.Type = elfabi::IFSSymbolType::Unknown;
-      break;
-      // TODO: Add support for TLS?
-    }
-    ElfSymbol.Size = IfsSymbol.Size;
-    ElfSymbol.Undefined = false;
-    ElfSymbol.Weak = IfsSymbol.Weak;
-    ElfSymbol.Warning = IfsSymbol.Warning;
-    ElfStub.Symbols.push_back(ElfSymbol);
+static void fatalError(Error Err) {
+  WithColor::defaultErrorHandler(std::move(Err));
+  exit(1);
+}
+
+/// writeIFS() writes a Text-Based ELF stub to a file using the latest version
+/// of the YAML parser.
+static Error writeIFS(StringRef FilePath, IFSStub &Stub) {
+  // Write IFS to memory first.
+  std::string IFSStr;
+  raw_string_ostream OutStr(IFSStr);
+  Error YAMLErr = writeIFSToOutputStream(OutStr, Stub);
+  if (YAMLErr)
+    return YAMLErr;
+  OutStr.flush();
+
+  if (WriteIfChanged) {
+    if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
+            MemoryBuffer::getFile(FilePath)) {
+      // Compare IFS output with existing IFS file.
+      // If IFS file unchanged, abort updating.
+      if ((*BufOrError)->getBuffer() == IFSStr)
+        return Error::success();
     }
-  return llvm::elfabi::validateIFSTarget(ElfStub, true);
-}
-
-static int writeIfso(const IFSStub &Stub, bool IsWriteIfs) {
-  std::string ObjectFileFormat =
-      ForceFormat.empty() ? std::string("ELF") : ForceFormat;
-
-  // Use InterfaceStub library if the option is enabled and output
-  // format is ELF.
-  if (UseInterfaceStub && (!IsWriteIfs) && ObjectFileFormat != "TBD") {
-    elfabi::IFSStub IfsStub;
-    Error ConvertError = convertIFSStub(Stub, IfsStub);
-    if (ConvertError) {
-      return -1;
-    }
-    Error BinaryWriteError = elfabi::writeBinaryStub(OutputFilename, IfsStub);
-    if (BinaryWriteError) {
-      return -1;
-    }
-    return 0;
   }
-
-  // Open file for writing.
+  // Open IFS file for writing.
   std::error_code SysErr;
-  raw_fd_ostream Out(OutputFilename, SysErr);
-  if (SysErr) {
-    WithColor::error() << "Couldn't open " << OutputFilename
-                       << " for writing.\n";
-    return -1;
-  }
-
-  if (IsWriteIfs) {
-    yaml::Output YamlOut(Out, NULL, /*WrapColumn =*/0);
-    YamlOut << const_cast<IFSStub &>(Stub);
-    return 0;
-  }
-
-  if (ObjectFileFormat == "ELF" || ForceFormat == "ELFOBJYAML")
-    return writeElfStub(llvm::Triple(Stub.Triple), Stub.Symbols,
-                        Stub.ObjectFileFormat, Out);
-  if (ObjectFileFormat == "TBD")
-    return writeTbdStub(llvm::Triple(Stub.Triple), Stub.Symbols,
-                        Stub.ObjectFileFormat, Out);
-
-  WithColor::error()
-      << "Invalid ObjectFileFormat: Only ELF and TBD are supported.\n";
-  return -1;
+  raw_fd_ostream Out(FilePath, SysErr);
+  if (SysErr)
+    return createStringError(SysErr, "Couldn't open `%s` for writing",
+                             FilePath.data());
+  Out << IFSStr;
+  return Error::success();
 }
 
-// TODO: Drop ObjectFileFormat, it can be subsumed from the triple.
-// New Interface Stubs Yaml Format:
-// --- !experimental-ifs-v2
-// IfsVersion: 2.0
-// Triple:          <llvm triple>
-// ObjectFileFormat: <ELF | others not yet supported>
-// Symbols:
-//   _ZSymbolName: { Type: <type> }
-// ...
-
 int main(int argc, char *argv[]) {
   // Parse arguments.
   cl::ParseCommandLineOptions(argc, argv);
 
-  if (InputFilenames.empty())
-    InputFilenames.push_back("-");
+  if (InputFilePaths.empty())
+    InputFilePaths.push_back("-");
+
+  // If input files are more than one, they can only be IFS files.
+  if (InputFilePaths.size() > 1)
+    InputFormat.setValue(FileFormat::IFS);
 
+  // Attempt to merge input.
   IFSStub Stub;
   std::map<std::string, IFSSymbol> SymbolMap;
-
   std::string PreviousInputFilePath;
-  for (const std::string &InputFilePath : InputFilenames) {
+  for (const std::string &InputFilePath : InputFilePaths) {
     Expected<std::unique_ptr<IFSStub>> StubOrErr = readInputFile(InputFilePath);
-    if (!StubOrErr) {
-      WithColor::error() << StubOrErr.takeError() << "\n";
-      return -1;
-    }
-    std::unique_ptr<IFSStub> TargetStub = std::move(StubOrErr.get());
+    if (!StubOrErr)
+      fatalError(StubOrErr.takeError());
 
-    if (Stub.Triple.empty()) {
-      PreviousInputFilePath = InputFilePath;
+    std::unique_ptr<IFSStub> TargetStub = std::move(StubOrErr.get());
+    if (PreviousInputFilePath.empty()) {
       Stub.IfsVersion = TargetStub->IfsVersion;
-      Stub.Triple = TargetStub->Triple;
-      Stub.ObjectFileFormat = TargetStub->ObjectFileFormat;
-      Stub.SOName = TargetStub->SOName;
+      Stub.Target = TargetStub->Target;
+      Stub.SoName = TargetStub->SoName;
       Stub.NeededLibs = TargetStub->NeededLibs;
     } else {
-      Stub.ObjectFileFormat = !Stub.ObjectFileFormat.empty()
-                                  ? Stub.ObjectFileFormat
-                                  : TargetStub->ObjectFileFormat;
-
       if (Stub.IfsVersion != TargetStub->IfsVersion) {
-        if (Stub.IfsVersion.getMajor() != IFSVersionCurrent.getMajor()) {
+        if (Stub.IfsVersion.getMajor() != IfsVersionCurrent.getMajor()) {
           WithColor::error()
               << "Interface Stub: IfsVersion Mismatch."
               << "\nFilenames: " << PreviousInputFilePath << " "
               << InputFilePath << "\nIfsVersion Values: " << Stub.IfsVersion
               << " " << TargetStub->IfsVersion << "\n";
           return -1;
         }
         if (TargetStub->IfsVersion > Stub.IfsVersion)
           Stub.IfsVersion = TargetStub->IfsVersion;
       }
-      if (Stub.ObjectFileFormat != TargetStub->ObjectFileFormat &&
-          !TargetStub->ObjectFileFormat.empty()) {
-        WithColor::error() << "Interface Stub: ObjectFileFormat Mismatch."
+      if (Stub.Target != TargetStub->Target && !TargetStub->Target.empty()) {
+        WithColor::error() << "Interface Stub: Target Mismatch."
                            << "\nFilenames: " << PreviousInputFilePath << " "
-                           << InputFilePath << "\nObjectFileFormat Values: "
-                           << Stub.ObjectFileFormat << " "
-                           << TargetStub->ObjectFileFormat << "\n";
+                           << InputFilePath;
+        //  << "\nTriple Values: " << Stub.Triple << " "
+        //  << TargetStub->Triple << "\n";
         return -1;
       }
-      if (Stub.Triple != TargetStub->Triple && !TargetStub->Triple.empty()) {
-        WithColor::error() << "Interface Stub: Triple Mismatch."
+      if (Stub.SoName != TargetStub->SoName) {
+        WithColor::error() << "Interface Stub: SoName Mismatch."
                            << "\nFilenames: " << PreviousInputFilePath << " "
                            << InputFilePath
-                           << "\nTriple Values: " << Stub.Triple << " "
-                           << TargetStub->Triple << "\n";
-        return -1;
-      }
-      if (Stub.SOName != TargetStub->SOName) {
-        WithColor::error() << "Interface Stub: SOName Mismatch."
-                           << "\nFilenames: " << PreviousInputFilePath << " "
-                           << InputFilePath
-                           << "\nSOName Values: " << Stub.SOName << " "
-                           << TargetStub->SOName << "\n";
+                           << "\nSoName Values: " << Stub.SoName << " "
+                           << TargetStub->SoName << "\n";
         return -1;
       }
       if (Stub.NeededLibs != TargetStub->NeededLibs) {
         WithColor::error() << "Interface Stub: NeededLibs Mismatch."
                            << "\nFilenames: " << PreviousInputFilePath << " "
                            << InputFilePath << "\n";
         return -1;
       }
for (auto Symbol : TargetStub->Symbols) {
         continue;
       }
       // TODO: Not checking Warning. Will be dropped.
     }
 
     PreviousInputFilePath = InputFilePath;
   }
 
-  if (Stub.IfsVersion != IFSVersionCurrent)
-    if (Stub.IfsVersion.getMajor() != IFSVersionCurrent.getMajor()) {
+  if (Stub.IfsVersion != IfsVersionCurrent)
+    if (Stub.IfsVersion.getMajor() != IfsVersionCurrent.getMajor()) {
       WithColor::error() << "Interface Stub: Bad IfsVersion: "
                          << Stub.IfsVersion << ", llvm-ifs supported version: "
-                         << IFSVersionCurrent << ".\n";
+                         << IfsVersionCurrent << ".\n";
       return -1;
     }
 
   for (auto &Entry : SymbolMap)
     Stub.Symbols.push_back(Entry.second);
 
-  return writeIfso(Stub, (Action == "write-ifs"));
+  // Change SoName before emitting stubs.
+  if (SoName.getNumOccurrences() == 1)
+    Stub.SoName = SoName;
+  Optional<IFSArch> OverrideArch;
+  Optional<IFSEndiannessType> OverrideEndianness;
+  Optional<IFSBitWidthType> OverrideBitWidth;
+  Optional<std::string> OverrideTriple;
+  if (OptArch.getNumOccurrences() == 1)
+    OverrideArch = ELF::convertArchNameToEMachine(OptArch.getValue());
+  if (OptEndianness.getNumOccurrences() == 1)
+    OverrideEndianness = OptEndianness.getValue();
+  if (OptBitWidth.getNumOccurrences() == 1)
+    OverrideBitWidth = OptBitWidth.getValue();
+  if (OptTargetTriple.getNumOccurrences() == 1)
+    OverrideTriple = OptTargetTriple.getValue();
+  Error OverrideError = overrideIFSTarget(
+      Stub, OverrideArch, OverrideEndianness, OverrideBitWidth, OverrideTriple);
+  if (OverrideError)
+    fatalError(std::move(OverrideError));
+
+  switch (OutputFormat.getValue()) {
+  case FileFormat::TBD: {
+    std::error_code SysErr;
+    raw_fd_ostream Out(OutputFilePath, SysErr);
+    if (SysErr) {
+      WithColor::error() << "Couldn't open " << OutputFilePath
+                         << " for writing.\n";
+      return -1;
+    }
+    if (!Stub.Target.Triple) {
+      WithColor::error()
+          << "Triple should be defined when output format is TBD";
+      return -1;
+    }
+    return writeTbdStub(llvm::Triple(Stub.Target.Triple.getValue()),
+                        Stub.Symbols, "TBD", Out);
+  }
+  case FileFormat::IFS: {
+    Stub.IfsVersion = IfsVersionCurrent;
+    if (InputFormat.getValue() == FileFormat::ELF &&
+        OptTargetTripleHint.getNumOccurrences() == 1) {
+      std::error_code HintEC(1, std::generic_category());
+      IFSTarget HintTarget = parseTriple(OptTargetTripleHint);
+      if (Stub.Target.Arch.getValue() != HintTarget.Arch.getValue()) {
+        fatalError(make_error<StringError>(
+            "Triple hint does not match the actual architecture", HintEC));
+      }
+      if (Stub.Target.Endianness.getValue() !=
+          HintTarget.Endianness.getValue()) {
+        fatalError(make_error<StringError>(
+            "Triple hint does not match the actual endianness", HintEC));
+      }
+      if (Stub.Target.BitWidth.getValue() != HintTarget.BitWidth.getValue()) {
+        fatalError(make_error<StringError>(
+            "Triple hint does not match the actual bit width", HintEC));
+      }
+      stripIFSTarget(Stub, true, false, false, false);
+      Stub.Target.Triple = OptTargetTripleHint.getValue();
+    } else {
+      stripIFSTarget(Stub, StripIFSTarget, StripIFSArch,
+                     StripIFSEndiannessWidth, StripIFSBitWidth);
+    }
+    Error IFSWriteError = writeIFS(OutputFilePath.getValue(), Stub);
+    if (IFSWriteError)
+      fatalError(std::move(IFSWriteError));
+    break;
+  }
+  case FileFormat::ELF: {
+    Error TargetError = validateIFSTarget(Stub, true);
+    if (TargetError)
+      fatalError(std::move(TargetError));
+    Error BinaryWriteError =
+        writeBinaryStub(OutputFilePath, Stub, WriteIfChanged);
+    if (BinaryWriteError)
+      fatalError(std::move(BinaryWriteError));
+    break;
+  }
+  }
+  return 0;
 }

llvm/unittests/InterfaceStub/ELFYAMLTest.cpp

 #include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
 using namespace llvm::ELF;
-using namespace llvm::elfabi;
+using namespace llvm::ifs;
 
 void compareByLine(StringRef LHS, StringRef RHS) {
   StringRef Line1;
   StringRef Line2;
   while (LHS.size() > 0 && RHS.size() > 0) {
     std::tie(Line1, LHS) = LHS.split('\n');
     std::tie(Line2, RHS) = RHS.split('\n');
     // Comparing StringRef objects works, but has messy output when not equal.

llvm/utils/gn/secondary/llvm/test/BUILD.gn

deps = [
     "//llvm/tools/llvm-cvtres",
     "//llvm/tools/llvm-cxxdump",
     "//llvm/tools/llvm-cxxfilt",
     "//llvm/tools/llvm-cxxmap",
     "//llvm/tools/llvm-diff",
     "//llvm/tools/llvm-dis",
     "//llvm/tools/llvm-dwarfdump",
     "//llvm/tools/llvm-dwp",
-    "//llvm/tools/llvm-elfabi",
     "//llvm/tools/llvm-exegesis",
     "//llvm/tools/llvm-extract",
     "//llvm/tools/llvm-gsymutil:llvm-gsymutil",
     "//llvm/tools/llvm-ifs",
     "//llvm/tools/llvm-isel-fuzzer",
     "//llvm/tools/llvm-jitlink",
     "//llvm/tools/llvm-jitlink/llvm-jitlink-executor",
     "//llvm/tools/llvm-libtool-darwin",

llvm/utils/gn/secondary/llvm/tools/llvm-elfabi/BUILD.gn

-executable("llvm-elfabi") {
-  deps = [
-    "//llvm/lib/InterfaceStub",
-    "//llvm/lib/Object",
-    "//llvm/lib/Support",
-    "//llvm/lib/TextAPI",
-  ]
-  sources = [
-    "ErrorCollector.cpp",
-    "llvm-elfabi.cpp",
-  ]
-}