|
150
|
1 //===- Writer.cpp ---------------------------------------------------------===//
|
|
|
2 //
|
|
|
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8
|
|
|
9 #include "Writer.h"
|
|
|
10 #include "AArch64ErrataFix.h"
|
|
|
11 #include "ARMErrataFix.h"
|
|
|
12 #include "CallGraphSort.h"
|
|
|
13 #include "Config.h"
|
|
|
14 #include "LinkerScript.h"
|
|
|
15 #include "MapFile.h"
|
|
|
16 #include "OutputSections.h"
|
|
|
17 #include "Relocations.h"
|
|
|
18 #include "SymbolTable.h"
|
|
|
19 #include "Symbols.h"
|
|
|
20 #include "SyntheticSections.h"
|
|
|
21 #include "Target.h"
|
|
|
22 #include "lld/Common/Filesystem.h"
|
|
|
23 #include "lld/Common/Memory.h"
|
|
|
24 #include "lld/Common/Strings.h"
|
|
|
25 #include "lld/Common/Threads.h"
|
|
|
26 #include "llvm/ADT/StringMap.h"
|
|
|
27 #include "llvm/ADT/StringSwitch.h"
|
|
|
28 #include "llvm/Support/RandomNumberGenerator.h"
|
|
|
29 #include "llvm/Support/SHA1.h"
|
|
|
30 #include "llvm/Support/TimeProfiler.h"
|
|
|
31 #include "llvm/Support/xxhash.h"
|
|
|
32 #include <climits>
|
|
|
33
|
|
|
34 using namespace llvm;
|
|
|
35 using namespace llvm::ELF;
|
|
|
36 using namespace llvm::object;
|
|
|
37 using namespace llvm::support;
|
|
|
38 using namespace llvm::support::endian;
|
|
|
39
|
|
|
40 namespace lld {
|
|
|
41 namespace elf {
|
|
|
42 namespace {
|
|
|
43 // The writer writes a SymbolTable result to a file.
|
|
|
44 template <class ELFT> class Writer {
|
|
|
45 public:
|
|
|
46 Writer() : buffer(errorHandler().outputBuffer) {}
|
|
|
47 using Elf_Shdr = typename ELFT::Shdr;
|
|
|
48 using Elf_Ehdr = typename ELFT::Ehdr;
|
|
|
49 using Elf_Phdr = typename ELFT::Phdr;
|
|
|
50
|
|
|
51 void run();
|
|
|
52
|
|
|
53 private:
|
|
|
54 void copyLocalSymbols();
|
|
|
55 void addSectionSymbols();
|
|
|
56 void forEachRelSec(llvm::function_ref<void(InputSectionBase &)> fn);
|
|
|
57 void sortSections();
|
|
|
58 void resolveShfLinkOrder();
|
|
|
59 void finalizeAddressDependentContent();
|
|
|
60 void sortInputSections();
|
|
|
61 void finalizeSections();
|
|
|
62 void checkExecuteOnly();
|
|
|
63 void setReservedSymbolSections();
|
|
|
64
|
|
|
65 std::vector<PhdrEntry *> createPhdrs(Partition &part);
|
|
|
66 void addPhdrForSection(Partition &part, unsigned shType, unsigned pType,
|
|
|
67 unsigned pFlags);
|
|
|
68 void assignFileOffsets();
|
|
|
69 void assignFileOffsetsBinary();
|
|
|
70 void setPhdrs(Partition &part);
|
|
|
71 void checkSections();
|
|
|
72 void fixSectionAlignments();
|
|
|
73 void openFile();
|
|
|
74 void writeTrapInstr();
|
|
|
75 void writeHeader();
|
|
|
76 void writeSections();
|
|
|
77 void writeSectionsBinary();
|
|
|
78 void writeBuildId();
|
|
|
79
|
|
|
80 std::unique_ptr<FileOutputBuffer> &buffer;
|
|
|
81
|
|
|
82 void addRelIpltSymbols();
|
|
|
83 void addStartEndSymbols();
|
|
|
84 void addStartStopSymbols(OutputSection *sec);
|
|
|
85
|
|
|
86 uint64_t fileSize;
|
|
|
87 uint64_t sectionHeaderOff;
|
|
|
88 };
|
|
|
89 } // anonymous namespace
|
|
|
90
|
|
|
91 static bool isSectionPrefix(StringRef prefix, StringRef name) {
|
|
|
92 return name.startswith(prefix) || name == prefix.drop_back();
|
|
|
93 }
|
|
|
94
|
|
|
95 StringRef getOutputSectionName(const InputSectionBase *s) {
|
|
|
96 if (config->relocatable)
|
|
|
97 return s->name;
|
|
|
98
|
|
|
99 // This is for --emit-relocs. If .text.foo is emitted as .text.bar, we want
|
|
|
100 // to emit .rela.text.foo as .rela.text.bar for consistency (this is not
|
|
|
101 // technically required, but not doing it is odd). This code guarantees that.
|
|
|
102 if (auto *isec = dyn_cast<InputSection>(s)) {
|
|
|
103 if (InputSectionBase *rel = isec->getRelocatedSection()) {
|
|
|
104 OutputSection *out = rel->getOutputSection();
|
|
|
105 if (s->type == SHT_RELA)
|
|
|
106 return saver.save(".rela" + out->name);
|
|
|
107 return saver.save(".rel" + out->name);
|
|
|
108 }
|
|
|
109 }
|
|
|
110
|
|
|
111 // This check is for -z keep-text-section-prefix. This option separates text
|
|
|
112 // sections with prefix ".text.hot", ".text.unlikely", ".text.startup" or
|
|
|
113 // ".text.exit".
|
|
|
114 // When enabled, this allows identifying the hot code region (.text.hot) in
|
|
|
115 // the final binary which can be selectively mapped to huge pages or mlocked,
|
|
|
116 // for instance.
|
|
|
117 if (config->zKeepTextSectionPrefix)
|
|
|
118 for (StringRef v :
|
|
|
119 {".text.hot.", ".text.unlikely.", ".text.startup.", ".text.exit."})
|
|
|
120 if (isSectionPrefix(v, s->name))
|
|
|
121 return v.drop_back();
|
|
|
122
|
|
|
123 for (StringRef v :
|
|
|
124 {".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.rel.ro.",
|
|
|
125 ".bss.", ".init_array.", ".fini_array.", ".ctors.", ".dtors.", ".tbss.",
|
|
|
126 ".gcc_except_table.", ".tdata.", ".ARM.exidx.", ".ARM.extab."})
|
|
|
127 if (isSectionPrefix(v, s->name))
|
|
|
128 return v.drop_back();
|
|
|
129
|
|
|
130 // CommonSection is identified as "COMMON" in linker scripts.
|
|
|
131 // By default, it should go to .bss section.
|
|
|
132 if (s->name == "COMMON")
|
|
|
133 return ".bss";
|
|
|
134
|
|
|
135 return s->name;
|
|
|
136 }
|
|
|
137
|
|
|
138 static bool needsInterpSection() {
|
|
|
139 return !config->relocatable && !config->shared &&
|
|
|
140 !config->dynamicLinker.empty() && script->needsInterpSection();
|
|
|
141 }
|
|
|
142
|
|
|
143 template <class ELFT> void writeResult() {
|
|
|
144 llvm::TimeTraceScope timeScope("Write output file");
|
|
|
145 Writer<ELFT>().run();
|
|
|
146 }
|
|
|
147
|
|
|
148 static void removeEmptyPTLoad(std::vector<PhdrEntry *> &phdrs) {
|
|
|
149 llvm::erase_if(phdrs, [&](const PhdrEntry *p) {
|
|
|
150 if (p->p_type != PT_LOAD)
|
|
|
151 return false;
|
|
|
152 if (!p->firstSec)
|
|
|
153 return true;
|
|
|
154 uint64_t size = p->lastSec->addr + p->lastSec->size - p->firstSec->addr;
|
|
|
155 return size == 0;
|
|
|
156 });
|
|
|
157 }
|
|
|
158
|
|
|
159 void copySectionsIntoPartitions() {
|
|
|
160 std::vector<InputSectionBase *> newSections;
|
|
|
161 for (unsigned part = 2; part != partitions.size() + 1; ++part) {
|
|
|
162 for (InputSectionBase *s : inputSections) {
|
|
|
163 if (!(s->flags & SHF_ALLOC) || !s->isLive())
|
|
|
164 continue;
|
|
|
165 InputSectionBase *copy;
|
|
|
166 if (s->type == SHT_NOTE)
|
|
|
167 copy = make<InputSection>(cast<InputSection>(*s));
|
|
|
168 else if (auto *es = dyn_cast<EhInputSection>(s))
|
|
|
169 copy = make<EhInputSection>(*es);
|
|
|
170 else
|
|
|
171 continue;
|
|
|
172 copy->partition = part;
|
|
|
173 newSections.push_back(copy);
|
|
|
174 }
|
|
|
175 }
|
|
|
176
|
|
|
177 inputSections.insert(inputSections.end(), newSections.begin(),
|
|
|
178 newSections.end());
|
|
|
179 }
|
|
|
180
|
|
|
181 void combineEhSections() {
|
|
|
182 for (InputSectionBase *&s : inputSections) {
|
|
|
183 // Ignore dead sections and the partition end marker (.part.end),
|
|
|
184 // whose partition number is out of bounds.
|
|
|
185 if (!s->isLive() || s->partition == 255)
|
|
|
186 continue;
|
|
|
187
|
|
|
188 Partition &part = s->getPartition();
|
|
|
189 if (auto *es = dyn_cast<EhInputSection>(s)) {
|
|
|
190 part.ehFrame->addSection(es);
|
|
|
191 s = nullptr;
|
|
|
192 } else if (s->kind() == SectionBase::Regular && part.armExidx &&
|
|
|
193 part.armExidx->addSection(cast<InputSection>(s))) {
|
|
|
194 s = nullptr;
|
|
|
195 }
|
|
|
196 }
|
|
|
197
|
|
|
198 std::vector<InputSectionBase *> &v = inputSections;
|
|
|
199 v.erase(std::remove(v.begin(), v.end(), nullptr), v.end());
|
|
|
200 }
|
|
|
201
|
|
|
202 static Defined *addOptionalRegular(StringRef name, SectionBase *sec,
|
|
|
203 uint64_t val, uint8_t stOther = STV_HIDDEN,
|
|
|
204 uint8_t binding = STB_GLOBAL) {
|
|
|
205 Symbol *s = symtab->find(name);
|
|
|
206 if (!s || s->isDefined())
|
|
|
207 return nullptr;
|
|
|
208
|
|
|
209 s->resolve(Defined{/*file=*/nullptr, name, binding, stOther, STT_NOTYPE, val,
|
|
|
210 /*size=*/0, sec});
|
|
|
211 return cast<Defined>(s);
|
|
|
212 }
|
|
|
213
|
|
|
214 static Defined *addAbsolute(StringRef name) {
|
|
|
215 Symbol *sym = symtab->addSymbol(Defined{nullptr, name, STB_GLOBAL, STV_HIDDEN,
|
|
|
216 STT_NOTYPE, 0, 0, nullptr});
|
|
|
217 return cast<Defined>(sym);
|
|
|
218 }
|
|
|
219
|
|
|
220 // The linker is expected to define some symbols depending on
|
|
|
221 // the linking result. This function defines such symbols.
|
|
|
222 void addReservedSymbols() {
|
|
|
223 if (config->emachine == EM_MIPS) {
|
|
|
224 // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
|
|
|
225 // so that it points to an absolute address which by default is relative
|
|
|
226 // to GOT. Default offset is 0x7ff0.
|
|
|
227 // See "Global Data Symbols" in Chapter 6 in the following document:
|
|
|
228 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
|
|
|
229 ElfSym::mipsGp = addAbsolute("_gp");
|
|
|
230
|
|
|
231 // On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
|
|
|
232 // start of function and 'gp' pointer into GOT.
|
|
|
233 if (symtab->find("_gp_disp"))
|
|
|
234 ElfSym::mipsGpDisp = addAbsolute("_gp_disp");
|
|
|
235
|
|
|
236 // The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
|
|
|
237 // pointer. This symbol is used in the code generated by .cpload pseudo-op
|
|
|
238 // in case of using -mno-shared option.
|
|
|
239 // https://sourceware.org/ml/binutils/2004-12/msg00094.html
|
|
|
240 if (symtab->find("__gnu_local_gp"))
|
|
|
241 ElfSym::mipsLocalGp = addAbsolute("__gnu_local_gp");
|
|
|
242 } else if (config->emachine == EM_PPC) {
|
|
|
243 // glibc *crt1.o has a undefined reference to _SDA_BASE_. Since we don't
|
|
|
244 // support Small Data Area, define it arbitrarily as 0.
|
|
|
245 addOptionalRegular("_SDA_BASE_", nullptr, 0, STV_HIDDEN);
|
|
|
246 }
|
|
|
247
|
|
|
248 // The Power Architecture 64-bit v2 ABI defines a TableOfContents (TOC) which
|
|
|
249 // combines the typical ELF GOT with the small data sections. It commonly
|
|
|
250 // includes .got .toc .sdata .sbss. The .TOC. symbol replaces both
|
|
|
251 // _GLOBAL_OFFSET_TABLE_ and _SDA_BASE_ from the 32-bit ABI. It is used to
|
|
|
252 // represent the TOC base which is offset by 0x8000 bytes from the start of
|
|
|
253 // the .got section.
|
|
|
254 // We do not allow _GLOBAL_OFFSET_TABLE_ to be defined by input objects as the
|
|
|
255 // correctness of some relocations depends on its value.
|
|
|
256 StringRef gotSymName =
|
|
|
257 (config->emachine == EM_PPC64) ? ".TOC." : "_GLOBAL_OFFSET_TABLE_";
|
|
|
258
|
|
|
259 if (Symbol *s = symtab->find(gotSymName)) {
|
|
|
260 if (s->isDefined()) {
|
|
|
261 error(toString(s->file) + " cannot redefine linker defined symbol '" +
|
|
|
262 gotSymName + "'");
|
|
|
263 return;
|
|
|
264 }
|
|
|
265
|
|
|
266 uint64_t gotOff = 0;
|
|
|
267 if (config->emachine == EM_PPC64)
|
|
|
268 gotOff = 0x8000;
|
|
|
269
|
|
|
270 s->resolve(Defined{/*file=*/nullptr, gotSymName, STB_GLOBAL, STV_HIDDEN,
|
|
|
271 STT_NOTYPE, gotOff, /*size=*/0, Out::elfHeader});
|
|
|
272 ElfSym::globalOffsetTable = cast<Defined>(s);
|
|
|
273 }
|
|
|
274
|
|
|
275 // __ehdr_start is the location of ELF file headers. Note that we define
|
|
|
276 // this symbol unconditionally even when using a linker script, which
|
|
|
277 // differs from the behavior implemented by GNU linker which only define
|
|
|
278 // this symbol if ELF headers are in the memory mapped segment.
|
|
|
279 addOptionalRegular("__ehdr_start", Out::elfHeader, 0, STV_HIDDEN);
|
|
|
280
|
|
|
281 // __executable_start is not documented, but the expectation of at
|
|
|
282 // least the Android libc is that it points to the ELF header.
|
|
|
283 addOptionalRegular("__executable_start", Out::elfHeader, 0, STV_HIDDEN);
|
|
|
284
|
|
|
285 // __dso_handle symbol is passed to cxa_finalize as a marker to identify
|
|
|
286 // each DSO. The address of the symbol doesn't matter as long as they are
|
|
|
287 // different in different DSOs, so we chose the start address of the DSO.
|
|
|
288 addOptionalRegular("__dso_handle", Out::elfHeader, 0, STV_HIDDEN);
|
|
|
289
|
|
|
290 // If linker script do layout we do not need to create any standard symbols.
|
|
|
291 if (script->hasSectionsCommand)
|
|
|
292 return;
|
|
|
293
|
|
|
294 auto add = [](StringRef s, int64_t pos) {
|
|
|
295 return addOptionalRegular(s, Out::elfHeader, pos, STV_DEFAULT);
|
|
|
296 };
|
|
|
297
|
|
|
298 ElfSym::bss = add("__bss_start", 0);
|
|
|
299 ElfSym::end1 = add("end", -1);
|
|
|
300 ElfSym::end2 = add("_end", -1);
|
|
|
301 ElfSym::etext1 = add("etext", -1);
|
|
|
302 ElfSym::etext2 = add("_etext", -1);
|
|
|
303 ElfSym::edata1 = add("edata", -1);
|
|
|
304 ElfSym::edata2 = add("_edata", -1);
|
|
|
305 }
|
|
|
306
|
|
|
307 static OutputSection *findSection(StringRef name, unsigned partition = 1) {
|
|
|
308 for (BaseCommand *base : script->sectionCommands)
|
|
|
309 if (auto *sec = dyn_cast<OutputSection>(base))
|
|
|
310 if (sec->name == name && sec->partition == partition)
|
|
|
311 return sec;
|
|
|
312 return nullptr;
|
|
|
313 }
|
|
|
314
|
|
|
315 template <class ELFT> void createSyntheticSections() {
|
|
|
316 // Initialize all pointers with NULL. This is needed because
|
|
|
317 // you can call lld::elf::main more than once as a library.
|
|
|
318 memset(&Out::first, 0, sizeof(Out));
|
|
|
319
|
|
|
320 // Add the .interp section first because it is not a SyntheticSection.
|
|
|
321 // The removeUnusedSyntheticSections() function relies on the
|
|
|
322 // SyntheticSections coming last.
|
|
|
323 if (needsInterpSection()) {
|
|
|
324 for (size_t i = 1; i <= partitions.size(); ++i) {
|
|
|
325 InputSection *sec = createInterpSection();
|
|
|
326 sec->partition = i;
|
|
|
327 inputSections.push_back(sec);
|
|
|
328 }
|
|
|
329 }
|
|
|
330
|
|
|
331 auto add = [](SyntheticSection *sec) { inputSections.push_back(sec); };
|
|
|
332
|
|
|
333 in.shStrTab = make<StringTableSection>(".shstrtab", false);
|
|
|
334
|
|
|
335 Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC);
|
|
|
336 Out::programHeaders->alignment = config->wordsize;
|
|
|
337
|
|
|
338 if (config->strip != StripPolicy::All) {
|
|
|
339 in.strTab = make<StringTableSection>(".strtab", false);
|
|
|
340 in.symTab = make<SymbolTableSection<ELFT>>(*in.strTab);
|
|
|
341 in.symTabShndx = make<SymtabShndxSection>();
|
|
|
342 }
|
|
|
343
|
|
|
344 in.bss = make<BssSection>(".bss", 0, 1);
|
|
|
345 add(in.bss);
|
|
|
346
|
|
|
347 // If there is a SECTIONS command and a .data.rel.ro section name use name
|
|
|
348 // .data.rel.ro.bss so that we match in the .data.rel.ro output section.
|
|
|
349 // This makes sure our relro is contiguous.
|
|
|
350 bool hasDataRelRo =
|
|
|
351 script->hasSectionsCommand && findSection(".data.rel.ro", 0);
|
|
|
352 in.bssRelRo =
|
|
|
353 make<BssSection>(hasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
|
|
|
354 add(in.bssRelRo);
|
|
|
355
|
|
|
356 // Add MIPS-specific sections.
|
|
|
357 if (config->emachine == EM_MIPS) {
|
|
|
358 if (!config->shared && config->hasDynSymTab) {
|
|
|
359 in.mipsRldMap = make<MipsRldMapSection>();
|
|
|
360 add(in.mipsRldMap);
|
|
|
361 }
|
|
|
362 if (auto *sec = MipsAbiFlagsSection<ELFT>::create())
|
|
|
363 add(sec);
|
|
|
364 if (auto *sec = MipsOptionsSection<ELFT>::create())
|
|
|
365 add(sec);
|
|
|
366 if (auto *sec = MipsReginfoSection<ELFT>::create())
|
|
|
367 add(sec);
|
|
|
368 }
|
|
|
369
|
|
|
370 StringRef relaDynName = config->isRela ? ".rela.dyn" : ".rel.dyn";
|
|
|
371
|
|
|
372 for (Partition &part : partitions) {
|
|
|
373 auto add = [&](SyntheticSection *sec) {
|
|
|
374 sec->partition = part.getNumber();
|
|
|
375 inputSections.push_back(sec);
|
|
|
376 };
|
|
|
377
|
|
|
378 if (!part.name.empty()) {
|
|
|
379 part.elfHeader = make<PartitionElfHeaderSection<ELFT>>();
|
|
|
380 part.elfHeader->name = part.name;
|
|
|
381 add(part.elfHeader);
|
|
|
382
|
|
|
383 part.programHeaders = make<PartitionProgramHeadersSection<ELFT>>();
|
|
|
384 add(part.programHeaders);
|
|
|
385 }
|
|
|
386
|
|
|
387 if (config->buildId != BuildIdKind::None) {
|
|
|
388 part.buildId = make<BuildIdSection>();
|
|
|
389 add(part.buildId);
|
|
|
390 }
|
|
|
391
|
|
|
392 part.dynStrTab = make<StringTableSection>(".dynstr", true);
|
|
|
393 part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
|
|
|
394 part.dynamic = make<DynamicSection<ELFT>>();
|
|
|
395 if (config->androidPackDynRelocs)
|
|
|
396 part.relaDyn = make<AndroidPackedRelocationSection<ELFT>>(relaDynName);
|
|
|
397 else
|
|
|
398 part.relaDyn =
|
|
|
399 make<RelocationSection<ELFT>>(relaDynName, config->zCombreloc);
|
|
|
400
|
|
|
401 if (config->hasDynSymTab) {
|
|
|
402 part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
|
|
|
403 add(part.dynSymTab);
|
|
|
404
|
|
|
405 part.verSym = make<VersionTableSection>();
|
|
|
406 add(part.verSym);
|
|
|
407
|
|
|
408 if (!namedVersionDefs().empty()) {
|
|
|
409 part.verDef = make<VersionDefinitionSection>();
|
|
|
410 add(part.verDef);
|
|
|
411 }
|
|
|
412
|
|
|
413 part.verNeed = make<VersionNeedSection<ELFT>>();
|
|
|
414 add(part.verNeed);
|
|
|
415
|
|
|
416 if (config->gnuHash) {
|
|
|
417 part.gnuHashTab = make<GnuHashTableSection>();
|
|
|
418 add(part.gnuHashTab);
|
|
|
419 }
|
|
|
420
|
|
|
421 if (config->sysvHash) {
|
|
|
422 part.hashTab = make<HashTableSection>();
|
|
|
423 add(part.hashTab);
|
|
|
424 }
|
|
|
425
|
|
|
426 add(part.dynamic);
|
|
|
427 add(part.dynStrTab);
|
|
|
428 add(part.relaDyn);
|
|
|
429 }
|
|
|
430
|
|
|
431 if (config->relrPackDynRelocs) {
|
|
|
432 part.relrDyn = make<RelrSection<ELFT>>();
|
|
|
433 add(part.relrDyn);
|
|
|
434 }
|
|
|
435
|
|
|
436 if (!config->relocatable) {
|
|
|
437 if (config->ehFrameHdr) {
|
|
|
438 part.ehFrameHdr = make<EhFrameHeader>();
|
|
|
439 add(part.ehFrameHdr);
|
|
|
440 }
|
|
|
441 part.ehFrame = make<EhFrameSection>();
|
|
|
442 add(part.ehFrame);
|
|
|
443 }
|
|
|
444
|
|
|
445 if (config->emachine == EM_ARM && !config->relocatable) {
|
|
|
446 // The ARMExidxsyntheticsection replaces all the individual .ARM.exidx
|
|
|
447 // InputSections.
|
|
|
448 part.armExidx = make<ARMExidxSyntheticSection>();
|
|
|
449 add(part.armExidx);
|
|
|
450 }
|
|
|
451 }
|
|
|
452
|
|
|
453 if (partitions.size() != 1) {
|
|
|
454 // Create the partition end marker. This needs to be in partition number 255
|
|
|
455 // so that it is sorted after all other partitions. It also has other
|
|
|
456 // special handling (see createPhdrs() and combineEhSections()).
|
|
|
457 in.partEnd = make<BssSection>(".part.end", config->maxPageSize, 1);
|
|
|
458 in.partEnd->partition = 255;
|
|
|
459 add(in.partEnd);
|
|
|
460
|
|
|
461 in.partIndex = make<PartitionIndexSection>();
|
|
|
462 addOptionalRegular("__part_index_begin", in.partIndex, 0);
|
|
|
463 addOptionalRegular("__part_index_end", in.partIndex,
|
|
|
464 in.partIndex->getSize());
|
|
|
465 add(in.partIndex);
|
|
|
466 }
|
|
|
467
|
|
|
468 // Add .got. MIPS' .got is so different from the other archs,
|
|
|
469 // it has its own class.
|
|
|
470 if (config->emachine == EM_MIPS) {
|
|
|
471 in.mipsGot = make<MipsGotSection>();
|
|
|
472 add(in.mipsGot);
|
|
|
473 } else {
|
|
|
474 in.got = make<GotSection>();
|
|
|
475 add(in.got);
|
|
|
476 }
|
|
|
477
|
|
|
478 if (config->emachine == EM_PPC) {
|
|
|
479 in.ppc32Got2 = make<PPC32Got2Section>();
|
|
|
480 add(in.ppc32Got2);
|
|
|
481 }
|
|
|
482
|
|
|
483 if (config->emachine == EM_PPC64) {
|
|
|
484 in.ppc64LongBranchTarget = make<PPC64LongBranchTargetSection>();
|
|
|
485 add(in.ppc64LongBranchTarget);
|
|
|
486 }
|
|
|
487
|
|
|
488 in.gotPlt = make<GotPltSection>();
|
|
|
489 add(in.gotPlt);
|
|
|
490 in.igotPlt = make<IgotPltSection>();
|
|
|
491 add(in.igotPlt);
|
|
|
492
|
|
|
493 // _GLOBAL_OFFSET_TABLE_ is defined relative to either .got.plt or .got. Treat
|
|
|
494 // it as a relocation and ensure the referenced section is created.
|
|
|
495 if (ElfSym::globalOffsetTable && config->emachine != EM_MIPS) {
|
|
|
496 if (target->gotBaseSymInGotPlt)
|
|
|
497 in.gotPlt->hasGotPltOffRel = true;
|
|
|
498 else
|
|
|
499 in.got->hasGotOffRel = true;
|
|
|
500 }
|
|
|
501
|
|
|
502 if (config->gdbIndex)
|
|
|
503 add(GdbIndexSection::create<ELFT>());
|
|
|
504
|
|
|
505 // We always need to add rel[a].plt to output if it has entries.
|
|
|
506 // Even for static linking it can contain R_[*]_IRELATIVE relocations.
|
|
|
507 in.relaPlt = make<RelocationSection<ELFT>>(
|
|
|
508 config->isRela ? ".rela.plt" : ".rel.plt", /*sort=*/false);
|
|
|
509 add(in.relaPlt);
|
|
|
510
|
|
|
511 // The relaIplt immediately follows .rel[a].dyn to ensure that the IRelative
|
|
|
512 // relocations are processed last by the dynamic loader. We cannot place the
|
|
|
513 // iplt section in .rel.dyn when Android relocation packing is enabled because
|
|
|
514 // that would cause a section type mismatch. However, because the Android
|
|
|
515 // dynamic loader reads .rel.plt after .rel.dyn, we can get the desired
|
|
|
516 // behaviour by placing the iplt section in .rel.plt.
|
|
|
517 in.relaIplt = make<RelocationSection<ELFT>>(
|
|
|
518 config->androidPackDynRelocs ? in.relaPlt->name : relaDynName,
|
|
|
519 /*sort=*/false);
|
|
|
520 add(in.relaIplt);
|
|
|
521
|
|
|
522 if ((config->emachine == EM_386 || config->emachine == EM_X86_64) &&
|
|
|
523 (config->andFeatures & GNU_PROPERTY_X86_FEATURE_1_IBT)) {
|
|
|
524 in.ibtPlt = make<IBTPltSection>();
|
|
|
525 add(in.ibtPlt);
|
|
|
526 }
|
|
|
527
|
|
|
528 in.plt = make<PltSection>();
|
|
|
529 add(in.plt);
|
|
|
530 in.iplt = make<IpltSection>();
|
|
|
531 add(in.iplt);
|
|
|
532
|
|
|
533 if (config->andFeatures)
|
|
|
534 add(make<GnuPropertySection>());
|
|
|
535
|
|
|
536 // .note.GNU-stack is always added when we are creating a re-linkable
|
|
|
537 // object file. Other linkers are using the presence of this marker
|
|
|
538 // section to control the executable-ness of the stack area, but that
|
|
|
539 // is irrelevant these days. Stack area should always be non-executable
|
|
|
540 // by default. So we emit this section unconditionally.
|
|
|
541 if (config->relocatable)
|
|
|
542 add(make<GnuStackSection>());
|
|
|
543
|
|
|
544 if (in.symTab)
|
|
|
545 add(in.symTab);
|
|
|
546 if (in.symTabShndx)
|
|
|
547 add(in.symTabShndx);
|
|
|
548 add(in.shStrTab);
|
|
|
549 if (in.strTab)
|
|
|
550 add(in.strTab);
|
|
|
551 }
|
|
|
552
|
|
|
553 // The main function of the writer.
|
|
|
554 template <class ELFT> void Writer<ELFT>::run() {
|
|
|
555 if (config->discard != DiscardPolicy::All)
|
|
|
556 copyLocalSymbols();
|
|
|
557
|
|
|
558 if (config->copyRelocs)
|
|
|
559 addSectionSymbols();
|
|
|
560
|
|
|
561 // Now that we have a complete set of output sections. This function
|
|
|
562 // completes section contents. For example, we need to add strings
|
|
|
563 // to the string table, and add entries to .got and .plt.
|
|
|
564 // finalizeSections does that.
|
|
|
565 finalizeSections();
|
|
|
566 checkExecuteOnly();
|
|
|
567 if (errorCount())
|
|
|
568 return;
|
|
|
569
|
|
|
570 // If -compressed-debug-sections is specified, we need to compress
|
|
|
571 // .debug_* sections. Do it right now because it changes the size of
|
|
|
572 // output sections.
|
|
|
573 for (OutputSection *sec : outputSections)
|
|
|
574 sec->maybeCompress<ELFT>();
|
|
|
575
|
|
|
576 if (script->hasSectionsCommand)
|
|
|
577 script->allocateHeaders(mainPart->phdrs);
|
|
|
578
|
|
|
579 // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
|
|
|
580 // 0 sized region. This has to be done late since only after assignAddresses
|
|
|
581 // we know the size of the sections.
|
|
|
582 for (Partition &part : partitions)
|
|
|
583 removeEmptyPTLoad(part.phdrs);
|
|
|
584
|
|
|
585 if (!config->oFormatBinary)
|
|
|
586 assignFileOffsets();
|
|
|
587 else
|
|
|
588 assignFileOffsetsBinary();
|
|
|
589
|
|
|
590 for (Partition &part : partitions)
|
|
|
591 setPhdrs(part);
|
|
|
592
|
|
|
593 if (config->relocatable)
|
|
|
594 for (OutputSection *sec : outputSections)
|
|
|
595 sec->addr = 0;
|
|
|
596
|
|
|
597 if (config->checkSections)
|
|
|
598 checkSections();
|
|
|
599
|
|
|
600 // It does not make sense try to open the file if we have error already.
|
|
|
601 if (errorCount())
|
|
|
602 return;
|
|
|
603 // Write the result down to a file.
|
|
|
604 openFile();
|
|
|
605 if (errorCount())
|
|
|
606 return;
|
|
|
607
|
|
|
608 if (!config->oFormatBinary) {
|
|
|
609 if (config->zSeparate != SeparateSegmentKind::None)
|
|
|
610 writeTrapInstr();
|
|
|
611 writeHeader();
|
|
|
612 writeSections();
|
|
|
613 } else {
|
|
|
614 writeSectionsBinary();
|
|
|
615 }
|
|
|
616
|
|
|
617 // Backfill .note.gnu.build-id section content. This is done at last
|
|
|
618 // because the content is usually a hash value of the entire output file.
|
|
|
619 writeBuildId();
|
|
|
620 if (errorCount())
|
|
|
621 return;
|
|
|
622
|
|
|
623 // Handle -Map and -cref options.
|
|
|
624 writeMapFile();
|
|
|
625 writeCrossReferenceTable();
|
|
|
626 if (errorCount())
|
|
|
627 return;
|
|
|
628
|
|
|
629 if (auto e = buffer->commit())
|
|
|
630 error("failed to write to the output file: " + toString(std::move(e)));
|
|
|
631 }
|
|
|
632
|
|
|
633 static bool shouldKeepInSymtab(const Defined &sym) {
|
|
|
634 if (sym.isSection())
|
|
|
635 return false;
|
|
|
636
|
|
|
637 if (config->discard == DiscardPolicy::None)
|
|
|
638 return true;
|
|
|
639
|
|
|
640 // If -emit-reloc is given, all symbols including local ones need to be
|
|
|
641 // copied because they may be referenced by relocations.
|
|
|
642 if (config->emitRelocs)
|
|
|
643 return true;
|
|
|
644
|
|
|
645 // In ELF assembly .L symbols are normally discarded by the assembler.
|
|
|
646 // If the assembler fails to do so, the linker discards them if
|
|
|
647 // * --discard-locals is used.
|
|
|
648 // * The symbol is in a SHF_MERGE section, which is normally the reason for
|
|
|
649 // the assembler keeping the .L symbol.
|
|
|
650 StringRef name = sym.getName();
|
|
|
651 bool isLocal = name.startswith(".L") || name.empty();
|
|
|
652 if (!isLocal)
|
|
|
653 return true;
|
|
|
654
|
|
|
655 if (config->discard == DiscardPolicy::Locals)
|
|
|
656 return false;
|
|
|
657
|
|
|
658 SectionBase *sec = sym.section;
|
|
|
659 return !sec || !(sec->flags & SHF_MERGE);
|
|
|
660 }
|
|
|
661
|
|
|
662 static bool includeInSymtab(const Symbol &b) {
|
|
|
663 if (!b.isLocal() && !b.isUsedInRegularObj)
|
|
|
664 return false;
|
|
|
665
|
|
|
666 if (auto *d = dyn_cast<Defined>(&b)) {
|
|
|
667 // Always include absolute symbols.
|
|
|
668 SectionBase *sec = d->section;
|
|
|
669 if (!sec)
|
|
|
670 return true;
|
|
|
671 sec = sec->repl;
|
|
|
672
|
|
|
673 // Exclude symbols pointing to garbage-collected sections.
|
|
|
674 if (isa<InputSectionBase>(sec) && !sec->isLive())
|
|
|
675 return false;
|
|
|
676
|
|
|
677 if (auto *s = dyn_cast<MergeInputSection>(sec))
|
|
|
678 if (!s->getSectionPiece(d->value)->live)
|
|
|
679 return false;
|
|
|
680 return true;
|
|
|
681 }
|
|
|
682 return b.used;
|
|
|
683 }
|
|
|
684
|
|
|
685 // Local symbols are not in the linker's symbol table. This function scans
|
|
|
686 // each object file's symbol table to copy local symbols to the output.
|
|
|
687 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
|
|
|
688 if (!in.symTab)
|
|
|
689 return;
|
|
|
690 for (InputFile *file : objectFiles) {
|
|
|
691 ObjFile<ELFT> *f = cast<ObjFile<ELFT>>(file);
|
|
|
692 for (Symbol *b : f->getLocalSymbols()) {
|
|
|
693 if (!b->isLocal())
|
|
|
694 fatal(toString(f) +
|
|
|
695 ": broken object: getLocalSymbols returns a non-local symbol");
|
|
|
696 auto *dr = dyn_cast<Defined>(b);
|
|
|
697
|
|
|
698 // No reason to keep local undefined symbol in symtab.
|
|
|
699 if (!dr)
|
|
|
700 continue;
|
|
|
701 if (!includeInSymtab(*b))
|
|
|
702 continue;
|
|
|
703 if (!shouldKeepInSymtab(*dr))
|
|
|
704 continue;
|
|
|
705 in.symTab->addSymbol(b);
|
|
|
706 }
|
|
|
707 }
|
|
|
708 }
|
|
|
709
|
|
|
710 // Create a section symbol for each output section so that we can represent
|
|
|
711 // relocations that point to the section. If we know that no relocation is
|
|
|
712 // referring to a section (that happens if the section is a synthetic one), we
|
|
|
713 // don't create a section symbol for that section.
|
|
|
714 template <class ELFT> void Writer<ELFT>::addSectionSymbols() {
|
|
|
715 for (BaseCommand *base : script->sectionCommands) {
|
|
|
716 auto *sec = dyn_cast<OutputSection>(base);
|
|
|
717 if (!sec)
|
|
|
718 continue;
|
|
|
719 auto i = llvm::find_if(sec->sectionCommands, [](BaseCommand *base) {
|
|
|
720 if (auto *isd = dyn_cast<InputSectionDescription>(base))
|
|
|
721 return !isd->sections.empty();
|
|
|
722 return false;
|
|
|
723 });
|
|
|
724 if (i == sec->sectionCommands.end())
|
|
|
725 continue;
|
|
|
726 InputSectionBase *isec = cast<InputSectionDescription>(*i)->sections[0];
|
|
|
727
|
|
|
728 // Relocations are not using REL[A] section symbols.
|
|
|
729 if (isec->type == SHT_REL || isec->type == SHT_RELA)
|
|
|
730 continue;
|
|
|
731
|
|
|
732 // Unlike other synthetic sections, mergeable output sections contain data
|
|
|
733 // copied from input sections, and there may be a relocation pointing to its
|
|
|
734 // contents if -r or -emit-reloc are given.
|
|
|
735 if (isa<SyntheticSection>(isec) && !(isec->flags & SHF_MERGE))
|
|
|
736 continue;
|
|
|
737
|
|
|
738 auto *sym =
|
|
|
739 make<Defined>(isec->file, "", STB_LOCAL, /*stOther=*/0, STT_SECTION,
|
|
|
740 /*value=*/0, /*size=*/0, isec);
|
|
|
741 in.symTab->addSymbol(sym);
|
|
|
742 }
|
|
|
743 }
|
|
|
744
|
|
|
745 // Today's loaders have a feature to make segments read-only after
|
|
|
746 // processing dynamic relocations to enhance security. PT_GNU_RELRO
|
|
|
747 // is defined for that.
|
|
|
748 //
|
|
|
749 // This function returns true if a section needs to be put into a
|
|
|
750 // PT_GNU_RELRO segment.
|
|
|
751 static bool isRelroSection(const OutputSection *sec) {
|
|
|
752 if (!config->zRelro)
|
|
|
753 return false;
|
|
|
754
|
|
|
755 uint64_t flags = sec->flags;
|
|
|
756
|
|
|
757 // Non-allocatable or non-writable sections don't need RELRO because
|
|
|
758 // they are not writable or not even mapped to memory in the first place.
|
|
|
759 // RELRO is for sections that are essentially read-only but need to
|
|
|
760 // be writable only at process startup to allow dynamic linker to
|
|
|
761 // apply relocations.
|
|
|
762 if (!(flags & SHF_ALLOC) || !(flags & SHF_WRITE))
|
|
|
763 return false;
|
|
|
764
|
|
|
765 // Once initialized, TLS data segments are used as data templates
|
|
|
766 // for a thread-local storage. For each new thread, runtime
|
|
|
767 // allocates memory for a TLS and copy templates there. No thread
|
|
|
768 // are supposed to use templates directly. Thus, it can be in RELRO.
|
|
|
769 if (flags & SHF_TLS)
|
|
|
770 return true;
|
|
|
771
|
|
|
772 // .init_array, .preinit_array and .fini_array contain pointers to
|
|
|
773 // functions that are executed on process startup or exit. These
|
|
|
774 // pointers are set by the static linker, and they are not expected
|
|
|
775 // to change at runtime. But if you are an attacker, you could do
|
|
|
776 // interesting things by manipulating pointers in .fini_array, for
|
|
|
777 // example. So they are put into RELRO.
|
|
|
778 uint32_t type = sec->type;
|
|
|
779 if (type == SHT_INIT_ARRAY || type == SHT_FINI_ARRAY ||
|
|
|
780 type == SHT_PREINIT_ARRAY)
|
|
|
781 return true;
|
|
|
782
|
|
|
783 // .got contains pointers to external symbols. They are resolved by
|
|
|
784 // the dynamic linker when a module is loaded into memory, and after
|
|
|
785 // that they are not expected to change. So, it can be in RELRO.
|
|
|
786 if (in.got && sec == in.got->getParent())
|
|
|
787 return true;
|
|
|
788
|
|
|
789 // .toc is a GOT-ish section for PowerPC64. Their contents are accessed
|
|
|
790 // through r2 register, which is reserved for that purpose. Since r2 is used
|
|
|
791 // for accessing .got as well, .got and .toc need to be close enough in the
|
|
|
792 // virtual address space. Usually, .toc comes just after .got. Since we place
|
|
|
793 // .got into RELRO, .toc needs to be placed into RELRO too.
|
|
|
794 if (sec->name.equals(".toc"))
|
|
|
795 return true;
|
|
|
796
|
|
|
797 // .got.plt contains pointers to external function symbols. They are
|
|
|
798 // by default resolved lazily, so we usually cannot put it into RELRO.
|
|
|
799 // However, if "-z now" is given, the lazy symbol resolution is
|
|
|
800 // disabled, which enables us to put it into RELRO.
|
|
|
801 if (sec == in.gotPlt->getParent())
|
|
|
802 return config->zNow;
|
|
|
803
|
|
|
804 // .dynamic section contains data for the dynamic linker, and
|
|
|
805 // there's no need to write to it at runtime, so it's better to put
|
|
|
806 // it into RELRO.
|
|
|
807 if (sec->name == ".dynamic")
|
|
|
808 return true;
|
|
|
809
|
|
|
810 // Sections with some special names are put into RELRO. This is a
|
|
|
811 // bit unfortunate because section names shouldn't be significant in
|
|
|
812 // ELF in spirit. But in reality many linker features depend on
|
|
|
813 // magic section names.
|
|
|
814 StringRef s = sec->name;
|
|
|
815 return s == ".data.rel.ro" || s == ".bss.rel.ro" || s == ".ctors" ||
|
|
|
816 s == ".dtors" || s == ".jcr" || s == ".eh_frame" ||
|
|
|
817 s == ".openbsd.randomdata";
|
|
|
818 }
|
|
|
819
|
|
|
820 // We compute a rank for each section. The rank indicates where the
|
|
|
821 // section should be placed in the file. Instead of using simple
|
|
|
822 // numbers (0,1,2...), we use a series of flags. One for each decision
|
|
|
823 // point when placing the section.
|
|
|
824 // Using flags has two key properties:
|
|
|
825 // * It is easy to check if a give branch was taken.
|
|
|
826 // * It is easy two see how similar two ranks are (see getRankProximity).
|
|
|
827 enum RankFlags {
|
|
|
828 RF_NOT_ADDR_SET = 1 << 27,
|
|
|
829 RF_NOT_ALLOC = 1 << 26,
|
|
|
830 RF_PARTITION = 1 << 18, // Partition number (8 bits)
|
|
|
831 RF_NOT_PART_EHDR = 1 << 17,
|
|
|
832 RF_NOT_PART_PHDR = 1 << 16,
|
|
|
833 RF_NOT_INTERP = 1 << 15,
|
|
|
834 RF_NOT_NOTE = 1 << 14,
|
|
|
835 RF_WRITE = 1 << 13,
|
|
|
836 RF_EXEC_WRITE = 1 << 12,
|
|
|
837 RF_EXEC = 1 << 11,
|
|
|
838 RF_RODATA = 1 << 10,
|
|
|
839 RF_NOT_RELRO = 1 << 9,
|
|
|
840 RF_NOT_TLS = 1 << 8,
|
|
|
841 RF_BSS = 1 << 7,
|
|
|
842 RF_PPC_NOT_TOCBSS = 1 << 6,
|
|
|
843 RF_PPC_TOCL = 1 << 5,
|
|
|
844 RF_PPC_TOC = 1 << 4,
|
|
|
845 RF_PPC_GOT = 1 << 3,
|
|
|
846 RF_PPC_BRANCH_LT = 1 << 2,
|
|
|
847 RF_MIPS_GPREL = 1 << 1,
|
|
|
848 RF_MIPS_NOT_GOT = 1 << 0
|
|
|
849 };
|
|
|
850
|
|
|
851 static unsigned getSectionRank(const OutputSection *sec) {
|
|
|
852 unsigned rank = sec->partition * RF_PARTITION;
|
|
|
853
|
|
|
854 // We want to put section specified by -T option first, so we
|
|
|
855 // can start assigning VA starting from them later.
|
|
|
856 if (config->sectionStartMap.count(sec->name))
|
|
|
857 return rank;
|
|
|
858 rank |= RF_NOT_ADDR_SET;
|
|
|
859
|
|
|
860 // Allocatable sections go first to reduce the total PT_LOAD size and
|
|
|
861 // so debug info doesn't change addresses in actual code.
|
|
|
862 if (!(sec->flags & SHF_ALLOC))
|
|
|
863 return rank | RF_NOT_ALLOC;
|
|
|
864
|
|
|
865 if (sec->type == SHT_LLVM_PART_EHDR)
|
|
|
866 return rank;
|
|
|
867 rank |= RF_NOT_PART_EHDR;
|
|
|
868
|
|
|
869 if (sec->type == SHT_LLVM_PART_PHDR)
|
|
|
870 return rank;
|
|
|
871 rank |= RF_NOT_PART_PHDR;
|
|
|
872
|
|
|
873 // Put .interp first because some loaders want to see that section
|
|
|
874 // on the first page of the executable file when loaded into memory.
|
|
|
875 if (sec->name == ".interp")
|
|
|
876 return rank;
|
|
|
877 rank |= RF_NOT_INTERP;
|
|
|
878
|
|
|
879 // Put .note sections (which make up one PT_NOTE) at the beginning so that
|
|
|
880 // they are likely to be included in a core file even if core file size is
|
|
|
881 // limited. In particular, we want a .note.gnu.build-id and a .note.tag to be
|
|
|
882 // included in a core to match core files with executables.
|
|
|
883 if (sec->type == SHT_NOTE)
|
|
|
884 return rank;
|
|
|
885 rank |= RF_NOT_NOTE;
|
|
|
886
|
|
|
887 // Sort sections based on their access permission in the following
|
|
|
888 // order: R, RX, RWX, RW. This order is based on the following
|
|
|
889 // considerations:
|
|
|
890 // * Read-only sections come first such that they go in the
|
|
|
891 // PT_LOAD covering the program headers at the start of the file.
|
|
|
892 // * Read-only, executable sections come next.
|
|
|
893 // * Writable, executable sections follow such that .plt on
|
|
|
894 // architectures where it needs to be writable will be placed
|
|
|
895 // between .text and .data.
|
|
|
896 // * Writable sections come last, such that .bss lands at the very
|
|
|
897 // end of the last PT_LOAD.
|
|
|
898 bool isExec = sec->flags & SHF_EXECINSTR;
|
|
|
899 bool isWrite = sec->flags & SHF_WRITE;
|
|
|
900
|
|
|
901 if (isExec) {
|
|
|
902 if (isWrite)
|
|
|
903 rank |= RF_EXEC_WRITE;
|
|
|
904 else
|
|
|
905 rank |= RF_EXEC;
|
|
|
906 } else if (isWrite) {
|
|
|
907 rank |= RF_WRITE;
|
|
|
908 } else if (sec->type == SHT_PROGBITS) {
|
|
|
909 // Make non-executable and non-writable PROGBITS sections (e.g .rodata
|
|
|
910 // .eh_frame) closer to .text. They likely contain PC or GOT relative
|
|
|
911 // relocations and there could be relocation overflow if other huge sections
|
|
|
912 // (.dynstr .dynsym) were placed in between.
|
|
|
913 rank |= RF_RODATA;
|
|
|
914 }
|
|
|
915
|
|
|
916 // Place RelRo sections first. After considering SHT_NOBITS below, the
|
|
|
917 // ordering is PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss),
|
|
|
918 // where | marks where page alignment happens. An alternative ordering is
|
|
|
919 // PT_LOAD(.data | PT_GNU_RELRO( .data.rel.ro .bss.rel.ro) | .bss), but it may
|
|
|
920 // waste more bytes due to 2 alignment places.
|
|
|
921 if (!isRelroSection(sec))
|
|
|
922 rank |= RF_NOT_RELRO;
|
|
|
923
|
|
|
924 // If we got here we know that both A and B are in the same PT_LOAD.
|
|
|
925
|
|
|
926 // The TLS initialization block needs to be a single contiguous block in a R/W
|
|
|
927 // PT_LOAD, so stick TLS sections directly before the other RelRo R/W
|
|
|
928 // sections. Since p_filesz can be less than p_memsz, place NOBITS sections
|
|
|
929 // after PROGBITS.
|
|
|
930 if (!(sec->flags & SHF_TLS))
|
|
|
931 rank |= RF_NOT_TLS;
|
|
|
932
|
|
|
933 // Within TLS sections, or within other RelRo sections, or within non-RelRo
|
|
|
934 // sections, place non-NOBITS sections first.
|
|
|
935 if (sec->type == SHT_NOBITS)
|
|
|
936 rank |= RF_BSS;
|
|
|
937
|
|
|
938 // Some architectures have additional ordering restrictions for sections
|
|
|
939 // within the same PT_LOAD.
|
|
|
940 if (config->emachine == EM_PPC64) {
|
|
|
941 // PPC64 has a number of special SHT_PROGBITS+SHF_ALLOC+SHF_WRITE sections
|
|
|
942 // that we would like to make sure appear is a specific order to maximize
|
|
|
943 // their coverage by a single signed 16-bit offset from the TOC base
|
|
|
944 // pointer. Conversely, the special .tocbss section should be first among
|
|
|
945 // all SHT_NOBITS sections. This will put it next to the loaded special
|
|
|
946 // PPC64 sections (and, thus, within reach of the TOC base pointer).
|
|
|
947 StringRef name = sec->name;
|
|
|
948 if (name != ".tocbss")
|
|
|
949 rank |= RF_PPC_NOT_TOCBSS;
|
|
|
950
|
|
|
951 if (name == ".toc1")
|
|
|
952 rank |= RF_PPC_TOCL;
|
|
|
953
|
|
|
954 if (name == ".toc")
|
|
|
955 rank |= RF_PPC_TOC;
|
|
|
956
|
|
|
957 if (name == ".got")
|
|
|
958 rank |= RF_PPC_GOT;
|
|
|
959
|
|
|
960 if (name == ".branch_lt")
|
|
|
961 rank |= RF_PPC_BRANCH_LT;
|
|
|
962 }
|
|
|
963
|
|
|
964 if (config->emachine == EM_MIPS) {
|
|
|
965 // All sections with SHF_MIPS_GPREL flag should be grouped together
|
|
|
966 // because data in these sections is addressable with a gp relative address.
|
|
|
967 if (sec->flags & SHF_MIPS_GPREL)
|
|
|
968 rank |= RF_MIPS_GPREL;
|
|
|
969
|
|
|
970 if (sec->name != ".got")
|
|
|
971 rank |= RF_MIPS_NOT_GOT;
|
|
|
972 }
|
|
|
973
|
|
|
974 return rank;
|
|
|
975 }
|
|
|
976
|
|
|
977 static bool compareSections(const BaseCommand *aCmd, const BaseCommand *bCmd) {
|
|
|
978 const OutputSection *a = cast<OutputSection>(aCmd);
|
|
|
979 const OutputSection *b = cast<OutputSection>(bCmd);
|
|
|
980
|
|
|
981 if (a->sortRank != b->sortRank)
|
|
|
982 return a->sortRank < b->sortRank;
|
|
|
983
|
|
|
984 if (!(a->sortRank & RF_NOT_ADDR_SET))
|
|
|
985 return config->sectionStartMap.lookup(a->name) <
|
|
|
986 config->sectionStartMap.lookup(b->name);
|
|
|
987 return false;
|
|
|
988 }
|
|
|
989
|
|
|
990 void PhdrEntry::add(OutputSection *sec) {
|
|
|
991 lastSec = sec;
|
|
|
992 if (!firstSec)
|
|
|
993 firstSec = sec;
|
|
|
994 p_align = std::max(p_align, sec->alignment);
|
|
|
995 if (p_type == PT_LOAD)
|
|
|
996 sec->ptLoad = this;
|
|
|
997 }
|
|
|
998
|
|
|
999 // The beginning and the ending of .rel[a].plt section are marked
|
|
|
1000 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked
|
|
|
1001 // executable. The runtime needs these symbols in order to resolve
|
|
|
1002 // all IRELATIVE relocs on startup. For dynamic executables, we don't
|
|
|
1003 // need these symbols, since IRELATIVE relocs are resolved through GOT
|
|
|
1004 // and PLT. For details, see http://www.airs.com/blog/archives/403.
|
|
|
1005 template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
|
|
|
1006 if (config->relocatable || needsInterpSection())
|
|
|
1007 return;
|
|
|
1008
|
|
|
1009 // By default, __rela_iplt_{start,end} belong to a dummy section 0
|
|
|
1010 // because .rela.plt might be empty and thus removed from output.
|
|
|
1011 // We'll override Out::elfHeader with In.relaIplt later when we are
|
|
|
1012 // sure that .rela.plt exists in output.
|
|
|
1013 ElfSym::relaIpltStart = addOptionalRegular(
|
|
|
1014 config->isRela ? "__rela_iplt_start" : "__rel_iplt_start",
|
|
|
1015 Out::elfHeader, 0, STV_HIDDEN, STB_WEAK);
|
|
|
1016
|
|
|
1017 ElfSym::relaIpltEnd = addOptionalRegular(
|
|
|
1018 config->isRela ? "__rela_iplt_end" : "__rel_iplt_end",
|
|
|
1019 Out::elfHeader, 0, STV_HIDDEN, STB_WEAK);
|
|
|
1020 }
|
|
|
1021
|
|
|
1022 template <class ELFT>
|
|
|
1023 void Writer<ELFT>::forEachRelSec(
|
|
|
1024 llvm::function_ref<void(InputSectionBase &)> fn) {
|
|
|
1025 // Scan all relocations. Each relocation goes through a series
|
|
|
1026 // of tests to determine if it needs special treatment, such as
|
|
|
1027 // creating GOT, PLT, copy relocations, etc.
|
|
|
1028 // Note that relocations for non-alloc sections are directly
|
|
|
1029 // processed by InputSection::relocateNonAlloc.
|
|
|
1030 for (InputSectionBase *isec : inputSections)
|
|
|
1031 if (isec->isLive() && isa<InputSection>(isec) && (isec->flags & SHF_ALLOC))
|
|
|
1032 fn(*isec);
|
|
|
1033 for (Partition &part : partitions) {
|
|
|
1034 for (EhInputSection *es : part.ehFrame->sections)
|
|
|
1035 fn(*es);
|
|
|
1036 if (part.armExidx && part.armExidx->isLive())
|
|
|
1037 for (InputSection *ex : part.armExidx->exidxSections)
|
|
|
1038 fn(*ex);
|
|
|
1039 }
|
|
|
1040 }
|
|
|
1041
|
|
|
1042 // This function generates assignments for predefined symbols (e.g. _end or
|
|
|
1043 // _etext) and inserts them into the commands sequence to be processed at the
|
|
|
1044 // appropriate time. This ensures that the value is going to be correct by the
|
|
|
1045 // time any references to these symbols are processed and is equivalent to
|
|
|
1046 // defining these symbols explicitly in the linker script.
|
|
|
1047 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
|
|
|
1048 if (ElfSym::globalOffsetTable) {
|
|
|
1049 // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually
|
|
|
1050 // to the start of the .got or .got.plt section.
|
|
|
1051 InputSection *gotSection = in.gotPlt;
|
|
|
1052 if (!target->gotBaseSymInGotPlt)
|
|
|
1053 gotSection = in.mipsGot ? cast<InputSection>(in.mipsGot)
|
|
|
1054 : cast<InputSection>(in.got);
|
|
|
1055 ElfSym::globalOffsetTable->section = gotSection;
|
|
|
1056 }
|
|
|
1057
|
|
|
1058 // .rela_iplt_{start,end} mark the start and the end of in.relaIplt.
|
|
|
1059 if (ElfSym::relaIpltStart && in.relaIplt->isNeeded()) {
|
|
|
1060 ElfSym::relaIpltStart->section = in.relaIplt;
|
|
|
1061 ElfSym::relaIpltEnd->section = in.relaIplt;
|
|
|
1062 ElfSym::relaIpltEnd->value = in.relaIplt->getSize();
|
|
|
1063 }
|
|
|
1064
|
|
|
1065 PhdrEntry *last = nullptr;
|
|
|
1066 PhdrEntry *lastRO = nullptr;
|
|
|
1067
|
|
|
1068 for (Partition &part : partitions) {
|
|
|
1069 for (PhdrEntry *p : part.phdrs) {
|
|
|
1070 if (p->p_type != PT_LOAD)
|
|
|
1071 continue;
|
|
|
1072 last = p;
|
|
|
1073 if (!(p->p_flags & PF_W))
|
|
|
1074 lastRO = p;
|
|
|
1075 }
|
|
|
1076 }
|
|
|
1077
|
|
|
1078 if (lastRO) {
|
|
|
1079 // _etext is the first location after the last read-only loadable segment.
|
|
|
1080 if (ElfSym::etext1)
|
|
|
1081 ElfSym::etext1->section = lastRO->lastSec;
|
|
|
1082 if (ElfSym::etext2)
|
|
|
1083 ElfSym::etext2->section = lastRO->lastSec;
|
|
|
1084 }
|
|
|
1085
|
|
|
1086 if (last) {
|
|
|
1087 // _edata points to the end of the last mapped initialized section.
|
|
|
1088 OutputSection *edata = nullptr;
|
|
|
1089 for (OutputSection *os : outputSections) {
|
|
|
1090 if (os->type != SHT_NOBITS)
|
|
|
1091 edata = os;
|
|
|
1092 if (os == last->lastSec)
|
|
|
1093 break;
|
|
|
1094 }
|
|
|
1095
|
|
|
1096 if (ElfSym::edata1)
|
|
|
1097 ElfSym::edata1->section = edata;
|
|
|
1098 if (ElfSym::edata2)
|
|
|
1099 ElfSym::edata2->section = edata;
|
|
|
1100
|
|
|
1101 // _end is the first location after the uninitialized data region.
|
|
|
1102 if (ElfSym::end1)
|
|
|
1103 ElfSym::end1->section = last->lastSec;
|
|
|
1104 if (ElfSym::end2)
|
|
|
1105 ElfSym::end2->section = last->lastSec;
|
|
|
1106 }
|
|
|
1107
|
|
|
1108 if (ElfSym::bss)
|
|
|
1109 ElfSym::bss->section = findSection(".bss");
|
|
|
1110
|
|
|
1111 // Setup MIPS _gp_disp/__gnu_local_gp symbols which should
|
|
|
1112 // be equal to the _gp symbol's value.
|
|
|
1113 if (ElfSym::mipsGp) {
|
|
|
1114 // Find GP-relative section with the lowest address
|
|
|
1115 // and use this address to calculate default _gp value.
|
|
|
1116 for (OutputSection *os : outputSections) {
|
|
|
1117 if (os->flags & SHF_MIPS_GPREL) {
|
|
|
1118 ElfSym::mipsGp->section = os;
|
|
|
1119 ElfSym::mipsGp->value = 0x7ff0;
|
|
|
1120 break;
|
|
|
1121 }
|
|
|
1122 }
|
|
|
1123 }
|
|
|
1124 }
|
|
|
1125
|
|
|
1126 // We want to find how similar two ranks are.
|
|
|
1127 // The more branches in getSectionRank that match, the more similar they are.
|
|
|
1128 // Since each branch corresponds to a bit flag, we can just use
|
|
|
1129 // countLeadingZeros.
|
|
|
1130 static int getRankProximityAux(OutputSection *a, OutputSection *b) {
|
|
|
1131 return countLeadingZeros(a->sortRank ^ b->sortRank);
|
|
|
1132 }
|
|
|
1133
|
|
|
1134 static int getRankProximity(OutputSection *a, BaseCommand *b) {
|
|
|
1135 auto *sec = dyn_cast<OutputSection>(b);
|
|
|
1136 return (sec && sec->hasInputSections) ? getRankProximityAux(a, sec) : -1;
|
|
|
1137 }
|
|
|
1138
|
|
|
1139 // When placing orphan sections, we want to place them after symbol assignments
|
|
|
1140 // so that an orphan after
|
|
|
1141 // begin_foo = .;
|
|
|
1142 // foo : { *(foo) }
|
|
|
1143 // end_foo = .;
|
|
|
1144 // doesn't break the intended meaning of the begin/end symbols.
|
|
|
1145 // We don't want to go over sections since findOrphanPos is the
|
|
|
1146 // one in charge of deciding the order of the sections.
|
|
|
1147 // We don't want to go over changes to '.', since doing so in
|
|
|
1148 // rx_sec : { *(rx_sec) }
|
|
|
1149 // . = ALIGN(0x1000);
|
|
|
1150 // /* The RW PT_LOAD starts here*/
|
|
|
1151 // rw_sec : { *(rw_sec) }
|
|
|
1152 // would mean that the RW PT_LOAD would become unaligned.
|
|
|
1153 static bool shouldSkip(BaseCommand *cmd) {
|
|
|
1154 if (auto *assign = dyn_cast<SymbolAssignment>(cmd))
|
|
|
1155 return assign->name != ".";
|
|
|
1156 return false;
|
|
|
1157 }
|
|
|
1158
|
|
|
1159 // We want to place orphan sections so that they share as much
|
|
|
1160 // characteristics with their neighbors as possible. For example, if
|
|
|
1161 // both are rw, or both are tls.
|
|
|
1162 static std::vector<BaseCommand *>::iterator
|
|
|
1163 findOrphanPos(std::vector<BaseCommand *>::iterator b,
|
|
|
1164 std::vector<BaseCommand *>::iterator e) {
|
|
|
1165 OutputSection *sec = cast<OutputSection>(*e);
|
|
|
1166
|
|
|
1167 // Find the first element that has as close a rank as possible.
|
|
|
1168 auto i = std::max_element(b, e, [=](BaseCommand *a, BaseCommand *b) {
|
|
|
1169 return getRankProximity(sec, a) < getRankProximity(sec, b);
|
|
|
1170 });
|
|
|
1171 if (i == e)
|
|
|
1172 return e;
|
|
|
1173
|
|
|
1174 // Consider all existing sections with the same proximity.
|
|
|
1175 int proximity = getRankProximity(sec, *i);
|
|
|
1176 for (; i != e; ++i) {
|
|
|
1177 auto *curSec = dyn_cast<OutputSection>(*i);
|
|
|
1178 if (!curSec || !curSec->hasInputSections)
|
|
|
1179 continue;
|
|
|
1180 if (getRankProximity(sec, curSec) != proximity ||
|
|
|
1181 sec->sortRank < curSec->sortRank)
|
|
|
1182 break;
|
|
|
1183 }
|
|
|
1184
|
|
|
1185 auto isOutputSecWithInputSections = [](BaseCommand *cmd) {
|
|
|
1186 auto *os = dyn_cast<OutputSection>(cmd);
|
|
|
1187 return os && os->hasInputSections;
|
|
|
1188 };
|
|
|
1189 auto j = std::find_if(llvm::make_reverse_iterator(i),
|
|
|
1190 llvm::make_reverse_iterator(b),
|
|
|
1191 isOutputSecWithInputSections);
|
|
|
1192 i = j.base();
|
|
|
1193
|
|
|
1194 // As a special case, if the orphan section is the last section, put
|
|
|
1195 // it at the very end, past any other commands.
|
|
|
1196 // This matches bfd's behavior and is convenient when the linker script fully
|
|
|
1197 // specifies the start of the file, but doesn't care about the end (the non
|
|
|
1198 // alloc sections for example).
|
|
|
1199 auto nextSec = std::find_if(i, e, isOutputSecWithInputSections);
|
|
|
1200 if (nextSec == e)
|
|
|
1201 return e;
|
|
|
1202
|
|
|
1203 while (i != e && shouldSkip(*i))
|
|
|
1204 ++i;
|
|
|
1205 return i;
|
|
|
1206 }
|
|
|
1207
|
|
|
1208 // Builds section order for handling --symbol-ordering-file.
|
|
|
1209 static DenseMap<const InputSectionBase *, int> buildSectionOrder() {
|
|
|
1210 DenseMap<const InputSectionBase *, int> sectionOrder;
|
|
|
1211 // Use the rarely used option -call-graph-ordering-file to sort sections.
|
|
|
1212 if (!config->callGraphProfile.empty())
|
|
|
1213 return computeCallGraphProfileOrder();
|
|
|
1214
|
|
|
1215 if (config->symbolOrderingFile.empty())
|
|
|
1216 return sectionOrder;
|
|
|
1217
|
|
|
1218 struct SymbolOrderEntry {
|
|
|
1219 int priority;
|
|
|
1220 bool present;
|
|
|
1221 };
|
|
|
1222
|
|
|
1223 // Build a map from symbols to their priorities. Symbols that didn't
|
|
|
1224 // appear in the symbol ordering file have the lowest priority 0.
|
|
|
1225 // All explicitly mentioned symbols have negative (higher) priorities.
|
|
|
1226 DenseMap<StringRef, SymbolOrderEntry> symbolOrder;
|
|
|
1227 int priority = -config->symbolOrderingFile.size();
|
|
|
1228 for (StringRef s : config->symbolOrderingFile)
|
|
|
1229 symbolOrder.insert({s, {priority++, false}});
|
|
|
1230
|
|
|
1231 // Build a map from sections to their priorities.
|
|
|
1232 auto addSym = [&](Symbol &sym) {
|
|
|
1233 auto it = symbolOrder.find(sym.getName());
|
|
|
1234 if (it == symbolOrder.end())
|
|
|
1235 return;
|
|
|
1236 SymbolOrderEntry &ent = it->second;
|
|
|
1237 ent.present = true;
|
|
|
1238
|
|
|
1239 maybeWarnUnorderableSymbol(&sym);
|
|
|
1240
|
|
|
1241 if (auto *d = dyn_cast<Defined>(&sym)) {
|
|
|
1242 if (auto *sec = dyn_cast_or_null<InputSectionBase>(d->section)) {
|
|
|
1243 int &priority = sectionOrder[cast<InputSectionBase>(sec->repl)];
|
|
|
1244 priority = std::min(priority, ent.priority);
|
|
|
1245 }
|
|
|
1246 }
|
|
|
1247 };
|
|
|
1248
|
|
|
1249 // We want both global and local symbols. We get the global ones from the
|
|
|
1250 // symbol table and iterate the object files for the local ones.
|
|
|
1251 for (Symbol *sym : symtab->symbols())
|
|
|
1252 if (!sym->isLazy())
|
|
|
1253 addSym(*sym);
|
|
|
1254
|
|
|
1255 for (InputFile *file : objectFiles)
|
|
|
1256 for (Symbol *sym : file->getSymbols())
|
|
|
1257 if (sym->isLocal())
|
|
|
1258 addSym(*sym);
|
|
|
1259
|
|
|
1260 if (config->warnSymbolOrdering)
|
|
|
1261 for (auto orderEntry : symbolOrder)
|
|
|
1262 if (!orderEntry.second.present)
|
|
|
1263 warn("symbol ordering file: no such symbol: " + orderEntry.first);
|
|
|
1264
|
|
|
1265 return sectionOrder;
|
|
|
1266 }
|
|
|
1267
|
|
|
1268 // Sorts the sections in ISD according to the provided section order.
|
|
|
1269 static void
|
|
|
1270 sortISDBySectionOrder(InputSectionDescription *isd,
|
|
|
1271 const DenseMap<const InputSectionBase *, int> &order) {
|
|
|
1272 std::vector<InputSection *> unorderedSections;
|
|
|
1273 std::vector<std::pair<InputSection *, int>> orderedSections;
|
|
|
1274 uint64_t unorderedSize = 0;
|
|
|
1275
|
|
|
1276 for (InputSection *isec : isd->sections) {
|
|
|
1277 auto i = order.find(isec);
|
|
|
1278 if (i == order.end()) {
|
|
|
1279 unorderedSections.push_back(isec);
|
|
|
1280 unorderedSize += isec->getSize();
|
|
|
1281 continue;
|
|
|
1282 }
|
|
|
1283 orderedSections.push_back({isec, i->second});
|
|
|
1284 }
|
|
|
1285 llvm::sort(orderedSections, llvm::less_second());
|
|
|
1286
|
|
|
1287 // Find an insertion point for the ordered section list in the unordered
|
|
|
1288 // section list. On targets with limited-range branches, this is the mid-point
|
|
|
1289 // of the unordered section list. This decreases the likelihood that a range
|
|
|
1290 // extension thunk will be needed to enter or exit the ordered region. If the
|
|
|
1291 // ordered section list is a list of hot functions, we can generally expect
|
|
|
1292 // the ordered functions to be called more often than the unordered functions,
|
|
|
1293 // making it more likely that any particular call will be within range, and
|
|
|
1294 // therefore reducing the number of thunks required.
|
|
|
1295 //
|
|
|
1296 // For example, imagine that you have 8MB of hot code and 32MB of cold code.
|
|
|
1297 // If the layout is:
|
|
|
1298 //
|
|
|
1299 // 8MB hot
|
|
|
1300 // 32MB cold
|
|
|
1301 //
|
|
|
1302 // only the first 8-16MB of the cold code (depending on which hot function it
|
|
|
1303 // is actually calling) can call the hot code without a range extension thunk.
|
|
|
1304 // However, if we use this layout:
|
|
|
1305 //
|
|
|
1306 // 16MB cold
|
|
|
1307 // 8MB hot
|
|
|
1308 // 16MB cold
|
|
|
1309 //
|
|
|
1310 // both the last 8-16MB of the first block of cold code and the first 8-16MB
|
|
|
1311 // of the second block of cold code can call the hot code without a thunk. So
|
|
|
1312 // we effectively double the amount of code that could potentially call into
|
|
|
1313 // the hot code without a thunk.
|
|
|
1314 size_t insPt = 0;
|
|
|
1315 if (target->getThunkSectionSpacing() && !orderedSections.empty()) {
|
|
|
1316 uint64_t unorderedPos = 0;
|
|
|
1317 for (; insPt != unorderedSections.size(); ++insPt) {
|
|
|
1318 unorderedPos += unorderedSections[insPt]->getSize();
|
|
|
1319 if (unorderedPos > unorderedSize / 2)
|
|
|
1320 break;
|
|
|
1321 }
|
|
|
1322 }
|
|
|
1323
|
|
|
1324 isd->sections.clear();
|
|
|
1325 for (InputSection *isec : makeArrayRef(unorderedSections).slice(0, insPt))
|
|
|
1326 isd->sections.push_back(isec);
|
|
|
1327 for (std::pair<InputSection *, int> p : orderedSections)
|
|
|
1328 isd->sections.push_back(p.first);
|
|
|
1329 for (InputSection *isec : makeArrayRef(unorderedSections).slice(insPt))
|
|
|
1330 isd->sections.push_back(isec);
|
|
|
1331 }
|
|
|
1332
|
|
|
1333 static void sortSection(OutputSection *sec,
|
|
|
1334 const DenseMap<const InputSectionBase *, int> &order) {
|
|
|
1335 StringRef name = sec->name;
|
|
|
1336
|
|
|
1337 // Sort input sections by section name suffixes for
|
|
|
1338 // __attribute__((init_priority(N))).
|
|
|
1339 if (name == ".init_array" || name == ".fini_array") {
|
|
|
1340 if (!script->hasSectionsCommand)
|
|
|
1341 sec->sortInitFini();
|
|
|
1342 return;
|
|
|
1343 }
|
|
|
1344
|
|
|
1345 // Sort input sections by the special rule for .ctors and .dtors.
|
|
|
1346 if (name == ".ctors" || name == ".dtors") {
|
|
|
1347 if (!script->hasSectionsCommand)
|
|
|
1348 sec->sortCtorsDtors();
|
|
|
1349 return;
|
|
|
1350 }
|
|
|
1351
|
|
|
1352 // Never sort these.
|
|
|
1353 if (name == ".init" || name == ".fini")
|
|
|
1354 return;
|
|
|
1355
|
|
|
1356 // .toc is allocated just after .got and is accessed using GOT-relative
|
|
|
1357 // relocations. Object files compiled with small code model have an
|
|
|
1358 // addressable range of [.got, .got + 0xFFFC] for GOT-relative relocations.
|
|
|
1359 // To reduce the risk of relocation overflow, .toc contents are sorted so that
|
|
|
1360 // sections having smaller relocation offsets are at beginning of .toc
|
|
|
1361 if (config->emachine == EM_PPC64 && name == ".toc") {
|
|
|
1362 if (script->hasSectionsCommand)
|
|
|
1363 return;
|
|
|
1364 assert(sec->sectionCommands.size() == 1);
|
|
|
1365 auto *isd = cast<InputSectionDescription>(sec->sectionCommands[0]);
|
|
|
1366 llvm::stable_sort(isd->sections,
|
|
|
1367 [](const InputSection *a, const InputSection *b) -> bool {
|
|
|
1368 return a->file->ppc64SmallCodeModelTocRelocs &&
|
|
|
1369 !b->file->ppc64SmallCodeModelTocRelocs;
|
|
|
1370 });
|
|
|
1371 return;
|
|
|
1372 }
|
|
|
1373
|
|
|
1374 // Sort input sections by priority using the list provided
|
|
|
1375 // by --symbol-ordering-file.
|
|
|
1376 if (!order.empty())
|
|
|
1377 for (BaseCommand *b : sec->sectionCommands)
|
|
|
1378 if (auto *isd = dyn_cast<InputSectionDescription>(b))
|
|
|
1379 sortISDBySectionOrder(isd, order);
|
|
|
1380 }
|
|
|
1381
|
|
|
1382 // If no layout was provided by linker script, we want to apply default
|
|
|
1383 // sorting for special input sections. This also handles --symbol-ordering-file.
|
|
|
1384 template <class ELFT> void Writer<ELFT>::sortInputSections() {
|
|
|
1385 // Build the order once since it is expensive.
|
|
|
1386 DenseMap<const InputSectionBase *, int> order = buildSectionOrder();
|
|
|
1387 for (BaseCommand *base : script->sectionCommands)
|
|
|
1388 if (auto *sec = dyn_cast<OutputSection>(base))
|
|
|
1389 sortSection(sec, order);
|
|
|
1390 }
|
|
|
1391
|
|
|
1392 template <class ELFT> void Writer<ELFT>::sortSections() {
|
|
|
1393 script->adjustSectionsBeforeSorting();
|
|
|
1394
|
|
|
1395 // Don't sort if using -r. It is not necessary and we want to preserve the
|
|
|
1396 // relative order for SHF_LINK_ORDER sections.
|
|
|
1397 if (config->relocatable)
|
|
|
1398 return;
|
|
|
1399
|
|
|
1400 sortInputSections();
|
|
|
1401
|
|
|
1402 for (BaseCommand *base : script->sectionCommands) {
|
|
|
1403 auto *os = dyn_cast<OutputSection>(base);
|
|
|
1404 if (!os)
|
|
|
1405 continue;
|
|
|
1406 os->sortRank = getSectionRank(os);
|
|
|
1407
|
|
|
1408 // We want to assign rude approximation values to outSecOff fields
|
|
|
1409 // to know the relative order of the input sections. We use it for
|
|
|
1410 // sorting SHF_LINK_ORDER sections. See resolveShfLinkOrder().
|
|
|
1411 uint64_t i = 0;
|
|
|
1412 for (InputSection *sec : getInputSections(os))
|
|
|
1413 sec->outSecOff = i++;
|
|
|
1414 }
|
|
|
1415
|
|
|
1416 if (!script->hasSectionsCommand) {
|
|
|
1417 // We know that all the OutputSections are contiguous in this case.
|
|
|
1418 auto isSection = [](BaseCommand *base) { return isa<OutputSection>(base); };
|
|
|
1419 std::stable_sort(
|
|
|
1420 llvm::find_if(script->sectionCommands, isSection),
|
|
|
1421 llvm::find_if(llvm::reverse(script->sectionCommands), isSection).base(),
|
|
|
1422 compareSections);
|
|
|
1423
|
|
|
1424 // Process INSERT commands. From this point onwards the order of
|
|
|
1425 // script->sectionCommands is fixed.
|
|
|
1426 script->processInsertCommands();
|
|
|
1427 return;
|
|
|
1428 }
|
|
|
1429
|
|
|
1430 script->processInsertCommands();
|
|
|
1431
|
|
|
1432 // Orphan sections are sections present in the input files which are
|
|
|
1433 // not explicitly placed into the output file by the linker script.
|
|
|
1434 //
|
|
|
1435 // The sections in the linker script are already in the correct
|
|
|
1436 // order. We have to figuere out where to insert the orphan
|
|
|
1437 // sections.
|
|
|
1438 //
|
|
|
1439 // The order of the sections in the script is arbitrary and may not agree with
|
|
|
1440 // compareSections. This means that we cannot easily define a strict weak
|
|
|
1441 // ordering. To see why, consider a comparison of a section in the script and
|
|
|
1442 // one not in the script. We have a two simple options:
|
|
|
1443 // * Make them equivalent (a is not less than b, and b is not less than a).
|
|
|
1444 // The problem is then that equivalence has to be transitive and we can
|
|
|
1445 // have sections a, b and c with only b in a script and a less than c
|
|
|
1446 // which breaks this property.
|
|
|
1447 // * Use compareSectionsNonScript. Given that the script order doesn't have
|
|
|
1448 // to match, we can end up with sections a, b, c, d where b and c are in the
|
|
|
1449 // script and c is compareSectionsNonScript less than b. In which case d
|
|
|
1450 // can be equivalent to c, a to b and d < a. As a concrete example:
|
|
|
1451 // .a (rx) # not in script
|
|
|
1452 // .b (rx) # in script
|
|
|
1453 // .c (ro) # in script
|
|
|
1454 // .d (ro) # not in script
|
|
|
1455 //
|
|
|
1456 // The way we define an order then is:
|
|
|
1457 // * Sort only the orphan sections. They are in the end right now.
|
|
|
1458 // * Move each orphan section to its preferred position. We try
|
|
|
1459 // to put each section in the last position where it can share
|
|
|
1460 // a PT_LOAD.
|
|
|
1461 //
|
|
|
1462 // There is some ambiguity as to where exactly a new entry should be
|
|
|
1463 // inserted, because Commands contains not only output section
|
|
|
1464 // commands but also other types of commands such as symbol assignment
|
|
|
1465 // expressions. There's no correct answer here due to the lack of the
|
|
|
1466 // formal specification of the linker script. We use heuristics to
|
|
|
1467 // determine whether a new output command should be added before or
|
|
|
1468 // after another commands. For the details, look at shouldSkip
|
|
|
1469 // function.
|
|
|
1470
|
|
|
1471 auto i = script->sectionCommands.begin();
|
|
|
1472 auto e = script->sectionCommands.end();
|
|
|
1473 auto nonScriptI = std::find_if(i, e, [](BaseCommand *base) {
|
|
|
1474 if (auto *sec = dyn_cast<OutputSection>(base))
|
|
|
1475 return sec->sectionIndex == UINT32_MAX;
|
|
|
1476 return false;
|
|
|
1477 });
|
|
|
1478
|
|
|
1479 // Sort the orphan sections.
|
|
|
1480 std::stable_sort(nonScriptI, e, compareSections);
|
|
|
1481
|
|
|
1482 // As a horrible special case, skip the first . assignment if it is before any
|
|
|
1483 // section. We do this because it is common to set a load address by starting
|
|
|
1484 // the script with ". = 0xabcd" and the expectation is that every section is
|
|
|
1485 // after that.
|
|
|
1486 auto firstSectionOrDotAssignment =
|
|
|
1487 std::find_if(i, e, [](BaseCommand *cmd) { return !shouldSkip(cmd); });
|
|
|
1488 if (firstSectionOrDotAssignment != e &&
|
|
|
1489 isa<SymbolAssignment>(**firstSectionOrDotAssignment))
|
|
|
1490 ++firstSectionOrDotAssignment;
|
|
|
1491 i = firstSectionOrDotAssignment;
|
|
|
1492
|
|
|
1493 while (nonScriptI != e) {
|
|
|
1494 auto pos = findOrphanPos(i, nonScriptI);
|
|
|
1495 OutputSection *orphan = cast<OutputSection>(*nonScriptI);
|
|
|
1496
|
|
|
1497 // As an optimization, find all sections with the same sort rank
|
|
|
1498 // and insert them with one rotate.
|
|
|
1499 unsigned rank = orphan->sortRank;
|
|
|
1500 auto end = std::find_if(nonScriptI + 1, e, [=](BaseCommand *cmd) {
|
|
|
1501 return cast<OutputSection>(cmd)->sortRank != rank;
|
|
|
1502 });
|
|
|
1503 std::rotate(pos, nonScriptI, end);
|
|
|
1504 nonScriptI = end;
|
|
|
1505 }
|
|
|
1506
|
|
|
1507 script->adjustSectionsAfterSorting();
|
|
|
1508 }
|
|
|
1509
|
|
|
1510 static bool compareByFilePosition(InputSection *a, InputSection *b) {
|
|
|
1511 InputSection *la = a->getLinkOrderDep();
|
|
|
1512 InputSection *lb = b->getLinkOrderDep();
|
|
|
1513 OutputSection *aOut = la->getParent();
|
|
|
1514 OutputSection *bOut = lb->getParent();
|
|
|
1515
|
|
|
1516 if (aOut != bOut)
|
|
|
1517 return aOut->sectionIndex < bOut->sectionIndex;
|
|
|
1518 return la->outSecOff < lb->outSecOff;
|
|
|
1519 }
|
|
|
1520
|
|
|
1521 template <class ELFT> void Writer<ELFT>::resolveShfLinkOrder() {
|
|
|
1522 for (OutputSection *sec : outputSections) {
|
|
|
1523 if (!(sec->flags & SHF_LINK_ORDER))
|
|
|
1524 continue;
|
|
|
1525
|
|
|
1526 // The ARM.exidx section use SHF_LINK_ORDER, but we have consolidated
|
|
|
1527 // this processing inside the ARMExidxsyntheticsection::finalizeContents().
|
|
|
1528 if (!config->relocatable && config->emachine == EM_ARM &&
|
|
|
1529 sec->type == SHT_ARM_EXIDX)
|
|
|
1530 continue;
|
|
|
1531
|
|
|
1532 // Link order may be distributed across several InputSectionDescriptions
|
|
|
1533 // but sort must consider them all at once.
|
|
|
1534 std::vector<InputSection **> scriptSections;
|
|
|
1535 std::vector<InputSection *> sections;
|
|
|
1536 for (BaseCommand *base : sec->sectionCommands) {
|
|
|
1537 if (auto *isd = dyn_cast<InputSectionDescription>(base)) {
|
|
|
1538 for (InputSection *&isec : isd->sections) {
|
|
|
1539 scriptSections.push_back(&isec);
|
|
|
1540 sections.push_back(isec);
|
|
|
1541
|
|
|
1542 InputSection *link = isec->getLinkOrderDep();
|
|
|
1543 if (!link->getParent())
|
|
|
1544 error(toString(isec) + ": sh_link points to discarded section " +
|
|
|
1545 toString(link));
|
|
|
1546 }
|
|
|
1547 }
|
|
|
1548 }
|
|
|
1549
|
|
|
1550 if (errorCount())
|
|
|
1551 continue;
|
|
|
1552
|
|
|
1553 llvm::stable_sort(sections, compareByFilePosition);
|
|
|
1554
|
|
|
1555 for (int i = 0, n = sections.size(); i < n; ++i)
|
|
|
1556 *scriptSections[i] = sections[i];
|
|
|
1557 }
|
|
|
1558 }
|
|
|
1559
|
|
|
1560 // We need to generate and finalize the content that depends on the address of
|
|
|
1561 // InputSections. As the generation of the content may also alter InputSection
|
|
|
1562 // addresses we must converge to a fixed point. We do that here. See the comment
|
|
|
1563 // in Writer<ELFT>::finalizeSections().
|
|
|
1564 template <class ELFT> void Writer<ELFT>::finalizeAddressDependentContent() {
|
|
|
1565 ThunkCreator tc;
|
|
|
1566 AArch64Err843419Patcher a64p;
|
|
|
1567 ARMErr657417Patcher a32p;
|
|
|
1568 script->assignAddresses();
|
|
|
1569
|
|
|
1570 int assignPasses = 0;
|
|
|
1571 for (;;) {
|
|
|
1572 bool changed = target->needsThunks && tc.createThunks(outputSections);
|
|
|
1573
|
|
|
1574 // With Thunk Size much smaller than branch range we expect to
|
|
|
1575 // converge quickly; if we get to 10 something has gone wrong.
|
|
|
1576 if (changed && tc.pass >= 10) {
|
|
|
1577 error("thunk creation not converged");
|
|
|
1578 break;
|
|
|
1579 }
|
|
|
1580
|
|
|
1581 if (config->fixCortexA53Errata843419) {
|
|
|
1582 if (changed)
|
|
|
1583 script->assignAddresses();
|
|
|
1584 changed |= a64p.createFixes();
|
|
|
1585 }
|
|
|
1586 if (config->fixCortexA8) {
|
|
|
1587 if (changed)
|
|
|
1588 script->assignAddresses();
|
|
|
1589 changed |= a32p.createFixes();
|
|
|
1590 }
|
|
|
1591
|
|
|
1592 if (in.mipsGot)
|
|
|
1593 in.mipsGot->updateAllocSize();
|
|
|
1594
|
|
|
1595 for (Partition &part : partitions) {
|
|
|
1596 changed |= part.relaDyn->updateAllocSize();
|
|
|
1597 if (part.relrDyn)
|
|
|
1598 changed |= part.relrDyn->updateAllocSize();
|
|
|
1599 }
|
|
|
1600
|
|
|
1601 const Defined *changedSym = script->assignAddresses();
|
|
|
1602 if (!changed) {
|
|
|
1603 // Some symbols may be dependent on section addresses. When we break the
|
|
|
1604 // loop, the symbol values are finalized because a previous
|
|
|
1605 // assignAddresses() finalized section addresses.
|
|
|
1606 if (!changedSym)
|
|
|
1607 break;
|
|
|
1608 if (++assignPasses == 5) {
|
|
|
1609 errorOrWarn("assignment to symbol " + toString(*changedSym) +
|
|
|
1610 " does not converge");
|
|
|
1611 break;
|
|
|
1612 }
|
|
|
1613 }
|
|
|
1614 }
|
|
|
1615 }
|
|
|
1616
|
|
|
1617 static void finalizeSynthetic(SyntheticSection *sec) {
|
|
|
1618 if (sec && sec->isNeeded() && sec->getParent())
|
|
|
1619 sec->finalizeContents();
|
|
|
1620 }
|
|
|
1621
|
|
|
1622 // In order to allow users to manipulate linker-synthesized sections,
|
|
|
1623 // we had to add synthetic sections to the input section list early,
|
|
|
1624 // even before we make decisions whether they are needed. This allows
|
|
|
1625 // users to write scripts like this: ".mygot : { .got }".
|
|
|
1626 //
|
|
|
1627 // Doing it has an unintended side effects. If it turns out that we
|
|
|
1628 // don't need a .got (for example) at all because there's no
|
|
|
1629 // relocation that needs a .got, we don't want to emit .got.
|
|
|
1630 //
|
|
|
1631 // To deal with the above problem, this function is called after
|
|
|
1632 // scanRelocations is called to remove synthetic sections that turn
|
|
|
1633 // out to be empty.
|
|
|
1634 static void removeUnusedSyntheticSections() {
|
|
|
1635 // All input synthetic sections that can be empty are placed after
|
|
|
1636 // all regular ones. We iterate over them all and exit at first
|
|
|
1637 // non-synthetic.
|
|
|
1638 for (InputSectionBase *s : llvm::reverse(inputSections)) {
|
|
|
1639 SyntheticSection *ss = dyn_cast<SyntheticSection>(s);
|
|
|
1640 if (!ss)
|
|
|
1641 return;
|
|
|
1642 OutputSection *os = ss->getParent();
|
|
|
1643 if (!os || ss->isNeeded())
|
|
|
1644 continue;
|
|
|
1645
|
|
|
1646 // If we reach here, then SS is an unused synthetic section and we want to
|
|
|
1647 // remove it from corresponding input section description of output section.
|
|
|
1648 for (BaseCommand *b : os->sectionCommands)
|
|
|
1649 if (auto *isd = dyn_cast<InputSectionDescription>(b))
|
|
|
1650 llvm::erase_if(isd->sections,
|
|
|
1651 [=](InputSection *isec) { return isec == ss; });
|
|
|
1652 }
|
|
|
1653 }
|
|
|
1654
|
|
|
1655 // Create output section objects and add them to OutputSections.
|
|
|
1656 template <class ELFT> void Writer<ELFT>::finalizeSections() {
|
|
|
1657 Out::preinitArray = findSection(".preinit_array");
|
|
|
1658 Out::initArray = findSection(".init_array");
|
|
|
1659 Out::finiArray = findSection(".fini_array");
|
|
|
1660
|
|
|
1661 // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop
|
|
|
1662 // symbols for sections, so that the runtime can get the start and end
|
|
|
1663 // addresses of each section by section name. Add such symbols.
|
|
|
1664 if (!config->relocatable) {
|
|
|
1665 addStartEndSymbols();
|
|
|
1666 for (BaseCommand *base : script->sectionCommands)
|
|
|
1667 if (auto *sec = dyn_cast<OutputSection>(base))
|
|
|
1668 addStartStopSymbols(sec);
|
|
|
1669 }
|
|
|
1670
|
|
|
1671 // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type.
|
|
|
1672 // It should be okay as no one seems to care about the type.
|
|
|
1673 // Even the author of gold doesn't remember why gold behaves that way.
|
|
|
1674 // https://sourceware.org/ml/binutils/2002-03/msg00360.html
|
|
|
1675 if (mainPart->dynamic->parent)
|
|
|
1676 symtab->addSymbol(Defined{/*file=*/nullptr, "_DYNAMIC", STB_WEAK,
|
|
|
1677 STV_HIDDEN, STT_NOTYPE,
|
|
|
1678 /*value=*/0, /*size=*/0, mainPart->dynamic});
|
|
|
1679
|
|
|
1680 // Define __rel[a]_iplt_{start,end} symbols if needed.
|
|
|
1681 addRelIpltSymbols();
|
|
|
1682
|
|
|
1683 // RISC-V's gp can address +/- 2 KiB, set it to .sdata + 0x800. This symbol
|
|
|
1684 // should only be defined in an executable. If .sdata does not exist, its
|
|
|
1685 // value/section does not matter but it has to be relative, so set its
|
|
|
1686 // st_shndx arbitrarily to 1 (Out::elfHeader).
|
|
|
1687 if (config->emachine == EM_RISCV && !config->shared) {
|
|
|
1688 OutputSection *sec = findSection(".sdata");
|
|
|
1689 ElfSym::riscvGlobalPointer =
|
|
|
1690 addOptionalRegular("__global_pointer$", sec ? sec : Out::elfHeader,
|
|
|
1691 0x800, STV_DEFAULT, STB_GLOBAL);
|
|
|
1692 }
|
|
|
1693
|
|
|
1694 if (config->emachine == EM_X86_64) {
|
|
|
1695 // On targets that support TLSDESC, _TLS_MODULE_BASE_ is defined in such a
|
|
|
1696 // way that:
|
|
|
1697 //
|
|
|
1698 // 1) Without relaxation: it produces a dynamic TLSDESC relocation that
|
|
|
1699 // computes 0.
|
|
|
1700 // 2) With LD->LE relaxation: _TLS_MODULE_BASE_@tpoff = 0 (lowest address in
|
|
|
1701 // the TLS block).
|
|
|
1702 //
|
|
|
1703 // 2) is special cased in @tpoff computation. To satisfy 1), we define it as
|
|
|
1704 // an absolute symbol of zero. This is different from GNU linkers which
|
|
|
1705 // define _TLS_MODULE_BASE_ relative to the first TLS section.
|
|
|
1706 Symbol *s = symtab->find("_TLS_MODULE_BASE_");
|
|
|
1707 if (s && s->isUndefined()) {
|
|
|
1708 s->resolve(Defined{/*file=*/nullptr, s->getName(), STB_GLOBAL, STV_HIDDEN,
|
|
|
1709 STT_TLS, /*value=*/0, 0,
|
|
|
1710 /*section=*/nullptr});
|
|
|
1711 ElfSym::tlsModuleBase = cast<Defined>(s);
|
|
|
1712 }
|
|
|
1713 }
|
|
|
1714
|
|
|
1715 // This responsible for splitting up .eh_frame section into
|
|
|
1716 // pieces. The relocation scan uses those pieces, so this has to be
|
|
|
1717 // earlier.
|
|
|
1718 for (Partition &part : partitions)
|
|
|
1719 finalizeSynthetic(part.ehFrame);
|
|
|
1720
|
|
|
1721 for (Symbol *sym : symtab->symbols())
|
|
|
1722 sym->isPreemptible = computeIsPreemptible(*sym);
|
|
|
1723
|
|
|
1724 // Change values of linker-script-defined symbols from placeholders (assigned
|
|
|
1725 // by declareSymbols) to actual definitions.
|
|
|
1726 script->processSymbolAssignments();
|
|
|
1727
|
|
|
1728 // Scan relocations. This must be done after every symbol is declared so that
|
|
|
1729 // we can correctly decide if a dynamic relocation is needed. This is called
|
|
|
1730 // after processSymbolAssignments() because it needs to know whether a
|
|
|
1731 // linker-script-defined symbol is absolute.
|
|
|
1732 if (!config->relocatable) {
|
|
|
1733 forEachRelSec(scanRelocations<ELFT>);
|
|
|
1734 reportUndefinedSymbols<ELFT>();
|
|
|
1735 }
|
|
|
1736
|
|
|
1737 if (in.plt && in.plt->isNeeded())
|
|
|
1738 in.plt->addSymbols();
|
|
|
1739 if (in.iplt && in.iplt->isNeeded())
|
|
|
1740 in.iplt->addSymbols();
|
|
|
1741
|
|
|
1742 if (!config->allowShlibUndefined) {
|
|
|
1743 // Error on undefined symbols in a shared object, if all of its DT_NEEDED
|
|
|
1744 // entries are seen. These cases would otherwise lead to runtime errors
|
|
|
1745 // reported by the dynamic linker.
|
|
|
1746 //
|
|
|
1747 // ld.bfd traces all DT_NEEDED to emulate the logic of the dynamic linker to
|
|
|
1748 // catch more cases. That is too much for us. Our approach resembles the one
|
|
|
1749 // used in ld.gold, achieves a good balance to be useful but not too smart.
|
|
|
1750 for (SharedFile *file : sharedFiles)
|
|
|
1751 file->allNeededIsKnown =
|
|
|
1752 llvm::all_of(file->dtNeeded, [&](StringRef needed) {
|
|
|
1753 return symtab->soNames.count(needed);
|
|
|
1754 });
|
|
|
1755
|
|
|
1756 for (Symbol *sym : symtab->symbols())
|
|
|
1757 if (sym->isUndefined() && !sym->isWeak())
|
|
|
1758 if (auto *f = dyn_cast_or_null<SharedFile>(sym->file))
|
|
|
1759 if (f->allNeededIsKnown)
|
|
|
1760 error(toString(f) + ": undefined reference to " + toString(*sym));
|
|
|
1761 }
|
|
|
1762
|
|
|
1763 // Now that we have defined all possible global symbols including linker-
|
|
|
1764 // synthesized ones. Visit all symbols to give the finishing touches.
|
|
|
1765 for (Symbol *sym : symtab->symbols()) {
|
|
|
1766 if (!includeInSymtab(*sym))
|
|
|
1767 continue;
|
|
|
1768 if (in.symTab)
|
|
|
1769 in.symTab->addSymbol(sym);
|
|
|
1770
|
|
|
1771 if (sym->includeInDynsym()) {
|
|
|
1772 partitions[sym->partition - 1].dynSymTab->addSymbol(sym);
|
|
|
1773 if (auto *file = dyn_cast_or_null<SharedFile>(sym->file))
|
|
|
1774 if (file->isNeeded && !sym->isUndefined())
|
|
|
1775 addVerneed(sym);
|
|
|
1776 }
|
|
|
1777 }
|
|
|
1778
|
|
|
1779 // We also need to scan the dynamic relocation tables of the other partitions
|
|
|
1780 // and add any referenced symbols to the partition's dynsym.
|
|
|
1781 for (Partition &part : MutableArrayRef<Partition>(partitions).slice(1)) {
|
|
|
1782 DenseSet<Symbol *> syms;
|
|
|
1783 for (const SymbolTableEntry &e : part.dynSymTab->getSymbols())
|
|
|
1784 syms.insert(e.sym);
|
|
|
1785 for (DynamicReloc &reloc : part.relaDyn->relocs)
|
|
|
1786 if (reloc.sym && !reloc.useSymVA && syms.insert(reloc.sym).second)
|
|
|
1787 part.dynSymTab->addSymbol(reloc.sym);
|
|
|
1788 }
|
|
|
1789
|
|
|
1790 // Do not proceed if there was an undefined symbol.
|
|
|
1791 if (errorCount())
|
|
|
1792 return;
|
|
|
1793
|
|
|
1794 if (in.mipsGot)
|
|
|
1795 in.mipsGot->build();
|
|
|
1796
|
|
|
1797 removeUnusedSyntheticSections();
|
|
|
1798
|
|
|
1799 sortSections();
|
|
|
1800
|
|
|
1801 // Now that we have the final list, create a list of all the
|
|
|
1802 // OutputSections for convenience.
|
|
|
1803 for (BaseCommand *base : script->sectionCommands)
|
|
|
1804 if (auto *sec = dyn_cast<OutputSection>(base))
|
|
|
1805 outputSections.push_back(sec);
|
|
|
1806
|
|
|
1807 // Prefer command line supplied address over other constraints.
|
|
|
1808 for (OutputSection *sec : outputSections) {
|
|
|
1809 auto i = config->sectionStartMap.find(sec->name);
|
|
|
1810 if (i != config->sectionStartMap.end())
|
|
|
1811 sec->addrExpr = [=] { return i->second; };
|
|
|
1812 }
|
|
|
1813
|
|
|
1814 // This is a bit of a hack. A value of 0 means undef, so we set it
|
|
|
1815 // to 1 to make __ehdr_start defined. The section number is not
|
|
|
1816 // particularly relevant.
|
|
|
1817 Out::elfHeader->sectionIndex = 1;
|
|
|
1818
|
|
|
1819 for (size_t i = 0, e = outputSections.size(); i != e; ++i) {
|
|
|
1820 OutputSection *sec = outputSections[i];
|
|
|
1821 sec->sectionIndex = i + 1;
|
|
|
1822 sec->shName = in.shStrTab->addString(sec->name);
|
|
|
1823 }
|
|
|
1824
|
|
|
1825 // Binary and relocatable output does not have PHDRS.
|
|
|
1826 // The headers have to be created before finalize as that can influence the
|
|
|
1827 // image base and the dynamic section on mips includes the image base.
|
|
|
1828 if (!config->relocatable && !config->oFormatBinary) {
|
|
|
1829 for (Partition &part : partitions) {
|
|
|
1830 part.phdrs = script->hasPhdrsCommands() ? script->createPhdrs()
|
|
|
1831 : createPhdrs(part);
|
|
|
1832 if (config->emachine == EM_ARM) {
|
|
|
1833 // PT_ARM_EXIDX is the ARM EHABI equivalent of PT_GNU_EH_FRAME
|
|
|
1834 addPhdrForSection(part, SHT_ARM_EXIDX, PT_ARM_EXIDX, PF_R);
|
|
|
1835 }
|
|
|
1836 if (config->emachine == EM_MIPS) {
|
|
|
1837 // Add separate segments for MIPS-specific sections.
|
|
|
1838 addPhdrForSection(part, SHT_MIPS_REGINFO, PT_MIPS_REGINFO, PF_R);
|
|
|
1839 addPhdrForSection(part, SHT_MIPS_OPTIONS, PT_MIPS_OPTIONS, PF_R);
|
|
|
1840 addPhdrForSection(part, SHT_MIPS_ABIFLAGS, PT_MIPS_ABIFLAGS, PF_R);
|
|
|
1841 }
|
|
|
1842 }
|
|
|
1843 Out::programHeaders->size = sizeof(Elf_Phdr) * mainPart->phdrs.size();
|
|
|
1844
|
|
|
1845 // Find the TLS segment. This happens before the section layout loop so that
|
|
|
1846 // Android relocation packing can look up TLS symbol addresses. We only need
|
|
|
1847 // to care about the main partition here because all TLS symbols were moved
|
|
|
1848 // to the main partition (see MarkLive.cpp).
|
|
|
1849 for (PhdrEntry *p : mainPart->phdrs)
|
|
|
1850 if (p->p_type == PT_TLS)
|
|
|
1851 Out::tlsPhdr = p;
|
|
|
1852 }
|
|
|
1853
|
|
|
1854 // Some symbols are defined in term of program headers. Now that we
|
|
|
1855 // have the headers, we can find out which sections they point to.
|
|
|
1856 setReservedSymbolSections();
|
|
|
1857
|
|
|
1858 finalizeSynthetic(in.bss);
|
|
|
1859 finalizeSynthetic(in.bssRelRo);
|
|
|
1860 finalizeSynthetic(in.symTabShndx);
|
|
|
1861 finalizeSynthetic(in.shStrTab);
|
|
|
1862 finalizeSynthetic(in.strTab);
|
|
|
1863 finalizeSynthetic(in.got);
|
|
|
1864 finalizeSynthetic(in.mipsGot);
|
|
|
1865 finalizeSynthetic(in.igotPlt);
|
|
|
1866 finalizeSynthetic(in.gotPlt);
|
|
|
1867 finalizeSynthetic(in.relaIplt);
|
|
|
1868 finalizeSynthetic(in.relaPlt);
|
|
|
1869 finalizeSynthetic(in.plt);
|
|
|
1870 finalizeSynthetic(in.iplt);
|
|
|
1871 finalizeSynthetic(in.ppc32Got2);
|
|
|
1872 finalizeSynthetic(in.partIndex);
|
|
|
1873
|
|
|
1874 // Dynamic section must be the last one in this list and dynamic
|
|
|
1875 // symbol table section (dynSymTab) must be the first one.
|
|
|
1876 for (Partition &part : partitions) {
|
|
|
1877 finalizeSynthetic(part.armExidx);
|
|
|
1878 finalizeSynthetic(part.dynSymTab);
|
|
|
1879 finalizeSynthetic(part.gnuHashTab);
|
|
|
1880 finalizeSynthetic(part.hashTab);
|
|
|
1881 finalizeSynthetic(part.verDef);
|
|
|
1882 finalizeSynthetic(part.relaDyn);
|
|
|
1883 finalizeSynthetic(part.relrDyn);
|
|
|
1884 finalizeSynthetic(part.ehFrameHdr);
|
|
|
1885 finalizeSynthetic(part.verSym);
|
|
|
1886 finalizeSynthetic(part.verNeed);
|
|
|
1887 finalizeSynthetic(part.dynamic);
|
|
|
1888 }
|
|
|
1889
|
|
|
1890 if (!script->hasSectionsCommand && !config->relocatable)
|
|
|
1891 fixSectionAlignments();
|
|
|
1892
|
|
|
1893 // SHFLinkOrder processing must be processed after relative section placements are
|
|
|
1894 // known but before addresses are allocated.
|
|
|
1895 resolveShfLinkOrder();
|
|
|
1896 if (errorCount())
|
|
|
1897 return;
|
|
|
1898
|
|
|
1899 // This is used to:
|
|
|
1900 // 1) Create "thunks":
|
|
|
1901 // Jump instructions in many ISAs have small displacements, and therefore
|
|
|
1902 // they cannot jump to arbitrary addresses in memory. For example, RISC-V
|
|
|
1903 // JAL instruction can target only +-1 MiB from PC. It is a linker's
|
|
|
1904 // responsibility to create and insert small pieces of code between
|
|
|
1905 // sections to extend the ranges if jump targets are out of range. Such
|
|
|
1906 // code pieces are called "thunks".
|
|
|
1907 //
|
|
|
1908 // We add thunks at this stage. We couldn't do this before this point
|
|
|
1909 // because this is the earliest point where we know sizes of sections and
|
|
|
1910 // their layouts (that are needed to determine if jump targets are in
|
|
|
1911 // range).
|
|
|
1912 //
|
|
|
1913 // 2) Update the sections. We need to generate content that depends on the
|
|
|
1914 // address of InputSections. For example, MIPS GOT section content or
|
|
|
1915 // android packed relocations sections content.
|
|
|
1916 //
|
|
|
1917 // 3) Assign the final values for the linker script symbols. Linker scripts
|
|
|
1918 // sometimes using forward symbol declarations. We want to set the correct
|
|
|
1919 // values. They also might change after adding the thunks.
|
|
|
1920 finalizeAddressDependentContent();
|
|
|
1921
|
|
|
1922 // finalizeAddressDependentContent may have added local symbols to the static symbol table.
|
|
|
1923 finalizeSynthetic(in.symTab);
|
|
|
1924 finalizeSynthetic(in.ppc64LongBranchTarget);
|
|
|
1925
|
|
|
1926 // Fill other section headers. The dynamic table is finalized
|
|
|
1927 // at the end because some tags like RELSZ depend on result
|
|
|
1928 // of finalizing other sections.
|
|
|
1929 for (OutputSection *sec : outputSections)
|
|
|
1930 sec->finalize();
|
|
|
1931 }
|
|
|
1932
|
|
|
1933 // Ensure data sections are not mixed with executable sections when
|
|
|
1934 // -execute-only is used. -execute-only is a feature to make pages executable
|
|
|
1935 // but not readable, and the feature is currently supported only on AArch64.
|
|
|
1936 template <class ELFT> void Writer<ELFT>::checkExecuteOnly() {
|
|
|
1937 if (!config->executeOnly)
|
|
|
1938 return;
|
|
|
1939
|
|
|
1940 for (OutputSection *os : outputSections)
|
|
|
1941 if (os->flags & SHF_EXECINSTR)
|
|
|
1942 for (InputSection *isec : getInputSections(os))
|
|
|
1943 if (!(isec->flags & SHF_EXECINSTR))
|
|
|
1944 error("cannot place " + toString(isec) + " into " + toString(os->name) +
|
|
|
1945 ": -execute-only does not support intermingling data and code");
|
|
|
1946 }
|
|
|
1947
|
|
|
1948 // The linker is expected to define SECNAME_start and SECNAME_end
|
|
|
1949 // symbols for a few sections. This function defines them.
|
|
|
1950 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
|
|
|
1951 // If a section does not exist, there's ambiguity as to how we
|
|
|
1952 // define _start and _end symbols for an init/fini section. Since
|
|
|
1953 // the loader assume that the symbols are always defined, we need to
|
|
|
1954 // always define them. But what value? The loader iterates over all
|
|
|
1955 // pointers between _start and _end to run global ctors/dtors, so if
|
|
|
1956 // the section is empty, their symbol values don't actually matter
|
|
|
1957 // as long as _start and _end point to the same location.
|
|
|
1958 //
|
|
|
1959 // That said, we don't want to set the symbols to 0 (which is
|
|
|
1960 // probably the simplest value) because that could cause some
|
|
|
1961 // program to fail to link due to relocation overflow, if their
|
|
|
1962 // program text is above 2 GiB. We use the address of the .text
|
|
|
1963 // section instead to prevent that failure.
|
|
|
1964 //
|
|
|
1965 // In rare situations, the .text section may not exist. If that's the
|
|
|
1966 // case, use the image base address as a last resort.
|
|
|
1967 OutputSection *Default = findSection(".text");
|
|
|
1968 if (!Default)
|
|
|
1969 Default = Out::elfHeader;
|
|
|
1970
|
|
|
1971 auto define = [=](StringRef start, StringRef end, OutputSection *os) {
|
|
|
1972 if (os) {
|
|
|
1973 addOptionalRegular(start, os, 0);
|
|
|
1974 addOptionalRegular(end, os, -1);
|
|
|
1975 } else {
|
|
|
1976 addOptionalRegular(start, Default, 0);
|
|
|
1977 addOptionalRegular(end, Default, 0);
|
|
|
1978 }
|
|
|
1979 };
|
|
|
1980
|
|
|
1981 define("__preinit_array_start", "__preinit_array_end", Out::preinitArray);
|
|
|
1982 define("__init_array_start", "__init_array_end", Out::initArray);
|
|
|
1983 define("__fini_array_start", "__fini_array_end", Out::finiArray);
|
|
|
1984
|
|
|
1985 if (OutputSection *sec = findSection(".ARM.exidx"))
|
|
|
1986 define("__exidx_start", "__exidx_end", sec);
|
|
|
1987 }
|
|
|
1988
|
|
|
1989 // If a section name is valid as a C identifier (which is rare because of
|
|
|
1990 // the leading '.'), linkers are expected to define __start_<secname> and
|
|
|
1991 // __stop_<secname> symbols. They are at beginning and end of the section,
|
|
|
1992 // respectively. This is not requested by the ELF standard, but GNU ld and
|
|
|
1993 // gold provide the feature, and used by many programs.
|
|
|
1994 template <class ELFT>
|
|
|
1995 void Writer<ELFT>::addStartStopSymbols(OutputSection *sec) {
|
|
|
1996 StringRef s = sec->name;
|
|
|
1997 if (!isValidCIdentifier(s))
|
|
|
1998 return;
|
|
|
1999 addOptionalRegular(saver.save("__start_" + s), sec, 0, STV_PROTECTED);
|
|
|
2000 addOptionalRegular(saver.save("__stop_" + s), sec, -1, STV_PROTECTED);
|
|
|
2001 }
|
|
|
2002
|
|
|
2003 static bool needsPtLoad(OutputSection *sec) {
|
|
|
2004 if (!(sec->flags & SHF_ALLOC) || sec->noload)
|
|
|
2005 return false;
|
|
|
2006
|
|
|
2007 // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
|
|
|
2008 // responsible for allocating space for them, not the PT_LOAD that
|
|
|
2009 // contains the TLS initialization image.
|
|
|
2010 if ((sec->flags & SHF_TLS) && sec->type == SHT_NOBITS)
|
|
|
2011 return false;
|
|
|
2012 return true;
|
|
|
2013 }
|
|
|
2014
|
|
|
2015 // Linker scripts are responsible for aligning addresses. Unfortunately, most
|
|
|
2016 // linker scripts are designed for creating two PT_LOADs only, one RX and one
|
|
|
2017 // RW. This means that there is no alignment in the RO to RX transition and we
|
|
|
2018 // cannot create a PT_LOAD there.
|
|
|
2019 static uint64_t computeFlags(uint64_t flags) {
|
|
|
2020 if (config->omagic)
|
|
|
2021 return PF_R | PF_W | PF_X;
|
|
|
2022 if (config->executeOnly && (flags & PF_X))
|
|
|
2023 return flags & ~PF_R;
|
|
|
2024 if (config->singleRoRx && !(flags & PF_W))
|
|
|
2025 return flags | PF_X;
|
|
|
2026 return flags;
|
|
|
2027 }
|
|
|
2028
|
|
|
2029 // Decide which program headers to create and which sections to include in each
|
|
|
2030 // one.
|
|
|
2031 template <class ELFT>
|
|
|
2032 std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs(Partition &part) {
|
|
|
2033 std::vector<PhdrEntry *> ret;
|
|
|
2034 auto addHdr = [&](unsigned type, unsigned flags) -> PhdrEntry * {
|
|
|
2035 ret.push_back(make<PhdrEntry>(type, flags));
|
|
|
2036 return ret.back();
|
|
|
2037 };
|
|
|
2038
|
|
|
2039 unsigned partNo = part.getNumber();
|
|
|
2040 bool isMain = partNo == 1;
|
|
|
2041
|
|
|
2042 // Add the first PT_LOAD segment for regular output sections.
|
|
|
2043 uint64_t flags = computeFlags(PF_R);
|
|
|
2044 PhdrEntry *load = nullptr;
|
|
|
2045
|
|
|
2046 // nmagic or omagic output does not have PT_PHDR, PT_INTERP, or the readonly
|
|
|
2047 // PT_LOAD.
|
|
|
2048 if (!config->nmagic && !config->omagic) {
|
|
|
2049 // The first phdr entry is PT_PHDR which describes the program header
|
|
|
2050 // itself.
|
|
|
2051 if (isMain)
|
|
|
2052 addHdr(PT_PHDR, PF_R)->add(Out::programHeaders);
|
|
|
2053 else
|
|
|
2054 addHdr(PT_PHDR, PF_R)->add(part.programHeaders->getParent());
|
|
|
2055
|
|
|
2056 // PT_INTERP must be the second entry if exists.
|
|
|
2057 if (OutputSection *cmd = findSection(".interp", partNo))
|
|
|
2058 addHdr(PT_INTERP, cmd->getPhdrFlags())->add(cmd);
|
|
|
2059
|
|
|
2060 // Add the headers. We will remove them if they don't fit.
|
|
|
2061 // In the other partitions the headers are ordinary sections, so they don't
|
|
|
2062 // need to be added here.
|
|
|
2063 if (isMain) {
|
|
|
2064 load = addHdr(PT_LOAD, flags);
|
|
|
2065 load->add(Out::elfHeader);
|
|
|
2066 load->add(Out::programHeaders);
|
|
|
2067 }
|
|
|
2068 }
|
|
|
2069
|
|
|
2070 // PT_GNU_RELRO includes all sections that should be marked as
|
|
|
2071 // read-only by dynamic linker after processing relocations.
|
|
|
2072 // Current dynamic loaders only support one PT_GNU_RELRO PHDR, give
|
|
|
2073 // an error message if more than one PT_GNU_RELRO PHDR is required.
|
|
|
2074 PhdrEntry *relRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R);
|
|
|
2075 bool inRelroPhdr = false;
|
|
|
2076 OutputSection *relroEnd = nullptr;
|
|
|
2077 for (OutputSection *sec : outputSections) {
|
|
|
2078 if (sec->partition != partNo || !needsPtLoad(sec))
|
|
|
2079 continue;
|
|
|
2080 if (isRelroSection(sec)) {
|
|
|
2081 inRelroPhdr = true;
|
|
|
2082 if (!relroEnd)
|
|
|
2083 relRo->add(sec);
|
|
|
2084 else
|
|
|
2085 error("section: " + sec->name + " is not contiguous with other relro" +
|
|
|
2086 " sections");
|
|
|
2087 } else if (inRelroPhdr) {
|
|
|
2088 inRelroPhdr = false;
|
|
|
2089 relroEnd = sec;
|
|
|
2090 }
|
|
|
2091 }
|
|
|
2092
|
|
|
2093 for (OutputSection *sec : outputSections) {
|
|
|
2094 if (!(sec->flags & SHF_ALLOC))
|
|
|
2095 break;
|
|
|
2096 if (!needsPtLoad(sec))
|
|
|
2097 continue;
|
|
|
2098
|
|
|
2099 // Normally, sections in partitions other than the current partition are
|
|
|
2100 // ignored. But partition number 255 is a special case: it contains the
|
|
|
2101 // partition end marker (.part.end). It needs to be added to the main
|
|
|
2102 // partition so that a segment is created for it in the main partition,
|
|
|
2103 // which will cause the dynamic loader to reserve space for the other
|
|
|
2104 // partitions.
|
|
|
2105 if (sec->partition != partNo) {
|
|
|
2106 if (isMain && sec->partition == 255)
|
|
|
2107 addHdr(PT_LOAD, computeFlags(sec->getPhdrFlags()))->add(sec);
|
|
|
2108 continue;
|
|
|
2109 }
|
|
|
2110
|
|
|
2111 // Segments are contiguous memory regions that has the same attributes
|
|
|
2112 // (e.g. executable or writable). There is one phdr for each segment.
|
|
|
2113 // Therefore, we need to create a new phdr when the next section has
|
|
|
2114 // different flags or is loaded at a discontiguous address or memory
|
|
|
2115 // region using AT or AT> linker script command, respectively. At the same
|
|
|
2116 // time, we don't want to create a separate load segment for the headers,
|
|
|
2117 // even if the first output section has an AT or AT> attribute.
|
|
|
2118 uint64_t newFlags = computeFlags(sec->getPhdrFlags());
|
|
|
2119 bool sameLMARegion =
|
|
|
2120 load && !sec->lmaExpr && sec->lmaRegion == load->firstSec->lmaRegion;
|
|
|
2121 if (!(load && newFlags == flags && sec != relroEnd &&
|
|
|
2122 sec->memRegion == load->firstSec->memRegion &&
|
|
|
2123 (sameLMARegion || load->lastSec == Out::programHeaders))) {
|
|
|
2124 load = addHdr(PT_LOAD, newFlags);
|
|
|
2125 flags = newFlags;
|
|
|
2126 }
|
|
|
2127
|
|
|
2128 load->add(sec);
|
|
|
2129 }
|
|
|
2130
|
|
|
2131 // Add a TLS segment if any.
|
|
|
2132 PhdrEntry *tlsHdr = make<PhdrEntry>(PT_TLS, PF_R);
|
|
|
2133 for (OutputSection *sec : outputSections)
|
|
|
2134 if (sec->partition == partNo && sec->flags & SHF_TLS)
|
|
|
2135 tlsHdr->add(sec);
|
|
|
2136 if (tlsHdr->firstSec)
|
|
|
2137 ret.push_back(tlsHdr);
|
|
|
2138
|
|
|
2139 // Add an entry for .dynamic.
|
|
|
2140 if (OutputSection *sec = part.dynamic->getParent())
|
|
|
2141 addHdr(PT_DYNAMIC, sec->getPhdrFlags())->add(sec);
|
|
|
2142
|
|
|
2143 if (relRo->firstSec)
|
|
|
2144 ret.push_back(relRo);
|
|
|
2145
|
|
|
2146 // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
|
|
|
2147 if (part.ehFrame->isNeeded() && part.ehFrameHdr &&
|
|
|
2148 part.ehFrame->getParent() && part.ehFrameHdr->getParent())
|
|
|
2149 addHdr(PT_GNU_EH_FRAME, part.ehFrameHdr->getParent()->getPhdrFlags())
|
|
|
2150 ->add(part.ehFrameHdr->getParent());
|
|
|
2151
|
|
|
2152 // PT_OPENBSD_RANDOMIZE is an OpenBSD-specific feature. That makes
|
|
|
2153 // the dynamic linker fill the segment with random data.
|
|
|
2154 if (OutputSection *cmd = findSection(".openbsd.randomdata", partNo))
|
|
|
2155 addHdr(PT_OPENBSD_RANDOMIZE, cmd->getPhdrFlags())->add(cmd);
|
|
|
2156
|
|
|
2157 if (config->zGnustack != GnuStackKind::None) {
|
|
|
2158 // PT_GNU_STACK is a special section to tell the loader to make the
|
|
|
2159 // pages for the stack non-executable. If you really want an executable
|
|
|
2160 // stack, you can pass -z execstack, but that's not recommended for
|
|
|
2161 // security reasons.
|
|
|
2162 unsigned perm = PF_R | PF_W;
|
|
|
2163 if (config->zGnustack == GnuStackKind::Exec)
|
|
|
2164 perm |= PF_X;
|
|
|
2165 addHdr(PT_GNU_STACK, perm)->p_memsz = config->zStackSize;
|
|
|
2166 }
|
|
|
2167
|
|
|
2168 // PT_OPENBSD_WXNEEDED is a OpenBSD-specific header to mark the executable
|
|
|
2169 // is expected to perform W^X violations, such as calling mprotect(2) or
|
|
|
2170 // mmap(2) with PROT_WRITE | PROT_EXEC, which is prohibited by default on
|
|
|
2171 // OpenBSD.
|
|
|
2172 if (config->zWxneeded)
|
|
|
2173 addHdr(PT_OPENBSD_WXNEEDED, PF_X);
|
|
|
2174
|
|
|
2175 if (OutputSection *cmd = findSection(".note.gnu.property", partNo))
|
|
|
2176 addHdr(PT_GNU_PROPERTY, PF_R)->add(cmd);
|
|
|
2177
|
|
|
2178 // Create one PT_NOTE per a group of contiguous SHT_NOTE sections with the
|
|
|
2179 // same alignment.
|
|
|
2180 PhdrEntry *note = nullptr;
|
|
|
2181 for (OutputSection *sec : outputSections) {
|
|
|
2182 if (sec->partition != partNo)
|
|
|
2183 continue;
|
|
|
2184 if (sec->type == SHT_NOTE && (sec->flags & SHF_ALLOC)) {
|
|
|
2185 if (!note || sec->lmaExpr || note->lastSec->alignment != sec->alignment)
|
|
|
2186 note = addHdr(PT_NOTE, PF_R);
|
|
|
2187 note->add(sec);
|
|
|
2188 } else {
|
|
|
2189 note = nullptr;
|
|
|
2190 }
|
|
|
2191 }
|
|
|
2192 return ret;
|
|
|
2193 }
|
|
|
2194
|
|
|
2195 template <class ELFT>
|
|
|
2196 void Writer<ELFT>::addPhdrForSection(Partition &part, unsigned shType,
|
|
|
2197 unsigned pType, unsigned pFlags) {
|
|
|
2198 unsigned partNo = part.getNumber();
|
|
|
2199 auto i = llvm::find_if(outputSections, [=](OutputSection *cmd) {
|
|
|
2200 return cmd->partition == partNo && cmd->type == shType;
|
|
|
2201 });
|
|
|
2202 if (i == outputSections.end())
|
|
|
2203 return;
|
|
|
2204
|
|
|
2205 PhdrEntry *entry = make<PhdrEntry>(pType, pFlags);
|
|
|
2206 entry->add(*i);
|
|
|
2207 part.phdrs.push_back(entry);
|
|
|
2208 }
|
|
|
2209
|
|
|
2210 // Place the first section of each PT_LOAD to a different page (of maxPageSize).
|
|
|
2211 // This is achieved by assigning an alignment expression to addrExpr of each
|
|
|
2212 // such section.
|
|
|
2213 template <class ELFT> void Writer<ELFT>::fixSectionAlignments() {
|
|
|
2214 const PhdrEntry *prev;
|
|
|
2215 auto pageAlign = [&](const PhdrEntry *p) {
|
|
|
2216 OutputSection *cmd = p->firstSec;
|
|
|
2217 if (cmd && !cmd->addrExpr) {
|
|
|
2218 // Prefer advancing to align(dot, maxPageSize) + dot%maxPageSize to avoid
|
|
|
2219 // padding in the file contents.
|
|
|
2220 //
|
|
|
2221 // When -z separate-code is used we must not have any overlap in pages
|
|
|
2222 // between an executable segment and a non-executable segment. We align to
|
|
|
2223 // the next maximum page size boundary on transitions between executable
|
|
|
2224 // and non-executable segments.
|
|
|
2225 //
|
|
|
2226 // SHT_LLVM_PART_EHDR marks the start of a partition. The partition
|
|
|
2227 // sections will be extracted to a separate file. Align to the next
|
|
|
2228 // maximum page size boundary so that we can find the ELF header at the
|
|
|
2229 // start. We cannot benefit from overlapping p_offset ranges with the
|
|
|
2230 // previous segment anyway.
|
|
|
2231 if (config->zSeparate == SeparateSegmentKind::Loadable ||
|
|
|
2232 (config->zSeparate == SeparateSegmentKind::Code && prev &&
|
|
|
2233 (prev->p_flags & PF_X) != (p->p_flags & PF_X)) ||
|
|
|
2234 cmd->type == SHT_LLVM_PART_EHDR)
|
|
|
2235 cmd->addrExpr = [] {
|
|
|
2236 return alignTo(script->getDot(), config->maxPageSize);
|
|
|
2237 };
|
|
|
2238 // PT_TLS is at the start of the first RW PT_LOAD. If `p` includes PT_TLS,
|
|
|
2239 // it must be the RW. Align to p_align(PT_TLS) to make sure
|
|
|
2240 // p_vaddr(PT_LOAD)%p_align(PT_LOAD) = 0. Otherwise, if
|
|
|
2241 // sh_addralign(.tdata) < sh_addralign(.tbss), we will set p_align(PT_TLS)
|
|
|
2242 // to sh_addralign(.tbss), while p_vaddr(PT_TLS)=p_vaddr(PT_LOAD) may not
|
|
|
2243 // be congruent to 0 modulo p_align(PT_TLS).
|
|
|
2244 //
|
|
|
2245 // Technically this is not required, but as of 2019, some dynamic loaders
|
|
|
2246 // don't handle p_vaddr%p_align != 0 correctly, e.g. glibc (i386 and
|
|
|
2247 // x86-64) doesn't make runtime address congruent to p_vaddr modulo
|
|
|
2248 // p_align for dynamic TLS blocks (PR/24606), FreeBSD rtld has the same
|
|
|
2249 // bug, musl (TLS Variant 1 architectures) before 1.1.23 handled TLS
|
|
|
2250 // blocks correctly. We need to keep the workaround for a while.
|
|
|
2251 else if (Out::tlsPhdr && Out::tlsPhdr->firstSec == p->firstSec)
|
|
|
2252 cmd->addrExpr = [] {
|
|
|
2253 return alignTo(script->getDot(), config->maxPageSize) +
|
|
|
2254 alignTo(script->getDot() % config->maxPageSize,
|
|
|
2255 Out::tlsPhdr->p_align);
|
|
|
2256 };
|
|
|
2257 else
|
|
|
2258 cmd->addrExpr = [] {
|
|
|
2259 return alignTo(script->getDot(), config->maxPageSize) +
|
|
|
2260 script->getDot() % config->maxPageSize;
|
|
|
2261 };
|
|
|
2262 }
|
|
|
2263 };
|
|
|
2264
|
|
|
2265 for (Partition &part : partitions) {
|
|
|
2266 prev = nullptr;
|
|
|
2267 for (const PhdrEntry *p : part.phdrs)
|
|
|
2268 if (p->p_type == PT_LOAD && p->firstSec) {
|
|
|
2269 pageAlign(p);
|
|
|
2270 prev = p;
|
|
|
2271 }
|
|
|
2272 }
|
|
|
2273 }
|
|
|
2274
|
|
|
2275 // Compute an in-file position for a given section. The file offset must be the
|
|
|
2276 // same with its virtual address modulo the page size, so that the loader can
|
|
|
2277 // load executables without any address adjustment.
|
|
|
2278 static uint64_t computeFileOffset(OutputSection *os, uint64_t off) {
|
|
|
2279 // The first section in a PT_LOAD has to have congruent offset and address
|
|
|
2280 // modulo the maximum page size.
|
|
|
2281 if (os->ptLoad && os->ptLoad->firstSec == os)
|
|
|
2282 return alignTo(off, os->ptLoad->p_align, os->addr);
|
|
|
2283
|
|
|
2284 // File offsets are not significant for .bss sections other than the first one
|
|
|
2285 // in a PT_LOAD. By convention, we keep section offsets monotonically
|
|
|
2286 // increasing rather than setting to zero.
|
|
|
2287 if (os->type == SHT_NOBITS)
|
|
|
2288 return off;
|
|
|
2289
|
|
|
2290 // If the section is not in a PT_LOAD, we just have to align it.
|
|
|
2291 if (!os->ptLoad)
|
|
|
2292 return alignTo(off, os->alignment);
|
|
|
2293
|
|
|
2294 // If two sections share the same PT_LOAD the file offset is calculated
|
|
|
2295 // using this formula: Off2 = Off1 + (VA2 - VA1).
|
|
|
2296 OutputSection *first = os->ptLoad->firstSec;
|
|
|
2297 return first->offset + os->addr - first->addr;
|
|
|
2298 }
|
|
|
2299
|
|
|
2300 // Set an in-file position to a given section and returns the end position of
|
|
|
2301 // the section.
|
|
|
2302 static uint64_t setFileOffset(OutputSection *os, uint64_t off) {
|
|
|
2303 off = computeFileOffset(os, off);
|
|
|
2304 os->offset = off;
|
|
|
2305
|
|
|
2306 if (os->type == SHT_NOBITS)
|
|
|
2307 return off;
|
|
|
2308 return off + os->size;
|
|
|
2309 }
|
|
|
2310
|
|
|
2311 template <class ELFT> void Writer<ELFT>::assignFileOffsetsBinary() {
|
|
|
2312 uint64_t off = 0;
|
|
|
2313 for (OutputSection *sec : outputSections)
|
|
|
2314 if (sec->flags & SHF_ALLOC)
|
|
|
2315 off = setFileOffset(sec, off);
|
|
|
2316 fileSize = alignTo(off, config->wordsize);
|
|
|
2317 }
|
|
|
2318
|
|
|
2319 static std::string rangeToString(uint64_t addr, uint64_t len) {
|
|
|
2320 return "[0x" + utohexstr(addr) + ", 0x" + utohexstr(addr + len - 1) + "]";
|
|
|
2321 }
|
|
|
2322
|
|
|
2323 // Assign file offsets to output sections.
|
|
|
2324 template <class ELFT> void Writer<ELFT>::assignFileOffsets() {
|
|
|
2325 uint64_t off = 0;
|
|
|
2326 off = setFileOffset(Out::elfHeader, off);
|
|
|
2327 off = setFileOffset(Out::programHeaders, off);
|
|
|
2328
|
|
|
2329 PhdrEntry *lastRX = nullptr;
|
|
|
2330 for (Partition &part : partitions)
|
|
|
2331 for (PhdrEntry *p : part.phdrs)
|
|
|
2332 if (p->p_type == PT_LOAD && (p->p_flags & PF_X))
|
|
|
2333 lastRX = p;
|
|
|
2334
|
|
|
2335 for (OutputSection *sec : outputSections) {
|
|
|
2336 off = setFileOffset(sec, off);
|
|
|
2337
|
|
|
2338 // If this is a last section of the last executable segment and that
|
|
|
2339 // segment is the last loadable segment, align the offset of the
|
|
|
2340 // following section to avoid loading non-segments parts of the file.
|
|
|
2341 if (config->zSeparate != SeparateSegmentKind::None && lastRX &&
|
|
|
2342 lastRX->lastSec == sec)
|
|
|
2343 off = alignTo(off, config->commonPageSize);
|
|
|
2344 }
|
|
|
2345
|
|
|
2346 sectionHeaderOff = alignTo(off, config->wordsize);
|
|
|
2347 fileSize = sectionHeaderOff + (outputSections.size() + 1) * sizeof(Elf_Shdr);
|
|
|
2348
|
|
|
2349 // Our logic assumes that sections have rising VA within the same segment.
|
|
|
2350 // With use of linker scripts it is possible to violate this rule and get file
|
|
|
2351 // offset overlaps or overflows. That should never happen with a valid script
|
|
|
2352 // which does not move the location counter backwards and usually scripts do
|
|
|
2353 // not do that. Unfortunately, there are apps in the wild, for example, Linux
|
|
|
2354 // kernel, which control segment distribution explicitly and move the counter
|
|
|
2355 // backwards, so we have to allow doing that to support linking them. We
|
|
|
2356 // perform non-critical checks for overlaps in checkSectionOverlap(), but here
|
|
|
2357 // we want to prevent file size overflows because it would crash the linker.
|
|
|
2358 for (OutputSection *sec : outputSections) {
|
|
|
2359 if (sec->type == SHT_NOBITS)
|
|
|
2360 continue;
|
|
|
2361 if ((sec->offset > fileSize) || (sec->offset + sec->size > fileSize))
|
|
|
2362 error("unable to place section " + sec->name + " at file offset " +
|
|
|
2363 rangeToString(sec->offset, sec->size) +
|
|
|
2364 "; check your linker script for overflows");
|
|
|
2365 }
|
|
|
2366 }
|
|
|
2367
|
|
|
2368 // Finalize the program headers. We call this function after we assign
|
|
|
2369 // file offsets and VAs to all sections.
|
|
|
2370 template <class ELFT> void Writer<ELFT>::setPhdrs(Partition &part) {
|
|
|
2371 for (PhdrEntry *p : part.phdrs) {
|
|
|
2372 OutputSection *first = p->firstSec;
|
|
|
2373 OutputSection *last = p->lastSec;
|
|
|
2374
|
|
|
2375 if (first) {
|
|
|
2376 p->p_filesz = last->offset - first->offset;
|
|
|
2377 if (last->type != SHT_NOBITS)
|
|
|
2378 p->p_filesz += last->size;
|
|
|
2379
|
|
|
2380 p->p_memsz = last->addr + last->size - first->addr;
|
|
|
2381 p->p_offset = first->offset;
|
|
|
2382 p->p_vaddr = first->addr;
|
|
|
2383
|
|
|
2384 // File offsets in partitions other than the main partition are relative
|
|
|
2385 // to the offset of the ELF headers. Perform that adjustment now.
|
|
|
2386 if (part.elfHeader)
|
|
|
2387 p->p_offset -= part.elfHeader->getParent()->offset;
|
|
|
2388
|
|
|
2389 if (!p->hasLMA)
|
|
|
2390 p->p_paddr = first->getLMA();
|
|
|
2391 }
|
|
|
2392
|
|
|
2393 if (p->p_type == PT_GNU_RELRO) {
|
|
|
2394 p->p_align = 1;
|
|
|
2395 // musl/glibc ld.so rounds the size down, so we need to round up
|
|
|
2396 // to protect the last page. This is a no-op on FreeBSD which always
|
|
|
2397 // rounds up.
|
|
|
2398 p->p_memsz = alignTo(p->p_offset + p->p_memsz, config->commonPageSize) -
|
|
|
2399 p->p_offset;
|
|
|
2400 }
|
|
|
2401 }
|
|
|
2402 }
|
|
|
2403
|
|
|
2404 // A helper struct for checkSectionOverlap.
|
|
|
2405 namespace {
|
|
|
2406 struct SectionOffset {
|
|
|
2407 OutputSection *sec;
|
|
|
2408 uint64_t offset;
|
|
|
2409 };
|
|
|
2410 } // namespace
|
|
|
2411
|
|
|
2412 // Check whether sections overlap for a specific address range (file offsets,
|
|
|
2413 // load and virtual addresses).
|
|
|
2414 static void checkOverlap(StringRef name, std::vector<SectionOffset> §ions,
|
|
|
2415 bool isVirtualAddr) {
|
|
|
2416 llvm::sort(sections, [=](const SectionOffset &a, const SectionOffset &b) {
|
|
|
2417 return a.offset < b.offset;
|
|
|
2418 });
|
|
|
2419
|
|
|
2420 // Finding overlap is easy given a vector is sorted by start position.
|
|
|
2421 // If an element starts before the end of the previous element, they overlap.
|
|
|
2422 for (size_t i = 1, end = sections.size(); i < end; ++i) {
|
|
|
2423 SectionOffset a = sections[i - 1];
|
|
|
2424 SectionOffset b = sections[i];
|
|
|
2425 if (b.offset >= a.offset + a.sec->size)
|
|
|
2426 continue;
|
|
|
2427
|
|
|
2428 // If both sections are in OVERLAY we allow the overlapping of virtual
|
|
|
2429 // addresses, because it is what OVERLAY was designed for.
|
|
|
2430 if (isVirtualAddr && a.sec->inOverlay && b.sec->inOverlay)
|
|
|
2431 continue;
|
|
|
2432
|
|
|
2433 errorOrWarn("section " + a.sec->name + " " + name +
|
|
|
2434 " range overlaps with " + b.sec->name + "\n>>> " + a.sec->name +
|
|
|
2435 " range is " + rangeToString(a.offset, a.sec->size) + "\n>>> " +
|
|
|
2436 b.sec->name + " range is " +
|
|
|
2437 rangeToString(b.offset, b.sec->size));
|
|
|
2438 }
|
|
|
2439 }
|
|
|
2440
|
|
|
2441 // Check for overlapping sections and address overflows.
|
|
|
2442 //
|
|
|
2443 // In this function we check that none of the output sections have overlapping
|
|
|
2444 // file offsets. For SHF_ALLOC sections we also check that the load address
|
|
|
2445 // ranges and the virtual address ranges don't overlap
|
|
|
2446 template <class ELFT> void Writer<ELFT>::checkSections() {
|
|
|
2447 // First, check that section's VAs fit in available address space for target.
|
|
|
2448 for (OutputSection *os : outputSections)
|
|
|
2449 if ((os->addr + os->size < os->addr) ||
|
|
|
2450 (!ELFT::Is64Bits && os->addr + os->size > UINT32_MAX))
|
|
|
2451 errorOrWarn("section " + os->name + " at 0x" + utohexstr(os->addr) +
|
|
|
2452 " of size 0x" + utohexstr(os->size) +
|
|
|
2453 " exceeds available address space");
|
|
|
2454
|
|
|
2455 // Check for overlapping file offsets. In this case we need to skip any
|
|
|
2456 // section marked as SHT_NOBITS. These sections don't actually occupy space in
|
|
|
2457 // the file so Sec->Offset + Sec->Size can overlap with others. If --oformat
|
|
|
2458 // binary is specified only add SHF_ALLOC sections are added to the output
|
|
|
2459 // file so we skip any non-allocated sections in that case.
|
|
|
2460 std::vector<SectionOffset> fileOffs;
|
|
|
2461 for (OutputSection *sec : outputSections)
|
|
|
2462 if (sec->size > 0 && sec->type != SHT_NOBITS &&
|
|
|
2463 (!config->oFormatBinary || (sec->flags & SHF_ALLOC)))
|
|
|
2464 fileOffs.push_back({sec, sec->offset});
|
|
|
2465 checkOverlap("file", fileOffs, false);
|
|
|
2466
|
|
|
2467 // When linking with -r there is no need to check for overlapping virtual/load
|
|
|
2468 // addresses since those addresses will only be assigned when the final
|
|
|
2469 // executable/shared object is created.
|
|
|
2470 if (config->relocatable)
|
|
|
2471 return;
|
|
|
2472
|
|
|
2473 // Checking for overlapping virtual and load addresses only needs to take
|
|
|
2474 // into account SHF_ALLOC sections since others will not be loaded.
|
|
|
2475 // Furthermore, we also need to skip SHF_TLS sections since these will be
|
|
|
2476 // mapped to other addresses at runtime and can therefore have overlapping
|
|
|
2477 // ranges in the file.
|
|
|
2478 std::vector<SectionOffset> vmas;
|
|
|
2479 for (OutputSection *sec : outputSections)
|
|
|
2480 if (sec->size > 0 && (sec->flags & SHF_ALLOC) && !(sec->flags & SHF_TLS))
|
|
|
2481 vmas.push_back({sec, sec->addr});
|
|
|
2482 checkOverlap("virtual address", vmas, true);
|
|
|
2483
|
|
|
2484 // Finally, check that the load addresses don't overlap. This will usually be
|
|
|
2485 // the same as the virtual addresses but can be different when using a linker
|
|
|
2486 // script with AT().
|
|
|
2487 std::vector<SectionOffset> lmas;
|
|
|
2488 for (OutputSection *sec : outputSections)
|
|
|
2489 if (sec->size > 0 && (sec->flags & SHF_ALLOC) && !(sec->flags & SHF_TLS))
|
|
|
2490 lmas.push_back({sec, sec->getLMA()});
|
|
|
2491 checkOverlap("load address", lmas, false);
|
|
|
2492 }
|
|
|
2493
|
|
|
2494 // The entry point address is chosen in the following ways.
|
|
|
2495 //
|
|
|
2496 // 1. the '-e' entry command-line option;
|
|
|
2497 // 2. the ENTRY(symbol) command in a linker control script;
|
|
|
2498 // 3. the value of the symbol _start, if present;
|
|
|
2499 // 4. the number represented by the entry symbol, if it is a number;
|
|
|
2500 // 5. the address of the first byte of the .text section, if present;
|
|
|
2501 // 6. the address 0.
|
|
|
2502 static uint64_t getEntryAddr() {
|
|
|
2503 // Case 1, 2 or 3
|
|
|
2504 if (Symbol *b = symtab->find(config->entry))
|
|
|
2505 return b->getVA();
|
|
|
2506
|
|
|
2507 // Case 4
|
|
|
2508 uint64_t addr;
|
|
|
2509 if (to_integer(config->entry, addr))
|
|
|
2510 return addr;
|
|
|
2511
|
|
|
2512 // Case 5
|
|
|
2513 if (OutputSection *sec = findSection(".text")) {
|
|
|
2514 if (config->warnMissingEntry)
|
|
|
2515 warn("cannot find entry symbol " + config->entry + "; defaulting to 0x" +
|
|
|
2516 utohexstr(sec->addr));
|
|
|
2517 return sec->addr;
|
|
|
2518 }
|
|
|
2519
|
|
|
2520 // Case 6
|
|
|
2521 if (config->warnMissingEntry)
|
|
|
2522 warn("cannot find entry symbol " + config->entry +
|
|
|
2523 "; not setting start address");
|
|
|
2524 return 0;
|
|
|
2525 }
|
|
|
2526
|
|
|
2527 static uint16_t getELFType() {
|
|
|
2528 if (config->isPic)
|
|
|
2529 return ET_DYN;
|
|
|
2530 if (config->relocatable)
|
|
|
2531 return ET_REL;
|
|
|
2532 return ET_EXEC;
|
|
|
2533 }
|
|
|
2534
|
|
|
2535 template <class ELFT> void Writer<ELFT>::writeHeader() {
|
|
|
2536 writeEhdr<ELFT>(Out::bufferStart, *mainPart);
|
|
|
2537 writePhdrs<ELFT>(Out::bufferStart + sizeof(Elf_Ehdr), *mainPart);
|
|
|
2538
|
|
|
2539 auto *eHdr = reinterpret_cast<Elf_Ehdr *>(Out::bufferStart);
|
|
|
2540 eHdr->e_type = getELFType();
|
|
|
2541 eHdr->e_entry = getEntryAddr();
|
|
|
2542 eHdr->e_shoff = sectionHeaderOff;
|
|
|
2543
|
|
|
2544 // Write the section header table.
|
|
|
2545 //
|
|
|
2546 // The ELF header can only store numbers up to SHN_LORESERVE in the e_shnum
|
|
|
2547 // and e_shstrndx fields. When the value of one of these fields exceeds
|
|
|
2548 // SHN_LORESERVE ELF requires us to put sentinel values in the ELF header and
|
|
|
2549 // use fields in the section header at index 0 to store
|
|
|
2550 // the value. The sentinel values and fields are:
|
|
|
2551 // e_shnum = 0, SHdrs[0].sh_size = number of sections.
|
|
|
2552 // e_shstrndx = SHN_XINDEX, SHdrs[0].sh_link = .shstrtab section index.
|
|
|
2553 auto *sHdrs = reinterpret_cast<Elf_Shdr *>(Out::bufferStart + eHdr->e_shoff);
|
|
|
2554 size_t num = outputSections.size() + 1;
|
|
|
2555 if (num >= SHN_LORESERVE)
|
|
|
2556 sHdrs->sh_size = num;
|
|
|
2557 else
|
|
|
2558 eHdr->e_shnum = num;
|
|
|
2559
|
|
|
2560 uint32_t strTabIndex = in.shStrTab->getParent()->sectionIndex;
|
|
|
2561 if (strTabIndex >= SHN_LORESERVE) {
|
|
|
2562 sHdrs->sh_link = strTabIndex;
|
|
|
2563 eHdr->e_shstrndx = SHN_XINDEX;
|
|
|
2564 } else {
|
|
|
2565 eHdr->e_shstrndx = strTabIndex;
|
|
|
2566 }
|
|
|
2567
|
|
|
2568 for (OutputSection *sec : outputSections)
|
|
|
2569 sec->writeHeaderTo<ELFT>(++sHdrs);
|
|
|
2570 }
|
|
|
2571
|
|
|
2572 // Open a result file.
|
|
|
2573 template <class ELFT> void Writer<ELFT>::openFile() {
|
|
|
2574 uint64_t maxSize = config->is64 ? INT64_MAX : UINT32_MAX;
|
|
|
2575 if (fileSize != size_t(fileSize) || maxSize < fileSize) {
|
|
|
2576 error("output file too large: " + Twine(fileSize) + " bytes");
|
|
|
2577 return;
|
|
|
2578 }
|
|
|
2579
|
|
|
2580 unlinkAsync(config->outputFile);
|
|
|
2581 unsigned flags = 0;
|
|
|
2582 if (!config->relocatable)
|
|
|
2583 flags |= FileOutputBuffer::F_executable;
|
|
|
2584 if (!config->mmapOutputFile)
|
|
|
2585 flags |= FileOutputBuffer::F_no_mmap;
|
|
|
2586 Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
|
|
|
2587 FileOutputBuffer::create(config->outputFile, fileSize, flags);
|
|
|
2588
|
|
|
2589 if (!bufferOrErr) {
|
|
|
2590 error("failed to open " + config->outputFile + ": " +
|
|
|
2591 llvm::toString(bufferOrErr.takeError()));
|
|
|
2592 return;
|
|
|
2593 }
|
|
|
2594 buffer = std::move(*bufferOrErr);
|
|
|
2595 Out::bufferStart = buffer->getBufferStart();
|
|
|
2596 }
|
|
|
2597
|
|
|
2598 template <class ELFT> void Writer<ELFT>::writeSectionsBinary() {
|
|
|
2599 for (OutputSection *sec : outputSections)
|
|
|
2600 if (sec->flags & SHF_ALLOC)
|
|
|
2601 sec->writeTo<ELFT>(Out::bufferStart + sec->offset);
|
|
|
2602 }
|
|
|
2603
|
|
|
2604 static void fillTrap(uint8_t *i, uint8_t *end) {
|
|
|
2605 for (; i + 4 <= end; i += 4)
|
|
|
2606 memcpy(i, &target->trapInstr, 4);
|
|
|
2607 }
|
|
|
2608
|
|
|
2609 // Fill the last page of executable segments with trap instructions
|
|
|
2610 // instead of leaving them as zero. Even though it is not required by any
|
|
|
2611 // standard, it is in general a good thing to do for security reasons.
|
|
|
2612 //
|
|
|
2613 // We'll leave other pages in segments as-is because the rest will be
|
|
|
2614 // overwritten by output sections.
|
|
|
2615 template <class ELFT> void Writer<ELFT>::writeTrapInstr() {
|
|
|
2616 for (Partition &part : partitions) {
|
|
|
2617 // Fill the last page.
|
|
|
2618 for (PhdrEntry *p : part.phdrs)
|
|
|
2619 if (p->p_type == PT_LOAD && (p->p_flags & PF_X))
|
|
|
2620 fillTrap(Out::bufferStart + alignDown(p->firstSec->offset + p->p_filesz,
|
|
|
2621 config->commonPageSize),
|
|
|
2622 Out::bufferStart + alignTo(p->firstSec->offset + p->p_filesz,
|
|
|
2623 config->commonPageSize));
|
|
|
2624
|
|
|
2625 // Round up the file size of the last segment to the page boundary iff it is
|
|
|
2626 // an executable segment to ensure that other tools don't accidentally
|
|
|
2627 // trim the instruction padding (e.g. when stripping the file).
|
|
|
2628 PhdrEntry *last = nullptr;
|
|
|
2629 for (PhdrEntry *p : part.phdrs)
|
|
|
2630 if (p->p_type == PT_LOAD)
|
|
|
2631 last = p;
|
|
|
2632
|
|
|
2633 if (last && (last->p_flags & PF_X))
|
|
|
2634 last->p_memsz = last->p_filesz =
|
|
|
2635 alignTo(last->p_filesz, config->commonPageSize);
|
|
|
2636 }
|
|
|
2637 }
|
|
|
2638
|
|
|
2639 // Write section contents to a mmap'ed file.
|
|
|
2640 template <class ELFT> void Writer<ELFT>::writeSections() {
|
|
|
2641 // In -r or -emit-relocs mode, write the relocation sections first as in
|
|
|
2642 // ELf_Rel targets we might find out that we need to modify the relocated
|
|
|
2643 // section while doing it.
|
|
|
2644 for (OutputSection *sec : outputSections)
|
|
|
2645 if (sec->type == SHT_REL || sec->type == SHT_RELA)
|
|
|
2646 sec->writeTo<ELFT>(Out::bufferStart + sec->offset);
|
|
|
2647
|
|
|
2648 for (OutputSection *sec : outputSections)
|
|
|
2649 if (sec->type != SHT_REL && sec->type != SHT_RELA)
|
|
|
2650 sec->writeTo<ELFT>(Out::bufferStart + sec->offset);
|
|
|
2651 }
|
|
|
2652
|
|
|
2653 // Split one uint8 array into small pieces of uint8 arrays.
|
|
|
2654 static std::vector<ArrayRef<uint8_t>> split(ArrayRef<uint8_t> arr,
|
|
|
2655 size_t chunkSize) {
|
|
|
2656 std::vector<ArrayRef<uint8_t>> ret;
|
|
|
2657 while (arr.size() > chunkSize) {
|
|
|
2658 ret.push_back(arr.take_front(chunkSize));
|
|
|
2659 arr = arr.drop_front(chunkSize);
|
|
|
2660 }
|
|
|
2661 if (!arr.empty())
|
|
|
2662 ret.push_back(arr);
|
|
|
2663 return ret;
|
|
|
2664 }
|
|
|
2665
|
|
|
2666 // Computes a hash value of Data using a given hash function.
|
|
|
2667 // In order to utilize multiple cores, we first split data into 1MB
|
|
|
2668 // chunks, compute a hash for each chunk, and then compute a hash value
|
|
|
2669 // of the hash values.
|
|
|
2670 static void
|
|
|
2671 computeHash(llvm::MutableArrayRef<uint8_t> hashBuf,
|
|
|
2672 llvm::ArrayRef<uint8_t> data,
|
|
|
2673 std::function<void(uint8_t *dest, ArrayRef<uint8_t> arr)> hashFn) {
|
|
|
2674 std::vector<ArrayRef<uint8_t>> chunks = split(data, 1024 * 1024);
|
|
|
2675 std::vector<uint8_t> hashes(chunks.size() * hashBuf.size());
|
|
|
2676
|
|
|
2677 // Compute hash values.
|
|
|
2678 parallelForEachN(0, chunks.size(), [&](size_t i) {
|
|
|
2679 hashFn(hashes.data() + i * hashBuf.size(), chunks[i]);
|
|
|
2680 });
|
|
|
2681
|
|
|
2682 // Write to the final output buffer.
|
|
|
2683 hashFn(hashBuf.data(), hashes);
|
|
|
2684 }
|
|
|
2685
|
|
|
2686 template <class ELFT> void Writer<ELFT>::writeBuildId() {
|
|
|
2687 if (!mainPart->buildId || !mainPart->buildId->getParent())
|
|
|
2688 return;
|
|
|
2689
|
|
|
2690 if (config->buildId == BuildIdKind::Hexstring) {
|
|
|
2691 for (Partition &part : partitions)
|
|
|
2692 part.buildId->writeBuildId(config->buildIdVector);
|
|
|
2693 return;
|
|
|
2694 }
|
|
|
2695
|
|
|
2696 // Compute a hash of all sections of the output file.
|
|
|
2697 size_t hashSize = mainPart->buildId->hashSize;
|
|
|
2698 std::vector<uint8_t> buildId(hashSize);
|
|
|
2699 llvm::ArrayRef<uint8_t> buf{Out::bufferStart, size_t(fileSize)};
|
|
|
2700
|
|
|
2701 switch (config->buildId) {
|
|
|
2702 case BuildIdKind::Fast:
|
|
|
2703 computeHash(buildId, buf, [](uint8_t *dest, ArrayRef<uint8_t> arr) {
|
|
|
2704 write64le(dest, xxHash64(arr));
|
|
|
2705 });
|
|
|
2706 break;
|
|
|
2707 case BuildIdKind::Md5:
|
|
|
2708 computeHash(buildId, buf, [&](uint8_t *dest, ArrayRef<uint8_t> arr) {
|
|
|
2709 memcpy(dest, MD5::hash(arr).data(), hashSize);
|
|
|
2710 });
|
|
|
2711 break;
|
|
|
2712 case BuildIdKind::Sha1:
|
|
|
2713 computeHash(buildId, buf, [&](uint8_t *dest, ArrayRef<uint8_t> arr) {
|
|
|
2714 memcpy(dest, SHA1::hash(arr).data(), hashSize);
|
|
|
2715 });
|
|
|
2716 break;
|
|
|
2717 case BuildIdKind::Uuid:
|
|
|
2718 if (auto ec = llvm::getRandomBytes(buildId.data(), hashSize))
|
|
|
2719 error("entropy source failure: " + ec.message());
|
|
|
2720 break;
|
|
|
2721 default:
|
|
|
2722 llvm_unreachable("unknown BuildIdKind");
|
|
|
2723 }
|
|
|
2724 for (Partition &part : partitions)
|
|
|
2725 part.buildId->writeBuildId(buildId);
|
|
|
2726 }
|
|
|
2727
|
|
|
2728 template void createSyntheticSections<ELF32LE>();
|
|
|
2729 template void createSyntheticSections<ELF32BE>();
|
|
|
2730 template void createSyntheticSections<ELF64LE>();
|
|
|
2731 template void createSyntheticSections<ELF64BE>();
|
|
|
2732
|
|
|
2733 template void writeResult<ELF32LE>();
|
|
|
2734 template void writeResult<ELF32BE>();
|
|
|
2735 template void writeResult<ELF64LE>();
|
|
|
2736 template void writeResult<ELF64BE>();
|
|
|
2737
|
|
|
2738 } // namespace elf
|
|
|
2739 } // namespace lld
|
