Index: test/tools/llvm-objcopy/basic-align-copy.test =================================================================== --- /dev/null +++ test/tools/llvm-objcopy/basic-align-copy.test @@ -0,0 +1,37 @@ +# RUN: yaml2obj %s -o %t +# RUN: llvm-objcopy -O binary %t %t2 +# RUN: od -t x2 %t2 | FileCheck %s +# RUN: wc -c < %t2 | FileCheck %s --check-prefix=SIZE + +!ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_EXEC + Machine: EM_X86_64 +Sections: + - Name: .text + Type: SHT_PROGBITS + Flags: [ SHF_ALLOC, SHF_EXECINSTR ] + AddressAlign: 0x0000000000001000 + Content: "c3c3c3c3" + - Name: .data + Type: SHT_PROGBITS + Flags: [ SHF_ALLOC, SHF_EXECINSTR ] + AddressAlign: 0x0000000000001000 + Content: "3232" +ProgramHeaders: + - Type: PT_LOAD + Flags: [ PF_X, PF_R ] + Sections: + - Section: .text + - Type: PT_LOAD + Flags: [ PF_R ] + Sections: + - Section: .data + +# CHECK: 0000000 c3c3 c3c3 0000 0000 0000 0000 0000 0000 +# CHECK-NEXT: 0000020 0000 0000 0000 0000 0000 0000 0000 0000 +# CHECK-NEXT: * +# CHECK-NEXT: 0010000 3232 +# SIZE: 4098 Index: test/tools/llvm-objcopy/basic-binary-copy.test =================================================================== --- /dev/null +++ test/tools/llvm-objcopy/basic-binary-copy.test @@ -0,0 +1,25 @@ +# RUN: yaml2obj %s -o %t +# RUN: llvm-objcopy -O binary %t %t2 +# RUN: od -t x2 -v %t2 | FileCheck %s +# RUN: wc -c < %t2 | FileCheck %s --check-prefix=SIZE + +!ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_EXEC + Machine: EM_X86_64 +Sections: + - Name: .text + Type: SHT_PROGBITS + Flags: [ SHF_ALLOC, SHF_EXECINSTR ] + AddressAlign: 0x0000000000001000 + Content: "c3c3c3c3" +ProgramHeaders: + - Type: PT_LOAD + Flags: [ PF_X, PF_R ] + Sections: + - Section: .text + +# CHECK: 0000000 c3c3 c3c3 +# SIZE: 4 Index: tools/llvm-objcopy/LLVMBuild.txt =================================================================== --- tools/llvm-objcopy/LLVMBuild.txt +++ tools/llvm-objcopy/LLVMBuild.txt @@ -18,4 +18,4 @@ type = Tool name = llvm-objcopy parent = Tools -required_libraries = Object MC +required_libraries = Object Support MC Index: tools/llvm-objcopy/Object.h =================================================================== --- tools/llvm-objcopy/Object.h +++ tools/llvm-objcopy/Object.h @@ -58,6 +58,7 @@ }; std::set Sections; + llvm::ArrayRef Contents; public: uint64_t Align; @@ -70,6 +71,7 @@ uint64_t Type; uint64_t VAddr; + Segment(llvm::ArrayRef Data) : Contents(Data) {} void finalize(); const SectionBase *firstSection() const { if (!Sections.empty()) @@ -78,6 +80,7 @@ } void addSection(const SectionBase *sec) { Sections.insert(sec); } template void writeHeader(llvm::FileOutputBuffer &Out) const; + void writeSegment(llvm::FileOutputBuffer &Out) const; }; class Section : public SectionBase { @@ -117,16 +120,16 @@ typedef typename ELFT::Ehdr Elf_Ehdr; typedef typename ELFT::Phdr Elf_Phdr; - StringTableSection *SectionNames; - std::vector Sections; - std::vector Segments; - - void sortSections(); - void assignOffsets(); SecPtr makeSection(const llvm::object::ELFFile &ElfFile, const Elf_Shdr &Shdr); void readProgramHeaders(const llvm::object::ELFFile &ElfFile); void readSectionHeaders(const llvm::object::ELFFile &ElfFile); + +protected: + StringTableSection *SectionNames; + std::vector Sections; + std::vector Segments; + void writeHeader(llvm::FileOutputBuffer &Out) const; void writeProgramHeaders(llvm::FileOutputBuffer &Out) const; void writeSectionData(llvm::FileOutputBuffer &Out) const; @@ -142,9 +145,43 @@ uint32_t Flags; Object(const llvm::object::ELFObjectFile &Obj); - size_t totalSize() const; - void finalize(); - void write(llvm::FileOutputBuffer &Out); + virtual size_t totalSize() const = 0; + virtual void finalize() = 0; + virtual void write(llvm::FileOutputBuffer &Out) const = 0; + virtual ~Object() = default; +}; + +template class ELFObject : public Object { +private: + typedef std::unique_ptr SecPtr; + typedef std::unique_ptr SegPtr; + + typedef typename ELFT::Shdr Elf_Shdr; + typedef typename ELFT::Ehdr Elf_Ehdr; + typedef typename ELFT::Phdr Elf_Phdr; + + void sortSections(); + void assignOffsets(); + +public: + ELFObject(const llvm::object::ELFObjectFile &Obj) : Object(Obj) {} + void finalize() override; + size_t totalSize() const override; + void write(llvm::FileOutputBuffer &Out) const override; }; +template class BinaryObject : public Object { +private: + typedef std::unique_ptr SecPtr; + typedef std::unique_ptr SegPtr; + + uint64_t TotalSize; + +public: + BinaryObject(const llvm::object::ELFObjectFile &Obj) + : Object(Obj) {} + void finalize() override; + size_t totalSize() const override; + void write(llvm::FileOutputBuffer &Out) const override; +}; #endif Index: tools/llvm-objcopy/Object.cpp =================================================================== --- tools/llvm-objcopy/Object.cpp +++ tools/llvm-objcopy/Object.cpp @@ -42,6 +42,13 @@ } } +void Segment::writeSegment(FileOutputBuffer &Out) const { + uint8_t *Buf = Out.getBufferStart() + Offset; + // We want to maintain segments' interstitial data and contents exactly. + // This lets us just copy segments directly. + std::copy(std::begin(Contents), std::end(Contents), Buf); +} + void SectionBase::finalize() {} template @@ -99,7 +106,9 @@ void Object::readProgramHeaders(const ELFFile &ElfFile) { uint32_t Index = 0; for (const auto &Phdr : unwrapOrError(ElfFile.program_headers())) { - Segments.emplace_back(llvm::make_unique()); + ArrayRef Data{ElfFile.base() + Phdr.p_offset, + (size_t)Phdr.p_filesz}; + Segments.emplace_back(llvm::make_unique(Data)); Segment &Seg = *Segments.back(); Seg.Type = Phdr.p_type; Seg.Flags = Phdr.p_flags; @@ -135,7 +144,7 @@ default: Data = unwrapOrError(ElfFile.getSectionContents(&Shdr)); return llvm::make_unique
(Data); - }; + } } template @@ -163,12 +172,6 @@ } } -template size_t Object::totalSize() const { - // We already have the section header offset so we can calculate the total - // size by just adding up the size of each section header. - return SHOffset + Sections.size() * sizeof(Elf_Shdr) + sizeof(Elf_Shdr); -} - template Object::Object(const ELFObjectFile &Obj) { const auto &ElfFile = *Obj.getELFFile(); const auto &Ehdr = *ElfFile.getHeader(); @@ -187,22 +190,76 @@ dyn_cast(Sections[Ehdr.e_shstrndx - 1].get()); } -template void Object::sortSections() { +template +void Object::writeHeader(FileOutputBuffer &Out) const { + uint8_t *Buf = Out.getBufferStart(); + Elf_Ehdr &Ehdr = *reinterpret_cast(Buf); + std::copy(Ident, Ident + 16, Ehdr.e_ident); + Ehdr.e_type = Type; + Ehdr.e_machine = Machine; + Ehdr.e_version = Version; + Ehdr.e_entry = Entry; + Ehdr.e_phoff = sizeof(Elf_Ehdr); + Ehdr.e_shoff = SHOffset; + Ehdr.e_flags = Flags; + Ehdr.e_ehsize = sizeof(Elf_Ehdr); + Ehdr.e_phentsize = sizeof(Elf_Phdr); + Ehdr.e_phnum = Segments.size(); + Ehdr.e_shentsize = sizeof(Elf_Shdr); + Ehdr.e_shnum = Sections.size() + 1; + Ehdr.e_shstrndx = SectionNames->Index; +} + +template +void Object::writeProgramHeaders(FileOutputBuffer &Out) const { + for (auto &Phdr : Segments) + Phdr->template writeHeader(Out); +} + +template +void Object::writeSectionHeaders(FileOutputBuffer &Out) const { + uint8_t *Buf = Out.getBufferStart() + SHOffset; + // This reference serves to write the dummy section header at the begining + // of the file. + Elf_Shdr &Shdr = *reinterpret_cast(Buf); + Shdr.sh_name = 0; + Shdr.sh_type = SHT_NULL; + Shdr.sh_flags = 0; + Shdr.sh_addr = 0; + Shdr.sh_offset = 0; + Shdr.sh_size = 0; + Shdr.sh_link = 0; + Shdr.sh_info = 0; + Shdr.sh_addralign = 0; + Shdr.sh_entsize = 0; + + for (auto &Section : Sections) + Section->template writeHeader(Out); +} + +template +void Object::writeSectionData(FileOutputBuffer &Out) const { + for (auto &Section : Sections) + Section->writeSection(Out); +} + +template void ELFObject::sortSections() { // Put all sections in offset order. Maintain the ordering as closely as // possible while meeting that demand however. auto CompareSections = [](const SecPtr &A, const SecPtr &B) { return A->OriginalOffset < B->OriginalOffset; }; - std::stable_sort(std::begin(Sections), std::end(Sections), CompareSections); + std::stable_sort(std::begin(this->Sections), std::end(this->Sections), + CompareSections); } -template void Object::assignOffsets() { +template void ELFObject::assignOffsets() { // Decide file offsets and indexes. - size_t PhdrSize = Segments.size() * sizeof(Elf_Phdr); + size_t PhdrSize = this->Segments.size() * sizeof(Elf_Phdr); // We can put section data after the ELF header and the program headers. uint64_t Offset = sizeof(Elf_Ehdr) + PhdrSize; uint64_t Index = 1; - for (auto &Section : Sections) { + for (auto &Section : this->Sections) { // The segment can have a different alignment than the section. In the case // that there is a parent segment then as long as we satisfy the alignment // of the segment it should follow that that the section is aligned. @@ -249,93 +306,93 @@ // this needs to be 4-byte aligned and on 64-bit it needs to be 8-byte aligned // so the size of ELFT::Addr is used to ensure this. Offset = alignTo(Offset, sizeof(typename ELFT::Addr)); - SHOffset = Offset; + this->SHOffset = Offset; } -template void Object::finalize() { - for (auto &Section : Sections) - SectionNames->addString(Section->Name); +template size_t ELFObject::totalSize() const { + // We already have the section header offset so we can calculate the total + // size by just adding up the size of each section header. + return this->SHOffset + this->Sections.size() * sizeof(Elf_Shdr) + + sizeof(Elf_Shdr); +} + +template void ELFObject::write(FileOutputBuffer &Out) const { + this->writeHeader(Out); + this->writeProgramHeaders(Out); + this->writeSectionData(Out); + this->writeSectionHeaders(Out); +} + +template void ELFObject::finalize() { + for (const auto &Section : this->Sections) { + this->SectionNames->addString(Section->Name); + } sortSections(); assignOffsets(); // Finalize SectionNames first so that we can assign name indexes. - SectionNames->finalize(); + this->SectionNames->finalize(); // Finally now that all offsets and indexes have been set we can finalize any // remaining issues. - uint64_t Offset = SHOffset + sizeof(Elf_Shdr); - for (auto &Section : Sections) { + uint64_t Offset = this->SHOffset + sizeof(Elf_Shdr); + for (auto &Section : this->Sections) { Section->HeaderOffset = Offset; Offset += sizeof(Elf_Shdr); - Section->NameIndex = SectionNames->findIndex(Section->Name); + Section->NameIndex = this->SectionNames->findIndex(Section->Name); Section->finalize(); } - for (auto &Segment : Segments) + for (auto &Segment : this->Segments) Segment->finalize(); } -template -void Object::writeHeader(FileOutputBuffer &Out) const { - uint8_t *Buf = Out.getBufferStart(); - Elf_Ehdr &Ehdr = *reinterpret_cast(Buf); - std::copy(Ident, Ident + 16, Ehdr.e_ident); - Ehdr.e_type = Type; - Ehdr.e_machine = Machine; - Ehdr.e_version = Version; - Ehdr.e_entry = Entry; - Ehdr.e_phoff = sizeof(Elf_Ehdr); - Ehdr.e_shoff = SHOffset; - Ehdr.e_flags = Flags; - Ehdr.e_ehsize = sizeof(Elf_Ehdr); - Ehdr.e_phentsize = sizeof(Elf_Phdr); - Ehdr.e_phnum = Segments.size(); - Ehdr.e_shentsize = sizeof(Elf_Shdr); - Ehdr.e_shnum = Sections.size() + 1; - Ehdr.e_shstrndx = SectionNames->Index; -} - -template -void Object::writeProgramHeaders(FileOutputBuffer &Out) const { - for (auto &Phdr : Segments) - Phdr->template writeHeader(Out); +template size_t BinaryObject::totalSize() const { + return TotalSize; } template -void Object::writeSectionHeaders(FileOutputBuffer &Out) const { - uint8_t *Buf = Out.getBufferStart() + SHOffset; - // This reference serves to write the dummy section header at the begining - // of the file. - Elf_Shdr &Shdr = *reinterpret_cast(Buf); - Shdr.sh_name = 0; - Shdr.sh_type = SHT_NULL; - Shdr.sh_flags = 0; - Shdr.sh_addr = 0; - Shdr.sh_offset = 0; - Shdr.sh_size = 0; - Shdr.sh_link = 0; - Shdr.sh_info = 0; - Shdr.sh_addralign = 0; - Shdr.sh_entsize = 0; - - for (auto &Section : Sections) - Section->template writeHeader(Out); +void BinaryObject::write(FileOutputBuffer &Out) const { + for (auto &Segment : this->Segments) { + if (Segment->Type == llvm::ELF::PT_LOAD) { + Segment->writeSegment(Out); + } + } } -template -void Object::writeSectionData(FileOutputBuffer &Out) const { - for (auto &Section : Sections) - Section->writeSection(Out); -} +template void BinaryObject::finalize() { + for (auto &Segment : this->Segments) + Segment->finalize(); -template void Object::write(FileOutputBuffer &Out) { - writeHeader(Out); - writeProgramHeaders(Out); - writeSectionData(Out); - writeSectionHeaders(Out); + // Put all segments in offset order. + auto CompareSegments = [](const SegPtr &A, const SegPtr &B) { + return A->Offset < B->Offset; + }; + std::sort(std::begin(this->Segments), std::end(this->Segments), + CompareSegments); + + uint64_t Offset = 0; + for (auto &Segment : this->Segments) { + if (Segment->Type == llvm::ELF::PT_LOAD) { + Offset = alignTo(Offset, Segment->Align); + Segment->Offset = Offset; + Offset += Segment->FileSize; + } + } + TotalSize = Offset; } template class Object; template class Object; template class Object; template class Object; + +template class ELFObject; +template class ELFObject; +template class ELFObject; +template class ELFObject; + +template class BinaryObject; +template class BinaryObject; +template class BinaryObject; +template class BinaryObject; Index: tools/llvm-objcopy/llvm-objcopy.cpp =================================================================== --- tools/llvm-objcopy/llvm-objcopy.cpp +++ tools/llvm-objcopy/llvm-objcopy.cpp @@ -53,13 +53,23 @@ cl::opt InputFilename(cl::Positional, cl::desc("")); cl::opt OutputFilename(cl::Positional, cl::desc(""), cl::init("-")); +cl::opt + OutputFormat("O", cl::desc("set output format to one of the following:" + "\n\tbinary")); void CopyBinary(const ELFObjectFile &ObjFile) { std::unique_ptr Buffer; - Object Obj{ObjFile}; - Obj.finalize(); + std::unique_ptr> Obj; + if (!OutputFormat.empty() && OutputFormat != "binary") + error("invalid output format '" + OutputFormat + "'"); + + if (!OutputFormat.empty() && OutputFormat == "binary") + Obj = llvm::make_unique>(ObjFile); + else + Obj = llvm::make_unique>(ObjFile); + Obj->finalize(); ErrorOr> BufferOrErr = - FileOutputBuffer::create(OutputFilename, Obj.totalSize(), + FileOutputBuffer::create(OutputFilename, Obj->totalSize(), FileOutputBuffer::F_executable); if (BufferOrErr.getError()) error("failed to open " + OutputFilename); @@ -68,7 +78,7 @@ std::error_code EC; if (EC) report_fatal_error(EC.message()); - Obj.write(*Buffer); + Obj->write(*Buffer); if (auto EC = Buffer->commit()) reportError(OutputFilename, EC); }