diff --git a/include/llvm/Analysis/AliasAnalysis.h b/include/llvm/Analysis/AliasAnalysis.h
index 925bcb6b6e9..53c0b18fa22 100644
--- a/include/llvm/Analysis/AliasAnalysis.h
+++ b/include/llvm/Analysis/AliasAnalysis.h
@@ -874,6 +874,9 @@ public:
   }
 
 private:
+  friend AnalysisBase<AAManager>;
+  static char PassID;
+
   SmallVector<void (*)(Function &F, AnalysisManager<Function> &AM,
                        AAResults &AAResults),
               4> ResultGetters;
@@ -895,8 +898,6 @@ private:
   }
 };
 
-extern template class AnalysisBase<AAManager>;
-
 /// A wrapper pass to provide the legacy pass manager access to a suitably
 /// prepared AAResults object.
 class AAResultsWrapperPass : public FunctionPass {
diff --git a/include/llvm/Analysis/AssumptionCache.h b/include/llvm/Analysis/AssumptionCache.h
index fbd4b5243ad..9c2737c5181 100644
--- a/include/llvm/Analysis/AssumptionCache.h
+++ b/include/llvm/Analysis/AssumptionCache.h
@@ -93,7 +93,11 @@ public:
 ///
 /// This analysis is intended for use with the new pass manager and will vend
 /// assumption caches for a given function.
-struct AssumptionAnalysis : AnalysisBase<AssumptionAnalysis> {
+class AssumptionAnalysis : public AnalysisBase<AssumptionAnalysis> {
+  friend AnalysisBase<AssumptionAnalysis>;
+  static char PassID;
+
+public:
   typedef AssumptionCache Result;
 
   AssumptionAnalysis() {}
@@ -105,8 +109,6 @@ struct AssumptionAnalysis : AnalysisBase<AssumptionAnalysis> {
   AssumptionCache run(Function &F) { return AssumptionCache(F); }
 };
 
-extern template class AnalysisBase<AssumptionAnalysis>;
-
 /// \brief Printer pass for the \c AssumptionAnalysis results.
 class AssumptionPrinterPass : public PassBase<AssumptionPrinterPass> {
   raw_ostream &OS;
diff --git a/include/llvm/Analysis/BasicAliasAnalysis.h b/include/llvm/Analysis/BasicAliasAnalysis.h
index 01cbbcd6183..bd71eae388c 100644
--- a/include/llvm/Analysis/BasicAliasAnalysis.h
+++ b/include/llvm/Analysis/BasicAliasAnalysis.h
@@ -180,7 +180,11 @@ private:
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
-struct BasicAA : AnalysisBase<BasicAA> {
+class BasicAA : public AnalysisBase<BasicAA> {
+  friend AnalysisBase<BasicAA>;
+  static char PassID;
+
+public:
   typedef BasicAAResult Result;
 
   BasicAAResult run(Function &F, AnalysisManager<Function> *AM);
diff --git a/include/llvm/Analysis/CFLAliasAnalysis.h b/include/llvm/Analysis/CFLAliasAnalysis.h
index 06fa3920675..1e7c3b72540 100644
--- a/include/llvm/Analysis/CFLAliasAnalysis.h
+++ b/include/llvm/Analysis/CFLAliasAnalysis.h
@@ -109,7 +109,11 @@ private:
 ///
 /// FIXME: We really should refactor CFL to use the analysis more heavily, and
 /// in particular to leverage invalidation to trigger re-computation of sets.
-struct CFLAA : AnalysisBase<CFLAA> {
+class CFLAA : public AnalysisBase<CFLAA> {
+  friend AnalysisBase<CFLAA>;
+  static char PassID;
+
+public:
   typedef CFLAAResult Result;
 
   CFLAAResult run(Function &F, AnalysisManager<Function> *AM);
diff --git a/include/llvm/Analysis/CGSCCPassManager.h b/include/llvm/Analysis/CGSCCPassManager.h
index 5cc1c382ad4..4da08741a8a 100644
--- a/include/llvm/Analysis/CGSCCPassManager.h
+++ b/include/llvm/Analysis/CGSCCPassManager.h
@@ -48,16 +48,12 @@ extern template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
 typedef InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>
     CGSCCAnalysisManagerModuleProxy;
 
-extern template class AnalysisBase<CGSCCAnalysisManagerModuleProxy>;
-
 extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
                                                 LazyCallGraph::SCC>;
 /// A proxy from a \c ModuleAnalysisManager to an \c SCC.
 typedef OuterAnalysisManagerProxy<ModuleAnalysisManager, LazyCallGraph::SCC>
     ModuleAnalysisManagerCGSCCProxy;
 
-extern template class AnalysisBase<ModuleAnalysisManagerCGSCCProxy>;
-
 /// \brief The core module pass which does a post-order walk of the SCCs and
 /// runs a CGSCC pass over each one.
 ///
@@ -148,8 +144,6 @@ extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
 typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, LazyCallGraph::SCC>
     FunctionAnalysisManagerCGSCCProxy;
 
-extern template class AnalysisBase<FunctionAnalysisManagerCGSCCProxy>;
-
 extern template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
 /// A proxy from a \c CGSCCAnalysisManager to a \c Function.
 typedef OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>
diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h
index 05939db3d59..45474f003cd 100644
--- a/include/llvm/Analysis/CallGraph.h
+++ b/include/llvm/Analysis/CallGraph.h
@@ -295,7 +295,10 @@ private:
 /// This class implements the concept of an analysis pass used by the \c
 /// ModuleAnalysisManager to run an analysis over a module and cache the
 /// resulting data.
-struct CallGraphAnalysis : AnalysisBase<CallGraphAnalysis> {
+class CallGraphAnalysis : public AnalysisBase<CallGraphAnalysis> {
+  friend AnalysisBase<CallGraphAnalysis>;
+  static char PassID;
+
 public:
   /// \brief A formulaic typedef to inform clients of the result type.
   typedef CallGraph Result;
@@ -306,9 +309,6 @@ public:
   CallGraph run(Module &M) { return CallGraph(M); }
 };
 
-/// Instantiated in CallGraph.cpp
-extern template class llvm::AnalysisBase<CallGraphAnalysis>;
-
 /// \brief Printer pass for the \c CallGraphAnalysis results.
 class CallGraphPrinterPass : public PassBase<CallGraphPrinterPass> {
   raw_ostream &OS;
diff --git a/include/llvm/Analysis/DominanceFrontier.h b/include/llvm/Analysis/DominanceFrontier.h
index ea2743dc810..197d3652d77 100644
--- a/include/llvm/Analysis/DominanceFrontier.h
+++ b/include/llvm/Analysis/DominanceFrontier.h
@@ -168,7 +168,12 @@ extern template class DominanceFrontierBase<BasicBlock>;
 extern template class ForwardDominanceFrontierBase<BasicBlock>;
 
 /// \brief Analysis pass which computes a \c DominanceFrontier.
-struct DominanceFrontierAnalysis : AnalysisBase<DominanceFrontierAnalysis> {
+class DominanceFrontierAnalysis
+    : public AnalysisBase<DominanceFrontierAnalysis> {
+  friend AnalysisBase<DominanceFrontierAnalysis>;
+  static char PassID;
+
+public:
   /// \brief Provide the result typedef for this analysis pass.
   typedef DominanceFrontier Result;
 
@@ -176,8 +181,6 @@ struct DominanceFrontierAnalysis : AnalysisBase<DominanceFrontierAnalysis> {
   DominanceFrontier run(Function &F, AnalysisManager<Function> *AM);
 };
 
-extern template class AnalysisBase<DominanceFrontierAnalysis>;
-
 /// \brief Printer pass for the \c DominanceFrontier.
 class DominanceFrontierPrinterPass
     : public PassBase<DominanceFrontierPrinterPass> {
diff --git a/include/llvm/Analysis/GlobalsModRef.h b/include/llvm/Analysis/GlobalsModRef.h
index 45be116e6ba..c8eea06b973 100644
--- a/include/llvm/Analysis/GlobalsModRef.h
+++ b/include/llvm/Analysis/GlobalsModRef.h
@@ -118,7 +118,11 @@ private:
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
-struct GlobalsAA : AnalysisBase<GlobalsAA> {
+class GlobalsAA : public AnalysisBase<GlobalsAA> {
+  friend AnalysisBase<GlobalsAA>;
+  static char PassID;
+
+public:
   typedef GlobalsAAResult Result;
 
   GlobalsAAResult run(Module &M, AnalysisManager<Module> *AM);
diff --git a/include/llvm/Analysis/LazyCallGraph.h b/include/llvm/Analysis/LazyCallGraph.h
index af2e067690d..89f8cf2062c 100644
--- a/include/llvm/Analysis/LazyCallGraph.h
+++ b/include/llvm/Analysis/LazyCallGraph.h
@@ -895,7 +895,11 @@ template <> struct GraphTraits<LazyCallGraph *> {
 };
 
 /// An analysis pass which computes the call graph for a module.
-struct LazyCallGraphAnalysis : AnalysisBase<LazyCallGraphAnalysis> {
+class LazyCallGraphAnalysis : public AnalysisBase<LazyCallGraphAnalysis> {
+  friend AnalysisBase<LazyCallGraphAnalysis>;
+  static char PassID;
+
+public:
   /// Inform generic clients of the result type.
   typedef LazyCallGraph Result;
 
@@ -906,8 +910,6 @@ struct LazyCallGraphAnalysis : AnalysisBase<LazyCallGraphAnalysis> {
   LazyCallGraph run(Module &M) { return LazyCallGraph(M); }
 };
 
-extern template class AnalysisBase<LazyCallGraphAnalysis>;
-
 /// A pass which prints the call graph to a \c raw_ostream.
 ///
 /// This is primarily useful for testing the analysis.
diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index d33c215e1f4..2ea8d283f3a 100644
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -787,14 +787,16 @@ template <> struct GraphTraits<Loop*> {
 };
 
 /// \brief Analysis pass that exposes the \c LoopInfo for a function.
-struct LoopAnalysis : AnalysisBase<LoopAnalysis> {
+class LoopAnalysis : public AnalysisBase<LoopAnalysis> {
+  friend AnalysisBase<LoopAnalysis>;
+  static char PassID;
+
+public:
   typedef LoopInfo Result;
 
   LoopInfo run(Function &F, AnalysisManager<Function> *AM);
 };
 
-extern template class AnalysisBase<LoopAnalysis>;
-
 /// \brief Printer pass for the \c LoopAnalysis results.
 class LoopPrinterPass : public PassBase<LoopPrinterPass> {
   raw_ostream &OS;
diff --git a/include/llvm/Analysis/LoopPassManager.h b/include/llvm/Analysis/LoopPassManager.h
index 34bd78d6eb3..c3a6c4e3545 100644
--- a/include/llvm/Analysis/LoopPassManager.h
+++ b/include/llvm/Analysis/LoopPassManager.h
@@ -43,8 +43,6 @@ extern template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
 typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function>
     LoopAnalysisManagerFunctionProxy;
 
-extern template class AnalysisBase<LoopAnalysisManagerFunctionProxy>;
-
 extern template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>;
 /// A proxy from a \c FunctionAnalysisManager to a \c Loop.
 typedef OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>
diff --git a/include/llvm/Analysis/MemoryDependenceAnalysis.h b/include/llvm/Analysis/MemoryDependenceAnalysis.h
index 38d8db51f45..b33765081d4 100644
--- a/include/llvm/Analysis/MemoryDependenceAnalysis.h
+++ b/include/llvm/Analysis/MemoryDependenceAnalysis.h
@@ -471,7 +471,11 @@ private:
 ///
 /// This is essentially a no-op because the results are computed entirely
 /// lazily.
-struct MemoryDependenceAnalysis : AnalysisBase<MemoryDependenceAnalysis> {
+class MemoryDependenceAnalysis : public AnalysisBase<MemoryDependenceAnalysis> {
+  friend AnalysisBase<MemoryDependenceAnalysis>;
+  static char PassID;
+
+public:
   typedef MemoryDependenceResults Result;
 
   MemoryDependenceResults run(Function &F, AnalysisManager<Function> *AM);
diff --git a/include/llvm/Analysis/ObjCARCAliasAnalysis.h b/include/llvm/Analysis/ObjCARCAliasAnalysis.h
index 3d634b17a70..0370b638de9 100644
--- a/include/llvm/Analysis/ObjCARCAliasAnalysis.h
+++ b/include/llvm/Analysis/ObjCARCAliasAnalysis.h
@@ -61,7 +61,11 @@ public:
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
-struct ObjCARCAA : AnalysisBase<ObjCARCAA> {
+class ObjCARCAA : public AnalysisBase<ObjCARCAA> {
+  friend AnalysisBase<ObjCARCAA>;
+  static char PassID;
+
+public:
   typedef ObjCARCAAResult Result;
 
   ObjCARCAAResult run(Function &F, AnalysisManager<Function> *AM);
diff --git a/include/llvm/Analysis/PostDominators.h b/include/llvm/Analysis/PostDominators.h
index fac8e88c2b0..22d1b236de1 100644
--- a/include/llvm/Analysis/PostDominators.h
+++ b/include/llvm/Analysis/PostDominators.h
@@ -37,7 +37,12 @@ struct PostDominatorTree : public DominatorTreeBase<BasicBlock> {
 };
 
 /// \brief Analysis pass which computes a \c PostDominatorTree.
-struct PostDominatorTreeAnalysis : AnalysisBase<PostDominatorTreeAnalysis> {
+class PostDominatorTreeAnalysis
+    : public AnalysisBase<PostDominatorTreeAnalysis> {
+  friend AnalysisBase<PostDominatorTreeAnalysis>;
+  static char PassID;
+
+public:
   /// \brief Provide the result typedef for this analysis pass.
   typedef PostDominatorTree Result;
 
@@ -46,8 +51,6 @@ struct PostDominatorTreeAnalysis : AnalysisBase<PostDominatorTreeAnalysis> {
   PostDominatorTree run(Function &F);
 };
 
-extern template class AnalysisBase<PostDominatorTreeAnalysis>;
-
 /// \brief Printer pass for the \c PostDominatorTree.
 class PostDominatorTreePrinterPass
     : public PassBase<PostDominatorTreePrinterPass> {
diff --git a/include/llvm/Analysis/RegionInfo.h b/include/llvm/Analysis/RegionInfo.h
index 1ab8bbef10f..3b3a75cf446 100644
--- a/include/llvm/Analysis/RegionInfo.h
+++ b/include/llvm/Analysis/RegionInfo.h
@@ -923,14 +923,16 @@ public:
 };
 
 /// \brief Analysis pass that exposes the \c RegionInfo for a function.
-struct RegionInfoAnalysis : AnalysisBase<RegionInfoAnalysis> {
+class RegionInfoAnalysis : public AnalysisBase<RegionInfoAnalysis> {
+  friend AnalysisBase<RegionInfoAnalysis>;
+  static char PassID;
+
+public:
   typedef RegionInfo Result;
 
   RegionInfo run(Function &F, AnalysisManager<Function> *AM);
 };
 
-extern template class AnalysisBase<RegionInfoAnalysis>;
-
 /// \brief Printer pass for the \c RegionInfo.
 class RegionInfoPrinterPass : public PassBase<RegionInfoPrinterPass> {
   raw_ostream &OS;
diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h
index acc5165e0eb..7d68c425645 100644
--- a/include/llvm/Analysis/ScalarEvolution.h
+++ b/include/llvm/Analysis/ScalarEvolution.h
@@ -1430,14 +1430,16 @@ namespace llvm {
   };
 
   /// \brief Analysis pass that exposes the \c ScalarEvolution for a function.
-  struct ScalarEvolutionAnalysis : AnalysisBase<ScalarEvolutionAnalysis> {
+  class ScalarEvolutionAnalysis : public AnalysisBase<ScalarEvolutionAnalysis> {
+    friend AnalysisBase<ScalarEvolutionAnalysis>;
+    static char PassID;
+
+  public:
     typedef ScalarEvolution Result;
 
     ScalarEvolution run(Function &F, AnalysisManager<Function> *AM);
   };
 
-  extern template class AnalysisBase<ScalarEvolutionAnalysis>;
-
   /// \brief Printer pass for the \c ScalarEvolutionAnalysis results.
   class ScalarEvolutionPrinterPass
       : public PassBase<ScalarEvolutionPrinterPass> {
diff --git a/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h b/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h
index 249e4b9a6b4..96ce5c61363 100644
--- a/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h
+++ b/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h
@@ -38,7 +38,11 @@ private:
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
-struct SCEVAA : AnalysisBase<SCEVAA> {
+class SCEVAA : public AnalysisBase<SCEVAA> {
+  friend AnalysisBase<SCEVAA>;
+  static char PassID;
+
+public:
   typedef SCEVAAResult Result;
 
   SCEVAAResult run(Function &F, AnalysisManager<Function> *AM);
diff --git a/include/llvm/Analysis/ScopedNoAliasAA.h b/include/llvm/Analysis/ScopedNoAliasAA.h
index 92924641954..08cb94b03ee 100644
--- a/include/llvm/Analysis/ScopedNoAliasAA.h
+++ b/include/llvm/Analysis/ScopedNoAliasAA.h
@@ -47,7 +47,11 @@ private:
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
-struct ScopedNoAliasAA : AnalysisBase<ScopedNoAliasAA> {
+class ScopedNoAliasAA : public AnalysisBase<ScopedNoAliasAA> {
+  friend AnalysisBase<ScopedNoAliasAA>;
+  static char PassID;
+
+public:
   typedef ScopedNoAliasAAResult Result;
 
   ScopedNoAliasAAResult run(Function &F, AnalysisManager<Function> *AM);
diff --git a/include/llvm/Analysis/TargetLibraryInfo.h b/include/llvm/Analysis/TargetLibraryInfo.h
index b6792586fae..d7d0878f541 100644
--- a/include/llvm/Analysis/TargetLibraryInfo.h
+++ b/include/llvm/Analysis/TargetLibraryInfo.h
@@ -292,6 +292,9 @@ public:
   TargetLibraryInfo run(Function &F);
 
 private:
+  friend AnalysisBase<TargetLibraryAnalysis>;
+  static char PassID;
+
   Optional<TargetLibraryInfoImpl> PresetInfoImpl;
 
   StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
@@ -299,8 +302,6 @@ private:
   TargetLibraryInfoImpl &lookupInfoImpl(Triple T);
 };
 
-extern template class AnalysisBase<TargetLibraryAnalysis>;
-
 class TargetLibraryInfoWrapperPass : public ImmutablePass {
   TargetLibraryInfoImpl TLIImpl;
   TargetLibraryInfo TLI;
diff --git a/include/llvm/Analysis/TargetTransformInfo.h b/include/llvm/Analysis/TargetTransformInfo.h
index bdc589c60ea..78ea97a1b83 100644
--- a/include/llvm/Analysis/TargetTransformInfo.h
+++ b/include/llvm/Analysis/TargetTransformInfo.h
@@ -922,6 +922,9 @@ public:
   Result run(const Function &F);
 
 private:
+  friend AnalysisBase<TargetIRAnalysis>;
+  static char PassID;
+
   /// \brief The callback used to produce a result.
   ///
   /// We use a completely opaque callback so that targets can provide whatever
@@ -938,8 +941,6 @@ private:
   static Result getDefaultTTI(const Function &F);
 };
 
-extern template class AnalysisBase<TargetIRAnalysis>;
-
 /// \brief Wrapper pass for TargetTransformInfo.
 ///
 /// This pass can be constructed from a TTI object which it stores internally
diff --git a/include/llvm/Analysis/TypeBasedAliasAnalysis.h b/include/llvm/Analysis/TypeBasedAliasAnalysis.h
index 32720dcb85d..2480d948959 100644
--- a/include/llvm/Analysis/TypeBasedAliasAnalysis.h
+++ b/include/llvm/Analysis/TypeBasedAliasAnalysis.h
@@ -48,7 +48,11 @@ private:
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
-struct TypeBasedAA : AnalysisBase<TypeBasedAA> {
+class TypeBasedAA : public AnalysisBase<TypeBasedAA> {
+  friend AnalysisBase<TypeBasedAA>;
+  static char PassID;
+
+public:
   typedef TypeBasedAAResult Result;
 
   TypeBasedAAResult run(Function &F, AnalysisManager<Function> *AM);
diff --git a/include/llvm/IR/Dominators.h b/include/llvm/IR/Dominators.h
index 1082896f0c8..1cb9202ae37 100644
--- a/include/llvm/IR/Dominators.h
+++ b/include/llvm/IR/Dominators.h
@@ -182,7 +182,11 @@ template <> struct GraphTraits<DominatorTree*>
 };
 
 /// \brief Analysis pass which computes a \c DominatorTree.
-struct DominatorTreeAnalysis : AnalysisBase<DominatorTreeAnalysis> {
+class DominatorTreeAnalysis : public AnalysisBase<DominatorTreeAnalysis> {
+  friend AnalysisBase<DominatorTreeAnalysis>;
+  static char PassID;
+
+public:
   /// \brief Provide the result typedef for this analysis pass.
   typedef DominatorTree Result;
 
@@ -190,8 +194,6 @@ struct DominatorTreeAnalysis : AnalysisBase<DominatorTreeAnalysis> {
   DominatorTree run(Function &F);
 };
 
-extern template class AnalysisBase<DominatorTreeAnalysis>;
-
 /// \brief Printer pass for the \c DominatorTree.
 class DominatorTreePrinterPass : public PassBase<DominatorTreePrinterPass> {
   raw_ostream &OS;
diff --git a/include/llvm/IR/PassManager.h b/include/llvm/IR/PassManager.h
index 1ba04fd0e02..02dfb65c9b8 100644
--- a/include/llvm/IR/PassManager.h
+++ b/include/llvm/IR/PassManager.h
@@ -183,17 +183,23 @@ template <typename DerivedT> struct PassBase {
 /// A CRTP mix-in base class to help define types that are valid analyses.
 ///
 /// This provides some boiler plate for types that are analysis passes.
-template <typename DerivedT> class AnalysisBase : public PassBase<DerivedT> {
-  static char PassID;
-
-public:
+template <typename DerivedT> struct AnalysisBase : PassBase<DerivedT> {
   /// Returns an opaque, unique ID for this pass type.
-  static void *ID() { return (void *)&PassID; }
+  ///
+  /// Note that this requires the derived type provide a static member whose
+  /// address can be converted to a void pointer.
+  ///
+  /// FIXME: The only reason the derived type needs to provide this rather than
+  /// this mixin providing it is due to broken implementations which cannot
+  /// correctly unique a templated static so that they have the same addresses
+  /// for each instantiation and are definitively emitted once for each
+  /// instantiation. The only currently known platform with this limitation are
+  /// Windows DLL builds, specifically building each part of LLVM as a DLL. If
+  /// we ever remove that build configuration, this mixin can provide the
+  /// static PassID as well.
+  static void *ID() { return (void *)&DerivedT::PassID; }
 };
 
-/// Private static data to provide unique ID.
-template <typename DerivedT> char AnalysisBase<DerivedT>::PassID;
-
 /// \brief Manages a sequence of passes over units of IR.
 ///
 /// A pass manager contains a sequence of passes to run over units of IR. It is
@@ -740,17 +746,21 @@ public:
   Result run(IRUnitT &IR) { return Result(*AM); }
 
 private:
+  friend AnalysisBase<InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>>;
+  static char PassID;
+
   AnalysisManagerT *AM;
 };
 
+template <typename AnalysisManagerT, typename IRUnitT>
+char InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>::PassID;
+
 extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
                                                 Module>;
 /// Provide the \c FunctionAnalysisManager to \c Module proxy.
 typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>
     FunctionAnalysisManagerModuleProxy;
 
-extern template class AnalysisBase<FunctionAnalysisManagerModuleProxy>;
-
 /// \brief A function analysis which acts as a proxy for a module analysis
 /// manager.
 ///
@@ -808,9 +818,15 @@ public:
   Result run(IRUnitT &) { return Result(*AM); }
 
 private:
+  friend AnalysisBase<OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT>>;
+  static char PassID;
+
   const AnalysisManagerT *AM;
 };
 
+template <typename AnalysisManagerT, typename IRUnitT>
+char OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT>::PassID;
+
 extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
                                                 Function>;
 /// Provide the \c ModuleAnalysisManager to \c Fucntion proxy.
diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp
index 29669899147..453bc3dbe67 100644
--- a/lib/Analysis/AliasAnalysis.cpp
+++ b/lib/Analysis/AliasAnalysis.cpp
@@ -504,7 +504,7 @@ bool AAResults::canInstructionRangeModRef(const Instruction &I1,
 AAResults::Concept::~Concept() {}
 
 // Provide a definition for the static object used to identify passes.
-template class llvm::AnalysisBase<AAManager>;
+char AAManager::PassID;
 
 namespace {
 /// A wrapper pass for external alias analyses. This just squirrels away the
diff --git a/lib/Analysis/AssumptionCache.cpp b/lib/Analysis/AssumptionCache.cpp
index 365397fd083..f468a43ef0b 100644
--- a/lib/Analysis/AssumptionCache.cpp
+++ b/lib/Analysis/AssumptionCache.cpp
@@ -74,7 +74,7 @@ void AssumptionCache::registerAssumption(CallInst *CI) {
 #endif
 }
 
-template class llvm::AnalysisBase<AssumptionAnalysis>;
+char AssumptionAnalysis::PassID;
 
 PreservedAnalyses AssumptionPrinterPass::run(Function &F,
                                              AnalysisManager<Function> *AM) {
diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp
index 4e28892d5f0..84507ec37d7 100644
--- a/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/lib/Analysis/BasicAliasAnalysis.cpp
@@ -1606,6 +1606,8 @@ bool BasicAAResult::constantOffsetHeuristic(
 // BasicAliasAnalysis Pass
 //===----------------------------------------------------------------------===//
 
+char BasicAA::PassID;
+
 BasicAAResult BasicAA::run(Function &F, AnalysisManager<Function> *AM) {
   return BasicAAResult(F.getParent()->getDataLayout(),
                        AM->getResult<TargetLibraryAnalysis>(F),
diff --git a/lib/Analysis/CFLAliasAnalysis.cpp b/lib/Analysis/CFLAliasAnalysis.cpp
index 8b30fb9eefc..9e4ca7ad103 100644
--- a/lib/Analysis/CFLAliasAnalysis.cpp
+++ b/lib/Analysis/CFLAliasAnalysis.cpp
@@ -1088,6 +1088,8 @@ AliasResult CFLAAResult::query(const MemoryLocation &LocA,
   return NoAlias;
 }
 
+char CFLAA::PassID;
+
 CFLAAResult CFLAA::run(Function &F, AnalysisManager<Function> *AM) {
   return CFLAAResult();
 }
diff --git a/lib/Analysis/CGSCCPassManager.cpp b/lib/Analysis/CGSCCPassManager.cpp
index cabbf917603..6326b34d68a 100644
--- a/lib/Analysis/CGSCCPassManager.cpp
+++ b/lib/Analysis/CGSCCPassManager.cpp
@@ -18,12 +18,9 @@ namespace llvm {
 template class PassManager<LazyCallGraph::SCC>;
 template class AnalysisManager<LazyCallGraph::SCC>;
 template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
-template class AnalysisBase<CGSCCAnalysisManagerModuleProxy>;
 template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
                                          LazyCallGraph::SCC>;
-template class AnalysisBase<ModuleAnalysisManagerCGSCCProxy>;
 template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
                                          LazyCallGraph::SCC>;
-template class AnalysisBase<FunctionAnalysisManagerCGSCCProxy>;
 template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
 }
diff --git a/lib/Analysis/CallGraph.cpp b/lib/Analysis/CallGraph.cpp
index 0b1bb620604..2de2e0d0ab9 100644
--- a/lib/Analysis/CallGraph.cpp
+++ b/lib/Analysis/CallGraph.cpp
@@ -260,7 +260,7 @@ void CallGraphNode::replaceCallEdge(CallSite CS,
 }
 
 // Provide an explicit template instantiation for the static ID.
-template class llvm::AnalysisBase<CallGraphAnalysis>;
+char CallGraphAnalysis::PassID;
 
 PreservedAnalyses CallGraphPrinterPass::run(Module &M,
                                             AnalysisManager<Module> *AM) {
diff --git a/lib/Analysis/DominanceFrontier.cpp b/lib/Analysis/DominanceFrontier.cpp
index 7ec70c73f8b..ef7062da775 100644
--- a/lib/Analysis/DominanceFrontier.cpp
+++ b/lib/Analysis/DominanceFrontier.cpp
@@ -56,7 +56,7 @@ LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const {
 }
 #endif
 
-template class llvm::AnalysisBase<DominanceFrontierAnalysis>;
+char DominanceFrontierAnalysis::PassID;
 
 DominanceFrontier DominanceFrontierAnalysis::run(Function &F,
                                                  FunctionAnalysisManager *AM) {
diff --git a/lib/Analysis/GlobalsModRef.cpp b/lib/Analysis/GlobalsModRef.cpp
index 8baaa0f427b..22a6fba34b6 100644
--- a/lib/Analysis/GlobalsModRef.cpp
+++ b/lib/Analysis/GlobalsModRef.cpp
@@ -936,6 +936,8 @@ GlobalsAAResult::analyzeModule(Module &M, const TargetLibraryInfo &TLI,
   return Result;
 }
 
+char GlobalsAA::PassID;
+
 GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager<Module> *AM) {
   return GlobalsAAResult::analyzeModule(M,
                                         AM->getResult<TargetLibraryAnalysis>(M),
diff --git a/lib/Analysis/LazyCallGraph.cpp b/lib/Analysis/LazyCallGraph.cpp
index 718c86410cc..5de90782a31 100644
--- a/lib/Analysis/LazyCallGraph.cpp
+++ b/lib/Analysis/LazyCallGraph.cpp
@@ -1499,7 +1499,7 @@ LazyCallGraph::RefSCC *LazyCallGraph::getNextRefSCCInPostOrder() {
   }
 }
 
-template class llvm::AnalysisBase<LazyCallGraphAnalysis>;
+char LazyCallGraphAnalysis::PassID;
 
 LazyCallGraphPrinterPass::LazyCallGraphPrinterPass(raw_ostream &OS) : OS(OS) {}
 
diff --git a/lib/Analysis/LoopInfo.cpp b/lib/Analysis/LoopInfo.cpp
index 51444b60b06..14ca91dc5e0 100644
--- a/lib/Analysis/LoopInfo.cpp
+++ b/lib/Analysis/LoopInfo.cpp
@@ -641,7 +641,7 @@ void LoopInfo::markAsRemoved(Loop *Unloop) {
   }
 }
 
-template class llvm::AnalysisBase<LoopAnalysis>;
+char LoopAnalysis::PassID;
 
 LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
   // FIXME: Currently we create a LoopInfo from scratch for every function.
diff --git a/lib/Analysis/LoopPassManager.cpp b/lib/Analysis/LoopPassManager.cpp
index 4e90cfac9e5..76210fa89c0 100644
--- a/lib/Analysis/LoopPassManager.cpp
+++ b/lib/Analysis/LoopPassManager.cpp
@@ -16,6 +16,5 @@ namespace llvm {
 template class PassManager<Loop>;
 template class AnalysisManager<Loop>;
 template class InnerAnalysisManagerProxy<LoopAnalysisManager, Function>;
-template class AnalysisBase<LoopAnalysisManagerFunctionProxy>;
 template class OuterAnalysisManagerProxy<FunctionAnalysisManager, Loop>;
 }
diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp
index bdb845cea65..9606c84d7c5 100644
--- a/lib/Analysis/MemoryDependenceAnalysis.cpp
+++ b/lib/Analysis/MemoryDependenceAnalysis.cpp
@@ -1659,6 +1659,8 @@ void MemoryDependenceResults::verifyRemoved(Instruction *D) const {
 #endif
 }
 
+char MemoryDependenceAnalysis::PassID;
+
 MemoryDependenceResults
 MemoryDependenceAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
   auto &AA = AM->getResult<AAManager>(F);
diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp
index 39ac455761d..b515108fafb 100644
--- a/lib/Analysis/PostDominators.cpp
+++ b/lib/Analysis/PostDominators.cpp
@@ -44,7 +44,7 @@ FunctionPass* llvm::createPostDomTree() {
   return new PostDominatorTreeWrapperPass();
 }
 
-template class llvm::AnalysisBase<PostDominatorTreeAnalysis>;
+char PostDominatorTreeAnalysis::PassID;
 
 PostDominatorTree PostDominatorTreeAnalysis::run(Function &F) {
   PostDominatorTree PDT;
diff --git a/lib/Analysis/RegionInfo.cpp b/lib/Analysis/RegionInfo.cpp
index 87ceb35367b..72b3217dc6f 100644
--- a/lib/Analysis/RegionInfo.cpp
+++ b/lib/Analysis/RegionInfo.cpp
@@ -185,7 +185,7 @@ namespace llvm {
 // RegionInfoAnalysis implementation
 //
 
-template class llvm::AnalysisBase<RegionInfoAnalysis>;
+char RegionInfoAnalysis::PassID;
 
 RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> *AM) {
   RegionInfo RI;
diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index b8bf0f1cb9e..454bb0931f3 100644
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -9730,7 +9730,7 @@ void ScalarEvolution::verify() const {
   // TODO: Verify more things.
 }
 
-template class llvm::AnalysisBase<ScalarEvolutionAnalysis>;
+char ScalarEvolutionAnalysis::PassID;
 
 ScalarEvolution ScalarEvolutionAnalysis::run(Function &F,
                                              AnalysisManager<Function> *AM) {
diff --git a/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp b/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
index f9576a2d1f9..f0ddc48ceef 100644
--- a/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
+++ b/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
@@ -110,6 +110,8 @@ Value *SCEVAAResult::GetBaseValue(const SCEV *S) {
   return nullptr;
 }
 
+char SCEVAA::PassID;
+
 SCEVAAResult SCEVAA::run(Function &F, AnalysisManager<Function> *AM) {
   return SCEVAAResult(AM->getResult<ScalarEvolutionAnalysis>(F));
 }
diff --git a/lib/Analysis/ScopedNoAliasAA.cpp b/lib/Analysis/ScopedNoAliasAA.cpp
index ba1f64402e8..e52f78049da 100644
--- a/lib/Analysis/ScopedNoAliasAA.cpp
+++ b/lib/Analysis/ScopedNoAliasAA.cpp
@@ -172,6 +172,8 @@ bool ScopedNoAliasAAResult::mayAliasInScopes(const MDNode *Scopes,
   return true;
 }
 
+char ScopedNoAliasAA::PassID;
+
 ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F,
                                            AnalysisManager<Function> *AM) {
   return ScopedNoAliasAAResult();
diff --git a/lib/Analysis/TargetLibraryInfo.cpp b/lib/Analysis/TargetLibraryInfo.cpp
index 38cd3ec40f0..3bd54c47e60 100644
--- a/lib/Analysis/TargetLibraryInfo.cpp
+++ b/lib/Analysis/TargetLibraryInfo.cpp
@@ -636,7 +636,7 @@ TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(
   initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
-template class llvm::AnalysisBase<TargetLibraryAnalysis>;
+char TargetLibraryAnalysis::PassID;
 
 // Register the basic pass.
 INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo",
diff --git a/lib/Analysis/TargetTransformInfo.cpp b/lib/Analysis/TargetTransformInfo.cpp
index 7380c44f0dd..bd957898834 100644
--- a/lib/Analysis/TargetTransformInfo.cpp
+++ b/lib/Analysis/TargetTransformInfo.cpp
@@ -377,7 +377,7 @@ TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F) {
   return TTICallback(F);
 }
 
-template class llvm::AnalysisBase<TargetIRAnalysis>;
+char TargetIRAnalysis::PassID;
 
 TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) {
   return Result(F.getParent()->getDataLayout());
diff --git a/lib/Analysis/TypeBasedAliasAnalysis.cpp b/lib/Analysis/TypeBasedAliasAnalysis.cpp
index c7f74b38575..fc9a62c0764 100644
--- a/lib/Analysis/TypeBasedAliasAnalysis.cpp
+++ b/lib/Analysis/TypeBasedAliasAnalysis.cpp
@@ -583,6 +583,8 @@ bool TypeBasedAAResult::PathAliases(const MDNode *A, const MDNode *B) const {
   return false;
 }
 
+char TypeBasedAA::PassID;
+
 TypeBasedAAResult TypeBasedAA::run(Function &F, AnalysisManager<Function> *AM) {
   return TypeBasedAAResult();
 }
diff --git a/lib/IR/Dominators.cpp b/lib/IR/Dominators.cpp
index 56247bf8598..b9d4fb7de88 100644
--- a/lib/IR/Dominators.cpp
+++ b/lib/IR/Dominators.cpp
@@ -308,7 +308,7 @@ DominatorTree DominatorTreeAnalysis::run(Function &F) {
   return DT;
 }
 
-template class llvm::AnalysisBase<DominatorTreeAnalysis>;
+char DominatorTreeAnalysis::PassID;
 
 DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {}
 
diff --git a/lib/IR/PassManager.cpp b/lib/IR/PassManager.cpp
index eb5ba437a29..9d5b4cb0516 100644
--- a/lib/IR/PassManager.cpp
+++ b/lib/IR/PassManager.cpp
@@ -20,6 +20,5 @@ template class PassManager<Function>;
 template class AnalysisManager<Module>;
 template class AnalysisManager<Function>;
 template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>;
-template class AnalysisBase<FunctionAnalysisManagerModuleProxy>;
 template class OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>;
 }
diff --git a/lib/Passes/PassBuilder.cpp b/lib/Passes/PassBuilder.cpp
index efe2f043f6a..e436966d320 100644
--- a/lib/Passes/PassBuilder.cpp
+++ b/lib/Passes/PassBuilder.cpp
@@ -70,7 +70,11 @@ struct NoOpModulePass {
 };
 
 /// \brief No-op module analysis.
-struct NoOpModuleAnalysis : AnalysisBase<NoOpModuleAnalysis> {
+class NoOpModuleAnalysis : public AnalysisBase<NoOpModuleAnalysis> {
+  friend AnalysisBase<NoOpModuleAnalysis>;
+  static char PassID;
+
+public:
   struct Result {};
   Result run(Module &) { return Result(); }
   static StringRef name() { return "NoOpModuleAnalysis"; }
@@ -85,7 +89,11 @@ struct NoOpCGSCCPass {
 };
 
 /// \brief No-op CGSCC analysis.
-struct NoOpCGSCCAnalysis : AnalysisBase<NoOpCGSCCAnalysis> {
+class NoOpCGSCCAnalysis : public AnalysisBase<NoOpCGSCCAnalysis> {
+  friend AnalysisBase<NoOpCGSCCAnalysis>;
+  static char PassID;
+
+public:
   struct Result {};
   Result run(LazyCallGraph::SCC &) { return Result(); }
   static StringRef name() { return "NoOpCGSCCAnalysis"; }
@@ -98,7 +106,11 @@ struct NoOpFunctionPass {
 };
 
 /// \brief No-op function analysis.
-struct NoOpFunctionAnalysis : AnalysisBase<NoOpFunctionAnalysis> {
+class NoOpFunctionAnalysis : public AnalysisBase<NoOpFunctionAnalysis> {
+  friend AnalysisBase<NoOpFunctionAnalysis>;
+  static char PassID;
+
+public:
   struct Result {};
   Result run(Function &) { return Result(); }
   static StringRef name() { return "NoOpFunctionAnalysis"; }
@@ -111,12 +123,21 @@ struct NoOpLoopPass {
 };
 
 /// \brief No-op loop analysis.
-struct NoOpLoopAnalysis : AnalysisBase<NoOpLoopAnalysis> {
+class NoOpLoopAnalysis : public AnalysisBase<NoOpLoopAnalysis> {
+  friend AnalysisBase<NoOpLoopAnalysis>;
+  static char PassID;
+
+public:
   struct Result {};
   Result run(Loop &) { return Result(); }
   static StringRef name() { return "NoOpLoopAnalysis"; }
 };
 
+char NoOpModuleAnalysis::PassID;
+char NoOpCGSCCAnalysis::PassID;
+char NoOpFunctionAnalysis::PassID;
+char NoOpLoopAnalysis::PassID;
+
 } // End anonymous namespace.
 
 void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {
diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp
index 857b5283c41..c00748cadb9 100644
--- a/unittests/IR/PassManagerTest.cpp
+++ b/unittests/IR/PassManagerTest.cpp
@@ -40,9 +40,14 @@ public:
   }
 
 private:
+  friend AnalysisBase<TestFunctionAnalysis>;
+  static char PassID;
+
   int &Runs;
 };
 
+char TestFunctionAnalysis::PassID;
+
 class TestModuleAnalysis : public AnalysisBase<TestModuleAnalysis> {
 public:
   struct Result {
@@ -61,9 +66,14 @@ public:
   }
 
 private:
+  friend AnalysisBase<TestModuleAnalysis>;
+  static char PassID;
+
   int &Runs;
 };
 
+char TestModuleAnalysis::PassID;
+
 struct TestModulePass : PassBase<TestModulePass> {
   TestModulePass(int &RunCount) : RunCount(RunCount) {}