RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity

[llvm][llvm-objcopy] Added support for outputting to binary in llvm-objcopy

Browse Source 
This change adds the "-O binary" flag which directs llvm-objcopy to
output the object file to the same format as GNU objcopy does when given
the flag "-O binary". This was done by splitting the Object class into
two subclasses ObjectELF and ObjectBianry which each output a different
format but relay on the same code to read in the Object in Object.

Patch by Jake Ehrlich

Differential Revision: https://reviews.llvm.org/D34480

llvm-svn: 309658
This commit is contained in:
Petr Hosek 2017-08-01 05:18:30 +00:00
parent da86042768
commit f01a57df58
6 changed files with 279 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
test/tools/llvm-objcopy/basic-align-copy.test Normal file
View File

@ -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: "32"
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 0032
# SIZE: 4097

25
test/tools/llvm-objcopy/basic-binary-copy.test Normal file
View File

@ -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

2
tools/llvm-objcopy/LLVMBuild.txt
View File

@ -18,4 +18,4 @@
type = Tool
name = llvm-objcopy
parent = Tools
required_libraries = Object MC
required_libraries = Object Support MC

261
tools/llvm-objcopy/Object.cpp
View File

@ -42,6 +42,13 @@ void Segment::finalize() {
}
}
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 <class ELFT>
@ -99,7 +106,8 @@ template <class ELFT>
void Object<ELFT>::readProgramHeaders(const ELFFile<ELFT> &ElfFile) {
uint32_t Index = 0;
for (const auto &Phdr : unwrapOrError(ElfFile.program_headers())) {
Segments.emplace_back(llvm::make_unique<Segment>());
ArrayRef<uint8_t> Data{ElfFile.base() + Phdr.p_offset, Phdr.p_filesz};
Segments.emplace_back(llvm::make_unique<Segment>(Data));
Segment &Seg = *Segments.back();
Seg.Type = Phdr.p_type;
Seg.Flags = Phdr.p_flags;
@ -135,7 +143,7 @@ Object<ELFT>::makeSection(const llvm::object::ELFFile<ELFT> &ElfFile,
default:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return llvm::make_unique<Section>(Data);
};
}
}
template <class ELFT>
@ -163,12 +171,6 @@ void Object<ELFT>::readSectionHeaders(const ELFFile<ELFT> &ElfFile) {
}
}
template <class ELFT> size_t Object<ELFT>::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 <class ELFT> Object<ELFT>::Object(const ELFObjectFile<ELFT> &Obj) {
const auto &ElfFile = *Obj.getELFFile();
const auto &Ehdr = *ElfFile.getHeader();
@ -187,94 +189,6 @@ template <class ELFT> Object<ELFT>::Object(const ELFObjectFile<ELFT> &Obj) {
dyn_cast<StringTableSection>(Sections[Ehdr.e_shstrndx - 1].get());
}
template <class ELFT> void Object<ELFT>::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);
}
template <class ELFT> void Object<ELFT>::assignOffsets() {
// Decide file offsets and indexes.
size_t PhdrSize = 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) {
// 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.
if (Section->ParentSegment) {
auto FirstInSeg = Section->ParentSegment->firstSection();
if (FirstInSeg == Section.get()) {
Offset = alignTo(Offset, Section->ParentSegment->Align);
// There can be gaps at the start of a segment before the first section.
// So first we assign the alignment of the segment and then assign the
// location of the section from there
Section->Offset =
Offset + Section->OriginalOffset - Section->ParentSegment->Offset;
}
// We should respect interstitial gaps of allocated sections. We *must*
// maintain the memory image so that addresses are preserved. As, with the
// exception of SHT_NOBITS sections at the end of segments, the memory
// image is a copy of the file image, we preserve the file image as well.
// There's a strange case where a thread local SHT_NOBITS can cause the
// memory image and file image to not be the same. This occurs, on some
// systems, when a thread local SHT_NOBITS is between two SHT_PROGBITS
// and the thread local SHT_NOBITS section is at the end of a TLS segment.
// In this case to faithfully copy the segment file image we must use
// relative offsets. In any other case this would be the same as using the
// relative addresses so this should maintian the memory image as desired.
Offset = FirstInSeg->Offset + Section->OriginalOffset -
FirstInSeg->OriginalOffset;
}
// Alignment should have already been handled by the above if statement if
// this if this section is in a segment. Technically this shouldn't do
// anything bad if the alignments of the sections are all correct and the
// file image isn't corrupted. Still in sticking with the motto "maintain
// the file image" we should avoid messing up the file image if the
// alignment disagrees with the file image.
if (!Section->ParentSegment && Section->Align)
Offset = alignTo(Offset, Section->Align);
Section->Offset = Offset;
Section->Index = Index++;
if (Section->Type != SHT_NOBITS)
Offset += Section->Size;
}
// 'offset' should now be just after all the section data so we should set the
// section header table offset to be exactly here. This spot might not be
// aligned properly however so we should align it as needed. For 32-bit ELF
// 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;
}
template <class ELFT> void Object<ELFT>::finalize() {
for (auto &Section : Sections)
SectionNames->addString(Section->Name);
sortSections();
assignOffsets();
// Finalize SectionNames first so that we can assign name indexes.
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) {
Section->HeaderOffset = Offset;
Offset += sizeof(Elf_Shdr);
Section->NameIndex = SectionNames->findIndex(Section->Name);
Section->finalize();
}
for (auto &Segment : Segments)
Segment->finalize();
}
template <class ELFT>
void Object<ELFT>::writeHeader(FileOutputBuffer &Out) const {
uint8_t *Buf = Out.getBufferStart();
@ -328,14 +242,151 @@ void Object<ELFT>::writeSectionData(FileOutputBuffer &Out) const {
Section->writeSection(Out);
}
template <class ELFT> void Object<ELFT>::write(FileOutputBuffer &Out) {
writeHeader(Out);
writeProgramHeaders(Out);
writeSectionData(Out);
writeSectionHeaders(Out);
template <class ELFT> void ELFObject<ELFT>::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(this->Sections), std::end(this->Sections),
CompareSections);
}
template class Object<ELF64LE>;
template class Object<ELF64BE>;
template class Object<ELF32LE>;
template class Object<ELF32BE>;
template <class ELFT> void ELFObject<ELFT>::assignOffsets() {
// Decide file offsets and indexes.
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 : 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.
if (Section->ParentSegment) {
auto FirstInSeg = Section->ParentSegment->firstSection();
if (FirstInSeg == Section.get()) {
Offset = alignTo(Offset, Section->ParentSegment->Align);
// There can be gaps at the start of a segment before the first section.
// So first we assign the alignment of the segment and then assign the
// location of the section from there
Section->Offset =
Offset + Section->OriginalOffset - Section->ParentSegment->Offset;
}
// We should respect interstitial gaps of allocated sections. We *must*
// maintain the memory image so that addresses are preserved. As, with the
// exception of SHT_NOBITS sections at the end of segments, the memory
// image is a copy of the file image, we preserve the file image as well.
// There's a strange case where a thread local SHT_NOBITS can cause the
// memory image and file image to not be the same. This occurs, on some
// systems, when a thread local SHT_NOBITS is between two SHT_PROGBITS
// and the thread local SHT_NOBITS section is at the end of a TLS segment.
// In this case to faithfully copy the segment file image we must use
// relative offsets. In any other case this would be the same as using the
// relative addresses so this should maintian the memory image as desired.
Offset = FirstInSeg->Offset + Section->OriginalOffset -
FirstInSeg->OriginalOffset;
}
// Alignment should have already been handled by the above if statement if
// this if this section is in a segment. Technically this shouldn't do
// anything bad if the alignments of the sections are all correct and the
// file image isn't corrupted. Still in sticking with the motto "maintain
// the file image" we should avoid messing up the file image if the
// alignment disagrees with the file image.
if (!Section->ParentSegment && Section->Align)
Offset = alignTo(Offset, Section->Align);
Section->Offset = Offset;
Section->Index = Index++;
if (Section->Type != SHT_NOBITS)
Offset += Section->Size;
}
// 'offset' should now be just after all the section data so we should set the
// section header table offset to be exactly here. This spot might not be
// aligned properly however so we should align it as needed. For 32-bit ELF
// 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));
this->SHOffset = Offset;
}
template <class ELFT> size_t ELFObject<ELFT>::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 <class ELFT> void ELFObject<ELFT>::write(FileOutputBuffer &Out) const {
this->writeHeader(Out);
this->writeProgramHeaders(Out);
this->writeSectionData(Out);
this->writeSectionHeaders(Out);
}
template <class ELFT> void ELFObject<ELFT>::finalize() {
for (const auto &Section : this->Sections) {
this->SectionNames->addString(Section->Name);
}
sortSections();
assignOffsets();
// Finalize SectionNames first so that we can assign name indexes.
this->SectionNames->finalize();
// Finally now that all offsets and indexes have been set we can finalize any
// remaining issues.
uint64_t Offset = this->SHOffset + sizeof(Elf_Shdr);
for (auto &Section : this->Sections) {
Section->HeaderOffset = Offset;
Offset += sizeof(Elf_Shdr);
Section->NameIndex = this->SectionNames->findIndex(Section->Name);
Section->finalize();
}
for (auto &Segment : this->Segments)
Segment->finalize();
}
template <class ELFT> size_t BinaryObject<ELFT>::totalSize() const {
return TotalSize;
}
template <class ELFT>
void BinaryObject<ELFT>::write(FileOutputBuffer &Out) const {
for (auto &Segment : this->Segments) {
if (Segment->Type == llvm::ELF::PT_LOAD) {
Segment->writeSegment(Out);
}
}
}
template <class ELFT> void BinaryObject<ELFT>::finalize() {
for (auto &Segment : this->Segments)
Segment->finalize();
// 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 ELFObject<ELF64LE>;
template class ELFObject<ELF64BE>;
template class ELFObject<ELF32LE>;
template class ELFObject<ELF32BE>;
template class BinaryObject<ELF64LE>;
template class BinaryObject<ELF64BE>;
template class BinaryObject<ELF32LE>;
template class BinaryObject<ELF32BE>;

55
tools/llvm-objcopy/Object.h
View File

@ -58,6 +58,7 @@ private:
};
std::set<const SectionBase *, SectionCompare> Sections;
llvm::ArrayRef<uint8_t> Contents;
public:
uint64_t Align;
@ -70,6 +71,7 @@ public:
uint64_t Type;
uint64_t VAddr;
Segment(llvm::ArrayRef<uint8_t> Data) : Contents(Data) {}
void finalize();
const SectionBase *firstSection() const {
if (!Sections.empty())
@ -78,6 +80,7 @@ public:
}
void addSection(const SectionBase *sec) { Sections.insert(sec); }
template <class ELFT> void writeHeader(llvm::FileOutputBuffer &Out) const;
void writeSegment(llvm::FileOutputBuffer &Out) const;
};
class Section : public SectionBase {
@ -117,16 +120,16 @@ private:
typedef typename ELFT::Ehdr Elf_Ehdr;
typedef typename ELFT::Phdr Elf_Phdr;
StringTableSection *SectionNames;
std::vector<SecPtr> Sections;
std::vector<SegPtr> Segments;
void sortSections();
void assignOffsets();
SecPtr makeSection(const llvm::object::ELFFile<ELFT> &ElfFile,
const Elf_Shdr &Shdr);
void readProgramHeaders(const llvm::object::ELFFile<ELFT> &ElfFile);
void readSectionHeaders(const llvm::object::ELFFile<ELFT> &ElfFile);
protected:
StringTableSection *SectionNames;
std::vector<SecPtr> Sections;
std::vector<SegPtr> Segments;
void writeHeader(llvm::FileOutputBuffer &Out) const;
void writeProgramHeaders(llvm::FileOutputBuffer &Out) const;
void writeSectionData(llvm::FileOutputBuffer &Out) const;
@ -142,9 +145,43 @@ public:
uint32_t Flags;
Object(const llvm::object::ELFObjectFile<ELFT> &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 ELFT> class ELFObject : public Object<ELFT> {
private:
typedef std::unique_ptr<SectionBase> SecPtr;
typedef std::unique_ptr<Segment> 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<ELFT> &Obj) : Object<ELFT>(Obj) {}
void finalize() override;
size_t totalSize() const override;
void write(llvm::FileOutputBuffer &Out) const override;
};
template <class ELFT> class BinaryObject : public Object<ELFT> {
private:
typedef std::unique_ptr<SectionBase> SecPtr;
typedef std::unique_ptr<Segment> SegPtr;
uint64_t TotalSize;
public:
BinaryObject(const llvm::object::ELFObjectFile<ELFT> &Obj)
: Object<ELFT>(Obj) {}
void finalize() override;
size_t totalSize() const override;
void write(llvm::FileOutputBuffer &Out) const override;
};
#endif

18
tools/llvm-objcopy/llvm-objcopy.cpp
View File

@ -53,13 +53,23 @@ LLVM_ATTRIBUTE_NORETURN void reportError(StringRef File, llvm::Error E) {
cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input>"));
cl::opt<std::string> OutputFilename(cl::Positional, cl::desc("<output>"),
cl::init("-"));
cl::opt<std::string>
OutputFormat("O", cl::desc("set output format to one of the following:"
"\n\tbinary"));
void CopyBinary(const ELFObjectFile<ELF64LE> &ObjFile) {
std::unique_ptr<FileOutputBuffer> Buffer;
Object<ELF64LE> Obj{ObjFile};
Obj.finalize();
std::unique_ptr<Object<ELF64LE>> Obj;
if (!OutputFormat.empty() && OutputFormat != "binary")
error("invalid output format '" + OutputFormat + "'");
if (!OutputFormat.empty() && OutputFormat == "binary")
Obj = llvm::make_unique<BinaryObject<ELF64LE>>(ObjFile);
else
Obj = llvm::make_unique<ELFObject<ELF64LE>>(ObjFile);
Obj->finalize();
ErrorOr<std::unique_ptr<FileOutputBuffer>> 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 @@ void CopyBinary(const ELFObjectFile<ELF64LE> &ObjFile) {
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);
}