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.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-09-05 06:48:30 +08:00
|
|
|
#include "Writer.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
#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-28 07:15:56 +08:00
|
|
|
#include "Symbols.h"
|
2015-08-06 07:24:46 +08:00
|
|
|
#include "SymbolTable.h"
|
2015-08-12 08:00:24 +08:00
|
|
|
|
2015-07-28 08:17:25 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2015-08-28 10:46:41 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2015-09-02 05:47:21 +08:00
|
|
|
#include "llvm/MC/StringTableBuilder.h"
|
2015-08-06 07:24:46 +08:00
|
|
|
#include "llvm/Support/FileOutputBuffer.h"
|
2015-08-28 07:15:56 +08:00
|
|
|
#include "llvm/Support/raw_ostream.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-14 06:14:37 +08:00
|
|
|
template <bool Is64Bits> class OutputSectionBase {
|
2015-08-12 07:22:24 +08:00
|
|
|
public:
|
2015-09-09 23:33:08 +08:00
|
|
|
typedef
|
|
|
|
typename std::conditional<Is64Bits, Elf64_Dyn, Elf32_Dyn>::type Elf_Dyn;
|
2015-08-14 02:37:23 +08:00
|
|
|
typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
|
|
|
|
typedef
|
|
|
|
typename std::conditional<Is64Bits, Elf64_Shdr, Elf32_Shdr>::type HeaderT;
|
2015-08-12 07:34:29 +08:00
|
|
|
|
2015-08-14 06:14:37 +08:00
|
|
|
OutputSectionBase(StringRef Name, uint32_t sh_type, uintX_t sh_flags)
|
2015-08-14 01:32:30 +08:00
|
|
|
: Name(Name) {
|
2015-08-14 02:37:23 +08:00
|
|
|
memset(&Header, 0, sizeof(HeaderT));
|
2015-08-14 01:32:30 +08:00
|
|
|
Header.sh_type = sh_type;
|
|
|
|
Header.sh_flags = sh_flags;
|
2015-08-13 07:25:42 +08:00
|
|
|
}
|
2015-08-14 02:25:47 +08:00
|
|
|
void setVA(uintX_t VA) { Header.sh_addr = VA; }
|
2015-09-09 23:33:08 +08:00
|
|
|
uintX_t getVA() const { return Header.sh_addr; }
|
2015-08-14 02:25:47 +08:00
|
|
|
void setFileOffset(uintX_t Off) { Header.sh_offset = Off; }
|
2015-08-14 02:37:23 +08:00
|
|
|
template <endianness E>
|
|
|
|
void writeHeaderTo(typename ELFFile<ELFType<E, Is64Bits>>::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
|
|
|
|
2015-08-25 04:06:32 +08:00
|
|
|
unsigned getSectionIndex() const { return SectionIndex; }
|
|
|
|
void setSectionIndex(unsigned I) { SectionIndex = I; }
|
|
|
|
|
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-09-01 06:07:18 +08:00
|
|
|
void setSize(uintX_t Val) { Header.sh_size = Val; }
|
2015-08-13 23:23:46 +08:00
|
|
|
uintX_t getFlags() { return Header.sh_flags; }
|
2015-08-14 13:17:30 +08:00
|
|
|
uintX_t getFileOff() { return Header.sh_offset; }
|
2015-09-05 08:25:33 +08:00
|
|
|
uintX_t getAlign() {
|
|
|
|
// The ELF spec states that a value of 0 means the section has no alignment
|
|
|
|
// constraits.
|
|
|
|
return std::max<uintX_t>(Header.sh_addralign, 1);
|
|
|
|
}
|
2015-09-01 04:23:57 +08:00
|
|
|
uint32_t getType() { return Header.sh_type; }
|
2015-08-13 23:23:46 +08:00
|
|
|
|
2015-08-14 06:14:37 +08:00
|
|
|
virtual void finalize() {}
|
|
|
|
virtual void writeTo(uint8_t *Buf) = 0;
|
|
|
|
|
|
|
|
protected:
|
2015-08-12 07:22:24 +08:00
|
|
|
StringRef Name;
|
2015-08-14 02:37:23 +08:00
|
|
|
HeaderT Header;
|
2015-08-25 04:06:32 +08:00
|
|
|
unsigned SectionIndex;
|
2015-08-14 06:14:37 +08:00
|
|
|
~OutputSectionBase() = default;
|
|
|
|
};
|
2015-08-25 04:06:32 +08:00
|
|
|
}
|
2015-08-14 06:14:37 +08:00
|
|
|
|
2015-08-14 06:21:37 +08:00
|
|
|
template <class ELFT>
|
2015-08-25 04:06:32 +08:00
|
|
|
class lld::elf2::OutputSection final
|
|
|
|
: public OutputSectionBase<ELFT::Is64Bits> {
|
2015-08-14 06:14:37 +08:00
|
|
|
public:
|
2015-08-14 06:21:37 +08:00
|
|
|
typedef typename OutputSectionBase<ELFT::Is64Bits>::uintX_t uintX_t;
|
2015-08-28 07:15:56 +08:00
|
|
|
typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
|
2015-08-14 06:14:37 +08:00
|
|
|
OutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags)
|
2015-08-14 06:21:37 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(Name, sh_type, sh_flags) {}
|
2015-08-14 06:14:37 +08:00
|
|
|
|
2015-08-14 06:21:37 +08:00
|
|
|
void addChunk(SectionChunk<ELFT> *C);
|
2015-08-14 06:14:37 +08:00
|
|
|
void writeTo(uint8_t *Buf) override;
|
|
|
|
|
|
|
|
private:
|
2015-08-14 06:21:37 +08:00
|
|
|
std::vector<SectionChunk<ELFT> *> Chunks;
|
2015-08-12 07:22:24 +08:00
|
|
|
};
|
|
|
|
|
2015-08-25 04:06:32 +08:00
|
|
|
namespace {
|
2015-08-14 06:14:37 +08:00
|
|
|
template <bool Is64Bits>
|
|
|
|
class StringTableSection final : public OutputSectionBase<Is64Bits> {
|
|
|
|
public:
|
2015-09-02 05:47:21 +08:00
|
|
|
llvm::StringTableBuilder StrTabBuilder;
|
|
|
|
|
2015-08-14 06:14:37 +08:00
|
|
|
typedef typename OutputSectionBase<Is64Bits>::uintX_t uintX_t;
|
2015-09-09 23:33:08 +08:00
|
|
|
StringTableSection(bool Dynamic)
|
|
|
|
: OutputSectionBase<Is64Bits>(Dynamic ? ".dynstr" : ".strtab", SHT_STRTAB,
|
|
|
|
Dynamic ? SHF_ALLOC : 0) {
|
2015-08-14 06:14:37 +08:00
|
|
|
this->Header.sh_addralign = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void add(StringRef S) { StrTabBuilder.add(S); }
|
2015-08-14 13:17:30 +08:00
|
|
|
size_t getFileOff(StringRef S) { return StrTabBuilder.getOffset(S); }
|
2015-08-14 06:14:37 +08:00
|
|
|
void writeTo(uint8_t *Buf) override;
|
|
|
|
|
|
|
|
void finalize() override {
|
|
|
|
StrTabBuilder.finalize(StringTableBuilder::ELF);
|
|
|
|
this->Header.sh_size = StrTabBuilder.data().size();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-08-14 10:42:20 +08:00
|
|
|
template <class ELFT>
|
|
|
|
class SymbolTableSection final : public OutputSectionBase<ELFT::Is64Bits> {
|
|
|
|
public:
|
2015-08-14 21:07:05 +08:00
|
|
|
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
2015-08-25 23:53:17 +08:00
|
|
|
typedef typename OutputSectionBase<ELFT::Is64Bits>::uintX_t uintX_t;
|
2015-09-09 03:23:30 +08:00
|
|
|
SymbolTableSection(SymbolTable &Table,
|
|
|
|
StringTableSection<ELFT::Is64Bits> &StrTabSec)
|
2015-08-14 21:07:05 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(".symtab", SHT_SYMTAB, 0),
|
2015-09-09 03:23:30 +08:00
|
|
|
Table(Table), Builder(StrTabSec.StrTabBuilder), StrTabSec(StrTabSec) {
|
2015-08-14 10:42:20 +08:00
|
|
|
typedef OutputSectionBase<ELFT::Is64Bits> Base;
|
|
|
|
typename Base::HeaderT &Header = this->Header;
|
|
|
|
|
|
|
|
// For now the only local symbol is going to be the one at index 0
|
|
|
|
Header.sh_info = 1;
|
|
|
|
|
2015-08-14 21:07:05 +08:00
|
|
|
Header.sh_entsize = sizeof(Elf_Sym);
|
2015-08-14 10:42:20 +08:00
|
|
|
Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
|
|
|
|
}
|
2015-09-02 04:36:51 +08:00
|
|
|
|
|
|
|
void finalize() override {
|
|
|
|
this->Header.sh_size = (NumVisible + 1) * sizeof(Elf_Sym);
|
2015-09-09 03:23:30 +08:00
|
|
|
this->Header.sh_link = StrTabSec.getSectionIndex();
|
2015-09-02 04:36:51 +08:00
|
|
|
}
|
|
|
|
|
2015-08-14 10:42:20 +08:00
|
|
|
void writeTo(uint8_t *Buf) override;
|
2015-08-14 21:07:05 +08:00
|
|
|
|
2015-08-24 22:48:18 +08:00
|
|
|
const SymbolTable &getSymTable() { return Table; }
|
|
|
|
|
2015-09-01 06:33:21 +08:00
|
|
|
OutputSection<ELFT> *BSSSec = nullptr;
|
2015-09-02 04:36:51 +08:00
|
|
|
unsigned NumVisible = 0;
|
2015-09-01 06:33:21 +08:00
|
|
|
|
2015-08-14 21:07:05 +08:00
|
|
|
private:
|
|
|
|
SymbolTable &Table;
|
2015-09-02 05:47:21 +08:00
|
|
|
llvm::StringTableBuilder &Builder;
|
2015-09-09 03:23:30 +08:00
|
|
|
const StringTableSection<ELFT::Is64Bits> &StrTabSec;
|
2015-08-14 10:42:20 +08:00
|
|
|
};
|
|
|
|
|
2015-09-09 03:43:27 +08:00
|
|
|
template <bool Is64Bits>
|
|
|
|
class DynamicSection final : public OutputSectionBase<Is64Bits> {
|
2015-09-09 23:33:08 +08:00
|
|
|
typedef OutputSectionBase<Is64Bits> Base;
|
|
|
|
typedef typename Base::HeaderT HeaderT;
|
|
|
|
typedef typename Base::Elf_Dyn Elf_Dyn;
|
|
|
|
|
2015-09-09 03:43:27 +08:00
|
|
|
public:
|
2015-09-10 04:26:23 +08:00
|
|
|
DynamicSection(SymbolTable &SymTab, StringTableSection<Is64Bits> &DynStrSec)
|
2015-09-09 03:43:27 +08:00
|
|
|
: OutputSectionBase<Is64Bits>(".dynamic", SHT_DYNAMIC,
|
|
|
|
SHF_ALLOC | SHF_WRITE),
|
2015-09-10 04:26:23 +08:00
|
|
|
DynStrSec(DynStrSec), SymTab(SymTab) {
|
2015-09-09 03:43:27 +08:00
|
|
|
typename Base::HeaderT &Header = this->Header;
|
|
|
|
Header.sh_addralign = Is64Bits ? 8 : 4;
|
|
|
|
Header.sh_entsize = Is64Bits ? 16 : 8;
|
2015-09-09 23:33:08 +08:00
|
|
|
|
|
|
|
unsigned NumEntries = 0;
|
|
|
|
|
|
|
|
++NumEntries; // DT_STRTAB
|
2015-09-10 04:26:23 +08:00
|
|
|
++NumEntries; // DT_STRSZ
|
|
|
|
|
|
|
|
const std::vector<std::unique_ptr<SharedFileBase>> &SharedFiles =
|
|
|
|
SymTab.getSharedFiles();
|
|
|
|
for (const std::unique_ptr<SharedFileBase> &File : SharedFiles)
|
|
|
|
DynStrSec.add(File->getName());
|
|
|
|
NumEntries += SharedFiles.size();
|
|
|
|
|
2015-09-09 23:33:08 +08:00
|
|
|
++NumEntries; // DT_NULL
|
|
|
|
|
|
|
|
Header.sh_size = NumEntries * Header.sh_entsize;
|
2015-09-09 03:43:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void finalize() override {
|
2015-09-09 23:33:08 +08:00
|
|
|
this->Header.sh_link = DynStrSec.getSectionIndex();
|
2015-09-09 03:43:27 +08:00
|
|
|
}
|
|
|
|
|
2015-09-09 23:33:08 +08:00
|
|
|
void writeTo(uint8_t *Buf) override {
|
|
|
|
auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
|
|
|
|
|
|
|
|
P->d_tag = DT_STRTAB;
|
|
|
|
P->d_un.d_ptr = DynStrSec.getVA();
|
|
|
|
++P;
|
|
|
|
|
2015-09-10 04:26:23 +08:00
|
|
|
P->d_tag = DT_STRSZ;
|
|
|
|
P->d_un.d_val = DynStrSec.StrTabBuilder.data().size();
|
|
|
|
++P;
|
|
|
|
|
|
|
|
const std::vector<std::unique_ptr<SharedFileBase>> &SharedFiles =
|
|
|
|
SymTab.getSharedFiles();
|
|
|
|
for (const std::unique_ptr<SharedFileBase> &File : SharedFiles) {
|
|
|
|
P->d_tag = DT_NEEDED;
|
|
|
|
P->d_un.d_val = DynStrSec.getFileOff(File->getName());
|
|
|
|
++P;
|
|
|
|
}
|
|
|
|
|
2015-09-09 23:33:08 +08:00
|
|
|
P->d_tag = DT_NULL;
|
|
|
|
P->d_un.d_val = 0;
|
2015-09-10 04:26:23 +08:00
|
|
|
++P;
|
2015-09-09 23:33:08 +08:00
|
|
|
}
|
2015-09-09 03:43:27 +08:00
|
|
|
|
|
|
|
private:
|
2015-09-10 04:26:23 +08:00
|
|
|
StringTableSection<Is64Bits> &DynStrSec;
|
|
|
|
SymbolTable &SymTab;
|
2015-09-09 03:43:27 +08:00
|
|
|
};
|
|
|
|
|
2015-08-06 07:24:46 +08:00
|
|
|
// The writer writes a SymbolTable result to a file.
|
|
|
|
template <class ELFT> class Writer {
|
|
|
|
public:
|
2015-09-09 05:57:31 +08:00
|
|
|
typedef typename ELFFile<ELFT>::uintX_t uintX_t;
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
2015-09-09 23:33:08 +08:00
|
|
|
Writer(SymbolTable *T)
|
|
|
|
: StrTabSec(false), DynStrSec(true), SymTable(*T, StrTabSec),
|
2015-09-10 04:26:23 +08:00
|
|
|
DynamicSec(*T, DynStrSec) {}
|
2015-08-06 07:24:46 +08:00
|
|
|
void run();
|
|
|
|
|
|
|
|
private:
|
|
|
|
void createSections();
|
|
|
|
void assignAddresses();
|
|
|
|
void openFile(StringRef OutputPath);
|
|
|
|
void writeHeader();
|
|
|
|
void writeSections();
|
|
|
|
|
|
|
|
std::unique_ptr<llvm::FileOutputBuffer> Buffer;
|
2015-08-14 06:21:37 +08:00
|
|
|
llvm::SpecificBumpPtrAllocator<OutputSection<ELFT>> CAlloc;
|
2015-08-14 06:14:37 +08:00
|
|
|
std::vector<OutputSectionBase<ELFT::Is64Bits> *> OutputSections;
|
2015-09-09 01:39:39 +08:00
|
|
|
unsigned getNumSections() const { return OutputSections.size() + 1; }
|
2015-08-06 07:24:46 +08:00
|
|
|
|
2015-08-12 07:14:13 +08:00
|
|
|
uintX_t FileSize;
|
2015-09-10 04:48:09 +08:00
|
|
|
uintX_t ProgramHeaderOff;
|
2015-08-06 07:24:46 +08:00
|
|
|
uintX_t SectionHeaderOff;
|
2015-09-10 04:48:09 +08:00
|
|
|
unsigned NumPhdrs;
|
2015-08-14 06:14:37 +08:00
|
|
|
|
2015-09-09 23:33:08 +08:00
|
|
|
StringTableSection<ELFT::Is64Bits> StrTabSec;
|
|
|
|
StringTableSection<ELFT::Is64Bits> DynStrSec;
|
2015-08-14 06:14:37 +08:00
|
|
|
|
2015-09-02 05:47:21 +08:00
|
|
|
SymbolTableSection<ELFT> SymTable;
|
2015-09-09 03:43:27 +08:00
|
|
|
|
|
|
|
DynamicSection<ELFT::Is64Bits> DynamicSec;
|
2015-08-06 07:24:46 +08:00
|
|
|
};
|
|
|
|
} // 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-14 06:21:37 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void OutputSection<ELFT>::addChunk(SectionChunk<ELFT> *C) {
|
2015-07-25 05:03:07 +08:00
|
|
|
Chunks.push_back(C);
|
2015-08-25 04:06:32 +08:00
|
|
|
C->setOutputSection(this);
|
2015-08-14 04:13:39 +08:00
|
|
|
uint32_t Align = C->getAlign();
|
2015-08-14 06:14:37 +08:00
|
|
|
if (Align > this->Header.sh_addralign)
|
|
|
|
this->Header.sh_addralign = Align;
|
2015-08-14 04:13:39 +08:00
|
|
|
|
2015-08-14 06:14:37 +08:00
|
|
|
uintX_t Off = this->Header.sh_size;
|
2015-08-14 04:13:39 +08:00
|
|
|
Off = RoundUpToAlignment(Off, Align);
|
2015-08-13 23:54:36 +08:00
|
|
|
C->setOutputSectionOff(Off);
|
2015-07-25 05:03:07 +08:00
|
|
|
Off += C->getSize();
|
2015-08-14 06:14:37 +08:00
|
|
|
this->Header.sh_size = Off;
|
|
|
|
}
|
|
|
|
|
2015-08-28 07:15:56 +08:00
|
|
|
template <class ELFT>
|
2015-09-09 05:57:31 +08:00
|
|
|
static typename ELFFile<ELFT>::uintX_t getSymVA(DefinedRegular<ELFT> *DR) {
|
2015-08-28 07:15:56 +08:00
|
|
|
const SectionChunk<ELFT> *SC = &DR->Section;
|
|
|
|
OutputSection<ELFT> *OS = SC->getOutputSection();
|
|
|
|
return OS->getVA() + SC->getOutputSectionOff() + DR->Sym.st_value;
|
|
|
|
}
|
|
|
|
|
2015-08-14 06:21:37 +08:00
|
|
|
template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-08-28 07:15:56 +08:00
|
|
|
for (SectionChunk<ELFT> *C : Chunks) {
|
2015-08-14 06:14:37 +08:00
|
|
|
C->writeTo(Buf);
|
2015-08-28 07:15:56 +08:00
|
|
|
ObjectFile<ELFT> *File = C->getFile();
|
|
|
|
ELFFile<ELFT> *EObj = File->getObj();
|
|
|
|
uint8_t *Base = Buf + C->getOutputSectionOff();
|
|
|
|
|
|
|
|
// Iterate over all relocation sections that apply to this section.
|
|
|
|
for (const Elf_Shdr *RelSec : C->RelocSections) {
|
|
|
|
// Only support RELA for now.
|
|
|
|
if (RelSec->sh_type != SHT_RELA)
|
|
|
|
continue;
|
|
|
|
for (const Elf_Rela &RI : EObj->relas(RelSec)) {
|
|
|
|
uint32_t SymIndex = RI.getSymbol(EObj->isMips64EL());
|
|
|
|
SymbolBody *Body = File->getSymbolBody(SymIndex);
|
|
|
|
if (!Body)
|
|
|
|
continue;
|
2015-08-31 07:17:30 +08:00
|
|
|
// Skip unsupported for now.
|
2015-08-28 07:15:56 +08:00
|
|
|
if (!isa<DefinedRegular<ELFT>>(Body))
|
2015-08-31 07:17:30 +08:00
|
|
|
continue;
|
2015-08-28 07:15:56 +08:00
|
|
|
uintX_t Offset = RI.r_offset;
|
|
|
|
uint32_t Type = RI.getType(EObj->isMips64EL());
|
|
|
|
uintX_t P = this->getVA() + C->getOutputSectionOff();
|
|
|
|
uintX_t SymVA = getSymVA<ELFT>(cast<DefinedRegular<ELFT>>(Body));
|
2015-08-29 21:15:42 +08:00
|
|
|
uint8_t *Location = Base + Offset;
|
2015-08-28 07:15:56 +08:00
|
|
|
switch (Type) {
|
|
|
|
case llvm::ELF::R_X86_64_PC32:
|
2015-08-29 21:15:42 +08:00
|
|
|
support::endian::write32le(Location,
|
2015-08-28 07:15:56 +08:00
|
|
|
SymVA + (RI.r_addend - (P + Offset)));
|
|
|
|
break;
|
2015-08-29 21:15:42 +08:00
|
|
|
case llvm::ELF::R_X86_64_32:
|
|
|
|
support::endian::write32le(Location, SymVA + RI.r_addend);
|
|
|
|
break;
|
2015-08-28 07:15:56 +08:00
|
|
|
default:
|
|
|
|
llvm::errs() << Twine("unrecognized reloc ") + Twine(Type) << '\n';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-08-14 06:14:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
void StringTableSection<Is64Bits>::writeTo(uint8_t *Buf) {
|
|
|
|
StringRef Data = StrTabBuilder.data();
|
|
|
|
memcpy(Buf, Data.data(), Data.size());
|
2015-07-29 08:30:10 +08:00
|
|
|
}
|
|
|
|
|
2015-08-28 10:46:41 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static int compareSym(const typename ELFFile<ELFT>::Elf_Sym *A,
|
|
|
|
const typename ELFFile<ELFT>::Elf_Sym *B) {
|
|
|
|
uint32_t AN = A->st_name;
|
|
|
|
uint32_t BN = B->st_name;
|
|
|
|
assert(AN != BN);
|
|
|
|
return AN - BN;
|
|
|
|
}
|
|
|
|
|
2015-09-08 23:50:05 +08:00
|
|
|
static bool includeInSymtab(const SymbolBody &B) {
|
|
|
|
if (B.isLazy())
|
|
|
|
return false;
|
|
|
|
if (!B.isUsedInRegularObj())
|
|
|
|
return false;
|
|
|
|
uint8_t V = B.getMostConstrainingVisibility();
|
|
|
|
if (V != STV_DEFAULT && V != STV_PROTECTED)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-08-14 21:07:05 +08:00
|
|
|
template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-08-28 10:46:41 +08:00
|
|
|
uint8_t *BufStart = Buf;
|
|
|
|
|
2015-08-14 21:07:05 +08:00
|
|
|
Buf += sizeof(Elf_Sym);
|
|
|
|
for (auto &P : Table.getSymbols()) {
|
|
|
|
StringRef Name = P.first;
|
2015-08-14 21:52:36 +08:00
|
|
|
Symbol *Sym = P.second;
|
2015-09-02 04:30:52 +08:00
|
|
|
SymbolBody *Body = Sym->Body;
|
2015-09-08 23:50:05 +08:00
|
|
|
if (!includeInSymtab(*Body))
|
2015-09-05 06:28:10 +08:00
|
|
|
continue;
|
2015-09-02 04:30:52 +08:00
|
|
|
const Elf_Sym &InputSym = cast<ELFSymbolBody<ELFT>>(Body)->Sym;
|
2015-08-14 21:52:36 +08:00
|
|
|
|
|
|
|
auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
|
|
|
|
ESym->st_name = Builder.getOffset(Name);
|
2015-08-25 04:06:32 +08:00
|
|
|
|
|
|
|
const SectionChunk<ELFT> *Section = nullptr;
|
2015-09-01 06:33:21 +08:00
|
|
|
OutputSection<ELFT> *Out = nullptr;
|
2015-08-25 04:06:32 +08:00
|
|
|
|
2015-08-14 23:10:49 +08:00
|
|
|
switch (Body->kind()) {
|
2015-09-02 04:30:52 +08:00
|
|
|
case SymbolBody::DefinedRegularKind:
|
|
|
|
Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
|
2015-08-14 21:52:36 +08:00
|
|
|
break;
|
2015-09-01 06:33:21 +08:00
|
|
|
case SymbolBody::DefinedCommonKind:
|
|
|
|
Out = BSSSec;
|
|
|
|
break;
|
2015-08-29 04:19:34 +08:00
|
|
|
case SymbolBody::UndefinedKind:
|
2015-09-08 22:32:29 +08:00
|
|
|
if (!Body->isWeak())
|
|
|
|
error(Twine("undefined symbol: ") + Name);
|
2015-08-27 20:40:06 +08:00
|
|
|
case SymbolBody::DefinedAbsoluteKind:
|
2015-09-08 23:50:05 +08:00
|
|
|
case SymbolBody::SharedKind:
|
2015-08-14 21:52:36 +08:00
|
|
|
break;
|
2015-09-05 06:28:10 +08:00
|
|
|
case SymbolBody::LazyKind:
|
|
|
|
llvm_unreachable("Lazy symbol got to output symbol table!");
|
2015-08-14 21:52:36 +08:00
|
|
|
}
|
2015-08-25 23:53:17 +08:00
|
|
|
|
2015-09-05 03:42:14 +08:00
|
|
|
ESym->setBindingAndType(InputSym.getBinding(), InputSym.getType());
|
2015-09-02 04:30:52 +08:00
|
|
|
ESym->st_size = InputSym.st_size;
|
2015-09-05 03:42:14 +08:00
|
|
|
ESym->setVisibility(Body->getMostConstrainingVisibility());
|
2015-09-02 04:30:52 +08:00
|
|
|
if (InputSym.isAbsolute()) {
|
|
|
|
ESym->st_shndx = SHN_ABS;
|
|
|
|
ESym->st_value = InputSym.st_value;
|
2015-08-25 23:53:17 +08:00
|
|
|
}
|
2015-08-14 21:52:36 +08:00
|
|
|
|
2015-09-01 06:33:21 +08:00
|
|
|
if (Section)
|
|
|
|
Out = Section->getOutputSection();
|
|
|
|
|
|
|
|
if (Out) {
|
2015-08-25 04:06:32 +08:00
|
|
|
ESym->st_shndx = Out->getSectionIndex();
|
2015-08-25 23:53:17 +08:00
|
|
|
uintX_t VA = Out->getVA();
|
2015-09-01 06:33:21 +08:00
|
|
|
if (Section)
|
|
|
|
VA += Section->getOutputSectionOff();
|
2015-09-01 06:55:21 +08:00
|
|
|
if (auto *C = dyn_cast<DefinedCommon<ELFT>>(Body))
|
|
|
|
VA += C->OffsetInBSS;
|
|
|
|
else
|
2015-09-02 04:30:52 +08:00
|
|
|
VA += InputSym.st_value;
|
2015-08-25 23:53:17 +08:00
|
|
|
ESym->st_value = VA;
|
2015-08-25 04:06:32 +08:00
|
|
|
}
|
|
|
|
|
2015-08-14 21:07:05 +08:00
|
|
|
Buf += sizeof(Elf_Sym);
|
|
|
|
}
|
2015-08-28 10:46:41 +08:00
|
|
|
|
|
|
|
// The order the global symbols are in is not defined. We can use an arbitrary
|
|
|
|
// order, but it has to be reproducible. That is true even when cross linking.
|
|
|
|
// The default hashing of StringRef produces different results on 32 and 64
|
|
|
|
// bit systems so we sort by st_name. That is arbitrary but deterministic.
|
|
|
|
// FIXME: Experiment with passing in a custom hashing instead.
|
|
|
|
auto *Syms = reinterpret_cast<Elf_Sym *>(BufStart);
|
|
|
|
++Syms;
|
2015-09-02 04:36:51 +08:00
|
|
|
array_pod_sort(Syms, Syms + NumVisible, compareSym<ELFT>);
|
2015-08-14 21:07:05 +08:00
|
|
|
}
|
2015-08-14 10:42:20 +08:00
|
|
|
|
2015-08-14 02:37:23 +08:00
|
|
|
template <bool Is64Bits>
|
|
|
|
template <endianness E>
|
2015-08-14 06:14:37 +08:00
|
|
|
void OutputSectionBase<Is64Bits>::writeHeaderTo(
|
2015-08-14 02:37:23 +08:00
|
|
|
typename ELFFile<ELFType<E, Is64Bits>>::Elf_Shdr *SHdr) {
|
|
|
|
SHdr->sh_name = Header.sh_name;
|
|
|
|
SHdr->sh_type = Header.sh_type;
|
|
|
|
SHdr->sh_flags = Header.sh_flags;
|
|
|
|
SHdr->sh_addr = Header.sh_addr;
|
|
|
|
SHdr->sh_offset = Header.sh_offset;
|
|
|
|
SHdr->sh_size = Header.sh_size;
|
|
|
|
SHdr->sh_link = Header.sh_link;
|
|
|
|
SHdr->sh_info = Header.sh_info;
|
|
|
|
SHdr->sh_addralign = Header.sh_addralign;
|
|
|
|
SHdr->sh_entsize = Header.sh_entsize;
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2015-08-14 01:04:50 +08:00
|
|
|
namespace {
|
|
|
|
template <bool Is64Bits> struct SectionKey {
|
|
|
|
typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
|
|
|
|
StringRef Name;
|
|
|
|
uint32_t sh_type;
|
|
|
|
uintX_t sh_flags;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
namespace llvm {
|
|
|
|
template <bool Is64Bits> struct DenseMapInfo<SectionKey<Is64Bits>> {
|
|
|
|
static SectionKey<Is64Bits> getEmptyKey() {
|
|
|
|
return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0};
|
|
|
|
}
|
|
|
|
static SectionKey<Is64Bits> getTombstoneKey() {
|
|
|
|
return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0,
|
|
|
|
0};
|
|
|
|
}
|
|
|
|
static unsigned getHashValue(const SectionKey<Is64Bits> &Val) {
|
|
|
|
return hash_combine(Val.Name, Val.sh_type, Val.sh_flags);
|
|
|
|
}
|
|
|
|
static bool isEqual(const SectionKey<Is64Bits> &LHS,
|
|
|
|
const SectionKey<Is64Bits> &RHS) {
|
|
|
|
return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
|
|
|
|
LHS.sh_type == RHS.sh_type && LHS.sh_flags == RHS.sh_flags;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-09-01 08:16:38 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static bool cmpAlign(const DefinedCommon<ELFT> *A,
|
|
|
|
const DefinedCommon<ELFT> *B) {
|
2015-09-01 09:19:12 +08:00
|
|
|
return A->MaxAlignment > B->MaxAlignment;
|
2015-09-01 08:16:38 +08:00
|
|
|
}
|
|
|
|
|
2015-09-09 02:08:57 +08:00
|
|
|
template <bool Is64Bits>
|
|
|
|
static bool compSec(OutputSectionBase<Is64Bits> *A,
|
|
|
|
OutputSectionBase<Is64Bits> *B) {
|
|
|
|
// Place SHF_ALLOC sections first.
|
|
|
|
return (A->getFlags() & SHF_ALLOC) && !(B->getFlags() & SHF_ALLOC);
|
|
|
|
}
|
|
|
|
|
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-14 06:21:37 +08:00
|
|
|
SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSection<ELFT> *> Map;
|
2015-09-01 06:07:18 +08:00
|
|
|
auto getSection = [&](StringRef Name, uint32_t sh_type,
|
|
|
|
uintX_t sh_flags) -> OutputSection<ELFT> * {
|
|
|
|
SectionKey<ELFT::Is64Bits> Key{Name, sh_type, sh_flags};
|
|
|
|
OutputSection<ELFT> *&Sec = Map[Key];
|
|
|
|
if (!Sec) {
|
|
|
|
Sec = new (CAlloc.Allocate())
|
|
|
|
OutputSection<ELFT>(Key.Name, Key.sh_type, Key.sh_flags);
|
2015-09-09 02:08:57 +08:00
|
|
|
OutputSections.push_back(Sec);
|
2015-09-01 06:07:18 +08:00
|
|
|
}
|
|
|
|
return Sec;
|
|
|
|
};
|
|
|
|
|
2015-08-24 22:48:18 +08:00
|
|
|
const SymbolTable &Symtab = SymTable.getSymTable();
|
2015-09-04 02:56:20 +08:00
|
|
|
for (const std::unique_ptr<ObjectFileBase> &FileB : Symtab.getObjectFiles()) {
|
2015-08-05 21:55:34 +08:00
|
|
|
auto &File = cast<ObjectFile<ELFT>>(*FileB);
|
|
|
|
for (SectionChunk<ELFT> *C : File.getChunks()) {
|
2015-08-25 04:06:32 +08:00
|
|
|
if (!C)
|
|
|
|
continue;
|
2015-08-14 01:04:50 +08:00
|
|
|
const Elf_Shdr *H = C->getSectionHdr();
|
2015-09-01 06:07:18 +08:00
|
|
|
OutputSection<ELFT> *Sec =
|
|
|
|
getSection(C->getSectionName(), H->sh_type, H->sh_flags);
|
2015-08-14 01:35:13 +08:00
|
|
|
Sec->addChunk(C);
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
}
|
2015-09-01 06:07:18 +08:00
|
|
|
|
2015-09-01 06:33:21 +08:00
|
|
|
SymTable.BSSSec = getSection(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
|
|
|
|
OutputSection<ELFT> *BSSSec = SymTable.BSSSec;
|
2015-09-01 06:07:18 +08:00
|
|
|
// FIXME: Try to avoid the extra walk over all global symbols.
|
2015-09-02 04:36:51 +08:00
|
|
|
unsigned &NumVisible = SymTable.NumVisible;
|
2015-09-09 23:33:08 +08:00
|
|
|
llvm::StringTableBuilder &Builder = StrTabSec.StrTabBuilder;
|
2015-09-01 08:16:38 +08:00
|
|
|
std::vector<DefinedCommon<ELFT> *> CommonSymbols;
|
2015-09-01 06:07:18 +08:00
|
|
|
for (auto &P : Symtab.getSymbols()) {
|
2015-09-02 05:47:21 +08:00
|
|
|
StringRef Name = P.first;
|
2015-09-01 06:07:18 +08:00
|
|
|
SymbolBody *Body = P.second->Body;
|
2015-09-01 08:16:38 +08:00
|
|
|
if (auto *C = dyn_cast<DefinedCommon<ELFT>>(Body))
|
|
|
|
CommonSymbols.push_back(C);
|
2015-09-08 23:50:05 +08:00
|
|
|
if (!includeInSymtab(*Body))
|
2015-09-02 05:47:21 +08:00
|
|
|
continue;
|
|
|
|
NumVisible++;
|
|
|
|
Builder.add(Name);
|
2015-09-01 08:16:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Sort the common symbols by alignment as an heuristic to pack them better.
|
|
|
|
std::stable_sort(CommonSymbols.begin(), CommonSymbols.end(), cmpAlign<ELFT>);
|
|
|
|
uintX_t Off = BSSSec->getSize();
|
|
|
|
for (DefinedCommon<ELFT> *C : CommonSymbols) {
|
2015-09-01 06:07:18 +08:00
|
|
|
const Elf_Sym &Sym = C->Sym;
|
2015-09-01 09:19:12 +08:00
|
|
|
uintX_t Align = C->MaxAlignment;
|
2015-09-01 06:07:18 +08:00
|
|
|
Off = RoundUpToAlignment(Off, Align);
|
2015-09-01 06:55:21 +08:00
|
|
|
C->OffsetInBSS = Off;
|
2015-09-01 06:07:18 +08:00
|
|
|
Off += Sym.st_size;
|
|
|
|
}
|
2015-09-01 08:16:38 +08:00
|
|
|
|
2015-09-01 06:07:18 +08:00
|
|
|
BSSSec->setSize(Off);
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-09-09 02:08:57 +08:00
|
|
|
OutputSections.push_back(&SymTable);
|
2015-09-09 23:33:08 +08:00
|
|
|
OutputSections.push_back(&StrTabSec);
|
2015-09-09 02:08:57 +08:00
|
|
|
|
2015-09-09 03:43:27 +08:00
|
|
|
const std::vector<std::unique_ptr<SharedFileBase>> &SharedFiles =
|
|
|
|
Symtab.getSharedFiles();
|
2015-09-09 23:33:08 +08:00
|
|
|
if (!SharedFiles.empty()) {
|
2015-09-09 03:43:27 +08:00
|
|
|
OutputSections.push_back(&DynamicSec);
|
2015-09-09 23:33:08 +08:00
|
|
|
OutputSections.push_back(&DynStrSec);
|
|
|
|
}
|
2015-09-09 03:43:27 +08:00
|
|
|
|
2015-09-09 02:08:57 +08:00
|
|
|
std::stable_sort(OutputSections.begin(), OutputSections.end(),
|
|
|
|
compSec<ELFT::Is64Bits>);
|
|
|
|
for (unsigned I = 0, N = OutputSections.size(); I < N; ++I)
|
|
|
|
OutputSections[I]->setSectionIndex(I + 1);
|
2015-08-13 23:23:46 +08:00
|
|
|
}
|
|
|
|
|
2015-09-10 04:48:09 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static bool outputSectionHasPHDR(OutputSectionBase<ELFT::Is64Bits> *Sec) {
|
|
|
|
return (Sec->getSize() != 0) && (Sec->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-08-12 07:14:13 +08:00
|
|
|
uintX_t VA = 0x1000; // The first page is kept unmapped.
|
2015-09-10 04:48:09 +08:00
|
|
|
uintX_t FileOff = sizeof(Elf_Ehdr);
|
|
|
|
|
|
|
|
// Reserve space for PHDRs.
|
|
|
|
ProgramHeaderOff = FileOff;
|
|
|
|
FileOff = RoundUpToAlignment(FileOff, PageSize);
|
2015-08-13 23:23:46 +08:00
|
|
|
|
2015-09-10 04:48:09 +08:00
|
|
|
NumPhdrs = 0;
|
2015-08-14 06:14:37 +08:00
|
|
|
for (OutputSectionBase<ELFT::Is64Bits> *Sec : OutputSections) {
|
2015-09-09 23:33:08 +08:00
|
|
|
StrTabSec.add(Sec->getName());
|
2015-08-14 06:14:37 +08:00
|
|
|
Sec->finalize();
|
|
|
|
|
2015-09-10 04:48:09 +08:00
|
|
|
// Since each output section gets its own PHDR, align each output section to
|
|
|
|
// a page.
|
|
|
|
if (outputSectionHasPHDR<ELFT>(Sec)) {
|
|
|
|
++NumPhdrs;
|
|
|
|
VA = RoundUpToAlignment(VA, PageSize);
|
|
|
|
FileOff = RoundUpToAlignment(FileOff, PageSize);
|
|
|
|
}
|
|
|
|
|
2015-08-14 04:24:18 +08:00
|
|
|
uintX_t Align = Sec->getAlign();
|
|
|
|
uintX_t Size = Sec->getSize();
|
2015-08-13 23:31:17 +08:00
|
|
|
if (Sec->getFlags() & SHF_ALLOC) {
|
|
|
|
Sec->setVA(VA);
|
2015-08-14 04:24:18 +08:00
|
|
|
VA += RoundUpToAlignment(Size, Align);
|
2015-08-13 23:31:17 +08:00
|
|
|
}
|
2015-07-25 05:03:07 +08:00
|
|
|
Sec->setFileOffset(FileOff);
|
2015-09-01 04:23:57 +08:00
|
|
|
if (Sec->getType() != SHT_NOBITS)
|
|
|
|
FileOff += RoundUpToAlignment(Size, Align);
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
2015-08-12 08:00:24 +08:00
|
|
|
|
2015-09-10 04:48:09 +08:00
|
|
|
// Add a PHDR for the dynamic table.
|
|
|
|
if (!SymTable.getSymTable().getSharedFiles().empty())
|
|
|
|
++NumPhdrs;
|
|
|
|
|
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-09-09 05:57:31 +08:00
|
|
|
FileOff += getNumSections() * sizeof(Elf_Shdr);
|
2015-09-10 04:48:09 +08:00
|
|
|
FileSize = FileOff;
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2015-09-10 04:48:09 +08:00
|
|
|
static uint32_t convertSectionFlagsToPHDRFlags(uint64_t Flags) {
|
2015-09-09 06:55:28 +08:00
|
|
|
uint32_t Ret = PF_R;
|
|
|
|
if (Flags & SHF_WRITE)
|
|
|
|
Ret |= PF_W;
|
|
|
|
|
|
|
|
if (Flags & SHF_EXECINSTR)
|
|
|
|
Ret |= PF_X;
|
|
|
|
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::writeHeader() {
|
|
|
|
uint8_t *Buf = Buffer->getBufferStart();
|
2015-09-09 05:57:31 +08:00
|
|
|
auto *EHdr = reinterpret_cast<Elf_Ehdr *>(Buf);
|
2015-07-25 05:03:07 +08:00
|
|
|
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
|
|
|
|
2015-09-09 06:55:28 +08:00
|
|
|
// FIXME: Generalize the segment construction similar to how we create
|
|
|
|
// output sections.
|
2015-08-24 22:48:18 +08:00
|
|
|
const SymbolTable &Symtab = SymTable.getSymTable();
|
2015-09-10 04:48:09 +08:00
|
|
|
bool HasDynamicSegment = !Symtab.getSharedFiles().empty();
|
2015-09-09 06:55:28 +08:00
|
|
|
|
|
|
|
EHdr->e_type = ET_EXEC;
|
2015-09-04 04:03:54 +08:00
|
|
|
auto &FirstObj = cast<ObjectFile<ELFT>>(*Symtab.getFirstELF());
|
|
|
|
EHdr->e_machine = FirstObj.getEMachine();
|
2015-07-25 05:03:07 +08:00
|
|
|
EHdr->e_version = EV_CURRENT;
|
2015-09-09 06:51:46 +08:00
|
|
|
EHdr->e_entry = getSymVA(cast<DefinedRegular<ELFT>>(Symtab.getEntrySym()));
|
2015-09-10 04:48:09 +08:00
|
|
|
EHdr->e_phoff = ProgramHeaderOff;
|
2015-07-29 08:30:10 +08:00
|
|
|
EHdr->e_shoff = SectionHeaderOff;
|
2015-09-09 05:57:31 +08:00
|
|
|
EHdr->e_ehsize = sizeof(Elf_Ehdr);
|
|
|
|
EHdr->e_phentsize = sizeof(Elf_Phdr);
|
2015-09-10 04:48:09 +08:00
|
|
|
EHdr->e_phnum = NumPhdrs;
|
2015-09-09 05:57:31 +08:00
|
|
|
EHdr->e_shentsize = sizeof(Elf_Shdr);
|
2015-09-09 01:39:39 +08:00
|
|
|
EHdr->e_shnum = getNumSections();
|
2015-09-09 23:33:08 +08:00
|
|
|
EHdr->e_shstrndx = StrTabSec.getSectionIndex();
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-09-09 05:57:31 +08:00
|
|
|
auto PHdrs = reinterpret_cast<Elf_Phdr *>(Buf + EHdr->e_phoff);
|
2015-09-10 04:48:09 +08:00
|
|
|
for (OutputSectionBase<ELFT::Is64Bits> *Sec : OutputSections) {
|
|
|
|
if (!outputSectionHasPHDR<ELFT>(Sec))
|
|
|
|
continue;
|
|
|
|
PHdrs->p_type = PT_LOAD;
|
|
|
|
PHdrs->p_flags = convertSectionFlagsToPHDRFlags(Sec->getFlags());
|
|
|
|
PHdrs->p_offset = Sec->getFileOff();
|
|
|
|
PHdrs->p_vaddr = Sec->getVA();
|
|
|
|
PHdrs->p_paddr = PHdrs->p_vaddr;
|
|
|
|
PHdrs->p_filesz = Sec->getType() == SHT_NOBITS ? 0 : Sec->getSize();
|
|
|
|
PHdrs->p_memsz = Sec->getSize();
|
|
|
|
PHdrs->p_align = PageSize;
|
|
|
|
++PHdrs;
|
|
|
|
}
|
2015-07-29 08:30:10 +08:00
|
|
|
|
2015-09-09 06:55:28 +08:00
|
|
|
if (HasDynamicSegment) {
|
|
|
|
PHdrs->p_type = PT_DYNAMIC;
|
2015-09-10 04:48:09 +08:00
|
|
|
PHdrs->p_flags = convertSectionFlagsToPHDRFlags(DynamicSec.getFlags());
|
2015-09-09 06:55:28 +08:00
|
|
|
PHdrs->p_offset = DynamicSec.getFileOff();
|
|
|
|
PHdrs->p_vaddr = DynamicSec.getVA();
|
|
|
|
PHdrs->p_paddr = PHdrs->p_vaddr;
|
2015-09-09 23:33:08 +08:00
|
|
|
PHdrs->p_filesz = DynamicSec.getSize();
|
|
|
|
PHdrs->p_memsz = DynamicSec.getSize();
|
2015-09-09 06:55:28 +08:00
|
|
|
PHdrs->p_align = DynamicSec.getAlign();
|
|
|
|
}
|
|
|
|
|
2015-09-09 05:57:31 +08:00
|
|
|
auto SHdrs = reinterpret_cast<Elf_Shdr *>(Buf + EHdr->e_shoff);
|
2015-07-29 08:30:10 +08:00
|
|
|
// First entry is null.
|
|
|
|
++SHdrs;
|
2015-08-14 06:14:37 +08:00
|
|
|
for (OutputSectionBase<ELFT::Is64Bits> *Sec : OutputSections) {
|
2015-09-09 23:33:08 +08:00
|
|
|
Sec->setNameOffset(StrTabSec.getFileOff(Sec->getName()));
|
2015-08-14 02:37:23 +08:00
|
|
|
Sec->template writeHeaderTo<ELFT::TargetEndianness>(SHdrs++);
|
2015-08-12 08:00:24 +08:00
|
|
|
}
|
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-14 06:14:37 +08:00
|
|
|
for (OutputSectionBase<ELFT::Is64Bits> *Sec : OutputSections)
|
2015-08-14 13:17:30 +08:00
|
|
|
Sec->writeTo(Buf + Sec->getFileOff());
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|