diff --git a/llvm/include/llvm/InterfaceStub/ELFObjHandler.h b/llvm/include/llvm/InterfaceStub/ELFObjHandler.h
--- a/llvm/include/llvm/InterfaceStub/ELFObjHandler.h
+++ b/llvm/include/llvm/InterfaceStub/ELFObjHandler.h
@@ -23,9 +23,21 @@
 
 namespace elfabi {
 
+enum class ELFTarget { ELF32LE, ELF32BE, ELF64LE, ELF64BE };
+
 /// Attempt to read a binary ELF file from a MemoryBuffer.
 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.
+Error writeBinaryStub(StringRef FilePath, const ELFStub &Stub,
+                      ELFTarget OutputFormat);
+
 } // end namespace elfabi
 } // end namespace llvm
 
diff --git a/llvm/lib/InterfaceStub/ELFObjHandler.cpp b/llvm/lib/InterfaceStub/ELFObjHandler.cpp
--- a/llvm/lib/InterfaceStub/ELFObjHandler.cpp
+++ b/llvm/lib/InterfaceStub/ELFObjHandler.cpp
@@ -8,11 +8,14 @@
 
 #include "llvm/InterfaceStub/ELFObjHandler.h"
 #include "llvm/InterfaceStub/ELFStub.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"
 
 using llvm::MemoryBufferRef;
@@ -38,6 +41,155 @@
   Optional<uint64_t> GnuHash;
 };
 
+/// This initializes an ELF file header with information specific to a binary
+/// dynamic shared object.
+/// Offsets, indexes, links, etc. for section and program headers are just
+/// zero-initialized as they will be updated elsewhere.
+///
+/// @param ElfHeader Target ELFT::Ehdr to populate.
+/// @param Machine Target architecture (e_machine from ELF specifications).
+template <class ELFT>
+void initELFHeader(typename ELFT::Ehdr &ElfHeader, uint16_t Machine) {
+  memset(&ElfHeader, 0, sizeof(ElfHeader));
+  // ELF identification.
+  ElfHeader.e_ident[EI_MAG0] = ElfMagic[EI_MAG0];
+  ElfHeader.e_ident[EI_MAG1] = ElfMagic[EI_MAG1];
+  ElfHeader.e_ident[EI_MAG2] = ElfMagic[EI_MAG2];
+  ElfHeader.e_ident[EI_MAG3] = ElfMagic[EI_MAG3];
+  ElfHeader.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
+  bool IsLittleEndian = ELFT::TargetEndianness == support::little;
+  ElfHeader.e_ident[EI_DATA] = IsLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
+  ElfHeader.e_ident[EI_VERSION] = EV_CURRENT;
+  ElfHeader.e_ident[EI_OSABI] = ELFOSABI_NONE;
+
+  // Remainder of ELF header.
+  ElfHeader.e_type = ET_DYN;
+  ElfHeader.e_machine = Machine;
+  ElfHeader.e_version = EV_CURRENT;
+  ElfHeader.e_ehsize = sizeof(typename ELFT::Ehdr);
+  ElfHeader.e_phentsize = sizeof(typename ELFT::Phdr);
+  ElfHeader.e_shentsize = sizeof(typename ELFT::Shdr);
+}
+
+template <class ELFT> struct OutputSection {
+  using Elf_Shdr = typename ELFT::Shdr;
+  std::string Name;
+  Elf_Shdr Shdr;
+  uint64_t Addr;
+  uint64_t Offset;
+  uint64_t Size;
+  uint64_t Align;
+  uint32_t Index;
+  bool NoBits = true;
+};
+
+template <class T, class ELFT>
+struct ContentSection : public OutputSection<ELFT> {
+  T Content;
+  ContentSection() { this->NoBits = false; }
+};
+
+// This class just wraps StringTableBuilder for the purpose of adding a
+// default constructor.
+class ELFStringTableBuilder : public StringTableBuilder {
+public:
+  ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {}
+};
+
+template <class ELFT> class ELFStubBuilder {
+public:
+  using Elf_Ehdr = typename ELFT::Ehdr;
+  using Elf_Shdr = typename ELFT::Shdr;
+  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) {
+    // Populate string tables.
+    ShStrTab.Name = ".shstrtab";
+    ShStrTab.Align = 1;
+    DynStr.Name = ".dynstr";
+    DynStr.Align = 1;
+    for (const ELFSymbol &Sym : Stub.Symbols)
+      DynStr.Content.add(Sym.Name);
+
+    std::vector<OutputSection<ELFT> *> Sections = {&DynStr, &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();
+    // Calculate sections' addresses and offsets.
+    uint64_t CurrentOffset = sizeof(Elf_Ehdr);
+    for (OutputSection<ELFT> *Sec : Sections) {
+      Sec->Offset = alignTo(CurrentOffset, Sec->Align);
+      Sec->Addr = Sec->Offset;
+      CurrentOffset = Sec->Offset + Sec->Size;
+    }
+    // Write section headers of string tables.
+    fillStrTabShdr(DynStr, SHF_ALLOC);
+    fillStrTabShdr(ShStrTab);
+    // Finish initilize ELFheader
+    initELFHeader<ELFT>(ElfHeader, Stub.Arch);
+    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);
+  }
+
+  void write(uint8_t *Data) const {
+    write(Data, ElfHeader);
+    DynStr.Content.write(Data + DynStr.Shdr.sh_offset);
+    ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset);
+    writeShdr(Data, DynStr);
+    writeShdr(Data, ShStrTab);
+  }
+
+private:
+  Elf_Ehdr ElfHeader;
+  ContentSection<ELFStringTableBuilder, ELFT> DynStr;
+  ContentSection<ELFStringTableBuilder, ELFT> ShStrTab;
+
+  template <class T> static void write(uint8_t *Data, const T &Value) {
+    *reinterpret_cast<T *>(Data) = Value;
+  }
+
+  void fillStrTabShdr(ContentSection<ELFStringTableBuilder, ELFT> &StrTab,
+                      uint32_t ShFlags = 0) const {
+    StrTab.Shdr.sh_type = SHT_STRTAB;
+    StrTab.Shdr.sh_flags = ShFlags;
+    StrTab.Shdr.sh_addr = StrTab.Addr;
+    StrTab.Shdr.sh_offset = StrTab.Offset;
+    StrTab.Shdr.sh_info = 0;
+    StrTab.Shdr.sh_size = StrTab.Size;
+    StrTab.Shdr.sh_name = ShStrTab.Content.getOffset(StrTab.Name);
+    StrTab.Shdr.sh_addralign = StrTab.Align;
+    StrTab.Shdr.sh_entsize = 0;
+    StrTab.Shdr.sh_link = 0;
+  }
+
+  uint64_t shdrOffset(const OutputSection<ELFT> &Sec) const {
+    return ElfHeader.e_shoff + Sec.Index * sizeof(Elf_Shdr);
+  }
+
+  void writeShdr(uint8_t *Data, const OutputSection<ELFT> &Sec) const {
+    write(Data + shdrOffset(Sec), Sec.Shdr);
+  }
+};
 /// This function behaves similarly to StringRef::substr(), but attempts to
 /// terminate the returned StringRef at the first null terminator. If no null
 /// terminator is found, an error is returned.
@@ -364,6 +516,32 @@
   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.
+template <class ELFT>
+Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub) {
+  ELFStubBuilder<ELFT> Builder{Stub};
+  Expected<std::unique_ptr<FileOutputBuffer>> BufOrError =
+      FileOutputBuffer::create(FilePath, Builder.getSize());
+  if (!BufOrError)
+    return createStringError(errc::invalid_argument,
+                             toString(BufOrError.takeError()) +
+                                 " when trying to open `" + FilePath +
+                                 "` for writing");
+
+  // Write binary to file.
+  std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufOrError);
+  Builder.write(Buf->getBufferStart());
+
+  if (Error E = Buf->commit())
+    return E;
+
+  return Error::success();
+}
+
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
   Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buf);
   if (!BinOrErr) {
@@ -380,9 +558,23 @@
   } 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,
+                      ELFTarget OutputFormat) {
+  if (OutputFormat == ELFTarget::ELF32LE)
+    return writeELFBinaryToFile<ELF32LE>(FilePath, Stub);
+  if (OutputFormat == ELFTarget::ELF32BE)
+    return writeELFBinaryToFile<ELF32BE>(FilePath, Stub);
+  if (OutputFormat == ELFTarget::ELF64LE)
+    return writeELFBinaryToFile<ELF64LE>(FilePath, Stub);
+  if (OutputFormat == ELFTarget::ELF64BE)
+    return writeELFBinaryToFile<ELF64BE>(FilePath, Stub);
+  llvm_unreachable("invalid binary output target");
+}
+
 } // end namespace elfabi
 } // end namespace llvm
diff --git a/llvm/test/tools/llvm-elfabi/fail-file-write.test b/llvm/test/tools/llvm-elfabi/fail-file-write.test
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/llvm-elfabi/fail-file-write.test
@@ -0,0 +1,17 @@
+## Test failing to write output file.
+
+# 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 %s --check-prefix=ERR
+# RUN: chmod 777 %t.TestDir
+# RUN: rm -rf %t.TestDir
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: AArch64
+Symbols: {}
+...
+
+# ERR: Permission denied when trying to open `{{.*}}.TestDir/Output.TestFile` for writing
diff --git a/llvm/test/tools/llvm-elfabi/missing-or-invalid-output-target.test b/llvm/test/tools/llvm-elfabi/missing-or-invalid-output-target.test
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/llvm-elfabi/missing-or-invalid-output-target.test
@@ -0,0 +1,13 @@
+# 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
+
+--- !tapi-tbe
+SoName: somelib.so
+TbeVersion: 1.0
+Arch: x86_64
+Symbols: {}
+...
+
+# MISSING: error: no binary output target specified.
+
+# INVALID: llvm-elfabi: for the --output-target option: Cannot find option named 'nope'!
\ No newline at end of file
diff --git a/llvm/test/tools/llvm-elfabi/write-elf32be-stub.test b/llvm/test/tools/llvm-elfabi/write-elf32be-stub.test
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/llvm-elfabi/write-elf32be-stub.test
@@ -0,0 +1,89 @@
+# Test writing 32bit big endinan stub elf with minimal sections.
+
+# RUN: llvm-elfabi %s --output-target=elf32-big %t
+# RUN: llvm-readobj -h %t | FileCheck %s --check-prefix=ELFHEADER
+# RUN: llvm-readobj -S %t | FileCheck %s --check-prefix=SECTIONS
+# RUN: llvm-readobj --string-dump .shstrtab %t | FileCheck %s --check-prefix=SHSTRTAB
+# RUN: llvm-readobj --string-dump .dynstr %t | FileCheck %s --check-prefix=DYNSTR
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+Symbols:
+  bar: { Type: Object, Size: 42 }
+  baz: { Type: TLS, Size: 3 }
+...
+
+# ELFHEADER:      ElfHeader {
+# ELFHEADER-NEXT:   Ident {
+# ELFHEADER-NEXT:     Magic: (7F 45 4C 46)
+# ELFHEADER-NEXT:     Class: 32-bit (0x1)
+# ELFHEADER-NEXT:     DataEncoding: BigEndian (0x2)
+# ELFHEADER-NEXT:     FileVersion: 1
+# ELFHEADER-NEXT:     OS/ABI: SystemV (0x0)
+# ELFHEADER-NEXT:     ABIVersion: 0
+# ELFHEADER-NEXT:     Unused: (00 00 00 00 00 00 00)
+# ELFHEADER-NEXT:   }
+# ELFHEADER-NEXT:   Type: SharedObject (0x3)
+# ELFHEADER-NEXT:   Machine: EM_X86_64 (0x3E)
+# ELFHEADER-NEXT:   Version: 1
+# ELFHEADER-NEXT:   Entry: 0x0
+# ELFHEADER:        Flags [ (0x0)
+# ELFHEADER-NEXT:   ]
+# ELFHEADER-NEXT:   HeaderSize: 52
+# ELFHEADER-NEXT:   ProgramHeaderEntrySize: 32
+# ELFHEADER:        SectionHeaderEntrySize: 40
+# ELFHEADER:        SectionHeaderCount: 3
+# ELFHEADER:        StringTableSectionIndex: 2
+
+# SECTIONS:      Section {
+# SECTIONS-NEXT:   Index: 0
+# SECTIONS-NEXT:   Name:  (0)
+# SECTIONS-NEXT:   Type: SHT_NULL
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address: 0x0
+# SECTIONS-NEXT:   Offset: 0x0
+# SECTIONS-NEXT:   Size: 0
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 0
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 1
+# SECTIONS-NEXT:   Name: .dynstr
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:     SHF_ALLOC
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 2
+# SECTIONS-NEXT:   Name: .shstrtab
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+
+# SHSTRTAB:      String dump of section '.shstrtab':
+# SHSTRTAB-NEXT: [     1] .dynstr
+# SHSTRTAB-NEXT: [     9] .shstrtab
+
+# DYNSTR:      String dump of section '.dynstr':
+# DYNSTR-NEXT: [     1] baz
+# DYNSTR-NEXT: [     5] bar
diff --git a/llvm/test/tools/llvm-elfabi/write-elf32le-stub.test b/llvm/test/tools/llvm-elfabi/write-elf32le-stub.test
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/llvm-elfabi/write-elf32le-stub.test
@@ -0,0 +1,89 @@
+# Test writing 32bit little endinan stub elf with minimal sections.
+
+# RUN: llvm-elfabi %s --output-target=elf32-little %t
+# RUN: llvm-readobj -h %t | FileCheck %s --check-prefix=ELFHEADER
+# RUN: llvm-readobj -S %t | FileCheck %s --check-prefix=SECTIONS
+# RUN: llvm-readobj --string-dump .shstrtab %t | FileCheck %s --check-prefix=SHSTRTAB
+# RUN: llvm-readobj --string-dump .dynstr %t | FileCheck %s --check-prefix=DYNSTR
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+Symbols:
+  bar: { Type: Object, Size: 42 }
+  baz: { Type: TLS, Size: 3 }
+...
+
+# ELFHEADER:      ElfHeader {
+# ELFHEADER-NEXT:   Ident {
+# ELFHEADER-NEXT:     Magic: (7F 45 4C 46)
+# ELFHEADER-NEXT:     Class: 32-bit (0x1)
+# ELFHEADER-NEXT:     DataEncoding: LittleEndian (0x1)
+# ELFHEADER-NEXT:     FileVersion: 1
+# ELFHEADER-NEXT:     OS/ABI: SystemV (0x0)
+# ELFHEADER-NEXT:     ABIVersion: 0
+# ELFHEADER-NEXT:     Unused: (00 00 00 00 00 00 00)
+# ELFHEADER-NEXT:   }
+# ELFHEADER-NEXT:   Type: SharedObject (0x3)
+# ELFHEADER-NEXT:   Machine: EM_X86_64 (0x3E)
+# ELFHEADER-NEXT:   Version: 1
+# ELFHEADER-NEXT:   Entry: 0x0
+# ELFHEADER:        Flags [ (0x0)
+# ELFHEADER-NEXT:   ]
+# ELFHEADER-NEXT:   HeaderSize: 52
+# ELFHEADER-NEXT:   ProgramHeaderEntrySize: 32
+# ELFHEADER:        SectionHeaderEntrySize: 40
+# ELFHEADER:        SectionHeaderCount: 3
+# ELFHEADER:        StringTableSectionIndex: 2
+
+# SECTIONS:      Section {
+# SECTIONS-NEXT:   Index: 0
+# SECTIONS-NEXT:   Name:  (0)
+# SECTIONS-NEXT:   Type: SHT_NULL
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address: 0x0
+# SECTIONS-NEXT:   Offset: 0x0
+# SECTIONS-NEXT:   Size: 0
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 0
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 1
+# SECTIONS-NEXT:   Name: .dynstr
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:     SHF_ALLOC
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 2
+# SECTIONS-NEXT:   Name: .shstrtab
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+
+# SHSTRTAB:      String dump of section '.shstrtab':
+# SHSTRTAB-NEXT: [     1] .dynstr
+# SHSTRTAB-NEXT: [     9] .shstrtab
+
+# DYNSTR:      String dump of section '.dynstr':
+# DYNSTR-NEXT: [     1] baz
+# DYNSTR-NEXT: [     5] bar
diff --git a/llvm/test/tools/llvm-elfabi/write-elf64be-stub.test b/llvm/test/tools/llvm-elfabi/write-elf64be-stub.test
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/llvm-elfabi/write-elf64be-stub.test
@@ -0,0 +1,89 @@
+# Test writing 64bit big endinan stub elf with minimal sections.
+
+# RUN: llvm-elfabi %s --output-target=elf64-big %t
+# RUN: llvm-readobj -h %t | FileCheck %s --check-prefix=ELFHEADER
+# RUN: llvm-readobj -S %t | FileCheck %s --check-prefix=SECTIONS
+# RUN: llvm-readobj --string-dump .shstrtab %t | FileCheck %s --check-prefix=SHSTRTAB
+# RUN: llvm-readobj --string-dump .dynstr %t | FileCheck %s --check-prefix=DYNSTR
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+Symbols:
+  bar: { Type: Object, Size: 42 }
+  baz: { Type: TLS, Size: 3 }
+...
+
+# ELFHEADER:      ElfHeader {
+# ELFHEADER-NEXT:   Ident {
+# ELFHEADER-NEXT:     Magic: (7F 45 4C 46)
+# ELFHEADER-NEXT:     Class: 64-bit (0x2)
+# ELFHEADER-NEXT:     DataEncoding: BigEndian (0x2)
+# ELFHEADER-NEXT:     FileVersion: 1
+# ELFHEADER-NEXT:     OS/ABI: SystemV (0x0)
+# ELFHEADER-NEXT:     ABIVersion: 0
+# ELFHEADER-NEXT:     Unused: (00 00 00 00 00 00 00)
+# ELFHEADER-NEXT:   }
+# ELFHEADER-NEXT:   Type: SharedObject (0x3)
+# ELFHEADER-NEXT:   Machine: EM_X86_64 (0x3E)
+# ELFHEADER-NEXT:   Version: 1
+# ELFHEADER-NEXT:   Entry: 0x0
+# ELFHEADER:        Flags [ (0x0)
+# ELFHEADER-NEXT:   ]
+# ELFHEADER-NEXT:   HeaderSize: 64
+# ELFHEADER-NEXT:   ProgramHeaderEntrySize: 56
+# ELFHEADER:        SectionHeaderEntrySize: 64
+# ELFHEADER:        SectionHeaderCount: 3
+# ELFHEADER:        StringTableSectionIndex: 2
+
+# SECTIONS:      Section {
+# SECTIONS-NEXT:   Index: 0
+# SECTIONS-NEXT:   Name:  (0)
+# SECTIONS-NEXT:   Type: SHT_NULL
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address: 0x0
+# SECTIONS-NEXT:   Offset: 0x0
+# SECTIONS-NEXT:   Size: 0
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 0
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 1
+# SECTIONS-NEXT:   Name: .dynstr
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:     SHF_ALLOC
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 2
+# SECTIONS-NEXT:   Name: .shstrtab
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+
+# SHSTRTAB:      String dump of section '.shstrtab':
+# SHSTRTAB-NEXT: [     1] .dynstr
+# SHSTRTAB-NEXT: [     9] .shstrtab
+
+# DYNSTR:      String dump of section '.dynstr':
+# DYNSTR-NEXT: [     1] baz
+# DYNSTR-NEXT: [     5] bar
diff --git a/llvm/test/tools/llvm-elfabi/write-elf64le-stub.test b/llvm/test/tools/llvm-elfabi/write-elf64le-stub.test
new file mode 100644
--- /dev/null
+++ b/llvm/test/tools/llvm-elfabi/write-elf64le-stub.test
@@ -0,0 +1,89 @@
+# Test writing 64bit little endinan stub elf with minimal sections.
+
+# RUN: llvm-elfabi %s --output-target=elf64-little %t
+# RUN: llvm-readobj -h %t | FileCheck %s --check-prefix=ELFHEADER
+# RUN: llvm-readobj -S %t | FileCheck %s --check-prefix=SECTIONS
+# RUN: llvm-readobj --string-dump .shstrtab %t | FileCheck %s --check-prefix=SHSTRTAB
+# RUN: llvm-readobj --string-dump .dynstr %t | FileCheck %s --check-prefix=DYNSTR
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+Symbols:
+  bar: { Type: Object, Size: 42 }
+  baz: { Type: TLS, Size: 3 }
+...
+
+# ELFHEADER:      ElfHeader {
+# ELFHEADER-NEXT:   Ident {
+# ELFHEADER-NEXT:     Magic: (7F 45 4C 46)
+# ELFHEADER-NEXT:     Class: 64-bit (0x2)
+# ELFHEADER-NEXT:     DataEncoding: LittleEndian (0x1)
+# ELFHEADER-NEXT:     FileVersion: 1
+# ELFHEADER-NEXT:     OS/ABI: SystemV (0x0)
+# ELFHEADER-NEXT:     ABIVersion: 0
+# ELFHEADER-NEXT:     Unused: (00 00 00 00 00 00 00)
+# ELFHEADER-NEXT:   }
+# ELFHEADER-NEXT:   Type: SharedObject (0x3)
+# ELFHEADER-NEXT:   Machine: EM_X86_64 (0x3E)
+# ELFHEADER-NEXT:   Version: 1
+# ELFHEADER-NEXT:   Entry: 0x0
+# ELFHEADER:        Flags [ (0x0)
+# ELFHEADER-NEXT:   ]
+# ELFHEADER-NEXT:   HeaderSize: 64
+# ELFHEADER-NEXT:   ProgramHeaderEntrySize: 56
+# ELFHEADER:        SectionHeaderEntrySize: 64
+# ELFHEADER:        SectionHeaderCount: 3
+# ELFHEADER:        StringTableSectionIndex: 2
+
+# SECTIONS:      Section {
+# SECTIONS-NEXT:   Index: 0
+# SECTIONS-NEXT:   Name:  (0)
+# SECTIONS-NEXT:   Type: SHT_NULL
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address: 0x0
+# SECTIONS-NEXT:   Offset: 0x0
+# SECTIONS-NEXT:   Size: 0
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 0
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 1
+# SECTIONS-NEXT:   Name: .dynstr
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:     SHF_ALLOC
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+# SECTIONS-NEXT: Section {
+# SECTIONS-NEXT:   Index: 2
+# SECTIONS-NEXT:   Name: .shstrtab
+# SECTIONS-NEXT:   Type: SHT_STRTAB
+# SECTIONS-NEXT:   Flags [
+# SECTIONS-NEXT:   ]
+# SECTIONS-NEXT:   Address:
+# SECTIONS-NEXT:   Offset:
+# SECTIONS-NEXT:   Size:
+# SECTIONS-NEXT:   Link: 0
+# SECTIONS-NEXT:   Info: 0
+# SECTIONS-NEXT:   AddressAlignment: 1
+# SECTIONS-NEXT:   EntrySize: 0
+# SECTIONS-NEXT: }
+
+# SHSTRTAB:      String dump of section '.shstrtab':
+# SHSTRTAB-NEXT: [     1] .dynstr
+# SHSTRTAB-NEXT: [     9] .shstrtab
+
+# DYNSTR:      String dump of section '.dynstr':
+# DYNSTR-NEXT: [     1] baz
+# DYNSTR-NEXT: [     5] bar
diff --git a/llvm/tools/llvm-elfabi/llvm-elfabi.cpp b/llvm/tools/llvm-elfabi/llvm-elfabi.cpp
--- a/llvm/tools/llvm-elfabi/llvm-elfabi.cpp
+++ b/llvm/tools/llvm-elfabi/llvm-elfabi.cpp
@@ -46,6 +46,17 @@
     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"));
 
 /// writeTBE() writes a Text-Based ELF stub to a file using the latest version
 /// of the YAML parser.
@@ -111,29 +122,44 @@
   return EC.makeError();
 }
 
+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) {
-    Error ReadError = StubOrErr.takeError();
-    WithColor::error() << ReadError << "\n";
-    exit(1);
+    fatalError(StubOrErr.takeError());
   }
 
   std::unique_ptr<ELFStub> TargetStub = std::move(StubOrErr.get());
 
-  // Write out .tbe file.
+  // Change SoName before emitting stubs.
+  if (SOName.getNumOccurrences() == 1)
+    TargetStub->SoName = SOName;
+
   if (EmitTBE.getNumOccurrences() == 1) {
     TargetStub->TbeVersion = TBEVersionCurrent;
-    if (SOName.getNumOccurrences() == 1) {
-      TargetStub->SoName = SOName;
-    }
     Error TBEWriteError = writeTBE(EmitTBE, *TargetStub);
     if (TBEWriteError) {
-      WithColor::error() << TBEWriteError << "\n";
-      exit(1);
+      fatalError(std::move(TBEWriteError));
+    }
+  }
+
+  // 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);
+    if (BinaryWriteError) {
+      fatalError(std::move(BinaryWriteError));
     }
   }
 }