[ifs] Prepare llvm-ifs for elfabi/ifs merging.

[haowei]

Summary

This diff changes llvm-ifs to use unified IFS file format and perform other renaming changes in preparation for the merging between elfabi/ifs.

[haowei]

Addressed clang tests.

[phosek]

This change is pretty large so I'm wondering if we could possibly split it into two changes, one that does the purely mechanical renaming of ELF and TBE to IFS, and second one that merges the two tools?

clang/lib/Driver/ToolChains/InterfaceStubs.cpp

26 ↗

(On Diff #335038)

Do we know whether the binary output format for the current target is ELF? Shouldn't we check it first?

llvm/include/llvm/InterfaceStub/IFSStub.h

28–52

Since IFS is supposed to be binary format agnostic, it's a bit confusing to use ELF constants here. Could we instead define these values ourselves and convert them to the corresponding ELF values when generating the stub?

42

50

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

83

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

139–156

141

233

374

The case difference on the left and right side (SoName vs SOName) is confusing, I'd unify them.

379–381

No need for curly braces.

[haowei]

I will try to split this change.

clang/lib/Driver/ToolChains/InterfaceStubs.cpp

26 ↗

(On Diff #335038)

I tried following way:

const bool WriteBin = !Args.getLastArg(options::OPT_emit_merged_ifs);
  if (WriteBin) {
    llvm::Triple::OSType OS = C.getDefaultToolChain().getEffectiveTriple().getOS();
    switch(OS) {
    case llvm::Triple::OSType::DragonFly:
    case llvm::Triple::OSType::Fuchsia:
    case llvm::Triple::OSType::KFreeBSD:
    case llvm::Triple::OSType::Linux:
    case llvm::Triple::OSType::Lv2:
    case llvm::Triple::OSType::NetBSD:
    case llvm::Triple::OSType::OpenBSD:
    case llvm::Triple::OSType::Solaris:
    case llvm::Triple::OSType::Haiku:
    case llvm::Triple::OSType::Minix:
    case llvm::Triple::OSType::NaCl:
    case llvm::Triple::OSType::PS4:
    case llvm::Triple::OSType::ELFIAMCU:
    case llvm::Triple::OSType::Contiki:
    case llvm::Triple::OSType::Hurd:
      CmdArgs.push_back("--output-format=ELF");
      break;
    // default:
    //   // Not adding "--output-format" will cause llvm-ifs to crash.
    }
  } else {
    CmdArgs.push_back("--output-format=IFS");
  }

but it does not work. It looks like the Toolchain object is not properly constructed in this stage, which makes it difficult to determine the target of current clang invocation. Do you have any suggestions?

llvm/include/llvm/InterfaceStub/IFSStub.h

28–52

I removed ELF constants and added helper functions.

[haowei]

Split this change into 2.

[haowei]

Rebase the code to resolve presubmit errors.

[phosek]

llvm/include/llvm/InterfaceStub/ELFObjHandler.h

24–25

Shouldn't this be in namespace ifs?

llvm/include/llvm/InterfaceStub/IFSStub.h

82–83

Use empty line between functions.

llvm/lib/InterfaceStub/IFSStub.cpp

57–61

This can be simplified.

65

I'd consider using switch here so if someone adds a new entry to the IFSBitWidthType enum, it gets caught by the compiler.

69

Ditto here.

[haowei]

llvm/include/llvm/InterfaceStub/ELFObjHandler.h

24–25

This was renamed to ifs in D100139. Rename it here will need some changes in elfabi code, which is unnecessary (and will be deleted in D100139)

llvm/lib/InterfaceStub/IFSStub.cpp

65

I changed it to switch and I added llvm_unreachable("unkown bitwidth"); to cases where an unknown bitwidth or endianness is used. Please let me know if it is OK to do so.

The Unknown enum is reserved for ifs file that has unknown bitwidth or endianness field and will trigger ifs tool's early termination. So it shouldn't be seen when IFS library is writing an ELF file.

[phosek]

LGTM

llvm/lib/InterfaceStub/IFSStub.cpp

65

LG

70

This shouldn't be needed.

82

This shouldn't be needed.

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/Clang.cpp

if (isa<AnalyzeJobAction>(JA)) {
     } else if (JA.getType() == types::TY_LLVM_BC ||
                JA.getType() == types::TY_LTO_BC) {
       CmdArgs.push_back("-emit-llvm-bc");
     } else if (JA.getType() == types::TY_IFS ||
                JA.getType() == types::TY_IFS_CPP) {
       StringRef ArgStr =
           Args.hasArg(options::OPT_interface_stub_version_EQ)
               ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ)
-              : "experimental-ifs-v2";
+              : "ifs-v1";
       CmdArgs.push_back("-emit-interface-stubs");
       CmdArgs.push_back(
           Args.MakeArgString(Twine("-interface-stub-version=") + ArgStr.str()));
     } else if (JA.getType() == types::TY_PP_Asm) {
       CmdArgs.push_back("-S");
     } else if (JA.getType() == types::TY_AST) {
       CmdArgs.push_back("-emit-pch");
     } else if (JA.getType() == types::TY_ModuleFile) {

clang/lib/Frontend/CompilerInvocation.cpp

if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
 
     if (ProgramAction == frontend::FixIt && Opt == OPT_fixit_EQ)
       Opts.FixItSuffix = A->getValue();
 
     if (ProgramAction == frontend::GenerateInterfaceStubs) {
       StringRef ArgStr =
           Args.hasArg(OPT_interface_stub_version_EQ)
               ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
-              : "experimental-ifs-v2";
+              : "ifs-v1";
       if (ArgStr == "experimental-yaml-elf-v1" ||
           ArgStr == "experimental-ifs-v1" ||
-          ArgStr == "experimental-tapi-elf-v1") {
+          ArgStr == "experimental-tapi-elf-v1" ||
+          ArgStr == "experimental-ifs-v2 ") {
         std::string ErrorMessage =
             "Invalid interface stub format: " + ArgStr.str() +
             " is deprecated.";
         Diags.Report(diag::err_drv_invalid_value)
             << "Must specify a valid interface stub format type, ie: "
-               "-interface-stub-version=experimental-ifs-v2"
+               "-interface-stub-version=ifs-v1"
             << ErrorMessage;
         ProgramAction = frontend::ParseSyntaxOnly;
-      } else if (!ArgStr.startswith("experimental-ifs-")) {
+      } else if (!ArgStr.startswith("ifs-")) {
         std::string ErrorMessage =
             "Invalid interface stub format: " + ArgStr.str() + ".";
         Diags.Report(diag::err_drv_invalid_value)
             << "Must specify a valid interface stub format type, ie: "
-               "-interface-stub-version=experimental-ifs-v2"
+               "-interface-stub-version=ifs-v1"
             << ErrorMessage;
         ProgramAction = frontend::ParseSyntaxOnly;
       }
     }
 
     Opts.ProgramAction = *ProgramAction;
   }
 

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

void HandleTranslationUnit(ASTContext &context) override {
 
     auto writeIfsV1 = [this](const llvm::Triple &T,
                              const MangledSymbols &Symbols,
                              const ASTContext &context, StringRef Format,
                              raw_ostream &OS) -> void {
       OS << "--- !" << Format << "\n";
       OS << "IfsVersion: 2.0\n";
       OS << "Triple: " << T.str() << "\n";
-      OS << "ObjectFileFormat: "
-         << "ELF"
-         << "\n"; // TODO: For now, just ELF.
       OS << "Symbols:\n";
       for (const auto &E : Symbols) {
         const MangledSymbol &Symbol = E.second;
         for (auto Name : Symbol.Names) {
           OS << "  - { Name: \""
              << (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus
                      ? ""
                      : (Symbol.ParentName + "."))
auto writeIfsV1 = [this](const llvm::Triple &T,
             OS << ", Weak: true";
           OS << " }\n";
         }
       }
       OS << "...\n";
       OS.flush();
     };
 
-    assert(Format == "experimental-ifs-v2" && "Unexpected IFS Format.");
+    assert(Format == "ifs-v1" && "Unexpected IFS Format.");
     writeIfsV1(Instance.getTarget().getTriple(), Symbols, context, Format, *OS);
   }
 };
 } // namespace
 
 std::unique_ptr<ASTConsumer>
 GenerateInterfaceStubsAction::CreateASTConsumer(CompilerInstance &CI,
                                                 StringRef InFile) {
-  return std::make_unique<InterfaceStubFunctionsConsumer>(
-      CI, InFile, "experimental-ifs-v2");
+  return std::make_unique<InterfaceStubFunctionsConsumer>(CI, InFile, "ifs-v1");
 }

llvm/include/llvm/InterfaceStub/ELFObjHandler.h

 //===- ELFObjHandler.h ------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===-----------------------------------------------------------------------===/
 ///
 /// This supports reading and writing of elf dynamic shared objects.
 ///
 //===-----------------------------------------------------------------------===/
 
 #ifndef LLVM_INTERFACESTUB_ELFOBJHANDLER_H
 #define LLVM_INTERFACESTUB_ELFOBJHANDLER_H
 
-#include "llvm/InterfaceStub/ELFStub.h"
+#include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Support/FileSystem.h"
 
 namespace llvm {
 
 class MemoryBuffer;
 
-namespace elfabi {
-
-enum class ELFTarget { ELF32LE, ELF32BE, ELF64LE, ELF64BE };
+namespace ifs {
 
 /// Attempt to read a binary ELF file from a MemoryBuffer.
-Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf);
+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 ELFStub &Stub,
+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

-//===- TBEHandler.h ---------------------------------------------*- C++ -*-===//
+//===- IFSHandler.h ---------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===-----------------------------------------------------------------------===/
 ///
 /// \file
-/// This file declares an interface for reading and writing .tbe (text-based
-/// ELF) files.
+/// This file declares an interface for reading and writing .ifs (text-based
+/// InterFace Stub) files.
 ///
 //===-----------------------------------------------------------------------===/
 
 #ifndef LLVM_INTERFACESTUB_TBEHANDLER_H
 #define LLVM_INTERFACESTUB_TBEHANDLER_H
 
-#include "ELFStub.h"
+#include "IFSStub.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include <memory>
 
 namespace llvm {
 
 class raw_ostream;
 class Error;
 class StringRef;
 
-namespace elfabi {
+namespace ifs {
 
-struct ELFStub;
+struct IFSStub;
 
-const VersionTuple TBEVersionCurrent(1, 0);
+const VersionTuple IFSVersionCurrent(3, 0);
 
-/// Attempts to read an ELF interface file from a StringRef buffer.
-Expected<std::unique_ptr<ELFStub>> readTBEFromBuffer(StringRef Buf);
+/// Attempts to read an IFS interface file from a StringRef buffer.
+Expected<std::unique_ptr<IFSStub>> readIFSFromBuffer(StringRef Buf);
 
-/// Attempts to write an ELF interface file to a raw_ostream.
-Error writeTBEToOutputStream(raw_ostream &OS, const ELFStub &Stub);
+/// Attempts to write an IFS interface file to a raw_ostream.
+Error writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub);
 
 /// Override the target platform inforation in the text stub.
-Error overrideTBETarget(ELFStub &Stub, Optional<ELFArch> OverrideArch,
-                        Optional<ELFEndiannessType> OverrideEndianness,
-                        Optional<ELFBitWidthType> OverrideBitWidth,
+Error overrideIFSTarget(IFSStub &Stub, Optional<IFSArch> OverrideArch,
+                        Optional<IFSEndiannessType> OverrideEndianness,
+                        Optional<IFSBitWidthType> OverrideBitWidth,
                         Optional<std::string> OverrideTriple);
 
 /// Validate the target platform inforation in the text stub.
-Error validateTBETarget(ELFStub &Stub, bool ParseTriple);
+Error validateIFSTarget(IFSStub &Stub, bool ParseTriple);
 
 /// Strips target platform information from the text stub.
-void stripTBETarget(ELFStub &Stub, bool StripTriple, bool StripArch,
+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_TBEHANDLER_H

llvm/include/llvm/InterfaceStub/IFSStub.h

-//===- ELFStub.h ------------------------------------------------*- C++ -*-===//
+//===- IFSStub.h ------------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===-----------------------------------------------------------------------===/
 ///
 /// \file
-/// This file defines an internal representation of an ELF stub.
+/// This file defines an internal representation of an InterFace Stub.
 ///
 //===-----------------------------------------------------------------------===/
 
-#ifndef LLVM_INTERFACESTUB_ELFSTUB_H
-#define LLVM_INTERFACESTUB_ELFSTUB_H
+#ifndef LLVM_INTERFACESTUB_IFSSTUB_H
+#define LLVM_INTERFACESTUB_IFSSTUB_H
 
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include <set>
 #include <vector>
 
 namespace llvm {
-namespace elfabi {
+namespace ifs {
 
-typedef uint16_t ELFArch;
+typedef uint16_t IFSArch;
 
-enum class ELFSymbolType {
+enum class IFSSymbolType {
   NoType = ELF::STT_NOTYPE,
   Object = ELF::STT_OBJECT,
   Func = ELF::STT_FUNC,
   TLS = ELF::STT_TLS,
 
   // Type information is 4 bits, so 16 is safely out of range.
   Unknown = 16,
 };
 
-enum class ELFEndiannessType {
+enum class IFSEndiannessType {
   Little = ELF::ELFDATA2LSB,
   Big = ELF::ELFDATA2MSB,
 
   // Endianness info is 1 bytes, 256 is safely out of rance.
   Unknown = 256,
 };
 
-enum class ELFBitWidthType {
+enum class IFSBitWidthType {
   ELF32 = ELF::ELFCLASS32,
   ELF64 = ELF::ELFCLASS64,
 
   // Bit width info is 1 bytes, 256 is safely out of rance.
   Unknown = 256,
 };
 
-struct ELFSymbol {
-  ELFSymbol() = default;
-  explicit ELFSymbol(std::string SymbolName) : Name(std::move(SymbolName)) {}
+struct IFSSymbol {
+  IFSSymbol() = default;
+  explicit IFSSymbol(std::string SymbolName) : Name(std::move(SymbolName)) {}
   std::string Name;
   uint64_t Size;
-  ELFSymbolType Type;
+  IFSSymbolType Type;
   bool Undefined;
   bool Weak;
   Optional<std::string> Warning;
-  bool operator<(const ELFSymbol &RHS) const { return Name < RHS.Name; }
+  bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; }
 };
 
 struct IFSTarget {
   Optional<std::string> Triple;
   Optional<std::string> ObjectFormat;
-  Optional<ELFArch> Arch;
+  Optional<IFSArch> Arch;
   Optional<std::string> ArchString;
-  Optional<ELFEndiannessType> Endianness;
-  Optional<ELFBitWidthType> BitWidth;
+  Optional<IFSEndiannessType> Endianness;
+  Optional<IFSBitWidthType> BitWidth;
+
+  bool empty();
 };
 
-// A cumulative representation of ELF stubs.
+inline bool operator==(const IFSTarget &lhs, const IFSTarget &rhs) {
+  if (lhs.Arch != rhs.Arch || lhs.BitWidth != rhs.BitWidth ||
+      lhs.Endianness != rhs.Endianness ||
+      lhs.ObjectFormat != rhs.ObjectFormat || lhs.Triple != rhs.Triple)
+    return false;
+  return true;
+}
+inline bool operator!=(const IFSTarget &lhs, const IFSTarget &rhs) {
+  return !(lhs == rhs);
+}
+
+// A cumulative representation of InterFace stubs.
 // Both textual and binary stubs will read into and write from this object.
-struct ELFStub {
+struct IFSStub {
   // TODO: Add support for symbol versioning.
-  VersionTuple TbeVersion;
+  VersionTuple IfsVersion;
   Optional<std::string> SoName;
   IFSTarget Target;
   std::vector<std::string> NeededLibs;
-  std::vector<ELFSymbol> Symbols;
+  std::vector<IFSSymbol> Symbols;
 
-  ELFStub() {}
-  ELFStub(const ELFStub &Stub);
-  ELFStub(ELFStub &&Stub);
+  IFSStub() {}
+  IFSStub(const IFSStub &Stub);
+  IFSStub(IFSStub &&Stub);
 };
 
-// Create a alias class for ELFStub.
+// Create a alias class for IFSStub.
 // LLVM's YAML library does not allow mapping a class with 2 traits,
 // which prevents us using 'Target:' field with different definitions.
 // This class makes it possible to map a second traits so the same data
 // structure can be used for 2 different yaml schema.
-struct ELFStubTriple : ELFStub {
-  ELFStubTriple() {}
-  ELFStubTriple(const ELFStub &Stub);
-  ELFStubTriple(const ELFStubTriple &Stub);
-  ELFStubTriple(ELFStubTriple &&Stub);
+struct IFSStubTriple : IFSStub {
+  IFSStubTriple() {}
+  IFSStubTriple(const IFSStub &Stub);
+  IFSStubTriple(const IFSStubTriple &Stub);
+  IFSStubTriple(IFSStubTriple &&Stub);
 };
 
-} // end namespace elfabi
+} // end namespace ifs
 } // end namespace llvm
 
-#endif // LLVM_INTERFACESTUB_ELFSTUB_H
+#endif // LLVM_INTERFACESTUB_IFSSTUB_H

llvm/lib/InterfaceStub/CMakeLists.txt

 add_llvm_component_library(LLVMInterfaceStub
   ELFObjHandler.cpp
-  ELFStub.cpp
-  TBEHandler.cpp
+  IFSHandler.cpp
+  IFSStub.cpp  
 
   LINK_COMPONENTS
   BinaryFormat
   MC
   Object
   Support
 )

llvm/lib/InterfaceStub/ELFObjHandler.cpp

 //===- ELFObjHandler.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/ELFObjHandler.h"
-#include "llvm/InterfaceStub/ELFStub.h"
+#include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Process.h"
 
 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:
public:
   using Elf_Phdr = typename ELFT::Phdr;
   using Elf_Sym = typename ELFT::Sym;
   using Elf_Addr = typename ELFT::Addr;
   using Elf_Dyn = typename ELFT::Dyn;
 
   ELFStubBuilder(const ELFStubBuilder &) = delete;
   ELFStubBuilder(ELFStubBuilder &&) = default;
 
-  explicit ELFStubBuilder(const ELFStub &Stub) {
+  explicit ELFStubBuilder(const IFSStub &Stub) {
     DynSym.Name = ".dynsym";
     DynSym.Align = sizeof(Elf_Addr);
     DynStr.Name = ".dynstr";
     DynStr.Align = 1;
     DynTab.Name = ".dynamic";
     DynTab.Align = sizeof(Elf_Addr);
     ShStrTab.Name = ".shstrtab";
     ShStrTab.Align = 1;
 
     // Populate string tables.
-    for (const ELFSymbol &Sym : Stub.Symbols)
+    for (const IFSSymbol &Sym : Stub.Symbols)
       DynStr.Content.add(Sym.Name);
     for (const std::string &Lib : Stub.NeededLibs)
       DynStr.Content.add(Lib);
     if (Stub.SoName)
       DynStr.Content.add(Stub.SoName.getValue());
 
     std::vector<OutputSection<ELFT> *> Sections = {&DynSym, &DynStr, &DynTab,
                                                    &ShStrTab};
     const OutputSection<ELFT> *LastSection = Sections.back();
     // Now set the Index and put sections names into ".shstrtab".
     uint64_t Index = 1;
     for (OutputSection<ELFT> *Sec : Sections) {
       Sec->Index = Index++;
       ShStrTab.Content.add(Sec->Name);
     }
     ShStrTab.Content.finalize();
     ShStrTab.Size = ShStrTab.Content.getSize();
     DynStr.Content.finalize();
     DynStr.Size = DynStr.Content.getSize();
 
     // Populate dynamic symbol table.
-    for (const ELFSymbol &Sym : Stub.Symbols) {
+    for (const IFSSymbol &Sym : Stub.Symbols) {
       uint8_t Bind = Sym.Weak ? STB_WEAK : STB_GLOBAL;
       // For non-undefined symbols, value of the shndx is not relevant at link
       // time as long as it is not SHN_UNDEF. Set shndx to 1, which
       // points to ".dynsym".
       uint16_t Shndx = Sym.Undefined ? SHN_UNDEF : 1;
       DynSym.Content.add(DynStr.Content.getOffset(Sym.Name), Sym.Size, Bind,
                          (uint8_t)Sym.Type, 0, Shndx);
     }
if (Offset >= Dyn.StrSize) {
                                Offset);
     }
   }
 
   return Error::success();
 }
 
 /// This function extracts symbol type from a symbol's st_info member and
-/// maps it to an ELFSymbolType enum.
+/// maps it to an IFSSymbolType enum.
 /// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
-/// Other symbol types are mapped to ELFSymbolType::Unknown.
+/// Other symbol types are mapped to IFSSymbolType::Unknown.
 ///
 /// @param Info Binary symbol st_info to extract symbol type from.
-static ELFSymbolType convertInfoToType(uint8_t Info) {
+static IFSSymbolType convertInfoToType(uint8_t Info) {
   Info = Info & 0xf;
   switch (Info) {
   case ELF::STT_NOTYPE:
-    return ELFSymbolType::NoType;
+    return IFSSymbolType::NoType;
   case ELF::STT_OBJECT:
-    return ELFSymbolType::Object;
+    return IFSSymbolType::Object;
   case ELF::STT_FUNC:
-    return ELFSymbolType::Func;
+    return IFSSymbolType::Func;
   case ELF::STT_TLS:
-    return ELFSymbolType::TLS;
+    return IFSSymbolType::TLS;
   default:
-    return ELFSymbolType::Unknown;
+    return IFSSymbolType::Unknown;
   }
 }
 
-/// This function creates an ELFSymbol and populates all members using
+/// This function creates an IFSSymbol and populates all members using
 /// information from a binary ELFT::Sym.
 ///
-/// @param SymName The desired name of the ELFSymbol.
+/// @param SymName The desired name of the IFSSymbol.
 /// @param RawSym ELFT::Sym to extract symbol information from.
 template <class ELFT>
-static ELFSymbol createELFSym(StringRef SymName,
+static IFSSymbol createELFSym(StringRef SymName,
                               const typename ELFT::Sym &RawSym) {
-  ELFSymbol TargetSym{std::string(SymName)};
+  IFSSymbol TargetSym{std::string(SymName)};
   uint8_t Binding = RawSym.getBinding();
   if (Binding == STB_WEAK)
     TargetSym.Weak = true;
   else
     TargetSym.Weak = false;
 
   TargetSym.Undefined = RawSym.isUndefined();
   TargetSym.Type = convertInfoToType(RawSym.st_info);
 
-  if (TargetSym.Type == ELFSymbolType::Func) {
+  if (TargetSym.Type == IFSSymbolType::Func) {
     TargetSym.Size = 0;
   } else {
     TargetSym.Size = RawSym.st_size;
   }
   return TargetSym;
 }
 
-/// This function populates an ELFStub with symbols using information read
+/// This function populates an IFSStub with symbols using information read
 /// from an ELF binary.
 ///
-/// @param TargetStub ELFStub to add symbols to.
+/// @param TargetStub IFSStub to add symbols to.
 /// @param DynSym Range of dynamic symbols to add to TargetStub.
 /// @param DynStr StringRef to the dynamic string table.
 template <class ELFT>
-static Error populateSymbols(ELFStub &TargetStub,
+static Error populateSymbols(IFSStub &TargetStub,
                              const typename ELFT::SymRange DynSym,
                              StringRef DynStr) {
   // Skips the first symbol since it's the NULL symbol.
   for (auto RawSym : DynSym.drop_front(1)) {
     // If a symbol does not have global or weak binding, ignore it.
     uint8_t Binding = RawSym.getBinding();
     if (!(Binding == STB_GLOBAL || Binding == STB_WEAK))
       continue;
     // If a symbol doesn't have default or protected visibility, ignore it.
     uint8_t Visibility = RawSym.getVisibility();
     if (!(Visibility == STV_DEFAULT || Visibility == STV_PROTECTED))
       continue;
-    // Create an ELFSymbol and populate it with information from the symbol
+    // Create an IFSSymbol and populate it with information from the symbol
     // table entry.
     Expected<StringRef> SymName = terminatedSubstr(DynStr, RawSym.st_name);
     if (!SymName)
       return SymName.takeError();
-    ELFSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);
+    IFSSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);
     TargetStub.Symbols.push_back(std::move(Sym));
     // TODO: Populate symbol warning.
   }
   return Error::success();
 }
 
-/// Returns a new ELFStub with all members populated from an ELFObjectFile.
+/// Returns a new IFSStub with all members populated from an ELFObjectFile.
 /// @param ElfObj Source ELFObjectFile.
 template <class ELFT>
-static Expected<std::unique_ptr<ELFStub>>
+static Expected<std::unique_ptr<IFSStub>>
 buildStub(const ELFObjectFile<ELFT> &ElfObj) {
   using Elf_Dyn_Range = typename ELFT::DynRange;
   using Elf_Phdr_Range = typename ELFT::PhdrRange;
   using Elf_Sym_Range = typename ELFT::SymRange;
   using Elf_Sym = typename ELFT::Sym;
-  std::unique_ptr<ELFStub> DestStub = std::make_unique<ELFStub>();
+  std::unique_ptr<IFSStub> DestStub = std::make_unique<IFSStub>();
   const ELFFile<ELFT> &ElfFile = ElfObj.getELFFile();
   // Fetch .dynamic table.
   Expected<Elf_Dyn_Range> DynTable = ElfFile.dynamicEntries();
   if (!DynTable) {
     return DynTable.takeError();
   }
 
   // Fetch program headers.
buildStub(const ELFObjectFile<ELFT> &ElfObj) {
   if (!DynStrPtr)
     return appendToError(DynStrPtr.takeError(),
                          "when locating .dynstr section contents");
 
   StringRef DynStr(reinterpret_cast<const char *>(DynStrPtr.get()),
                    DynEnt.StrSize);
 
   // Populate Arch from ELF header.
-  DestStub->Target.Arch = static_cast<ELFArch>(ElfFile.getHeader().e_machine);
+  DestStub->Target.Arch = static_cast<IFSArch>(ElfFile.getHeader().e_machine);
   DestStub->Target.BitWidth =
-      (ELFBitWidthType)ElfFile.getHeader().e_ident[EI_CLASS];
+      (IFSBitWidthType)ElfFile.getHeader().e_ident[EI_CLASS];
   DestStub->Target.Endianness =
-      (ELFEndiannessType)ElfFile.getHeader().e_ident[EI_DATA];
+      (IFSEndiannessType)ElfFile.getHeader().e_ident[EI_DATA];
   DestStub->Target.ObjectFormat = "ELF";
 
   // Populate SoName from .dynamic entries and dynamic string table.
   if (DynEnt.SONameOffset.hasValue()) {
     Expected<StringRef> NameOrErr =
         terminatedSubstr(DynStr, *DynEnt.SONameOffset);
     if (!NameOrErr) {
       return appendToError(NameOrErr.takeError(), "when reading DT_SONAME");
buildStub(const ELFObjectFile<ELFT> &ElfObj) {
 
   return std::move(DestStub);
 }
 
 /// This function opens a file for writing and then writes a binary ELF stub to
 /// the file.
 ///
 /// @param FilePath File path for writing the ELF binary.
-/// @param Stub Source ELFStub to generate a binary ELF stub from.
+/// @param Stub Source InterFace Stub to generate a binary ELF stub from.
 template <class ELFT>
-static Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub,
+static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub,
                                   bool WriteIfChanged) {
   ELFStubBuilder<ELFT> Builder{Stub};
   // Write Stub to memory first.
   std::vector<uint8_t> Buf(Builder.getSize());
   Builder.write(Buf.data());
 
   if (WriteIfChanged) {
     if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub,
 
   // Write binary to file.
   std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);
   memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());
 
   return FileBuf->commit();
 }
 
-Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
+Expected<std::unique_ptr<IFSStub>> readELFFile(MemoryBufferRef Buf) {
   Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buf);
   if (!BinOrErr) {
     return BinOrErr.takeError();
   }
 
   Binary *Bin = BinOrErr->get();
   if (auto Obj = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
     return buildStub(*Obj);
   } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
     return buildStub(*Obj);
   } else if (auto Obj = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
     return buildStub(*Obj);
   } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
     return buildStub(*Obj);
   }
   return createStringError(errc::not_supported, "unsupported binary format");
 }
 
 // This function wraps the ELFT writeELFBinaryToFile() so writeBinaryStub()
 // can be called without having to use ELFType templates directly.
-Error writeBinaryStub(StringRef FilePath, const ELFStub &Stub,
+Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub,
                       bool WriteIfChanged) {
   assert(Stub.Target.Arch);
   assert(Stub.Target.BitWidth);
   assert(Stub.Target.Endianness);
-  if (Stub.Target.BitWidth == ELFBitWidthType::ELF32) {
-    if (Stub.Target.Endianness == ELFEndiannessType::Little) {
+  if (Stub.Target.BitWidth == IFSBitWidthType::ELF32) {
+    if (Stub.Target.Endianness == IFSEndiannessType::Little) {
       return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
     } else {
       return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
     }
   } else {
-    if (Stub.Target.Endianness == ELFEndiannessType::Little) {
+    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");
 }
 
-} // end namespace elfabi
+} // end namespace ifs
 } // end namespace llvm

llvm/lib/InterfaceStub/IFSHandler.cpp

 //===- TBEHandler.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/TBEHandler.h"
+#include "llvm/InterfaceStub/IFSHandler.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/InterfaceStub/ELFStub.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(ELFSymbol)
+LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
 
 namespace llvm {
 namespace yaml {
 
 /// YAML traits for ELFSymbolType.
-template <> struct ScalarEnumerationTraits<ELFSymbolType> {
-  static void enumeration(IO &IO, ELFSymbolType &SymbolType) {
-    IO.enumCase(SymbolType, "NoType", ELFSymbolType::NoType);
-    IO.enumCase(SymbolType, "Func", ELFSymbolType::Func);
-    IO.enumCase(SymbolType, "Object", ELFSymbolType::Object);
-    IO.enumCase(SymbolType, "TLS", ELFSymbolType::TLS);
-    IO.enumCase(SymbolType, "Unknown", ELFSymbolType::Unknown);
+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, "TLS", IFSSymbolType::TLS);
+    IO.enumCase(SymbolType, "Unknown", IFSSymbolType::Unknown);
     // Treat other symbol types as noise, and map to Unknown.
     if (!IO.outputting() && IO.matchEnumFallback())
-      SymbolType = ELFSymbolType::Unknown;
+      SymbolType = IFSSymbolType::Unknown;
   }
 };
 
-template <> struct ScalarTraits<ELFEndiannessType> {
-  static void output(const ELFEndiannessType &Value, void *,
+template <> struct ScalarTraits<IFSEndiannessType> {
+  static void output(const IFSEndiannessType &Value, void *,
                      llvm::raw_ostream &Out) {
     switch (Value) {
-    case ELFEndiannessType::Big:
+    case IFSEndiannessType::Big:
       Out << "big";
       break;
-    case ELFEndiannessType::Little:
+    case IFSEndiannessType::Little:
       Out << "little";
       break;
     default:
       llvm_unreachable("Unsupported endianness");
     }
   }
 
-  static StringRef input(StringRef Scalar, void *, ELFEndiannessType &Value) {
-    Value = StringSwitch<ELFEndiannessType>(Scalar)
-                .Case("big", ELFEndiannessType::Big)
-                .Case("little", ELFEndiannessType::Little)
-                .Default(ELFEndiannessType::Unknown);
-    if (Value == ELFEndiannessType::Unknown) {
+  static StringRef input(StringRef Scalar, void *, IFSEndiannessType &Value) {
+    Value = StringSwitch<IFSEndiannessType>(Scalar)
+                .Case("big", IFSEndiannessType::Big)
+                .Case("little", IFSEndiannessType::Little)
+                .Default(IFSEndiannessType::Unknown);
+    if (Value == IFSEndiannessType::Unknown) {
       return "Unsupported endianness";
     }
     return StringRef();
   }
 
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
-template <> struct ScalarTraits<ELFBitWidthType> {
-  static void output(const ELFBitWidthType &Value, void *,
+template <> struct ScalarTraits<IFSBitWidthType> {
+  static void output(const IFSBitWidthType &Value, void *,
                      llvm::raw_ostream &Out) {
     switch (Value) {
-    case ELFBitWidthType::ELF32:
+    case IFSBitWidthType::ELF32:
       Out << "32";
       break;
-    case ELFBitWidthType::ELF64:
+    case IFSBitWidthType::ELF64:
       Out << "64";
       break;
     default:
       llvm_unreachable("Unsupported bit width");
     }
   }
 
-  static StringRef input(StringRef Scalar, void *, ELFBitWidthType &Value) {
-    Value = StringSwitch<ELFBitWidthType>(Scalar)
-                .Case("32", ELFBitWidthType::ELF32)
-                .Case("64", ELFBitWidthType::ELF64)
-                .Default(ELFBitWidthType::Unknown);
-    if (Value == ELFBitWidthType::Unknown) {
+  static StringRef input(StringRef Scalar, void *, IFSBitWidthType &Value) {
+    Value = StringSwitch<IFSBitWidthType>(Scalar)
+                .Case("32", IFSBitWidthType::ELF32)
+                .Case("64", IFSBitWidthType::ELF64)
+                .Default(IFSBitWidthType::Unknown);
+    if (Value == IFSBitWidthType::Unknown) {
       return "Unsupported bit width";
     }
     return StringRef();
   }
 
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template <> struct MappingTraits<IFSTarget> {
   static void mapping(IO &IO, IFSTarget &Target) {
     IO.mapOptional("ObjectFormat", Target.ObjectFormat);
     IO.mapOptional("Arch", Target.ArchString);
     IO.mapOptional("Endianness", Target.Endianness);
     IO.mapOptional("BitWidth", Target.BitWidth);
   }
 
   // Compacts symbol information into a single line.
   static const bool flow = true;
 };
 
 /// YAML traits for ELFSymbol.
-template <> struct MappingTraits<ELFSymbol> {
-  static void mapping(IO &IO, ELFSymbol &Symbol) {
+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 == ELFSymbolType::NoType) {
+    if (Symbol.Type == IFSSymbolType::NoType) {
       IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
-    } else if (Symbol.Type == ELFSymbolType::Func) {
+    } else if (Symbol.Type == IFSSymbolType::Func) {
       Symbol.Size = 0;
     } else {
       IO.mapRequired("Size", Symbol.Size);
     }
     IO.mapOptional("Undefined", Symbol.Undefined, false);
     IO.mapOptional("Weak", Symbol.Weak, false);
     IO.mapOptional("Warning", Symbol.Warning);
   }
 
   // Compacts symbol information into a single line.
   static const bool flow = true;
 };
 
 /// YAML traits for ELFStub objects.
-template <> struct MappingTraits<ELFStub> {
-  static void mapping(IO &IO, ELFStub &Stub) {
+template <> struct MappingTraits<IFSStub> {
+  static void mapping(IO &IO, IFSStub &Stub) {
     if (!IO.mapTag("!ifs-v1", true))
       IO.setError("Not a .tbe YAML file.");
-    IO.mapRequired("TbeVersion", Stub.TbeVersion);
+    IO.mapRequired("IfsVersion", Stub.IfsVersion);
     IO.mapOptional("SoName", Stub.SoName);
     IO.mapOptional("Target", Stub.Target);
     IO.mapOptional("NeededLibs", Stub.NeededLibs);
     IO.mapRequired("Symbols", Stub.Symbols);
   }
 };
 
 /// YAML traits for ELFStubTriple objects.
-template <> struct MappingTraits<ELFStubTriple> {
-  static void mapping(IO &IO, ELFStubTriple &Stub) {
+template <> struct MappingTraits<IFSStubTriple> {
+  static void mapping(IO &IO, IFSStubTriple &Stub) {
     if (!IO.mapTag("!ifs-v1", true))
       IO.setError("Not a .tbe YAML file.");
-    IO.mapRequired("TbeVersion", Stub.TbeVersion);
+    IO.mapRequired("IfsVersion", Stub.IfsVersion);
     IO.mapOptional("SoName", Stub.SoName);
     IO.mapOptional("Target", Stub.Target.Triple);
     IO.mapOptional("NeededLibs", Stub.NeededLibs);
     IO.mapRequired("Symbols", Stub.Symbols);
   }
 };
 } // end namespace yaml
 } // end namespace llvm
 
 /// Attempt to determine if a Text stub uses target triple.
 bool usesTriple(StringRef Buf) {
   for (line_iterator I(MemoryBufferRef(Buf, "ELFStub")); !I.is_at_eof(); ++I) {
     StringRef Line = (*I).trim();
     if (Line.startswith("Target:")) {
       if (Line == "Target:" || (Line.find("{") != Line.npos)) {
         return false;
       }
     }
   }
   return true;
 }
 
-Expected<std::unique_ptr<ELFStub>> elfabi::readTBEFromBuffer(StringRef Buf) {
+Expected<std::unique_ptr<IFSStub>> ifs::readIFSFromBuffer(StringRef Buf) {
   yaml::Input YamlIn(Buf);
-  std::unique_ptr<ELFStubTriple> Stub(new ELFStubTriple());
+  std::unique_ptr<IFSStubTriple> Stub(new IFSStubTriple());
   if (usesTriple(Buf)) {
     YamlIn >> *Stub;
   } else {
-    YamlIn >> *static_cast<ELFStub *>(Stub.get());
+    YamlIn >> *static_cast<IFSStub *>(Stub.get());
   }
   if (std::error_code Err = YamlIn.error()) {
     return createStringError(Err, "YAML failed reading as TBE");
   }
 
-  if (Stub->TbeVersion > elfabi::TBEVersionCurrent)
+  if (Stub->IfsVersion > ifs::IFSVersionCurrent)
     return make_error<StringError>(
-        "TBE version " + Stub->TbeVersion.getAsString() + " is unsupported.",
+        "TBE 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::writeTBEToOutputStream(raw_ostream &OS, const ELFStub &Stub) {
+Error ifs::writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub) {
   yaml::Output YamlOut(OS, NULL, /*WrapColumn =*/0);
-  std::unique_ptr<ELFStubTriple> CopyStub(new ELFStubTriple(Stub));
+  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<ELFStub *>(CopyStub.get());
+    YamlOut << *static_cast<IFSStub *>(CopyStub.get());
   return Error::success();
 }
 
-Error elfabi::overrideTBETarget(ELFStub &Stub, Optional<ELFArch> OverrideArch,
-                                Optional<ELFEndiannessType> OverrideEndianness,
-                                Optional<ELFBitWidthType> OverrideBitWidth,
-                                Optional<std::string> OverrideTriple) {
+Error ifs::overrideIFSTarget(IFSStub &Stub, Optional<IFSArch> OverrideArch,
+                             Optional<IFSEndiannessType> OverrideEndianness,
+                             Optional<IFSBitWidthType> OverrideBitWidth,
   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::validateTBETarget(ELFStub &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 = (ELFArch)ELF::EM_AARCH64;
+    RetTarget.Arch = (IFSArch)ELF::EM_AARCH64;
     break;
   case Triple::ArchType::x86_64:
-    RetTarget.Arch = (ELFArch)ELF::EM_X86_64;
+    RetTarget.Arch = (IFSArch)ELF::EM_X86_64;
     break;
   default:
-    RetTarget.Arch = (ELFArch)ELF::EM_NONE;
+    RetTarget.Arch = (IFSArch)ELF::EM_NONE;
   }
-  RetTarget.Endianness = IFSTriple.isLittleEndian() ? ELFEndiannessType::Little
-                                                    : ELFEndiannessType::Big;
+  RetTarget.Endianness = IFSTriple.isLittleEndian() ? IFSEndiannessType::Little
+                                                    : IFSEndiannessType::Big;
   RetTarget.BitWidth =
-      IFSTriple.isArch64Bit() ? ELFBitWidthType::ELF64 : ELFBitWidthType::ELF32;
+      IFSTriple.isArch64Bit() ? IFSBitWidthType::ELF64 : IFSBitWidthType::ELF32;
   return RetTarget;
 }
 
-void elfabi::stripTBETarget(ELFStub &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

-//===- ELFStub.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/ELFStub.h"
+#include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/Support/Error.h"
 
 using namespace llvm;
-using namespace llvm::elfabi;
+using namespace llvm::ifs;
 
-ELFStub::ELFStub(ELFStub const &Stub) {
-  TbeVersion = Stub.TbeVersion;
+IFSStub::IFSStub(IFSStub const &Stub) {
+  IfsVersion = Stub.IfsVersion;
   Target = Stub.Target;
   SoName = Stub.SoName;
   NeededLibs = Stub.NeededLibs;
   Symbols = Stub.Symbols;
 }
 
-ELFStub::ELFStub(ELFStub &&Stub) {
-  TbeVersion = std::move(Stub.TbeVersion);
+IFSStub::IFSStub(IFSStub &&Stub) {
+  IfsVersion = std::move(Stub.IfsVersion);
   Target = std::move(Stub.Target);
   SoName = std::move(Stub.SoName);
   NeededLibs = std::move(Stub.NeededLibs);
   Symbols = std::move(Stub.Symbols);
 }
 
-ELFStubTriple::ELFStubTriple(ELFStubTriple const &Stub) {
-  TbeVersion = Stub.TbeVersion;
+IFSStubTriple::IFSStubTriple(IFSStubTriple const &Stub) {
+  IfsVersion = Stub.IfsVersion;
   Target = Stub.Target;
   SoName = Stub.SoName;
   NeededLibs = Stub.NeededLibs;
   Symbols = Stub.Symbols;
 }
 
-ELFStubTriple::ELFStubTriple(ELFStub const &Stub) {
-  TbeVersion = Stub.TbeVersion;
+IFSStubTriple::IFSStubTriple(IFSStub const &Stub) {
+  IfsVersion = Stub.IfsVersion;
   Target = Stub.Target;
   SoName = Stub.SoName;
   NeededLibs = Stub.NeededLibs;
   Symbols = Stub.Symbols;
 }
 
-ELFStubTriple::ELFStubTriple(ELFStubTriple &&Stub) {
-  TbeVersion = std::move(Stub.TbeVersion);
+IFSStubTriple::IFSStubTriple(IFSStubTriple &&Stub) {
+  IfsVersion = std::move(Stub.IfsVersion);
   Target = std::move(Stub.Target);
   SoName = std::move(Stub.SoName);
   NeededLibs = std::move(Stub.NeededLibs);
   Symbols = std::move(Stub.Symbols);
 }
+
+bool IFSTarget::empty() {
+  if (!Triple && !ObjectFormat && !Arch && !ArchString && !Endianness &&
+      !BitWidth) {
+    return true;
+  }
+  return false;
+}

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-elfabi/output-target-error.test

-## Test running llvm-elfabi without specifying a valid target.
-
-# RUN: not llvm-elfabi --output=%t %s 2>&1 | FileCheck %s --check-prefix=MISSING
-# RUN: not llvm-elfabi --output-format=nope --output=%t %s 2>&1 | FileCheck %s --check-prefix=INVALID
-
---- !ifs-v1
-SoName: somelib.so
-TbeVersion: 1.0
-Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
-Symbols: []
-...
-
-# MISSING: llvm-elfabi: for the --output-format option: must be specified at least once!
-
-# INVALID: llvm-elfabi: for the --output-format option: Cannot find option named 'nope'!

llvm/test/tools/llvm-elfabi/preserve-dates-tbe.test

-## Test writing unchanged content to TBE file with --write-if-changed flag.
-
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --output=%t %p/Inputs/gnu_hash.so
-# RUN: env TZ=GMT touch -m -t 197001010000 %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --output=%t --write-if-changed %p/Inputs/gnu_hash.so
-# RUN: env TZ=GMT ls -l %t | FileCheck %s
-
-# CHECK: {{[[:space:]]1970}}

llvm/test/tools/llvm-elfabi/strip-target.test

-## Test writing tbe with stripped target information.
-
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --strip-ifs-target --output=- %p/Inputs/sysv_hash.so | FileCheck %s --check-prefix=NOTARGET
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --strip-ifs-arch --strip-ifs-endianness --strip-ifs-bitwidth --output=- %p/Inputs/sysv_hash.so | FileCheck %s --check-prefix=NOTARGET
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --strip-ifs-arch --output=- %p/Inputs/sysv_hash.so | FileCheck %s -DELFTARGET="ObjectFormat: ELF, Endianness: little, BitWidth: 64" --check-prefix=CHECK
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --strip-ifs-endianness --output=- %p/Inputs/sysv_hash.so | FileCheck %s -DELFTARGET="ObjectFormat: ELF, Arch: x86_64, BitWidth: 64" --check-prefix=CHECK
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --strip-ifs-bitwidth --output=- %p/Inputs/sysv_hash.so | FileCheck %s -DELFTARGET="ObjectFormat: ELF, Arch: x86_64, Endianness: little" --check-prefix=CHECK
-
-
-# CHECK:      --- !ifs-v1
-# CHECK-NEXT: TbeVersion:      1.0
-# CHECK-NEXT: SoName:          libsomething.so
-# CHECK-NEXT: Target: { [[ELFTARGET]] }
-# CHECK-NEXT: NeededLibs:
-# CHECK-NEXT:   - libm.so.6
-# CHECK-NEXT:   - libc.so.6
-# CHECK-NEXT:   - ld-linux-x86-64.so.2
-# CHECK-NEXT: Symbols:
-
-# NOTARGET:      --- !ifs-v1
-# NOTARGET-NEXT: TbeVersion:      1.0
-# NOTARGET-NEXT: SoName:          libsomething.so
-# NOTARGET-NEXT: NeededLibs:
-# NOTARGET-NEXT:   - libm.so.6
-# NOTARGET-NEXT:   - libc.so.6
-# NOTARGET-NEXT:   - ld-linux-x86-64.so.2
-# NOTARGET-NEXT: Symbols:

llvm/test/tools/llvm-ifs/Inputs/strong-mismatch-size.ifs

 # NOTE: Used by weak-mismatch.ifs
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !ifs-v1
+IfsVersion: 3.0
+Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: foobar, Type: Object, Size: 2 }
 ...

llvm/test/tools/llvm-ifs/Inputs/strong-mismatch-type.ifs

 # NOTE: Used by weak-mismatch.ifs
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !ifs-v1
+IfsVersion: 3.0
+Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: foobar, Type: Func }
 ...

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

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --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:
- Type:     PT_LOAD
     LastSec:  .dynamic
   - Type: PT_DYNAMIC
     Flags: [ PF_X, PF_R ]
     VAddr: 0x0008
     FirstSec: .dynamic
     LastSec:  .dynamic
 
 # CHECK:      --- !ifs-v1
-# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+# CHECK-NEXT: IfsVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: SoName: best.so{{$}}
 # CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: Symbols: []
 # CHECK-NEXT: ...

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

 # RUN: yaml2obj --docnum=1 %s -o %t
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --output=- %t | FileCheck %s -DTARGET="{ ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }"
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --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:
- Type:     PT_LOAD
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     Flags:    [ PF_X, PF_R ]
     VAddr:    0x0008
     FirstSec: .dynamic
     LastSec:  .dynamic
 
 # CHECK:      --- !ifs-v1
-# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+# 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=TBE --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=TBE --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=TBE --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=TBE --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=TBE --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=TBE --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=TBE --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=TBE --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=TBE --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=TBE --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=TBE --output=- %t | FileCheck %s --check-prefix=ORIGINAL
-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --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=TBE --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=TBE --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:
- Type:     PT_LOAD
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     Flags:    [ PF_X, PF_R ]
     VAddr:    0x1018
     FirstSec: .dynamic
     LastSec:  .dynamic
 
 # CHECK:      --- !ifs-v1
-# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+# 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: ...

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

-# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --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: TbeVersion:      1.0
+# 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=TBE --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: TbeVersion:      1.0
+# 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-format.ifs

-# RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
-# RUN: FileCheck %s --check-prefixes=CHECK-IFS
-
-# CHECK-IFS: error: Interface Stub: ObjectFileFormat Mismatch.
-# CHECK-IFS-NEXT: Filenames:
-# CHECK-IFS-NEXT: ObjectFileFormat Values: TBD ELF
-
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple:          x86_64-apple-unknown
-ObjectFileFormat: TBD
-Symbols:
-  - { Name: a, Type: Func }
-...

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
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple:          mips-unknown-linux
-ObjectFileFormat: ELF
+--- !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: 2.0.
+# CHECK-IFS2: error: Interface Stub: Bad IfsVersion: 0.0, llvm-ifs supported version: 3.0.
 
---- !experimental-ifs-v2
+--- !ifs-v1
 IfsVersion:      0.0
-Triple:          x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+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
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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 }
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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: --- !experimental-ifs-v2
-# CHECK-DEFAULT-NEXT: IfsVersion: 2.0
-# CHECK-DEFAULT-NEXT: Triple:          ''
-# CHECK-DEFAULT-NEXT: ObjectFileFormat: ELF
+# CHECK-DEFAULT: --- !ifs-v1
+# CHECK-DEFAULT-NEXT: IfsVersion: 3.0
 # CHECK-DEFAULT-NEXT: Symbols:         []
 # CHECK-DEFAULT-NEXT: ...
 
-# CHECK-MERGE: --- !experimental-ifs-v2
-# CHECK-MERGE-NEXT: IfsVersion: 2.0
-# CHECK-MERGE-NEXT: Triple: x86_64-unknown-linux-gnu
-# CHECK-MERGE-NEXT: ObjectFileFormat: ELF
+# 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: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple:          ''
-ObjectFileFormat: ELF
+--- !ifs-v1
+IfsVersion: 3.0
 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: --- !experimental-ifs-v2
-# CHECK-NEXT: IfsVersion: 2.0
-# CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
-# CHECK-NEXT: ObjectFileFormat: ELF
+# CHECK: --- !ifs-v1
+# CHECK-NEXT: IfsVersion: 3.0
+# CHECK-NEXT: Target: x86_64-unknown-linux-gnu
 # CHECK-NEXT: Symbols: []
 # CHECK: ...
 
---- !experimental-ifs-v2
-IfsVersion:      2.0
-Triple:          x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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: --- !experimental-ifs-v2
-# CHECK-NEXT: IfsVersion: 2.0
-# CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
-# CHECK-NEXT: ObjectFileFormat: ELF
+# CHECK: --- !ifs-v1
+# CHECK-NEXT: IfsVersion: 3.0
+# CHECK-NEXT: Target: x86_64-unknown-linux-gnu
 # CHECK-NEXT: Symbols: []
 # CHECK: ...
 
---- !experimental-ifs-v2
-IfsVersion:      2.0
-Triple:          x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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=TBE --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
-TbeVersion: 1.0
+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
-TbeVersion: 1.0
+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: --- !experimental-ifs-v2
-# CHECK-IFS-NEXT: IfsVersion: 2.0
-# CHECK-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
-# CHECK-IFS-NEXT: ObjectFileFormat: 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: a, Type: Func }
 # CHECK-IFS-DAG:   - { Name: b, Type: Object, Size: 4 }
 # CHECK-IFS: ...
 
 # CHECK-ELF: ELF Header:
 # CHECK-ELF:   Class:                             ELF64
 # CHECK-ELF:   Type:                              DYN (Shared object file)

 # CHECK-DARWIN-TBD3-NEXT: compatibility-version: 0
 # CHECK-DARWIN-TBD3-NEXT: objc-constraint: none
 # CHECK-DARWIN-TBD3-NEXT: exports:
 # CHECK-DARWIN-TBD3-NEXT:   - archs:           [ x86_64 ]
 # CHECK-DARWIN-TBD3-NEXT:     symbols:         [ a, b ]
 # CHECK-DARWIN-TBD3-NEXT: ...
 
 # Here we are testing to see if two identical symbols will merge.
-# CHECK-MERGE-IFS: --- !experimental-ifs-v2
-# CHECK-MERGE-IFS-NEXT: IfsVersion: 2.0
-# CHECK-MERGE-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
-# CHECK-MERGE-IFS-NEXT: ObjectFileFormat: ELF
+# CHECK-MERGE-IFS: --- !ifs-v1
+# CHECK-MERGE-IFS-NEXT: IfsVersion: 3.0
+# CHECK-MERGE-IFS-NEXT: Target:          x86_64-unknown-linux-gnu
 # CHECK-MERGE-IFS-NEXT: Symbols:
 # CHECK-MERGE-IFS-NEXT:   - { Name: a, Type: Func }
 # CHECK-MERGE-IFS-NEXT: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !ifs-v1
+IfsVersion: 3.0
+Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: a, Type: Func }
 ...

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

-# RUN: llvm-elfabi --output-format=TBE --output=- %s | FileCheck %s
+# RUN: llvm-ifs --output-format=IFS --output=- %s | FileCheck %s
 
 --- !ifs-v1
-TbeVersion: 1.0
+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: TbeVersion: 1.0
+# CHECK-NEXT: IfsVersion: 3.0

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

-# RUN: llvm-elfabi --output-format=TBE --output=- %s | FileCheck %s
+# RUN: llvm-ifs --output-format=IFS --output=- %s | FileCheck %s
 
 --- !ifs-v1
 SoName: somelib.so
-TbeVersion: 1.0
+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: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+# 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 -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
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: arm64-apple-ios
-ObjectFileFormat: TBD
+--- !ifs-v1
+IfsVersion: 3.0
+Target: arm64-apple-ios
 Symbols:
   - { Name: __Z3fooi, Type: Func }
 ...

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

-# RUN: llvm-ifs --action write-bin -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
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: arm64-apple-macosx
-ObjectFileFormat: TBD
+--- !ifs-v1
+IfsVersion: 3.0
+Target: arm64-apple-macosx
 Symbols:
   - { Name: __Z3fooi, Type: Func }
 ...

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: --- !experimental-ifs-v2
-# CHECK-IFS-NEXT: IfsVersion: 2.0
-# CHECK-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
-# CHECK-IFS-NEXT: ObjectFileFormat: 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 }
 # CHECK-IFS-DAG:   - { Name: f,              Type: Object, Size: 2 }
 # CHECK-IFS-DAG:   - { Name: _Z10strongFuncv, Type: Func }
 # CHECK-IFS-DAG:   - { Name: _Z8weakFuncv,   Type: Func, Weak: true }
 # CHECK-IFS-DAG:   - { Name: b,              Type: Object, Size: 4 }
 # CHECK-IFS: ...
 
 # CHECK-ELF: FUNC    GLOBAL DEFAULT  1 _Z10strongFuncv
 # CHECK-ELF: FUNC    WEAK   DEFAULT  1 _Z8weakFuncv
 # CHECK-ELF: FUNC    GLOBAL DEFAULT  1 a
 # CHECK-ELF: OBJECT  GLOBAL DEFAULT  1 b
 # CHECK-ELF: OBJECT  GLOBAL DEFAULT  1 e
 # CHECK-ELF: OBJECT  GLOBAL DEFAULT  1 f
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple:          x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !ifs-v1
+IfsVersion: 3.0
+Target:          x86_64-unknown-linux-gnu
 Symbols:
   - { Name: e, Type: Object, Size: 8 }
   - { Name: f, Type: Object, Size: 2 }
 ...

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: --- !experimental-ifs-v2
-# CHECK-IFS-NEXT: IfsVersion: 2.0
-# CHECK-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
-# CHECK-IFS-NEXT: ObjectFileFormat: 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: ...
 
 # CHECK-ELF: ELF Header:
 # CHECK-ELF:   Class:                             ELF64
 # CHECK-ELF:   Data:                              2's complement, little endian
 # CHECK-ELF:   Type:                              DYN (Shared object file)
 # CHECK-ELF-NOT:   FUNC    GLOBAL DEFAULT  1 a
 # CHECK-ELF:   OBJECT  GLOBAL DEFAULT  1 b
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !ifs-v1
+IfsVersion: 3.0
+Target: x86_64-unknown-linux-gnu
 Symbols:
   - { Name: b, Type: Object, Size: 4 }
 ...

llvm/test/tools/llvm-ifs/output-target-error.test

+## Test running llvm-ifs without specifying a valid target.
+
+# RUN: not llvm-ifs --output=%t %s 2>&1 | FileCheck %s --check-prefix=MISSING
+# RUN: not llvm-ifs --output-format=nope --output=%t %s 2>&1 | FileCheck %s --check-prefix=INVALID
+
+--- !ifs-v1
+SoName: somelib.so
+IfsVersion: 3.0
+Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
+Symbols: []
+...
+
+# MISSING: llvm-ifs: for the --output-format option: must be specified at least once!
+
+# INVALID: llvm-ifs: for the --output-format option: Cannot find option named 'nope'!

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

+## Test writing unchanged content to TBE file with --write-if-changed flag.
+
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=%t %p/Inputs/gnu_hash.so
+# RUN: env TZ=GMT touch -m -t 197001010000 %t
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --output=%t --write-if-changed %p/Inputs/gnu_hash.so
+# RUN: env TZ=GMT ls -l %t | FileCheck %s
+
+# CHECK: {{[[:space:]]1970}}

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
-TbeVersion: 1.0
+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=TBE --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=TBE --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=TBE --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=TBE --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: TbeVersion:      1.0
+# 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=TBE --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
-TbeVersion: 1.0
+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-tbe-as-elf.test` (unsupported/malformed file?)

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

-# RUN: llvm-elfabi --input-format=TBE --output-format=TBE --output=- %s | FileCheck %s
+# RUN: llvm-ifs --input-format=IFS --output-format=IFS --output=- %s | FileCheck %s
 
 --- !ifs-v1
-TbeVersion: 1.0
+IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 Symbols: []
 ...
 
 # CHECK:      --- !ifs-v1
-# CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
+# 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=TBE --output=- %s 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --output-format=IFS --output=- %s 2>&1 | FileCheck %s
 
 --- !ifs-v1
 SoName: somelib.so
-TbeVersion: 1.0
+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=TBE --output=- %s 2>&1 | FileCheck %s
+# RUN: not llvm-ifs --output-format=IFS --output=- %s 2>&1 | FileCheck %s
 
 --- !ifs-v1
 SoName: somelib.so
-TbeVersion: 1.0
+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=TBE --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 TBE
 # CHECK: No file readers succeeded reading `{{.*}}` (unsupported/malformed file?)

llvm/test/tools/llvm-ifs/strip-target.test

+## Test writing tbe with stripped target information.
+
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --strip-ifs-target --output=- %p/Inputs/sysv_hash.so | FileCheck %s --check-prefix=NOTARGET
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --strip-ifs-arch --strip-ifs-endianness --strip-ifs-bitwidth --output=- %p/Inputs/sysv_hash.so | FileCheck %s --check-prefix=NOTARGET
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --strip-ifs-arch --output=- %p/Inputs/sysv_hash.so | FileCheck %s -DELFTARGET="ObjectFormat: ELF, Endianness: little, BitWidth: 64" --check-prefix=CHECK
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --strip-ifs-endianness --output=- %p/Inputs/sysv_hash.so | FileCheck %s -DELFTARGET="ObjectFormat: ELF, Arch: x86_64, BitWidth: 64" --check-prefix=CHECK
+# RUN: llvm-ifs --input-format=ELF --output-format=IFS --strip-ifs-bitwidth --output=- %p/Inputs/sysv_hash.so | FileCheck %s -DELFTARGET="ObjectFormat: ELF, Arch: x86_64, Endianness: little" --check-prefix=CHECK
+
+
+# CHECK:      --- !ifs-v1
+# CHECK-NEXT: IfsVersion:      3.0
+# CHECK-NEXT: SoName:          libsomething.so
+# CHECK-NEXT: Target: { [[ELFTARGET]] }
+# CHECK-NEXT: NeededLibs:
+# CHECK-NEXT:   - libm.so.6
+# CHECK-NEXT:   - libc.so.6
+# CHECK-NEXT:   - ld-linux-x86-64.so.2
+# CHECK-NEXT: Symbols:
+
+# NOTARGET:      --- !ifs-v1
+# NOTARGET-NEXT: IfsVersion:      3.0
+# NOTARGET-NEXT: SoName:          libsomething.so
+# NOTARGET-NEXT: NeededLibs:
+# NOTARGET-NEXT:   - libm.so.6
+# NOTARGET-NEXT:   - libc.so.6
+# NOTARGET-NEXT:   - ld-linux-x86-64.so.2
+# NOTARGET-NEXT: Symbols:

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: --- !experimental-ifs-v2
-# CHECK-IFS-NEXT: IfsVersion: 2.0
-# CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
-# CHECK-IFS-NEXT: ObjectFileFormat: 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: _Z8weakFuncv, Type: Func }
 # CHECK-IFS: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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 -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
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: arm64-apple-tvos
-ObjectFileFormat: TBD
+--- !ifs-v1
+IfsVersion: 3.0
+Target: arm64-apple-tvos
 Symbols:
   - { Name: __Z3fooi, Type: Func }
 ...

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
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple:          x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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 -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
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: arm64-apple-watchos
-ObjectFileFormat: TBD
+--- !ifs-v1
+IfsVersion: 3.0
+Target: arm64-apple-watchos
 Symbols:
   - { Name: __Z3fooi, Type: Func }
 ...

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
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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: --- !experimental-ifs-v2
-# CHECK-IFS-NEXT: IfsVersion: 2.0
-# CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
-# CHECK-IFS-NEXT: ObjectFileFormat: 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: _Z8weakFuncv, Type: Func, Weak: true }
 # CHECK-IFS-DAG:   - { Name: _Z10strongFuncv, Type: Func }
 # CHECK-IFS: ...
 
---- !experimental-ifs-v2
-IfsVersion: 2.0
-Triple: x86_64-unknown-linux-gnu
-ObjectFileFormat: ELF
+--- !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
-TbeVersion: 1.0
+IfsVersion: 3.0
 Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 NeededLibs:
   - libc.so.6
 Symbols: []
 ...
 
 # CHECK:      Section {
 # CHECK-NEXT:   Index: 0

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=TBE --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=TBE --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
-TbeVersion: 1.0
+IfsVersion: 3.0
 NeededLibs:
   - libc.so.6
 Symbols:
   - { Name: bar, Type: Object, Size: 42 }
   - { Name: baz, Type: TLS, Size: 3 }
   - { Name: plus, Type: Func }
 ...
 

 # 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 ----------------------------------------------------===//
+//===- 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/InterfaceStub/ELFObjHandler.h"
-#include "llvm/InterfaceStub/TBEHandler.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>
cl::values(clEnumValN(FileFormat::TBE, "TBE", "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::TBE, "TBE", "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<ELFBitWidthType> OptBitWidth(
+cl::opt<IFSBitWidthType> OptBitWidth(
     "bitwidth", cl::desc("Specify the bit width"),
-    cl::values(clEnumValN(ELFBitWidthType::ELF32, "32", "32 bits"),
-               clEnumValN(ELFBitWidthType::ELF64, "64", "64 bits")));
-cl::opt<ELFEndiannessType> OptEndianness(
+    cl::values(clEnumValN(IFSBitWidthType::ELF32, "32", "32 bits"),
+               clEnumValN(IFSBitWidthType::ELF64, "64", "64 bits")));
+cl::opt<IFSEndiannessType> OptEndianness(
     "endianness", cl::desc("Specify the endianness"),
-    cl::values(clEnumValN(ELFEndiannessType::Little, "little", "Little Endian"),
-               clEnumValN(ELFEndiannessType::Big, "big", "Big Endian")));
+    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 'TBE', this flag will hint the expected "
              "target triple for IFS output"));
 cl::opt<bool> StripIFSArch(
     "strip-ifs-arch",
SOName("soname",
            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."));
 
 /// writeTBE() writes a Text-Based ELF stub to a file using the latest version
 /// of the YAML parser.
-static Error writeTBE(StringRef FilePath, ELFStub &Stub) {
+static Error writeTBE(StringRef FilePath, IFSStub &Stub) {
   // Write TBE to memory first.
   std::string TBEStr;
   raw_string_ostream OutStr(TBEStr);
-  Error YAMLErr = writeTBEToOutputStream(OutStr, Stub);
+  Error YAMLErr = writeIFSToOutputStream(OutStr, Stub);
   if (YAMLErr)
     return YAMLErr;
   OutStr.flush();
 
   if (WriteIfChanged) {
     if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
             MemoryBuffer::getFile(FilePath)) {
       // Compare TBE output with existing TBE file.
       // If TBE file unchanged, abort updating.
       if ((*BufOrError)->getBuffer() == TBEStr)
         return Error::success();
     }
   }
   // Open TBE 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 << TBEStr;
   return Error::success();
 }
 
-/// readInputFile populates an ELFStub by attempting to read the
+/// readInputFile populates an IFSStub by attempting to read the
 /// input file using both the TBE and binary ELF parsers.
-static Expected<std::unique_ptr<ELFStub>> readInputFile(StringRef FilePath) {
+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<ELFStub>> StubFromELF =
+    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 tbe.
   if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::TBE) {
-    Expected<std::unique_ptr<ELFStub>> StubFromTBE =
-        readTBEFromBuffer(FileReadBuffer->getBuffer());
+    Expected<std::unique_ptr<IFSStub>> StubFromTBE =
+        readIFSFromBuffer(FileReadBuffer->getBuffer());
     if (StubFromTBE) {
       return std::move(*StubFromTBE);
     }
     EC.addError(StubFromTBE.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<ELFStub>> StubOrErr = readInputFile(InputFilePath);
+  Expected<std::unique_ptr<IFSStub>> StubOrErr = readInputFile(InputFilePath);
   if (!StubOrErr)
     fatalError(StubOrErr.takeError());
 
-  std::unique_ptr<ELFStub> TargetStub = std::move(StubOrErr.get());
+  std::unique_ptr<IFSStub> TargetStub = std::move(StubOrErr.get());
 
   // Change SoName before emitting stubs.
   if (SOName.getNumOccurrences() == 1)
     TargetStub->SoName = SOName;
-  Optional<ELFArch> OverrideArch;
-  Optional<ELFEndiannessType> OverrideEndianness;
-  Optional<ELFBitWidthType> OverrideBitWidth;
+  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 =
-      overrideTBETarget(*TargetStub, OverrideArch, OverrideEndianness,
+      overrideIFSTarget(*TargetStub, OverrideArch, OverrideEndianness,
                         OverrideBitWidth, OverrideTriple);
   if (OverrideError)
     fatalError(std::move(OverrideError));
   switch (OutputFormat.getValue()) {
   case FileFormat::TBE: {
     TargetStub->TbeVersion = TBEVersionCurrent;
     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));
       }
-      stripTBETarget(*TargetStub, true, false, false, false);
+      stripIFSTarget(*TargetStub, true, false, false, false);
       TargetStub->Target.Triple = OptTargetTripleHint.getValue();
     } else {
-      stripTBETarget(*TargetStub, StripIFSTarget, StripIFSArch,
+      stripIFSTarget(*TargetStub, StripIFSTarget, StripIFSArch,
                      StripIFSEndiannessWidth, StripIFSBitWidth);
     }
     Error TBEWriteError = writeTBE(OutputFilePath.getValue(), *TargetStub);
     if (TBEWriteError)
       fatalError(std::move(TBEWriteError));
     break;
   }
   case FileFormat::ELF: {
-    Error TargetError = validateTBETarget(*TargetStub, true);
+    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_IFS_ERRORCOLLECTOR_H
+#define LLVM_TOOLS_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_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/ELFStub.h"
-#include "llvm/InterfaceStub/TBEHandler.h"
+#include "llvm/InterfaceStub/IFSHandler.h"
+#include "llvm/InterfaceStub/IFSStub.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TextAPI/MachO/InterfaceFile.h"
 #include "llvm/TextAPI/MachO/TextAPIReader.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(2, 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::ELF32, "32", "32 bits"),
+               clEnumValN(IFSBitWidthType::ELF64, "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 'TBE', 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("!experimental-ifs-v2", true))
-      IO.setError("Not a .ifs YAML file.");
-
-    auto OldContext = IO.getContext();
-    IO.setContext(&Stub);
-    IO.mapRequired("IfsVersion", Stub.IfsVersion);
-    IO.mapOptional("Triple", Stub.Triple);
-    IO.mapOptional("ObjectFileFormat", Stub.ObjectFileFormat);
-    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 tbe.
+  if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::IFS) {
+    Expected<std::unique_ptr<IFSStub>> StubFromTBE =
+        readIFSFromBuffer(FileReadBuffer->getBuffer());
+    if (StubFromTBE) {
+      if ((*StubFromTBE)->IfsVersion > IfsVersionCurrent)
+        EC.addError(
+            createStringError(errc::not_supported,
+                              "IFS version " +
+                                  (*StubFromTBE)->IfsVersion.getAsString() +
+                                  " is unsupported."),
+            "ReadInputFile");
+      else
+        return std::move(*StubFromTBE);
+    } else {
+      EC.addError(StubFromTBE.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::ELFStub &ElfStub) {
-  ElfStub.TbeVersion = IfsStub.IfsVersion;
-  ElfStub.SoName = IfsStub.SOName;
-  ElfStub.Target.Triple = IfsStub.Triple;
-  ElfStub.NeededLibs = IfsStub.NeededLibs;
-  for (const IFSSymbol &IfsSymbol : IfsStub.Symbols) {
-    elfabi::ELFSymbol ElfSymbol(IfsSymbol.Name);
-    switch (IfsSymbol.Type) {
-    case IFSSymbolType::Func:
-      ElfSymbol.Type = elfabi::ELFSymbolType::Func;
-      break;
-    case IFSSymbolType::NoType:
-      ElfSymbol.Type = elfabi::ELFSymbolType::NoType;
-      break;
-    case IFSSymbolType::Object:
-      ElfSymbol.Type = elfabi::ELFSymbolType::Object;
-      break;
-    default:
-      ElfSymbol.Type = elfabi::ELFSymbolType::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);
+}
+
+/// writeTBE() writes a Text-Based ELF stub to a file using the latest version
+/// of the YAML parser.
+static Error writeTBE(StringRef FilePath, IFSStub &Stub) {
+  // Write TBE to memory first.
+  std::string TBEStr;
+  raw_string_ostream OutStr(TBEStr);
+  Error YAMLErr = writeIFSToOutputStream(OutStr, Stub);
+  if (YAMLErr)
+    return YAMLErr;
+  OutStr.flush();
+
+  if (WriteIfChanged) {
+    if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
+            MemoryBuffer::getFile(FilePath)) {
+      // Compare TBE output with existing TBE file.
+      // If TBE file unchanged, abort updating.
+      if ((*BufOrError)->getBuffer() == TBEStr)
+        return Error::success();
     }
-  return llvm::elfabi::validateTBETarget(ElfStub, true);
-}
-
-static int writeIfso(const IFSStub &Stub, bool IsWriteIfs) {
-  std::string ObjectFileFormat =
-      ForceFormat.empty() ? Stub.ObjectFileFormat : ForceFormat;
-
-  // Use InterfaceStub library if the option is enabled and output
-  // format is ELF.
-  if (UseInterfaceStub && (!IsWriteIfs) && ObjectFileFormat != "TBD") {
-    elfabi::ELFStub ElfStub;
-    Error ConvertError = convertIFSStub(Stub, ElfStub);
-    if (ConvertError) {
-      return -1;
-    }
-    Error BinaryWriteError = elfabi::writeBinaryStub(OutputFilename, ElfStub);
-    if (BinaryWriteError) {
-      return -1;
-    }
-    return 0;
   }
-
-  // Open file for writing.
+  // Open TBE 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 << TBEStr;
+  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."
-                           << "\nFilenames: " << PreviousInputFilePath << " "
-                           << InputFilePath
-                           << "\nTriple Values: " << Stub.Triple << " "
-                           << TargetStub->Triple << "\n";
-        return -1;
-      }
-      if (Stub.SOName != TargetStub->SOName) {
+      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 TBEWriteError = writeTBE(OutputFilePath.getValue(), Stub);
+    if (TBEWriteError)
+      fatalError(std::move(TBEWriteError));
+    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

 //===- llvm/unittests/TextAPI/YAMLTest.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/ADT/StringRef.h"
-#include "llvm/InterfaceStub/ELFStub.h"
-#include "llvm/InterfaceStub/TBEHandler.h"
+#include "llvm/InterfaceStub/IFSHandler.h"
+#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.
     // Using STREQ on StringRef.data() doesn't work since these substrings are
     // not null terminated.
     // This is inefficient, but forces null terminated strings that can be
     // cleanly compared.
     EXPECT_STREQ(Line1.str().data(), Line2.str().data());
   }
 }
 
 TEST(ElfYamlTextAPI, YAMLReadableTBE) {
   const char Data[] = "--- !ifs-v1\n"
-                      "TbeVersion: 1.0\n"
+                      "IfsVersion: 1.0\n"
                       "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
                       "little, BitWidth: 64 }\n"
                       "NeededLibs: [libc.so, libfoo.so, libbar.so]\n"
                       "Symbols:\n"
                       "  - { Name: foo, Type: Func, Undefined: true }\n"
                       "...\n";
-  Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
+  Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
-  std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
+  std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
   EXPECT_NE(Stub.get(), nullptr);
   EXPECT_FALSE(Stub->SoName.hasValue());
   EXPECT_TRUE(Stub->Target.Arch.hasValue());
   EXPECT_EQ(Stub->Target.Arch.getValue(), (uint16_t)llvm::ELF::EM_X86_64);
   EXPECT_EQ(Stub->NeededLibs.size(), 3u);
   EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so");
   EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.so");
   EXPECT_STREQ(Stub->NeededLibs[2].c_str(), "libbar.so");
 }
 
 TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) {
   const char Data[] =
       "--- !ifs-v1\n"
-      "TbeVersion: 1.0\n"
+      "IfsVersion: 1.0\n"
       "SoName: test.so\n"
       "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, "
       "BitWidth: 64 }\n"
       "Symbols:\n"
       "  - { Name: bar, Type: Object, Size: 42 }\n"
       "  - { Name: baz, Type: TLS, Size: 3 }\n"
       "  - { Name: foo, Type: Func, Warning: \"Deprecated!\" }\n"
       "  - { Name: nor, Type: NoType, Undefined: true }\n"
       "  - { Name: not, Type: File, Undefined: true, Size: 111, "
       "Weak: true, Warning: \'All fields populated!\' }\n"
       "...\n";
-  Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
+  Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
-  std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
+  std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
   EXPECT_NE(Stub.get(), nullptr);
   EXPECT_TRUE(Stub->SoName.hasValue());
   EXPECT_STREQ(Stub->SoName->c_str(), "test.so");
   EXPECT_EQ(Stub->Symbols.size(), 5u);
 
   auto Iterator = Stub->Symbols.begin();
-  ELFSymbol const &SymBar = *Iterator++;
+  IFSSymbol const &SymBar = *Iterator++;
   EXPECT_STREQ(SymBar.Name.c_str(), "bar");
   EXPECT_EQ(SymBar.Size, 42u);
-  EXPECT_EQ(SymBar.Type, ELFSymbolType::Object);
+  EXPECT_EQ(SymBar.Type, IFSSymbolType::Object);
   EXPECT_FALSE(SymBar.Undefined);
   EXPECT_FALSE(SymBar.Weak);
   EXPECT_FALSE(SymBar.Warning.hasValue());
 
-  ELFSymbol const &SymBaz = *Iterator++;
+  IFSSymbol const &SymBaz = *Iterator++;
   EXPECT_STREQ(SymBaz.Name.c_str(), "baz");
   EXPECT_EQ(SymBaz.Size, 3u);
-  EXPECT_EQ(SymBaz.Type, ELFSymbolType::TLS);
+  EXPECT_EQ(SymBaz.Type, IFSSymbolType::TLS);
   EXPECT_FALSE(SymBaz.Undefined);
   EXPECT_FALSE(SymBaz.Weak);
   EXPECT_FALSE(SymBaz.Warning.hasValue());
 
-  ELFSymbol const &SymFoo = *Iterator++;
+  IFSSymbol const &SymFoo = *Iterator++;
   EXPECT_STREQ(SymFoo.Name.c_str(), "foo");
   EXPECT_EQ(SymFoo.Size, 0u);
-  EXPECT_EQ(SymFoo.Type, ELFSymbolType::Func);
+  EXPECT_EQ(SymFoo.Type, IFSSymbolType::Func);
   EXPECT_FALSE(SymFoo.Undefined);
   EXPECT_FALSE(SymFoo.Weak);
   EXPECT_TRUE(SymFoo.Warning.hasValue());
   EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");
 
-  ELFSymbol const &SymNor = *Iterator++;
+  IFSSymbol const &SymNor = *Iterator++;
   EXPECT_STREQ(SymNor.Name.c_str(), "nor");
   EXPECT_EQ(SymNor.Size, 0u);
-  EXPECT_EQ(SymNor.Type, ELFSymbolType::NoType);
+  EXPECT_EQ(SymNor.Type, IFSSymbolType::NoType);
   EXPECT_TRUE(SymNor.Undefined);
   EXPECT_FALSE(SymNor.Weak);
   EXPECT_FALSE(SymNor.Warning.hasValue());
 
-  ELFSymbol const &SymNot = *Iterator++;
+  IFSSymbol const &SymNot = *Iterator++;
   EXPECT_STREQ(SymNot.Name.c_str(), "not");
   EXPECT_EQ(SymNot.Size, 111u);
-  EXPECT_EQ(SymNot.Type, ELFSymbolType::Unknown);
+  EXPECT_EQ(SymNot.Type, IFSSymbolType::Unknown);
   EXPECT_TRUE(SymNot.Undefined);
   EXPECT_TRUE(SymNot.Weak);
   EXPECT_TRUE(SymNot.Warning.hasValue());
   EXPECT_STREQ(SymNot.Warning->c_str(), "All fields populated!");
 }
 
 TEST(ElfYamlTextAPI, YAMLReadsNoTBESyms) {
   const char Data[] = "--- !ifs-v1\n"
-                      "TbeVersion: 1.0\n"
+                      "IfsVersion: 1.0\n"
                       "SoName: test.so\n"
                       "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
                       "little, BitWidth: 64 }\n"
                       "Symbols: []\n"
                       "...\n";
-  Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
+  Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
-  std::unique_ptr<ELFStub> Stub = std::move(StubOrErr.get());
+  std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
   EXPECT_NE(Stub.get(), nullptr);
   EXPECT_EQ(0u, Stub->Symbols.size());
 }
 
 TEST(ElfYamlTextAPI, YAMLUnreadableTBE) {
   // Can't read: wrong format/version.
   const char Data[] = "--- !tapi-tbz\n"
-                      "TbeVersion: z.3\n"
+                      "IfsVersion: z.3\n"
                       "SoName: test.so\n"
                       "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
                       "little, BitWidth: 64 }\n"
                       "Symbols:\n"
                       "  foo: { Type: Func, Undefined: true }\n";
-  Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
+  Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Failed());
 }
 
 TEST(ElfYamlTextAPI, YAMLUnsupportedVersion) {
   const char Data[] = "--- !ifs-v1\n"
-                      "TbeVersion: 9.9.9\n"
+                      "IfsVersion: 9.9.9\n"
                       "SoName: test.so\n"
                       "Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: "
                       "little, BitWidth: 64 }\n"
                       "Symbols: []\n"
                       "...\n";
-  Expected<std::unique_ptr<ELFStub>> StubOrErr = readTBEFromBuffer(Data);
+  Expected<std::unique_ptr<IFSStub>> StubOrErr = readIFSFromBuffer(Data);
   std::string ErrorMessage = toString(StubOrErr.takeError());
   EXPECT_EQ("TBE version 9.9.9 is unsupported.", ErrorMessage);
 }
 
 TEST(ElfYamlTextAPI, YAMLWritesTBESymbols) {
   const char Expected[] =
       "--- !ifs-v1\n"
-      "TbeVersion:      1.0\n"
+      "IfsVersion:      1.0\n"
       "Target:          { ObjectFormat: ELF, Arch: AArch64, Endianness: "
       "little, BitWidth: 64 }\n"
       "Symbols:\n"
       "  - { Name: bar, Type: Func, Weak: true }\n"
       "  - { Name: foo, Type: NoType, Size: 99, Warning: Does nothing }\n"
       "  - { Name: nor, Type: Func, Undefined: true }\n"
       "  - { Name: not, Type: Unknown, Size: 12345678901234 }\n"
       "...\n";
-  ELFStub Stub;
-  Stub.TbeVersion = VersionTuple(1, 0);
+  IFSStub Stub;
+  Stub.IfsVersion = VersionTuple(1, 0);
   Stub.Target.Arch = ELF::EM_AARCH64;
-  Stub.Target.BitWidth = ELFBitWidthType::ELF64;
-  Stub.Target.Endianness = ELFEndiannessType::Little;
+  Stub.Target.BitWidth = IFSBitWidthType::ELF64;
+  Stub.Target.Endianness = IFSEndiannessType::Little;
   Stub.Target.ObjectFormat = "ELF";
 
-  ELFSymbol SymBar("bar");
+  IFSSymbol SymBar("bar");
   SymBar.Size = 128u;
-  SymBar.Type = ELFSymbolType::Func;
+  SymBar.Type = IFSSymbolType::Func;
   SymBar.Undefined = false;
   SymBar.Weak = true;
 
-  ELFSymbol SymFoo("foo");
+  IFSSymbol SymFoo("foo");
   SymFoo.Size = 99u;
-  SymFoo.Type = ELFSymbolType::NoType;
+  SymFoo.Type = IFSSymbolType::NoType;
   SymFoo.Undefined = false;
   SymFoo.Weak = false;
   SymFoo.Warning = "Does nothing";
 
-  ELFSymbol SymNor("nor");
+  IFSSymbol SymNor("nor");
   SymNor.Size = 1234u;
-  SymNor.Type = ELFSymbolType::Func;
+  SymNor.Type = IFSSymbolType::Func;
   SymNor.Undefined = true;
   SymNor.Weak = false;
 
-  ELFSymbol SymNot("not");
+  IFSSymbol SymNot("not");
   SymNot.Size = 12345678901234u;
-  SymNot.Type = ELFSymbolType::Unknown;
+  SymNot.Type = IFSSymbolType::Unknown;
   SymNot.Undefined = false;
   SymNot.Weak = false;
 
   // Symbol order is preserved instead of being sorted.
   Stub.Symbols.push_back(SymBar);
   Stub.Symbols.push_back(SymFoo);
   Stub.Symbols.push_back(SymNor);
   Stub.Symbols.push_back(SymNot);
 
   // Ensure move constructor works as expected.
-  ELFStub Moved = std::move(Stub);
+  IFSStub Moved = std::move(Stub);
 
   std::string Result;
   raw_string_ostream OS(Result);
-  ASSERT_THAT_ERROR(writeTBEToOutputStream(OS, Moved), Succeeded());
+  ASSERT_THAT_ERROR(writeIFSToOutputStream(OS, Moved), Succeeded());
   Result = OS.str();
   compareByLine(Result.c_str(), Expected);
 }
 
 TEST(ElfYamlTextAPI, YAMLWritesNoTBESyms) {
   const char Expected[] = "--- !ifs-v1\n"
-                          "TbeVersion:      1.0\n"
+                          "IfsVersion:      1.0\n"
                           "SoName:          nosyms.so\n"
                           "Target:          { ObjectFormat: ELF, Arch: x86_64, "
                           "Endianness: little, BitWidth: 64 }\n"
                           "NeededLibs:\n"
                           "  - libc.so\n"
                           "  - libfoo.so\n"
                           "  - libbar.so\n"
                           "Symbols:         []\n"
                           "...\n";
-  ELFStub Stub;
-  Stub.TbeVersion = VersionTuple(1, 0);
+  IFSStub Stub;
+  Stub.IfsVersion = VersionTuple(1, 0);
   Stub.SoName = "nosyms.so";
   Stub.Target.Arch = ELF::EM_X86_64;
-  Stub.Target.BitWidth = ELFBitWidthType::ELF64;
-  Stub.Target.Endianness = ELFEndiannessType::Little;
+  Stub.Target.BitWidth = IFSBitWidthType::ELF64;
+  Stub.Target.Endianness = IFSEndiannessType::Little;
   Stub.Target.ObjectFormat = "ELF";
   Stub.NeededLibs.push_back("libc.so");
   Stub.NeededLibs.push_back("libfoo.so");
   Stub.NeededLibs.push_back("libbar.so");
 
   std::string Result;
   raw_string_ostream OS(Result);
-  ASSERT_THAT_ERROR(writeTBEToOutputStream(OS, Stub), Succeeded());
+  ASSERT_THAT_ERROR(writeIFSToOutputStream(OS, Stub), Succeeded());
   Result = OS.str();
   compareByLine(Result.c_str(), Expected);
 }

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-ifs",
     "//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") {
+executable("llvm-ifs") {
   deps = [
     "//llvm/lib/InterfaceStub",
     "//llvm/lib/Object",
     "//llvm/lib/Support",
     "//llvm/lib/TextAPI",
   ]
   sources = [
     "ErrorCollector.cpp",
-    "llvm-elfabi.cpp",
+    "llvm-ifs.cpp",
   ]
 }