2015-07-25 05:03:07 +08:00
|
|
|
//===- Writer.cpp ---------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Linker
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "Chunks.h"
|
2015-08-06 07:51:50 +08:00
|
|
|
#include "Config.h"
|
2015-08-06 23:08:23 +08:00
|
|
|
#include "Error.h"
|
2015-08-06 07:24:46 +08:00
|
|
|
#include "SymbolTable.h"
|
|
|
|
#include "Writer.h"
|
2015-08-12 08:00:24 +08:00
|
|
|
|
2015-07-28 08:17:25 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2015-08-12 08:00:24 +08:00
|
|
|
#include "llvm/MC/StringTableBuilder.h"
|
2015-08-06 07:24:46 +08:00
|
|
|
#include "llvm/Support/FileOutputBuffer.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::ELF;
|
|
|
|
using namespace llvm::object;
|
|
|
|
|
|
|
|
using namespace lld;
|
|
|
|
using namespace lld::elf2;
|
|
|
|
|
|
|
|
static const int PageSize = 4096;
|
|
|
|
|
2015-08-06 07:24:46 +08:00
|
|
|
namespace {
|
2015-08-12 07:22:24 +08:00
|
|
|
// OutputSection represents a section in an output file. It's a
|
|
|
|
// container of chunks. OutputSection and Chunk are 1:N relationship.
|
|
|
|
// Chunks cannot belong to more than one OutputSections. The writer
|
|
|
|
// creates multiple OutputSections and assign them unique,
|
|
|
|
// non-overlapping file offsets and VAs.
|
2015-08-12 07:34:29 +08:00
|
|
|
template <class ELFT> class OutputSection {
|
2015-08-12 07:22:24 +08:00
|
|
|
public:
|
2015-08-12 07:34:29 +08:00
|
|
|
typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
|
|
|
|
typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
|
|
|
|
|
2015-08-13 07:25:42 +08:00
|
|
|
OutputSection(StringRef Name) : Name(Name) {
|
|
|
|
memset(&Header, 0, sizeof(Elf_Shdr));
|
|
|
|
}
|
2015-08-12 07:34:29 +08:00
|
|
|
void setVA(uintX_t);
|
|
|
|
void setFileOffset(uintX_t);
|
|
|
|
void addSectionChunk(SectionChunk<ELFT> *C);
|
2015-08-12 07:22:24 +08:00
|
|
|
std::vector<Chunk *> &getChunks() { return Chunks; }
|
2015-08-12 07:34:29 +08:00
|
|
|
void writeHeaderTo(Elf_Shdr *SHdr);
|
2015-08-12 08:00:24 +08:00
|
|
|
StringRef getName() { return Name; }
|
|
|
|
void setNameOffset(uintX_t Offset) { Header.sh_name = Offset; }
|
2015-08-12 07:22:24 +08:00
|
|
|
|
|
|
|
// Returns the size of the section in the output file.
|
2015-08-12 07:34:29 +08:00
|
|
|
uintX_t getSize() { return Header.sh_size; }
|
2015-08-12 07:22:24 +08:00
|
|
|
|
2015-08-13 23:23:46 +08:00
|
|
|
uintX_t getFlags() { return Header.sh_flags; }
|
|
|
|
|
2015-08-12 07:22:24 +08:00
|
|
|
private:
|
|
|
|
StringRef Name;
|
2015-08-12 07:34:29 +08:00
|
|
|
Elf_Shdr Header;
|
2015-08-12 07:22:24 +08:00
|
|
|
std::vector<Chunk *> Chunks;
|
|
|
|
};
|
|
|
|
|
2015-08-06 07:24:46 +08:00
|
|
|
// The writer writes a SymbolTable result to a file.
|
|
|
|
template <class ELFT> class Writer {
|
|
|
|
public:
|
|
|
|
typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
|
2015-08-06 07:51:50 +08:00
|
|
|
Writer(SymbolTable *T) : Symtab(T) {}
|
2015-08-06 07:24:46 +08:00
|
|
|
void run();
|
|
|
|
|
|
|
|
private:
|
|
|
|
void createSections();
|
|
|
|
void assignAddresses();
|
|
|
|
void openFile(StringRef OutputPath);
|
|
|
|
void writeHeader();
|
|
|
|
void writeSections();
|
|
|
|
|
|
|
|
SymbolTable *Symtab;
|
|
|
|
std::unique_ptr<llvm::FileOutputBuffer> Buffer;
|
2015-08-12 07:34:29 +08:00
|
|
|
llvm::SpecificBumpPtrAllocator<OutputSection<ELFT>> CAlloc;
|
|
|
|
std::vector<OutputSection<ELFT> *> OutputSections;
|
2015-08-06 07:24:46 +08:00
|
|
|
|
2015-08-12 07:14:13 +08:00
|
|
|
uintX_t FileSize;
|
|
|
|
uintX_t SizeOfHeaders;
|
2015-08-06 07:24:46 +08:00
|
|
|
uintX_t SectionHeaderOff;
|
2015-08-12 08:00:24 +08:00
|
|
|
uintX_t StringTableOff;
|
|
|
|
unsigned StringTableIndex;
|
|
|
|
StringTableBuilder StrTabBuilder;
|
|
|
|
unsigned NumSections;
|
2015-08-06 07:24:46 +08:00
|
|
|
|
|
|
|
std::vector<std::unique_ptr<Chunk>> Chunks;
|
|
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
namespace lld {
|
|
|
|
namespace elf2 {
|
|
|
|
|
2015-08-04 22:29:01 +08:00
|
|
|
template <class ELFT>
|
2015-08-06 07:51:50 +08:00
|
|
|
void writeResult(SymbolTable *Symtab) { Writer<ELFT>(Symtab).run(); }
|
2015-08-06 07:24:46 +08:00
|
|
|
|
2015-08-06 07:51:50 +08:00
|
|
|
template void writeResult<ELF32LE>(SymbolTable *);
|
|
|
|
template void writeResult<ELF32BE>(SymbolTable *);
|
|
|
|
template void writeResult<ELF64LE>(SymbolTable *);
|
|
|
|
template void writeResult<ELF64BE>(SymbolTable *);
|
2015-08-06 07:24:46 +08:00
|
|
|
|
|
|
|
} // namespace elf2
|
|
|
|
} // namespace lld
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
// The main function of the writer.
|
2015-08-06 07:24:46 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::run() {
|
2015-07-25 05:03:07 +08:00
|
|
|
createSections();
|
|
|
|
assignAddresses();
|
2015-08-06 07:51:50 +08:00
|
|
|
openFile(Config->OutputFile);
|
2015-07-25 05:03:07 +08:00
|
|
|
writeHeader();
|
|
|
|
writeSections();
|
|
|
|
error(Buffer->commit());
|
|
|
|
}
|
|
|
|
|
2015-08-12 07:34:29 +08:00
|
|
|
template <class ELFT> void OutputSection<ELFT>::setVA(uintX_t VA) {
|
2015-07-25 05:03:07 +08:00
|
|
|
Header.sh_addr = VA;
|
|
|
|
}
|
|
|
|
|
2015-08-12 07:34:29 +08:00
|
|
|
template <class ELFT> void OutputSection<ELFT>::setFileOffset(uintX_t Off) {
|
2015-07-25 05:03:07 +08:00
|
|
|
if (Header.sh_size == 0)
|
|
|
|
return;
|
|
|
|
Header.sh_offset = Off;
|
|
|
|
for (Chunk *C : Chunks)
|
|
|
|
C->setFileOff(C->getFileOff() + Off);
|
|
|
|
}
|
|
|
|
|
2015-07-30 06:14:50 +08:00
|
|
|
template <class ELFT>
|
2015-08-12 07:34:29 +08:00
|
|
|
void OutputSection<ELFT>::addSectionChunk(SectionChunk<ELFT> *C) {
|
2015-07-25 05:03:07 +08:00
|
|
|
Chunks.push_back(C);
|
2015-08-12 07:14:13 +08:00
|
|
|
uintX_t Off = Header.sh_size;
|
2015-07-25 05:03:07 +08:00
|
|
|
Off = RoundUpToAlignment(Off, C->getAlign());
|
|
|
|
C->setFileOff(Off);
|
|
|
|
Off += C->getSize();
|
|
|
|
Header.sh_size = Off;
|
2015-08-05 21:55:34 +08:00
|
|
|
Header.sh_type = C->getSectionHdr()->sh_type;
|
|
|
|
Header.sh_flags |= C->getSectionHdr()->sh_flags;
|
2015-07-29 08:30:10 +08:00
|
|
|
}
|
|
|
|
|
2015-08-12 07:34:29 +08:00
|
|
|
template <class ELFT> void OutputSection<ELFT>::writeHeaderTo(Elf_Shdr *SHdr) {
|
|
|
|
*SHdr = Header;
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create output section objects and add them to OutputSections.
|
|
|
|
template <class ELFT> void Writer<ELFT>::createSections() {
|
2015-08-12 07:34:29 +08:00
|
|
|
SmallDenseMap<StringRef, OutputSection<ELFT> *> Map;
|
2015-08-05 21:55:34 +08:00
|
|
|
for (std::unique_ptr<ObjectFileBase> &FileB : Symtab->ObjectFiles) {
|
|
|
|
auto &File = cast<ObjectFile<ELFT>>(*FileB);
|
|
|
|
for (SectionChunk<ELFT> *C : File.getChunks()) {
|
2015-08-12 07:34:29 +08:00
|
|
|
OutputSection<ELFT> *&Sec = Map[C->getSectionName()];
|
2015-08-04 21:39:30 +08:00
|
|
|
if (!Sec) {
|
2015-08-12 07:34:29 +08:00
|
|
|
Sec = new (CAlloc.Allocate()) OutputSection<ELFT>(C->getSectionName());
|
2015-08-04 21:39:30 +08:00
|
|
|
OutputSections.push_back(Sec);
|
|
|
|
}
|
2015-08-12 07:34:29 +08:00
|
|
|
Sec->addSectionChunk(C);
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-13 23:23:46 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static bool compSec(OutputSection<ELFT> *A, OutputSection<ELFT> *B) {
|
|
|
|
// Place SHF_ALLOC sections first.
|
|
|
|
return (A->getFlags() & SHF_ALLOC) && !(B->getFlags() & SHF_ALLOC);
|
|
|
|
}
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
// Visits all sections to assign incremental, non-overlapping RVAs and
|
|
|
|
// file offsets.
|
|
|
|
template <class ELFT> void Writer<ELFT>::assignAddresses() {
|
2015-07-29 08:30:10 +08:00
|
|
|
SizeOfHeaders = RoundUpToAlignment(sizeof(Elf_Ehdr_Impl<ELFT>), PageSize);
|
2015-08-12 07:14:13 +08:00
|
|
|
uintX_t VA = 0x1000; // The first page is kept unmapped.
|
|
|
|
uintX_t FileOff = SizeOfHeaders;
|
2015-08-13 23:23:46 +08:00
|
|
|
|
|
|
|
std::stable_sort(OutputSections.begin(), OutputSections.end(), compSec<ELFT>);
|
|
|
|
|
2015-08-12 07:34:29 +08:00
|
|
|
for (OutputSection<ELFT> *Sec : OutputSections) {
|
2015-07-25 05:03:07 +08:00
|
|
|
Sec->setVA(VA);
|
|
|
|
Sec->setFileOffset(FileOff);
|
|
|
|
VA += RoundUpToAlignment(Sec->getSize(), PageSize);
|
|
|
|
FileOff += RoundUpToAlignment(Sec->getSize(), 8);
|
2015-08-12 08:00:24 +08:00
|
|
|
StrTabBuilder.add(Sec->getName());
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
2015-08-12 08:00:24 +08:00
|
|
|
|
|
|
|
// Regular sections.
|
|
|
|
NumSections = OutputSections.size();
|
|
|
|
|
|
|
|
// First dummy section.
|
|
|
|
NumSections++;
|
|
|
|
|
|
|
|
// String table.
|
|
|
|
StrTabBuilder.add(".strtab");
|
|
|
|
StringTableIndex = NumSections;
|
|
|
|
StringTableOff = FileOff;
|
|
|
|
StrTabBuilder.finalize(StringTableBuilder::ELF);
|
|
|
|
FileOff += StrTabBuilder.data().size();
|
|
|
|
NumSections++;
|
|
|
|
|
2015-08-12 09:45:28 +08:00
|
|
|
FileOff += OffsetToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
|
|
|
|
|
2015-07-29 08:30:10 +08:00
|
|
|
// Add space for section headers.
|
|
|
|
SectionHeaderOff = FileOff;
|
2015-08-12 08:00:24 +08:00
|
|
|
FileOff += NumSections * sizeof(Elf_Shdr_Impl<ELFT>);
|
2015-07-25 05:03:07 +08:00
|
|
|
FileSize = SizeOfHeaders + RoundUpToAlignment(FileOff - SizeOfHeaders, 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void Writer<ELFT>::writeHeader() {
|
|
|
|
uint8_t *Buf = Buffer->getBufferStart();
|
|
|
|
auto *EHdr = reinterpret_cast<Elf_Ehdr_Impl<ELFT> *>(Buf);
|
|
|
|
EHdr->e_ident[EI_MAG0] = 0x7F;
|
|
|
|
EHdr->e_ident[EI_MAG1] = 0x45;
|
|
|
|
EHdr->e_ident[EI_MAG2] = 0x4C;
|
|
|
|
EHdr->e_ident[EI_MAG3] = 0x46;
|
2015-08-05 23:08:40 +08:00
|
|
|
EHdr->e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
|
|
|
|
EHdr->e_ident[EI_DATA] = ELFT::TargetEndianness == llvm::support::little
|
|
|
|
? ELFDATA2LSB
|
|
|
|
: ELFDATA2MSB;
|
2015-07-25 05:03:07 +08:00
|
|
|
EHdr->e_ident[EI_VERSION] = EV_CURRENT;
|
2015-08-05 19:55:52 +08:00
|
|
|
EHdr->e_ident[EI_OSABI] = ELFOSABI_NONE;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
EHdr->e_type = ET_EXEC;
|
2015-08-05 23:08:40 +08:00
|
|
|
auto &FirstObj = cast<ObjectFile<ELFT>>(*Symtab->ObjectFiles[0]);
|
|
|
|
EHdr->e_machine = FirstObj.getObj()->getHeader()->e_machine;
|
2015-07-25 05:03:07 +08:00
|
|
|
EHdr->e_version = EV_CURRENT;
|
|
|
|
EHdr->e_entry = 0x401000;
|
|
|
|
EHdr->e_phoff = sizeof(Elf_Ehdr_Impl<ELFT>);
|
2015-07-29 08:30:10 +08:00
|
|
|
EHdr->e_shoff = SectionHeaderOff;
|
2015-07-25 05:03:07 +08:00
|
|
|
EHdr->e_ehsize = sizeof(Elf_Ehdr_Impl<ELFT>);
|
|
|
|
EHdr->e_phentsize = sizeof(Elf_Phdr_Impl<ELFT>);
|
|
|
|
EHdr->e_phnum = 1;
|
|
|
|
EHdr->e_shentsize = sizeof(Elf_Shdr_Impl<ELFT>);
|
2015-08-12 08:00:24 +08:00
|
|
|
EHdr->e_shnum = NumSections;
|
|
|
|
EHdr->e_shstrndx = StringTableIndex;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
auto PHdrs = reinterpret_cast<Elf_Phdr_Impl<ELFT> *>(Buf + EHdr->e_phoff);
|
|
|
|
PHdrs->p_type = PT_LOAD;
|
|
|
|
PHdrs->p_flags = PF_R | PF_X;
|
|
|
|
PHdrs->p_offset = 0x0000;
|
|
|
|
PHdrs->p_vaddr = 0x400000;
|
|
|
|
PHdrs->p_paddr = PHdrs->p_vaddr;
|
|
|
|
PHdrs->p_filesz = FileSize;
|
|
|
|
PHdrs->p_memsz = FileSize;
|
|
|
|
PHdrs->p_align = 0x4000;
|
2015-07-29 08:30:10 +08:00
|
|
|
|
|
|
|
auto SHdrs = reinterpret_cast<Elf_Shdr_Impl<ELFT> *>(Buf + EHdr->e_shoff);
|
|
|
|
// First entry is null.
|
|
|
|
++SHdrs;
|
2015-08-12 08:00:24 +08:00
|
|
|
for (OutputSection<ELFT> *Sec : OutputSections) {
|
|
|
|
Sec->setNameOffset(StrTabBuilder.getOffset(Sec->getName()));
|
2015-08-12 07:34:29 +08:00
|
|
|
Sec->writeHeaderTo(SHdrs++);
|
2015-08-12 08:00:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// String table.
|
|
|
|
SHdrs->sh_name = StrTabBuilder.getOffset(".strtab");
|
|
|
|
SHdrs->sh_type = SHT_STRTAB;
|
|
|
|
SHdrs->sh_flags = 0;
|
|
|
|
SHdrs->sh_addr = 0;
|
|
|
|
SHdrs->sh_offset = StringTableOff;
|
|
|
|
SHdrs->sh_size = StrTabBuilder.data().size();
|
|
|
|
SHdrs->sh_link = 0;
|
|
|
|
SHdrs->sh_info = 0;
|
|
|
|
SHdrs->sh_addralign = 1;
|
|
|
|
SHdrs->sh_entsize = 0;
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void Writer<ELFT>::openFile(StringRef Path) {
|
2015-08-13 08:31:46 +08:00
|
|
|
ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
|
|
|
|
FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable);
|
|
|
|
error(BufferOrErr, Twine("failed to open ") + Path);
|
|
|
|
Buffer = std::move(*BufferOrErr);
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Write section contents to a mmap'ed file.
|
|
|
|
template <class ELFT> void Writer<ELFT>::writeSections() {
|
|
|
|
uint8_t *Buf = Buffer->getBufferStart();
|
2015-08-12 07:34:29 +08:00
|
|
|
for (OutputSection<ELFT> *Sec : OutputSections) {
|
2015-07-25 05:03:07 +08:00
|
|
|
for (Chunk *C : Sec->getChunks())
|
|
|
|
C->writeTo(Buf);
|
|
|
|
}
|
2015-08-12 08:00:24 +08:00
|
|
|
|
|
|
|
// String table.
|
|
|
|
StringRef Data = StrTabBuilder.data();
|
|
|
|
memcpy(Buf + StringTableOff, Data.data(), Data.size());
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|