Index: llvm/include/llvm/TextAPI/ELF/ELFStub.h =================================================================== --- llvm/include/llvm/TextAPI/ELF/ELFStub.h +++ llvm/include/llvm/TextAPI/ELF/ELFStub.h @@ -38,6 +38,7 @@ ELFSymbol(std::string SymbolName) : Name(SymbolName) {} std::string Name; uint64_t Size; + uint64_t Alignment; ELFSymbolType Type; bool Undefined; bool Weak; Index: llvm/lib/TextAPI/ELF/TBEHandler.cpp =================================================================== --- llvm/lib/TextAPI/ELF/TBEHandler.cpp +++ llvm/lib/TextAPI/ELF/TBEHandler.cpp @@ -98,10 +98,13 @@ // The need for symbol size depends on the symbol type. if (Symbol.Type == ELFSymbolType::NoType) { IO.mapOptional("Size", Symbol.Size, (uint64_t)0); + IO.mapOptional("Alignment", Symbol.Size, (uint64_t)0); } else if (Symbol.Type == ELFSymbolType::Func) { Symbol.Size = 0; + Symbol.Alignment = 0; } else { IO.mapRequired("Size", Symbol.Size); + IO.mapOptional("Alignment", Symbol.Alignment, (uint64_t)0); } IO.mapOptional("Undefined", Symbol.Undefined, false); IO.mapOptional("Weak", Symbol.Weak, false); Index: llvm/test/tools/llvm-elfabi/binary-write-neededlibs.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/binary-write-neededlibs.test @@ -0,0 +1,20 @@ +# This test ensures .dynamic strings are added to .dynstr with suffix matching. +# RUN: llvm-elfabi %s --output-target=elf64-little %t +# RUN: llvm-readobj --dynamic %t | FileCheck %s + +--- !tapi-tbe +TbeVersion: 1.0 +SoName: libsomething.so +Arch: x86_64 +NeededLibs: + - libc.so + - libclang.so + - thing.so +Symbols: {} +... + +# CHECK: SONAME Library soname: [libsomething.so] +# CHECK: NEEDED Shared library: [libc.so] +# CHECK: NEEDED Shared library: [libclang.so] +# CHECK: NEEDED Shared library: [thing.so] +# CHECK: STRSZ 67 (bytes) Index: llvm/test/tools/llvm-elfabi/binary-write-pheaders.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/binary-write-pheaders.test @@ -0,0 +1,36 @@ +# RUN: llvm-elfabi %s --output-target=elf64-little %t +# RUN: llvm-readobj -h %t | FileCheck %s --check-prefix=ELFHEADER +# RUN: llvm-readobj -l %t | FileCheck %s --check-prefix=PHDRS + +--- !tapi-tbe +TbeVersion: 1.0 +Arch: x86_64 +Symbols: {} +... + +# ELFHEADER: ProgramHeaderCount: 2 + +# PHDRS: ProgramHeader { +# PHDRS-NEXT: Type: PT_LOAD +# PHDRS-NEXT: Offset: 0x0 +# PHDRS-NEXT: VirtualAddress: 0x0 +# PHDRS-NEXT: PhysicalAddress: 0x0 +# PHDRS-NEXT: FileSize: +# PHDRS-NEXT: MemSize: +# PHDRS-NEXT: Flags [ +# PHDRS-NEXT: PF_R +# PHDRS-NEXT: ] +# PHDRS-NEXT: Alignment: 4096 +# PHDRS-NEXT: } +# PHDRS-NEXT: ProgramHeader { +# PHDRS-NEXT: Type: PT_DYNAMIC +# PHDRS-NEXT: Offset: +# PHDRS-NEXT: VirtualAddress: +# PHDRS-NEXT: PhysicalAddress: +# PHDRS-NEXT: FileSize: +# PHDRS-NEXT: MemSize: +# PHDRS-NEXT: Flags [ +# PHDRS-NEXT: PF_R +# PHDRS-NEXT: ] +# PHDRS-NEXT: Alignment: 8 +# PHDRS-NEXT: } Index: llvm/test/tools/llvm-elfabi/binary-write-sheaders.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/binary-write-sheaders.test @@ -0,0 +1,87 @@ +# 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 + +--- !tapi-tbe +TbeVersion: 1.0 +Arch: x86_64 +Symbols: {} +... + +# ELFHEADER: SectionHeaderCount: 5 +# 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: .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: } +# SECTIONS-NEXT: Section { +# SECTIONS-NEXT: Index: 2 +# SECTIONS-NEXT: Name: .dynsym +# SECTIONS-NEXT: Type: SHT_DYNSYM +# SECTIONS-NEXT: Flags [ +# SECTIONS-NEXT: SHF_ALLOC +# SECTIONS-NEXT: ] +# SECTIONS-NEXT: Address: +# SECTIONS-NEXT: Offset: +# SECTIONS-NEXT: Size: 24 +# SECTIONS-NEXT: Link: 1 +# SECTIONS-NEXT: Info: 0 +# SECTIONS-NEXT: AddressAlignment: 8 +# SECTIONS-NEXT: EntrySize: 24 +# SECTIONS-NEXT: } +# SECTIONS-NEXT: Section { +# SECTIONS-NEXT: Index: 3 +# SECTIONS-NEXT: Name: .dynamic +# SECTIONS-NEXT: Type: SHT_DYNAMIC +# SECTIONS-NEXT: Flags [ +# SECTIONS-NEXT: SHF_ALLOC +# SECTIONS-NEXT: ] +# SECTIONS-NEXT: Address: +# SECTIONS-NEXT: Offset: +# SECTIONS-NEXT: Size: +# SECTIONS-NEXT: Link: 1 +# SECTIONS-NEXT: Info: +# SECTIONS-NEXT: AddressAlignment: 8 +# SECTIONS-NEXT: EntrySize: 16 +# SECTIONS-NEXT: } +# SECTIONS-NEXT: Section { +# SECTIONS-NEXT: Index: 4 +# SECTIONS-NEXT: Name: .def +# SECTIONS-NEXT: Type: SHT_NOBITS +# SECTIONS-NEXT: Flags [ +# SECTIONS-NEXT: SHF_ALLOC +# SECTIONS-NEXT: ] +# SECTIONS-NEXT: Address: +# SECTIONS-NEXT: Offset: +# SECTIONS-NEXT: Size: 0 +# SECTIONS-NEXT: Link: 0 +# SECTIONS-NEXT: Info: 0 +# SECTIONS-NEXT: AddressAlignment: 0 +# SECTIONS-NEXT: EntrySize: 0 +# SECTIONS-NEXT: } Index: llvm/test/tools/llvm-elfabi/binary-write-soname.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/binary-write-soname.test @@ -0,0 +1,12 @@ +# RUN: llvm-elfabi %s --output-target=elf64-little %t +# RUN: llvm-readobj --dynamic %t | FileCheck %s + +--- !tapi-tbe +TbeVersion: 1.0 +SoName: somelib.so +Arch: x86_64 +Symbols: {} +... + +# CHECK: SONAME Library soname: [somelib.so] +# CHECK: STRSZ 42 (bytes) Index: llvm/test/tools/llvm-elfabi/binary-write-symbols.test =================================================================== --- /dev/null +++ llvm/test/tools/llvm-elfabi/binary-write-symbols.test @@ -0,0 +1,80 @@ +# RUN: llvm-elfabi %s --output-target=elf64-little %t +# RUN: llvm-readobj --dynamic --dyn-symbols %t | FileCheck %s + +--- !tapi-tbe +TbeVersion: 1.0 +SoName: libfoo.so +Arch: x86_64 +NeededLibs: + - libc.so + - libclang.so + - thing.so +Symbols: + foo: { Type: Func } + bar: { Type: Object, Size: 42 } + baz: { Type: Object, Alignment: 64, Size: 8 } + not: { Type: Object, Undefined: true, Size: 128 } + nor: { Type: Func, Undefined: true } +... + +#CHECK: Symbol { +#CHECK-NEXT: Name: +#CHECK-NEXT: Value: 0x0 +#CHECK-NEXT: Size: 0 +#CHECK-NEXT: Binding: Local +#CHECK-NEXT: Type: None +#CHECK-NEXT: Other: 0 +#CHECK-NEXT: Section: Undefined +#CHECK-NEXT: } +#CHECK-NEXT: Symbol { +#CHECK-NEXT: Name: bar +#CHECK-NEXT: Value: 0x240 +#CHECK-NEXT: Size: 42 +#CHECK-NEXT: Binding: Global (0x1) +#CHECK-NEXT: Type: Object (0x1) +#CHECK-NEXT: Other: 0 +#CHECK-NEXT: Section: .def +#CHECK-NEXT: } +#CHECK-NEXT: Symbol { +#CHECK-NEXT: Name: baz +#CHECK-NEXT: Value: 0x280 +#CHECK-NEXT: Size: 8 +#CHECK-NEXT: Binding: Global +#CHECK-NEXT: Type: Object +#CHECK-NEXT: Other: 0 +#CHECK-NEXT: Section: .def +#CHECK-NEXT: } +#CHECK-NEXT: Symbol { +#CHECK-NEXT: Name: foo +#CHECK-NEXT: Value: 0x288 +#CHECK-NEXT: Size: 0 +#CHECK-NEXT: Binding: Global +#CHECK-NEXT: Type: Function +#CHECK-NEXT: Other: 0 +#CHECK-NEXT: Section: .def +#CHECK-NEXT: } +#CHECK-NEXT: Symbol { +#CHECK-NEXT: Name: nor +#CHECK-NEXT: Value: 0x0 +#CHECK-NEXT: Size: 0 +#CHECK-NEXT: Binding: Global +#CHECK-NEXT: Type: Function +#CHECK-NEXT: Other: 0 +#CHECK-NEXT: Section: Undefined +#CHECK-NEXT: } +#CHECK-NEXT: Symbol { +#CHECK-NEXT: Name: not +#CHECK-NEXT: Value: 0x0 +#CHECK-NEXT: Size: 128 +#CHECK-NEXT: Binding: Global +#CHECK-NEXT: Type: Object +#CHECK-NEXT: Other: 0 +#CHECK-NEXT: Section: Undefined +#CHECK-NEXT: } + +# CHECK: SONAME Library soname: [libfoo.so] +# CHECK: NEEDED Shared library: [libc.so] +# CHECK: NEEDED Shared library: [libclang.so] +# CHECK: NEEDED Shared library: [thing.so] + + Index: llvm/test/tools/llvm-elfabi/invalid-bin-target.test =================================================================== --- /dev/null +++ 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'! Index: llvm/test/tools/llvm-elfabi/missing-bin-target.test =================================================================== --- /dev/null +++ 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. Index: llvm/test/tools/llvm-elfabi/write-elf32be-ehdr.test =================================================================== --- /dev/null +++ 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{{$}} Index: llvm/test/tools/llvm-elfabi/write-elf32le-ehdr.test =================================================================== --- /dev/null +++ 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{{$}} Index: llvm/test/tools/llvm-elfabi/write-elf64be-ehdr.test =================================================================== --- /dev/null +++ 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{{$}} Index: llvm/test/tools/llvm-elfabi/write-elf64le-ehdr.test =================================================================== --- /dev/null +++ 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{{$}} Index: llvm/tools/llvm-elfabi/ELFObjHandler.h =================================================================== --- llvm/tools/llvm-elfabi/ELFObjHandler.h +++ llvm/tools/llvm-elfabi/ELFObjHandler.h @@ -23,9 +23,26 @@ 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 Index: llvm/tools/llvm-elfabi/ELFObjHandler.cpp =================================================================== --- llvm/tools/llvm-elfabi/ELFObjHandler.cpp +++ llvm/tools/llvm-elfabi/ELFObjHandler.cpp @@ -7,14 +7,19 @@ //===-----------------------------------------------------------------------===/ #include "ELFObjHandler.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" #include "llvm/TextAPI/ELF/ELFStub.h" +#include + using llvm::MemoryBufferRef; using llvm::object::ELFObjectFile; @@ -22,8 +27,9 @@ 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 { @@ -38,13 +44,62 @@ Optional GnuHash; }; +// Lazy assumes that T is default constructable. +// Lazy also acts like a read-only, move-only type. +template class Lazy { +private: + mutable std::function Func; + mutable Optional Value; + +public: + Lazy(const Lazy &) = delete; + Lazy(Lazy &&) = default; + // Allow Lazy values to be default constructed to an empty state. + Lazy() = default; + explicit Lazy(std::function &&F) : Func(std::move(F)) {} + + Lazy &operator=(std::function &&F) { + // Once a thunk has been assigned don't allow it to change. + assert(!Value && !Func); + Func = F; + return *this; + } + Lazy &operator=(T &&Val) { + assert(!Value && !Func); + Value = std::move(Val); + return *this; + } + Lazy &operator=(const T &Val) { + assert(!Value && !Func); + Value = Val; + return *this; + } + + const T &operator*() const { + // Assert that a value has been assigned, lazy or otherwise. + assert(Value || Func); + if (Value) + return *Value; + std::function TFunc{std::move(Func)}; + Func = [](T&) { llvm_unreachable("cycle detected"); }; + Value.emplace(); + TFunc(*Value); + return *Value; + } + const T *operator->() const { return &**this; } +}; + +template Lazy makeLazy(std::function &&F) { + return Lazy{std::move(F)}; +} + /// 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 terminatedSubstr(StringRef Str, size_t Offset) { +Expected terminatedSubstr(StringRef Str, size_t Offset) { size_t StrEnd = Str.find('\0', Offset); if (StrEnd == StringLiteral::npos) { return createError( @@ -78,8 +133,7 @@ /// @param Dyn Target DynamicEntries struct to populate. /// @param DynTable Source dynamic table. template -static Error populateDynamic(DynamicEntries &Dyn, - typename ELFT::DynRange DynTable) { +Error populateDynamic(DynamicEntries &Dyn, typename ELFT::DynRange DynTable) { if (DynTable.empty()) return createError("No .dynamic section found"); @@ -128,19 +182,17 @@ "Couldn't locate dynamic symbol table (no DT_SYMTAB entry)"); } if (Dyn.SONameOffset.hasValue() && *Dyn.SONameOffset >= Dyn.StrSize) { - return createStringError( - object_error::parse_failed, - "DT_SONAME string offset (0x%016" PRIx64 - ") outside of dynamic string table", - *Dyn.SONameOffset); + return createStringError(object_error::parse_failed, + "DT_SONAME string offset (0x%016" PRIx64 + ") outside of dynamic string table", + *Dyn.SONameOffset); } for (uint64_t Offset : Dyn.NeededLibNames) { if (Offset >= Dyn.StrSize) { - return createStringError( - object_error::parse_failed, - "DT_NEEDED string offset (0x%016" PRIx64 - ") outside of dynamic string table", - Offset); + return createStringError(object_error::parse_failed, + "DT_NEEDED string offset (0x%016" PRIx64 + ") outside of dynamic string table", + Offset); } } @@ -151,7 +203,7 @@ /// /// @param Table The GNU hash table for .dynsym. template -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; @@ -179,8 +231,8 @@ /// @param Dyn Entries with the locations of hash tables. /// @param ElfFile The ElfFile that the section contents reside in. template -static Expected getNumSyms(DynamicEntries &Dyn, - const ELFFile &ElfFile) { +Expected getNumSyms(DynamicEntries &Dyn, + const ELFFile &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. @@ -209,19 +261,19 @@ /// 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; + 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; } } @@ -231,8 +283,7 @@ /// @param SymName The desired name of the ELFSymbol. /// @param RawSym ELFT::Sym to extract symbol information from. template -static ELFSymbol createELFSym(StringRef SymName, - const typename ELFT::Sym &RawSym) { +ELFSymbol createELFSym(StringRef SymName, const typename ELFT::Sym &RawSym) { ELFSymbol TargetSym(SymName); uint8_t Binding = RawSym.getBinding(); if (Binding == STB_WEAK) @@ -258,9 +309,8 @@ /// @param DynSym Range of dynamic symbols to add to TargetStub. /// @param DynStr StringRef to the dynamic string table. template -static Error populateSymbols(ELFStub &TargetStub, - const typename ELFT::SymRange DynSym, - StringRef DynStr) { +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. @@ -276,7 +326,10 @@ Expected SymName = terminatedSubstr(DynStr, RawSym.st_name); if (!SymName) return SymName.takeError(); + // TODO: Populate alignment by calculating it from the section alignment + // and the offset within the section. For not just set it to zero. ELFSymbol Sym = createELFSym(*SymName, RawSym); + Sym.Alignment = 0; TargetStub.Symbols.insert(std::move(Sym)); // TODO: Populate symbol warning. } @@ -286,7 +339,7 @@ /// Returns a new ELFStub with all members populated from an ELFObjectFile. /// @param ElfObj Source ELFObjectFile. template -static Expected> +Expected> buildStub(const ELFObjectFile &ElfObj) { using Elf_Dyn_Range = typename ELFT::DynRange; using Elf_Phdr_Range = typename ELFT::PhdrRange; @@ -311,7 +364,7 @@ if (Error Err = populateDynamic(DynEnt, *DynTable)) return std::move(Err); - // Get pointer to in-memory location of .dynstr section. + // Get pointer to in-memory location of .dynstr section. Expected DynStrPtr = ElfFile->toMappedAddr(DynEnt.StrTabAddr); if (!DynStrPtr) @@ -355,9 +408,8 @@ if (!DynSymPtr) return appendToError(DynSymPtr.takeError(), "when locating .dynsym section contents"); - Elf_Sym_Range DynSyms = - ArrayRef(reinterpret_cast(*DynSymPtr), - *SymCount); + Elf_Sym_Range DynSyms = ArrayRef( + reinterpret_cast(*DynSymPtr), *SymCount); Error SymReadError = populateSymbols(*DestStub, DynSyms, DynStr); if (SymReadError) return appendToError(std::move(SymReadError), @@ -367,6 +419,409 @@ 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 +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); +} + +template struct OutputSection { + using Elf_Shdr = typename ELFT::Shdr; + std::string Name; + Lazy Shdr; + Lazy Addr; + Lazy Offset; + Lazy Size; + Lazy Align; + uint32_t Index; + bool NoBits = true; +}; + +template +struct ContentSection : public OutputSection { + Lazy Content; + ContentSection() { this->NoBits = false; } +}; + +class ELFStringTableBuilder : public StringTableBuilder { +public: + ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {} +}; + +template struct Symbols { + using Elf_Sym = typename ELFT::Sym; + std::vector> Symbols; + uint64_t MaxAlign = 0; + uint64_t MaxAddr = 0; +}; + +template class ELFBuilder { +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: + Lazy ElfHeader; + ContentSection StrTab; + ContentSection, ELFT> DynSym; + OutputSection DefSec; + ContentSection, ELFT> Dynamic; + std::vector> ProgramHeaders; + + template static void Write(uint8_t *Data, const T &Value) { + *reinterpret_cast(Data) = Value; + } + template + static void WriteLazyVector(uint8_t *Data, const std::vector> &Vec) { + T *Iter = reinterpret_cast(Data); + for (const auto &Value : Vec) { + *Iter++ = *Value; + } + } + template + static void WriteVector(uint8_t *Data, const std::vector &Vec) { + std::copy(Vec.begin(), Vec.end(), reinterpret_cast(Data)); + } + 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: + ELFBuilder(const ELFBuilder &) = delete; + ELFBuilder(ELFBuilder &&) = default; + explicit ELFBuilder(const ELFStub &Stub) { + std::vector *> Sections; + Sections.push_back(&StrTab); + Sections.push_back(&DynSym); + Sections.push_back(&Dynamic); + Sections.push_back(&DefSec); + + const OutputSection *LastSection = Sections.back(); + ElfHeader = [this, &Stub, LastSection](Elf_Ehdr &Ehdr) { + initELFHeader(Ehdr, Stub.Arch); + Ehdr.e_shstrndx = StrTab.Index; + Ehdr.e_shnum = LastSection->Index + 1; + Ehdr.e_phnum = ProgramHeaders.size(); + Ehdr.e_phoff = sizeof(Elf_Ehdr); + if (LastSection->NoBits) + Ehdr.e_shoff = alignTo(*LastSection->Offset, sizeof(Elf_Addr)); + else + Ehdr.e_shoff = alignTo(*LastSection->Offset + *LastSection->Size, + sizeof(Elf_Addr)); + }; + + ProgramHeaders.emplace_back([this](Elf_Phdr &Load) { + Load.p_type = PT_LOAD; + Load.p_offset = 0x0; + Load.p_vaddr = 0x0; + Load.p_paddr = 0x0; + Load.p_filesz = *DefSec.Offset; + Load.p_memsz = *DefSec.Addr + *DefSec.Size; + Load.p_flags = PF_R; + Load.p_align = 0x1000; + }); + ProgramHeaders.emplace_back([this](Elf_Phdr &Dyn) { + Dyn.p_type = PT_DYNAMIC; + Dyn.p_offset = *Dynamic.Offset; + Dyn.p_vaddr = *Dynamic.Addr; + Dyn.p_paddr = Dyn.p_vaddr; + Dyn.p_filesz = *Dynamic.Size; + Dyn.p_memsz = Dyn.p_filesz; + Dyn.p_flags = PF_R; + Dyn.p_align = *Dynamic.Align; + }); + + // Manually set the indexes of these. + uint64_t Index = 1; + const OutputSection *Prev = nullptr; + uint64_t StartOffset = + sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * ProgramHeaders.size(); + // Now set the Index, Offset, and Addr of everything. + for (auto Sec : Sections) { + Sec->Index = Index++; + Sec->Offset = [=](uint64_t &Offset) { + uint64_t Align = *Sec->Align ? *Sec->Align : 1; + // Don't align the offset of a NOBITS section. + if (Sec->NoBits) + Align = 1; + if (Prev == nullptr) + Offset = alignTo(StartOffset, Align); + else if (Prev->NoBits) + Offset = alignTo(*Prev->Offset, Align); + else + Offset = alignTo(*Prev->Offset + *Prev->Size, Align); + }; + Sec->Addr = [=](uint64_t &Addr) { + uint64_t Align = *Sec->Align ? *Sec->Align : 1; + if (Prev == nullptr) + Addr = alignTo(StartOffset, Align); + else + Addr = alignTo(*Prev->Addr + *Prev->Size, Align); + }; + Prev = Sec; + } + + DefSec.Name = ".def"; + DefSec.Shdr = [this](Elf_Shdr &Shdr) { + Shdr.sh_name = StrTab.Content->getOffset(DefSec.Name); + Shdr.sh_type = SHT_NOBITS; + Shdr.sh_flags = SHF_ALLOC; + Shdr.sh_size = *DefSec.Size; + Shdr.sh_addralign = *DefSec.Align; + Shdr.sh_addr = *DefSec.Addr; + Shdr.sh_offset = *DefSec.Offset; + }; + DefSec.Size = [this](uint64_t &Size) { Size = DynSym.Content->MaxAddr; }; + DefSec.Align = [this](uint64_t &Align) { + Align = DynSym.Content->MaxAlign; + }; + + // Define the string table. + StrTab.Name = ".dynstr"; + StrTab.Shdr = [this](Elf_Shdr &Shdr) { + Shdr.sh_name = StrTab.Content->getOffset(StrTab.Name); + Shdr.sh_type = SHT_STRTAB; + Shdr.sh_flags = SHF_ALLOC; + Shdr.sh_size = *StrTab.Size; + Shdr.sh_addr = *StrTab.Addr; + Shdr.sh_offset = *StrTab.Offset; + }; + StrTab.Size = [this](uint64_t &Size) { Size = StrTab.Content->getSize(); }; + StrTab.Align = 0; + StrTab.Content = [this, &Stub](ELFStringTableBuilder &Builder) { + Builder.add(StrTab.Name); + Builder.add(DynSym.Name); + Builder.add(DefSec.Name); + Builder.add(Dynamic.Name); + for (const auto &Sym : Stub.Symbols) + Builder.add(Sym.Name); + if (Stub.SoName) + Builder.add(*Stub.SoName); + for (const auto &Needed : Stub.NeededLibs) + Builder.add(Needed); + Builder.finalize(); + }; + + // Define the symbol table. + DynSym.Name = ".dynsym"; + DynSym.Shdr = [this](Elf_Shdr &Shdr) { + Shdr.sh_name = StrTab.Content->getOffset(DynSym.Name); + Shdr.sh_type = SHT_DYNSYM; + Shdr.sh_flags = SHF_ALLOC; + Shdr.sh_size = *DynSym.Size; + Shdr.sh_addralign = sizeof(Elf_Addr); + Shdr.sh_addr = *DynSym.Addr; + Shdr.sh_offset = *DynSym.Offset; + Shdr.sh_link = StrTab.Index; + Shdr.sh_entsize = sizeof(Elf_Sym); + }; + DynSym.Align = sizeof(Elf_Addr); + // Make sure to account for the null symbol. + DynSym.Size = (Stub.Symbols.size() + 1) * sizeof(Elf_Sym); + DynSym.Content = [this, &Stub](Symbols &SymbolInfo) { + uint64_t Addr = 0x0; + uint64_t MaxAlign = 0x0; + // Make sure to add the null symbol. + SymbolInfo.Symbols.emplace_back([](Elf_Sym &Sym) { + memset(&Sym, 0, sizeof(Sym)); + }); + for (const auto &Symbol : Stub.Symbols) { + Elf_Sym ElfSym; + memset(&ElfSym, 0, sizeof(ElfSym)); + ElfSym.st_name = StrTab.Content->getOffset(Symbol.Name); + ElfSym.st_size = Symbol.Size; + if (!Symbol.Undefined) { + switch (Symbol.Type) { + case ELFSymbolType::Func: + ElfSym.st_shndx = DefSec.Index; + ElfSym.st_value = Addr++; + break; + case ELFSymbolType::Object: + case ELFSymbolType::TLS: + ElfSym.st_shndx = DefSec.Index; + // Make sure we use the minimal valid alignment. The below aligns + // Addr + Align to twice the alignment required which ensures that + // after we subtract the alignment will be minimal. If just bumping + // the Addr to Symbol.Alignment would have given us minimal + // alignment then so will this expression. If it wouldn't then this + // expression puts us only Symbol.Alignment further along which is + // optimal. + outs() << "\n" << Addr << " " << Symbol.Alignment << "\n"; + Addr = alignTo(Addr + Symbol.Alignment, Symbol.Alignment ? 2*Symbol.Alignment : 1) - Symbol.Alignment; + ElfSym.st_value = Addr; + Addr += Symbol.Size; + MaxAlign = std::max(Symbol.Alignment, MaxAlign); + break; + default: + break; + } + } + ElfSym.setType(static_cast(Symbol.Type)); + if (Symbol.Weak) + ElfSym.setBinding(STB_WEAK); + else + ElfSym.setBinding(STB_GLOBAL); + // Add in the final address back in. + // TODO: Consider writing directly into output so that each Elf_Sym is + // once and not twice. + SymbolInfo.Symbols.emplace_back([this, ElfSym](Elf_Sym &Sym) { + Sym = ElfSym; + if (Sym.st_shndx != 0) + Sym.st_value += *DefSec.Addr; + }); + } + SymbolInfo.MaxAddr = Addr; + SymbolInfo.MaxAlign = MaxAlign; + }; + + // Construct the .dynamic table. + Dynamic.Name = ".dynamic"; + Dynamic.Shdr = [this](Elf_Shdr &Shdr) { + Shdr.sh_name = StrTab.Content->getOffset(Dynamic.Name); + Shdr.sh_type = SHT_DYNAMIC; + Shdr.sh_flags = SHF_ALLOC; + Shdr.sh_addr = *Dynamic.Addr; + Shdr.sh_offset = *Dynamic.Offset; + Shdr.sh_size = *Dynamic.Size; + Shdr.sh_link = StrTab.Index; + Shdr.sh_addralign = sizeof(Elf_Addr); + Shdr.sh_entsize = sizeof(Elf_Dyn); + }; + Dynamic.Align = sizeof(Elf_Addr); + Dynamic.Size = [this](uint64_t &Size) { + // TODO: This can be calculated without knowing the Content. + Size = Dynamic.Content->size() * sizeof(Elf_Dyn); + }; + Dynamic.Content = [this, &Stub](std::vector &Entries) { + auto Add = [&Entries](uint16_t Tag) -> Elf_Dyn & { + Entries.emplace_back(); + Elf_Dyn &Dyn = Entries.back(); + Dyn.d_tag = Tag; + return Dyn; + }; + if (Stub.SoName) + Add(DT_SONAME).d_un.d_val = StrTab.Content->getOffset(*Stub.SoName); + for (const auto &Needed : Stub.NeededLibs) + Add(DT_NEEDED).d_un.d_val = StrTab.Content->getOffset(Needed); + Add(DT_STRTAB).d_un.d_ptr = *StrTab.Addr; + Add(DT_STRSZ).d_un.d_ptr = *StrTab.Size; + Add(DT_SYMTAB).d_un.d_ptr = *DynSym.Addr; + Add(DT_SYMENT).d_un.d_ptr = sizeof(Elf_Sym); + // TODO: For compaitability a hash table would be useful. In particular + // llvm-elfabi currently only reads symbols from a hash table so it + // can't read its own output. eu-elflint also complains about this issue. + Add(DT_NULL); + }; + } + + // GetSize will effectivelly compute the whole layout. + size_t GetSize() const { + return ElfHeader->e_shoff + ElfHeader->e_shnum * sizeof(Elf_Shdr); + } + + void Write(uint8_t *Data) const { + Write(Data, *ElfHeader); + StrTab.Content->write(Data + StrTab.Shdr->sh_offset); + WriteLazyVector(Data + sizeof(Elf_Ehdr), ProgramHeaders); + WriteLazyVector(Data + DynSym.Shdr->sh_offset, DynSym.Content->Symbols); + WriteVector(Data + Dynamic.Shdr->sh_offset, *Dynamic.Content); + WriteShdr(Data, StrTab); + WriteShdr(Data, DynSym); + WriteShdr(Data, DefSec); + WriteShdr(Data, Dynamic); + } +}; + +/// 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) { + ELFBuilder 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(); +} + +} // 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(FilePath, Stub); + } else if (OutputFormat == ELFTarget::ELF32BE) { + return writeELFBinaryToFile(FilePath, Stub); + } else if (OutputFormat == ELFTarget::ELF64LE) { + return writeELFBinaryToFile(FilePath, Stub); + } else if (OutputFormat == ELFTarget::ELF64BE) { + return writeELFBinaryToFile(FilePath, Stub); + } + return createStringError(errc::invalid_argument, + "Invalid binary output target"); +} + Expected> readELFFile(MemoryBufferRef Buf) { Expected> BinOrErr = createBinary(Buf); if (!BinOrErr) { Index: llvm/tools/llvm-elfabi/llvm-elfabi.cpp =================================================================== --- llvm/tools/llvm-elfabi/llvm-elfabi.cpp +++ llvm/tools/llvm-elfabi/llvm-elfabi.cpp @@ -49,6 +49,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 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 +138,32 @@ 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) { 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); + } + } }