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> 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,179 @@ Optional 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 +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] = 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; + 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); +} + +template 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 +struct ContentSection : public OutputSection { + T Content; + ContentSection() { this->NoBits = false; } +}; + +// default constructable. This class just wraps it for the purpose of adding a +// default constructor. +class ELFStringTableBuilder : public StringTableBuilder { +public: + ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {} +}; + +class ELFSymbolTableBuilder {}; + +template 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; + +private: + Elf_Ehdr ElfHeader; + ContentSection StrTab; + ContentSection ShStrTab; + + template static void Write(uint8_t *Data, const T &Value) { + *reinterpret_cast(Data) = Value; + } + void FillStrTabShdr(ContentSection &StrTab, + uint32_t sh_flags = 0) const { + StrTab.Shdr.sh_type = SHT_STRTAB; + StrTab.Shdr.sh_flags = sh_flags; + 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 = this->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 &Sec) const { + return ElfHeader.e_shoff + Sec.Index * sizeof(Elf_Shdr); + } + void WriteShdr(uint8_t *Data, const OutputSection &Sec) const { + Write(Data + ShdrOffset(Sec), Sec.Shdr); + } + +public: + ELFStubBuilder(const ELFStubBuilder &) = delete; + ELFStubBuilder(ELFStubBuilder &&) = default; + explicit ELFStubBuilder(const ELFStub &Stub) { + // populate string tables. + ShStrTab.Name = ".shstrtab"; + ShStrTab.Align = 0; + StrTab.Name = ".dynstr"; + StrTab.Align = 0; + for (auto& sym : Stub.Symbols) { + StrTab.Content.add(sym.Name); + } + std::vector *> Sections; + Sections.push_back(&ShStrTab); + Sections.push_back(&StrTab); + const OutputSection *LastSection = Sections.back(); + // Now set the Index and put sections names into .shstrtab . + uint64_t Index = 1; + for (auto Sec : Sections) { + Sec->Index = Index++; + if (!Sec->Name.empty()) + ShStrTab.Content.add(Sec->Name); + } + ShStrTab.Content.finalize(); + ShStrTab.Size = ShStrTab.Content.getSize(); + StrTab.Content.finalize(); + StrTab.Size = StrTab.Content.getSize(); + // Calculate sections' addrs and offsets. + const OutputSection *Prev = nullptr; + uint64_t StartOffset = sizeof(Elf_Ehdr); + for (auto Sec : Sections) { + uint64_t Align = Sec->Align ? Sec->Align : 1; + if (Sec->NoBits) + Align = 1; + if (Prev == nullptr) { + Sec->Offset = alignTo(StartOffset, Align); + } else if (Prev->NoBits) + Sec->Offset = alignTo(Prev->Offset, Align); + else + Sec->Offset = alignTo(Prev->Offset + Prev->Size, Align); + if (Prev == nullptr) + Sec->Addr = alignTo(StartOffset, Align); + else + Sec->Addr = alignTo(Prev->Addr + Prev->Size, Align); + Prev = Sec; + } + // Write Shdr of String tables + FillStrTabShdr(StrTab, SHF_ALLOC); + FillStrTabShdr(ShStrTab); + // Initilize ELFheader + initELFHeader(ElfHeader, Stub.Arch); + ElfHeader.e_shstrndx = ShStrTab.Index; + ElfHeader.e_shnum = LastSection->Index + 1; + ElfHeader.e_phnum = 0; + ElfHeader.e_phoff = 0; + if (LastSection->NoBits) + ElfHeader.e_shoff = alignTo(LastSection->Offset, sizeof(Elf_Addr)); + else + 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); + ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset); + StrTab.Content.write(Data + StrTab.Shdr.sh_offset); + WriteShdr(Data, ShStrTab); + WriteShdr(Data, StrTab); + } +}; /// 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 +540,36 @@ 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 +Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub) { + ELFStubBuilder Builder{Stub}; + Expected> BufOrError = + FileOutputBuffer::create(FilePath, Builder.GetSize()); + 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 Buf = std::move(*BufOrError); + Builder.Write(Buf->getBufferStart()); + + if (Error FileWriteError = Buf->commit()) + return FileWriteError; + + return Error::success(); +} + Expected> readELFFile(MemoryBufferRef Buf) { Expected> BinOrErr = createBinary(Buf); if (!BinOrErr) { @@ -384,5 +590,22 @@ 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(FilePath, Stub); + if (OutputFormat == ELFTarget::ELF32BE) + return writeELFBinaryToFile(FilePath, Stub); + if (OutputFormat == ELFTarget::ELF64LE) + return writeELFBinaryToFile(FilePath, Stub); + if (OutputFormat == ELFTarget::ELF64BE) + return writeELFBinaryToFile(FilePath, Stub); + + return createStringError(errc::invalid_argument, + "Invalid binary output target"); +} + } // end namespace elfabi } // end namespace llvm diff --git a/llvm/test/tools/llvm-elfabi/binary-write-sheaders.test b/llvm/test/tools/llvm-elfabi/binary-write-sheaders.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-elfabi/binary-write-sheaders.test @@ -0,0 +1,70 @@ +# 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 -h %t | FileCheck %s --check-prefix=ELFHEADER +# 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: SectionHeaderCount: 3 +# ELFHEADER: StringTableSectionIndex: 1 + +# 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: .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: 0 +# SECTIONS-NEXT: EntrySize: 0 +# SECTIONS-NEXT: } +# SECTIONS-NEXT: Section { +# SECTIONS-NEXT: Index: 2 +# 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: 0 +# 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 \ No newline at end of file diff --git a/llvm/test/tools/llvm-elfabi/invalid-bin-target.test b/llvm/test/tools/llvm-elfabi/invalid-bin-target.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-elfabi/invalid-bin-target.test @@ -0,0 +1,10 @@ +# 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'! \ No newline at end of file diff --git a/llvm/test/tools/llvm-elfabi/missing-bin-target.test b/llvm/test/tools/llvm-elfabi/missing-bin-target.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-elfabi/missing-bin-target.test @@ -0,0 +1,10 @@ +# 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. \ No newline at end of file diff --git a/llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test b/llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test @@ -0,0 +1,28 @@ +# 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{{$}} \ No newline at end of file diff --git a/llvm/test/tools/llvm-elfabi/write-elf32le-ehdr.test b/llvm/test/tools/llvm-elfabi/write-elf32le-ehdr.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-elfabi/write-elf32le-ehdr.test @@ -0,0 +1,28 @@ +# 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{{$}} \ No newline at end of file diff --git a/llvm/test/tools/llvm-elfabi/write-elf64be-ehdr.test b/llvm/test/tools/llvm-elfabi/write-elf64be-ehdr.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-elfabi/write-elf64be-ehdr.test @@ -0,0 +1,28 @@ +# 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{{$}} \ No newline at end of file diff --git a/llvm/test/tools/llvm-elfabi/write-elf64le-ehdr.test b/llvm/test/tools/llvm-elfabi/write-elf64le-ehdr.test new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-elfabi/write-elf64le-ehdr.test @@ -0,0 +1,28 @@ +# 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{{$}} \ No newline at end of file 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 @@ -21,10 +21,7 @@ namespace llvm { namespace elfabi { -enum class FileFormat { - TBE, - ELF -}; +enum class FileFormat { TBE, ELF }; } // end namespace elfabi } // end namespace llvm @@ -35,20 +32,31 @@ // Command line flags: cl::opt 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::values(clEnumValN(FileFormat::TBE, "tbe", + "Read `input` as text-based ELF stub"), + clEnumValN(FileFormat::ELF, "elf", + "Read `input` as ELF binary"))); cl::opt InputFilePath(cl::Positional, cl::desc("input"), cl::Required); cl::opt EmitTBE("emit-tbe", cl::desc("Emit a text-based ELF stub (.tbe) from the input file"), cl::value_desc("path")); -cl::opt SOName( - "soname", - cl::desc("Manually set the DT_SONAME entry of any emitted files"), - cl::value_desc("name")); +cl::opt + SOName("soname", + cl::desc("Manually set the DT_SONAME entry of any emitted files"), + cl::value_desc("name")); +cl::opt 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 BinaryOutputFilePath(cl::Positional, cl::desc("output")); /// writeTBE() writes a Text-Based ELF stub to a file using the latest version /// of the YAML parser. @@ -127,16 +135,31 @@ std::unique_ptr 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); } } + + // 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); + } + } }