Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-05-14 01:46:41 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
llvm-capstone/llvm/tools/llvm-objcopy/ELF/Object.cpp
Jordan Rupprecht f8f9d65f85 [llvm-objcopy] Fix SHT_GROUP ordering. 
Summary:
When llvm-objcopy sorts sections during finalization, it only sorts based on the offset, which can cause the group section to come after the sections it contains. This causes link failures when using gold to link objects created by llvm-objcopy.

Fix this for now by copying GNU objcopy's behavior of placing SHT_GROUP sections first. In the future, we may want to remove this sorting entirely to more closely preserve the input file layout.

This fixes https://bugs.llvm.org/show_bug.cgi?id=42052.

Reviewers: jakehehrlich, jhenderson, MaskRay, espindola, alexshap

Reviewed By: MaskRay

Subscribers: phuongtrang148993, emaste, arichardson, llvm-commits

Tags: #llvm

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

llvm-svn: 362973
2019-06-10 18:35:01 +00:00

2121 lines
74 KiB
C++
Raw Blame History

//===- Object.cpp ---------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "Object.h"
#include "llvm-objcopy.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/MC/MCTargetOptions.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Support/Compression.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileOutputBuffer.h"
#include "llvm/Support/Path.h"
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <unordered_set>
#include <utility>
#include <vector>
namespace llvm {
namespace objcopy {
namespace elf {
using namespace object;
using namespace ELF;
template <class ELFT> void ELFWriter<ELFT>::writePhdr(const Segment &Seg) {
uint8_t *B = Buf.getBufferStart() + Obj.ProgramHdrSegment.Offset +
Seg.Index * sizeof(Elf_Phdr);
Elf_Phdr &Phdr = *reinterpret_cast<Elf_Phdr *>(B);
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;
}
Error SectionBase::removeSectionReferences(
bool AllowBrokenLinks,
function_ref<bool(const SectionBase *)> ToRemove) {
return Error::success();
}
Error SectionBase::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
return Error::success();
}
void SectionBase::initialize(SectionTableRef SecTable) {}
void SectionBase::finalize() {}
void SectionBase::markSymbols() {}
void SectionBase::replaceSectionReferences(
const DenseMap<SectionBase *, SectionBase *> &) {}
template <class ELFT> void ELFWriter<ELFT>::writeShdr(const SectionBase &Sec) {
uint8_t *B = Buf.getBufferStart() + Sec.HeaderOffset;
Elf_Shdr &Shdr = *reinterpret_cast<Elf_Shdr *>(B);
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;
}
template <class ELFT> void ELFSectionSizer<ELFT>::visit(Section &Sec) {}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(OwnedDataSection &Sec) {}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(StringTableSection &Sec) {}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(DynamicRelocationSection &Sec) {}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(SymbolTableSection &Sec) {
Sec.EntrySize = sizeof(Elf_Sym);
Sec.Size = Sec.Symbols.size() * Sec.EntrySize;
// Align to the largest field in Elf_Sym.
Sec.Align = ELFT::Is64Bits ? sizeof(Elf_Xword) : sizeof(Elf_Word);
}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(RelocationSection &Sec) {
Sec.EntrySize = Sec.Type == SHT_REL ? sizeof(Elf_Rel) : sizeof(Elf_Rela);
Sec.Size = Sec.Relocations.size() * Sec.EntrySize;
// Align to the largest field in Elf_Rel(a).
Sec.Align = ELFT::Is64Bits ? sizeof(Elf_Xword) : sizeof(Elf_Word);
}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(GnuDebugLinkSection &Sec) {}
template <class ELFT> void ELFSectionSizer<ELFT>::visit(GroupSection &Sec) {}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(SectionIndexSection &Sec) {}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(CompressedSection &Sec) {}
template <class ELFT>
void ELFSectionSizer<ELFT>::visit(DecompressedSection &Sec) {}
void BinarySectionWriter::visit(const SectionIndexSection &Sec) {
error("cannot write symbol section index table '" + Sec.Name + "' ");
}
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 '" + Sec.Name + "' out to binary");
}
void BinarySectionWriter::visit(const GroupSection &Sec) {
error("cannot write '" + Sec.Name + "' out to binary");
}
void SectionWriter::visit(const Section &Sec) {
if (Sec.Type != SHT_NOBITS)
llvm::copy(Sec.Contents, Out.getBufferStart() + Sec.Offset);
}
static bool addressOverflows32bit(uint64_t Addr) {
// Sign extended 32 bit addresses (e.g 0xFFFFFFFF80000000) are ok
return Addr > UINT32_MAX && Addr + 0x80000000 > UINT32_MAX;
}
template <class T> static T checkedGetHex(StringRef S) {
T Value;
bool Fail = S.getAsInteger(16, Value);
assert(!Fail);
(void)Fail;
return Value;
}
// Fills exactly Len bytes of buffer with hexadecimal characters
// representing value 'X'
template <class T, class Iterator>
static Iterator utohexstr(T X, Iterator It, size_t Len) {
// Fill range with '0'
std::fill(It, It + Len, '0');
for (long I = Len - 1; I >= 0; --I) {
unsigned char Mod = static_cast<unsigned char>(X) & 15;
*(It + I) = hexdigit(Mod, false);
X >>= 4;
}
assert(X == 0);
return It + Len;
}
uint8_t IHexRecord::getChecksum(StringRef S) {
assert((S.size() & 1) == 0);
uint8_t Checksum = 0;
while (!S.empty()) {
Checksum += checkedGetHex<uint8_t>(S.take_front(2));
S = S.drop_front(2);
}
return -Checksum;
}
IHexLineData IHexRecord::getLine(uint8_t Type, uint16_t Addr,
ArrayRef<uint8_t> Data) {
IHexLineData Line(getLineLength(Data.size()));
assert(Line.size());
auto Iter = Line.begin();
*Iter++ = ':';
Iter = utohexstr(Data.size(), Iter, 2);
Iter = utohexstr(Addr, Iter, 4);
Iter = utohexstr(Type, Iter, 2);
for (uint8_t X : Data)
Iter = utohexstr(X, Iter, 2);
StringRef S(Line.data() + 1, std::distance(Line.begin() + 1, Iter));
Iter = utohexstr(getChecksum(S), Iter, 2);
*Iter++ = '\r';
*Iter++ = '\n';
assert(Iter == Line.end());
return Line;
}
static uint64_t sectionPhysicalAddr(const SectionBase *Sec) {
Segment *Seg = Sec->ParentSegment;
if (Seg && Seg->Type != ELF::PT_LOAD)
Seg = nullptr;
return Seg ? Seg->PAddr + Sec->OriginalOffset - Seg->OriginalOffset
: Sec->Addr;
}
void IHexSectionWriterBase::writeSection(const SectionBase *Sec,
ArrayRef<uint8_t> Data) {
assert(Data.size() == Sec->Size);
const uint32_t ChunkSize = 16;
uint32_t Addr = sectionPhysicalAddr(Sec) & 0xFFFFFFFFU;
while (!Data.empty()) {
uint64_t DataSize = std::min<uint64_t>(Data.size(), ChunkSize);
if (Addr > SegmentAddr + BaseAddr + 0xFFFFU) {
if (Addr > 0xFFFFFU) {
// Write extended address record, zeroing segment address
// if needed.
if (SegmentAddr != 0)
SegmentAddr = writeSegmentAddr(0U);
BaseAddr = writeBaseAddr(Addr);
} else {
// We can still remain 16-bit
SegmentAddr = writeSegmentAddr(Addr);
}
}
uint64_t SegOffset = Addr - BaseAddr - SegmentAddr;
assert(SegOffset <= 0xFFFFU);
DataSize = std::min(DataSize, 0x10000U - SegOffset);
writeData(0, SegOffset, Data.take_front(DataSize));
Addr += DataSize;
Data = Data.drop_front(DataSize);
}
}
uint64_t IHexSectionWriterBase::writeSegmentAddr(uint64_t Addr) {
assert(Addr <= 0xFFFFFU);
uint8_t Data[] = {static_cast<uint8_t>((Addr & 0xF0000U) >> 12), 0};
writeData(2, 0, Data);
return Addr & 0xF0000U;
}
uint64_t IHexSectionWriterBase::writeBaseAddr(uint64_t Addr) {
assert(Addr <= 0xFFFFFFFFU);
uint64_t Base = Addr & 0xFFFF0000U;
uint8_t Data[] = {static_cast<uint8_t>(Base >> 24),
static_cast<uint8_t>((Base >> 16) & 0xFF)};
writeData(4, 0, Data);
return Base;
}
void IHexSectionWriterBase::writeData(uint8_t Type, uint16_t Addr,
ArrayRef<uint8_t> Data) {
Offset += IHexRecord::getLineLength(Data.size());
}
void IHexSectionWriterBase::visit(const Section &Sec) {
writeSection(&Sec, Sec.Contents);
}
void IHexSectionWriterBase::visit(const OwnedDataSection &Sec) {
writeSection(&Sec, Sec.Data);
}
void IHexSectionWriterBase::visit(const StringTableSection &Sec) {
// Check that sizer has already done its work
assert(Sec.Size == Sec.StrTabBuilder.getSize());
// We are free to pass an invalid pointer to writeSection as long
// as we don't actually write any data. The real writer class has
// to override this method .
writeSection(&Sec, {nullptr, static_cast<size_t>(Sec.Size)});
}
void IHexSectionWriterBase::visit(const DynamicRelocationSection &Sec) {
writeSection(&Sec, Sec.Contents);
}
void IHexSectionWriter::writeData(uint8_t Type, uint16_t Addr,
ArrayRef<uint8_t> Data) {
IHexLineData HexData = IHexRecord::getLine(Type, Addr, Data);
memcpy(Out.getBufferStart() + Offset, HexData.data(), HexData.size());
Offset += HexData.size();
}
void IHexSectionWriter::visit(const StringTableSection &Sec) {
assert(Sec.Size == Sec.StrTabBuilder.getSize());
std::vector<uint8_t> Data(Sec.Size);
Sec.StrTabBuilder.write(Data.data());
writeSection(&Sec, Data);
}
void Section::accept(SectionVisitor &Visitor) const { Visitor.visit(*this); }
void Section::accept(MutableSectionVisitor &Visitor) { Visitor.visit(*this); }
void SectionWriter::visit(const OwnedDataSection &Sec) {
llvm::copy(Sec.Data, Out.getBufferStart() + Sec.Offset);
}
static const std::vector<uint8_t> ZlibGnuMagic = {'Z', 'L', 'I', 'B'};
static bool isDataGnuCompressed(ArrayRef<uint8_t> Data) {
return Data.size() > ZlibGnuMagic.size() &&
std::equal(ZlibGnuMagic.begin(), ZlibGnuMagic.end(), Data.data());
}
template <class ELFT>
static std::tuple<uint64_t, uint64_t>
getDecompressedSizeAndAlignment(ArrayRef<uint8_t> Data) {
const bool IsGnuDebug = isDataGnuCompressed(Data);
const uint64_t DecompressedSize =
IsGnuDebug
? support::endian::read64be(Data.data() + ZlibGnuMagic.size())
: reinterpret_cast<const Elf_Chdr_Impl<ELFT> *>(Data.data())->ch_size;
const uint64_t DecompressedAlign =
IsGnuDebug ? 1
: reinterpret_cast<const Elf_Chdr_Impl<ELFT> *>(Data.data())
->ch_addralign;
return std::make_tuple(DecompressedSize, DecompressedAlign);
}
template <class ELFT>
void ELFSectionWriter<ELFT>::visit(const DecompressedSection &Sec) {
const size_t DataOffset = isDataGnuCompressed(Sec.OriginalData)
? (ZlibGnuMagic.size() + sizeof(Sec.Size))
: sizeof(Elf_Chdr_Impl<ELFT>);
StringRef CompressedContent(
reinterpret_cast<const char *>(Sec.OriginalData.data()) + DataOffset,
Sec.OriginalData.size() - DataOffset);
SmallVector<char, 128> DecompressedContent;
if (Error E = zlib::uncompress(CompressedContent, DecompressedContent,
static_cast<size_t>(Sec.Size)))
reportError(Sec.Name, std::move(E));
uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
std::copy(DecompressedContent.begin(), DecompressedContent.end(), Buf);
}
void BinarySectionWriter::visit(const DecompressedSection &Sec) {
error("cannot write compressed section '" + Sec.Name + "' ");
}
void DecompressedSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void DecompressedSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
void OwnedDataSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void OwnedDataSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
void OwnedDataSection::appendHexData(StringRef HexData) {
assert((HexData.size() & 1) == 0);
while (!HexData.empty()) {
Data.push_back(checkedGetHex<uint8_t>(HexData.take_front(2)));
HexData = HexData.drop_front(2);
}
Size = Data.size();
}
void BinarySectionWriter::visit(const CompressedSection &Sec) {
error("cannot write compressed section '" + Sec.Name + "' ");
}
template <class ELFT>
void ELFSectionWriter<ELFT>::visit(const CompressedSection &Sec) {
uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
if (Sec.CompressionType == DebugCompressionType::None) {
std::copy(Sec.OriginalData.begin(), Sec.OriginalData.end(), Buf);
return;
}
if (Sec.CompressionType == DebugCompressionType::GNU) {
const char *Magic = "ZLIB";
memcpy(Buf, Magic, strlen(Magic));
Buf += strlen(Magic);
const uint64_t DecompressedSize =
support::endian::read64be(&Sec.DecompressedSize);
memcpy(Buf, &DecompressedSize, sizeof(DecompressedSize));
Buf += sizeof(DecompressedSize);
} else {
Elf_Chdr_Impl<ELFT> Chdr;
Chdr.ch_type = ELF::ELFCOMPRESS_ZLIB;
Chdr.ch_size = Sec.DecompressedSize;
Chdr.ch_addralign = Sec.DecompressedAlign;
memcpy(Buf, &Chdr, sizeof(Chdr));
Buf += sizeof(Chdr);
}
std::copy(Sec.CompressedData.begin(), Sec.CompressedData.end(), Buf);
}
CompressedSection::CompressedSection(const SectionBase &Sec,
DebugCompressionType CompressionType)
: SectionBase(Sec), CompressionType(CompressionType),
DecompressedSize(Sec.OriginalData.size()), DecompressedAlign(Sec.Align) {
if (Error E = zlib::compress(
StringRef(reinterpret_cast<const char *>(OriginalData.data()),
OriginalData.size()),
CompressedData))
reportError(Name, std::move(E));
size_t ChdrSize;
if (CompressionType == DebugCompressionType::GNU) {
Name = ".z" + Sec.Name.substr(1);
ChdrSize = sizeof("ZLIB") - 1 + sizeof(uint64_t);
} else {
Flags |= ELF::SHF_COMPRESSED;
ChdrSize =
std::max(std::max(sizeof(object::Elf_Chdr_Impl<object::ELF64LE>),
sizeof(object::Elf_Chdr_Impl<object::ELF64BE>)),
std::max(sizeof(object::Elf_Chdr_Impl<object::ELF32LE>),
sizeof(object::Elf_Chdr_Impl<object::ELF32BE>)));
}
Size = ChdrSize + CompressedData.size();
Align = 8;
}
CompressedSection::CompressedSection(ArrayRef<uint8_t> CompressedData,
uint64_t DecompressedSize,
uint64_t DecompressedAlign)
: CompressionType(DebugCompressionType::None),
DecompressedSize(DecompressedSize), DecompressedAlign(DecompressedAlign) {
OriginalData = CompressedData;
}
void CompressedSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void CompressedSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
void StringTableSection::addString(StringRef Name) { StrTabBuilder.add(Name); }
uint32_t StringTableSection::findIndex(StringRef Name) const {
return StrTabBuilder.getOffset(Name);
}
void StringTableSection::prepareForLayout() {
StrTabBuilder.finalize();
Size = StrTabBuilder.getSize();
}
void SectionWriter::visit(const StringTableSection &Sec) {
Sec.StrTabBuilder.write(Out.getBufferStart() + Sec.Offset);
}
void StringTableSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void StringTableSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
template <class ELFT>
void ELFSectionWriter<ELFT>::visit(const SectionIndexSection &Sec) {
uint8_t *Buf = Out.getBufferStart() + Sec.Offset;
llvm::copy(Sec.Indexes, reinterpret_cast<Elf_Word *>(Buf));
}
void SectionIndexSection::initialize(SectionTableRef SecTable) {
Size = 0;
setSymTab(SecTable.getSectionOfType<SymbolTableSection>(
Link,
"Link field value " + Twine(Link) + " in section " + Name + " is invalid",
"Link field value " + Twine(Link) + " in section " + Name +
" is not a symbol table"));
Symbols->setShndxTable(this);
}
void SectionIndexSection::finalize() { Link = Symbols->Index; }
void SectionIndexSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void SectionIndexSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
static bool isValidReservedSectionIndex(uint16_t Index, uint16_t Machine) {
switch (Index) {
case SHN_ABS:
case SHN_COMMON:
return true;
}
if (Machine == EM_HEXAGON) {
switch (Index) {
case SHN_HEXAGON_SCOMMON:
case SHN_HEXAGON_SCOMMON_2:
case SHN_HEXAGON_SCOMMON_4:
case SHN_HEXAGON_SCOMMON_8:
return true;
}
}
return false;
}
// Large indexes force us to clarify exactly what this function should do. This
// function should return the value that will appear in st_shndx when written
// out.
uint16_t Symbol::getShndx() const {
if (DefinedIn != nullptr) {
if (DefinedIn->Index >= SHN_LORESERVE)
return SHN_XINDEX;
return DefinedIn->Index;
}
switch (ShndxType) {
// This means that we don't have a defined section but we do need to
// output a legitimate section index.
case SYMBOL_SIMPLE_INDEX:
return SHN_UNDEF;
case SYMBOL_ABS:
case SYMBOL_COMMON:
case SYMBOL_HEXAGON_SCOMMON:
case SYMBOL_HEXAGON_SCOMMON_2:
case SYMBOL_HEXAGON_SCOMMON_4:
case SYMBOL_HEXAGON_SCOMMON_8:
case SYMBOL_XINDEX:
return static_cast<uint16_t>(ShndxType);
}
llvm_unreachable("Symbol with invalid ShndxType encountered");
}
bool Symbol::isCommon() const { return getShndx() == SHN_COMMON; }
void SymbolTableSection::assignIndices() {
uint32_t Index = 0;
for (auto &Sym : Symbols)
Sym->Index = Index++;
}
void SymbolTableSection::addSymbol(Twine Name, uint8_t Bind, uint8_t Type,
SectionBase *DefinedIn, uint64_t Value,
uint8_t Visibility, uint16_t Shndx,
uint64_t SymbolSize) {
Symbol Sym;
Sym.Name = Name.str();
Sym.Binding = Bind;
Sym.Type = Type;
Sym.DefinedIn = DefinedIn;
if (DefinedIn != nullptr)
DefinedIn->HasSymbol = true;
if (DefinedIn == nullptr) {
if (Shndx >= SHN_LORESERVE)
Sym.ShndxType = static_cast<SymbolShndxType>(Shndx);
else
Sym.ShndxType = SYMBOL_SIMPLE_INDEX;
}
Sym.Value = Value;
Sym.Visibility = Visibility;
Sym.Size = SymbolSize;
Sym.Index = Symbols.size();
Symbols.emplace_back(llvm::make_unique<Symbol>(Sym));
Size += this->EntrySize;
}
Error SymbolTableSection::removeSectionReferences(
bool AllowBrokenLinks,
function_ref<bool(const SectionBase *)> ToRemove) {
if (ToRemove(SectionIndexTable))
SectionIndexTable = nullptr;
if (ToRemove(SymbolNames)) {
if (!AllowBrokenLinks)
return createStringError(
llvm::errc::invalid_argument,
"string table '%s' cannot be removed because it is "
"referenced by the symbol table '%s'",
SymbolNames->Name.data(), this->Name.data());
SymbolNames = nullptr;
}
return removeSymbols(
[ToRemove](const Symbol &Sym) { return ToRemove(Sym.DefinedIn); });
}
void SymbolTableSection::updateSymbols(function_ref<void(Symbol &)> Callable) {
std::for_each(std::begin(Symbols) + 1, std::end(Symbols),
[Callable](SymPtr &Sym) { Callable(*Sym); });
std::stable_partition(
std::begin(Symbols), std::end(Symbols),
[](const SymPtr &Sym) { return Sym->Binding == STB_LOCAL; });
assignIndices();
}
Error SymbolTableSection::removeSymbols(
function_ref<bool(const Symbol &)> ToRemove) {
Symbols.erase(
std::remove_if(std::begin(Symbols) + 1, std::end(Symbols),
[ToRemove](const SymPtr &Sym) { return ToRemove(*Sym); }),
std::end(Symbols));
Size = Symbols.size() * EntrySize;
assignIndices();
return Error::success();
}
void SymbolTableSection::replaceSectionReferences(
const DenseMap<SectionBase *, SectionBase *> &FromTo) {
for (std::unique_ptr<Symbol> &Sym : Symbols)
if (SectionBase *To = FromTo.lookup(Sym->DefinedIn))
Sym->DefinedIn = To;
}
void SymbolTableSection::initialize(SectionTableRef SecTable) {
Size = 0;
setStrTab(SecTable.getSectionOfType<StringTableSection>(
Link,
"Symbol table has link index of " + Twine(Link) +
" which is not a valid index",
"Symbol table has link index of " + Twine(Link) +
" which is not a string table"));
}
void SymbolTableSection::finalize() {
uint32_t MaxLocalIndex = 0;
for (std::unique_ptr<Symbol> &Sym : Symbols) {
Sym->NameIndex =
SymbolNames == nullptr ? 0 : SymbolNames->findIndex(Sym->Name);
if (Sym->Binding == STB_LOCAL)
MaxLocalIndex = std::max(MaxLocalIndex, Sym->Index);
}
// Now we need to set the Link and Info fields.
Link = SymbolNames == nullptr ? 0 : SymbolNames->Index;
Info = MaxLocalIndex + 1;
}
void SymbolTableSection::prepareForLayout() {
// Reserve proper amount of space in section index table, so we can
// layout sections correctly. We will fill the table with correct
// indexes later in fillShdnxTable.
if (SectionIndexTable)
SectionIndexTable->reserve(Symbols.size());
// Add all of our strings to SymbolNames so that SymbolNames has the right
// size before layout is decided.
// If the symbol names section has been removed, don't try to add strings to
// the table.
if (SymbolNames != nullptr)
for (std::unique_ptr<Symbol> &Sym : Symbols)
SymbolNames->addString(Sym->Name);
}
void SymbolTableSection::fillShndxTable() {
if (SectionIndexTable == nullptr)
return;
// Fill section index table with real section indexes. This function must
// be called after assignOffsets.
for (const std::unique_ptr<Symbol> &Sym : Symbols) {
if (Sym->DefinedIn != nullptr && Sym->DefinedIn->Index >= SHN_LORESERVE)
SectionIndexTable->addIndex(Sym->DefinedIn->Index);
else
SectionIndexTable->addIndex(SHN_UNDEF);
}
}
const Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) const {
if (Symbols.size() <= Index)
error("invalid symbol index: " + Twine(Index));
return Symbols[Index].get();
}
Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) {
return const_cast<Symbol *>(
static_cast<const SymbolTableSection *>(this)->getSymbolByIndex(Index));
}
template <class ELFT>
void ELFSectionWriter<ELFT>::visit(const SymbolTableSection &Sec) {
Elf_Sym *Sym = reinterpret_cast<Elf_Sym *>(Out.getBufferStart() + Sec.Offset);
// Loop though symbols setting each entry of the symbol table.
for (const std::unique_ptr<Symbol> &Symbol : Sec.Symbols) {
Sym->st_name = Symbol->NameIndex;
Sym->st_value = Symbol->Value;
Sym->st_size = Symbol->Size;
Sym->st_other = Symbol->Visibility;
Sym->setBinding(Symbol->Binding);
Sym->setType(Symbol->Type);
Sym->st_shndx = Symbol->getShndx();
++Sym;
}
}
void SymbolTableSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void SymbolTableSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
Error RelocationSection::removeSectionReferences(
bool AllowBrokenLinks,
function_ref<bool(const SectionBase *)> ToRemove) {
if (ToRemove(Symbols)) {
if (!AllowBrokenLinks)
return createStringError(
llvm::errc::invalid_argument,
"symbol table '%s' cannot be removed because it is "
"referenced by the relocation section '%s'",
Symbols->Name.data(), this->Name.data());
Symbols = nullptr;
}
for (const Relocation &R : Relocations) {
if (!R.RelocSymbol->DefinedIn || !ToRemove(R.RelocSymbol->DefinedIn))
continue;
return createStringError(llvm::errc::invalid_argument,
"section '%s' cannot be removed: (%s+0x%" PRIx64
") has relocation against symbol '%s'",
R.RelocSymbol->DefinedIn->Name.data(),
SecToApplyRel->Name.data(), R.Offset,
R.RelocSymbol->Name.c_str());
}
return Error::success();
}
template <class SymTabType>
void RelocSectionWithSymtabBase<SymTabType>::initialize(
SectionTableRef SecTable) {
if (Link != SHN_UNDEF)
setSymTab(SecTable.getSectionOfType<SymTabType>(
Link,
"Link field value " + Twine(Link) + " in section " + Name +
" is invalid",
"Link field value " + Twine(Link) + " in section " + Name +
" is not a symbol table"));
if (Info != SHN_UNDEF)
setSection(SecTable.getSection(Info, "Info field value " + Twine(Info) +
" in section " + Name +
" is invalid"));
else
setSection(nullptr);
}
template <class SymTabType>
void RelocSectionWithSymtabBase<SymTabType>::finalize() {
this->Link = Symbols ? Symbols->Index : 0;
if (SecToApplyRel != nullptr)
this->Info = SecToApplyRel->Index;
}
template <class ELFT>
static void setAddend(Elf_Rel_Impl<ELFT, false> &Rel, uint64_t Addend) {}
template <class ELFT>
static void setAddend(Elf_Rel_Impl<ELFT, true> &Rela, uint64_t Addend) {
Rela.r_addend = Addend;
}
template <class RelRange, class T>
static void writeRel(const RelRange &Relocations, T *Buf) {
for (const auto &Reloc : Relocations) {
Buf->r_offset = Reloc.Offset;
setAddend(*Buf, Reloc.Addend);
Buf->setSymbolAndType(Reloc.RelocSymbol->Index, Reloc.Type, false);
++Buf;
}
}
template <class ELFT>
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(Sec.Relocations, reinterpret_cast<Elf_Rela *>(Buf));
}
void RelocationSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void RelocationSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
Error RelocationSection::removeSymbols(
function_ref<bool(const Symbol &)> ToRemove) {
for (const Relocation &Reloc : Relocations)
if (ToRemove(*Reloc.RelocSymbol))
return createStringError(
llvm::errc::invalid_argument,
"not stripping symbol '%s' because it is named in a relocation",
Reloc.RelocSymbol->Name.data());
return Error::success();
}
void RelocationSection::markSymbols() {
for (const Relocation &Reloc : Relocations)
Reloc.RelocSymbol->Referenced = true;
}
void RelocationSection::replaceSectionReferences(
const DenseMap<SectionBase *, SectionBase *> &FromTo) {
// Update the target section if it was replaced.
if (SectionBase *To = FromTo.lookup(SecToApplyRel))
SecToApplyRel = To;
}
void SectionWriter::visit(const DynamicRelocationSection &Sec) {
llvm::copy(Sec.Contents, Out.getBufferStart() + Sec.Offset);
}
void DynamicRelocationSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void DynamicRelocationSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
Error DynamicRelocationSection::removeSectionReferences(
bool AllowBrokenLinks, function_ref<bool(const SectionBase *)> ToRemove) {
if (ToRemove(Symbols)) {
if (!AllowBrokenLinks)
return createStringError(
llvm::errc::invalid_argument,
"symbol table '%s' cannot be removed because it is "
"referenced by the relocation section '%s'",
Symbols->Name.data(), this->Name.data());
Symbols = nullptr;
}
// SecToApplyRel contains a section referenced by sh_info field. It keeps
// a section to which the relocation section applies. When we remove any
// sections we also remove their relocation sections. Since we do that much
// earlier, this assert should never be triggered.
assert(!SecToApplyRel || !ToRemove(SecToApplyRel));
return Error::success();
}
Error Section::removeSectionReferences(bool AllowBrokenDependency,
function_ref<bool(const SectionBase *)> ToRemove) {
if (ToRemove(LinkSection)) {
if (!AllowBrokenDependency)
return createStringError(llvm::errc::invalid_argument,
"section '%s' cannot be removed because it is "
"referenced by the section '%s'",
LinkSection->Name.data(), this->Name.data());
LinkSection = nullptr;
}
return Error::success();
}
void GroupSection::finalize() {
this->Info = Sym->Index;
this->Link = SymTab->Index;
}
Error GroupSection::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
if (ToRemove(*Sym))
return createStringError(llvm::errc::invalid_argument,
"symbol '%s' cannot be removed because it is "
"referenced by the section '%s[%d]'",
Sym->Name.data(), this->Name.data(), this->Index);
return Error::success();
}
void GroupSection::markSymbols() {
if (Sym)
Sym->Referenced = true;
}
void GroupSection::replaceSectionReferences(
const DenseMap<SectionBase *, SectionBase *> &FromTo) {
for (SectionBase *&Sec : GroupMembers)
if (SectionBase *To = FromTo.lookup(Sec))
Sec = To;
}
void Section::initialize(SectionTableRef SecTable) {
if (Link == ELF::SHN_UNDEF)
return;
LinkSection =
SecTable.getSection(Link, "Link field value " + Twine(Link) +
" in section " + Name + " is invalid");
if (LinkSection->Type == ELF::SHT_SYMTAB)
LinkSection = nullptr;
}
void Section::finalize() { this->Link = LinkSection ? LinkSection->Index : 0; }
void GnuDebugLinkSection::init(StringRef File) {
FileName = sys::path::filename(File);
// The format for the .gnu_debuglink starts with the file name and is
// followed by a null terminator and then the CRC32 of the file. The CRC32
// should be 4 byte aligned. So we add the FileName size, a 1 for the null
// byte, and then finally push the size to alignment and add 4.
Size = alignTo(FileName.size() + 1, 4) + 4;
// The CRC32 will only be aligned if we align the whole section.
Align = 4;
Type = ELF::SHT_PROGBITS;
Name = ".gnu_debuglink";
// For sections not found in segments, OriginalOffset is only used to
// establish the order that sections should go in. By using the maximum
// possible offset we cause this section to wind up at the end.
OriginalOffset = std::numeric_limits<uint64_t>::max();
}
GnuDebugLinkSection::GnuDebugLinkSection(StringRef File,
uint32_t PrecomputedCRC)
: FileName(File), CRC32(PrecomputedCRC) {
init(File);
}
template <class ELFT>
void ELFSectionWriter<ELFT>::visit(const GnuDebugLinkSection &Sec) {
unsigned char *Buf = Out.getBufferStart() + Sec.Offset;
Elf_Word *CRC =
reinterpret_cast<Elf_Word *>(Buf + Sec.Size - sizeof(Elf_Word));
*CRC = Sec.CRC32;
llvm::copy(Sec.FileName, Buf);
}
void GnuDebugLinkSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void GnuDebugLinkSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
template <class ELFT>
void ELFSectionWriter<ELFT>::visit(const GroupSection &Sec) {
ELF::Elf32_Word *Buf =
reinterpret_cast<ELF::Elf32_Word *>(Out.getBufferStart() + Sec.Offset);
*Buf++ = Sec.FlagWord;
for (SectionBase *S : Sec.GroupMembers)
support::endian::write32<ELFT::TargetEndianness>(Buf++, S->Index);
}
void GroupSection::accept(SectionVisitor &Visitor) const {
Visitor.visit(*this);
}
void GroupSection::accept(MutableSectionVisitor &Visitor) {
Visitor.visit(*this);
}
// Returns true IFF a section is wholly inside the range of a segment
static bool sectionWithinSegment(const SectionBase &Section,
const Segment &Segment) {
// If a section is empty it should be treated like it has a size of 1. This is
// to clarify the case when an empty section lies on a boundary between two
// segments and ensures that the section "belongs" to the second segment and
// not the first.
uint64_t SecSize = Section.Size ? Section.Size : 1;
if (Section.Type == SHT_NOBITS) {
if (!(Section.Flags & SHF_ALLOC))
return false;
bool SectionIsTLS = Section.Flags & SHF_TLS;
bool SegmentIsTLS = Segment.Type == PT_TLS;
if (SectionIsTLS != SegmentIsTLS)
return false;
return Segment.VAddr <= Section.Addr &&
Segment.VAddr + Segment.MemSize >= Section.Addr + SecSize;
}
return Segment.Offset <= Section.OriginalOffset &&
Segment.Offset + Segment.FileSize >= Section.OriginalOffset + SecSize;
}
// Returns true IFF a segment's original offset is inside of another segment's
// range.
static bool segmentOverlapsSegment(const Segment &Child,
const Segment &Parent) {
return Parent.OriginalOffset <= Child.OriginalOffset &&
Parent.OriginalOffset + Parent.FileSize > Child.OriginalOffset;
}
static bool compareSegmentsByOffset(const Segment *A, const Segment *B) {
// Any segment without a parent segment should come before a segment
// that has a parent segment.
if (A->OriginalOffset < B->OriginalOffset)
return true;
if (A->OriginalOffset > B->OriginalOffset)
return false;
return A->Index < B->Index;
}
static bool compareSegmentsByPAddr(const Segment *A, const Segment *B) {
if (A->PAddr < B->PAddr)
return true;
if (A->PAddr > B->PAddr)
return false;
return A->Index < B->Index;
}
void BinaryELFBuilder::initFileHeader() {
Obj->Flags = 0x0;
Obj->Type = ET_REL;
Obj->OSABI = ELFOSABI_NONE;
Obj->ABIVersion = 0;
Obj->Entry = 0x0;
Obj->Machine = EMachine;
Obj->Version = 1;
}
void BinaryELFBuilder::initHeaderSegment() { Obj->ElfHdrSegment.Index = 0; }
StringTableSection *BinaryELFBuilder::addStrTab() {
auto &StrTab = Obj->addSection<StringTableSection>();
StrTab.Name = ".strtab";
Obj->SectionNames = &StrTab;
return &StrTab;
}
SymbolTableSection *BinaryELFBuilder::addSymTab(StringTableSection *StrTab) {
auto &SymTab = Obj->addSection<SymbolTableSection>();
SymTab.Name = ".symtab";
SymTab.Link = StrTab->Index;
// The symbol table always needs a null symbol
SymTab.addSymbol("", 0, 0, nullptr, 0, 0, 0, 0);
Obj->SymbolTable = &SymTab;
return &SymTab;
}
void BinaryELFBuilder::addData(SymbolTableSection *SymTab) {
auto Data = ArrayRef<uint8_t>(
reinterpret_cast<const uint8_t *>(MemBuf->getBufferStart()),
MemBuf->getBufferSize());
auto &DataSection = Obj->addSection<Section>(Data);
DataSection.Name = ".data";
DataSection.Type = ELF::SHT_PROGBITS;
DataSection.Size = Data.size();
DataSection.Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
std::string SanitizedFilename = MemBuf->getBufferIdentifier().str();
std::replace_if(std::begin(SanitizedFilename), std::end(SanitizedFilename),
[](char C) { return !isalnum(C); }, '_');
Twine Prefix = Twine("_binary_") + SanitizedFilename;
SymTab->addSymbol(Prefix + "_start", STB_GLOBAL, STT_NOTYPE, &DataSection,
/*Value=*/0, STV_DEFAULT, 0, 0);
SymTab->addSymbol(Prefix + "_end", STB_GLOBAL, STT_NOTYPE, &DataSection,
/*Value=*/DataSection.Size, STV_DEFAULT, 0, 0);
SymTab->addSymbol(Prefix + "_size", STB_GLOBAL, STT_NOTYPE, nullptr,
/*Value=*/DataSection.Size, STV_DEFAULT, SHN_ABS, 0);
}
void BinaryELFBuilder::initSections() {
for (SectionBase &Section : Obj->sections())
Section.initialize(Obj->sections());
}
std::unique_ptr<Object> BinaryELFBuilder::build() {
initFileHeader();
initHeaderSegment();
SymbolTableSection *SymTab = addSymTab(addStrTab());
initSections();
addData(SymTab);
return std::move(Obj);
}
template <class ELFT> void ELFBuilder<ELFT>::setParentSegment(Segment &Child) {
for (Segment &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)) {
// We want a canonical "most parental" segment but this requires
// inspecting the ParentSegment.
if (compareSegmentsByOffset(&Parent, &Child))
if (Child.ParentSegment == nullptr ||
compareSegmentsByOffset(&Parent, Child.ParentSegment)) {
Child.ParentSegment = &Parent;
}
}
}
}
template <class ELFT> void ELFBuilder<ELFT>::findEhdrOffset() {
if (!ExtractPartition)
return;
for (const SectionBase &Section : Obj.sections()) {
if (Section.Type == SHT_LLVM_PART_EHDR &&
Section.Name == *ExtractPartition) {
EhdrOffset = Section.Offset;
return;
}
}
error("could not find partition named '" + *ExtractPartition + "'");
}
template <class ELFT>
void ELFBuilder<ELFT>::readProgramHeaders(const ELFFile<ELFT> &HeadersFile) {
uint32_t Index = 0;
for (const auto &Phdr : unwrapOrError(HeadersFile.program_headers())) {
if (Phdr.p_offset + Phdr.p_filesz > HeadersFile.getBufSize())
error("program header with offset 0x" + Twine::utohexstr(Phdr.p_offset) +
" and file size 0x" + Twine::utohexstr(Phdr.p_filesz) +
" goes past the end of the file");
ArrayRef<uint8_t> Data{HeadersFile.base() + Phdr.p_offset,
(size_t)Phdr.p_filesz};
Segment &Seg = Obj.addSegment(Data);
Seg.Type = Phdr.p_type;
Seg.Flags = Phdr.p_flags;
Seg.OriginalOffset = Phdr.p_offset + EhdrOffset;
Seg.Offset = Phdr.p_offset + EhdrOffset;
Seg.VAddr = Phdr.p_vaddr;
Seg.PAddr = Phdr.p_paddr;
Seg.FileSize = Phdr.p_filesz;
Seg.MemSize = Phdr.p_memsz;
Seg.Align = Phdr.p_align;
Seg.Index = Index++;
for (SectionBase &Section : Obj.sections()) {
if (sectionWithinSegment(Section, Seg)) {
Seg.addSection(&Section);
if (!Section.ParentSegment ||
Section.ParentSegment->Offset > Seg.Offset) {
Section.ParentSegment = &Seg;
}
}
}
}
auto &ElfHdr = Obj.ElfHdrSegment;
ElfHdr.Index = Index++;
ElfHdr.OriginalOffset = ElfHdr.Offset = EhdrOffset;
const auto &Ehdr = *HeadersFile.getHeader();
auto &PrHdr = Obj.ProgramHdrSegment;
PrHdr.Type = PT_PHDR;
PrHdr.Flags = 0;
// The spec requires us to have p_vaddr % p_align == p_offset % p_align.
// Whereas this works automatically for ElfHdr, here OriginalOffset is
// always non-zero and to ensure the equation we assign the same value to
// VAddr as well.
PrHdr.OriginalOffset = PrHdr.Offset = PrHdr.VAddr = EhdrOffset + Ehdr.e_phoff;
PrHdr.PAddr = 0;
PrHdr.FileSize = PrHdr.MemSize = Ehdr.e_phentsize * Ehdr.e_phnum;
// The spec requires us to naturally align all the fields.
PrHdr.Align = sizeof(Elf_Addr);
PrHdr.Index = Index++;
// Now we do an O(n^2) loop through the segments in order to match up
// segments.
for (Segment &Child : Obj.segments())
setParentSegment(Child);
setParentSegment(ElfHdr);
setParentSegment(PrHdr);
}
template <class ELFT>
void ELFBuilder<ELFT>::initGroupSection(GroupSection *GroupSec) {
if (GroupSec->Align % sizeof(ELF::Elf32_Word) != 0)
error("invalid alignment " + Twine(GroupSec->Align) + " of group section '" +
GroupSec->Name + "'");
SectionTableRef SecTable = Obj.sections();
auto SymTab = SecTable.template getSectionOfType<SymbolTableSection>(
GroupSec->Link,
"link field value '" + Twine(GroupSec->Link) + "' in section '" +
GroupSec->Name + "' is invalid",
"link field value '" + Twine(GroupSec->Link) + "' in section '" +
GroupSec->Name + "' is not a symbol table");
Symbol *Sym = SymTab->getSymbolByIndex(GroupSec->Info);
if (!Sym)
error("info field value '" + Twine(GroupSec->Info) + "' in section '" +
GroupSec->Name + "' is not a valid symbol index");
GroupSec->setSymTab(SymTab);
GroupSec->setSymbol(Sym);
if (GroupSec->Contents.size() % sizeof(ELF::Elf32_Word) ||
GroupSec->Contents.empty())
error("the content of the section " + GroupSec->Name + " is malformed");
const ELF::Elf32_Word *Word =
reinterpret_cast<const ELF::Elf32_Word *>(GroupSec->Contents.data());
const ELF::Elf32_Word *End =
Word + GroupSec->Contents.size() / sizeof(ELF::Elf32_Word);
GroupSec->setFlagWord(*Word++);
for (; Word != End; ++Word) {
uint32_t Index = support::endian::read32<ELFT::TargetEndianness>(Word);
GroupSec->addMember(SecTable.getSection(
Index, "group member index " + Twine(Index) + " in section '" +
GroupSec->Name + "' is invalid"));
}
}
template <class ELFT>
void ELFBuilder<ELFT>::initSymbolTable(SymbolTableSection *SymTab) {
const Elf_Shdr &Shdr = *unwrapOrError(ElfFile.getSection(SymTab->Index));
StringRef StrTabData = unwrapOrError(ElfFile.getStringTableForSymtab(Shdr));
ArrayRef<Elf_Word> ShndxData;
auto Symbols = unwrapOrError(ElfFile.symbols(&Shdr));
for (const auto &Sym : Symbols) {
SectionBase *DefSection = nullptr;
StringRef Name = unwrapOrError(Sym.getName(StrTabData));
if (Sym.st_shndx == SHN_XINDEX) {
if (SymTab->getShndxTable() == nullptr)
error("symbol '" + Name +
"' has index SHN_XINDEX but no SHT_SYMTAB_SHNDX section exists");
if (ShndxData.data() == nullptr) {
const Elf_Shdr &ShndxSec =
*unwrapOrError(ElfFile.getSection(SymTab->getShndxTable()->Index));
ShndxData = unwrapOrError(
ElfFile.template getSectionContentsAsArray<Elf_Word>(&ShndxSec));
if (ShndxData.size() != Symbols.size())
error("symbol section index table does not have the same number of "
"entries as the symbol table");
}
Elf_Word Index = ShndxData[&Sym - Symbols.begin()];
DefSection = Obj.sections().getSection(
Index,
"symbol '" + Name + "' has invalid section index " + Twine(Index));
} else if (Sym.st_shndx >= SHN_LORESERVE) {
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 = Obj.sections().getSection(
Sym.st_shndx, "symbol '" + Name +
"' is defined has invalid section index " +
Twine(Sym.st_shndx));
}
SymTab->addSymbol(Name, Sym.getBinding(), Sym.getType(), DefSection,
Sym.getValue(), Sym.st_other, Sym.st_shndx, Sym.st_size);
}
}
template <class ELFT>
static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, false> &Rel) {}
template <class ELFT>
static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, true> &Rela) {
ToSet = Rela.r_addend;
}
template <class T>
static void initRelocations(RelocationSection *Relocs,
SymbolTableSection *SymbolTable, T RelRange) {
for (const auto &Rel : RelRange) {
Relocation ToAdd;
ToAdd.Offset = Rel.r_offset;
getAddend(ToAdd.Addend, Rel);
ToAdd.Type = Rel.getType(false);
ToAdd.RelocSymbol = SymbolTable->getSymbolByIndex(Rel.getSymbol(false));
Relocs->addRelocation(ToAdd);
}
}
SectionBase *SectionTableRef::getSection(uint32_t Index, Twine ErrMsg) {
if (Index == SHN_UNDEF || Index > Sections.size())
error(ErrMsg);
return Sections[Index - 1].get();
}
template <class T>
T *SectionTableRef::getSectionOfType(uint32_t Index, Twine IndexErrMsg,
Twine TypeErrMsg) {
if (T *Sec = dyn_cast<T>(getSection(Index, IndexErrMsg)))
return Sec;
error(TypeErrMsg);
}
template <class ELFT>
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 Obj.addSection<DynamicRelocationSection>(Data);
}
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 Obj.addSection<Section>(Data);
}
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 Obj.addSection<Section>(Data);
case SHT_GROUP:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return Obj.addSection<GroupSection>(Data);
case SHT_DYNSYM:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return Obj.addSection<DynamicSymbolTableSection>(Data);
case SHT_DYNAMIC:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
return Obj.addSection<DynamicSection>(Data);
case SHT_SYMTAB: {
auto &SymTab = Obj.addSection<SymbolTableSection>();
Obj.SymbolTable = &SymTab;
return SymTab;
}
case SHT_SYMTAB_SHNDX: {
auto &ShndxSection = Obj.addSection<SectionIndexSection>();
Obj.SectionIndexTable = &ShndxSection;
return ShndxSection;
}
case SHT_NOBITS:
return Obj.addSection<Section>(Data);
default: {
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
StringRef Name = unwrapOrError(ElfFile.getSectionName(&Shdr));
if (Name.startswith(".zdebug") || (Shdr.sh_flags & ELF::SHF_COMPRESSED)) {
uint64_t DecompressedSize, DecompressedAlign;
std::tie(DecompressedSize, DecompressedAlign) =
getDecompressedSizeAndAlignment<ELFT>(Data);
return Obj.addSection<CompressedSection>(Data, DecompressedSize,
DecompressedAlign);
}
return Obj.addSection<Section>(Data);
}
}
}
template <class ELFT> void ELFBuilder<ELFT>::readSectionHeaders() {
uint32_t Index = 0;
for (const auto &Shdr : unwrapOrError(ElfFile.sections())) {
if (Index == 0) {
++Index;
continue;
}
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++;
Sec.OriginalData =
ArrayRef<uint8_t>(ElfFile.base() + Shdr.sh_offset,
(Shdr.sh_type == SHT_NOBITS) ? 0 : Shdr.sh_size);
}
}
template <class ELFT> void ELFBuilder<ELFT>::readSections() {
// If a section index table exists we'll need to initialize it before we
// initialize the symbol table because the symbol table might need to
// reference it.
if (Obj.SectionIndexTable)
Obj.SectionIndexTable->initialize(Obj.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 (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 : Obj.sections()) {
if (&Section == Obj.SymbolTable)
continue;
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, Obj.SymbolTable,
unwrapOrError(ElfFile.rels(Shdr)));
else
initRelocations(RelSec, Obj.SymbolTable,
unwrapOrError(ElfFile.relas(Shdr)));
} else if (auto GroupSec = dyn_cast<GroupSection>(&Section)) {
initGroupSection(GroupSec);
}
}
uint32_t ShstrIndex = ElfFile.getHeader()->e_shstrndx;
if (ShstrIndex == SHN_XINDEX)
ShstrIndex = unwrapOrError(ElfFile.getSection(0))->sh_link;
if (ShstrIndex == SHN_UNDEF)
Obj.HadShdrs = false;
else
Obj.SectionNames =
Obj.sections().template getSectionOfType<StringTableSection>(
ShstrIndex,
"e_shstrndx field value " + Twine(ShstrIndex) + " in elf header " +
" is invalid",
"e_shstrndx field value " + Twine(ShstrIndex) + " in elf header " +
" is not a string table");
}
template <class ELFT> void ELFBuilder<ELFT>::build() {
readSectionHeaders();
findEhdrOffset();
// The ELFFile whose ELF headers and program headers are copied into the
// output file. Normally the same as ElfFile, but if we're extracting a
// loadable partition it will point to the partition's headers.
ELFFile<ELFT> HeadersFile = unwrapOrError(ELFFile<ELFT>::create(toStringRef(
{ElfFile.base() + EhdrOffset, ElfFile.getBufSize() - EhdrOffset})));
auto &Ehdr = *HeadersFile.getHeader();
Obj.OSABI = Ehdr.e_ident[EI_OSABI];
Obj.ABIVersion = Ehdr.e_ident[EI_ABIVERSION];
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;
readSections();
readProgramHeaders(HeadersFile);
}
Writer::~Writer() {}
Reader::~Reader() {}
std::unique_ptr<Object> BinaryReader::create() const {
return BinaryELFBuilder(MInfo.EMachine, MemBuf).build();
}
std::unique_ptr<Object> ELFReader::create() const {
auto Obj = llvm::make_unique<Object>();
if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
ELFBuilder<ELF32LE> Builder(*O, *Obj, ExtractPartition);
Builder.build();
return Obj;
} else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
ELFBuilder<ELF64LE> Builder(*O, *Obj, ExtractPartition);
Builder.build();
return Obj;
} else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
ELFBuilder<ELF32BE> Builder(*O, *Obj, ExtractPartition);
Builder.build();
return Obj;
} else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
ELFBuilder<ELF64BE> Builder(*O, *Obj, ExtractPartition);
Builder.build();
return Obj;
}
error("invalid file type");
}
template <class ELFT> void ELFWriter<ELFT>::writeEhdr() {
Elf_Ehdr &Ehdr = *reinterpret_cast<Elf_Ehdr *>(Buf.getBufferStart());
std::fill(Ehdr.e_ident, Ehdr.e_ident + 16, 0);
Ehdr.e_ident[EI_MAG0] = 0x7f;
Ehdr.e_ident[EI_MAG1] = 'E';
Ehdr.e_ident[EI_MAG2] = 'L';
Ehdr.e_ident[EI_MAG3] = 'F';
Ehdr.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
Ehdr.e_ident[EI_DATA] =
ELFT::TargetEndianness == support::big ? ELFDATA2MSB : ELFDATA2LSB;
Ehdr.e_ident[EI_VERSION] = EV_CURRENT;
Ehdr.e_ident[EI_OSABI] = Obj.OSABI;
Ehdr.e_ident[EI_ABIVERSION] = Obj.ABIVersion;
Ehdr.e_type = Obj.Type;
Ehdr.e_machine = Obj.Machine;
Ehdr.e_version = Obj.Version;
Ehdr.e_entry = Obj.Entry;
// We have to use the fully-qualified name llvm::size
// since some compilers complain on ambiguous resolution.
Ehdr.e_phnum = llvm::size(Obj.segments());
Ehdr.e_phoff = (Ehdr.e_phnum != 0) ? Obj.ProgramHdrSegment.Offset : 0;
Ehdr.e_phentsize = (Ehdr.e_phnum != 0) ? sizeof(Elf_Phdr) : 0;
Ehdr.e_flags = Obj.Flags;
Ehdr.e_ehsize = sizeof(Elf_Ehdr);
if (WriteSectionHeaders && Obj.sections().size() != 0) {
Ehdr.e_shentsize = sizeof(Elf_Shdr);
Ehdr.e_shoff = Obj.SHOffset;
// """
// If the number of sections is greater than or equal to
// SHN_LORESERVE (0xff00), this member has the value zero and the actual
// number of section header table entries is contained in the sh_size field
// of the section header at index 0.
// """
auto Shnum = Obj.sections().size() + 1;
if (Shnum >= SHN_LORESERVE)
Ehdr.e_shnum = 0;
else
Ehdr.e_shnum = Shnum;
// """
// If the section name string table section index is greater than or equal
// to SHN_LORESERVE (0xff00), this member has the value SHN_XINDEX (0xffff)
// and the actual index of the section name string table section is
// contained in the sh_link field of the section header at index 0.
// """
if (Obj.SectionNames->Index >= SHN_LORESERVE)
Ehdr.e_shstrndx = SHN_XINDEX;
else
Ehdr.e_shstrndx = Obj.SectionNames->Index;
} else {
Ehdr.e_shentsize = 0;
Ehdr.e_shoff = 0;
Ehdr.e_shnum = 0;
Ehdr.e_shstrndx = 0;
}
}
template <class ELFT> void ELFWriter<ELFT>::writePhdrs() {
for (auto &Seg : Obj.segments())
writePhdr(Seg);
}
template <class ELFT> void ELFWriter<ELFT>::writeShdrs() {
// 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.getBufferStart() + Obj.SHOffset);
Shdr.sh_name = 0;
Shdr.sh_type = SHT_NULL;
Shdr.sh_flags = 0;
Shdr.sh_addr = 0;
Shdr.sh_offset = 0;
// See writeEhdr for why we do this.
uint64_t Shnum = Obj.sections().size() + 1;
if (Shnum >= SHN_LORESERVE)
Shdr.sh_size = Shnum;
else
Shdr.sh_size = 0;
// See writeEhdr for why we do this.
if (Obj.SectionNames != nullptr && Obj.SectionNames->Index >= SHN_LORESERVE)
Shdr.sh_link = Obj.SectionNames->Index;
else
Shdr.sh_link = 0;
Shdr.sh_info = 0;
Shdr.sh_addralign = 0;
Shdr.sh_entsize = 0;
for (SectionBase &Sec : Obj.sections())
writeShdr(Sec);
}
template <class ELFT> void ELFWriter<ELFT>::writeSectionData() {
for (SectionBase &Sec : Obj.sections())
// Segments are responsible for writing their contents, so only write the
// section data if the section is not in a segment. Note that this renders
// sections in segments effectively immutable.
if (Sec.ParentSegment == nullptr)
Sec.accept(*SecWriter);
}
template <class ELFT> void ELFWriter<ELFT>::writeSegmentData() {
for (Segment &Seg : Obj.segments()) {
uint8_t *B = Buf.getBufferStart() + Seg.Offset;
assert(Seg.FileSize == Seg.getContents().size() &&
"Segment size must match contents size");
std::memcpy(B, Seg.getContents().data(), Seg.FileSize);
}
// Iterate over removed sections and overwrite their old data with zeroes.
for (auto &Sec : Obj.removedSections()) {
Segment *Parent = Sec.ParentSegment;
if (Parent == nullptr || Sec.Type == SHT_NOBITS || Sec.Size == 0)
continue;
uint64_t Offset =
Sec.OriginalOffset - Parent->OriginalOffset + Parent->Offset;
std::memset(Buf.getBufferStart() + Offset, 0, Sec.Size);
}
}
template <class ELFT>
ELFWriter<ELFT>::ELFWriter(Object &Obj, Buffer &Buf, bool WSH)
: Writer(Obj, Buf), WriteSectionHeaders(WSH && Obj.HadShdrs) {}
Error Object::removeSections(bool AllowBrokenLinks,
std::function<bool(const SectionBase &)> ToRemove) {
auto Iter = std::stable_partition(
std::begin(Sections), std::end(Sections), [=](const SecPtr &Sec) {
if (ToRemove(*Sec))
return false;
if (auto RelSec = dyn_cast<RelocationSectionBase>(Sec.get())) {
if (auto ToRelSec = RelSec->getSection())
return !ToRemove(*ToRelSec);
}
return true;
});
if (SymbolTable != nullptr && ToRemove(*SymbolTable))
SymbolTable = nullptr;
if (SectionNames != nullptr && ToRemove(*SectionNames))
SectionNames = nullptr;
if (SectionIndexTable != nullptr && ToRemove(*SectionIndexTable))
SectionIndexTable = nullptr;
// Now make sure there are no remaining references to the sections that will
// be removed. Sometimes it is impossible to remove a reference so we emit
// an error here instead.
std::unordered_set<const SectionBase *> RemoveSections;
RemoveSections.reserve(std::distance(Iter, std::end(Sections)));
for (auto &RemoveSec : make_range(Iter, std::end(Sections))) {
for (auto &Segment : Segments)
Segment->removeSection(RemoveSec.get());
RemoveSections.insert(RemoveSec.get());
}
// For each section that remains alive, we want to remove the dead references.
// This either might update the content of the section (e.g. remove symbols
// from symbol table that belongs to removed section) or trigger an error if
// a live section critically depends on a section being removed somehow
// (e.g. the removed section is referenced by a relocation).
for (auto &KeepSec : make_range(std::begin(Sections), Iter)) {
if (Error E = KeepSec->removeSectionReferences(AllowBrokenLinks,
[&RemoveSections](const SectionBase *Sec) {
return RemoveSections.find(Sec) != RemoveSections.end();
}))
return E;
}
// Transfer removed sections into the Object RemovedSections container for use
// later.
std::move(Iter, Sections.end(), std::back_inserter(RemovedSections));
// Now finally get rid of them all together.
Sections.erase(Iter, std::end(Sections));
return Error::success();
}
Error Object::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
if (SymbolTable)
for (const SecPtr &Sec : Sections)
if (Error E = Sec->removeSymbols(ToRemove))
return E;
return Error::success();
}
void Object::sortSections() {
// Use stable_sort to maintain the original ordering as closely as possible.
llvm::stable_sort(Sections, [](const SecPtr &A, const SecPtr &B) {
// Put SHT_GROUP sections first, since group section headers must come
// before the sections they contain. This also matches what GNU objcopy
// does.
if (A->Type != B->Type &&
(A->Type == ELF::SHT_GROUP || B->Type == ELF::SHT_GROUP))
return A->Type == ELF::SHT_GROUP;
// For all other sections, sort by offset order.
return A->OriginalOffset < B->OriginalOffset;
});
}
static uint64_t alignToAddr(uint64_t Offset, uint64_t Addr, uint64_t Align) {
// Calculate Diff such that (Offset + Diff) & -Align == Addr & -Align.
if (Align == 0)
Align = 1;
auto Diff =
static_cast<int64_t>(Addr % Align) - static_cast<int64_t>(Offset % Align);
// We only want to add to Offset, however, so if Diff < 0 we can add Align and
// (Offset + Diff) & -Align == Addr & -Align will still hold.
if (Diff < 0)
Diff += Align;
return Offset + Diff;
}
// Orders segments such that if x = y->ParentSegment then y comes before x.
static void orderSegments(std::vector<Segment *> &Segments) {
llvm::stable_sort(Segments, compareSegmentsByOffset);
}
// This function finds a consistent layout for a list of segments starting from
// an Offset. It assumes that Segments have been sorted by OrderSegments and
// returns an Offset one past the end of the last segment.
static uint64_t layoutSegments(std::vector<Segment *> &Segments,
uint64_t Offset) {
assert(std::is_sorted(std::begin(Segments), std::end(Segments),
compareSegmentsByOffset));
// The only way a segment should move is if a section was between two
// segments and that section was removed. If that section isn't in a segment
// then it's acceptable, but not ideal, to simply move it to after the
// segments. So we can simply layout segments one after the other accounting
// for alignment.
for (Segment *Seg : Segments) {
// We assume that segments have been ordered by OriginalOffset and Index
// such that a parent segment will always come before a child segment in
// OrderedSegments. This means that the Offset of the ParentSegment should
// already be set and we can set our offset relative to it.
if (Seg->ParentSegment != nullptr) {
Segment *Parent = Seg->ParentSegment;
Seg->Offset =
Parent->Offset + Seg->OriginalOffset - Parent->OriginalOffset;
} else {
Offset = alignToAddr(Offset, Seg->VAddr, Seg->Align);
Seg->Offset = Offset;
}
Offset = std::max(Offset, Seg->Offset + Seg->FileSize);
}
return Offset;
}
// This function finds a consistent layout for a list of sections. It assumes
// that the ->ParentSegment of each section has already been laid out. The
// supplied starting Offset is used for the starting offset of any section that
// 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 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
// the offset from the start of the segment. Using the offset from the start
// of the segment we can assign a new offset to the section. For sections not
// 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);
} else {
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 ELFWriter<ELFT>::initEhdrSegment() {
Segment &ElfHdr = Obj.ElfHdrSegment;
ElfHdr.Type = PT_PHDR;
ElfHdr.Flags = 0;
ElfHdr.VAddr = 0;
ElfHdr.PAddr = 0;
ElfHdr.FileSize = ElfHdr.MemSize = sizeof(Elf_Ehdr);
ElfHdr.Align = 0;
}
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 (Segment &Segment : Obj.segments())
OrderedSegments.push_back(&Segment);
OrderedSegments.push_back(&Obj.ElfHdrSegment);
OrderedSegments.push_back(&Obj.ProgramHdrSegment);
orderSegments(OrderedSegments);
// Offset is used as the start offset of the first segment to be laid out.
// Since the ELF Header (ElfHdrSegment) must be at the start of the file,
// we start at offset 0.
uint64_t Offset = 0;
Offset = layoutSegments(OrderedSegments, 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 (WriteSectionHeaders)
Offset = alignTo(Offset, sizeof(Elf_Addr));
Obj.SHOffset = Offset;
}
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.
if (!WriteSectionHeaders)
return Obj.SHOffset;
size_t ShdrCount = Obj.sections().size() + 1; // Includes null shdr.
return Obj.SHOffset + ShdrCount * sizeof(Elf_Shdr);
}
template <class ELFT> Error ELFWriter<ELFT>::write() {
// Segment data must be written first, so that the ELF header and program
// header tables can overwrite it, if covered by a segment.
writeSegmentData();
writeEhdr();
writePhdrs();
writeSectionData();
if (WriteSectionHeaders)
writeShdrs();
return Buf.commit();
}
template <class ELFT> Error 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)
return createStringError(llvm::errc::invalid_argument,
"cannot write section header table because "
"section header string table was removed");
Obj.sortSections();
// We need to assign indexes before we perform layout because we need to know
// if we need large indexes or not. We can assign indexes first and check as
// we go to see if we will actully need large indexes.
bool NeedsLargeIndexes = false;
if (Obj.sections().size() >= SHN_LORESERVE) {
SectionTableRef Sections = Obj.sections();
NeedsLargeIndexes =
std::any_of(Sections.begin() + SHN_LORESERVE, Sections.end(),
[](const SectionBase &Sec) { return Sec.HasSymbol; });
// TODO: handle case where only one section needs the large index table but
// only needs it because the large index table hasn't been removed yet.
}
if (NeedsLargeIndexes) {
// This means we definitely need to have a section index table but if we
// already have one then we should use it instead of making a new one.
if (Obj.SymbolTable != nullptr && Obj.SectionIndexTable == nullptr) {
// Addition of a section to the end does not invalidate the indexes of
// other sections and assigns the correct index to the new section.
auto &Shndx = Obj.addSection<SectionIndexSection>();
Obj.SymbolTable->setShndxTable(&Shndx);
Shndx.setSymTab(Obj.SymbolTable);
}
} else {
// Since we don't need SectionIndexTable we should remove it and all
// references to it.
if (Obj.SectionIndexTable != nullptr) {
// We do not support sections referring to the section index table.
if (Error E = Obj.removeSections(false /*AllowBrokenLinks*/,
[this](const SectionBase &Sec) {
return &Sec == Obj.SectionIndexTable;
}))
return E;
}
}
// Make sure we add the names of all the sections. Importantly this must be
// done after we decide to add or remove SectionIndexes.
if (Obj.SectionNames != nullptr)
for (const auto &Section : Obj.sections()) {
Obj.SectionNames->addString(Section.Name);
}
initEhdrSegment();
// Before we can prepare for layout the indexes need to be finalized.
// Also, the output arch may not be the same as the input arch, so fix up
// size-related fields before doing layout calculations.
uint64_t Index = 0;
auto SecSizer = llvm::make_unique<ELFSectionSizer<ELFT>>();
for (auto &Sec : Obj.sections()) {
Sec.Index = Index++;
Sec.accept(*SecSizer);
}
// The symbol table does not update all other sections on update. For
// instance, symbol names are not added as new symbols are added. This means
// that some sections, like .strtab, don't yet have their final size.
if (Obj.SymbolTable != nullptr)
Obj.SymbolTable->prepareForLayout();
// Now that all strings are added we want to finalize string table builders,
// because that affects section sizes which in turn affects section offsets.
for (SectionBase &Sec : Obj.sections())
if (auto StrTab = dyn_cast<StringTableSection>(&Sec))
StrTab->prepareForLayout();
assignOffsets();
// layoutSections could have modified section indexes, so we need
// to fill the index table after assignOffsets.
if (Obj.SymbolTable != nullptr)
Obj.SymbolTable->fillShndxTable();
// Finally now that all offsets and indexes have been set we can finalize any
// remaining issues.
uint64_t Offset = Obj.SHOffset + sizeof(Elf_Shdr);
for (SectionBase &Section : Obj.sections()) {
Section.HeaderOffset = Offset;
Offset += sizeof(Elf_Shdr);
if (WriteSectionHeaders)
Section.NameIndex = Obj.SectionNames->findIndex(Section.Name);
Section.finalize();
}
if (Error E = Buf.allocate(totalSize()))
return E;
SecWriter = llvm::make_unique<ELFSectionWriter<ELFT>>(Buf);
return Error::success();
}
Error BinaryWriter::write() {
for (auto &Section : Obj.sections())
if (Section.Flags & SHF_ALLOC)
Section.accept(*SecWriter);
return Buf.commit();
}
Error 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.
// 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 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 (SectionBase &Section : Obj.sections())
if ((Section.Flags & SHF_ALLOC) != 0 && Section.ParentSegment != nullptr)
OrderedSegments.push_back(Section.ParentSegment);
// For binary output, we're going to use physical addresses instead of
// virtual addresses, since a binary output is used for cases like ROM
// loading and physical addresses are intended for ROM loading.
// However, if no segment has a physical address, we'll fallback to using
// virtual addresses for all.
if (all_of(OrderedSegments,
[](const Segment *Seg) { return Seg->PAddr == 0; }))
for (Segment *Seg : OrderedSegments)
Seg->PAddr = Seg->VAddr;
llvm::stable_sort(OrderedSegments, compareSegmentsByPAddr);
// Because we add a ParentSegment for each section we might have duplicate
// segments in OrderedSegments. If there were duplicates then LayoutSegments
// would do very strange things.
auto End =
std::unique(std::begin(OrderedSegments), std::end(OrderedSegments));
OrderedSegments.erase(End, std::end(OrderedSegments));
uint64_t Offset = 0;
// Modify the first segment so that there is no gap at the start. This allows
// our layout algorithm to proceed as expected while not writing out the gap
// at the start.
if (!OrderedSegments.empty()) {
Segment *Seg = OrderedSegments[0];
const SectionBase *Sec = Seg->firstSection();
auto Diff = Sec->OriginalOffset - Seg->OriginalOffset;
Seg->OriginalOffset += Diff;
// The size needs to be shrunk as well.
Seg->FileSize -= Diff;
// The PAddr needs to be increased to remove the gap before the first
// section.
Seg->PAddr += Diff;
uint64_t LowestPAddr = Seg->PAddr;
for (Segment *Segment : OrderedSegments) {
Segment->Offset = Segment->PAddr - LowestPAddr;
Offset = std::max(Offset, Segment->Offset + Segment->FileSize);
}
}
// TODO: generalize LayoutSections to take a range. Pass a special range
// constructed from an iterator that skips values for which a predicate does
// not hold. Then pass such a range to LayoutSections instead of constructing
// AllocatedSections here.
std::vector<SectionBase *> AllocatedSections;
for (SectionBase &Section : Obj.sections())
if (Section.Flags & SHF_ALLOC)
AllocatedSections.push_back(&Section);
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
// LayoutSections, because we want to truncate the last segment to the end of
// its last section, to match GNU objcopy's behaviour.
TotalSize = 0;
for (SectionBase *Section : AllocatedSections)
if (Section->Type != SHT_NOBITS)
TotalSize = std::max(TotalSize, Section->Offset + Section->Size);
if (Error E = Buf.allocate(TotalSize))
return E;
SecWriter = llvm::make_unique<BinarySectionWriter>(Buf);
return Error::success();
}
bool IHexWriter::SectionCompare::operator()(const SectionBase *Lhs,
const SectionBase *Rhs) const {
return (sectionPhysicalAddr(Lhs) & 0xFFFFFFFFU) <
(sectionPhysicalAddr(Rhs) & 0xFFFFFFFFU);
}
uint64_t IHexWriter::writeEntryPointRecord(uint8_t *Buf) {
IHexLineData HexData;
uint8_t Data[4] = {};
// We don't write entry point record if entry is zero.
if (Obj.Entry == 0)
return 0;
if (Obj.Entry <= 0xFFFFFU) {
Data[0] = ((Obj.Entry & 0xF0000U) >> 12) & 0xFF;
support::endian::write(&Data[2], static_cast<uint16_t>(Obj.Entry),
support::big);
HexData = IHexRecord::getLine(IHexRecord::StartAddr80x86, 0, Data);
} else {
support::endian::write(Data, static_cast<uint32_t>(Obj.Entry),
support::big);
HexData = IHexRecord::getLine(IHexRecord::StartAddr, 0, Data);
}
memcpy(Buf, HexData.data(), HexData.size());
return HexData.size();
}
uint64_t IHexWriter::writeEndOfFileRecord(uint8_t *Buf) {
IHexLineData HexData = IHexRecord::getLine(IHexRecord::EndOfFile, 0, {});
memcpy(Buf, HexData.data(), HexData.size());
return HexData.size();
}
Error IHexWriter::write() {
IHexSectionWriter Writer(Buf);
// Write sections.
for (const SectionBase *Sec : Sections)
Sec->accept(Writer);
uint64_t Offset = Writer.getBufferOffset();
// Write entry point address.
Offset += writeEntryPointRecord(Buf.getBufferStart() + Offset);
// Write EOF.
Offset += writeEndOfFileRecord(Buf.getBufferStart() + Offset);
assert(Offset == TotalSize);
return Buf.commit();
}
Error IHexWriter::checkSection(const SectionBase &Sec) {
uint64_t Addr = sectionPhysicalAddr(&Sec);
if (addressOverflows32bit(Addr) || addressOverflows32bit(Addr + Sec.Size - 1))
return createStringError(
errc::invalid_argument,
"Section '%s' address range [0x%llx, 0x%llx] is not 32 bit", Sec.Name.c_str(),
Addr, Addr + Sec.Size - 1);
return Error::success();
}
Error IHexWriter::finalize() {
bool UseSegments = false;
auto ShouldWrite = [](const SectionBase &Sec) {
return (Sec.Flags & ELF::SHF_ALLOC) && (Sec.Type != ELF::SHT_NOBITS);
};
auto IsInPtLoad = [](const SectionBase &Sec) {
return Sec.ParentSegment && Sec.ParentSegment->Type == ELF::PT_LOAD;
};
// We can't write 64-bit addresses.
if (addressOverflows32bit(Obj.Entry))
return createStringError(errc::invalid_argument,
"Entry point address 0x%llx overflows 32 bits.",
Obj.Entry);
// If any section we're to write has segment then we
// switch to using physical addresses. Otherwise we
// use section virtual address.
for (auto &Section : Obj.sections())
if (ShouldWrite(Section) && IsInPtLoad(Section)) {
UseSegments = true;
break;
}
for (auto &Section : Obj.sections())
if (ShouldWrite(Section) && (!UseSegments || IsInPtLoad(Section))) {
if (Error E = checkSection(Section))
return E;
Sections.insert(&Section);
}
IHexSectionWriterBase LengthCalc(Buf);
for (const SectionBase *Sec : Sections)
Sec->accept(LengthCalc);
// We need space to write section records + StartAddress record
// (if start adress is not zero) + EndOfFile record.
TotalSize = LengthCalc.getBufferOffset() +
(Obj.Entry ? IHexRecord::getLineLength(4) : 0) +
IHexRecord::getLineLength(0);
if (Error E = Buf.allocate(TotalSize))
return E;
return Error::success();
}
template class ELFBuilder<ELF64LE>;
template class ELFBuilder<ELF64BE>;
template class ELFBuilder<ELF32LE>;
template class ELFBuilder<ELF32BE>;
template class ELFWriter<ELF64LE>;
template class ELFWriter<ELF64BE>;
template class ELFWriter<ELF32LE>;
template class ELFWriter<ELF32BE>;
} // end namespace elf
} // end namespace objcopy
} // end namespace llvm
Reference in New Issue View Git Blame Copy Permalink