Switch LLVM_INSTANTIATE_REGISTRY to just doing a full class template explicit instantiation

Author: fsfod

llvm/include/llvm/Support/Registry.h

@@ -82,7 +82,13 @@ namespace llvm {
     /// add a node to the executable's registry. Therefore it's not defined here
     /// to avoid it being instantiated in the plugin and is instead defined in
     /// the executable (see LLVM_INSTANTIATE_REGISTRY below).
-    static void add_node(node *N);
+    static void add_node(node *N) {
+      if (Tail)
+        Tail->Next = N;
+      else
+        Head = N;
+      Tail = N;
+    }
 
     /// Iterators for registry entries.
     ///
@@ -101,7 +107,7 @@ namespace llvm {
 
     // begin is not defined here in order to avoid usage of an undefined static
     // data member, instead it's instantiated by LLVM_INSTANTIATE_REGISTRY.
-    static iterator begin();
+    static iterator begin() { return iterator(Head); } 
     static iterator end()   { return iterator(nullptr); }
 
     static iterator_range<iterator> entries() {
@@ -130,39 +136,22 @@ namespace llvm {
       }
     };
   };
+
+  template<typename T> typename Registry<T>::node *Registry<T>::Head = nullptr;
+  template<typename T> typename Registry<T>::node *Registry<T>::Tail = nullptr;
 } // end namespace llvm
 
+#ifdef _WIN32
 /// Instantiate a registry class.
-///
-/// This provides template definitions of add_node, begin, and the Head and Tail
-/// pointers, then explicitly instantiates them. We could explicitly specialize
-/// them, instead of the two-step process of define then instantiate, but
-/// strictly speaking that's not allowed by the C++ standard (we would need to
-/// have explicit specialization declarations in all translation units where the
-/// specialization is used) so we don't.
-#define LLVM_INSTANTIATE_REGISTRY(REGISTRY_CLASS)                              \
-  namespace llvm {                                                             \
-  template <typename T>                                                        \
-  typename Registry<T>::node *Registry<T>::Head = nullptr;                     \
-  template <typename T>                                                        \
-  typename Registry<T>::node *Registry<T>::Tail = nullptr;                     \
-  template <typename T>                                                        \
-  void Registry<T>::add_node(typename Registry<T>::node *N) {                  \
-    if (Tail)                                                                  \
-      Tail->Next = N;                                                          \
-    else                                                                       \
-      Head = N;                                                                \
-    Tail = N;                                                                  \
-  }                                                                            \
-  template <typename T> typename Registry<T>::iterator Registry<T>::begin() {  \
-    return iterator(Head);                                                     \
-  }                                                                            \
-  template REGISTRY_CLASS::node *Registry<REGISTRY_CLASS::type>::Head;         \
-  template REGISTRY_CLASS::node *Registry<REGISTRY_CLASS::type>::Tail;         \
-  template LLVM_ABI_EXPORT void                                                \
-  Registry<REGISTRY_CLASS::type>::add_node(REGISTRY_CLASS::node *);            \
-  template LLVM_ABI_EXPORT REGISTRY_CLASS::iterator                            \
-  Registry<REGISTRY_CLASS::type>::begin();                                     \
+#define LLVM_INSTANTIATE_REGISTRY(REGISTRY_CLASS) \
+  namespace llvm { \
+    template class LLVM_ABI_EXPORT Registry<REGISTRY_CLASS::type>;\
+  }
+#else
+#define LLVM_INSTANTIATE_REGISTRY(REGISTRY_CLASS) \
+  namespace llvm { \
+    template class Registry<REGISTRY_CLASS>;\
   }
+#endif
 
 #endif // LLVM_SUPPORT_REGISTRY_H