[libcxx] r337960 - [libc++] Use __int128_t to represent file_time_type.
Eric Fiselier via cfe-commits
cfe-commits at lists.llvm.org
Wed Jul 25 19:42:51 PDT 2018
Looks like macOS 10.11 only supports a resolution of seconds, but I can't
find documentation confirming that.
I'll adjust the test.
/Eric
On Wed, Jul 25, 2018 at 8:33 PM Alex L <arphaman at gmail.com> wrote:
> Looks like 'SupportsNanosecondRoundTrip' is set to 0.
>
> On 25 July 2018 at 19:30, Alex L <arphaman at gmail.com> wrote:
>
>> Sure,
>>
>> Standard Error:
>>
>> --
>>
>> PRIOR:3
>>
>> AFTER:0
>>
>>
>> Diff:
>>
>>
>> - return last_write_time(p) == ft;
>>
>> + std::cerr << "PRIOR:" << (long long)ft.time_since_epoch().count() <<
>> std::endl;
>>
>> + auto ft2 = last_write_time(p);
>>
>> + std::cerr << "AFTER:" << (long long)ft2.time_since_epoch().count()
>> << std::endl;
>>
>> + return ft2 == ft;
>>
>> On 25 July 2018 at 19:20, Eric Fiselier <eric at efcs.ca> wrote:
>>
>>> Could you tell me what the value of the initial time point, and the
>>> resulting one are on this line?
>>>
>>>
>>> https://github.com/llvm-mirror/libcxx/blob/master/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp#L224
>>>
>>> On Wed, Jul 25, 2018 at 8:17 PM Alex L <arphaman at gmail.com> wrote:
>>>
>>>> Please let me know if this information is helpful. If not, I'll mark
>>>> the test as UNSUPPORTED for darwin for the time being and will create an
>>>> internal issue to track the investigation into the OS-specific failure.
>>>> Cheers,
>>>> Alex
>>>>
>>>> On 25 July 2018 at 19:12, Alex L <arphaman at gmail.com> wrote:
>>>>
>>>>> I got the following output on an macOS10.11 machine:
>>>>>
>>>>> Exit Code: 1
>>>>>
>>>>> Standard Error:
>>>>>
>>>>> --
>>>>>
>>>>> Test Case = file, epoch_time
>>>>>
>>>>> 0
>>>>>
>>>>> 0
>>>>>
>>>>> Test Case = dir, epoch_time
>>>>>
>>>>> 0
>>>>>
>>>>> 0
>>>>>
>>>>> Test Case = file, future_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> 1532581924000000000
>>>>>
>>>>> 1532581924695307000
>>>>>
>>>>> Test Case = dir, future_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> 1532581924000000000
>>>>>
>>>>> 1532581924695307000
>>>>>
>>>>> Test Case = file, past_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> 1532570860000000000
>>>>>
>>>>> 1532570860695273000
>>>>>
>>>>> Test Case = dir, past_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> 1532570860000000000
>>>>>
>>>>> 1532570860695273000
>>>>>
>>>>> Test Case = file, before_epoch_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> -223000000000
>>>>>
>>>>> -222000017000
>>>>>
>>>>> Test Case = dir, before_epoch_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> -223000000000
>>>>>
>>>>> -222000017000
>>>>>
>>>>> Test Case = file, just_before_epoch_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> -1000000000
>>>>>
>>>>> -17000
>>>>>
>>>>> Test Case = dir, just_before_epoch_time
>>>>>
>>>>> In set_last_write_time_dynamic_env_test():455 Assertion
>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> -1000000000
>>>>>
>>>>> -17000
>>>>>
>>>>> In last_write_time_symlink_test():487 Assertion TEST_CHECK(got_time ==
>>>>> new_time) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> In last_write_time_symlink_test():489 Assertion
>>>>> TEST_CHECK(CompareTime(LastWriteTime(file), new_time)) failed.
>>>>>
>>>>> in file:
>>>>> /Users/local/llvm/projects/libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>>
>>>>> Summary for testsuite last_write_time_test_suite:
>>>>>
>>>>> 7 of 9 test cases passed.
>>>>>
>>>>> 88 of 98 assertions passed.
>>>>>
>>>>> 0 unsupported test cases.
>>>>>
>>>>> --
>>>>>
>>>>>
>>>>> Compiled test failed unexpectedly!
>>>>>
>>>>> ********************
>>>>>
>>>>> Testing Time: 4.43s
>>>>>
>>>>> ********************
>>>>>
>>>>> Failing Tests (1):
>>>>>
>>>>> libc++ ::
>>>>> std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>
>>>>>
>>>>> Unexpected Failures: 1
>>>>>
>>>>> On 25 July 2018 at 18:20, Eric Fiselier <eric at efcs.ca> wrote:
>>>>>
>>>>>> OK. I also added debug print statements to the test to give more
>>>>>> information. I'm just waiting for the bots to cycle now.
>>>>>>
>>>>>> On Wed, Jul 25, 2018 at 7:18 PM Alex L <arphaman at gmail.com> wrote:
>>>>>>
>>>>>>> I couldn't reproduce it on my machine, and I don't have access to
>>>>>>> the bot ATM, but I will try it on an older OS to see if it's an issue with
>>>>>>> the particular OS that's used on our bot.
>>>>>>>
>>>>>>> Cheers,
>>>>>>> Alex
>>>>>>>
>>>>>>> On 25 July 2018 at 17:43, Alex L <arphaman at gmail.com> wrote:
>>>>>>>
>>>>>>>> I'll take a look and will try to reproduce it right now.
>>>>>>>>
>>>>>>>> On 25 July 2018 at 17:37, Eric Fiselier <eric at efcs.ca> wrote:
>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> On Wed, Jul 25, 2018 at 6:03 PM Alex L <arphaman at gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> Hmm, looks like the added test is failing on Darwin even after
>>>>>>>>>> your fixes.
>>>>>>>>>>
>>>>>>>>>> Do you have an idea of why that could be?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Not yet, working on it now.
>>>>>>>>> I'm failing to reproduce it on my macbook though. If you can, any
>>>>>>>>> information about what's going on would be helpful.
>>>>>>>>> Like what are those actual values?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> http://lab.llvm.org:8080/green/job/libcxx_master_cmake/4784/testReport/junit/libc++/std_experimental_filesystem_fs_op_funcs_fs_op_last_write_time/last_write_time_pass_cpp/
>>>>>>>>>>
>>>>>>>>>> Compiled With:
>>>>>>>>>> ['/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++',
>>>>>>>>>> '-o',
>>>>>>>>>> '/Users/buildslave/jenkins/sharedspace/libcxx/build/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/Output/last_write_time.pass.cpp.o',
>>>>>>>>>> '-x', 'c++',
>>>>>>>>>> '/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp',
>>>>>>>>>> '-c', '-v', '-arch', 'x86_64', '-mmacosx-version-min=10.13',
>>>>>>>>>> '-D_LIBCPP_DISABLE_AVAILABILITY', '-ftemplate-depth=270',
>>>>>>>>>> '-Werror=thread-safety', '-std=c++11', '-include',
>>>>>>>>>> '/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/support/nasty_macros.hpp',
>>>>>>>>>> '-nostdinc++',
>>>>>>>>>> '-I/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/include',
>>>>>>>>>> '-I/Users/buildslave/jenkins/sharedspace/libcxx/build/include/c++build',
>>>>>>>>>> '-isysroot',
>>>>>>>>>> '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk',
>>>>>>>>>> '-I/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/support',
>>>>>>>>>> '-DLIBCXX_FILESYSTEM_STATIC_TEST_ROOT="/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/Inputs/static_test_env"',
>>>>>>>>>> '-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT="/Users/buildslave/jenkins/sharedspace/libcxx/build/test/filesystem/Output/dynamic_env"',
>>>>>>>>>> '-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER="/usr/local/opt/python at 2/bin/python2.7
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/support/filesystem_dynamic_test_helper.py"',
>>>>>>>>>> '-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER', '-Wall', '-Wextra', '-Werror',
>>>>>>>>>> '-Wuser-defined-warnings', '-Wshadow', '-Wno-unused-command-line-argument',
>>>>>>>>>> '-Wno-attributes', '-Wno-pessimizing-move', '-Wno-c++11-extensions',
>>>>>>>>>> '-Wno-user-defined-literals', '-Wno-noexcept-type',
>>>>>>>>>> '-Wno-aligned-allocation-unavailable', '-Wsign-compare',
>>>>>>>>>> '-Wunused-variable', '-Wunused-parameter', '-Wunreachable-code',
>>>>>>>>>> '-Wno-conversion', '-Wno-unused-local-typedef', '-c', '&&',
>>>>>>>>>> '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++',
>>>>>>>>>> '-o',
>>>>>>>>>> '/Users/buildslave/jenkins/sharedspace/libcxx/build/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/Output/last_write_time.pass.cpp.exe',
>>>>>>>>>> '/Users/buildslave/jenkins/sharedspace/libcxx/build/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/Output/last_write_time.pass.cpp.o',
>>>>>>>>>> '-v', '-arch', 'x86_64', '-mmacosx-version-min=10.13',
>>>>>>>>>> '-D_LIBCPP_DISABLE_AVAILABILITY', '-ftemplate-depth=270',
>>>>>>>>>> '-L/Users/buildslave/jenkins/sharedspace/libcxx/build/lib',
>>>>>>>>>> '-Wl,-rpath,/Users/buildslave/jenkins/sharedspace/libcxx/build/lib',
>>>>>>>>>> '-nodefaultlibs', '-lc++experimental', '-lc++', '-lSystem']
>>>>>>>>>> Command:
>>>>>>>>>> ['/Users/buildslave/jenkins/sharedspace/libcxx/build/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/Output/last_write_time.pass.cpp.exe']
>>>>>>>>>> Exit Code: 1
>>>>>>>>>> Standard Error:
>>>>>>>>>> --
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In last_write_time_symlink_test():477 Assertion
>>>>>>>>>> TEST_CHECK(got_time == new_time) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> In last_write_time_symlink_test():479 Assertion
>>>>>>>>>> TEST_CHECK(CompareTime(LastWriteTime(file), new_time)) failed.
>>>>>>>>>> in file:
>>>>>>>>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>
>>>>>>>>>> Summary for testsuite last_write_time_test_suite:
>>>>>>>>>> 7 of 9 test cases passed.
>>>>>>>>>> 78 of 88 assertions passed.
>>>>>>>>>> 0 unsupported test cases.
>>>>>>>>>> --
>>>>>>>>>>
>>>>>>>>>> Compiled test failed unexpectedly!
>>>>>>>>>>
>>>>>>>>>> Thanks,
>>>>>>>>>> Alex
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On 25 July 2018 at 17:00, Alex L <arphaman at gmail.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> Sure! Fixed it up in r337984.
>>>>>>>>>>>
>>>>>>>>>>> On 25 July 2018 at 15:03, Eric Fiselier <eric at efcs.ca> wrote:
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> On Wed, Jul 25, 2018 at 3:39 PM Alex L <arphaman at gmail.com>
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> Looks like this works:
>>>>>>>>>>>>>
>>>>>>>>>>>>> +++ b/src/experimental/filesystem/filesystem_common.h
>>>>>>>>>>>>> @@ -393,7 +393,7 @@ bool set_file_times(const path& p,
>>>>>>>>>>>>> std::array<TimeSpec, 2> const& TS,
>>>>>>>>>>>>> error_code& ec) {
>>>>>>>>>>>>> #if !defined(_LIBCPP_USE_UTIMENSAT)
>>>>>>>>>>>>> using namespace chrono;
>>>>>>>>>>>>> - auto Convert = [](long nsec) {
>>>>>>>>>>>>> + auto Convert = [](long nsec) ->
>>>>>>>>>>>>> decltype(std::declval<::timeval>().tv_usec) {
>>>>>>>>>>>>> return
>>>>>>>>>>>>> duration_cast<microseconds>(nanoseconds(nsec)).count();
>>>>>>>>>>>>> };
>>>>>>>>>>>>> struct ::timeval ConvertedTS[2] = {{TS[0].tv_sec,
>>>>>>>>>>>>> Convert(TS[0].tv_nsec)},
>>>>>>>>>>>>>
>>>>>>>>>>>>> I will commit this fix in a couple of minutes.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I think I would prefer an explicit cast to an implicit one
>>>>>>>>>>>> since the narrowing is intended, and should be safe.
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe:
>>>>>>>>>>>>
>>>>>>>>>>>> auto Convert [](long nsec) {
>>>>>>>>>>>> using int_type = decltype(::timeval::tv_usec);
>>>>>>>>>>>> auto dur =
>>>>>>>>>>>> duration_cast<microseconds>(nanoseconds(nsec)).count();
>>>>>>>>>>>> return static_cast<int_type>(dur);
>>>>>>>>>>>> };
>>>>>>>>>>>>
>>>>>>>>>>>> ?
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 25 July 2018 at 14:27, Eric Fiselier <eric at efcs.ca> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thanks. let me know if you want me to take over
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On Wed, Jul 25, 2018, 3:22 PM Alex L, <arphaman at gmail.com>
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 25 July 2018 at 13:51, Eric Fiselier via cfe-commits <
>>>>>>>>>>>>>>> cfe-commits at lists.llvm.org> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Author: ericwf
>>>>>>>>>>>>>>>> Date: Wed Jul 25 13:51:49 2018
>>>>>>>>>>>>>>>> New Revision: 337960
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project?rev=337960&view=rev
>>>>>>>>>>>>>>>> Log:
>>>>>>>>>>>>>>>> [libc++] Use __int128_t to represent file_time_type.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Summary:
>>>>>>>>>>>>>>>> The ``file_time_type`` time point is used to represent the
>>>>>>>>>>>>>>>> write times for files.
>>>>>>>>>>>>>>>> Its job is to act as part of a C++ wrapper for less ideal
>>>>>>>>>>>>>>>> system interfaces. The
>>>>>>>>>>>>>>>> underlying filesystem uses the ``timespec`` struct for the
>>>>>>>>>>>>>>>> same purpose.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> However, the initial implementation of ``file_time_type``
>>>>>>>>>>>>>>>> could not represent
>>>>>>>>>>>>>>>> either the range or resolution of ``timespec``, making it
>>>>>>>>>>>>>>>> unsuitable. Fixing
>>>>>>>>>>>>>>>> this requires an implementation which uses more than 64
>>>>>>>>>>>>>>>> bits to store the
>>>>>>>>>>>>>>>> time point.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I primarily considered two solutions: Using ``__int128_t``
>>>>>>>>>>>>>>>> and using a
>>>>>>>>>>>>>>>> arithmetic emulation of ``timespec``. Each has its pros and
>>>>>>>>>>>>>>>> cons, and both
>>>>>>>>>>>>>>>> come with more than one complication.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> However, after a lot of consideration, I decided on using
>>>>>>>>>>>>>>>> `__int128_t`. This patch implements that change.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Please see the [FileTimeType Design Document](
>>>>>>>>>>>>>>>> http://libcxx.llvm.org/docs/DesignDocs/FileTimeType.html)
>>>>>>>>>>>>>>>> for more information.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Reviewers: mclow.lists, ldionne, joerg, arthur.j.odwyer,
>>>>>>>>>>>>>>>> EricWF
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Reviewed By: EricWF
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Subscribers: christof, K-ballo, cfe-commits, BillyONeal
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Differential Revision: https://reviews.llvm.org/D49774
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Added:
>>>>>>>>>>>>>>>> libcxx/trunk/src/include/apple_availability.h
>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>> libcxx/trunk/include/experimental/filesystem
>>>>>>>>>>>>>>>> libcxx/trunk/src/chrono.cpp
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> libcxx/trunk/src/experimental/filesystem/filesystem_common.h
>>>>>>>>>>>>>>>> libcxx/trunk/src/experimental/filesystem/operations.cpp
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified: libcxx/trunk/include/experimental/filesystem
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/experimental/filesystem?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> --- libcxx/trunk/include/experimental/filesystem (original)
>>>>>>>>>>>>>>>> +++ libcxx/trunk/include/experimental/filesystem Wed Jul 25
>>>>>>>>>>>>>>>> 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -260,7 +260,37 @@ _LIBCPP_PUSH_MACROS
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -typedef chrono::time_point<std::chrono::system_clock>
>>>>>>>>>>>>>>>> file_time_type;
>>>>>>>>>>>>>>>> +struct _FilesystemClock {
>>>>>>>>>>>>>>>> +#if !defined(_LIBCPP_HAS_NO_INT128)
>>>>>>>>>>>>>>>> + typedef __int128_t rep;
>>>>>>>>>>>>>>>> + typedef nano period;
>>>>>>>>>>>>>>>> +#else
>>>>>>>>>>>>>>>> + typedef long long rep;
>>>>>>>>>>>>>>>> + typedef nano period;
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + typedef chrono::duration<rep, period> duration;
>>>>>>>>>>>>>>>> + typedef chrono::time_point<_FilesystemClock> time_point;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool
>>>>>>>>>>>>>>>> is_steady = false;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + _LIBCPP_FUNC_VIS static time_point now() noexcept;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + _LIBCPP_INLINE_VISIBILITY
>>>>>>>>>>>>>>>> + static time_t to_time_t(const time_point& __t) noexcept {
>>>>>>>>>>>>>>>> + typedef chrono::duration<rep> __secs;
>>>>>>>>>>>>>>>> + return time_t(
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> chrono::duration_cast<__secs>(__t.time_since_epoch()).count());
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + _LIBCPP_INLINE_VISIBILITY
>>>>>>>>>>>>>>>> + static time_point from_time_t(time_t __t) noexcept {
>>>>>>>>>>>>>>>> + typedef chrono::duration<rep> __secs;
>>>>>>>>>>>>>>>> + return time_point(__secs(__t));
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +typedef chrono::time_point<_FilesystemClock>
>>>>>>>>>>>>>>>> file_time_type;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> struct _LIBCPP_TYPE_VIS space_info
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified: libcxx/trunk/src/chrono.cpp
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/chrono.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> --- libcxx/trunk/src/chrono.cpp (original)
>>>>>>>>>>>>>>>> +++ libcxx/trunk/src/chrono.cpp Wed Jul 25 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -11,27 +11,10 @@
>>>>>>>>>>>>>>>> #include "cerrno" // errno
>>>>>>>>>>>>>>>> #include "system_error" // __throw_system_error
>>>>>>>>>>>>>>>> #include <time.h> // clock_gettime, CLOCK_MONOTONIC
>>>>>>>>>>>>>>>> and CLOCK_REALTIME
>>>>>>>>>>>>>>>> +#include "include/apple_availability.h"
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -#if (__APPLE__)
>>>>>>>>>>>>>>>> -#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >=
>>>>>>>>>>>>>>>> 100000
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>>>>>>>>> -#else
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> +#if !defined(__APPLE__)
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> #endif // __APPLE__
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> #if defined(_LIBCPP_WIN32API)
>>>>>>>>>>>>>>>> @@ -42,7 +25,7 @@
>>>>>>>>>>>>>>>> #include <winapifamily.h>
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>> #else
>>>>>>>>>>>>>>>> -#if !defined(CLOCK_REALTIME) ||
>>>>>>>>>>>>>>>> !defined(_LIBCXX_USE_CLOCK_GETTIME)
>>>>>>>>>>>>>>>> +#if !defined(CLOCK_REALTIME) ||
>>>>>>>>>>>>>>>> !defined(_LIBCPP_USE_CLOCK_GETTIME)
>>>>>>>>>>>>>>>> #include <sys/time.h> // for gettimeofday and
>>>>>>>>>>>>>>>> timeval
>>>>>>>>>>>>>>>> #endif // !defined(CLOCK_REALTIME)
>>>>>>>>>>>>>>>> #endif // defined(_LIBCPP_WIN32API)
>>>>>>>>>>>>>>>> @@ -92,16 +75,16 @@ system_clock::now() _NOEXCEPT
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> static_cast<__int64>(ft.dwLowDateTime)};
>>>>>>>>>>>>>>>> return time_point(duration_cast<duration>(d -
>>>>>>>>>>>>>>>> nt_to_unix_epoch));
>>>>>>>>>>>>>>>> #else
>>>>>>>>>>>>>>>> -#if defined(_LIBCXX_USE_CLOCK_GETTIME) &&
>>>>>>>>>>>>>>>> defined(CLOCK_REALTIME)
>>>>>>>>>>>>>>>> - struct timespec tp;
>>>>>>>>>>>>>>>> - if (0 != clock_gettime(CLOCK_REALTIME, &tp))
>>>>>>>>>>>>>>>> - __throw_system_error(errno,
>>>>>>>>>>>>>>>> "clock_gettime(CLOCK_REALTIME) failed");
>>>>>>>>>>>>>>>> - return time_point(seconds(tp.tv_sec) +
>>>>>>>>>>>>>>>> microseconds(tp.tv_nsec / 1000));
>>>>>>>>>>>>>>>> +#if defined(_LIBCPP_USE_CLOCK_GETTIME) &&
>>>>>>>>>>>>>>>> defined(CLOCK_REALTIME)
>>>>>>>>>>>>>>>> + struct timespec tp;
>>>>>>>>>>>>>>>> + if (0 != clock_gettime(CLOCK_REALTIME, &tp))
>>>>>>>>>>>>>>>> + __throw_system_error(errno,
>>>>>>>>>>>>>>>> "clock_gettime(CLOCK_REALTIME) failed");
>>>>>>>>>>>>>>>> + return time_point(seconds(tp.tv_sec) +
>>>>>>>>>>>>>>>> microseconds(tp.tv_nsec / 1000));
>>>>>>>>>>>>>>>> #else
>>>>>>>>>>>>>>>> timeval tv;
>>>>>>>>>>>>>>>> gettimeofday(&tv, 0);
>>>>>>>>>>>>>>>> return time_point(seconds(tv.tv_sec) +
>>>>>>>>>>>>>>>> microseconds(tv.tv_usec));
>>>>>>>>>>>>>>>> -#endif // _LIBCXX_USE_CLOCK_GETTIME && CLOCK_REALTIME
>>>>>>>>>>>>>>>> +#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> @@ -129,7 +112,7 @@ const bool steady_clock::is_steady;
>>>>>>>>>>>>>>>> #if defined(__APPLE__)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> // Darwin libc versions >= 1133 provide ns precision via
>>>>>>>>>>>>>>>> CLOCK_UPTIME_RAW
>>>>>>>>>>>>>>>> -#if defined(_LIBCXX_USE_CLOCK_GETTIME) &&
>>>>>>>>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>>>>>>>>> +#if defined(_LIBCPP_USE_CLOCK_GETTIME) &&
>>>>>>>>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>>>>>>>>> steady_clock::time_point
>>>>>>>>>>>>>>>> steady_clock::now() _NOEXCEPT
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> @@ -191,7 +174,7 @@ steady_clock::now() _NOEXCEPT
>>>>>>>>>>>>>>>> static FP fp = init_steady_clock();
>>>>>>>>>>>>>>>> return time_point(duration(fp()));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> -#endif // defined(_LIBCXX_USE_CLOCK_GETTIME) &&
>>>>>>>>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>>>>>>>>> +#endif // defined(_LIBCPP_USE_CLOCK_GETTIME) &&
>>>>>>>>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> #elif defined(_LIBCPP_WIN32API)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>> libcxx/trunk/src/experimental/filesystem/filesystem_common.h
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/experimental/filesystem/filesystem_common.h?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> ---
>>>>>>>>>>>>>>>> libcxx/trunk/src/experimental/filesystem/filesystem_common.h (original)
>>>>>>>>>>>>>>>> +++
>>>>>>>>>>>>>>>> libcxx/trunk/src/experimental/filesystem/filesystem_common.h Wed Jul 25
>>>>>>>>>>>>>>>> 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -23,33 +23,17 @@
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> #include <experimental/filesystem>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -#if (__APPLE__)
>>>>>>>>>>>>>>>> -#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101300
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >=
>>>>>>>>>>>>>>>> 110000
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 110000
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> -#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 40000
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>>>>>>>>> -#else
>>>>>>>>>>>>>>>> +#include "../../include/apple_availability.h"
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#if !defined(__APPLE__)
>>>>>>>>>>>>>>>> // We can use the presence of UTIME_OMIT to detect
>>>>>>>>>>>>>>>> platforms that provide
>>>>>>>>>>>>>>>> // utimensat.
>>>>>>>>>>>>>>>> #if defined(UTIME_OMIT)
>>>>>>>>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>> -#endif // __APPLE__
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> +#if !defined(_LIBCPP_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> #include <sys/time.h> // for ::utimes as used in
>>>>>>>>>>>>>>>> __last_write_time
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> @@ -212,76 +196,119 @@ private:
>>>>>>>>>>>>>>>> ErrorHandler& operator=(ErrorHandler const&) = delete;
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -namespace time_util {
>>>>>>>>>>>>>>>> +using chrono::duration;
>>>>>>>>>>>>>>>> +using chrono::duration_cast;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -using namespace chrono;
>>>>>>>>>>>>>>>> +using TimeSpec = struct ::timespec;
>>>>>>>>>>>>>>>> +using StatT = struct ::stat;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -template <class FileTimeT,
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT,
>>>>>>>>>>>>>>>> bool IsFloat = is_floating_point<typename
>>>>>>>>>>>>>>>> FileTimeT::rep>::value>
>>>>>>>>>>>>>>>> -struct fs_time_util_base {
>>>>>>>>>>>>>>>> - static constexpr seconds::rep max_seconds =
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> duration_cast<seconds>(FileTimeT::duration::max()).count();
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> - static constexpr nanoseconds::rep max_nsec =
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> duration_cast<nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>>>>>>>>> - seconds(max_seconds))
>>>>>>>>>>>>>>>> +struct time_util_base {
>>>>>>>>>>>>>>>> + using rep = typename FileTimeT::rep;
>>>>>>>>>>>>>>>> + using fs_duration = typename FileTimeT::duration;
>>>>>>>>>>>>>>>> + using fs_seconds = duration<rep>;
>>>>>>>>>>>>>>>> + using fs_nanoseconds = duration<rep, nano>;
>>>>>>>>>>>>>>>> + using fs_microseconds = duration<rep, micro>;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr rep max_seconds =
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr rep max_nsec =
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> fs_seconds(max_seconds))
>>>>>>>>>>>>>>>> .count();
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - static constexpr seconds::rep min_seconds =
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> duration_cast<seconds>(FileTimeT::duration::min()).count();
>>>>>>>>>>>>>>>> + static constexpr rep min_seconds =
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - static constexpr nanoseconds::rep min_nsec_timespec =
>>>>>>>>>>>>>>>> - duration_cast<nanoseconds>(
>>>>>>>>>>>>>>>> - (FileTimeT::duration::min() -
>>>>>>>>>>>>>>>> seconds(min_seconds)) + seconds(1))
>>>>>>>>>>>>>>>> + static constexpr rep min_nsec_timespec =
>>>>>>>>>>>>>>>> + duration_cast<fs_nanoseconds>(
>>>>>>>>>>>>>>>> + (FileTimeT::duration::min() -
>>>>>>>>>>>>>>>> fs_seconds(min_seconds)) +
>>>>>>>>>>>>>>>> + fs_seconds(1))
>>>>>>>>>>>>>>>> .count();
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> +private:
>>>>>>>>>>>>>>>> +#if _LIBCPP_STD_VER > 11
>>>>>>>>>>>>>>>> + static constexpr fs_duration get_min_nsecs() {
>>>>>>>>>>>>>>>> + return duration_cast<fs_duration>(
>>>>>>>>>>>>>>>> + fs_nanoseconds(min_nsec_timespec) -
>>>>>>>>>>>>>>>> + duration_cast<fs_nanoseconds>(fs_seconds(1)));
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> // Static assert that these values properly round trip.
>>>>>>>>>>>>>>>> - static_assert((seconds(min_seconds) +
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> duration_cast<microseconds>(nanoseconds(min_nsec_timespec))) -
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> duration_cast<microseconds>(seconds(1)) ==
>>>>>>>>>>>>>>>> + static_assert(fs_seconds(min_seconds) + get_min_nsecs()
>>>>>>>>>>>>>>>> ==
>>>>>>>>>>>>>>>> FileTimeT::duration::min(),
>>>>>>>>>>>>>>>> - "");
>>>>>>>>>>>>>>>> + "value doesn't roundtrip");
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr bool check_range() {
>>>>>>>>>>>>>>>> + // This kinda sucks, but it's what happens when we
>>>>>>>>>>>>>>>> don't have __int128_t.
>>>>>>>>>>>>>>>> + if (sizeof(TimeT) == sizeof(rep)) {
>>>>>>>>>>>>>>>> + typedef duration<long long, ratio<3600 * 24 * 365> >
>>>>>>>>>>>>>>>> Years;
>>>>>>>>>>>>>>>> + return duration_cast<Years>(fs_seconds(max_seconds))
>>>>>>>>>>>>>>>> > Years(250) &&
>>>>>>>>>>>>>>>> + duration_cast<Years>(fs_seconds(min_seconds))
>>>>>>>>>>>>>>>> < Years(-250);
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> + return max_seconds >= numeric_limits<TimeT>::max() &&
>>>>>>>>>>>>>>>> + min_seconds <= numeric_limits<TimeT>::min();
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> + static_assert(check_range(), "the representable range is
>>>>>>>>>>>>>>>> unacceptable small");
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -template <class FileTimeT>
>>>>>>>>>>>>>>>> -struct fs_time_util_base<FileTimeT, true> {
>>>>>>>>>>>>>>>> - static const long long max_seconds;
>>>>>>>>>>>>>>>> - static const long long max_nsec;
>>>>>>>>>>>>>>>> - static const long long min_seconds;
>>>>>>>>>>>>>>>> - static const long long min_nsec_timespec;
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>>>>>>>>> +struct time_util_base<FileTimeT, TimeT, true> {
>>>>>>>>>>>>>>>> + using rep = typename FileTimeT::rep;
>>>>>>>>>>>>>>>> + using fs_duration = typename FileTimeT::duration;
>>>>>>>>>>>>>>>> + using fs_seconds = duration<rep>;
>>>>>>>>>>>>>>>> + using fs_nanoseconds = duration<rep, nano>;
>>>>>>>>>>>>>>>> + using fs_microseconds = duration<rep, micro>;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static const rep max_seconds;
>>>>>>>>>>>>>>>> + static const rep max_nsec;
>>>>>>>>>>>>>>>> + static const rep min_seconds;
>>>>>>>>>>>>>>>> + static const rep min_nsec_timespec;
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -template <class FileTimeT>
>>>>>>>>>>>>>>>> -const long long fs_time_util_base<FileTimeT,
>>>>>>>>>>>>>>>> true>::max_seconds =
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> duration_cast<seconds>(FileTimeT::duration::max()).count();
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -template <class FileTimeT>
>>>>>>>>>>>>>>>> -const long long fs_time_util_base<FileTimeT,
>>>>>>>>>>>>>>>> true>::max_nsec =
>>>>>>>>>>>>>>>> - duration_cast<nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>>>>>>>>> - seconds(max_seconds))
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>>>>>>>>> +const typename FileTimeT::rep
>>>>>>>>>>>>>>>> + time_util_base<FileTimeT, TimeT, true>::max_seconds =
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>>>>>>>>> +const typename FileTimeT::rep time_util_base<FileTimeT,
>>>>>>>>>>>>>>>> TimeT, true>::max_nsec =
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>>>>>>>>> + fs_seconds(max_seconds))
>>>>>>>>>>>>>>>> .count();
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -template <class FileTimeT>
>>>>>>>>>>>>>>>> -const long long fs_time_util_base<FileTimeT,
>>>>>>>>>>>>>>>> true>::min_seconds =
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> duration_cast<seconds>(FileTimeT::duration::min()).count();
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -template <class FileTimeT>
>>>>>>>>>>>>>>>> -const long long fs_time_util_base<FileTimeT,
>>>>>>>>>>>>>>>> true>::min_nsec_timespec =
>>>>>>>>>>>>>>>> - duration_cast<nanoseconds>(
>>>>>>>>>>>>>>>> - (FileTimeT::duration::min() -
>>>>>>>>>>>>>>>> seconds(min_seconds)) + seconds(1))
>>>>>>>>>>>>>>>> - .count();
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>>>>>>>>> +const typename FileTimeT::rep
>>>>>>>>>>>>>>>> + time_util_base<FileTimeT, TimeT, true>::min_seconds =
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>>>>>>>>> +const typename FileTimeT::rep
>>>>>>>>>>>>>>>> + time_util_base<FileTimeT, TimeT,
>>>>>>>>>>>>>>>> true>::min_nsec_timespec =
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_nanoseconds>((FileTimeT::duration::min() -
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> fs_seconds(min_seconds)) +
>>>>>>>>>>>>>>>> + fs_seconds(1))
>>>>>>>>>>>>>>>> + .count();
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT>
>>>>>>>>>>>>>>>> -struct fs_time_util : fs_time_util_base<FileTimeT> {
>>>>>>>>>>>>>>>> - using Base = fs_time_util_base<FileTimeT>;
>>>>>>>>>>>>>>>> +struct time_util : time_util_base<FileTimeT, TimeT> {
>>>>>>>>>>>>>>>> + using Base = time_util_base<FileTimeT, TimeT>;
>>>>>>>>>>>>>>>> using Base::max_nsec;
>>>>>>>>>>>>>>>> using Base::max_seconds;
>>>>>>>>>>>>>>>> using Base::min_nsec_timespec;
>>>>>>>>>>>>>>>> using Base::min_seconds;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> + using typename Base::fs_duration;
>>>>>>>>>>>>>>>> + using typename Base::fs_microseconds;
>>>>>>>>>>>>>>>> + using typename Base::fs_nanoseconds;
>>>>>>>>>>>>>>>> + using typename Base::fs_seconds;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> public:
>>>>>>>>>>>>>>>> template <class CType, class ChronoType>
>>>>>>>>>>>>>>>> - static bool checked_set(CType* out, ChronoType time) {
>>>>>>>>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>>>>>>>>> checked_set(CType* out,
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> ChronoType time) {
>>>>>>>>>>>>>>>> using Lim = numeric_limits<CType>;
>>>>>>>>>>>>>>>> if (time > Lim::max() || time < Lim::min())
>>>>>>>>>>>>>>>> return false;
>>>>>>>>>>>>>>>> @@ -291,21 +318,21 @@ public:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>>>>>>>>> is_representable(TimeSpecT tm) {
>>>>>>>>>>>>>>>> if (tm.tv_sec >= 0) {
>>>>>>>>>>>>>>>> - return (tm.tv_sec < max_seconds) ||
>>>>>>>>>>>>>>>> + return tm.tv_sec < max_seconds ||
>>>>>>>>>>>>>>>> (tm.tv_sec == max_seconds && tm.tv_nsec <=
>>>>>>>>>>>>>>>> max_nsec);
>>>>>>>>>>>>>>>> } else if (tm.tv_sec == (min_seconds - 1)) {
>>>>>>>>>>>>>>>> return tm.tv_nsec >= min_nsec_timespec;
>>>>>>>>>>>>>>>> } else {
>>>>>>>>>>>>>>>> - return (tm.tv_sec >= min_seconds);
>>>>>>>>>>>>>>>> + return tm.tv_sec >= min_seconds;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>>>>>>>>> is_representable(FileTimeT tm) {
>>>>>>>>>>>>>>>> - auto secs =
>>>>>>>>>>>>>>>> duration_cast<seconds>(tm.time_since_epoch());
>>>>>>>>>>>>>>>> - auto nsecs =
>>>>>>>>>>>>>>>> duration_cast<nanoseconds>(tm.time_since_epoch() - secs);
>>>>>>>>>>>>>>>> + auto secs =
>>>>>>>>>>>>>>>> duration_cast<fs_seconds>(tm.time_since_epoch());
>>>>>>>>>>>>>>>> + auto nsecs =
>>>>>>>>>>>>>>>> duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
>>>>>>>>>>>>>>>> if (nsecs.count() < 0) {
>>>>>>>>>>>>>>>> - secs = secs + seconds(1);
>>>>>>>>>>>>>>>> - nsecs = nsecs + seconds(1);
>>>>>>>>>>>>>>>> + secs = secs + fs_seconds(1);
>>>>>>>>>>>>>>>> + nsecs = nsecs + fs_seconds(1);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> using TLim = numeric_limits<TimeT>;
>>>>>>>>>>>>>>>> if (secs.count() >= 0)
>>>>>>>>>>>>>>>> @@ -314,49 +341,45 @@ public:
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT
>>>>>>>>>>>>>>>> - convert_timespec(TimeSpecT tm) {
>>>>>>>>>>>>>>>> - auto adj_msec =
>>>>>>>>>>>>>>>> duration_cast<microseconds>(nanoseconds(tm.tv_nsec));
>>>>>>>>>>>>>>>> - if (tm.tv_sec >= 0) {
>>>>>>>>>>>>>>>> - auto Dur = seconds(tm.tv_sec) +
>>>>>>>>>>>>>>>> microseconds(adj_msec);
>>>>>>>>>>>>>>>> - return FileTimeT(Dur);
>>>>>>>>>>>>>>>> - } else if
>>>>>>>>>>>>>>>> (duration_cast<microseconds>(nanoseconds(tm.tv_nsec)).count() ==
>>>>>>>>>>>>>>>> - 0) {
>>>>>>>>>>>>>>>> - return FileTimeT(seconds(tm.tv_sec));
>>>>>>>>>>>>>>>> + convert_from_timespec(TimeSpecT tm) {
>>>>>>>>>>>>>>>> + if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
>>>>>>>>>>>>>>>> + return FileTimeT(fs_seconds(tm.tv_sec) +
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
>>>>>>>>>>>>>>>> } else { // tm.tv_sec < 0
>>>>>>>>>>>>>>>> - auto adj_subsec =
>>>>>>>>>>>>>>>> - duration_cast<microseconds>(seconds(1) -
>>>>>>>>>>>>>>>> nanoseconds(tm.tv_nsec));
>>>>>>>>>>>>>>>> - auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
>>>>>>>>>>>>>>>> + auto adj_subsec =
>>>>>>>>>>>>>>>> duration_cast<fs_duration>(fs_seconds(1) -
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> fs_nanoseconds(tm.tv_nsec));
>>>>>>>>>>>>>>>> + auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
>>>>>>>>>>>>>>>> return FileTimeT(Dur);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - template <class SubSecDurT, class SubSecT>
>>>>>>>>>>>>>>>> - static bool set_times_checked(TimeT* sec_out, SubSecT*
>>>>>>>>>>>>>>>> subsec_out,
>>>>>>>>>>>>>>>> - FileTimeT tp) {
>>>>>>>>>>>>>>>> + template <class SubSecT>
>>>>>>>>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>>>>>>>>> + set_times_checked(TimeT* sec_out, SubSecT* subsec_out,
>>>>>>>>>>>>>>>> FileTimeT tp) {
>>>>>>>>>>>>>>>> auto dur = tp.time_since_epoch();
>>>>>>>>>>>>>>>> - auto sec_dur = duration_cast<seconds>(dur);
>>>>>>>>>>>>>>>> - auto subsec_dur = duration_cast<SubSecDurT>(dur -
>>>>>>>>>>>>>>>> sec_dur);
>>>>>>>>>>>>>>>> + auto sec_dur = duration_cast<fs_seconds>(dur);
>>>>>>>>>>>>>>>> + auto subsec_dur = duration_cast<fs_nanoseconds>(dur -
>>>>>>>>>>>>>>>> sec_dur);
>>>>>>>>>>>>>>>> // The tv_nsec and tv_usec fields must not be negative
>>>>>>>>>>>>>>>> so adjust accordingly
>>>>>>>>>>>>>>>> if (subsec_dur.count() < 0) {
>>>>>>>>>>>>>>>> if (sec_dur.count() > min_seconds) {
>>>>>>>>>>>>>>>> - sec_dur -= seconds(1);
>>>>>>>>>>>>>>>> - subsec_dur += seconds(1);
>>>>>>>>>>>>>>>> + sec_dur -= fs_seconds(1);
>>>>>>>>>>>>>>>> + subsec_dur += fs_seconds(1);
>>>>>>>>>>>>>>>> } else {
>>>>>>>>>>>>>>>> - subsec_dur = SubSecDurT::zero();
>>>>>>>>>>>>>>>> + subsec_dur = fs_nanoseconds::zero();
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> return checked_set(sec_out, sec_dur.count()) &&
>>>>>>>>>>>>>>>> checked_set(subsec_out, subsec_dur.count());
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>>>>>>>>> convert_to_timespec(TimeSpecT& dest,
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> FileTimeT tp) {
>>>>>>>>>>>>>>>> + if (!is_representable(tp))
>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>> + return set_times_checked(&dest.tv_sec, &dest.tv_nsec,
>>>>>>>>>>>>>>>> tp);
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -} // namespace time_util
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -using TimeSpec = struct ::timespec;
>>>>>>>>>>>>>>>> -using StatT = struct ::stat;
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -using FSTime = time_util::fs_time_util<file_time_type,
>>>>>>>>>>>>>>>> time_t, struct timespec>;
>>>>>>>>>>>>>>>> +using fs_time = time_util<file_time_type, time_t,
>>>>>>>>>>>>>>>> TimeSpec>;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> #if defined(__APPLE__)
>>>>>>>>>>>>>>>> TimeSpec extract_mtime(StatT const& st) { return
>>>>>>>>>>>>>>>> st.st_mtimespec; }
>>>>>>>>>>>>>>>> @@ -366,20 +389,18 @@ TimeSpec extract_mtime(StatT const&
>>>>>>>>>>>>>>>> st)
>>>>>>>>>>>>>>>> TimeSpec extract_atime(StatT const& st) { return
>>>>>>>>>>>>>>>> st.st_atim; }
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> -using TimeStruct = struct ::timeval;
>>>>>>>>>>>>>>>> -using TimeStructArray = TimeStruct[2];
>>>>>>>>>>>>>>>> -#else
>>>>>>>>>>>>>>>> -using TimeStruct = TimeSpec;
>>>>>>>>>>>>>>>> -using TimeStructArray = TimeStruct[2];
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -bool SetFileTimes(const path& p, TimeStructArray const& TS,
>>>>>>>>>>>>>>>> - error_code& ec) {
>>>>>>>>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> - if (::utimes(p.c_str(), TS) == -1)
>>>>>>>>>>>>>>>> +bool set_file_times(const path& p, std::array<TimeSpec, 2>
>>>>>>>>>>>>>>>> const& TS,
>>>>>>>>>>>>>>>> + error_code& ec) {
>>>>>>>>>>>>>>>> +#if !defined(_LIBCPP_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> + using namespace chrono;
>>>>>>>>>>>>>>>> + auto Convert = [](long nsec) {
>>>>>>>>>>>>>>>> + return
>>>>>>>>>>>>>>>> duration_cast<microseconds>(nanoseconds(nsec)).count();
>>>>>>>>>>>>>>>> + };
>>>>>>>>>>>>>>>> + struct ::timeval ConvertedTS[2] = {{TS[0].tv_sec,
>>>>>>>>>>>>>>>> Convert(TS[0].tv_nsec)},
>>>>>>>>>>>>>>>> + {TS[1].tv_sec,
>>>>>>>>>>>>>>>> Convert(TS[1].tv_nsec)}};
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This causes the '-Wc++11-narrowing' warning on Darwin:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> filesystem_common.h:399:53: error: non-constant-expression
>>>>>>>>>>>>>>> cannot be narrowed from type 'long long' to '__darwin_suseconds_t' (aka
>>>>>>>>>>>>>>> 'int') in initializer list [-Wc++11-narrowing] struct ::timeval
>>>>>>>>>>>>>>> ConvertedTS[2] = {{TS[0].tv_sec, Convert(TS[0].tv_nsec)},
>>>>>>>>>>>>>>> ^~~~~~~~~~~~~~~~~~~~~~
>>>>>>>>>>>>>>> I'll work on a fix commit.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> + if (::utimes(p.c_str(), ConvertedTS) == -1)
>>>>>>>>>>>>>>>> #else
>>>>>>>>>>>>>>>> - if (::utimensat(AT_FDCWD, p.c_str(), TS, 0) == -1)
>>>>>>>>>>>>>>>> + if (::utimensat(AT_FDCWD, p.c_str(), TS.data(), 0) == -1)
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> ec = capture_errno();
>>>>>>>>>>>>>>>> @@ -388,25 +409,9 @@ bool SetFileTimes(const path& p,
>>>>>>>>>>>>>>>> TimeStr
>>>>>>>>>>>>>>>> return false;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -void SetTimeStructTo(TimeStruct& TS, TimeSpec ToTS) {
>>>>>>>>>>>>>>>> - using namespace chrono;
>>>>>>>>>>>>>>>> - TS.tv_sec = ToTS.tv_sec;
>>>>>>>>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> - TS.tv_usec =
>>>>>>>>>>>>>>>> duration_cast<microseconds>(nanoseconds(ToTS.tv_nsec)).count();
>>>>>>>>>>>>>>>> -#else
>>>>>>>>>>>>>>>> - TS.tv_nsec = ToTS.tv_nsec;
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> -}
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -bool SetTimeStructTo(TimeStruct& TS, file_time_type
>>>>>>>>>>>>>>>> NewTime) {
>>>>>>>>>>>>>>>> - using namespace chrono;
>>>>>>>>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> - return
>>>>>>>>>>>>>>>> !FSTime::set_times_checked<microseconds>(&TS.tv_sec, &TS.tv_usec,
>>>>>>>>>>>>>>>> - NewTime);
>>>>>>>>>>>>>>>> -#else
>>>>>>>>>>>>>>>> - return
>>>>>>>>>>>>>>>> !FSTime::set_times_checked<nanoseconds>(&TS.tv_sec, &TS.tv_nsec,
>>>>>>>>>>>>>>>> - NewTime);
>>>>>>>>>>>>>>>> -#endif
>>>>>>>>>>>>>>>> +bool set_time_spec_to(TimeSpec& TS, file_time_type
>>>>>>>>>>>>>>>> NewTime) {
>>>>>>>>>>>>>>>> + return !fs_time::set_times_checked(
>>>>>>>>>>>>>>>> + &TS.tv_sec, &TS.tv_nsec, NewTime);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> } // namespace
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>> libcxx/trunk/src/experimental/filesystem/operations.cpp
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/experimental/filesystem/operations.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> --- libcxx/trunk/src/experimental/filesystem/operations.cpp
>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>> +++ libcxx/trunk/src/experimental/filesystem/operations.cpp
>>>>>>>>>>>>>>>> Wed Jul 25 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -23,6 +23,7 @@
>>>>>>>>>>>>>>>> #include <unistd.h>
>>>>>>>>>>>>>>>> #include <sys/stat.h>
>>>>>>>>>>>>>>>> #include <sys/statvfs.h>
>>>>>>>>>>>>>>>> +#include <time.h>
>>>>>>>>>>>>>>>> #include <fcntl.h> /* values for fchmodat */
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> #if defined(__linux__)
>>>>>>>>>>>>>>>> @@ -36,6 +37,14 @@
>>>>>>>>>>>>>>>> # define _LIBCPP_USE_COPYFILE
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> +#if !defined(__APPLE__)
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#if !defined(CLOCK_REALTIME) ||
>>>>>>>>>>>>>>>> !defined(_LIBCPP_USE_CLOCK_GETTIME)
>>>>>>>>>>>>>>>> +#include <sys/time.h> // for gettimeofday and timeval
>>>>>>>>>>>>>>>> +#endif // !defined(CLOCK_REALTIME)
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> #if defined(_LIBCPP_COMPILER_GCC)
>>>>>>>>>>>>>>>> #if _GNUC_VER < 500
>>>>>>>>>>>>>>>> #pragma GCC diagnostic ignored
>>>>>>>>>>>>>>>> "-Wmissing-field-initializers"
>>>>>>>>>>>>>>>> @@ -44,9 +53,6 @@
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -filesystem_error::~filesystem_error() {}
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> namespace { namespace parser
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> @@ -355,7 +361,7 @@ private:
>>>>>>>>>>>>>>>> explicit FileDescriptor(const path* p, int fd = -1) :
>>>>>>>>>>>>>>>> name(*p), fd(fd) {}
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -perms posix_get_perms(const struct ::stat& st) noexcept {
>>>>>>>>>>>>>>>> +perms posix_get_perms(const StatT& st) noexcept {
>>>>>>>>>>>>>>>> return static_cast<perms>(st.st_mode) & perms::mask;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> @@ -364,8 +370,7 @@ perms posix_get_perms(const struct ::sta
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> file_status create_file_status(error_code& m_ec, path
>>>>>>>>>>>>>>>> const& p,
>>>>>>>>>>>>>>>> - const struct ::stat&
>>>>>>>>>>>>>>>> path_stat,
>>>>>>>>>>>>>>>> - error_code* ec) {
>>>>>>>>>>>>>>>> + const StatT& path_stat,
>>>>>>>>>>>>>>>> error_code* ec) {
>>>>>>>>>>>>>>>> if (ec)
>>>>>>>>>>>>>>>> *ec = m_ec;
>>>>>>>>>>>>>>>> if (m_ec && (m_ec.value() == ENOENT || m_ec.value() ==
>>>>>>>>>>>>>>>> ENOTDIR)) {
>>>>>>>>>>>>>>>> @@ -400,8 +405,7 @@ file_status create_file_status(error_cod
>>>>>>>>>>>>>>>> return fs_tmp;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -file_status posix_stat(path const& p, struct ::stat&
>>>>>>>>>>>>>>>> path_stat,
>>>>>>>>>>>>>>>> - error_code* ec) {
>>>>>>>>>>>>>>>> +file_status posix_stat(path const& p, StatT& path_stat,
>>>>>>>>>>>>>>>> error_code* ec) {
>>>>>>>>>>>>>>>> error_code m_ec;
>>>>>>>>>>>>>>>> if (::stat(p.c_str(), &path_stat) == -1)
>>>>>>>>>>>>>>>> m_ec = detail::capture_errno();
>>>>>>>>>>>>>>>> @@ -409,12 +413,11 @@ file_status posix_stat(path const& p,
>>>>>>>>>>>>>>>> st
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> file_status posix_stat(path const& p, error_code* ec) {
>>>>>>>>>>>>>>>> - struct ::stat path_stat;
>>>>>>>>>>>>>>>> + StatT path_stat;
>>>>>>>>>>>>>>>> return posix_stat(p, path_stat, ec);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -file_status posix_lstat(path const& p, struct ::stat&
>>>>>>>>>>>>>>>> path_stat,
>>>>>>>>>>>>>>>> - error_code* ec) {
>>>>>>>>>>>>>>>> +file_status posix_lstat(path const& p, StatT& path_stat,
>>>>>>>>>>>>>>>> error_code* ec) {
>>>>>>>>>>>>>>>> error_code m_ec;
>>>>>>>>>>>>>>>> if (::lstat(p.c_str(), &path_stat) == -1)
>>>>>>>>>>>>>>>> m_ec = detail::capture_errno();
>>>>>>>>>>>>>>>> @@ -422,7 +425,7 @@ file_status posix_lstat(path const& p, s
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> file_status posix_lstat(path const& p, error_code* ec) {
>>>>>>>>>>>>>>>> - struct ::stat path_stat;
>>>>>>>>>>>>>>>> + StatT path_stat;
>>>>>>>>>>>>>>>> return posix_lstat(p, path_stat, ec);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> @@ -464,10 +467,32 @@ file_status
>>>>>>>>>>>>>>>> FileDescriptor::refresh_stat
>>>>>>>>>>>>>>>> using detail::capture_errno;
>>>>>>>>>>>>>>>> using detail::ErrorHandler;
>>>>>>>>>>>>>>>> using detail::StatT;
>>>>>>>>>>>>>>>> +using detail::TimeSpec;
>>>>>>>>>>>>>>>> using parser::createView;
>>>>>>>>>>>>>>>> using parser::PathParser;
>>>>>>>>>>>>>>>> using parser::string_view_t;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> +const bool _FilesystemClock::is_steady;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +_FilesystemClock::time_point _FilesystemClock::now()
>>>>>>>>>>>>>>>> noexcept {
>>>>>>>>>>>>>>>> + typedef chrono::duration<rep> __secs;
>>>>>>>>>>>>>>>> +#if defined(_LIBCPP_USE_CLOCK_GETTIME) &&
>>>>>>>>>>>>>>>> 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 // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +filesystem_error::~filesystem_error() {}
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> void filesystem_error::__create_what(int __num_paths) {
>>>>>>>>>>>>>>>> const char* derived_what = system_error::what();
>>>>>>>>>>>>>>>> __storage_->__what_ = [&]() -> string {
>>>>>>>>>>>>>>>> @@ -525,14 +550,14 @@ void __copy(const path& from, const
>>>>>>>>>>>>>>>> path
>>>>>>>>>>>>>>>> const bool sym_status2 = bool(options &
>>>>>>>>>>>>>>>> copy_options::copy_symlinks);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> error_code m_ec1;
>>>>>>>>>>>>>>>> - struct ::stat f_st = {};
>>>>>>>>>>>>>>>> + StatT f_st = {};
>>>>>>>>>>>>>>>> const file_status f = sym_status || sym_status2
>>>>>>>>>>>>>>>> ? detail::posix_lstat(from,
>>>>>>>>>>>>>>>> f_st, &m_ec1)
>>>>>>>>>>>>>>>> : detail::posix_stat(from,
>>>>>>>>>>>>>>>> f_st, &m_ec1);
>>>>>>>>>>>>>>>> if (m_ec1)
>>>>>>>>>>>>>>>> return err.report(m_ec1);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - struct ::stat t_st = {};
>>>>>>>>>>>>>>>> + StatT t_st = {};
>>>>>>>>>>>>>>>> const file_status t = sym_status ?
>>>>>>>>>>>>>>>> detail::posix_lstat(to, t_st, &m_ec1)
>>>>>>>>>>>>>>>> :
>>>>>>>>>>>>>>>> detail::posix_stat(to, t_st, &m_ec1);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> @@ -916,7 +941,7 @@ uintmax_t __file_size(const path& p, err
>>>>>>>>>>>>>>>> ErrorHandler<uintmax_t> err("file_size", ec, &p);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> error_code m_ec;
>>>>>>>>>>>>>>>> - struct ::stat st;
>>>>>>>>>>>>>>>> + StatT st;
>>>>>>>>>>>>>>>> file_status fst = detail::posix_stat(p, st, &m_ec);
>>>>>>>>>>>>>>>> if (!exists(fst) || !is_regular_file(fst)) {
>>>>>>>>>>>>>>>> errc error_kind =
>>>>>>>>>>>>>>>> @@ -966,14 +991,14 @@ bool __fs_is_empty(const path& p,
>>>>>>>>>>>>>>>> error_
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> static file_time_type __extract_last_write_time(const
>>>>>>>>>>>>>>>> path& p, const StatT& st,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> error_code* ec) {
>>>>>>>>>>>>>>>> - using detail::FSTime;
>>>>>>>>>>>>>>>> + using detail::fs_time;
>>>>>>>>>>>>>>>> ErrorHandler<file_time_type> err("last_write_time", ec,
>>>>>>>>>>>>>>>> &p);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> auto ts = detail::extract_mtime(st);
>>>>>>>>>>>>>>>> - if (!FSTime::is_representable(ts))
>>>>>>>>>>>>>>>> + if (!fs_time::is_representable(ts))
>>>>>>>>>>>>>>>> return err.report(errc::value_too_large);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - return FSTime::convert_timespec(ts);
>>>>>>>>>>>>>>>> + return fs_time::convert_from_timespec(ts);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> file_time_type __last_write_time(const path& p, error_code
>>>>>>>>>>>>>>>> *ec)
>>>>>>>>>>>>>>>> @@ -992,30 +1017,27 @@ file_time_type
>>>>>>>>>>>>>>>> __last_write_time(const p
>>>>>>>>>>>>>>>> void __last_write_time(const path& p, file_time_type
>>>>>>>>>>>>>>>> new_time,
>>>>>>>>>>>>>>>> error_code *ec)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> - using namespace chrono;
>>>>>>>>>>>>>>>> - using namespace detail;
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> ErrorHandler<void> err("last_write_time", ec, &p);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> error_code m_ec;
>>>>>>>>>>>>>>>> - TimeStructArray tbuf;
>>>>>>>>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>>>>>>>>> + 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
>>>>>>>>>>>>>>>> - struct ::stat st;
>>>>>>>>>>>>>>>> + StatT st;
>>>>>>>>>>>>>>>> file_status fst = detail::posix_stat(p, st, &m_ec);
>>>>>>>>>>>>>>>> - if (m_ec && !status_known(fst))
>>>>>>>>>>>>>>>> + if (m_ec)
>>>>>>>>>>>>>>>> return err.report(m_ec);
>>>>>>>>>>>>>>>> - SetTimeStructTo(tbuf[0], detail::extract_atime(st));
>>>>>>>>>>>>>>>> + tbuf[0] = detail::extract_atime(st);
>>>>>>>>>>>>>>>> #else
>>>>>>>>>>>>>>>> tbuf[0].tv_sec = 0;
>>>>>>>>>>>>>>>> tbuf[0].tv_nsec = UTIME_OMIT;
>>>>>>>>>>>>>>>> #endif
>>>>>>>>>>>>>>>> - if (SetTimeStructTo(tbuf[1], new_time))
>>>>>>>>>>>>>>>> - return err.report(errc::invalid_argument);
>>>>>>>>>>>>>>>> + if (detail::set_time_spec_to(tbuf[1], new_time))
>>>>>>>>>>>>>>>> + return err.report(errc::value_too_large);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - SetFileTimes(p, tbuf, m_ec);
>>>>>>>>>>>>>>>> + detail::set_file_times(p, tbuf, m_ec);
>>>>>>>>>>>>>>>> if (m_ec)
>>>>>>>>>>>>>>>> return err.report(m_ec);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> @@ -1591,7 +1613,7 @@ error_code
>>>>>>>>>>>>>>>> directory_entry::__do_refresh
>>>>>>>>>>>>>>>> __data_.__reset();
>>>>>>>>>>>>>>>> error_code failure_ec;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - struct ::stat full_st;
>>>>>>>>>>>>>>>> + StatT full_st;
>>>>>>>>>>>>>>>> file_status st = detail::posix_lstat(__p_, full_st,
>>>>>>>>>>>>>>>> &failure_ec);
>>>>>>>>>>>>>>>> if (!status_known(st)) {
>>>>>>>>>>>>>>>> __data_.__reset();
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Added: libcxx/trunk/src/include/apple_availability.h
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/include/apple_availability.h?rev=337960&view=auto
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> --- libcxx/trunk/src/include/apple_availability.h (added)
>>>>>>>>>>>>>>>> +++ libcxx/trunk/src/include/apple_availability.h Wed Jul
>>>>>>>>>>>>>>>> 25 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -0,0 +1,52 @@
>>>>>>>>>>>>>>>> +//===------------------------ apple_availability.h
>>>>>>>>>>>>>>>> ------------------------===//
>>>>>>>>>>>>>>>> +//
>>>>>>>>>>>>>>>> +// The LLVM Compiler Infrastructure
>>>>>>>>>>>>>>>> +//
>>>>>>>>>>>>>>>> +// This file is dual licensed under the MIT and the
>>>>>>>>>>>>>>>> University of Illinois Open
>>>>>>>>>>>>>>>> +// Source Licenses. See LICENSE.TXT for details.
>>>>>>>>>>>>>>>> +//
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> +//===----------------------------------------------------------------------===//
>>>>>>>>>>>>>>>> +#ifndef _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
>>>>>>>>>>>>>>>> +#define _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#if defined(__APPLE__)
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101300
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >=
>>>>>>>>>>>>>>>> 110000
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 110000
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 40000
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >=
>>>>>>>>>>>>>>>> 100000
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#elif
>>>>>>>>>>>>>>>> defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>>>>>>>>> +#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000
>>>>>>>>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#endif // __APPLE__
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#endif // _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/experimental/filesystem/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> ---
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp
>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>> +++
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/class.directory_entry/directory_entry.mods/last_write_time.sh.cpp
>>>>>>>>>>>>>>>> Wed Jul 25 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -41,9 +41,7 @@ TEST_CASE(last_write_time_not_representa
>>>>>>>>>>>>>>>> ToTime.tv_sec =
>>>>>>>>>>>>>>>> std::numeric_limits<decltype(ToTime.tv_sec)>::max();
>>>>>>>>>>>>>>>> ToTime.tv_nsec =
>>>>>>>>>>>>>>>> duration_cast<nanoseconds>(seconds(1)).count() - 1;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - TimeStructArray TS;
>>>>>>>>>>>>>>>> - SetTimeStructTo(TS[0], ToTime);
>>>>>>>>>>>>>>>> - SetTimeStructTo(TS[1], ToTime);
>>>>>>>>>>>>>>>> + std::array<TimeSpec, 2> TS = {ToTime, ToTime};
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> file_time_type old_time = last_write_time(file);
>>>>>>>>>>>>>>>> directory_entry ent(file);
>>>>>>>>>>>>>>>> @@ -57,9 +55,7 @@ TEST_CASE(last_write_time_not_representa
>>>>>>>>>>>>>>>> file_time_type rep_value;
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> std::error_code ec;
>>>>>>>>>>>>>>>> - if (SetFileTimes(file, TS, ec)) {
>>>>>>>>>>>>>>>> - TEST_REQUIRE(false && "unsupported");
>>>>>>>>>>>>>>>> - }
>>>>>>>>>>>>>>>> + TEST_REQUIRE(!set_file_times(file, TS, ec));
>>>>>>>>>>>>>>>> ec.clear();
>>>>>>>>>>>>>>>> rep_value = last_write_time(file, ec);
>>>>>>>>>>>>>>>> IsRepresentable = !bool(ec);
>>>>>>>>>>>>>>>> @@ -82,7 +78,7 @@ TEST_CASE(last_write_time_not_representa
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ExceptionChecker CheckExcept(file, expected_err,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> "directory_entry::last_write_time");
>>>>>>>>>>>>>>>> - TEST_CHECK_THROW_RESULT(fs::filesystem_error,
>>>>>>>>>>>>>>>> CheckExcept,
>>>>>>>>>>>>>>>> + TEST_CHECK_THROW_RESULT(filesystem_error, CheckExcept,
>>>>>>>>>>>>>>>> ent.last_write_time());
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> } else {
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> ---
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>> +++
>>>>>>>>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
>>>>>>>>>>>>>>>> Wed Jul 25 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -25,15 +25,23 @@
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> #include "filesystem_common.h"
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> +#ifndef __SIZEOF_INT128__
>>>>>>>>>>>>>>>> +#define TEST_HAS_NO_INT128_T
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> using namespace std::chrono;
>>>>>>>>>>>>>>>> namespace fs = std::experimental::filesystem;
>>>>>>>>>>>>>>>> using fs::file_time_type;
>>>>>>>>>>>>>>>> -using fs::detail::time_util::fs_time_util;
>>>>>>>>>>>>>>>> +using fs::detail::time_util;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#ifdef TEST_HAS_NO_INT128_T
>>>>>>>>>>>>>>>> +static_assert(sizeof(fs::file_time_type::rep) <= 8, "");
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -enum TestKind { TK_64Bit, TK_32Bit, TK_FloatingPoint };
>>>>>>>>>>>>>>>> +enum TestKind { TK_128Bit, TK_64Bit, TK_32Bit,
>>>>>>>>>>>>>>>> TK_FloatingPoint };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -template <class FileTimeT, class TimeT, class TimeSpec>
>>>>>>>>>>>>>>>> -constexpr TestKind getTestKind() {
>>>>>>>>>>>>>>>> +template <class TimeT>
>>>>>>>>>>>>>>>> +constexpr TestKind getTimeTTestKind() {
>>>>>>>>>>>>>>>> if (sizeof(TimeT) == 8 &&
>>>>>>>>>>>>>>>> !std::is_floating_point<TimeT>::value)
>>>>>>>>>>>>>>>> return TK_64Bit;
>>>>>>>>>>>>>>>> else if (sizeof(TimeT) == 4 &&
>>>>>>>>>>>>>>>> !std::is_floating_point<TimeT>::value)
>>>>>>>>>>>>>>>> @@ -43,17 +51,99 @@ constexpr TestKind getTestKind() {
>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>> assert(false && "test kind not supported");
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> +template <class FileTimeT>
>>>>>>>>>>>>>>>> +constexpr TestKind getFileTimeTestKind() {
>>>>>>>>>>>>>>>> + using Rep = typename FileTimeT::rep;
>>>>>>>>>>>>>>>> + if (std::is_floating_point<Rep>::value)
>>>>>>>>>>>>>>>> + return TK_FloatingPoint;
>>>>>>>>>>>>>>>> + if (sizeof(Rep) == 16)
>>>>>>>>>>>>>>>> + return TK_128Bit;
>>>>>>>>>>>>>>>> + if (sizeof(Rep) == 8)
>>>>>>>>>>>>>>>> + return TK_64Bit;
>>>>>>>>>>>>>>>> + assert(false && "test kind not supported");
>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT,
>>>>>>>>>>>>>>>> - class Base = fs_time_util<FileTimeT, TimeT,
>>>>>>>>>>>>>>>> TimeSpecT>,
>>>>>>>>>>>>>>>> - TestKind = getTestKind<FileTimeT, TimeT,
>>>>>>>>>>>>>>>> TimeSpecT>()>
>>>>>>>>>>>>>>>> -struct check_is_representable;
>>>>>>>>>>>>>>>> + class Base = time_util<FileTimeT, TimeT,
>>>>>>>>>>>>>>>> TimeSpecT>,
>>>>>>>>>>>>>>>> + TestKind = getTimeTTestKind<TimeT>(),
>>>>>>>>>>>>>>>> + TestKind = getFileTimeTestKind<FileTimeT>()>
>>>>>>>>>>>>>>>> +struct test_case;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT,
>>>>>>>>>>>>>>>> class Base>
>>>>>>>>>>>>>>>> -struct check_is_representable<FileTimeT, TimeT, TimeSpecT,
>>>>>>>>>>>>>>>> Base, TK_64Bit>
>>>>>>>>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>>>>>>>>> TK_64Bit, TK_128Bit>
>>>>>>>>>>>>>>>> : public Base {
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - using Base::convert_timespec;
>>>>>>>>>>>>>>>> + using Base::convert_from_timespec;
>>>>>>>>>>>>>>>> + using Base::convert_to_timespec;
>>>>>>>>>>>>>>>> + using Base::is_representable;
>>>>>>>>>>>>>>>> + using Base::max_nsec;
>>>>>>>>>>>>>>>> + using Base::max_seconds;
>>>>>>>>>>>>>>>> + using Base::min_nsec_timespec;
>>>>>>>>>>>>>>>> + using Base::min_seconds;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr auto max_time_t =
>>>>>>>>>>>>>>>> std::numeric_limits<TimeT>::max();
>>>>>>>>>>>>>>>> + static constexpr auto min_time_t =
>>>>>>>>>>>>>>>> std::numeric_limits<TimeT>::min();
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr bool test_timespec() {
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t,
>>>>>>>>>>>>>>>> 0}), "");
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t,
>>>>>>>>>>>>>>>> 999999999}), "");
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t,
>>>>>>>>>>>>>>>> 1000000000}), "");
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t,
>>>>>>>>>>>>>>>> max_nsec}), "");
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t,
>>>>>>>>>>>>>>>> 0}), "");
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t,
>>>>>>>>>>>>>>>> 999999999}), "");
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t,
>>>>>>>>>>>>>>>> 1000000000}), "");
>>>>>>>>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t,
>>>>>>>>>>>>>>>> min_nsec_timespec}),
>>>>>>>>>>>>>>>> + "");
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + return true;
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr bool test_file_time_type() {
>>>>>>>>>>>>>>>> + // This kinda sucks. Oh well.
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> static_assert(!Base::is_representable(FileTimeT::max()), "");
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> static_assert(!Base::is_representable(FileTimeT::min()), "");
>>>>>>>>>>>>>>>> + return true;
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr bool check_round_trip(TimeSpecT orig) {
>>>>>>>>>>>>>>>> + TimeSpecT new_ts = {};
>>>>>>>>>>>>>>>> + FileTimeT out = convert_from_timespec(orig);
>>>>>>>>>>>>>>>> + assert(convert_to_timespec(new_ts, out));
>>>>>>>>>>>>>>>> + return new_ts.tv_sec == orig.tv_sec && new_ts.tv_nsec
>>>>>>>>>>>>>>>> == orig.tv_nsec;
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static constexpr bool test_convert_timespec() {
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({0, 0}), "");
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({0, 1}), "");
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({1, 1}), "");
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({-1, 1}), "");
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({max_time_t,
>>>>>>>>>>>>>>>> max_nsec}), "");
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({max_time_t, 123}), "");
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({min_time_t,
>>>>>>>>>>>>>>>> min_nsec_timespec}), "");
>>>>>>>>>>>>>>>> + static_assert(check_round_trip({min_time_t, 123}), "");
>>>>>>>>>>>>>>>> + return true;
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + static bool test() {
>>>>>>>>>>>>>>>> + static_assert(test_timespec(), "");
>>>>>>>>>>>>>>>> + static_assert(test_file_time_type(), "");
>>>>>>>>>>>>>>>> + static_assert(test_convert_timespec(), "");
>>>>>>>>>>>>>>>> + return true;
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT, class TimeSpecT,
>>>>>>>>>>>>>>>> class Base>
>>>>>>>>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>>>>>>>>> TK_32Bit, TK_128Bit>
>>>>>>>>>>>>>>>> + : public test_case<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>>>>>>>>> TK_64Bit, TK_128Bit> {
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT, class TimeSpecT,
>>>>>>>>>>>>>>>> class Base>
>>>>>>>>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>>>>>>>>> TK_64Bit, TK_64Bit>
>>>>>>>>>>>>>>>> + : public Base {
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + using Base::convert_from_timespec;
>>>>>>>>>>>>>>>> using Base::is_representable;
>>>>>>>>>>>>>>>> using Base::max_nsec;
>>>>>>>>>>>>>>>> using Base::max_seconds;
>>>>>>>>>>>>>>>> @@ -88,24 +178,25 @@ struct
>>>>>>>>>>>>>>>> check_is_representable<FileTimeT,
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> static constexpr bool test_convert_timespec() {
>>>>>>>>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{max_seconds,
>>>>>>>>>>>>>>>> max_nsec}) ==
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> static_assert(convert_from_timespec(TimeSpecT{max_seconds, max_nsec}) ==
>>>>>>>>>>>>>>>> FileTimeT::max(),
>>>>>>>>>>>>>>>> "");
>>>>>>>>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{max_seconds,
>>>>>>>>>>>>>>>> max_nsec - 1}) <
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> static_assert(convert_from_timespec(TimeSpecT{max_seconds, max_nsec - 1}) <
>>>>>>>>>>>>>>>> FileTimeT::max(),
>>>>>>>>>>>>>>>> "");
>>>>>>>>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{max_seconds -
>>>>>>>>>>>>>>>> 1, 999999999}) <
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> static_assert(convert_from_timespec(TimeSpecT{max_seconds - 1, 999999999}) <
>>>>>>>>>>>>>>>> FileTimeT::max(),
>>>>>>>>>>>>>>>> "");
>>>>>>>>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{
>>>>>>>>>>>>>>>> + static_assert(convert_from_timespec(TimeSpecT{
>>>>>>>>>>>>>>>> min_seconds - 1, min_nsec_timespec})
>>>>>>>>>>>>>>>> == FileTimeT::min(),
>>>>>>>>>>>>>>>> "");
>>>>>>>>>>>>>>>> - static_assert(
>>>>>>>>>>>>>>>> - convert_timespec(TimeSpecT{min_seconds - 1,
>>>>>>>>>>>>>>>> min_nsec_timespec + 1}) >
>>>>>>>>>>>>>>>> - FileTimeT::min(),
>>>>>>>>>>>>>>>> - "");
>>>>>>>>>>>>>>>> - static_assert(
>>>>>>>>>>>>>>>> - convert_timespec(TimeSpecT{min_seconds, 0}) >
>>>>>>>>>>>>>>>> FileTimeT::min(), "");
>>>>>>>>>>>>>>>> + static_assert(convert_from_timespec(
>>>>>>>>>>>>>>>> + TimeSpecT{min_seconds - 1,
>>>>>>>>>>>>>>>> min_nsec_timespec + 1}) >
>>>>>>>>>>>>>>>> + FileTimeT::min(),
>>>>>>>>>>>>>>>> + "");
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> static_assert(convert_from_timespec(TimeSpecT{min_seconds, 0}) >
>>>>>>>>>>>>>>>> + FileTimeT::min(),
>>>>>>>>>>>>>>>> + "");
>>>>>>>>>>>>>>>> return true;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> @@ -118,12 +209,12 @@ struct
>>>>>>>>>>>>>>>> check_is_representable<FileTimeT,
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT,
>>>>>>>>>>>>>>>> class Base>
>>>>>>>>>>>>>>>> -struct check_is_representable<FileTimeT, TimeT, TimeSpecT,
>>>>>>>>>>>>>>>> Base, TK_32Bit>
>>>>>>>>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>>>>>>>>> TK_32Bit, TK_64Bit>
>>>>>>>>>>>>>>>> : public Base {
>>>>>>>>>>>>>>>> static constexpr auto max_time_t =
>>>>>>>>>>>>>>>> std::numeric_limits<TimeT>::max();
>>>>>>>>>>>>>>>> static constexpr auto min_time_t =
>>>>>>>>>>>>>>>> std::numeric_limits<TimeT>::min();
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> - using Base::convert_timespec;
>>>>>>>>>>>>>>>> + using Base::convert_from_timespec;
>>>>>>>>>>>>>>>> using Base::is_representable;
>>>>>>>>>>>>>>>> using Base::max_nsec;
>>>>>>>>>>>>>>>> using Base::max_seconds;
>>>>>>>>>>>>>>>> @@ -158,9 +249,10 @@ struct
>>>>>>>>>>>>>>>> check_is_representable<FileTimeT,
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -template <class FileTimeT, class TimeT, class TimeSpec,
>>>>>>>>>>>>>>>> class Base>
>>>>>>>>>>>>>>>> -struct check_is_representable<FileTimeT, TimeT, TimeSpec,
>>>>>>>>>>>>>>>> Base,
>>>>>>>>>>>>>>>> - TK_FloatingPoint> : public
>>>>>>>>>>>>>>>> Base {
>>>>>>>>>>>>>>>> +template <class FileTimeT, class TimeT, class TimeSpec,
>>>>>>>>>>>>>>>> class Base,
>>>>>>>>>>>>>>>> + TestKind FileTimeTKind>
>>>>>>>>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpec, Base,
>>>>>>>>>>>>>>>> TK_FloatingPoint,
>>>>>>>>>>>>>>>> + FileTimeTKind> : public Base {
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> static bool test() { return true; }
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>> @@ -182,19 +274,33 @@ struct TestClock {
>>>>>>>>>>>>>>>> static time_point now() noexcept { return {}; }
>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -template <class IntType, class Dur = duration<IntType,
>>>>>>>>>>>>>>>> std::micro> >
>>>>>>>>>>>>>>>> -using TestFileTimeT = time_point<TestClock<Dur> >;
>>>>>>>>>>>>>>>> +template <class IntType, class Period = std::micro>
>>>>>>>>>>>>>>>> +using TestFileTimeT =
>>>>>>>>>>>>>>>> time_point<TestClock<duration<IntType, Period> > >;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main() {
>>>>>>>>>>>>>>>> - assert((
>>>>>>>>>>>>>>>> - check_is_representable<file_time_type, time_t,
>>>>>>>>>>>>>>>> struct timespec>::test()));
>>>>>>>>>>>>>>>> - assert((check_is_representable<TestFileTimeT<int64_t>,
>>>>>>>>>>>>>>>> int64_t,
>>>>>>>>>>>>>>>> - TestTimeSpec<int64_t,
>>>>>>>>>>>>>>>> long> >::test()));
>>>>>>>>>>>>>>>> - assert((check_is_representable<TestFileTimeT<long long>,
>>>>>>>>>>>>>>>> int32_t,
>>>>>>>>>>>>>>>> - TestTimeSpec<int32_t,
>>>>>>>>>>>>>>>> int32_t> >::test()));
>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>> - // Test that insane platforms like ppc64 linux, which
>>>>>>>>>>>>>>>> use long double as time_t,
>>>>>>>>>>>>>>>> - // at least compile.
>>>>>>>>>>>>>>>> - assert((check_is_representable<TestFileTimeT<long
>>>>>>>>>>>>>>>> double>, double,
>>>>>>>>>>>>>>>> - TestTimeSpec<long double,
>>>>>>>>>>>>>>>> long> >::test()));
>>>>>>>>>>>>>>>> + { assert((test_case<file_time_type, time_t, struct
>>>>>>>>>>>>>>>> timespec>::test())); }
>>>>>>>>>>>>>>>> + {
>>>>>>>>>>>>>>>> + assert((test_case<TestFileTimeT<int64_t>, int64_t,
>>>>>>>>>>>>>>>> + TestTimeSpec<int64_t, long>
>>>>>>>>>>>>>>>> >::test()));
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> + {
>>>>>>>>>>>>>>>> + assert((test_case<TestFileTimeT<long long>, int32_t,
>>>>>>>>>>>>>>>> + TestTimeSpec<int32_t, int32_t>
>>>>>>>>>>>>>>>> >::test()));
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> + {
>>>>>>>>>>>>>>>> + // Test that insane platforms like ppc64 linux, which
>>>>>>>>>>>>>>>> use long double as time_t,
>>>>>>>>>>>>>>>> + // at least compile.
>>>>>>>>>>>>>>>> + assert((test_case<TestFileTimeT<long double>, double,
>>>>>>>>>>>>>>>> + TestTimeSpec<long double, long>
>>>>>>>>>>>>>>>> >::test()));
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +#ifndef TEST_HAS_NO_INT128_T
>>>>>>>>>>>>>>>> + {
>>>>>>>>>>>>>>>> + assert((test_case<TestFileTimeT<__int128_t,
>>>>>>>>>>>>>>>> std::nano>, int64_t,
>>>>>>>>>>>>>>>> + TestTimeSpec<int64_t, long>
>>>>>>>>>>>>>>>> >::test()));
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> + {
>>>>>>>>>>>>>>>> + assert((test_case<TestFileTimeT<__int128_t,
>>>>>>>>>>>>>>>> std::nano>, int32_t,
>>>>>>>>>>>>>>>> + TestTimeSpec<int32_t, int32_t>
>>>>>>>>>>>>>>>> >::test()));
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> ---
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp
>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>> +++
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp
>>>>>>>>>>>>>>>> Wed Jul 25 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -17,15 +17,30 @@
>>>>>>>>>>>>>>>> #include <chrono>
>>>>>>>>>>>>>>>> #include <type_traits>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> +#include "test_macros.h"
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> // system_clock is used because it meets the requirements
>>>>>>>>>>>>>>>> of TrivialClock,
>>>>>>>>>>>>>>>> // and the resolution and range of system_clock should
>>>>>>>>>>>>>>>> match the operating
>>>>>>>>>>>>>>>> // system's file time type.
>>>>>>>>>>>>>>>> -typedef std::chrono::system_clock
>>>>>>>>>>>>>>>> ExpectedClock;
>>>>>>>>>>>>>>>> -typedef std::chrono::time_point<ExpectedClock>
>>>>>>>>>>>>>>>> ExpectedTimePoint;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +void test_trivial_clock() {
>>>>>>>>>>>>>>>> + using namespace fs;
>>>>>>>>>>>>>>>> + using Clock = file_time_type::clock;
>>>>>>>>>>>>>>>> + ASSERT_NOEXCEPT(Clock::now());
>>>>>>>>>>>>>>>> + ASSERT_SAME_TYPE(decltype(Clock::now()), file_time_type);
>>>>>>>>>>>>>>>> + ASSERT_SAME_TYPE(Clock::time_point, file_time_type);
>>>>>>>>>>>>>>>> + volatile auto* odr_use = &Clock::is_steady;
>>>>>>>>>>>>>>>> + ((void)odr_use);
>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +void test_time_point_resolution_and_range() {
>>>>>>>>>>>>>>>> + using namespace fs;
>>>>>>>>>>>>>>>> + using Dur = file_time_type::duration;
>>>>>>>>>>>>>>>> + using Period = Dur::period;
>>>>>>>>>>>>>>>> + ASSERT_SAME_TYPE(Period, std::nano);
>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main() {
>>>>>>>>>>>>>>>> - static_assert(std::is_same<
>>>>>>>>>>>>>>>> - fs::file_time_type,
>>>>>>>>>>>>>>>> - ExpectedTimePoint
>>>>>>>>>>>>>>>> - >::value, "");
>>>>>>>>>>>>>>>> + test_trivial_clock();
>>>>>>>>>>>>>>>> + test_time_point_resolution_and_range();
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>> ---
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>> +++
>>>>>>>>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>>>>>>>> Wed Jul 25 13:51:49 2018
>>>>>>>>>>>>>>>> @@ -30,13 +30,86 @@
>>>>>>>>>>>>>>>> #include <sys/stat.h>
>>>>>>>>>>>>>>>> #include <iostream>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> +#include <fcntl.h>
>>>>>>>>>>>>>>>> +#include <sys/time.h>
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> using namespace fs;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> -struct Times { std::time_t access, write; };
>>>>>>>>>>>>>>>> +using TimeSpec = struct ::timespec;
>>>>>>>>>>>>>>>> +using StatT = struct ::stat;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +using Sec = std::chrono::duration<file_time_type::rep>;
>>>>>>>>>>>>>>>> +using Hours = std::chrono::hours;
>>>>>>>>>>>>>>>> +using Minutes = std::chrono::minutes;
>>>>>>>>>>>>>>>> +using MicroSec =
>>>>>>>>>>>>>>>> std::chrono::duration<file_time_type::rep, std::micro>;
>>>>>>>>>>>>>>>> +using NanoSec = std::chrono::duration<file_time_type::rep,
>>>>>>>>>>>>>>>> std::nano>;
>>>>>>>>>>>>>>>> +using std::chrono::duration_cast;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +#if defined(__APPLE__)
>>>>>>>>>>>>>>>> +TimeSpec extract_mtime(StatT const& st) { return
>>>>>>>>>>>>>>>> st.st_mtimespec; }
>>>>>>>>>>>>>>>> +TimeSpec extract_atime(StatT const& st) { return
>>>>>>>>>>>>>>>> st.st_atimespec; }
>>>>>>>>>>>>>>>> +#else
>>>>>>>>>>>>>>>> +TimeSpec extract_mtime(StatT const& st) { return
>>>>>>>>>>>>>>>> st.st_mtim; }
>>>>>>>>>>>>>>>> +TimeSpec extract_atime(StatT const& st) { return
>>>>>>>>>>>>>>>> st.st_atim; }
>>>>>>>>>>>>>>>> +#endif
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +bool ConvertToTimeSpec(TimeSpec& ts, file_time_type ft) {
>>>>>>>>>>>>>>>> + using SecFieldT = decltype(TimeSpec::tv_sec);
>>>>>>>>>>>>>>>> + using NSecFieldT = decltype(TimeSpec::tv_nsec);
>>>>>>>>>>>>>>>> + using SecLim = std::numeric_limits<SecFieldT>;
>>>>>>>>>>>>>>>> + using NSecLim = std::numeric_limits<NSecFieldT>;
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> + auto secs = duration_cast<Sec>(ft.time_since_epoch());
>>>>>>>>>>>>>>>> + auto nsecs =
>>>>>>>>>>>>>>>> duration_cast<NanoSec>(ft.time_since_epoch() - secs);
>>>>>>>>>>>>>>>> + if (nsecs.count() < 0) {
>>>>>>>>>>>>>>>> + if (Sec::min().count() > SecLim::min()) {
>>>>>>>>>>>>>>>> + secs += Sec(1);
>>>>>>>>>>>>>>>> + nsecs -= Sec(1);
>>>>>>>>>>>>>>>> + } else {
>>>>>>>>>>>>>>>> + nsecs = NanoSec(0);
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>> + if (SecLim::max() < secs.count() || SecLim::min() >
>>>>>>>>>>>>>>>> secs.count())
>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>> + if (NSecLim::max() < nsecs.count() || NSecLim::min() >
>>>>>>>>>>>>>>>> nsecs.count())
>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>> + ts.tv_sec = secs.count();
>>>>>>>>>>>>>>>> + ts.tv_nsec = nsecs.count();
>>>>>>>>>>>>>>>> + return true;
>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +bool ConvertFromTimeSpec(file_time_type& ft, TimeSpec ts) {
>>>>>>>>>>>>>>>> + auto secs_part =
>>>>>>>>>>>>>>>> duration_cast<file_time_type::duration>(Sec(ts.tv_sec));
>>>>>>>>>>>>>>>> + if (duration_cast<Sec>(secs_part).count() != ts.tv_sec)
>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>> + auto subsecs =
>>>>>>>>>>>>>>>> duration_cast<file_time_type::duration>(NanoSec(ts.tv_nsec));
>>>>>>>>>>>>>>>> + auto dur = secs_part + subsecs;
>>>>>>>>>>>>>>>> + if (dur < secs_part && subsecs.count() >= 0)
>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>> + ft = file_time_type(dur);
>>>>>>>>>>>>>>>> + return true;
>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>> +bool CompareTimeExact(TimeSpec ts, TimeSpec ts2) {
>>>>>>>>>>>>>>>> + return ts2.tv_sec == ts.tv_sec && ts2.tv_nsec ==
>>>>>>>>>>>>>>>> ts.tv_nsec;
>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>> +bool CompareTimeExact(file_time_type ft, TimeSpec ts) {
>>>>>>>>>>>>>>>> + TimeSpec ts2
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20180725/b745fba8/attachment-0001.html>
More information about the cfe-commits
mailing list