[libcxx] Handle windows system error code mapping in std::error_code.

[jyknight]

Summary

The std::error_code/std::error_category functionality is designed to
support multiple error domains. On Unix, both system calls and libc
functions return the same error codes, and thus, libc++ today treats
generic_category() and system_category() as being equivalent.

However, on Windows, libc functions return errno.h error codes in
the errno global, but system calls return the very different
winerror.h error codes via GetLastError().

As such, there is a need to map the winerr.h error codes into generic
errno codes. In libc++, however, the system_error facility does not
currently implement this mapping, and instead the mapping is hidden
inside libc++, used directly by the std::filesystem implementation.

That has a few problems:

1. For std::filesystem APIs, the concrete windows error number is lost, before users can see it. The intent of the distinction between std::error_code and std::error_condition is that the error_code return has the original (potentially more detailed) error code.

2. User-written code which calls Windows system APIs requires this same mapping, so it also can also return error_code objects that other (cross-platform) code can understand.

After this commit, an error_code with generic_category() is used
to report an error from errno, and, on Windows only, an error_code
with system_category() is used to report an error from
GetLastError(). On Unix, system_category remains identity-mapped to
generic_category, but is never used by libc++ itself.

The windows error code mapping is moved into system_error, so that
conversion of an error_code to error_condition correctly
translates the system_category() code into a generic_category()
code, when appropriate.

This allows code like:
error_code(GetLastError(), system_category()) == errc::invalid_argument
to work as expected -- as it does with MSVC STL.

[philnik]

Could you split the NFC changes into a separate patch?

libcxx/include/__filesystem/directory_entry.h

328–329

This should be equivalent, unless I'm missing something.

[mstorsjo]

Looks mostly reasonable to me, but one rather significant issue about mapping between CRT and system error codes in the filesystem code.

One typo in the commit message, "winderr.h".

I don't quite follow all cases where errors can be compared directly and where they need to be canonicalized in the tests though.

libcxx/src/filesystem/operations.cpp

56–57

The detail::open() function uses _wopen(), which is a CRT function, which sets errno, not the windows error. (I guess it plausibly might leave the windows error code set too, but I guess we can't rely on it?)

So for all these cases where we switch from capture_errno() to get_last_error(), we'd need to make sure that we really do set the windows error code (or try to map from errno to windows error code).

(I guess the alternative, to keep track of which calls return in errno and which return in the windows error code and call the right function here, is unmaintainble.)

libcxx/src/system_error.cpp

31

Use lowercase windows.h for compatibility with mingw headers (which use lowercased header names consistently); while it is named Windows.h in the winsdk, the winsdk itself isn't self consistent and can't be used on a case sensitive filesystem without fixups in one form or another.

[jyknight]

In D151493#4373979, @mstorsjo wrote:

I don't quite follow all cases where errors can be compared directly and where they need to be canonicalized in the tests though.

The error_code comparison/canonicalization issue in the tests is isolated to directory_entry.

These tests are attempting to compare for equality the error_code you get from directory_entry.stat() to that you get from std::filesystem::stat(path), for a nonexistent path. However, directory_entry caches the absence of a file, and calls make_error_code(errc::no_such_file_or_directory);, instead of passing through the system's error code.

That is, in create_file_status, called from directory_entry::__do_refresh, it translates
m_ec == errc::no_such_file_or_directory || m_ec == errc::not_a_directory into file_type::not_found. Note that that comparison does the conversion from error_code to error_condition, which invokes system_category->generic_category conversion. Then, in __get_ft (and __get_sym_ft), it translates file_type::not_found into no_such_file_or_directory -- directly. So, we do lose which exact underlying error_code was originally reported.

I don't think this is likely to be a problem in practice, but it does break those test-cases.

libcxx/src/filesystem/operations.cpp

56–57

Ah, good catch, sorry I missed that! And, yeah, that is a significant problem.

One solution is to stop using the CRT functions at all in the filesystem impl layer for win32. That'll be a bit of work, but maybe it's not too bad. We'd abstract int fd into an internal file-handle type, (int on unix, HANDLE on win32) so we don't need open to return an int fd. Then, replace _wmkdir, _wopen, _close, _wchdir, and _wgetcwd. I think that's all. Seems doable -- and IMO, probably a good idea, anyways.

An alternative would be to return error_code from each of the detail::* functions. That way, it can be created from errno or GetLastError as required, right after the OS call in question.. The downside of that is that we'd need to add trivial wrapper functions on unix, instead of the current using ::open; etc.

[jyknight]

libcxx/src/filesystem/operations.cpp

56–57

Looking into this a bit more, we cannot actually migrate open/close away from fds. The only usage of open/close the std::filesystem impl is for copy_file, which (on windows) uses iostreams to actually do the copy -- which uses the [io]fstream::__open(int fd, ...) API. So, unless we _also_ migrated iostreams to using a HANDLE on windows instead of an fd, we still need to use fds (and thus libc's open) in the filesystem code.

I think the simplest fix is to go ahead and switch the other 3 calls over to native windows APIs, and simply remove open/close from the posix_compat.h layer (instead, just putting the #if inline in operations.cpp's FileDescriptor class -- the only user).

That way, everything in the the posix_compat abstraction layer is consistently returning errors via get_last_error.

[jyknight]

Rebase on top of new parent review, and address comments.

[jyknight]

In D151493#4373925, @philnik wrote:

Could you split the NFC changes into a separate patch?

I haven't done this, because I'm not sure which changes you're referring to -- I don't think there's any separable NFC changes here.

[philnik]

In D151493#4425263, @jyknight wrote:

In D151493#4373925, @philnik wrote:

Could you split the NFC changes into a separate patch?

I haven't done this, because I'm not sure which changes you're referring to -- I don't think there's any separable NFC changes here.

For example, moving __win_err_to_errc is NFC AFAICT.

[jyknight]

In D151493#4425486, @philnik wrote:

For example, moving __win_err_to_errc is NFC AFAICT.

In the new code, __win_err_to_errc is a private implementation detail of std::system_error, living in an anonymous namespace inside system_error.cpp. In the old code, it's an extern function used by directory_iterator.cpp and operations.cpp within std::filesystem::detail. I _could_ kludge together a separate change which moves the source location of the code into system_error.cpp, while still having it be an extern symbol in the std::filesystem::detail namespace, but ISTM that's really stretching the bounds of a reasonable sort of NFC change to split off.

[jyknight]

Rebase.

[jyknight]

Rebase.

[jyknight]

Rebase

[jyknight]

Ping!

[mstorsjo]

Overall, this LGTM, but I'm not a libcxx approver.

libcxx/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp

37

This changes what is tested for other platforms, previously this checked m1 != m3, now it checks m2 != m3. Although it is tested above that m1 == m2 though... (A comment about this change could be good, it's not immediately obvious to me what is fixed here.)

libcxx/include/__filesystem/directory_entry.h

 #include <__filesystem/file_status.h>
 #include <__filesystem/file_time_type.h>
 #include <__filesystem/file_type.h>
 #include <__filesystem/filesystem_error.h>
 #include <__filesystem/operations.h>
 #include <__filesystem/path.h>
 #include <__filesystem/perms.h>
 #include <__system_error/errc.h>
+#include <__system_error/error_category.h>
 #include <__system_error/error_code.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstdint>
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
private:
   void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
     __p_ = _VSTD::move(__p);
     __data_ = __dt;
   }
 
   _LIBCPP_EXPORTED_FROM_ABI error_code __do_refresh() noexcept;
 
   _LIBCPP_INLINE_VISIBILITY
   static bool __is_dne_error(error_code const& __ec) {
-    if (!__ec)
-      return true;
-    switch (static_cast<errc>(__ec.value())) {
-    case errc::no_such_file_or_directory:
-    case errc::not_a_directory:
-      return true;
-    default:
-      return false;
-    }
+    return !__ec || __ec == errc::no_such_file_or_directory || __ec == errc::not_a_directory;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void __handle_error(const char* __msg, error_code* __dest_ec,
                       error_code const& __ec, bool __allow_dne = false) const {
     if (__dest_ec) {
       *__dest_ec = __ec;
       return;

libcxx/include/__system_error/system_error.h

public:
   ~system_error() _NOEXCEPT override;
 
   _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }
 
 private:
   static string __init(const error_code&, string);
 };
 
+// __ev is expected to be an error in the generic_category domain (e.g. from
+// errno, or std::errc::*), not system_category (e.g. from windows syscalls).
 _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_system_error(int __ev, const char* __what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H

libcxx/src/filesystem/directory_iterator.cpp

public:
   __dir_stream(const path& root, directory_options opts, error_code& ec)
       : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
     if (root.native().empty()) {
       ec = make_error_code(errc::no_such_file_or_directory);
       return;
     }
     __stream_ = ::FindFirstFileW((root / "*").c_str(), &__data_);
     if (__stream_ == INVALID_HANDLE_VALUE) {
-      ec = detail::make_windows_error(GetLastError());
+      ec = detail::get_last_error();
       const bool ignore_permission_denied =
           bool(opts & directory_options::skip_permission_denied);
-      if (ignore_permission_denied &&
-          ec.value() == static_cast<int>(errc::permission_denied))
+      if (ignore_permission_denied && ec == errc::permission_denied)
         ec.clear();
       return;
     }
     if (!assign())
       advance(ec);
   }
 
   ~__dir_stream() noexcept {
__entry_.__assign_iter_entry(
         directory_entry::__create_iter_result(detail::get_file_type(__data_)));
     return true;
   }
 
 private:
   error_code close() noexcept {
     error_code ec;
     if (!::FindClose(__stream_))
-      ec = detail::make_windows_error(GetLastError());
+      ec = detail::get_last_error();
     __stream_ = INVALID_HANDLE_VALUE;
     return ec;
   }
 
   HANDLE __stream_{INVALID_HANDLE_VALUE};
   WIN32_FIND_DATAW __data_;
 
 public:
public:
   }
 
   __dir_stream(const path& root, directory_options opts, error_code& ec)
       : __stream_(nullptr), __root_(root) {
     if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
       ec = detail::capture_errno();
       const bool allow_eacces =
           bool(opts & directory_options::skip_permission_denied);
-      if (allow_eacces && ec.value() == EACCES)
+      if (allow_eacces && ec == errc::permission_denied)
         ec.clear();
       return;
     }
     advance(ec);
   }
 
   ~__dir_stream() noexcept {
     if (__stream_)
if (!skip_rec) {
     if (new_it.good()) {
       __imp_->__stack_.push(std::move(new_it));
       return true;
     }
   }
   if (m_ec) {
     const bool allow_eacess =
         bool(__imp_->__options_ & directory_options::skip_permission_denied);
-    if (m_ec.value() == EACCES && allow_eacess) {
+    if (m_ec == errc::permission_denied && allow_eacess) {
       if (ec)
         ec->clear();
     } else {
       path at_ent = std::move(curr_it.__entry_.__p_);
       __imp_.reset();
       err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT,
                  at_ent.c_str());
     }
   }
   return false;
 }
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM

libcxx/src/filesystem/error.h

 # define NOMINMAX
 # include <windows.h> // ERROR_* macros
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 namespace detail {
 
-#if defined(_LIBCPP_WIN32API)
-
-inline errc __win_err_to_errc(int err) {
-  constexpr struct {
-    DWORD win;
-    errc errc;
-  } win_error_mapping[] = {
-      {ERROR_ACCESS_DENIED, errc::permission_denied},
-      {ERROR_ALREADY_EXISTS, errc::file_exists},
-      {ERROR_BAD_NETPATH, errc::no_such_file_or_directory},
-      {ERROR_BAD_PATHNAME, errc::no_such_file_or_directory},
-      {ERROR_BAD_UNIT, errc::no_such_device},
-      {ERROR_BROKEN_PIPE, errc::broken_pipe},
-      {ERROR_BUFFER_OVERFLOW, errc::filename_too_long},
-      {ERROR_BUSY, errc::device_or_resource_busy},
-      {ERROR_BUSY_DRIVE, errc::device_or_resource_busy},
-      {ERROR_CANNOT_MAKE, errc::permission_denied},
-      {ERROR_CANTOPEN, errc::io_error},
-      {ERROR_CANTREAD, errc::io_error},
-      {ERROR_CANTWRITE, errc::io_error},
-      {ERROR_CURRENT_DIRECTORY, errc::permission_denied},
-      {ERROR_DEV_NOT_EXIST, errc::no_such_device},
-      {ERROR_DEVICE_IN_USE, errc::device_or_resource_busy},
-      {ERROR_DIR_NOT_EMPTY, errc::directory_not_empty},
-      {ERROR_DIRECTORY, errc::invalid_argument},
-      {ERROR_DISK_FULL, errc::no_space_on_device},
-      {ERROR_FILE_EXISTS, errc::file_exists},
-      {ERROR_FILE_NOT_FOUND, errc::no_such_file_or_directory},
-      {ERROR_HANDLE_DISK_FULL, errc::no_space_on_device},
-      {ERROR_INVALID_ACCESS, errc::permission_denied},
-      {ERROR_INVALID_DRIVE, errc::no_such_device},
-      {ERROR_INVALID_FUNCTION, errc::function_not_supported},
-      {ERROR_INVALID_HANDLE, errc::invalid_argument},
-      {ERROR_INVALID_NAME, errc::no_such_file_or_directory},
-      {ERROR_INVALID_PARAMETER, errc::invalid_argument},
-      {ERROR_LOCK_VIOLATION, errc::no_lock_available},
-      {ERROR_LOCKED, errc::no_lock_available},
-      {ERROR_NEGATIVE_SEEK, errc::invalid_argument},
-      {ERROR_NOACCESS, errc::permission_denied},
-      {ERROR_NOT_ENOUGH_MEMORY, errc::not_enough_memory},
-      {ERROR_NOT_READY, errc::resource_unavailable_try_again},
-      {ERROR_NOT_SAME_DEVICE, errc::cross_device_link},
-      {ERROR_NOT_SUPPORTED, errc::not_supported},
-      {ERROR_OPEN_FAILED, errc::io_error},
-      {ERROR_OPEN_FILES, errc::device_or_resource_busy},
-      {ERROR_OPERATION_ABORTED, errc::operation_canceled},
-      {ERROR_OUTOFMEMORY, errc::not_enough_memory},
-      {ERROR_PATH_NOT_FOUND, errc::no_such_file_or_directory},
-      {ERROR_READ_FAULT, errc::io_error},
-      {ERROR_REPARSE_TAG_INVALID, errc::invalid_argument},
-      {ERROR_RETRY, errc::resource_unavailable_try_again},
-      {ERROR_SEEK, errc::io_error},
-      {ERROR_SHARING_VIOLATION, errc::permission_denied},
-      {ERROR_TOO_MANY_OPEN_FILES, errc::too_many_files_open},
-      {ERROR_WRITE_FAULT, errc::io_error},
-      {ERROR_WRITE_PROTECT, errc::permission_denied},
-  };
-
-  for (const auto &pair : win_error_mapping)
-    if (pair.win == static_cast<DWORD>(err))
-      return pair.errc;
-  return errc::invalid_argument;
-}
-
-#endif // _LIBCPP_WIN32API
+// On windows, libc functions use errno, but system functions use GetLastError.
+// So, callers need to be careful which of these next functions they call!
 
 inline error_code capture_errno() {
   _LIBCPP_ASSERT_UNCATEGORIZED(errno != 0, "Expected errno to be non-zero");
   return error_code(errno, generic_category());
 }
 
+inline error_code get_last_error() {
 #if defined(_LIBCPP_WIN32API)
-inline error_code make_windows_error(int err) {
-  return make_error_code(__win_err_to_errc(err));
-}
+  return std::error_code(GetLastError(), std::system_category());
+#else
+  return capture_errno();
 #endif
+}
 
 template <class T>
 T error_value();
 template <>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX14 void error_value<void>() {}
 template <>
 inline bool error_value<bool>() {
   return false;

libcxx/src/filesystem/file_descriptor.h

 inline perms posix_get_perms(const StatT& st) noexcept {
   return static_cast<perms>(st.st_mode) & perms::mask;
 }
 
 inline file_status create_file_status(error_code& m_ec, path const& p,
                                       const StatT& path_stat, error_code* ec) {
   if (ec)
     *ec = m_ec;
-  if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
+  if (m_ec && (m_ec == errc::no_such_file_or_directory || m_ec == errc::not_a_directory)) {
     return file_status(file_type::not_found);
   } else if (m_ec) {
     ErrorHandler<void> err("posix_stat", ec, &p);
     err.report(m_ec, "failed to determine attributes for the specified path");
     return file_status(file_type::none);
   }
   // else
 
inline file_status create_file_status(error_code& m_ec, path const& p,
 
   fs_tmp.permissions(detail::posix_get_perms(path_stat));
   return fs_tmp;
 }
 
 inline file_status posix_stat(path const& p, StatT& path_stat, error_code* ec) {
   error_code m_ec;
   if (detail::stat(p.c_str(), &path_stat) == -1)
-    m_ec = detail::capture_errno();
+    m_ec = detail::get_last_error();
   return create_file_status(m_ec, p, path_stat, ec);
 }
 
 inline file_status posix_stat(path const& p, error_code* ec) {
   StatT path_stat;
   return posix_stat(p, path_stat, ec);
 }
 
 inline file_status posix_lstat(path const& p, StatT& path_stat, error_code* ec) {
   error_code m_ec;
   if (detail::lstat(p.c_str(), &path_stat) == -1)
-    m_ec = detail::capture_errno();
+    m_ec = detail::get_last_error();
   return create_file_status(m_ec, p, path_stat, ec);
 }
 
 inline file_status posix_lstat(path const& p, error_code* ec) {
   StatT path_stat;
   return posix_lstat(p, path_stat, ec);
 }
 
 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html
 inline bool posix_ftruncate(const FileDescriptor& fd, off_t to_size, error_code& ec) {
   if (detail::ftruncate(fd.fd, to_size) == -1) {
-    ec = capture_errno();
+    ec = get_last_error();
     return true;
   }
   ec.clear();
   return false;
 }
 
 inline bool posix_fchmod(const FileDescriptor& fd, const StatT& st, error_code& ec) {
   if (detail::fchmod(fd.fd, st.st_mode) == -1) {
-    ec = capture_errno();
+    ec = get_last_error();
     return true;
   }
   ec.clear();
   return false;
 }
 
 inline bool stat_equivalent(const StatT& st1, const StatT& st2) {
   return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
 }
 
 inline file_status FileDescriptor::refresh_status(error_code& ec) {
   // FD must be open and good.
   m_status = file_status{};
   m_stat = {};
   error_code m_ec;
   if (detail::fstat(fd, &m_stat) == -1)
-    m_ec = capture_errno();
+    m_ec = get_last_error();
   m_status = create_file_status(m_ec, name, m_stat, &ec);
   return m_status;
 }
 
 } // end namespace detail
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // FILESYSTEM_FILE_DESCRIPTOR_H

libcxx/src/filesystem/operations.cpp

 # define _LIBCPP_FILESYSTEM_USE_FSTREAM
 #endif
 
 #if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
 # pragma comment(lib, "rt")
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 using detail::capture_errno;
 using detail::ErrorHandler;
 using detail::StatT;
 using detail::TimeSpec;
 using parser::createView;
 using parser::PathParser;
 using parser::string_view_t;
 
 static path __do_absolute(const path& p, path* cwd, error_code* ec) {
path __canonical(path const& orig_p, error_code* ec) {
   path cwd;
   ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
 
   path p = __do_absolute(orig_p, &cwd, ec);
 #if (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112) || defined(_LIBCPP_WIN32API)
   std::unique_ptr<path::value_type, decltype(&::free)>
     hold(detail::realpath(p.c_str(), nullptr), &::free);
   if (hold.get() == nullptr)
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
   return {hold.get()};
 #else
   #if defined(__MVS__) && !defined(PATH_MAX)
     path::value_type buff[ _XOPEN_PATH_MAX + 1 ];
   #else
     path::value_type buff[PATH_MAX + 1];
   #endif
   path::value_type* ret;
   if ((ret = detail::realpath(p.c_str(), buff)) == nullptr)
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
   return {ret};
 #endif
 }
 
 void __copy(const path& from, const path& to, copy_options options,
             error_code* ec) {
   ErrorHandler<void> err("copy", ec, &from, &to);
 

 }
 
 bool __create_directory(const path& p, error_code* ec) {
   ErrorHandler<bool> err("create_directory", ec, &p);
 
   if (detail::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
     return true;
 
-  if (errno != EEXIST)
-    return err.report(capture_errno());
-  error_code mec = capture_errno();
+  error_code mec = detail::get_last_error();
+  if (mec != errc::file_exists)
+    return err.report(mec);
   error_code ignored_ec;
   const file_status st = status(p, ignored_ec);
   if (!is_directory(st))
     return err.report(mec);
   return false;
 }
 
 bool __create_directory(path const& p, path const& attributes, error_code* ec) {
   ErrorHandler<bool> err("create_directory", ec, &p, &attributes);
 
   StatT attr_stat;
   error_code mec;
   file_status st = detail::posix_stat(attributes, attr_stat, &mec);
   if (!status_known(st))
     return err.report(mec);
   if (!is_directory(st))
     return err.report(errc::not_a_directory,
                       "the specified attribute path is invalid");
 
   if (detail::mkdir(p.c_str(), attr_stat.st_mode) == 0)
     return true;
 
-  if (errno != EEXIST)
-    return err.report(capture_errno());
+  mec = detail::get_last_error();
+  if (mec != errc::file_exists)
+    return err.report(mec);
 
-  mec = capture_errno();
   error_code ignored_ec;
   st = status(p, ignored_ec);
   if (!is_directory(st))
     return err.report(mec);
   return false;
 }
 
 void __create_directory_symlink(path const& from, path const& to,
                                 error_code* ec) {
   ErrorHandler<void> err("create_directory_symlink", ec, &from, &to);
   if (detail::symlink_dir(from.c_str(), to.c_str()) == -1)
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
 }
 
 void __create_hard_link(const path& from, const path& to, error_code* ec) {
   ErrorHandler<void> err("create_hard_link", ec, &from, &to);
   if (detail::link(from.c_str(), to.c_str()) == -1)
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
 }
 
 void __create_symlink(path const& from, path const& to, error_code* ec) {
   ErrorHandler<void> err("create_symlink", ec, &from, &to);
   if (detail::symlink_file(from.c_str(), to.c_str()) == -1)
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
 }
 
 path __current_path(error_code* ec) {
   ErrorHandler<path> err("current_path", ec);
 
 #if defined(_LIBCPP_WIN32API) || defined(__GLIBC__) || defined(__APPLE__)
   // Common extension outside of POSIX getcwd() spec, without needing to
   // preallocate a buffer. Also supported by a number of other POSIX libcs.
#else
   // below.
   struct Deleter { void operator()(void*) const {} };
   Deleter deleter;
 #endif
 
   unique_ptr<path::value_type, Deleter> hold(detail::getcwd(ptr, size),
                                              deleter);
   if (hold.get() == nullptr)
-    return err.report(capture_errno(), "call to getcwd failed");
+    return err.report(detail::get_last_error(), "call to getcwd failed");
 
   return {hold.get()};
 }
 
 void __current_path(const path& p, error_code* ec) {
   ErrorHandler<void> err("current_path", ec, &p);
   if (detail::chdir(p.c_str()) == -1)
-    err.report(capture_errno());
+    err.report(detail::get_last_error());
 }
 
 bool __equivalent(const path& p1, const path& p2, error_code* ec) {
   ErrorHandler<bool> err("equivalent", ec, &p1, &p2);
 
   error_code ec1, ec2;
   StatT st1 = {}, st2 = {};
   auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
void __last_write_time(const path& p, file_time_type new_time, error_code* ec) {
   ErrorHandler<void> err("last_write_time", ec, &p);
 
 #if defined(_LIBCPP_WIN32API)
   TimeSpec ts;
   if (!fs_time::convert_to_timespec(ts, new_time))
     return err.report(errc::value_too_large);
   detail::WinHandle h(p.c_str(), FILE_WRITE_ATTRIBUTES, 0);
   if (!h)
-    return err.report(detail::make_windows_error(GetLastError()));
+    return err.report(detail::get_last_error());
   FILETIME last_write = timespec_to_filetime(ts);
   if (!SetFileTime(h, nullptr, nullptr, &last_write))
-    return err.report(detail::make_windows_error(GetLastError()));
+    return err.report(detail::get_last_error());
 #else
   error_code m_ec;
   array<TimeSpec, 2> tbuf;
 #if !defined(_LIBCPP_USE_UTIMENSAT)
   // This implementation has a race condition between determining the
   // last access time and attempting to set it to the same value using
   // ::utimes
   StatT st;
if (!resolve_symlinks || (add_perms || remove_perms)) {
     else if (remove_perms)
       prms = st.permissions() & ~prms;
   }
   const auto real_perms = static_cast<detail::ModeT>(prms & perms::mask);
 
 #if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
   const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
   if (detail::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
   }
 #else
   if (set_sym_perms)
     return err.report(errc::operation_not_supported);
   if (::chmod(p.c_str(), real_perms) == -1) {
     return err.report(capture_errno());
   }
 #endif

 #else
   const size_t size = PATH_MAX + 1;
 #endif
   path::value_type stack_buff[size];
   auto buff = std::unique_ptr<path::value_type[], NullDeleter>(stack_buff);
 #else
   StatT sb;
   if (detail::lstat(p.c_str(), &sb) == -1) {
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
   }
   const size_t size = sb.st_size + 1;
   auto buff = unique_ptr<path::value_type[]>(new path::value_type[size]);
 #endif
   detail::SSizeT ret;
   if ((ret = detail::readlink(p.c_str(), buff.get(), size)) == -1)
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
   _LIBCPP_ASSERT_UNCATEGORIZED(ret > 0, "TODO");
   if (static_cast<size_t>(ret) >= size)
     return err.report(errc::value_too_large);
   buff[ret] = 0;
   return {buff.get()};
 }
 
 bool __remove(const path& p, error_code* ec) {
   ErrorHandler<bool> err("remove", ec, &p);
   if (detail::remove(p.c_str()) == -1) {
-    if (errno != ENOENT)
-      err.report(capture_errno());
+    error_code mec = detail::get_last_error();
+    if (mec != errc::no_such_file_or_directory)
+      err.report(mec);
     return false;
   }
   return true;
 }
 
 // We currently have two implementations of `__remove_all`. The first one is general and
 // used on platforms where we don't have access to the `openat()` family of POSIX functions.
 // That implementation uses `directory_iterator`, however it is vulnerable to some race
uintmax_t __remove_all(const path& p, error_code* ec) {
   return count;
 }
 
 #endif // REMOVE_ALL_USE_DIRECTORY_ITERATOR
 
 void __rename(const path& from, const path& to, error_code* ec) {
   ErrorHandler<void> err("rename", ec, &from, &to);
   if (detail::rename(from.c_str(), to.c_str()) == -1)
-    err.report(capture_errno());
+    err.report(detail::get_last_error());
 }
 
 void __resize_file(const path& p, uintmax_t size, error_code* ec) {
   ErrorHandler<void> err("resize_file", ec, &p);
   if (detail::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
-    return err.report(capture_errno());
+    return err.report(detail::get_last_error());
 }
 
 space_info __space(const path& p, error_code* ec) {
   ErrorHandler<void> err("space", ec, &p);
   space_info si;
   detail::StatVFS m_svfs = {};
   if (detail::statvfs(p.c_str(), &m_svfs) == -1) {
-    err.report(capture_errno());
+    err.report(detail::get_last_error());
     si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
     return si;
   }
   // Multiply with overflow checking.
   auto do_mult = [&](uintmax_t& out, uintmax_t other) {
     out = other * m_svfs.f_frsize;
     if (other == 0 || out / other != m_svfs.f_frsize)
       out = static_cast<uintmax_t>(-1);

 
 path __temp_directory_path(error_code* ec) {
   ErrorHandler<path> err("temp_directory_path", ec);
 
 #if defined(_LIBCPP_WIN32API)
   wchar_t buf[MAX_PATH];
   DWORD retval = GetTempPathW(MAX_PATH, buf);
   if (!retval)
-    return err.report(detail::make_windows_error(GetLastError()));
+    return err.report(detail::get_last_error());
   if (retval > MAX_PATH)
     return err.report(errc::filename_too_long);
   // GetTempPathW returns a path with a trailing slash, which we
   // shouldn't include for consistency.
   if (buf[retval-1] == L'\\')
     buf[retval-1] = L'\0';
   path p(buf);
 #else

libcxx/src/filesystem/posix_compat.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 //
 // POSIX-like portability helper functions.
 //
 // These generally behave like the proper posix functions, with these
 // exceptions:
-// On Windows, they take paths in wchar_t* form, instead of char* form.
-// The symlink() function is split into two frontends, symlink_file()
-// and symlink_dir().
+// - On Windows, they take paths in wchar_t* form, instead of char* form.
+// - The symlink() function is split into two frontends, symlink_file()
+//   and symlink_dir().
+// - Errors should be retrieved with get_last_error, not errno.
 //
 // These are provided within an anonymous namespace within the detail
 // namespace - callers need to include this header and call them as
 // detail::function(), regardless of platform.
 //
 
 #ifndef POSIX_COMPAT_H
 #define POSIX_COMPAT_H

 #define S_ISFIFO(m)     (((m) & _S_IFMT) == _S_IFIFO)
 #define S_ISREG(m)      (((m) & _S_IFMT) == _S_IFREG)
 #define S_ISBLK(m)      (((m) & _S_IFMT) == _S_IFBLK)
 #define S_ISLNK(m)      (((m) & _S_IFMT) == _S_IFLNK)
 #define S_ISSOCK(m)     (((m) & _S_IFMT) == _S_IFSOCK)
 
 #define O_NONBLOCK 0
 
-inline int set_errno(int e = GetLastError()) {
-  errno = static_cast<int>(__win_err_to_errc(e));
-  return -1;
-}
-
 class WinHandle {
 public:
   WinHandle(const wchar_t *p, DWORD access, DWORD flags) {
     h = CreateFileW(
         p, access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
         nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | flags, nullptr);
   }
   ~WinHandle() {
     if (h != INVALID_HANDLE_VALUE)
       CloseHandle(h);
   }
   operator HANDLE() const { return h; }
   operator bool() const { return h != INVALID_HANDLE_VALUE; }
 
 private:
   HANDLE h;
 };
 
 inline int stat_handle(HANDLE h, StatT *buf) {
   FILE_BASIC_INFO basic;
   if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
-    return set_errno();
+    return -1;
   memset(buf, 0, sizeof(*buf));
   buf->st_mtim = filetime_to_timespec(basic.LastWriteTime);
   buf->st_atim = filetime_to_timespec(basic.LastAccessTime);
   buf->st_mode = 0555; // Read-only
   if (!(basic.FileAttributes & FILE_ATTRIBUTE_READONLY))
     buf->st_mode |= 0222; // Write
   if (basic.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
     buf->st_mode |= _S_IFDIR;
   } else {
     buf->st_mode |= _S_IFREG;
   }
   if (basic.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
     FILE_ATTRIBUTE_TAG_INFO tag;
     if (!GetFileInformationByHandleEx(h, FileAttributeTagInfo, &tag,
                                       sizeof(tag)))
-      return set_errno();
+      return -1;
     if (tag.ReparseTag == IO_REPARSE_TAG_SYMLINK)
       buf->st_mode = (buf->st_mode & ~_S_IFMT) | _S_IFLNK;
   }
   FILE_STANDARD_INFO standard;
   if (!GetFileInformationByHandleEx(h, FileStandardInfo, &standard,
                                     sizeof(standard)))
-    return set_errno();
+    return -1;
   buf->st_nlink = standard.NumberOfLinks;
   buf->st_size = standard.EndOfFile.QuadPart;
   BY_HANDLE_FILE_INFORMATION info;
   if (!GetFileInformationByHandle(h, &info))
-    return set_errno();
+    return -1;
   buf->st_dev = info.dwVolumeSerialNumber;
   memcpy(&buf->st_ino.id[0], &info.nFileIndexHigh, 4);
   memcpy(&buf->st_ino.id[4], &info.nFileIndexLow, 4);
   return 0;
 }
 
 inline int stat_file(const wchar_t *path, StatT *buf, DWORD flags) {
   WinHandle h(path, FILE_READ_ATTRIBUTES, flags);
   if (!h)
-    return set_errno();
+    return -1;
   int ret = stat_handle(h, buf);
   return ret;
 }
 
 inline int stat(const wchar_t *path, StatT *buf) { return stat_file(path, buf, 0); }
 
 inline int lstat(const wchar_t *path, StatT *buf) {
   return stat_file(path, buf, FILE_FLAG_OPEN_REPARSE_POINT);
 }
 
 inline int fstat(int fd, StatT *buf) {
   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
   return stat_handle(h, buf);
 }
 
 inline int mkdir(const wchar_t *path, int permissions) {
   (void)permissions;
   if (!CreateDirectoryW(path, nullptr))
-    return set_errno();
+    return -1;
   return 0;
 }
 
 inline int symlink_file_dir(const wchar_t *oldname, const wchar_t *newname,
                             bool is_dir) {
   path dest(oldname);
   dest.make_preferred();
   oldname = dest.c_str();
   DWORD flags = is_dir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
   if (CreateSymbolicLinkW(newname, oldname,
                           flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE))
     return 0;
   int e = GetLastError();
   if (e != ERROR_INVALID_PARAMETER)
-    return set_errno(e);
+    return -1;
   if (CreateSymbolicLinkW(newname, oldname, flags))
     return 0;
-  return set_errno();
+  return -1;
 }
 
 inline int symlink_file(const wchar_t *oldname, const wchar_t *newname) {
   return symlink_file_dir(oldname, newname, false);
 }
 
 inline int symlink_dir(const wchar_t *oldname, const wchar_t *newname) {
   return symlink_file_dir(oldname, newname, true);
 }
 
 inline int link(const wchar_t *oldname, const wchar_t *newname) {
   if (CreateHardLinkW(newname, oldname, nullptr))
     return 0;
-  return set_errno();
+  return -1;
 }
 
 inline int remove(const wchar_t *path) {
   detail::WinHandle h(path, DELETE, FILE_FLAG_OPEN_REPARSE_POINT);
   if (!h)
-    return set_errno();
+    return -1;
   FILE_DISPOSITION_INFO info;
   info.DeleteFile = TRUE;
   if (!SetFileInformationByHandle(h, FileDispositionInfo, &info, sizeof(info)))
-    return set_errno();
+    return -1;
   return 0;
 }
 
 inline int truncate_handle(HANDLE h, off_t length) {
   LARGE_INTEGER size_param;
   size_param.QuadPart = length;
   if (!SetFilePointerEx(h, size_param, 0, FILE_BEGIN))
-    return set_errno();
+    return -1;
   if (!SetEndOfFile(h))
-    return set_errno();
+    return -1;
   return 0;
 }
 
 inline int ftruncate(int fd, off_t length) {
   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
   return truncate_handle(h, length);
 }
 
 inline int truncate(const wchar_t *path, off_t length) {
   detail::WinHandle h(path, GENERIC_WRITE, 0);
   if (!h)
-    return set_errno();
+    return -1;
   return truncate_handle(h, length);
 }
 
 inline int rename(const wchar_t *from, const wchar_t *to) {
   if (!(MoveFileExW(from, to,
                     MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING |
                         MOVEFILE_WRITE_THROUGH)))
-    return set_errno();
+    return -1;
   return 0;
 }
 
 inline int chdir(const wchar_t* path) {
   if (!SetCurrentDirectoryW(path))
-    return set_errno();
+    return -1;
   return 0;
 }
 
 struct StatVFS {
   uint64_t f_frsize;
   uint64_t f_blocks;
   uint64_t f_bfree;
   uint64_t f_bavail;
 };
 
 inline int statvfs(const wchar_t *p, StatVFS *buf) {
   path dir = p;
   while (true) {
     error_code local_ec;
     const file_status st = status(dir, local_ec);
     if (!exists(st) || is_directory(st))
       break;
     path parent = dir.parent_path();
     if (parent == dir) {
-      errno = ENOENT;
+      SetLastError(ERROR_PATH_NOT_FOUND);
       return -1;
     }
     dir = parent;
   }
   ULARGE_INTEGER free_bytes_available_to_caller, total_number_of_bytes,
       total_number_of_free_bytes;
   if (!GetDiskFreeSpaceExW(dir.c_str(), &free_bytes_available_to_caller,
                            &total_number_of_bytes, &total_number_of_free_bytes))
-    return set_errno();
+    return -1;
   buf->f_frsize = 1;
   buf->f_blocks = total_number_of_bytes.QuadPart;
   buf->f_bfree = total_number_of_free_bytes.QuadPart;
   buf->f_bavail = free_bytes_available_to_caller.QuadPart;
   return 0;
 }
 
 inline wchar_t* getcwd([[maybe_unused]] wchar_t* in_buf, [[maybe_unused]] size_t in_size) {
   // Only expected to be used with us allocating the buffer.
   _LIBCPP_ASSERT(in_buf == nullptr, "Windows getcwd() assumes in_buf==nullptr");
   _LIBCPP_ASSERT(in_size == 0, "Windows getcwd() assumes in_size==0");
 
   size_t buff_size = MAX_PATH + 10;
   std::unique_ptr<wchar_t, decltype(&::free)> buff(static_cast<wchar_t*>(malloc(buff_size * sizeof(wchar_t))), &::free);
   DWORD retval = GetCurrentDirectoryW(buff_size, buff.get());
   if (retval > buff_size) {
     buff_size = retval;
     buff.reset(static_cast<wchar_t*>(malloc(buff_size * sizeof(wchar_t))));
     retval = GetCurrentDirectoryW(buff_size, buff.get());
   }
   if (!retval) {
-    set_errno();
     return nullptr;
   }
   return buff.release();
 }
 
 inline wchar_t *realpath(const wchar_t *path, [[maybe_unused]] wchar_t *resolved_name) {
   // Only expected to be used with us allocating the buffer.
   _LIBCPP_ASSERT_UNCATEGORIZED(resolved_name == nullptr,
                  "Windows realpath() assumes a null resolved_name");
 
   WinHandle h(path, FILE_READ_ATTRIBUTES, 0);
   if (!h) {
-    set_errno();
     return nullptr;
   }
   size_t buff_size = MAX_PATH + 10;
   std::unique_ptr<wchar_t, decltype(&::free)> buff(
       static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))), &::free);
   DWORD retval = GetFinalPathNameByHandleW(
       h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
   if (retval > buff_size) {
     buff_size = retval;
     buff.reset(static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))));
     retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size,
                                        FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
   }
   if (!retval) {
-    set_errno();
     return nullptr;
   }
   wchar_t *ptr = buff.get();
   if (!wcsncmp(ptr, L"\\\\?\\", 4)) {
     if (ptr[5] == ':') { // \\?\X: -> X:
       memmove(&ptr[0], &ptr[4], (wcslen(&ptr[4]) + 1) * sizeof(wchar_t));
     } else if (!wcsncmp(&ptr[4], L"UNC\\", 4)) { // \\?\UNC\server -> \\server
       wcscpy(&ptr[0], L"\\\\");
       memmove(&ptr[2], &ptr[8], (wcslen(&ptr[8]) + 1) * sizeof(wchar_t));
     }
   }
   return buff.release();
 }
 
 #define AT_FDCWD -1
 #define AT_SYMLINK_NOFOLLOW 1
 using ModeT = int;
 
 inline int fchmod_handle(HANDLE h, int perms) {
   FILE_BASIC_INFO basic;
   if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
-    return set_errno();
+    return -1;
   DWORD orig_attributes = basic.FileAttributes;
   basic.FileAttributes &= ~FILE_ATTRIBUTE_READONLY;
   if ((perms & 0222) == 0)
     basic.FileAttributes |= FILE_ATTRIBUTE_READONLY;
   if (basic.FileAttributes != orig_attributes &&
       !SetFileInformationByHandle(h, FileBasicInfo, &basic, sizeof(basic)))
-    return set_errno();
+    return -1;
   return 0;
 }
 
 inline int fchmodat(int /*fd*/, const wchar_t *path, int perms, int flag) {
   DWORD attributes = GetFileAttributesW(path);
   if (attributes == INVALID_FILE_ATTRIBUTES)
-    return set_errno();
+    return -1;
   if (attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
       !(flag & AT_SYMLINK_NOFOLLOW)) {
     // If the file is a symlink, and we are supposed to operate on the target
     // of the symlink, we need to open a handle to it, without the
     // FILE_FLAG_OPEN_REPARSE_POINT flag, to open the destination of the
     // symlink, and operate on it via the handle.
     detail::WinHandle h(path, FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, 0);
     if (!h)
-      return set_errno();
+      return -1;
     return fchmod_handle(h, perms);
   } else {
     // For a non-symlink, or if operating on the symlink itself instead of
     // its target, we can use SetFileAttributesW, saving a few calls.
     DWORD orig_attributes = attributes;
     attributes &= ~FILE_ATTRIBUTE_READONLY;
     if ((perms & 0222) == 0)
       attributes |= FILE_ATTRIBUTE_READONLY;
     if (attributes != orig_attributes && !SetFileAttributesW(path, attributes))
-      return set_errno();
+      return -1;
   }
   return 0;
 }
 
 inline int fchmod(int fd, int perms) {
   HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
   return fchmod_handle(h, perms);
 }
 
 #define MAX_SYMLINK_SIZE MAXIMUM_REPARSE_DATA_BUFFER_SIZE
 using SSizeT = ::int64_t;
 
 inline SSizeT readlink(const wchar_t *path, wchar_t *ret_buf, size_t bufsize) {
   uint8_t buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
   detail::WinHandle h(path, FILE_READ_ATTRIBUTES, FILE_FLAG_OPEN_REPARSE_POINT);
   if (!h)
-    return set_errno();
+    return -1;
   DWORD out;
   if (!DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, nullptr, 0, buf, sizeof(buf),
                        &out, 0))
-    return set_errno();
+    return -1;
   const auto *reparse = reinterpret_cast<LIBCPP_REPARSE_DATA_BUFFER *>(buf);
   size_t path_buf_offset = offsetof(LIBCPP_REPARSE_DATA_BUFFER,
                                     SymbolicLinkReparseBuffer.PathBuffer[0]);
   if (out < path_buf_offset) {
-    errno = EINVAL;
+    SetLastError(ERROR_REPARSE_TAG_INVALID);
     return -1;
   }
   if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
-    errno = EINVAL;
+    SetLastError(ERROR_REPARSE_TAG_INVALID);
     return -1;
   }
   const auto &symlink = reparse->SymbolicLinkReparseBuffer;
   unsigned short name_offset, name_length;
   if (symlink.PrintNameLength == 0) {
     name_offset = symlink.SubstituteNameOffset;
     name_length = symlink.SubstituteNameLength;
   } else {
     name_offset = symlink.PrintNameOffset;
     name_length = symlink.PrintNameLength;
   }
   // name_offset/length are expressed in bytes, not in wchar_t
   if (path_buf_offset + name_offset + name_length > out) {
-    errno = EINVAL;
+    SetLastError(ERROR_REPARSE_TAG_INVALID);
     return -1;
   }
   if (name_length / sizeof(wchar_t) > bufsize) {
-    errno = ENOMEM;
+    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
     return -1;
   }
   memcpy(ret_buf, &symlink.PathBuffer[name_offset / sizeof(wchar_t)],
          name_length);
   return name_length / sizeof(wchar_t);
 }
 
 #else

libcxx/src/system_error.cpp

 #   define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS
 #endif
 
 #include <__assert>
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <string>
+#include <optional>
 #include <string.h>
+#include <string>
 #include <system_error>
 
 #include "include/config_elast.h"
 
 #if defined(__ANDROID__)
 #include <android/api-level.h>
 #endif
 
+#if defined(_LIBCPP_WIN32API)
+#  include <windows.h>
+#  include <winerror.h>
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if defined(_LIBCPP_WIN32API)
+
+namespace {
+std::optional<errc> __win_err_to_errc(int err) {
+  constexpr struct {
+    int win;
+    errc errc;
+  } win_error_mapping[] = {
+      {ERROR_ACCESS_DENIED, errc::permission_denied},
+      {ERROR_ALREADY_EXISTS, errc::file_exists},
+      {ERROR_BAD_NETPATH, errc::no_such_file_or_directory},
+      {ERROR_BAD_PATHNAME, errc::no_such_file_or_directory},
+      {ERROR_BAD_UNIT, errc::no_such_device},
+      {ERROR_BROKEN_PIPE, errc::broken_pipe},
+      {ERROR_BUFFER_OVERFLOW, errc::filename_too_long},
+      {ERROR_BUSY, errc::device_or_resource_busy},
+      {ERROR_BUSY_DRIVE, errc::device_or_resource_busy},
+      {ERROR_CANNOT_MAKE, errc::permission_denied},
+      {ERROR_CANTOPEN, errc::io_error},
+      {ERROR_CANTREAD, errc::io_error},
+      {ERROR_CANTWRITE, errc::io_error},
+      {ERROR_CURRENT_DIRECTORY, errc::permission_denied},
+      {ERROR_DEV_NOT_EXIST, errc::no_such_device},
+      {ERROR_DEVICE_IN_USE, errc::device_or_resource_busy},
+      {ERROR_DIR_NOT_EMPTY, errc::directory_not_empty},
+      {ERROR_DIRECTORY, errc::invalid_argument},
+      {ERROR_DISK_FULL, errc::no_space_on_device},
+      {ERROR_FILE_EXISTS, errc::file_exists},
+      {ERROR_FILE_NOT_FOUND, errc::no_such_file_or_directory},
+      {ERROR_HANDLE_DISK_FULL, errc::no_space_on_device},
+      {ERROR_INVALID_ACCESS, errc::permission_denied},
+      {ERROR_INVALID_DRIVE, errc::no_such_device},
+      {ERROR_INVALID_FUNCTION, errc::function_not_supported},
+      {ERROR_INVALID_HANDLE, errc::invalid_argument},
+      {ERROR_INVALID_NAME, errc::no_such_file_or_directory},
+      {ERROR_INVALID_PARAMETER, errc::invalid_argument},
+      {ERROR_LOCK_VIOLATION, errc::no_lock_available},
+      {ERROR_LOCKED, errc::no_lock_available},
+      {ERROR_NEGATIVE_SEEK, errc::invalid_argument},
+      {ERROR_NOACCESS, errc::permission_denied},
+      {ERROR_NOT_ENOUGH_MEMORY, errc::not_enough_memory},
+      {ERROR_NOT_READY, errc::resource_unavailable_try_again},
+      {ERROR_NOT_SAME_DEVICE, errc::cross_device_link},
+      {ERROR_NOT_SUPPORTED, errc::not_supported},
+      {ERROR_OPEN_FAILED, errc::io_error},
+      {ERROR_OPEN_FILES, errc::device_or_resource_busy},
+      {ERROR_OPERATION_ABORTED, errc::operation_canceled},
+      {ERROR_OUTOFMEMORY, errc::not_enough_memory},
+      {ERROR_PATH_NOT_FOUND, errc::no_such_file_or_directory},
+      {ERROR_READ_FAULT, errc::io_error},
+      {ERROR_REPARSE_TAG_INVALID, errc::invalid_argument},
+      {ERROR_RETRY, errc::resource_unavailable_try_again},
+      {ERROR_SEEK, errc::io_error},
+      {ERROR_SHARING_VIOLATION, errc::permission_denied},
+      {ERROR_TOO_MANY_OPEN_FILES, errc::too_many_files_open},
+      {ERROR_WRITE_FAULT, errc::io_error},
+      {ERROR_WRITE_PROTECT, errc::permission_denied},
+  };
+
+  for (const auto& pair : win_error_mapping)
+    if (pair.win == err)
+      return pair.errc;
+  return {};
+}
+} // namespace
+#endif
+
 // class error_category
 
 #if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
 error_category::error_category() noexcept
 {
 }
 #endif
 

 __system_error_category::name() const noexcept
 {
     return "system";
 }
 
 string
 __system_error_category::message(int ev) const
 {
-#ifdef _LIBCPP_ELAST
+#ifdef _LIBCPP_WIN32API
+    std::string result;
+    char* str               = nullptr;
+    unsigned long num_chars = FormatMessageA(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+        nullptr,
+        ev,
+        0,
+        reinterpret_cast<char*>(&str),
+        0,
+        nullptr);
+    auto is_whitespace = [](char ch) { return ch == '\n' || ch == '\r' || ch == ' '; };
+    while (num_chars > 0 && is_whitespace(str[num_chars - 1]))
+      --num_chars;
+
+    if (num_chars)
+      result = std::string(str, num_chars);
+    else
+      result = "Unknown error";
+
+    LocalFree(str);
+    return result;
+#else
+#  ifdef _LIBCPP_ELAST
     if (ev > _LIBCPP_ELAST)
       return string("unspecified system_category error");
-#endif // _LIBCPP_ELAST
+#  endif // _LIBCPP_ELAST
     return __do_message::message(ev);
+#endif
 }
 
 error_condition
 __system_error_category::default_error_condition(int ev) const noexcept
 {
-#ifdef _LIBCPP_ELAST
+#ifdef _LIBCPP_WIN32API
+    // Remap windows error codes to generic error codes if possible.
+    if (ev == 0)
+      return error_condition(0, generic_category());
+    if (auto maybe_errc = __win_err_to_errc(ev))
+      return error_condition(static_cast<int>(maybe_errc.value()), generic_category());
+    return error_condition(ev, system_category());
+#else
+#  ifdef _LIBCPP_ELAST
     if (ev > _LIBCPP_ELAST)
       return error_condition(ev, system_category());
-#endif // _LIBCPP_ELAST
+#  endif // _LIBCPP_ELAST
     return error_condition(ev, generic_category());
+#endif
 }
 
 const error_category&
 system_category() noexcept
 {
     static __system_error_category s;
     return s;
 }

 system_error::~system_error() noexcept
 {
 }
 
 void
 __throw_system_error(int ev, const char* what_arg)
 {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw system_error(error_code(ev, system_category()), what_arg);
+    throw system_error(error_code(ev, generic_category()), what_arg);
 #else
     (void)ev;
     (void)what_arg;
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/std/diagnostics/syserr/syserr.compare/eq_error_code_error_code.pass.cpp

 // bool operator!=(const error_condition& lhs, const error_code&      rhs);
 // bool operator!=(const error_condition& lhs, const error_condition& rhs);
 
 #include <system_error>
 #include <cassert>
 
 #include "test_macros.h"
 
+#ifndef _WIN32
+#  define TEST_SYSTEM_CATEGORY_IS_GENERIC_CATEGORY
+#endif
+
 int main(int, char**)
 {
     std::error_code e_code1(5, std::generic_category());
     std::error_code e_code2(5, std::system_category());
     std::error_code e_code3(6, std::generic_category());
     std::error_code e_code4(6, std::system_category());
     std::error_condition e_condition1(5, std::generic_category());
     std::error_condition e_condition2(5, std::system_category());
     std::error_condition e_condition3(6, std::generic_category());
     std::error_condition e_condition4(6, std::system_category());
 
     assert(e_code1 == e_code1);
     assert(e_code1 != e_code2);
     assert(e_code1 != e_code3);
     assert(e_code1 != e_code4);
     assert(e_code1 == e_condition1);
     assert(e_code1 != e_condition2);
     assert(e_code1 != e_condition3);
     assert(e_code1 != e_condition4);
 
     assert(e_code2 != e_code1);
     assert(e_code2 == e_code2);
     assert(e_code2 != e_code3);
     assert(e_code2 != e_code4);
-    assert(e_code2 == e_condition1);  // ?
+#ifdef TEST_SYSTEM_CATEGORY_IS_GENERIC_CATEGORY
+    assert(e_code2 == e_condition1);
+#endif
     assert(e_code2 == e_condition2);
     assert(e_code2 != e_condition3);
     assert(e_code2 != e_condition4);
 
     assert(e_code3 != e_code1);
     assert(e_code3 != e_code2);
     assert(e_code3 == e_code3);
     assert(e_code3 != e_code4);
     assert(e_code3 != e_condition1);
     assert(e_code3 != e_condition2);
     assert(e_code3 == e_condition3);
     assert(e_code3 != e_condition4);
 
     assert(e_code4 != e_code1);
     assert(e_code4 != e_code2);
     assert(e_code4 != e_code3);
     assert(e_code4 == e_code4);
     assert(e_code4 != e_condition1);
     assert(e_code4 != e_condition2);
+#ifdef TEST_SYSTEM_CATEGORY_IS_GENERIC_CATEGORY
     assert(e_code4 == e_condition3);  // ?
+#endif
     assert(e_code4 == e_condition4);
 
     assert(e_condition1 == e_code1);
+#ifdef TEST_SYSTEM_CATEGORY_IS_GENERIC_CATEGORY
     assert(e_condition1 == e_code2);  // ?
+#endif
     assert(e_condition1 != e_code3);
     assert(e_condition1 != e_code4);
     assert(e_condition1 == e_condition1);
     assert(e_condition1 != e_condition2);
     assert(e_condition1 != e_condition3);
     assert(e_condition1 != e_condition4);
 
     assert(e_condition2 != e_code1);
     assert(e_condition2 == e_code2);
     assert(e_condition2 != e_code3);
     assert(e_condition2 != e_code4);
     assert(e_condition2 != e_condition1);
     assert(e_condition2 == e_condition2);
     assert(e_condition2 != e_condition3);
     assert(e_condition2 != e_condition4);
 
     assert(e_condition3 != e_code1);
     assert(e_condition3 != e_code2);
     assert(e_condition3 == e_code3);
+#ifdef TEST_SYSTEM_CATEGORY_IS_GENERIC_CATEGORY
     assert(e_condition3 == e_code4);  // ?
+#endif
     assert(e_condition3 != e_condition1);
     assert(e_condition3 != e_condition2);
     assert(e_condition3 == e_condition3);
     assert(e_condition3 != e_condition4);
 
     assert(e_condition4 != e_code1);
     assert(e_condition4 != e_code2);
     assert(e_condition4 != e_code3);
     assert(e_condition4 == e_code4);
     assert(e_condition4 != e_condition1);
     assert(e_condition4 != e_condition2);
     assert(e_condition4 != e_condition3);
     assert(e_condition4 == e_condition4);
 
   return 0;
 }

libcxx/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.derived/message.pass.cpp

int main(int, char**)
     const std::error_category& e_cat1 = std::generic_category();
     const std::error_category& e_cat2 = std::system_category();
     std::string m1 = e_cat1.message(5);
     std::string m2 = e_cat2.message(5);
     std::string m3 = e_cat2.message(6);
     assert(!m1.empty());
     assert(!m2.empty());
     assert(!m3.empty());
+#ifndef _WIN32
+    // On windows, system_category is distinct.
     assert(m1 == m2);
-    assert(m1 != m3);
+#endif
+    assert(m2 != m3);
 
     return 0;
 }

libcxx/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp

 #endif
     assert(errno == E2BIG);
 }
 
 int main(int, char**)
 {
     const std::error_category& e_cat1 = std::system_category();
     std::error_condition e_cond = e_cat1.default_error_condition(5);
+#ifdef _WIN32
+    // Windows error 5 is ERROR_ACCESS_DENIED, which maps to generic code permission_denied.
+    assert(e_cond.value() == static_cast<int>(std::errc::permission_denied));
+#else
     assert(e_cond.value() == 5);
+#endif
     assert(e_cond.category() == std::generic_category());
+
     e_cond = e_cat1.default_error_condition(5000);
     assert(e_cond.value() == 5000);
     assert(e_cond.category() == std::system_category());
     {
         test_message_for_bad_value();
     }
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp

static void test_with_ec_dne() {
   for (auto p : {static_env.DNE, static_env.BadSymlink}) {
 
     directory_entry e(p);
     std::error_code status_ec = GetTestEC();
     std::error_code sym_status_ec = GetTestEC(1);
     file_status st = status(p, status_ec);
     file_status sym_st = symlink_status(p, sym_status_ec);
     std::error_code ec = GetTestEC(2);
-    auto CheckEC = [&](std::error_code const& other_ec) {
-      bool res = ec == other_ec;
+    auto CheckEC                  = [&](std::error_code const& other_ec) {
+      // We compare the canonicalized error_conditions for this case, because
+      // directory_entry may construct its own generic_category error when a
+      // file doesn't exist, instead of directly returning a system_category
+      // error.
+      bool res = ec.default_error_condition() == other_ec.default_error_condition();
       ec = GetTestEC(2);
       return res;
     };
 
     assert(e.exists(ec) == exists(st));
     assert(CheckEC(status_ec));
 
     assert(e.is_block_file(ec) == is_block_file(st));

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp

path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
                       static_env.DNE};
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     std::error_code pec = GetTestEC(), eec = GetTestEC(1);
     file_status ps = fs::status(p, pec);
     file_status es = e.status(eec);
     assert(ps.type() == es.type());
     assert(ps.permissions() == es.permissions());
-    assert(pec == eec);
+    assert(pec.default_error_condition() == eec.default_error_condition());
   }
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     file_status ps = fs::status(p);
     file_status es = e.status();
     assert(ps.type() == es.type());
     assert(ps.permissions() == es.permissions());
   }
 }
 
 int main(int, char**) {
   test_basic();
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp

path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
                       static_env.DNE};
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     std::error_code pec = GetTestEC(), eec = GetTestEC(1);
     file_status ps = fs::symlink_status(p, pec);
     file_status es = e.symlink_status(eec);
     assert(ps.type() == es.type());
     assert(ps.permissions() == es.permissions());
-    assert(pec == eec);
+    assert(pec.default_error_condition() == eec.default_error_condition());
   }
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     file_status ps = fs::symlink_status(p);
     file_status es = e.symlink_status();
     assert(ps.type() == es.type());
     assert(ps.permissions() == es.permissions());
   }
 }
 
 int main(int, char**) {
   test_signature();
   return 0;
 }

libcxx/test/support/filesystem_test_helper.h

explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err,
                             const char* fun_name, std::string opt_msg = {})
       : expected_err(first_err), expected_path1(p1), expected_path2(p2),
         num_paths(2), func_name(fun_name), opt_message(opt_msg) {}
 
   void operator()(fs::filesystem_error const& Err) {
     assert(ErrorIsImp(Err.code(), {expected_err}));
     assert(Err.path1() == expected_path1);
     assert(Err.path2() == expected_path2);
+#ifndef _WIN32
+    // On Windows, the error strings are windows error code strings, and don't
+    // match textually with the strings generated for generic std::errc::*.
     LIBCPP_ONLY(check_libcxx_string(Err));
+#endif
   }
 
   void check_libcxx_string(fs::filesystem_error const& Err) {
     std::string message = std::make_error_code(expected_err).message();
 
     std::string additional_msg = "";
     if (!opt_message.empty()) {
       additional_msg = opt_message + ": ";