diff options
Diffstat (limited to 'llvm/tools/llvm-objcopy/ELF/Object.cpp')
| -rw-r--r-- | llvm/tools/llvm-objcopy/ELF/Object.cpp | 2826 |
1 files changed, 0 insertions, 2826 deletions
diff --git a/llvm/tools/llvm-objcopy/ELF/Object.cpp b/llvm/tools/llvm-objcopy/ELF/Object.cpp deleted file mode 100644 index 3b4152a..0000000 --- a/llvm/tools/llvm-objcopy/ELF/Object.cpp +++ /dev/null @@ -1,2826 +0,0 @@ -//===- 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/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/ELF.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> - -using namespace llvm; -using namespace llvm::ELF; -using namespace llvm::objcopy::elf; -using namespace llvm::object; - -template <class ELFT> void ELFWriter<ELFT>::writePhdr(const Segment &Seg) { - uint8_t *B = reinterpret_cast<uint8_t *>(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, function_ref<bool(const SectionBase *)>) { - return Error::success(); -} - -Error SectionBase::removeSymbols(function_ref<bool(const Symbol &)>) { - return Error::success(); -} - -Error SectionBase::initialize(SectionTableRef) { return Error::success(); } -void SectionBase::finalize() {} -void SectionBase::markSymbols() {} -void SectionBase::replaceSectionReferences( - const DenseMap<SectionBase *, SectionBase *> &) {} -void SectionBase::onRemove() {} - -template <class ELFT> void ELFWriter<ELFT>::writeShdr(const SectionBase &Sec) { - uint8_t *B = - reinterpret_cast<uint8_t *>(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> Error ELFSectionSizer<ELFT>::visit(Section &) { - return Error::success(); -} - -template <class ELFT> Error ELFSectionSizer<ELFT>::visit(OwnedDataSection &) { - return Error::success(); -} - -template <class ELFT> Error ELFSectionSizer<ELFT>::visit(StringTableSection &) { - return Error::success(); -} - -template <class ELFT> -Error ELFSectionSizer<ELFT>::visit(DynamicRelocationSection &) { - return Error::success(); -} - -template <class ELFT> -Error 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); - return Error::success(); -} - -template <class ELFT> -Error 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); - return Error::success(); -} - -template <class ELFT> -Error ELFSectionSizer<ELFT>::visit(GnuDebugLinkSection &) { - return Error::success(); -} - -template <class ELFT> Error ELFSectionSizer<ELFT>::visit(GroupSection &Sec) { - Sec.Size = sizeof(Elf_Word) + Sec.GroupMembers.size() * sizeof(Elf_Word); - return Error::success(); -} - -template <class ELFT> -Error ELFSectionSizer<ELFT>::visit(SectionIndexSection &) { - return Error::success(); -} - -template <class ELFT> Error ELFSectionSizer<ELFT>::visit(CompressedSection &) { - return Error::success(); -} - -template <class ELFT> -Error ELFSectionSizer<ELFT>::visit(DecompressedSection &) { - return Error::success(); -} - -Error BinarySectionWriter::visit(const SectionIndexSection &Sec) { - return createStringError(errc::operation_not_permitted, - "cannot write symbol section index table '" + - Sec.Name + "' "); -} - -Error BinarySectionWriter::visit(const SymbolTableSection &Sec) { - return createStringError(errc::operation_not_permitted, - "cannot write symbol table '" + Sec.Name + - "' out to binary"); -} - -Error BinarySectionWriter::visit(const RelocationSection &Sec) { - return createStringError(errc::operation_not_permitted, - "cannot write relocation section '" + Sec.Name + - "' out to binary"); -} - -Error BinarySectionWriter::visit(const GnuDebugLinkSection &Sec) { - return createStringError(errc::operation_not_permitted, - "cannot write '" + Sec.Name + "' out to binary"); -} - -Error BinarySectionWriter::visit(const GroupSection &Sec) { - return createStringError(errc::operation_not_permitted, - "cannot write '" + Sec.Name + "' out to binary"); -} - -Error SectionWriter::visit(const Section &Sec) { - if (Sec.Type != SHT_NOBITS) - llvm::copy(Sec.Contents, Out.getBufferStart() + Sec.Offset); - - return Error::success(); -} - -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 toHexStr(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 = toHexStr(Data.size(), Iter, 2); - Iter = toHexStr(Addr, Iter, 4); - Iter = toHexStr(Type, Iter, 2); - for (uint8_t X : Data) - Iter = toHexStr(X, Iter, 2); - StringRef S(Line.data() + 1, std::distance(Line.begin() + 1, Iter)); - Iter = toHexStr(getChecksum(S), Iter, 2); - *Iter++ = '\r'; - *Iter++ = '\n'; - assert(Iter == Line.end()); - return Line; -} - -static Error checkRecord(const IHexRecord &R) { - switch (R.Type) { - case IHexRecord::Data: - if (R.HexData.size() == 0) - return createStringError( - errc::invalid_argument, - "zero data length is not allowed for data records"); - break; - case IHexRecord::EndOfFile: - break; - case IHexRecord::SegmentAddr: - // 20-bit segment address. Data length must be 2 bytes - // (4 bytes in hex) - if (R.HexData.size() != 4) - return createStringError( - errc::invalid_argument, - "segment address data should be 2 bytes in size"); - break; - case IHexRecord::StartAddr80x86: - case IHexRecord::StartAddr: - if (R.HexData.size() != 8) - return createStringError(errc::invalid_argument, - "start address data should be 4 bytes in size"); - // According to Intel HEX specification '03' record - // only specifies the code address within the 20-bit - // segmented address space of the 8086/80186. This - // means 12 high order bits should be zeroes. - if (R.Type == IHexRecord::StartAddr80x86 && - R.HexData.take_front(3) != "000") - return createStringError(errc::invalid_argument, - "start address exceeds 20 bit for 80x86"); - break; - case IHexRecord::ExtendedAddr: - // 16-31 bits of linear base address - if (R.HexData.size() != 4) - return createStringError( - errc::invalid_argument, - "extended address data should be 2 bytes in size"); - break; - default: - // Unknown record type - return createStringError(errc::invalid_argument, "unknown record type: %u", - static_cast<unsigned>(R.Type)); - } - return Error::success(); -} - -// Checks that IHEX line contains valid characters. -// This allows converting hexadecimal data to integers -// without extra verification. -static Error checkChars(StringRef Line) { - assert(!Line.empty()); - if (Line[0] != ':') - return createStringError(errc::invalid_argument, - "missing ':' in the beginning of line."); - - for (size_t Pos = 1; Pos < Line.size(); ++Pos) - if (hexDigitValue(Line[Pos]) == -1U) - return createStringError(errc::invalid_argument, - "invalid character at position %zu.", Pos + 1); - return Error::success(); -} - -Expected<IHexRecord> IHexRecord::parse(StringRef Line) { - assert(!Line.empty()); - - // ':' + Length + Address + Type + Checksum with empty data ':LLAAAATTCC' - if (Line.size() < 11) - return createStringError(errc::invalid_argument, - "line is too short: %zu chars.", Line.size()); - - if (Error E = checkChars(Line)) - return std::move(E); - - IHexRecord Rec; - size_t DataLen = checkedGetHex<uint8_t>(Line.substr(1, 2)); - if (Line.size() != getLength(DataLen)) - return createStringError(errc::invalid_argument, - "invalid line length %zu (should be %zu)", - Line.size(), getLength(DataLen)); - - Rec.Addr = checkedGetHex<uint16_t>(Line.substr(3, 4)); - Rec.Type = checkedGetHex<uint8_t>(Line.substr(7, 2)); - Rec.HexData = Line.substr(9, DataLen * 2); - - if (getChecksum(Line.drop_front(1)) != 0) - return createStringError(errc::invalid_argument, "incorrect checksum."); - if (Error E = checkRecord(Rec)) - return std::move(E); - return Rec; -} - -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, uint16_t, - ArrayRef<uint8_t> Data) { - Offset += IHexRecord::getLineLength(Data.size()); -} - -Error IHexSectionWriterBase::visit(const Section &Sec) { - writeSection(&Sec, Sec.Contents); - return Error::success(); -} - -Error IHexSectionWriterBase::visit(const OwnedDataSection &Sec) { - writeSection(&Sec, Sec.Data); - return Error::success(); -} - -Error 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)}); - return Error::success(); -} - -Error IHexSectionWriterBase::visit(const DynamicRelocationSection &Sec) { - writeSection(&Sec, Sec.Contents); - return Error::success(); -} - -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(); -} - -Error 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); - return Error::success(); -} - -Error Section::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error Section::accept(MutableSectionVisitor &Visitor) { - return Visitor.visit(*this); -} - -Error SectionWriter::visit(const OwnedDataSection &Sec) { - llvm::copy(Sec.Data, Out.getBufferStart() + Sec.Offset); - return Error::success(); -} - -static constexpr std::array<uint8_t, 4> 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> -Error 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 Err = zlib::uncompress(CompressedContent, DecompressedContent, - static_cast<size_t>(Sec.Size))) - return createStringError(errc::invalid_argument, - "'" + Sec.Name + "': " + toString(std::move(Err))); - - uint8_t *Buf = reinterpret_cast<uint8_t *>(Out.getBufferStart()) + Sec.Offset; - std::copy(DecompressedContent.begin(), DecompressedContent.end(), Buf); - - return Error::success(); -} - -Error BinarySectionWriter::visit(const DecompressedSection &Sec) { - return createStringError(errc::operation_not_permitted, - "cannot write compressed section '" + Sec.Name + - "' "); -} - -Error DecompressedSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error DecompressedSection::accept(MutableSectionVisitor &Visitor) { - return Visitor.visit(*this); -} - -Error OwnedDataSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error OwnedDataSection::accept(MutableSectionVisitor &Visitor) { - return 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(); -} - -Error BinarySectionWriter::visit(const CompressedSection &Sec) { - return createStringError(errc::operation_not_permitted, - "cannot write compressed section '" + Sec.Name + - "' "); -} - -template <class ELFT> -Error ELFSectionWriter<ELFT>::visit(const CompressedSection &Sec) { - uint8_t *Buf = reinterpret_cast<uint8_t *>(Out.getBufferStart()) + Sec.Offset; - if (Sec.CompressionType == DebugCompressionType::None) { - std::copy(Sec.OriginalData.begin(), Sec.OriginalData.end(), Buf); - return Error::success(); - } - - 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); - return Error::success(); -} - -Expected<CompressedSection> -CompressedSection::create(const SectionBase &Sec, - DebugCompressionType CompressionType) { - Error Err = Error::success(); - CompressedSection Section(Sec, CompressionType, Err); - - if (Err) - return std::move(Err); - - return Section; -} -Expected<CompressedSection> -CompressedSection::create(ArrayRef<uint8_t> CompressedData, - uint64_t DecompressedSize, - uint64_t DecompressedAlign) { - return CompressedSection(CompressedData, DecompressedSize, DecompressedAlign); -} - -CompressedSection::CompressedSection(const SectionBase &Sec, - DebugCompressionType CompressionType, - Error &OutErr) - : SectionBase(Sec), CompressionType(CompressionType), - DecompressedSize(Sec.OriginalData.size()), DecompressedAlign(Sec.Align) { - ErrorAsOutParameter EAO(&OutErr); - - if (Error Err = zlib::compress( - StringRef(reinterpret_cast<const char *>(OriginalData.data()), - OriginalData.size()), - CompressedData)) { - OutErr = createStringError(llvm::errc::invalid_argument, - "'" + Name + "': " + toString(std::move(Err))); - return; - } - - 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; -} - -Error CompressedSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error CompressedSection::accept(MutableSectionVisitor &Visitor) { - return 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(); -} - -Error SectionWriter::visit(const StringTableSection &Sec) { - Sec.StrTabBuilder.write(reinterpret_cast<uint8_t *>(Out.getBufferStart()) + - Sec.Offset); - return Error::success(); -} - -Error StringTableSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error StringTableSection::accept(MutableSectionVisitor &Visitor) { - return Visitor.visit(*this); -} - -template <class ELFT> -Error ELFSectionWriter<ELFT>::visit(const SectionIndexSection &Sec) { - uint8_t *Buf = reinterpret_cast<uint8_t *>(Out.getBufferStart()) + Sec.Offset; - llvm::copy(Sec.Indexes, reinterpret_cast<Elf_Word *>(Buf)); - return Error::success(); -} - -Error SectionIndexSection::initialize(SectionTableRef SecTable) { - Size = 0; - Expected<SymbolTableSection *> Sec = - 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"); - if (!Sec) - return Sec.takeError(); - - setSymTab(*Sec); - Symbols->setShndxTable(this); - return Error::success(); -} - -void SectionIndexSection::finalize() { Link = Symbols->Index; } - -Error SectionIndexSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error SectionIndexSection::accept(MutableSectionVisitor &Visitor) { - return 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_AMDGPU) { - return Index == SHN_AMDGPU_LDS; - } - - if (Machine == EM_HEXAGON) { - switch (Index) { - case SHN_HEXAGON_SCOMMON: - case SHN_HEXAGON_SCOMMON_1: - 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; - } - - if (ShndxType == SYMBOL_SIMPLE_INDEX) { - // This means that we don't have a defined section but we do need to - // output a legitimate section index. - return SHN_UNDEF; - } - - assert(ShndxType == SYMBOL_ABS || ShndxType == SYMBOL_COMMON || - (ShndxType >= SYMBOL_LOPROC && ShndxType <= SYMBOL_HIPROC) || - (ShndxType >= SYMBOL_LOOS && ShndxType <= SYMBOL_HIOS)); - return static_cast<uint16_t>(ShndxType); -} - -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(std::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; -} - -Error SymbolTableSection::initialize(SectionTableRef SecTable) { - Size = 0; - Expected<StringTableSection *> Sec = - 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"); - if (!Sec) - return Sec.takeError(); - - setStrTab(*Sec); - return Error::success(); -} - -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); - } -} - -Expected<const Symbol *> -SymbolTableSection::getSymbolByIndex(uint32_t Index) const { - if (Symbols.size() <= Index) - return createStringError(errc::invalid_argument, - "invalid symbol index: " + Twine(Index)); - return Symbols[Index].get(); -} - -Expected<Symbol *> SymbolTableSection::getSymbolByIndex(uint32_t Index) { - Expected<const Symbol *> Sym = - static_cast<const SymbolTableSection *>(this)->getSymbolByIndex(Index); - if (!Sym) - return Sym.takeError(); - - return const_cast<Symbol *>(*Sym); -} - -template <class ELFT> -Error 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; - } - return Error::success(); -} - -Error SymbolTableSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error SymbolTableSection::accept(MutableSectionVisitor &Visitor) { - return Visitor.visit(*this); -} - -StringRef RelocationSectionBase::getNamePrefix() const { - switch (Type) { - case SHT_REL: - return ".rel"; - case SHT_RELA: - return ".rela"; - default: - llvm_unreachable("not a relocation section"); - } -} - -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 || !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> -Error RelocSectionWithSymtabBase<SymTabType>::initialize( - SectionTableRef SecTable) { - if (Link != SHN_UNDEF) { - Expected<SymTabType *> Sec = 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 (!Sec) - return Sec.takeError(); - - setSymTab(*Sec); - } - - if (Info != SHN_UNDEF) { - Expected<SectionBase *> Sec = - SecTable.getSection(Info, "Info field value " + Twine(Info) + - " in section " + Name + " is invalid"); - if (!Sec) - return Sec.takeError(); - - setSection(*Sec); - } else - setSection(nullptr); - - return Error::success(); -} - -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> &, uint64_t) {} - -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, bool IsMips64EL) { - for (const auto &Reloc : Relocations) { - Buf->r_offset = Reloc.Offset; - setAddend(*Buf, Reloc.Addend); - Buf->setSymbolAndType(Reloc.RelocSymbol ? Reloc.RelocSymbol->Index : 0, - Reloc.Type, IsMips64EL); - ++Buf; - } -} - -template <class ELFT> -Error ELFSectionWriter<ELFT>::visit(const RelocationSection &Sec) { - uint8_t *Buf = reinterpret_cast<uint8_t *>(Out.getBufferStart()) + Sec.Offset; - if (Sec.Type == SHT_REL) - writeRel(Sec.Relocations, reinterpret_cast<Elf_Rel *>(Buf), - Sec.getObject().IsMips64EL); - else - writeRel(Sec.Relocations, reinterpret_cast<Elf_Rela *>(Buf), - Sec.getObject().IsMips64EL); - return Error::success(); -} - -Error RelocationSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error RelocationSection::accept(MutableSectionVisitor &Visitor) { - return Visitor.visit(*this); -} - -Error RelocationSection::removeSymbols( - function_ref<bool(const Symbol &)> ToRemove) { - for (const Relocation &Reloc : Relocations) - if (Reloc.RelocSymbol && 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) - if (Reloc.RelocSymbol) - 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; -} - -Error SectionWriter::visit(const DynamicRelocationSection &Sec) { - llvm::copy(Sec.Contents, Out.getBufferStart() + Sec.Offset); - return Error::success(); -} - -Error DynamicRelocationSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error DynamicRelocationSection::accept(MutableSectionVisitor &Visitor) { - return 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 ? Sym->Index : 0; - this->Link = SymTab ? SymTab->Index : 0; - // Linker deduplication for GRP_COMDAT is based on Sym->Name. The local/global - // status is not part of the equation. If Sym is localized, the intention is - // likely to make the group fully localized. Drop GRP_COMDAT to suppress - // deduplication. See https://groups.google.com/g/generic-abi/c/2X6mR-s2zoc - if ((FlagWord & GRP_COMDAT) && Sym && Sym->Binding == STB_LOCAL) - this->FlagWord &= ~GRP_COMDAT; -} - -Error GroupSection::removeSectionReferences( - bool AllowBrokenLinks, function_ref<bool(const SectionBase *)> ToRemove) { - if (ToRemove(SymTab)) { - if (!AllowBrokenLinks) - return createStringError( - llvm::errc::invalid_argument, - "section '.symtab' cannot be removed because it is " - "referenced by the group section '%s'", - this->Name.data()); - SymTab = nullptr; - Sym = nullptr; - } - llvm::erase_if(GroupMembers, ToRemove); - return Error::success(); -} - -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 GroupSection::onRemove() { - // As the header section of the group is removed, drop the Group flag in its - // former members. - for (SectionBase *Sec : GroupMembers) - Sec->Flags &= ~SHF_GROUP; -} - -Error Section::initialize(SectionTableRef SecTable) { - if (Link == ELF::SHN_UNDEF) - return Error::success(); - - Expected<SectionBase *> Sec = - SecTable.getSection(Link, "Link field value " + Twine(Link) + - " in section " + Name + " is invalid"); - if (!Sec) - return Sec.takeError(); - - LinkSection = *Sec; - - if (LinkSection->Type == ELF::SHT_SYMTAB) - LinkSection = nullptr; - - return Error::success(); -} - -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 = OriginalType = 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> -Error ELFSectionWriter<ELFT>::visit(const GnuDebugLinkSection &Sec) { - unsigned char *Buf = - reinterpret_cast<uint8_t *>(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); - return Error::success(); -} - -Error GnuDebugLinkSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error GnuDebugLinkSection::accept(MutableSectionVisitor &Visitor) { - return Visitor.visit(*this); -} - -template <class ELFT> -Error ELFSectionWriter<ELFT>::visit(const GroupSection &Sec) { - ELF::Elf32_Word *Buf = - reinterpret_cast<ELF::Elf32_Word *>(Out.getBufferStart() + Sec.Offset); - support::endian::write32<ELFT::TargetEndianness>(Buf++, Sec.FlagWord); - for (SectionBase *S : Sec.GroupMembers) - support::endian::write32<ELFT::TargetEndianness>(Buf++, S->Index); - return Error::success(); -} - -Error GroupSection::accept(SectionVisitor &Visitor) const { - return Visitor.visit(*this); -} - -Error GroupSection::accept(MutableSectionVisitor &Visitor) { - return Visitor.visit(*this); -} - -// Returns true IFF a section is wholly inside the range of a segment -static bool sectionWithinSegment(const SectionBase &Sec, const Segment &Seg) { - // 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 = Sec.Size ? Sec.Size : 1; - - // Ignore just added sections. - if (Sec.OriginalOffset == std::numeric_limits<uint64_t>::max()) - return false; - - if (Sec.Type == SHT_NOBITS) { - if (!(Sec.Flags & SHF_ALLOC)) - return false; - - bool SectionIsTLS = Sec.Flags & SHF_TLS; - bool SegmentIsTLS = Seg.Type == PT_TLS; - if (SectionIsTLS != SegmentIsTLS) - return false; - - return Seg.VAddr <= Sec.Addr && - Seg.VAddr + Seg.MemSize >= Sec.Addr + SecSize; - } - - return Seg.Offset <= Sec.OriginalOffset && - Seg.Offset + Seg.FileSize >= Sec.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; -} - -void BasicELFBuilder::initFileHeader() { - Obj->Flags = 0x0; - Obj->Type = ET_REL; - Obj->OSABI = ELFOSABI_NONE; - Obj->ABIVersion = 0; - Obj->Entry = 0x0; - Obj->Machine = EM_NONE; - Obj->Version = 1; -} - -void BasicELFBuilder::initHeaderSegment() { Obj->ElfHdrSegment.Index = 0; } - -StringTableSection *BasicELFBuilder::addStrTab() { - auto &StrTab = Obj->addSection<StringTableSection>(); - StrTab.Name = ".strtab"; - - Obj->SectionNames = &StrTab; - return &StrTab; -} - -SymbolTableSection *BasicELFBuilder::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; -} - -Error BasicELFBuilder::initSections() { - for (SectionBase &Sec : Obj->sections()) - if (Error Err = Sec.initialize(Obj->sections())) - return Err; - - return Error::success(); -} - -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, NewSymbolVisibility, 0, 0); - SymTab->addSymbol(Prefix + "_end", STB_GLOBAL, STT_NOTYPE, &DataSection, - /*Value=*/DataSection.Size, NewSymbolVisibility, 0, 0); - SymTab->addSymbol(Prefix + "_size", STB_GLOBAL, STT_NOTYPE, nullptr, - /*Value=*/DataSection.Size, NewSymbolVisibility, SHN_ABS, - 0); -} - -Expected<std::unique_ptr<Object>> BinaryELFBuilder::build() { - initFileHeader(); - initHeaderSegment(); - - SymbolTableSection *SymTab = addSymTab(addStrTab()); - if (Error Err = initSections()) - return std::move(Err); - addData(SymTab); - - return std::move(Obj); -} - -// Adds sections from IHEX data file. Data should have been -// fully validated by this time. -void IHexELFBuilder::addDataSections() { - OwnedDataSection *Section = nullptr; - uint64_t SegmentAddr = 0, BaseAddr = 0; - uint32_t SecNo = 1; - - for (const IHexRecord &R : Records) { - uint64_t RecAddr; - switch (R.Type) { - case IHexRecord::Data: - // Ignore empty data records - if (R.HexData.empty()) - continue; - RecAddr = R.Addr + SegmentAddr + BaseAddr; - if (!Section || Section->Addr + Section->Size != RecAddr) { - // OriginalOffset field is only used to sort sections before layout, so - // instead of keeping track of real offsets in IHEX file, and as - // layoutSections() and layoutSectionsForOnlyKeepDebug() use - // llvm::stable_sort(), we can just set it to a constant (zero). - Section = &Obj->addSection<OwnedDataSection>( - ".sec" + std::to_string(SecNo), RecAddr, - ELF::SHF_ALLOC | ELF::SHF_WRITE, 0); - SecNo++; - } - Section->appendHexData(R.HexData); - break; - case IHexRecord::EndOfFile: - break; - case IHexRecord::SegmentAddr: - // 20-bit segment address. - SegmentAddr = checkedGetHex<uint16_t>(R.HexData) << 4; - break; - case IHexRecord::StartAddr80x86: - case IHexRecord::StartAddr: - Obj->Entry = checkedGetHex<uint32_t>(R.HexData); - assert(Obj->Entry <= 0xFFFFFU); - break; - case IHexRecord::ExtendedAddr: - // 16-31 bits of linear base address - BaseAddr = checkedGetHex<uint16_t>(R.HexData) << 16; - break; - default: - llvm_unreachable("unknown record type"); - } - } -} - -Expected<std::unique_ptr<Object>> IHexELFBuilder::build() { - initFileHeader(); - initHeaderSegment(); - StringTableSection *StrTab = addStrTab(); - addSymTab(StrTab); - if (Error Err = initSections()) - return std::move(Err); - addDataSections(); - - return std::move(Obj); -} - -template <class ELFT> -ELFBuilder<ELFT>::ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj, - Optional<StringRef> ExtractPartition) - : ElfFile(ElfObj.getELFFile()), Obj(Obj), - ExtractPartition(ExtractPartition) { - Obj.IsMips64EL = ElfFile.isMips64EL(); -} - -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 its 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> Error ELFBuilder<ELFT>::findEhdrOffset() { - if (!ExtractPartition) - return Error::success(); - - for (const SectionBase &Sec : Obj.sections()) { - if (Sec.Type == SHT_LLVM_PART_EHDR && Sec.Name == *ExtractPartition) { - EhdrOffset = Sec.Offset; - return Error::success(); - } - } - return createStringError(errc::invalid_argument, - "could not find partition named '" + - *ExtractPartition + "'"); -} - -template <class ELFT> -Error ELFBuilder<ELFT>::readProgramHeaders(const ELFFile<ELFT> &HeadersFile) { - uint32_t Index = 0; - - Expected<typename ELFFile<ELFT>::Elf_Phdr_Range> Headers = - HeadersFile.program_headers(); - if (!Headers) - return Headers.takeError(); - - for (const typename ELFFile<ELFT>::Elf_Phdr &Phdr : *Headers) { - if (Phdr.p_offset + Phdr.p_filesz > HeadersFile.getBufSize()) - return createStringError( - errc::invalid_argument, - "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 &Sec : Obj.sections()) - if (sectionWithinSegment(Sec, Seg)) { - Seg.addSection(&Sec); - if (!Sec.ParentSegment || Sec.ParentSegment->Offset > Seg.Offset) - Sec.ParentSegment = &Seg; - } - } - - auto &ElfHdr = Obj.ElfHdrSegment; - ElfHdr.Index = Index++; - ElfHdr.OriginalOffset = ElfHdr.Offset = EhdrOffset; - - const typename ELFT::Ehdr &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); - - return Error::success(); -} - -template <class ELFT> -Error ELFBuilder<ELFT>::initGroupSection(GroupSection *GroupSec) { - if (GroupSec->Align % sizeof(ELF::Elf32_Word) != 0) - return createStringError(errc::invalid_argument, - "invalid alignment " + Twine(GroupSec->Align) + - " of group section '" + GroupSec->Name + "'"); - SectionTableRef SecTable = Obj.sections(); - if (GroupSec->Link != SHN_UNDEF) { - 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"); - if (!SymTab) - return SymTab.takeError(); - - Expected<Symbol *> Sym = (*SymTab)->getSymbolByIndex(GroupSec->Info); - if (!Sym) - return createStringError(errc::invalid_argument, - "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()) - return createStringError(errc::invalid_argument, - "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( - support::endian::read32<ELFT::TargetEndianness>(Word++)); - for (; Word != End; ++Word) { - uint32_t Index = support::endian::read32<ELFT::TargetEndianness>(Word); - Expected<SectionBase *> Sec = SecTable.getSection( - Index, "group member index " + Twine(Index) + " in section '" + - GroupSec->Name + "' is invalid"); - if (!Sec) - return Sec.takeError(); - - GroupSec->addMember(*Sec); - } - - return Error::success(); -} - -template <class ELFT> -Error ELFBuilder<ELFT>::initSymbolTable(SymbolTableSection *SymTab) { - Expected<const Elf_Shdr *> Shdr = ElfFile.getSection(SymTab->Index); - if (!Shdr) - return Shdr.takeError(); - - Expected<StringRef> StrTabData = ElfFile.getStringTableForSymtab(**Shdr); - if (!StrTabData) - return StrTabData.takeError(); - - ArrayRef<Elf_Word> ShndxData; - - Expected<typename ELFFile<ELFT>::Elf_Sym_Range> Symbols = - ElfFile.symbols(*Shdr); - if (!Symbols) - return Symbols.takeError(); - - for (const typename ELFFile<ELFT>::Elf_Sym &Sym : *Symbols) { - SectionBase *DefSection = nullptr; - - Expected<StringRef> Name = Sym.getName(*StrTabData); - if (!Name) - return Name.takeError(); - - if (Sym.st_shndx == SHN_XINDEX) { - if (SymTab->getShndxTable() == nullptr) - return createStringError(errc::invalid_argument, - "symbol '" + *Name + - "' has index SHN_XINDEX but no " - "SHT_SYMTAB_SHNDX section exists"); - if (ShndxData.data() == nullptr) { - Expected<const Elf_Shdr *> ShndxSec = - ElfFile.getSection(SymTab->getShndxTable()->Index); - if (!ShndxSec) - return ShndxSec.takeError(); - - Expected<ArrayRef<Elf_Word>> Data = - ElfFile.template getSectionContentsAsArray<Elf_Word>(**ShndxSec); - if (!Data) - return Data.takeError(); - - ShndxData = *Data; - if (ShndxData.size() != Symbols->size()) - return createStringError( - errc::invalid_argument, - "symbol section index table does not have the same number of " - "entries as the symbol table"); - } - Elf_Word Index = ShndxData[&Sym - Symbols->begin()]; - Expected<SectionBase *> Sec = Obj.sections().getSection( - Index, - "symbol '" + *Name + "' has invalid section index " + Twine(Index)); - if (!Sec) - return Sec.takeError(); - - DefSection = *Sec; - } else if (Sym.st_shndx >= SHN_LORESERVE) { - if (!isValidReservedSectionIndex(Sym.st_shndx, Obj.Machine)) { - return createStringError( - errc::invalid_argument, - "symbol '" + *Name + - "' has unsupported value greater than or equal " - "to SHN_LORESERVE: " + - Twine(Sym.st_shndx)); - } - } else if (Sym.st_shndx != SHN_UNDEF) { - Expected<SectionBase *> Sec = Obj.sections().getSection( - Sym.st_shndx, "symbol '" + *Name + - "' is defined has invalid section index " + - Twine(Sym.st_shndx)); - if (!Sec) - return Sec.takeError(); - - DefSection = *Sec; - } - - SymTab->addSymbol(*Name, Sym.getBinding(), Sym.getType(), DefSection, - Sym.getValue(), Sym.st_other, Sym.st_shndx, Sym.st_size); - } - - return Error::success(); -} - -template <class ELFT> -static void getAddend(uint64_t &, const Elf_Rel_Impl<ELFT, false> &) {} - -template <class ELFT> -static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, true> &Rela) { - ToSet = Rela.r_addend; -} - -template <class T> -static Error initRelocations(RelocationSection *Relocs, T RelRange) { - for (const auto &Rel : RelRange) { - Relocation ToAdd; - ToAdd.Offset = Rel.r_offset; - getAddend(ToAdd.Addend, Rel); - ToAdd.Type = Rel.getType(Relocs->getObject().IsMips64EL); - - if (uint32_t Sym = Rel.getSymbol(Relocs->getObject().IsMips64EL)) { - if (!Relocs->getObject().SymbolTable) - return createStringError( - errc::invalid_argument, - "'" + Relocs->Name + "': relocation references symbol with index " + - Twine(Sym) + ", but there is no symbol table"); - Expected<Symbol *> SymByIndex = - Relocs->getObject().SymbolTable->getSymbolByIndex(Sym); - if (!SymByIndex) - return SymByIndex.takeError(); - - ToAdd.RelocSymbol = *SymByIndex; - } - - Relocs->addRelocation(ToAdd); - } - - return Error::success(); -} - -Expected<SectionBase *> SectionTableRef::getSection(uint32_t Index, - Twine ErrMsg) { - if (Index == SHN_UNDEF || Index > Sections.size()) - return createStringError(errc::invalid_argument, ErrMsg); - return Sections[Index - 1].get(); -} - -template <class T> -Expected<T *> SectionTableRef::getSectionOfType(uint32_t Index, - Twine IndexErrMsg, - Twine TypeErrMsg) { - Expected<SectionBase *> BaseSec = getSection(Index, IndexErrMsg); - if (!BaseSec) - return BaseSec.takeError(); - - if (T *Sec = dyn_cast<T>(*BaseSec)) - return Sec; - - return createStringError(errc::invalid_argument, TypeErrMsg); -} - -template <class ELFT> -Expected<SectionBase &> ELFBuilder<ELFT>::makeSection(const Elf_Shdr &Shdr) { - switch (Shdr.sh_type) { - case SHT_REL: - case SHT_RELA: - if (Shdr.sh_flags & SHF_ALLOC) { - if (Expected<ArrayRef<uint8_t>> Data = ElfFile.getSectionContents(Shdr)) - return Obj.addSection<DynamicRelocationSection>(*Data); - else - return Data.takeError(); - } - return Obj.addSection<RelocationSection>(Obj); - 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) { - if (Expected<ArrayRef<uint8_t>> Data = ElfFile.getSectionContents(Shdr)) - return Obj.addSection<Section>(*Data); - else - return Data.takeError(); - } - 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. - if (Expected<ArrayRef<uint8_t>> Data = ElfFile.getSectionContents(Shdr)) - return Obj.addSection<Section>(*Data); - else - return Data.takeError(); - case SHT_GROUP: - if (Expected<ArrayRef<uint8_t>> Data = ElfFile.getSectionContents(Shdr)) - return Obj.addSection<GroupSection>(*Data); - else - return Data.takeError(); - case SHT_DYNSYM: - if (Expected<ArrayRef<uint8_t>> Data = ElfFile.getSectionContents(Shdr)) - return Obj.addSection<DynamicSymbolTableSection>(*Data); - else - return Data.takeError(); - case SHT_DYNAMIC: - if (Expected<ArrayRef<uint8_t>> Data = ElfFile.getSectionContents(Shdr)) - return Obj.addSection<DynamicSection>(*Data); - else - return Data.takeError(); - 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>(ArrayRef<uint8_t>()); - default: { - Expected<ArrayRef<uint8_t>> Data = ElfFile.getSectionContents(Shdr); - if (!Data) - return Data.takeError(); - - Expected<StringRef> Name = ElfFile.getSectionName(Shdr); - if (!Name) - return Name.takeError(); - - if (Name->startswith(".zdebug") || (Shdr.sh_flags & ELF::SHF_COMPRESSED)) { - uint64_t DecompressedSize, DecompressedAlign; - std::tie(DecompressedSize, DecompressedAlign) = - getDecompressedSizeAndAlignment<ELFT>(*Data); - Expected<CompressedSection> NewSection = - CompressedSection::create(*Data, DecompressedSize, DecompressedAlign); - if (!NewSection) - return NewSection.takeError(); - - return Obj.addSection<CompressedSection>(std::move(*NewSection)); - } - - return Obj.addSection<Section>(*Data); - } - } -} - -template <class ELFT> Error ELFBuilder<ELFT>::readSectionHeaders() { - uint32_t Index = 0; - Expected<typename ELFFile<ELFT>::Elf_Shdr_Range> Sections = - ElfFile.sections(); - if (!Sections) - return Sections.takeError(); - - for (const typename ELFFile<ELFT>::Elf_Shdr &Shdr : *Sections) { - if (Index == 0) { - ++Index; - continue; - } - Expected<SectionBase &> Sec = makeSection(Shdr); - if (!Sec) - return Sec.takeError(); - - Expected<StringRef> SecName = ElfFile.getSectionName(Shdr); - if (!SecName) - return SecName.takeError(); - Sec->Name = SecName->str(); - Sec->Type = Sec->OriginalType = Shdr.sh_type; - Sec->Flags = Sec->OriginalFlags = 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->OriginalIndex = Sec->Index; - Sec->OriginalData = - ArrayRef<uint8_t>(ElfFile.base() + Shdr.sh_offset, - (Shdr.sh_type == SHT_NOBITS) ? (size_t)0 : Shdr.sh_size); - } - - return Error::success(); -} - -template <class ELFT> Error ELFBuilder<ELFT>::readSections(bool EnsureSymtab) { - uint32_t ShstrIndex = ElfFile.getHeader().e_shstrndx; - if (ShstrIndex == SHN_XINDEX) { - Expected<const Elf_Shdr *> Sec = ElfFile.getSection(0); - if (!Sec) - return Sec.takeError(); - - ShstrIndex = (*Sec)->sh_link; - } - - if (ShstrIndex == SHN_UNDEF) - Obj.HadShdrs = false; - else { - Expected<StringTableSection *> Sec = - 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 " + - " does not reference a string table"); - if (!Sec) - return Sec.takeError(); - - Obj.SectionNames = *Sec; - } - - // 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) - if (Error Err = Obj.SectionIndexTable->initialize(Obj.sections())) - return Err; - - // 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) { - if (Error Err = Obj.SymbolTable->initialize(Obj.sections())) - return Err; - if (Error Err = initSymbolTable(Obj.SymbolTable)) - return Err; - } else if (EnsureSymtab) { - if (Error Err = Obj.addNewSymbolTable()) - return Err; - } - - // 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 (SectionBase &Sec : Obj.sections()) { - if (&Sec == Obj.SymbolTable) - continue; - if (Error Err = Sec.initialize(Obj.sections())) - return Err; - if (auto RelSec = dyn_cast<RelocationSection>(&Sec)) { - Expected<typename ELFFile<ELFT>::Elf_Shdr_Range> Sections = - ElfFile.sections(); - if (!Sections) - return Sections.takeError(); - - const typename ELFFile<ELFT>::Elf_Shdr *Shdr = - Sections->begin() + RelSec->Index; - if (RelSec->Type == SHT_REL) { - Expected<typename ELFFile<ELFT>::Elf_Rel_Range> Rels = - ElfFile.rels(*Shdr); - if (!Rels) - return Rels.takeError(); - - if (Error Err = initRelocations(RelSec, *Rels)) - return Err; - } else { - Expected<typename ELFFile<ELFT>::Elf_Rela_Range> Relas = - ElfFile.relas(*Shdr); - if (!Relas) - return Relas.takeError(); - - if (Error Err = initRelocations(RelSec, *Relas)) - return Err; - } - } else if (auto GroupSec = dyn_cast<GroupSection>(&Sec)) { - if (Error Err = initGroupSection(GroupSec)) - return Err; - } - } - - return Error::success(); -} - -template <class ELFT> Error ELFBuilder<ELFT>::build(bool EnsureSymtab) { - if (Error E = readSectionHeaders()) - return E; - if (Error E = findEhdrOffset()) - return E; - - // 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. - Expected<ELFFile<ELFT>> HeadersFile = ELFFile<ELFT>::create(toStringRef( - {ElfFile.base() + EhdrOffset, ElfFile.getBufSize() - EhdrOffset})); - if (!HeadersFile) - return HeadersFile.takeError(); - - const typename ELFFile<ELFT>::Elf_Ehdr &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; - - if (Error E = readSections(EnsureSymtab)) - return E; - return readProgramHeaders(*HeadersFile); -} - -Writer::~Writer() {} - -Reader::~Reader() {} - -Expected<std::unique_ptr<Object>> -BinaryReader::create(bool /*EnsureSymtab*/) const { - return BinaryELFBuilder(MemBuf, NewSymbolVisibility).build(); -} - -Expected<std::vector<IHexRecord>> IHexReader::parse() const { - SmallVector<StringRef, 16> Lines; - std::vector<IHexRecord> Records; - bool HasSections = false; - - MemBuf->getBuffer().split(Lines, '\n'); - Records.reserve(Lines.size()); - for (size_t LineNo = 1; LineNo <= Lines.size(); ++LineNo) { - StringRef Line = Lines[LineNo - 1].trim(); - if (Line.empty()) - continue; - - Expected<IHexRecord> R = IHexRecord::parse(Line); - if (!R) - return parseError(LineNo, R.takeError()); - if (R->Type == IHexRecord::EndOfFile) - break; - HasSections |= (R->Type == IHexRecord::Data); - Records.push_back(*R); - } - if (!HasSections) - return parseError(-1U, "no sections"); - - return std::move(Records); -} - -Expected<std::unique_ptr<Object>> -IHexReader::create(bool /*EnsureSymtab*/) const { - Expected<std::vector<IHexRecord>> Records = parse(); - if (!Records) - return Records.takeError(); - - return IHexELFBuilder(*Records).build(); -} - -Expected<std::unique_ptr<Object>> ELFReader::create(bool EnsureSymtab) const { - auto Obj = std::make_unique<Object>(); - if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) { - ELFBuilder<ELF32LE> Builder(*O, *Obj, ExtractPartition); - if (Error Err = Builder.build(EnsureSymtab)) - return std::move(Err); - return std::move(Obj); - } else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) { - ELFBuilder<ELF64LE> Builder(*O, *Obj, ExtractPartition); - if (Error Err = Builder.build(EnsureSymtab)) - return std::move(Err); - return std::move(Obj); - } else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) { - ELFBuilder<ELF32BE> Builder(*O, *Obj, ExtractPartition); - if (Error Err = Builder.build(EnsureSymtab)) - return std::move(Err); - return std::move(Obj); - } else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) { - ELFBuilder<ELF64BE> Builder(*O, *Obj, ExtractPartition); - if (Error Err = Builder.build(EnsureSymtab)) - return std::move(Err); - return std::move(Obj); - } - return createStringError(errc::invalid_argument, "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.SHOff; - // """ - // 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.SHOff); - 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> Error 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) - if (Error Err = Sec.accept(*SecWriter)) - return Err; - - return Error::success(); -} - -template <class ELFT> void ELFWriter<ELFT>::writeSegmentData() { - for (Segment &Seg : Obj.segments()) { - size_t Size = std::min<size_t>(Seg.FileSize, Seg.getContents().size()); - std::memcpy(Buf->getBufferStart() + Seg.Offset, Seg.getContents().data(), - Size); - } - - for (auto it : Obj.getUpdatedSections()) { - SectionBase *Sec = it.first; - ArrayRef<uint8_t> Data = it.second; - - auto *Parent = Sec->ParentSegment; - assert(Parent && "This section should've been part of a segment."); - uint64_t Offset = - Sec->OriginalOffset - Parent->OriginalOffset + Parent->Offset; - llvm::copy(Data, Buf->getBufferStart() + Offset); - } - - // 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, raw_ostream &Buf, bool WSH, - bool OnlyKeepDebug) - : Writer(Obj, Buf), WriteSectionHeaders(WSH && Obj.HadShdrs), - OnlyKeepDebug(OnlyKeepDebug) {} - -Error Object::updateSection(StringRef Name, ArrayRef<uint8_t> Data) { - auto It = llvm::find_if(Sections, - [&](const SecPtr &Sec) { return Sec->Name == Name; }); - if (It == Sections.end()) - return createStringError(errc::invalid_argument, "section '%s' not found", - Name.str().c_str()); - - auto *OldSec = It->get(); - if (!OldSec->hasContents()) - return createStringError( - errc::invalid_argument, - "section '%s' cannot be updated because it does not have contents", - Name.str().c_str()); - - if (Data.size() > OldSec->Size && OldSec->ParentSegment) - return createStringError(errc::invalid_argument, - "cannot fit data of size %zu into section '%s' " - "with size %zu that is part of a segment", - Data.size(), Name.str().c_str(), OldSec->Size); - - if (!OldSec->ParentSegment) { - *It = std::make_unique<OwnedDataSection>(*OldSec, Data); - } else { - // The segment writer will be in charge of updating these contents. - OldSec->Size = Data.size(); - UpdatedSections[OldSec] = Data; - } - - return Error::success(); -} - -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()); - RemoveSec->onRemove(); - 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::replaceSections( - const DenseMap<SectionBase *, SectionBase *> &FromTo) { - auto SectionIndexLess = [](const SecPtr &Lhs, const SecPtr &Rhs) { - return Lhs->Index < Rhs->Index; - }; - assert(llvm::is_sorted(Sections, SectionIndexLess) && - "Sections are expected to be sorted by Index"); - // Set indices of new sections so that they can be later sorted into positions - // of removed ones. - for (auto &I : FromTo) - I.second->Index = I.first->Index; - - // Notify all sections about the replacement. - for (auto &Sec : Sections) - Sec->replaceSectionReferences(FromTo); - - if (Error E = removeSections( - /*AllowBrokenLinks=*/false, - [=](const SectionBase &Sec) { return FromTo.count(&Sec) > 0; })) - return E; - llvm::sort(Sections, SectionIndexLess); - 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(); -} - -Error Object::addNewSymbolTable() { - assert(!SymbolTable && "Object must not has a SymbolTable."); - - // Reuse an existing SHT_STRTAB section if it exists. - StringTableSection *StrTab = nullptr; - for (SectionBase &Sec : sections()) { - if (Sec.Type == ELF::SHT_STRTAB && !(Sec.Flags & SHF_ALLOC)) { - StrTab = static_cast<StringTableSection *>(&Sec); - - // Prefer a string table that is not the section header string table, if - // such a table exists. - if (SectionNames != &Sec) - break; - } - } - if (!StrTab) - StrTab = &addSection<StringTableSection>(); - - SymbolTableSection &SymTab = addSection<SymbolTableSection>(); - SymTab.Name = ".symtab"; - SymTab.Link = StrTab->Index; - if (Error Err = SymTab.initialize(sections())) - return Err; - SymTab.addSymbol("", 0, 0, nullptr, 0, 0, 0, 0); - - SymbolTable = &SymTab; - - return Error::success(); -} - -// 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(llvm::is_sorted(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 { - Seg->Offset = - alignTo(Offset, std::max<uint64_t>(Seg->Align, 1), Seg->VAddr); - } - 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. - // While it is not necessary, layout the sections in the order based on their - // original offsets to resemble the input file as close as possible. - std::vector<SectionBase *> OutOfSegmentSections; - uint32_t Index = 1; - for (auto &Sec : Sections) { - Sec.Index = Index++; - if (Sec.ParentSegment != nullptr) { - auto Segment = *Sec.ParentSegment; - Sec.Offset = - Segment.Offset + (Sec.OriginalOffset - Segment.OriginalOffset); - } else - OutOfSegmentSections.push_back(&Sec); - } - - llvm::stable_sort(OutOfSegmentSections, - [](const SectionBase *Lhs, const SectionBase *Rhs) { - return Lhs->OriginalOffset < Rhs->OriginalOffset; - }); - for (auto *Sec : OutOfSegmentSections) { - Offset = alignTo(Offset, Sec->Align == 0 ? 1 : Sec->Align); - Sec->Offset = Offset; - if (Sec->Type != SHT_NOBITS) - Offset += Sec->Size; - } - return Offset; -} - -// Rewrite sh_offset after some sections are changed to SHT_NOBITS and thus -// occupy no space in the file. -static uint64_t layoutSectionsForOnlyKeepDebug(Object &Obj, uint64_t Off) { - // The layout algorithm requires the sections to be handled in the order of - // their offsets in the input file, at least inside segments. - std::vector<SectionBase *> Sections; - Sections.reserve(Obj.sections().size()); - uint32_t Index = 1; - for (auto &Sec : Obj.sections()) { - Sec.Index = Index++; - Sections.push_back(&Sec); - } - llvm::stable_sort(Sections, - [](const SectionBase *Lhs, const SectionBase *Rhs) { - return Lhs->OriginalOffset < Rhs->OriginalOffset; - }); - - for (auto *Sec : Sections) { - auto *FirstSec = Sec->ParentSegment && Sec->ParentSegment->Type == PT_LOAD - ? Sec->ParentSegment->firstSection() - : nullptr; - - // The first section in a PT_LOAD has to have congruent offset and address - // modulo the alignment, which usually equals the maximum page size. - if (FirstSec && FirstSec == Sec) - Off = alignTo(Off, Sec->ParentSegment->Align, Sec->Addr); - - // sh_offset is not significant for SHT_NOBITS sections, but the congruence - // rule must be followed if it is the first section in a PT_LOAD. Do not - // advance Off. - if (Sec->Type == SHT_NOBITS) { - Sec->Offset = Off; - continue; - } - - if (!FirstSec) { - // FirstSec being nullptr generally means that Sec does not have the - // SHF_ALLOC flag. - Off = Sec->Align ? alignTo(Off, Sec->Align) : Off; - } else if (FirstSec != Sec) { - // The offset is relative to the first section in the PT_LOAD segment. Use - // sh_offset for non-SHF_ALLOC sections. - Off = Sec->OriginalOffset - FirstSec->OriginalOffset + FirstSec->Offset; - } - Sec->Offset = Off; - Off += Sec->Size; - } - return Off; -} - -// Rewrite p_offset and p_filesz of non-PT_PHDR segments after sh_offset values -// have been updated. -static uint64_t layoutSegmentsForOnlyKeepDebug(std::vector<Segment *> &Segments, - uint64_t HdrEnd) { - uint64_t MaxOffset = 0; - for (Segment *Seg : Segments) { - if (Seg->Type == PT_PHDR) - continue; - - // The segment offset is generally the offset of the first section. - // - // For a segment containing no section (see sectionWithinSegment), if it has - // a parent segment, copy the parent segment's offset field. This works for - // empty PT_TLS. If no parent segment, use 0: the segment is not useful for - // debugging anyway. - const SectionBase *FirstSec = Seg->firstSection(); - uint64_t Offset = - FirstSec ? FirstSec->Offset - : (Seg->ParentSegment ? Seg->ParentSegment->Offset : 0); - uint64_t FileSize = 0; - for (const SectionBase *Sec : Seg->Sections) { - uint64_t Size = Sec->Type == SHT_NOBITS ? 0 : Sec->Size; - if (Sec->Offset + Size > Offset) - FileSize = std::max(FileSize, Sec->Offset + Size - Offset); - } - - // If the segment includes EHDR and program headers, don't make it smaller - // than the headers. - if (Seg->Offset < HdrEnd && HdrEnd <= Seg->Offset + Seg->FileSize) { - FileSize += Offset - Seg->Offset; - Offset = Seg->Offset; - FileSize = std::max(FileSize, HdrEnd - Offset); - } - - Seg->Offset = Offset; - Seg->FileSize = FileSize; - MaxOffset = std::max(MaxOffset, Offset + FileSize); - } - return MaxOffset; -} - -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); - - uint64_t Offset; - if (OnlyKeepDebug) { - // For --only-keep-debug, the sections that did not preserve contents were - // changed to SHT_NOBITS. We now rewrite sh_offset fields of sections, and - // then rewrite p_offset/p_filesz of program headers. - uint64_t HdrEnd = - sizeof(Elf_Ehdr) + llvm::size(Obj.segments()) * sizeof(Elf_Phdr); - Offset = layoutSectionsForOnlyKeepDebug(Obj, HdrEnd); - Offset = std::max(Offset, - layoutSegmentsForOnlyKeepDebug(OrderedSegments, HdrEnd)); - } else { - // 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. - Offset = layoutSegments(OrderedSegments, 0); - 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.SHOff = 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.SHOff; - size_t ShdrCount = Obj.sections().size() + 1; // Includes null shdr. - return Obj.SHOff + 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(); - if (Error E = writeSectionData()) - return E; - if (WriteSectionHeaders) - writeShdrs(); - - // TODO: Implement direct writing to the output stream (without intermediate - // memory buffer Buf). - Out.write(Buf->getBufferStart(), Buf->getBufferSize()); - return Error::success(); -} - -static Error removeUnneededSections(Object &Obj) { - // We can remove an empty symbol table from non-relocatable objects. - // Relocatable objects typically have relocation sections whose - // sh_link field points to .symtab, so we can't remove .symtab - // even if it is empty. - if (Obj.isRelocatable() || Obj.SymbolTable == nullptr || - !Obj.SymbolTable->empty()) - return Error::success(); - - // .strtab can be used for section names. In such a case we shouldn't - // remove it. - auto *StrTab = Obj.SymbolTable->getStrTab() == Obj.SectionNames - ? nullptr - : Obj.SymbolTable->getStrTab(); - return Obj.removeSections(false, [&](const SectionBase &Sec) { - return &Sec == Obj.SymbolTable || &Sec == StrTab; - }); -} - -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"); - - if (Error E = removeUnneededSections(Obj)) - return E; - - // 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(); - // Sections doesn't include the null section header, so account for this - // when skipping the first N sections. - NeedsLargeIndexes = - any_of(drop_begin(Sections, SHN_LORESERVE - 1), - [](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 SectionBase &Sec : Obj.sections()) - Obj.SectionNames->addString(Sec.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 = std::make_unique<ELFSectionSizer<ELFT>>(); - for (SectionBase &Sec : Obj.sections()) { - Sec.Index = Index++; - if (Error Err = Sec.accept(*SecSizer)) - return Err; - } - - // 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.SHOff + sizeof(Elf_Shdr); - for (SectionBase &Sec : Obj.sections()) { - Sec.HeaderOffset = Offset; - Offset += sizeof(Elf_Shdr); - if (WriteSectionHeaders) - Sec.NameIndex = Obj.SectionNames->findIndex(Sec.Name); - Sec.finalize(); - } - - size_t TotalSize = totalSize(); - Buf = WritableMemoryBuffer::getNewMemBuffer(TotalSize); - if (!Buf) - return createStringError(errc::not_enough_memory, - "failed to allocate memory buffer of " + - Twine::utohexstr(TotalSize) + " bytes"); - - SecWriter = std::make_unique<ELFSectionWriter<ELFT>>(*Buf); - return Error::success(); -} - -Error BinaryWriter::write() { - for (const SectionBase &Sec : Obj.allocSections()) - if (Error Err = Sec.accept(*SecWriter)) - return Err; - - // TODO: Implement direct writing to the output stream (without intermediate - // memory buffer Buf). - Out.write(Buf->getBufferStart(), Buf->getBufferSize()); - return Error::success(); -} - -Error BinaryWriter::finalize() { - // Compute the section LMA based on its sh_offset and the containing segment's - // p_offset and p_paddr. Also compute the minimum LMA of all non-empty - // sections as MinAddr. In the output, the contents between address 0 and - // MinAddr will be skipped. - uint64_t MinAddr = UINT64_MAX; - for (SectionBase &Sec : Obj.allocSections()) { - if (Sec.ParentSegment != nullptr) - Sec.Addr = - Sec.Offset - Sec.ParentSegment->Offset + Sec.ParentSegment->PAddr; - if (Sec.Type != SHT_NOBITS && Sec.Size > 0) - MinAddr = std::min(MinAddr, Sec.Addr); - } - - // 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 non-empty section, to match GNU objcopy's behaviour. - TotalSize = 0; - for (SectionBase &Sec : Obj.allocSections()) - if (Sec.Type != SHT_NOBITS && Sec.Size > 0) { - Sec.Offset = Sec.Addr - MinAddr; - TotalSize = std::max(TotalSize, Sec.Offset + Sec.Size); - } - - Buf = WritableMemoryBuffer::getNewMemBuffer(TotalSize); - if (!Buf) - return createStringError(errc::not_enough_memory, - "failed to allocate memory buffer of " + - Twine::utohexstr(TotalSize) + " bytes"); - SecWriter = std::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) - if (Error Err = Sec->accept(Writer)) - return Err; - - uint64_t Offset = Writer.getBufferOffset(); - // Write entry point address. - Offset += writeEntryPointRecord( - reinterpret_cast<uint8_t *>(Buf->getBufferStart()) + Offset); - // Write EOF. - Offset += writeEndOfFileRecord( - reinterpret_cast<uint8_t *>(Buf->getBufferStart()) + Offset); - assert(Offset == TotalSize); - - // TODO: Implement direct writing to the output stream (without intermediate - // memory buffer Buf). - Out.write(Buf->getBufferStart(), Buf->getBufferSize()); - return Error::success(); -} - -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() { - // 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); - - for (const SectionBase &Sec : Obj.sections()) - if ((Sec.Flags & ELF::SHF_ALLOC) && Sec.Type != ELF::SHT_NOBITS && - Sec.Size > 0) { - if (Error E = checkSection(Sec)) - return E; - Sections.insert(&Sec); - } - - std::unique_ptr<WritableMemoryBuffer> EmptyBuffer = - WritableMemoryBuffer::getNewMemBuffer(0); - if (!EmptyBuffer) - return createStringError(errc::not_enough_memory, - "failed to allocate memory buffer of 0 bytes"); - - IHexSectionWriterBase LengthCalc(*EmptyBuffer); - for (const SectionBase *Sec : Sections) - if (Error Err = Sec->accept(LengthCalc)) - return Err; - - // 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); - - Buf = WritableMemoryBuffer::getNewMemBuffer(TotalSize); - if (!Buf) - return createStringError(errc::not_enough_memory, - "failed to allocate memory buffer of " + - Twine::utohexstr(TotalSize) + " bytes"); - - return Error::success(); -} - -namespace llvm { -namespace objcopy { -namespace elf { - -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 |