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

[haowei]

Summary

This change implements unified text stub format and command line interface proposed in the elfabi/ifs merge plan (https://lists.llvm.org/pipermail/llvm-dev/2021-March/149263.html). This CL mainly serves the purpose of verifying the ideas proposed in the merge plan. Once it lands, the next step will be update the clang IFSO driver and llvm-ifs to generate the text stub in the same format and performs the actual merging.

I ran into a lot of issues with LLVM's yaml library. It does not allow using ScalarTraits on Optional<uint16_t> type. It also does not allow mapping 2 traits on the same type, creating a lot of difficulties to support both Target: triple_string and Target: { Arch:..., Endianness: ...} in the same data structure. Please let me know if you have better workarounds than the one I used in this change.

When updating ifs tool with the unified text stub and command line interfacing, I plan to rename 'ELFStub.h' to 'InterfaceStub.h' 'TBEHandler.cpp' to 'IFSHandler.cpp' as these 2 will cover formats like TBD and COEF in the future. The naming of 'ELFObjHandler.h' will remans the same since it still only covers ELF related operations. Please let me know if you have any suggestions.

[haowei]

Address clang-tidy warnings.

[plotfi]

I will take another look over this commit in the morning. Overall looks good.

llvm/lib/InterfaceStub/ELFStub.cpp

56

Can we populate this in this commit?

66

Can we populate this in this commit?

[haowei]

Address test failures.

[phosek]

llvm/lib/InterfaceStub/ELFStub.cpp

56

StringSwitch should be more efficient than StringMap. It may be better to move this to llvm/lib/BinaryFormat/ELF.cpp and expose it as a helper function through llvm/include/llvm/BinaryFormat/ELF.h.

247

Ditto, I'd move this to llvm/lib/BinaryFormat/ELF.cpp.

llvm/lib/InterfaceStub/TBEHandler.cpp

137

Would this eventually become IFSVersion?

[haowei]

llvm/lib/InterfaceStub/ELFStub.cpp

56

StringSwitch should be more efficient than StringMap.

Is that because the map is relatively small, nor worth hashing it?

[phosek]

llvm/lib/BinaryFormat/ELF.cpp

206 ↗

(On Diff #334310)

I'd just use switch and return StringRef akin to https://github.com/llvm/llvm-project/blob/f59ba0849f7a148265dcc89d36a11717d365f368/llvm/lib/Support/Triple.cpp#L23

llvm/lib/InterfaceStub/ELFStub.cpp

56

StringSwitch is written in a way that takes advantage of LLVM optimizations and should produce the most optimal code in this case.

[plotfi]

llvm/include/llvm/InterfaceStub/ELFStub.h

90

struct instead of class public?

llvm/lib/InterfaceStub/ELFObjHandler.cpp

564–569

Why both casts? How about one cast, or a static_cast<ELFArch> ?

llvm/lib/InterfaceStub/TBEHandler.cpp

50

default llvm_unreachable here?

54

Default StringSwitch case?

73

default llvm_unreachable?

79

Same as before. Default?

137

I think I would be OK with IFSVersion and TBE version sharing the same number.

205

Do we even support dynamic_casts in LLVM anymore? I might be missing something here, sorry.

[haowei]

llvm/lib/InterfaceStub/TBEHandler.cpp

137

It will eventually be IFSVersion.

205

I tried dyn_cast seems not working. Not sure if dynamic_casts is allowed or not so I just change it static_cast.

[plotfi]

llvm/lib/InterfaceStub/TBEHandler.cpp

205

LLVM is compiled with no-rtti and no exceptions afaik.

[alexander-shaposhnikov]

llvm/include/llvm/InterfaceStub/ELFStub.h

50

1. explicit

2. Name(std::move(SymbolName))

[plotfi]

llvm/include/llvm/InterfaceStub/ELFStub.h

50

Does this need to be a std::move?

[plotfi]

llvm/include/llvm/InterfaceStub/ELFStub.h

50

Ah never mind, I see. Ignore my previous std::move comment.

[phosek]

This looks good to me modulo a few nits although you may also want to wait for thumbs up from @plotfi and @compnerd.

llvm/lib/InterfaceStub/ELFObjHandler.cpp

253

This should be a C++ cast, probably a static_cast.

llvm/lib/InterfaceStub/TBEHandler.cpp

59

Does this trigger an error? If not we should maybe consider using an assertion.

97

Ditto here.

[plotfi]

LGTM once you've addressed @phosek's nits.

[haowei]

llvm/lib/InterfaceStub/TBEHandler.cpp

59

Yes, there is a test case in tools/llvm-elfabi/read-tbe-with-bad-endianness.test , Since the data is from a yaml file, it's better to generate an error message instead of using assertion.

97

there is a test case in tools/llvm-elfabi/read-tbe-with-bad-bitwidth.test

[haowei]

Suppress clang-tidy warnings on YAML flow control variable.

llvm/include/llvm/InterfaceStub/ELFObjHandler.h

 Expected<std::unique_ptr<ELFStub>> 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 OutputFormat Target ELFType to write binary as.
 /// @param WriteIfChanged Whether or not to preserve timestamp if
 ///        the output stays the same.
 Error writeBinaryStub(StringRef FilePath, const ELFStub &Stub,
-                      ELFTarget OutputFormat, bool WriteIfChanged = false);
+                      bool WriteIfChanged = false);
 
 } // end namespace elfabi
 } // end namespace llvm
 
 #endif // LLVM_INTERFACESTUB_ELFOBJHANDLER_H

llvm/include/llvm/InterfaceStub/ELFStub.h

 /// This file defines an internal representation of an ELF stub.
 ///
 //===-----------------------------------------------------------------------===/
 
 #ifndef LLVM_INTERFACESTUB_ELFSTUB_H
 #define LLVM_INTERFACESTUB_ELFSTUB_H
 
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/VersionTuple.h"
 #include <set>
 #include <vector>
 
 namespace llvm {
 namespace elfabi {
 
 typedef uint16_t ELFArch;
 
 enum class ELFSymbolType {
   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 {
+  Little = ELF::ELFDATA2LSB,
+  Big = ELF::ELFDATA2MSB,
+};
+
+enum class ELFBitWidthType {
+  ELF32 = ELF::ELFCLASS32,
+  ELF64 = ELF::ELFCLASS64,
+};
+
 struct ELFSymbol {
+  ELFSymbol() = default;
   ELFSymbol(std::string SymbolName) : Name(SymbolName) {}
   std::string Name;
   uint64_t Size;
   ELFSymbolType Type;
   bool Undefined;
   bool Weak;
   Optional<std::string> Warning;
   bool operator<(const ELFSymbol &RHS) const { return Name < RHS.Name; }
 };
 
+struct IFSTarget {
+  Optional<std::string> Triple;
+  Optional<std::string> ObjectFormat;
+  Optional<ELFArch> Arch;
+  Optional<std::string> ArchString;
+  Optional<ELFEndiannessType> Endianness;
+  Optional<ELFBitWidthType> BitWidth;
+};
+
 // A cumulative representation of ELF stubs.
 // Both textual and binary stubs will read into and write from this object.
 class ELFStub {
   // TODO: Add support for symbol versioning.
 public:
   VersionTuple TbeVersion;
   Optional<std::string> SoName;
-  ELFArch Arch;
+  IFSTarget Target;
   std::vector<std::string> NeededLibs;
-  std::set<ELFSymbol> Symbols;
+  std::vector<ELFSymbol> Symbols;
 
   ELFStub() {}
   ELFStub(const ELFStub &Stub);
   ELFStub(ELFStub &&Stub);
 };
+
+// Create a alias class for ELFStub.
+// 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.
+class ELFStubTriple : public ELFStub {
+public:
+  ELFStubTriple() {}
+  ELFStubTriple(const ELFStub &Stub);
+  ELFStubTriple(const ELFStubTriple &Stub);
+  ELFStubTriple(ELFStubTriple &&Stub);
+};
+
+/// Convert an architecture name into ELF's e_machine value.
+Expected<ELFArch> ConvertArchNameToEMachine(StringRef Arch);
+
+/// Convert an ELF's e_machine value into an architecture name.
+Expected<std::string> ConvertEMachineToArchName(ELFArch EMachine);
+
 } // end namespace elfabi
 } // end namespace llvm
 
 #endif // LLVM_INTERFACESTUB_ELFSTUB_H

llvm/include/llvm/InterfaceStub/TBEHandler.h

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

llvm/lib/InterfaceStub/ELFObjHandler.cpp

explicit ELFStubBuilder(const ELFStub &Stub) {
     DynTab.Content.modifyAddr(DynStrIndex, DynStr.Addr);
     // Write section headers of string tables.
     fillSymTabShdr(DynSym, SHT_DYNSYM);
     fillStrTabShdr(DynStr, SHF_ALLOC);
     fillDynTabShdr(DynTab);
     fillStrTabShdr(ShStrTab);
 
     // Finish initializing the ELF header.
-    initELFHeader<ELFT>(ElfHeader, Stub.Arch);
+    initELFHeader<ELFT>(ElfHeader, (uint16_t)(Stub.Target.Arch.getValue()));
     ElfHeader.e_shstrndx = ShStrTab.Index;
     ElfHeader.e_shnum = LastSection->Index + 1;
     ElfHeader.e_shoff =
         alignTo(LastSection->Offset + LastSection->Size, sizeof(Elf_Addr));
   }
 
   size_t getSize() const {
     return ElfHeader.e_shoff + ElfHeader.e_shnum * sizeof(Elf_Shdr);
for (auto RawSym : DynSym.drop_front(1)) {
     if (!(Visibility == STV_DEFAULT || Visibility == STV_PROTECTED))
       continue;
     // Create an ELFSymbol 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);
-    TargetStub.Symbols.insert(std::move(Sym));
+    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.
 /// @param ElfObj Source ELFObjectFile.
 template <class ELFT>
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->Arch = ElfFile.getHeader().e_machine;
+  DestStub->Target.Arch = (ELFArch)(uint16_t)(ElfFile.getHeader().e_machine);
+  DestStub->Target.BitWidth =
+      (ELFBitWidthType)ElfFile.getHeader().e_ident[EI_CLASS];
+  DestStub->Target.Endianness =
+      (ELFEndiannessType)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");
     }
if (auto Obj = dyn_cast<ELFObjectFile<ELF32LE>>(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,
-                      ELFTarget OutputFormat, bool WriteIfChanged) {
-  if (OutputFormat == ELFTarget::ELF32LE)
+                      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) {
       return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
-  if (OutputFormat == ELFTarget::ELF32BE)
+    } else {
       return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
-  if (OutputFormat == ELFTarget::ELF64LE)
+    }
+  } else {
+    if (Stub.Target.Endianness == ELFEndiannessType::Little) {
       return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
-  if (OutputFormat == ELFTarget::ELF64BE)
+    } else {
       return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
+    }
+  }
   llvm_unreachable("invalid binary output target");
 }
 
 } // end namespace elfabi
 } // end namespace llvm

llvm/lib/InterfaceStub/ELFStub.cpp

 //===- ELFStub.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/Support/Error.h"
 
 using namespace llvm;
 using namespace llvm::elfabi;
 
 ELFStub::ELFStub(ELFStub const &Stub) {
   TbeVersion = Stub.TbeVersion;
-  Arch = Stub.Arch;
+  Target = Stub.Target;
   SoName = Stub.SoName;
   NeededLibs = Stub.NeededLibs;
   Symbols = Stub.Symbols;
 }
 
 ELFStub::ELFStub(ELFStub &&Stub) {
   TbeVersion = std::move(Stub.TbeVersion);
-  Arch = std::move(Stub.Arch);
+  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;
+  Target = Stub.Target;
+  SoName = Stub.SoName;
+  NeededLibs = Stub.NeededLibs;
+  Symbols = Stub.Symbols;
+}
+
+ELFStubTriple::ELFStubTriple(ELFStub const &Stub) {
+  TbeVersion = Stub.TbeVersion;
+  Target = Stub.Target;
+  SoName = Stub.SoName;
+  NeededLibs = Stub.NeededLibs;
+  Symbols = Stub.Symbols;
+}
+
+ELFStubTriple::ELFStubTriple(ELFStubTriple &&Stub) {
+  TbeVersion = std::move(Stub.TbeVersion);
+  Target = std::move(Stub.Target);
+  SoName = std::move(Stub.SoName);
+  NeededLibs = std::move(Stub.NeededLibs);
+  Symbols = std::move(Stub.Symbols);
+}
+
+Expected<ELFArch> llvm::elfabi::ConvertArchNameToEMachine(StringRef Arch) {
+  // TODO: Support all availabe architectures.
+  if (Arch == "x86_64")
+    return ELF::EM_X86_64;
+  if (Arch == "AArch64")
+    return ELF::EM_AARCH64;
+  return ELF::EM_NONE;
+}
+
+Expected<std::string>
+llvm::elfabi::ConvertEMachineToArchName(ELFArch EMachine) {
+  // TODO: Support all availabe architectures.
+  switch (EMachine) {
+  case ELF::EM_X86_64:
+    return "x86_64";
+  case ELF::EM_AARCH64:
+    return "AArch64";
+  default:
+    return "None";
+  }
+}
 No newline at end of file

llvm/lib/InterfaceStub/TBEHandler.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/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/InterfaceStub/ELFStub.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/LineIterator.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace llvm;
 using namespace llvm::elfabi;
 
-LLVM_YAML_STRONG_TYPEDEF(ELFArch, ELFArchMapper)
+LLVM_YAML_IS_SEQUENCE_VECTOR(ELFSymbol)
 
 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);
     // Treat other symbol types as noise, and map to Unknown.
     if (!IO.outputting() && IO.matchEnumFallback())
       SymbolType = ELFSymbolType::Unknown;
   }
 };
 
-/// YAML traits for ELFArch.
-template <> struct ScalarTraits<ELFArchMapper> {
-  static void output(const ELFArchMapper &Value, void *,
+template <> struct ScalarTraits<ELFEndiannessType> {
+  static void output(const ELFEndiannessType &Value, void *,
                      llvm::raw_ostream &Out) {
-    // Map from integer to architecture string.
     switch (Value) {
-    case (ELFArch)ELF::EM_X86_64:
-      Out << "x86_64";
+    case ELFEndiannessType::Big:
+      Out << "big";
       break;
-    case (ELFArch)ELF::EM_AARCH64:
-      Out << "AArch64";
+    case ELFEndiannessType::Little:
+      Out << "little";
       break;
-    case (ELFArch)ELF::EM_NONE:
-    default:
-      Out << "Unknown";
     }
   }
 
-  static StringRef input(StringRef Scalar, void *, ELFArchMapper &Value) {
-    // Map from architecture string to integer.
-    Value = StringSwitch<ELFArch>(Scalar)
-                .Case("x86_64", ELF::EM_X86_64)
-                .Case("AArch64", ELF::EM_AARCH64)
-                .Case("Unknown", ELF::EM_NONE)
-                .Default(ELF::EM_NONE);
+  static StringRef input(StringRef Scalar, void *, ELFEndiannessType &Value) {
+    Value = StringSwitch<ELFEndiannessType>(Scalar)
+                .Case("big", ELFEndiannessType::Big)
+                .Case("little", ELFEndiannessType::Little);
+    return StringRef();
+  }
+
+  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
+};
+
+template <> struct ScalarTraits<ELFBitWidthType> {
+  static void output(const ELFBitWidthType &Value, void *,
+                     llvm::raw_ostream &Out) {
+    switch (Value) {
+    case ELFBitWidthType::ELF32:
+      Out << "32";
+      break;
+    case ELFBitWidthType::ELF64:
+      Out << "64";
+      break;
+    }
+  }
 
-    // Returning empty StringRef indicates successful parse.
+  static StringRef input(StringRef Scalar, void *, ELFBitWidthType &Value) {
+    Value = StringSwitch<ELFBitWidthType>(Scalar)
+                .Case("32", ELFBitWidthType::ELF32)
+                .Case("64", ELFBitWidthType::ELF64);
     return StringRef();
   }
 
-  // Don't place quotation marks around architecture value.
   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);
+  }
+
+  static const bool flow = true;
+};
+
 /// YAML traits for ELFSymbol.
 template <> struct MappingTraits<ELFSymbol> {
   static void mapping(IO &IO, ELFSymbol &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) {
       IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
     } else if (Symbol.Type == ELFSymbolType::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 set of ELFSymbols.
-template <> struct CustomMappingTraits<std::set<ELFSymbol>> {
-  static void inputOne(IO &IO, StringRef Key, std::set<ELFSymbol> &Set) {
-    ELFSymbol Sym(Key.str());
-    IO.mapRequired(Key.str().c_str(), Sym);
-    Set.insert(Sym);
-  }
-
-  static void output(IO &IO, std::set<ELFSymbol> &Set) {
-    for (auto &Sym : Set)
-      IO.mapRequired(Sym.Name.c_str(), const_cast<ELFSymbol &>(Sym));
-  }
-};
-
 /// YAML traits for ELFStub objects.
 template <> struct MappingTraits<ELFStub> {
   static void mapping(IO &IO, ELFStub &Stub) {
-    if (!IO.mapTag("!tapi-tbe", true))
+    if (!IO.mapTag("!ifs-v1", true))
       IO.setError("Not a .tbe YAML file.");
     IO.mapRequired("TbeVersion", Stub.TbeVersion);
     IO.mapOptional("SoName", Stub.SoName);
-    IO.mapRequired("Arch", (ELFArchMapper &)Stub.Arch);
+    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) {
+    if (!IO.mapTag("!ifs-v1", true))
+      IO.setError("Not a .tbe YAML file.");
+    IO.mapRequired("TbeVersion", Stub.TbeVersion);
+    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) {
   yaml::Input YamlIn(Buf);
-  std::unique_ptr<ELFStub> Stub(new ELFStub());
+  std::unique_ptr<ELFStubTriple> Stub(new ELFStubTriple());
+  if (usesTriple(Buf)) {
     YamlIn >> *Stub;
-  if (std::error_code Err = YamlIn.error())
+  } else {
+    YamlIn >> *dynamic_cast<ELFStub *>(Stub.get());
+  }
+  if (std::error_code Err = YamlIn.error()) {
     return createStringError(Err, "YAML failed reading as TBE");
+  }
 
   if (Stub->TbeVersion > elfabi::TBEVersionCurrent)
     return make_error<StringError>(
         "TBE version " + Stub->TbeVersion.getAsString() + " is unsupported.",
         std::make_error_code(std::errc::invalid_argument));
-
+  if (Stub->Target.ArchString) {
+    Expected<ELFArch> Arch =
+        ConvertArchNameToEMachine(Stub->Target.ArchString.getValue());
+    if (!Arch) {
+      return Arch.takeError();
+    }
+    Stub->Target.Arch = Arch.get();
+  }
   return std::move(Stub);
 }
 
 Error elfabi::writeTBEToOutputStream(raw_ostream &OS, const ELFStub &Stub) {
   yaml::Output YamlOut(OS, NULL, /*WrapColumn =*/0);
+  std::unique_ptr<ELFStubTriple> CopyStub(new ELFStubTriple(Stub));
+  if (Stub.Target.Arch) {
+    Expected<std::string> ArchString =
+        ConvertEMachineToArchName(Stub.Target.Arch.getValue());
+    if (!ArchString) {
+      return ArchString.takeError();
+    }
+    CopyStub->Target.ArchString = ArchString.get();
+  }
+  IFSTarget Target = Stub.Target;
+
+  if (CopyStub->Target.Triple ||
+      (!CopyStub->Target.ArchString && !CopyStub->Target.Endianness &&
+       !CopyStub->Target.BitWidth))
+    YamlOut << *CopyStub;
+  else
+    YamlOut << *dynamic_cast<ELFStub *>(CopyStub.get());
+  return Error::success();
+}
+
+Error elfabi::overrideTBETarget(ELFStub &Stub, Optional<ELFArch> OverrideArch,
+                                Optional<ELFEndiannessType> OverrideEndianness,
+                                Optional<ELFBitWidthType> OverrideBitWidth,
+                                Optional<std::string> OverrideTriple) {
+  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 (OverrideEndianness) {
+    if (Stub.Target.Endianness &&
+        Stub.Target.Endianness.getValue() != OverrideEndianness.getValue()) {
+      return make_error<StringError>(
+          "Supplied Endianness conflicts with the text stub", OverrideEC);
+    }
+    Stub.Target.Endianness = OverrideEndianness.getValue();
+  }
+  if (OverrideBitWidth) {
+    if (Stub.Target.BitWidth &&
+        Stub.Target.BitWidth.getValue() != OverrideBitWidth.getValue()) {
+      return make_error<StringError>(
+          "Supplied BitWidth conflicts with the text stub", OverrideEC);
+    }
+    Stub.Target.BitWidth = OverrideBitWidth.getValue();
+  }
+  if (OverrideTriple) {
+    if (Stub.Target.Triple &&
+        Stub.Target.Triple.getValue() != OverrideTriple.getValue()) {
+      return make_error<StringError>(
+          "Supplied Triple conflicts with the text stub", OverrideEC);
+    }
+    Stub.Target.Triple = OverrideTriple.getValue();
+  }
+  return Error::success();
+}
 
-  YamlOut << const_cast<ELFStub &>(Stub);
+Error elfabi::validateTBETarget(ELFStub &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 (ParseTriple) {
+      IFSTarget TargetFromTriple = parseTriple(Stub.Target.Triple.getValue());
+      Stub.Target.Arch = TargetFromTriple.Arch;
+      Stub.Target.BitWidth = TargetFromTriple.BitWidth;
+      Stub.Target.Endianness = TargetFromTriple.Endianness;
+    }
+    return Error::success();
+  }
+  if (!Stub.Target.Arch || !Stub.Target.BitWidth || !Stub.Target.Endianness) {
+    // TODO: unify the error message.
+    if (!Stub.Target.Arch) {
+      return make_error<StringError>("Arch is not defined in the text stub",
+                                     ValidationEC);
+    }
+    if (!Stub.Target.BitWidth) {
+      return make_error<StringError>("BitWidth is not defined in the text stub",
+                                     ValidationEC);
+    }
+    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) {
+  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;
+    break;
+  case Triple::ArchType::x86_64:
+    RetTarget.Arch = (ELFArch)ELF::EM_X86_64;
+    break;
+  default:
+    RetTarget.Arch = (ELFArch)ELF::EM_NONE;
+  }
+  RetTarget.Endianness = IFSTriple.isLittleEndian() ? ELFEndiannessType::Little
+                                                    : ELFEndiannessType::Big;
+  RetTarget.BitWidth =
+      IFSTriple.isArch64Bit() ? ELFBitWidthType::ELF64 : ELFBitWidthType::ELF64;
+  return RetTarget;
+}
+
+void elfabi::stripTBETarget(ELFStub &Stub, bool StripTriple, bool StripArch,
+                            bool StripEndianness, bool StripBitWidth) {
+  if (StripTriple || StripArch) {
+    Stub.Target.Arch.reset();
+    Stub.Target.ArchString.reset();
+  }
+  if (StripTriple || StripEndianness) {
+    Stub.Target.Endianness.reset();
+  }
+  if (StripTriple || StripBitWidth) {
+    Stub.Target.BitWidth.reset();
+  }
+  if (StripTriple) {
+    Stub.Target.Triple.reset();
+  }
+  if (!Stub.Target.Arch && !Stub.Target.BitWidth && !Stub.Target.Endianness) {
+    Stub.Target.ObjectFormat.reset();
+  }
+}

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

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --elf %t --emit-tbe=- --soname=best.so | FileCheck %s
+# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --output=- --soname=best.so %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_AARCH64
 Sections:
- Type:     PT_LOAD
     FirstSec: .dynstr
     LastSec:  .dynamic
   - Type: PT_DYNAMIC
     Flags: [ PF_X, PF_R ]
     VAddr: 0x0008
     FirstSec: .dynamic
     LastSec:  .dynamic
 
-# CHECK:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: SoName: best.so{{$}}
-# CHECK-NEXT: Arch: AArch64
-# CHECK-NEXT: Symbols: {}
+# CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
+# CHECK-NEXT: Symbols: []
 # CHECK-NEXT: ...

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

-# RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
+# 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"
 
-!ELF
+--- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
   - Name:            .dynstr
     Type:            SHT_STRTAB
- Type:     PT_LOAD
     FirstSec: .dynstr
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     Flags:    [ PF_X, PF_R ]
     VAddr:    0x0008
     FirstSec: .dynamic
     LastSec:  .dynamic
 
-# CHECK:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
-# CHECK-NEXT: Arch: x86_64
-# CHECK-NEXT: Symbols: {}
+# 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
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2MSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000
+    Content:         "00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000000008
+    Link:            .dynstr
+    AddressAlign:    0x0000000000000008
+    EntSize:         0x0000000000000010
+    Entries:
+      - Tag:             DT_STRSZ
+        Value:           0x0000000000000001
+      - Tag:             DT_STRTAB
+        Value:           0x0000000000000000
+      - Tag:             DT_SYMTAB
+        Value:           0x0000000000000000
+      - Tag:             DT_NULL
+        Value:           0x0000000000000000
+ProgramHeaders:
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    VAddr:    0x0000
+    Align:    8
+    FirstSec: .dynstr
+    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
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000
+    Content:         "00"
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000000008
+    Link:            .dynstr
+    AddressAlign:    0x0000000000000008
+    EntSize:         0x0000000000000010
+    Entries:
+      - Tag:             DT_STRSZ
+        Value:           0x0000000000000001
+      - Tag:             DT_STRTAB
+        Value:           0x0000000000000000
+      - Tag:             DT_SYMTAB
+        Value:           0x0000000000000000
+      - Tag:             DT_NULL
+        Value:           0x0000000000000000
+ProgramHeaders:
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    VAddr:    0x0000
+    Align:    8
+    FirstSec: .dynstr
+    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

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

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --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-elfabi/binary-read-bad-vaddr.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --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-elfabi/binary-read-neededlibs-bad-offset.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --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-elfabi/binary-read-neededlibs.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --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: 0x1024
 
 # CHECK:      NeededLibs:
 # CHECK-NEXT:   - libfoo.so{{$}}
 # CHECK-NEXT:   - libbar.so{{$}}
-# CHECK-NEXT: Symbols: {}
+# CHECK-NEXT: Symbols: []

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

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --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-elfabi/binary-read-no-dt-strtab.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --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-elfabi/binary-read-no-dynamic.test

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --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-elfabi/binary-read-replace-soname.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s --check-prefix=ORIGINAL
-# RUN: llvm-elfabi --elf %t --emit-tbe=- --soname=libbest.so | FileCheck %s --check-prefix=REPLACED
+# 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
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

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

 # RUN: yaml2obj %s -o %t
-# RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --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-elfabi/binary-read-soname.test

 # RUN: yaml2obj %s -o %t
-# RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --output=- %t | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
- Type:     PT_LOAD
     FirstSec: .dynstr
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     Flags:    [ PF_X, PF_R ]
     VAddr:    0x1018
     FirstSec: .dynamic
     LastSec:  .dynamic
 
-# CHECK:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: SoName: somelib.so{{$}}
-# CHECK-NEXT: Arch: x86_64
-# CHECK-NEXT: Symbols: {}
+# CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
+# CHECK-NEXT: Symbols: []
 # CHECK-NEXT: ...

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

-# RUN: llvm-elfabi --elf %p/Inputs/gnu_hash.so --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --output=- %p/Inputs/gnu_hash.so | FileCheck %s
 
-# CHECK:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion:      1.0
 # CHECK-NEXT: SoName:          libsomething.so
-# CHECK-NEXT: Arch:            x86_64
+# 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:   AGlobalInteger:  { Type: Object, Size: 4 }
-# CHECK-NEXT:   AThreadLocalLongInteger: { Type: TLS, Size: 8 }
-# CHECK-NEXT:   _ITM_deregisterTMCloneTable: { Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   _ITM_registerTMCloneTable: { Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   _Z11rotateArrayPii: { Type: Func }
-# CHECK-NEXT:   __cxa_finalize:  { Type: Func, Undefined: true, Weak: true }
-# CHECK-NEXT:   __gmon_start__:  { Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   __tls_get_addr:  { Type: Func, Undefined: true }
-# CHECK-NEXT:   _fini:           { Type: Func }
-# CHECK-NEXT:   _init:           { Type: Func }
+# CHECK-NEXT:   - { Name: __gmon_start__, Type: NoType, Undefined: true, Weak: true }
+# 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: __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: ...

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

-# RUN: llvm-elfabi --elf %p/Inputs/sysv_hash.so --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --output=- %p/Inputs/sysv_hash.so | FileCheck %s
 
-# CHECK:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion:      1.0
 # CHECK-NEXT: SoName:          libsomething.so
-# CHECK-NEXT: Arch:            x86_64
+# 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:   AGlobalInteger:  { Type: Object, Size: 4 }
-# CHECK-NEXT:   AThreadLocalLongInteger: { Type: TLS, Size: 8 }
-# CHECK-NEXT:   _ITM_deregisterTMCloneTable: { Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   _ITM_registerTMCloneTable: { Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   _Z11rotateArrayPii: { Type: Func }
-# CHECK-NEXT:   __cxa_finalize:  { Type: Func, Undefined: true, Weak: true }
-# CHECK-NEXT:   __gmon_start__:  { Type: NoType, Undefined: true, Weak: true }
-# CHECK-NEXT:   __tls_get_addr:  { Type: Func, Undefined: true }
-# CHECK-NEXT:   _fini:           { Type: Func }
-# CHECK-NEXT:   _init:           { Type: Func }
+# 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: _Z11rotateArrayPii, Type: Func }
+# CHECK-NEXT:   - { Name: __tls_get_addr, Type: Func, Undefined: true }
 # CHECK-NEXT: ...

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

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

llvm/test/tools/llvm-elfabi/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 %s --output-target=elf64-little %t.TestFile 2>&1 | FileCheck -DMSG=%errc_EACCES %s --check-prefix=ERR
+# RUN: not llvm-elfabi --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
 
---- !tapi-tbe
+--- !ifs-v1
 TbeVersion: 1.0
-Arch: AArch64
-Symbols: {}
+Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
+Symbols: []
 ...
 
 # ERR: error: [[MSG]]

llvm/test/tools/llvm-elfabi/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 %s --output-target=elf64-little %t.TestDir/Output.TestFile 2>&1 | FileCheck -DMSG=%errc_EACCES %s --check-prefix=ERR
+# RUN: not llvm-elfabi --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
 
---- !tapi-tbe
+--- !ifs-v1
 TbeVersion: 1.0
-Arch: AArch64
-Symbols: {}
+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-elfabi/output-target-error.test

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

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

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

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

 ## Test writing unchanged content to TBE file with --write-if-changed flag.
 
-# RUN: llvm-elfabi --elf %p/Inputs/gnu_hash.so --emit-tbe=%t
+# 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 --elf %p/Inputs/gnu_hash.so --emit-tbe=%t --write-if-changed
+# 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/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.
 # RUN: yaml2obj %s -o %tfull -DGNUHASHVALUE="[0x9]" -DTAG1="DT_GNU_HASH" -DVAL1="0xC00"
-# RUN: llvm-elfabi --elf %tfull --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --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.
 # RUN: yaml2obj %s -o %tfull -DGNUHASHVALUE="[0x9]" -DTAG1="DT_GNU_HASH" -DVAL1="0xC00" -DENTSIZE="0x19"
-# RUN: not llvm-elfabi --elf %tfull --emit-tbe=- 2>&1 | FileCheck %s --check-prefix=BADENTSIZE
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --output=- %tfull 2>&1 | FileCheck %s --check-prefix=BADENTSIZE
 
 ## Test if llvm-elfabi 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 --elf %tw.gnu.hash --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --input-format=ELF --output-format=TBE --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.
 # RUN: yaml2obj %s -o %tw.gnu.hash -DGNUHASHVALUE="[0x8, 0xA]" -DTAG1="DT_GNU_HASH" -DVAL1="0xC00" -DNOHEADER="true"
-# RUN: not llvm-elfabi --elf %tw.gnu.hash --emit-tbe=- 2>&1 | FileCheck %s --check-prefix=NOTERMINATOR
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --output=- %tw.gnu.hash  2>&1 | FileCheck %s --check-prefix=NOTERMINATOR
 
-# CHECK:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion:      1.0
-# CHECK-NEXT: Arch:            AArch64
+# CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: Symbols:
-# CHECK-NEXT:  bar:             { Type: Object, Size: 0, Undefined: true }
-# CHECK-NEXT:  foo:             { Type: Func, Undefined: true }
+# CHECK-NEXT:   - { Name: foo, Type: Func, Undefined: true }
+# CHECK-NEXT:   - { Name: bar, Type: Object, Size: 0, 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-elfabi/read-tbe-as-elf.test

-# RUN: not llvm-elfabi --elf %s --emit-tbe=%t  2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --input-format=ELF --output-format=TBE --output=%t %s 2>&1 | FileCheck %s
 
---- !tapi-tbe
+--- !ifs-v1
 SoName: somelib.so
 TbeVersion: 1.0
-Arch: x86_64
+Target: { ObjectFormat: ELF, Arch: AArch64, Endianness: little, BitWidth: 64 }
 Symbols:
-  foo: { Type: Func }
-  bar: { Type: Object, Size: 42 }
-  baz: { Type: Object, Size: 8 }
-  not: { Type: Object, Undefined: true, Size: 128 }
-  nor: { Type: Func, Undefined: true }
+  - { 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-elfabi/read-tbe-as-tbe.test

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

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

-# RUN: not llvm-elfabi %s --emit-tbe=%t 2>&1 | FileCheck %s
+# RUN: not llvm-elfabi --output-format=TBE --output=- %s 2>&1| FileCheck %s
 
 This is just some text that cannot be read by llvm-elfabi.
 
 # 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-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-elfabi/tbe-emits-current-version.test

-# RUN: llvm-elfabi %s --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --output-format=TBE --output=- %s | FileCheck %s
 
---- !tapi-tbe
+--- !ifs-v1
 TbeVersion: 1.0
-Arch: AArch64
-Symbols: {}
+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:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion: 1.0

llvm/test/tools/llvm-elfabi/tbe-read-basic.test

-# RUN: llvm-elfabi %s --emit-tbe=- | FileCheck %s
+# RUN: llvm-elfabi --output-format=TBE --output=- %s | FileCheck %s
 
---- !tapi-tbe
+--- !ifs-v1
 SoName: somelib.so
 TbeVersion: 1.0
-Arch: x86_64
+Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 Symbols:
-  foo: { Type: Func }
-  bar: { Type: Object, Size: 42 }
-  baz: { Type: Object, Size: 8 }
-  not: { Type: Object, Undefined: true, Size: 128 }
-  nor: { Type: Func, Undefined: true }
+  - { 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:      --- !tapi-tbe
+# CHECK:      --- !ifs-v1
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: SoName: somelib.so
-# CHECK-NEXT: Arch: x86_64
+# CHECK-NEXT: Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 # CHECK-NEXT: Symbols:
-# CHECK-NEXT:   bar: { Type: Object, Size: 42 }
-# CHECK-NEXT:   baz: { Type: Object, Size: 8 }
-# CHECK-NEXT:   foo: { Type: Func }
-# CHECK-NEXT:   nor: { Type: Func, Undefined: true }
-# CHECK-NEXT:   not: { Type: Object, Size: 128, Undefined: true }
+# 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: nor, Type: Func, Undefined: true }
 # CHECK-NEXT: ...

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

 ## Test writing stub elf when symbol table contains no non-local symbol.
 
-# RUN: llvm-elfabi %s --output-target=elf64-little %t
+# RUN: llvm-elfabi --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
 
---- !tapi-tbe
+--- !ifs-v1
 TbeVersion: 1.0
-Arch: x86_64
+Target: { ObjectFormat: ELF, Arch: x86_64, Endianness: little, BitWidth: 64 }
 NeededLibs:
   - libc.so.6
-Symbols: {}
+Symbols: []
 ...
 
 # CHECK:      Section {
 # CHECK-NEXT:   Index: 0
 # CHECK-NEXT:   Name:  (0)
 # CHECK-NEXT:   Type: SHT_NULL
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:   ]

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

 ## Test writing stub elf with minimal sections.
 
-# RUN: llvm-elfabi %s --output-target=elf32-little %t.elf32l
+# RUN: llvm-elfabi --output-format=ELF --output=%t --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 %s --output-target=elf32-big %t.elf32b
+# RUN: llvm-elfabi --output-format=ELF --output=%t --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 %s --output-target=elf64-little %t.elf64l
+# RUN: llvm-elfabi --output-format=ELF --output=%t --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 %s --output-target=elf64-big %t.elf64b
+# RUN: llvm-elfabi --output-format=ELF --output=%t --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 --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
 
---- !tapi-tbe
+# 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-elfabi --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-elfabi --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-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
+
+--- !ifs-v1
 TbeVersion: 1.0
-Arch: x86_64
 NeededLibs:
   - libc.so.6
 Symbols:
-  bar: { Type: Object, Size: 42 }
-  baz: { Type: TLS, Size: 3 }
-  plus: { Type: Func }
+  - { Name: bar, Type: Object, Size: 42 }
+  - { Name: baz, Type: TLS, Size: 3 }
+  - { Name: plus, Type: Func }
 ...
 
 # CHECK:      ElfHeader {
 # CHECK-NEXT:   Ident {
 # CHECK-NEXT:     Magic: (7F 45 4C 46)
 # CHECK-NEXT:     Class: [[CLASS]]
 # CHECK-NEXT:     DataEncoding: [[DE]]
 # CHECK-NEXT:     FileVersion: 1

 # CHECK-NEXT: [     a] bar
 # CHECK-NEXT: [     e] libc.so.6
 
 # CHECK:      String dump of section '.shstrtab':
 # 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/llvm-elfabi.cpp

 
 } // end namespace elfabi
 } // end namespace llvm
 
 using namespace llvm;
 using namespace llvm::elfabi;
 
 // Command line flags:
-cl::opt<FileFormat> InputFileFormat(
-    cl::desc("Force input file format:"),
-    cl::values(clEnumValN(FileFormat::TBE, "tbe",
-                          "Read `input` as text-based ELF stub"),
-               clEnumValN(FileFormat::ELF, "elf",
-                          "Read `input` as ELF binary")));
 cl::opt<std::string> InputFilePath(cl::Positional, cl::desc("input"),
                                    cl::Required);
-cl::opt<std::string>
-    EmitTBE("emit-tbe",
-            cl::desc("Emit a text-based ELF stub (.tbe) from the input file"),
-            cl::value_desc("path"));
+cl::opt<FileFormat> InputFormat(
+    "input-format", cl::desc("Specify the input file format"),
+    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(
+    "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(
+    "endianness", cl::desc("Specify the endianness"),
+    cl::values(clEnumValN(ELFEndiannessType::Little, "little", "Little Endian"),
+               clEnumValN(ELFEndiannessType::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<ELFTarget> BinaryOutputTarget(
-    "output-target", cl::desc("Create a binary stub for the specified target"),
-    cl::values(clEnumValN(ELFTarget::ELF32LE, "elf32-little",
-                          "32-bit little-endian ELF stub"),
-               clEnumValN(ELFTarget::ELF32BE, "elf32-big",
-                          "32-bit big-endian ELF stub"),
-               clEnumValN(ELFTarget::ELF64LE, "elf64-little",
-                          "64-bit little-endian ELF stub"),
-               clEnumValN(ELFTarget::ELF64BE, "elf64-big",
-                          "64-bit big-endian ELF stub")));
-cl::opt<std::string> BinaryOutputFilePath(cl::Positional, cl::desc("output"));
+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) {
   // Write TBE to memory first.
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 (InputFileFormat.getNumOccurrences() == 0 ||
-      InputFileFormat == FileFormat::ELF) {
+  if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::ELF) {
     Expected<std::unique_ptr<ELFStub>> StubFromELF =
         readELFFile(FileReadBuffer->getMemBufferRef());
     if (StubFromELF) {
       return std::move(*StubFromELF);
     }
     EC.addError(StubFromELF.takeError(), "BinaryRead");
   }
 
   // Fall back to reading as a tbe.
-  if (InputFileFormat.getNumOccurrences() == 0 ||
-      InputFileFormat == FileFormat::TBE) {
+  if (InputFormat.getNumOccurrences() == 0 || InputFormat == FileFormat::TBE) {
     Expected<std::unique_ptr<ELFStub>> StubFromTBE =
         readTBEFromBuffer(FileReadBuffer->getBuffer());
     if (StubFromTBE) {
       return std::move(*StubFromTBE);
     }
     EC.addError(StubFromTBE.takeError(), "YamlParse");
   }
 

 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);
   if (!StubOrErr)
     fatalError(StubOrErr.takeError());
 
   std::unique_ptr<ELFStub> TargetStub = std::move(StubOrErr.get());
 
   // Change SoName before emitting stubs.
   if (SOName.getNumOccurrences() == 1)
     TargetStub->SoName = SOName;
-
-  if (EmitTBE.getNumOccurrences() == 1) {
+  Optional<ELFArch> OverrideArch;
+  Optional<ELFEndiannessType> OverrideEndianness;
+  Optional<ELFBitWidthType> OverrideBitWidth;
+  Optional<std::string> OverrideTriple;
+  if (OptArch.getNumOccurrences() == 1) {
+    Expected<ELFArch> ArchOrErr = ConvertArchNameToEMachine(OptArch.getValue());
+    if (!ArchOrErr) {
+      fatalError(ArchOrErr.takeError());
+    }
+    OverrideArch = ArchOrErr.get();
+  }
+  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,
+                        OverrideBitWidth, OverrideTriple);
+  if (OverrideError)
+    fatalError(std::move(OverrideError));
+  switch (OutputFormat.getValue()) {
+  case FileFormat::TBE: {
     TargetStub->TbeVersion = TBEVersionCurrent;
-    Error TBEWriteError = writeTBE(EmitTBE, *TargetStub);
+    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);
+      TargetStub->Target.Triple = OptTargetTripleHint.getValue();
+    } else {
+      stripTBETarget(*TargetStub, StripIFSTarget, StripIFSArch,
+                     StripIFSEndiannessWidth, StripIFSBitWidth);
+    }
+    Error TBEWriteError = writeTBE(OutputFilePath.getValue(), *TargetStub);
     if (TBEWriteError)
       fatalError(std::move(TBEWriteError));
+    break;
   }
-
-  // Write out binary ELF stub.
-  if (BinaryOutputFilePath.getNumOccurrences() == 1) {
-    if (BinaryOutputTarget.getNumOccurrences() == 0)
-      fatalError(createStringError(errc::not_supported,
-                                   "no binary output target specified."));
-    Error BinaryWriteError = writeBinaryStub(
-        BinaryOutputFilePath, *TargetStub, BinaryOutputTarget, WriteIfChanged);
+  case FileFormat::ELF: {
+    Error TargetError = validateTBETarget(*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/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 "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/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"
static elfabi::ELFTarget convertIFSStub(const IFSStub &IfsStub,
                                         elfabi::ELFStub &ElfStub) {
   ElfStub.TbeVersion = IfsStub.IfsVersion;
   ElfStub.SoName = IfsStub.SOName;
   // TODO: Support more archs and targets.
   Triple IFSTriple(IfsStub.Triple);
   elfabi::ELFTarget Target = elfabi::ELFTarget::ELF64LE;
   switch (IFSTriple.getArch()) {
   case Triple::ArchType::aarch64:
-    ElfStub.Arch = (elfabi::ELFArch)ELF::EM_AARCH64;
+    ElfStub.Target.Arch = (llvm::elfabi::ELFArch)ELF::EM_AARCH64;
     break;
   case Triple::ArchType::x86_64:
-    ElfStub.Arch = (elfabi::ELFArch)ELF::EM_X86_64;
+    ElfStub.Target.Arch = (llvm::elfabi::ELFArch)ELF::EM_X86_64;
     break;
   default:
-    ElfStub.Arch = (elfabi::ELFArch)ELF::EM_NONE;
+    ElfStub.Target.Arch = (llvm::elfabi::ELFArch)ELF::EM_NONE;
   }
   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.insert(ElfSymbol);
+    ElfStub.Symbols.push_back(ElfSymbol);
   }
   return Target;
 }
 
 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;
-    elfabi::ELFTarget Target = convertIFSStub(Stub, ElfStub);
-    Error BinaryWriteError =
-        elfabi::writeBinaryStub(OutputFilename, ElfStub, Target);
+    convertIFSStub(Stub, ElfStub);
+    Error BinaryWriteError = elfabi::writeBinaryStub(OutputFilename, ElfStub);
     if (BinaryWriteError) {
       return -1;
     }
     return 0;
   }
 
   // Open file for writing.
   std::error_code SysErr;