2015-07-25 05:03:07 +08:00
|
|
|
//===- Writer.cpp ---------------------------------------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// 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
|
2015-07-25 05:03:07 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-09-05 06:48:30 +08:00
|
|
|
#include "Writer.h"
|
2017-12-05 23:59:05 +08:00
|
|
|
#include "AArch64ErrataFix.h"
|
2018-04-18 07:30:05 +08:00
|
|
|
#include "CallGraphSort.h"
|
2015-08-06 07:51:50 +08:00
|
|
|
#include "Config.h"
|
2016-02-12 05:17:59 +08:00
|
|
|
#include "LinkerScript.h"
|
2017-01-14 05:05:46 +08:00
|
|
|
#include "MapFile.h"
|
2015-09-22 05:38:08 +08:00
|
|
|
#include "OutputSections.h"
|
2016-05-25 04:24:43 +08:00
|
|
|
#include "Relocations.h"
|
2015-08-06 07:24:46 +08:00
|
|
|
#include "SymbolTable.h"
|
2017-12-10 00:56:18 +08:00
|
|
|
#include "Symbols.h"
|
2016-11-02 04:28:21 +08:00
|
|
|
#include "SyntheticSections.h"
|
2015-09-23 02:19:46 +08:00
|
|
|
#include "Target.h"
|
2019-03-12 00:30:55 +08:00
|
|
|
#include "lld/Common/Filesystem.h"
|
2017-11-29 04:39:17 +08:00
|
|
|
#include "lld/Common/Memory.h"
|
2018-03-01 01:38:19 +08:00
|
|
|
#include "lld/Common/Strings.h"
|
2017-10-14 02:22:55 +08:00
|
|
|
#include "lld/Common/Threads.h"
|
2015-11-12 17:52:08 +08:00
|
|
|
#include "llvm/ADT/StringMap.h"
|
2015-10-13 04:51:48 +08:00
|
|
|
#include "llvm/ADT/StringSwitch.h"
|
2016-09-29 09:45:22 +08:00
|
|
|
#include <climits>
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::ELF;
|
|
|
|
using namespace llvm::object;
|
2016-10-10 17:39:26 +08:00
|
|
|
using namespace llvm::support;
|
|
|
|
using namespace llvm::support::endian;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
using namespace lld;
|
2016-02-28 08:25:54 +08:00
|
|
|
using namespace lld::elf;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-08-06 07:24:46 +08:00
|
|
|
namespace {
|
|
|
|
// The writer writes a SymbolTable result to a file.
|
|
|
|
template <class ELFT> class Writer {
|
|
|
|
public:
|
2017-11-14 02:06:43 +08:00
|
|
|
Writer() : Buffer(errorHandler().OutputBuffer) {}
|
2019-04-01 08:11:24 +08:00
|
|
|
using Elf_Shdr = typename ELFT::Shdr;
|
|
|
|
using Elf_Ehdr = typename ELFT::Ehdr;
|
|
|
|
using Elf_Phdr = typename ELFT::Phdr;
|
2017-04-06 05:46:06 +08:00
|
|
|
|
2015-08-06 07:24:46 +08:00
|
|
|
void run();
|
|
|
|
|
|
|
|
private:
|
2015-10-09 07:49:30 +08:00
|
|
|
void copyLocalSymbols();
|
2017-02-11 09:40:49 +08:00
|
|
|
void addSectionSymbols();
|
2018-06-16 20:11:34 +08:00
|
|
|
void forEachRelSec(llvm::function_ref<void(InputSectionBase &)> Fn);
|
2016-09-22 06:36:19 +08:00
|
|
|
void sortSections();
|
2017-12-12 21:30:44 +08:00
|
|
|
void resolveShfLinkOrder();
|
2018-10-24 06:03:33 +08:00
|
|
|
void maybeAddThunks();
|
2017-10-30 18:12:49 +08:00
|
|
|
void sortInputSections();
|
2016-07-20 22:43:20 +08:00
|
|
|
void finalizeSections();
|
2018-10-24 22:24:01 +08:00
|
|
|
void checkExecuteOnly();
|
2017-09-13 00:38:01 +08:00
|
|
|
void setReservedSymbolSections();
|
2015-12-25 15:38:58 +08:00
|
|
|
|
2017-07-27 15:46:50 +08:00
|
|
|
std::vector<PhdrEntry *> createPhdrs();
|
2016-12-06 21:43:34 +08:00
|
|
|
void removeEmptyPTLoad();
|
2019-02-20 22:47:02 +08:00
|
|
|
void addPhdrForSection(std::vector<PhdrEntry *> &Phdrs, unsigned ShType,
|
|
|
|
unsigned PType, unsigned PFlags);
|
2016-04-02 01:07:17 +08:00
|
|
|
void assignFileOffsets();
|
2016-08-25 17:05:47 +08:00
|
|
|
void assignFileOffsetsBinary();
|
2016-04-02 01:07:17 +08:00
|
|
|
void setPhdrs();
|
2018-04-04 17:24:31 +08:00
|
|
|
void checkSections();
|
2016-03-31 03:41:51 +08:00
|
|
|
void fixSectionAlignments();
|
2016-04-02 01:24:19 +08:00
|
|
|
void openFile();
|
2017-08-03 00:35:00 +08:00
|
|
|
void writeTrapInstr();
|
2015-08-06 07:24:46 +08:00
|
|
|
void writeHeader();
|
|
|
|
void writeSections();
|
2016-08-25 17:05:47 +08:00
|
|
|
void writeSectionsBinary();
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
void writeBuildId();
|
2015-08-06 07:24:46 +08:00
|
|
|
|
2017-11-14 02:06:43 +08:00
|
|
|
std::unique_ptr<FileOutputBuffer> &Buffer;
|
2015-09-18 03:58:07 +08:00
|
|
|
|
2015-12-26 17:47:57 +08:00
|
|
|
void addRelIpltSymbols();
|
2015-12-26 17:48:00 +08:00
|
|
|
void addStartEndSymbols();
|
2017-02-24 23:07:30 +08:00
|
|
|
void addStartStopSymbols(OutputSection *Sec);
|
2015-10-11 06:34:30 +08:00
|
|
|
|
2017-07-27 15:46:50 +08:00
|
|
|
std::vector<PhdrEntry *> Phdrs;
|
2015-09-18 03:58:07 +08:00
|
|
|
|
2019-03-02 02:53:41 +08:00
|
|
|
uint64_t FileSize;
|
2017-04-06 05:37:09 +08:00
|
|
|
uint64_t SectionHeaderOff;
|
2015-08-06 07:24:46 +08:00
|
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
|
2018-05-09 07:19:50 +08:00
|
|
|
static bool isSectionPrefix(StringRef Prefix, StringRef Name) {
|
|
|
|
return Name.startswith(Prefix) || Name == Prefix.drop_back();
|
|
|
|
}
|
|
|
|
|
2018-05-23 09:58:43 +08:00
|
|
|
StringRef elf::getOutputSectionName(const InputSectionBase *S) {
|
2016-10-05 18:10:45 +08:00
|
|
|
if (Config->Relocatable)
|
2017-12-01 17:14:56 +08:00
|
|
|
return S->Name;
|
2016-10-05 18:10:45 +08:00
|
|
|
|
2017-12-01 17:04:52 +08:00
|
|
|
// This is for --emit-relocs. If .text.foo is emitted as .text.bar, we want
|
|
|
|
// to emit .rela.text.foo as .rela.text.bar for consistency (this is not
|
|
|
|
// technically required, but not doing it is odd). This code guarantees that.
|
2018-03-27 02:49:31 +08:00
|
|
|
if (auto *IS = dyn_cast<InputSection>(S)) {
|
|
|
|
if (InputSectionBase *Rel = IS->getRelocatedSection()) {
|
|
|
|
OutputSection *Out = Rel->getOutputSection();
|
|
|
|
if (S->Type == SHT_RELA)
|
|
|
|
return Saver.save(".rela" + Out->Name);
|
|
|
|
return Saver.save(".rel" + Out->Name);
|
|
|
|
}
|
2017-12-01 17:04:52 +08:00
|
|
|
}
|
2017-10-27 19:38:31 +08:00
|
|
|
|
2018-05-09 07:19:50 +08:00
|
|
|
// This check is for -z keep-text-section-prefix. This option separates text
|
|
|
|
// sections with prefix ".text.hot", ".text.unlikely", ".text.startup" or
|
|
|
|
// ".text.exit".
|
|
|
|
// When enabled, this allows identifying the hot code region (.text.hot) in
|
|
|
|
// the final binary which can be selectively mapped to huge pages or mlocked,
|
|
|
|
// for instance.
|
|
|
|
if (Config->ZKeepTextSectionPrefix)
|
|
|
|
for (StringRef V :
|
2018-09-11 21:41:58 +08:00
|
|
|
{".text.hot.", ".text.unlikely.", ".text.startup.", ".text.exit."})
|
2018-05-09 07:19:50 +08:00
|
|
|
if (isSectionPrefix(V, S->Name))
|
|
|
|
return V.drop_back();
|
|
|
|
|
2016-09-20 03:59:21 +08:00
|
|
|
for (StringRef V :
|
2017-03-17 18:14:53 +08:00
|
|
|
{".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.rel.ro.",
|
|
|
|
".bss.", ".init_array.", ".fini_array.", ".ctors.", ".dtors.", ".tbss.",
|
2018-09-11 21:41:58 +08:00
|
|
|
".gcc_except_table.", ".tdata.", ".ARM.exidx.", ".ARM.extab."})
|
2018-05-09 07:19:50 +08:00
|
|
|
if (isSectionPrefix(V, S->Name))
|
|
|
|
return V.drop_back();
|
2016-10-13 06:36:31 +08:00
|
|
|
|
2016-11-06 07:05:47 +08:00
|
|
|
// CommonSection is identified as "COMMON" in linker scripts.
|
|
|
|
// By default, it should go to .bss section.
|
2017-12-01 17:14:56 +08:00
|
|
|
if (S->Name == "COMMON")
|
2016-11-06 07:05:47 +08:00
|
|
|
return ".bss";
|
|
|
|
|
2017-12-01 17:14:56 +08:00
|
|
|
return S->Name;
|
2016-07-12 16:50:42 +08:00
|
|
|
}
|
|
|
|
|
2017-09-19 17:20:54 +08:00
|
|
|
static bool needsInterpSection() {
|
|
|
|
return !SharedFiles.empty() && !Config->DynamicLinker.empty() &&
|
2017-10-08 11:52:15 +08:00
|
|
|
Script->needsInterpSection();
|
2016-07-21 19:01:23 +08:00
|
|
|
}
|
|
|
|
|
2016-11-14 18:14:18 +08:00
|
|
|
template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
|
2015-10-08 03:18:16 +08:00
|
|
|
|
2016-12-06 21:43:34 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::removeEmptyPTLoad() {
|
2017-08-28 17:28:15 +08:00
|
|
|
llvm::erase_if(Phdrs, [&](const PhdrEntry *P) {
|
2017-07-27 15:46:50 +08:00
|
|
|
if (P->p_type != PT_LOAD)
|
2016-12-06 21:43:34 +08:00
|
|
|
return false;
|
2017-09-07 19:01:10 +08:00
|
|
|
if (!P->FirstSec)
|
2016-12-08 11:17:05 +08:00
|
|
|
return true;
|
2017-09-07 19:01:10 +08:00
|
|
|
uint64_t Size = P->LastSec->Addr + P->LastSec->Size - P->FirstSec->Addr;
|
2016-12-06 21:43:34 +08:00
|
|
|
return Size == 0;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-04-02 02:01:18 +08:00
|
|
|
template <class ELFT> static void combineEhSections() {
|
2017-03-11 04:00:42 +08:00
|
|
|
for (InputSectionBase *&S : InputSections) {
|
2019-04-02 02:01:18 +08:00
|
|
|
if (!S->Live)
|
2017-03-11 04:00:42 +08:00
|
|
|
continue;
|
|
|
|
|
2019-04-02 02:01:18 +08:00
|
|
|
if (auto *ES = dyn_cast<EhInputSection>(S)) {
|
|
|
|
In.EhFrame->addSection<ELFT>(ES);
|
|
|
|
S = nullptr;
|
|
|
|
} else if (S->kind() == SectionBase::Regular && In.ARMExidx &&
|
|
|
|
In.ARMExidx->addSection(cast<InputSection>(S))) {
|
|
|
|
S = nullptr;
|
|
|
|
}
|
2017-03-11 04:00:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<InputSectionBase *> &V = InputSections;
|
|
|
|
V.erase(std::remove(V.begin(), V.end(), nullptr), V.end());
|
|
|
|
}
|
|
|
|
|
2017-12-09 03:13:27 +08:00
|
|
|
static Defined *addOptionalRegular(StringRef Name, SectionBase *Sec,
|
|
|
|
uint64_t Val, uint8_t StOther = STV_HIDDEN,
|
|
|
|
uint8_t Binding = STB_GLOBAL) {
|
|
|
|
Symbol *S = Symtab->find(Name);
|
|
|
|
if (!S || S->isDefined())
|
|
|
|
return nullptr;
|
2018-11-22 19:40:08 +08:00
|
|
|
return Symtab->addDefined(Name, StOther, STT_NOTYPE, Val,
|
|
|
|
/*Size=*/0, Binding, Sec,
|
|
|
|
/*File=*/nullptr);
|
2017-12-09 03:13:27 +08:00
|
|
|
}
|
|
|
|
|
2018-10-20 19:12:50 +08:00
|
|
|
static Defined *addAbsolute(StringRef Name) {
|
2018-11-22 19:40:08 +08:00
|
|
|
return Symtab->addDefined(Name, STV_HIDDEN, STT_NOTYPE, 0, 0, STB_GLOBAL,
|
|
|
|
nullptr, nullptr);
|
2018-10-24 15:42:06 +08:00
|
|
|
}
|
2018-10-20 19:12:50 +08:00
|
|
|
|
2017-12-09 03:13:27 +08:00
|
|
|
// The linker is expected to define some symbols depending on
|
|
|
|
// the linking result. This function defines such symbols.
|
2017-12-24 01:21:39 +08:00
|
|
|
void elf::addReservedSymbols() {
|
2017-12-09 03:13:27 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
|
|
|
// Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
|
|
|
|
// so that it points to an absolute address which by default is relative
|
|
|
|
// to GOT. Default offset is 0x7ff0.
|
|
|
|
// See "Global Data Symbols" in Chapter 6 in the following document:
|
|
|
|
// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
|
2018-10-20 19:12:50 +08:00
|
|
|
ElfSym::MipsGp = addAbsolute("_gp");
|
2017-12-09 03:13:27 +08:00
|
|
|
|
|
|
|
// On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
|
|
|
|
// start of function and 'gp' pointer into GOT.
|
|
|
|
if (Symtab->find("_gp_disp"))
|
2018-10-20 19:12:50 +08:00
|
|
|
ElfSym::MipsGpDisp = addAbsolute("_gp_disp");
|
2017-12-09 03:13:27 +08:00
|
|
|
|
|
|
|
// The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
|
|
|
|
// pointer. This symbol is used in the code generated by .cpload pseudo-op
|
|
|
|
// in case of using -mno-shared option.
|
|
|
|
// https://sourceware.org/ml/binutils/2004-12/msg00094.html
|
|
|
|
if (Symtab->find("__gnu_local_gp"))
|
2018-10-20 19:12:50 +08:00
|
|
|
ElfSym::MipsLocalGp = addAbsolute("__gnu_local_gp");
|
2017-12-09 03:13:27 +08:00
|
|
|
}
|
|
|
|
|
2018-05-17 13:34:29 +08:00
|
|
|
// The Power Architecture 64-bit v2 ABI defines a TableOfContents (TOC) which
|
|
|
|
// combines the typical ELF GOT with the small data sections. It commonly
|
|
|
|
// includes .got .toc .sdata .sbss. The .TOC. symbol replaces both
|
|
|
|
// _GLOBAL_OFFSET_TABLE_ and _SDA_BASE_ from the 32-bit ABI. It is used to
|
|
|
|
// represent the TOC base which is offset by 0x8000 bytes from the start of
|
|
|
|
// the .got section.
|
2018-11-29 19:18:07 +08:00
|
|
|
// We do not allow _GLOBAL_OFFSET_TABLE_ to be defined by input objects as the
|
|
|
|
// correctness of some relocations depends on its value.
|
2019-03-29 01:38:53 +08:00
|
|
|
StringRef GotSymName =
|
2018-11-29 19:18:07 +08:00
|
|
|
(Config->EMachine == EM_PPC64) ? ".TOC." : "_GLOBAL_OFFSET_TABLE_";
|
2019-03-29 01:38:53 +08:00
|
|
|
|
|
|
|
if (Symbol *S = Symtab->find(GotSymName)) {
|
|
|
|
if (S->isDefined()) {
|
2018-11-29 19:18:07 +08:00
|
|
|
error(toString(S->File) + " cannot redefine linker defined symbol '" +
|
2019-03-29 01:38:53 +08:00
|
|
|
GotSymName + "'");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t GotOff = 0;
|
|
|
|
if (Config->EMachine == EM_PPC || Config->EMachine == EM_PPC64)
|
|
|
|
GotOff = 0x8000;
|
|
|
|
|
|
|
|
ElfSym::GlobalOffsetTable =
|
|
|
|
Symtab->addDefined(GotSymName, STV_HIDDEN, STT_NOTYPE, GotOff,
|
|
|
|
/*Size=*/0, STB_GLOBAL, Out::ElfHeader,
|
|
|
|
/*File=*/nullptr);
|
2018-11-29 19:18:07 +08:00
|
|
|
}
|
2017-12-09 03:13:27 +08:00
|
|
|
|
|
|
|
// __ehdr_start is the location of ELF file headers. Note that we define
|
|
|
|
// this symbol unconditionally even when using a linker script, which
|
|
|
|
// differs from the behavior implemented by GNU linker which only define
|
|
|
|
// this symbol if ELF headers are in the memory mapped segment.
|
2018-03-29 06:09:40 +08:00
|
|
|
addOptionalRegular("__ehdr_start", Out::ElfHeader, 0, STV_HIDDEN);
|
|
|
|
|
2017-12-09 03:13:27 +08:00
|
|
|
// __executable_start is not documented, but the expectation of at
|
2018-03-29 06:09:40 +08:00
|
|
|
// least the Android libc is that it points to the ELF header.
|
|
|
|
addOptionalRegular("__executable_start", Out::ElfHeader, 0, STV_HIDDEN);
|
|
|
|
|
2017-12-09 03:13:27 +08:00
|
|
|
// __dso_handle symbol is passed to cxa_finalize as a marker to identify
|
|
|
|
// each DSO. The address of the symbol doesn't matter as long as they are
|
|
|
|
// different in different DSOs, so we chose the start address of the DSO.
|
2018-03-29 06:09:40 +08:00
|
|
|
addOptionalRegular("__dso_handle", Out::ElfHeader, 0, STV_HIDDEN);
|
2017-12-09 03:13:27 +08:00
|
|
|
|
|
|
|
// If linker script do layout we do not need to create any standart symbols.
|
|
|
|
if (Script->HasSectionsCommand)
|
|
|
|
return;
|
|
|
|
|
|
|
|
auto Add = [](StringRef S, int64_t Pos) {
|
2017-12-24 01:21:39 +08:00
|
|
|
return addOptionalRegular(S, Out::ElfHeader, Pos, STV_DEFAULT);
|
2017-12-09 03:13:27 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
ElfSym::Bss = Add("__bss_start", 0);
|
|
|
|
ElfSym::End1 = Add("end", -1);
|
|
|
|
ElfSym::End2 = Add("_end", -1);
|
|
|
|
ElfSym::Etext1 = Add("etext", -1);
|
|
|
|
ElfSym::Etext2 = Add("_etext", -1);
|
|
|
|
ElfSym::Edata1 = Add("edata", -1);
|
|
|
|
ElfSym::Edata2 = Add("_edata", -1);
|
|
|
|
}
|
|
|
|
|
2017-12-09 05:44:11 +08:00
|
|
|
static OutputSection *findSection(StringRef Name) {
|
|
|
|
for (BaseCommand *Base : Script->SectionCommands)
|
|
|
|
if (auto *Sec = dyn_cast<OutputSection>(Base))
|
|
|
|
if (Sec->Name == Name)
|
|
|
|
return Sec;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2017-02-27 10:31:26 +08:00
|
|
|
// Initialize Out members.
|
2017-12-09 05:50:29 +08:00
|
|
|
template <class ELFT> static void createSyntheticSections() {
|
2016-11-02 07:17:45 +08:00
|
|
|
// Initialize all pointers with NULL. This is needed because
|
|
|
|
// you can call lld::elf::main more than once as a library.
|
2017-02-27 10:31:26 +08:00
|
|
|
memset(&Out::First, 0, sizeof(Out));
|
2016-11-02 07:17:45 +08:00
|
|
|
|
2017-02-27 10:32:08 +08:00
|
|
|
auto Add = [](InputSectionBase *Sec) { InputSections.push_back(Sec); };
|
2017-02-05 13:18:58 +08:00
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
In.DynStrTab = make<StringTableSection>(".dynstr", true);
|
|
|
|
In.Dynamic = make<DynamicSection<ELFT>>();
|
2017-10-28 01:49:40 +08:00
|
|
|
if (Config->AndroidPackDynRelocs) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.RelaDyn = make<AndroidPackedRelocationSection<ELFT>>(
|
2017-10-28 01:49:40 +08:00
|
|
|
Config->IsRela ? ".rela.dyn" : ".rel.dyn");
|
|
|
|
} else {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.RelaDyn = make<RelocationSection<ELFT>>(
|
2017-10-28 01:49:40 +08:00
|
|
|
Config->IsRela ? ".rela.dyn" : ".rel.dyn", Config->ZCombreloc);
|
|
|
|
}
|
2018-09-26 03:26:58 +08:00
|
|
|
In.ShStrTab = make<StringTableSection>(".shstrtab", false);
|
2016-11-02 07:17:45 +08:00
|
|
|
|
2017-02-27 10:31:26 +08:00
|
|
|
Out::ProgramHeaders = make<OutputSection>("", 0, SHF_ALLOC);
|
2017-10-07 08:58:34 +08:00
|
|
|
Out::ProgramHeaders->Alignment = Config->Wordsize;
|
2016-11-02 07:17:45 +08:00
|
|
|
|
2019-02-20 10:32:53 +08:00
|
|
|
if (needsInterpSection())
|
|
|
|
Add(createInterpSection());
|
2016-11-02 07:17:45 +08:00
|
|
|
|
|
|
|
if (Config->Strip != StripPolicy::All) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.StrTab = make<StringTableSection>(".strtab", false);
|
|
|
|
In.SymTab = make<SymbolTableSection<ELFT>>(*In.StrTab);
|
|
|
|
In.SymTabShndx = make<SymtabShndxSection>();
|
2016-11-02 07:17:45 +08:00
|
|
|
}
|
|
|
|
|
2016-11-22 08:54:15 +08:00
|
|
|
if (Config->BuildId != BuildIdKind::None) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.BuildId = make<BuildIdSection>();
|
|
|
|
Add(In.BuildId);
|
2016-11-22 08:54:15 +08:00
|
|
|
}
|
2016-11-06 07:05:47 +08:00
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
In.Bss = make<BssSection>(".bss", 0, 1);
|
|
|
|
Add(In.Bss);
|
2017-11-24 16:48:29 +08:00
|
|
|
|
|
|
|
// If there is a SECTIONS command and a .data.rel.ro section name use name
|
|
|
|
// .data.rel.ro.bss so that we match in the .data.rel.ro output section.
|
|
|
|
// This makes sure our relro is contiguous.
|
2018-03-22 21:47:56 +08:00
|
|
|
bool HasDataRelRo = Script->HasSectionsCommand && findSection(".data.rel.ro");
|
2018-09-26 03:26:58 +08:00
|
|
|
In.BssRelRo =
|
2018-03-22 21:47:56 +08:00
|
|
|
make<BssSection>(HasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
|
2018-09-26 03:26:58 +08:00
|
|
|
Add(In.BssRelRo);
|
2017-03-17 18:14:53 +08:00
|
|
|
|
2016-11-22 12:28:39 +08:00
|
|
|
// Add MIPS-specific sections.
|
2016-11-10 05:36:56 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
2017-09-16 02:05:02 +08:00
|
|
|
if (!Config->Shared && Config->HasDynSymTab) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.MipsRldMap = make<MipsRldMapSection>();
|
|
|
|
Add(In.MipsRldMap);
|
2016-11-23 01:49:14 +08:00
|
|
|
}
|
2016-11-22 12:28:39 +08:00
|
|
|
if (auto *Sec = MipsAbiFlagsSection<ELFT>::create())
|
2017-02-05 13:18:58 +08:00
|
|
|
Add(Sec);
|
2016-11-22 12:28:39 +08:00
|
|
|
if (auto *Sec = MipsOptionsSection<ELFT>::create())
|
2017-02-05 13:18:58 +08:00
|
|
|
Add(Sec);
|
2016-11-22 12:28:39 +08:00
|
|
|
if (auto *Sec = MipsReginfoSection<ELFT>::create())
|
2017-02-05 13:18:58 +08:00
|
|
|
Add(Sec);
|
2016-11-10 05:36:56 +08:00
|
|
|
}
|
2016-11-10 17:48:29 +08:00
|
|
|
|
2017-09-16 02:05:02 +08:00
|
|
|
if (Config->HasDynSymTab) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.DynSymTab = make<SymbolTableSection<ELFT>>(*In.DynStrTab);
|
|
|
|
Add(In.DynSymTab);
|
2016-11-25 16:05:41 +08:00
|
|
|
|
2019-03-06 11:07:48 +08:00
|
|
|
In.VerSym = make<VersionTableSection>();
|
|
|
|
Add(In.VerSym);
|
2016-11-25 16:05:41 +08:00
|
|
|
|
|
|
|
if (!Config->VersionDefinitions.empty()) {
|
2018-09-26 04:37:51 +08:00
|
|
|
In.VerDef = make<VersionDefinitionSection>();
|
|
|
|
Add(In.VerDef);
|
2016-11-25 16:05:41 +08:00
|
|
|
}
|
|
|
|
|
2019-03-06 11:07:48 +08:00
|
|
|
In.VerNeed = make<VersionNeedSection<ELFT>>();
|
|
|
|
Add(In.VerNeed);
|
2016-11-25 16:05:41 +08:00
|
|
|
|
|
|
|
if (Config->GnuHash) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.GnuHashTab = make<GnuHashTableSection>();
|
|
|
|
Add(In.GnuHashTab);
|
2016-11-25 16:05:41 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Config->SysvHash) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.HashTab = make<HashTableSection>();
|
|
|
|
Add(In.HashTab);
|
2016-11-25 16:05:41 +08:00
|
|
|
}
|
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
Add(In.Dynamic);
|
|
|
|
Add(In.DynStrTab);
|
|
|
|
Add(In.RelaDyn);
|
2016-11-25 16:05:41 +08:00
|
|
|
}
|
|
|
|
|
2018-07-10 04:08:55 +08:00
|
|
|
if (Config->RelrPackDynRelocs) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.RelrDyn = make<RelrSection<ELFT>>();
|
|
|
|
Add(In.RelrDyn);
|
2018-07-10 04:08:55 +08:00
|
|
|
}
|
|
|
|
|
2016-11-22 12:28:39 +08:00
|
|
|
// Add .got. MIPS' .got is so different from the other archs,
|
|
|
|
// it has its own class.
|
2016-11-25 16:05:41 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.MipsGot = make<MipsGotSection>();
|
|
|
|
Add(In.MipsGot);
|
2016-11-25 16:05:41 +08:00
|
|
|
} else {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.Got = make<GotSection>();
|
|
|
|
Add(In.Got);
|
2016-11-25 16:05:41 +08:00
|
|
|
}
|
2016-11-17 05:01:02 +08:00
|
|
|
|
2018-11-15 01:56:43 +08:00
|
|
|
if (Config->EMachine == EM_PPC64) {
|
|
|
|
In.PPC64LongBranchTarget = make<PPC64LongBranchTargetSection>();
|
|
|
|
Add(In.PPC64LongBranchTarget);
|
|
|
|
}
|
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
In.GotPlt = make<GotPltSection>();
|
|
|
|
Add(In.GotPlt);
|
|
|
|
In.IgotPlt = make<IgotPltSection>();
|
|
|
|
Add(In.IgotPlt);
|
2016-11-30 00:05:27 +08:00
|
|
|
|
[ELF] Change GOT*_FROM_END (relative to end(.got)) to GOTPLT* (start(.got.plt))
Summary:
This should address remaining issues discussed in PR36555.
Currently R_GOT*_FROM_END are exclusively used by x86 and x86_64 to
express relocations types relative to the GOT base. We have
_GLOBAL_OFFSET_TABLE_ (GOT base) = start(.got.plt) but end(.got) !=
start(.got.plt)
This can have problems when _GLOBAL_OFFSET_TABLE_ is used as a symbol, e.g.
glibc dl_machine_dynamic assumes _GLOBAL_OFFSET_TABLE_ is start(.got.plt),
which is not true.
extern const ElfW(Addr) _GLOBAL_OFFSET_TABLE_[] attribute_hidden;
return _GLOBAL_OFFSET_TABLE_[0]; // R_X86_64_GOTPC32
In this patch, we
* Change all GOT*_FROM_END to GOTPLT* to fix the problem.
* Add HasGotPltOffRel to denote whether .got.plt should be kept even if
the section is empty.
* Simplify GotSection::empty and GotPltSection::empty by setting
HasGotOffRel and HasGotPltOffRel according to GlobalOffsetTable early.
The change of R_386_GOTPC makes X86::writePltHeader simpler as we don't
have to compute the offset start(.got.plt) - Ebx (it is constant 0).
We still diverge from ld.bfd (at least in most cases) and gold in that
.got.plt and .got are not adjacent, but the advantage doing that is
unclear.
Reviewers: ruiu, sivachandra, espindola
Subscribers: emaste, mehdi_amini, arichardson, dexonsmith, jdoerfert, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D59594
llvm-svn: 356968
2019-03-26 07:46:19 +08:00
|
|
|
// _GLOBAL_OFFSET_TABLE_ is defined relative to either .got.plt or .got. Treat
|
|
|
|
// it as a relocation and ensure the referenced section is created.
|
|
|
|
if (ElfSym::GlobalOffsetTable && Config->EMachine != EM_MIPS) {
|
|
|
|
if (Target->GotBaseSymInGotPlt)
|
|
|
|
In.GotPlt->HasGotPltOffRel = true;
|
|
|
|
else
|
|
|
|
In.Got->HasGotOffRel = true;
|
|
|
|
}
|
|
|
|
|
2019-02-20 19:34:18 +08:00
|
|
|
if (Config->GdbIndex)
|
|
|
|
Add(GdbIndexSection::create<ELFT>());
|
2016-11-30 00:05:27 +08:00
|
|
|
|
|
|
|
// We always need to add rel[a].plt to output if it has entries.
|
|
|
|
// Even for static linking it can contain R_[*]_IRELATIVE relocations.
|
2018-09-26 03:26:58 +08:00
|
|
|
In.RelaPlt = make<RelocationSection<ELFT>>(
|
2017-03-18 07:29:01 +08:00
|
|
|
Config->IsRela ? ".rela.plt" : ".rel.plt", false /*Sort*/);
|
2018-09-26 03:26:58 +08:00
|
|
|
Add(In.RelaPlt);
|
2016-11-30 00:05:27 +08:00
|
|
|
|
2016-12-08 20:58:55 +08:00
|
|
|
// The RelaIplt immediately follows .rel.plt (.rel.dyn for ARM) to ensure
|
2017-10-28 01:49:40 +08:00
|
|
|
// that the IRelative relocations are processed last by the dynamic loader.
|
|
|
|
// We cannot place the iplt section in .rel.dyn when Android relocation
|
|
|
|
// packing is enabled because that would cause a section type mismatch.
|
|
|
|
// However, because the Android dynamic loader reads .rel.plt after .rel.dyn,
|
|
|
|
// we can get the desired behaviour by placing the iplt section in .rel.plt.
|
2018-09-26 03:26:58 +08:00
|
|
|
In.RelaIplt = make<RelocationSection<ELFT>>(
|
2017-10-28 01:49:40 +08:00
|
|
|
(Config->EMachine == EM_ARM && !Config->AndroidPackDynRelocs)
|
|
|
|
? ".rel.dyn"
|
2018-09-26 03:26:58 +08:00
|
|
|
: In.RelaPlt->Name,
|
2016-12-08 20:58:55 +08:00
|
|
|
false /*Sort*/);
|
2018-09-26 03:26:58 +08:00
|
|
|
Add(In.RelaIplt);
|
2016-12-08 20:58:55 +08:00
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
In.Plt = make<PltSection>(false);
|
|
|
|
Add(In.Plt);
|
|
|
|
In.Iplt = make<PltSection>(true);
|
|
|
|
Add(In.Iplt);
|
2016-11-30 00:05:27 +08:00
|
|
|
|
2018-08-29 15:27:09 +08:00
|
|
|
// .note.GNU-stack is always added when we are creating a re-linkable
|
|
|
|
// object file. Other linkers are using the presence of this marker
|
|
|
|
// section to control the executable-ness of the stack area, but that
|
|
|
|
// is irrelevant these days. Stack area should always be non-executable
|
|
|
|
// by default. So we emit this section unconditionally.
|
|
|
|
if (Config->Relocatable)
|
|
|
|
Add(make<GnuStackSection>());
|
|
|
|
|
2017-02-24 06:06:28 +08:00
|
|
|
if (!Config->Relocatable) {
|
2017-03-09 16:45:25 +08:00
|
|
|
if (Config->EhFrameHdr) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.EhFrameHdr = make<EhFrameHeader>();
|
|
|
|
Add(In.EhFrameHdr);
|
2017-03-09 16:45:25 +08:00
|
|
|
}
|
2018-09-26 03:26:58 +08:00
|
|
|
In.EhFrame = make<EhFrameSection>();
|
|
|
|
Add(In.EhFrame);
|
2017-02-24 06:06:28 +08:00
|
|
|
}
|
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
if (In.SymTab)
|
|
|
|
Add(In.SymTab);
|
|
|
|
if (In.SymTabShndx)
|
|
|
|
Add(In.SymTabShndx);
|
|
|
|
Add(In.ShStrTab);
|
|
|
|
if (In.StrTab)
|
|
|
|
Add(In.StrTab);
|
2017-12-20 16:56:10 +08:00
|
|
|
|
2019-03-28 19:10:20 +08:00
|
|
|
if (Config->EMachine == EM_ARM && !Config->Relocatable) {
|
|
|
|
// The ARMExidxsyntheticsection replaces all the individual .ARM.exidx
|
|
|
|
// InputSections.
|
|
|
|
In.ARMExidx = make<ARMExidxSyntheticSection>();
|
|
|
|
Add(In.ARMExidx);
|
|
|
|
}
|
2016-11-02 07:17:45 +08:00
|
|
|
}
|
|
|
|
|
2017-12-09 05:50:29 +08:00
|
|
|
// The main function of the writer.
|
|
|
|
template <class ELFT> void Writer<ELFT>::run() {
|
|
|
|
// Create linker-synthesized sections such as .got or .plt.
|
|
|
|
// Such sections are of type input section.
|
|
|
|
createSyntheticSections<ELFT>();
|
|
|
|
|
2019-04-02 02:01:18 +08:00
|
|
|
// Some input sections that are used for exception handling need to be moved
|
|
|
|
// into synthetic sections. Do that now so that they aren't assigned to
|
|
|
|
// output sections in the usual way.
|
2017-12-09 05:50:29 +08:00
|
|
|
if (!Config->Relocatable)
|
2019-04-02 02:01:18 +08:00
|
|
|
combineEhSections<ELFT>();
|
2017-12-09 05:50:29 +08:00
|
|
|
|
|
|
|
// We want to process linker script commands. When SECTIONS command
|
|
|
|
// is given we let it create sections.
|
|
|
|
Script->processSectionCommands();
|
|
|
|
|
|
|
|
// Linker scripts controls how input sections are assigned to output sections.
|
|
|
|
// Input sections that were not handled by scripts are called "orphans", and
|
|
|
|
// they are assigned to output sections by the default rule. Process that.
|
|
|
|
Script->addOrphanSections();
|
|
|
|
|
|
|
|
if (Config->Discard != DiscardPolicy::All)
|
|
|
|
copyLocalSymbols();
|
|
|
|
|
|
|
|
if (Config->CopyRelocs)
|
|
|
|
addSectionSymbols();
|
|
|
|
|
|
|
|
// Now that we have a complete set of output sections. This function
|
|
|
|
// completes section contents. For example, we need to add strings
|
|
|
|
// to the string table, and add entries to .got and .plt.
|
|
|
|
// finalizeSections does that.
|
|
|
|
finalizeSections();
|
2018-10-24 22:24:01 +08:00
|
|
|
checkExecuteOnly();
|
2017-12-09 05:50:29 +08:00
|
|
|
if (errorCount())
|
|
|
|
return;
|
|
|
|
|
[ELF] Compress debug sections after assignAddresses and support custom layout
Previously, in r320472, I moved the calculation of section offsets and sizes
for compressed debug sections into maybeCompress, which happens before
assignAddresses, so that the compression had the required information. However,
I failed to take account of relocations that patch such sections. This had two
effects:
1. A race condition existed when a debug section referred to a different debug
section (see PR35788).
2. References to symbols in non-debug sections would be patched incorrectly.
This is because the addresses of such symbols are not calculated until after
assignAddresses (this was a partial regression caused by r320472, but they
could still have been broken before, in the event that a custom layout was used
in a linker script).
assignAddresses does not need to know about the output section size of
non-allocatable sections, because they do not affect the value of Dot. This
means that there is no longer a reason not to support custom layout of
compressed debug sections, as far as I'm aware. These two points allow for
delaying when maybeCompress can be called, removing the need for the loop I
previously added to calculate the section size, and therefore the race
condition. Furthermore, by delaying, we fix the issues of relocations getting
incorrect symbol values, because they have now all been finalized.
llvm-svn: 321986
2018-01-08 18:17:03 +08:00
|
|
|
Script->assignAddresses();
|
|
|
|
|
2017-12-09 05:50:29 +08:00
|
|
|
// If -compressed-debug-sections is specified, we need to compress
|
|
|
|
// .debug_* sections. Do it right now because it changes the size of
|
|
|
|
// output sections.
|
2018-01-09 07:12:42 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
|
|
|
Sec->maybeCompress<ELFT>();
|
2017-12-09 05:50:29 +08:00
|
|
|
|
|
|
|
Script->allocateHeaders(Phdrs);
|
|
|
|
|
|
|
|
// Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
|
|
|
|
// 0 sized region. This has to be done late since only after assignAddresses
|
|
|
|
// we know the size of the sections.
|
|
|
|
removeEmptyPTLoad();
|
|
|
|
|
|
|
|
if (!Config->OFormatBinary)
|
|
|
|
assignFileOffsets();
|
|
|
|
else
|
|
|
|
assignFileOffsetsBinary();
|
|
|
|
|
|
|
|
setPhdrs();
|
|
|
|
|
2018-10-24 22:24:01 +08:00
|
|
|
if (Config->Relocatable)
|
2017-12-09 05:50:29 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
|
|
|
Sec->Addr = 0;
|
|
|
|
|
2018-02-03 06:24:06 +08:00
|
|
|
if (Config->CheckSections)
|
2018-04-04 17:24:31 +08:00
|
|
|
checkSections();
|
2018-01-31 17:22:44 +08:00
|
|
|
|
2017-12-09 05:50:29 +08:00
|
|
|
// It does not make sense try to open the file if we have error already.
|
|
|
|
if (errorCount())
|
|
|
|
return;
|
|
|
|
// Write the result down to a file.
|
|
|
|
openFile();
|
|
|
|
if (errorCount())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!Config->OFormatBinary) {
|
|
|
|
writeTrapInstr();
|
|
|
|
writeHeader();
|
|
|
|
writeSections();
|
|
|
|
} else {
|
|
|
|
writeSectionsBinary();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Backfill .note.gnu.build-id section content. This is done at last
|
|
|
|
// because the content is usually a hash value of the entire output file.
|
|
|
|
writeBuildId();
|
|
|
|
if (errorCount())
|
|
|
|
return;
|
|
|
|
|
2018-03-15 04:29:45 +08:00
|
|
|
// Handle -Map and -cref options.
|
2017-12-09 05:50:29 +08:00
|
|
|
writeMapFile();
|
2018-03-15 04:29:45 +08:00
|
|
|
writeCrossReferenceTable();
|
2017-12-09 05:50:29 +08:00
|
|
|
if (errorCount())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (auto E = Buffer->commit())
|
2018-08-04 21:41:12 +08:00
|
|
|
error("failed to write to the output file: " + toString(std::move(E)));
|
2017-12-09 05:50:29 +08:00
|
|
|
}
|
|
|
|
|
2017-03-09 06:36:28 +08:00
|
|
|
static bool shouldKeepInSymtab(SectionBase *Sec, StringRef SymName,
|
2017-11-04 05:21:47 +08:00
|
|
|
const Symbol &B) {
|
2018-04-09 19:43:52 +08:00
|
|
|
if (B.isSection())
|
2016-01-28 02:04:26 +08:00
|
|
|
return false;
|
|
|
|
|
2016-08-31 16:46:30 +08:00
|
|
|
if (Config->Discard == DiscardPolicy::None)
|
2016-01-28 02:04:26 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// In ELF assembly .L symbols are normally discarded by the assembler.
|
|
|
|
// If the assembler fails to do so, the linker discards them if
|
|
|
|
// * --discard-locals is used.
|
|
|
|
// * The symbol is in a SHF_MERGE section, which is normally the reason for
|
|
|
|
// the assembler keeping the .L symbol.
|
|
|
|
if (!SymName.startswith(".L") && !SymName.empty())
|
|
|
|
return true;
|
|
|
|
|
2016-08-31 16:46:30 +08:00
|
|
|
if (Config->Discard == DiscardPolicy::Locals)
|
2016-01-28 02:04:26 +08:00
|
|
|
return false;
|
|
|
|
|
2016-10-26 20:36:56 +08:00
|
|
|
return !Sec || !(Sec->Flags & SHF_MERGE);
|
2016-01-28 02:04:26 +08:00
|
|
|
}
|
|
|
|
|
2017-11-04 05:21:47 +08:00
|
|
|
static bool includeInSymtab(const Symbol &B) {
|
2017-11-01 00:07:41 +08:00
|
|
|
if (!B.isLocal() && !B.IsUsedInRegularObj)
|
2016-05-06 00:40:28 +08:00
|
|
|
return false;
|
|
|
|
|
2017-11-06 12:35:31 +08:00
|
|
|
if (auto *D = dyn_cast<Defined>(&B)) {
|
2016-05-06 00:40:28 +08:00
|
|
|
// Always include absolute symbols.
|
2017-03-09 06:36:28 +08:00
|
|
|
SectionBase *Sec = D->Section;
|
|
|
|
if (!Sec)
|
2016-05-06 00:40:28 +08:00
|
|
|
return true;
|
2017-12-14 06:59:23 +08:00
|
|
|
Sec = Sec->Repl;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-12-14 06:59:23 +08:00
|
|
|
// Exclude symbols pointing to garbage-collected sections.
|
|
|
|
if (isa<InputSectionBase>(Sec) && !Sec->Live)
|
|
|
|
return false;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-03-09 06:36:28 +08:00
|
|
|
if (auto *S = dyn_cast<MergeInputSection>(Sec))
|
2016-05-22 08:41:38 +08:00
|
|
|
if (!S->getSectionPiece(D->Value)->Live)
|
2016-05-06 00:40:28 +08:00
|
|
|
return false;
|
2017-11-29 04:17:58 +08:00
|
|
|
return true;
|
2016-05-06 00:40:28 +08:00
|
|
|
}
|
2017-11-29 04:17:58 +08:00
|
|
|
return B.Used;
|
2016-05-06 00:40:28 +08:00
|
|
|
}
|
2016-05-06 00:38:46 +08:00
|
|
|
|
2015-10-09 07:49:30 +08:00
|
|
|
// Local symbols are not in the linker's symbol table. This function scans
|
|
|
|
// each object file's symbol table to copy local symbols to the output.
|
|
|
|
template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
|
2018-09-26 03:26:58 +08:00
|
|
|
if (!In.SymTab)
|
2016-01-21 11:07:38 +08:00
|
|
|
return;
|
2017-09-19 17:20:54 +08:00
|
|
|
for (InputFile *File : ObjectFiles) {
|
|
|
|
ObjFile<ELFT> *F = cast<ObjFile<ELFT>>(File);
|
2017-11-04 05:21:47 +08:00
|
|
|
for (Symbol *B : F->getLocalSymbols()) {
|
2017-10-13 11:37:26 +08:00
|
|
|
if (!B->isLocal())
|
2016-11-24 02:07:33 +08:00
|
|
|
fatal(toString(F) +
|
2016-10-11 17:07:14 +08:00
|
|
|
": broken object: getLocalSymbols returns a non-local symbol");
|
2017-11-06 12:35:31 +08:00
|
|
|
auto *DR = dyn_cast<Defined>(B);
|
2016-11-24 02:07:33 +08:00
|
|
|
|
2016-04-04 22:04:16 +08:00
|
|
|
// No reason to keep local undefined symbol in symtab.
|
|
|
|
if (!DR)
|
|
|
|
continue;
|
2017-03-16 19:20:02 +08:00
|
|
|
if (!includeInSymtab(*B))
|
2016-05-06 00:38:46 +08:00
|
|
|
continue;
|
2016-11-24 02:07:33 +08:00
|
|
|
|
2017-03-09 06:36:28 +08:00
|
|
|
SectionBase *Sec = DR->Section;
|
2017-03-16 19:20:02 +08:00
|
|
|
if (!shouldKeepInSymtab(Sec, B->getName(), *B))
|
2015-10-10 03:25:07 +08:00
|
|
|
continue;
|
2018-09-26 03:26:58 +08:00
|
|
|
In.SymTab->addSymbol(B);
|
2015-10-09 07:49:30 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-25 05:59:58 +08:00
|
|
|
// Create a section symbol for each output section so that we can represent
|
|
|
|
// relocations that point to the section. If we know that no relocation is
|
|
|
|
// referring to a section (that happens if the section is a synthetic one), we
|
|
|
|
// don't create a section symbol for that section.
|
2017-02-11 09:40:49 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::addSectionSymbols() {
|
2017-10-11 09:50:56 +08:00
|
|
|
for (BaseCommand *Base : Script->SectionCommands) {
|
2017-07-28 03:22:43 +08:00
|
|
|
auto *Sec = dyn_cast<OutputSection>(Base);
|
|
|
|
if (!Sec)
|
2017-03-01 03:43:54 +08:00
|
|
|
continue;
|
2017-10-11 09:50:56 +08:00
|
|
|
auto I = llvm::find_if(Sec->SectionCommands, [](BaseCommand *Base) {
|
2017-07-05 03:08:40 +08:00
|
|
|
if (auto *ISD = dyn_cast<InputSectionDescription>(Base))
|
|
|
|
return !ISD->Sections.empty();
|
|
|
|
return false;
|
|
|
|
});
|
2017-10-11 09:50:56 +08:00
|
|
|
if (I == Sec->SectionCommands.end())
|
2017-07-05 03:08:40 +08:00
|
|
|
continue;
|
|
|
|
InputSection *IS = cast<InputSectionDescription>(*I)->Sections[0];
|
2017-11-16 20:33:36 +08:00
|
|
|
|
|
|
|
// Relocations are not using REL[A] section symbols.
|
|
|
|
if (IS->Type == SHT_REL || IS->Type == SHT_RELA)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Unlike other synthetic sections, mergeable output sections contain data
|
|
|
|
// copied from input sections, and there may be a relocation pointing to its
|
2017-11-17 19:27:57 +08:00
|
|
|
// contents if -r or -emit-reloc are given.
|
2017-11-16 20:33:36 +08:00
|
|
|
if (isa<SyntheticSection>(IS) && !(IS->Flags & SHF_MERGE))
|
2017-02-11 09:40:49 +08:00
|
|
|
continue;
|
|
|
|
|
2017-11-30 06:47:35 +08:00
|
|
|
auto *Sym =
|
|
|
|
make<Defined>(IS->File, "", STB_LOCAL, /*StOther=*/0, STT_SECTION,
|
|
|
|
/*Value=*/0, /*Size=*/0, IS);
|
2018-09-26 03:26:58 +08:00
|
|
|
In.SymTab->addSymbol(Sym);
|
2017-02-11 09:40:49 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-16 12:51:46 +08:00
|
|
|
// Today's loaders have a feature to make segments read-only after
|
|
|
|
// processing dynamic relocations to enhance security. PT_GNU_RELRO
|
|
|
|
// is defined for that.
|
|
|
|
//
|
|
|
|
// This function returns true if a section needs to be put into a
|
|
|
|
// PT_GNU_RELRO segment.
|
2017-07-25 07:55:33 +08:00
|
|
|
static bool isRelroSection(const OutputSection *Sec) {
|
2016-02-11 06:43:13 +08:00
|
|
|
if (!Config->ZRelro)
|
|
|
|
return false;
|
2017-02-16 12:51:46 +08:00
|
|
|
|
2016-11-10 07:23:45 +08:00
|
|
|
uint64_t Flags = Sec->Flags;
|
2017-04-13 13:40:07 +08:00
|
|
|
|
|
|
|
// Non-allocatable or non-writable sections don't need RELRO because
|
|
|
|
// they are not writable or not even mapped to memory in the first place.
|
|
|
|
// RELRO is for sections that are essentially read-only but need to
|
|
|
|
// be writable only at process startup to allow dynamic linker to
|
|
|
|
// apply relocations.
|
2015-11-24 18:15:50 +08:00
|
|
|
if (!(Flags & SHF_ALLOC) || !(Flags & SHF_WRITE))
|
|
|
|
return false;
|
2017-04-13 13:40:07 +08:00
|
|
|
|
|
|
|
// Once initialized, TLS data segments are used as data templates
|
|
|
|
// for a thread-local storage. For each new thread, runtime
|
|
|
|
// allocates memory for a TLS and copy templates there. No thread
|
|
|
|
// are supposed to use templates directly. Thus, it can be in RELRO.
|
2015-12-11 03:13:08 +08:00
|
|
|
if (Flags & SHF_TLS)
|
|
|
|
return true;
|
2017-02-16 12:51:46 +08:00
|
|
|
|
2017-04-13 13:40:07 +08:00
|
|
|
// .init_array, .preinit_array and .fini_array contain pointers to
|
|
|
|
// functions that are executed on process startup or exit. These
|
|
|
|
// pointers are set by the static linker, and they are not expected
|
|
|
|
// to change at runtime. But if you are an attacker, you could do
|
|
|
|
// interesting things by manipulating pointers in .fini_array, for
|
|
|
|
// example. So they are put into RELRO.
|
2016-11-09 09:42:41 +08:00
|
|
|
uint32_t Type = Sec->Type;
|
2015-12-11 03:13:08 +08:00
|
|
|
if (Type == SHT_INIT_ARRAY || Type == SHT_FINI_ARRAY ||
|
|
|
|
Type == SHT_PREINIT_ARRAY)
|
2015-11-24 18:15:50 +08:00
|
|
|
return true;
|
2017-02-16 12:51:46 +08:00
|
|
|
|
2017-04-13 13:40:07 +08:00
|
|
|
// .got contains pointers to external symbols. They are resolved by
|
|
|
|
// the dynamic linker when a module is loaded into memory, and after
|
|
|
|
// that they are not expected to change. So, it can be in RELRO.
|
2018-09-26 03:26:58 +08:00
|
|
|
if (In.Got && Sec == In.Got->getParent())
|
2017-04-13 13:40:07 +08:00
|
|
|
return true;
|
|
|
|
|
2018-10-25 05:59:48 +08:00
|
|
|
// .toc is a GOT-ish section for PowerPC64. Their contents are accessed
|
|
|
|
// through r2 register, which is reserved for that purpose. Since r2 is used
|
|
|
|
// for accessing .got as well, .got and .toc need to be close enough in the
|
|
|
|
// virtual address space. Usually, .toc comes just after .got. Since we place
|
|
|
|
// .got into RELRO, .toc needs to be placed into RELRO too.
|
2018-05-24 23:59:41 +08:00
|
|
|
if (Sec->Name.equals(".toc"))
|
|
|
|
return true;
|
|
|
|
|
2017-04-13 13:40:07 +08:00
|
|
|
// .got.plt contains pointers to external function symbols. They are
|
|
|
|
// by default resolved lazily, so we usually cannot put it into RELRO.
|
|
|
|
// However, if "-z now" is given, the lazy symbol resolution is
|
|
|
|
// disabled, which enables us to put it into RELRO.
|
2018-09-26 03:26:58 +08:00
|
|
|
if (Sec == In.GotPlt->getParent())
|
2015-11-24 18:15:50 +08:00
|
|
|
return Config->ZNow;
|
2017-04-13 13:40:07 +08:00
|
|
|
|
|
|
|
// .dynamic section contains data for the dynamic linker, and
|
|
|
|
// there's no need to write to it at runtime, so it's better to put
|
|
|
|
// it into RELRO.
|
2018-09-26 03:26:58 +08:00
|
|
|
if (Sec == In.Dynamic->getParent())
|
2016-11-17 05:01:02 +08:00
|
|
|
return true;
|
2017-04-13 13:40:07 +08:00
|
|
|
|
|
|
|
// Sections with some special names are put into RELRO. This is a
|
|
|
|
// bit unfortunate because section names shouldn't be significant in
|
|
|
|
// ELF in spirit. But in reality many linker features depend on
|
|
|
|
// magic section names.
|
2017-02-24 22:28:00 +08:00
|
|
|
StringRef S = Sec->Name;
|
2017-12-05 19:15:58 +08:00
|
|
|
return S == ".data.rel.ro" || S == ".bss.rel.ro" || S == ".ctors" ||
|
|
|
|
S == ".dtors" || S == ".jcr" || S == ".eh_frame" ||
|
|
|
|
S == ".openbsd.randomdata";
|
2015-11-24 18:15:50 +08:00
|
|
|
}
|
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
// We compute a rank for each section. The rank indicates where the
|
|
|
|
// section should be placed in the file. Instead of using simple
|
|
|
|
// numbers (0,1,2...), we use a series of flags. One for each decision
|
|
|
|
// point when placing the section.
|
|
|
|
// Using flags has two key properties:
|
|
|
|
// * It is easy to check if a give branch was taken.
|
|
|
|
// * It is easy two see how similar two ranks are (see getRankProximity).
|
|
|
|
enum RankFlags {
|
[ELF] Simplify RelRo, TLS, NOBITS section ranks and make RW PT_LOAD start with RelRo
Old: PT_LOAD(.data | PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss)
The placement of | indicates page alignment caused by PT_GNU_RELRO. The
new layout has simpler rules and saves space for many cases.
Old size: roundup(.data) + roundup(.data.rel.ro)
New size: roundup(.data.rel.ro + .bss.rel.ro) + .data
Other advantages:
* At runtime the 3 memory mappings decrease to 2.
* start(PT_TLS) = start(PT_GNU_RELRO) = start(RW PT_LOAD). This
simplifies binary manipulation tools.
GNU strip before 2.31 discards PT_GNU_RELRO if its
address is not equal to the start of its associated PT_LOAD.
This has been fixed by https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=f2731e0c374e5323ce4cdae2bcc7b7fe22da1a6f
But with this change, we will be compatible with GNU strip before 2.31
* Before, .got.plt (non-relro by default) was placed before .got (relro
by default), which made it impossible to have _GLOBAL_OFFSET_TABLE_
(start of .got.plt on x86-64) equal to the end of .got (R_GOT*_FROM_END)
(https://bugs.llvm.org/show_bug.cgi?id=36555). With the new ordering, we
can improve on this regard if we'd like to.
Reviewers: ruiu, espindola, pcc
Subscribers: emaste, arichardson, llvm-commits, joerg, jdoerfert
Differential Revision: https://reviews.llvm.org/D56828
llvm-svn: 356117
2019-03-14 11:47:45 +08:00
|
|
|
RF_NOT_ADDR_SET = 1 << 17,
|
|
|
|
RF_NOT_ALLOC = 1 << 16,
|
|
|
|
RF_NOT_INTERP = 1 << 15,
|
|
|
|
RF_NOT_NOTE = 1 << 14,
|
|
|
|
RF_WRITE = 1 << 13,
|
|
|
|
RF_EXEC_WRITE = 1 << 12,
|
|
|
|
RF_EXEC = 1 << 11,
|
|
|
|
RF_RODATA = 1 << 10,
|
|
|
|
RF_NOT_RELRO = 1 << 9,
|
2018-12-19 03:16:37 +08:00
|
|
|
RF_NOT_TLS = 1 << 8,
|
|
|
|
RF_BSS = 1 << 7,
|
2017-05-19 00:20:12 +08:00
|
|
|
RF_PPC_NOT_TOCBSS = 1 << 6,
|
2018-05-24 23:59:41 +08:00
|
|
|
RF_PPC_TOCL = 1 << 5,
|
|
|
|
RF_PPC_TOC = 1 << 4,
|
|
|
|
RF_PPC_GOT = 1 << 3,
|
2017-05-19 00:20:12 +08:00
|
|
|
RF_PPC_BRANCH_LT = 1 << 2,
|
|
|
|
RF_MIPS_GPREL = 1 << 1,
|
|
|
|
RF_MIPS_NOT_GOT = 1 << 0
|
2017-05-12 22:52:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static unsigned getSectionRank(const OutputSection *Sec) {
|
|
|
|
unsigned Rank = 0;
|
|
|
|
|
|
|
|
// We want to put section specified by -T option first, so we
|
|
|
|
// can start assigning VA starting from them later.
|
|
|
|
if (Config->SectionStartMap.count(Sec->Name))
|
|
|
|
return Rank;
|
|
|
|
Rank |= RF_NOT_ADDR_SET;
|
|
|
|
|
2018-12-19 03:16:37 +08:00
|
|
|
// Allocatable sections go first to reduce the total PT_LOAD size and
|
|
|
|
// so debug info doesn't change addresses in actual code.
|
|
|
|
if (!(Sec->Flags & SHF_ALLOC))
|
|
|
|
return Rank | RF_NOT_ALLOC;
|
|
|
|
|
2016-11-03 02:58:44 +08:00
|
|
|
// Put .interp first because some loaders want to see that section
|
|
|
|
// on the first page of the executable file when loaded into memory.
|
2017-05-12 22:52:22 +08:00
|
|
|
if (Sec->Name == ".interp")
|
|
|
|
return Rank;
|
|
|
|
Rank |= RF_NOT_INTERP;
|
2016-11-03 02:58:44 +08:00
|
|
|
|
2018-12-19 03:16:37 +08:00
|
|
|
// Put .note sections (which make up one PT_NOTE) at the beginning so that
|
|
|
|
// they are likely to be included in a core file even if core file size is
|
|
|
|
// limited. In particular, we want a .note.gnu.build-id and a .note.tag to be
|
|
|
|
// included in a core to match core files with executables.
|
|
|
|
if (Sec->Type == SHT_NOTE)
|
|
|
|
return Rank;
|
|
|
|
Rank |= RF_NOT_NOTE;
|
2016-12-20 05:21:07 +08:00
|
|
|
|
2017-05-27 01:23:25 +08:00
|
|
|
// Sort sections based on their access permission in the following
|
|
|
|
// order: R, RX, RWX, RW. This order is based on the following
|
|
|
|
// considerations:
|
|
|
|
// * Read-only sections come first such that they go in the
|
|
|
|
// PT_LOAD covering the program headers at the start of the file.
|
2018-06-27 01:04:47 +08:00
|
|
|
// * Read-only, executable sections come next.
|
2017-05-27 01:23:25 +08:00
|
|
|
// * Writable, executable sections follow such that .plt on
|
|
|
|
// architectures where it needs to be writable will be placed
|
|
|
|
// between .text and .data.
|
|
|
|
// * Writable sections come last, such that .bss lands at the very
|
|
|
|
// end of the last PT_LOAD.
|
|
|
|
bool IsExec = Sec->Flags & SHF_EXECINSTR;
|
|
|
|
bool IsWrite = Sec->Flags & SHF_WRITE;
|
|
|
|
|
|
|
|
if (IsExec) {
|
|
|
|
if (IsWrite)
|
|
|
|
Rank |= RF_EXEC_WRITE;
|
2018-06-27 01:04:47 +08:00
|
|
|
else
|
2017-05-12 22:52:22 +08:00
|
|
|
Rank |= RF_EXEC;
|
2018-06-27 23:56:32 +08:00
|
|
|
} else if (IsWrite) {
|
|
|
|
Rank |= RF_WRITE;
|
|
|
|
} else if (Sec->Type == SHT_PROGBITS) {
|
2018-06-27 06:13:32 +08:00
|
|
|
// Make non-executable and non-writable PROGBITS sections (e.g .rodata
|
2018-06-27 23:56:32 +08:00
|
|
|
// .eh_frame) closer to .text. They likely contain PC or GOT relative
|
2018-06-27 06:13:32 +08:00
|
|
|
// relocations and there could be relocation overflow if other huge sections
|
|
|
|
// (.dynstr .dynsym) were placed in between.
|
2018-06-27 23:56:32 +08:00
|
|
|
Rank |= RF_RODATA;
|
2016-09-30 06:48:55 +08:00
|
|
|
}
|
2015-10-09 07:49:30 +08:00
|
|
|
|
[ELF] Simplify RelRo, TLS, NOBITS section ranks and make RW PT_LOAD start with RelRo
Old: PT_LOAD(.data | PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss)
The placement of | indicates page alignment caused by PT_GNU_RELRO. The
new layout has simpler rules and saves space for many cases.
Old size: roundup(.data) + roundup(.data.rel.ro)
New size: roundup(.data.rel.ro + .bss.rel.ro) + .data
Other advantages:
* At runtime the 3 memory mappings decrease to 2.
* start(PT_TLS) = start(PT_GNU_RELRO) = start(RW PT_LOAD). This
simplifies binary manipulation tools.
GNU strip before 2.31 discards PT_GNU_RELRO if its
address is not equal to the start of its associated PT_LOAD.
This has been fixed by https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=f2731e0c374e5323ce4cdae2bcc7b7fe22da1a6f
But with this change, we will be compatible with GNU strip before 2.31
* Before, .got.plt (non-relro by default) was placed before .got (relro
by default), which made it impossible to have _GLOBAL_OFFSET_TABLE_
(start of .got.plt on x86-64) equal to the end of .got (R_GOT*_FROM_END)
(https://bugs.llvm.org/show_bug.cgi?id=36555). With the new ordering, we
can improve on this regard if we'd like to.
Reviewers: ruiu, espindola, pcc
Subscribers: emaste, arichardson, llvm-commits, joerg, jdoerfert
Differential Revision: https://reviews.llvm.org/D56828
llvm-svn: 356117
2019-03-14 11:47:45 +08:00
|
|
|
// Place RelRo sections first. After considering SHT_NOBITS below, the
|
|
|
|
// ordering is PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss),
|
|
|
|
// where | marks where page alignment happens. An alternative ordering is
|
|
|
|
// PT_LOAD(.data | PT_GNU_RELRO( .data.rel.ro .bss.rel.ro) | .bss), but it may
|
|
|
|
// waste more bytes due to 2 alignment places.
|
|
|
|
if (!isRelroSection(Sec))
|
|
|
|
Rank |= RF_NOT_RELRO;
|
2015-10-17 07:11:07 +08:00
|
|
|
|
[ELF] Simplify RelRo, TLS, NOBITS section ranks and make RW PT_LOAD start with RelRo
Old: PT_LOAD(.data | PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss)
The placement of | indicates page alignment caused by PT_GNU_RELRO. The
new layout has simpler rules and saves space for many cases.
Old size: roundup(.data) + roundup(.data.rel.ro)
New size: roundup(.data.rel.ro + .bss.rel.ro) + .data
Other advantages:
* At runtime the 3 memory mappings decrease to 2.
* start(PT_TLS) = start(PT_GNU_RELRO) = start(RW PT_LOAD). This
simplifies binary manipulation tools.
GNU strip before 2.31 discards PT_GNU_RELRO if its
address is not equal to the start of its associated PT_LOAD.
This has been fixed by https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=f2731e0c374e5323ce4cdae2bcc7b7fe22da1a6f
But with this change, we will be compatible with GNU strip before 2.31
* Before, .got.plt (non-relro by default) was placed before .got (relro
by default), which made it impossible to have _GLOBAL_OFFSET_TABLE_
(start of .got.plt on x86-64) equal to the end of .got (R_GOT*_FROM_END)
(https://bugs.llvm.org/show_bug.cgi?id=36555). With the new ordering, we
can improve on this regard if we'd like to.
Reviewers: ruiu, espindola, pcc
Subscribers: emaste, arichardson, llvm-commits, joerg, jdoerfert
Differential Revision: https://reviews.llvm.org/D56828
llvm-svn: 356117
2019-03-14 11:47:45 +08:00
|
|
|
// If we got here we know that both A and B are in the same PT_LOAD.
|
2017-01-10 09:21:30 +08:00
|
|
|
|
|
|
|
// The TLS initialization block needs to be a single contiguous block in a R/W
|
|
|
|
// PT_LOAD, so stick TLS sections directly before the other RelRo R/W
|
[ELF] Simplify RelRo, TLS, NOBITS section ranks and make RW PT_LOAD start with RelRo
Old: PT_LOAD(.data | PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss)
The placement of | indicates page alignment caused by PT_GNU_RELRO. The
new layout has simpler rules and saves space for many cases.
Old size: roundup(.data) + roundup(.data.rel.ro)
New size: roundup(.data.rel.ro + .bss.rel.ro) + .data
Other advantages:
* At runtime the 3 memory mappings decrease to 2.
* start(PT_TLS) = start(PT_GNU_RELRO) = start(RW PT_LOAD). This
simplifies binary manipulation tools.
GNU strip before 2.31 discards PT_GNU_RELRO if its
address is not equal to the start of its associated PT_LOAD.
This has been fixed by https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=f2731e0c374e5323ce4cdae2bcc7b7fe22da1a6f
But with this change, we will be compatible with GNU strip before 2.31
* Before, .got.plt (non-relro by default) was placed before .got (relro
by default), which made it impossible to have _GLOBAL_OFFSET_TABLE_
(start of .got.plt on x86-64) equal to the end of .got (R_GOT*_FROM_END)
(https://bugs.llvm.org/show_bug.cgi?id=36555). With the new ordering, we
can improve on this regard if we'd like to.
Reviewers: ruiu, espindola, pcc
Subscribers: emaste, arichardson, llvm-commits, joerg, jdoerfert
Differential Revision: https://reviews.llvm.org/D56828
llvm-svn: 356117
2019-03-14 11:47:45 +08:00
|
|
|
// sections. Since p_filesz can be less than p_memsz, place NOBITS sections
|
|
|
|
// after PROGBITS.
|
|
|
|
if (!(Sec->Flags & SHF_TLS))
|
2017-05-12 22:52:22 +08:00
|
|
|
Rank |= RF_NOT_TLS;
|
2017-01-10 09:21:30 +08:00
|
|
|
|
[ELF] Simplify RelRo, TLS, NOBITS section ranks and make RW PT_LOAD start with RelRo
Old: PT_LOAD(.data | PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss)
The placement of | indicates page alignment caused by PT_GNU_RELRO. The
new layout has simpler rules and saves space for many cases.
Old size: roundup(.data) + roundup(.data.rel.ro)
New size: roundup(.data.rel.ro + .bss.rel.ro) + .data
Other advantages:
* At runtime the 3 memory mappings decrease to 2.
* start(PT_TLS) = start(PT_GNU_RELRO) = start(RW PT_LOAD). This
simplifies binary manipulation tools.
GNU strip before 2.31 discards PT_GNU_RELRO if its
address is not equal to the start of its associated PT_LOAD.
This has been fixed by https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=f2731e0c374e5323ce4cdae2bcc7b7fe22da1a6f
But with this change, we will be compatible with GNU strip before 2.31
* Before, .got.plt (non-relro by default) was placed before .got (relro
by default), which made it impossible to have _GLOBAL_OFFSET_TABLE_
(start of .got.plt on x86-64) equal to the end of .got (R_GOT*_FROM_END)
(https://bugs.llvm.org/show_bug.cgi?id=36555). With the new ordering, we
can improve on this regard if we'd like to.
Reviewers: ruiu, espindola, pcc
Subscribers: emaste, arichardson, llvm-commits, joerg, jdoerfert
Differential Revision: https://reviews.llvm.org/D56828
llvm-svn: 356117
2019-03-14 11:47:45 +08:00
|
|
|
// Within TLS sections, or within other RelRo sections, or within non-RelRo
|
|
|
|
// sections, place non-NOBITS sections first.
|
|
|
|
if (Sec->Type == SHT_NOBITS)
|
2017-05-12 22:52:22 +08:00
|
|
|
Rank |= RF_BSS;
|
|
|
|
|
2017-08-19 00:15:36 +08:00
|
|
|
// Some architectures have additional ordering restrictions for sections
|
|
|
|
// within the same PT_LOAD.
|
2017-05-12 22:52:22 +08:00
|
|
|
if (Config->EMachine == EM_PPC64) {
|
|
|
|
// PPC64 has a number of special SHT_PROGBITS+SHF_ALLOC+SHF_WRITE sections
|
|
|
|
// that we would like to make sure appear is a specific order to maximize
|
|
|
|
// their coverage by a single signed 16-bit offset from the TOC base
|
|
|
|
// pointer. Conversely, the special .tocbss section should be first among
|
|
|
|
// all SHT_NOBITS sections. This will put it next to the loaded special
|
|
|
|
// PPC64 sections (and, thus, within reach of the TOC base pointer).
|
|
|
|
StringRef Name = Sec->Name;
|
|
|
|
if (Name != ".tocbss")
|
|
|
|
Rank |= RF_PPC_NOT_TOCBSS;
|
|
|
|
|
|
|
|
if (Name == ".toc1")
|
|
|
|
Rank |= RF_PPC_TOCL;
|
|
|
|
|
|
|
|
if (Name == ".toc")
|
|
|
|
Rank |= RF_PPC_TOC;
|
|
|
|
|
2018-05-24 23:59:41 +08:00
|
|
|
if (Name == ".got")
|
|
|
|
Rank |= RF_PPC_GOT;
|
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
if (Name == ".branch_lt")
|
|
|
|
Rank |= RF_PPC_BRANCH_LT;
|
|
|
|
}
|
2018-03-01 10:31:29 +08:00
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
|
|
|
// All sections with SHF_MIPS_GPREL flag should be grouped together
|
|
|
|
// because data in these sections is addressable with a gp relative address.
|
|
|
|
if (Sec->Flags & SHF_MIPS_GPREL)
|
|
|
|
Rank |= RF_MIPS_GPREL;
|
2015-11-24 18:15:50 +08:00
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
if (Sec->Name != ".got")
|
|
|
|
Rank |= RF_MIPS_NOT_GOT;
|
|
|
|
}
|
2015-10-14 03:07:29 +08:00
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
return Rank;
|
|
|
|
}
|
|
|
|
|
2017-06-16 05:51:01 +08:00
|
|
|
static bool compareSections(const BaseCommand *ACmd, const BaseCommand *BCmd) {
|
2017-07-28 03:22:43 +08:00
|
|
|
const OutputSection *A = cast<OutputSection>(ACmd);
|
|
|
|
const OutputSection *B = cast<OutputSection>(BCmd);
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
if (A->SortRank != B->SortRank)
|
|
|
|
return A->SortRank < B->SortRank;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
if (!(A->SortRank & RF_NOT_ADDR_SET))
|
|
|
|
return Config->SectionStartMap.lookup(A->Name) <
|
|
|
|
Config->SectionStartMap.lookup(B->Name);
|
2016-09-22 06:36:19 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-02-24 23:07:30 +08:00
|
|
|
void PhdrEntry::add(OutputSection *Sec) {
|
2017-09-07 19:01:10 +08:00
|
|
|
LastSec = Sec;
|
|
|
|
if (!FirstSec)
|
|
|
|
FirstSec = Sec;
|
2017-03-07 22:55:52 +08:00
|
|
|
p_align = std::max(p_align, Sec->Alignment);
|
2016-12-20 01:01:01 +08:00
|
|
|
if (p_type == PT_LOAD)
|
2017-09-07 18:53:07 +08:00
|
|
|
Sec->PtLoad = this;
|
2016-07-19 17:25:43 +08:00
|
|
|
}
|
|
|
|
|
2015-12-26 17:47:57 +08:00
|
|
|
// The beginning and the ending of .rel[a].plt section are marked
|
|
|
|
// with __rel[a]_iplt_{start,end} symbols if it is a statically linked
|
|
|
|
// executable. The runtime needs these symbols in order to resolve
|
|
|
|
// all IRELATIVE relocs on startup. For dynamic executables, we don't
|
|
|
|
// need these symbols, since IRELATIVE relocs are resolved through GOT
|
|
|
|
// and PLT. For details, see http://www.airs.com/blog/archives/403.
|
2016-04-14 21:23:02 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
|
Don't mess up RelIplt symbols during relocatable processing
Summary:
During upgrading of the FreeBSD source tree with lld 7.0.0, I noticed
that it started complaining about `crt1.o` having an "index past the
end of the symbol table".
Such a symbol table looks approximately like this, viewed with `readelf
-s` (note the `Ndx` field being messed up):
```
Symbol table '.symtab' contains 4 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 SECTION LOCAL DEFAULT 1
2: 00000000 0 NOTYPE WEAK HIDDEN RSV[0xffff] __rel_iplt_end
3: 00000000 0 NOTYPE WEAK HIDDEN RSV[0xffff] __rel_iplt_start
```
At first, it seemed that recent ifunc relocation work had caused this:
<https://reviews.freebsd.org/rS339351>, but it turned out that it was
due to incorrect processing of the object files by lld, when using `-r`
(a.k.a. --relocatable).
Bisecting showed that rL324421 ("Convert a use of Config->Static") was
the commit where this new behavior began. Simply reverting it solved
the issue, and the `__rel_iplt` symbols had an index of `UND` again.
Looking at Rafael's commit message, I think he simply missed the
possibility of `--relocatable` being in effect, so I have added an
additional check for it.
I also added a simple regression test case.
Reviewers: grimar, ruiu, emaste, espindola
Reviewed By: ruiu
Subscribers: arichardson, krytarowski, llvm-commits
Differential Revision: https://reviews.llvm.org/D53515
llvm-svn: 345002
2018-10-23 13:53:15 +08:00
|
|
|
if (Config->Relocatable || needsInterpSection())
|
2015-12-21 18:12:06 +08:00
|
|
|
return;
|
2015-12-26 17:47:57 +08:00
|
|
|
|
2019-01-16 02:30:23 +08:00
|
|
|
// By default, __rela_iplt_{start,end} belong to a dummy section 0
|
|
|
|
// because .rela.plt might be empty and thus removed from output.
|
|
|
|
// We'll override Out::ElfHeader with In.RelaIplt later when we are
|
|
|
|
// sure that .rela.plt exists in output.
|
|
|
|
ElfSym::RelaIpltStart = addOptionalRegular(
|
|
|
|
Config->IsRela ? "__rela_iplt_start" : "__rel_iplt_start",
|
|
|
|
Out::ElfHeader, 0, STV_HIDDEN, STB_WEAK);
|
|
|
|
|
|
|
|
ElfSym::RelaIpltEnd = addOptionalRegular(
|
|
|
|
Config->IsRela ? "__rela_iplt_end" : "__rel_iplt_end",
|
|
|
|
Out::ElfHeader, 0, STV_HIDDEN, STB_WEAK);
|
2015-12-21 18:12:06 +08:00
|
|
|
}
|
|
|
|
|
2016-07-21 01:58:07 +08:00
|
|
|
template <class ELFT>
|
2018-06-16 20:11:34 +08:00
|
|
|
void Writer<ELFT>::forEachRelSec(
|
|
|
|
llvm::function_ref<void(InputSectionBase &)> Fn) {
|
2017-09-13 15:54:47 +08:00
|
|
|
// Scan all relocations. Each relocation goes through a series
|
|
|
|
// of tests to determine if it needs special treatment, such as
|
|
|
|
// creating GOT, PLT, copy relocations, etc.
|
|
|
|
// Note that relocations for non-alloc sections are directly
|
|
|
|
// processed by InputSection::relocateNonAlloc.
|
|
|
|
for (InputSectionBase *IS : InputSections)
|
|
|
|
if (IS->Live && isa<InputSection>(IS) && (IS->Flags & SHF_ALLOC))
|
2016-11-10 22:53:24 +08:00
|
|
|
Fn(*IS);
|
2018-09-26 03:26:58 +08:00
|
|
|
for (EhInputSection *ES : In.EhFrame->Sections)
|
2017-09-13 15:54:47 +08:00
|
|
|
Fn(*ES);
|
2019-03-28 19:10:20 +08:00
|
|
|
if (In.ARMExidx && In.ARMExidx->Live)
|
|
|
|
for (InputSection *Ex : In.ARMExidx->ExidxSections)
|
|
|
|
Fn(*Ex);
|
2016-07-21 01:58:07 +08:00
|
|
|
}
|
|
|
|
|
2017-09-01 10:23:31 +08:00
|
|
|
// This function generates assignments for predefined symbols (e.g. _end or
|
|
|
|
// _etext) and inserts them into the commands sequence to be processed at the
|
|
|
|
// appropriate time. This ensures that the value is going to be correct by the
|
|
|
|
// time any references to these symbols are processed and is equivalent to
|
|
|
|
// defining these symbols explicitly in the linker script.
|
2017-09-13 00:38:01 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
|
2017-12-12 01:23:28 +08:00
|
|
|
if (ElfSym::GlobalOffsetTable) {
|
2018-03-19 14:52:51 +08:00
|
|
|
// The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually
|
|
|
|
// to the start of the .got or .got.plt section.
|
2018-09-26 03:26:58 +08:00
|
|
|
InputSection *GotSection = In.GotPlt;
|
2018-03-19 14:52:51 +08:00
|
|
|
if (!Target->GotBaseSymInGotPlt)
|
2018-09-26 03:26:58 +08:00
|
|
|
GotSection = In.MipsGot ? cast<InputSection>(In.MipsGot)
|
|
|
|
: cast<InputSection>(In.Got);
|
2017-12-12 01:23:28 +08:00
|
|
|
ElfSym::GlobalOffsetTable->Section = GotSection;
|
|
|
|
}
|
|
|
|
|
2019-01-16 02:30:23 +08:00
|
|
|
// .rela_iplt_{start,end} mark the start and the end of .rela.plt section.
|
2019-04-01 16:16:08 +08:00
|
|
|
if (ElfSym::RelaIpltStart && In.RelaIplt->isNeeded()) {
|
2019-01-16 02:30:23 +08:00
|
|
|
ElfSym::RelaIpltStart->Section = In.RelaIplt;
|
|
|
|
ElfSym::RelaIpltEnd->Section = In.RelaIplt;
|
2018-09-26 03:26:58 +08:00
|
|
|
ElfSym::RelaIpltEnd->Value = In.RelaIplt->getSize();
|
2019-01-16 02:30:23 +08:00
|
|
|
}
|
2018-04-20 00:54:30 +08:00
|
|
|
|
2017-09-01 10:23:31 +08:00
|
|
|
PhdrEntry *Last = nullptr;
|
|
|
|
PhdrEntry *LastRO = nullptr;
|
2017-09-06 04:17:37 +08:00
|
|
|
|
2017-09-01 10:23:31 +08:00
|
|
|
for (PhdrEntry *P : Phdrs) {
|
|
|
|
if (P->p_type != PT_LOAD)
|
|
|
|
continue;
|
|
|
|
Last = P;
|
2017-11-03 19:51:58 +08:00
|
|
|
if (!(P->p_flags & PF_W))
|
2017-09-01 10:23:31 +08:00
|
|
|
LastRO = P;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (LastRO) {
|
2017-10-30 06:31:48 +08:00
|
|
|
// _etext is the first location after the last read-only loadable segment.
|
2017-09-13 00:38:01 +08:00
|
|
|
if (ElfSym::Etext1)
|
|
|
|
ElfSym::Etext1->Section = LastRO->LastSec;
|
|
|
|
if (ElfSym::Etext2)
|
|
|
|
ElfSym::Etext2->Section = LastRO->LastSec;
|
2017-09-01 10:23:31 +08:00
|
|
|
}
|
2017-09-06 04:17:37 +08:00
|
|
|
|
2017-10-30 06:31:48 +08:00
|
|
|
if (Last) {
|
|
|
|
// _edata points to the end of the last mapped initialized section.
|
|
|
|
OutputSection *Edata = nullptr;
|
|
|
|
for (OutputSection *OS : OutputSections) {
|
|
|
|
if (OS->Type != SHT_NOBITS)
|
|
|
|
Edata = OS;
|
|
|
|
if (OS == Last->LastSec)
|
2017-10-17 22:31:29 +08:00
|
|
|
break;
|
2017-10-30 06:31:48 +08:00
|
|
|
}
|
2017-10-17 22:31:29 +08:00
|
|
|
|
2017-09-13 00:38:01 +08:00
|
|
|
if (ElfSym::Edata1)
|
2017-10-30 06:31:48 +08:00
|
|
|
ElfSym::Edata1->Section = Edata;
|
2017-09-13 00:38:01 +08:00
|
|
|
if (ElfSym::Edata2)
|
2017-10-30 06:31:48 +08:00
|
|
|
ElfSym::Edata2->Section = Edata;
|
|
|
|
|
|
|
|
// _end is the first location after the uninitialized data region.
|
|
|
|
if (ElfSym::End1)
|
|
|
|
ElfSym::End1->Section = Last->LastSec;
|
|
|
|
if (ElfSym::End2)
|
|
|
|
ElfSym::End2->Section = Last->LastSec;
|
2017-09-13 00:38:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ElfSym::Bss)
|
|
|
|
ElfSym::Bss->Section = findSection(".bss");
|
|
|
|
|
|
|
|
// Setup MIPS _gp_disp/__gnu_local_gp symbols which should
|
|
|
|
// be equal to the _gp symbol's value.
|
2017-09-21 02:30:57 +08:00
|
|
|
if (ElfSym::MipsGp) {
|
2017-09-13 00:38:01 +08:00
|
|
|
// Find GP-relative section with the lowest address
|
|
|
|
// and use this address to calculate default _gp value.
|
|
|
|
for (OutputSection *OS : OutputSections) {
|
|
|
|
if (OS->Flags & SHF_MIPS_GPREL) {
|
|
|
|
ElfSym::MipsGp->Section = OS;
|
|
|
|
ElfSym::MipsGp->Value = 0x7ff0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-09-01 10:23:31 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
// We want to find how similar two ranks are.
|
|
|
|
// The more branches in getSectionRank that match, the more similar they are.
|
|
|
|
// Since each branch corresponds to a bit flag, we can just use
|
|
|
|
// countLeadingZeros.
|
2017-07-28 03:22:43 +08:00
|
|
|
static int getRankProximityAux(OutputSection *A, OutputSection *B) {
|
2017-05-12 22:52:22 +08:00
|
|
|
return countLeadingZeros(A->SortRank ^ B->SortRank);
|
2016-11-08 18:44:48 +08:00
|
|
|
}
|
|
|
|
|
2017-06-16 05:51:01 +08:00
|
|
|
static int getRankProximity(OutputSection *A, BaseCommand *B) {
|
2017-07-28 03:22:43 +08:00
|
|
|
if (auto *Sec = dyn_cast<OutputSection>(B))
|
2018-02-23 18:53:04 +08:00
|
|
|
return getRankProximityAux(A, Sec);
|
2017-06-16 05:51:01 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// When placing orphan sections, we want to place them after symbol assignments
|
|
|
|
// so that an orphan after
|
|
|
|
// begin_foo = .;
|
|
|
|
// foo : { *(foo) }
|
|
|
|
// end_foo = .;
|
|
|
|
// doesn't break the intended meaning of the begin/end symbols.
|
|
|
|
// We don't want to go over sections since findOrphanPos is the
|
|
|
|
// one in charge of deciding the order of the sections.
|
|
|
|
// We don't want to go over changes to '.', since doing so in
|
|
|
|
// rx_sec : { *(rx_sec) }
|
|
|
|
// . = ALIGN(0x1000);
|
|
|
|
// /* The RW PT_LOAD starts here*/
|
|
|
|
// rw_sec : { *(rw_sec) }
|
|
|
|
// would mean that the RW PT_LOAD would become unaligned.
|
|
|
|
static bool shouldSkip(BaseCommand *Cmd) {
|
|
|
|
if (auto *Assign = dyn_cast<SymbolAssignment>(Cmd))
|
|
|
|
return Assign->Name != ".";
|
2018-07-04 23:05:21 +08:00
|
|
|
return false;
|
2017-06-16 05:51:01 +08:00
|
|
|
}
|
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
// We want to place orphan sections so that they share as much
|
|
|
|
// characteristics with their neighbors as possible. For example, if
|
|
|
|
// both are rw, or both are tls.
|
2017-06-16 05:51:01 +08:00
|
|
|
static std::vector<BaseCommand *>::iterator
|
|
|
|
findOrphanPos(std::vector<BaseCommand *>::iterator B,
|
|
|
|
std::vector<BaseCommand *>::iterator E) {
|
2017-07-28 03:22:43 +08:00
|
|
|
OutputSection *Sec = cast<OutputSection>(*E);
|
2017-05-09 21:58:46 +08:00
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
// Find the first element that has as close a rank as possible.
|
2017-06-16 05:51:01 +08:00
|
|
|
auto I = std::max_element(B, E, [=](BaseCommand *A, BaseCommand *B) {
|
2017-05-12 22:52:22 +08:00
|
|
|
return getRankProximity(Sec, A) < getRankProximity(Sec, B);
|
|
|
|
});
|
|
|
|
if (I == E)
|
2017-05-09 21:58:46 +08:00
|
|
|
return E;
|
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
// Consider all existing sections with the same proximity.
|
2017-06-16 05:51:01 +08:00
|
|
|
int Proximity = getRankProximity(Sec, *I);
|
|
|
|
for (; I != E; ++I) {
|
2017-07-28 03:22:43 +08:00
|
|
|
auto *CurSec = dyn_cast<OutputSection>(*I);
|
2018-02-23 18:53:04 +08:00
|
|
|
if (!CurSec)
|
2017-06-16 05:51:01 +08:00
|
|
|
continue;
|
2017-07-28 03:22:43 +08:00
|
|
|
if (getRankProximity(Sec, CurSec) != Proximity ||
|
|
|
|
Sec->SortRank < CurSec->SortRank)
|
2017-06-16 05:51:01 +08:00
|
|
|
break;
|
|
|
|
}
|
2017-10-23 08:51:08 +08:00
|
|
|
|
2018-02-23 18:53:04 +08:00
|
|
|
auto IsOutputSec = [](BaseCommand *Cmd) { return isa<OutputSection>(Cmd); };
|
2017-10-10 18:05:52 +08:00
|
|
|
auto J = std::find_if(llvm::make_reverse_iterator(I),
|
2018-02-23 18:53:04 +08:00
|
|
|
llvm::make_reverse_iterator(B), IsOutputSec);
|
2017-06-16 05:51:01 +08:00
|
|
|
I = J.base();
|
2017-09-20 01:29:58 +08:00
|
|
|
|
|
|
|
// As a special case, if the orphan section is the last section, put
|
|
|
|
// it at the very end, past any other commands.
|
|
|
|
// This matches bfd's behavior and is convenient when the linker script fully
|
|
|
|
// specifies the start of the file, but doesn't care about the end (the non
|
|
|
|
// alloc sections for example).
|
2018-02-23 18:53:04 +08:00
|
|
|
auto NextSec = std::find_if(I, E, IsOutputSec);
|
2017-09-20 01:29:58 +08:00
|
|
|
if (NextSec == E)
|
|
|
|
return E;
|
|
|
|
|
2017-06-16 05:51:01 +08:00
|
|
|
while (I != E && shouldSkip(*I))
|
2017-05-12 22:52:22 +08:00
|
|
|
++I;
|
|
|
|
return I;
|
2017-05-09 21:58:46 +08:00
|
|
|
}
|
|
|
|
|
2018-01-31 00:24:04 +08:00
|
|
|
// Builds section order for handling --symbol-ordering-file.
|
2018-02-14 09:42:26 +08:00
|
|
|
static DenseMap<const InputSectionBase *, int> buildSectionOrder() {
|
|
|
|
DenseMap<const InputSectionBase *, int> SectionOrder;
|
2018-04-18 07:30:05 +08:00
|
|
|
// Use the rarely used option -call-graph-ordering-file to sort sections.
|
|
|
|
if (!Config->CallGraphProfile.empty())
|
|
|
|
return computeCallGraphProfileOrder();
|
|
|
|
|
2018-01-31 00:24:04 +08:00
|
|
|
if (Config->SymbolOrderingFile.empty())
|
|
|
|
return SectionOrder;
|
|
|
|
|
2018-02-14 21:36:22 +08:00
|
|
|
struct SymbolOrderEntry {
|
|
|
|
int Priority;
|
|
|
|
bool Present;
|
|
|
|
};
|
|
|
|
|
2018-01-31 00:24:04 +08:00
|
|
|
// Build a map from symbols to their priorities. Symbols that didn't
|
|
|
|
// appear in the symbol ordering file have the lowest priority 0.
|
|
|
|
// All explicitly mentioned symbols have negative (higher) priorities.
|
2018-02-14 21:36:22 +08:00
|
|
|
DenseMap<StringRef, SymbolOrderEntry> SymbolOrder;
|
2018-01-31 00:24:04 +08:00
|
|
|
int Priority = -Config->SymbolOrderingFile.size();
|
|
|
|
for (StringRef S : Config->SymbolOrderingFile)
|
2018-02-14 21:36:22 +08:00
|
|
|
SymbolOrder.insert({S, {Priority++, false}});
|
2018-01-31 00:24:04 +08:00
|
|
|
|
|
|
|
// Build a map from sections to their priorities.
|
2018-04-06 11:36:19 +08:00
|
|
|
auto AddSym = [&](Symbol &Sym) {
|
|
|
|
auto It = SymbolOrder.find(Sym.getName());
|
|
|
|
if (It == SymbolOrder.end())
|
|
|
|
return;
|
|
|
|
SymbolOrderEntry &Ent = It->second;
|
|
|
|
Ent.Present = true;
|
|
|
|
|
2018-10-26 23:07:12 +08:00
|
|
|
maybeWarnUnorderableSymbol(&Sym);
|
2018-02-14 21:36:22 +08:00
|
|
|
|
2018-04-06 11:36:19 +08:00
|
|
|
if (auto *D = dyn_cast<Defined>(&Sym)) {
|
2018-03-08 01:24:46 +08:00
|
|
|
if (auto *Sec = dyn_cast_or_null<InputSectionBase>(D->Section)) {
|
|
|
|
int &Priority = SectionOrder[cast<InputSectionBase>(Sec->Repl)];
|
|
|
|
Priority = std::min(Priority, Ent.Priority);
|
2018-02-14 09:42:26 +08:00
|
|
|
}
|
2018-01-31 00:24:04 +08:00
|
|
|
}
|
2018-04-06 11:36:19 +08:00
|
|
|
};
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2018-04-06 11:36:19 +08:00
|
|
|
// We want both global and local symbols. We get the global ones from the
|
|
|
|
// symbol table and iterate the object files for the local ones.
|
|
|
|
for (Symbol *Sym : Symtab->getSymbols())
|
|
|
|
if (!Sym->isLazy())
|
|
|
|
AddSym(*Sym);
|
|
|
|
for (InputFile *File : ObjectFiles)
|
|
|
|
for (Symbol *Sym : File->getSymbols())
|
|
|
|
if (Sym->isLocal())
|
|
|
|
AddSym(*Sym);
|
2018-02-14 21:36:22 +08:00
|
|
|
|
|
|
|
if (Config->WarnSymbolOrdering)
|
|
|
|
for (auto OrderEntry : SymbolOrder)
|
|
|
|
if (!OrderEntry.second.Present)
|
|
|
|
warn("symbol ordering file: no such symbol: " + OrderEntry.first);
|
|
|
|
|
2018-01-31 00:24:04 +08:00
|
|
|
return SectionOrder;
|
|
|
|
}
|
|
|
|
|
2018-03-31 05:36:54 +08:00
|
|
|
// Sorts the sections in ISD according to the provided section order.
|
|
|
|
static void
|
|
|
|
sortISDBySectionOrder(InputSectionDescription *ISD,
|
|
|
|
const DenseMap<const InputSectionBase *, int> &Order) {
|
|
|
|
std::vector<InputSection *> UnorderedSections;
|
2018-04-04 03:45:10 +08:00
|
|
|
std::vector<std::pair<InputSection *, int>> OrderedSections;
|
2018-03-31 05:36:54 +08:00
|
|
|
uint64_t UnorderedSize = 0;
|
|
|
|
|
|
|
|
for (InputSection *IS : ISD->Sections) {
|
2018-04-04 03:45:10 +08:00
|
|
|
auto I = Order.find(IS);
|
|
|
|
if (I == Order.end()) {
|
2018-03-31 05:36:54 +08:00
|
|
|
UnorderedSections.push_back(IS);
|
|
|
|
UnorderedSize += IS->getSize();
|
|
|
|
continue;
|
|
|
|
}
|
2018-04-04 03:45:10 +08:00
|
|
|
OrderedSections.push_back({IS, I->second});
|
2018-03-31 05:36:54 +08:00
|
|
|
}
|
2018-09-27 04:54:42 +08:00
|
|
|
llvm::sort(OrderedSections, [&](std::pair<InputSection *, int> A,
|
|
|
|
std::pair<InputSection *, int> B) {
|
|
|
|
return A.second < B.second;
|
|
|
|
});
|
2018-03-31 05:36:54 +08:00
|
|
|
|
|
|
|
// Find an insertion point for the ordered section list in the unordered
|
|
|
|
// section list. On targets with limited-range branches, this is the mid-point
|
|
|
|
// of the unordered section list. This decreases the likelihood that a range
|
|
|
|
// extension thunk will be needed to enter or exit the ordered region. If the
|
|
|
|
// ordered section list is a list of hot functions, we can generally expect
|
|
|
|
// the ordered functions to be called more often than the unordered functions,
|
|
|
|
// making it more likely that any particular call will be within range, and
|
|
|
|
// therefore reducing the number of thunks required.
|
|
|
|
//
|
|
|
|
// For example, imagine that you have 8MB of hot code and 32MB of cold code.
|
|
|
|
// If the layout is:
|
|
|
|
//
|
|
|
|
// 8MB hot
|
|
|
|
// 32MB cold
|
|
|
|
//
|
|
|
|
// only the first 8-16MB of the cold code (depending on which hot function it
|
|
|
|
// is actually calling) can call the hot code without a range extension thunk.
|
|
|
|
// However, if we use this layout:
|
|
|
|
//
|
|
|
|
// 16MB cold
|
|
|
|
// 8MB hot
|
|
|
|
// 16MB cold
|
|
|
|
//
|
|
|
|
// both the last 8-16MB of the first block of cold code and the first 8-16MB
|
|
|
|
// of the second block of cold code can call the hot code without a thunk. So
|
|
|
|
// we effectively double the amount of code that could potentially call into
|
|
|
|
// the hot code without a thunk.
|
2018-04-04 04:08:45 +08:00
|
|
|
size_t InsPt = 0;
|
2018-08-20 17:37:50 +08:00
|
|
|
if (Target->getThunkSectionSpacing() && !OrderedSections.empty()) {
|
2018-03-31 05:36:54 +08:00
|
|
|
uint64_t UnorderedPos = 0;
|
2018-04-04 04:08:45 +08:00
|
|
|
for (; InsPt != UnorderedSections.size(); ++InsPt) {
|
|
|
|
UnorderedPos += UnorderedSections[InsPt]->getSize();
|
2018-03-31 05:36:54 +08:00
|
|
|
if (UnorderedPos > UnorderedSize / 2)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-04 04:08:45 +08:00
|
|
|
ISD->Sections.clear();
|
|
|
|
for (InputSection *IS : makeArrayRef(UnorderedSections).slice(0, InsPt))
|
|
|
|
ISD->Sections.push_back(IS);
|
2018-04-04 03:45:10 +08:00
|
|
|
for (std::pair<InputSection *, int> P : OrderedSections)
|
2018-04-04 04:08:45 +08:00
|
|
|
ISD->Sections.push_back(P.first);
|
|
|
|
for (InputSection *IS : makeArrayRef(UnorderedSections).slice(InsPt))
|
|
|
|
ISD->Sections.push_back(IS);
|
2018-03-31 05:36:54 +08:00
|
|
|
}
|
|
|
|
|
2018-02-10 00:09:22 +08:00
|
|
|
static void sortSection(OutputSection *Sec,
|
2018-02-14 09:42:26 +08:00
|
|
|
const DenseMap<const InputSectionBase *, int> &Order) {
|
2018-02-10 00:09:22 +08:00
|
|
|
StringRef Name = Sec->Name;
|
2018-01-31 00:20:08 +08:00
|
|
|
|
2017-10-30 18:12:49 +08:00
|
|
|
// Sort input sections by section name suffixes for
|
|
|
|
// __attribute__((init_priority(N))).
|
2018-02-10 00:09:22 +08:00
|
|
|
if (Name == ".init_array" || Name == ".fini_array") {
|
|
|
|
if (!Script->HasSectionsCommand)
|
|
|
|
Sec->sortInitFini();
|
|
|
|
return;
|
|
|
|
}
|
2017-10-30 18:12:49 +08:00
|
|
|
|
|
|
|
// Sort input sections by the special rule for .ctors and .dtors.
|
2018-02-10 00:09:22 +08:00
|
|
|
if (Name == ".ctors" || Name == ".dtors") {
|
|
|
|
if (!Script->HasSectionsCommand)
|
|
|
|
Sec->sortCtorsDtors();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Never sort these.
|
|
|
|
if (Name == ".init" || Name == ".fini")
|
|
|
|
return;
|
|
|
|
|
2019-01-25 02:17:40 +08:00
|
|
|
// .toc is allocated just after .got and is accessed using GOT-relative
|
|
|
|
// relocations. Object files compiled with small code model have an
|
|
|
|
// addressable range of [.got, .got + 0xFFFC] for GOT-relative relocations.
|
|
|
|
// To reduce the risk of relocation overflow, .toc contents are sorted so that
|
|
|
|
// sections having smaller relocation offsets are at beginning of .toc
|
|
|
|
if (Config->EMachine == EM_PPC64 && Name == ".toc") {
|
|
|
|
if (Script->HasSectionsCommand)
|
|
|
|
return;
|
|
|
|
assert(Sec->SectionCommands.size() == 1);
|
|
|
|
auto *ISD = cast<InputSectionDescription>(Sec->SectionCommands[0]);
|
|
|
|
std::stable_sort(ISD->Sections.begin(), ISD->Sections.end(),
|
|
|
|
[](const InputSection *A, const InputSection *B) -> bool {
|
2019-02-12 23:35:49 +08:00
|
|
|
return A->File->PPC64SmallCodeModelTocRelocs &&
|
|
|
|
!B->File->PPC64SmallCodeModelTocRelocs;
|
2019-01-25 02:17:40 +08:00
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-10 00:09:22 +08:00
|
|
|
// Sort input sections by priority using the list provided
|
|
|
|
// by --symbol-ordering-file.
|
|
|
|
if (!Order.empty())
|
2018-03-31 05:36:54 +08:00
|
|
|
for (BaseCommand *B : Sec->SectionCommands)
|
|
|
|
if (auto *ISD = dyn_cast<InputSectionDescription>(B))
|
|
|
|
sortISDBySectionOrder(ISD, Order);
|
2018-02-10 00:09:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If no layout was provided by linker script, we want to apply default
|
|
|
|
// sorting for special input sections. This also handles --symbol-ordering-file.
|
|
|
|
template <class ELFT> void Writer<ELFT>::sortInputSections() {
|
|
|
|
// Build the order once since it is expensive.
|
2018-02-14 09:42:26 +08:00
|
|
|
DenseMap<const InputSectionBase *, int> Order = buildSectionOrder();
|
2018-02-10 00:09:22 +08:00
|
|
|
for (BaseCommand *Base : Script->SectionCommands)
|
|
|
|
if (auto *Sec = dyn_cast<OutputSection>(Base))
|
|
|
|
sortSection(Sec, Order);
|
2017-10-30 18:12:49 +08:00
|
|
|
}
|
|
|
|
|
2016-09-22 06:36:19 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::sortSections() {
|
2017-10-02 17:11:13 +08:00
|
|
|
Script->adjustSectionsBeforeSorting();
|
2017-06-28 17:59:34 +08:00
|
|
|
|
2016-11-12 06:43:27 +08:00
|
|
|
// Don't sort if using -r. It is not necessary and we want to preserve the
|
|
|
|
// relative order for SHF_LINK_ORDER sections.
|
|
|
|
if (Config->Relocatable)
|
2017-06-29 06:44:11 +08:00
|
|
|
return;
|
2017-05-12 22:52:22 +08:00
|
|
|
|
2018-01-31 00:20:08 +08:00
|
|
|
sortInputSections();
|
2017-10-30 18:12:49 +08:00
|
|
|
|
2018-04-09 21:01:50 +08:00
|
|
|
for (BaseCommand *Base : Script->SectionCommands) {
|
|
|
|
auto *OS = dyn_cast<OutputSection>(Base);
|
|
|
|
if (!OS)
|
|
|
|
continue;
|
|
|
|
OS->SortRank = getSectionRank(OS);
|
|
|
|
|
|
|
|
// We want to assign rude approximation values to OutSecOff fields
|
|
|
|
// to know the relative order of the input sections. We use it for
|
|
|
|
// sorting SHF_LINK_ORDER sections. See resolveShfLinkOrder().
|
|
|
|
uint64_t I = 0;
|
|
|
|
for (InputSection *Sec : getInputSections(OS))
|
|
|
|
Sec->OutSecOff = I++;
|
|
|
|
}
|
|
|
|
|
2018-01-31 00:20:08 +08:00
|
|
|
if (!Script->HasSectionsCommand) {
|
2017-10-30 18:12:49 +08:00
|
|
|
// We know that all the OutputSections are contiguous in this case.
|
2017-07-28 03:22:43 +08:00
|
|
|
auto IsSection = [](BaseCommand *Base) { return isa<OutputSection>(Base); };
|
2018-04-11 17:03:02 +08:00
|
|
|
std::stable_sort(
|
|
|
|
llvm::find_if(Script->SectionCommands, IsSection),
|
|
|
|
llvm::find_if(llvm::reverse(Script->SectionCommands), IsSection).base(),
|
|
|
|
compareSections);
|
2016-09-22 06:36:19 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-16 05:51:01 +08:00
|
|
|
// Orphan sections are sections present in the input files which are
|
|
|
|
// not explicitly placed into the output file by the linker script.
|
|
|
|
//
|
|
|
|
// The sections in the linker script are already in the correct
|
|
|
|
// order. We have to figuere out where to insert the orphan
|
|
|
|
// sections.
|
|
|
|
//
|
2016-09-22 06:36:19 +08:00
|
|
|
// The order of the sections in the script is arbitrary and may not agree with
|
2017-06-16 05:51:01 +08:00
|
|
|
// compareSections. This means that we cannot easily define a strict weak
|
|
|
|
// ordering. To see why, consider a comparison of a section in the script and
|
|
|
|
// one not in the script. We have a two simple options:
|
2016-09-22 06:36:19 +08:00
|
|
|
// * Make them equivalent (a is not less than b, and b is not less than a).
|
|
|
|
// The problem is then that equivalence has to be transitive and we can
|
|
|
|
// have sections a, b and c with only b in a script and a less than c
|
|
|
|
// which breaks this property.
|
|
|
|
// * Use compareSectionsNonScript. Given that the script order doesn't have
|
|
|
|
// to match, we can end up with sections a, b, c, d where b and c are in the
|
|
|
|
// script and c is compareSectionsNonScript less than b. In which case d
|
|
|
|
// can be equivalent to c, a to b and d < a. As a concrete example:
|
|
|
|
// .a (rx) # not in script
|
|
|
|
// .b (rx) # in script
|
|
|
|
// .c (ro) # in script
|
|
|
|
// .d (ro) # not in script
|
|
|
|
//
|
|
|
|
// The way we define an order then is:
|
2017-06-16 05:51:01 +08:00
|
|
|
// * Sort only the orphan sections. They are in the end right now.
|
|
|
|
// * Move each orphan section to its preferred position. We try
|
2018-02-23 10:05:48 +08:00
|
|
|
// to put each section in the last position where it can share
|
2016-11-08 18:44:48 +08:00
|
|
|
// a PT_LOAD.
|
2017-06-16 05:51:01 +08:00
|
|
|
//
|
|
|
|
// There is some ambiguity as to where exactly a new entry should be
|
2017-10-11 09:19:33 +08:00
|
|
|
// inserted, because Commands contains not only output section
|
2017-06-16 05:51:01 +08:00
|
|
|
// commands but also other types of commands such as symbol assignment
|
|
|
|
// expressions. There's no correct answer here due to the lack of the
|
|
|
|
// formal specification of the linker script. We use heuristics to
|
|
|
|
// determine whether a new output command should be added before or
|
|
|
|
// after another commands. For the details, look at shouldSkip
|
|
|
|
// function.
|
|
|
|
|
2017-10-11 09:50:56 +08:00
|
|
|
auto I = Script->SectionCommands.begin();
|
|
|
|
auto E = Script->SectionCommands.end();
|
2017-06-16 05:51:01 +08:00
|
|
|
auto NonScriptI = std::find_if(I, E, [](BaseCommand *Base) {
|
2017-07-28 03:22:43 +08:00
|
|
|
if (auto *Sec = dyn_cast<OutputSection>(Base))
|
2018-03-08 03:25:36 +08:00
|
|
|
return Sec->SectionIndex == UINT32_MAX;
|
2017-06-16 05:51:01 +08:00
|
|
|
return false;
|
|
|
|
});
|
|
|
|
|
|
|
|
// Sort the orphan sections.
|
|
|
|
std::stable_sort(NonScriptI, E, compareSections);
|
2016-09-22 06:36:19 +08:00
|
|
|
|
2017-06-16 05:51:01 +08:00
|
|
|
// As a horrible special case, skip the first . assignment if it is before any
|
|
|
|
// section. We do this because it is common to set a load address by starting
|
|
|
|
// the script with ". = 0xabcd" and the expectation is that every section is
|
|
|
|
// after that.
|
|
|
|
auto FirstSectionOrDotAssignment =
|
|
|
|
std::find_if(I, E, [](BaseCommand *Cmd) { return !shouldSkip(Cmd); });
|
|
|
|
if (FirstSectionOrDotAssignment != E &&
|
|
|
|
isa<SymbolAssignment>(**FirstSectionOrDotAssignment))
|
|
|
|
++FirstSectionOrDotAssignment;
|
|
|
|
I = FirstSectionOrDotAssignment;
|
2016-09-22 06:36:19 +08:00
|
|
|
|
2017-05-12 22:52:22 +08:00
|
|
|
while (NonScriptI != E) {
|
2019-03-17 21:53:42 +08:00
|
|
|
auto Pos = findOrphanPos(I, NonScriptI);
|
2017-07-28 03:22:43 +08:00
|
|
|
OutputSection *Orphan = cast<OutputSection>(*NonScriptI);
|
2017-05-12 22:52:22 +08:00
|
|
|
|
|
|
|
// As an optimization, find all sections with the same sort rank
|
|
|
|
// and insert them with one rotate.
|
2017-06-16 05:51:01 +08:00
|
|
|
unsigned Rank = Orphan->SortRank;
|
|
|
|
auto End = std::find_if(NonScriptI + 1, E, [=](BaseCommand *Cmd) {
|
2017-07-28 03:22:43 +08:00
|
|
|
return cast<OutputSection>(Cmd)->SortRank != Rank;
|
2017-05-12 22:52:22 +08:00
|
|
|
});
|
|
|
|
std::rotate(Pos, NonScriptI, End);
|
|
|
|
NonScriptI = End;
|
|
|
|
}
|
2016-11-14 23:39:38 +08:00
|
|
|
|
2017-03-20 18:09:58 +08:00
|
|
|
Script->adjustSectionsAfterSorting();
|
2016-09-22 06:36:19 +08:00
|
|
|
}
|
|
|
|
|
2017-12-12 21:30:44 +08:00
|
|
|
static bool compareByFilePosition(InputSection *A, InputSection *B) {
|
|
|
|
InputSection *LA = A->getLinkOrderDep();
|
|
|
|
InputSection *LB = B->getLinkOrderDep();
|
|
|
|
OutputSection *AOut = LA->getParent();
|
|
|
|
OutputSection *BOut = LB->getParent();
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-12-12 21:30:44 +08:00
|
|
|
if (AOut != BOut)
|
|
|
|
return AOut->SectionIndex < BOut->SectionIndex;
|
|
|
|
return LA->OutSecOff < LB->OutSecOff;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void Writer<ELFT>::resolveShfLinkOrder() {
|
|
|
|
for (OutputSection *Sec : OutputSections) {
|
|
|
|
if (!(Sec->Flags & SHF_LINK_ORDER))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Link order may be distributed across several InputSectionDescriptions
|
|
|
|
// but sort must consider them all at once.
|
|
|
|
std::vector<InputSection **> ScriptSections;
|
|
|
|
std::vector<InputSection *> Sections;
|
|
|
|
for (BaseCommand *Base : Sec->SectionCommands) {
|
|
|
|
if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
|
|
|
|
for (InputSection *&IS : ISD->Sections) {
|
|
|
|
ScriptSections.push_back(&IS);
|
|
|
|
Sections.push_back(IS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-12-15 19:09:41 +08:00
|
|
|
|
2019-03-28 19:10:20 +08:00
|
|
|
// The ARM.exidx section use SHF_LINK_ORDER, but we have consolidated
|
|
|
|
// this processing inside the ARMExidxsyntheticsection::finalizeContents().
|
2017-12-20 16:56:10 +08:00
|
|
|
if (!Config->Relocatable && Config->EMachine == EM_ARM &&
|
2019-03-28 19:10:20 +08:00
|
|
|
Sec->Type == SHT_ARM_EXIDX)
|
|
|
|
continue;
|
2019-03-22 01:17:54 +08:00
|
|
|
|
2019-03-28 19:10:20 +08:00
|
|
|
std::stable_sort(Sections.begin(), Sections.end(), compareByFilePosition);
|
2017-12-15 19:09:41 +08:00
|
|
|
|
2017-12-12 21:30:44 +08:00
|
|
|
for (int I = 0, N = Sections.size(); I < N; ++I)
|
|
|
|
*ScriptSections[I] = Sections[I];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-24 06:03:33 +08:00
|
|
|
// For most RISC ISAs, we need to generate content that depends on the address
|
|
|
|
// of InputSections. For example some architectures such as AArch64 use small
|
|
|
|
// displacements for jump instructions that is the linker's responsibility for
|
|
|
|
// creating range extension thunks for. As the generation of the content may
|
|
|
|
// also alter InputSection addresses we must converge to a fixed point.
|
|
|
|
template <class ELFT> void Writer<ELFT>::maybeAddThunks() {
|
|
|
|
if (!Target->NeedsThunks && !Config->AndroidPackDynRelocs &&
|
|
|
|
!Config->RelrPackDynRelocs)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ThunkCreator TC;
|
|
|
|
AArch64Err843419Patcher A64P;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
bool Changed = false;
|
|
|
|
|
|
|
|
Script->assignAddresses();
|
|
|
|
|
|
|
|
if (Target->NeedsThunks)
|
|
|
|
Changed |= TC.createThunks(OutputSections);
|
|
|
|
|
|
|
|
if (Config->FixCortexA53Errata843419) {
|
|
|
|
if (Changed)
|
|
|
|
Script->assignAddresses();
|
|
|
|
Changed |= A64P.createFixes();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (In.MipsGot)
|
|
|
|
In.MipsGot->updateAllocSize();
|
|
|
|
|
|
|
|
Changed |= In.RelaDyn->updateAllocSize();
|
|
|
|
|
|
|
|
if (In.RelrDyn)
|
|
|
|
Changed |= In.RelrDyn->updateAllocSize();
|
|
|
|
|
|
|
|
if (!Changed)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-24 05:17:00 +08:00
|
|
|
static void finalizeSynthetic(SyntheticSection *Sec) {
|
2019-04-01 16:16:08 +08:00
|
|
|
if (Sec && Sec->isNeeded() && Sec->getParent())
|
2018-10-24 05:17:00 +08:00
|
|
|
Sec->finalizeContents();
|
2016-11-15 20:26:55 +08:00
|
|
|
}
|
|
|
|
|
2017-10-03 02:54:59 +08:00
|
|
|
// In order to allow users to manipulate linker-synthesized sections,
|
|
|
|
// we had to add synthetic sections to the input section list early,
|
|
|
|
// even before we make decisions whether they are needed. This allows
|
|
|
|
// users to write scripts like this: ".mygot : { .got }".
|
|
|
|
//
|
|
|
|
// Doing it has an unintended side effects. If it turns out that we
|
|
|
|
// don't need a .got (for example) at all because there's no
|
|
|
|
// relocation that needs a .got, we don't want to emit .got.
|
|
|
|
//
|
|
|
|
// To deal with the above problem, this function is called after
|
|
|
|
// scanRelocations is called to remove synthetic sections that turn
|
|
|
|
// out to be empty.
|
2017-07-04 00:54:39 +08:00
|
|
|
static void removeUnusedSyntheticSections() {
|
2017-02-03 21:06:18 +08:00
|
|
|
// All input synthetic sections that can be empty are placed after
|
|
|
|
// all regular ones. We iterate over them all and exit at first
|
|
|
|
// non-synthetic.
|
2017-02-27 10:32:08 +08:00
|
|
|
for (InputSectionBase *S : llvm::reverse(InputSections)) {
|
2017-02-27 10:56:02 +08:00
|
|
|
SyntheticSection *SS = dyn_cast<SyntheticSection>(S);
|
2016-12-06 05:39:35 +08:00
|
|
|
if (!SS)
|
2016-11-25 16:05:41 +08:00
|
|
|
return;
|
2017-06-01 04:17:44 +08:00
|
|
|
OutputSection *OS = SS->getParent();
|
2019-04-01 16:16:08 +08:00
|
|
|
if (!OS || SS->isNeeded())
|
2016-11-25 16:05:41 +08:00
|
|
|
continue;
|
2017-07-04 00:54:39 +08:00
|
|
|
|
2018-02-07 17:11:07 +08:00
|
|
|
// If we reach here, then SS is an unused synthetic section and we want to
|
|
|
|
// remove it from corresponding input section description of output section.
|
|
|
|
for (BaseCommand *B : OS->SectionCommands)
|
|
|
|
if (auto *ISD = dyn_cast<InputSectionDescription>(B))
|
2017-09-08 21:26:45 +08:00
|
|
|
llvm::erase_if(ISD->Sections,
|
|
|
|
[=](InputSection *IS) { return IS == SS; });
|
2016-11-25 16:05:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-10 23:05:37 +08:00
|
|
|
// Returns true if a symbol can be replaced at load-time by a symbol
|
|
|
|
// with the same name defined in other ELF executable or DSO.
|
2017-11-04 05:21:47 +08:00
|
|
|
static bool computeIsPreemptible(const Symbol &B) {
|
2017-08-10 23:05:37 +08:00
|
|
|
assert(!B.isLocal());
|
2018-10-25 06:15:32 +08:00
|
|
|
|
2017-08-10 23:05:37 +08:00
|
|
|
// Only symbols that appear in dynsym can be preempted.
|
2017-11-01 00:07:41 +08:00
|
|
|
if (!B.includeInDynsym())
|
2017-08-10 23:05:37 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Only default visibility symbols can be preempted.
|
2017-11-01 00:07:41 +08:00
|
|
|
if (B.Visibility != STV_DEFAULT)
|
2017-08-10 23:05:37 +08:00
|
|
|
return false;
|
|
|
|
|
2017-09-13 01:18:03 +08:00
|
|
|
// At this point copy relocations have not been created yet, so any
|
|
|
|
// symbol that is not defined locally is preemptible.
|
2017-11-06 12:39:07 +08:00
|
|
|
if (!B.isDefined())
|
2017-09-09 02:16:59 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// If we have a dynamic list it specifies which local symbols are preemptible.
|
2017-09-09 02:53:43 +08:00
|
|
|
if (Config->HasDynamicList)
|
2017-09-09 02:16:59 +08:00
|
|
|
return false;
|
|
|
|
|
2017-08-10 23:05:37 +08:00
|
|
|
if (!Config->Shared)
|
2017-09-09 02:16:59 +08:00
|
|
|
return false;
|
2017-08-10 23:05:37 +08:00
|
|
|
|
|
|
|
// -Bsymbolic means that definitions are not preempted.
|
|
|
|
if (Config->Bsymbolic || (Config->BsymbolicFunctions && B.isFunc()))
|
2017-09-09 02:23:25 +08:00
|
|
|
return false;
|
2017-08-10 23:05:37 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-07-20 22:43:20 +08:00
|
|
|
// Create output section objects and add them to OutputSections.
|
|
|
|
template <class ELFT> void Writer<ELFT>::finalizeSections() {
|
2017-07-28 03:22:43 +08:00
|
|
|
Out::PreinitArray = findSection(".preinit_array");
|
|
|
|
Out::InitArray = findSection(".init_array");
|
|
|
|
Out::FiniArray = findSection(".fini_array");
|
2015-10-03 03:37:55 +08:00
|
|
|
|
2015-12-26 17:48:00 +08:00
|
|
|
// The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop
|
|
|
|
// symbols for sections, so that the runtime can get the start and end
|
|
|
|
// addresses of each section by section name. Add such symbols.
|
2016-03-02 03:12:35 +08:00
|
|
|
if (!Config->Relocatable) {
|
|
|
|
addStartEndSymbols();
|
2017-10-11 09:50:56 +08:00
|
|
|
for (BaseCommand *Base : Script->SectionCommands)
|
2017-07-28 03:22:43 +08:00
|
|
|
if (auto *Sec = dyn_cast<OutputSection>(Base))
|
|
|
|
addStartStopSymbols(Sec);
|
2016-03-02 03:12:35 +08:00
|
|
|
}
|
2016-03-05 02:34:14 +08:00
|
|
|
|
|
|
|
// Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type.
|
|
|
|
// It should be okay as no one seems to care about the type.
|
|
|
|
// Even the author of gold doesn't remember why gold behaves that way.
|
|
|
|
// https://sourceware.org/ml/binutils/2002-03/msg00360.html
|
2018-12-10 17:24:49 +08:00
|
|
|
if (In.Dynamic->Parent)
|
2018-10-12 04:43:01 +08:00
|
|
|
Symtab->addDefined("_DYNAMIC", STV_HIDDEN, STT_NOTYPE, 0 /*Value*/,
|
2018-09-26 03:26:58 +08:00
|
|
|
/*Size=*/0, STB_WEAK, In.Dynamic,
|
2017-12-24 01:21:39 +08:00
|
|
|
/*File=*/nullptr);
|
2015-10-19 23:21:42 +08:00
|
|
|
|
2016-02-05 05:33:05 +08:00
|
|
|
// Define __rel[a]_iplt_{start,end} symbols if needed.
|
|
|
|
addRelIpltSymbols();
|
|
|
|
|
2018-08-10 01:59:56 +08:00
|
|
|
// RISC-V's gp can address +/- 2 KiB, set it to .sdata + 0x800 if not defined.
|
2018-10-24 05:00:28 +08:00
|
|
|
if (Config->EMachine == EM_RISCV)
|
|
|
|
if (!dyn_cast_or_null<Defined>(Symtab->find("__global_pointer$")))
|
|
|
|
addOptionalRegular("__global_pointer$", findSection(".sdata"), 0x800);
|
2018-08-10 01:59:56 +08:00
|
|
|
|
2017-02-24 06:06:28 +08:00
|
|
|
// This responsible for splitting up .eh_frame section into
|
2017-03-08 22:06:24 +08:00
|
|
|
// pieces. The relocation scan uses those pieces, so this has to be
|
2017-02-24 06:06:28 +08:00
|
|
|
// earlier.
|
2018-10-24 05:17:00 +08:00
|
|
|
finalizeSynthetic(In.EhFrame);
|
2016-04-07 22:22:09 +08:00
|
|
|
|
2017-11-04 05:21:47 +08:00
|
|
|
for (Symbol *S : Symtab->getSymbols())
|
2018-10-25 06:15:32 +08:00
|
|
|
if (!S->IsPreemptible)
|
|
|
|
S->IsPreemptible = computeIsPreemptible(*S);
|
2017-08-10 23:05:37 +08:00
|
|
|
|
2016-07-21 01:58:07 +08:00
|
|
|
// Scan relocations. This must be done after every symbol is declared so that
|
|
|
|
// we can correctly decide if a dynamic relocation is needed.
|
2017-09-13 15:54:47 +08:00
|
|
|
if (!Config->Relocatable)
|
|
|
|
forEachRelSec(scanRelocations<ELFT>);
|
2016-07-21 01:58:07 +08:00
|
|
|
|
2019-02-14 05:49:55 +08:00
|
|
|
addIRelativeRelocs();
|
|
|
|
|
2019-04-01 16:16:08 +08:00
|
|
|
if (In.Plt && In.Plt->isNeeded())
|
2018-09-26 03:26:58 +08:00
|
|
|
In.Plt->addSymbols();
|
2019-04-01 16:16:08 +08:00
|
|
|
if (In.Iplt && In.Iplt->isNeeded())
|
2018-09-26 03:26:58 +08:00
|
|
|
In.Iplt->addSymbols();
|
2017-01-25 18:31:16 +08:00
|
|
|
|
[ELF] Support --{,no-}allow-shlib-undefined
Summary:
In ld.bfd/gold, --no-allow-shlib-undefined is the default when linking
an executable. This patch implements a check to error on undefined
symbols in a shared object, if all of its DT_NEEDED entries are seen.
Our approach resembles the one used in gold, achieves a good balance to
be useful but not too smart (ld.bfd traces all DSOs and emulates the
behavior of a dynamic linker to catch more cases).
The error is issued based on the symbol table, different from undefined
reference errors issued for relocations. It is most effective when there
are DSOs that were not linked with -z defs (e.g. when static sanitizers
runtime is used).
gold has a comment that some system libraries on GNU/Linux may have
spurious undefined references and thus system libraries should be
excluded (https://sourceware.org/bugzilla/show_bug.cgi?id=6811). The
story may have changed now but we make --allow-shlib-undefined the
default for now. Its interaction with -shared can be discussed in the
future.
Reviewers: ruiu, grimar, pcc, espindola
Reviewed By: ruiu
Subscribers: joerg, emaste, arichardson, llvm-commits
Differential Revision: https://reviews.llvm.org/D57385
llvm-svn: 352826
2019-02-01 10:25:05 +08:00
|
|
|
if (!Config->AllowShlibUndefined) {
|
|
|
|
// Error on undefined symbols in a shared object, if all of its DT_NEEDED
|
|
|
|
// entires are seen. These cases would otherwise lead to runtime errors
|
|
|
|
// reported by the dynamic linker.
|
|
|
|
//
|
|
|
|
// ld.bfd traces all DT_NEEDED to emulate the logic of the dynamic linker to
|
|
|
|
// catch more cases. That is too much for us. Our approach resembles the one
|
|
|
|
// used in ld.gold, achieves a good balance to be useful but not too smart.
|
|
|
|
for (InputFile *File : SharedFiles) {
|
|
|
|
SharedFile<ELFT> *F = cast<SharedFile<ELFT>>(File);
|
|
|
|
F->AllNeededIsKnown = llvm::all_of(F->DtNeeded, [&](StringRef Needed) {
|
|
|
|
return Symtab->SoNames.count(Needed);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
for (Symbol *Sym : Symtab->getSymbols())
|
|
|
|
if (Sym->isUndefined() && !Sym->isWeak())
|
|
|
|
if (auto *F = dyn_cast_or_null<SharedFile<ELFT>>(Sym->File))
|
|
|
|
if (F->AllNeededIsKnown)
|
|
|
|
error(toString(F) + ": undefined reference to " + toString(*Sym));
|
|
|
|
}
|
|
|
|
|
2017-02-20 19:12:33 +08:00
|
|
|
// Now that we have defined all possible global symbols including linker-
|
2015-12-26 18:22:16 +08:00
|
|
|
// synthesized ones. Visit all symbols to give the finishing touches.
|
2017-11-04 05:21:47 +08:00
|
|
|
for (Symbol *Sym : Symtab->getSymbols()) {
|
2017-11-01 00:07:41 +08:00
|
|
|
if (!includeInSymtab(*Sym))
|
2015-09-23 07:38:23 +08:00
|
|
|
continue;
|
2018-09-26 03:26:58 +08:00
|
|
|
if (In.SymTab)
|
|
|
|
In.SymTab->addSymbol(Sym);
|
2015-09-23 07:38:23 +08:00
|
|
|
|
2018-12-03 22:44:02 +08:00
|
|
|
if (Sym->includeInDynsym()) {
|
2018-09-26 03:26:58 +08:00
|
|
|
In.DynSymTab->addSymbol(Sym);
|
2018-04-27 01:58:58 +08:00
|
|
|
if (auto *File = dyn_cast_or_null<SharedFile<ELFT>>(Sym->File))
|
|
|
|
if (File->IsNeeded && !Sym->isUndefined())
|
2019-03-06 11:07:48 +08:00
|
|
|
In.VerNeed->addSymbol(Sym);
|
2016-04-28 04:22:31 +08:00
|
|
|
}
|
2015-09-23 07:38:23 +08:00
|
|
|
}
|
2016-01-29 06:56:29 +08:00
|
|
|
|
|
|
|
// Do not proceed if there was an undefined symbol.
|
[lld] unified COFF and ELF error handling on new Common/ErrorHandler
Summary:
The COFF linker and the ELF linker have long had similar but separate
Error.h and Error.cpp files to implement error handling. This change
introduces new error handling code in Common/ErrorHandler.h, changes the
COFF and ELF linkers to use it, and removes the old, separate
implementations.
Reviewers: ruiu
Reviewed By: ruiu
Subscribers: smeenai, jyknight, emaste, sdardis, nemanjai, nhaehnle, mgorny, javed.absar, kbarton, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D39259
llvm-svn: 316624
2017-10-26 06:28:38 +08:00
|
|
|
if (errorCount())
|
2016-04-02 01:24:19 +08:00
|
|
|
return;
|
2016-01-29 06:56:29 +08:00
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
if (In.MipsGot)
|
2019-03-06 11:07:57 +08:00
|
|
|
In.MipsGot->build();
|
2018-06-11 15:24:31 +08:00
|
|
|
|
2017-07-04 00:54:39 +08:00
|
|
|
removeUnusedSyntheticSections();
|
|
|
|
|
2016-09-22 06:36:19 +08:00
|
|
|
sortSections();
|
2017-06-16 05:51:01 +08:00
|
|
|
|
|
|
|
// Now that we have the final list, create a list of all the
|
2017-07-28 03:22:43 +08:00
|
|
|
// OutputSections for convenience.
|
2017-10-11 09:50:56 +08:00
|
|
|
for (BaseCommand *Base : Script->SectionCommands)
|
2017-07-28 03:22:43 +08:00
|
|
|
if (auto *Sec = dyn_cast<OutputSection>(Base))
|
|
|
|
OutputSections.push_back(Sec);
|
2015-12-26 15:50:41 +08:00
|
|
|
|
2017-06-20 09:51:50 +08:00
|
|
|
// Prefer command line supplied address over other constraints.
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections) {
|
|
|
|
auto I = Config->SectionStartMap.find(Sec->Name);
|
2017-06-20 09:51:50 +08:00
|
|
|
if (I != Config->SectionStartMap.end())
|
2017-07-28 03:22:43 +08:00
|
|
|
Sec->AddrExpr = [=] { return I->second; };
|
2017-06-20 09:51:50 +08:00
|
|
|
}
|
|
|
|
|
2017-01-29 01:48:21 +08:00
|
|
|
// This is a bit of a hack. A value of 0 means undef, so we set it
|
2018-04-27 13:50:40 +08:00
|
|
|
// to 1 to make __ehdr_start defined. The section number is not
|
2017-01-29 01:48:21 +08:00
|
|
|
// particularly relevant.
|
2017-02-27 10:31:26 +08:00
|
|
|
Out::ElfHeader->SectionIndex = 1;
|
2017-01-29 01:48:21 +08:00
|
|
|
|
2018-10-24 21:42:33 +08:00
|
|
|
for (size_t I = 0, E = OutputSections.size(); I != E; ++I) {
|
|
|
|
OutputSection *Sec = OutputSections[I];
|
|
|
|
Sec->SectionIndex = I + 1;
|
2018-09-26 03:26:58 +08:00
|
|
|
Sec->ShName = In.ShStrTab->addString(Sec->Name);
|
2016-04-06 15:20:45 +08:00
|
|
|
}
|
2015-12-26 15:50:41 +08:00
|
|
|
|
2016-12-20 05:21:07 +08:00
|
|
|
// Binary and relocatable output does not have PHDRS.
|
|
|
|
// The headers have to be created before finalize as that can influence the
|
|
|
|
// image base and the dynamic section on mips includes the image base.
|
|
|
|
if (!Config->Relocatable && !Config->OFormatBinary) {
|
2017-06-14 07:26:31 +08:00
|
|
|
Phdrs = Script->hasPhdrsCommands() ? Script->createPhdrs() : createPhdrs();
|
2019-02-20 22:47:02 +08:00
|
|
|
if (Config->EMachine == EM_ARM) {
|
|
|
|
// PT_ARM_EXIDX is the ARM EHABI equivalent of PT_GNU_EH_FRAME
|
|
|
|
addPhdrForSection(Phdrs, SHT_ARM_EXIDX, PT_ARM_EXIDX, PF_R);
|
|
|
|
}
|
|
|
|
if (Config->EMachine == EM_MIPS) {
|
|
|
|
// Add separate segments for MIPS-specific sections.
|
|
|
|
addPhdrForSection(Phdrs, SHT_MIPS_REGINFO, PT_MIPS_REGINFO, PF_R);
|
|
|
|
addPhdrForSection(Phdrs, SHT_MIPS_OPTIONS, PT_MIPS_OPTIONS, PF_R);
|
|
|
|
addPhdrForSection(Phdrs, SHT_MIPS_ABIFLAGS, PT_MIPS_ABIFLAGS, PF_R);
|
|
|
|
}
|
2017-05-05 03:34:17 +08:00
|
|
|
Out::ProgramHeaders->Size = sizeof(Elf_Phdr) * Phdrs.size();
|
[ELF] Set Out::TlsPhdr earlier for encoding packed reloc tables
Summary:
For --pack-dyn-relocs=android, finalizeSections calls
LinkerScript::assignAddresses and
AndroidPackedRelocationSection::updateAllocSize in a loop,
where assignAddresses lays out the ELF image, then updateAllocSize
determines the size of the Android packed relocation table by encoding it.
Encoding the table requires knowing the values of relocation addends.
To get the addend of a TLS relocation, updateAllocSize can call getSymVA
on a TLS symbol before setPhdrs has initialized Out::TlsPhdr, producing an
error:
<file> has an STT_TLS symbol but doesn't have an SHF_TLS section
Fix the problem by initializing Out::TlsPhdr immediately after the program
headers are created. The segment's p_vaddr field isn't initialized until
setPhdrs, so use FirstSec->Addr, which is what setPhdrs would use.
FirstSec will typically refer to the .tdata or .tbss output section, whose
(tentative) address was computed by assignAddresses.
Android currently avoids this problem because it uses emutls and doesn't
support ELF TLS. This problem doesn't apply to --pack-dyn-relocs=relr
because SHR_RELR only handles relative relocations without explicit addends
or info.
Fixes https://bugs.llvm.org/show_bug.cgi?id=37841.
Reviewers: ruiu, pcc, chh, javed.absar, espindola
Subscribers: emaste, arichardson, llvm-commits, srhines
Differential Revision: https://reviews.llvm.org/D51671
llvm-svn: 342432
2018-09-18 08:24:48 +08:00
|
|
|
|
|
|
|
// Find the TLS segment. This happens before the section layout loop so that
|
|
|
|
// Android relocation packing can look up TLS symbol addresses.
|
|
|
|
for (PhdrEntry *P : Phdrs)
|
|
|
|
if (P->p_type == PT_TLS)
|
|
|
|
Out::TlsPhdr = P;
|
2016-12-20 05:21:07 +08:00
|
|
|
}
|
|
|
|
|
2017-09-13 00:38:01 +08:00
|
|
|
// Some symbols are defined in term of program headers. Now that we
|
|
|
|
// have the headers, we can find out which sections they point to.
|
|
|
|
setReservedSymbolSections();
|
|
|
|
|
2016-11-18 14:44:18 +08:00
|
|
|
// Dynamic section must be the last one in this list and dynamic
|
|
|
|
// symbol table section (DynSymTab) must be the first one.
|
2018-10-24 05:17:00 +08:00
|
|
|
finalizeSynthetic(In.DynSymTab);
|
2019-03-28 19:10:20 +08:00
|
|
|
finalizeSynthetic(In.ARMExidx);
|
2018-10-24 05:17:00 +08:00
|
|
|
finalizeSynthetic(In.Bss);
|
|
|
|
finalizeSynthetic(In.BssRelRo);
|
|
|
|
finalizeSynthetic(In.GnuHashTab);
|
|
|
|
finalizeSynthetic(In.HashTab);
|
|
|
|
finalizeSynthetic(In.SymTabShndx);
|
|
|
|
finalizeSynthetic(In.ShStrTab);
|
|
|
|
finalizeSynthetic(In.StrTab);
|
|
|
|
finalizeSynthetic(In.VerDef);
|
|
|
|
finalizeSynthetic(In.Got);
|
|
|
|
finalizeSynthetic(In.MipsGot);
|
|
|
|
finalizeSynthetic(In.IgotPlt);
|
|
|
|
finalizeSynthetic(In.GotPlt);
|
|
|
|
finalizeSynthetic(In.RelaDyn);
|
|
|
|
finalizeSynthetic(In.RelrDyn);
|
|
|
|
finalizeSynthetic(In.RelaIplt);
|
|
|
|
finalizeSynthetic(In.RelaPlt);
|
|
|
|
finalizeSynthetic(In.Plt);
|
|
|
|
finalizeSynthetic(In.Iplt);
|
|
|
|
finalizeSynthetic(In.EhFrameHdr);
|
2019-03-06 11:07:48 +08:00
|
|
|
finalizeSynthetic(In.VerSym);
|
|
|
|
finalizeSynthetic(In.VerNeed);
|
2018-10-24 05:17:00 +08:00
|
|
|
finalizeSynthetic(In.Dynamic);
|
2017-03-08 22:06:24 +08:00
|
|
|
|
2017-10-11 09:34:51 +08:00
|
|
|
if (!Script->HasSectionsCommand && !Config->Relocatable)
|
2017-09-06 22:02:14 +08:00
|
|
|
fixSectionAlignments();
|
|
|
|
|
2019-03-28 19:10:20 +08:00
|
|
|
// SHFLinkOrder processing must be processed after relative section placements are
|
|
|
|
// known but before addresses are allocated.
|
2017-12-12 21:30:44 +08:00
|
|
|
resolveShfLinkOrder();
|
|
|
|
|
2018-10-24 06:03:33 +08:00
|
|
|
// Jump instructions in many ISAs have small displacements, and therefore they
|
|
|
|
// cannot jump to arbitrary addresses in memory. For example, RISC-V JAL
|
|
|
|
// instruction can target only +-1 MiB from PC. It is a linker's
|
|
|
|
// responsibility to create and insert small pieces of code between sections
|
|
|
|
// to extend the ranges if jump targets are out of range. Such code pieces are
|
|
|
|
// called "thunks".
|
|
|
|
//
|
|
|
|
// We add thunks at this stage. We couldn't do this before this point because
|
|
|
|
// this is the earliest point where we know sizes of sections and their
|
|
|
|
// layouts (that are needed to determine if jump targets are in range).
|
|
|
|
maybeAddThunks();
|
2017-06-05 16:51:15 +08:00
|
|
|
|
2018-10-25 05:59:58 +08:00
|
|
|
// maybeAddThunks may have added local symbols to the static symbol table.
|
2018-10-24 05:17:00 +08:00
|
|
|
finalizeSynthetic(In.SymTab);
|
2018-11-15 01:56:43 +08:00
|
|
|
finalizeSynthetic(In.PPC64LongBranchTarget);
|
2018-04-11 17:24:27 +08:00
|
|
|
|
2017-03-08 22:06:24 +08:00
|
|
|
// Fill other section headers. The dynamic table is finalized
|
|
|
|
// at the end because some tags like RELSZ depend on result
|
|
|
|
// of finalizing other sections.
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
2019-03-06 11:07:57 +08:00
|
|
|
Sec->finalize();
|
2015-12-26 15:50:41 +08:00
|
|
|
}
|
|
|
|
|
2018-10-24 22:24:01 +08:00
|
|
|
// Ensure data sections are not mixed with executable sections when
|
|
|
|
// -execute-only is used. -execute-only is a feature to make pages executable
|
|
|
|
// but not readable, and the feature is currently supported only on AArch64.
|
|
|
|
template <class ELFT> void Writer<ELFT>::checkExecuteOnly() {
|
|
|
|
if (!Config->ExecuteOnly)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (OutputSection *OS : OutputSections)
|
|
|
|
if (OS->Flags & SHF_EXECINSTR)
|
|
|
|
for (InputSection *IS : getInputSections(OS))
|
|
|
|
if (!(IS->Flags & SHF_EXECINSTR))
|
2018-10-25 02:15:40 +08:00
|
|
|
error("cannot place " + toString(IS) + " into " + toString(OS->Name) +
|
|
|
|
": -execute-only does not support intermingling data and code");
|
2018-10-24 22:24:01 +08:00
|
|
|
}
|
|
|
|
|
2015-12-26 17:48:00 +08:00
|
|
|
// The linker is expected to define SECNAME_start and SECNAME_end
|
|
|
|
// symbols for a few sections. This function defines them.
|
|
|
|
template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
|
2018-05-18 11:01:06 +08:00
|
|
|
// If a section does not exist, there's ambiguity as to how we
|
|
|
|
// define _start and _end symbols for an init/fini section. Since
|
|
|
|
// the loader assume that the symbols are always defined, we need to
|
|
|
|
// always define them. But what value? The loader iterates over all
|
|
|
|
// pointers between _start and _end to run global ctors/dtors, so if
|
|
|
|
// the section is empty, their symbol values don't actually matter
|
|
|
|
// as long as _start and _end point to the same location.
|
|
|
|
//
|
|
|
|
// That said, we don't want to set the symbols to 0 (which is
|
|
|
|
// probably the simplest value) because that could cause some
|
|
|
|
// program to fail to link due to relocation overflow, if their
|
|
|
|
// program text is above 2 GiB. We use the address of the .text
|
|
|
|
// section instead to prevent that failure.
|
2018-10-24 01:52:44 +08:00
|
|
|
//
|
|
|
|
// In a rare sitaution, .text section may not exist. If that's the
|
|
|
|
// case, use the image base address as a last resort.
|
2018-05-18 11:01:06 +08:00
|
|
|
OutputSection *Default = findSection(".text");
|
|
|
|
if (!Default)
|
|
|
|
Default = Out::ElfHeader;
|
2018-10-24 01:52:44 +08:00
|
|
|
|
2018-05-18 11:01:06 +08:00
|
|
|
auto Define = [=](StringRef Start, StringRef End, OutputSection *OS) {
|
2017-03-14 00:40:20 +08:00
|
|
|
if (OS) {
|
2017-12-24 01:21:39 +08:00
|
|
|
addOptionalRegular(Start, OS, 0);
|
|
|
|
addOptionalRegular(End, OS, -1);
|
2017-03-14 00:40:20 +08:00
|
|
|
} else {
|
2018-05-18 11:01:06 +08:00
|
|
|
addOptionalRegular(Start, Default, 0);
|
|
|
|
addOptionalRegular(End, Default, 0);
|
2017-03-14 00:40:20 +08:00
|
|
|
}
|
2015-12-26 17:48:00 +08:00
|
|
|
};
|
|
|
|
|
2017-02-27 10:31:26 +08:00
|
|
|
Define("__preinit_array_start", "__preinit_array_end", Out::PreinitArray);
|
|
|
|
Define("__init_array_start", "__init_array_end", Out::InitArray);
|
|
|
|
Define("__fini_array_start", "__fini_array_end", Out::FiniArray);
|
2016-10-27 18:28:53 +08:00
|
|
|
|
2017-07-28 03:22:43 +08:00
|
|
|
if (OutputSection *Sec = findSection(".ARM.exidx"))
|
2016-10-27 18:28:53 +08:00
|
|
|
Define("__exidx_start", "__exidx_end", Sec);
|
2015-12-26 17:48:00 +08:00
|
|
|
}
|
|
|
|
|
2015-10-16 01:11:03 +08:00
|
|
|
// If a section name is valid as a C identifier (which is rare because of
|
|
|
|
// the leading '.'), linkers are expected to define __start_<secname> and
|
|
|
|
// __stop_<secname> symbols. They are at beginning and end of the section,
|
|
|
|
// respectively. This is not requested by the ELF standard, but GNU ld and
|
|
|
|
// gold provide the feature, and used by many programs.
|
|
|
|
template <class ELFT>
|
2017-02-24 23:07:30 +08:00
|
|
|
void Writer<ELFT>::addStartStopSymbols(OutputSection *Sec) {
|
2017-02-24 22:28:00 +08:00
|
|
|
StringRef S = Sec->Name;
|
2015-10-16 01:11:03 +08:00
|
|
|
if (!isValidCIdentifier(S))
|
|
|
|
return;
|
2018-03-20 22:22:10 +08:00
|
|
|
addOptionalRegular(Saver.save("__start_" + S), Sec, 0, STV_PROTECTED);
|
|
|
|
addOptionalRegular(Saver.save("__stop_" + S), Sec, -1, STV_PROTECTED);
|
2015-10-16 01:11:03 +08:00
|
|
|
}
|
|
|
|
|
2017-03-16 19:20:02 +08:00
|
|
|
static bool needsPtLoad(OutputSection *Sec) {
|
2018-04-05 21:23:59 +08:00
|
|
|
if (!(Sec->Flags & SHF_ALLOC) || Sec->Noload)
|
2016-02-11 07:29:38 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
|
|
|
|
// responsible for allocating space for them, not the PT_LOAD that
|
|
|
|
// contains the TLS initialization image.
|
2018-10-24 21:44:51 +08:00
|
|
|
if ((Sec->Flags & SHF_TLS) && Sec->Type == SHT_NOBITS)
|
2016-02-11 07:29:38 +08:00
|
|
|
return false;
|
|
|
|
return true;
|
2015-09-10 04:48:09 +08:00
|
|
|
}
|
|
|
|
|
2016-09-20 23:22:27 +08:00
|
|
|
// Linker scripts are responsible for aligning addresses. Unfortunately, most
|
|
|
|
// linker scripts are designed for creating two PT_LOADs only, one RX and one
|
|
|
|
// RW. This means that there is no alignment in the RO to RX transition and we
|
|
|
|
// cannot create a PT_LOAD there.
|
2017-04-06 05:37:09 +08:00
|
|
|
static uint64_t computeFlags(uint64_t Flags) {
|
2017-02-25 09:52:03 +08:00
|
|
|
if (Config->Omagic)
|
2016-11-29 17:43:51 +08:00
|
|
|
return PF_R | PF_W | PF_X;
|
[AArch64] Support execute-only LOAD segments.
Summary:
This adds an LLD flag to mark executable LOAD segments execute-only for AArch64 targets.
In AArch64 the expectation is that code is execute-only compatible, so this just adds a linker option to enforce this.
Patch by: ivanlozano (Ivan Lozano)
Reviewers: srhines, echristo, peter.smith, eugenis, javed.absar, espindola, ruiu
Reviewed By: ruiu
Subscribers: dokyungs, emaste, arichardson, kristof.beyls, llvm-commits
Differential Revision: https://reviews.llvm.org/D49456
llvm-svn: 338271
2018-07-31 01:02:46 +08:00
|
|
|
if (Config->ExecuteOnly && (Flags & PF_X))
|
|
|
|
return Flags & ~PF_R;
|
2017-04-06 05:37:09 +08:00
|
|
|
if (Config->SingleRoRx && !(Flags & PF_W))
|
|
|
|
return Flags | PF_X;
|
|
|
|
return Flags;
|
2016-09-20 23:22:27 +08:00
|
|
|
}
|
|
|
|
|
2016-02-11 06:43:13 +08:00
|
|
|
// Decide which program headers to create and which sections to include in each
|
|
|
|
// one.
|
2017-07-27 15:46:50 +08:00
|
|
|
template <class ELFT> std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs() {
|
|
|
|
std::vector<PhdrEntry *> Ret;
|
2016-12-20 01:01:01 +08:00
|
|
|
auto AddHdr = [&](unsigned Type, unsigned Flags) -> PhdrEntry * {
|
2017-07-27 15:46:50 +08:00
|
|
|
Ret.push_back(make<PhdrEntry>(Type, Flags));
|
|
|
|
return Ret.back();
|
2016-02-11 06:43:13 +08:00
|
|
|
};
|
2015-09-10 04:48:09 +08:00
|
|
|
|
2015-10-24 05:45:59 +08:00
|
|
|
// The first phdr entry is PT_PHDR which describes the program header itself.
|
2017-02-27 10:31:26 +08:00
|
|
|
AddHdr(PT_PHDR, PF_R)->add(Out::ProgramHeaders);
|
2015-08-13 23:23:46 +08:00
|
|
|
|
2015-10-24 05:45:59 +08:00
|
|
|
// PT_INTERP must be the second entry if exists.
|
2017-07-28 03:22:43 +08:00
|
|
|
if (OutputSection *Cmd = findSection(".interp"))
|
|
|
|
AddHdr(PT_INTERP, Cmd->getPhdrFlags())->add(Cmd);
|
2015-09-12 02:49:42 +08:00
|
|
|
|
2015-10-24 05:45:59 +08:00
|
|
|
// Add the first PT_LOAD segment for regular output sections.
|
2017-04-06 05:37:09 +08:00
|
|
|
uint64_t Flags = computeFlags(PF_R);
|
2016-12-20 01:01:01 +08:00
|
|
|
PhdrEntry *Load = AddHdr(PT_LOAD, Flags);
|
2017-05-05 03:34:17 +08:00
|
|
|
|
|
|
|
// Add the headers. We will remove them if they don't fit.
|
|
|
|
Load->add(Out::ElfHeader);
|
|
|
|
Load->add(Out::ProgramHeaders);
|
|
|
|
|
[ELF] Split RW PT_LOAD on the PT_GNU_RELRO boundary
Summary:
Based on Peter Collingbourne's suggestion in D56828.
Before D56828: PT_LOAD(.data PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) .bss)
Old: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) .data .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro)) PT_LOAD(.data. .bss)
The new layout reflects the runtime memory mappings.
By having two PT_LOAD segments, we can utilize the NOBITS part of the
first PT_LOAD and save bytes for .bss.rel.ro.
.bss.rel.ro is currently small and only used by copy relocations of
symbols in read-only segments, but it can be used for other purposes in
the future, e.g. if a relro section's statically relocated data is all
zeros, we can move it to .bss.rel.ro.
Reviewers: espindola, ruiu, pcc
Reviewed By: ruiu
Subscribers: nemanjai, jvesely, nhaehnle, javed.absar, kbarton, emaste, arichardson, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D58892
llvm-svn: 356226
2019-03-15 09:29:57 +08:00
|
|
|
// PT_GNU_RELRO includes all sections that should be marked as
|
|
|
|
// read-only by dynamic linker after proccessing relocations.
|
|
|
|
// Current dynamic loaders only support one PT_GNU_RELRO PHDR, give
|
|
|
|
// an error message if more than one PT_GNU_RELRO PHDR is required.
|
|
|
|
PhdrEntry *RelRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R);
|
|
|
|
bool InRelroPhdr = false;
|
|
|
|
OutputSection *RelroEnd = nullptr;
|
|
|
|
for (OutputSection *Sec : OutputSections) {
|
|
|
|
if (!needsPtLoad(Sec))
|
|
|
|
continue;
|
|
|
|
if (isRelroSection(Sec)) {
|
|
|
|
InRelroPhdr = true;
|
|
|
|
if (!RelroEnd)
|
|
|
|
RelRo->add(Sec);
|
|
|
|
else
|
|
|
|
error("section: " + Sec->Name + " is not contiguous with other relro" +
|
|
|
|
" sections");
|
|
|
|
} else if (InRelroPhdr) {
|
|
|
|
InRelroPhdr = false;
|
|
|
|
RelroEnd = Sec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections) {
|
2016-11-09 09:42:41 +08:00
|
|
|
if (!(Sec->Flags & SHF_ALLOC))
|
2016-09-17 05:29:07 +08:00
|
|
|
break;
|
2017-03-16 19:20:02 +08:00
|
|
|
if (!needsPtLoad(Sec))
|
2016-02-11 07:29:38 +08:00
|
|
|
continue;
|
|
|
|
|
2016-08-17 15:44:19 +08:00
|
|
|
// Segments are contiguous memory regions that has the same attributes
|
|
|
|
// (e.g. executable or writable). There is one phdr for each segment.
|
|
|
|
// Therefore, we need to create a new phdr when the next section has
|
2018-08-02 16:07:07 +08:00
|
|
|
// different flags or is loaded at a discontiguous address or memory
|
|
|
|
// region using AT or AT> linker script command, respectively. At the same
|
|
|
|
// time, we don't want to create a separate load segment for the headers,
|
|
|
|
// even if the first output section has an AT or AT> attribute.
|
2017-04-06 05:37:09 +08:00
|
|
|
uint64_t NewFlags = computeFlags(Sec->getPhdrFlags());
|
2018-08-02 16:07:07 +08:00
|
|
|
if (((Sec->LMAExpr ||
|
|
|
|
(Sec->LMARegion && (Sec->LMARegion != Load->FirstSec->LMARegion))) &&
|
|
|
|
Load->LastSec != Out::ProgramHeaders) ||
|
[ELF] Split RW PT_LOAD on the PT_GNU_RELRO boundary
Summary:
Based on Peter Collingbourne's suggestion in D56828.
Before D56828: PT_LOAD(.data PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) .bss)
Old: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) .data .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro)) PT_LOAD(.data. .bss)
The new layout reflects the runtime memory mappings.
By having two PT_LOAD segments, we can utilize the NOBITS part of the
first PT_LOAD and save bytes for .bss.rel.ro.
.bss.rel.ro is currently small and only used by copy relocations of
symbols in read-only segments, but it can be used for other purposes in
the future, e.g. if a relro section's statically relocated data is all
zeros, we can move it to .bss.rel.ro.
Reviewers: espindola, ruiu, pcc
Reviewed By: ruiu
Subscribers: nemanjai, jvesely, nhaehnle, javed.absar, kbarton, emaste, arichardson, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D58892
llvm-svn: 356226
2019-03-15 09:29:57 +08:00
|
|
|
Sec->MemRegion != Load->FirstSec->MemRegion || Flags != NewFlags ||
|
|
|
|
Sec == RelroEnd) {
|
2016-03-10 05:37:22 +08:00
|
|
|
Load = AddHdr(PT_LOAD, NewFlags);
|
2016-02-11 06:43:13 +08:00
|
|
|
Flags = NewFlags;
|
2015-08-13 23:31:17 +08:00
|
|
|
}
|
2015-08-12 08:00:24 +08:00
|
|
|
|
2016-07-21 03:36:41 +08:00
|
|
|
Load->add(Sec);
|
2015-11-05 10:00:35 +08:00
|
|
|
}
|
2015-11-03 08:34:39 +08:00
|
|
|
|
2017-02-02 06:42:17 +08:00
|
|
|
// Add a TLS segment if any.
|
2017-07-27 15:46:50 +08:00
|
|
|
PhdrEntry *TlsHdr = make<PhdrEntry>(PT_TLS, PF_R);
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
2017-02-02 06:42:17 +08:00
|
|
|
if (Sec->Flags & SHF_TLS)
|
2017-07-27 15:46:50 +08:00
|
|
|
TlsHdr->add(Sec);
|
2017-09-07 19:01:10 +08:00
|
|
|
if (TlsHdr->FirstSec)
|
2017-07-27 15:46:50 +08:00
|
|
|
Ret.push_back(TlsHdr);
|
2016-02-11 06:43:13 +08:00
|
|
|
|
2015-10-24 05:45:59 +08:00
|
|
|
// Add an entry for .dynamic.
|
2018-12-10 17:24:49 +08:00
|
|
|
if (OutputSection *Sec = In.Dynamic->getParent())
|
|
|
|
AddHdr(PT_DYNAMIC, Sec->getPhdrFlags())->add(Sec);
|
2015-08-12 09:45:28 +08:00
|
|
|
|
2017-09-07 19:01:10 +08:00
|
|
|
if (RelRo->FirstSec)
|
2017-07-27 15:46:50 +08:00
|
|
|
Ret.push_back(RelRo);
|
2015-11-24 18:15:50 +08:00
|
|
|
|
2016-02-11 06:43:13 +08:00
|
|
|
// PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
|
2019-04-01 16:16:08 +08:00
|
|
|
if (In.EhFrame->isNeeded() && In.EhFrameHdr && In.EhFrame->getParent() &&
|
2018-09-26 03:26:58 +08:00
|
|
|
In.EhFrameHdr->getParent())
|
|
|
|
AddHdr(PT_GNU_EH_FRAME, In.EhFrameHdr->getParent()->getPhdrFlags())
|
|
|
|
->add(In.EhFrameHdr->getParent());
|
2016-01-15 21:34:52 +08:00
|
|
|
|
2017-03-24 08:15:57 +08:00
|
|
|
// PT_OPENBSD_RANDOMIZE is an OpenBSD-specific feature. That makes
|
|
|
|
// the dynamic linker fill the segment with random data.
|
2017-07-28 03:22:43 +08:00
|
|
|
if (OutputSection *Cmd = findSection(".openbsd.randomdata"))
|
|
|
|
AddHdr(PT_OPENBSD_RANDOMIZE, Cmd->getPhdrFlags())->add(Cmd);
|
2016-10-14 21:02:22 +08:00
|
|
|
|
2015-11-22 06:19:32 +08:00
|
|
|
// PT_GNU_STACK is a special section to tell the loader to make the
|
2017-02-23 16:09:51 +08:00
|
|
|
// pages for the stack non-executable. If you really want an executable
|
|
|
|
// stack, you can pass -z execstack, but that's not recommended for
|
|
|
|
// security reasons.
|
2018-03-23 22:43:51 +08:00
|
|
|
unsigned Perm = PF_R | PF_W;
|
2017-02-23 16:09:51 +08:00
|
|
|
if (Config->ZExecstack)
|
2018-03-23 22:43:51 +08:00
|
|
|
Perm |= PF_X;
|
2017-02-23 16:09:51 +08:00
|
|
|
AddHdr(PT_GNU_STACK, Perm)->p_memsz = Config->ZStackSize;
|
2016-03-01 21:23:29 +08:00
|
|
|
|
2016-10-14 18:34:36 +08:00
|
|
|
// PT_OPENBSD_WXNEEDED is a OpenBSD-specific header to mark the executable
|
|
|
|
// is expected to perform W^X violations, such as calling mprotect(2) or
|
|
|
|
// mmap(2) with PROT_WRITE | PROT_EXEC, which is prohibited by default on
|
|
|
|
// OpenBSD.
|
|
|
|
if (Config->ZWxneeded)
|
|
|
|
AddHdr(PT_OPENBSD_WXNEEDED, PF_X);
|
|
|
|
|
2017-02-02 04:58:41 +08:00
|
|
|
// Create one PT_NOTE per a group of contiguous .note sections.
|
|
|
|
PhdrEntry *Note = nullptr;
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections) {
|
2018-05-10 19:12:18 +08:00
|
|
|
if (Sec->Type == SHT_NOTE && (Sec->Flags & SHF_ALLOC)) {
|
2017-07-28 03:22:43 +08:00
|
|
|
if (!Note || Sec->LMAExpr)
|
2017-02-02 04:58:41 +08:00
|
|
|
Note = AddHdr(PT_NOTE, PF_R);
|
|
|
|
Note->add(Sec);
|
|
|
|
} else {
|
|
|
|
Note = nullptr;
|
|
|
|
}
|
|
|
|
}
|
2016-07-21 03:36:39 +08:00
|
|
|
return Ret;
|
2016-02-11 06:43:13 +08:00
|
|
|
}
|
|
|
|
|
2016-11-28 08:40:21 +08:00
|
|
|
template <class ELFT>
|
2019-02-20 22:47:02 +08:00
|
|
|
void Writer<ELFT>::addPhdrForSection(std::vector<PhdrEntry *> &Phdrs,
|
|
|
|
unsigned ShType, unsigned PType,
|
|
|
|
unsigned PFlags) {
|
|
|
|
auto I = llvm::find_if(
|
|
|
|
OutputSections, [=](OutputSection *Cmd) { return Cmd->Type == ShType; });
|
2017-07-28 03:22:43 +08:00
|
|
|
if (I == OutputSections.end())
|
2016-11-28 08:40:21 +08:00
|
|
|
return;
|
|
|
|
|
2019-02-20 22:47:02 +08:00
|
|
|
PhdrEntry *Entry = make<PhdrEntry>(PType, PFlags);
|
|
|
|
Entry->add(*I);
|
|
|
|
Phdrs.push_back(Entry);
|
2016-11-28 08:40:21 +08:00
|
|
|
}
|
|
|
|
|
2017-01-10 09:21:30 +08:00
|
|
|
// The first section of each PT_LOAD, the first section in PT_GNU_RELRO and the
|
|
|
|
// first section after PT_GNU_RELRO have to be page aligned so that the dynamic
|
|
|
|
// linker can set the permissions.
|
2016-03-31 03:41:51 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::fixSectionAlignments() {
|
2017-07-28 03:22:43 +08:00
|
|
|
auto PageAlign = [](OutputSection *Cmd) {
|
2017-06-02 09:37:58 +08:00
|
|
|
if (Cmd && !Cmd->AddrExpr)
|
|
|
|
Cmd->AddrExpr = [=] {
|
|
|
|
return alignTo(Script->getDot(), Config->MaxPageSize);
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2017-07-27 15:46:50 +08:00
|
|
|
for (const PhdrEntry *P : Phdrs)
|
2017-09-07 19:01:10 +08:00
|
|
|
if (P->p_type == PT_LOAD && P->FirstSec)
|
|
|
|
PageAlign(P->FirstSec);
|
2016-03-31 03:41:51 +08:00
|
|
|
|
2017-07-27 15:46:50 +08:00
|
|
|
for (const PhdrEntry *P : Phdrs) {
|
|
|
|
if (P->p_type != PT_GNU_RELRO)
|
2016-03-31 03:41:51 +08:00
|
|
|
continue;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-09-07 19:01:10 +08:00
|
|
|
if (P->FirstSec)
|
|
|
|
PageAlign(P->FirstSec);
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2016-03-31 03:41:51 +08:00
|
|
|
// Find the first section after PT_GNU_RELRO. If it is in a PT_LOAD we
|
|
|
|
// have to align it to a page.
|
2017-07-28 03:22:43 +08:00
|
|
|
auto End = OutputSections.end();
|
2019-03-30 00:21:16 +08:00
|
|
|
auto I = llvm::find(OutputSections, P->LastSec);
|
2016-03-31 03:41:51 +08:00
|
|
|
if (I == End || (I + 1) == End)
|
|
|
|
continue;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-07-28 03:22:43 +08:00
|
|
|
OutputSection *Cmd = (*(I + 1));
|
|
|
|
if (needsPtLoad(Cmd))
|
|
|
|
PageAlign(Cmd);
|
2016-03-31 03:41:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-24 23:47:46 +08:00
|
|
|
// Compute an in-file position for a given section. The file offset must be the
|
|
|
|
// same with its virtual address modulo the page size, so that the loader can
|
|
|
|
// load executables without any address adjustment.
|
|
|
|
static uint64_t computeFileOffset(OutputSection *OS, uint64_t Off) {
|
|
|
|
// File offsets are not significant for .bss sections. By convention, we keep
|
|
|
|
// section offsets monotonically increasing rather than setting to zero.
|
|
|
|
if (OS->Type == SHT_NOBITS)
|
2018-01-03 00:46:30 +08:00
|
|
|
return Off;
|
|
|
|
|
|
|
|
// If the section is not in a PT_LOAD, we just have to align it.
|
2018-10-24 23:47:46 +08:00
|
|
|
if (!OS->PtLoad)
|
|
|
|
return alignTo(Off, OS->Alignment);
|
|
|
|
|
|
|
|
// The first section in a PT_LOAD has to have congruent offset and address
|
|
|
|
// module the page size.
|
|
|
|
OutputSection *First = OS->PtLoad->FirstSec;
|
|
|
|
if (OS == First) {
|
|
|
|
uint64_t Alignment = std::max<uint64_t>(OS->Alignment, Config->MaxPageSize);
|
|
|
|
return alignTo(Off, Alignment, OS->Addr);
|
|
|
|
}
|
2018-01-03 00:46:30 +08:00
|
|
|
|
2016-12-08 04:20:39 +08:00
|
|
|
// If two sections share the same PT_LOAD the file offset is calculated
|
|
|
|
// using this formula: Off2 = Off1 + (VA2 - VA1).
|
2018-10-24 23:47:46 +08:00
|
|
|
return First->Offset + OS->Addr - First->Addr;
|
2016-04-27 17:16:28 +08:00
|
|
|
}
|
|
|
|
|
2018-10-24 23:47:46 +08:00
|
|
|
// Set an in-file position to a given section and returns the end position of
|
|
|
|
// the section.
|
|
|
|
static uint64_t setFileOffset(OutputSection *OS, uint64_t Off) {
|
|
|
|
Off = computeFileOffset(OS, Off);
|
|
|
|
OS->Offset = Off;
|
2018-01-03 00:46:30 +08:00
|
|
|
|
2018-10-24 23:47:46 +08:00
|
|
|
if (OS->Type == SHT_NOBITS)
|
2018-01-03 00:46:30 +08:00
|
|
|
return Off;
|
2018-10-24 23:47:46 +08:00
|
|
|
return Off + OS->Size;
|
2016-08-25 17:05:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void Writer<ELFT>::assignFileOffsetsBinary() {
|
2017-04-06 05:37:09 +08:00
|
|
|
uint64_t Off = 0;
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
2016-11-09 09:42:41 +08:00
|
|
|
if (Sec->Flags & SHF_ALLOC)
|
2018-10-24 23:47:46 +08:00
|
|
|
Off = setFileOffset(Sec, Off);
|
2017-04-06 05:37:09 +08:00
|
|
|
FileSize = alignTo(Off, Config->Wordsize);
|
2016-08-25 17:05:47 +08:00
|
|
|
}
|
|
|
|
|
2018-03-13 16:47:17 +08:00
|
|
|
static std::string rangeToString(uint64_t Addr, uint64_t Len) {
|
|
|
|
return "[0x" + utohexstr(Addr) + ", 0x" + utohexstr(Addr + Len - 1) + "]";
|
|
|
|
}
|
|
|
|
|
2016-04-02 01:07:17 +08:00
|
|
|
// Assign file offsets to output sections.
|
|
|
|
template <class ELFT> void Writer<ELFT>::assignFileOffsets() {
|
2017-04-06 05:37:09 +08:00
|
|
|
uint64_t Off = 0;
|
2018-10-24 23:47:46 +08:00
|
|
|
Off = setFileOffset(Out::ElfHeader, Off);
|
|
|
|
Off = setFileOffset(Out::ProgramHeaders, Off);
|
2016-04-06 15:20:45 +08:00
|
|
|
|
2017-08-03 00:35:00 +08:00
|
|
|
PhdrEntry *LastRX = nullptr;
|
|
|
|
for (PhdrEntry *P : Phdrs)
|
|
|
|
if (P->p_type == PT_LOAD && (P->p_flags & PF_X))
|
|
|
|
LastRX = P;
|
|
|
|
|
|
|
|
for (OutputSection *Sec : OutputSections) {
|
2018-10-24 23:47:46 +08:00
|
|
|
Off = setFileOffset(Sec, Off);
|
2017-10-11 09:34:51 +08:00
|
|
|
if (Script->HasSectionsCommand)
|
2017-08-03 00:35:00 +08:00
|
|
|
continue;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-08-03 00:35:00 +08:00
|
|
|
// If this is a last section of the last executable segment and that
|
|
|
|
// segment is the last loadable segment, align the offset of the
|
|
|
|
// following section to avoid loading non-segments parts of the file.
|
2017-09-07 19:01:10 +08:00
|
|
|
if (LastRX && LastRX->LastSec == Sec)
|
2017-08-03 00:35:00 +08:00
|
|
|
Off = alignTo(Off, Target->PageSize);
|
|
|
|
}
|
2016-07-01 18:27:36 +08:00
|
|
|
|
2017-04-06 05:37:09 +08:00
|
|
|
SectionHeaderOff = alignTo(Off, Config->Wordsize);
|
2017-07-28 03:22:43 +08:00
|
|
|
FileSize = SectionHeaderOff + (OutputSections.size() + 1) * sizeof(Elf_Shdr);
|
2018-03-13 16:47:17 +08:00
|
|
|
|
|
|
|
// Our logic assumes that sections have rising VA within the same segment.
|
|
|
|
// With use of linker scripts it is possible to violate this rule and get file
|
|
|
|
// offset overlaps or overflows. That should never happen with a valid script
|
|
|
|
// which does not move the location counter backwards and usually scripts do
|
|
|
|
// not do that. Unfortunately, there are apps in the wild, for example, Linux
|
|
|
|
// kernel, which control segment distribution explicitly and move the counter
|
|
|
|
// backwards, so we have to allow doing that to support linking them. We
|
2018-04-03 20:28:53 +08:00
|
|
|
// perform non-critical checks for overlaps in checkSectionOverlap(), but here
|
|
|
|
// we want to prevent file size overflows because it would crash the linker.
|
2018-03-13 16:47:17 +08:00
|
|
|
for (OutputSection *Sec : OutputSections) {
|
|
|
|
if (Sec->Type == SHT_NOBITS)
|
|
|
|
continue;
|
|
|
|
if ((Sec->Offset > FileSize) || (Sec->Offset + Sec->Size > FileSize))
|
|
|
|
error("unable to place section " + Sec->Name + " at file offset " +
|
2018-08-04 18:34:52 +08:00
|
|
|
rangeToString(Sec->Offset, Sec->Size) +
|
2018-03-13 16:47:17 +08:00
|
|
|
"; check your linker script for overflows");
|
|
|
|
}
|
2016-04-01 18:49:14 +08:00
|
|
|
}
|
|
|
|
|
2016-04-02 01:07:17 +08:00
|
|
|
// Finalize the program headers. We call this function after we assign
|
|
|
|
// file offsets and VAs to all sections.
|
|
|
|
template <class ELFT> void Writer<ELFT>::setPhdrs() {
|
2017-07-27 15:46:50 +08:00
|
|
|
for (PhdrEntry *P : Phdrs) {
|
2017-09-07 19:01:10 +08:00
|
|
|
OutputSection *First = P->FirstSec;
|
|
|
|
OutputSection *Last = P->LastSec;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2016-04-02 06:42:04 +08:00
|
|
|
if (First) {
|
2017-07-27 15:46:50 +08:00
|
|
|
P->p_filesz = Last->Offset - First->Offset;
|
2016-11-09 09:42:41 +08:00
|
|
|
if (Last->Type != SHT_NOBITS)
|
2017-07-27 15:46:50 +08:00
|
|
|
P->p_filesz += Last->Size;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-07-27 15:46:50 +08:00
|
|
|
P->p_memsz = Last->Addr + Last->Size - First->Addr;
|
|
|
|
P->p_offset = First->Offset;
|
|
|
|
P->p_vaddr = First->Addr;
|
2018-10-25 05:59:58 +08:00
|
|
|
|
2017-07-27 15:46:50 +08:00
|
|
|
if (!P->HasLMA)
|
|
|
|
P->p_paddr = First->getLMA();
|
2016-02-11 06:43:13 +08:00
|
|
|
}
|
2018-10-25 05:59:58 +08:00
|
|
|
|
|
|
|
if (P->p_type == PT_LOAD) {
|
2017-07-27 15:46:50 +08:00
|
|
|
P->p_align = std::max<uint64_t>(P->p_align, Config->MaxPageSize);
|
2018-10-25 05:59:58 +08:00
|
|
|
} else if (P->p_type == PT_GNU_RELRO) {
|
2017-07-27 15:46:50 +08:00
|
|
|
P->p_align = 1;
|
2017-01-05 02:56:15 +08:00
|
|
|
// The glibc dynamic loader rounds the size down, so we need to round up
|
|
|
|
// to protect the last page. This is a no-op on FreeBSD which always
|
|
|
|
// rounds up.
|
2017-07-27 15:46:50 +08:00
|
|
|
P->p_memsz = alignTo(P->p_memsz, Target->PageSize);
|
2017-01-05 02:56:15 +08:00
|
|
|
}
|
2016-08-17 15:44:19 +08:00
|
|
|
|
2019-01-09 08:09:59 +08:00
|
|
|
if (P->p_type == PT_TLS && P->p_memsz) {
|
|
|
|
if (!Config->Shared &&
|
|
|
|
(Config->EMachine == EM_ARM || Config->EMachine == EM_AARCH64)) {
|
|
|
|
// On ARM/AArch64, reserve extra space (8 words) between the thread
|
|
|
|
// pointer and an executable's TLS segment by overaligning the segment.
|
|
|
|
// This reservation is needed for backwards compatibility with Android's
|
|
|
|
// TCB, which allocates several slots after the thread pointer (e.g.
|
|
|
|
// TLS_SLOT_STACK_GUARD==5). For simplicity, this overalignment is also
|
|
|
|
// done on other operating systems.
|
|
|
|
P->p_align = std::max<uint64_t>(P->p_align, Config->Wordsize * 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
// The TLS pointer goes after PT_TLS for variant 2 targets. At least glibc
|
|
|
|
// will align it, so round up the size to make sure the offsets are
|
|
|
|
// correct.
|
[ELF] Set Out::TlsPhdr earlier for encoding packed reloc tables
Summary:
For --pack-dyn-relocs=android, finalizeSections calls
LinkerScript::assignAddresses and
AndroidPackedRelocationSection::updateAllocSize in a loop,
where assignAddresses lays out the ELF image, then updateAllocSize
determines the size of the Android packed relocation table by encoding it.
Encoding the table requires knowing the values of relocation addends.
To get the addend of a TLS relocation, updateAllocSize can call getSymVA
on a TLS symbol before setPhdrs has initialized Out::TlsPhdr, producing an
error:
<file> has an STT_TLS symbol but doesn't have an SHF_TLS section
Fix the problem by initializing Out::TlsPhdr immediately after the program
headers are created. The segment's p_vaddr field isn't initialized until
setPhdrs, so use FirstSec->Addr, which is what setPhdrs would use.
FirstSec will typically refer to the .tdata or .tbss output section, whose
(tentative) address was computed by assignAddresses.
Android currently avoids this problem because it uses emutls and doesn't
support ELF TLS. This problem doesn't apply to --pack-dyn-relocs=relr
because SHR_RELR only handles relative relocations without explicit addends
or info.
Fixes https://bugs.llvm.org/show_bug.cgi?id=37841.
Reviewers: ruiu, pcc, chh, javed.absar, espindola
Subscribers: emaste, arichardson, llvm-commits, srhines
Differential Revision: https://reviews.llvm.org/D51671
llvm-svn: 342432
2018-09-18 08:24:48 +08:00
|
|
|
P->p_memsz = alignTo(P->p_memsz, P->p_align);
|
2019-01-09 08:09:59 +08:00
|
|
|
}
|
2015-10-24 05:45:59 +08:00
|
|
|
}
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2018-03-30 02:24:01 +08:00
|
|
|
// A helper struct for checkSectionOverlap.
|
|
|
|
namespace {
|
|
|
|
struct SectionOffset {
|
|
|
|
OutputSection *Sec;
|
|
|
|
uint64_t Offset;
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
2018-01-31 17:22:44 +08:00
|
|
|
// Check whether sections overlap for a specific address range (file offsets,
|
|
|
|
// load and virtual adresses).
|
2018-06-27 16:08:12 +08:00
|
|
|
static void checkOverlap(StringRef Name, std::vector<SectionOffset> &Sections,
|
|
|
|
bool IsVirtualAddr) {
|
2018-09-27 04:54:42 +08:00
|
|
|
llvm::sort(Sections, [=](const SectionOffset &A, const SectionOffset &B) {
|
|
|
|
return A.Offset < B.Offset;
|
|
|
|
});
|
2018-03-30 02:24:01 +08:00
|
|
|
|
2018-03-30 03:51:53 +08:00
|
|
|
// Finding overlap is easy given a vector is sorted by start position.
|
|
|
|
// If an element starts before the end of the previous element, they overlap.
|
|
|
|
for (size_t I = 1, End = Sections.size(); I < End; ++I) {
|
|
|
|
SectionOffset A = Sections[I - 1];
|
|
|
|
SectionOffset B = Sections[I];
|
2018-06-27 16:08:12 +08:00
|
|
|
if (B.Offset >= A.Offset + A.Sec->Size)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If both sections are in OVERLAY we allow the overlapping of virtual
|
|
|
|
// addresses, because it is what OVERLAY was designed for.
|
|
|
|
if (IsVirtualAddr && A.Sec->InOverlay && B.Sec->InOverlay)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
errorOrWarn("section " + A.Sec->Name + " " + Name +
|
|
|
|
" range overlaps with " + B.Sec->Name + "\n>>> " + A.Sec->Name +
|
|
|
|
" range is " + rangeToString(A.Offset, A.Sec->Size) + "\n>>> " +
|
|
|
|
B.Sec->Name + " range is " +
|
|
|
|
rangeToString(B.Offset, B.Sec->Size));
|
2018-01-31 17:22:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-03 20:39:28 +08:00
|
|
|
// Check for overlapping sections and address overflows.
|
2018-01-31 17:22:44 +08:00
|
|
|
//
|
|
|
|
// In this function we check that none of the output sections have overlapping
|
|
|
|
// file offsets. For SHF_ALLOC sections we also check that the load address
|
|
|
|
// ranges and the virtual address ranges don't overlap
|
2018-04-04 17:24:31 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::checkSections() {
|
2018-04-03 20:39:28 +08:00
|
|
|
// First, check that section's VAs fit in available address space for target.
|
|
|
|
for (OutputSection *OS : OutputSections)
|
|
|
|
if ((OS->Addr + OS->Size < OS->Addr) ||
|
|
|
|
(!ELFT::Is64Bits && OS->Addr + OS->Size > UINT32_MAX))
|
|
|
|
errorOrWarn("section " + OS->Name + " at 0x" + utohexstr(OS->Addr) +
|
|
|
|
" of size 0x" + utohexstr(OS->Size) +
|
|
|
|
" exceeds available address space");
|
|
|
|
|
|
|
|
// Check for overlapping file offsets. In this case we need to skip any
|
|
|
|
// section marked as SHT_NOBITS. These sections don't actually occupy space in
|
|
|
|
// the file so Sec->Offset + Sec->Size can overlap with others. If --oformat
|
|
|
|
// binary is specified only add SHF_ALLOC sections are added to the output
|
|
|
|
// file so we skip any non-allocated sections in that case.
|
2018-03-30 02:24:01 +08:00
|
|
|
std::vector<SectionOffset> FileOffs;
|
|
|
|
for (OutputSection *Sec : OutputSections)
|
2018-08-04 18:56:26 +08:00
|
|
|
if (Sec->Size > 0 && Sec->Type != SHT_NOBITS &&
|
2018-03-30 02:24:01 +08:00
|
|
|
(!Config->OFormatBinary || (Sec->Flags & SHF_ALLOC)))
|
|
|
|
FileOffs.push_back({Sec, Sec->Offset});
|
2018-06-27 16:08:12 +08:00
|
|
|
checkOverlap("file", FileOffs, false);
|
2018-01-31 17:22:44 +08:00
|
|
|
|
|
|
|
// When linking with -r there is no need to check for overlapping virtual/load
|
|
|
|
// addresses since those addresses will only be assigned when the final
|
|
|
|
// executable/shared object is created.
|
|
|
|
if (Config->Relocatable)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Checking for overlapping virtual and load addresses only needs to take
|
2018-02-23 10:05:48 +08:00
|
|
|
// into account SHF_ALLOC sections since others will not be loaded.
|
2018-01-31 17:22:44 +08:00
|
|
|
// Furthermore, we also need to skip SHF_TLS sections since these will be
|
|
|
|
// mapped to other addresses at runtime and can therefore have overlapping
|
|
|
|
// ranges in the file.
|
2018-03-30 02:24:01 +08:00
|
|
|
std::vector<SectionOffset> VMAs;
|
|
|
|
for (OutputSection *Sec : OutputSections)
|
2018-08-04 18:56:26 +08:00
|
|
|
if (Sec->Size > 0 && (Sec->Flags & SHF_ALLOC) && !(Sec->Flags & SHF_TLS))
|
2018-03-30 02:24:01 +08:00
|
|
|
VMAs.push_back({Sec, Sec->Addr});
|
2018-06-27 16:08:12 +08:00
|
|
|
checkOverlap("virtual address", VMAs, true);
|
2018-01-31 17:22:44 +08:00
|
|
|
|
|
|
|
// Finally, check that the load addresses don't overlap. This will usually be
|
|
|
|
// the same as the virtual addresses but can be different when using a linker
|
|
|
|
// script with AT().
|
2018-03-30 02:24:01 +08:00
|
|
|
std::vector<SectionOffset> LMAs;
|
|
|
|
for (OutputSection *Sec : OutputSections)
|
2018-08-04 18:56:26 +08:00
|
|
|
if (Sec->Size > 0 && (Sec->Flags & SHF_ALLOC) && !(Sec->Flags & SHF_TLS))
|
2018-03-30 02:24:01 +08:00
|
|
|
LMAs.push_back({Sec, Sec->getLMA()});
|
2018-06-27 16:08:12 +08:00
|
|
|
checkOverlap("load address", LMAs, false);
|
2018-01-31 17:22:44 +08:00
|
|
|
}
|
|
|
|
|
2016-11-24 06:41:00 +08:00
|
|
|
// The entry point address is chosen in the following ways.
|
|
|
|
//
|
|
|
|
// 1. the '-e' entry command-line option;
|
|
|
|
// 2. the ENTRY(symbol) command in a linker control script;
|
2017-11-30 09:04:26 +08:00
|
|
|
// 3. the value of the symbol _start, if present;
|
2017-10-25 03:53:51 +08:00
|
|
|
// 4. the number represented by the entry symbol, if it is a number;
|
|
|
|
// 5. the address of the first byte of the .text section, if present;
|
|
|
|
// 6. the address 0.
|
2018-09-21 06:58:00 +08:00
|
|
|
static uint64_t getEntryAddr() {
|
2017-10-25 03:53:51 +08:00
|
|
|
// Case 1, 2 or 3
|
2017-11-04 05:21:47 +08:00
|
|
|
if (Symbol *B = Symtab->find(Config->Entry))
|
2017-03-17 19:56:54 +08:00
|
|
|
return B->getVA();
|
2017-10-25 03:53:51 +08:00
|
|
|
|
|
|
|
// Case 4
|
2016-12-07 11:23:06 +08:00
|
|
|
uint64_t Addr;
|
2017-05-16 16:19:25 +08:00
|
|
|
if (to_integer(Config->Entry, Addr))
|
2016-12-07 11:23:06 +08:00
|
|
|
return Addr;
|
2016-11-24 06:41:00 +08:00
|
|
|
|
2017-10-25 03:53:51 +08:00
|
|
|
// Case 5
|
2017-07-28 03:22:43 +08:00
|
|
|
if (OutputSection *Sec = findSection(".text")) {
|
2016-12-07 12:06:21 +08:00
|
|
|
if (Config->WarnMissingEntry)
|
2016-12-07 10:26:16 +08:00
|
|
|
warn("cannot find entry symbol " + Config->Entry + "; defaulting to 0x" +
|
|
|
|
utohexstr(Sec->Addr));
|
2016-11-24 06:41:00 +08:00
|
|
|
return Sec->Addr;
|
|
|
|
}
|
|
|
|
|
2017-10-25 03:53:51 +08:00
|
|
|
// Case 6
|
2016-12-07 12:06:21 +08:00
|
|
|
if (Config->WarnMissingEntry)
|
2016-12-07 10:26:16 +08:00
|
|
|
warn("cannot find entry symbol " + Config->Entry +
|
|
|
|
"; not setting start address");
|
2016-10-20 08:07:36 +08:00
|
|
|
return 0;
|
2015-12-24 16:37:34 +08:00
|
|
|
}
|
|
|
|
|
2016-02-26 03:28:37 +08:00
|
|
|
static uint16_t getELFType() {
|
2017-03-18 07:29:01 +08:00
|
|
|
if (Config->Pic)
|
2016-02-26 03:28:37 +08:00
|
|
|
return ET_DYN;
|
|
|
|
if (Config->Relocatable)
|
|
|
|
return ET_REL;
|
|
|
|
return ET_EXEC;
|
|
|
|
}
|
|
|
|
|
2018-02-23 19:28:57 +08:00
|
|
|
static uint8_t getAbiVersion() {
|
2018-03-29 05:53:10 +08:00
|
|
|
// MIPS non-PIC executable gets ABI version 1.
|
2019-02-15 07:59:44 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
|
|
|
if (getELFType() == ET_EXEC &&
|
|
|
|
(Config->EFlags & (EF_MIPS_PIC | EF_MIPS_CPIC)) == EF_MIPS_CPIC)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Config->EMachine == EM_AMDGPU) {
|
|
|
|
uint8_t Ver = ObjectFiles[0]->ABIVersion;
|
|
|
|
for (InputFile *File : makeArrayRef(ObjectFiles).slice(1))
|
|
|
|
if (File->ABIVersion != Ver)
|
|
|
|
error("incompatible ABI version: " + toString(File));
|
|
|
|
return Ver;
|
|
|
|
}
|
|
|
|
|
2018-02-23 19:28:57 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::writeHeader() {
|
2018-03-31 04:49:34 +08:00
|
|
|
// For executable segments, the trap instructions are written before writing
|
|
|
|
// the header. Setting Elf header bytes to zero ensures that any unused bytes
|
|
|
|
// in header are zero-cleared, instead of having trap instructions.
|
2019-03-01 07:11:35 +08:00
|
|
|
memset(Out::BufferStart, 0, sizeof(Elf_Ehdr));
|
|
|
|
memcpy(Out::BufferStart, "\177ELF", 4);
|
2015-10-24 06:44:39 +08:00
|
|
|
|
2015-10-25 01:57:40 +08:00
|
|
|
// Write the ELF header.
|
2019-03-01 07:11:35 +08:00
|
|
|
auto *EHdr = reinterpret_cast<Elf_Ehdr *>(Out::BufferStart);
|
2017-04-06 05:08:47 +08:00
|
|
|
EHdr->e_ident[EI_CLASS] = Config->Is64 ? ELFCLASS64 : ELFCLASS32;
|
|
|
|
EHdr->e_ident[EI_DATA] = Config->IsLE ? ELFDATA2LSB : ELFDATA2MSB;
|
2015-07-25 05:03:07 +08:00
|
|
|
EHdr->e_ident[EI_VERSION] = EV_CURRENT;
|
2016-10-27 22:00:51 +08:00
|
|
|
EHdr->e_ident[EI_OSABI] = Config->OSABI;
|
2018-02-23 19:28:57 +08:00
|
|
|
EHdr->e_ident[EI_ABIVERSION] = getAbiVersion();
|
2016-02-26 03:28:37 +08:00
|
|
|
EHdr->e_type = getELFType();
|
2016-10-27 22:00:51 +08:00
|
|
|
EHdr->e_machine = Config->EMachine;
|
2015-07-25 05:03:07 +08:00
|
|
|
EHdr->e_version = EV_CURRENT;
|
2016-11-24 06:41:00 +08:00
|
|
|
EHdr->e_entry = getEntryAddr();
|
2015-07-29 08:30:10 +08:00
|
|
|
EHdr->e_shoff = SectionHeaderOff;
|
2017-10-25 01:01:40 +08:00
|
|
|
EHdr->e_flags = Config->EFlags;
|
2015-09-09 05:57:31 +08:00
|
|
|
EHdr->e_ehsize = sizeof(Elf_Ehdr);
|
2015-10-11 06:34:30 +08:00
|
|
|
EHdr->e_phnum = Phdrs.size();
|
2015-09-09 05:57:31 +08:00
|
|
|
EHdr->e_shentsize = sizeof(Elf_Shdr);
|
2015-10-25 01:57:40 +08:00
|
|
|
|
2016-02-25 16:23:37 +08:00
|
|
|
if (!Config->Relocatable) {
|
|
|
|
EHdr->e_phoff = sizeof(Elf_Ehdr);
|
|
|
|
EHdr->e_phentsize = sizeof(Elf_Phdr);
|
|
|
|
}
|
|
|
|
|
2015-10-25 01:57:40 +08:00
|
|
|
// Write the program header table.
|
2019-03-01 07:11:35 +08:00
|
|
|
auto *HBuf = reinterpret_cast<Elf_Phdr *>(Out::BufferStart + EHdr->e_phoff);
|
2017-07-27 15:46:50 +08:00
|
|
|
for (PhdrEntry *P : Phdrs) {
|
|
|
|
HBuf->p_type = P->p_type;
|
|
|
|
HBuf->p_flags = P->p_flags;
|
|
|
|
HBuf->p_offset = P->p_offset;
|
|
|
|
HBuf->p_vaddr = P->p_vaddr;
|
|
|
|
HBuf->p_paddr = P->p_paddr;
|
|
|
|
HBuf->p_filesz = P->p_filesz;
|
|
|
|
HBuf->p_memsz = P->p_memsz;
|
|
|
|
HBuf->p_align = P->p_align;
|
2016-12-20 01:01:01 +08:00
|
|
|
++HBuf;
|
|
|
|
}
|
2015-09-09 06:55:28 +08:00
|
|
|
|
2018-07-18 16:44:38 +08:00
|
|
|
// Write the section header table.
|
|
|
|
//
|
|
|
|
// The ELF header can only store numbers up to SHN_LORESERVE in the e_shnum
|
|
|
|
// and e_shstrndx fields. When the value of one of these fields exceeds
|
|
|
|
// SHN_LORESERVE ELF requires us to put sentinel values in the ELF header and
|
|
|
|
// use fields in the section header at index 0 to store
|
|
|
|
// the value. The sentinel values and fields are:
|
|
|
|
// e_shnum = 0, SHdrs[0].sh_size = number of sections.
|
|
|
|
// e_shstrndx = SHN_XINDEX, SHdrs[0].sh_link = .shstrtab section index.
|
2019-03-01 07:11:35 +08:00
|
|
|
auto *SHdrs = reinterpret_cast<Elf_Shdr *>(Out::BufferStart + EHdr->e_shoff);
|
2018-07-18 16:44:38 +08:00
|
|
|
size_t Num = OutputSections.size() + 1;
|
|
|
|
if (Num >= SHN_LORESERVE)
|
|
|
|
SHdrs->sh_size = Num;
|
|
|
|
else
|
|
|
|
EHdr->e_shnum = Num;
|
|
|
|
|
2018-09-26 03:26:58 +08:00
|
|
|
uint32_t StrTabIndex = In.ShStrTab->getParent()->SectionIndex;
|
2018-07-18 16:44:38 +08:00
|
|
|
if (StrTabIndex >= SHN_LORESERVE) {
|
|
|
|
SHdrs->sh_link = StrTabIndex;
|
|
|
|
EHdr->e_shstrndx = SHN_XINDEX;
|
|
|
|
} else {
|
|
|
|
EHdr->e_shstrndx = StrTabIndex;
|
|
|
|
}
|
|
|
|
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
|
|
|
Sec->writeHeaderTo<ELFT>(++SHdrs);
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2016-12-06 01:40:37 +08:00
|
|
|
// Open a result file.
|
2016-04-02 01:24:19 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::openFile() {
|
2018-12-04 01:42:57 +08:00
|
|
|
uint64_t MaxSize = Config->Is64 ? INT64_MAX : UINT32_MAX;
|
2019-03-02 02:53:41 +08:00
|
|
|
if (FileSize != size_t(FileSize) || MaxSize < FileSize) {
|
2017-04-06 05:37:09 +08:00
|
|
|
error("output file too large: " + Twine(FileSize) + " bytes");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-12-06 01:40:37 +08:00
|
|
|
unlinkAsync(Config->OutputFile);
|
2017-12-12 07:30:54 +08:00
|
|
|
unsigned Flags = 0;
|
|
|
|
if (!Config->Relocatable)
|
|
|
|
Flags = FileOutputBuffer::F_executable;
|
2017-11-08 09:05:52 +08:00
|
|
|
Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
|
2017-12-12 07:30:54 +08:00
|
|
|
FileOutputBuffer::create(Config->OutputFile, FileSize, Flags);
|
2016-12-06 01:40:37 +08:00
|
|
|
|
2019-03-01 07:11:35 +08:00
|
|
|
if (!BufferOrErr) {
|
2017-11-08 09:05:52 +08:00
|
|
|
error("failed to open " + Config->OutputFile + ": " +
|
|
|
|
llvm::toString(BufferOrErr.takeError()));
|
2019-03-01 07:11:35 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
Buffer = std::move(*BufferOrErr);
|
|
|
|
Out::BufferStart = Buffer->getBufferStart();
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2016-08-25 17:05:47 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::writeSectionsBinary() {
|
2017-07-28 03:22:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
2016-11-09 09:42:41 +08:00
|
|
|
if (Sec->Flags & SHF_ALLOC)
|
2019-03-01 07:11:35 +08:00
|
|
|
Sec->writeTo<ELFT>(Out::BufferStart + Sec->Offset);
|
2016-08-25 17:05:47 +08:00
|
|
|
}
|
|
|
|
|
2017-08-15 05:18:12 +08:00
|
|
|
static void fillTrap(uint8_t *I, uint8_t *End) {
|
2017-08-21 16:31:14 +08:00
|
|
|
for (; I + 4 <= End; I += 4)
|
2017-08-03 00:35:00 +08:00
|
|
|
memcpy(I, &Target->TrapInstr, 4);
|
|
|
|
}
|
|
|
|
|
2017-08-15 05:18:12 +08:00
|
|
|
// Fill the last page of executable segments with trap instructions
|
|
|
|
// instead of leaving them as zero. Even though it is not required by any
|
|
|
|
// standard, it is in general a good thing to do for security reasons.
|
|
|
|
//
|
|
|
|
// We'll leave other pages in segments as-is because the rest will be
|
|
|
|
// overwritten by output sections.
|
2017-08-03 00:35:00 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::writeTrapInstr() {
|
2017-10-11 09:34:51 +08:00
|
|
|
if (Script->HasSectionsCommand)
|
2017-08-03 00:35:00 +08:00
|
|
|
return;
|
|
|
|
|
2017-08-15 05:18:12 +08:00
|
|
|
// Fill the last page.
|
|
|
|
for (PhdrEntry *P : Phdrs)
|
|
|
|
if (P->p_type == PT_LOAD && (P->p_flags & PF_X))
|
2019-03-01 07:11:35 +08:00
|
|
|
fillTrap(Out::BufferStart +
|
|
|
|
alignDown(P->p_offset + P->p_filesz, Target->PageSize),
|
|
|
|
Out::BufferStart +
|
|
|
|
alignTo(P->p_offset + P->p_filesz, Target->PageSize));
|
2017-08-03 00:35:00 +08:00
|
|
|
|
2017-08-15 05:18:12 +08:00
|
|
|
// Round up the file size of the last segment to the page boundary iff it is
|
2017-10-27 12:59:33 +08:00
|
|
|
// an executable segment to ensure that other tools don't accidentally
|
2017-08-15 05:18:12 +08:00
|
|
|
// trim the instruction padding (e.g. when stripping the file).
|
2017-10-27 13:08:39 +08:00
|
|
|
PhdrEntry *Last = nullptr;
|
|
|
|
for (PhdrEntry *P : Phdrs)
|
|
|
|
if (P->p_type == PT_LOAD)
|
|
|
|
Last = P;
|
|
|
|
|
|
|
|
if (Last && (Last->p_flags & PF_X))
|
|
|
|
Last->p_memsz = Last->p_filesz = alignTo(Last->p_filesz, Target->PageSize);
|
2017-08-03 00:35:00 +08:00
|
|
|
}
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
// Write section contents to a mmap'ed file.
|
|
|
|
template <class ELFT> void Writer<ELFT>::writeSections() {
|
2017-02-11 09:40:49 +08:00
|
|
|
// In -r or -emit-relocs mode, write the relocation sections first as in
|
|
|
|
// ELf_Rel targets we might find out that we need to modify the relocated
|
|
|
|
// section while doing it.
|
2017-10-07 04:12:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
2017-02-11 09:40:49 +08:00
|
|
|
if (Sec->Type == SHT_REL || Sec->Type == SHT_RELA)
|
2019-03-01 07:11:35 +08:00
|
|
|
Sec->writeTo<ELFT>(Out::BufferStart + Sec->Offset);
|
2017-02-11 09:40:49 +08:00
|
|
|
|
2017-10-07 04:12:43 +08:00
|
|
|
for (OutputSection *Sec : OutputSections)
|
2019-03-01 07:11:35 +08:00
|
|
|
if (Sec->Type != SHT_REL && Sec->Type != SHT_RELA)
|
|
|
|
Sec->writeTo<ELFT>(Out::BufferStart + Sec->Offset);
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
2015-10-10 05:07:25 +08:00
|
|
|
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
template <class ELFT> void Writer<ELFT>::writeBuildId() {
|
2018-09-26 03:26:58 +08:00
|
|
|
if (!In.BuildId || !In.BuildId->getParent())
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
return;
|
|
|
|
|
2016-09-02 06:43:03 +08:00
|
|
|
// Compute a hash of all sections of the output file.
|
2019-03-02 02:53:41 +08:00
|
|
|
In.BuildId->writeBuildId({Out::BufferStart, size_t(FileSize)});
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
}
|
|
|
|
|
2016-08-09 11:38:23 +08:00
|
|
|
template void elf::writeResult<ELF32LE>();
|
|
|
|
template void elf::writeResult<ELF32BE>();
|
|
|
|
template void elf::writeResult<ELF64LE>();
|
|
|
|
template void elf::writeResult<ELF64BE>();
|