lld/MachO/OutputSegment.cpp

   1 //===- OutputSegment.cpp --------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "OutputSegment.h"
  10 #include "ConcatOutputSection.h"
  11 #include "InputSection.h"
  12 #include "Symbols.h"
  13 #include "SyntheticSections.h"
  14
  15 #include "lld/Common/ErrorHandler.h"
  16 #include "lld/Common/Memory.h"
  17 #include "llvm/ADT/StringSwitch.h"
  18 #include "llvm/BinaryFormat/MachO.h"
  19
  20 using namespace llvm;
  21 using namespace llvm::MachO;
  22 using namespace lld;
  23 using namespace lld::macho;
  24
  25 static uint32_t initProt(StringRef name) {
  26   auto it = find_if(
  27       config->segmentProtections,
  28       [&](const SegmentProtection &segprot) { return segprot.name == name; });
  29   if (it != config->segmentProtections.end())
  30     return it->initProt;
  31
  32   if (name == segment_names::text)
  33     return VM_PROT_READ | VM_PROT_EXECUTE;
  34   if (name == segment_names::pageZero)
  35     return 0;
  36   if (name == segment_names::linkEdit)
  37     return VM_PROT_READ;
  38   return VM_PROT_READ | VM_PROT_WRITE;
  39 }
  40
  41 static uint32_t maxProt(StringRef name) {
  42   assert(config->arch() != AK_i386 &&
  43          "TODO: i386 has different maxProt requirements");
  44   return initProt(name);
  45 }
  46
  47 static uint32_t flags(StringRef name) {
  48   // If we ever implement shared cache output support, SG_READ_ONLY should not
  49   // be used for dylibs that can be placed in it.
  50   return name == segment_names::dataConst ? (uint32_t)SG_READ_ONLY : 0;
  51 }
  52
  53 size_t OutputSegment::numNonHiddenSections() const {
  54   size_t count = 0;
  55   for (const OutputSection *osec : sections)
  56     count += (!osec->isHidden() ? 1 : 0);
  57   return count;
  58 }
  59
  60 void OutputSegment::addOutputSection(OutputSection *osec) {
  61   inputOrder = std::min(inputOrder, osec->inputOrder);
  62
  63   osec->parent = this;
  64   sections.push_back(osec);
  65
  66   for (const SectionAlign &sectAlign : config->sectionAlignments)
  67     if (sectAlign.segName == name && sectAlign.sectName == osec->name)
  68       osec->align = sectAlign.align;
  69 }
  70
  71 template <typename T, typename F> static auto compareByOrder(F ord) {
  72   return [=](T a, T b) { return ord(a) < ord(b); };
  73 }
  74
  75 static int segmentOrder(OutputSegment *seg) {
  76   return StringSwitch<int>(seg->name)
  77       .Case(segment_names::pageZero, -4)
  78       .Case(segment_names::text, -3)
  79       .Case(segment_names::dataConst, -2)
  80       .Case(segment_names::data, -1)
  81       .Case(segment_names::llvm, std::numeric_limits<int>::max() - 1)
  82       // Make sure __LINKEDIT is the last segment (i.e. all its hidden
  83       // sections must be ordered after other sections).
  84       .Case(segment_names::linkEdit, std::numeric_limits<int>::max())
  85       .Default(seg->inputOrder);
  86 }
  87
  88 static int sectionOrder(OutputSection *osec) {
  89   StringRef segname = osec->parent->name;
  90   // Sections are uniquely identified by their segment + section name.
  91   if (segname == segment_names::text) {
  92     return StringSwitch<int>(osec->name)
  93         .Case(section_names::header, -6)
  94         .Case(section_names::text, -5)
  95         .Case(section_names::stubs, -4)
  96         .Case(section_names::stubHelper, -3)
  97         .Case(section_names::objcStubs, -2)
  98         .Case(section_names::initOffsets, -1)
  99         .Case(section_names::unwindInfo, std::numeric_limits<int>::max() - 1)
 100         .Case(section_names::ehFrame, std::numeric_limits<int>::max())
 101         .Default(osec->inputOrder);
 102   } else if (segname == segment_names::data ||
 103              segname == segment_names::dataConst) {
 104     // For each thread spawned, dyld will initialize its TLVs by copying the
 105     // address range from the start of the first thread-local data section to
 106     // the end of the last one. We therefore arrange these sections contiguously
 107     // to minimize the amount of memory used. Additionally, since zerofill
 108     // sections must be at the end of their segments, and since TLV data
 109     // sections can be zerofills, we end up putting all TLV data sections at the
 110     // end of the segment.
 111     switch (sectionType(osec->flags)) {
 112     case S_THREAD_LOCAL_VARIABLE_POINTERS:
 113       return std::numeric_limits<int>::max() - 3;
 114     case S_THREAD_LOCAL_REGULAR:
 115       return std::numeric_limits<int>::max() - 2;
 116     case S_THREAD_LOCAL_ZEROFILL:
 117       return std::numeric_limits<int>::max() - 1;
 118     case S_ZEROFILL:
 119       return std::numeric_limits<int>::max();
 120     default:
 121       return StringSwitch<int>(osec->name)
 122           .Case(section_names::got, -3)
 123           .Case(section_names::lazySymbolPtr, -2)
 124           .Case(section_names::const_, -1)
 125           .Default(osec->inputOrder);
 126     }
 127   } else if (segname == segment_names::linkEdit) {
 128     return StringSwitch<int>(osec->name)
 129         .Case(section_names::chainFixups, -11)
 130         .Case(section_names::rebase, -10)
 131         .Case(section_names::binding, -9)
 132         .Case(section_names::weakBinding, -8)
 133         .Case(section_names::lazyBinding, -7)
 134         .Case(section_names::export_, -6)
 135         .Case(section_names::functionStarts, -5)
 136         .Case(section_names::dataInCode, -4)
 137         .Case(section_names::symbolTable, -3)
 138         .Case(section_names::indirectSymbolTable, -2)
 139         .Case(section_names::stringTable, -1)
 140         .Case(section_names::codeSignature, std::numeric_limits<int>::max())
 141         .Default(osec->inputOrder);
 142   }
 143   // ZeroFill sections must always be the at the end of their segments:
 144   // dyld checks if a segment's file size is smaller than its in-memory
 145   // size to detect if a segment has zerofill sections, and if so it maps
 146   // the missing tail as zerofill.
 147   if (sectionType(osec->flags) == S_ZEROFILL)
 148     return std::numeric_limits<int>::max();
 149   return osec->inputOrder;
 150 }
 151
 152 void OutputSegment::sortOutputSections() {
 153   // Must be stable_sort() to keep special sections such as
 154   // S_THREAD_LOCAL_REGULAR in input order.
 155   llvm::stable_sort(sections, compareByOrder<OutputSection *>(sectionOrder));
 156 }
 157
 158 void OutputSegment::assignAddressesToStartEndSymbols() {
 159   for (Defined *d : segmentStartSymbols)
 160     d->value = addr;
 161   for (Defined *d : segmentEndSymbols)
 162     d->value = addr + vmSize;
 163 }
 164
 165 void macho::sortOutputSegments() {
 166   llvm::stable_sort(outputSegments,
 167                     compareByOrder<OutputSegment *>(segmentOrder));
 168 }
 169
 170 static DenseMap<StringRef, OutputSegment *> nameToOutputSegment;
 171 std::vector<OutputSegment *> macho::outputSegments;
 172
 173 void macho::resetOutputSegments() {
 174   outputSegments.clear();
 175   nameToOutputSegment.clear();
 176 }
 177
 178 static StringRef maybeRenameSegment(StringRef name) {
 179   auto newName = config->segmentRenameMap.find(name);
 180   if (newName != config->segmentRenameMap.end())
 181     return newName->second;
 182   return name;
 183 }
 184
 185 OutputSegment *macho::getOrCreateOutputSegment(StringRef name) {
 186   name = maybeRenameSegment(name);
 187
 188   OutputSegment *&segRef = nameToOutputSegment[name];
 189   if (segRef)
 190     return segRef;
 191
 192   segRef = make<OutputSegment>();
 193   segRef->name = name;
 194   segRef->maxProt = maxProt(name);
 195   segRef->initProt = initProt(name);
 196   segRef->flags = flags(name);
 197
 198   outputSegments.push_back(segRef);
 199   return segRef;
 200 }