Rename InputSectionDescription SectionPattern.

[ruiu]

Summary

"InputSectionDescription" is a bad name for a class that is used very
frequently, which hurts code readability. We need a shorter, less
descriptive name for a common concept. At least that's how we name classes
in lld. Originally, that class was not intended to be used at many places,
but it has grown beyond my expectation. It should have been given a
shorter name from the beginning.

We had "SectionPattern" class. In this patch, that class was renamed
"Wildcard".

[grimar]

lld/ELF/Arch/ARM.cpp

40

This just should have been named IS initially it seems.

lld/ELF/LinkerScript.h

146

SectionPattern -> Wildcard renaming looks good to me.

It also matches the linker script doc and sounds IMO better than SectionPattern:
https://sourceware.org/binutils/docs/ld/Input-Section-Wildcards.html#Input-Section-Wildcards

161

Honestly, I do not feel SectionPattern is a better name.

As far I remember we named it InputSectionDescription because it was named like that in the ld documentation:
https://sourceware.org/binutils/docs/ld/Input-Section-Basics.html
And I think we usually tried to follow the documented names in such cases, even if they were not ideal. Though in this case
I see probably see nothing wrong with the naming in the documentation.

What about renaming to SectionDescription? It is also short.

lld/ELF/AArch64ErrataFix.h

 #include <map>
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class Defined;
 class InputSection;
-struct InputSectionDescription;
+struct SectionPattern;
 class OutputSection;
 class Patch843419Section;
 
 class AArch64Err843419Patcher {
 public:
   // return true if Patches have been added to the OutputSections.
   bool createFixes();
 
 private:
-  std::vector<Patch843419Section *>
-  patchInputSectionDescription(InputSectionDescription &ISD);
+  std::vector<Patch843419Section *> patchSectionPattern(SectionPattern &Pat);
 
-  void insertPatches(InputSectionDescription &ISD,
+  void insertPatches(SectionPattern &Pat,
                      std::vector<Patch843419Section *> &Patches);
 
   void init();
 
   // A cache of the mapping symbols defined by the InputSecion sorted in order
   // of ascending value with redundant symbols removed. These describe
   // the ranges of code and data in an executable InputSection.
   std::map<InputSection *, std::vector<const Defined *>> SectionMap;
 
   bool Initialized = false;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/AArch64ErrataFix.cpp

MapSyms.erase(
                              (IsDataMapSymbol(A) && IsDataMapSymbol(B));
                     }),
         MapSyms.end());
   }
   Initialized = true;
 }
 
 // Insert the PatchSections we have created back into the
-// InputSectionDescription. As inserting patches alters the addresses of
+// SectionPattern. As inserting patches alters the addresses of
 // InputSections that follow them, we try and place the patches after all the
 // executable sections, although we may need to insert them earlier if the
-// InputSectionDescription is larger than the maximum branch range.
+// SectionPattern is larger than the maximum branch range.
 void AArch64Err843419Patcher::insertPatches(
-    InputSectionDescription &ISD, std::vector<Patch843419Section *> &Patches) {
+    SectionPattern &Pat, std::vector<Patch843419Section *> &Patches) {
   uint64_t ISLimit;
-  uint64_t PrevISLimit = ISD.Sections.front()->OutSecOff;
+  uint64_t PrevISLimit = Pat.Sections.front()->OutSecOff;
   uint64_t PatchUpperBound = PrevISLimit + Target->getThunkSectionSpacing();
 
   // Set the OutSecOff of patches to the place where we want to insert them.
   // We use a similar strategy to Thunk placement. Place patches roughly
   // every multiple of maximum branch range.
   auto PatchIt = Patches.begin();
   auto PatchEnd = Patches.end();
-  for (const InputSection *IS : ISD.Sections) {
+  for (const InputSection *IS : Pat.Sections) {
     ISLimit = IS->OutSecOff + IS->getSize();
     if (ISLimit > PatchUpperBound) {
       while (PatchIt != PatchEnd) {
         if ((*PatchIt)->getLDSTAddr() >= PrevISLimit)
           break;
         (*PatchIt)->OutSecOff = PrevISLimit;
         ++PatchIt;
       }
       PatchUpperBound = PrevISLimit + Target->getThunkSectionSpacing();
     }
     PrevISLimit = ISLimit;
   }
   for (; PatchIt != PatchEnd; ++PatchIt) {
     (*PatchIt)->OutSecOff = ISLimit;
   }
 
   // merge all patch sections. We use the OutSecOff assigned above to
   // determine the insertion point. This is ok as we only merge into an
-  // InputSectionDescription once per pass, and at the end of the pass
+  // SectionPattern once per pass, and at the end of the pass
   // assignAddresses() will recalculate all the OutSecOff values.
   std::vector<InputSection *> Tmp;
-  Tmp.reserve(ISD.Sections.size() + Patches.size());
+  Tmp.reserve(Pat.Sections.size() + Patches.size());
   auto MergeCmp = [](const InputSection *A, const InputSection *B) {
     if (A->OutSecOff < B->OutSecOff)
       return true;
     if (A->OutSecOff == B->OutSecOff && isa<Patch843419Section>(A) &&
         !isa<Patch843419Section>(B))
       return true;
     return false;
   };
-  std::merge(ISD.Sections.begin(), ISD.Sections.end(), Patches.begin(),
+  std::merge(Pat.Sections.begin(), Pat.Sections.end(), Patches.begin(),
              Patches.end(), std::back_inserter(Tmp), MergeCmp);
-  ISD.Sections = std::move(Tmp);
+  Pat.Sections = std::move(Tmp);
 }
 
 // Given an erratum sequence that starts at address AdrpAddr, with an
 // instruction that we need to patch at PatcheeOffset from the start of
 // InputSection IS, create a Patch843419 Section and add it to the
 // Patches that we need to insert.
 static void implementPatch(uint64_t AdrpAddr, uint64_t PatcheeOffset,
                            InputSection *IS,
static void implementPatch(uint64_t AdrpAddr, uint64_t PatcheeOffset,
   if (RelIt != IS->Relocations.end()) {
     PS->Relocations.push_back(
         {RelIt->Expr, RelIt->Type, 0, RelIt->Addend, RelIt->Sym});
     *RelIt = MakeRelToPatch(PatcheeOffset, PS->PatchSym);
   } else
     IS->Relocations.push_back(MakeRelToPatch(PatcheeOffset, PS->PatchSym));
 }
 
-// Scan all the instructions in InputSectionDescription, for each instance of
+// Scan all the instructions in SectionPattern, for each instance of
 // the erratum sequence create a Patch843419Section. We return the list of
-// Patch843419Sections that need to be applied to ISD.
+// Patch843419Sections that need to be applied to Pat.
 std::vector<Patch843419Section *>
-AArch64Err843419Patcher::patchInputSectionDescription(
-    InputSectionDescription &ISD) {
+AArch64Err843419Patcher::patchSectionPattern(SectionPattern &Pat) {
   std::vector<Patch843419Section *> Patches;
-  for (InputSection *IS : ISD.Sections) {
+  for (InputSection *IS : Pat.Sections) {
     //  LLD doesn't use the erratum sequence in SyntheticSections.
     if (isa<SyntheticSection>(IS))
       continue;
     // Use SectionMap to make sure we only scan code and not inline data.
     // We have already sorted MapSyms in ascending order and removed consecutive
     // mapping symbols of the same type. Our range of executable instructions to
     // scan is therefore [CodeSym->Value, DataSym->Value) or [CodeSym->Value,
     // section size).
while (CodeSym != MapSyms.end()) {
       if (DataSym == MapSyms.end())
         break;
       CodeSym = std::next(DataSym);
     }
   }
   return Patches;
 }
 
-// For each InputSectionDescription make one pass over the executable sections
+// For each SectionPattern make one pass over the executable sections
 // looking for the erratum sequence; creating a synthetic Patch843419Section
 // for each instance found. We insert these synthetic patch sections after the
-// executable code in each InputSectionDescription.
+// executable code in each SectionPattern.
 //
 // PreConditions:
 // The Output and Input Sections have had their final addresses assigned.
 //
 // PostConditions:
 // Returns true if at least one patch was added. The addresses of the
 // Ouptut and Input Sections may have been changed.
 // Returns false if no patches were required and no changes were made.
 bool AArch64Err843419Patcher::createFixes() {
   if (Initialized == false)
     init();
 
   bool AddressesChanged = false;
   for (OutputSection *OS : OutputSections) {
     if (!(OS->Flags & SHF_ALLOC) || !(OS->Flags & SHF_EXECINSTR))
       continue;
     for (BaseCommand *BC : OS->SectionCommands)
-      if (auto *ISD = dyn_cast<InputSectionDescription>(BC)) {
-        std::vector<Patch843419Section *> Patches =
-            patchInputSectionDescription(*ISD);
+      if (auto *Pat = dyn_cast<SectionPattern>(BC)) {
+        std::vector<Patch843419Section *> Patches = patchSectionPattern(*Pat);
         if (!Patches.empty()) {
-          insertPatches(*ISD, Patches);
+          insertPatches(*Pat, Patches);
           AddressesChanged = true;
         }
       }
   }
   return AddressesChanged;
 }

lld/ELF/Arch/ARM.cpp

public:
   RelType getDynRel(RelType Type) const override;
   int64_t getImplicitAddend(const uint8_t *Buf, RelType Type) const override;
   void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writeIgotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void addPltSymbols(InputSection &IS, uint64_t Off) const override;
-  void addPltHeaderSymbols(InputSection &ISD) const override;
+  void addPltHeaderSymbols(InputSection &Pat) const override;
   bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
                   uint64_t BranchAddr, const Symbol &S) const override;
   uint32_t getThunkSectionSpacing() const override;
   bool inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
 };
 } // namespace
 

lld/ELF/LinkerScript.h

 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class Defined;
 class InputSection;
 class InputSectionBase;
-class InputSectionBase;
 class OutputSection;
 class SectionBase;
 class Symbol;
 class ThunkSection;
 
 // This represents an r-value in the linker script.
 struct ExprValue {
   ExprValue(SectionBase *Sec, bool ForceAbsolute, uint64_t Val,
struct MemoryRegion {
   uint32_t Flags;
   uint32_t NegFlags;
   uint64_t CurPos = 0;
 };
 
 // This struct represents one section match pattern in SECTIONS() command.
 // It can optionally have negative match pattern for EXCLUDED_FILE command.
 // Also it may be surrounded with SORT() command, so contains sorting rules.
-struct SectionPattern {
-  SectionPattern(StringMatcher &&Pat1, StringMatcher &&Pat2)
+struct Wildcard {
+  Wildcard(StringMatcher &&Pat1, StringMatcher &&Pat2)
       : ExcludedFilePat(Pat1), SectionPat(Pat2) {}
 
   StringMatcher ExcludedFilePat;
   StringMatcher SectionPat;
   SortSectionPolicy SortOuter;
   SortSectionPolicy SortInner;
 };
 
-struct InputSectionDescription : BaseCommand {
-  InputSectionDescription(StringRef FilePattern)
+// This class represents the "input section description" which is the most
+// common output section command. An example is "*(.text)" which specifies .text
+// sections in all input files.
+//
+// https://sourceware.org/binutils/docs/ld/Input-Section-Basics.html
+struct SectionPattern : BaseCommand {
+  SectionPattern(StringRef FilePattern)
       : BaseCommand(InputSectionKind), FilePat(FilePattern) {}
 
   static bool classof(const BaseCommand *C) {
     return C->Kind == InputSectionKind;
   }
 
   StringMatcher FilePat;
 
-  // Input sections that matches at least one of SectionPatterns
-  // will be associated with this InputSectionDescription.
-  std::vector<SectionPattern> SectionPatterns;
+  // Input sections that matches at least one of Wildcards
+  // will be associated with this SectionPattern.
+  std::vector<Wildcard> Wildcards;
 
   std::vector<InputSection *> Sections;
 
   // Temporary record of synthetic ThunkSection instances and the pass that
   // they were created in. This is used to insert newly created ThunkSections
   // into Sections at the end of a createThunks() pass.
   std::vector<std::pair<ThunkSection *, uint32_t>> ThunkSections;
 };
class LinkerScript final {
   llvm::DenseMap<StringRef, OutputSection *> NameToOutputSection;
 
   void addSymbol(SymbolAssignment *Cmd);
   void assignSymbol(SymbolAssignment *Cmd, bool InSec);
   void setDot(Expr E, const Twine &Loc, bool InSec);
   void expandOutputSection(uint64_t Size);
   void expandMemoryRegions(uint64_t Size);
 
-  std::vector<InputSection *>
-  computeInputSections(const InputSectionDescription *);
+  std::vector<InputSection *> computeInputSections(const SectionPattern *);
 
   std::vector<InputSection *> createInputSectionList(OutputSection &Cmd);
 
   std::vector<size_t> getPhdrIndices(OutputSection *Sec);
 
   MemoryRegion *findMemoryRegion(OutputSection *Sec);
 
   void switchTo(OutputSection *Sec);
public:
   // PHDRS command list.
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool HasSectionsCommand = false;
   bool ErrorOnMissingSection = false;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
-  std::vector<InputSectionDescription *> KeptSections;
+  std::vector<SectionPattern *> KeptSections;
 
   // A map from memory region name to a memory region descriptor.
   llvm::MapVector<llvm::StringRef, MemoryRegion *> MemoryRegions;
 
   // A list of symbols referenced by the script.
   std::vector<llvm::StringRef> ReferencedSymbols;
 
   // Used to implement INSERT [AFTER|BEFORE]. Contains commands that need

lld/ELF/LinkerScript.cpp

if (File->ArchiveName.empty())
     return File->getName();
   return (File->ArchiveName + "(" + File->getName() + ")").str();
 }
 
 bool LinkerScript::shouldKeep(InputSectionBase *S) {
   if (KeptSections.empty())
     return false;
   std::string Filename = getFilename(S->File);
-  for (InputSectionDescription *ID : KeptSections)
+  for (SectionPattern *ID : KeptSections)
     if (ID->FilePat.match(Filename))
-      for (SectionPattern &P : ID->SectionPatterns)
+      for (Wildcard &P : ID->Wildcards)
         if (P.SectionPat.match(S->Name))
           return true;
   return false;
 }
 
 // A helper function for the SORT() command.
 static std::function<bool(InputSectionBase *, InputSectionBase *)>
 getComparator(SortSectionPolicy K) {

 // behavior we have here is a bit complicated. Here are the rules.
 //
 // 1. If two SORT commands are given, --sort-section is ignored.
 // 2. If one SORT command is given, and if it is not SORT_NONE,
 //    --sort-section is handled as an inner SORT command.
 // 3. If one SORT command is given, and if it is SORT_NONE, don't sort.
 // 4. If no SORT command is given, sort according to --sort-section.
 static void sortInputSections(MutableArrayRef<InputSection *> Vec,
-                              const SectionPattern &Pat) {
+                              const Wildcard &Pat) {
   if (Pat.SortOuter == SortSectionPolicy::None)
     return;
 
   if (Pat.SortInner == SortSectionPolicy::Default)
     sortSections(Vec, Config->SortSection);
   else
     sortSections(Vec, Pat.SortInner);
   sortSections(Vec, Pat.SortOuter);
 }
 
-// Compute and remember which sections the InputSectionDescription matches.
+// Compute and remember which sections the SectionPattern matches.
 std::vector<InputSection *>
-LinkerScript::computeInputSections(const InputSectionDescription *Cmd) {
+LinkerScript::computeInputSections(const SectionPattern *Cmd) {
   std::vector<InputSection *> Ret;
 
   // Collects all sections that satisfy constraints of Cmd.
-  for (const SectionPattern &Pat : Cmd->SectionPatterns) {
+  for (const Wildcard &Pat : Cmd->Wildcards) {
     size_t SizeBefore = Ret.size();
 
     for (InputSectionBase *Sec : InputSections) {
       if (!Sec->Live || Sec->Assigned)
         continue;
 
       // For -emit-relocs we have to ignore entries like
       //   .rela.dyn : { *(.rela.data) }
void LinkerScript::discard(ArrayRef<InputSection *> V) {
   }
 }
 
 std::vector<InputSection *>
 LinkerScript::createInputSectionList(OutputSection &OutCmd) {
   std::vector<InputSection *> Ret;
 
   for (BaseCommand *Base : OutCmd.SectionCommands) {
-    if (auto *Cmd = dyn_cast<InputSectionDescription>(Base)) {
+    if (auto *Cmd = dyn_cast<SectionPattern>(Base)) {
       Cmd->Sections = computeInputSections(Cmd);
       Ret.insert(Ret.end(), Cmd->Sections.begin(), Cmd->Sections.end());
     }
   }
   return Ret;
 }
 
 void LinkerScript::processSectionCommands() {
if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
       Dot += Cmd->Size;
       expandOutputSection(Cmd->Size);
       continue;
     }
 
     // Handle a single input section description command.
     // It calculates and assigns the offsets for each section and also
     // updates the output section size.
-    for (InputSection *Sec : cast<InputSectionDescription>(Base)->Sections)
+    for (InputSection *Sec : cast<SectionPattern>(Base)->Sections)
       output(Sec);
   }
 }
 
 static bool isDiscardable(OutputSection &Sec) {
   // We do not remove empty sections that are explicitly
   // assigned to any segment.
   if (!Sec.Phdrs.empty())
     return false;
 
   // We do not want to remove sections that reference symbols in address and
   // other expressions. We add script symbols as undefined, and want to ensure
   // all of them are defined in the output, hence have to keep them.
   if (Sec.ExpressionsUseSymbols)
     return false;
 
   for (BaseCommand *Base : Sec.SectionCommands) {
     if (auto Cmd = dyn_cast<SymbolAssignment>(Base))
       // Don't create empty output sections just for unreferenced PROVIDE
       // symbols.
       if (Cmd->Name != "." && !Cmd->Sym)
         continue;
 
-    if (!isa<InputSectionDescription>(*Base))
+    if (!isa<SectionPattern>(*Base))
       return false;
   }
   return true;
 }
 
 void LinkerScript::adjustSectionsBeforeSorting() {
   // If the output section contains only symbol assignments, create a
   // corresponding output section. The issue is what to do with linker script

lld/ELF/MapFile.cpp

for (BaseCommand *Base : Script->SectionCommands) {
     }
 
     auto *OSec = cast<OutputSection>(Base);
     writeHeader(OS, OSec->Addr, OSec->getLMA(), OSec->Size, OSec->Alignment);
     OS << OSec->Name << '\n';
 
     // Dump symbols for each input section.
     for (BaseCommand *Base : OSec->SectionCommands) {
-      if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
-        for (InputSection *IS : ISD->Sections) {
+      if (auto *Pat = dyn_cast<SectionPattern>(Base)) {
+        for (InputSection *IS : Pat->Sections) {
           if (IS == In.EhFrame) {
             printEhFrame(OS, OSec);
             continue;
           }
 
           writeHeader(OS, IS->getVA(0), OSec->getLMA() + IS->getOffset(0),
                       IS->getSize(), IS->Alignment);
           OS << Indent8 << toString(IS) << '\n';

lld/ELF/OutputSections.cpp

void OutputSection::addSection(InputSection *IS) {
   // If this section contains a table of fixed-size entries, sh_entsize
   // holds the element size. If it contains elements of different size we
   // set sh_entsize to 0.
   if (Entsize != IS->Entsize)
     Entsize = 0;
 
   if (!IS->Assigned) {
     IS->Assigned = true;
-    if (SectionCommands.empty() ||
-        !isa<InputSectionDescription>(SectionCommands.back()))
-      SectionCommands.push_back(make<InputSectionDescription>(""));
-    auto *ISD = cast<InputSectionDescription>(SectionCommands.back());
-    ISD->Sections.push_back(IS);
+    if (SectionCommands.empty() || !isa<SectionPattern>(SectionCommands.back()))
+      SectionCommands.push_back(make<SectionPattern>(""));
+    auto *Pat = cast<SectionPattern>(SectionCommands.back());
+    Pat->Sections.push_back(IS);
   }
 }
 
 static void sortByOrder(MutableArrayRef<InputSection *> In,
                         llvm::function_ref<int(InputSectionBase *S)> Order) {
   typedef std::pair<int, InputSection *> Pair;
   auto Comp = [](const Pair &A, const Pair &B) { return A.first < B.first; };
 

 
 bool OutputSection::classof(const BaseCommand *C) {
   return C->Kind == OutputSectionKind;
 }
 
 void OutputSection::sort(llvm::function_ref<int(InputSectionBase *S)> Order) {
   assert(Live);
   for (BaseCommand *B : SectionCommands)
-    if (auto *ISD = dyn_cast<InputSectionDescription>(B))
-      sortByOrder(ISD->Sections, Order);
+    if (auto *Pat = dyn_cast<SectionPattern>(B))
+      sortByOrder(Pat->Sections, Order);
 }
 
 // Fill [Buf, Buf + Size) with Filler.
 // This is used for linker script "=fillexp" command.
 static void fill(uint8_t *Buf, size_t Size, uint32_t Filler) {
   size_t I = 0;
   for (; I + 4 < Size; I += 4)
     memcpy(Buf + I, &Filler, 4);
static bool compCtors(const InputSection *A, const InputSection *B) {
   return X < Y;
 }
 
 // Sorts input sections by the special rules for .ctors and .dtors.
 // Unfortunately, the rules are different from the one for .{init,fini}_array.
 // Read the comment above.
 void OutputSection::sortCtorsDtors() {
   assert(SectionCommands.size() == 1);
-  auto *ISD = cast<InputSectionDescription>(SectionCommands[0]);
-  std::stable_sort(ISD->Sections.begin(), ISD->Sections.end(), compCtors);
+  auto *Pat = cast<SectionPattern>(SectionCommands[0]);
+  std::stable_sort(Pat->Sections.begin(), Pat->Sections.end(), compCtors);
 }
 
 // If an input string is in the form of "foo.N" where N is a number,
 // return N. Otherwise, returns 65536, which is one greater than the
 // lowest priority.
 int elf::getPriority(StringRef S) {
   size_t Pos = S.rfind('.');
   if (Pos == StringRef::npos)
     return 65536;
   int V;
   if (!to_integer(S.substr(Pos + 1), V, 10))
     return 65536;
   return V;
 }
 
 std::vector<InputSection *> elf::getInputSections(OutputSection *OS) {
   std::vector<InputSection *> Ret;
   for (BaseCommand *Base : OS->SectionCommands)
-    if (auto *ISD = dyn_cast<InputSectionDescription>(Base))
-      Ret.insert(Ret.end(), ISD->Sections.begin(), ISD->Sections.end());
+    if (auto *Pat = dyn_cast<SectionPattern>(Base))
+      Ret.insert(Ret.end(), Pat->Sections.begin(), Pat->Sections.end());
   return Ret;
 }
 
 // Sorts input sections by section name suffixes, so that .foo.N comes
 // before .foo.M if N < M. Used to sort .{init,fini}_array.N sections.
 // We want to keep the original order if the priorities are the same
 // because the compiler keeps the original initialization order in a
 // translation unit and we need to respect that.

lld/ELF/Relocations.h

bool operator()(uint64_t Val, const Relocation &Rel) {
     return Val < Rel.Offset;
   }
 };
 
 template <class ELFT> void scanRelocations(InputSectionBase &);
 
 class ThunkSection;
 class Thunk;
-struct InputSectionDescription;
+struct SectionPattern;
 
 class ThunkCreator {
 public:
   // Return true if Thunks have been added to OutputSections
   bool createThunks(ArrayRef<OutputSection *> OutputSections);
 
   // The number of completed passes of createThunks this permits us
   // to do one time initialization on Pass 0 and put a limit on the
   // number of times it can be called to prevent infinite loops.
   uint32_t Pass = 0;
 
 private:
   void mergeThunks(ArrayRef<OutputSection *> OutputSections);
 
-  ThunkSection *getISDThunkSec(OutputSection *OS, InputSection *IS,
-                               InputSectionDescription *ISD, uint32_t Type,
+  ThunkSection *getPatThunkSec(OutputSection *OS, InputSection *IS,
+                               SectionPattern *Pat, uint32_t Type,
                                uint64_t Src);
 
   ThunkSection *getISThunkSec(InputSection *IS);
 
   void createInitialThunkSections(ArrayRef<OutputSection *> OutputSections);
 
   std::pair<Thunk *, bool> getThunk(Symbol &Sym, RelType Type, uint64_t Src);
 
-  ThunkSection *addThunkSection(OutputSection *OS, InputSectionDescription *,
+  ThunkSection *addThunkSection(OutputSection *OS, SectionPattern *,
                                 uint64_t Off);
 
   bool normalizeExistingThunk(Relocation &Rel, uint64_t Src);
 
   // Record all the available Thunks for a Symbol
   llvm::DenseMap<std::pair<SectionBase *, uint64_t>, std::vector<Thunk *>>
       ThunkedSymbolsBySection;
   llvm::DenseMap<Symbol *, std::vector<Thunk *>> ThunkedSymbols;

lld/ELF/Relocations.cpp

if (A->OutSecOff == B->OutSecOff) {
     if (TA && !TB && !TA->getTargetInputSection())
       return true;
   }
 
   return false;
 }
 
 // Call Fn on every executable InputSection accessed via the linker script
-// InputSectionDescription::Sections.
-static void forEachInputSectionDescription(
+// SectionPattern::Sections.
+static void forEachSectionPattern(
     ArrayRef<OutputSection *> OutputSections,
-    llvm::function_ref<void(OutputSection *, InputSectionDescription *)> Fn) {
+    llvm::function_ref<void(OutputSection *, SectionPattern *)> Fn) {
   for (OutputSection *OS : OutputSections) {
     if (!(OS->Flags & SHF_ALLOC) || !(OS->Flags & SHF_EXECINSTR))
       continue;
     for (BaseCommand *BC : OS->SectionCommands)
-      if (auto *ISD = dyn_cast<InputSectionDescription>(BC))
-        Fn(OS, ISD);
+      if (auto *Pat = dyn_cast<SectionPattern>(BC))
+        Fn(OS, Pat);
   }
 }
 
 // Thunk Implementation
 //
 // Thunks (sometimes called stubs, veneers or branch islands) are small pieces
 // of code that the linker inserts inbetween a caller and a callee. The thunks
 // are added at link time rather than compile time as the decision on whether

 // possible choices given that the maximum range from the caller is usually
 // much larger than the average InputSection size. Desirable properties include:
 // - Maximize reuse of thunks by multiple callers
 // - Minimize number of ThunkSections to simplify insertion
 // - Handle impact of already added Thunks on addresses
 // - Simple to understand and implement
 //
 // In lld for the first pass, we pre-create one or more ThunkSections per
-// InputSectionDescription at Target specific intervals. A ThunkSection is
+// SectionPattern at Target specific intervals. A ThunkSection is
 // placed so that the estimated end of the ThunkSection is within range of the
-// start of the InputSectionDescription or the previous ThunkSection. For
+// start of the SectionPattern or the previous ThunkSection. For
 // example:
-// InputSectionDescription
+// SectionPattern
 // Section 0
 // ...
 // Section N
 // ThunkSection 0
 // Section N + 1
 // ...
 // Section N + K
 // Thunk Section 1

 // Remove ThunkSections that are empty, this should only be the initial set
 // precreated on pass 0.
 
 // Insert the Thunks for OutputSection OS into their designated place
 // in the Sections vector, and recalculate the InputSection output section
 // offsets.
 // This may invalidate any output section offsets stored outside of InputSection
 void ThunkCreator::mergeThunks(ArrayRef<OutputSection *> OutputSections) {
-  forEachInputSectionDescription(
-      OutputSections, [&](OutputSection *OS, InputSectionDescription *ISD) {
-        if (ISD->ThunkSections.empty())
+  forEachSectionPattern(
+      OutputSections, [&](OutputSection *OS, SectionPattern *Pat) {
+        if (Pat->ThunkSections.empty())
           return;
 
         // Remove any zero sized precreated Thunks.
-        llvm::erase_if(ISD->ThunkSections,
+        llvm::erase_if(Pat->ThunkSections,
                        [](const std::pair<ThunkSection *, uint32_t> &TS) {
                          return TS.first->getSize() == 0;
                        });
 
-        // ISD->ThunkSections contains all created ThunkSections, including
+        // Pat->ThunkSections contains all created ThunkSections, including
         // those inserted in previous passes. Extract the Thunks created this
         // pass and order them in ascending OutSecOff.
         std::vector<ThunkSection *> NewThunks;
-        for (const std::pair<ThunkSection *, uint32_t> TS : ISD->ThunkSections)
+        for (const std::pair<ThunkSection *, uint32_t> TS : Pat->ThunkSections)
           if (TS.second == Pass)
             NewThunks.push_back(TS.first);
         std::stable_sort(NewThunks.begin(), NewThunks.end(),
                          [](const ThunkSection *A, const ThunkSection *B) {
                            return A->OutSecOff < B->OutSecOff;
                          });
 
         // Merge sorted vectors of Thunks and InputSections by OutSecOff
         std::vector<InputSection *> Tmp;
-        Tmp.reserve(ISD->Sections.size() + NewThunks.size());
+        Tmp.reserve(Pat->Sections.size() + NewThunks.size());
 
-        std::merge(ISD->Sections.begin(), ISD->Sections.end(),
+        std::merge(Pat->Sections.begin(), Pat->Sections.end(),
                    NewThunks.begin(), NewThunks.end(), std::back_inserter(Tmp),
                    mergeCmp);
 
-        ISD->Sections = std::move(Tmp);
+        Pat->Sections = std::move(Tmp);
       });
 }
 
-// Find or create a ThunkSection within the InputSectionDescription (ISD) that
-// is in range of Src. An ISD maps to a range of InputSections described by a
+// Find or create a ThunkSection within the SectionPattern (Pat) that
+// is in range of Src. An Pat maps to a range of InputSections described by a
 // linker script section pattern such as { .text .text.* }.
-ThunkSection *ThunkCreator::getISDThunkSec(OutputSection *OS, InputSection *IS,
-                                           InputSectionDescription *ISD,
-                                           uint32_t Type, uint64_t Src) {
-  for (std::pair<ThunkSection *, uint32_t> TP : ISD->ThunkSections) {
+ThunkSection *ThunkCreator::getPatThunkSec(OutputSection *OS, InputSection *IS,
+                                           SectionPattern *Pat, uint32_t Type,
+                                           uint64_t Src) {
+  for (std::pair<ThunkSection *, uint32_t> TP : Pat->ThunkSections) {
     ThunkSection *TS = TP.first;
     uint64_t TSBase = OS->Addr + TS->OutSecOff;
     uint64_t TSLimit = TSBase + TS->getSize();
     if (Target->inBranchRange(Type, Src, (Src > TSLimit) ? TSBase : TSLimit))
       return TS;
   }
 
   // No suitable ThunkSection exists. This can happen when there is a branch
   // with lower range than the ThunkSection spacing or when there are too
   // many Thunks. Create a new ThunkSection as close to the InputSection as
   // possible. Error if InputSection is so large we cannot place ThunkSection
   // anywhere in Range.
   uint64_t ThunkSecOff = IS->OutSecOff;
   if (!Target->inBranchRange(Type, Src, OS->Addr + ThunkSecOff)) {
     ThunkSecOff = IS->OutSecOff + IS->getSize();
     if (!Target->inBranchRange(Type, Src, OS->Addr + ThunkSecOff))
       fatal("InputSection too large for range extension thunk " +
             IS->getObjMsg(Src - (OS->Addr + IS->OutSecOff)));
   }
-  return addThunkSection(OS, ISD, ThunkSecOff);
+  return addThunkSection(OS, Pat, ThunkSecOff);
 }
 
 // Add a Thunk that needs to be placed in a ThunkSection that immediately
 // precedes its Target.
 ThunkSection *ThunkCreator::getISThunkSec(InputSection *IS) {
   ThunkSection *TS = ThunkedSections.lookup(IS);
   if (TS)
     return TS;
 
   // Find InputSectionRange within Target Output Section (TOS) that the
   // InputSection (IS) that we need to precede is in.
   OutputSection *TOS = IS->getParent();
   for (BaseCommand *BC : TOS->SectionCommands) {
-    auto *ISD = dyn_cast<InputSectionDescription>(BC);
-    if (!ISD || ISD->Sections.empty())
+    auto *Pat = dyn_cast<SectionPattern>(BC);
+    if (!Pat || Pat->Sections.empty())
       continue;
 
-    InputSection *First = ISD->Sections.front();
-    InputSection *Last = ISD->Sections.back();
+    InputSection *First = Pat->Sections.front();
+    InputSection *Last = Pat->Sections.back();
 
     if (IS->OutSecOff < First->OutSecOff || Last->OutSecOff < IS->OutSecOff)
       continue;
 
-    TS = addThunkSection(TOS, ISD, IS->OutSecOff);
+    TS = addThunkSection(TOS, Pat, IS->OutSecOff);
     ThunkedSections[IS] = TS;
     return TS;
   }
 
   return nullptr;
 }
 
 // Create one or more ThunkSections per OS that can be used to place Thunks.
 // We attempt to place the ThunkSections using the following desirable
 // properties:
 // - Within range of the maximum number of callers
 // - Minimise the number of ThunkSections
 //
 // We follow a simple but conservative heuristic to place ThunkSections at
 // offsets that are multiples of a Target specific branch range.
-// For an InputSectionDescription that is smaller than the range, a single
+// For an SectionPattern that is smaller than the range, a single
 // ThunkSection at the end of the range will do.
 //
-// For an InputSectionDescription that is more than twice the size of the range,
+// For an SectionPattern that is more than twice the size of the range,
 // we place the last ThunkSection at range bytes from the end of the
-// InputSectionDescription in order to increase the likelihood that the
+// SectionPattern in order to increase the likelihood that the
 // distance from a thunk to its target will be sufficiently small to
 // allow for the creation of a short thunk.
 void ThunkCreator::createInitialThunkSections(
     ArrayRef<OutputSection *> OutputSections) {
   uint32_t ThunkSectionSpacing = Target->getThunkSectionSpacing();
 
-  forEachInputSectionDescription(
-      OutputSections, [&](OutputSection *OS, InputSectionDescription *ISD) {
-        if (ISD->Sections.empty())
+  forEachSectionPattern(
+      OutputSections, [&](OutputSection *OS, SectionPattern *Pat) {
+        if (Pat->Sections.empty())
           return;
 
-        uint32_t ISDBegin = ISD->Sections.front()->OutSecOff;
-        uint32_t ISDEnd =
-            ISD->Sections.back()->OutSecOff + ISD->Sections.back()->getSize();
+        uint32_t PatBegin = Pat->Sections.front()->OutSecOff;
+        uint32_t PatEnd =
+            Pat->Sections.back()->OutSecOff + Pat->Sections.back()->getSize();
         uint32_t LastThunkLowerBound = -1;
-        if (ISDEnd - ISDBegin > ThunkSectionSpacing * 2)
-          LastThunkLowerBound = ISDEnd - ThunkSectionSpacing;
+        if (PatEnd - PatBegin > ThunkSectionSpacing * 2)
+          LastThunkLowerBound = PatEnd - ThunkSectionSpacing;
 
         uint32_t ISLimit;
-        uint32_t PrevISLimit = ISDBegin;
-        uint32_t ThunkUpperBound = ISDBegin + ThunkSectionSpacing;
+        uint32_t PrevISLimit = PatBegin;
+        uint32_t ThunkUpperBound = PatBegin + ThunkSectionSpacing;
 
-        for (const InputSection *IS : ISD->Sections) {
+        for (const InputSection *IS : Pat->Sections) {
           ISLimit = IS->OutSecOff + IS->getSize();
           if (ISLimit > ThunkUpperBound) {
-            addThunkSection(OS, ISD, PrevISLimit);
+            addThunkSection(OS, Pat, PrevISLimit);
             ThunkUpperBound = PrevISLimit + ThunkSectionSpacing;
           }
           if (ISLimit > LastThunkLowerBound)
             break;
           PrevISLimit = ISLimit;
         }
-        addThunkSection(OS, ISD, ISLimit);
+        addThunkSection(OS, Pat, ISLimit);
       });
 }
 
 ThunkSection *ThunkCreator::addThunkSection(OutputSection *OS,
-                                            InputSectionDescription *ISD,
-                                            uint64_t Off) {
+                                            SectionPattern *Pat, uint64_t Off) {
   auto *TS = make<ThunkSection>(OS, Off);
-  ISD->ThunkSections.push_back({TS, Pass});
+  Pat->ThunkSections.push_back({TS, Pass});
   return TS;
 }
 
 std::pair<Thunk *, bool> ThunkCreator::getThunk(Symbol &Sym, RelType Type,
                                                 uint64_t Src) {
   std::vector<Thunk *> *ThunkVec = nullptr;
 
   // We use (section, offset) pair to find the thunk position if possible so
if (Thunk *T = Thunks.lookup(Rel.Sym)) {
     Rel.Sym = &T->Destination;
     if (Rel.Sym->isInPlt())
       Rel.Expr = toPlt(Rel.Expr);
   }
   return false;
 }
 
 // Process all relocations from the InputSections that have been assigned
-// to InputSectionDescriptions and redirect through Thunks if needed. The
+// to SectionPatterns and redirect through Thunks if needed. The
 // function should be called iteratively until it returns false.
 //
 // PreConditions:
 // All InputSections that may need a Thunk are reachable from
 // OutputSectionCommands.
 //
 // All OutputSections have an address and all InputSections have an offset
 // within the OutputSection.
if (Pass == 0 && Target->getThunkSectionSpacing())
     createInitialThunkSections(OutputSections);
 
   // With Thunk Size much smaller than branch range we expect to
   // converge quickly; if we get to 10 something has gone wrong.
   if (Pass == 10)
     fatal("thunk creation not converged");
 
   // Create all the Thunks and insert them into synthetic ThunkSections. The
-  // ThunkSections are later inserted back into InputSectionDescriptions.
+  // ThunkSections are later inserted back into SectionPatterns.
   // We separate the creation of ThunkSections from the insertion of the
   // ThunkSections as ThunkSections are not always inserted into the same
-  // InputSectionDescription as the caller.
-  forEachInputSectionDescription(
-      OutputSections, [&](OutputSection *OS, InputSectionDescription *ISD) {
-        for (InputSection *IS : ISD->Sections)
+  // SectionPattern as the caller.
+  forEachSectionPattern(
+      OutputSections, [&](OutputSection *OS, SectionPattern *Pat) {
+        for (InputSection *IS : Pat->Sections)
           for (Relocation &Rel : IS->Relocations) {
             uint64_t Src = IS->getVA(Rel.Offset);
 
             // If we are a relocation to an existing Thunk, check if it is
             // still in range. If not then Rel will be altered to point to its
             // original target so another Thunk can be generated.
             if (Pass > 0 && normalizeExistingThunk(Rel, Src))
               continue;
 
             if (!Target->needsThunk(Rel.Expr, Rel.Type, IS->File, Src,
                                     *Rel.Sym))
               continue;
 
             Thunk *T;
             bool IsNew;
             std::tie(T, IsNew) = getThunk(*Rel.Sym, Rel.Type, Src);
 
             if (IsNew) {
               // Find or create a ThunkSection for the new Thunk
               ThunkSection *TS;
               if (auto *TIS = T->getTargetInputSection())
                 TS = getISThunkSec(TIS);
               else
-                TS = getISDThunkSec(OS, IS, ISD, Rel.Type, Src);
+                TS = getPatThunkSec(OS, IS, Pat, Rel.Type, Src);
               TS->addThunk(T);
               Thunks[T->getThunkTargetSym()] = T;
             }
 
             // Redirect relocation to Thunk, we never go via the PLT to a Thunk
             Rel.Sym = T->getThunkTargetSym();
             Rel.Expr = fromPlt(Rel.Expr);
           }
 
-        for (auto &P : ISD->ThunkSections)
+        for (auto &P : Pat->ThunkSections)
           AddressesChanged |= P.first->assignOffsets();
       });
 
   for (auto &P : ThunkedSections)
     AddressesChanged |= P.second->assignOffsets();
 
   // Merge all created synthetic ThunkSections back into OutputSection
   mergeThunks(OutputSections);
   ++Pass;
   return AddressesChanged;
 }
 
 template void elf::scanRelocations<ELF32LE>(InputSectionBase &);
 template void elf::scanRelocations<ELF32BE>(InputSectionBase &);
 template void elf::scanRelocations<ELF64LE>(InputSectionBase &);
 template void elf::scanRelocations<ELF64BE>(InputSectionBase &);

lld/ELF/ScriptParser.cpp

private:
   uint32_t readFill();
   uint32_t parseFill(StringRef Tok);
   bool readSectionDirective(OutputSection *Cmd, StringRef Tok1, StringRef Tok2);
   void readSectionAddressType(OutputSection *Cmd);
   OutputSection *readOverlaySectionDescription();
   OutputSection *readOutputSectionDescription(StringRef OutSec);
   std::vector<BaseCommand *> readOverlay();
   std::vector<StringRef> readOutputSectionPhdrs();
-  InputSectionDescription *readInputSectionDescription(StringRef Tok);
+  SectionPattern *readSectionPattern(StringRef Tok);
   StringMatcher readFilePatterns();
-  std::vector<SectionPattern> readInputSectionsList();
-  InputSectionDescription *readInputSectionRules(StringRef FilePattern);
+  std::vector<Wildcard> readInputSectionsList();
+  SectionPattern *readInputSectionRules(StringRef FilePattern);
   unsigned readPhdrType();
   SortSectionPolicy readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
   SymbolAssignment *readAssignment(StringRef Tok);
   std::pair<ELFKind, uint16_t> readBfdName();
   void readSort();
   Expr readAssert();
   Expr readConstant();

 //
 // For example,
 //
 // *(.foo EXCLUDE_FILE (a.o) .bar EXCLUDE_FILE (b.o) .baz)
 //
 // is parsed as ".foo", ".bar" with "a.o", and ".baz" with "b.o".
 // The semantics of that is section .foo in any file, section .bar in
 // any file but a.o, and section .baz in any file but b.o.
-std::vector<SectionPattern> ScriptParser::readInputSectionsList() {
-  std::vector<SectionPattern> Ret;
+std::vector<Wildcard> ScriptParser::readInputSectionsList() {
+  std::vector<Wildcard> Ret;
   while (!errorCount() && peek() != ")") {
     StringMatcher ExcludeFilePat;
     if (consume("EXCLUDE_FILE")) {
       expect("(");
       ExcludeFilePat = readFilePatterns();
     }
 
     std::vector<StringRef> V;

 // <patterns> ::= <section-list>
 //              | <sort> "(" <section-list> ")"
 //              | <sort> "(" <sort> "(" <section-list> ")" ")"
 //
 // <sort>     ::= "SORT" | "SORT_BY_NAME" | "SORT_BY_ALIGNMENT"
 //              | "SORT_BY_INIT_PRIORITY" | "SORT_NONE"
 //
 // <section-list> is parsed by readInputSectionsList().
-InputSectionDescription *
-ScriptParser::readInputSectionRules(StringRef FilePattern) {
-  auto *Cmd = make<InputSectionDescription>(FilePattern);
+SectionPattern *ScriptParser::readInputSectionRules(StringRef FilePattern) {
+  auto *Cmd = make<SectionPattern>(FilePattern);
   expect("(");
 
   while (!errorCount() && !consume(")")) {
     SortSectionPolicy Outer = readSortKind();
     SortSectionPolicy Inner = SortSectionPolicy::Default;
-    std::vector<SectionPattern> V;
+    std::vector<Wildcard> V;
     if (Outer != SortSectionPolicy::Default) {
       expect("(");
       Inner = readSortKind();
       if (Inner != SortSectionPolicy::Default) {
         expect("(");
         V = readInputSectionsList();
         expect(")");
       } else {
         V = readInputSectionsList();
       }
       expect(")");
     } else {
       V = readInputSectionsList();
     }
 
-    for (SectionPattern &Pat : V) {
+    for (Wildcard &Pat : V) {
       Pat.SortInner = Inner;
       Pat.SortOuter = Outer;
     }
 
-    std::move(V.begin(), V.end(), std::back_inserter(Cmd->SectionPatterns));
+    std::move(V.begin(), V.end(), std::back_inserter(Cmd->Wildcards));
   }
   return Cmd;
 }
 
-InputSectionDescription *
-ScriptParser::readInputSectionDescription(StringRef Tok) {
+SectionPattern *ScriptParser::readSectionPattern(StringRef Tok) {
   // Input section wildcard can be surrounded by KEEP.
   // https://sourceware.org/binutils/docs/ld/Input-Section-Keep.html#Input-Section-Keep
   if (Tok == "KEEP") {
     expect("(");
     StringRef FilePattern = next();
-    InputSectionDescription *Cmd = readInputSectionRules(FilePattern);
+    SectionPattern *Cmd = readInputSectionRules(FilePattern);
     expect(")");
     Script->KeptSections.push_back(Cmd);
     return Cmd;
   }
   return readInputSectionRules(Tok);
 }
 
 void ScriptParser::readSort() {
if (Tok == ";") {
       // For ELF, we should ignore.
     } else if (Tok == "FILL") {
       Cmd->Filler = readFill();
     } else if (Tok == "SORT") {
       readSort();
     } else if (Tok == "INCLUDE") {
       readInclude();
     } else if (peek() == "(") {
-      Cmd->SectionCommands.push_back(readInputSectionDescription(Tok));
+      Cmd->SectionCommands.push_back(readSectionPattern(Tok));
     } else {
       setError("unknown command " + Tok);
     }
   }
 
   if (consume(">"))
     Cmd->MemoryRegionName = next();
 

lld/ELF/SyntheticSections.cpp

template <class ELFT> void MipsGotSection::build() {
 
   // Evaluate number of "page" entries in each GOT.
   for (FileGot &Got : Gots) {
     for (std::pair<const OutputSection *, FileGot::PageBlock> &P :
          Got.PagesMap) {
       const OutputSection *OS = P.first;
       uint64_t SecSize = 0;
       for (BaseCommand *Cmd : OS->SectionCommands) {
-        if (auto *ISD = dyn_cast<InputSectionDescription>(Cmd))
-          for (InputSection *IS : ISD->Sections) {
+        if (auto *Pat = dyn_cast<SectionPattern>(Cmd))
+          for (InputSection *IS : Pat->Sections) {
             uint64_t Off = alignTo(SecSize, IS->Alignment);
             SecSize = Off + IS->getSize();
           }
       }
       P.second.Count = getMipsPageCount(SecSize);
     }
   }
 

lld/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::addSectionSymbols() {
   // relocations that point to the section. If we know that no relocation is
   // referring to a section (that happens if the section is a synthetic one), we
   // don't create a section symbol for that section.
   for (BaseCommand *Base : Script->SectionCommands) {
     auto *Sec = dyn_cast<OutputSection>(Base);
     if (!Sec)
       continue;
     auto I = llvm::find_if(Sec->SectionCommands, [](BaseCommand *Base) {
-      if (auto *ISD = dyn_cast<InputSectionDescription>(Base))
-        return !ISD->Sections.empty();
+      if (auto *Pat = dyn_cast<SectionPattern>(Base))
+        return !Pat->Sections.empty();
       return false;
     });
     if (I == Sec->SectionCommands.end())
       continue;
-    InputSection *IS = cast<InputSectionDescription>(*I)->Sections[0];
+    InputSection *IS = cast<SectionPattern>(*I)->Sections[0];
 
     // Relocations are not using REL[A] section symbols.
     if (IS->Type == SHT_REL || IS->Type == SHT_RELA)
       continue;
 
     // Unlike other synthetic sections, mergeable output sections contain data
     // copied from input sections, and there may be a relocation pointing to its
     // contents if -r or -emit-reloc are given.
static DenseMap<const InputSectionBase *, int> buildSectionOrder() {
   if (Config->WarnSymbolOrdering)
     for (auto OrderEntry : SymbolOrder)
       if (!OrderEntry.second.Present)
         warn("symbol ordering file: no such symbol: " + OrderEntry.first);
 
   return SectionOrder;
 }
 
-// Sorts the sections in ISD according to the provided section order.
+// Sorts the sections in Pat according to the provided section order.
 static void
-sortISDBySectionOrder(InputSectionDescription *ISD,
+sortPatBySectionOrder(SectionPattern *Pat,
                       const DenseMap<const InputSectionBase *, int> &Order) {
   std::vector<InputSection *> UnorderedSections;
   std::vector<std::pair<InputSection *, int>> OrderedSections;
   uint64_t UnorderedSize = 0;
 
-  for (InputSection *IS : ISD->Sections) {
+  for (InputSection *IS : Pat->Sections) {
     auto I = Order.find(IS);
     if (I == Order.end()) {
       UnorderedSections.push_back(IS);
       UnorderedSize += IS->getSize();
       continue;
     }
     OrderedSections.push_back({IS, I->second});
   }
if (Target->getThunkSectionSpacing() && !OrderedSections.empty()) {
     uint64_t UnorderedPos = 0;
     for (; InsPt != UnorderedSections.size(); ++InsPt) {
       UnorderedPos += UnorderedSections[InsPt]->getSize();
       if (UnorderedPos > UnorderedSize / 2)
         break;
     }
   }
 
-  ISD->Sections.clear();
+  Pat->Sections.clear();
   for (InputSection *IS : makeArrayRef(UnorderedSections).slice(0, InsPt))
-    ISD->Sections.push_back(IS);
+    Pat->Sections.push_back(IS);
   for (std::pair<InputSection *, int> P : OrderedSections)
-    ISD->Sections.push_back(P.first);
+    Pat->Sections.push_back(P.first);
   for (InputSection *IS : makeArrayRef(UnorderedSections).slice(InsPt))
-    ISD->Sections.push_back(IS);
+    Pat->Sections.push_back(IS);
 }
 
 static void sortSection(OutputSection *Sec,
                         const DenseMap<const InputSectionBase *, int> &Order) {
   StringRef Name = Sec->Name;
 
   // Sort input sections by section name suffixes for
   // __attribute__((init_priority(N))).
static void sortSection(OutputSection *Sec,
   // Never sort these.
   if (Name == ".init" || Name == ".fini")
     return;
 
   // Sort input sections by priority using the list provided
   // by --symbol-ordering-file.
   if (!Order.empty())
     for (BaseCommand *B : Sec->SectionCommands)
-      if (auto *ISD = dyn_cast<InputSectionDescription>(B))
-        sortISDBySectionOrder(ISD, Order);
+      if (auto *Pat = dyn_cast<SectionPattern>(B))
+        sortPatBySectionOrder(Pat, Order);
 }
 
 // If no layout was provided by linker script, we want to apply default
 // sorting for special input sections. This also handles --symbol-ordering-file.
 template <class ELFT> void Writer<ELFT>::sortInputSections() {
   // Build the order once since it is expensive.
   DenseMap<const InputSectionBase *, int> Order = buildSectionOrder();
   for (BaseCommand *Base : Script->SectionCommands)
static bool isDuplicateArmExidxSec(InputSection *Prev, InputSection *Cur) {
   return true;
 }
 
 template <class ELFT> void Writer<ELFT>::resolveShfLinkOrder() {
   for (OutputSection *Sec : OutputSections) {
     if (!(Sec->Flags & SHF_LINK_ORDER))
       continue;
 
-    // Link order may be distributed across several InputSectionDescriptions
+    // Link order may be distributed across several SectionPatterns
     // but sort must consider them all at once.
     std::vector<InputSection **> ScriptSections;
     std::vector<InputSection *> Sections;
     for (BaseCommand *Base : Sec->SectionCommands) {
-      if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
-        for (InputSection *&IS : ISD->Sections) {
+      if (auto *Pat = dyn_cast<SectionPattern>(Base)) {
+        for (InputSection *&IS : Pat->Sections) {
           ScriptSections.push_back(&IS);
           Sections.push_back(IS);
         }
       }
     }
     std::stable_sort(Sections.begin(), Sections.end(), compareByFilePosition);
 
     if (!Config->Relocatable && Config->EMachine == EM_ARM &&
if (!Config->Relocatable && Config->EMachine == EM_ARM &&
       }
     }
 
     for (int I = 0, N = Sections.size(); I < N; ++I)
       *ScriptSections[I] = Sections[I];
 
     // Remove the Sections we marked as duplicate earlier.
     for (BaseCommand *Base : Sec->SectionCommands)
-      if (auto *ISD = dyn_cast<InputSectionDescription>(Base))
-        llvm::erase_if(ISD->Sections, [](InputSection *IS) { return !IS; });
+      if (auto *Pat = dyn_cast<SectionPattern>(Base))
+        llvm::erase_if(Pat->Sections, [](InputSection *IS) { return !IS; });
   }
 }
 
 // For most RISC ISAs, we need to generate content that depends on the address
 // of InputSections. For example some architectures such as AArch64 use small
 // displacements for jump instructions that is the linker's responsibility for
 // creating range extension thunks for. As the generation of the content may
 // also alter InputSection addresses we must converge to a fixed point.
if (!SS)
       return;
     OutputSection *OS = SS->getParent();
     if (!OS || !SS->empty())
       continue;
 
     // If we reach here, then SS is an unused synthetic section and we want to
     // remove it from corresponding input section description of output section.
     for (BaseCommand *B : OS->SectionCommands)
-      if (auto *ISD = dyn_cast<InputSectionDescription>(B))
-        llvm::erase_if(ISD->Sections,
+      if (auto *Pat = dyn_cast<SectionPattern>(B))
+        llvm::erase_if(Pat->Sections,
                        [=](InputSection *IS) { return IS == SS; });
   }
 }
 
 // Returns true if a symbol can be replaced at load-time by a symbol
 // with the same name defined in other ELF executable or DSO.
 static bool computeIsPreemptible(const Symbol &B) {
   assert(!B.isLocal());