diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -1291,7 +1291,7 @@
 }
 
 // Force Sym to be entered in the output. Used for -u or equivalent.
-template <class ELFT> static void handleUndefined(StringRef Name) {
+static void handleUndefined(StringRef Name) {
   Symbol *Sym = Symtab->find(Name);
   if (!Sym)
     return;
@@ -1301,10 +1301,10 @@
   Sym->IsUsedInRegularObj = true;
 
   if (Sym->isLazy())
-    Symtab->fetchLazy<ELFT>(Sym);
+    Symtab->fetchLazy(Sym);
 }
 
-template <class ELFT> static void handleLibcall(StringRef Name) {
+static void handleLibcall(StringRef Name) {
   Symbol *Sym = Symtab->find(Name);
   if (!Sym || !Sym->isLazy())
     return;
@@ -1316,7 +1316,7 @@
     MB = cast<LazyArchive>(Sym)->getMemberBuffer();
 
   if (isBitcode(MB))
-    Symtab->fetchLazy<ELFT>(Sym);
+    Symtab->fetchLazy(Sym);
 }
 
 static void replaceCommonSymbols() {
@@ -1419,7 +1419,7 @@
 
 template <class ELFT> static Symbol *addUndefined(StringRef Name) {
   Undefined Sym(nullptr, Name, STB_GLOBAL, STV_DEFAULT, 0);
-  return Symtab->addUndefined<ELFT>(&Sym);
+  return Symtab->addUndefined(&Sym);
 }
 
 // The --wrap option is a feature to rename symbols so that you can write
@@ -1543,7 +1543,7 @@
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
   for (InputFile *F : Files)
-    parseFile<ELFT>(F);
+    parseFile(F);
 
   // Now that we have every file, we can decide if we will need a
   // dynamic symbol table.
@@ -1561,10 +1561,10 @@
 
   // Handle the `--undefined <sym>` options.
   for (StringRef S : Config->Undefined)
-    handleUndefined<ELFT>(S);
+    handleUndefined(S);
 
   // If an entry symbol is in a static archive, pull out that file now.
-  handleUndefined<ELFT>(Config->Entry);
+  handleUndefined(Config->Entry);
 
   // If any of our inputs are bitcode files, the LTO code generator may create
   // references to certain library functions that might not be explicit in the
@@ -1585,7 +1585,7 @@
   // object file to the link.
   if (!BitcodeFiles.empty())
     for (const char *S : LibcallRoutineNames)
-      handleLibcall<ELFT>(S);
+      handleLibcall(S);
 
   // Return if there were name resolution errors.
   if (errorCount())
diff --git a/lld/ELF/InputFiles.h b/lld/ELF/InputFiles.h
--- a/lld/ELF/InputFiles.h
+++ b/lld/ELF/InputFiles.h
@@ -55,7 +55,7 @@
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 // Add symbols in File to the symbol table.
-template <class ELFT> void parseFile(InputFile *File);
+void parseFile(InputFile *File);
 
 // The root class of input files.
 class InputFile {
@@ -323,7 +323,7 @@
 public:
   explicit ArchiveFile(std::unique_ptr<Archive> &&File);
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
-  template <class ELFT> void parse();
+  void parse();
 
   // Pulls out an object file that contains a definition for Sym and
   // returns it. If the same file was instantiated before, this
diff --git a/lld/ELF/InputFiles.cpp b/lld/ELF/InputFiles.cpp
--- a/lld/ELF/InputFiles.cpp
+++ b/lld/ELF/InputFiles.cpp
@@ -109,8 +109,7 @@
   return false;
 }
 
-// Add symbols in File to the symbol table.
-template <class ELFT> void elf::parseFile(InputFile *File) {
+template <class ELFT> static void doParseFile(InputFile *File) {
   // Comdat groups define "link once" sections. If two comdat groups have the
   // same name, only one of them is linked, and the other is ignored. This set
   // is used to uniquify them.
@@ -128,7 +127,7 @@
 
   // .a file
   if (auto *F = dyn_cast<ArchiveFile>(File)) {
-    F->parse<ELFT>();
+    F->parse();
     return;
   }
 
@@ -160,6 +159,26 @@
   cast<ObjFile<ELFT>>(File)->parse(ComdatGroups);
 }
 
+// Add symbols in File to the symbol table.
+void elf::parseFile(InputFile *File) {
+  switch (Config->EKind) {
+  case ELF32LEKind:
+    doParseFile<ELF32LE>(File);
+    return;
+  case ELF32BEKind:
+    doParseFile<ELF32BE>(File);
+    return;
+  case ELF64LEKind:
+    doParseFile<ELF64LE>(File);
+    return;
+  case ELF64BEKind:
+    doParseFile<ELF64BE>(File);
+    return;
+  default:
+    llvm_unreachable("unknown ELFT");
+  }
+}
+
 // Concatenates arguments to construct a string representing an error location.
 static std::string createFileLineMsg(StringRef Path, unsigned Line) {
   std::string Filename = path::filename(Path);
@@ -895,7 +914,7 @@
   switch (Sym->st_shndx) {
   case SHN_UNDEF: {
     Undefined S(this, Name, Binding, StOther, Type);
-    return Symtab->addUndefined<ELFT>(&S);
+    return Symtab->addUndefined(&S);
   }
   case SHN_COMMON:
     if (Value == 0 || Value >= UINT32_MAX)
@@ -913,7 +932,7 @@
   case STB_GNU_UNIQUE:
     if (Sec == &InputSection::Discarded) {
       Undefined S(this, Name, Binding, StOther, Type);
-      return Symtab->addUndefined<ELFT>(&S);
+      return Symtab->addUndefined(&S);
     }
 
     Defined New(this, Name, Binding, StOther, Type, Value, Size, Sec);
@@ -925,10 +944,10 @@
     : InputFile(ArchiveKind, File->getMemoryBufferRef()),
       File(std::move(File)) {}
 
-template <class ELFT> void ArchiveFile::parse() {
+void ArchiveFile::parse() {
   for (const Archive::Symbol &Sym : File->symbols()) {
     LazyArchive New(*this, Sym);
-    Symtab->addLazyArchive<ELFT>(&New);
+    Symtab->addLazyArchive(&New);
   }
 }
 
@@ -1131,7 +1150,7 @@
 
     if (Sym.isUndefined()) {
       Undefined New(this, Name, Sym.getBinding(), Sym.st_other, Sym.getType());
-      Symbol *S = Symtab->addUndefined<ELFT>(&New);
+      Symbol *S = Symtab->addUndefined(&New);
       S->ExportDynamic = true;
       continue;
     }
@@ -1271,7 +1290,7 @@
     Undefined New(&F, Name, Binding, Visibility, Type);
     if (CanOmitFromDynSym)
       New.ExportDynamic = false;
-    return Symtab->addUndefined<ELFT>(&New);
+    return Symtab->addUndefined(&New);
   }
 
   if (ObjSym.isCommon()) {
@@ -1419,7 +1438,7 @@
       if (Sym.isUndefined())
         continue;
       LazyObject New(*this, Saver.save(Sym.getName()));
-      Symtab->addLazyObject<ELFT>(&New);
+      Symtab->addLazyObject(&New);
     }
     return;
   }
@@ -1445,7 +1464,7 @@
       if (Sym.st_shndx == SHN_UNDEF)
         continue;
       LazyObject New(*this, CHECK(Sym.getName(StringTable), this));
-      Symtab->addLazyObject<ELFT>(&New);
+      Symtab->addLazyObject(&New);
     }
     return;
   }
@@ -1460,16 +1479,6 @@
   return Path;
 }
 
-template void elf::parseFile<ELF32LE>(InputFile *);
-template void elf::parseFile<ELF32BE>(InputFile *);
-template void elf::parseFile<ELF64LE>(InputFile *);
-template void elf::parseFile<ELF64BE>(InputFile *);
-
-template void ArchiveFile::parse<ELF32LE>();
-template void ArchiveFile::parse<ELF32BE>();
-template void ArchiveFile::parse<ELF64LE>();
-template void ArchiveFile::parse<ELF64BE>();
-
 template void BitcodeFile::parse<ELF32LE>(DenseSet<CachedHashStringRef> &);
 template void BitcodeFile::parse<ELF32BE>(DenseSet<CachedHashStringRef> &);
 template void BitcodeFile::parse<ELF64LE>(DenseSet<CachedHashStringRef> &);
diff --git a/lld/ELF/SymbolTable.h b/lld/ELF/SymbolTable.h
--- a/lld/ELF/SymbolTable.h
+++ b/lld/ELF/SymbolTable.h
@@ -45,22 +45,18 @@
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
 
-  template <class ELFT> Symbol *addUndefined(Undefined *New);
-
+  Symbol *addUndefined(Undefined *New);
   Symbol *addDefined(Defined *New);
-
   void addShared(SharedSymbol *New);
-
-  template <class ELFT> void addLazyArchive(LazyArchive *New);
-  template <class ELFT> void addLazyObject(LazyObject *New);
-
+  void addLazyArchive(LazyArchive *New);
+  void addLazyObject(LazyObject *New);
   Symbol *addBitcode(Defined *New);
   Symbol *addCommon(CommonSymbol *New);
 
   Symbol *insert(Symbol *New);
   void mergeProperties(Symbol *Old, Symbol *New);
 
-  template <class ELFT> void fetchLazy(Symbol *Sym);
+  void fetchLazy(Symbol *Sym);
 
   void scanVersionScript();
 
@@ -74,7 +70,7 @@
   llvm::DenseMap<StringRef, SharedFile *> SoNames;
 
 private:
-  template <class ELFT, class LazyT> void addLazy(LazyT *New);
+  template <class LazyT> void addLazy(LazyT *New);
 
   std::vector<Symbol *> findByVersion(SymbolVersion Ver);
   std::vector<Symbol *> findAllByVersion(SymbolVersion Ver);
diff --git a/lld/ELF/SymbolTable.cpp b/lld/ELF/SymbolTable.cpp
--- a/lld/ELF/SymbolTable.cpp
+++ b/lld/ELF/SymbolTable.cpp
@@ -144,7 +144,7 @@
     Old->Visibility = getMinVisibility(Old->Visibility, New->Visibility);
 }
 
-template <class ELFT> Symbol *SymbolTable::addUndefined(Undefined *New) {
+Symbol *SymbolTable::addUndefined(Undefined *New) {
   Symbol *Old = insert(New);
   mergeProperties(Old, New);
 
@@ -224,7 +224,7 @@
     // group assignment rule simulates the traditional linker's semantics.
     bool Backref = Config->WarnBackrefs && New->File &&
                    Old->File->GroupId < New->File->GroupId;
-    fetchLazy<ELFT>(Old);
+    fetchLazy(Old);
 
     // We don't report backward references to weak symbols as they can be
     // overridden later.
@@ -430,7 +430,7 @@
   return SymVector[It->second];
 }
 
-template <class ELFT, class LazyT> void SymbolTable::addLazy(LazyT *New) {
+template <class LazyT> void SymbolTable::addLazy(LazyT *New) {
   Symbol *Old = insert(New);
   mergeProperties(Old, New);
 
@@ -453,27 +453,23 @@
   }
 
   if (InputFile *F = New->fetch())
-    parseFile<ELFT>(F);
+    parseFile(F);
 }
 
-template <class ELFT> void SymbolTable::addLazyArchive(LazyArchive *New) {
-  addLazy<ELFT>(New);
-}
+void SymbolTable::addLazyArchive(LazyArchive *New) { addLazy(New); }
 
-template <class ELFT> void SymbolTable::addLazyObject(LazyObject *New) {
-  addLazy<ELFT>(New);
-}
+void SymbolTable::addLazyObject(LazyObject *New) { addLazy(New); }
 
-template <class ELFT> void SymbolTable::fetchLazy(Symbol *Sym) {
+void SymbolTable::fetchLazy(Symbol *Sym) {
   if (auto *S = dyn_cast<LazyArchive>(Sym)) {
     if (InputFile *File = S->fetch())
-      parseFile<ELFT>(File);
+      parseFile(File);
     return;
   }
 
   auto *S = cast<LazyObject>(Sym);
   if (InputFile *File = cast<LazyObjFile>(S->File)->fetch())
-    parseFile<ELFT>(File);
+    parseFile(File);
 }
 
 // Initialize DemangledSyms with a map from demangled symbols to symbol
@@ -637,27 +633,7 @@
     Sym->parseSymbolVersion();
 }
 
-template Symbol *SymbolTable::addUndefined<ELF32LE>(Undefined *);
-template Symbol *SymbolTable::addUndefined<ELF32BE>(Undefined *);
-template Symbol *SymbolTable::addUndefined<ELF64LE>(Undefined *);
-template Symbol *SymbolTable::addUndefined<ELF64BE>(Undefined *);
-
 template void SymbolTable::addCombinedLTOObject<ELF32LE>();
 template void SymbolTable::addCombinedLTOObject<ELF32BE>();
 template void SymbolTable::addCombinedLTOObject<ELF64LE>();
 template void SymbolTable::addCombinedLTOObject<ELF64BE>();
-
-template void SymbolTable::addLazyArchive<ELF32LE>(LazyArchive *);
-template void SymbolTable::addLazyArchive<ELF32BE>(LazyArchive *);
-template void SymbolTable::addLazyArchive<ELF64LE>(LazyArchive *);
-template void SymbolTable::addLazyArchive<ELF64BE>(LazyArchive *);
-
-template void SymbolTable::addLazyObject<ELF32LE>(LazyObject *);
-template void SymbolTable::addLazyObject<ELF32BE>(LazyObject *);
-template void SymbolTable::addLazyObject<ELF64LE>(LazyObject *);
-template void SymbolTable::addLazyObject<ELF64BE>(LazyObject *);
-
-template void SymbolTable::fetchLazy<ELF32LE>(Symbol *);
-template void SymbolTable::fetchLazy<ELF32BE>(Symbol *);
-template void SymbolTable::fetchLazy<ELF64LE>(Symbol *);
-template void SymbolTable::fetchLazy<ELF64BE>(Symbol *);