contrib/llvm-project/lld/ELF/SyntheticSections.h

   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:
  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;
  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.
  53   virtual bool updateAllocSize() { return false; }
  54   virtual bool isNeeded() const { return true; }
  55
  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;
  72   bool isNeeded() const override { return !sections.empty(); }
  73   size_t getSize() const override { return size; }
  74
  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;
  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();
 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
 132   uint64_t getTlsIndexVA() { return this->getVA() + tlsIndexOff; }
 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:
 148   GnuStackSection()
 149       : SyntheticSection(0, llvm::ELF::SHT_PROGBITS, 1, ".note.GNU-stack") {}
 150   void writeTo(uint8_t *buf) override {}
 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;
 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);
 184   void writeTo(uint8_t *) override {
 185     llvm_unreachable("unexpected writeTo() call for SHT_NOBITS section");
 186   }
 187   bool isNeeded() const override { return size != 0; }
 188   size_t getSize() const override { return size; }
 189
 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;
 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;
 333       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   // ovwerflow 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;
 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;
 408   size_t getSize() const override { return size; }
 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:
 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.
 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 };
 456
 457 template <class ELFT> class DynamicSection final : public SyntheticSection {
 458   using Elf_Dyn = typename ELFT::Dyn;
 459   using Elf_Rel = typename ELFT::Rel;
 460   using Elf_Rela = typename ELFT::Rela;
 461   using Elf_Relr = typename ELFT::Relr;
 462   using Elf_Shdr = typename ELFT::Shdr;
 463   using Elf_Sym = typename ELFT::Sym;
 464
 465   // finalizeContents() fills this vector with the section contents.
 466   std::vector<std::pair<int32_t, std::function<uint64_t()>>> entries;
 467
 468 public:
 469   DynamicSection();
 470   void finalizeContents() override;
 471   void writeTo(uint8_t *buf) override;
 472   size_t getSize() const override { return size; }
 473
 474 private:
 475   void add(int32_t tag, std::function<uint64_t()> fn);
 476   void addInt(int32_t tag, uint64_t val);
 477   void addInSec(int32_t tag, InputSection *sec);
 478   void addInSecRelative(int32_t tag, InputSection *sec);
 479   void addOutSec(int32_t tag, OutputSection *sec);
 480   void addSize(int32_t tag, OutputSection *sec);
 481   void addSym(int32_t tag, Symbol *sym);
 482
 483   uint64_t size = 0;
 484 };
 485
 486 class RelocationBaseSection : public SyntheticSection {
 487 public:
 488   RelocationBaseSection(StringRef name, uint32_t type, int32_t dynamicTag,
 489                         int32_t sizeDynamicTag);
 490   void addReloc(RelType dynType, InputSectionBase *isec, uint64_t offsetInSec,
 491                 Symbol *sym);
 492   // Add a dynamic relocation that might need an addend. This takes care of
 493   // writing the addend to the output section if needed.
 494   void addReloc(RelType dynType, InputSectionBase *inputSec,
 495                 uint64_t offsetInSec, Symbol *sym, int64_t addend, RelExpr expr,
 496                 RelType type);
 497   void addReloc(const DynamicReloc &reloc);
 498   bool isNeeded() const override { return !relocs.empty(); }
 499   size_t getSize() const override { return relocs.size() * this->entsize; }
 500   size_t getRelativeRelocCount() const { return numRelativeRelocs; }
 501   void finalizeContents() override;
 502   int32_t dynamicTag, sizeDynamicTag;
 503   std::vector<DynamicReloc> relocs;
 504
 505 protected:
 506   size_t numRelativeRelocs = 0;
 507 };
 508
 509 template <class ELFT>
 510 class RelocationSection final : public RelocationBaseSection {
 511   using Elf_Rel = typename ELFT::Rel;
 512   using Elf_Rela = typename ELFT::Rela;
 513
 514 public:
 515   RelocationSection(StringRef name, bool sort);
 516   void writeTo(uint8_t *buf) override;
 517
 518 private:
 519   bool sort;
 520 };
 521
 522 template <class ELFT>
 523 class AndroidPackedRelocationSection final : public RelocationBaseSection {
 524   using Elf_Rel = typename ELFT::Rel;
 525   using Elf_Rela = typename ELFT::Rela;
 526
 527 public:
 528   AndroidPackedRelocationSection(StringRef name);
 529
 530   bool updateAllocSize() override;
 531   size_t getSize() const override { return relocData.size(); }
 532   void writeTo(uint8_t *buf) override {
 533     memcpy(buf, relocData.data(), relocData.size());
 534   }
 535
 536 private:
 537   SmallVector<char, 0> relocData;
 538 };
 539
 540 struct RelativeReloc {
 541   uint64_t getOffset() const { return inputSec->getVA(offsetInSec); }
 542
 543   const InputSectionBase *inputSec;
 544   uint64_t offsetInSec;
 545 };
 546
 547 class RelrBaseSection : public SyntheticSection {
 548 public:
 549   RelrBaseSection();
 550   bool isNeeded() const override { return !relocs.empty(); }
 551   std::vector<RelativeReloc> relocs;
 552 };
 553
 554 // RelrSection is used to encode offsets for relative relocations.
 555 // Proposal for adding SHT_RELR sections to generic-abi is here:
 556 //   https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
 557 // For more details, see the comment in RelrSection::updateAllocSize().
 558 template <class ELFT> class RelrSection final : public RelrBaseSection {
 559   using Elf_Relr = typename ELFT::Relr;
 560
 561 public:
 562   RelrSection();
 563
 564   bool updateAllocSize() override;
 565   size_t getSize() const override { return relrRelocs.size() * this->entsize; }
 566   void writeTo(uint8_t *buf) override {
 567     memcpy(buf, relrRelocs.data(), getSize());
 568   }
 569
 570 private:
 571   std::vector<Elf_Relr> relrRelocs;
 572 };
 573
 574 struct SymbolTableEntry {
 575   Symbol *sym;
 576   size_t strTabOffset;
 577 };
 578
 579 class SymbolTableBaseSection : public SyntheticSection {
 580 public:
 581   SymbolTableBaseSection(StringTableSection &strTabSec);
 582   void finalizeContents() override;
 583   size_t getSize() const override { return getNumSymbols() * entsize; }
 584   void addSymbol(Symbol *sym);
 585   unsigned getNumSymbols() const { return symbols.size() + 1; }
 586   size_t getSymbolIndex(Symbol *sym);
 587   ArrayRef<SymbolTableEntry> getSymbols() const { return symbols; }
 588
 589 protected:
 590   void sortSymTabSymbols();
 591
 592   // A vector of symbols and their string table offsets.
 593   std::vector<SymbolTableEntry> symbols;
 594
 595   StringTableSection &strTabSec;
 596
 597   llvm::once_flag onceFlag;
 598   llvm::DenseMap<Symbol *, size_t> symbolIndexMap;
 599   llvm::DenseMap<OutputSection *, size_t> sectionIndexMap;
 600 };
 601
 602 template <class ELFT>
 603 class SymbolTableSection final : public SymbolTableBaseSection {
 604   using Elf_Sym = typename ELFT::Sym;
 605
 606 public:
 607   SymbolTableSection(StringTableSection &strTabSec);
 608   void writeTo(uint8_t *buf) override;
 609 };
 610
 611 class SymtabShndxSection final : public SyntheticSection {
 612 public:
 613   SymtabShndxSection();
 614
 615   void writeTo(uint8_t *buf) override;
 616   size_t getSize() const override;
 617   bool isNeeded() const override;
 618   void finalizeContents() override;
 619 };
 620
 621 // Outputs GNU Hash section. For detailed explanation see:
 622 // https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections
 623 class GnuHashTableSection final : public SyntheticSection {
 624 public:
 625   GnuHashTableSection();
 626   void finalizeContents() override;
 627   void writeTo(uint8_t *buf) override;
 628   size_t getSize() const override { return size; }
 629
 630   // Adds symbols to the hash table.
 631   // Sorts the input to satisfy GNU hash section requirements.
 632   void addSymbols(std::vector<SymbolTableEntry> &symbols);
 633
 634 private:
 635   // See the comment in writeBloomFilter.
 636   enum { Shift2 = 26 };
 637
 638   void writeBloomFilter(uint8_t *buf);
 639   void writeHashTable(uint8_t *buf);
 640
 641   struct Entry {
 642     Symbol *sym;
 643     size_t strTabOffset;
 644     uint32_t hash;
 645     uint32_t bucketIdx;
 646   };
 647
 648   std::vector<Entry> symbols;
 649   size_t maskWords;
 650   size_t nBuckets = 0;
 651   size_t size = 0;
 652 };
 653
 654 class HashTableSection final : public SyntheticSection {
 655 public:
 656   HashTableSection();
 657   void finalizeContents() override;
 658   void writeTo(uint8_t *buf) override;
 659   size_t getSize() const override { return size; }
 660
 661 private:
 662   size_t size = 0;
 663 };
 664
 665 // Used for PLT entries. It usually has a PLT header for lazy binding. Each PLT
 666 // entry is associated with a JUMP_SLOT relocation, which may be resolved lazily
 667 // at runtime.
 668 //
 669 // On PowerPC, this section contains lazy symbol resolvers. A branch instruction
 670 // jumps to a PLT call stub, which will then jump to the target (BIND_NOW) or a
 671 // lazy symbol resolver.
 672 //
 673 // On x86 when IBT is enabled, this section (.plt.sec) contains PLT call stubs.
 674 // A call instruction jumps to a .plt.sec entry, which will then jump to the
 675 // target (BIND_NOW) or a .plt entry.
 676 class PltSection : public SyntheticSection {
 677 public:
 678   PltSection();
 679   void writeTo(uint8_t *buf) override;
 680   size_t getSize() const override;
 681   bool isNeeded() const override;
 682   void addSymbols();
 683   void addEntry(Symbol &sym);
 684   size_t getNumEntries() const { return entries.size(); }
 685
 686   size_t headerSize;
 687
 688   std::vector<const Symbol *> entries;
 689 };
 690
 691 // Used for non-preemptible ifuncs. It does not have a header. Each entry is
 692 // associated with an IRELATIVE relocation, which will be resolved eagerly at
 693 // runtime. PltSection can only contain entries associated with JUMP_SLOT
 694 // relocations, so IPLT entries are in a separate section.
 695 class IpltSection final : public SyntheticSection {
 696   std::vector<const Symbol *> entries;
 697
 698 public:
 699   IpltSection();
 700   void writeTo(uint8_t *buf) override;
 701   size_t getSize() const override;
 702   bool isNeeded() const override { return !entries.empty(); }
 703   void addSymbols();
 704   void addEntry(Symbol &sym);
 705 };
 706
 707 class PPC32GlinkSection : public PltSection {
 708 public:
 709   PPC32GlinkSection();
 710   void writeTo(uint8_t *buf) override;
 711   size_t getSize() const override;
 712
 713   std::vector<const Symbol *> canonical_plts;
 714   static constexpr size_t footerSize = 64;
 715 };
 716
 717 // This is x86-only.
 718 class IBTPltSection : public SyntheticSection {
 719 public:
 720   IBTPltSection();
 721   void writeTo(uint8_t *Buf) override;
 722   size_t getSize() const override;
 723 };
 724
 725 class GdbIndexSection final : public SyntheticSection {
 726 public:
 727   struct AddressEntry {
 728     InputSection *section;
 729     uint64_t lowAddress;
 730     uint64_t highAddress;
 731     uint32_t cuIndex;
 732   };
 733
 734   struct CuEntry {
 735     uint64_t cuOffset;
 736     uint64_t cuLength;
 737   };
 738
 739   struct NameAttrEntry {
 740     llvm::CachedHashStringRef name;
 741     uint32_t cuIndexAndAttrs;
 742   };
 743
 744   struct GdbChunk {
 745     InputSection *sec;
 746     std::vector<AddressEntry> addressAreas;
 747     std::vector<CuEntry> compilationUnits;
 748   };
 749
 750   struct GdbSymbol {
 751     llvm::CachedHashStringRef name;
 752     std::vector<uint32_t> cuVector;
 753     uint32_t nameOff;
 754     uint32_t cuVectorOff;
 755   };
 756
 757   GdbIndexSection();
 758   template <typename ELFT> static GdbIndexSection *create();
 759   void writeTo(uint8_t *buf) override;
 760   size_t getSize() const override { return size; }
 761   bool isNeeded() const override;
 762
 763 private:
 764   struct GdbIndexHeader {
 765     llvm::support::ulittle32_t version;
 766     llvm::support::ulittle32_t cuListOff;
 767     llvm::support::ulittle32_t cuTypesOff;
 768     llvm::support::ulittle32_t addressAreaOff;
 769     llvm::support::ulittle32_t symtabOff;
 770     llvm::support::ulittle32_t constantPoolOff;
 771   };
 772
 773   void initOutputSize();
 774   size_t computeSymtabSize() const;
 775
 776   // Each chunk contains information gathered from debug sections of a
 777   // single object file.
 778   std::vector<GdbChunk> chunks;
 779
 780   // A symbol table for this .gdb_index section.
 781   std::vector<GdbSymbol> symbols;
 782
 783   size_t size;
 784 };
 785
 786 // --eh-frame-hdr option tells linker to construct a header for all the
 787 // .eh_frame sections. This header is placed to a section named .eh_frame_hdr
 788 // and also to a PT_GNU_EH_FRAME segment.
 789 // At runtime the unwinder then can find all the PT_GNU_EH_FRAME segments by
 790 // calling dl_iterate_phdr.
 791 // This section contains a lookup table for quick binary search of FDEs.
 792 // Detailed info about internals can be found in Ian Lance Taylor's blog:
 793 // http://www.airs.com/blog/archives/460 (".eh_frame")
 794 // http://www.airs.com/blog/archives/462 (".eh_frame_hdr")
 795 class EhFrameHeader final : public SyntheticSection {
 796 public:
 797   EhFrameHeader();
 798   void write();
 799   void writeTo(uint8_t *buf) override;
 800   size_t getSize() const override;
 801   bool isNeeded() const override;
 802 };
 803
 804 // For more information about .gnu.version and .gnu.version_r see:
 805 // https://www.akkadia.org/drepper/symbol-versioning
 806
 807 // The .gnu.version_d section which has a section type of SHT_GNU_verdef shall
 808 // contain symbol version definitions. The number of entries in this section
 809 // shall be contained in the DT_VERDEFNUM entry of the .dynamic section.
 810 // The section shall contain an array of Elf_Verdef structures, optionally
 811 // followed by an array of Elf_Verdaux structures.
 812 class VersionDefinitionSection final : public SyntheticSection {
 813 public:
 814   VersionDefinitionSection();
 815   void finalizeContents() override;
 816   size_t getSize() const override;
 817   void writeTo(uint8_t *buf) override;
 818
 819 private:
 820   enum { EntrySize = 28 };
 821   void writeOne(uint8_t *buf, uint32_t index, StringRef name, size_t nameOff);
 822   StringRef getFileDefName();
 823
 824   unsigned fileDefNameOff;
 825   std::vector<unsigned> verDefNameOffs;
 826 };
 827
 828 // The .gnu.version section specifies the required version of each symbol in the
 829 // dynamic symbol table. It contains one Elf_Versym for each dynamic symbol
 830 // table entry. An Elf_Versym is just a 16-bit integer that refers to a version
 831 // identifier defined in the either .gnu.version_r or .gnu.version_d section.
 832 // The values 0 and 1 are reserved. All other values are used for versions in
 833 // the own object or in any of the dependencies.
 834 class VersionTableSection final : public SyntheticSection {
 835 public:
 836   VersionTableSection();
 837   void finalizeContents() override;
 838   size_t getSize() const override;
 839   void writeTo(uint8_t *buf) override;
 840   bool isNeeded() const override;
 841 };
 842
 843 // The .gnu.version_r section defines the version identifiers used by
 844 // .gnu.version. It contains a linked list of Elf_Verneed data structures. Each
 845 // Elf_Verneed specifies the version requirements for a single DSO, and contains
 846 // a reference to a linked list of Elf_Vernaux data structures which define the
 847 // mapping from version identifiers to version names.
 848 template <class ELFT>
 849 class VersionNeedSection final : public SyntheticSection {
 850   using Elf_Verneed = typename ELFT::Verneed;
 851   using Elf_Vernaux = typename ELFT::Vernaux;
 852
 853   struct Vernaux {
 854     uint64_t hash;
 855     uint32_t verneedIndex;
 856     uint64_t nameStrTab;
 857   };
 858
 859   struct Verneed {
 860     uint64_t nameStrTab;
 861     std::vector<Vernaux> vernauxs;
 862   };
 863
 864   std::vector<Verneed> verneeds;
 865
 866 public:
 867   VersionNeedSection();
 868   void finalizeContents() override;
 869   void writeTo(uint8_t *buf) override;
 870   size_t getSize() const override;
 871   bool isNeeded() const override;
 872 };
 873
 874 // MergeSyntheticSection is a class that allows us to put mergeable sections
 875 // with different attributes in a single output sections. To do that
 876 // we put them into MergeSyntheticSection synthetic input sections which are
 877 // attached to regular output sections.
 878 class MergeSyntheticSection : public SyntheticSection {
 879 public:
 880   void addSection(MergeInputSection *ms);
 881   std::vector<MergeInputSection *> sections;
 882
 883 protected:
 884   MergeSyntheticSection(StringRef name, uint32_t type, uint64_t flags,
 885                         uint32_t alignment)
 886       : SyntheticSection(flags, type, alignment, name) {}
 887 };
 888
 889 class MergeTailSection final : public MergeSyntheticSection {
 890 public:
 891   MergeTailSection(StringRef name, uint32_t type, uint64_t flags,
 892                    uint32_t alignment);
 893
 894   size_t getSize() const override;
 895   void writeTo(uint8_t *buf) override;
 896   void finalizeContents() override;
 897
 898 private:
 899   llvm::StringTableBuilder builder;
 900 };
 901
 902 class MergeNoTailSection final : public MergeSyntheticSection {
 903 public:
 904   MergeNoTailSection(StringRef name, uint32_t type, uint64_t flags,
 905                      uint32_t alignment)
 906       : MergeSyntheticSection(name, type, flags, alignment) {}
 907
 908   size_t getSize() const override { return size; }
 909   void writeTo(uint8_t *buf) override;
 910   void finalizeContents() override;
 911
 912 private:
 913   // We use the most significant bits of a hash as a shard ID.
 914   // The reason why we don't want to use the least significant bits is
 915   // because DenseMap also uses lower bits to determine a bucket ID.
 916   // If we use lower bits, it significantly increases the probability of
 917   // hash collisons.
 918   size_t getShardId(uint32_t hash) {
 919     assert((hash >> 31) == 0);
 920     return hash >> (31 - llvm::countTrailingZeros(numShards));
 921   }
 922
 923   // Section size
 924   size_t size;
 925
 926   // String table contents
 927   constexpr static size_t numShards = 32;
 928   std::vector<llvm::StringTableBuilder> shards;
 929   size_t shardOffsets[numShards];
 930 };
 931
 932 // .MIPS.abiflags section.
 933 template <class ELFT>
 934 class MipsAbiFlagsSection final : public SyntheticSection {
 935   using Elf_Mips_ABIFlags = llvm::object::Elf_Mips_ABIFlags<ELFT>;
 936
 937 public:
 938   static MipsAbiFlagsSection *create();
 939
 940   MipsAbiFlagsSection(Elf_Mips_ABIFlags flags);
 941   size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
 942   void writeTo(uint8_t *buf) override;
 943
 944 private:
 945   Elf_Mips_ABIFlags flags;
 946 };
 947
 948 // .MIPS.options section.
 949 template <class ELFT> class MipsOptionsSection final : public SyntheticSection {
 950   using Elf_Mips_Options = llvm::object::Elf_Mips_Options<ELFT>;
 951   using Elf_Mips_RegInfo = llvm::object::Elf_Mips_RegInfo<ELFT>;
 952
 953 public:
 954   static MipsOptionsSection *create();
 955
 956   MipsOptionsSection(Elf_Mips_RegInfo reginfo);
 957   void writeTo(uint8_t *buf) override;
 958
 959   size_t getSize() const override {
 960     return sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
 961   }
 962
 963 private:
 964   Elf_Mips_RegInfo reginfo;
 965 };
 966
 967 // MIPS .reginfo section.
 968 template <class ELFT> class MipsReginfoSection final : public SyntheticSection {
 969   using Elf_Mips_RegInfo = llvm::object::Elf_Mips_RegInfo<ELFT>;
 970
 971 public:
 972   static MipsReginfoSection *create();
 973
 974   MipsReginfoSection(Elf_Mips_RegInfo reginfo);
 975   size_t getSize() const override { return sizeof(Elf_Mips_RegInfo); }
 976   void writeTo(uint8_t *buf) override;
 977
 978 private:
 979   Elf_Mips_RegInfo reginfo;
 980 };
 981
 982 // This is a MIPS specific section to hold a space within the data segment
 983 // of executable file which is pointed to by the DT_MIPS_RLD_MAP entry.
 984 // See "Dynamic section" in Chapter 5 in the following document:
 985 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 986 class MipsRldMapSection : public SyntheticSection {
 987 public:
 988   MipsRldMapSection();
 989   size_t getSize() const override { return config->wordsize; }
 990   void writeTo(uint8_t *buf) override {}
 991 };
 992
 993 // Representation of the combined .ARM.Exidx input sections. We process these
 994 // as a SyntheticSection like .eh_frame as we need to merge duplicate entries
 995 // and add terminating sentinel entries.
 996 //
 997 // The .ARM.exidx input sections after SHF_LINK_ORDER processing is done form
 998 // a table that the unwinder can derive (Addresses are encoded as offsets from
 999 // table):
1000 // | Address of function | Unwind instructions for function |
1001 // where the unwind instructions are either a small number of unwind or the
1002 // special EXIDX_CANTUNWIND entry representing no unwinding information.
1003 // When an exception is thrown from an address A, the unwinder searches the
1004 // table for the closest table entry with Address of function <= A. This means
1005 // that for two consecutive table entries:
1006 // | A1 | U1 |
1007 // | A2 | U2 |
1008 // The range of addresses described by U1 is [A1, A2)
1009 //
1010 // There are two cases where we need a linker generated table entry to fixup
1011 // the address ranges in the table
1012 // Case 1:
1013 // - A sentinel entry added with an address higher than all
1014 // executable sections. This was needed to work around libunwind bug pr31091.
1015 // - After address assignment we need to find the highest addressed executable
1016 // section and use the limit of that section so that the unwinder never
1017 // matches it.
1018 // Case 2:
1019 // - InputSections without a .ARM.exidx section (usually from Assembly)
1020 // need a table entry so that they terminate the range of the previously
1021 // function. This is pr40277.
1022 //
1023 // Instead of storing pointers to the .ARM.exidx InputSections from
1024 // InputObjects, we store pointers to the executable sections that need
1025 // .ARM.exidx sections. We can then use the dependentSections of these to
1026 // either find the .ARM.exidx section or know that we need to generate one.
1027 class ARMExidxSyntheticSection : public SyntheticSection {
1028 public:
1029   ARMExidxSyntheticSection();
1030
1031   // Add an input section to the ARMExidxSyntheticSection. Returns whether the
1032   // section needs to be removed from the main input section list.
1033   bool addSection(InputSection *isec);
1034
1035   size_t getSize() const override { return size; }
1036   void writeTo(uint8_t *buf) override;
1037   bool isNeeded() const override;
1038   // Sort and remove duplicate entries.
1039   void finalizeContents() override;
1040   InputSection *getLinkOrderDep() const;
1041
1042   static bool classof(const SectionBase *d);
1043
1044   // Links to the ARMExidxSections so we can transfer the relocations once the
1045   // layout is known.
1046   std::vector<InputSection *> exidxSections;
1047
1048 private:
1049   size_t size;
1050
1051   // Instead of storing pointers to the .ARM.exidx InputSections from
1052   // InputObjects, we store pointers to the executable sections that need
1053   // .ARM.exidx sections. We can then use the dependentSections of these to
1054   // either find the .ARM.exidx section or know that we need to generate one.
1055   std::vector<InputSection *> executableSections;
1056
1057   // The executable InputSection with the highest address to use for the
1058   // sentinel. We store separately from ExecutableSections as merging of
1059   // duplicate entries may mean this InputSection is removed from
1060   // ExecutableSections.
1061   InputSection *sentinel = nullptr;
1062 };
1063
1064 // A container for one or more linker generated thunks. Instances of these
1065 // thunks including ARM interworking and Mips LA25 PI to non-PI thunks.
1066 class ThunkSection : public SyntheticSection {
1067 public:
1068   // ThunkSection in OS, with desired outSecOff of Off
1069   ThunkSection(OutputSection *os, uint64_t off);
1070
1071   // Add a newly created Thunk to this container:
1072   // Thunk is given offset from start of this InputSection
1073   // Thunk defines a symbol in this InputSection that can be used as target
1074   // of a relocation
1075   void addThunk(Thunk *t);
1076   size_t getSize() const override;
1077   void writeTo(uint8_t *buf) override;
1078   InputSection *getTargetInputSection() const;
1079   bool assignOffsets();
1080
1081   // When true, round up reported size of section to 4 KiB. See comment
1082   // in addThunkSection() for more details.
1083   bool roundUpSizeForErrata = false;
1084
1085 private:
1086   std::vector<Thunk *> thunks;
1087   size_t size = 0;
1088 };
1089
1090 // Used to compute outSecOff of .got2 in each object file. This is needed to
1091 // synthesize PLT entries for PPC32 Secure PLT ABI.
1092 class PPC32Got2Section final : public SyntheticSection {
1093 public:
1094   PPC32Got2Section();
1095   size_t getSize() const override { return 0; }
1096   bool isNeeded() const override;
1097   void finalizeContents() override;
1098   void writeTo(uint8_t *buf) override {}
1099 };
1100
1101 // This section is used to store the addresses of functions that are called
1102 // in range-extending thunks on PowerPC64. When producing position dependent
1103 // code the addresses are link-time constants and the table is written out to
1104 // the binary. When producing position-dependent code the table is allocated and
1105 // filled in by the dynamic linker.
1106 class PPC64LongBranchTargetSection final : public SyntheticSection {
1107 public:
1108   PPC64LongBranchTargetSection();
1109   uint64_t getEntryVA(const Symbol *sym, int64_t addend);
1110   llvm::Optional<uint32_t> addEntry(const Symbol *sym, int64_t addend);
1111   size_t getSize() const override;
1112   void writeTo(uint8_t *buf) override;
1113   bool isNeeded() const override;
1114   void finalizeContents() override { finalized = true; }
1115
1116 private:
1117   std::vector<std::pair<const Symbol *, int64_t>> entries;
1118   llvm::DenseMap<std::pair<const Symbol *, int64_t>, uint32_t> entry_index;
1119   bool finalized = false;
1120 };
1121
1122 template <typename ELFT>
1123 class PartitionElfHeaderSection : public SyntheticSection {
1124 public:
1125   PartitionElfHeaderSection();
1126   size_t getSize() const override;
1127   void writeTo(uint8_t *buf) override;
1128 };
1129
1130 template <typename ELFT>
1131 class PartitionProgramHeadersSection : public SyntheticSection {
1132 public:
1133   PartitionProgramHeadersSection();
1134   size_t getSize() const override;
1135   void writeTo(uint8_t *buf) override;
1136 };
1137
1138 class PartitionIndexSection : public SyntheticSection {
1139 public:
1140   PartitionIndexSection();
1141   size_t getSize() const override;
1142   void finalizeContents() override;
1143   void writeTo(uint8_t *buf) override;
1144 };
1145
1146 InputSection *createInterpSection();
1147 MergeInputSection *createCommentSection();
1148 MergeSyntheticSection *createMergeSynthetic(StringRef name, uint32_t type,
1149                                             uint64_t flags, uint32_t alignment);
1150 template <class ELFT> void splitSections();
1151
1152 template <typename ELFT> void writeEhdr(uint8_t *buf, Partition &part);
1153 template <typename ELFT> void writePhdrs(uint8_t *buf, Partition &part);
1154
1155 Defined *addSyntheticLocal(StringRef name, uint8_t type, uint64_t value,
1156                            uint64_t size, InputSectionBase &section);
1157
1158 void addVerneed(Symbol *ss);
1159
1160 // Linker generated per-partition sections.
1161 struct Partition {
1162   StringRef name;
1163   uint64_t nameStrTab;
1164
1165   SyntheticSection *elfHeader;
1166   SyntheticSection *programHeaders;
1167   std::vector<PhdrEntry *> phdrs;
1168
1169   ARMExidxSyntheticSection *armExidx;
1170   BuildIdSection *buildId;
1171   SyntheticSection *dynamic;
1172   StringTableSection *dynStrTab;
1173   SymbolTableBaseSection *dynSymTab;
1174   EhFrameHeader *ehFrameHdr;
1175   EhFrameSection *ehFrame;
1176   GnuHashTableSection *gnuHashTab;
1177   HashTableSection *hashTab;
1178   RelocationBaseSection *relaDyn;
1179   RelrBaseSection *relrDyn;
1180   VersionDefinitionSection *verDef;
1181   SyntheticSection *verNeed;
1182   VersionTableSection *verSym;
1183
1184   unsigned getNumber() const { return this - &partitions[0] + 1; }
1185 };
1186
1187 extern Partition *mainPart;
1188
1189 inline Partition &SectionBase::getPartition() const {
1190   assert(isLive());
1191   return partitions[partition - 1];
1192 }
1193
1194 // Linker generated sections which can be used as inputs and are not specific to
1195 // a partition.
1196 struct InStruct {
1197   InputSection *armAttributes;
1198   BssSection *bss;
1199   BssSection *bssRelRo;
1200   GotSection *got;
1201   GotPltSection *gotPlt;
1202   IgotPltSection *igotPlt;
1203   PPC64LongBranchTargetSection *ppc64LongBranchTarget;
1204   MipsGotSection *mipsGot;
1205   MipsRldMapSection *mipsRldMap;
1206   SyntheticSection *partEnd;
1207   SyntheticSection *partIndex;
1208   PltSection *plt;
1209   IpltSection *iplt;
1210   PPC32Got2Section *ppc32Got2;
1211   IBTPltSection *ibtPlt;
1212   RelocationBaseSection *relaPlt;
1213   RelocationBaseSection *relaIplt;
1214   StringTableSection *shStrTab;
1215   StringTableSection *strTab;
1216   SymbolTableBaseSection *symTab;
1217   SymtabShndxSection *symTabShndx;
1218 };
1219
1220 extern InStruct in;
1221
1222 } // namespace elf
1223 } // namespace lld
1224
1225 #endif