[mlir:TypeID] Use a static variable for explicit TypeIDs

[rriddle]

Summary

When the explicit type id macros were added, they unfortunately moved
the definitions of the TypeID::get functions to the .cpp files. This commit
moves the method definition back to the header and instead uses a
global variable (declared in the header as well) to anchor the definition
to a specific translation unit. This leads to much more optimal code
for TypeID::get, and has improved the compile time of some benchmarks
by anywhere from 3.5-10%.

[mehdi_amini]

Did you look into the build failures?

[rriddle]

This is subsumed by D122775, which has a better reworking of TypeID in general.

mlir/include/mlir/Support/TypeID.h

private:
   friend class TypeIDAllocator;
 };
 
 /// Enable hashing TypeID.
 inline ::llvm::hash_code hash_value(TypeID id) {
   return DenseMapInfo<const TypeID::Storage *>::getHashValue(id.storage);
 }
 
+/// Defines a TypeID for each instance of this class by using a pointer to the
+/// instance. Thus, the copy and move constructor are deleted.
+class alignas(8) SelfOwningTypeID {
+public:
+  SelfOwningTypeID() = default;
+  SelfOwningTypeID(const SelfOwningTypeID &) = delete;
+  SelfOwningTypeID &operator=(const SelfOwningTypeID &) = delete;
+  SelfOwningTypeID(SelfOwningTypeID &&) = delete;
+  SelfOwningTypeID &operator=(SelfOwningTypeID &&) = delete;
+
+  /// Return the TypeID owned by this object.
+  TypeID getTypeID() const { return TypeID::getFromOpaquePointer(this); }
+
+  /// Allow implicit conversion to the owned TypeID.
+  operator TypeID() const { return getTypeID(); }
+};
+
 namespace detail {
+/// This class is used by explicit TypeID instantions to provide the type id
+/// object.
+template <typename T>
+struct ExplicitTypeIDInstantion {
+  static SelfOwningTypeID id;
+};
 
 /// The static local instance of each get method must be emitted with
 /// "default" (public) visibility across all shared libraries, regardless of
 /// whether they are compiled with hidden visibility or not. The only reliable
 /// way to make this happen is to set the visibility attribute at the
 /// containing namespace/struct scope. We don't do this on the TypeID (internal
 /// API) class in order to reduce the scope of what gets exported with
 /// public visibility. Instead, the get() methods on TypeID trampoline
public:
   TypeID allocate() { return TypeID(ids.Allocate()); }
 
 private:
   /// The TypeIDs allocated are the addresses of the different storages.
   /// Keeping those in memory ensure uniqueness of the TypeIDs.
   llvm::SpecificBumpPtrAllocator<TypeID::Storage> ids;
 };
 
-/// Defines a TypeID for each instance of this class by using a pointer to the
-/// instance. Thus, the copy and move constructor are deleted.
-class SelfOwningTypeID {
-public:
-  SelfOwningTypeID() = default;
-  SelfOwningTypeID(const SelfOwningTypeID &) = delete;
-  SelfOwningTypeID &operator=(const SelfOwningTypeID &) = delete;
-  SelfOwningTypeID(SelfOwningTypeID &&) = delete;
-  SelfOwningTypeID &operator=(SelfOwningTypeID &&) = delete;
-
-  TypeID getTypeID() const { return TypeID::getFromOpaquePointer(this); }
-};
-
 } // namespace mlir
 
 // Declare/define an explicit specialization for TypeID: this forces the
 // compiler to emit a strong definition for a class and controls which
 // translation unit and shared object will actually have it.
 // This can be useful to turn to a link-time failure what would be in other
 // circumstances a hard-to-catch runtime bug when a TypeID is hidden in two
 // different shared libraries and instances of the same class only gets the same
 // TypeID inside a given DSO.
 #define DECLARE_EXPLICIT_TYPE_ID(CLASS_NAME)                                   \
   namespace mlir {                                                             \
   namespace detail {                                                           \
   template <>                                                                  \
-  LLVM_EXTERNAL_VISIBILITY TypeID TypeIDExported::get<CLASS_NAME>();           \
+  SelfOwningTypeID ExplicitTypeIDInstantion<CLASS_NAME>::id;                   \
+                                                                               \
+  template <>                                                                  \
+  inline LLVM_EXTERNAL_VISIBILITY TypeID TypeIDExported::get<CLASS_NAME>() {   \
+    return ExplicitTypeIDInstantion<CLASS_NAME>::id;                           \
+  }                                                                            \
   }                                                                            \
   }
 
 #define DEFINE_EXPLICIT_TYPE_ID(CLASS_NAME)                                    \
   namespace mlir {                                                             \
   namespace detail {                                                           \
   template <>                                                                  \
-  LLVM_EXTERNAL_VISIBILITY TypeID TypeIDExported::get<CLASS_NAME>() {          \
-    static TypeID::Storage instance;                                           \
-    return TypeID(&instance);                                                  \
-  }                                                                            \
+  SelfOwningTypeID ExplicitTypeIDInstantion<CLASS_NAME>::id = {};              \
   }                                                                            \
   }
 
 namespace llvm {
 template <> struct DenseMapInfo<mlir::TypeID> {
   static inline mlir::TypeID getEmptyKey() {
     void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::TypeID::getFromOpaquePointer(pointer);