[libcxx] Introduce clang::lto_visibility_public attribute

[leonardchan]

Summary

In fuchsia, we build our shared libs with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS and -fvisibility=hidden to ensure all symbols manifested from classes in libc++ headers are hidden. But if we build with LTO, then then each of the classes included from libc++ headers have hidden LTO visibility (which is unique to LTO and separate from ELF visibility). This is an issue if we ship a libc++.so that was not built with LTO because those same libc++ classes will have default LTO visibility. This can lead to incorrect behavior because LTO will only work if classes used across multiple linkage units have default LTO visibility, which can be achieved by either compiling everything with LTO and default visibility, or explicitly adding [[clang::lto_visibility_public]] to those classes. To ensure that we can still use -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS and -fvisibility=hidden to make sure libc++ symbols have hidden visibility, we can apply [[clang::lto_visibility_public]] to libc++ classes which effectively prevents whole program devirtualization from operating on them.

[philnik]

I've got a few problems with this patch (in no particular order):

1. It makes our visibility annotations even more complicated. It is already way to complicated, we should avoid making it even worse.
2. You say you build with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden which AFAICT defeats the purpose of a shared library, since it wouldn't export a single symbol.
3. This is a completely untested configuration, which means it will regress (which is already a problem with the current visibility annotations)

My biggest concern right now is (2).

[Mordante]

Next to @philnik's issues I have a large issue with the lack of documentation. Our visibility macros are already not very well documented, adding more without any documentation seems like a bad idea.
Especially there is no explanation which friend declarations need this markup and which don't.

[leonardchan]

You say you build with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden which AFAICT defeats the purpose of a shared library, since it wouldn't export a single symbol.

My bad, I should've clarified on this. For fuchsia, we build everything with hidden visibility by default and individual binaries need to explicitly mark their symbols with default visibility if they want to be exported. This also means that when a fuchsia binary uses libc++, we need to make sure it doesn't accidentally export any libc++ symbols. Fuchsia binaries can consume libc++ as either a shared lib or a hermetic static lib, but we don't know at compile time how libc++ will eventually be consumed. If used as a shared lib, then symbols will be defined libc++.so. If linked in as a hermetic static lib, then we need to ensure those symbols have hidden visibility. To cover both cases and prevent us from having to compile twice, we just compile everything with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden.

It makes our visibility annotations even more complicated. It is already way to complicated, we should avoid making it even worse.

In terms of minimizing extra added visibility annotation complexity, what do you think of this alternative: update _LIBCPP_TEMPLATE_VIS and _LIBCPP_TYPE_VIS in <__config> such that it can be defined in the compilation step as an argument. If left undefined, the default behavior would what libcxx does now, which is defining the macro according to _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS. This way, the change would be less intrusive to libcxx and downstream users can have more flexibility on libc++ class annotations.

This is a completely untested configuration, which means it will regress (which is already a problem with the current visibility annotations)
Next to @philnik's issues I have a large issue with the lack of documentation. Our visibility macros are already not very well documented, adding more without any documentation seems like a bad idea. Especially there is no explanation which friend declarations need this markup and which don't.

I'll also be sure to update the next revision with tests and docs. The initial reasoning for the the friend variants is because some attributes like [[clang::lto_visibility_public]] can only be attached to class definitions, but not friend declarations.

[ldionne]

In D147832#4256529, @leonardchan wrote:

You say you build with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden which AFAICT defeats the purpose of a shared library, since it wouldn't export a single symbol.

My bad, I should've clarified on this. For fuchsia, we build everything with hidden visibility by default and individual binaries need to explicitly mark their symbols with default visibility if they want to be exported. This also means that when a fuchsia binary uses libc++, we need to make sure it doesn't accidentally export any libc++ symbols. Fuchsia binaries can consume libc++ as either a shared lib or a hermetic static lib, but we don't know at compile time how libc++ will eventually be consumed. If used as a shared lib, then symbols will be defined libc++.so. If linked in as a hermetic static lib, then we need to ensure those symbols have hidden visibility. To cover both cases and prevent us from having to compile twice, we just compile everything with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden.

I still don't understand your setup. So you compile the program using LTO and passing -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden, right? That way the program itself doesn't export any libc++ symbols and everything in the program has hidden visibility AND hidden LTO visibility. But then you compile libc++.so with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden, which causes everything in libc++.so to have hidden visibility. But since you compile libc++.so with LTO disabled, everything in libc++.so has default LTO visibility.

So for example, let's say you have a std::map<int, int> instantiated in your program and let's say there's also one instantiated inside libc++.so. On the program side, std::map<int, int> has hidden visibility because you passed -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden, and it has hidden LTO visibility for the same reason. On the libc++.so side, it has hidden visibility because you passed -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden when building the .so, but it has default LTO visibility because you did not compile libc++.so with LTO enabled. That's an ODR violation. Is that correct?

[leonardchan]

In D147832#4644272, @ldionne wrote:

In D147832#4256529, @leonardchan wrote:

You say you build with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden which AFAICT defeats the purpose of a shared library, since it wouldn't export a single symbol.

My bad, I should've clarified on this. For fuchsia, we build everything with hidden visibility by default and individual binaries need to explicitly mark their symbols with default visibility if they want to be exported. This also means that when a fuchsia binary uses libc++, we need to make sure it doesn't accidentally export any libc++ symbols. Fuchsia binaries can consume libc++ as either a shared lib or a hermetic static lib, but we don't know at compile time how libc++ will eventually be consumed. If used as a shared lib, then symbols will be defined libc++.so. If linked in as a hermetic static lib, then we need to ensure those symbols have hidden visibility. To cover both cases and prevent us from having to compile twice, we just compile everything with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden.

I still don't understand your setup. So you compile the program using LTO and passing -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden, right? That way the program itself doesn't export any libc++ symbols and everything in the program has hidden visibility AND hidden LTO visibility. But then you compile libc++.so with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden, which causes everything in libc++.so to have hidden visibility. But since you compile libc++.so with LTO disabled, everything in libc++.so has default LTO visibility.

The program is compiled with LTO and -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden but out libc++.so isn't compiled with -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS, -fvisibility=hidden, or LTO so all the symbols in our libc++.so have default visibility and default LTO visibility while an equivalent symbol in the program will have hidden elf and LTO visibility.

So for example, let's say you have a std::map<int, int> instantiated in your program and let's say there's also one instantiated inside libc++.so. On the program side, std::map<int, int> has hidden visibility because you passed -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden, and it has hidden LTO visibility for the same reason. On the libc++.so side, it has hidden visibility because you passed -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden when building the .so, but it has default LTO visibility because you did not compile libc++.so with LTO enabled. That's an ODR violation. Is that correct?

A slight difference in the example is that the symbol has default ELF visibility in the libc++.so side, but yes I believe this is an ODR violation since the map has differing LTO visibilities across different linkage units which is what this patch attempts to fix. We need to make sure the symbols on the program side are hidden ELF visibility and the symbols in libc++ are default ELF visibility, but to ensure LTO visibility is respected, we need a way to plumb [[clang::lto_visibility_public]] to all relevant libc++ classes.

[ldionne]

After careful consideration, I am left wondering why -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden even makes sense. I understand that you want to minimize the number of symbols exported from your program and I think that's a desirable goal. However, let's say you take a typical program and just compile it normally without using -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden -- what's the problem? What symbols end up being exported that you wouldn't want to export?

We already mark the vast majority of symbols in libc++ as hidden (using _LIBCPP_HIDE_FROM_ABI), and the ones that are not marked as hidden basically need to be public for correctness purposes.

[leonardchan]

In D147832#4645512, @ldionne wrote:

After careful consideration, I am left wondering why -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden even makes sense. I understand that you want to minimize the number of symbols exported from your program and I think that's a desirable goal. However, let's say you take a typical program and just compile it normally without using -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS -fvisibility=hidden -- what's the problem? What symbols end up being exported that you wouldn't want to export?

We already mark the vast majority of symbols in libc++ as hidden (using _LIBCPP_HIDE_FROM_ABI), and the ones that are not marked as hidden basically need to be public for correctness purposes.

We also want to reduce size and startup time so marking them as hidden reduces dynamic relocations at least for ELF. Usage of classes included from headers can manifest public symbols that we don't need to be public. std::streambuf is one I've seen a lot and any usage of that also brings in the methods associated with it.

libcxx/include/__config

 #      define _LIBCPP_DLL_VIS __declspec(dllimport)
 #      define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DLL_VIS
 #      define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
 #      define _LIBCPP_OVERRIDABLE_FUNC_VIS
 #      define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllimport)
 #    endif
 
 #    define _LIBCPP_TYPE_VIS _LIBCPP_DLL_VIS
+#    define _LIBCPP_FRIEND_TYPE_VIS _LIBCPP_DLL_VIS
 #    define _LIBCPP_FUNC_VIS _LIBCPP_DLL_VIS
 #    define _LIBCPP_EXCEPTION_ABI _LIBCPP_DLL_VIS
 #    define _LIBCPP_HIDDEN
 #    define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 #    define _LIBCPP_TEMPLATE_VIS
+#    define _LIBCPP_FRIEND_TEMPLATE_VIS
 #    define _LIBCPP_TEMPLATE_DATA_VIS
 #    define _LIBCPP_ENUM_VIS
 
 #  else
 
+#    if !defined(_LIBCPP_DISABLE_LTO_VISIBILITY_ANNOTATIONS) && defined(__clang__)
+#      define _LIBCPP_LTO_VISIBILITY [[clang::lto_visibility_public]]
+#    else
+#      define _LIBCPP_LTO_VISIBILITY
+#    endif
+
 #    if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 #      define _LIBCPP_VISIBILITY(vis) __attribute__((__visibility__(vis)))
 #    else
 #      define _LIBCPP_VISIBILITY(vis)
 #    endif
 
 #    define _LIBCPP_HIDDEN _LIBCPP_VISIBILITY("hidden")
 #    define _LIBCPP_FUNC_VIS _LIBCPP_VISIBILITY("default")
-#    define _LIBCPP_TYPE_VIS _LIBCPP_VISIBILITY("default")
+#    define _LIBCPP_TYPE_VIS _LIBCPP_VISIBILITY("default") _LIBCPP_LTO_VISIBILITY
+#    define _LIBCPP_FRIEND_TYPE_VIS _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_TEMPLATE_DATA_VIS _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_EXCEPTION_ABI _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
 
 // TODO: Make this a proper customization point or remove the option to override it.
 #    ifndef _LIBCPP_OVERRIDABLE_FUNC_VIS
 #      define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_VISIBILITY("default")
 #    endif
 
 #    if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 // The inline should be removed once PR32114 is resolved
 #      define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS inline _LIBCPP_HIDDEN
 #    else
 #      define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 #    endif
 
 #    if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 #      if __has_attribute(__type_visibility__)
 #        define _LIBCPP_TEMPLATE_VIS __attribute__((__type_visibility__("default")))
 #      else
 #        define _LIBCPP_TEMPLATE_VIS __attribute__((__visibility__("default")))
 #      endif
+#      define _LIBCPP_FRIEND_TEMPLATE_VIS _LIBCPP_TEMPLATE_VIS
 #    else
-#      define _LIBCPP_TEMPLATE_VIS
+#      define _LIBCPP_TEMPLATE_VIS _LIBCPP_LTO_VISIBILITY
+#      define _LIBCPP_FRIEND_TEMPLATE_VIS
 #    endif
 
 #    if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
 #      define _LIBCPP_ENUM_VIS __attribute__((__type_visibility__("default")))
 #    else
 #      define _LIBCPP_ENUM_VIS
 #    endif
 

libcxx/include/__hash_table

explicit __hash_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
         : __node_(__node)
         {
             (void)__c;
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
             __get_db()->__insert_ic(this, __c);
 #endif
         }
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_map_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _NodePtr>
 class _LIBCPP_TEMPLATE_VIS __hash_const_iterator
 {
     static_assert(!is_const<typename pointer_traits<_NodePtr>::element_type>::value, "");
     typedef __hash_node_types<_NodePtr> _NodeTypes;
     typedef _NodePtr                            __node_pointer;
explicit __hash_const_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
         : __node_(__node)
         {
             (void)__c;
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
             __get_db()->__insert_ic(this, __c);
 #endif
         }
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _NodePtr>
 class _LIBCPP_TEMPLATE_VIS __hash_local_iterator
 {
     typedef __hash_node_types<_NodePtr> _NodeTypes;
     typedef _NodePtr                            __node_pointer;
     typedef typename _NodeTypes::__next_pointer __next_pointer;
explicit __hash_local_iterator(__next_pointer __node, size_t __bucket,
             (void)__c;
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
             __get_db()->__insert_ic(this, __c);
 #endif
             if (__node_ != nullptr)
                 __node_ = __node_->__next_;
         }
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_map_iterator;
 };
 
 template <class _ConstNodePtr>
 class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator
 {
     typedef __hash_node_types<_ConstNodePtr> _NodeTypes;
     typedef _ConstNodePtr                       __node_pointer;
     typedef typename _NodeTypes::__next_pointer __next_pointer;
explicit __hash_const_local_iterator(__next_pointer __node_ptr, size_t __bucket,
             (void)__c;
 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
             __get_db()->__insert_ic(this, __c);
 #endif
             if (__node_ != nullptr)
                 __node_ = __node_->__next_;
         }
     template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _Alloc>
 class __bucket_list_deallocator
 {
     typedef _Alloc                                          allocator_type;
     typedef allocator_traits<allocator_type>                __alloc_traits;
     typedef typename __alloc_traits::size_type              size_type;
void __move_assign_alloc(__hash_table& __u, true_type)
         __node_alloc() = _VSTD::move(__u.__node_alloc());
     }
     _LIBCPP_INLINE_VISIBILITY
         void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
 
     void __deallocate_node(__next_pointer __np) _NOEXCEPT;
     __next_pointer __detach() _NOEXCEPT;
 
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
     _NOEXCEPT_(
         is_nothrow_default_constructible<__bucket_list>::value &&
         is_nothrow_default_constructible<__first_node>::value &&

libcxx/include/__iterator/wrap_iter.h

 #ifdef _LIBCPP_ENABLE_DEBUG_MODE
       if (!__libcpp_is_constant_evaluated())
         __get_db()->__insert_ic(this, __p);
 #endif
     }
 
     template <class _Up> friend class __wrap_iter;
     template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
-    template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector;
-    template <class _Tp, size_t> friend class _LIBCPP_TEMPLATE_VIS span;
+    template <class _Tp, class _Alloc>
+    friend class _LIBCPP_FRIEND_TEMPLATE_VIS vector;
+    template <class _Tp, size_t>
+    friend class _LIBCPP_FRIEND_TEMPLATE_VIS span;
 };
 
 template <class _Iter1>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 bool operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
 {
     return __x.base() == __y.base();
 }

libcxx/include/__memory/shared_ptr.h

struct __shared_ptr_default_delete<_Yp[_Sz], _Un>
         : default_delete<_Yp[]>
     { };
 
     template <class _Yp, class _Un>
     struct __shared_ptr_default_delete<_Yp[], _Un>
         : default_delete<_Yp[]>
     { };
 
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
+    template <class _Up>
+    friend class _LIBCPP_FRIEND_TEMPLATE_VIS shared_ptr;
+    template <class _Up>
+    friend class _LIBCPP_FRIEND_TEMPLATE_VIS weak_ptr;
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _Tp>
 shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
 template<class _Tp, class _Dp>
 shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
 #endif
template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT
         {return __cntrl_ < __r.__cntrl_;}
     template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT
         {return __cntrl_ < __r.__cntrl_;}
 
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
+    template <class _Up>
+    friend class _LIBCPP_FRIEND_TEMPLATE_VIS weak_ptr;
+    template <class _Up>
+    friend class _LIBCPP_FRIEND_TEMPLATE_VIS shared_ptr;
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _Tp>
 weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
 #endif
 
 template<class _Tp>

libcxx/include/__threading_support

#endif // _LIBCPP_STD_VER <= 17
     basic_ostream<_CharT, _Traits>&
     operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
 
     friend __thread_id this_thread::get_id() _NOEXCEPT;
-    friend class _LIBCPP_TYPE_VIS thread;
-    friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
+    friend class _LIBCPP_FRIEND_TYPE_VIS thread;
+    friend struct _LIBCPP_FRIEND_TEMPLATE_VIS hash<__thread_id>;
 };
 
 inline _LIBCPP_HIDE_FROM_ABI
 bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT {
   // Don't pass id==0 to underlying routines
   if (__x.__id_ == 0)
     return __y.__id_ == 0;
   if (__y.__id_ == 0)

libcxx/include/__tree

 private:
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
     template <class, class, class> friend class __tree;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_iterator;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
+    template <class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __tree_const_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __map_iterator;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS multimap;
+    template <class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS set;
+    template <class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS multiset;
 };
 
 template <class _Tp, class _NodePtr, class _DiffType>
 class _LIBCPP_TEMPLATE_VIS __tree_const_iterator
 {
     typedef __tree_node_types<_NodePtr>                     _NodeTypes;
     typedef typename _NodeTypes::__node_pointer             __node_pointer;
     typedef typename _NodeTypes::__node_base_pointer        __node_base_pointer;
explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
         : __ptr_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT
         : __ptr_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
 
     template <class, class, class> friend class __tree;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS multimap;
+    template <class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS set;
+    template <class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS multiset;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __map_const_iterator;
 
 };
 
 template<class _Tp, class _Compare>
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
         "the specified comparator type does not provide a viable const call operator")
 #endif
private:
       static __node_pointer __detach_next(__node_pointer) _NOEXCEPT;
 
       __tree *__t_;
       __node_pointer __cache_root_;
       __node_pointer __cache_elem_;
     };
 
 
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS multimap;
 };
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
         _NOEXCEPT_(
             is_nothrow_default_constructible<__node_allocator>::value &&
             is_nothrow_copy_constructible<value_compare>::value)
     : __pair3_(0, __comp)

libcxx/include/deque

#endif
     _LIBCPP_HIDE_FROM_ABI friend
         bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y)
         {return !(__x < __y);}
 
 private:
     _LIBCPP_HIDE_FROM_ABI explicit __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
         : __m_iter_(__m), __ptr_(__p) {}
 
-    template <class _Tp, class _Ap> friend class _LIBCPP_TEMPLATE_VIS deque;
+    template <class _Tp, class _Ap> friend class _LIBCPP_FRIEND_TEMPLATE_VIS deque;
     template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
-        friend class _LIBCPP_TEMPLATE_VIS __deque_iterator;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS __deque_iterator;
 
     template <class>
     friend struct __segmented_iterator_traits;
 };
 
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize>
 struct __segmented_iterator_traits<
     __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize> > {

libcxx/include/ext/hash_map

public:
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ == __y.__i_;}
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS hash_map;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS hash_multimap;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
 class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
 {
     _HashIterator __i_;
 
     typedef const typename _HashIterator::value_type::first_type key_type;
public:
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ == __y.__i_;}
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS hash_multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS hash_map;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS hash_multimap;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_local_iterator;
 };
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = std::equal_to<_Key>,
           class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
 class _LIBCPP_TEMPLATE_VIS hash_map
 {
 public:
     // types

libcxx/include/forward_list

class _LIBCPP_TEMPLATE_VIS __forward_list_iterator
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_iterator(__begin_node_pointer __p) _NOEXCEPT
         : __ptr_(__traits::__as_iter_node(__p)) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT
         : __ptr_(__traits::__as_iter_node(__p)) {}
 
-    template<class, class> friend class _LIBCPP_TEMPLATE_VIS forward_list;
-    template<class> friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
+    template<class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS forward_list;
+    template<class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __forward_list_const_iterator;
 
 public:
     typedef forward_iterator_tag                              iterator_category;
     typedef typename __traits::__node_value_type              value_type;
     typedef value_type&                                       reference;
     typedef typename pointer_traits<__node_pointer>::difference_type
                                                               difference_type;
     typedef __rebind_pointer_t<__node_pointer, value_type> pointer;

libcxx/include/map

public:
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __map_iterator& __x, const __map_iterator& __y)
         {return __x.__i_ == __y.__i_;}
     friend
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __map_iterator& __x, const __map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS multimap;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __map_const_iterator;
 };
 
 template <class _TreeIterator>
 class _LIBCPP_TEMPLATE_VIS __map_const_iterator
 {
     typedef typename _TreeIterator::_NodeTypes                   _NodeTypes;
     typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
 
public:
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const __map_const_iterator& __x, const __map_const_iterator& __y)
         {return __x.__i_ == __y.__i_;}
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS map;
+    template <class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS multimap;
+    template <class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __tree_const_iterator;
 };
 
 template <class _Key, class _Tp, class _Compare = less<_Key>,
           class _Allocator = allocator<pair<const _Key, _Tp> > >
 class _LIBCPP_TEMPLATE_VIS map
 {
 public:
     // types:
public:
     typedef _VSTD::reverse_iterator<const_iterator>         const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
     typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
     template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS map;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS map;
     template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multimap;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS multimap;
 
     _LIBCPP_INLINE_VISIBILITY
     map()
         _NOEXCEPT_(
             is_nothrow_default_constructible<allocator_type>::value &&
             is_nothrow_default_constructible<key_compare>::value &&
             is_nothrow_copy_constructible<key_compare>::value)
         : __tree_(__vc(key_compare())) {}
public:
     typedef _VSTD::reverse_iterator<iterator>               reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator>         const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
 #endif
 
     template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS map;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS map;
     template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multimap;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS multimap;
 
     _LIBCPP_INLINE_VISIBILITY
     multimap()
         _NOEXCEPT_(
             is_nothrow_default_constructible<allocator_type>::value &&
             is_nothrow_default_constructible<key_compare>::value &&
             is_nothrow_copy_constructible<key_compare>::value)
         : __tree_(__vc(key_compare())) {}

libcxx/include/set

public:
     typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
     typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
     template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS set;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS set;
     template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multiset;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS multiset;
 
     _LIBCPP_INLINE_VISIBILITY
     set()
         _NOEXCEPT_(
             is_nothrow_default_constructible<allocator_type>::value &&
             is_nothrow_default_constructible<key_compare>::value &&
             is_nothrow_copy_constructible<key_compare>::value)
         : __tree_(value_compare()) {}
public:
     typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
 #endif
 
     template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS set;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS set;
     template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multiset;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS multiset;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
     multiset()
         _NOEXCEPT_(
             is_nothrow_default_constructible<allocator_type>::value &&
             is_nothrow_default_constructible<key_compare>::value &&
             is_nothrow_copy_constructible<key_compare>::value)

libcxx/include/unordered_map

public:
 
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ == __y.__i_;}
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
 class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
 {
     _HashIterator __i_;
 
     typedef  __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
public:
 
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ == __y.__i_;}
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
         {return __x.__i_ != __y.__i_;}
 
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_map;
+    template <class, class, class, class, class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multimap;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_iterator;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS __hash_const_local_iterator;
 };
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 class unordered_multimap;
 
 template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
 class _LIBCPP_TEMPLATE_VIS unordered_map
public:
     typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __map_node_handle<__node, allocator_type> node_type;
     typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
     template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_map;
     template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multimap;
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_map()
         _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
     {
         _VSTD::__debug_db_insert_c(this);
     }
     explicit unordered_map(size_type __n, const hasher& __hf = hasher(),
public:
     typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
     typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __map_node_handle<__node, allocator_type> node_type;
 #endif
 
     template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_map;
     template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multimap;
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_multimap()
         _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
     {
         _VSTD::__debug_db_insert_c(this);
     }
     explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(),

libcxx/include/unordered_set

public:
     typedef typename __table::const_local_iterator const_local_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
     typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
     template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_set;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_set;
     template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multiset;
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_set()
         _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
     {
         _VSTD::__debug_db_insert_c(this);
     }
     explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
public:
     typedef typename __table::const_local_iterator local_iterator;
     typedef typename __table::const_local_iterator const_local_iterator;
 
 #if _LIBCPP_STD_VER >= 17
     typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
 #endif
 
     template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_set;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_set;
     template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
+        friend class _LIBCPP_FRIEND_TEMPLATE_VIS unordered_multiset;
 
     _LIBCPP_INLINE_VISIBILITY
     unordered_multiset()
         _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
     {
         _VSTD::__debug_db_insert_c(this);
     }
     explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(),

libcxx/include/valarray

public:
     _LIBCPP_INLINE_VISIBILITY
     __result_type operator[](size_t __i) const
         {return __expr_[__start_ + __i * __stride_];}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __size_;}
 
     template <class> friend class __val_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS valarray;
 };
 
 template <class _ValExpr>
 class __mask_expr;
 
 template <class _ValExpr>
 class __indirect_expr;
 
#endif // _LIBCPP_CXX03_LANG
 
     valarray shift (int __i) const;
     valarray cshift(int __i) const;
     valarray apply(value_type __f(value_type)) const;
     valarray apply(value_type __f(const value_type&)) const;
     void     resize(size_t __n, value_type __x = value_type());
 
 private:
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS valarray;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS slice_array;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS gslice_array;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS mask_array;
     template <class> friend class __mask_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS indirect_array;
     template <class> friend class __indirect_expr;
     template <class> friend class __val_expr;
 
     template <class _Up>
     friend
     _Up*
     begin(valarray<_Up>& __v);
 
public:
     _LIBCPP_INLINE_VISIBILITY
     __result_type operator[](size_t __i) const
         {return __expr_[__1d_[__i]];}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __1d_.size();}
 
     template <class> friend class __val_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
+    template <class> friend class _LIBCPP_FRIEND_TEMPLATE_VIS valarray;
 };
 
 template<class _ValExpr>
 class __val_expr
 {
     typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
 
     _ValExpr __expr_;

libcxx/include/vector

private:
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t __hash_code() const _NOEXCEPT;
 
     friend class __bit_reference<vector>;
     friend class __bit_const_reference<vector>;
     friend class __bit_iterator<vector, false>;
     friend class __bit_iterator<vector, true>;
     friend struct __bit_array<vector>;
-    friend struct _LIBCPP_TEMPLATE_VIS hash<vector>;
+    friend struct _LIBCPP_FRIEND_TEMPLATE_VIS hash<vector>;
 };
 
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT
 {
     if (this->__begin_ != nullptr)
     {