diff --git a/lld/ELF/LinkerScript.h b/lld/ELF/LinkerScript.h
index bdfcb7d..edda27b 100644
--- a/lld/ELF/LinkerScript.h
+++ b/lld/ELF/LinkerScript.h
@@ -20,7 +20,23 @@
 namespace elf2 {
 
 class ScriptParser;
+template <class ELFT> class InputSectionBase;
 
+// This class represents each rule in SECTIONS command.
+class SectionRule {
+public:
+  SectionRule(StringRef D, StringRef S) : Dest(D), SectionPattern(S) {}
+
+  // Returns true if S should be in Dest section.
+  template <class ELFT> bool match(InputSectionBase<ELFT> *S);
+
+  StringRef Dest;
+
+private:
+  StringRef SectionPattern;
+};
+
+// This is a runner of the linker script.
 class LinkerScript {
   friend class ScriptParser;
 
@@ -29,14 +45,13 @@
   // this object and Config.
   void read(MemoryBufferRef MB);
 
-  StringRef getOutputSection(StringRef InputSection);
-  bool isDiscarded(StringRef InputSection);
+  template <class ELFT> StringRef getOutputSection(InputSectionBase<ELFT> *S);
+  template <class ELFT> bool isDiscarded(InputSectionBase<ELFT> *S);
   int compareSections(StringRef A, StringRef B);
 
 private:
-  // A map for SECTIONS command. The key is input section name
-  // and the value is the corresponding output section name.
-  llvm::DenseMap<StringRef, StringRef> Sections;
+  // SECTIONS commands.
+  std::vector<SectionRule> Sections;
 
   // Output sections are sorted by this order.
   std::vector<StringRef> SectionOrder;
