lld/ELF/OutputSections.h

   1 //===- OutputSections.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 #ifndef LLD_ELF_OUTPUT_SECTIONS_H
  10 #define LLD_ELF_OUTPUT_SECTIONS_H
  11
  12 #include "InputSection.h"
  13 #include "LinkerScript.h"
  14 #include "lld/Common/LLVM.h"
  15 #include "llvm/Support/Compiler.h"
  16 #include "llvm/Support/Parallel.h"
  17
  18 #include <array>
  19
  20 namespace lld::elf {
  21
  22 struct PhdrEntry;
  23
  24 struct CompressedData {
  25   std::unique_ptr<SmallVector<uint8_t, 0>[]> shards;
  26   uint32_t type = 0;
  27   uint32_t numShards = 0;
  28   uint32_t checksum = 0;
  29   uint64_t uncompressedSize;
  30 };
  31
  32 // This represents a section in an output file.
  33 // It is composed of multiple InputSections.
  34 // The writer creates multiple OutputSections and assign them unique,
  35 // non-overlapping file offsets and VAs.
  36 class OutputSection final : public SectionBase {
  37 public:
  38   OutputSection(Ctx &, StringRef name, uint32_t type, uint64_t flags);
  39
  40   static bool classof(const SectionBase *s) {
  41     return s->kind() == SectionBase::Output;
  42   }
  43
  44   uint64_t getLMA() const;
  45   template <typename ELFT> void writeHeaderTo(typename ELFT::Shdr *sHdr);
  46
  47   Ctx &ctx;
  48   uint32_t sectionIndex = UINT32_MAX;
  49   unsigned sortRank;
  50
  51   uint32_t getPhdrFlags() const;
  52
  53   // Pointer to the PT_LOAD segment, which this section resides in. This field
  54   // is used to correctly compute file offset of a section. When two sections
  55   // share the same load segment, difference between their file offsets should
  56   // be equal to difference between their virtual addresses. To compute some
  57   // section offset we use the following formula: Off = Off_first + VA -
  58   // VA_first, where Off_first and VA_first is file offset and VA of first
  59   // section in PT_LOAD.
  60   PhdrEntry *ptLoad = nullptr;
  61
  62   // Pointer to a relocation section for this section. Usually nullptr because
  63   // we consume relocations, but if --emit-relocs is specified (which is rare),
  64   // it may have a non-null value.
  65   OutputSection *relocationSection = nullptr;
  66
  67   // Initially this field is the number of InputSections that have been added to
  68   // the OutputSection so far. Later on, after a call to assignAddresses, it
  69   // corresponds to the Elf_Shdr member.
  70   uint64_t size = 0;
  71
  72   // The following fields correspond to Elf_Shdr members.
  73   uint64_t offset = 0;
  74   uint64_t addr = 0;
  75   uint32_t shName = 0;
  76
  77   void recordSection(InputSectionBase *isec);
  78   void commitSection(InputSection *isec);
  79   void finalizeInputSections();
  80
  81   // The following members are normally only used in linker scripts.
  82   MemoryRegion *memRegion = nullptr;
  83   MemoryRegion *lmaRegion = nullptr;
  84   Expr addrExpr;
  85   Expr alignExpr;
  86   Expr lmaExpr;
  87   Expr subalignExpr;
  88
  89   // Used by non-alloc SHT_CREL to hold the header and content byte stream.
  90   uint64_t crelHeader = 0;
  91   SmallVector<char, 0> crelBody;
  92
  93   SmallVector<SectionCommand *, 0> commands;
  94   SmallVector<StringRef, 0> phdrs;
  95   std::optional<std::array<uint8_t, 4>> filler;
  96   ConstraintKind constraint = ConstraintKind::NoConstraint;
  97   std::string location;
  98   std::string memoryRegionName;
  99   std::string lmaRegionName;
 100   bool nonAlloc = false;
 101   bool typeIsSet = false;
 102   bool expressionsUseSymbols = false;
 103   bool usedInExpression = false;
 104   bool inOverlay = false;
 105
 106   // Tracks whether the section has ever had an input section added to it, even
 107   // if the section was later removed (e.g. because it is a synthetic section
 108   // that wasn't needed). This is needed for orphan placement.
 109   bool hasInputSections = false;
 110
 111   // The output section description is specified between DATA_SEGMENT_ALIGN and
 112   // DATA_RELRO_END.
 113   bool relro = false;
 114
 115   template <bool is64> void finalizeNonAllocCrel(Ctx &);
 116   void finalize(Ctx &);
 117   template <class ELFT>
 118   void writeTo(Ctx &, uint8_t *buf, llvm::parallel::TaskGroup &tg);
 119   // Check that the addends for dynamic relocations were written correctly.
 120   void checkDynRelAddends(Ctx &);
 121   template <class ELFT> void maybeCompress(Ctx &);
 122
 123   void sort(llvm::function_ref<int(InputSectionBase *s)> order);
 124   void sortInitFini();
 125   void sortCtorsDtors();
 126
 127   // Used for implementation of --compress-debug-sections and
 128   // --compress-sections.
 129   CompressedData compressed;
 130
 131 private:
 132   SmallVector<InputSection *, 0> storage;
 133
 134   std::array<uint8_t, 4> getFiller(Ctx &);
 135 };
 136
 137 struct OutputDesc final : SectionCommand {
 138   OutputSection osec;
 139   OutputDesc(Ctx &ctx, StringRef name, uint32_t type, uint64_t flags)
 140       : SectionCommand(OutputSectionKind), osec(ctx, name, type, flags) {}
 141
 142   static bool classof(const SectionCommand *c) {
 143     return c->kind == OutputSectionKind;
 144   }
 145 };
 146
 147 // This represents a CLASS(class_name) { ... } that can be referenced by output
 148 // section descriptions. If referenced more than once, the sections can be
 149 // spilled to the next reference like --enable-non-contiguous-regions.
 150 struct SectionClass final : public SectionBase {
 151   SmallVector<InputSectionDescription *, 0> commands;
 152   bool assigned = false;
 153
 154   SectionClass(StringRef name)
 155       : SectionBase(Class, nullptr, name, 0, 0, 0, 0, 0, 0) {}
 156   static bool classof(const SectionBase *s) { return s->kind() == Class; }
 157 };
 158
 159 struct SectionClassDesc : SectionCommand {
 160   SectionClass sc;
 161
 162   SectionClassDesc(StringRef name) : SectionCommand(ClassKind), sc(name) {}
 163
 164   static bool classof(const SectionCommand *c) { return c->kind == ClassKind; }
 165 };
 166
 167 int getPriority(StringRef s);
 168
 169 InputSection *getFirstInputSection(const OutputSection *os);
 170 llvm::ArrayRef<InputSection *>
 171 getInputSections(const OutputSection &os,
 172                  SmallVector<InputSection *, 0> &storage);
 173
 174 uint64_t getHeaderSize(Ctx &);
 175 } // namespace lld::elf
 176
 177 #endif