[libc++] Avoid including things that require a filesystem in filesytem_clock.cpp

[ldionne]

Summary

The filesystem clock implementation should be available regardless of
whether a proper filesystem is available on the platform, so it makes
sense to try and avoid including things that are inherently filesystem-y
in the implementation of filesystem clock.

[ldionne]

Fix Windows issue.

[michaelplatings]

With these changes, copied from chrono.cpp, this patch fixes building with picolibc.

libcxx/src/filesystem/filesystem_clock.cpp

22–24

39

[ldionne]

In D154390#4471924, @michaelplatings wrote:

With these changes, copied from chrono.cpp, this patch fixes building with picolibc.

Ok, thanks a lot. But just to be sure, this wasn't working previously with picolibc, was it? Or did it start failing only when I split up the source files?

[ldionne]

I'll ship this as-is because it passes the CI and it makes sense as a self-standing change. I'll apply your suggested changes in another patch, I'll ping you.

[ldionne]

See D154457.

[michaelplatings]

In D154390#4471948, @ldionne wrote:

Ok, thanks a lot. But just to be sure, this wasn't working previously with picolibc, was it? Or did it start failing only when I split up the source files?

The picolibc build was working previously and started failing after D152382 landed. D154457 fixes it, thanks!

libcxx/src/filesystem/file_descriptor.h

 #include <cstdint>
 #include <filesystem>
 #include <string_view>
 #include <system_error>
 #include <utility>
 
 #include "error.h"
 #include "posix_compat.h"
+#include "time_utils.h"
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 #else
 # include <dirent.h>   // for DIR & friends
 # include <fcntl.h>    // values for fchmodat

libcxx/src/filesystem/filesystem_clock.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
 #include <chrono>
 #include <filesystem>
 #include <time.h>
 
-#include "posix_compat.h" // TimeSpec
+#include "time_utils.h"
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 #endif
 
 #if !defined(CLOCK_REALTIME) && !defined(_LIBCPP_WIN32API)
 # include <sys/time.h> // for gettimeofday and timeval
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 const bool _FilesystemClock::is_steady;
 
 _FilesystemClock::time_point _FilesystemClock::now() noexcept {
   typedef chrono::duration<rep> __secs;
 #if defined(_LIBCPP_WIN32API)
   typedef chrono::duration<rep, nano> __nsecs;
   FILETIME time;
   GetSystemTimeAsFileTime(&time);
   detail::TimeSpec tp = detail::filetime_to_timespec(time);
   return time_point(__secs(tp.tv_sec) +
                     chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
 #elif defined(CLOCK_REALTIME)
   typedef chrono::duration<rep, nano> __nsecs;
   struct timespec tp;
   if (0 != clock_gettime(CLOCK_REALTIME, &tp))
     __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
   return time_point(__secs(tp.tv_sec) +
                     chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
 #else
   typedef chrono::duration<rep, micro> __microsecs;
   timeval tv;
   gettimeofday(&tv, 0);
   return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
 #endif // CLOCK_REALTIME
 }
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM

libcxx/src/filesystem/posix_compat.h

 #ifndef POSIX_COMPAT_H
 #define POSIX_COMPAT_H
 
 #include <__assert>
 #include <__config>
 #include <filesystem>
 
 #include "error.h"
+#include "time_utils.h"
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 # include <io.h>
 # include <winioctl.h>
 #else

 };
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 namespace detail {
 
 #if defined(_LIBCPP_WIN32API)
-// Various C runtime versions (UCRT, or the legacy msvcrt.dll used by
-// some mingw toolchains) provide different stat function implementations,
-// with a number of limitations with respect to what we want from the
-// stat function. Instead provide our own which does exactly what we want,
-// along with our own stat structure and flag macros.
-
-struct TimeSpec {
-  int64_t tv_sec;
-  int64_t tv_nsec;
-};
-struct StatT {
-  unsigned st_mode;
-  TimeSpec st_atim;
-  TimeSpec st_mtim;
-  uint64_t st_dev; // FILE_ID_INFO::VolumeSerialNumber
-  struct FileIdStruct {
-    unsigned char id[16]; // FILE_ID_INFO::FileId
-    bool operator==(const FileIdStruct &other) const {
-      for (int i = 0; i < 16; i++)
-        if (id[i] != other.id[i])
-          return false;
-      return true;
-    }
-  } st_ino;
-  uint32_t st_nlink;
-  uintmax_t st_size;
-};
-
-#else
-using TimeSpec = struct timespec;
-using TimeVal = struct timeval;
-using StatT = struct stat;
-#endif
-
-#if defined(_LIBCPP_WIN32API)
 
 // Various C runtime header sets provide more or less of these. As we
 // provide our own implementation, undef all potential defines from the
 // C runtime headers and provide a complete set of macros of our own.
 
 #undef _S_IFMT
 #undef _S_IFDIR
 #undef _S_IFCHR

 #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
 
-
-// There were 369 years and 89 leap days from the Windows epoch
-// (1601) to the Unix epoch (1970).
-#define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
-
-inline TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
-  TimeSpec ret;
-  ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
-  ret.tv_nsec = (li.QuadPart % 10000000) * 100;
-  return ret;
-}
-
-inline TimeSpec filetime_to_timespec(FILETIME ft) {
-  LARGE_INTEGER li;
-  li.LowPart = ft.dwLowDateTime;
-  li.HighPart = ft.dwHighDateTime;
-  return filetime_to_timespec(li);
-}
-
-inline FILETIME timespec_to_filetime(TimeSpec ts) {
-  LARGE_INTEGER li;
-  li.QuadPart =
-      ts.tv_nsec / 100 + (ts.tv_sec + FILE_TIME_OFFSET_SECS) * 10000000;
-  FILETIME ft;
-  ft.dwLowDateTime = li.LowPart;
-  ft.dwHighDateTime = li.HighPart;
-  return ft;
-}
-
 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) {

libcxx/src/filesystem/time_utils.h

 #include <limits>
 #include <ratio>
 #include <system_error>
 #include <type_traits>
 #include <utility>
 
 #include "error.h"
 #include "format_string.h"
-#include "posix_compat.h"
 
 #if defined(_LIBCPP_WIN32API)
 # define WIN32_LEAN_AND_MEAN
 # define NOMINMAX
 # include <windows.h>
 #else
+# include <fcntl.h>
+# include <sys/stat.h>
 # include <sys/time.h> // for ::utimes as used in __last_write_time
 #endif
 
 // We can use the presence of UTIME_OMIT to detect platforms that provide utimensat.
 #if defined(UTIME_OMIT)
 # define _LIBCPP_USE_UTIMENSAT
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 namespace detail {
 
+#if defined(_LIBCPP_WIN32API)
+// Various C runtime versions (UCRT, or the legacy msvcrt.dll used by
+// some mingw toolchains) provide different stat function implementations,
+// with a number of limitations with respect to what we want from the
+// stat function. Instead provide our own which does exactly what we want,
+// along with our own stat structure and flag macros.
+
+struct TimeSpec {
+  int64_t tv_sec;
+  int64_t tv_nsec;
+};
+struct StatT {
+  unsigned st_mode;
+  TimeSpec st_atim;
+  TimeSpec st_mtim;
+  uint64_t st_dev; // FILE_ID_INFO::VolumeSerialNumber
+  struct FileIdStruct {
+    unsigned char id[16]; // FILE_ID_INFO::FileId
+    bool operator==(const FileIdStruct &other) const {
+      for (int i = 0; i < 16; i++)
+        if (id[i] != other.id[i])
+          return false;
+      return true;
+    }
+  } st_ino;
+  uint32_t st_nlink;
+  uintmax_t st_size;
+};
+
+// There were 369 years and 89 leap days from the Windows epoch
+// (1601) to the Unix epoch (1970).
+#define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
+
+inline TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
+  TimeSpec ret;
+  ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
+  ret.tv_nsec = (li.QuadPart % 10000000) * 100;
+  return ret;
+}
+
+inline TimeSpec filetime_to_timespec(FILETIME ft) {
+  LARGE_INTEGER li;
+  li.LowPart = ft.dwLowDateTime;
+  li.HighPart = ft.dwHighDateTime;
+  return filetime_to_timespec(li);
+}
+
+inline FILETIME timespec_to_filetime(TimeSpec ts) {
+  LARGE_INTEGER li;
+  li.QuadPart =
+      ts.tv_nsec / 100 + (ts.tv_sec + FILE_TIME_OFFSET_SECS) * 10000000;
+  FILETIME ft;
+  ft.dwLowDateTime = li.LowPart;
+  ft.dwHighDateTime = li.HighPart;
+  return ft;
+}
+
+#else
+using TimeSpec = struct timespec;
+using TimeVal = struct timeval;
+using StatT = struct stat;
+
+inline TimeVal make_timeval(TimeSpec const& ts) {
+  using namespace chrono;
+  auto Convert = [](long nsec) {
+    using int_type = decltype(std::declval<TimeVal>().tv_usec);
+    auto dur = duration_cast<microseconds>(nanoseconds(nsec)).count();
+    return static_cast<int_type>(dur);
+  };
+  TimeVal TV = {};
+  TV.tv_sec = ts.tv_sec;
+  TV.tv_usec = Convert(ts.tv_nsec);
+  return TV;
+}
+#endif
+
 using chrono::duration;
 using chrono::duration_cast;
 
 template <class FileTimeT, class TimeT,
           bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
 struct time_util_base {
   using rep = typename FileTimeT::rep;
   using fs_duration = typename FileTimeT::duration;
inline TimeSpec extract_atime(StatT const& st) {
   TimeSpec TS = {st.st_atime, st.st_atime_n};
   return TS;
 }
 #else
 inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
 inline TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
 #endif
 
-#if !defined(_LIBCPP_WIN32API)
-inline TimeVal make_timeval(TimeSpec const& ts) {
-  using namespace chrono;
-  auto Convert = [](long nsec) {
-    using int_type = decltype(std::declval<TimeVal>().tv_usec);
-    auto dur = duration_cast<microseconds>(nanoseconds(nsec)).count();
-    return static_cast<int_type>(dur);
-  };
-  TimeVal TV = {};
-  TV.tv_sec = ts.tv_sec;
-  TV.tv_usec = Convert(ts.tv_nsec);
-  return TV;
-}
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
 
+#if !defined(_LIBCPP_WIN32API)
 inline bool posix_utimes(const path& p, std::array<TimeSpec, 2> const& TS,
                   error_code& ec) {
   TimeVal ConvertedTS[2] = {make_timeval(TS[0]), make_timeval(TS[1])};
   if (::utimes(p.c_str(), ConvertedTS) == -1) {
     ec = capture_errno();
     return true;
   }
   return false;
inline file_time_type __extract_last_write_time(const path& p, const StatT& st,
 
   auto ts = detail::extract_mtime(st);
   if (!fs_time::is_representable(ts))
     return err.report(errc::value_too_large);
 
   return fs_time::convert_from_timespec(ts);
 }
 
+#endif // !_LIBCPP_HAS_NO_FILESYSTEM
+
 } // end namespace detail
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // FILESYSTEM_TIME_UTILS_H