maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

tmp 

llvm-svn: 323463
This commit is contained in:
Jake Ehrlich 2018-01-25 20:24:17 +00:00
parent 896c1c0746
commit df35594077
7 changed files with 627 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
llvm/test/tools/llvm-objcopy/Inputs/alloc-symtab.o Normal file
View File

Binary file not shown.

2
llvm/test/tools/llvm-objcopy/binary-out-error.test Normal file
View File

@ -0,0 +1,2 @@
# RUN: not llvm-objcopy -O binary %p/Inputs/alloc-symtab.o %t2 2>&1 >/dev/null | FileCheck %s --check-prefix=SYMTAB
# SYMTAB: Cannot write symbol table '.symtab' out to binary

2
llvm/test/tools/llvm-objcopy/remove-shstrtab-error.test
View File

@ -8,4 +8,4 @@ FileHeader:
Type: ET_REL
Machine: EM_X86_64
# CHECK: Cannot remove .shstrtab because it is the section header string table.
# CHECK: Cannot write section header table because section header string table was removed.

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

@ -30,61 +30,73 @@ using namespace llvm;
using namespace object;
using namespace ELF;
template <class ELFT> void Segment::writeHeader(FileOutputBuffer &Out) const {
template <class ELFT> void ELFWriter<ELFT>::writePhdr(const Segment &Seg) {
using Elf_Ehdr = typename ELFT::Ehdr;
using Elf_Phdr = typename ELFT::Phdr;
uint8_t *Buf = Out.getBufferStart();
Buf += sizeof(Elf_Ehdr) + Index * sizeof(Elf_Phdr);
uint8_t *Buf = BufPtr->getBufferStart();
Buf += sizeof(Elf_Ehdr) + Seg.Index * sizeof(Elf_Phdr);
Elf_Phdr &Phdr = *reinterpret_cast<Elf_Phdr *>(Buf);
Phdr.p_type = Type;
Phdr.p_flags = Flags;
Phdr.p_offset = Offset;
Phdr.p_vaddr = VAddr;
Phdr.p_paddr = PAddr;
Phdr.p_filesz = FileSize;
Phdr.p_memsz = MemSize;
Phdr.p_align = Align;
}
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);
Phdr.p_type = Seg.Type;
Phdr.p_flags = Seg.Flags;
Phdr.p_offset = Seg.Offset;
Phdr.p_vaddr = Seg.VAddr;
Phdr.p_paddr = Seg.PAddr;
Phdr.p_filesz = Seg.FileSize;
Phdr.p_memsz = Seg.MemSize;
Phdr.p_align = Seg.Align;
}
void SectionBase::removeSectionReferences(const SectionBase *Sec) {}
void SectionBase::initialize(SectionTableRef SecTable) {}
void SectionBase::finalize() {}
template <class ELFT>
void SectionBase::writeHeader(FileOutputBuffer &Out) const {
uint8_t *Buf = Out.getBufferStart();
Buf += HeaderOffset;
template <class ELFT> void ELFWriter<ELFT>::writeShdr(const SectionBase &Sec) {
uint8_t *Buf = BufPtr->getBufferStart();
Buf += Sec.HeaderOffset;
typename ELFT::Shdr &Shdr = *reinterpret_cast<typename ELFT::Shdr *>(Buf);
Shdr.sh_name = NameIndex;
Shdr.sh_type = Type;
Shdr.sh_flags = Flags;
Shdr.sh_addr = Addr;
Shdr.sh_offset = Offset;
Shdr.sh_size = Size;
Shdr.sh_link = Link;
Shdr.sh_info = Info;
Shdr.sh_addralign = Align;
Shdr.sh_entsize = EntrySize;
Shdr.sh_name = Sec.NameIndex;
Shdr.sh_type = Sec.Type;
Shdr.sh_flags = Sec.Flags;
Shdr.sh_addr = Sec.Addr;
Shdr.sh_offset = Sec.Offset;
Shdr.sh_size = Sec.Size;
Shdr.sh_link = Sec.Link;
Shdr.sh_info = Sec.Info;
Shdr.sh_addralign = Sec.Align;
Shdr.sh_entsize = Sec.EntrySize;
}
void Section::writeSection(FileOutputBuffer &Out) const {
if (Type == SHT_NOBITS)
SectionVisitor::~SectionVisitor() {}
void BinarySectionWriter::visit(const SymbolTableSection &Sec) {
error("Cannot write symbol table '" + Sec.Name + "' out to binary");
}
void BinarySectionWriter::visit(const RelocationSection &Sec) {
error("Cannot write relocation section '" + Sec.Name + "' out to binary");
}
void BinarySectionWriter::visit(const GnuDebugLinkSection &Sec) {
error("Cannot write '.gnu_debuglink' out to binary");
}
void SectionWriter::visit(const Section &Sec) {
if (Sec.Type == SHT_NOBITS)
return;
uint8_t *Buf = Out.getBufferStart() + Offset;
std::copy(std::begin(Contents), std::end(Contents), Buf);
uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
std::copy(std::begin(Sec.Contents), std::end(Sec.Contents), Buf);
}
void OwnedDataSection::writeSection(FileOutputBuffer &Out) const {
uint8_t *Buf = Out.getBufferStart() + Offset;
std::copy(std::begin(Data), std::end(Data), Buf);
void Section::accept(SectionVisitor &Visitor) const { Visitor.visit(*this); }
void SectionWriter::visit(const OwnedDataSection &Sec) {
uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
std::copy(std::begin(Sec.Data), std::end(Sec.Data), Buf);
}
void OwnedDataSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void StringTableSection::addString(StringRef Name) {
@ -98,8 +110,12 @@ uint32_t StringTableSection::findIndex(StringRef Name) const {
void StringTableSection::finalize() { StrTabBuilder.finalize(); }
void StringTableSection::writeSection(FileOutputBuffer &Out) const {
StrTabBuilder.write(Out.getBufferStart() + Offset);
void SectionWriter::visit(const StringTableSection &Sec) {
Sec.StrTabBuilder.write(Out.getBufferStart() + Sec.Offset);
}
void StringTableSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
static bool isValidReservedSectionIndex(uint16_t Index, uint16_t Machine) {
@ -234,12 +250,12 @@ const Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) const {
}
template <class ELFT>
void SymbolTableSectionImpl<ELFT>::writeSection(FileOutputBuffer &Out) const {
void ELFSectionWriter<ELFT>::visit(const SymbolTableSection &Sec) {
uint8_t *Buf = Out.getBufferStart();
Buf += Offset;
Buf += Sec.Offset;
typename ELFT::Sym *Sym = reinterpret_cast<typename ELFT::Sym *>(Buf);
// Loop though symbols setting each entry of the symbol table.
for (auto &Symbol : Symbols) {
for (auto &Symbol : Sec.Symbols) {
Sym->st_name = Symbol->NameIndex;
Sym->st_value = Symbol->Value;
Sym->st_size = Symbol->Size;
@ -251,6 +267,10 @@ void SymbolTableSectionImpl<ELFT>::writeSection(FileOutputBuffer &Out) const {
}
}
void SymbolTableSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
template <class SymTabType>
void RelocSectionWithSymtabBase<SymTabType>::removeSectionReferences(
const SectionBase *Sec) {
@ -294,9 +314,8 @@ void setAddend(Elf_Rel_Impl<ELFT, true> &Rela, uint64_t Addend) {
Rela.r_addend = Addend;
}
template <class ELFT>
template <class T>
void RelocationSection<ELFT>::writeRel(T *Buf) const {
template <class RelRange, class T>
void writeRel(const RelRange &Relocations, T *Buf) {
for (const auto &Reloc : Relocations) {
Buf->r_offset = Reloc.Offset;
setAddend(*Buf, Reloc.Addend);
@ -306,17 +325,25 @@ void RelocationSection<ELFT>::writeRel(T *Buf) const {
}
template <class ELFT>
void RelocationSection<ELFT>::writeSection(FileOutputBuffer &Out) const {
uint8_t *Buf = Out.getBufferStart() + Offset;
if (Type == SHT_REL)
writeRel(reinterpret_cast<Elf_Rel *>(Buf));
void ELFSectionWriter<ELFT>::visit(const RelocationSection &Sec) {
uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
if (Sec.Type == SHT_REL)
writeRel(Sec.Relocations, reinterpret_cast<Elf_Rel *>(Buf));
else
writeRel(reinterpret_cast<Elf_Rela *>(Buf));
writeRel(Sec.Relocations, reinterpret_cast<Elf_Rela *>(Buf));
}
void DynamicRelocationSection::writeSection(FileOutputBuffer &Out) const {
std::copy(std::begin(Contents), std::end(Contents),
Out.getBufferStart() + Offset);
void RelocationSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void SectionWriter::visit(const DynamicRelocationSection &Sec) {
std::copy(std::begin(Sec.Contents), std::end(Sec.Contents),
Out.getBufferStart() + Sec.Offset);
}
void DynamicRelocationSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void SectionWithStrTab::removeSectionReferences(const SectionBase *Sec) {
@ -344,8 +371,7 @@ void SectionWithStrTab::initialize(SectionTableRef SecTable) {
void SectionWithStrTab::finalize() { this->Link = StrTab->Index; }
template <class ELFT>
void GnuDebugLinkSection<ELFT>::init(StringRef File, StringRef Data) {
void GnuDebugLinkSection::init(StringRef File, StringRef Data) {
FileName = sys::path::stem(File);
// The format for the .gnu_debuglink starts with the stemmed file name and is
// followed by a null terminator and then the CRC32 of the file. The CRC32
@ -368,9 +394,7 @@ void GnuDebugLinkSection<ELFT>::init(StringRef File, StringRef Data) {
CRC32 = ~crc.getCRC();
}
template <class ELFT>
GnuDebugLinkSection<ELFT>::GnuDebugLinkSection(StringRef File)
: FileName(File) {
GnuDebugLinkSection::GnuDebugLinkSection(StringRef File) : FileName(File) {
// Read in the file to compute the CRC of it.
auto DebugOrErr = MemoryBuffer::getFile(File);
if (!DebugOrErr)
@ -380,12 +404,17 @@ GnuDebugLinkSection<ELFT>::GnuDebugLinkSection(StringRef File)
}
template <class ELFT>
void GnuDebugLinkSection<ELFT>::writeSection(FileOutputBuffer &Out) const {
auto Buf = Out.getBufferStart() + Offset;
void ELFSectionWriter<ELFT>::visit(const GnuDebugLinkSection &Sec) {
auto Buf = Out.getBufferStart() + Sec.Offset;
char *File = reinterpret_cast<char *>(Buf);
Elf_Word *CRC = reinterpret_cast<Elf_Word *>(Buf + Size - sizeof(Elf_Word));
*CRC = CRC32;
std::copy(std::begin(FileName), std::end(FileName), File);
Elf_Word *CRC =
reinterpret_cast<Elf_Word *>(Buf + Sec.Size - sizeof(Elf_Word));
*CRC = Sec.CRC32;
std::copy(std::begin(Sec.FileName), std::end(Sec.FileName), File);
}
void GnuDebugLinkSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
// Returns true IFF a section is wholly inside the range of a segment
@ -427,14 +456,12 @@ static bool compareSegmentsByPAddr(const Segment *A, const Segment *B) {
return A->Index < B->Index;
}
template <class ELFT>
void Object<ELFT>::readProgramHeaders(const ELFFile<ELFT> &ElfFile) {
template <class ELFT> void ELFBuilder<ELFT>::readProgramHeaders() {
uint32_t Index = 0;
for (const auto &Phdr : unwrapOrError(ElfFile.program_headers())) {
ArrayRef<uint8_t> Data{ElfFile.base() + Phdr.p_offset,
(size_t)Phdr.p_filesz};
Segments.emplace_back(llvm::make_unique<Segment>(Data));
Segment &Seg = *Segments.back();
Segment &Seg = Obj.addSegment(Data);
Seg.Type = Phdr.p_type;
Seg.Flags = Phdr.p_flags;
Seg.OriginalOffset = Phdr.p_offset;
@ -445,29 +472,29 @@ void Object<ELFT>::readProgramHeaders(const ELFFile<ELFT> &ElfFile) {
Seg.MemSize = Phdr.p_memsz;
Seg.Align = Phdr.p_align;
Seg.Index = Index++;
for (auto &Section : Sections) {
if (sectionWithinSegment(*Section, Seg)) {
Seg.addSection(&*Section);
if (!Section->ParentSegment ||
Section->ParentSegment->Offset > Seg.Offset) {
Section->ParentSegment = &Seg;
for (auto &Section : Obj.sections()) {
if (sectionWithinSegment(Section, Seg)) {
Seg.addSection(&Section);
if (!Section.ParentSegment ||
Section.ParentSegment->Offset > Seg.Offset) {
Section.ParentSegment = &Seg;
}
}
}
}
// Now we do an O(n^2) loop through the segments in order to match up
// segments.
for (auto &Child : Segments) {
for (auto &Parent : Segments) {
for (auto &Child : Obj.segments()) {
for (auto &Parent : Obj.segments()) {
// Every segment will overlap with itself but we don't want a segment to
// be it's own parent so we avoid that situation.
if (&Child != &Parent && segmentOverlapsSegment(*Child, *Parent)) {
if (&Child != &Parent && segmentOverlapsSegment(Child, Parent)) {
// We want a canonical "most parental" segment but this requires
// inspecting the ParentSegment.
if (compareSegmentsByOffset(Parent.get(), Child.get()))
if (Child->ParentSegment == nullptr ||
compareSegmentsByOffset(Parent.get(), Child->ParentSegment)) {
Child->ParentSegment = Parent.get();
if (compareSegmentsByOffset(&Parent, &Child))
if (Child.ParentSegment == nullptr ||
compareSegmentsByOffset(&Parent, Child.ParentSegment)) {
Child.ParentSegment = &Parent;
}
}
}
@ -475,9 +502,7 @@ void Object<ELFT>::readProgramHeaders(const ELFFile<ELFT> &ElfFile) {
}
template <class ELFT>
void Object<ELFT>::initSymbolTable(const object::ELFFile<ELFT> &ElfFile,
SymbolTableSection *SymTab,
SectionTableRef SecTable) {
void ELFBuilder<ELFT>::initSymbolTable(SymbolTableSection *SymTab) {
const Elf_Shdr &Shdr = *unwrapOrError(ElfFile.getSection(SymTab->Index));
StringRef StrTabData = unwrapOrError(ElfFile.getStringTableForSymtab(Shdr));
@ -486,14 +511,14 @@ void Object<ELFT>::initSymbolTable(const object::ELFFile<ELFT> &ElfFile,
StringRef Name = unwrapOrError(Sym.getName(StrTabData));
if (Sym.st_shndx >= SHN_LORESERVE) {
if (!isValidReservedSectionIndex(Sym.st_shndx, Machine)) {
if (!isValidReservedSectionIndex(Sym.st_shndx, Obj.Machine)) {
error(
"Symbol '" + Name +
"' has unsupported value greater than or equal to SHN_LORESERVE: " +
Twine(Sym.st_shndx));
}
} else if (Sym.st_shndx != SHN_UNDEF) {
DefSection = SecTable.getSection(
DefSection = Obj.sections().getSection(
Sym.st_shndx,
"Symbol '" + Name + "' is defined in invalid section with index " +
Twine(Sym.st_shndx));
@ -512,9 +537,9 @@ static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, true> &Rela) {
ToSet = Rela.r_addend;
}
template <class ELFT, class T>
void initRelocations(RelocationSection<ELFT> *Relocs,
SymbolTableSection *SymbolTable, T RelRange) {
template <class T>
void initRelocations(RelocationSection *Relocs, SymbolTableSection *SymbolTable,
T RelRange) {
for (const auto &Rel : RelRange) {
Relocation ToAdd;
ToAdd.Offset = Rel.r_offset;
@ -540,147 +565,190 @@ T *SectionTableRef::getSectionOfType(uint16_t Index, Twine IndexErrMsg,
}
template <class ELFT>
std::unique_ptr<SectionBase>
Object<ELFT>::makeSection(const object::ELFFile<ELFT> &ElfFile,
const Elf_Shdr &Shdr) {
SectionBase &ELFBuilder<ELFT>::makeSection(const Elf_Shdr &Shdr) {
ArrayRef<uint8_t> Data;
switch (Shdr.sh_type) {
case SHT_REL:
case SHT_RELA:
if (Shdr.sh_flags & SHF_ALLOC) {
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return llvm::make_unique<DynamicRelocationSection>(Data);
return Obj.addSection<DynamicRelocationSection>(Data);
}
return llvm::make_unique<RelocationSection<ELFT>>();
return Obj.addSection<RelocationSection>();
case SHT_STRTAB:
// If a string table is allocated we don't want to mess with it. That would
// mean altering the memory image. There are no special link types or
// anything so we can just use a Section.
if (Shdr.sh_flags & SHF_ALLOC) {
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return llvm::make_unique<Section>(Data);
return Obj.addSection<Section>(Data);
}
return llvm::make_unique<StringTableSection>();
return Obj.addSection<StringTableSection>();
case SHT_HASH:
case SHT_GNU_HASH:
// Hash tables should refer to SHT_DYNSYM which we're not going to change.
// Because of this we don't need to mess with the hash tables either.
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return llvm::make_unique<Section>(Data);
return Obj.addSection<Section>(Data);
case SHT_DYNSYM:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return llvm::make_unique<DynamicSymbolTableSection>(Data);
return Obj.addSection<DynamicSymbolTableSection>(Data);
case SHT_DYNAMIC:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return llvm::make_unique<DynamicSection>(Data);
return Obj.addSection<DynamicSection>(Data);
case SHT_SYMTAB: {
auto SymTab = llvm::make_unique<SymbolTableSectionImpl<ELFT>>();
SymbolTable = SymTab.get();
return std::move(SymTab);
auto &SymTab = Obj.addSection<SymbolTableSection>();
Obj.SymbolTable = &SymTab;
return SymTab;
}
case SHT_NOBITS:
return llvm::make_unique<Section>(Data);
return Obj.addSection<Section>(Data);
default:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return llvm::make_unique<Section>(Data);
return Obj.addSection<Section>(Data);
}
}
template <class ELFT>
SectionTableRef Object<ELFT>::readSectionHeaders(const ELFFile<ELFT> &ElfFile) {
template <class ELFT> void ELFBuilder<ELFT>::readSectionHeaders() {
uint32_t Index = 0;
for (const auto &Shdr : unwrapOrError(ElfFile.sections())) {
if (Index == 0) {
++Index;
continue;
}
SecPtr Sec = makeSection(ElfFile, Shdr);
Sec->Name = unwrapOrError(ElfFile.getSectionName(&Shdr));
Sec->Type = Shdr.sh_type;
Sec->Flags = Shdr.sh_flags;
Sec->Addr = Shdr.sh_addr;
Sec->Offset = Shdr.sh_offset;
Sec->OriginalOffset = Shdr.sh_offset;
Sec->Size = Shdr.sh_size;
Sec->Link = Shdr.sh_link;
Sec->Info = Shdr.sh_info;
Sec->Align = Shdr.sh_addralign;
Sec->EntrySize = Shdr.sh_entsize;
Sec->Index = Index++;
Sections.push_back(std::move(Sec));
auto &Sec = makeSection(Shdr);
Sec.Name = unwrapOrError(ElfFile.getSectionName(&Shdr));
Sec.Type = Shdr.sh_type;
Sec.Flags = Shdr.sh_flags;
Sec.Addr = Shdr.sh_addr;
Sec.Offset = Shdr.sh_offset;
Sec.OriginalOffset = Shdr.sh_offset;
Sec.Size = Shdr.sh_size;
Sec.Link = Shdr.sh_link;
Sec.Info = Shdr.sh_info;
Sec.Align = Shdr.sh_addralign;
Sec.EntrySize = Shdr.sh_entsize;
Sec.Index = Index++;
}
SectionTableRef SecTable(Sections);
// Now that all of the sections have been added we can fill out some extra
// details about symbol tables. We need the symbol table filled out before
// any relocations.
if (SymbolTable) {
SymbolTable->initialize(SecTable);
initSymbolTable(ElfFile, SymbolTable, SecTable);
if (Obj.SymbolTable) {
Obj.SymbolTable->initialize(Obj.sections());
initSymbolTable(Obj.SymbolTable);
}
// Now that all sections and symbols have been added we can add
// relocations that reference symbols and set the link and info fields for
// relocation sections.
for (auto &Section : Sections) {
if (Section.get() == SymbolTable)
for (auto &Section : Obj.sections()) {
if (&Section == Obj.SymbolTable)
continue;
Section->initialize(SecTable);
if (auto RelSec = dyn_cast<RelocationSection<ELFT>>(Section.get())) {
Section.initialize(Obj.sections());
if (auto RelSec = dyn_cast<RelocationSection>(&Section)) {
auto Shdr = unwrapOrError(ElfFile.sections()).begin() + RelSec->Index;
if (RelSec->Type == SHT_REL)
initRelocations(RelSec, SymbolTable, unwrapOrError(ElfFile.rels(Shdr)));
initRelocations(RelSec, Obj.SymbolTable,
unwrapOrError(ElfFile.rels(Shdr)));
else
initRelocations(RelSec, SymbolTable,
initRelocations(RelSec, Obj.SymbolTable,
unwrapOrError(ElfFile.relas(Shdr)));
}
}
return SecTable;
}
template <class ELFT> Object<ELFT>::Object(const ELFObjectFile<ELFT> &Obj) {
const auto &ElfFile = *Obj.getELFFile();
template <class ELFT> void ELFBuilder<ELFT>::build() {
const auto &Ehdr = *ElfFile.getHeader();
std::copy(Ehdr.e_ident, Ehdr.e_ident + 16, Ident);
Type = Ehdr.e_type;
Machine = Ehdr.e_machine;
Version = Ehdr.e_version;
Entry = Ehdr.e_entry;
Flags = Ehdr.e_flags;
std::copy(Ehdr.e_ident, Ehdr.e_ident + 16, Obj.Ident);
Obj.Type = Ehdr.e_type;
Obj.Machine = Ehdr.e_machine;
Obj.Version = Ehdr.e_version;
Obj.Entry = Ehdr.e_entry;
Obj.Flags = Ehdr.e_flags;
SectionTableRef SecTable = readSectionHeaders(ElfFile);
readProgramHeaders(ElfFile);
readSectionHeaders();
readProgramHeaders();
SectionNames = SecTable.getSectionOfType<StringTableSection>(
Ehdr.e_shstrndx,
"e_shstrndx field value " + Twine(Ehdr.e_shstrndx) + " in elf header " +
" is invalid",
"e_shstrndx field value " + Twine(Ehdr.e_shstrndx) + " in elf header " +
" is not a string table");
Obj.SectionNames =
Obj.sections().template getSectionOfType<StringTableSection>(
Ehdr.e_shstrndx,
"e_shstrndx field value " + Twine(Ehdr.e_shstrndx) +
" in elf header " + " is invalid",
"e_shstrndx field value " + Twine(Ehdr.e_shstrndx) +
" in elf header " + " is not a string table");
}
template <class ELFT>
void Object<ELFT>::writeHeader(FileOutputBuffer &Out) const {
uint8_t *Buf = Out.getBufferStart();
// A generic size function which computes sizes of any random access range.
template <class R> size_t size(R &&Range) {
return static_cast<size_t>(std::end(Range) - std::begin(Range));
}
Writer::~Writer() {}
Reader::~Reader() {}
ELFReader::ELFReader(StringRef File) {
auto BinaryOrErr = createBinary(File);
if (!BinaryOrErr)
reportError(File, BinaryOrErr.takeError());
auto Bin = std::move(BinaryOrErr.get());
std::tie(Binary, Data) = Bin.takeBinary();
}
ElfType ELFReader::getElfType() const {
if (auto *o = dyn_cast<ELFObjectFile<ELF32LE>>(Binary.get()))
return ELFT_ELF32LE;
if (auto *o = dyn_cast<ELFObjectFile<ELF64LE>>(Binary.get()))
return ELFT_ELF64LE;
if (auto *o = dyn_cast<ELFObjectFile<ELF32BE>>(Binary.get()))
return ELFT_ELF32BE;
if (auto *o = dyn_cast<ELFObjectFile<ELF64BE>>(Binary.get()))
return ELFT_ELF64BE;
llvm_unreachable("Invalid ELFType");
}
std::unique_ptr<Object> ELFReader::create() const {
auto Obj = llvm::make_unique<Object>(Data);
if (auto *o = dyn_cast<ELFObjectFile<ELF32LE>>(Binary.get())) {
ELFBuilder<ELF32LE> Builder(*o, *Obj);
Builder.build();
return Obj;
} else if (auto *o = dyn_cast<ELFObjectFile<ELF64LE>>(Binary.get())) {
ELFBuilder<ELF64LE> Builder(*o, *Obj);
Builder.build();
return Obj;
} else if (auto *o = dyn_cast<ELFObjectFile<ELF32BE>>(Binary.get())) {
ELFBuilder<ELF32BE> Builder(*o, *Obj);
Builder.build();
return Obj;
} else if (auto *o = dyn_cast<ELFObjectFile<ELF64BE>>(Binary.get())) {
ELFBuilder<ELF64BE> Builder(*o, *Obj);
Builder.build();
return Obj;
}
error("Invalid file type");
}
template <class ELFT> void ELFWriter<ELFT>::writeEhdr() {
uint8_t *Buf = BufPtr->getBufferStart();
Elf_Ehdr &Ehdr = *reinterpret_cast<Elf_Ehdr *>(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;
std::copy(Obj.Ident, Obj.Ident + 16, Ehdr.e_ident);
Ehdr.e_type = Obj.Type;
Ehdr.e_machine = Obj.Machine;
Ehdr.e_version = Obj.Version;
Ehdr.e_entry = Obj.Entry;
Ehdr.e_phoff = sizeof(Elf_Ehdr);
Ehdr.e_flags = Flags;
Ehdr.e_flags = Obj.Flags;
Ehdr.e_ehsize = sizeof(Elf_Ehdr);
Ehdr.e_phentsize = sizeof(Elf_Phdr);
Ehdr.e_phnum = Segments.size();
Ehdr.e_phnum = size(Obj.segments());
Ehdr.e_shentsize = sizeof(Elf_Shdr);
if (WriteSectionHeaders) {
Ehdr.e_shoff = SHOffset;
Ehdr.e_shnum = Sections.size() + 1;
Ehdr.e_shstrndx = SectionNames->Index;
Ehdr.e_shoff = Obj.SHOffset;
Ehdr.e_shnum = size(Obj.sections()) + 1;
Ehdr.e_shstrndx = Obj.SectionNames->Index;
} else {
Ehdr.e_shoff = 0;
Ehdr.e_shnum = 0;
@ -688,15 +756,13 @@ void Object<ELFT>::writeHeader(FileOutputBuffer &Out) const {
}
}
template <class ELFT>
void Object<ELFT>::writeProgramHeaders(FileOutputBuffer &Out) const {
for (auto &Phdr : Segments)
Phdr->template writeHeader<ELFT>(Out);
template <class ELFT> void ELFWriter<ELFT>::writePhdrs() {
for (auto &Seg : Obj.segments())
writePhdr(Seg);
}
template <class ELFT>
void Object<ELFT>::writeSectionHeaders(FileOutputBuffer &Out) const {
uint8_t *Buf = Out.getBufferStart() + SHOffset;
template <class ELFT> void ELFWriter<ELFT>::writeShdrs() {
uint8_t *Buf = BufPtr->getBufferStart() + Obj.SHOffset;
// This reference serves to write the dummy section header at the begining
// of the file. It is not used for anything else
Elf_Shdr &Shdr = *reinterpret_cast<Elf_Shdr *>(Buf);
@ -711,19 +777,16 @@ void Object<ELFT>::writeSectionHeaders(FileOutputBuffer &Out) const {
Shdr.sh_addralign = 0;
Shdr.sh_entsize = 0;
for (auto &Section : Sections)
Section->template writeHeader<ELFT>(Out);
for (auto &Sec : Obj.sections())
writeShdr(Sec);
}
template <class ELFT>
void Object<ELFT>::writeSectionData(FileOutputBuffer &Out) const {
for (auto &Section : Sections)
Section->writeSection(Out);
template <class ELFT> void ELFWriter<ELFT>::writeSectionData() {
for (auto &Sec : Obj.sections())
Sec.accept(*SecWriter);
}
template <class ELFT>
void Object<ELFT>::removeSections(
std::function<bool(const SectionBase &)> ToRemove) {
void Object::removeSections(std::function<bool(const SectionBase &)> ToRemove) {
auto Iter = std::stable_partition(
std::begin(Sections), std::end(Sections), [=](const SecPtr &Sec) {
@ -737,10 +800,7 @@ void Object<ELFT>::removeSections(
});
if (SymbolTable != nullptr && ToRemove(*SymbolTable))
SymbolTable = nullptr;
if (ToRemove(*SectionNames)) {
if (WriteSectionHeaders)
error("Cannot remove " + SectionNames->Name +
" because it is the section header string table.");
if (SectionNames != nullptr && ToRemove(*SectionNames)) {
SectionNames = nullptr;
}
// Now make sure there are no remaining references to the sections that will
@ -756,18 +816,7 @@ void Object<ELFT>::removeSections(
Sections.erase(Iter, std::end(Sections));
}
template <class ELFT>
void Object<ELFT>::addSection(StringRef SecName, ArrayRef<uint8_t> Data) {
auto Sec = llvm::make_unique<OwnedDataSection>(SecName, Data);
Sec->OriginalOffset = ~0ULL;
Sections.push_back(std::move(Sec));
}
template <class ELFT> void Object<ELFT>::addGnuDebugLink(StringRef File) {
Sections.emplace_back(llvm::make_unique<GnuDebugLinkSection<ELFT>>(File));
}
template <class ELFT> void ELFObject<ELFT>::sortSections() {
void Object::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) {
@ -832,8 +881,8 @@ static uint64_t LayoutSegments(std::vector<Segment *> &Segments,
// does not have a ParentSegment. It returns either the offset given if all
// sections had a ParentSegment or an offset one past the last section if there
// was a section that didn't have a ParentSegment.
template <class SecPtr>
static uint64_t LayoutSections(std::vector<SecPtr> &Sections, uint64_t Offset) {
template <class Range>
static uint64_t LayoutSections(Range Sections, uint64_t Offset) {
// Now the offset of every segment has been set we can assign the offsets
// of each section. For sections that are covered by a segment we should use
// the segment's original offset and the section's original offset to compute
@ -842,28 +891,28 @@ static uint64_t LayoutSections(std::vector<SecPtr> &Sections, uint64_t Offset) {
// covered by segments we can just bump Offset to the next valid location.
uint32_t Index = 1;
for (auto &Section : Sections) {
Section->Index = Index++;
if (Section->ParentSegment != nullptr) {
auto Segment = Section->ParentSegment;
Section->Offset =
Segment->Offset + (Section->OriginalOffset - Segment->OriginalOffset);
Section.Index = Index++;
if (Section.ParentSegment != nullptr) {
auto Segment = *Section.ParentSegment;
Section.Offset =
Segment.Offset + (Section.OriginalOffset - Segment.OriginalOffset);
} else {
Offset = alignTo(Offset, Section->Align == 0 ? 1 : Section->Align);
Section->Offset = Offset;
if (Section->Type != SHT_NOBITS)
Offset += Section->Size;
Offset = alignTo(Offset, Section.Align == 0 ? 1 : Section.Align);
Section.Offset = Offset;
if (Section.Type != SHT_NOBITS)
Offset += Section.Size;
}
}
return Offset;
}
template <class ELFT> void ELFObject<ELFT>::assignOffsets() {
template <class ELFT> void ELFWriter<ELFT>::assignOffsets() {
// We need a temporary list of segments that has a special order to it
// so that we know that anytime ->ParentSegment is set that segment has
// already had its offset properly set.
std::vector<Segment *> OrderedSegments;
for (auto &Segment : this->Segments)
OrderedSegments.push_back(Segment.get());
for (auto &Segment : Obj.segments())
OrderedSegments.push_back(&Segment);
OrderSegments(OrderedSegments);
// The size of ELF + program headers will not change so it is ok to assume
// that the first offset of the first segment is a good place to start
@ -876,72 +925,88 @@ template <class ELFT> void ELFObject<ELFT>::assignOffsets() {
Offset = sizeof(Elf_Ehdr);
}
Offset = LayoutSegments(OrderedSegments, Offset);
Offset = LayoutSections(this->Sections, Offset);
Offset = LayoutSections(Obj.sections(), Offset);
// If we need to write the section header table out then we need to align the
// Offset so that SHOffset is valid.
if (this->WriteSectionHeaders)
if (WriteSectionHeaders)
Offset = alignTo(Offset, sizeof(typename ELFT::Addr));
this->SHOffset = Offset;
Obj.SHOffset = Offset;
}
template <class ELFT> size_t ELFObject<ELFT>::totalSize() const {
template <class ELFT> size_t ELFWriter<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.
auto NullSectionSize = this->WriteSectionHeaders ? sizeof(Elf_Shdr) : 0;
return this->SHOffset + this->Sections.size() * sizeof(Elf_Shdr) +
auto NullSectionSize = WriteSectionHeaders ? sizeof(Elf_Shdr) : 0;
return Obj.SHOffset + size(Obj.sections()) * sizeof(Elf_Shdr) +
NullSectionSize;
}
template <class ELFT> void ELFObject<ELFT>::write(FileOutputBuffer &Out) const {
this->writeHeader(Out);
this->writeProgramHeaders(Out);
this->writeSectionData(Out);
if (this->WriteSectionHeaders)
this->writeSectionHeaders(Out);
template <class ELFT> void ELFWriter<ELFT>::write() {
writeEhdr();
writePhdrs();
writeSectionData();
if (WriteSectionHeaders)
writeShdrs();
if (auto E = BufPtr->commit())
reportError(File, errorToErrorCode(std::move(E)));
}
template <class ELFT> void ELFObject<ELFT>::finalize() {
void Writer::createBuffer(uint64_t Size) {
auto BufferOrErr =
FileOutputBuffer::create(File, Size, FileOutputBuffer::F_executable);
handleAllErrors(BufferOrErr.takeError(), [this](const ErrorInfoBase &) {
error("failed to open " + File);
});
BufPtr = std::move(*BufferOrErr);
}
template <class ELFT> void ELFWriter<ELFT>::finalize() {
// It could happen that SectionNames has been removed and yet the user wants
// a section header table output. We need to throw an error if a user tries
// to do that.
if (Obj.SectionNames == nullptr && WriteSectionHeaders)
error("Cannot write section header table because section header string "
"table was removed.");
// Make sure we add the names of all the sections.
if (this->SectionNames != nullptr)
for (const auto &Section : this->Sections) {
this->SectionNames->addString(Section->Name);
if (Obj.SectionNames != nullptr)
for (const auto &Section : Obj.sections()) {
Obj.SectionNames->addString(Section.Name);
}
// Make sure we add the names of all the symbols.
if (this->SymbolTable != nullptr)
this->SymbolTable->addSymbolNames();
if (Obj.SymbolTable != nullptr)
Obj.SymbolTable->addSymbolNames();
sortSections();
Obj.sortSections();
assignOffsets();
// Finalize SectionNames first so that we can assign name indexes.
if (this->SectionNames != nullptr)
this->SectionNames->finalize();
if (Obj.SectionNames != nullptr)
Obj.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;
uint64_t Offset = Obj.SHOffset + sizeof(Elf_Shdr);
for (auto &Section : Obj.sections()) {
Section.HeaderOffset = Offset;
Offset += sizeof(Elf_Shdr);
if (this->WriteSectionHeaders)
Section->NameIndex = this->SectionNames->findIndex(Section->Name);
Section->finalize();
if (WriteSectionHeaders)
Section.NameIndex = Obj.SectionNames->findIndex(Section.Name);
Section.finalize();
}
createBuffer(totalSize());
SecWriter = llvm::make_unique<ELFSectionWriter<ELFT>>(*BufPtr);
}
template <class ELFT> size_t BinaryObject<ELFT>::totalSize() const {
return TotalSize;
}
template <class ELFT>
void BinaryObject<ELFT>::write(FileOutputBuffer &Out) const {
for (auto &Section : this->Sections) {
if ((Section->Flags & SHF_ALLOC) == 0)
void BinaryWriter::write() {
for (auto &Section : Obj.sections()) {
if ((Section.Flags & SHF_ALLOC) == 0)
continue;
Section->writeSection(Out);
Section.accept(*SecWriter);
}
}
template <class ELFT> void BinaryObject<ELFT>::finalize() {
void BinaryWriter::finalize() {
// TODO: Create a filter range to construct OrderedSegments from so that this
// code can be deduped with assignOffsets above. This should also solve the
// todo below for LayoutSections.
@ -950,10 +1015,9 @@ template <class ELFT> void BinaryObject<ELFT>::finalize() {
// already had it's offset properly set. We only want to consider the segments
// that will affect layout of allocated sections so we only add those.
std::vector<Segment *> OrderedSegments;
for (auto &Section : this->Sections) {
if ((Section->Flags & SHF_ALLOC) != 0 &&
Section->ParentSegment != nullptr) {
OrderedSegments.push_back(Section->ParentSegment);
for (auto &Section : Obj.sections()) {
if ((Section.Flags & SHF_ALLOC) != 0 && Section.ParentSegment != nullptr) {
OrderedSegments.push_back(Section.ParentSegment);
}
}
@ -1004,12 +1068,12 @@ template <class ELFT> void BinaryObject<ELFT>::finalize() {
// not hold. Then pass such a range to LayoutSections instead of constructing
// AllocatedSections here.
std::vector<SectionBase *> AllocatedSections;
for (auto &Section : this->Sections) {
if ((Section->Flags & SHF_ALLOC) == 0)
for (auto &Section : Obj.sections()) {
if ((Section.Flags & SHF_ALLOC) == 0)
continue;
AllocatedSections.push_back(Section.get());
AllocatedSections.push_back(&Section);
}
LayoutSections(AllocatedSections, Offset);
LayoutSections(make_pointee_range(AllocatedSections), Offset);
// Now that every section has been laid out we just need to compute the total
// file size. This might not be the same as the offset returned by
@ -1020,23 +1084,21 @@ template <class ELFT> void BinaryObject<ELFT>::finalize() {
if (Section->Type != SHT_NOBITS)
TotalSize = std::max(TotalSize, Section->Offset + Section->Size);
}
createBuffer(TotalSize);
SecWriter = llvm::make_unique<BinarySectionWriter>(*BufPtr);
}
namespace llvm {
template class Object<ELF64LE>;
template class Object<ELF64BE>;
template class Object<ELF32LE>;
template class Object<ELF32BE>;
template class ELFBuilder<ELF64LE>;
template class ELFBuilder<ELF64BE>;
template class ELFBuilder<ELF32LE>;
template class ELFBuilder<ELF32BE>;
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>;
template class ELFWriter<ELF64LE>;
template class ELFWriter<ELF64BE>;
template class ELFWriter<ELF32LE>;
template class ELFWriter<ELF32BE>;
} // end namespace llvm

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

@ -16,6 +16,7 @@
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/MC/StringTableBuilder.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Support/FileOutputBuffer.h"
#include "llvm/Support/JamCRC.h"
#include <cstddef>
#include <cstdint>
@ -26,25 +27,159 @@
namespace llvm {
class FileOutputBuffer;
class SectionBase;
class Section;
class OwnedDataSection;
class StringTableSection;
class SymbolTableSection;
class RelocationSection;
class DynamicRelocationSection;
class GnuDebugLinkSection;
class Segment;
class Object;
class SectionTableRef {
private:
ArrayRef<std::unique_ptr<SectionBase>> Sections;
MutableArrayRef<std::unique_ptr<SectionBase>> Sections;
public:
SectionTableRef(ArrayRef<std::unique_ptr<SectionBase>> Secs)
using iterator = pointee_iterator<std::unique_ptr<SectionBase> *>;
SectionTableRef(MutableArrayRef<std::unique_ptr<SectionBase>> Secs)
: Sections(Secs) {}
SectionTableRef(const SectionTableRef &) = default;
iterator begin() { return iterator(Sections.data()); }
iterator end() { return iterator(Sections.data() + Sections.size()); }
SectionBase *getSection(uint16_t Index, Twine ErrMsg);
template <class T>
T *getSectionOfType(uint16_t Index, Twine IndexErrMsg, Twine TypeErrMsg);
};
enum ElfType { ELFT_ELF32LE, ELFT_ELF64LE, ELFT_ELF32BE, ELFT_ELF64BE };
class SectionVisitor {
public:
virtual ~SectionVisitor();
virtual void visit(const Section &Sec) = 0;
virtual void visit(const OwnedDataSection &Sec) = 0;
virtual void visit(const StringTableSection &Sec) = 0;
virtual void visit(const SymbolTableSection &Sec) = 0;
virtual void visit(const RelocationSection &Sec) = 0;
virtual void visit(const DynamicRelocationSection &Sec) = 0;
virtual void visit(const GnuDebugLinkSection &Sec) = 0;
};
class SectionWriter : public SectionVisitor {
protected:
FileOutputBuffer &Out;
public:
virtual ~SectionWriter(){};
void visit(const Section &Sec) override;
void visit(const OwnedDataSection &Sec) override;
void visit(const StringTableSection &Sec) override;
void visit(const DynamicRelocationSection &Sec) override;
virtual void visit(const SymbolTableSection &Sec) override = 0;
virtual void visit(const RelocationSection &Sec) override = 0;
virtual void visit(const GnuDebugLinkSection &Sec) override = 0;
SectionWriter(FileOutputBuffer &Buf) : Out(Buf) {}
};
template <class ELFT> class ELFSectionWriter : public SectionWriter {
private:
using Elf_Word = typename ELFT::Word;
using Elf_Rel = typename ELFT::Rel;
using Elf_Rela = typename ELFT::Rela;
public:
virtual ~ELFSectionWriter() {}
void visit(const SymbolTableSection &Sec) override;
void visit(const RelocationSection &Sec) override;
void visit(const GnuDebugLinkSection &Sec) override;
ELFSectionWriter(FileOutputBuffer &Buf) : SectionWriter(Buf) {}
};
#define MAKE_SEC_WRITER_FRIEND \
template friend class SectionWriter; \
template <class ELFT> friend class ELFSectionWriter;
class BinarySectionWriter : public SectionWriter {
public:
virtual ~BinarySectionWriter() {}
void visit(const SymbolTableSection &Sec) override;
void visit(const RelocationSection &Sec) override;
void visit(const GnuDebugLinkSection &Sec) override;
BinarySectionWriter(FileOutputBuffer &Buf) : SectionWriter(Buf) {}
};
class Writer {
protected:
StringRef File;
Object &Obj;
std::unique_ptr<FileOutputBuffer> BufPtr;
void createBuffer(uint64_t Size);
public:
virtual ~Writer();
virtual void finalize() = 0;
virtual void write() = 0;
Writer(StringRef File, Object &Obj) : File(File), Obj(Obj) {}
};
template <class ELFT> class ELFWriter : public Writer {
private:
using Elf_Shdr = typename ELFT::Shdr;
using Elf_Phdr = typename ELFT::Phdr;
using Elf_Ehdr = typename ELFT::Ehdr;
void writeEhdr();
void writePhdr(const Segment &Seg);
void writeShdr(const SectionBase &Sec);
void writePhdrs();
void writeShdrs();
void writeSectionData();
void assignOffsets();
std::unique_ptr<ELFSectionWriter<ELFT>> SecWriter;
size_t totalSize() const;
public:
virtual ~ELFWriter() {}
bool WriteSectionHeaders = true;
void finalize() override;
void write() override;
ELFWriter(StringRef File, Object &Obj, bool WSH)
: Writer(File, Obj), WriteSectionHeaders(WSH) {}
};
class BinaryWriter : public Writer {
private:
std::unique_ptr<BinarySectionWriter> SecWriter;
uint64_t TotalSize;
public:
~BinaryWriter() {}
void finalize() override;
void write() override;
BinaryWriter(StringRef File, Object &Obj) : Writer(File, Obj) {}
};
class SectionBase {
public:
StringRef Name;
@ -69,8 +204,7 @@ public:
virtual void initialize(SectionTableRef SecTable);
virtual void finalize();
virtual void removeSectionReferences(const SectionBase *Sec);
template <class ELFT> void writeHeader(FileOutputBuffer &Out) const;
virtual void writeSection(FileOutputBuffer &Out) const = 0;
virtual void accept(SectionVisitor &Visitor) const = 0;
};
class Segment {
@ -113,21 +247,23 @@ public:
void removeSection(const SectionBase *Sec) { Sections.erase(Sec); }
void addSection(const SectionBase *Sec) { Sections.insert(Sec); }
template <class ELFT> void writeHeader(FileOutputBuffer &Out) const;
void writeSegment(FileOutputBuffer &Out) const;
};
class Section : public SectionBase {
MAKE_SEC_WRITER_FRIEND
private:
ArrayRef<uint8_t> Contents;
public:
Section(ArrayRef<uint8_t> Data) : Contents(Data) {}
void writeSection(FileOutputBuffer &Out) const override;
void accept(SectionVisitor &Visitor) const override;
};
class OwnedDataSection : public SectionBase {
MAKE_SEC_WRITER_FRIEND
private:
std::vector<uint8_t> Data;
@ -137,8 +273,10 @@ public:
Name = SecName;
Type = ELF::SHT_PROGBITS;
Size = Data.size();
OriginalOffset = std::numeric_limits<uint64_t>::max();
}
void writeSection(FileOutputBuffer &Out) const override;
void accept(SectionVisitor &Sec) const override;
};
// There are two types of string tables that can exist, dynamic and not dynamic.
@ -150,6 +288,8 @@ public:
// classof method checks that the particular instance is not allocated. This
// then agrees with the makeSection method used to construct most sections.
class StringTableSection : public SectionBase {
MAKE_SEC_WRITER_FRIEND
private:
StringTableBuilder StrTabBuilder;
@ -161,7 +301,7 @@ public:
void addString(StringRef Name);
uint32_t findIndex(StringRef Name) const;
void finalize() override;
void writeSection(FileOutputBuffer &Out) const override;
void accept(SectionVisitor &Visitor) const override;
static bool classof(const SectionBase *S) {
if (S->Flags & ELF::SHF_ALLOC)
@ -200,6 +340,8 @@ struct Symbol {
};
class SymbolTableSection : public SectionBase {
MAKE_SEC_WRITER_FRIEND
protected:
std::vector<std::unique_ptr<Symbol>> Symbols;
StringTableSection *SymbolNames = nullptr;
@ -218,17 +360,13 @@ public:
void localize(std::function<bool(const Symbol &)> ToLocalize);
void initialize(SectionTableRef SecTable) override;
void finalize() override;
void accept(SectionVisitor &Visitor) const override;
static bool classof(const SectionBase *S) {
return S->Type == ELF::SHT_SYMTAB;
}
};
// Only writeSection depends on the ELF type so we implement it in a subclass.
template <class ELFT> class SymbolTableSectionImpl : public SymbolTableSection {
void writeSection(FileOutputBuffer &Out) const override;
};
struct Relocation {
const Symbol *RelocSymbol = nullptr;
uint64_t Offset;
@ -275,20 +413,16 @@ public:
void finalize() override;
};
template <class ELFT>
class RelocationSection
: public RelocSectionWithSymtabBase<SymbolTableSection> {
MAKE_SEC_WRITER_FRIEND
private:
using Elf_Rel = typename ELFT::Rel;
using Elf_Rela = typename ELFT::Rela;
std::vector<Relocation> Relocations;
template <class T> void writeRel(T *Buf) const;
public:
void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
void writeSection(FileOutputBuffer &Out) const override;
void accept(SectionVisitor &Visitor) const override;
static bool classof(const SectionBase *S) {
if (S->Flags & ELF::SHF_ALLOC)
@ -331,13 +465,15 @@ public:
class DynamicRelocationSection
: public RelocSectionWithSymtabBase<DynamicSymbolTableSection> {
MAKE_SEC_WRITER_FRIEND
private:
ArrayRef<uint8_t> Contents;
public:
DynamicRelocationSection(ArrayRef<uint8_t> Data) : Contents(Data) {}
void writeSection(FileOutputBuffer &Out) const override;
void accept(SectionVisitor &) const override;
static bool classof(const SectionBase *S) {
if (!(S->Flags & ELF::SHF_ALLOC))
@ -346,12 +482,10 @@ public:
}
};
template <class ELFT> class GnuDebugLinkSection : public SectionBase {
class GnuDebugLinkSection : public SectionBase {
MAKE_SEC_WRITER_FRIEND
private:
// Elf_Word is 4-bytes on every format but has the same endianess as the elf
// type ELFT. We'll need to write the CRC32 out in the proper endianess so
// we'll make sure to use this type.
using Elf_Word = typename ELFT::Word;
StringRef FileName;
uint32_t CRC32;
@ -361,37 +495,68 @@ private:
public:
// If we add this section from an external source we can use this ctor.
GnuDebugLinkSection(StringRef File);
void writeSection(FileOutputBuffer &Out) const override;
void accept(SectionVisitor &Visitor) const override;
};
template <class ELFT> class Object {
class Reader {
public:
virtual ~Reader();
virtual std::unique_ptr<Object> create() const = 0;
};
using object::OwningBinary;
using object::Binary;
using object::ELFFile;
using object::ELFObjectFile;
template <class ELFT> class ELFBuilder {
private:
using Elf_Shdr = typename ELFT::Shdr;
const ELFFile<ELFT> &ElfFile;
Object &Obj;
void readProgramHeaders();
void initSymbolTable(SymbolTableSection *SymTab);
void readSectionHeaders();
SectionBase &makeSection(const Elf_Shdr &Shdr);
public:
ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj)
: ElfFile(*ElfObj.getELFFile()), Obj(Obj) {}
void build();
};
class ELFReader : public Reader {
private:
std::unique_ptr<Binary> Binary;
std::shared_ptr<MemoryBuffer> Data;
public:
ElfType getElfType() const;
std::unique_ptr<Object> create() const override;
ELFReader(StringRef File);
};
class Object {
private:
using SecPtr = std::unique_ptr<SectionBase>;
using SegPtr = std::unique_ptr<Segment>;
using Elf_Shdr = typename ELFT::Shdr;
using Elf_Ehdr = typename ELFT::Ehdr;
using Elf_Phdr = typename ELFT::Phdr;
void initSymbolTable(const object::ELFFile<ELFT> &ElfFile,
SymbolTableSection *SymTab, SectionTableRef SecTable);
SecPtr makeSection(const object::ELFFile<ELFT> &ElfFile,
const Elf_Shdr &Shdr);
void readProgramHeaders(const object::ELFFile<ELFT> &ElfFile);
SectionTableRef readSectionHeaders(const object::ELFFile<ELFT> &ElfFile);
protected:
StringTableSection *SectionNames = nullptr;
SymbolTableSection *SymbolTable = nullptr;
std::shared_ptr<MemoryBuffer> OwnedData;
std::vector<SecPtr> Sections;
std::vector<SegPtr> Segments;
void writeHeader(FileOutputBuffer &Out) const;
void writeProgramHeaders(FileOutputBuffer &Out) const;
void writeSectionData(FileOutputBuffer &Out) const;
void writeSectionHeaders(FileOutputBuffer &Out) const;
public:
template <class T>
using Range = iterator_range<
pointee_iterator<typename std::vector<std::unique_ptr<T>>::iterator>>;
template <class T>
using ConstRange = iterator_range<pointee_iterator<
typename std::vector<std::unique_ptr<T>>::const_iterator>>;
uint8_t Ident[16];
uint64_t Entry;
uint64_t SHOffset;
@ -399,54 +564,32 @@ public:
uint32_t Machine;
uint32_t Version;
uint32_t Flags;
bool WriteSectionHeaders = true;
Object(const object::ELFObjectFile<ELFT> &Obj);
StringTableSection *SectionNames = nullptr;
SymbolTableSection *SymbolTable = nullptr;
Object(std::shared_ptr<MemoryBuffer> Data) : OwnedData(Data) {}
virtual ~Object() = default;
SymbolTableSection *getSymTab() const { return SymbolTable; }
const SectionBase *getSectionHeaderStrTab() const { return SectionNames; }
void removeSections(std::function<bool(const SectionBase &)> ToRemove);
void addSection(StringRef SecName, ArrayRef<uint8_t> Data);
void addGnuDebugLink(StringRef File);
virtual size_t totalSize() const = 0;
virtual void finalize() = 0;
virtual void write(FileOutputBuffer &Out) const = 0;
};
template <class ELFT> class ELFObject : public Object<ELFT> {
private:
using SecPtr = std::unique_ptr<SectionBase>;
using SegPtr = std::unique_ptr<Segment>;
using Elf_Shdr = typename ELFT::Shdr;
using Elf_Ehdr = typename ELFT::Ehdr;
using Elf_Phdr = typename ELFT::Phdr;
void sortSections();
void assignOffsets();
SectionTableRef sections() { return SectionTableRef(Sections); }
ConstRange<SectionBase> sections() const {
return make_pointee_range(Sections);
}
Range<Segment> segments() { return make_pointee_range(Segments); }
ConstRange<Segment> segments() const { return make_pointee_range(Segments); }
public:
ELFObject(const object::ELFObjectFile<ELFT> &Obj) : Object<ELFT>(Obj) {}
void finalize() override;
size_t totalSize() const override;
void write(FileOutputBuffer &Out) const override;
};
template <class ELFT> class BinaryObject : public Object<ELFT> {
private:
using SecPtr = std::unique_ptr<SectionBase>;
using SegPtr = std::unique_ptr<Segment>;
uint64_t TotalSize;
public:
BinaryObject(const object::ELFObjectFile<ELFT> &Obj) : Object<ELFT>(Obj) {}
void finalize() override;
size_t totalSize() const override;
void write(FileOutputBuffer &Out) const override;
void removeSections(std::function<bool(const SectionBase &)> ToRemove);
template <class T, class... Ts> T &addSection(Ts &&... Args) {
auto Sec = llvm::make_unique<T>(std::forward<Ts>(Args)...);
auto Ptr = Sec.get();
Sections.emplace_back(std::move(Sec));
return *Ptr;
}
Segment &addSegment(ArrayRef<uint8_t> Data) {
Segments.emplace_back(llvm::make_unique<Segment>(Data));
return *Segments.back();
}
};
} // end namespace llvm

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

@ -130,42 +130,42 @@ using SectionPred = std::function<bool(const SectionBase &Sec)>;
bool IsDWOSection(const SectionBase &Sec) { return Sec.Name.endswith(".dwo"); }
template <class ELFT>
bool OnlyKeepDWOPred(const Object<ELFT> &Obj, const SectionBase &Sec) {
bool OnlyKeepDWOPred(const Object &Obj, const SectionBase &Sec) {
// We can't remove the section header string table.
if (&Sec == Obj.getSectionHeaderStrTab())
if (&Sec == Obj.SectionNames)
return false;
// Short of keeping the string table we want to keep everything that is a DWO
// section and remove everything else.
return !IsDWOSection(Sec);
}
template <class ELFT>
void WriteObjectFile(const Object<ELFT> &Obj, StringRef File) {
std::unique_ptr<FileOutputBuffer> Buffer;
Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
FileOutputBuffer::create(File, Obj.totalSize(),
FileOutputBuffer::F_executable);
handleAllErrors(BufferOrErr.takeError(), [](const ErrorInfoBase &) {
error("failed to open " + OutputFilename);
});
Buffer = std::move(*BufferOrErr);
static ElfType OutputElfType;
Obj.write(*Buffer);
if (auto E = Buffer->commit())
reportError(File, errorToErrorCode(std::move(E)));
std::unique_ptr<Writer> CreateWriter(Object &Obj, StringRef File) {
if (OutputFormat == "binary") {
return llvm::make_unique<BinaryWriter>(OutputFilename, Obj);
}
// Depending on the initial ELFT and OutputFormat we need a different Writer.
switch (OutputElfType) {
case ELFT_ELF32LE:
return llvm::make_unique<ELFWriter<ELF32LE>>(File, Obj, !StripSections);
case ELFT_ELF64LE:
return llvm::make_unique<ELFWriter<ELF64LE>>(File, Obj, !StripSections);
case ELFT_ELF32BE:
return llvm::make_unique<ELFWriter<ELF32BE>>(File, Obj, !StripSections);
case ELFT_ELF64BE:
return llvm::make_unique<ELFWriter<ELF64BE>>(File, Obj, !StripSections);
}
llvm_unreachable("Invalid output format");
}
template <class ELFT>
void SplitDWOToFile(const ELFObjectFile<ELFT> &ObjFile, StringRef File) {
// Construct a second output file for the DWO sections.
ELFObject<ELFT> DWOFile(ObjFile);
DWOFile.removeSections([&](const SectionBase &Sec) {
return OnlyKeepDWOPred<ELFT>(DWOFile, Sec);
});
DWOFile.finalize();
WriteObjectFile(DWOFile, File);
void SplitDWOToFile(const Reader &Reader, StringRef File) {
auto DWOFile = Reader.create();
DWOFile->removeSections(
[&](const SectionBase &Sec) { return OnlyKeepDWOPred(*DWOFile, Sec); });
auto Writer = CreateWriter(*DWOFile, File);
Writer->finalize();
Writer->write();
}
// This function handles the high level operations of GNU objcopy including
@ -175,23 +175,16 @@ void SplitDWOToFile(const ELFObjectFile<ELFT> &ObjFile, StringRef File) {
// any previous removals. Lastly whether or not something is removed shouldn't
// depend a) on the order the options occur in or b) on some opaque priority
// system. The only priority is that keeps/copies overrule removes.
template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
std::unique_ptr<Object<ELFT>> Obj;
void HandleArgs(Object &Obj, const Reader &Reader) {
if (!OutputFormat.empty() && OutputFormat != "binary")
error("invalid output format '" + OutputFormat + "'");
if (!OutputFormat.empty() && OutputFormat == "binary")
Obj = llvm::make_unique<BinaryObject<ELFT>>(ObjFile);
else
Obj = llvm::make_unique<ELFObject<ELFT>>(ObjFile);
if (!SplitDWO.empty())
SplitDWOToFile<ELFT>(ObjFile, SplitDWO.getValue());
if (!SplitDWO.empty()) {
SplitDWOToFile(Reader, SplitDWO);
}
// Localize:
if (LocalizeHidden) {
Obj->getSymTab()->localize([](const Symbol &Sym) {
Obj.SymbolTable->localize([](const Symbol &Sym) {
return Sym.Visibility == STV_HIDDEN || Sym.Visibility == STV_INTERNAL;
});
}
@ -214,7 +207,7 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
if (ExtractDWO)
RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
return OnlyKeepDWOPred(*Obj, Sec) || RemovePred(Sec);
return OnlyKeepDWOPred(Obj, Sec) || RemovePred(Sec);
};
if (StripAllGNU)
@ -223,7 +216,7 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
return true;
if ((Sec.Flags & SHF_ALLOC) != 0)
return false;
if (&Sec == Obj->getSectionHeaderStrTab())
if (&Sec == Obj.SectionNames)
return false;
switch (Sec.Type) {
case SHT_SYMTAB:
@ -239,7 +232,6 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
RemovePred = [RemovePred](const SectionBase &Sec) {
return RemovePred(Sec) || (Sec.Flags & SHF_ALLOC) == 0;
};
Obj->WriteSectionHeaders = false;
}
if (StripDebug) {
@ -252,7 +244,7 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
if (RemovePred(Sec))
return true;
if (&Sec == Obj->getSectionHeaderStrTab())
if (&Sec == Obj.SectionNames)
return false;
return (Sec.Flags & SHF_ALLOC) == 0;
};
@ -261,7 +253,7 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
if (RemovePred(Sec))
return true;
if (&Sec == Obj->getSectionHeaderStrTab())
if (&Sec == Obj.SectionNames)
return false;
if (Sec.Name.startswith(".gnu.warning"))
return false;
@ -278,17 +270,15 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
return false;
// Allow all implicit removes.
if (RemovePred(Sec)) {
if (RemovePred(Sec))
return true;
}
// Keep special sections.
if (Obj->getSectionHeaderStrTab() == &Sec) {
if (Obj.SectionNames == &Sec)
return false;
}
if (Obj->getSymTab() == &Sec || Obj->getSymTab()->getStrTab() == &Sec) {
if (Obj.SymbolTable == &Sec || Obj.SymbolTable->getStrTab() == &Sec)
return false;
}
// Remove everything else.
return true;
};
@ -305,7 +295,7 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
};
}
Obj->removeSections(RemovePred);
Obj.removeSections(RemovePred);
if (!AddSection.empty()) {
for (const auto &Flag : AddSection) {
@ -318,16 +308,22 @@ template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
auto Buf = std::move(*BufOrErr);
auto BufPtr = reinterpret_cast<const uint8_t *>(Buf->getBufferStart());
auto BufSize = Buf->getBufferSize();
Obj->addSection(SecName, ArrayRef<uint8_t>(BufPtr, BufSize));
Obj.addSection<OwnedDataSection>(SecName,
ArrayRef<uint8_t>(BufPtr, BufSize));
}
}
if (!AddGnuDebugLink.empty()) {
Obj->addGnuDebugLink(AddGnuDebugLink);
Obj.addSection<GnuDebugLinkSection>(StringRef(AddGnuDebugLink));
}
}
Obj->finalize();
WriteObjectFile(*Obj, OutputFilename.getValue());
std::unique_ptr<Reader> CreateReader() {
// Right now we can only read ELF files so there's only one reader;
auto Out = llvm::make_unique<ELFReader>(StringRef(InputFilename));
// We need to set the default ElfType for output.
OutputElfType = Out->getElfType();
return std::move(Out);
}
int main(int argc, char **argv) {
@ -341,25 +337,11 @@ int main(int argc, char **argv) {
cl::PrintHelpMessage();
return 2;
}
Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(InputFilename);
if (!BinaryOrErr)
reportError(InputFilename, BinaryOrErr.takeError());
Binary &Binary = *BinaryOrErr.get().getBinary();
if (auto *o = dyn_cast<ELFObjectFile<ELF64LE>>(&Binary)) {
CopyBinary(*o);
return 0;
}
if (auto *o = dyn_cast<ELFObjectFile<ELF32LE>>(&Binary)) {
CopyBinary(*o);
return 0;
}
if (auto *o = dyn_cast<ELFObjectFile<ELF64BE>>(&Binary)) {
CopyBinary(*o);
return 0;
}
if (auto *o = dyn_cast<ELFObjectFile<ELF32BE>>(&Binary)) {
CopyBinary(*o);
return 0;
}
reportError(InputFilename, object_error::invalid_file_type);
auto Reader = CreateReader();
auto Obj = Reader->create();
auto Writer = CreateWriter(*Obj, OutputFilename);
HandleArgs(*Obj, *Reader);
Writer->finalize();
Writer->write();
}

3
llvm/tools/llvm-objcopy/llvm-objcopy.h
View File

@ -19,6 +19,9 @@
namespace llvm {
LLVM_ATTRIBUTE_NORETURN extern void error(Twine Message);
LLVM_ATTRIBUTE_NORETURN extern void reportError(StringRef File, Error E);
LLVM_ATTRIBUTE_NORETURN extern void reportError(StringRef File,
std::error_code EC);
// This is taken from llvm-readobj.
// [see here](llvm/tools/llvm-readobj/llvm-readobj.h:38)