Index: ELF/InputFiles.cpp
===================================================================
--- ELF/InputFiles.cpp
+++ ELF/InputFiles.cpp
@@ -357,9 +357,9 @@
     // we see. The eglibc ARM dynamic loaders require the presence of an
     // attribute section for dlopen to work.
     // In a full implementation we would merge all attribute sections.
-    if (In<ELFT>::ARMAttributes == nullptr) {
-      In<ELFT>::ARMAttributes = make<InputSection>(this, &Sec, Name);
-      return In<ELFT>::ARMAttributes;
+    if (In::ARMAttributes == nullptr) {
+      In::ARMAttributes = make<InputSection>(this, &Sec, Name);
+      return In::ARMAttributes;
     }
     return &InputSection::Discarded;
   case SHT_RELA:
Index: ELF/InputSection.cpp
===================================================================
--- ELF/InputSection.cpp
+++ ELF/InputSection.cpp
@@ -252,7 +252,7 @@
     // section, but for --emit-relocs it is an virtual address.
     P->r_offset = RelocatedSection->OutSec->Addr +
                   RelocatedSection->getOffset(Rel.r_offset);
-    P->setSymbolAndType(In<ELFT>::SymTab->getSymbolIndex(&Body), Type,
+    P->setSymbolAndType(In::X<ELFT>::SymTab->getSymbolIndex(&Body), Type,
                         Config->isMips64EL());
 
     if (Body.Type == STT_SECTION) {
@@ -328,20 +328,20 @@
   case R_TLSDESC_CALL:
     llvm_unreachable("cannot relocate hint relocs");
   case R_TLSLD:
-    return In<ELFT>::Got->getTlsIndexOff() + A - In<ELFT>::Got->getSize();
+    return In::X<ELFT>::Got->getTlsIndexOff() + A - In::X<ELFT>::Got->getSize();
   case R_TLSLD_PC:
-    return In<ELFT>::Got->getTlsIndexVA() + A - P;
+    return In::X<ELFT>::Got->getTlsIndexVA() + A - P;
   case R_PPC_TOC:
     return getPPC64TocBase() + A;
   case R_TLSGD:
-    return In<ELFT>::Got->getGlobalDynOffset(Body) + A -
-           In<ELFT>::Got->getSize();
+    return In::X<ELFT>::Got->getGlobalDynOffset(Body) + A -
+           In::X<ELFT>::Got->getSize();
   case R_TLSGD_PC:
-    return In<ELFT>::Got->getGlobalDynAddr(Body) + A - P;
+    return In::X<ELFT>::Got->getGlobalDynAddr(Body) + A - P;
   case R_TLSDESC:
-    return In<ELFT>::Got->getGlobalDynAddr(Body) + A;
+    return In::X<ELFT>::Got->getGlobalDynAddr(Body) + A;
   case R_TLSDESC_PAGE:
-    return getAArch64Page(In<ELFT>::Got->getGlobalDynAddr(Body) + A) -
+    return getAArch64Page(In::X<ELFT>::Got->getGlobalDynAddr(Body) + A) -
            getAArch64Page(P);
   case R_PLT:
     return Body.getPltVA<ELFT>() + A;
@@ -351,13 +351,13 @@
   case R_SIZE:
     return Body.getSize<ELFT>() + A;
   case R_GOTREL:
-    return Body.getVA<ELFT>(A) - In<ELFT>::Got->getVA();
+    return Body.getVA<ELFT>(A) - In::X<ELFT>::Got->getVA();
   case R_GOTREL_FROM_END:
-    return Body.getVA<ELFT>(A) - In<ELFT>::Got->getVA() -
-           In<ELFT>::Got->getSize();
+    return Body.getVA<ELFT>(A) - In::X<ELFT>::Got->getVA() -
+           In::X<ELFT>::Got->getSize();
   case R_RELAX_TLS_GD_TO_IE_END:
   case R_GOT_FROM_END:
-    return Body.getGotOffset<ELFT>() + A - In<ELFT>::Got->getSize();
+    return Body.getGotOffset<ELFT>() + A - In::X<ELFT>::Got->getSize();
   case R_RELAX_TLS_GD_TO_IE_ABS:
   case R_GOT:
     return Body.getGotVA<ELFT>() + A;
@@ -368,9 +368,9 @@
   case R_GOT_PC:
     return Body.getGotVA<ELFT>() + A - P;
   case R_GOTONLY_PC:
-    return In<ELFT>::Got->getVA() + A - P;
+    return In::X<ELFT>::Got->getVA() + A - P;
   case R_GOTONLY_PC_FROM_END:
-    return In<ELFT>::Got->getVA() + A - P + In<ELFT>::Got->getSize();
+    return In::X<ELFT>::Got->getVA() + A - P + In::X<ELFT>::Got->getSize();
   case R_RELAX_TLS_LD_TO_LE:
   case R_RELAX_TLS_IE_TO_LE:
   case R_RELAX_TLS_GD_TO_LE:
@@ -399,26 +399,29 @@
     // If relocation against MIPS local symbol requires GOT entry, this entry
     // should be initialized by 'page address'. This address is high 16-bits
     // of sum the symbol's value and the addend.
-    return In<ELFT>::MipsGot->getVA() +
-           In<ELFT>::MipsGot->getPageEntryOffset(Body, A) -
-           In<ELFT>::MipsGot->getGp();
+    return In::X<ELFT>::MipsGot->getVA() +
+           In::X<ELFT>::MipsGot->getPageEntryOffset(Body, A) -
+           In::X<ELFT>::MipsGot->getGp();
   case R_MIPS_GOT_OFF:
   case R_MIPS_GOT_OFF32:
     // In case of MIPS if a GOT relocation has non-zero addend this addend
     // should be applied to the GOT entry content not to the GOT entry offset.
     // That is why we use separate expression type.
-    return In<ELFT>::MipsGot->getVA() +
-           In<ELFT>::MipsGot->getBodyEntryOffset(Body, A) -
-           In<ELFT>::MipsGot->getGp();
+    return In::X<ELFT>::MipsGot->getVA() +
+           In::X<ELFT>::MipsGot->getBodyEntryOffset(Body, A) -
+           In::X<ELFT>::MipsGot->getGp();
   case R_MIPS_GOTREL:
-    return Body.getVA<ELFT>(A) - In<ELFT>::MipsGot->getGp();
+    return Body.getVA<ELFT>(A) - In::X<ELFT>::MipsGot->getGp();
   case R_MIPS_TLSGD:
-    return In<ELFT>::MipsGot->getVA() + In<ELFT>::MipsGot->getTlsOffset() +
-           In<ELFT>::MipsGot->getGlobalDynOffset(Body) -
-           In<ELFT>::MipsGot->getGp();
+    return In::X<ELFT>::MipsGot->getVA() +
+           In::X<ELFT>::MipsGot->getTlsOffset() +
+           In::X<ELFT>::MipsGot->getGlobalDynOffset(Body) -
+           In::X<ELFT>::MipsGot->getGp();
   case R_MIPS_TLSLD:
-    return In<ELFT>::MipsGot->getVA() + In<ELFT>::MipsGot->getTlsOffset() +
-           In<ELFT>::MipsGot->getTlsIndexOff() - In<ELFT>::MipsGot->getGp();
+    return In::X<ELFT>::MipsGot->getVA() +
+           In::X<ELFT>::MipsGot->getTlsOffset() +
+           In::X<ELFT>::MipsGot->getTlsIndexOff() -
+           In::X<ELFT>::MipsGot->getGp();
   case R_PPC_OPD: {
     uint64_t SymVA = Body.getVA<ELFT>(A);
     // If we have an undefined weak symbol, we might get here with a symbol
Index: ELF/LinkerScript.cpp
===================================================================
--- ELF/LinkerScript.cpp
+++ ELF/LinkerScript.cpp
@@ -297,7 +297,7 @@
 void LinkerScript<ELFT>::discard(ArrayRef<InputSectionBase *> V) {
   for (InputSectionBase *S : V) {
     S->Live = false;
-    if (S == In<ELFT>::ShStrTab)
+    if (S == In::X<ELFT>::ShStrTab)
       error("discarding .shstrtab section is not allowed");
     discard(S->DependentSections);
   }
Index: ELF/OutputSections.cpp
===================================================================
--- ELF/OutputSections.cpp
+++ ELF/OutputSections.cpp
@@ -107,7 +107,7 @@
   if (isa<SyntheticSection>(First))
     return;
 
-  this->Link = In<ELFT>::SymTab->OutSec->SectionIndex;
+  this->Link = In::X<ELFT>::SymTab->OutSec->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
   InputSectionBase *S = First->getRelocatedSection<ELFT>();
Index: ELF/Relocations.cpp
===================================================================
--- ELF/Relocations.cpp
+++ ELF/Relocations.cpp
@@ -106,7 +106,7 @@
           {R_ABS, Target->TlsModuleIndexRel, Off, 0, &Body});
     else {
       SymbolBody *Dest = LD ? nullptr : &Body;
-      In<ELFT>::RelaDyn->addReloc(
+      In::X<ELFT>::RelaDyn->addReloc(
           {Target->TlsModuleIndexRel, Got, Off, false, Dest, 0});
     }
   };
@@ -122,9 +122,9 @@
       uintX_t Off = Got->getGlobalDynOffset(Body);
       addModuleReloc(Body, Got, Off, false);
       if (Body.isPreemptible())
-        In<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Got,
-                                     Off + (uintX_t)sizeof(uintX_t), false,
-                                     &Body, 0});
+        In::X<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Got,
+                                        Off + (uintX_t)sizeof(uintX_t), false,
+                                        &Body, 0});
     }
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     return 1;
@@ -146,19 +146,19 @@
   typedef typename ELFT::uint uintX_t;
 
   if (Config->EMachine == EM_ARM)
-    return handleNoRelaxTlsRelocation<ELFT>(In<ELFT>::Got, Type, Body, C,
+    return handleNoRelaxTlsRelocation<ELFT>(In::X<ELFT>::Got, Type, Body, C,
                                             Offset, Addend, Expr);
   if (Config->EMachine == EM_MIPS)
-    return handleNoRelaxTlsRelocation<ELFT>(In<ELFT>::MipsGot, Type, Body, C,
+    return handleNoRelaxTlsRelocation<ELFT>(In::X<ELFT>::MipsGot, Type, Body, C,
                                             Offset, Addend, Expr);
 
   bool IsPreemptible = isPreemptible(Body, Type);
   if (isRelExprOneOf<R_TLSDESC, R_TLSDESC_PAGE, R_TLSDESC_CALL>(Expr) &&
       Config->Shared) {
-    if (In<ELFT>::Got->addDynTlsEntry(Body)) {
-      uintX_t Off = In<ELFT>::Got->getGlobalDynOffset(Body);
-      In<ELFT>::RelaDyn->addReloc({Target->TlsDescRel, In<ELFT>::Got, Off,
-                                   !IsPreemptible, &Body, 0});
+    if (In::X<ELFT>::Got->addDynTlsEntry(Body)) {
+      uintX_t Off = In::X<ELFT>::Got->getGlobalDynOffset(Body);
+      In::X<ELFT>::RelaDyn->addReloc({Target->TlsDescRel, In::X<ELFT>::Got, Off,
+                                      !IsPreemptible, &Body, 0});
     }
     if (Expr != R_TLSDESC_CALL)
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
@@ -172,10 +172,10 @@
           {R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
       return 2;
     }
-    if (In<ELFT>::Got->addTlsIndex())
-      In<ELFT>::RelaDyn->addReloc({Target->TlsModuleIndexRel, In<ELFT>::Got,
-                                   In<ELFT>::Got->getTlsIndexOff(), false,
-                                   nullptr, 0});
+    if (In::X<ELFT>::Got->addTlsIndex())
+      In::X<ELFT>::RelaDyn->addReloc(
+          {Target->TlsModuleIndexRel, In::X<ELFT>::Got,
+           In::X<ELFT>::Got->getTlsIndexOff(), false, nullptr, 0});
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     return 1;
   }
@@ -190,19 +190,21 @@
   if (isRelExprOneOf<R_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL>(Expr) ||
       Target->isTlsGlobalDynamicRel(Type)) {
     if (Config->Shared) {
-      if (In<ELFT>::Got->addDynTlsEntry(Body)) {
-        uintX_t Off = In<ELFT>::Got->getGlobalDynOffset(Body);
-        In<ELFT>::RelaDyn->addReloc(
-            {Target->TlsModuleIndexRel, In<ELFT>::Got, Off, false, &Body, 0});
+      if (In::X<ELFT>::Got->addDynTlsEntry(Body)) {
+        uintX_t Off = In::X<ELFT>::Got->getGlobalDynOffset(Body);
+        In::X<ELFT>::RelaDyn->addReloc({Target->TlsModuleIndexRel,
+                                        In::X<ELFT>::Got, Off, false, &Body,
+                                        0});
 
         // If the symbol is preemptible we need the dynamic linker to write
         // the offset too.
         uintX_t OffsetOff = Off + (uintX_t)sizeof(uintX_t);
         if (IsPreemptible)
-          In<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, In<ELFT>::Got,
-                                       OffsetOff, false, &Body, 0});
+          In::X<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel,
+                                          In::X<ELFT>::Got, OffsetOff, false,
+                                          &Body, 0});
         else
-          In<ELFT>::Got->Relocations.push_back(
+          In::X<ELFT>::Got->Relocations.push_back(
               {R_ABS, Target->TlsOffsetRel, OffsetOff, 0, &Body});
       }
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
@@ -216,10 +218,10 @@
           {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_IE), Type,
            Offset, Addend, &Body});
       if (!Body.isInGot()) {
-        In<ELFT>::Got->addEntry(Body);
-        In<ELFT>::RelaDyn->addReloc({Target->TlsGotRel, In<ELFT>::Got,
-                                     Body.getGotOffset<ELFT>(), false, &Body,
-                                     0});
+        In::X<ELFT>::Got->addEntry(Body);
+        In::X<ELFT>::RelaDyn->addReloc({Target->TlsGotRel, In::X<ELFT>::Got,
+                                        Body.getGotOffset<ELFT>(), false, &Body,
+                                        0});
       }
       return Target->TlsGdRelaxSkip;
     }
@@ -495,7 +497,7 @@
     Sym->symbol()->IsUsedInRegularObj = true;
   }
 
-  In<ELFT>::RelaDyn->addReloc({Target->CopyRel, ISec, 0, false, SS, 0});
+  In::X<ELFT>::RelaDyn->addReloc({Target->CopyRel, ISec, 0, false, SS, 0});
 }
 
 template <class ELFT>
@@ -657,7 +659,7 @@
   bool IsWrite = C.Flags & SHF_WRITE;
 
   auto AddDyn = [=](const DynamicReloc<ELFT> &Reloc) {
-    In<ELFT>::RelaDyn->addReloc(Reloc);
+    In::X<ELFT>::RelaDyn->addReloc(Reloc);
   };
 
   const elf::ObjectFile<ELFT> *File = C.getFile<ELFT>();
@@ -722,7 +724,7 @@
     // needs it to be created. Here we request for that.
     if (isRelExprOneOf<R_GOTONLY_PC, R_GOTONLY_PC_FROM_END, R_GOTREL,
                        R_GOTREL_FROM_END, R_PPC_TOC>(Expr))
-      In<ELFT>::Got->HasGotOffRel = true;
+      In::X<ELFT>::Got->HasGotOffRel = true;
 
     int64_t Addend = computeAddend(*File, Buf, E, RI, Expr, Body);
 
@@ -778,7 +780,7 @@
       // a dynamic relocation.
       // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf p.4-19
       if (Config->EMachine == EM_MIPS)
-        In<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
+        In::X<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
       continue;
     }
 
@@ -791,17 +793,17 @@
         continue;
 
       if (Body.isGnuIFunc() && !Preemptible) {
-        In<ELFT>::Iplt->addEntry(Body);
-        In<ELFT>::IgotPlt->addEntry(Body);
-        In<ELFT>::RelaIplt->addReloc({Target->IRelativeRel, In<ELFT>::IgotPlt,
-                                      Body.getGotPltOffset<ELFT>(),
-                                      !Preemptible, &Body, 0});
+        In::X<ELFT>::Iplt->addEntry(Body);
+        In::X<ELFT>::IgotPlt->addEntry(Body);
+        In::X<ELFT>::RelaIplt->addReloc(
+            {Target->IRelativeRel, In::X<ELFT>::IgotPlt,
+             Body.getGotPltOffset<ELFT>(), !Preemptible, &Body, 0});
       } else {
-        In<ELFT>::Plt->addEntry(Body);
-        In<ELFT>::GotPlt->addEntry(Body);
-        In<ELFT>::RelaPlt->addReloc({Target->PltRel, In<ELFT>::GotPlt,
-                                     Body.getGotPltOffset<ELFT>(), !Preemptible,
-                                     &Body, 0});
+        In::X<ELFT>::Plt->addEntry(Body);
+        In::X<ELFT>::GotPlt->addEntry(Body);
+        In::X<ELFT>::RelaPlt->addReloc({Target->PltRel, In::X<ELFT>::GotPlt,
+                                        Body.getGotPltOffset<ELFT>(),
+                                        !Preemptible, &Body, 0});
       }
       continue;
     }
@@ -815,9 +817,9 @@
         // See "Global Offset Table" in Chapter 5 in the following document
         // for detailed description:
         // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-        In<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
+        In::X<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
         if (Body.isTls() && Body.isPreemptible())
-          AddDyn({Target->TlsGotRel, In<ELFT>::MipsGot,
+          AddDyn({Target->TlsGotRel, In::X<ELFT>::MipsGot,
                   Body.getGotOffset<ELFT>(), false, &Body, 0});
         continue;
       }
@@ -825,7 +827,7 @@
       if (Body.isInGot())
         continue;
 
-      In<ELFT>::Got->addEntry(Body);
+      In::X<ELFT>::Got->addEntry(Body);
       uintX_t Off = Body.getGotOffset<ELFT>();
       uint32_t DynType;
       RelExpr GotRE = R_ABS;
@@ -841,9 +843,10 @@
       bool Constant =
           !Preemptible && !(Config->pic() && !isAbsolute<ELFT>(Body));
       if (!Constant)
-        AddDyn({DynType, In<ELFT>::Got, Off, !Preemptible, &Body, 0});
+        AddDyn({DynType, In::X<ELFT>::Got, Off, !Preemptible, &Body, 0});
       if (Constant || (!RelTy::IsRela && !Preemptible))
-        In<ELFT>::Got->Relocations.push_back({GotRE, DynType, Off, 0, &Body});
+        In::X<ELFT>::Got->Relocations.push_back(
+            {GotRE, DynType, Off, 0, &Body});
       continue;
     }
   }
Index: ELF/Symbols.cpp
===================================================================
--- ELF/Symbols.cpp
+++ ELF/Symbols.cpp
@@ -101,7 +101,7 @@
   case SymbolBody::DefinedCommonKind:
     if (!Config->DefineCommon)
       return 0;
-    return In<ELFT>::Common->OutSec->Addr + In<ELFT>::Common->OutSecOff +
+    return In::Common->OutSec->Addr + In::Common->OutSecOff +
            cast<DefinedCommon>(Body).Offset;
   case SymbolBody::SharedKind: {
     auto &SS = cast<SharedSymbol>(Body);
@@ -164,7 +164,7 @@
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotVA() const {
-  return In<ELFT>::Got->getVA() + getGotOffset<ELFT>();
+  return In::X<ELFT>::Got->getVA() + getGotOffset<ELFT>();
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotOffset() const {
@@ -173,8 +173,8 @@
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltVA() const {
   if (this->IsInIgot)
-    return In<ELFT>::IgotPlt->getVA() + getGotPltOffset<ELFT>();
-  return In<ELFT>::GotPlt->getVA() + getGotPltOffset<ELFT>();
+    return In::X<ELFT>::IgotPlt->getVA() + getGotPltOffset<ELFT>();
+  return In::X<ELFT>::GotPlt->getVA() + getGotPltOffset<ELFT>();
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltOffset() const {
@@ -183,8 +183,8 @@
 
 template <class ELFT> typename ELFT::uint SymbolBody::getPltVA() const {
   if (this->IsInIplt)
-    return In<ELFT>::Iplt->getVA() + PltIndex * Target->PltEntrySize;
-  return In<ELFT>::Plt->getVA() + Target->PltHeaderSize +
+    return In::X<ELFT>::Iplt->getVA() + PltIndex * Target->PltEntrySize;
+  return In::X<ELFT>::Plt->getVA() + Target->PltHeaderSize +
          PltIndex * Target->PltEntrySize;
 }
 
@@ -213,7 +213,7 @@
 
   if (isa<DefinedCommon>(this)) {
     if (Config->DefineCommon)
-      return In<ELFT>::Common->OutSec;
+      return In::Common->OutSec;
     return nullptr;
   }
 
Index: ELF/SyntheticSections.h
===================================================================
--- ELF/SyntheticSections.h
+++ ELF/SyntheticSections.h
@@ -760,65 +760,65 @@
                               uint64_t Size, InputSectionBase *Section);
 
 // Linker generated sections which can be used as inputs.
-template <class ELFT> struct In {
+struct In {
   static InputSection *ARMAttributes;
-  static BuildIdSection<ELFT> *BuildId;
   static InputSection *Common;
-  static DynamicSection<ELFT> *Dynamic;
-  static StringTableSection<ELFT> *DynStrTab;
-  static SymbolTableSection<ELFT> *DynSymTab;
-  static EhFrameHeader<ELFT> *EhFrameHdr;
-  static GnuHashTableSection<ELFT> *GnuHashTab;
-  static GdbIndexSection<ELFT> *GdbIndex;
-  static GotSection<ELFT> *Got;
-  static EhFrameSection<ELFT> *EhFrame;
-  static MipsGotSection<ELFT> *MipsGot;
-  static GotPltSection<ELFT> *GotPlt;
-  static IgotPltSection<ELFT> *IgotPlt;
-  static HashTableSection<ELFT> *HashTab;
   static InputSection *Interp;
-  static MipsRldMapSection<ELFT> *MipsRldMap;
-  static PltSection<ELFT> *Plt;
-  static PltSection<ELFT> *Iplt;
-  static RelocationSection<ELFT> *RelaDyn;
-  static RelocationSection<ELFT> *RelaPlt;
-  static RelocationSection<ELFT> *RelaIplt;
-  static StringTableSection<ELFT> *ShStrTab;
-  static StringTableSection<ELFT> *StrTab;
-  static SymbolTableSection<ELFT> *SymTab;
-  static VersionDefinitionSection<ELFT> *VerDef;
-  static VersionTableSection<ELFT> *VerSym;
-  static VersionNeedSection<ELFT> *VerNeed;
-};
-
-template <class ELFT> InputSection *In<ELFT>::ARMAttributes;
-template <class ELFT> BuildIdSection<ELFT> *In<ELFT>::BuildId;
-template <class ELFT> InputSection *In<ELFT>::Common;
-template <class ELFT> DynamicSection<ELFT> *In<ELFT>::Dynamic;
-template <class ELFT> StringTableSection<ELFT> *In<ELFT>::DynStrTab;
-template <class ELFT> SymbolTableSection<ELFT> *In<ELFT>::DynSymTab;
-template <class ELFT> EhFrameHeader<ELFT> *In<ELFT>::EhFrameHdr;
-template <class ELFT> GdbIndexSection<ELFT> *In<ELFT>::GdbIndex;
-template <class ELFT> GnuHashTableSection<ELFT> *In<ELFT>::GnuHashTab;
-template <class ELFT> GotSection<ELFT> *In<ELFT>::Got;
-template <class ELFT> EhFrameSection<ELFT> *In<ELFT>::EhFrame;
-template <class ELFT> MipsGotSection<ELFT> *In<ELFT>::MipsGot;
-template <class ELFT> GotPltSection<ELFT> *In<ELFT>::GotPlt;
-template <class ELFT> IgotPltSection<ELFT> *In<ELFT>::IgotPlt;
-template <class ELFT> HashTableSection<ELFT> *In<ELFT>::HashTab;
-template <class ELFT> InputSection *In<ELFT>::Interp;
-template <class ELFT> MipsRldMapSection<ELFT> *In<ELFT>::MipsRldMap;
-template <class ELFT> PltSection<ELFT> *In<ELFT>::Plt;
-template <class ELFT> PltSection<ELFT> *In<ELFT>::Iplt;
-template <class ELFT> RelocationSection<ELFT> *In<ELFT>::RelaDyn;
-template <class ELFT> RelocationSection<ELFT> *In<ELFT>::RelaPlt;
-template <class ELFT> RelocationSection<ELFT> *In<ELFT>::RelaIplt;
-template <class ELFT> StringTableSection<ELFT> *In<ELFT>::ShStrTab;
-template <class ELFT> StringTableSection<ELFT> *In<ELFT>::StrTab;
-template <class ELFT> SymbolTableSection<ELFT> *In<ELFT>::SymTab;
-template <class ELFT> VersionDefinitionSection<ELFT> *In<ELFT>::VerDef;
-template <class ELFT> VersionTableSection<ELFT> *In<ELFT>::VerSym;
-template <class ELFT> VersionNeedSection<ELFT> *In<ELFT>::VerNeed;
+
+  template <class ELFT> struct X {
+    static BuildIdSection<ELFT> *BuildId;
+    static DynamicSection<ELFT> *Dynamic;
+    static StringTableSection<ELFT> *DynStrTab;
+    static SymbolTableSection<ELFT> *DynSymTab;
+    static EhFrameHeader<ELFT> *EhFrameHdr;
+    static GnuHashTableSection<ELFT> *GnuHashTab;
+    static GdbIndexSection<ELFT> *GdbIndex;
+    static GotSection<ELFT> *Got;
+    static EhFrameSection<ELFT> *EhFrame;
+    static MipsGotSection<ELFT> *MipsGot;
+    static GotPltSection<ELFT> *GotPlt;
+    static IgotPltSection<ELFT> *IgotPlt;
+    static HashTableSection<ELFT> *HashTab;
+    static MipsRldMapSection<ELFT> *MipsRldMap;
+    static PltSection<ELFT> *Plt;
+    static PltSection<ELFT> *Iplt;
+    static RelocationSection<ELFT> *RelaDyn;
+    static RelocationSection<ELFT> *RelaPlt;
+    static RelocationSection<ELFT> *RelaIplt;
+    static StringTableSection<ELFT> *ShStrTab;
+    static StringTableSection<ELFT> *StrTab;
+    static SymbolTableSection<ELFT> *SymTab;
+    static VersionDefinitionSection<ELFT> *VerDef;
+    static VersionTableSection<ELFT> *VerSym;
+    static VersionNeedSection<ELFT> *VerNeed;
+  };
+};
+
+template <class ELFT> BuildIdSection<ELFT> *In::X<ELFT>::BuildId;
+template <class ELFT> DynamicSection<ELFT> *In::X<ELFT>::Dynamic;
+template <class ELFT> StringTableSection<ELFT> *In::X<ELFT>::DynStrTab;
+template <class ELFT> SymbolTableSection<ELFT> *In::X<ELFT>::DynSymTab;
+template <class ELFT> EhFrameHeader<ELFT> *In::X<ELFT>::EhFrameHdr;
+template <class ELFT> GdbIndexSection<ELFT> *In::X<ELFT>::GdbIndex;
+template <class ELFT> GnuHashTableSection<ELFT> *In::X<ELFT>::GnuHashTab;
+template <class ELFT> GotSection<ELFT> *In::X<ELFT>::Got;
+template <class ELFT> EhFrameSection<ELFT> *In::X<ELFT>::EhFrame;
+template <class ELFT> MipsGotSection<ELFT> *In::X<ELFT>::MipsGot;
+template <class ELFT> GotPltSection<ELFT> *In::X<ELFT>::GotPlt;
+template <class ELFT> IgotPltSection<ELFT> *In::X<ELFT>::IgotPlt;
+template <class ELFT> HashTableSection<ELFT> *In::X<ELFT>::HashTab;
+template <class ELFT> MipsRldMapSection<ELFT> *In::X<ELFT>::MipsRldMap;
+template <class ELFT> PltSection<ELFT> *In::X<ELFT>::Plt;
+template <class ELFT> PltSection<ELFT> *In::X<ELFT>::Iplt;
+template <class ELFT> RelocationSection<ELFT> *In::X<ELFT>::RelaDyn;
+template <class ELFT> RelocationSection<ELFT> *In::X<ELFT>::RelaPlt;
+template <class ELFT> RelocationSection<ELFT> *In::X<ELFT>::RelaIplt;
+template <class ELFT> StringTableSection<ELFT> *In::X<ELFT>::ShStrTab;
+template <class ELFT> StringTableSection<ELFT> *In::X<ELFT>::StrTab;
+template <class ELFT> SymbolTableSection<ELFT> *In::X<ELFT>::SymTab;
+template <class ELFT> VersionDefinitionSection<ELFT> *In::X<ELFT>::VerDef;
+template <class ELFT> VersionTableSection<ELFT> *In::X<ELFT>::VerSym;
+template <class ELFT> VersionNeedSection<ELFT> *In::X<ELFT>::VerNeed;
 } // namespace elf
 } // namespace lld
 
Index: ELF/SyntheticSections.cpp
===================================================================
--- ELF/SyntheticSections.cpp
+++ ELF/SyntheticSections.cpp
@@ -197,7 +197,7 @@
   Options->size = getSize();
 
   if (!Config->Relocatable)
-    Reginfo.ri_gp_value = In<ELFT>::MipsGot->getGp();
+    Reginfo.ri_gp_value = In::X<ELFT>::MipsGot->getGp();
   memcpy(Buf + sizeof(Elf_Mips_Options), &Reginfo, sizeof(Reginfo));
 }
 
@@ -255,7 +255,7 @@
 
 template <class ELFT> void MipsReginfoSection<ELFT>::writeTo(uint8_t *Buf) {
   if (!Config->Relocatable)
-    Reginfo.ri_gp_value = In<ELFT>::MipsGot->getGp();
+    Reginfo.ri_gp_value = In::X<ELFT>::MipsGot->getGp();
   memcpy(Buf, &Reginfo, sizeof(Reginfo));
 }
 
@@ -309,8 +309,8 @@
                                    uint64_t Size, InputSectionBase *Section) {
   auto *S = make<DefinedRegular>(Name, /*IsLocal*/ true, STV_DEFAULT, Type,
                                  Value, Size, Section, nullptr);
-  if (In<ELFT>::SymTab)
-    In<ELFT>::SymTab->addSymbol(S);
+  if (In::X<ELFT>::SymTab)
+    In::X<ELFT>::SymTab->addSymbol(S);
   return S;
 }
 
@@ -607,13 +607,13 @@
   // Construct .eh_frame_hdr. .eh_frame_hdr is a binary search table
   // to get a FDE from an address to which FDE is applied. So here
   // we obtain two addresses and pass them to EhFrameHdr object.
-  if (In<ELFT>::EhFrameHdr) {
+  if (In::X<ELFT>::EhFrameHdr) {
     for (CieRecord *Cie : Cies) {
       uint8_t Enc = getFdeEncoding<ELFT>(Cie->Piece);
       for (SectionPiece *Fde : Cie->FdePieces) {
         uintX_t Pc = getFdePc(Buf, Fde->OutputOff, Enc);
         uintX_t FdeVA = this->OutSec->Addr + Fde->OutputOff;
-        In<ELFT>::EhFrameHdr->addFde(Pc, FdeVA);
+        In::X<ELFT>::EhFrameHdr->addFde(Pc, FdeVA);
       }
     }
   }
@@ -1044,15 +1044,15 @@
   // Add strings to .dynstr early so that .dynstr's size will be
   // fixed early.
   for (StringRef S : Config->AuxiliaryList)
-    add({DT_AUXILIARY, In<ELFT>::DynStrTab->addString(S)});
+    add({DT_AUXILIARY, In::X<ELFT>::DynStrTab->addString(S)});
   if (!Config->RPath.empty())
     add({Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
-         In<ELFT>::DynStrTab->addString(Config->RPath)});
+         In::X<ELFT>::DynStrTab->addString(Config->RPath)});
   for (SharedFile<ELFT> *F : Symtab<ELFT>::X->getSharedFiles())
     if (F->isNeeded())
-      add({DT_NEEDED, In<ELFT>::DynStrTab->addString(F->getSoName())});
+      add({DT_NEEDED, In::X<ELFT>::DynStrTab->addString(F->getSoName())});
   if (!Config->SoName.empty())
-    add({DT_SONAME, In<ELFT>::DynStrTab->addString(Config->SoName)});
+    add({DT_SONAME, In::X<ELFT>::DynStrTab->addString(Config->SoName)});
 
   // Set DT_FLAGS and DT_FLAGS_1.
   uint32_t DtFlags = 0;
@@ -1084,11 +1084,11 @@
   if (this->Size)
     return; // Already finalized.
 
-  this->Link = In<ELFT>::DynStrTab->OutSec->SectionIndex;
-  if (In<ELFT>::RelaDyn->OutSec->Size > 0) {
+  this->Link = In::X<ELFT>::DynStrTab->OutSec->SectionIndex;
+  if (In::X<ELFT>::RelaDyn->OutSec->Size > 0) {
     bool IsRela = Config->isRela();
-    add({IsRela ? DT_RELA : DT_REL, In<ELFT>::RelaDyn});
-    add({IsRela ? DT_RELASZ : DT_RELSZ, In<ELFT>::RelaDyn->OutSec->Size});
+    add({IsRela ? DT_RELA : DT_REL, In::X<ELFT>::RelaDyn});
+    add({IsRela ? DT_RELASZ : DT_RELSZ, In::X<ELFT>::RelaDyn->OutSec->Size});
     add({IsRela ? DT_RELAENT : DT_RELENT,
          uintX_t(IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel))});
 
@@ -1096,29 +1096,29 @@
     // The problem is in the tight relation between dynamic
     // relocations and GOT. So do not emit this tag on MIPS.
     if (Config->EMachine != EM_MIPS) {
-      size_t NumRelativeRels = In<ELFT>::RelaDyn->getRelativeRelocCount();
+      size_t NumRelativeRels = In::X<ELFT>::RelaDyn->getRelativeRelocCount();
       if (Config->ZCombreloc && NumRelativeRels)
         add({IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels});
     }
   }
-  if (In<ELFT>::RelaPlt->OutSec->Size > 0) {
-    add({DT_JMPREL, In<ELFT>::RelaPlt});
-    add({DT_PLTRELSZ, In<ELFT>::RelaPlt->OutSec->Size});
+  if (In::X<ELFT>::RelaPlt->OutSec->Size > 0) {
+    add({DT_JMPREL, In::X<ELFT>::RelaPlt});
+    add({DT_PLTRELSZ, In::X<ELFT>::RelaPlt->OutSec->Size});
     add({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
-         In<ELFT>::GotPlt});
+         In::X<ELFT>::GotPlt});
     add({DT_PLTREL, uint64_t(Config->isRela() ? DT_RELA : DT_REL)});
   }
 
-  add({DT_SYMTAB, In<ELFT>::DynSymTab});
+  add({DT_SYMTAB, In::X<ELFT>::DynSymTab});
   add({DT_SYMENT, sizeof(Elf_Sym)});
-  add({DT_STRTAB, In<ELFT>::DynStrTab});
-  add({DT_STRSZ, In<ELFT>::DynStrTab->getSize()});
+  add({DT_STRTAB, In::X<ELFT>::DynStrTab});
+  add({DT_STRSZ, In::X<ELFT>::DynStrTab->getSize()});
   if (!Config->ZText)
     add({DT_TEXTREL, (uint64_t)0});
-  if (In<ELFT>::GnuHashTab)
-    add({DT_GNU_HASH, In<ELFT>::GnuHashTab});
-  if (In<ELFT>::HashTab)
-    add({DT_HASH, In<ELFT>::HashTab});
+  if (In::X<ELFT>::GnuHashTab)
+    add({DT_GNU_HASH, In::X<ELFT>::GnuHashTab});
+  if (In::X<ELFT>::HashTab)
+    add({DT_HASH, In::X<ELFT>::HashTab});
 
   if (Out::PreinitArray) {
     add({DT_PREINIT_ARRAY, Out::PreinitArray});
@@ -1138,31 +1138,31 @@
   if (SymbolBody *B = Symtab<ELFT>::X->findInCurrentDSO(Config->Fini))
     add({DT_FINI, B});
 
-  bool HasVerNeed = In<ELFT>::VerNeed->getNeedNum() != 0;
-  if (HasVerNeed || In<ELFT>::VerDef)
-    add({DT_VERSYM, In<ELFT>::VerSym});
-  if (In<ELFT>::VerDef) {
-    add({DT_VERDEF, In<ELFT>::VerDef});
+  bool HasVerNeed = In::X<ELFT>::VerNeed->getNeedNum() != 0;
+  if (HasVerNeed || In::X<ELFT>::VerDef)
+    add({DT_VERSYM, In::X<ELFT>::VerSym});
+  if (In::X<ELFT>::VerDef) {
+    add({DT_VERDEF, In::X<ELFT>::VerDef});
     add({DT_VERDEFNUM, getVerDefNum()});
   }
   if (HasVerNeed) {
-    add({DT_VERNEED, In<ELFT>::VerNeed});
-    add({DT_VERNEEDNUM, In<ELFT>::VerNeed->getNeedNum()});
+    add({DT_VERNEED, In::X<ELFT>::VerNeed});
+    add({DT_VERNEEDNUM, In::X<ELFT>::VerNeed->getNeedNum()});
   }
 
   if (Config->EMachine == EM_MIPS) {
     add({DT_MIPS_RLD_VERSION, 1});
     add({DT_MIPS_FLAGS, RHF_NOTPOT});
     add({DT_MIPS_BASE_ADDRESS, Config->ImageBase});
-    add({DT_MIPS_SYMTABNO, In<ELFT>::DynSymTab->getNumSymbols()});
-    add({DT_MIPS_LOCAL_GOTNO, In<ELFT>::MipsGot->getLocalEntriesNum()});
-    if (const SymbolBody *B = In<ELFT>::MipsGot->getFirstGlobalEntry())
+    add({DT_MIPS_SYMTABNO, In::X<ELFT>::DynSymTab->getNumSymbols()});
+    add({DT_MIPS_LOCAL_GOTNO, In::X<ELFT>::MipsGot->getLocalEntriesNum()});
+    if (const SymbolBody *B = In::X<ELFT>::MipsGot->getFirstGlobalEntry())
       add({DT_MIPS_GOTSYM, B->DynsymIndex});
     else
-      add({DT_MIPS_GOTSYM, In<ELFT>::DynSymTab->getNumSymbols()});
-    add({DT_PLTGOT, In<ELFT>::MipsGot});
-    if (In<ELFT>::MipsRldMap)
-      add({DT_MIPS_RLD_MAP, In<ELFT>::MipsRldMap});
+      add({DT_MIPS_GOTSYM, In::X<ELFT>::DynSymTab->getNumSymbols()});
+    add({DT_PLTGOT, In::X<ELFT>::MipsGot});
+    if (In::X<ELFT>::MipsRldMap)
+      add({DT_MIPS_RLD_MAP, In::X<ELFT>::MipsRldMap});
   }
 
   this->OutSec->Link = this->Link;
@@ -1248,11 +1248,11 @@
     if (Config->isRela())
       P->r_addend = Rel.getAddend();
     P->r_offset = Rel.getOffset();
-    if (Config->EMachine == EM_MIPS && Rel.getInputSec() == In<ELFT>::MipsGot)
+    if (Config->EMachine == EM_MIPS && Rel.getInputSec() == In::X<ELFT>::MipsGot)
       // Dynamic relocation against MIPS GOT section make deal TLS entries
       // allocated in the end of the GOT. We need to adjust the offset to take
       // in account 'local' and 'global' GOT entries.
-      P->r_offset += In<ELFT>::MipsGot->getTlsOffset();
+      P->r_offset += In::X<ELFT>::MipsGot->getTlsOffset();
     P->setSymbolAndType(Rel.getSymIndex(), Rel.Type, Config->isMips64EL());
   }
 
@@ -1272,8 +1272,9 @@
 }
 
 template <class ELFT> void RelocationSection<ELFT>::finalizeContents() {
-  this->Link = In<ELFT>::DynSymTab ? In<ELFT>::DynSymTab->OutSec->SectionIndex
-                                   : In<ELFT>::SymTab->OutSec->SectionIndex;
+  this->Link = In::X<ELFT>::DynSymTab
+                   ? In::X<ELFT>::DynSymTab->OutSec->SectionIndex
+                   : In::X<ELFT>::SymTab->OutSec->SectionIndex;
 
   // Set required output section properties.
   this->OutSec->Link = this->Link;
@@ -1319,9 +1320,9 @@
     // Because the first symbol entry is a null entry, 1 is the first.
     this->OutSec->Info = 1;
 
-    if (In<ELFT>::GnuHashTab) {
+    if (In::X<ELFT>::GnuHashTab) {
       // NB: It also sorts Symbols to meet the GNU hash table requirements.
-      In<ELFT>::GnuHashTab->addSymbols(Symbols);
+      In::X<ELFT>::GnuHashTab->addSymbols(Symbols);
     } else if (Config->EMachine == EM_MIPS) {
       std::stable_sort(Symbols.begin(), Symbols.end(), sortMipsSymbols);
     }
@@ -1470,7 +1471,7 @@
 }
 
 template <class ELFT> void GnuHashTableSection<ELFT>::finalizeContents() {
-  this->OutSec->Link = In<ELFT>::DynSymTab->OutSec->SectionIndex;
+  this->OutSec->Link = In::X<ELFT>::DynSymTab->OutSec->SectionIndex;
 
   // Computes bloom filter size in word size. We want to allocate 8
   // bits for each symbol. It must be a power of two.
@@ -1489,7 +1490,7 @@
   // Write a header.
   const endianness E = ELFT::TargetEndianness;
   write32<E>(Buf, NBuckets);
-  write32<E>(Buf + 4, In<ELFT>::DynSymTab->getNumSymbols() - Symbols.size());
+  write32<E>(Buf + 4, In::X<ELFT>::DynSymTab->getNumSymbols() - Symbols.size());
   write32<E>(Buf + 8, MaskWords);
   write32<E>(Buf + 12, getShift2());
   Buf += 16;
@@ -1611,15 +1612,15 @@
 }
 
 template <class ELFT> void HashTableSection<ELFT>::finalizeContents() {
-  this->OutSec->Link = In<ELFT>::DynSymTab->OutSec->SectionIndex;
+  this->OutSec->Link = In::X<ELFT>::DynSymTab->OutSec->SectionIndex;
 
   unsigned NumEntries = 2;                            // nbucket and nchain.
-  NumEntries += In<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
+  NumEntries += In::X<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
 
   // Create as many buckets as there are symbols.
   // FIXME: This is simplistic. We can try to optimize it, but implementing
   // support for SHT_GNU_HASH is probably even more profitable.
-  NumEntries += In<ELFT>::DynSymTab->getNumSymbols();
+  NumEntries += In::X<ELFT>::DynSymTab->getNumSymbols();
   this->Size = NumEntries * 4;
 }
 
@@ -1627,7 +1628,7 @@
   // A 32-bit integer type in the target endianness.
   typedef typename ELFT::Word Elf_Word;
 
-  unsigned NumSymbols = In<ELFT>::DynSymTab->getNumSymbols();
+  unsigned NumSymbols = In::X<ELFT>::DynSymTab->getNumSymbols();
 
   auto *P = reinterpret_cast<Elf_Word *>(Buf);
   *P++ = NumSymbols; // nbucket
@@ -1636,7 +1637,7 @@
   Elf_Word *Buckets = P;
   Elf_Word *Chains = P + NumSymbols;
 
-  for (const SymbolTableEntry &S : In<ELFT>::DynSymTab->getSymbols()) {
+  for (const SymbolTableEntry &S : In::X<ELFT>::DynSymTab->getSymbols()) {
     SymbolBody *Body = S.Symbol;
     StringRef Name = Body->getName();
     unsigned I = Body->DynsymIndex;
@@ -1672,9 +1673,9 @@
 
 template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody &Sym) {
   Sym.PltIndex = Entries.size();
-  RelocationSection<ELFT> *PltRelocSection = In<ELFT>::RelaPlt;
+  RelocationSection<ELFT> *PltRelocSection = In::X<ELFT>::RelaPlt;
   if (HeaderSize == 0) {
-    PltRelocSection = In<ELFT>::RelaIplt;
+    PltRelocSection = In::X<ELFT>::RelaIplt;
     Sym.IsInIplt = true;
   }
   unsigned RelOff = PltRelocSection->getRelocOffset();
@@ -1699,7 +1700,7 @@
 }
 
 template <class ELFT> unsigned PltSection<ELFT>::getPltRelocOff() const {
-  return (HeaderSize == 0) ? In<ELFT>::Plt->getSize() : 0;
+  return (HeaderSize == 0) ? In::X<ELFT>::Plt->getSize() : 0;
 }
 
 template <class ELFT>
@@ -1938,7 +1939,7 @@
   Buf[1] = DW_EH_PE_pcrel | DW_EH_PE_sdata4;
   Buf[2] = DW_EH_PE_udata4;
   Buf[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
-  write32<E>(Buf + 4, In<ELFT>::EhFrame->OutSec->Addr - this->getVA() - 4);
+  write32<E>(Buf + 4, In::X<ELFT>::EhFrame->OutSec->Addr - this->getVA() - 4);
   write32<E>(Buf + 8, Fdes.size());
   Buf += 12;
 
@@ -1952,7 +1953,7 @@
 
 template <class ELFT> size_t EhFrameHeader<ELFT>::getSize() const {
   // .eh_frame_hdr has a 12 bytes header followed by an array of FDEs.
-  return 12 + In<ELFT>::EhFrame->NumFdes * 8;
+  return 12 + In::X<ELFT>::EhFrame->NumFdes * 8;
 }
 
 template <class ELFT>
@@ -1961,7 +1962,7 @@
 }
 
 template <class ELFT> bool EhFrameHeader<ELFT>::empty() const {
-  return In<ELFT>::EhFrame->empty();
+  return In::X<ELFT>::EhFrame->empty();
 }
 
 template <class ELFT>
@@ -1976,11 +1977,11 @@
 }
 
 template <class ELFT> void VersionDefinitionSection<ELFT>::finalizeContents() {
-  FileDefNameOff = In<ELFT>::DynStrTab->addString(getFileDefName());
+  FileDefNameOff = In::X<ELFT>::DynStrTab->addString(getFileDefName());
   for (VersionDefinition &V : Config->VersionDefinitions)
-    V.NameOff = In<ELFT>::DynStrTab->addString(V.Name);
+    V.NameOff = In::X<ELFT>::DynStrTab->addString(V.Name);
 
-  this->OutSec->Link = In<ELFT>::DynStrTab->OutSec->SectionIndex;
+  this->OutSec->Link = In::X<ELFT>::DynStrTab->OutSec->SectionIndex;
 
   // sh_info should be set to the number of definitions. This fact is missed in
   // documentation, but confirmed by binutils community:
@@ -2033,23 +2034,23 @@
 template <class ELFT> void VersionTableSection<ELFT>::finalizeContents() {
   // At the moment of june 2016 GNU docs does not mention that sh_link field
   // should be set, but Sun docs do. Also readelf relies on this field.
-  this->OutSec->Link = In<ELFT>::DynSymTab->OutSec->SectionIndex;
+  this->OutSec->Link = In::X<ELFT>::DynSymTab->OutSec->SectionIndex;
 }
 
 template <class ELFT> size_t VersionTableSection<ELFT>::getSize() const {
-  return sizeof(Elf_Versym) * (In<ELFT>::DynSymTab->getSymbols().size() + 1);
+  return sizeof(Elf_Versym) * (In::X<ELFT>::DynSymTab->getSymbols().size() + 1);
 }
 
 template <class ELFT> void VersionTableSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *OutVersym = reinterpret_cast<Elf_Versym *>(Buf) + 1;
-  for (const SymbolTableEntry &S : In<ELFT>::DynSymTab->getSymbols()) {
+  for (const SymbolTableEntry &S : In::X<ELFT>::DynSymTab->getSymbols()) {
     OutVersym->vs_index = S.Symbol->symbol()->VersionId;
     ++OutVersym;
   }
 }
 
 template <class ELFT> bool VersionTableSection<ELFT>::empty() const {
-  return !In<ELFT>::VerDef && In<ELFT>::VerNeed->empty();
+  return !In::X<ELFT>::VerDef && In::X<ELFT>::VerNeed->empty();
 }
 
 template <class ELFT>
@@ -2076,14 +2077,15 @@
   // to create one by adding it to our needed list and creating a dynstr entry
   // for the soname.
   if (File->VerdefMap.empty())
-    Needed.push_back({File, In<ELFT>::DynStrTab->addString(File->getSoName())});
+    Needed.push_back(
+        {File, In::X<ELFT>::DynStrTab->addString(File->getSoName())});
   typename SharedFile<ELFT>::NeededVer &NV = File->VerdefMap[Ver];
   // If we don't already know that we need an Elf_Vernaux for this Elf_Verdef,
   // prepare to create one by allocating a version identifier and creating a
   // dynstr entry for the version name.
   if (NV.Index == 0) {
-    NV.StrTab = In<ELFT>::DynStrTab->addString(File->getStringTable().data() +
-                                               Ver->getAux()->vda_name);
+    NV.StrTab = In::X<ELFT>::DynStrTab->addString(
+        File->getStringTable().data() + Ver->getAux()->vda_name);
     NV.Index = NextIndex++;
   }
   SS->symbol()->VersionId = NV.Index;
@@ -2125,7 +2127,7 @@
 }
 
 template <class ELFT> void VersionNeedSection<ELFT>::finalizeContents() {
-  this->OutSec->Link = In<ELFT>::DynStrTab->OutSec->SectionIndex;
+  this->OutSec->Link = In::X<ELFT>::DynStrTab->OutSec->SectionIndex;
   this->OutSec->Info = Needed.size();
 }
 
@@ -2266,6 +2268,10 @@
   return T->getTargetInputSection();
 }
 
+InputSection *In::ARMAttributes;
+InputSection *In::Common;
+InputSection *In::Interp;
+
 template InputSection *elf::createCommonSection<ELF32LE>();
 template InputSection *elf::createCommonSection<ELF32BE>();
 template InputSection *elf::createCommonSection<ELF64LE>();
Index: ELF/Target.cpp
===================================================================
--- ELF/Target.cpp
+++ ELF/Target.cpp
@@ -409,7 +409,7 @@
 }
 
 void X86TargetInfo::writeGotPltHeader(uint8_t *Buf) const {
-  write32le(Buf, In<ELF32LE>::Dynamic->getVA());
+  write32le(Buf, In::X<ELF32LE>::Dynamic->getVA());
 }
 
 void X86TargetInfo::writeGotPlt(uint8_t *Buf, const SymbolBody &S) const {
@@ -462,7 +462,7 @@
       0x90, 0x90, 0x90, 0x90              // nop; nop; nop; nop
   };
   memcpy(Buf, PltData, sizeof(PltData));
-  uint32_t Got = In<ELF32LE>::GotPlt->getVA();
+  uint32_t Got = In::X<ELF32LE>::GotPlt->getVA();
   write32le(Buf + 2, Got + 4);
   write32le(Buf + 8, Got + 8);
 }
@@ -479,7 +479,7 @@
 
   // jmp *foo@GOT(%ebx) or jmp *foo_in_GOT
   Buf[1] = Config->pic() ? 0xa3 : 0x25;
-  uint32_t Got = In<ELF32LE>::GotPlt->getVA();
+  uint32_t Got = In::X<ELF32LE>::GotPlt->getVA();
   write32le(Buf + 2, Config->Shared ? GotEntryAddr - Got : GotEntryAddr);
   write32le(Buf + 7, RelOff);
   write32le(Buf + 12, -Index * PltEntrySize - PltHeaderSize - 16);
@@ -697,7 +697,7 @@
   // required, but it is documented in the psabi and the glibc dynamic linker
   // seems to use it (note that this is relevant for linking ld.so, not any
   // other program).
-  write64le(Buf, In<ELFT>::Dynamic->getVA());
+  write64le(Buf, In::X<ELFT>::Dynamic->getVA());
 }
 
 template <class ELFT>
@@ -715,8 +715,8 @@
       0x0f, 0x1f, 0x40, 0x00              // nopl 0x0(rax)
   };
   memcpy(Buf, PltData, sizeof(PltData));
-  uint64_t Got = In<ELFT>::GotPlt->getVA();
-  uint64_t Plt = In<ELFT>::Plt->getVA();
+  uint64_t Got = In::X<ELFT>::GotPlt->getVA();
+  uint64_t Plt = In::X<ELFT>::Plt->getVA();
   write32le(Buf + 2, Got - Plt + 2); // GOT+8
   write32le(Buf + 8, Got - Plt + 4); // GOT+16
 }
@@ -1130,7 +1130,7 @@
   // TOC starts where the first of these sections starts. We always create a
   // .got when we see a relocation that uses it, so for us the start is always
   // the .got.
-  uint64_t TocVA = In<ELF64BE>::Got->getVA();
+  uint64_t TocVA = In::X<ELF64BE>::Got->getVA();
 
   // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
   // thus permitting a full 64 Kbytes segment. Note that the glibc startup
@@ -1363,7 +1363,7 @@
 }
 
 void AArch64TargetInfo::writeGotPlt(uint8_t *Buf, const SymbolBody &) const {
-  write64le(Buf, In<ELF64LE>::Plt->getVA());
+  write64le(Buf, In::X<ELF64LE>::Plt->getVA());
 }
 
 // Page(Expr) is the page address of the expression Expr, defined
@@ -1386,8 +1386,8 @@
   };
   memcpy(Buf, PltData, sizeof(PltData));
 
-  uint64_t Got = In<ELF64LE>::GotPlt->getVA();
-  uint64_t Plt = In<ELF64LE>::Plt->getVA();
+  uint64_t Got = In::X<ELF64LE>::GotPlt->getVA();
+  uint64_t Plt = In::X<ELF64LE>::Plt->getVA();
   relocateOne(Buf + 4, R_AARCH64_ADR_PREL_PG_HI21,
               getAArch64Page(Got + 16) - getAArch64Page(Plt + 4));
   relocateOne(Buf + 8, R_AARCH64_LDST64_ABS_LO12_NC, Got + 16);
@@ -1738,7 +1738,7 @@
 }
 
 void ARMTargetInfo::writeGotPlt(uint8_t *Buf, const SymbolBody &) const {
-  write32le(Buf, In<ELF32LE>::Plt->getVA());
+  write32le(Buf, In::X<ELF32LE>::Plt->getVA());
 }
 
 void ARMTargetInfo::writeIgotPlt(uint8_t *Buf, const SymbolBody &S) const {
@@ -1755,8 +1755,8 @@
       0x00, 0x00, 0x00, 0x00, // L2: .word   &(.got.plt) - L1 - 8
   };
   memcpy(Buf, PltData, sizeof(PltData));
-  uint64_t GotPlt = In<ELF32LE>::GotPlt->getVA();
-  uint64_t L1 = In<ELF32LE>::Plt->getVA() + 8;
+  uint64_t GotPlt = In::X<ELF32LE>::GotPlt->getVA();
+  uint64_t L1 = In::X<ELF32LE>::Plt->getVA() + 8;
   write32le(Buf + 16, GotPlt - L1 - 8);
 }
 
@@ -2142,7 +2142,7 @@
 
 template <class ELFT>
 void MipsTargetInfo<ELFT>::writeGotPlt(uint8_t *Buf, const SymbolBody &) const {
-  write32<ELFT::TargetEndianness>(Buf, In<ELFT>::Plt->getVA());
+  write32<ELFT::TargetEndianness>(Buf, In::X<ELFT>::Plt->getVA());
 }
 
 template <endianness E, uint8_t BSIZE, uint8_t SHIFT>
@@ -2209,7 +2209,7 @@
   write32<E>(Buf + 20, 0x0018c082); // srl   $24, $24, 2
   write32<E>(Buf + 24, 0x0320f809); // jalr  $25
   write32<E>(Buf + 28, 0x2718fffe); // subu  $24, $24, 2
-  uint64_t Got = In<ELFT>::GotPlt->getVA();
+  uint64_t Got = In::X<ELFT>::GotPlt->getVA();
   writeMipsHi16<E>(Buf, Got);
   writeMipsLo16<E>(Buf + 4, Got);
   writeMipsLo16<E>(Buf + 8, Got);
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -208,7 +208,7 @@
     if (!ES->Live)
       continue;
 
-    In<ELFT>::EhFrame->addSection(ES);
+    In::X<ELFT>::EhFrame->addSection(ES);
     S = nullptr;
   }
 
@@ -333,11 +333,11 @@
   Out::Bss = make<OutputSection>(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
   Out::BssRelRo =
       make<OutputSection>(".bss.rel.ro", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
-  In<ELFT>::DynStrTab = make<StringTableSection<ELFT>>(".dynstr", true);
-  In<ELFT>::Dynamic = make<DynamicSection<ELFT>>();
-  In<ELFT>::RelaDyn = make<RelocationSection<ELFT>>(
+  In::X<ELFT>::DynStrTab = make<StringTableSection<ELFT>>(".dynstr", true);
+  In::X<ELFT>::Dynamic = make<DynamicSection<ELFT>>();
+  In::X<ELFT>::RelaDyn = make<RelocationSection<ELFT>>(
       Config->isRela() ? ".rela.dyn" : ".rel.dyn", Config->ZCombreloc);
-  In<ELFT>::ShStrTab = make<StringTableSection<ELFT>>(".shstrtab", false);
+  In::X<ELFT>::ShStrTab = make<StringTableSection<ELFT>>(".shstrtab", false);
 
   Out::ElfHeader = make<OutputSection>("", 0, SHF_ALLOC);
   Out::ElfHeader->Size = sizeof(Elf_Ehdr);
@@ -345,28 +345,28 @@
   Out::ProgramHeaders->updateAlignment(sizeof(uintX_t));
 
   if (needsInterpSection<ELFT>()) {
-    In<ELFT>::Interp = createInterpSection();
-    Add(In<ELFT>::Interp);
+    In::Interp = createInterpSection();
+    Add(In::Interp);
   } else {
-    In<ELFT>::Interp = nullptr;
+    In::Interp = nullptr;
   }
 
   if (!Config->Relocatable)
     Add(createCommentSection<ELFT>());
 
   if (Config->Strip != StripPolicy::All) {
-    In<ELFT>::StrTab = make<StringTableSection<ELFT>>(".strtab", false);
-    In<ELFT>::SymTab = make<SymbolTableSection<ELFT>>(*In<ELFT>::StrTab);
+    In::X<ELFT>::StrTab = make<StringTableSection<ELFT>>(".strtab", false);
+    In::X<ELFT>::SymTab = make<SymbolTableSection<ELFT>>(*In::X<ELFT>::StrTab);
   }
 
   if (Config->BuildId != BuildIdKind::None) {
-    In<ELFT>::BuildId = make<BuildIdSection<ELFT>>();
-    Add(In<ELFT>::BuildId);
+    In::X<ELFT>::BuildId = make<BuildIdSection<ELFT>>();
+    Add(In::X<ELFT>::BuildId);
   }
 
   InputSection *Common = createCommonSection<ELFT>();
   if (!Common->Data.empty()) {
-    In<ELFT>::Common = Common;
+    In::Common = Common;
     Add(Common);
   }
 
@@ -376,8 +376,8 @@
       Config->ExportDynamic;
   if (Config->EMachine == EM_MIPS) {
     if (!Config->Shared && HasDynSymTab) {
-      In<ELFT>::MipsRldMap = make<MipsRldMapSection<ELFT>>();
-      Add(In<ELFT>::MipsRldMap);
+      In::X<ELFT>::MipsRldMap = make<MipsRldMapSection<ELFT>>();
+      Add(In::X<ELFT>::MipsRldMap);
     }
     if (auto *Sec = MipsAbiFlagsSection<ELFT>::create())
       Add(Sec);
@@ -388,87 +388,88 @@
   }
 
   if (HasDynSymTab) {
-    In<ELFT>::DynSymTab = make<SymbolTableSection<ELFT>>(*In<ELFT>::DynStrTab);
-    Add(In<ELFT>::DynSymTab);
+    In::X<ELFT>::DynSymTab =
+        make<SymbolTableSection<ELFT>>(*In::X<ELFT>::DynStrTab);
+    Add(In::X<ELFT>::DynSymTab);
 
-    In<ELFT>::VerSym = make<VersionTableSection<ELFT>>();
-    Add(In<ELFT>::VerSym);
+    In::X<ELFT>::VerSym = make<VersionTableSection<ELFT>>();
+    Add(In::X<ELFT>::VerSym);
 
     if (!Config->VersionDefinitions.empty()) {
-      In<ELFT>::VerDef = make<VersionDefinitionSection<ELFT>>();
-      Add(In<ELFT>::VerDef);
+      In::X<ELFT>::VerDef = make<VersionDefinitionSection<ELFT>>();
+      Add(In::X<ELFT>::VerDef);
     }
 
-    In<ELFT>::VerNeed = make<VersionNeedSection<ELFT>>();
-    Add(In<ELFT>::VerNeed);
+    In::X<ELFT>::VerNeed = make<VersionNeedSection<ELFT>>();
+    Add(In::X<ELFT>::VerNeed);
 
     if (Config->GnuHash) {
-      In<ELFT>::GnuHashTab = make<GnuHashTableSection<ELFT>>();
-      Add(In<ELFT>::GnuHashTab);
+      In::X<ELFT>::GnuHashTab = make<GnuHashTableSection<ELFT>>();
+      Add(In::X<ELFT>::GnuHashTab);
     }
 
     if (Config->SysvHash) {
-      In<ELFT>::HashTab = make<HashTableSection<ELFT>>();
-      Add(In<ELFT>::HashTab);
+      In::X<ELFT>::HashTab = make<HashTableSection<ELFT>>();
+      Add(In::X<ELFT>::HashTab);
     }
 
-    Add(In<ELFT>::Dynamic);
-    Add(In<ELFT>::DynStrTab);
-    Add(In<ELFT>::RelaDyn);
+    Add(In::X<ELFT>::Dynamic);
+    Add(In::X<ELFT>::DynStrTab);
+    Add(In::X<ELFT>::RelaDyn);
   }
 
   // Add .got. MIPS' .got is so different from the other archs,
   // it has its own class.
   if (Config->EMachine == EM_MIPS) {
-    In<ELFT>::MipsGot = make<MipsGotSection<ELFT>>();
-    Add(In<ELFT>::MipsGot);
+    In::X<ELFT>::MipsGot = make<MipsGotSection<ELFT>>();
+    Add(In::X<ELFT>::MipsGot);
   } else {
-    In<ELFT>::Got = make<GotSection<ELFT>>();
-    Add(In<ELFT>::Got);
+    In::X<ELFT>::Got = make<GotSection<ELFT>>();
+    Add(In::X<ELFT>::Got);
   }
 
-  In<ELFT>::GotPlt = make<GotPltSection<ELFT>>();
-  Add(In<ELFT>::GotPlt);
-  In<ELFT>::IgotPlt = make<IgotPltSection<ELFT>>();
-  Add(In<ELFT>::IgotPlt);
+  In::X<ELFT>::GotPlt = make<GotPltSection<ELFT>>();
+  Add(In::X<ELFT>::GotPlt);
+  In::X<ELFT>::IgotPlt = make<IgotPltSection<ELFT>>();
+  Add(In::X<ELFT>::IgotPlt);
 
   if (Config->GdbIndex) {
-    In<ELFT>::GdbIndex = make<GdbIndexSection<ELFT>>();
-    Add(In<ELFT>::GdbIndex);
+    In::X<ELFT>::GdbIndex = make<GdbIndexSection<ELFT>>();
+    Add(In::X<ELFT>::GdbIndex);
   }
 
   // We always need to add rel[a].plt to output if it has entries.
   // Even for static linking it can contain R_[*]_IRELATIVE relocations.
-  In<ELFT>::RelaPlt = make<RelocationSection<ELFT>>(
+  In::X<ELFT>::RelaPlt = make<RelocationSection<ELFT>>(
       Config->isRela() ? ".rela.plt" : ".rel.plt", false /*Sort*/);
-  Add(In<ELFT>::RelaPlt);
+  Add(In::X<ELFT>::RelaPlt);
 
   // The RelaIplt immediately follows .rel.plt (.rel.dyn for ARM) to ensure
   // that the IRelative relocations are processed last by the dynamic loader
-  In<ELFT>::RelaIplt = make<RelocationSection<ELFT>>(
-      (Config->EMachine == EM_ARM) ? ".rel.dyn" : In<ELFT>::RelaPlt->Name,
+  In::X<ELFT>::RelaIplt = make<RelocationSection<ELFT>>(
+      (Config->EMachine == EM_ARM) ? ".rel.dyn" : In::X<ELFT>::RelaPlt->Name,
       false /*Sort*/);
-  Add(In<ELFT>::RelaIplt);
+  Add(In::X<ELFT>::RelaIplt);
 
-  In<ELFT>::Plt = make<PltSection<ELFT>>(Target->PltHeaderSize);
-  Add(In<ELFT>::Plt);
-  In<ELFT>::Iplt = make<PltSection<ELFT>>(0);
-  Add(In<ELFT>::Iplt);
+  In::X<ELFT>::Plt = make<PltSection<ELFT>>(Target->PltHeaderSize);
+  Add(In::X<ELFT>::Plt);
+  In::X<ELFT>::Iplt = make<PltSection<ELFT>>(0);
+  Add(In::X<ELFT>::Iplt);
 
   if (!Config->Relocatable) {
     if (Config->EhFrameHdr) {
-      In<ELFT>::EhFrameHdr = make<EhFrameHeader<ELFT>>();
-      Add(In<ELFT>::EhFrameHdr);
+      In::X<ELFT>::EhFrameHdr = make<EhFrameHeader<ELFT>>();
+      Add(In::X<ELFT>::EhFrameHdr);
     }
-    In<ELFT>::EhFrame = make<EhFrameSection<ELFT>>();
-    Add(In<ELFT>::EhFrame);
+    In::X<ELFT>::EhFrame = make<EhFrameSection<ELFT>>();
+    Add(In::X<ELFT>::EhFrame);
   }
 
-  if (In<ELFT>::SymTab)
-    Add(In<ELFT>::SymTab);
-  Add(In<ELFT>::ShStrTab);
-  if (In<ELFT>::StrTab)
-    Add(In<ELFT>::StrTab);
+  if (In::X<ELFT>::SymTab)
+    Add(In::X<ELFT>::SymTab);
+  Add(In::X<ELFT>::ShStrTab);
+  if (In::X<ELFT>::StrTab)
+    Add(In::X<ELFT>::StrTab);
 }
 
 template <class ELFT>
@@ -524,7 +525,7 @@
 // Local symbols are not in the linker's symbol table. This function scans
 // each object file's symbol table to copy local symbols to the output.
 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
-  if (!In<ELFT>::SymTab)
+  if (!In::X<ELFT>::SymTab)
     return;
   for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
     for (SymbolBody *B : F->getLocalSymbols()) {
@@ -542,7 +543,7 @@
       SectionBase *Sec = DR->Section;
       if (!shouldKeepInSymtab<ELFT>(Sec, B->getName(), *B))
         continue;
-      In<ELFT>::SymTab->addSymbol(B);
+      In::X<ELFT>::SymTab->addSymbol(B);
     }
   }
 }
@@ -562,7 +563,7 @@
     auto *Sym =
         make<DefinedRegular>("", /*IsLocal=*/true, /*StOther=*/0, STT_SECTION,
                              /*Value=*/0, /*Size=*/0, IS, nullptr);
-    In<ELFT>::SymTab->addSymbol(Sym);
+    In::X<ELFT>::SymTab->addSymbol(Sym);
   }
 }
 
@@ -613,11 +614,11 @@
       Type == SHT_PREINIT_ARRAY)
     return true;
 
-  if (Sec == In<ELFT>::GotPlt->OutSec)
+  if (Sec == In::X<ELFT>::GotPlt->OutSec)
     return Config->ZNow;
-  if (Sec == In<ELFT>::Dynamic->OutSec)
+  if (Sec == In::X<ELFT>::Dynamic->OutSec)
     return true;
-  if (In<ELFT>::Got && Sec == In<ELFT>::Got->OutSec)
+  if (In::X<ELFT>::Got && Sec == In::X<ELFT>::Got->OutSec)
     return true;
   if (Sec == Out::BssRelRo)
     return true;
@@ -787,13 +788,13 @@
 // need these symbols, since IRELATIVE relocs are resolved through GOT
 // and PLT. For details, see http://www.airs.com/blog/archives/403.
 template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
-  if (In<ELFT>::DynSymTab)
+  if (In::X<ELFT>::DynSymTab)
     return;
   StringRef S = Config->isRela() ? "__rela_iplt_start" : "__rel_iplt_start";
-  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, 0, STV_HIDDEN, STB_WEAK);
+  addOptionalRegular<ELFT>(S, In::X<ELFT>::RelaIplt, 0, STV_HIDDEN, STB_WEAK);
 
   S = Config->isRela() ? "__rela_iplt_end" : "__rel_iplt_end";
-  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, -1, STV_HIDDEN, STB_WEAK);
+  addOptionalRegular<ELFT>(S, In::X<ELFT>::RelaIplt, -1, STV_HIDDEN, STB_WEAK);
 }
 
 // The linker is expected to define some symbols depending on
@@ -844,7 +845,7 @@
   // to avoid the undefined symbol error. As usual special cases are ARM and
   // MIPS - the libc for these targets defines __tls_get_addr itself because
   // there are no TLS optimizations for these targets.
-  if (!In<ELFT>::DynSymTab &&
+  if (!In::X<ELFT>::DynSymTab &&
       (Config->EMachine != EM_MIPS && Config->EMachine != EM_ARM))
     Symtab<ELFT>::X->addIgnored("__tls_get_addr");
 
@@ -929,7 +930,7 @@
   }
 
   if (!Config->Relocatable) {
-    for (EhInputSection *ES : In<ELFT>::EhFrame->Sections)
+    for (EhInputSection *ES : In::X<ELFT>::EhFrame->Sections)
       Fn(*ES);
   }
 }
@@ -1095,8 +1096,8 @@
   // It should be okay as no one seems to care about the type.
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
-  if (In<ELFT>::DynSymTab)
-    addRegular<ELFT>("_DYNAMIC", In<ELFT>::Dynamic, 0);
+  if (In::X<ELFT>::DynSymTab)
+    addRegular<ELFT>("_DYNAMIC", In::X<ELFT>::Dynamic, 0);
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
@@ -1104,17 +1105,17 @@
   // This responsible for splitting up .eh_frame section into
   // pieces. The relocation scan uses those pieces, so this has to be
   // earlier.
-  applySynthetic<ELFT>({In<ELFT>::EhFrame},
+  applySynthetic<ELFT>({In::X<ELFT>::EhFrame},
                        [](SyntheticSection *SS) { SS->finalizeContents(); });
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
   forEachRelSec(scanRelocations<ELFT>);
 
-  if (In<ELFT>::Plt && !In<ELFT>::Plt->empty())
-    In<ELFT>::Plt->addSymbols();
-  if (In<ELFT>::Iplt && !In<ELFT>::Iplt->empty())
-    In<ELFT>::Iplt->addSymbols();
+  if (In::X<ELFT>::Plt && !In::X<ELFT>::Plt->empty())
+    In::X<ELFT>::Plt->addSymbols();
+  if (In::X<ELFT>::Iplt && !In::X<ELFT>::Iplt->empty())
+    In::X<ELFT>::Iplt->addSymbols();
 
   // Now that we have defined all possible global symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.
@@ -1123,14 +1124,14 @@
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
-    if (In<ELFT>::SymTab)
-      In<ELFT>::SymTab->addSymbol(Body);
+    if (In::X<ELFT>::SymTab)
+      In::X<ELFT>::SymTab->addSymbol(Body);
 
-    if (In<ELFT>::DynSymTab && S->includeInDynsym()) {
-      In<ELFT>::DynSymTab->addSymbol(Body);
+    if (In::X<ELFT>::DynSymTab && S->includeInDynsym()) {
+      In::X<ELFT>::DynSymTab->addSymbol(Body);
       if (auto *SS = dyn_cast<SharedSymbol>(Body))
         if (cast<SharedFile<ELFT>>(SS->File)->isNeeded())
-          In<ELFT>::VerNeed->addSymbol(SS);
+          In::X<ELFT>::VerNeed->addSymbol(SS);
     }
   }
 
@@ -1153,7 +1154,7 @@
   unsigned I = 1;
   for (OutputSection *Sec : OutputSections) {
     Sec->SectionIndex = I++;
-    Sec->ShName = In<ELFT>::ShStrTab->addString(Sec->Name);
+    Sec->ShName = In::X<ELFT>::ShStrTab->addString(Sec->Name);
   }
 
   // Binary and relocatable output does not have PHDRS.
@@ -1169,14 +1170,14 @@
   // Dynamic section must be the last one in this list and dynamic
   // symbol table section (DynSymTab) must be the first one.
   applySynthetic<ELFT>(
-      {In<ELFT>::DynSymTab, In<ELFT>::GnuHashTab, In<ELFT>::HashTab,
-       In<ELFT>::SymTab,    In<ELFT>::ShStrTab,   In<ELFT>::StrTab,
-       In<ELFT>::VerDef,    In<ELFT>::DynStrTab,  In<ELFT>::GdbIndex,
-       In<ELFT>::Got,       In<ELFT>::MipsGot,    In<ELFT>::IgotPlt,
-       In<ELFT>::GotPlt,    In<ELFT>::RelaDyn,    In<ELFT>::RelaIplt,
-       In<ELFT>::RelaPlt,   In<ELFT>::Plt,        In<ELFT>::Iplt,
-       In<ELFT>::Plt,       In<ELFT>::EhFrameHdr, In<ELFT>::VerSym,
-       In<ELFT>::VerNeed,   In<ELFT>::Dynamic},
+      {In::X<ELFT>::DynSymTab, In::X<ELFT>::GnuHashTab, In::X<ELFT>::HashTab,
+       In::X<ELFT>::SymTab,    In::X<ELFT>::ShStrTab,   In::X<ELFT>::StrTab,
+       In::X<ELFT>::VerDef,    In::X<ELFT>::DynStrTab,  In::X<ELFT>::GdbIndex,
+       In::X<ELFT>::Got,       In::X<ELFT>::MipsGot,    In::X<ELFT>::IgotPlt,
+       In::X<ELFT>::GotPlt,    In::X<ELFT>::RelaDyn,    In::X<ELFT>::RelaIplt,
+       In::X<ELFT>::RelaPlt,   In::X<ELFT>::Plt,        In::X<ELFT>::Iplt,
+       In::X<ELFT>::Plt,       In::X<ELFT>::EhFrameHdr, In::X<ELFT>::VerSym,
+       In::X<ELFT>::VerNeed,   In::X<ELFT>::Dynamic},
       [](SyntheticSection *SS) { SS->finalizeContents(); });
 
   // Some architectures use small displacements for jump instructions.
@@ -1190,7 +1191,7 @@
     // are out of range. This will need to turn into a loop that converges
     // when no more Thunks are added
     if (createThunks<ELFT>(OutputSections))
-      applySynthetic<ELFT>({In<ELFT>::MipsGot},
+      applySynthetic<ELFT>({In::X<ELFT>::MipsGot},
                            [](SyntheticSection *SS) { SS->updateAllocSize(); });
   }
   // Fill other section headers. The dynamic table is finalized
@@ -1200,8 +1201,9 @@
     Sec->finalize<ELFT>();
 
   // createThunks may have added local symbols to the static symbol table
-  applySynthetic<ELFT>({In<ELFT>::SymTab, In<ELFT>::ShStrTab, In<ELFT>::StrTab},
-                       [](SyntheticSection *SS) { SS->postThunkContents(); });
+  applySynthetic<ELFT>(
+      {In::X<ELFT>::SymTab, In::X<ELFT>::ShStrTab, In::X<ELFT>::StrTab},
+      [](SyntheticSection *SS) { SS->postThunkContents(); });
 }
 
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
@@ -1341,9 +1343,9 @@
     Ret.push_back(std::move(TlsHdr));
 
   // Add an entry for .dynamic.
-  if (In<ELFT>::DynSymTab)
-    AddHdr(PT_DYNAMIC, In<ELFT>::Dynamic->OutSec->getPhdrFlags())
-        ->add(In<ELFT>::Dynamic->OutSec);
+  if (In::X<ELFT>::DynSymTab)
+    AddHdr(PT_DYNAMIC, In::X<ELFT>::Dynamic->OutSec->getPhdrFlags())
+        ->add(In::X<ELFT>::Dynamic->OutSec);
 
   // PT_GNU_RELRO includes all sections that should be marked as
   // read-only by dynamic linker after proccessing relocations.
@@ -1355,10 +1357,10 @@
     Ret.push_back(std::move(RelRo));
 
   // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
-  if (!In<ELFT>::EhFrame->empty() && In<ELFT>::EhFrameHdr &&
-      In<ELFT>::EhFrame->OutSec && In<ELFT>::EhFrameHdr->OutSec)
-    AddHdr(PT_GNU_EH_FRAME, In<ELFT>::EhFrameHdr->OutSec->getPhdrFlags())
-        ->add(In<ELFT>::EhFrameHdr->OutSec);
+  if (!In::X<ELFT>::EhFrame->empty() && In::X<ELFT>::EhFrameHdr &&
+      In::X<ELFT>::EhFrame->OutSec && In::X<ELFT>::EhFrameHdr->OutSec)
+    AddHdr(PT_GNU_EH_FRAME, In::X<ELFT>::EhFrameHdr->OutSec->getPhdrFlags())
+        ->add(In::X<ELFT>::EhFrameHdr->OutSec);
 
   // PT_OPENBSD_RANDOMIZE specifies the location and size of a part of the
   // memory image of the program that must be filled with random data before any
@@ -1738,7 +1740,7 @@
   EHdr->e_phnum = Phdrs.size();
   EHdr->e_shentsize = sizeof(Elf_Shdr);
   EHdr->e_shnum = OutputSections.size() + 1;
-  EHdr->e_shstrndx = In<ELFT>::ShStrTab->OutSec->SectionIndex;
+  EHdr->e_shstrndx = In::X<ELFT>::ShStrTab->OutSec->SectionIndex;
 
   if (Config->EMachine == EM_ARM)
     // We don't currently use any features incompatible with EF_ARM_EABI_VER5,
@@ -1841,7 +1843,7 @@
   }
 
   OutputSection *EhFrameHdr =
-      In<ELFT>::EhFrameHdr ? In<ELFT>::EhFrameHdr->OutSec : nullptr;
+      In::X<ELFT>::EhFrameHdr ? In::X<ELFT>::EhFrameHdr->OutSec : nullptr;
 
   // In -r or -emit-relocs mode, write the relocation sections first as in
   // ELf_Rel targets we might find out that we need to modify the relocated
@@ -1862,13 +1864,13 @@
 }
 
 template <class ELFT> void Writer<ELFT>::writeBuildId() {
-  if (!In<ELFT>::BuildId || !In<ELFT>::BuildId->OutSec)
+  if (!In::X<ELFT>::BuildId || !In::X<ELFT>::BuildId->OutSec)
     return;
 
   // Compute a hash of all sections of the output file.
   uint8_t *Start = Buffer->getBufferStart();
   uint8_t *End = Start + FileSize;
-  In<ELFT>::BuildId->writeBuildId({Start, End});
+  In::X<ELFT>::BuildId->writeBuildId({Start, End});
 }
 
 template void elf::writeResult<ELF32LE>();