Index: llvm/test/tools/llvm-elfabi/invalid-bin-target.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/invalid-bin-target.test @@ -0,0 +1,15 @@ +# 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: + 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 } +... + +#CHECK: Invalid binary output target. Index: llvm/test/tools/llvm-elfabi/missing-bin-target.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/missing-bin-target.test @@ -0,0 +1,15 @@ +# RUN: not llvm-elfabi %s %t 2>&1 | FileCheck %s + +--- !tapi-tbe +SoName: somelib.so +TbeVersion: 1.0 +Arch: x86_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 } +... + +#CHECK: No binary output target specified. Index: llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test @@ -0,0 +1,30 @@ +# 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: Format: ELF32-x86-64 +#CHECK-NEXT: Arch: x86_64 +#CHECK-NEXT: AddressSize: 32bit + +#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 Index: llvm/test/tools/llvm-elfabi/write-elf32le-ehdr.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/write-elf32le-ehdr.test @@ -0,0 +1,30 @@ +# 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: Format: ELF32-x86-64 +#CHECK-NEXT: Arch: x86_64 +#CHECK-NEXT: AddressSize: 32bit + +#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 Index: llvm/test/tools/llvm-elfabi/write-elf64be-ehdr.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/write-elf64be-ehdr.test @@ -0,0 +1,30 @@ +# 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: Format: ELF64-x86-64 +#CHECK-NEXT: Arch: x86_64 +#CHECK-NEXT: AddressSize: 64bit + +#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 Index: llvm/test/tools/llvm-elfabi/write-elf64le-ehdr.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/write-elf64le-ehdr.test @@ -0,0 +1,30 @@ +# 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: Format: ELF64-aarch64-little +#CHECK-NEXT: Arch: aarch64 +#CHECK-NEXT: AddressSize: 64bit + +#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 Index: llvm/tools/llvm-elfabi/ELFObjHandler.h =================================================================== --- llvm/tools/llvm-elfabi/ELFObjHandler.h +++ llvm/tools/llvm-elfabi/ELFObjHandler.h @@ -24,6 +24,8 @@ namespace elfabi { +template class ELFBinaryWriterImpl; + /// Returns a new ELFStub with all members populated from an ELFObjectFile. /// @param ElfObj Source ELFObjectFile. template @@ -39,6 +41,62 @@ /// Attempt to read a binary ELF file from a MemoryBuffer. Expected> readELFFile(MemoryBufferRef Buf); + +/// Write an ELF binary to a buffer. +/// @param Stub Source ELFStub used to generate a binary stub. +/// @param Buf Target buffer to write to. +/// @param Size Size of buffer. +template +Error writeELFBinary(const ELFStub &Stub, char *Buf, size_t Size) { + ELFBinaryWriterImpl Writer; + return Writer.writeToBuffer(Stub, Buf, Size); +} + +/// This function calculates what the size of an ELF binary stub generated +/// from an ELFStub would be. +/// @param Stub Source ELFStub. +/// +/// @return Size (in bytes) of the final binary stub. +template +size_t getBinaryStubSize(const ELFStub &Stub) { + ELFBinaryWriterImpl Writer; + return Writer.getBinarySize(Stub); +} + +/// This class serves three purposes: +/// 1. It obscures the implementation so helper functions aren't used directly. +/// 2. It makes helper functions accessible for testing. +/// 3. It makes use of ELFType templates significantly less messy. +/// This class will NOT contain any state. +template class ELFBinaryWriterImpl { +public: + using Elf_Ehdr = typename ELFT::Ehdr; + + ELFBinaryWriterImpl() {} + + /// Write an ELF binary to a buffer. + /// @param Stub Source ELFStub used to generate a binary stub. + /// @param Buf Target buffer to write to. + /// @param Size Size of target buffer. + Error writeToBuffer(const ELFStub &Stub, char *Buf, size_t Size); + + /// This function calculates what the size of an ELF binary stub generated + /// from an ELFStub will be. This includes the cost of additional padding + /// needed for correct alignment. + /// @param Stub Source ELFStub. + /// + /// @return Size (in bytes) of the final binary stub. + size_t getBinarySize(const ELFStub &Stub); + + /// 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. + /// @param ElfHeader Target ELFT::Ehdr to populate. + /// @param Machine Target architecture (e_machine from ELF specifications). + void initELFHeader(Elf_Ehdr &ElfHeader, uint16_t Machine); +}; + } // end namespace elfabi } // end namespace llvm Index: llvm/tools/llvm-elfabi/ELFObjHandler.cpp =================================================================== --- llvm/tools/llvm-elfabi/ELFObjHandler.cpp +++ llvm/tools/llvm-elfabi/ELFObjHandler.cpp @@ -67,5 +67,52 @@ return createStringError(errc::not_supported, "Unsupported binary format"); } +template +void ELFBinaryWriterImpl::initELFHeader(Elf_Ehdr &ElfHeader, + uint16_t Machine) { + 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] = 0u; + + // remainder of ELF header + ElfHeader.e_type = ET_DYN; + ElfHeader.e_machine = Machine; + ElfHeader.e_version = EV_CURRENT; + ElfHeader.e_entry = 0x00; + ElfHeader.e_flags = 0u; + ElfHeader.e_ehsize = sizeof(Elf_Ehdr); +} + +template +Error ELFBinaryWriterImpl::writeToBuffer(const ELFStub &Stub, char *Buf, + size_t Size) { + if (Size < getBinarySize(Stub)) { + return createStringError(errc::invalid_argument, + "Destination buffer too small"); + } + Elf_Ehdr *ElfHeader = reinterpret_cast(Buf); + initELFHeader(*ElfHeader, Stub.Arch); + return Error::success(); +} + +template +size_t ELFBinaryWriterImpl::getBinarySize(const ELFStub &Stub) { + return sizeof(Elf_Ehdr); +} + +template class ELFBinaryWriterImpl; +template class ELFBinaryWriterImpl; +template class ELFBinaryWriterImpl; +template class ELFBinaryWriterImpl; + } // end namespace elfabi } // end namespace llvm Index: llvm/tools/llvm-elfabi/llvm-elfabi.cpp =================================================================== --- llvm/tools/llvm-elfabi/llvm-elfabi.cpp +++ llvm/tools/llvm-elfabi/llvm-elfabi.cpp @@ -9,6 +9,7 @@ #include "ELFObjHandler.h" #include "ErrorCollector.h" +#include "llvm/Object/ELFTypes.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Errc.h" #include "llvm/Support/FileOutputBuffer.h" @@ -20,6 +21,7 @@ using namespace llvm; using namespace llvm::elfabi; +using namespace llvm::object; // Command line flags: cl::opt InputFilePath(cl::Positional, cl::desc("input"), @@ -32,6 +34,17 @@ "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 "), + cl::value_desc("target")); +cl::opt BinaryOutputFilePath(cl::Positional, cl::desc("output")); + +cl::extrahelp + HelpSpacer("\n"); +cl::extrahelp + SupportedOutTargets("Supported output targets: elf32-little, elf32-big, " + "elf64-little, elf64-big\n"); /// writeTBE() writes a Text-Based ELF stub to a file using the latest version /// of the YAML parser. @@ -51,6 +64,55 @@ return Error::success(); } +template +static Error writeELFBinary(StringRef FilePath, ELFStub &Stub) { + // Open file for writing. + Expected> BufOrError = + FileOutputBuffer::create(FilePath, getBinaryStubSize(Stub)); + if (!BufOrError) { + return createStringError(errc::invalid_argument, + "Couldn't open `%s` for writing.", + FilePath.data()); + } + std::unique_ptr Buf = std::move(*BufOrError); + char *Data = reinterpret_cast(Buf->getBufferStart()); + Error BinaryWriteError = + writeELFBinary(Stub, Data, Buf->getBufferSize()); + if (BinaryWriteError) { + return BinaryWriteError; + } + + Error FileWriteError = Buf->commit(); + if (FileWriteError) { + return FileWriteError; + } + + return Error::success(); +} + +// Determine the appropriate ELFType and begin writing binary stub output. +static Error writeBinaryWithTarget(StringRef FilePath, ELFStub &Stub) { + if (BinaryOutputTarget.getNumOccurrences() == 0) { + return createStringError(errc::invalid_argument, + "No binary output target specified."); + } + // Make a StringRef from `BinaryOutputTarget` since cl::opt doesn't allow + // member access. + StringRef Target(BinaryOutputTarget); + if (Target.equals("elf32-little")) { + return writeELFBinary(FilePath, Stub); + } else if (Target.equals("elf32-big")) { + return writeELFBinary(FilePath, Stub); + } else if (Target.equals("elf64-little")) { + return writeELFBinary(FilePath, Stub); + } else if (Target.equals("elf64-big")) { + return writeELFBinary(FilePath, Stub); + } + + return createStringError(errc::invalid_argument, + "Invalid binary output target."); +} + /// readInputFile populates an ELFStub by attempting to read the /// input file using both the TBE and binary ELF parsers. static Expected> readInputFile(StringRef FilePath) { @@ -104,16 +166,27 @@ std::unique_ptr TargetStub = std::move(StubOrErr.get()); + // Change SoName before emitting stubs. + if (SOName.getNumOccurrences() == 1) { + TargetStub->SoName = SOName; + } // Write out .tbe file. if (EmitTBE.getNumOccurrences() == 1) { TargetStub->TbeVersion = TBEVersionCurrent; - if (SOName.getNumOccurrences() == 1) { - TargetStub->SoName = SOName; - } Error TBEWriteError = writeTBE(EmitTBE, *TargetStub); if (TBEWriteError) { errs() << "Error: " << TBEWriteError << "\n"; exit(1); } } + + // Write out binary ELF stub. + if (BinaryOutputFilePath.getNumOccurrences() == 1) { + Error BinaryWriteError = + writeBinaryWithTarget(BinaryOutputFilePath, *TargetStub); + if (BinaryWriteError) { + errs() << "Error: " << BinaryWriteError << "\n"; + exit(1); + } + } }