1 //===- SyntheticSection.h ---------------------------------------*- C++ -*-===//
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 // Synthetic sections represent chunks of linker-created data. If you
10 // need to create a chunk of data that to be included in some section
11 // in the result, you probably want to create that as a synthetic section.
12 //
13 // Synthetic sections are designed as input sections as opposed to
14 // output sections because we want to allow them to be manipulated
15 // using linker scripts just like other input sections from regular
16 // files.
17 //
18 //===----------------------------------------------------------------------===//
19
20 #ifndef LLD_ELF_SYNTHETIC_SECTIONS_H
21 #define LLD_ELF_SYNTHETIC_SECTIONS_H
22
23 #include "DWARF.h"
24 #include "EhFrame.h"
25 #include "InputSection.h"
26 #include "llvm/ADT/MapVector.h"
27 #include "llvm/MC/StringTableBuilder.h"
28 #include "llvm/Support/Endian.h"
29 #include <functional>
30
31 namespace lld {
32 namespace elf {
33 class Defined;
34 struct PhdrEntry;
35 class SymbolTableBaseSection;
36 class VersionNeedBaseSection;
37
38 class SyntheticSection : public InputSection {
39 public:
SyntheticSection(uint64_t flags,uint32_t type,uint32_t alignment,StringRef name)40 SyntheticSection(uint64_t flags, uint32_t type, uint32_t alignment,
41 StringRef name)
42 : InputSection(nullptr, flags, type, alignment, {}, name,
43 InputSectionBase::Synthetic) {
44 markLive();
45 }
46
47 virtual ~SyntheticSection() = default;
48 virtual void writeTo(uint8_t *buf) = 0;
49 virtual size_t getSize() const = 0;
finalizeContents()50 virtual void finalizeContents() {}
51 // If the section has the SHF_ALLOC flag and the size may be changed if
52 // thunks are added, update the section size.
updateAllocSize()53 virtual bool updateAllocSize() { return false; }
isNeeded()54 virtual bool isNeeded() const { return true; }
55
classof(const SectionBase * d)56 static bool classof(const SectionBase *d) {
57 return d->kind() == InputSectionBase::Synthetic;
58 }
59 };
60
61 struct CieRecord {
62 EhSectionPiece *cie = nullptr;
63 std::vector<EhSectionPiece *> fdes;
64 };
65
66 // Section for .eh_frame.
67 class EhFrameSection final : public SyntheticSection {
68 public:
69 EhFrameSection();
70 void writeTo(uint8_t *buf) override;
71 void finalizeContents() override;
isNeeded()72 bool isNeeded() const override { return !sections.empty(); }
getSize()73 size_t getSize() const override { return size; }
74
classof(const SectionBase * d)75 static bool classof(const SectionBase *d) {
76 return SyntheticSection::classof(d) && d->name == ".eh_frame";
77 }
78
79 void addSection(EhInputSection *sec);
80
81 std::vector<EhInputSection *> sections;
82 size_t numFdes = 0;
83
84 struct FdeData {
85 uint32_t pcRel;
86 uint32_t fdeVARel;
87 };
88
89 std::vector<FdeData> getFdeData() const;
getCieRecords()90 ArrayRef<CieRecord *> getCieRecords() const { return cieRecords; }
91
92 private:
93 // This is used only when parsing EhInputSection. We keep it here to avoid
94 // allocating one for each EhInputSection.
95 llvm::DenseMap<size_t, CieRecord *> offsetToCie;
96
97 uint64_t size = 0;
98
99 template <class ELFT, class RelTy>
100 void addRecords(EhInputSection *s, llvm::ArrayRef<RelTy> rels);
101 template <class ELFT>
102 void addSectionAux(EhInputSection *s);
103
104 template <class ELFT, class RelTy>
105 CieRecord *addCie(EhSectionPiece &piece, ArrayRef<RelTy> rels);
106
107 template <class ELFT, class RelTy>
108 bool isFdeLive(EhSectionPiece &piece, ArrayRef<RelTy> rels);
109
110 uint64_t getFdePc(uint8_t *buf, size_t off, uint8_t enc) const;
111
112 std::vector<CieRecord *> cieRecords;
113
114 // CIE records are uniquified by their contents and personality functions.
115 llvm::DenseMap<std::pair<ArrayRef<uint8_t>, Symbol *>, CieRecord *> cieMap;
116 };
117
118 class GotSection : public SyntheticSection {
119 public:
120 GotSection();
getSize()121 size_t getSize() const override { return size; }
122 void finalizeContents() override;
123 bool isNeeded() const override;
124 void writeTo(uint8_t *buf) override;
125
126 void addEntry(Symbol &sym);
127 bool addDynTlsEntry(Symbol &sym);
128 bool addTlsIndex();
129 uint64_t getGlobalDynAddr(const Symbol &b) const;
130 uint64_t getGlobalDynOffset(const Symbol &b) const;
131
getTlsIndexVA()132 uint64_t getTlsIndexVA() { return this->getVA() + tlsIndexOff; }
getTlsIndexOff()133 uint32_t getTlsIndexOff() const { return tlsIndexOff; }
134
135 // Flag to force GOT to be in output if we have relocations
136 // that relies on its address.
137 bool hasGotOffRel = false;
138
139 protected:
140 size_t numEntries = 0;
141 uint32_t tlsIndexOff = -1;
142 uint64_t size = 0;
143 };
144
145 // .note.GNU-stack section.
146 class GnuStackSection : public SyntheticSection {
147 public:
GnuStackSection()148 GnuStackSection()
149 : SyntheticSection(0, llvm::ELF::SHT_PROGBITS, 1, ".note.GNU-stack") {}
writeTo(uint8_t * buf)150 void writeTo(uint8_t *buf) override {}
getSize()151 size_t getSize() const override { return 0; }
152 };
153
154 class GnuPropertySection : public SyntheticSection {
155 public:
156 GnuPropertySection();
157 void writeTo(uint8_t *buf) override;
158 size_t getSize() const override;
159 };
160
161 // .note.gnu.build-id section.
162 class BuildIdSection : public SyntheticSection {
163 // First 16 bytes are a header.
164 static const unsigned headerSize = 16;
165
166 public:
167 const size_t hashSize;
168 BuildIdSection();
169 void writeTo(uint8_t *buf) override;
getSize()170 size_t getSize() const override { return headerSize + hashSize; }
171 void writeBuildId(llvm::ArrayRef<uint8_t> buf);
172
173 private:
174 uint8_t *hashBuf;
175 };
176
177 // BssSection is used to reserve space for copy relocations and common symbols.
178 // We create three instances of this class for .bss, .bss.rel.ro and "COMMON",
179 // that are used for writable symbols, read-only symbols and common symbols,
180 // respectively.
181 class BssSection final : public SyntheticSection {
182 public:
183 BssSection(StringRef name, uint64_t size, uint32_t alignment);
writeTo(uint8_t *)184 void writeTo(uint8_t *) override {
185 llvm_unreachable("unexpected writeTo() call for SHT_NOBITS section");
186 }
isNeeded()187 bool isNeeded() const override { return size != 0; }
getSize()188 size_t getSize() const override { return size; }
189
classof(const SectionBase * s)190 static bool classof(const SectionBase *s) { return s->bss; }
191 uint64_t size;
192 };
193
194 class MipsGotSection final : public SyntheticSection {
195 public:
196 MipsGotSection();
197 void writeTo(uint8_t *buf) override;
getSize()198 size_t getSize() const override { return size; }
199 bool updateAllocSize() override;
200 void finalizeContents() override;
201 bool isNeeded() const override;
202
203 // Join separate GOTs built for each input file to generate
204 // primary and optional multiple secondary GOTs.
205 void build();
206
207 void addEntry(InputFile &file, Symbol &sym, int64_t addend, RelExpr expr);
208 void addDynTlsEntry(InputFile &file, Symbol &sym);
209 void addTlsIndex(InputFile &file);
210
211 uint64_t getPageEntryOffset(const InputFile *f, const Symbol &s,
212 int64_t addend) const;
213 uint64_t getSymEntryOffset(const InputFile *f, const Symbol &s,
214 int64_t addend) const;
215 uint64_t getGlobalDynOffset(const InputFile *f, const Symbol &s) const;
216 uint64_t getTlsIndexOffset(const InputFile *f) const;
217
218 // Returns the symbol which corresponds to the first entry of the global part
219 // of GOT on MIPS platform. It is required to fill up MIPS-specific dynamic
220 // table properties.
221 // Returns nullptr if the global part is empty.
222 const Symbol *getFirstGlobalEntry() const;
223
224 // Returns the number of entries in the local part of GOT including
225 // the number of reserved entries.
226 unsigned getLocalEntriesNum() const;
227
228 // Return _gp value for primary GOT (nullptr) or particular input file.
229 uint64_t getGp(const InputFile *f = nullptr) const;
230
231 private:
232 // MIPS GOT consists of three parts: local, global and tls. Each part
233 // contains different types of entries. Here is a layout of GOT:
234 // - Header entries |
235 // - Page entries | Local part
236 // - Local entries (16-bit access) |
237 // - Local entries (32-bit access) |
238 // - Normal global entries || Global part
239 // - Reloc-only global entries ||
240 // - TLS entries ||| TLS part
241 //
242 // Header:
243 // Two entries hold predefined value 0x0 and 0x80000000.
244 // Page entries:
245 // These entries created by R_MIPS_GOT_PAGE relocation and R_MIPS_GOT16
246 // relocation against local symbols. They are initialized by higher 16-bit
247 // of the corresponding symbol's value. So each 64kb of address space
248 // requires a single GOT entry.
249 // Local entries (16-bit access):
250 // These entries created by GOT relocations against global non-preemptible
251 // symbols so dynamic linker is not necessary to resolve the symbol's
252 // values. "16-bit access" means that corresponding relocations address
253 // GOT using 16-bit index. Each unique Symbol-Addend pair has its own
254 // GOT entry.
255 // Local entries (32-bit access):
256 // These entries are the same as above but created by relocations which
257 // address GOT using 32-bit index (R_MIPS_GOT_HI16/LO16 etc).
258 // Normal global entries:
259 // These entries created by GOT relocations against preemptible global
260 // symbols. They need to be initialized by dynamic linker and they ordered
261 // exactly as the corresponding entries in the dynamic symbols table.
262 // Reloc-only global entries:
263 // These entries created for symbols that are referenced by dynamic
264 // relocations R_MIPS_REL32. These entries are not accessed with gp-relative
265 // addressing, but MIPS ABI requires that these entries be present in GOT.
266 // TLS entries:
267 // Entries created by TLS relocations.
268 //
269 // If the sum of local, global and tls entries is less than 64K only single
270 // got is enough. Otherwise, multi-got is created. Series of primary and
271 // multiple secondary GOTs have the following layout:
272 // - Primary GOT
273 // Header
274 // Local entries
275 // Global entries
276 // Relocation only entries
277 // TLS entries
278 //
279 // - Secondary GOT
280 // Local entries
281 // Global entries
282 // TLS entries
283 // ...
284 //
285 // All GOT entries required by relocations from a single input file entirely
286 // belong to either primary or one of secondary GOTs. To reference GOT entries
287 // each GOT has its own _gp value points to the "middle" of the GOT.
288 // In the code this value loaded to the register which is used for GOT access.
289 //
290 // MIPS 32 function's prologue:
291 // lui v0,0x0
292 // 0: R_MIPS_HI16 _gp_disp
293 // addiu v0,v0,0
294 // 4: R_MIPS_LO16 _gp_disp
295 //
296 // MIPS 64:
297 // lui at,0x0
298 // 14: R_MIPS_GPREL16 main
299 //
300 // Dynamic linker does not know anything about secondary GOTs and cannot
301 // use a regular MIPS mechanism for GOT entries initialization. So we have
302 // to use an approach accepted by other architectures and create dynamic
303 // relocations R_MIPS_REL32 to initialize global entries (and local in case
304 // of PIC code) in secondary GOTs. But ironically MIPS dynamic linker
305 // requires GOT entries and correspondingly ordered dynamic symbol table
306 // entries to deal with dynamic relocations. To handle this problem
307 // relocation-only section in the primary GOT contains entries for all
308 // symbols referenced in global parts of secondary GOTs. Although the sum
309 // of local and normal global entries of the primary got should be less
310 // than 64K, the size of the primary got (including relocation-only entries
311 // can be greater than 64K, because parts of the primary got that overflow
312 // the 64K limit are used only by the dynamic linker at dynamic link-time
313 // and not by 16-bit gp-relative addressing at run-time.
314 //
315 // For complete multi-GOT description see the following link
316 // https://dmz-portal.mips.com/wiki/MIPS_Multi_GOT
317
318 // Number of "Header" entries.
319 static const unsigned headerEntriesNum = 2;
320
321 uint64_t size = 0;
322
323 // Symbol and addend.
324 using GotEntry = std::pair<Symbol *, int64_t>;
325
326 struct FileGot {
327 InputFile *file = nullptr;
328 size_t startIndex = 0;
329
330 struct PageBlock {
331 size_t firstIndex;
332 size_t count;
PageBlockFileGot::PageBlock333 PageBlock() : firstIndex(0), count(0) {}
334 };
335
336 // Map output sections referenced by MIPS GOT relocations
337 // to the description (index/count) "page" entries allocated
338 // for this section.
339 llvm::SmallMapVector<const OutputSection *, PageBlock, 16> pagesMap;
340 // Maps from Symbol+Addend pair or just Symbol to the GOT entry index.
341 llvm::MapVector<GotEntry, size_t> local16;
342 llvm::MapVector<GotEntry, size_t> local32;
343 llvm::MapVector<Symbol *, size_t> global;
344 llvm::MapVector<Symbol *, size_t> relocs;
345 llvm::MapVector<Symbol *, size_t> tls;
346 // Set of symbols referenced by dynamic TLS relocations.
347 llvm::MapVector<Symbol *, size_t> dynTlsSymbols;
348
349 // Total number of all entries.
350 size_t getEntriesNum() const;
351 // Number of "page" entries.
352 size_t getPageEntriesNum() const;
353 // Number of entries require 16-bit index to access.
354 size_t getIndexedEntriesNum() const;
355 };
356
357 // Container of GOT created for each input file.
358 // After building a final series of GOTs this container
359 // holds primary and secondary GOT's.
360 std::vector<FileGot> gots;
361
362 // Return (and create if necessary) `FileGot`.
363 FileGot &getGot(InputFile &f);
364
365 // Try to merge two GOTs. In case of success the `Dst` contains
366 // result of merging and the function returns true. In case of
367 // overflow the `Dst` is unchanged and the function returns false.
368 bool tryMergeGots(FileGot & dst, FileGot & src, bool isPrimary);
369 };
370
371 class GotPltSection final : public SyntheticSection {
372 public:
373 GotPltSection();
374 void addEntry(Symbol &sym);
375 size_t getSize() const override;
376 void writeTo(uint8_t *buf) override;
377 bool isNeeded() const override;
378
379 // Flag to force GotPlt to be in output if we have relocations
380 // that relies on its address.
381 bool hasGotPltOffRel = false;
382
383 private:
384 std::vector<const Symbol *> entries;
385 };
386
387 // The IgotPltSection is a Got associated with the PltSection for GNU Ifunc
388 // Symbols that will be relocated by Target->IRelativeRel.
389 // On most Targets the IgotPltSection will immediately follow the GotPltSection
390 // on ARM the IgotPltSection will immediately follow the GotSection.
391 class IgotPltSection final : public SyntheticSection {
392 public:
393 IgotPltSection();
394 void addEntry(Symbol &sym);
395 size_t getSize() const override;
396 void writeTo(uint8_t *buf) override;
isNeeded()397 bool isNeeded() const override { return !entries.empty(); }
398
399 private:
400 std::vector<const Symbol *> entries;
401 };
402
403 class StringTableSection final : public SyntheticSection {
404 public:
405 StringTableSection(StringRef name, bool dynamic);
406 unsigned addString(StringRef s, bool hashIt = true);
407 void writeTo(uint8_t *buf) override;
getSize()408 size_t getSize() const override { return size; }
isDynamic()409 bool isDynamic() const { return dynamic; }
410
411 private:
412 const bool dynamic;
413
414 uint64_t size = 0;
415
416 llvm::DenseMap<StringRef, unsigned> stringMap;
417 std::vector<StringRef> strings;
418 };
419
420 class DynamicReloc {
421 public:
DynamicReloc(RelType type,const InputSectionBase * inputSec,uint64_t offsetInSec,bool useSymVA,Symbol * sym,int64_t addend)422 DynamicReloc(RelType type, const InputSectionBase *inputSec,
423 uint64_t offsetInSec, bool useSymVA, Symbol *sym, int64_t addend)
424 : type(type), sym(sym), inputSec(inputSec), offsetInSec(offsetInSec),
425 useSymVA(useSymVA), addend(addend), outputSec(nullptr) {}
426 // This constructor records dynamic relocation settings used by MIPS
427 // multi-GOT implementation. It's to relocate addresses of 64kb pages
428 // lie inside the output section.
DynamicReloc(RelType type,const InputSectionBase * inputSec,uint64_t offsetInSec,const OutputSection * outputSec,int64_t addend)429 DynamicReloc(RelType type, const InputSectionBase *inputSec,
430 uint64_t offsetInSec, const OutputSection *outputSec,
431 int64_t addend)
432 : type(type), sym(nullptr), inputSec(inputSec), offsetInSec(offsetInSec),
433 useSymVA(false), addend(addend), outputSec(outputSec) {}
434
435 uint64_t getOffset() const;
436 uint32_t getSymIndex(SymbolTableBaseSection *symTab) const;
437
438 // Computes the addend of the dynamic relocation. Note that this is not the
439 // same as the addend member variable as it also includes the symbol address
440 // if useSymVA is true.
441 int64_t computeAddend() const;
442
443 RelType type;
444
445 Symbol *sym;
446 const InputSectionBase *inputSec = nullptr;
447 uint64_t offsetInSec;
448 // If this member is true, the dynamic relocation will not be against the
449 // symbol but will instead be a relative relocation that simply adds the
450 // load address. This means we need to write the symbol virtual address
451 // plus the original addend as the final relocation addend.
452 bool useSymVA;
453 int64_t addend;
454 const OutputSection *outputSec;
455 friend class RelocationBaseSection;
456 };
457
458 template <class ELFT> class DynamicSection final : public SyntheticSection {
459 using Elf_Dyn = typename ELFT::Dyn;
460 using Elf_Rel = typename ELFT::Rel;
461 using Elf_Rela = typename ELFT::Rela;
462 using Elf_Relr = typename ELFT::Relr;
463 using Elf_Shdr = typename ELFT::Shdr;
464 using Elf_Sym = typename ELFT::Sym;
465
466 // finalizeContents() fills this vector with the section contents.
467 std::vector<std::pair<int32_t, std::function<uint64_t()>>> entries;
468
469 public:
470 DynamicSection();
471 void finalizeContents() override;
472 void writeTo(uint8_t *buf) override;
getSize()473 size_t getSize() const override { return size; }
474
475 private:
476 void add(int32_t tag, std::function<uint64_t()> fn);
477 void addInt(int32_t tag, uint64_t val);
478 void addInSec(int32_t tag, InputSection *sec);
479 void addInSecRelative(int32_t tag, InputSection *sec);
480 void addOutSec(int32_t tag, OutputSection *sec);
481 void addSize(int32_t tag, OutputSection *sec);
482 void addSym(int32_t tag, Symbol *sym);
483
484 uint64_t size = 0;
485 };
486
487 class RelocationBaseSection : public SyntheticSection {
488 public:
489 RelocationBaseSection(StringRef name, uint32_t type, int32_t dynamicTag,
490 int32_t sizeDynamicTag);
491 void addReloc(RelType dynType, InputSectionBase *isec, uint64_t offsetInSec,
492 Symbol *sym);
493 // Add a dynamic relocation that might need an addend. This takes care of
494 // writing the addend to the output section if needed.
495 void addReloc(RelType dynType, InputSectionBase *inputSec,
496 uint64_t offsetInSec, Symbol *sym, int64_t addend, RelExpr expr,
497 RelType type);
498 void addReloc(const DynamicReloc &reloc);
isNeeded()499 bool isNeeded() const override { return !relocs.empty(); }
getSize()500 size_t getSize() const override { return relocs.size() * this->entsize; }
getRelativeRelocCount()501 size_t getRelativeRelocCount() const { return numRelativeRelocs; }
502 void finalizeContents() override;
503 int32_t dynamicTag, sizeDynamicTag;
504 std::vector<DynamicReloc> relocs;
505
506 protected:
507 size_t numRelativeRelocs = 0;
508 };
509
510 template <class ELFT>
511 class RelocationSection final : public RelocationBaseSection {
512 using Elf_Rel = typename ELFT::Rel;
513 using Elf_Rela = typename ELFT::Rela;
514
515 public:
516 RelocationSection(StringRef name, bool sort);
517 void writeTo(uint8_t *buf) override;
518
519 private:
520 bool sort;
521 };
522
523 template <class ELFT>
524 class AndroidPackedRelocationSection final : public RelocationBaseSection {
525 using Elf_Rel = typename ELFT::Rel;
526 using Elf_Rela = typename ELFT::Rela;
527
528 public:
529 AndroidPackedRelocationSection(StringRef name);
530
531 bool updateAllocSize() override;
getSize()532 size_t getSize() const override { return relocData.size(); }
writeTo(uint8_t * buf)533 void writeTo(uint8_t *buf) override {
534 memcpy(buf, relocData.data(), relocData.size());
535 }
536
537 private:
538 SmallVector<char, 0> relocData;
539 };
540
541 struct RelativeReloc {
getOffsetRelativeReloc542 uint64_t getOffset() const { return inputSec->getVA(offsetInSec); }
543
544 const InputSectionBase *inputSec;
545 uint64_t offsetInSec;
546 };
547
548 class RelrBaseSection : public SyntheticSection {
549 public:
550 RelrBaseSection();
isNeeded()551 bool isNeeded() const override { return !relocs.empty(); }
552 std::vector<RelativeReloc> relocs;
553 };
554
555 // RelrSection is used to encode offsets for relative relocations.
556 // Proposal for adding SHT_RELR sections to generic-abi is here:
557 // https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
558 // For more details, see the comment in RelrSection::updateAllocSize().
559 template <class ELFT> class RelrSection final : public RelrBaseSection {
560 using Elf_Relr = typename ELFT::Relr;
561
562 public:
563 RelrSection();
564
565 bool updateAllocSize() override;
getSize()566 size_t getSize() const override { return relrRelocs.size() * this->entsize; }
writeTo(uint8_t * buf)567 void writeTo(uint8_t *buf) override {
568 memcpy(buf, relrRelocs.data(), getSize());
569 }
570
571 private:
572 std::vector<Elf_Relr> relrRelocs;
573 };
574
575 struct SymbolTableEntry {
576 Symbol *sym;
577 size_t strTabOffset;
578 };
579
580 class SymbolTableBaseSection : public SyntheticSection {
581 public:
582 SymbolTableBaseSection(StringTableSection &strTabSec);
583 void finalizeContents() override;
getSize()584 size_t getSize() const override { return getNumSymbols() * entsize; }
585 void addSymbol(Symbol *sym);
getNumSymbols()586 unsigned getNumSymbols() const { return symbols.size() + 1; }
587 size_t getSymbolIndex(Symbol *sym);
getSymbols()588 ArrayRef<SymbolTableEntry> getSymbols() const { return symbols; }
589
590 protected:
591 void sortSymTabSymbols();
592
593 // A vector of symbols and their string table offsets.
594 std::vector<SymbolTableEntry> symbols;
595
596 StringTableSection &strTabSec;
597
598 llvm::once_flag onceFlag;
599 llvm::DenseMap<Symbol *, size_t> symbolIndexMap;
600 llvm::DenseMap<OutputSection *, size_t> sectionIndexMap;
601 };
602
603 template <class ELFT>
604 class SymbolTableSection final : public SymbolTableBaseSection {
605 using Elf_Sym = typename ELFT::Sym;
606
607 public:
608 SymbolTableSection(StringTableSection &strTabSec);
609 void writeTo(uint8_t *buf) override;
610 };
611
612 class SymtabShndxSection final : public SyntheticSection {
613 public:
614 SymtabShndxSection();
615
616 void writeTo(uint8_t *buf) override;
617 size_t getSize() const override;
618 bool isNeeded() const override;
619 void finalizeContents() override;
620 };
621
622 // Outputs GNU Hash section. For detailed explanation see:
623 // https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections
624 class GnuHashTableSection final : public SyntheticSection {
625 public:
626 GnuHashTableSection();
627 void finalizeContents() override;
628 void writeTo(uint8_t *buf) override;
getSize()629 size_t getSize() const override { return size; }
630
631 // Adds symbols to the hash table.
632 // Sorts the input to satisfy GNU hash section requirements.
633 void addSymbols(std::vector<SymbolTableEntry> &symbols);
634
635 private:
636 // See the comment in writeBloomFilter.
637 enum { Shift2 = 26 };
638
639 void writeBloomFilter(uint8_t *buf);
640 void writeHashTable(uint8_t *buf);
641
642 struct Entry {
643 Symbol *sym;
644 size_t strTabOffset;
645 uint32_t hash;
646 uint32_t bucketIdx;
647 };
648
649 std::vector<Entry> symbols;
650 size_t maskWords;
651 size_t nBuckets = 0;
652 size_t size = 0;
653 };
654
655 class HashTableSection final : public SyntheticSection {
656 public:
657 HashTableSection();
658 void finalizeContents() override;
659 void writeTo(uint8_t *buf) override;
getSize()660 size_t getSize() const override { return size; }
661
662 private:
663 size_t size = 0;
664 };
665
666 // Used for PLT entries. It usually has a PLT header for lazy binding. Each PLT
667 // entry is associated with a JUMP_SLOT relocation, which may be resolved lazily
668 // at runtime.
669 //
670 // On PowerPC, this section contains lazy symbol resolvers. A branch instruction
671 // jumps to a PLT call stub, which will then jump to the target (BIND_NOW) or a
672 // lazy symbol resolver.
673 //
674 // On x86 when IBT is enabled, this section (.plt.sec) contains PLT call stubs.
675 // A call instruction jumps to a .plt.sec entry, which will then jump to the
676 // target (BIND_NOW) or a .plt entry.
677 class PltSection : public SyntheticSection {
678 public:
679 PltSection();
680 void writeTo(uint8_t *buf) override;
681 size_t getSize() const override;
682 bool isNeeded() const override;
683 void addSymbols();
684 void addEntry(Symbol &sym);
getNumEntries()685 size_t getNumEntries() const { return entries.size(); }
686
687 size_t headerSize;
688
689 std::vector<const Symbol *> entries;
690 };
691
692 // Used for non-preemptible ifuncs. It does not have a header. Each entry is
693 // associated with an IRELATIVE relocation, which will be resolved eagerly at
694 // runtime. PltSection can only contain entries associated with JUMP_SLOT
695 // relocations, so IPLT entries are in a separate section.
696 class IpltSection final : public SyntheticSection {
697 std::vector<const Symbol *> entries;
698
699 public:
700 IpltSection();
701 void writeTo(uint8_t *buf) override;
702 size_t getSize() const override;
isNeeded()703 bool isNeeded() const override { return !entries.empty(); }
704 void addSymbols();
705 void addEntry(Symbol &sym);
706 };
707
708 class PPC32GlinkSection : public PltSection {
709 public:
710 PPC32GlinkSection();
711 void writeTo(uint8_t *buf) override;
712 size_t getSize() const override;
713
714 std::vector<const Symbol *> canonical_plts;
715 static constexpr size_t footerSize = 64;
716 };
717
718 // This is x86-only.
719 class IBTPltSection : public SyntheticSection {
720 public:
721 IBTPltSection();
722 void writeTo(uint8_t *Buf) override;
723 size_t getSize() const override;
724 };
725
726 class GdbIndexSection final : public SyntheticSection {
727 public:
728 struct AddressEntry {
729 InputSection *section;
730 uint64_t lowAddress;
731 uint64_t highAddress;
732 uint32_t cuIndex;
733 };
734
735 struct CuEntry {
736 uint64_t cuOffset;
737 uint64_t cuLength;
738 };
739
740 struct NameAttrEntry {
741 llvm::CachedHashStringRef name;
742 uint32_t cuIndexAndAttrs;
743 };
744
745 struct GdbChunk {
746 InputSection *sec;
747 std::vector<AddressEntry> addressAreas;
748 std::vector<CuEntry> compilationUnits;
749 };
750
751 struct GdbSymbol {
752 llvm::CachedHashStringRef name;
753 std::vector<uint32_t> cuVector;
754 uint32_t nameOff;
755 uint32_t cuVectorOff;
756 };
757
758 GdbIndexSection();
759 template <typename ELFT> static GdbIndexSection *create();
760 void writeTo(uint8_t *buf) override;
getSize()761 size_t getSize() const override { return size; }
762 bool isNeeded() const override;
763
764 private:
765 struct GdbIndexHeader {
766 llvm::support::ulittle32_t version;
767 llvm::support::ulittle32_t cuListOff;
768 llvm::support::ulittle32_t cuTypesOff;
769 llvm::support::ulittle32_t addressAreaOff;
770 llvm::support::ulittle32_t symtabOff;
771 llvm::support::ulittle32_t constantPoolOff;
772 };
773
774 void initOutputSize();
775 size_t computeSymtabSize() const;
776
777 // Each chunk contains information gathered from debug sections of a
778 // single object file.
779 std::vector<GdbChunk> chunks;
780
781 // A symbol table for this .gdb_index section.
782 std::vector<GdbSymbol> symbols;
783
784 size_t size;
785 };
786
787 // --eh-frame-hdr option tells linker to construct a header for all the
788 // .eh_frame sections. This header is placed to a section named .eh_frame_hdr
789 // and also to a PT_GNU_EH_FRAME segment.
790 // At runtime the unwinder then can find all the PT_GNU_EH_FRAME segments by
791 // calling dl_iterate_phdr.
792 // This section contains a lookup table for quick binary search of FDEs.
793 // Detailed info about internals can be found in Ian Lance Taylor's blog:
794 // http://www.airs.com/blog/archives/460 (".eh_frame")
795 // http://www.airs.com/blog/archives/462 (".eh_frame_hdr")
796 class EhFrameHeader final : public SyntheticSection {
797 public:
798 EhFrameHeader();
799 void write();
800 void writeTo(uint8_t *buf) override;
801 size_t getSize() const override;
802 bool isNeeded() const override;
803 };
804
805 // For more information about .gnu.version and .gnu.version_r see:
806 // https://www.akkadia.org/drepper/symbol-versioning
807
808 // The .gnu.version_d section which has a section type of SHT_GNU_verdef shall
809 // contain symbol version definitions. The number of entries in this section
810 // shall be contained in the DT_VERDEFNUM entry of the .dynamic section.
811 // The section shall contain an array of Elf_Verdef structures, optionally
812 // followed by an array of Elf_Verdaux structures.
813 class VersionDefinitionSection final : public SyntheticSection {
814 public:
815 VersionDefinitionSection();
816 void finalizeContents() override;
817 size_t getSize() const override;
818 void writeTo(uint8_t *buf) override;
819
820 private:
821 enum { EntrySize = 28 };
822 void writeOne(uint8_t *buf, uint32_t index, StringRef name, size_t nameOff);
823 StringRef getFileDefName();
824
825 unsigned fileDefNameOff;
826 std::vector<unsigned> verDefNameOffs;
827 };
828
829 // The .gnu.version section specifies the required version of each symbol in the
830 // dynamic symbol table. It contains one Elf_Versym for each dynamic symbol
831 // table entry. An Elf_Versym is just a 16-bit integer that refers to a version
832 // identifier defined in the either .gnu.version_r or .gnu.version_d section.
833 // The values 0 and 1 are reserved. All other values are used for versions in
834 // the own object or in any of the dependencies.
835 class VersionTableSection final : public SyntheticSection {
836 public:
837 VersionTableSection();
838 void finalizeContents() override;
839 size_t getSize() const override;
840 void writeTo(uint8_t *buf) override;
841 bool isNeeded() const override;
842 };
843
844 // The .gnu.version_r section defines the version identifiers used by
845 // .gnu.version. It contains a linked list of Elf_Verneed data structures. Each
846 // Elf_Verneed specifies the version requirements for a single DSO, and contains
847 // a reference to a linked list of Elf_Vernaux data structures which define the
848 // mapping from version identifiers to version names.
849 template <class ELFT>
850 class VersionNeedSection final : public SyntheticSection {
851 using Elf_Verneed = typename ELFT::Verneed;
852 using Elf_Vernaux = typename ELFT::Vernaux;
853
854 struct Vernaux {
855 uint64_t hash;
856 uint32_t verneedIndex;
857 uint64_t nameStrTab;
858 };
859
860 struct Verneed {
861 uint64_t nameStrTab;
862 std::vector<Vernaux> vernauxs;
863 };
864
865 std::vector<Verneed> verneeds;
866
867 public:
868 VersionNeedSection();
869 void finalizeContents() override;
870 void writeTo(uint8_t *buf) override;
871 size_t getSize() const override;
872 bool isNeeded() const override;
873 };
874
875 // MergeSyntheticSection is a class that allows us to put mergeable sections
876 // with different attributes in a single output sections. To do that
877 // we put them into MergeSyntheticSection synthetic input sections which are
878 // attached to regular output sections.
879 class MergeSyntheticSection : public SyntheticSection {
880 public:
881 void addSection(MergeInputSection *ms);
882 std::vector<MergeInputSection *> sections;
883
884 protected:
MergeSyntheticSection(StringRef name,uint32_t type,uint64_t flags,uint32_t alignment)885 MergeSyntheticSection(StringRef name, uint32_t type, uint64_t flags,
886 uint32_t alignment)
887 : SyntheticSection(flags, type, alignment, name) {}
888 };
889
890 class MergeTailSection final : public MergeSyntheticSection {
891 public:
892 MergeTailSection(StringRef name, uint32_t type, uint64_t flags,
893 uint32_t alignment);
894
895 size_t getSize() const override;
896 void writeTo(uint8_t *buf) override;
897 void finalizeContents() override;
898
899 private:
900 llvm::StringTableBuilder builder;
901 };
902
903 class MergeNoTailSection final : public MergeSyntheticSection {
904 public:
MergeNoTailSection(StringRef name,uint32_t type,uint64_t flags,uint32_t alignment)905 MergeNoTailSection(StringRef name, uint32_t type, uint64_t flags,
906 uint32_t alignment)
907 : MergeSyntheticSection(name, type, flags, alignment) {}
908
getSize()909 size_t getSize() const override { return size; }
910 void writeTo(uint8_t *buf) override;
911 void finalizeContents() override;
912
913 private:
914 // We use the most significant bits of a hash as a shard ID.
915 // The reason why we don't want to use the least significant bits is
916 // because DenseMap also uses lower bits to determine a bucket ID.
917 // If we use lower bits, it significantly increases the probability of
918 // hash collisons.
getShardId(uint32_t hash)919 size_t getShardId(uint32_t hash) {
920 assert((hash >> 31) == 0);
921 return hash >> (31 - llvm::countTrailingZeros(numShards));
922 }
923
924 // Section size
925 size_t size;
926
927 // String table contents
928 constexpr static size_t numShards = 32;
929 std::vector<llvm::StringTableBuilder> shards;
930 size_t shardOffsets[numShards];
931 };
932
933 // .MIPS.abiflags section.
934 template <class ELFT>
935 class MipsAbiFlagsSection final : public SyntheticSection {
936 using Elf_Mips_ABIFlags = llvm::object::Elf_Mips_ABIFlags<ELFT>;
937
938 public:
939 static MipsAbiFlagsSection *create();
940
941 MipsAbiFlagsSection(Elf_Mips_ABIFlags flags);
getSize()942 size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
943 void writeTo(uint8_t *buf) override;
944 llvm::Optional<unsigned> getCheriAbiVariant() const;
945
946 private:
947 Elf_Mips_ABIFlags flags;
948 };
949
950 // .MIPS.options section.
951 template <class ELFT> class MipsOptionsSection final : public SyntheticSection {
952 using Elf_Mips_Options = llvm::object::Elf_Mips_Options<ELFT>;
953 using Elf_Mips_RegInfo = llvm::object::Elf_Mips_RegInfo<ELFT>;
954
955 public:
956 static MipsOptionsSection *create();
957
958 MipsOptionsSection(Elf_Mips_RegInfo reginfo);
959 void writeTo(uint8_t *buf) override;
960
getSize()961 size_t getSize() const override {
962 return sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
963 }
964
965 private:
966 Elf_Mips_RegInfo reginfo;
967 };
968
969 // MIPS .reginfo section.
970 template <class ELFT> class MipsReginfoSection final : public SyntheticSection {
971 using Elf_Mips_RegInfo = llvm::object::Elf_Mips_RegInfo<ELFT>;
972
973 public:
974 static MipsReginfoSection *create();
975
976 MipsReginfoSection(Elf_Mips_RegInfo reginfo);
getSize()977 size_t getSize() const override { return sizeof(Elf_Mips_RegInfo); }
978 void writeTo(uint8_t *buf) override;
979
980 private:
981 Elf_Mips_RegInfo reginfo;
982 };
983
984 // This is a MIPS specific section to hold a space within the data segment
985 // of executable file which is pointed to by the DT_MIPS_RLD_MAP entry.
986 // See "Dynamic section" in Chapter 5 in the following document:
987 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
988 class MipsRldMapSection : public SyntheticSection {
989 public:
990 MipsRldMapSection();
getSize()991 size_t getSize() const override { return config->wordsize; }
writeTo(uint8_t * buf)992 void writeTo(uint8_t *buf) override {}
993 };
994
995 // Representation of the combined .ARM.Exidx input sections. We process these
996 // as a SyntheticSection like .eh_frame as we need to merge duplicate entries
997 // and add terminating sentinel entries.
998 //
999 // The .ARM.exidx input sections after SHF_LINK_ORDER processing is done form
1000 // a table that the unwinder can derive (Addresses are encoded as offsets from
1001 // table):
1002 // | Address of function | Unwind instructions for function |
1003 // where the unwind instructions are either a small number of unwind or the
1004 // special EXIDX_CANTUNWIND entry representing no unwinding information.
1005 // When an exception is thrown from an address A, the unwinder searches the
1006 // table for the closest table entry with Address of function <= A. This means
1007 // that for two consecutive table entries:
1008 // | A1 | U1 |
1009 // | A2 | U2 |
1010 // The range of addresses described by U1 is [A1, A2)
1011 //
1012 // There are two cases where we need a linker generated table entry to fixup
1013 // the address ranges in the table
1014 // Case 1:
1015 // - A sentinel entry added with an address higher than all
1016 // executable sections. This was needed to work around libunwind bug pr31091.
1017 // - After address assignment we need to find the highest addressed executable
1018 // section and use the limit of that section so that the unwinder never
1019 // matches it.
1020 // Case 2:
1021 // - InputSections without a .ARM.exidx section (usually from Assembly)
1022 // need a table entry so that they terminate the range of the previously
1023 // function. This is pr40277.
1024 //
1025 // Instead of storing pointers to the .ARM.exidx InputSections from
1026 // InputObjects, we store pointers to the executable sections that need
1027 // .ARM.exidx sections. We can then use the dependentSections of these to
1028 // either find the .ARM.exidx section or know that we need to generate one.
1029 class ARMExidxSyntheticSection : public SyntheticSection {
1030 public:
1031 ARMExidxSyntheticSection();
1032
1033 // Add an input section to the ARMExidxSyntheticSection. Returns whether the
1034 // section needs to be removed from the main input section list.
1035 bool addSection(InputSection *isec);
1036
getSize()1037 size_t getSize() const override { return size; }
1038 void writeTo(uint8_t *buf) override;
1039 bool isNeeded() const override;
1040 // Sort and remove duplicate entries.
1041 void finalizeContents() override;
1042 InputSection *getLinkOrderDep() const;
1043
1044 static bool classof(const SectionBase *d);
1045
1046 // Links to the ARMExidxSections so we can transfer the relocations once the
1047 // layout is known.
1048 std::vector<InputSection *> exidxSections;
1049
1050 private:
1051 size_t size = 0;
1052
1053 // Instead of storing pointers to the .ARM.exidx InputSections from
1054 // InputObjects, we store pointers to the executable sections that need
1055 // .ARM.exidx sections. We can then use the dependentSections of these to
1056 // either find the .ARM.exidx section or know that we need to generate one.
1057 std::vector<InputSection *> executableSections;
1058
1059 // The executable InputSection with the highest address to use for the
1060 // sentinel. We store separately from ExecutableSections as merging of
1061 // duplicate entries may mean this InputSection is removed from
1062 // ExecutableSections.
1063 InputSection *sentinel = nullptr;
1064 };
1065
1066 // A container for one or more linker generated thunks. Instances of these
1067 // thunks including ARM interworking and Mips LA25 PI to non-PI thunks.
1068 class ThunkSection : public SyntheticSection {
1069 public:
1070 // ThunkSection in OS, with desired outSecOff of Off
1071 ThunkSection(OutputSection *os, uint64_t off);
1072
1073 // Add a newly created Thunk to this container:
1074 // Thunk is given offset from start of this InputSection
1075 // Thunk defines a symbol in this InputSection that can be used as target
1076 // of a relocation
1077 void addThunk(Thunk *t);
1078 size_t getSize() const override;
1079 void writeTo(uint8_t *buf) override;
1080 InputSection *getTargetInputSection() const;
1081 bool assignOffsets();
1082
1083 // When true, round up reported size of section to 4 KiB. See comment
1084 // in addThunkSection() for more details.
1085 bool roundUpSizeForErrata = false;
1086
1087 private:
1088 std::vector<Thunk *> thunks;
1089 size_t size = 0;
1090 };
1091
1092 // Used to compute outSecOff of .got2 in each object file. This is needed to
1093 // synthesize PLT entries for PPC32 Secure PLT ABI.
1094 class PPC32Got2Section final : public SyntheticSection {
1095 public:
1096 PPC32Got2Section();
getSize()1097 size_t getSize() const override { return 0; }
1098 bool isNeeded() const override;
1099 void finalizeContents() override;
writeTo(uint8_t * buf)1100 void writeTo(uint8_t *buf) override {}
1101 };
1102
1103 // This section is used to store the addresses of functions that are called
1104 // in range-extending thunks on PowerPC64. When producing position dependent
1105 // code the addresses are link-time constants and the table is written out to
1106 // the binary. When producing position-dependent code the table is allocated and
1107 // filled in by the dynamic linker.
1108 class PPC64LongBranchTargetSection final : public SyntheticSection {
1109 public:
1110 PPC64LongBranchTargetSection();
1111 uint64_t getEntryVA(const Symbol *sym, int64_t addend);
1112 llvm::Optional<uint32_t> addEntry(const Symbol *sym, int64_t addend);
1113 size_t getSize() const override;
1114 void writeTo(uint8_t *buf) override;
1115 bool isNeeded() const override;
finalizeContents()1116 void finalizeContents() override { finalized = true; }
1117
1118 private:
1119 std::vector<std::pair<const Symbol *, int64_t>> entries;
1120 llvm::DenseMap<std::pair<const Symbol *, int64_t>, uint32_t> entry_index;
1121 bool finalized = false;
1122 };
1123
1124 // Can only be forward declared here since it depends on SyntheticSection
1125 template <class ELFT> class CheriCapRelocsSection;
1126 class CheriCapTableSection;
1127 class CheriCapTableMappingSection;
1128
1129 template <typename ELFT>
1130 class PartitionElfHeaderSection : public SyntheticSection {
1131 public:
1132 PartitionElfHeaderSection();
1133 size_t getSize() const override;
1134 void writeTo(uint8_t *buf) override;
1135 };
1136
1137 template <typename ELFT>
1138 class PartitionProgramHeadersSection : public SyntheticSection {
1139 public:
1140 PartitionProgramHeadersSection();
1141 size_t getSize() const override;
1142 void writeTo(uint8_t *buf) override;
1143 };
1144
1145 class PartitionIndexSection : public SyntheticSection {
1146 public:
1147 PartitionIndexSection();
1148 size_t getSize() const override;
1149 void finalizeContents() override;
1150 void writeTo(uint8_t *buf) override;
1151 };
1152
1153 InputSection *createInterpSection();
1154 MergeInputSection *createCommentSection();
1155 MergeSyntheticSection *createMergeSynthetic(StringRef name, uint32_t type,
1156 uint64_t flags, uint32_t alignment);
1157 template <class ELFT> void splitSections();
1158
1159 template <typename ELFT> void writeEhdr(uint8_t *buf, Partition &part);
1160 template <typename ELFT> void writePhdrs(uint8_t *buf, Partition &part);
1161
1162 Defined *addSyntheticLocal(StringRef name, uint8_t type, uint64_t value,
1163 uint64_t size, InputSectionBase §ion);
1164
1165 void addVerneed(Symbol *ss);
1166
1167 // Linker generated per-partition sections.
1168 struct Partition {
1169 StringRef name;
1170 uint64_t nameStrTab;
1171
1172 SyntheticSection *elfHeader;
1173 SyntheticSection *programHeaders;
1174 std::vector<PhdrEntry *> phdrs;
1175
1176 ARMExidxSyntheticSection *armExidx;
1177 BuildIdSection *buildId;
1178 SyntheticSection *dynamic;
1179 StringTableSection *dynStrTab;
1180 SymbolTableBaseSection *dynSymTab;
1181 EhFrameHeader *ehFrameHdr;
1182 EhFrameSection *ehFrame;
1183 GnuHashTableSection *gnuHashTab;
1184 HashTableSection *hashTab;
1185 RelocationBaseSection *relaDyn;
1186 RelrBaseSection *relrDyn;
1187 VersionDefinitionSection *verDef;
1188 SyntheticSection *verNeed;
1189 VersionTableSection *verSym;
1190
getNumberPartition1191 unsigned getNumber() const { return this - &partitions[0] + 1; }
1192 };
1193
1194 extern Partition *mainPart;
1195
getPartition()1196 inline Partition &SectionBase::getPartition() const {
1197 assert(isLive());
1198 return partitions[partition - 1];
1199 }
1200
1201 // Linker generated sections which can be used as inputs and are not specific to
1202 // a partition.
1203 struct InStruct {
1204 InputSection *attributes;
1205 BssSection *bss;
1206 BssSection *bssRelRo;
1207 GotSection *got;
1208 GotPltSection *gotPlt;
1209 IgotPltSection *igotPlt;
1210 CheriCapTableSection *cheriCapTable;
1211 // For per-file/per-function tables:
1212 CheriCapTableMappingSection *cheriCapTableMapping;
1213 PPC64LongBranchTargetSection *ppc64LongBranchTarget;
1214 MipsGotSection *mipsGot;
1215 MipsRldMapSection *mipsRldMap;
1216 SyntheticSection *partEnd;
1217 SyntheticSection *partIndex;
1218 PltSection *plt;
1219 IpltSection *iplt;
1220 PPC32Got2Section *ppc32Got2;
1221 IBTPltSection *ibtPlt;
1222 RelocationBaseSection *relaPlt;
1223 RelocationBaseSection *relaIplt;
1224 StringTableSection *shStrTab;
1225 StringTableSection *strTab;
1226 SymbolTableBaseSection *symTab;
1227 SymtabShndxSection *symTabShndx;
1228 };
1229
1230 extern InStruct in;
1231
1232 template <class ELFT> struct InX {
1233 // XXXAR: needs to be templated because writing depends on endianess
1234 // TODO: use the non-templated version
1235 static CheriCapRelocsSection<ELFT> *capRelocs;
1236 static MipsAbiFlagsSection<ELFT> *mipsAbiFlags;
1237 };
1238
1239 template <class ELFT> CheriCapRelocsSection<ELFT> *InX<ELFT>::capRelocs;
1240 template <class ELFT> MipsAbiFlagsSection<ELFT> *InX<ELFT>::mipsAbiFlags;
1241 } // namespace elf
1242 } // namespace lld
1243
1244 #endif
1245