diff --git a/libcxx/include/__system_error/error_category.h b/libcxx/include/__system_error/error_category.h
--- a/libcxx/include/__system_error/error_category.h
+++ b/libcxx/include/__system_error/error_category.h
@@ -25,52 +25,46 @@
 
 class _LIBCPP_HIDDEN __do_message;
 
-class _LIBCPP_TYPE_VIS error_category
-{
+class _LIBCPP_TYPE_VIS error_category {
 public:
-    virtual ~error_category() _NOEXCEPT;
+  virtual ~error_category() _NOEXCEPT;
 
 #if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
-    error_category() noexcept;
+  error_category() noexcept;
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
+  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
 #endif
-    error_category(const error_category&) = delete;
-    error_category& operator=(const error_category&) = delete;
+  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;
+  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_INLINE_VISIBILITY 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));}
+  _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
+#else  // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    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_INLINE_VISIBILITY
-    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; }
 
 #endif // _LIBCPP_STD_VER >= 20
 
-    friend class _LIBCPP_HIDDEN __do_message;
+  friend class _LIBCPP_HIDDEN __do_message;
 };
 
-class _LIBCPP_HIDDEN __do_message
-    : public error_category
-{
+class _LIBCPP_HIDDEN __do_message : public error_category {
 public:
-    string message(int __ev) const override;
+  string message(int __ev) const override;
 };
 
 _LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
diff --git a/libcxx/include/__system_error/error_code.h b/libcxx/include/__system_error/error_code.h
--- a/libcxx/include/__system_error/error_code.h
+++ b/libcxx/include/__system_error/error_code.h
@@ -27,8 +27,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
-    : public false_type {};
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum : public false_type {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
@@ -36,154 +35,111 @@
 #endif
 
 namespace __adl_only {
-    // Those cause ADL to trigger but they are not viable candidates,
-    // so they are never actually selected.
-    void make_error_code() = delete;
+// Those cause ADL to trigger but they are not viable candidates,
+// so they are never actually selected.
+void make_error_code() = delete;
 } // namespace __adl_only
 
-class _LIBCPP_TYPE_VIS error_code
-{
-    int __val_;
-    const error_category* __cat_;
+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_INLINE_VISIBILITY
-    error_code(int __val, const error_category& __cat) _NOEXCEPT
-        : __val_(__val), __cat_(&__cat) {}
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        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
-    {
-        __val_ = __val;
-        __cat_ = &__cat;
-    }
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        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
-    {
-        __val_ = 0;
-        __cat_ = &system_category();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    int value() const _NOEXCEPT {return __val_;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    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_INLINE_VISIBILITY error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+
+  _LIBCPP_INLINE_VISIBILITY error_code(int __val, const error_category& __cat) _NOEXCEPT
+      : __val_(__val),
+        __cat_(&__cat) {}
+
+  template <class _Ep>
+  _LIBCPP_INLINE_VISIBILITY
+  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 {
+    __val_ = __val;
+    __cat_ = &__cat;
+  }
+
+  template <class _Ep>
+  _LIBCPP_INLINE_VISIBILITY 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 {
+    __val_ = 0;
+    __cat_ = &system_category();
+  }
+
+  _LIBCPP_INLINE_VISIBILITY int value() const _NOEXCEPT { return __val_; }
+
+  _LIBCPP_INLINE_VISIBILITY const error_category& category() const _NOEXCEPT { return *__cat_; }
+
+  _LIBCPP_INLINE_VISIBILITY 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; }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-error_code
-make_error_code(errc __e) _NOEXCEPT
-{
-    return error_code(static_cast<int>(__e), generic_category());
+inline _LIBCPP_INLINE_VISIBILITY 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
-{
-    return __x.category() == __y.category() && __x.value() == __y.value();
+inline _LIBCPP_INLINE_VISIBILITY 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
-{
-    return __x.category().equivalent(__x.value(), __y)
-        || __y.category().equivalent(__x, __y.value());
+inline _LIBCPP_INLINE_VISIBILITY 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
-{
-    return __y == __x;
+inline _LIBCPP_INLINE_VISIBILITY 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
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-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
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
-{
-    return __x.category() < __y.category()
-        || (__x.category() == __y.category() && __x.value() < __y.value());
+inline _LIBCPP_INLINE_VISIBILITY 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 {
+  return !(__x == __y);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY 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 {
+  return __x.category() < __y.category() || (__x.category() == __y.category() && __x.value() < __y.value());
 }
 
-#else // _LIBCPP_STD_VER <= 17
+#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();
+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
-    {
-        return static_cast<size_t>(__ec.value());
-    }
+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 {
+    return static_cast<size_t>(__ec.value());
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__system_error/error_condition.h b/libcxx/include/__system_error/error_condition.h
--- a/libcxx/include/__system_error/error_condition.h
+++ b/libcxx/include/__system_error/error_condition.h
@@ -25,8 +25,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
-    : public false_type {};
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum : public false_type {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
@@ -34,133 +33,97 @@
 #endif
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
-    : true_type { };
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> : true_type {};
 
 #ifdef _LIBCPP_CXX03_LANG
 template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
-    : true_type { };
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx> : true_type {};
 #endif
 
 namespace __adl_only {
-    // Those cause ADL to trigger but they are not viable candidates,
-    // so they are never actually selected.
-    void make_error_condition() = delete;
+// Those cause ADL to trigger but they are not viable candidates,
+// so they are never actually selected.
+void make_error_condition() = delete;
 } // namespace __adl_only
 
-class _LIBCPP_TYPE_VIS error_condition
-{
-    int __val_;
-    const error_category* __cat_;
+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_INLINE_VISIBILITY
-    error_condition(int __val, const error_category& __cat) _NOEXCEPT
-        : __val_(__val), __cat_(&__cat) {}
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        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
-    {
-        __val_ = __val;
-        __cat_ = &__cat;
-    }
-
-    template <class _Ep>
-        _LIBCPP_INLINE_VISIBILITY
-        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
-    {
-        __val_ = 0;
-        __cat_ = &generic_category();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    int value() const _NOEXCEPT {return __val_;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
-    string message() const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
+  _LIBCPP_INLINE_VISIBILITY error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
+
+  _LIBCPP_INLINE_VISIBILITY error_condition(int __val, const error_category& __cat) _NOEXCEPT
+      : __val_(__val),
+        __cat_(&__cat) {}
+
+  template <class _Ep>
+  _LIBCPP_INLINE_VISIBILITY
+  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 {
+    __val_ = __val;
+    __cat_ = &__cat;
+  }
+
+  template <class _Ep>
+  _LIBCPP_INLINE_VISIBILITY 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 {
+    __val_ = 0;
+    __cat_ = &generic_category();
+  }
+
+  _LIBCPP_INLINE_VISIBILITY int value() const _NOEXCEPT { return __val_; }
+
+  _LIBCPP_INLINE_VISIBILITY const error_category& category() const _NOEXCEPT { return *__cat_; }
+  string message() const;
+
+  _LIBCPP_INLINE_VISIBILITY explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-error_condition
-make_error_condition(errc __e) _NOEXCEPT
-{
-    return error_condition(static_cast<int>(__e), generic_category());
+inline _LIBCPP_INLINE_VISIBILITY 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
-{
-    return __x.category() == __y.category() && __x.value() == __y.value();
+inline _LIBCPP_INLINE_VISIBILITY 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
-{return !(__x == __y);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{
-    return __x.category() < __y.category()
-        || (__x.category() == __y.category() && __x.value() < __y.value());
+inline _LIBCPP_INLINE_VISIBILITY 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 {
+  return __x.category() < __y.category() || (__x.category() == __y.category() && __x.value() < __y.value());
+}
 
-#else // _LIBCPP_STD_VER <= 17
+#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();
+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
-    {
-        return static_cast<size_t>(__ec.value());
-    }
+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 {
+    return static_cast<size_t>(__ec.value());
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__system_error/system_error.h b/libcxx/include/__system_error/system_error.h
--- a/libcxx/include/__system_error/system_error.h
+++ b/libcxx/include/__system_error/system_error.h
@@ -22,30 +22,26 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS system_error
-    : public runtime_error
-{
-    error_code __ec_;
+class _LIBCPP_TYPE_VIS system_error : public runtime_error {
+  error_code __ec_;
+
 public:
-    system_error(error_code __ec, const string& __what_arg);
-    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_;}
+  system_error(error_code __ec, const string& __what_arg);
+  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_; }
 
 private:
-    static string __init(const error_code&, string);
+  static string __init(const error_code&, string);
 };
 
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
-void __throw_system_error(int __ev, const char* __what_arg);
-
+_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
diff --git a/libcxx/utils/data/ignore_format.txt b/libcxx/utils/data/ignore_format.txt
--- a/libcxx/utils/data/ignore_format.txt
+++ b/libcxx/utils/data/ignore_format.txt
@@ -611,10 +611,6 @@
 libcxx/include/__support/win32/locale_win32.h
 libcxx/include/__support/xlocale/__nop_locale_mgmt.h
 libcxx/include/__system_error/errc.h
-libcxx/include/__system_error/error_category.h
-libcxx/include/__system_error/error_code.h
-libcxx/include/__system_error/error_condition.h
-libcxx/include/__system_error/system_error.h
 libcxx/include/thread
 libcxx/include/__threading_support
 libcxx/include/__thread/poll_with_backoff.h