[mlir] Fix TypeID for shared libraries built with -fvisibility=hidden.

[stellaraccident]

Summary

• Isolates the visibility controlled parts of its implementation to a detail namespace.
• Applies a struct level visibility attribute which applies to the static local within the get() functions.
• The prior version was not emitting a symbol for the static local "instance" fields when the user TU was compiled with -fvisibility=hidden.

[bondhugula]

mlir/include/mlir/Support/TypeID.h

91

Any useful comment here? May be redirect to the long one below.

[stellaraccident]

Rebase.

[bondhugula]

mlir/include/mlir/Support/TypeID.h

99

Nit: A blank new line here would be good.

[stellaraccident]

Addressed Uday's comments in a followon NFC commit.

[mehdi_amini]

Nice improvement here!

mlir/include/mlir/Support/TypeID.h

112

Thanks for the extensive doc!

mlir/include/mlir/Support/TypeID.h

 #define MLIR_SUPPORT_TYPEID_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
 
+namespace detail {
+struct TypeIDExported;
+} // namespace detail
+
 /// This class provides an efficient unique identifier for a specific C++ type.
 /// This allows for a C++ type to be compared, hashed, and stored in an opaque
 /// context. This class is similar in some ways to std::type_index, but can be
 /// used for any type. For example, this class could be used to implement LLVM
 /// style isa/dyn_cast functionality for a type hierarchy:
 ///
 ///  struct Base {
 ///    Base(TypeID typeID) : typeID(typeID) {}
public:
 
   /// Comparison operations.
   bool operator==(const TypeID &other) const {
     return storage == other.storage;
   }
   bool operator!=(const TypeID &other) const { return !(*this == other); }
 
   /// Construct a type info object for the given type T.
-  /// TODO: This currently won't work when using DLLs as it requires properly
-  /// attaching dllimport and dllexport. Fix this when that information is
-  /// available within LLVM.
   template <typename T>
-  LLVM_EXTERNAL_VISIBILITY static TypeID get() {
-    static Storage instance;
-    return TypeID(&instance);
-  }
+  static TypeID get();
   template <template <typename> class Trait>
-  LLVM_EXTERNAL_VISIBILITY static TypeID get() {
-    static Storage instance;
-    return TypeID(&instance);
-  }
+  static TypeID get();
 
   /// Methods for supporting PointerLikeTypeTraits.
   const void *getAsOpaquePointer() const {
     return static_cast<const void *>(storage);
   }
   static TypeID getFromOpaquePointer(const void *pointer) {
     return TypeID(reinterpret_cast<const Storage *>(pointer));
   }
 
   /// Enable hashing TypeID.
   friend ::llvm::hash_code hash_value(TypeID id);
 
 private:
   TypeID(const Storage *storage) : storage(storage) {}
 
   /// The storage of this type info object.
   const Storage *storage;
+
+  friend struct detail::TypeIDExported;
 };
 
 /// Enable hashing TypeID.
 inline ::llvm::hash_code hash_value(TypeID id) {
   return llvm::hash_value(id.storage);
 }
 
+namespace detail {
+/// 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
+/// through those on this detail class with specific visibility controls
+/// applied, making visibility declarations on the internal TypeID class not
+/// required (all visibility relevant pieces are here).
+/// TODO: This currently won't work when using DLLs as it requires properly
+/// attaching dllimport and dllexport. Fix this when that information is
+/// available within LLVM.
+struct LLVM_EXTERNAL_VISIBILITY TypeIDExported {
+  template <typename T>
+  static TypeID get() {
+    static TypeID::Storage instance;
+    return TypeID(&instance);
+  }
+  template <template <typename> class Trait>
+  static TypeID get() {
+    static TypeID::Storage instance;
+    return TypeID(&instance);
+  }
+};
+} // namespace detail
+
+template <typename T>
+TypeID TypeID::get() {
+  return detail::TypeIDExported::get<T>();
+}
+template <template <typename> class Trait>
+TypeID TypeID::get() {
+  return detail::TypeIDExported::get<Trait>();
+}
+
 } // end namespace mlir
 
 namespace llvm {
 template <> struct DenseMapInfo<mlir::TypeID> {
   static mlir::TypeID getEmptyKey() {
     void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::TypeID::getFromOpaquePointer(pointer);
   }