[elfabi] Add support for writing ELF header for binary stubs

[jakehehrlich]

Summary

This change introduces the beginnings of ELF binary stub write support for elfabi. Specifying an output file path as well as --output-target=<target> will write a binary ELF stub to the specified output file path. For this patch, only the ELF file header is written to the file.

[jakehehrlich]

The structure looks most good but I've got a lot of little requests.

llvm/test/tools/llvm-elfabi/invalid-bin-target.test

8

There's no need to have these extra symbols here.

llvm/test/tools/llvm-elfabi/missing-bin-target.test

8

ditto.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

558

Not sure I like this interface but if you do want todo something like this 1) use uint8_t instead of 'char' and 2) MutableArrayRef wraps the pointer and size for you so you don't have to carry them around while still allowing you to modify the contents as you need to.

560

Calling getBinarySize twice since the user already has to call it isn't ideal. Also if you want this check it seems like an assertion would be better. Also if you just return a Buffer from here rather than telling the user how big of a buffer to construct (though you force them to use a specific kind of buffer) then you can avoid the check all together.

574

I think using this technique is most justified by larger code (like what you'll have later) so I'm cool keeping these but at this size it feels like it could just all go in a header.

llvm/tools/llvm-elfabi/ELFObjHandler.h

42

Seems like this can be inlined.

63

The whole 'Writer' thing is supposed to allow for a base class to exist so you don't have to know what Writer you're using, but nothing like that is happening here. If we're not doing anything like that do you think we could just make these all functions?

65

This can be private or if you turn these into functions, you can make them static in the defining object.

69–81

Seems like you might be able to simplify this to just return a buffer of some kind.

89

This can be private.

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

93

Use uint8_t instead of char for raw binary data. llvm doesn't even use full C++11 but in C++17 we'll use std::byte

109

I think it would be nicer if this took the output format as a parameter.

117

Use == and don't construct a StringRef.

[ruiu]

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

552–553

0x00 and 0u are all just 0, so I'd just write "0". Sign-extending 0 yields just 0, so "u" is redundant.

llvm/tools/llvm-elfabi/ELFObjHandler.h

63

I agree with Jake that because this can be done with functions it's probably better to do this using functions without a class. In addition to that, it looks like a "Impl" class that doesn't inherit any class a bit weird, because usually an "Impl" class implements an abstract interface of some other class (I'm not suggesting you define an abstract class and an implementation class, but just pointing out that the current name is perhaps not that good.)

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

158–159

It might be discussed before, but what is a value of returning an Error from a function and then print that error & exit from the main function? Propagating an error all the way to the main function makes function signatures more complex (any function that can fail or calls a function that can fail has to have a function signature of ErrorOr<T> instead of just T). If this is just a command, then maybe just printing out an error message and exit is better?

[jakehehrlich]

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

87

Since you have an error and are currently returning an error, that error should incorporate the specific information from this error and not make it more vauge.

158–159

Yeah there's some line where things will only ever go in this code and some line where things would go into an eventual library. It isn't 100% clear where that line is right now. I'm in favor of earing on the side of caution and propagating more than less for the time being.

[amontanez]

This should address most of the comments. All functions except for the single writeBinaryStub() have become static functions, and the class has been removed. I'll be updating D55864 to match these changes as soon as possible.

[jhenderson]

llvm/test/tools/llvm-elfabi/invalid-bin-target.test

11

Super nit: Space between # and CHECK. Same applies to other tests.

llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test

11–13

I believe this information is derived from the ElfHeader, so there's not much point in testing it, since you already test it below when testing the ElfHeader itself.

Same applies to other tests.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

532

"calculates what the size" -> "calculates the size"

580

You should probably set the e_shentsize and e_phentsize fields too, since those are constant.

609

Same comment as above. It seems weird for Stub to be a non-const reference.

621

Add a blank line here.

625–626

You can do these two lines in one, and lose the braces too, i.e:

if (Error BinaryWriteError = writeELFBinaryToBuffer<ELFT>(Stub, BufRef))
  return BinaryWriteError;

630–631

Ditto.

llvm/tools/llvm-elfabi/ELFObjHandler.h

38

"begins the process"? Sounds to me like this function should do the whole process, given its name.

43

It seems odd to me that Stub is a non-const reference. I wouldn't expect this function to modify it based on the current description.

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

146

It probably reads easier if there's a new line between each if block.

[amontanez]

Comments addressed.

[jhenderson]

One small comment from me, otherwise looks good from my point of view, assuming the other reviewers are happy.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

582–583

Now that you are doing this, please make sure that it is tested too.

[amontanez]

Updated tests.

[jakehehrlich]

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

538

Calculating the size and writing can be a bit fragile. That said you can't write until you have enough space allocated and because we want to use a FileBuffer and avoid copying, we only want to write once. A trick I've seen used is to think about 'WriteCommands' write commands know the maximum index that they write to and can perform the write themselves. So rather than performing size calculation and writes separately, you construct a list of write commands. From this list you then traverse it to get the maximum index written to, and then traverse it once more to write into the now allocated buffer. This way you don't have parallel code but you avoid reallocating a mapped buffer.

564

Use ELFMAG* instead of each of the actual constants here.

572

It turns out that there are use cases where this can be other things. This is a good default but sometimes the user should have to specify this. @jhenderson has hit this issue in BSD land. I can't seem to find the code for that however. Hopefully James can weigh in.

Either way I don't think its something you need to worry about right now but it was possibly an oversight on our part.

623–624

You can append to an error I believe so that you don't have to consume it.

[jhenderson]

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

572

The issue in llvm-objcopy was that it was copying an existing file and discarding the EI_OSABI and EI_ABIVERSION. Certainly it might be useful in the future to be able to say what the value should be, but as this is not currently required, I think it can be delayed until there's a request for it.

On the other hand, converting a binary into a text file then back into a binary should probably support this at some point.

575

Nit: this should start with a capital letter and end with a full stop.

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

151–152

You might want to consider factoring these out into a single function that takes an Error.

[jakehehrlich]

I'm picking this up. Looking for review on this again. I'm going to drive this to completion enough to use on Fuchsia and then maintain it. After it has the features we want for Fuchsia I'll work on adding features that other people want but at a slower pace (like I did after a while with llvm-objcopy) eventually I'll ramp down but honestly, unlike llvm-objcopy, I could see this tool stabilizing.

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

538

I went ahead and implemented my own advice here. Seems to solve the problem of separating calculation of size and writing of data. The alternative is to have a type that mirrors the format of the stub but contains layout information and then to perform layout and then writing individually like we do in llvm-objcopy.

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

151–152

Do you remember what you meant by this? I'm starting this back up again.

[jhenderson]

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

51

clang-format? (I think it should be const T &Value)

442

out -> Out

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

151–152

The WithColor::error() and exit(1) are repeated in a couple of places. It might be nice if they were a simple function that takes an llvm::Errror and does not return, e.g:

void reportError(Error Err) {
      WithColor::error() << Err << "\n";
      exit(1);
}

although I feel like there might also be other functions available to do the same thing.

[plotfi]

In D55839#1481114, @jakehehrlich wrote:

I'm picking this up. Looking for review on this again. I'm going to drive this to completion enough to use on Fuchsia and then maintain it. After it has the features we want for Fuchsia I'll work on adding features that other people want but at a slower pace (like I did after a while with llvm-objcopy) eventually I'll ramp down but honestly, unlike llvm-objcopy, I could see this tool stabilizing.

@jakehehrlich Is this the diff for adding the binary stubs support we were talking about in D60974 ?

llvm/test/tools/llvm-elfabi/invalid-bin-target.test

+# RUN: not llvm-elfabi %s --output-target=nope %t 2>&1 | FileCheck %s
+
+--- !tapi-tbe
+SoName: somelib.so
+TbeVersion: 1.0
+Arch: x86_64
+Symbols: {}
+...
+
+# CHECK: llvm-elfabi: for the -output-target option: Cannot find option named 'nope'!

llvm/test/tools/llvm-elfabi/missing-bin-target.test

+# RUN: not llvm-elfabi %s %t 2>&1 | FileCheck %s
+
+--- !tapi-tbe
+SoName: somelib.so
+TbeVersion: 1.0
+Arch: x86_64
+Symbols: {}
+...
+
+# CHECK: No binary output target specified.

llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test

+# RUN: llvm-elfabi %s --output-target=elf32-big %t
+# RUN: llvm-readobj --file-headers %t | FileCheck %s
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+Symbols: {}
+...
+
+# CHECK:      ElfHeader {
+# CHECK-NEXT:   Ident {
+# CHECK-NEXT:     Magic: (7F 45 4C 46)
+# CHECK-NEXT:     Class: 32-bit (0x1)
+# CHECK-NEXT:     DataEncoding: BigEndian (0x2)
+# CHECK-NEXT:     FileVersion: 1{{$}}
+# CHECK-NEXT:     OS/ABI: SystemV (0x0)
+# CHECK-NEXT:     ABIVersion: 0{{$}}
+# CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Type: SharedObject (0x3)
+# CHECK-NEXT:   Machine: EM_X86_64 (0x3E)
+# CHECK-NEXT:   Version: 1{{$}}
+# CHECK-NEXT:   Entry: 0x0{{$}}
+# CHECK:        Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   HeaderSize: 52{{$}}
+# CHECK-NEXT:   ProgramHeaderEntrySize: 32{{$}}
+# CHECK:        SectionHeaderEntrySize: 40{{$}}

llvm/test/tools/llvm-elfabi/write-elf32le-ehdr.test

+# RUN: llvm-elfabi %s --output-target=elf32-little %t
+# RUN: llvm-readobj --file-headers %t | FileCheck %s
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+Symbols: {}
+...
+
+# CHECK:      ElfHeader {
+# CHECK-NEXT:   Ident {
+# CHECK-NEXT:     Magic: (7F 45 4C 46)
+# CHECK-NEXT:     Class: 32-bit (0x1)
+# CHECK-NEXT:     DataEncoding: LittleEndian (0x1)
+# CHECK-NEXT:     FileVersion: 1{{$}}
+# CHECK-NEXT:     OS/ABI: SystemV (0x0)
+# CHECK-NEXT:     ABIVersion: 0{{$}}
+# CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Type: SharedObject (0x3)
+# CHECK-NEXT:   Machine: EM_X86_64 (0x3E)
+# CHECK-NEXT:   Version: 1{{$}}
+# CHECK-NEXT:   Entry: 0x0{{$}}
+# CHECK:        Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   HeaderSize: 52{{$}}
+# CHECK-NEXT:   ProgramHeaderEntrySize: 32{{$}}
+# CHECK:        SectionHeaderEntrySize: 40{{$}}

llvm/test/tools/llvm-elfabi/write-elf64be-ehdr.test

+# RUN: llvm-elfabi %s --output-target=elf64-big %t
+# RUN: llvm-readobj --file-headers %t | FileCheck %s
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: x86_64
+Symbols: {}
+...
+
+# CHECK:      ElfHeader {
+# CHECK-NEXT:   Ident {
+# CHECK-NEXT:     Magic: (7F 45 4C 46)
+# CHECK-NEXT:     Class: 64-bit (0x2)
+# CHECK-NEXT:     DataEncoding: BigEndian (0x2)
+# CHECK-NEXT:     FileVersion: 1{{$}}
+# CHECK-NEXT:     OS/ABI: SystemV (0x0)
+# CHECK-NEXT:     ABIVersion: 0{{$}}
+# CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Type: SharedObject (0x3)
+# CHECK-NEXT:   Machine: EM_X86_64 (0x3E)
+# CHECK-NEXT:   Version: 1{{$}}
+# CHECK-NEXT:   Entry: 0x0{{$}}
+# CHECK:        Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   HeaderSize: 64{{$}}
+# CHECK-NEXT:   ProgramHeaderEntrySize: 56{{$}}
+# CHECK:        SectionHeaderEntrySize: 64{{$}}

llvm/test/tools/llvm-elfabi/write-elf64le-ehdr.test

+# RUN: llvm-elfabi %s --output-target=elf64-little %t
+# RUN: llvm-readobj --file-headers %t | FileCheck %s
+
+--- !tapi-tbe
+TbeVersion: 1.0
+Arch: AArch64
+Symbols: {}
+...
+
+# CHECK:      ElfHeader {
+# CHECK-NEXT:   Ident {
+# CHECK-NEXT:     Magic: (7F 45 4C 46)
+# CHECK-NEXT:     Class: 64-bit (0x2)
+# CHECK-NEXT:     DataEncoding: LittleEndian (0x1)
+# CHECK-NEXT:     FileVersion: 1{{$}}
+# CHECK-NEXT:     OS/ABI: SystemV (0x0)
+# CHECK-NEXT:     ABIVersion: 0{{$}}
+# CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Type: SharedObject (0x3)
+# CHECK-NEXT:   Machine: EM_AARCH64 (0xB7)
+# CHECK-NEXT:   Version: 1{{$}}
+# CHECK-NEXT:   Entry: 0x0{{$}}
+# CHECK:        Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   HeaderSize: 64{{$}}
+# CHECK-NEXT:   ProgramHeaderEntrySize: 56{{$}}
+# CHECK:        SectionHeaderEntrySize: 64{{$}}

llvm/tools/llvm-elfabi/ELFObjHandler.h

 #include "llvm/TextAPI/ELF/ELFStub.h"
 
 namespace llvm {
 
 class MemoryBuffer;
 
 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
 
 #endif // LLVM_TOOLS_ELFABI_ELFOBJHANDLER_H

llvm/tools/llvm-elfabi/ELFObjHandler.cpp

 //===- ELFObjHandler.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===-----------------------------------------------------------------------===/
 
 #include "ELFObjHandler.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/MemoryBuffer.h"
 #include "llvm/TextAPI/ELF/ELFStub.h"
 
+#include <functional>
+
 using llvm::MemoryBufferRef;
 using llvm::object::ELFObjectFile;
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
-namespace llvm {
-namespace elfabi {
+namespace {
+
+using namespace llvm::elfabi;
 
 // Simple struct to hold relevant .dynamic entries.
 struct DynamicEntries {
   uint64_t StrTabAddr = 0;
   uint64_t StrSize = 0;
   Optional<uint64_t> SONameOffset;
   std::vector<uint64_t> NeededLibNames;
   // Symbol table:
   uint64_t DynSymAddr = 0;
   // Hash tables:
   Optional<uint64_t> ElfHash;
   Optional<uint64_t> GnuHash;
 };
 
+class CommandWriter {
+private:
+  uint64_t MaxLocation = 0;
+  std::vector<std::function<void(uint8_t *)>> Commands;
+public:
+  template<class T>
+  void add(uint64_t Offset, const T& Value) {
+    MaxLocation = std::max(Offset + sizeof(T), MaxLocation);
+    Commands.emplace_back([Offset, Value](uint8_t *Data) {
+      *reinterpret_cast<T *>(Data + Offset) = Value;
+    });
+  }
+
+  uint64_t size() const {
+    return MaxLocation;
+  }
+
+  void write(uint8_t* Data) {
+    for (const auto &Cmd : Commands)
+      Cmd(Data);
+  }
+};
+
 /// 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.
 ///
 /// @param Str Source string to create a substring from.
 /// @param Offset The start index of the desired substring.
-static Expected<StringRef> terminatedSubstr(StringRef Str, size_t Offset) {
+Expected<StringRef> terminatedSubstr(StringRef Str, size_t Offset) {
   size_t StrEnd = Str.find('\0', Offset);
   if (StrEnd == StringLiteral::npos) {
     return createError(
         "String overran bounds of string table (no null terminator)");
   }
 
   size_t StrLen = StrEnd - Offset;
   return Str.substr(Offset, StrLen);

 
 /// This function populates a DynamicEntries struct using an ELFT::DynRange.
 /// After populating the struct, the members are validated with
 /// some basic sanity checks.
 ///
 /// @param Dyn Target DynamicEntries struct to populate.
 /// @param DynTable Source dynamic table.
 template <class ELFT>
-static Error populateDynamic(DynamicEntries &Dyn,
+Error populateDynamic(DynamicEntries &Dyn,
                              typename ELFT::DynRange DynTable) {
   if (DynTable.empty())
     return createError("No .dynamic section found");
 
   // Search .dynamic for relevant entries.
   bool FoundDynStr = false;
   bool FoundDynStrSz = false;
   bool FoundDynSym = false;
Error populateDynamic(DynamicEntries &Dyn,
 
   return Error::success();
 }
 
 /// This function finds the number of dynamic symbols using a GNU hash table.
 ///
 /// @param Table The GNU hash table for .dynsym.
 template <class ELFT>
-static uint64_t getDynSymtabSize(const typename ELFT::GnuHash &Table) {
+uint64_t getDynSymtabSize(const typename ELFT::GnuHash &Table) {
   using Elf_Word = typename ELFT::Word;
   if (Table.nbuckets == 0)
     return Table.symndx + 1;
   uint64_t LastSymIdx = 0;
   uint64_t BucketVal = 0;
   // Find the index of the first symbol in the last chain.
   for (Elf_Word Val : Table.buckets()) {
     BucketVal = std::max(BucketVal, (uint64_t)Val);

 
 /// This function determines the number of dynamic symbols.
 /// Without access to section headers, the number of symbols must be determined
 /// by parsing dynamic hash tables.
 ///
 /// @param Dyn Entries with the locations of hash tables.
 /// @param ElfFile The ElfFile that the section contents reside in.
 template <class ELFT>
-static Expected<uint64_t> getNumSyms(DynamicEntries &Dyn,
+Expected<uint64_t> getNumSyms(DynamicEntries &Dyn,
                                      const ELFFile<ELFT> &ElfFile) {
   using Elf_Hash = typename ELFT::Hash;
   using Elf_GnuHash = typename ELFT::GnuHash;
   // Search GNU hash table to try to find the upper bound of dynsym.
   if (Dyn.GnuHash.hasValue()) {
     Expected<const uint8_t *> TablePtr = ElfFile.toMappedAddr(*Dyn.GnuHash);
     if (!TablePtr)
       return TablePtr.takeError();

 }
 
 /// This function extracts symbol type from a symbol's st_info member and
 /// maps it to an ELFSymbolType enum.
 /// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
 /// Other symbol types are mapped to ELFSymbolType::Unknown.
 ///
 /// @param Info Binary symbol st_info to extract symbol type from.
-static ELFSymbolType convertInfoToType(uint8_t Info) {
+ELFSymbolType convertInfoToType(uint8_t Info) {
   Info = Info & 0xf;
   switch (Info) {
     case ELF::STT_NOTYPE:
       return ELFSymbolType::NoType;
     case ELF::STT_OBJECT:
       return ELFSymbolType::Object;
     case ELF::STT_FUNC:
       return ELFSymbolType::Func;
     case ELF::STT_TLS:
       return ELFSymbolType::TLS;
     default:
       return ELFSymbolType::Unknown;
   }
 }
 
 /// This function creates an ELFSymbol and populates all members using
 /// information from a binary ELFT::Sym.
 ///
 /// @param SymName The desired name of the ELFSymbol.
 /// @param RawSym ELFT::Sym to extract symbol information from.
 template <class ELFT>
-static ELFSymbol createELFSym(StringRef SymName,
+ELFSymbol createELFSym(StringRef SymName,
                               const typename ELFT::Sym &RawSym) {
   ELFSymbol TargetSym(SymName);
   uint8_t Binding = RawSym.getBinding();
   if (Binding == STB_WEAK)
     TargetSym.Weak = true;
   else
     TargetSym.Weak = false;
 

 
 /// This function populates an ELFStub with symbols using information read
 /// from an ELF binary.
 ///
 /// @param TargetStub ELFStub to add symbols to.
 /// @param DynSym Range of dynamic symbols to add to TargetStub.
 /// @param DynStr StringRef to the dynamic string table.
 template <class ELFT>
-static Error populateSymbols(ELFStub &TargetStub,
+Error populateSymbols(ELFStub &TargetStub,
                             const typename ELFT::SymRange DynSym,
                             StringRef DynStr) {
   // Skips the first symbol since it's the NULL symbol.
   for (auto RawSym : DynSym.drop_front(1)) {
     // If a symbol does not have global or weak binding, ignore it.
     uint8_t Binding = RawSym.getBinding();
     if (!(Binding == STB_GLOBAL || Binding == STB_WEAK))
       continue;
for (auto RawSym : DynSym.drop_front(1)) {
     // 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>
-static Expected<std::unique_ptr<ELFStub>>
+Expected<std::unique_ptr<ELFStub>>
 buildStub(const ELFObjectFile<ELFT> &ElfObj) {
   using Elf_Dyn_Range = typename ELFT::DynRange;
   using Elf_Phdr_Range = typename ELFT::PhdrRange;
   using Elf_Sym_Range = typename ELFT::SymRange;
   using Elf_Sym = typename ELFT::Sym;
   std::unique_ptr<ELFStub> DestStub = make_unique<ELFStub>();
   const ELFFile<ELFT> *ElfFile = ElfObj.getELFFile();
   // Fetch .dynamic table.
if (*SymCount > 0) {
     if (SymReadError)
       return appendToError(std::move(SymReadError),
                            "when reading dynamic symbols");
   }
 
   return std::move(DestStub);
 }
 
+/// 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) {
+  using Elf_Ehdr = typename ELFT::Ehdr;
+  using Elf_Phdr = typename ELFT::Phdr;
+  using Elf_Shdr = typename ELFT::Shdr;
+
+  memset(&ElfHeader, 0, sizeof(Elf_Ehdr));
+  // ELF identification
+  ElfHeader.e_ident[EI_MAG0] = 0x7f; // ELFMAG0
+  ElfHeader.e_ident[EI_MAG1] = 'E';  // ELFMAG1
+  ElfHeader.e_ident[EI_MAG2] = 'L';  // ELFMAG2
+  ElfHeader.e_ident[EI_MAG3] = 'F';  // ELFMAG3
+  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;
+  ElfHeader.e_ident[EI_ABIVERSION] = 0;
+
+  // remainder of ELF header
+  ElfHeader.e_type = ET_DYN;
+  ElfHeader.e_machine = Machine;
+  ElfHeader.e_version = EV_CURRENT;
+  ElfHeader.e_entry = 0;
+  ElfHeader.e_flags = 0;
+  ElfHeader.e_ehsize = sizeof(Elf_Ehdr);
+  ElfHeader.e_phentsize = sizeof(Elf_Phdr);
+  ElfHeader.e_shentsize = sizeof(Elf_Shdr);
+}
+
+/// This function uses an ELFStub to generate a CommandWriter that can be
+/// written to a buffer and will represent a full stub written to disk.
+///
+/// @param FilePath File path for writing the ELF binary.
+/// @param Stub Source ELFStub to generate a binary ELF stub from.
+template <class ELFT>
+CommandWriter makeELFBinaryWriter(const ELFStub &Stub) {
+  using Elf_Ehdr = typename ELFT::Ehdr;
+  CommandWriter out;
+
+  Elf_Ehdr ElfHeader;
+  initELFHeader<ELFT>(ElfHeader, Stub.Arch);
+  out.add(0, ElfHeader);
+  // TODO: Not everyone will want all of these. We should add options that
+  // let us configure which of these are written and which are not. For
+  // instance at a first pass only the section headers, .dynsym, and .dynstr
+  // are all that are needed.
+  // TODO: Write section headers.
+  // TODO: Write program headers.
+  // TODO: Write .dynsym section.
+  // TODO: Write .dynstr section.
+  // TODO: Write .dynamic section.
+  // TODO: Write .shstrtab section.
+  return out;
+}
+
+/// 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) {
+  CommandWriter Writer = makeELFBinaryWriter<ELFT>(Stub);
+  Expected<std::unique_ptr<FileOutputBuffer>> BufOrError =
+      FileOutputBuffer::create(FilePath, Writer.size());
+  if (!BufOrError) {
+    Error FileReadError = BufOrError.takeError();
+    std::string Message;
+    raw_string_ostream Stream(Message);
+    Stream << FileReadError;
+    Stream << " when trying to open `" << FilePath <<"` for writing";
+    consumeError(std::move(FileReadError));
+    return createStringError(errc::invalid_argument, Stream.str().c_str());
+  }
+
+  // Write binary to file.
+  std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufOrError);
+  Writer.write(Buf->getBufferStart());
+
+  if (Error FileWriteError = Buf->commit())
+    return FileWriteError;
+
+  return Error::success();
+}
+
+} // end namespace
+
+namespace llvm {
+namespace elfabi {
+
+// 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);
+  } else if (OutputFormat == ELFTarget::ELF32BE) {
+    return writeELFBinaryToFile<ELF32BE>(FilePath, Stub);
+  } else if (OutputFormat == ELFTarget::ELF64LE) {
+    return writeELFBinaryToFile<ELF64LE>(FilePath, Stub);
+  } else if (OutputFormat == ELFTarget::ELF64BE) {
+    return writeELFBinaryToFile<ELF64BE>(FilePath, Stub);
+  }
+  return createStringError(errc::invalid_argument,
+                           "Invalid binary output target");
+}
+
 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
   Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buf);
   if (!BinOrErr) {
     return BinOrErr.takeError();
   }
 
   Binary *Bin = BinOrErr->get();
   if (auto Obj = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
     return buildStub(*Obj);
   } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
     return buildStub(*Obj);
   } else if (auto Obj = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
     return buildStub(*Obj);
   } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
     return buildStub(*Obj);
   }
 
   return createStringError(errc::not_supported, "Unsupported binary format");
 }
 
 } // end namespace elfabi
 } // end namespace llvm

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

 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<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"));
 
 /// 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) {
   std::error_code SysErr;
 
   // Open file for writing.
   raw_fd_ostream Out(FilePath, SysErr);
   if (SysErr)
     return createStringError(SysErr, "Couldn't open `%s` for writing",
                              FilePath.data());
   // Write file.
   Error YAMLErr = writeTBEToOutputStream(Out, Stub);
   if (YAMLErr)
     return YAMLErr;
 
   return Error::success();
 }
 
 /// readInputFile populates an ELFStub by attempting to read the
 /// input file using both the TBE and binary ELF parsers.
 static Expected<std::unique_ptr<ELFStub>> readInputFile(StringRef FilePath) {
   // Read in file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
       MemoryBuffer::getFile(FilePath);
   if (!BufOrError) {
     return createStringError(BufOrError.getError(), "Could not open `%s`",
                              FilePath.data());
   }
 
   std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
   ErrorCollector EC(/*UseFatalErrors=*/false);
 
   // First try to read as a binary (fails fast if not binary).
   if (InputFileFormat.getNumOccurrences() == 0 ||
       InputFileFormat == 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) {
     Expected<std::unique_ptr<ELFStub>> StubFromTBE =
         readTBEFromBuffer(FileReadBuffer->getBuffer());
     if (StubFromTBE) {
       return std::move(*StubFromTBE);
     }
     EC.addError(StubFromTBE.takeError(), "YamlParse");
   }
 
   // If both readers fail, build a new error that includes all information.
   EC.addError(createStringError(errc::not_supported,
                                 "No file readers succeeded reading `%s` "
                                 "(unsupported/malformed file?)",
                                 FilePath.data()),
               "ReadInputFile");
   EC.escalateToFatal();
   return EC.makeError();
 }
 
 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);
   }
 
   std::unique_ptr<ELFStub> TargetStub = std::move(StubOrErr.get());
 
-  // Write out .tbe file.
-  if (EmitTBE.getNumOccurrences() == 1) {
-    TargetStub->TbeVersion = TBEVersionCurrent;
-    if (SOName.getNumOccurrences() == 1) {
-      TargetStub->SoName = SOName;
-    }
+  // Change SoName before emitting stubs.
+
+  // Write out .tbe file.
+  if (EmitTBE.getNumOccurrences() == 1) {
+    TargetStub->TbeVersion = TBEVersionCurrent;
     Error TBEWriteError = writeTBE(EmitTBE, *TargetStub);
     if (TBEWriteError) {
       WithColor::error() << TBEWriteError << "\n";
       exit(1);
     }
   }
+
+  // Write out binary ELF stub.
+  if (BinaryOutputFilePath.getNumOccurrences() == 1) {
+    if (BinaryOutputTarget.getNumOccurrences() == 0) {
+      WithColor::error() << "No binary output target specified.\n";
+      exit(1);
+    }
+    Error BinaryWriteError = writeBinaryStub(BinaryOutputFilePath, *TargetStub,
+                                             BinaryOutputTarget);
+    if (BinaryWriteError) {
+      WithColor::error() << BinaryWriteError << "\n";
+      exit(1);
+    }
+  }
 }