No functionality change at this time.  I've split _LIBCPP_VISIBLE up into two flags: _LIBCPP_TYPE_VIS and _LIBCPP_FUNC_VIS.  This is in preparation for taking advantage of clang's new __type_visibility__ attribute.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@176593 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/functional b/include/functional
index 2582782..995db56 100644
--- a/include/functional
+++ b/include/functional
@@ -474,63 +474,63 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE plus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS plus : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x + __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE minus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS minus : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x - __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE multiplies : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x * __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE divides : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS divides : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x / __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE modulus : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x % __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE negate : unary_function<_Tp, _Tp>
+struct _LIBCPP_TYPE_VIS negate : unary_function<_Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const
         {return -__x;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE equal_to : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS equal_to : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x == __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE not_equal_to : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x != __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE greater : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS greater : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x > __y;}
@@ -539,63 +539,63 @@
 // less in <__functional_base>
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE greater_equal : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x >= __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE less_equal : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS less_equal : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x <= __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE logical_and : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS logical_and : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x && __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE logical_or : binary_function<_Tp, _Tp, bool>
+struct _LIBCPP_TYPE_VIS logical_or : binary_function<_Tp, _Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x || __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE logical_not : unary_function<_Tp, bool>
+struct _LIBCPP_TYPE_VIS logical_not : unary_function<_Tp, bool>
 {
     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const
         {return !__x;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE bit_and : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x & __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE bit_or : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x | __y;}
 };
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE bit_xor : binary_function<_Tp, _Tp, _Tp>
+struct _LIBCPP_TYPE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
 {
     _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
         {return __x ^ __y;}
 };
 
 template <class _Predicate>
-class _LIBCPP_VISIBLE unary_negate
+class _LIBCPP_TYPE_VIS unary_negate
     : public unary_function<typename _Predicate::argument_type, bool>
 {
     _Predicate __pred_;
@@ -612,7 +612,7 @@
 not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 
 template <class _Predicate>
-class _LIBCPP_VISIBLE binary_negate
+class _LIBCPP_TYPE_VIS binary_negate
     : public binary_function<typename _Predicate::first_argument_type,
                              typename _Predicate::second_argument_type,
                              bool>
@@ -632,7 +632,7 @@
 not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 
 template <class __Operation>
-class _LIBCPP_VISIBLE binder1st
+class _LIBCPP_TYPE_VIS binder1st
     : public unary_function<typename __Operation::second_argument_type,
                             typename __Operation::result_type>
 {
@@ -658,7 +658,7 @@
     {return binder1st<__Operation>(__op, __x);}
 
 template <class __Operation>
-class _LIBCPP_VISIBLE binder2nd
+class _LIBCPP_TYPE_VIS binder2nd
     : public unary_function<typename __Operation::first_argument_type,
                             typename __Operation::result_type>
 {
@@ -684,7 +684,7 @@
     {return binder2nd<__Operation>(__op, __x);}
 
 template <class _Arg, class _Result>
-class _LIBCPP_VISIBLE pointer_to_unary_function
+class _LIBCPP_TYPE_VIS pointer_to_unary_function
     : public unary_function<_Arg, _Result>
 {
     _Result (*__f_)(_Arg);
@@ -702,7 +702,7 @@
     {return pointer_to_unary_function<_Arg,_Result>(__f);}
 
 template <class _Arg1, class _Arg2, class _Result>
-class _LIBCPP_VISIBLE pointer_to_binary_function
+class _LIBCPP_TYPE_VIS pointer_to_binary_function
     : public binary_function<_Arg1, _Arg2, _Result>
 {
     _Result (*__f_)(_Arg1, _Arg2);
@@ -720,7 +720,7 @@
     {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_VISIBLE mem_fun_t : public unary_function<_Tp*, _Sp>
+class _LIBCPP_TYPE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:
@@ -731,7 +731,7 @@
 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_VISIBLE mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
+class _LIBCPP_TYPE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
@@ -754,7 +754,7 @@
     {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_VISIBLE mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TYPE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:
@@ -765,7 +765,7 @@
 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_VISIBLE mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
+class _LIBCPP_TYPE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
@@ -788,7 +788,7 @@
     {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_VISIBLE const_mem_fun_t : public unary_function<const _Tp*, _Sp>
+class _LIBCPP_TYPE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:
@@ -799,7 +799,7 @@
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_VISIBLE const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
+class _LIBCPP_TYPE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;
 public:
@@ -822,7 +822,7 @@
     {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_VISIBLE const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TYPE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:
@@ -833,7 +833,7 @@
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_VISIBLE const_mem_fun1_ref_t
+class _LIBCPP_TYPE_VIS const_mem_fun1_ref_t
     : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;
@@ -932,7 +932,7 @@
 {
 };
 
-template<class _Fp> class _LIBCPP_VISIBLE function; // undefined
+template<class _Fp> class _LIBCPP_TYPE_VIS function; // undefined
 
 namespace __function
 {
@@ -1083,7 +1083,7 @@
 }  // __function
 
 template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_VISIBLE function<_Rp(_ArgTypes...)>
+class _LIBCPP_TYPE_VIS function<_Rp(_ArgTypes...)>
     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
       public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
 {
@@ -1496,11 +1496,11 @@
 {return __x.swap(__y);}
 
 template<class _Tp> struct __is_bind_expression : public false_type {};
-template<class _Tp> struct _LIBCPP_VISIBLE is_bind_expression
+template<class _Tp> struct _LIBCPP_TYPE_VIS is_bind_expression
     : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
 
 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
-template<class _Tp> struct _LIBCPP_VISIBLE is_placeholder
+template<class _Tp> struct _LIBCPP_TYPE_VIS is_placeholder
     : public __is_placeholder<typename remove_cv<_Tp>::type> {};
 
 namespace placeholders
@@ -1859,7 +1859,7 @@
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <>
-struct _LIBCPP_VISIBLE hash<bool>
+struct _LIBCPP_TYPE_VIS hash<bool>
     : public unary_function<bool, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1867,7 +1867,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<char>
+struct _LIBCPP_TYPE_VIS hash<char>
     : public unary_function<char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1875,7 +1875,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<signed char>
+struct _LIBCPP_TYPE_VIS hash<signed char>
     : public unary_function<signed char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1883,7 +1883,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<unsigned char>
+struct _LIBCPP_TYPE_VIS hash<unsigned char>
     : public unary_function<unsigned char, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1893,7 +1893,7 @@
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_VISIBLE hash<char16_t>
+struct _LIBCPP_TYPE_VIS hash<char16_t>
     : public unary_function<char16_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1901,7 +1901,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<char32_t>
+struct _LIBCPP_TYPE_VIS hash<char32_t>
     : public unary_function<char32_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1911,7 +1911,7 @@
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
-struct _LIBCPP_VISIBLE hash<wchar_t>
+struct _LIBCPP_TYPE_VIS hash<wchar_t>
     : public unary_function<wchar_t, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1919,7 +1919,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<short>
+struct _LIBCPP_TYPE_VIS hash<short>
     : public unary_function<short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1927,7 +1927,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<unsigned short>
+struct _LIBCPP_TYPE_VIS hash<unsigned short>
     : public unary_function<unsigned short, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1935,7 +1935,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<int>
+struct _LIBCPP_TYPE_VIS hash<int>
     : public unary_function<int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1943,7 +1943,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<unsigned int>
+struct _LIBCPP_TYPE_VIS hash<unsigned int>
     : public unary_function<unsigned int, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1951,7 +1951,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<long>
+struct _LIBCPP_TYPE_VIS hash<long>
     : public unary_function<long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1959,7 +1959,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<unsigned long>
+struct _LIBCPP_TYPE_VIS hash<unsigned long>
     : public unary_function<unsigned long, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1967,19 +1967,19 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<long long>
+struct _LIBCPP_TYPE_VIS hash<long long>
     : public __scalar_hash<long long>
 {
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<unsigned long long>
+struct _LIBCPP_TYPE_VIS hash<unsigned long long>
     : public __scalar_hash<unsigned long long>
 {
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<float>
+struct _LIBCPP_TYPE_VIS hash<float>
     : public __scalar_hash<float>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -1993,7 +1993,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<double>
+struct _LIBCPP_TYPE_VIS hash<double>
     : public __scalar_hash<double>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -2007,7 +2007,7 @@
 };
 
 template <>
-struct _LIBCPP_VISIBLE hash<long double>
+struct _LIBCPP_TYPE_VIS hash<long double>
     : public __scalar_hash<long double>
 {
     _LIBCPP_INLINE_VISIBILITY