contrib/llvm/tools/lld/ELF/LinkerScript.cpp

   1 //===- LinkerScript.cpp ---------------------------------------------------===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains the parser/evaluator of the linker script.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "LinkerScript.h"
  15 #include "Config.h"
  16 #include "InputSection.h"
  17 #include "Memory.h"
  18 #include "OutputSections.h"
  19 #include "Strings.h"
  20 #include "SymbolTable.h"
  21 #include "Symbols.h"
  22 #include "SyntheticSections.h"
  23 #include "Target.h"
  24 #include "Threads.h"
  25 #include "Writer.h"
  26 #include "llvm/ADT/STLExtras.h"
  27 #include "llvm/ADT/StringRef.h"
  28 #include "llvm/Support/Casting.h"
  29 #include "llvm/Support/Compression.h"
  30 #include "llvm/Support/ELF.h"
  31 #include "llvm/Support/Endian.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/FileSystem.h"
  34 #include "llvm/Support/Path.h"
  35 #include <algorithm>
  36 #include <cassert>
  37 #include <cstddef>
  38 #include <cstdint>
  39 #include <iterator>
  40 #include <limits>
  41 #include <string>
  42 #include <vector>
  43
  44 using namespace llvm;
  45 using namespace llvm::ELF;
  46 using namespace llvm::object;
  47 using namespace llvm::support::endian;
  48 using namespace lld;
  49 using namespace lld::elf;
  50
  51 LinkerScript *elf::Script;
  52
  53 uint64_t ExprValue::getValue() const {
  54   if (Sec) {
  55     if (OutputSection *OS = Sec->getOutputSection())
  56       return alignTo(Sec->getOffset(Val) + OS->Addr, Alignment);
  57     error("unable to evaluate expression: input section " + Sec->Name +
  58           " has no output section assigned");
  59   }
  60   return alignTo(Val, Alignment);
  61 }
  62
  63 uint64_t ExprValue::getSecAddr() const {
  64   if (Sec)
  65     return Sec->getOffset(0) + Sec->getOutputSection()->Addr;
  66   return 0;
  67 }
  68
  69 template <class ELFT> static SymbolBody *addRegular(SymbolAssignment *Cmd) {
  70   Symbol *Sym;
  71   uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
  72   std::tie(Sym, std::ignore) = Symtab<ELFT>::X->insert(
  73       Cmd->Name, /*Type*/ 0, Visibility, /*CanOmitFromDynSym*/ false,
  74       /*File*/ nullptr);
  75   Sym->Binding = STB_GLOBAL;
  76   ExprValue Value = Cmd->Expression();
  77   SectionBase *Sec = Value.isAbsolute() ? nullptr : Value.Sec;
  78
  79   // We want to set symbol values early if we can. This allows us to use symbols
  80   // as variables in linker scripts. Doing so allows us to write expressions
  81   // like this: `alignment = 16; . = ALIGN(., alignment)`
  82   uint64_t SymValue = Value.isAbsolute() ? Value.getValue() : 0;
  83   replaceBody<DefinedRegular>(Sym, Cmd->Name, /*IsLocal=*/false, Visibility,
  84                               STT_NOTYPE, SymValue, 0, Sec, nullptr);
  85   return Sym->body();
  86 }
  87
  88 OutputSectionCommand *
  89 LinkerScript::createOutputSectionCommand(StringRef Name, StringRef Location) {
  90   OutputSectionCommand *&CmdRef = NameToOutputSectionCommand[Name];
  91   OutputSectionCommand *Cmd;
  92   if (CmdRef && CmdRef->Location.empty()) {
  93     // There was a forward reference.
  94     Cmd = CmdRef;
  95   } else {
  96     Cmd = make<OutputSectionCommand>(Name);
  97     if (!CmdRef)
  98       CmdRef = Cmd;
  99   }
 100   Cmd->Location = Location;
 101   return Cmd;
 102 }
 103
 104 OutputSectionCommand *
 105 LinkerScript::getOrCreateOutputSectionCommand(StringRef Name) {
 106   OutputSectionCommand *&CmdRef = NameToOutputSectionCommand[Name];
 107   if (!CmdRef)
 108     CmdRef = make<OutputSectionCommand>(Name);
 109   return CmdRef;
 110 }
 111
 112 void LinkerScript::setDot(Expr E, const Twine &Loc, bool InSec) {
 113   uint64_t Val = E().getValue();
 114   if (Val < Dot) {
 115     if (InSec)
 116       error(Loc + ": unable to move location counter backward for: " +
 117             CurOutSec->Name);
 118     else
 119       error(Loc + ": unable to move location counter backward");
 120   }
 121   Dot = Val;
 122   // Update to location counter means update to section size.
 123   if (InSec)
 124     CurOutSec->Size = Dot - CurOutSec->Addr;
 125 }
 126
 127 // Sets value of a symbol. Two kinds of symbols are processed: synthetic
 128 // symbols, whose value is an offset from beginning of section and regular
 129 // symbols whose value is absolute.
 130 void LinkerScript::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
 131   if (Cmd->Name == ".") {
 132     setDot(Cmd->Expression, Cmd->Location, InSec);
 133     return;
 134   }
 135
 136   if (!Cmd->Sym)
 137     return;
 138
 139   auto *Sym = cast<DefinedRegular>(Cmd->Sym);
 140   ExprValue V = Cmd->Expression();
 141   if (V.isAbsolute()) {
 142     Sym->Value = V.getValue();
 143   } else {
 144     Sym->Section = V.Sec;
 145     if (Sym->Section->Flags & SHF_ALLOC)
 146       Sym->Value = alignTo(V.Val, V.Alignment);
 147     else
 148       Sym->Value = V.getValue();
 149   }
 150 }
 151
 152 static SymbolBody *findSymbol(StringRef S) {
 153   switch (Config->EKind) {
 154   case ELF32LEKind:
 155     return Symtab<ELF32LE>::X->find(S);
 156   case ELF32BEKind:
 157     return Symtab<ELF32BE>::X->find(S);
 158   case ELF64LEKind:
 159     return Symtab<ELF64LE>::X->find(S);
 160   case ELF64BEKind:
 161     return Symtab<ELF64BE>::X->find(S);
 162   default:
 163     llvm_unreachable("unknown Config->EKind");
 164   }
 165 }
 166
 167 static SymbolBody *addRegularSymbol(SymbolAssignment *Cmd) {
 168   switch (Config->EKind) {
 169   case ELF32LEKind:
 170     return addRegular<ELF32LE>(Cmd);
 171   case ELF32BEKind:
 172     return addRegular<ELF32BE>(Cmd);
 173   case ELF64LEKind:
 174     return addRegular<ELF64LE>(Cmd);
 175   case ELF64BEKind:
 176     return addRegular<ELF64BE>(Cmd);
 177   default:
 178     llvm_unreachable("unknown Config->EKind");
 179   }
 180 }
 181
 182 void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
 183   if (Cmd->Name == ".")
 184     return;
 185
 186   // If a symbol was in PROVIDE(), we need to define it only when
 187   // it is a referenced undefined symbol.
 188   SymbolBody *B = findSymbol(Cmd->Name);
 189   if (Cmd->Provide && (!B || B->isDefined()))
 190     return;
 191
 192   Cmd->Sym = addRegularSymbol(Cmd);
 193 }
 194
 195 bool SymbolAssignment::classof(const BaseCommand *C) {
 196   return C->Kind == AssignmentKind;
 197 }
 198
 199 bool OutputSectionCommand::classof(const BaseCommand *C) {
 200   return C->Kind == OutputSectionKind;
 201 }
 202
 203 // Fill [Buf, Buf + Size) with Filler.
 204 // This is used for linker script "=fillexp" command.
 205 static void fill(uint8_t *Buf, size_t Size, uint32_t Filler) {
 206   size_t I = 0;
 207   for (; I + 4 < Size; I += 4)
 208     memcpy(Buf + I, &Filler, 4);
 209   memcpy(Buf + I, &Filler, Size - I);
 210 }
 211
 212 bool InputSectionDescription::classof(const BaseCommand *C) {
 213   return C->Kind == InputSectionKind;
 214 }
 215
 216 bool AssertCommand::classof(const BaseCommand *C) {
 217   return C->Kind == AssertKind;
 218 }
 219
 220 bool BytesDataCommand::classof(const BaseCommand *C) {
 221   return C->Kind == BytesDataKind;
 222 }
 223
 224 static StringRef basename(InputSectionBase *S) {
 225   if (S->File)
 226     return sys::path::filename(S->File->getName());
 227   return "";
 228 }
 229
 230 bool LinkerScript::shouldKeep(InputSectionBase *S) {
 231   for (InputSectionDescription *ID : Opt.KeptSections)
 232     if (ID->FilePat.match(basename(S)))
 233       for (SectionPattern &P : ID->SectionPatterns)
 234         if (P.SectionPat.match(S->Name))
 235           return true;
 236   return false;
 237 }
 238
 239 // A helper function for the SORT() command.
 240 static std::function<bool(InputSectionBase *, InputSectionBase *)>
 241 getComparator(SortSectionPolicy K) {
 242   switch (K) {
 243   case SortSectionPolicy::Alignment:
 244     return [](InputSectionBase *A, InputSectionBase *B) {
 245       // ">" is not a mistake. Sections with larger alignments are placed
 246       // before sections with smaller alignments in order to reduce the
 247       // amount of padding necessary. This is compatible with GNU.
 248       return A->Alignment > B->Alignment;
 249     };
 250   case SortSectionPolicy::Name:
 251     return [](InputSectionBase *A, InputSectionBase *B) {
 252       return A->Name < B->Name;
 253     };
 254   case SortSectionPolicy::Priority:
 255     return [](InputSectionBase *A, InputSectionBase *B) {
 256       return getPriority(A->Name) < getPriority(B->Name);
 257     };
 258   default:
 259     llvm_unreachable("unknown sort policy");
 260   }
 261 }
 262
 263 // A helper function for the SORT() command.
 264 static bool matchConstraints(ArrayRef<InputSectionBase *> Sections,
 265                              ConstraintKind Kind) {
 266   if (Kind == ConstraintKind::NoConstraint)
 267     return true;
 268
 269   bool IsRW = llvm::any_of(Sections, [](InputSectionBase *Sec) {
 270     return static_cast<InputSectionBase *>(Sec)->Flags & SHF_WRITE;
 271   });
 272
 273   return (IsRW && Kind == ConstraintKind::ReadWrite) ||
 274          (!IsRW && Kind == ConstraintKind::ReadOnly);
 275 }
 276
 277 static void sortSections(InputSection **Begin, InputSection **End,
 278                          SortSectionPolicy K) {
 279   if (K != SortSectionPolicy::Default && K != SortSectionPolicy::None)
 280     std::stable_sort(Begin, End, getComparator(K));
 281 }
 282
 283 // Compute and remember which sections the InputSectionDescription matches.
 284 std::vector<InputSection *>
 285 LinkerScript::computeInputSections(const InputSectionDescription *Cmd) {
 286   std::vector<InputSection *> Ret;
 287
 288   // Collects all sections that satisfy constraints of Cmd.
 289   for (const SectionPattern &Pat : Cmd->SectionPatterns) {
 290     size_t SizeBefore = Ret.size();
 291
 292     for (InputSectionBase *Sec : InputSections) {
 293       if (Sec->Assigned)
 294         continue;
 295
 296       if (!Sec->Live) {
 297         reportDiscarded(Sec);
 298         continue;
 299       }
 300
 301       // For -emit-relocs we have to ignore entries like
 302       //   .rela.dyn : { *(.rela.data) }
 303       // which are common because they are in the default bfd script.
 304       if (Sec->Type == SHT_REL || Sec->Type == SHT_RELA)
 305         continue;
 306
 307       StringRef Filename = basename(Sec);
 308       if (!Cmd->FilePat.match(Filename) ||
 309           Pat.ExcludedFilePat.match(Filename) ||
 310           !Pat.SectionPat.match(Sec->Name))
 311         continue;
 312
 313       Ret.push_back(cast<InputSection>(Sec));
 314       Sec->Assigned = true;
 315     }
 316
 317     // Sort sections as instructed by SORT-family commands and --sort-section
 318     // option. Because SORT-family commands can be nested at most two depth
 319     // (e.g. SORT_BY_NAME(SORT_BY_ALIGNMENT(.text.*))) and because the command
 320     // line option is respected even if a SORT command is given, the exact
 321     // behavior we have here is a bit complicated. Here are the rules.
 322     //
 323     // 1. If two SORT commands are given, --sort-section is ignored.
 324     // 2. If one SORT command is given, and if it is not SORT_NONE,
 325     //    --sort-section is handled as an inner SORT command.
 326     // 3. If one SORT command is given, and if it is SORT_NONE, don't sort.
 327     // 4. If no SORT command is given, sort according to --sort-section.
 328     InputSection **Begin = Ret.data() + SizeBefore;
 329     InputSection **End = Ret.data() + Ret.size();
 330     if (Pat.SortOuter != SortSectionPolicy::None) {
 331       if (Pat.SortInner == SortSectionPolicy::Default)
 332         sortSections(Begin, End, Config->SortSection);
 333       else
 334         sortSections(Begin, End, Pat.SortInner);
 335       sortSections(Begin, End, Pat.SortOuter);
 336     }
 337   }
 338   return Ret;
 339 }
 340
 341 void LinkerScript::discard(ArrayRef<InputSectionBase *> V) {
 342   for (InputSectionBase *S : V) {
 343     S->Live = false;
 344     if (S == InX::ShStrTab)
 345       error("discarding .shstrtab section is not allowed");
 346     discard(S->DependentSections);
 347   }
 348 }
 349
 350 std::vector<InputSectionBase *>
 351 LinkerScript::createInputSectionList(OutputSectionCommand &OutCmd) {
 352   std::vector<InputSectionBase *> Ret;
 353
 354   for (BaseCommand *Base : OutCmd.Commands) {
 355     auto *Cmd = dyn_cast<InputSectionDescription>(Base);
 356     if (!Cmd)
 357       continue;
 358
 359     Cmd->Sections = computeInputSections(Cmd);
 360     Ret.insert(Ret.end(), Cmd->Sections.begin(), Cmd->Sections.end());
 361   }
 362
 363   return Ret;
 364 }
 365
 366 void LinkerScript::processCommands(OutputSectionFactory &Factory) {
 367   // A symbol can be assigned before any section is mentioned in the linker
 368   // script. In an DSO, the symbol values are addresses, so the only important
 369   // section values are:
 370   // * SHN_UNDEF
 371   // * SHN_ABS
 372   // * Any value meaning a regular section.
 373   // To handle that, create a dummy aether section that fills the void before
 374   // the linker scripts switches to another section. It has an index of one
 375   // which will map to whatever the first actual section is.
 376   Aether = make<OutputSection>("", 0, SHF_ALLOC);
 377   Aether->SectionIndex = 1;
 378   CurOutSec = Aether;
 379   Dot = 0;
 380
 381   for (size_t I = 0; I < Opt.Commands.size(); ++I) {
 382     // Handle symbol assignments outside of any output section.
 383     if (auto *Cmd = dyn_cast<SymbolAssignment>(Opt.Commands[I])) {
 384       addSymbol(Cmd);
 385       continue;
 386     }
 387
 388     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Opt.Commands[I])) {
 389       std::vector<InputSectionBase *> V = createInputSectionList(*Cmd);
 390
 391       // The output section name `/DISCARD/' is special.
 392       // Any input section assigned to it is discarded.
 393       if (Cmd->Name == "/DISCARD/") {
 394         discard(V);
 395         continue;
 396       }
 397
 398       // This is for ONLY_IF_RO and ONLY_IF_RW. An output section directive
 399       // ".foo : ONLY_IF_R[OW] { ... }" is handled only if all member input
 400       // sections satisfy a given constraint. If not, a directive is handled
 401       // as if it wasn't present from the beginning.
 402       //
 403       // Because we'll iterate over Commands many more times, the easiest
 404       // way to "make it as if it wasn't present" is to just remove it.
 405       if (!matchConstraints(V, Cmd->Constraint)) {
 406         for (InputSectionBase *S : V)
 407           S->Assigned = false;
 408         Opt.Commands.erase(Opt.Commands.begin() + I);
 409         --I;
 410         continue;
 411       }
 412
 413       // A directive may contain symbol definitions like this:
 414       // ".foo : { ...; bar = .; }". Handle them.
 415       for (BaseCommand *Base : Cmd->Commands)
 416         if (auto *OutCmd = dyn_cast<SymbolAssignment>(Base))
 417           addSymbol(OutCmd);
 418
 419       // Handle subalign (e.g. ".foo : SUBALIGN(32) { ... }"). If subalign
 420       // is given, input sections are aligned to that value, whether the
 421       // given value is larger or smaller than the original section alignment.
 422       if (Cmd->SubalignExpr) {
 423         uint32_t Subalign = Cmd->SubalignExpr().getValue();
 424         for (InputSectionBase *S : V)
 425           S->Alignment = Subalign;
 426       }
 427
 428       // Add input sections to an output section.
 429       for (InputSectionBase *S : V)
 430         Factory.addInputSec(S, Cmd->Name, Cmd->Sec);
 431       if (OutputSection *Sec = Cmd->Sec) {
 432         assert(Sec->SectionIndex == INT_MAX);
 433         Sec->SectionIndex = I;
 434         SecToCommand[Sec] = Cmd;
 435       }
 436     }
 437   }
 438   CurOutSec = nullptr;
 439 }
 440
 441 void LinkerScript::fabricateDefaultCommands() {
 442   std::vector<BaseCommand *> Commands;
 443
 444   // Define start address
 445   uint64_t StartAddr = Config->ImageBase + elf::getHeaderSize();
 446
 447   // The Sections with -T<section> have been sorted in order of ascending
 448   // address. We must lower StartAddr if the lowest -T<section address> as
 449   // calls to setDot() must be monotonically increasing.
 450   for (auto& KV : Config->SectionStartMap)
 451     StartAddr = std::min(StartAddr, KV.second);
 452
 453   Commands.push_back(
 454       make<SymbolAssignment>(".", [=] { return StartAddr; }, ""));
 455
 456   // For each OutputSection that needs a VA fabricate an OutputSectionCommand
 457   // with an InputSectionDescription describing the InputSections
 458   for (OutputSection *Sec : *OutputSections) {
 459     auto *OSCmd = createOutputSectionCommand(Sec->Name, "<internal>");
 460     OSCmd->Sec = Sec;
 461     SecToCommand[Sec] = OSCmd;
 462
 463     // Prefer user supplied address over additional alignment constraint
 464     auto I = Config->SectionStartMap.find(Sec->Name);
 465     if (I != Config->SectionStartMap.end())
 466       OSCmd->AddrExpr = [=] { return I->second; };
 467
 468     Commands.push_back(OSCmd);
 469     if (Sec->Sections.size()) {
 470       auto *ISD = make<InputSectionDescription>("");
 471       OSCmd->Commands.push_back(ISD);
 472       for (InputSection *ISec : Sec->Sections) {
 473         ISD->Sections.push_back(ISec);
 474         ISec->Assigned = true;
 475       }
 476     }
 477   }
 478   // SECTIONS commands run before other non SECTIONS commands
 479   Commands.insert(Commands.end(), Opt.Commands.begin(), Opt.Commands.end());
 480   Opt.Commands = std::move(Commands);
 481 }
 482
 483 // Add sections that didn't match any sections command.
 484 void LinkerScript::addOrphanSections(OutputSectionFactory &Factory) {
 485   for (InputSectionBase *S : InputSections) {
 486     if (!S->Live || S->Parent)
 487       continue;
 488     StringRef Name = getOutputSectionName(S->Name);
 489     auto I = std::find_if(
 490         Opt.Commands.begin(), Opt.Commands.end(), [&](BaseCommand *Base) {
 491           if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base))
 492             return Cmd->Name == Name;
 493           return false;
 494         });
 495     if (I == Opt.Commands.end()) {
 496       Factory.addInputSec(S, Name);
 497     } else {
 498       auto *Cmd = cast<OutputSectionCommand>(*I);
 499       Factory.addInputSec(S, Name, Cmd->Sec);
 500       if (OutputSection *Sec = Cmd->Sec) {
 501         SecToCommand[Sec] = Cmd;
 502         unsigned Index = std::distance(Opt.Commands.begin(), I);
 503         assert(Sec->SectionIndex == INT_MAX || Sec->SectionIndex == Index);
 504         Sec->SectionIndex = Index;
 505       }
 506       auto *ISD = make<InputSectionDescription>("");
 507       ISD->Sections.push_back(cast<InputSection>(S));
 508       Cmd->Commands.push_back(ISD);
 509     }
 510   }
 511 }
 512
 513 uint64_t LinkerScript::advance(uint64_t Size, unsigned Align) {
 514   bool IsTbss = (CurOutSec->Flags & SHF_TLS) && CurOutSec->Type == SHT_NOBITS;
 515   uint64_t Start = IsTbss ? Dot + ThreadBssOffset : Dot;
 516   Start = alignTo(Start, Align);
 517   uint64_t End = Start + Size;
 518
 519   if (IsTbss)
 520     ThreadBssOffset = End - Dot;
 521   else
 522     Dot = End;
 523   return End;
 524 }
 525
 526 void LinkerScript::output(InputSection *S) {
 527   uint64_t Pos = advance(S->getSize(), S->Alignment);
 528   S->OutSecOff = Pos - S->getSize() - CurOutSec->Addr;
 529
 530   // Update output section size after adding each section. This is so that
 531   // SIZEOF works correctly in the case below:
 532   // .foo { *(.aaa) a = SIZEOF(.foo); *(.bbb) }
 533   CurOutSec->Size = Pos - CurOutSec->Addr;
 534
 535   // If there is a memory region associated with this input section, then
 536   // place the section in that region and update the region index.
 537   if (CurMemRegion) {
 538     CurMemRegion->Offset += CurOutSec->Size;
 539     uint64_t CurSize = CurMemRegion->Offset - CurMemRegion->Origin;
 540     if (CurSize > CurMemRegion->Length) {
 541       uint64_t OverflowAmt = CurSize - CurMemRegion->Length;
 542       error("section '" + CurOutSec->Name + "' will not fit in region '" +
 543             CurMemRegion->Name + "': overflowed by " + Twine(OverflowAmt) +
 544             " bytes");
 545     }
 546   }
 547 }
 548
 549 void LinkerScript::switchTo(OutputSection *Sec) {
 550   if (CurOutSec == Sec)
 551     return;
 552
 553   CurOutSec = Sec;
 554   CurOutSec->Addr = advance(0, CurOutSec->Alignment);
 555
 556   // If neither AT nor AT> is specified for an allocatable section, the linker
 557   // will set the LMA such that the difference between VMA and LMA for the
 558   // section is the same as the preceding output section in the same region
 559   // https://sourceware.org/binutils/docs-2.20/ld/Output-Section-LMA.html
 560   if (LMAOffset)
 561     CurOutSec->LMAOffset = LMAOffset();
 562 }
 563
 564 void LinkerScript::process(BaseCommand &Base) {
 565   // This handles the assignments to symbol or to the dot.
 566   if (auto *Cmd = dyn_cast<SymbolAssignment>(&Base)) {
 567     assignSymbol(Cmd, true);
 568     return;
 569   }
 570
 571   // Handle BYTE(), SHORT(), LONG(), or QUAD().
 572   if (auto *Cmd = dyn_cast<BytesDataCommand>(&Base)) {
 573     Cmd->Offset = Dot - CurOutSec->Addr;
 574     Dot += Cmd->Size;
 575     CurOutSec->Size = Dot - CurOutSec->Addr;
 576     return;
 577   }
 578
 579   // Handle ASSERT().
 580   if (auto *Cmd = dyn_cast<AssertCommand>(&Base)) {
 581     Cmd->Expression();
 582     return;
 583   }
 584
 585   // Handle a single input section description command.
 586   // It calculates and assigns the offsets for each section and also
 587   // updates the output section size.
 588   auto &Cmd = cast<InputSectionDescription>(Base);
 589   for (InputSection *Sec : Cmd.Sections) {
 590     // We tentatively added all synthetic sections at the beginning and removed
 591     // empty ones afterwards (because there is no way to know whether they were
 592     // going be empty or not other than actually running linker scripts.)
 593     // We need to ignore remains of empty sections.
 594     if (auto *S = dyn_cast<SyntheticSection>(Sec))
 595       if (S->empty())
 596         continue;
 597
 598     if (!Sec->Live)
 599       continue;
 600     assert(CurOutSec == Sec->getParent());
 601     output(Sec);
 602   }
 603 }
 604
 605 // This function searches for a memory region to place the given output
 606 // section in. If found, a pointer to the appropriate memory region is
 607 // returned. Otherwise, a nullptr is returned.
 608 MemoryRegion *LinkerScript::findMemoryRegion(OutputSectionCommand *Cmd) {
 609   // If a memory region name was specified in the output section command,
 610   // then try to find that region first.
 611   if (!Cmd->MemoryRegionName.empty()) {
 612     auto It = Opt.MemoryRegions.find(Cmd->MemoryRegionName);
 613     if (It != Opt.MemoryRegions.end())
 614       return &It->second;
 615     error("memory region '" + Cmd->MemoryRegionName + "' not declared");
 616     return nullptr;
 617   }
 618
 619   // If at least one memory region is defined, all sections must
 620   // belong to some memory region. Otherwise, we don't need to do
 621   // anything for memory regions.
 622   if (Opt.MemoryRegions.empty())
 623     return nullptr;
 624
 625   OutputSection *Sec = Cmd->Sec;
 626   // See if a region can be found by matching section flags.
 627   for (auto &Pair : Opt.MemoryRegions) {
 628     MemoryRegion &M = Pair.second;
 629     if ((M.Flags & Sec->Flags) && (M.NegFlags & Sec->Flags) == 0)
 630       return &M;
 631   }
 632
 633   // Otherwise, no suitable region was found.
 634   if (Sec->Flags & SHF_ALLOC)
 635     error("no memory region specified for section '" + Sec->Name + "'");
 636   return nullptr;
 637 }
 638
 639 // This function assigns offsets to input sections and an output section
 640 // for a single sections command (e.g. ".text { *(.text); }").
 641 void LinkerScript::assignOffsets(OutputSectionCommand *Cmd) {
 642   OutputSection *Sec = Cmd->Sec;
 643   if (!Sec)
 644     return;
 645
 646   if (Cmd->AddrExpr && (Sec->Flags & SHF_ALLOC))
 647     setDot(Cmd->AddrExpr, Cmd->Location, false);
 648
 649   if (Cmd->LMAExpr) {
 650     uint64_t D = Dot;
 651     LMAOffset = [=] { return Cmd->LMAExpr().getValue() - D; };
 652   }
 653
 654   CurMemRegion = Cmd->MemRegion;
 655   if (CurMemRegion)
 656     Dot = CurMemRegion->Offset;
 657   switchTo(Sec);
 658
 659   // We do not support custom layout for compressed debug sectons.
 660   // At this point we already know their size and have compressed content.
 661   if (CurOutSec->Flags & SHF_COMPRESSED)
 662     return;
 663
 664   for (BaseCommand *C : Cmd->Commands)
 665     process(*C);
 666 }
 667
 668 void LinkerScript::removeEmptyCommands() {
 669   // It is common practice to use very generic linker scripts. So for any
 670   // given run some of the output sections in the script will be empty.
 671   // We could create corresponding empty output sections, but that would
 672   // clutter the output.
 673   // We instead remove trivially empty sections. The bfd linker seems even
 674   // more aggressive at removing them.
 675   auto Pos = std::remove_if(
 676       Opt.Commands.begin(), Opt.Commands.end(), [&](BaseCommand *Base) {
 677         if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base))
 678           return std::find(OutputSections->begin(), OutputSections->end(),
 679                            Cmd->Sec) == OutputSections->end();
 680         return false;
 681       });
 682   Opt.Commands.erase(Pos, Opt.Commands.end());
 683 }
 684
 685 static bool isAllSectionDescription(const OutputSectionCommand &Cmd) {
 686   for (BaseCommand *Base : Cmd.Commands)
 687     if (!isa<InputSectionDescription>(*Base))
 688       return false;
 689   return true;
 690 }
 691
 692 void LinkerScript::adjustSectionsBeforeSorting() {
 693   // If the output section contains only symbol assignments, create a
 694   // corresponding output section. The bfd linker seems to only create them if
 695   // '.' is assigned to, but creating these section should not have any bad
 696   // consequeces and gives us a section to put the symbol in.
 697   uint64_t Flags = SHF_ALLOC;
 698
 699   for (int I = 0, E = Opt.Commands.size(); I != E; ++I) {
 700     auto *Cmd = dyn_cast<OutputSectionCommand>(Opt.Commands[I]);
 701     if (!Cmd)
 702       continue;
 703     if (OutputSection *Sec = Cmd->Sec) {
 704       Flags = Sec->Flags;
 705       continue;
 706     }
 707
 708     if (isAllSectionDescription(*Cmd))
 709       continue;
 710
 711     auto *OutSec = make<OutputSection>(Cmd->Name, SHT_PROGBITS, Flags);
 712     OutSec->SectionIndex = I;
 713     OutputSections->push_back(OutSec);
 714     Cmd->Sec = OutSec;
 715     SecToCommand[OutSec] = Cmd;
 716   }
 717 }
 718
 719 void LinkerScript::adjustSectionsAfterSorting() {
 720   placeOrphanSections();
 721
 722   // Try and find an appropriate memory region to assign offsets in.
 723   for (BaseCommand *Base : Opt.Commands) {
 724     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base)) {
 725       Cmd->MemRegion = findMemoryRegion(Cmd);
 726       // Handle align (e.g. ".foo : ALIGN(16) { ... }").
 727       if (Cmd->AlignExpr)
 728         Cmd->Sec->updateAlignment(Cmd->AlignExpr().getValue());
 729     }
 730   }
 731
 732   // If output section command doesn't specify any segments,
 733   // and we haven't previously assigned any section to segment,
 734   // then we simply assign section to the very first load segment.
 735   // Below is an example of such linker script:
 736   // PHDRS { seg PT_LOAD; }
 737   // SECTIONS { .aaa : { *(.aaa) } }
 738   std::vector<StringRef> DefPhdrs;
 739   auto FirstPtLoad =
 740       std::find_if(Opt.PhdrsCommands.begin(), Opt.PhdrsCommands.end(),
 741                    [](const PhdrsCommand &Cmd) { return Cmd.Type == PT_LOAD; });
 742   if (FirstPtLoad != Opt.PhdrsCommands.end())
 743     DefPhdrs.push_back(FirstPtLoad->Name);
 744
 745   // Walk the commands and propagate the program headers to commands that don't
 746   // explicitly specify them.
 747   for (BaseCommand *Base : Opt.Commands) {
 748     auto *Cmd = dyn_cast<OutputSectionCommand>(Base);
 749     if (!Cmd)
 750       continue;
 751
 752     if (Cmd->Phdrs.empty())
 753       Cmd->Phdrs = DefPhdrs;
 754     else
 755       DefPhdrs = Cmd->Phdrs;
 756   }
 757
 758   removeEmptyCommands();
 759 }
 760
 761 // When placing orphan sections, we want to place them after symbol assignments
 762 // so that an orphan after
 763 //   begin_foo = .;
 764 //   foo : { *(foo) }
 765 //   end_foo = .;
 766 // doesn't break the intended meaning of the begin/end symbols.
 767 // We don't want to go over sections since Writer<ELFT>::sortSections is the
 768 // one in charge of deciding the order of the sections.
 769 // We don't want to go over alignments, since doing so in
 770 //  rx_sec : { *(rx_sec) }
 771 //  . = ALIGN(0x1000);
 772 //  /* The RW PT_LOAD starts here*/
 773 //  rw_sec : { *(rw_sec) }
 774 // would mean that the RW PT_LOAD would become unaligned.
 775 static bool shouldSkip(BaseCommand *Cmd) {
 776   if (isa<OutputSectionCommand>(Cmd))
 777     return false;
 778   if (auto *Assign = dyn_cast<SymbolAssignment>(Cmd))
 779     return Assign->Name != ".";
 780   return true;
 781 }
 782
 783 // Orphan sections are sections present in the input files which are
 784 // not explicitly placed into the output file by the linker script.
 785 //
 786 // When the control reaches this function, Opt.Commands contains
 787 // output section commands for non-orphan sections only. This function
 788 // adds new elements for orphan sections so that all sections are
 789 // explicitly handled by Opt.Commands.
 790 //
 791 // Writer<ELFT>::sortSections has already sorted output sections.
 792 // What we need to do is to scan OutputSections vector and
 793 // Opt.Commands in parallel to find orphan sections. If there is an
 794 // output section that doesn't have a corresponding entry in
 795 // Opt.Commands, we will insert a new entry to Opt.Commands.
 796 //
 797 // There is some ambiguity as to where exactly a new entry should be
 798 // inserted, because Opt.Commands contains not only output section
 799 // commands but also other types of commands such as symbol assignment
 800 // expressions. There's no correct answer here due to the lack of the
 801 // formal specification of the linker script. We use heuristics to
 802 // determine whether a new output command should be added before or
 803 // after another commands. For the details, look at shouldSkip
 804 // function.
 805 void LinkerScript::placeOrphanSections() {
 806   // The OutputSections are already in the correct order.
 807   // This loops creates or moves commands as needed so that they are in the
 808   // correct order.
 809   int CmdIndex = 0;
 810
 811   // As a horrible special case, skip the first . assignment if it is before any
 812   // section. We do this because it is common to set a load address by starting
 813   // the script with ". = 0xabcd" and the expectation is that every section is
 814   // after that.
 815   auto FirstSectionOrDotAssignment =
 816       std::find_if(Opt.Commands.begin(), Opt.Commands.end(),
 817                    [](BaseCommand *Cmd) { return !shouldSkip(Cmd); });
 818   if (FirstSectionOrDotAssignment != Opt.Commands.end()) {
 819     CmdIndex = FirstSectionOrDotAssignment - Opt.Commands.begin();
 820     if (isa<SymbolAssignment>(**FirstSectionOrDotAssignment))
 821       ++CmdIndex;
 822   }
 823
 824   for (OutputSection *Sec : *OutputSections) {
 825     StringRef Name = Sec->Name;
 826
 827     // Find the last spot where we can insert a command and still get the
 828     // correct result.
 829     auto CmdIter = Opt.Commands.begin() + CmdIndex;
 830     auto E = Opt.Commands.end();
 831     while (CmdIter != E && shouldSkip(*CmdIter)) {
 832       ++CmdIter;
 833       ++CmdIndex;
 834     }
 835
 836     // If there is no command corresponding to this output section,
 837     // create one and put a InputSectionDescription in it so that both
 838     // representations agree on which input sections to use.
 839     OutputSectionCommand *Cmd = getCmd(Sec);
 840     if (!Cmd) {
 841       Cmd = createOutputSectionCommand(Name, "<internal>");
 842       Opt.Commands.insert(CmdIter, Cmd);
 843       ++CmdIndex;
 844
 845       Cmd->Sec = Sec;
 846       SecToCommand[Sec] = Cmd;
 847       auto *ISD = make<InputSectionDescription>("");
 848       for (InputSection *IS : Sec->Sections)
 849         ISD->Sections.push_back(IS);
 850       Cmd->Commands.push_back(ISD);
 851
 852       continue;
 853     }
 854
 855     // Continue from where we found it.
 856     while (*CmdIter != Cmd) {
 857       ++CmdIter;
 858       ++CmdIndex;
 859     }
 860     ++CmdIndex;
 861   }
 862 }
 863
 864 void LinkerScript::processNonSectionCommands() {
 865   for (BaseCommand *Base : Opt.Commands) {
 866     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base))
 867       assignSymbol(Cmd, false);
 868     else if (auto *Cmd = dyn_cast<AssertCommand>(Base))
 869       Cmd->Expression();
 870   }
 871 }
 872
 873 // Do a last effort at synchronizing the linker script "AST" and the section
 874 // list. This is needed to account for last minute changes, like adding a
 875 // .ARM.exidx terminator and sorting SHF_LINK_ORDER sections.
 876 //
 877 // FIXME: We should instead create the "AST" earlier and the above changes would
 878 // be done directly in the "AST".
 879 //
 880 // This can only handle new sections being added and sections being reordered.
 881 void LinkerScript::synchronize() {
 882   for (BaseCommand *Base : Opt.Commands) {
 883     auto *Cmd = dyn_cast<OutputSectionCommand>(Base);
 884     if (!Cmd)
 885       continue;
 886     ArrayRef<InputSection *> Sections = Cmd->Sec->Sections;
 887     std::vector<InputSection **> ScriptSections;
 888     DenseSet<InputSection *> ScriptSectionsSet;
 889     for (BaseCommand *Base : Cmd->Commands) {
 890       auto *ISD = dyn_cast<InputSectionDescription>(Base);
 891       if (!ISD)
 892         continue;
 893       for (InputSection *&IS : ISD->Sections) {
 894         if (IS->Live) {
 895           ScriptSections.push_back(&IS);
 896           ScriptSectionsSet.insert(IS);
 897         }
 898       }
 899     }
 900     std::vector<InputSection *> Missing;
 901     for (InputSection *IS : Sections)
 902       if (!ScriptSectionsSet.count(IS))
 903         Missing.push_back(IS);
 904     if (!Missing.empty()) {
 905       auto ISD = make<InputSectionDescription>("");
 906       ISD->Sections = Missing;
 907       Cmd->Commands.push_back(ISD);
 908       for (InputSection *&IS : ISD->Sections)
 909         if (IS->Live)
 910           ScriptSections.push_back(&IS);
 911     }
 912     assert(ScriptSections.size() == Sections.size());
 913     for (int I = 0, N = Sections.size(); I < N; ++I)
 914       *ScriptSections[I] = Sections[I];
 915   }
 916 }
 917
 918 static bool
 919 allocateHeaders(std::vector<PhdrEntry> &Phdrs,
 920                 ArrayRef<OutputSectionCommand *> OutputSectionCommands,
 921                 uint64_t Min) {
 922   auto FirstPTLoad =
 923       std::find_if(Phdrs.begin(), Phdrs.end(),
 924                    [](const PhdrEntry &E) { return E.p_type == PT_LOAD; });
 925   if (FirstPTLoad == Phdrs.end())
 926     return false;
 927
 928   uint64_t HeaderSize = getHeaderSize();
 929   if (HeaderSize <= Min || Script->hasPhdrsCommands()) {
 930     Min = alignDown(Min - HeaderSize, Config->MaxPageSize);
 931     Out::ElfHeader->Addr = Min;
 932     Out::ProgramHeaders->Addr = Min + Out::ElfHeader->Size;
 933     return true;
 934   }
 935
 936   assert(FirstPTLoad->First == Out::ElfHeader);
 937   OutputSection *ActualFirst = nullptr;
 938   for (OutputSectionCommand *Cmd : OutputSectionCommands) {
 939     OutputSection *Sec = Cmd->Sec;
 940     if (Sec->FirstInPtLoad == Out::ElfHeader) {
 941       ActualFirst = Sec;
 942       break;
 943     }
 944   }
 945   if (ActualFirst) {
 946     for (OutputSectionCommand *Cmd : OutputSectionCommands) {
 947       OutputSection *Sec = Cmd->Sec;
 948       if (Sec->FirstInPtLoad == Out::ElfHeader)
 949         Sec->FirstInPtLoad = ActualFirst;
 950     }
 951     FirstPTLoad->First = ActualFirst;
 952   } else {
 953     Phdrs.erase(FirstPTLoad);
 954   }
 955
 956   auto PhdrI = std::find_if(Phdrs.begin(), Phdrs.end(), [](const PhdrEntry &E) {
 957     return E.p_type == PT_PHDR;
 958   });
 959   if (PhdrI != Phdrs.end())
 960     Phdrs.erase(PhdrI);
 961   return false;
 962 }
 963
 964 void LinkerScript::assignAddresses(
 965     std::vector<PhdrEntry> &Phdrs,
 966     ArrayRef<OutputSectionCommand *> OutputSectionCommands) {
 967   // Assign addresses as instructed by linker script SECTIONS sub-commands.
 968   Dot = 0;
 969   ErrorOnMissingSection = true;
 970   switchTo(Aether);
 971
 972   for (BaseCommand *Base : Opt.Commands) {
 973     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
 974       assignSymbol(Cmd, false);
 975       continue;
 976     }
 977
 978     if (auto *Cmd = dyn_cast<AssertCommand>(Base)) {
 979       Cmd->Expression();
 980       continue;
 981     }
 982
 983     auto *Cmd = cast<OutputSectionCommand>(Base);
 984     assignOffsets(Cmd);
 985   }
 986
 987   uint64_t MinVA = std::numeric_limits<uint64_t>::max();
 988   for (OutputSectionCommand *Cmd : OutputSectionCommands) {
 989     OutputSection *Sec = Cmd->Sec;
 990     if (Sec->Flags & SHF_ALLOC)
 991       MinVA = std::min<uint64_t>(MinVA, Sec->Addr);
 992     else
 993       Sec->Addr = 0;
 994   }
 995
 996   allocateHeaders(Phdrs, OutputSectionCommands, MinVA);
 997 }
 998
 999 // Creates program headers as instructed by PHDRS linker script command.
1000 std::vector<PhdrEntry> LinkerScript::createPhdrs() {
1001   std::vector<PhdrEntry> Ret;
1002
1003   // Process PHDRS and FILEHDR keywords because they are not
1004   // real output sections and cannot be added in the following loop.
1005   for (const PhdrsCommand &Cmd : Opt.PhdrsCommands) {
1006     Ret.emplace_back(Cmd.Type, Cmd.Flags == UINT_MAX ? PF_R : Cmd.Flags);
1007     PhdrEntry &Phdr = Ret.back();
1008
1009     if (Cmd.HasFilehdr)
1010       Phdr.add(Out::ElfHeader);
1011     if (Cmd.HasPhdrs)
1012       Phdr.add(Out::ProgramHeaders);
1013
1014     if (Cmd.LMAExpr) {
1015       Phdr.p_paddr = Cmd.LMAExpr().getValue();
1016       Phdr.HasLMA = true;
1017     }
1018   }
1019
1020   // Add output sections to program headers.
1021   for (OutputSection *Sec : *OutputSections) {
1022     if (!(Sec->Flags & SHF_ALLOC))
1023       break;
1024
1025     // Assign headers specified by linker script
1026     for (size_t Id : getPhdrIndices(Sec)) {
1027       Ret[Id].add(Sec);
1028       if (Opt.PhdrsCommands[Id].Flags == UINT_MAX)
1029         Ret[Id].p_flags |= Sec->getPhdrFlags();
1030     }
1031   }
1032   return Ret;
1033 }
1034
1035 bool LinkerScript::ignoreInterpSection() {
1036   // Ignore .interp section in case we have PHDRS specification
1037   // and PT_INTERP isn't listed.
1038   if (Opt.PhdrsCommands.empty())
1039     return false;
1040   for (PhdrsCommand &Cmd : Opt.PhdrsCommands)
1041     if (Cmd.Type == PT_INTERP)
1042       return false;
1043   return true;
1044 }
1045
1046 OutputSectionCommand *LinkerScript::getCmd(OutputSection *Sec) const {
1047   auto I = SecToCommand.find(Sec);
1048   if (I == SecToCommand.end())
1049     return nullptr;
1050   return I->second;
1051 }
1052
1053 uint32_t OutputSectionCommand::getFiller() {
1054   if (Filler)
1055     return *Filler;
1056   if (Sec->Flags & SHF_EXECINSTR)
1057     return Target->TrapInstr;
1058   return 0;
1059 }
1060
1061 static void writeInt(uint8_t *Buf, uint64_t Data, uint64_t Size) {
1062   if (Size == 1)
1063     *Buf = Data;
1064   else if (Size == 2)
1065     write16(Buf, Data, Config->Endianness);
1066   else if (Size == 4)
1067     write32(Buf, Data, Config->Endianness);
1068   else if (Size == 8)
1069     write64(Buf, Data, Config->Endianness);
1070   else
1071     llvm_unreachable("unsupported Size argument");
1072 }
1073
1074 // Compress section contents if this section contains debug info.
1075 template <class ELFT> void OutputSectionCommand::maybeCompress() {
1076   typedef typename ELFT::Chdr Elf_Chdr;
1077
1078   // Compress only DWARF debug sections.
1079   if (!Config->CompressDebugSections || (Sec->Flags & SHF_ALLOC) ||
1080       !Name.startswith(".debug_"))
1081     return;
1082
1083   // Create a section header.
1084   Sec->ZDebugHeader.resize(sizeof(Elf_Chdr));
1085   auto *Hdr = reinterpret_cast<Elf_Chdr *>(Sec->ZDebugHeader.data());
1086   Hdr->ch_type = ELFCOMPRESS_ZLIB;
1087   Hdr->ch_size = Sec->Size;
1088   Hdr->ch_addralign = Sec->Alignment;
1089
1090   // Write section contents to a temporary buffer and compress it.
1091   std::vector<uint8_t> Buf(Sec->Size);
1092   writeTo<ELFT>(Buf.data());
1093   if (Error E = zlib::compress(toStringRef(Buf), Sec->CompressedData))
1094     fatal("compress failed: " + llvm::toString(std::move(E)));
1095
1096   // Update section headers.
1097   Sec->Size = sizeof(Elf_Chdr) + Sec->CompressedData.size();
1098   Sec->Flags |= SHF_COMPRESSED;
1099 }
1100
1101 template <class ELFT> void OutputSectionCommand::writeTo(uint8_t *Buf) {
1102   Sec->Loc = Buf;
1103
1104   // We may have already rendered compressed content when using
1105   // -compress-debug-sections option. Write it together with header.
1106   if (!Sec->CompressedData.empty()) {
1107     memcpy(Buf, Sec->ZDebugHeader.data(), Sec->ZDebugHeader.size());
1108     memcpy(Buf + Sec->ZDebugHeader.size(), Sec->CompressedData.data(),
1109            Sec->CompressedData.size());
1110     return;
1111   }
1112
1113   if (Sec->Type == SHT_NOBITS)
1114     return;
1115
1116   // Write leading padding.
1117   std::vector<InputSection *> Sections;
1118   for (BaseCommand *Cmd : Commands)
1119     if (auto *ISD = dyn_cast<InputSectionDescription>(Cmd))
1120       for (InputSection *IS : ISD->Sections)
1121         if (IS->Live)
1122           Sections.push_back(IS);
1123   uint32_t Filler = getFiller();
1124   if (Filler)
1125     fill(Buf, Sections.empty() ? Sec->Size : Sections[0]->OutSecOff, Filler);
1126
1127   parallelForEachN(0, Sections.size(), [=](size_t I) {
1128     InputSection *IS = Sections[I];
1129     IS->writeTo<ELFT>(Buf);
1130
1131     // Fill gaps between sections.
1132     if (Filler) {
1133       uint8_t *Start = Buf + IS->OutSecOff + IS->getSize();
1134       uint8_t *End;
1135       if (I + 1 == Sections.size())
1136         End = Buf + Sec->Size;
1137       else
1138         End = Buf + Sections[I + 1]->OutSecOff;
1139       fill(Start, End - Start, Filler);
1140     }
1141   });
1142
1143   // Linker scripts may have BYTE()-family commands with which you
1144   // can write arbitrary bytes to the output. Process them if any.
1145   for (BaseCommand *Base : Commands)
1146     if (auto *Data = dyn_cast<BytesDataCommand>(Base))
1147       writeInt(Buf + Data->Offset, Data->Expression().getValue(), Data->Size);
1148 }
1149
1150 bool LinkerScript::hasLMA(OutputSection *Sec) {
1151   if (OutputSectionCommand *Cmd = getCmd(Sec))
1152     if (Cmd->LMAExpr)
1153       return true;
1154   return false;
1155 }
1156
1157 ExprValue LinkerScript::getSymbolValue(const Twine &Loc, StringRef S) {
1158   if (S == ".")
1159     return {CurOutSec, Dot - CurOutSec->Addr};
1160   if (SymbolBody *B = findSymbol(S)) {
1161     if (auto *D = dyn_cast<DefinedRegular>(B))
1162       return {D->Section, D->Value};
1163     if (auto *C = dyn_cast<DefinedCommon>(B))
1164       return {InX::Common, C->Offset};
1165   }
1166   error(Loc + ": symbol not found: " + S);
1167   return 0;
1168 }
1169
1170 bool LinkerScript::isDefined(StringRef S) { return findSymbol(S) != nullptr; }
1171
1172 // Returns indices of ELF headers containing specific section. Each index is a
1173 // zero based number of ELF header listed within PHDRS {} script block.
1174 std::vector<size_t> LinkerScript::getPhdrIndices(OutputSection *Sec) {
1175   if (OutputSectionCommand *Cmd = getCmd(Sec)) {
1176     std::vector<size_t> Ret;
1177     for (StringRef PhdrName : Cmd->Phdrs)
1178       Ret.push_back(getPhdrIndex(Cmd->Location, PhdrName));
1179     return Ret;
1180   }
1181   return {};
1182 }
1183
1184 size_t LinkerScript::getPhdrIndex(const Twine &Loc, StringRef PhdrName) {
1185   size_t I = 0;
1186   for (PhdrsCommand &Cmd : Opt.PhdrsCommands) {
1187     if (Cmd.Name == PhdrName)
1188       return I;
1189     ++I;
1190   }
1191   error(Loc + ": section header '" + PhdrName + "' is not listed in PHDRS");
1192   return 0;
1193 }
1194
1195 template void OutputSectionCommand::writeTo<ELF32LE>(uint8_t *Buf);
1196 template void OutputSectionCommand::writeTo<ELF32BE>(uint8_t *Buf);
1197 template void OutputSectionCommand::writeTo<ELF64LE>(uint8_t *Buf);
1198 template void OutputSectionCommand::writeTo<ELF64BE>(uint8_t *Buf);
1199
1200 template void OutputSectionCommand::maybeCompress<ELF32LE>();
1201 template void OutputSectionCommand::maybeCompress<ELF32BE>();
1202 template void OutputSectionCommand::maybeCompress<ELF64LE>();
1203 template void OutputSectionCommand::maybeCompress<ELF64BE>();