[NFC][libc++] Use _LIBCPP_HIDE_FROM_ABI.

[Mordante]

Summary

This updates the new __system_error directory.

libcxx/include/__system_error/error_category.h

 
 class _LIBCPP_TYPE_VIS error_category {
 public:
   virtual ~error_category() _NOEXCEPT;
 
 #if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
   error_category() noexcept;
 #else
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
 #endif
   error_category(const error_category&)            = delete;
   error_category& operator=(const error_category&) = delete;
 
   virtual const char* name() const _NOEXCEPT = 0;
   virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
   virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
   virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
   virtual string message(int __ev) const = 0;
 
-  _LIBCPP_INLINE_VISIBILITY bool operator==(const error_category& __rhs) const _NOEXCEPT { return this == &__rhs; }
+  _LIBCPP_HIDE_FROM_ABI bool operator==(const error_category& __rhs) const _NOEXCEPT { return this == &__rhs; }
 
 #if _LIBCPP_STD_VER >= 20
 
   _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const error_category& __rhs) const noexcept {
     return compare_three_way()(this, std::addressof(__rhs));
   }
 
 #else  // _LIBCPP_STD_VER >= 20
 
-  _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_category& __rhs) const _NOEXCEPT { return !(*this == __rhs); }
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_category& __rhs) const _NOEXCEPT { return !(*this == __rhs); }
 
-  _LIBCPP_INLINE_VISIBILITY bool operator<(const error_category& __rhs) const _NOEXCEPT { return this < &__rhs; }
+  _LIBCPP_HIDE_FROM_ABI bool operator<(const error_category& __rhs) const _NOEXCEPT { return this < &__rhs; }
 
 #endif // _LIBCPP_STD_VER >= 20
 
   friend class _LIBCPP_HIDDEN __do_message;
 };
 
 class _LIBCPP_HIDDEN __do_message : public error_category {
 public:

libcxx/include/__system_error/error_code.h

 void make_error_code() = delete;
 } // namespace __adl_only
 
 class _LIBCPP_TYPE_VIS error_code {
   int __val_;
   const error_category* __cat_;
 
 public:
-  _LIBCPP_INLINE_VISIBILITY error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+  _LIBCPP_HIDE_FROM_ABI error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
 
-  _LIBCPP_INLINE_VISIBILITY error_code(int __val, const error_category& __cat) _NOEXCEPT
-      : __val_(__val),
-        __cat_(&__cat) {}
+  _LIBCPP_HIDE_FROM_ABI error_code(int __val, const error_category& __cat) _NOEXCEPT : __val_(__val), __cat_(&__cat) {}
 
   template <class _Ep>
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   error_code(_Ep __e, typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
     using __adl_only::make_error_code;
     *this = make_error_code(__e);
   }
 
-  _LIBCPP_INLINE_VISIBILITY void assign(int __val, const error_category& __cat) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI void assign(int __val, const error_category& __cat) _NOEXCEPT {
     __val_ = __val;
     __cat_ = &__cat;
   }
 
   template <class _Ep>
-  _LIBCPP_INLINE_VISIBILITY typename enable_if< is_error_code_enum<_Ep>::value, error_code& >::type
+  _LIBCPP_HIDE_FROM_ABI typename enable_if< is_error_code_enum<_Ep>::value, error_code& >::type
   operator=(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_code;
     *this = make_error_code(__e);
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT {
     __val_ = 0;
     __cat_ = &system_category();
   }
 
-  _LIBCPP_INLINE_VISIBILITY int value() const _NOEXCEPT { return __val_; }
+  _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }
 
-  _LIBCPP_INLINE_VISIBILITY const error_category& category() const _NOEXCEPT { return *__cat_; }
+  _LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }
 
-  _LIBCPP_INLINE_VISIBILITY error_condition default_error_condition() const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI error_condition default_error_condition() const _NOEXCEPT {
     return __cat_->default_error_condition(__val_);
   }
 
   string message() const;
 
-  _LIBCPP_INLINE_VISIBILITY explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY error_code make_error_code(errc __e) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(errc __e) _NOEXCEPT {
   return error_code(static_cast<int>(__e), generic_category());
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_code& __x, const error_code& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_code& __x, const error_code& __y) _NOEXCEPT {
   return __x.category() == __y.category() && __x.value() == __y.value();
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT {
   return __x.category().equivalent(__x.value(), __y) || __y.category().equivalent(__x, __y.value());
 }
 
 #if _LIBCPP_STD_VER <= 17
-inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT {
   return __y == __x;
 }
 #endif
 
 #if _LIBCPP_STD_VER <= 17
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT {
   return !(__x == __y);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT {
   return !(__x == __y);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT {
   return !(__x == __y);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator<(const error_code& __x, const error_code& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const error_code& __x, const error_code& __y) _NOEXCEPT {
   return __x.category() < __y.category() || (__x.category() == __y.category() && __x.value() < __y.value());
 }
 
 #else  // _LIBCPP_STD_VER <= 17
 
 inline _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const error_code& __x, const error_code& __y) noexcept {
   if (auto __c = __x.category() <=> __y.category(); __c != 0)
     return __c;
   return __x.value() <=> __y.value();
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<error_code> : public __unary_function<error_code, size_t> {
-  _LIBCPP_INLINE_VISIBILITY size_t operator()(const error_code& __ec) const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const error_code& __ec) const _NOEXCEPT {
     return static_cast<size_t>(__ec.value());
   }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H

libcxx/include/__system_error/error_condition.h

 void make_error_condition() = delete;
 } // namespace __adl_only
 
 class _LIBCPP_TYPE_VIS error_condition {
   int __val_;
   const error_category* __cat_;
 
 public:
-  _LIBCPP_INLINE_VISIBILITY error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
+  _LIBCPP_HIDE_FROM_ABI error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
 
-  _LIBCPP_INLINE_VISIBILITY error_condition(int __val, const error_category& __cat) _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI error_condition(int __val, const error_category& __cat) _NOEXCEPT
       : __val_(__val),
         __cat_(&__cat) {}
 
   template <class _Ep>
-  _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   error_condition(_Ep __e, typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
     using __adl_only::make_error_condition;
     *this = make_error_condition(__e);
   }
 
-  _LIBCPP_INLINE_VISIBILITY void assign(int __val, const error_category& __cat) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI void assign(int __val, const error_category& __cat) _NOEXCEPT {
     __val_ = __val;
     __cat_ = &__cat;
   }
 
   template <class _Ep>
-  _LIBCPP_INLINE_VISIBILITY typename enable_if< is_error_condition_enum<_Ep>::value, error_condition& >::type
+  _LIBCPP_HIDE_FROM_ABI typename enable_if< is_error_condition_enum<_Ep>::value, error_condition& >::type
   operator=(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_condition;
     *this = make_error_condition(__e);
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT {
     __val_ = 0;
     __cat_ = &generic_category();
   }
 
-  _LIBCPP_INLINE_VISIBILITY int value() const _NOEXCEPT { return __val_; }
+  _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }
 
-  _LIBCPP_INLINE_VISIBILITY const error_category& category() const _NOEXCEPT { return *__cat_; }
+  _LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }
   string message() const;
 
-  _LIBCPP_INLINE_VISIBILITY explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY error_condition make_error_condition(errc __e) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(errc __e) _NOEXCEPT {
   return error_condition(static_cast<int>(__e), generic_category());
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
   return __x.category() == __y.category() && __x.value() == __y.value();
 }
 
 #if _LIBCPP_STD_VER <= 17
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
   return !(__x == __y);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
   return __x.category() < __y.category() || (__x.category() == __y.category() && __x.value() < __y.value());
 }
 
 #else  // _LIBCPP_STD_VER <= 17
 
 inline _LIBCPP_HIDE_FROM_ABI strong_ordering
 operator<=>(const error_condition& __x, const error_condition& __y) noexcept {
   if (auto __c = __x.category() <=> __y.category(); __c != 0)
     return __c;
   return __x.value() <=> __y.value();
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<error_condition> : public __unary_function<error_condition, size_t> {
-  _LIBCPP_INLINE_VISIBILITY size_t operator()(const error_condition& __ec) const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const error_condition& __ec) const _NOEXCEPT {
     return static_cast<size_t>(__ec.value());
   }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H

libcxx/include/__system_error/system_error.h

public:
   system_error(error_code __ec, const char* __what_arg);
   system_error(error_code __ec);
   system_error(int __ev, const error_category& __ecat, const string& __what_arg);
   system_error(int __ev, const error_category& __ecat, const char* __what_arg);
   system_error(int __ev, const error_category& __ecat);
   system_error(const system_error&) _NOEXCEPT = default;
   ~system_error() _NOEXCEPT override;
 
-  _LIBCPP_INLINE_VISIBILITY const error_code& code() const _NOEXCEPT { return __ec_; }
+  _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }
 
 private:
   static string __init(const error_code&, string);
 };
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_system_error(int __ev, const char* __what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
+
 #endif // _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H