From 90e8e06d349074dc58e81a15355b4756285c8182 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 2 Sep 2015 00:49:16 +0200
Subject: Refactor pytime.c

Move code to convert double timestamp to subfunctions.
---
 Python/pytime.c | 113 ++++++++++++++++++++++++++++++++------------------------
 1 file changed, 65 insertions(+), 48 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 02a93749c7..17ef197225 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -61,43 +61,51 @@ _PyLong_FromTime_t(time_t t)
 }
 
 static int
-_PyTime_ObjectToDenominator(PyObject *obj, time_t *sec, long *numerator,
+_PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
                             double denominator, _PyTime_round_t round)
 {
-    assert(denominator <= LONG_MAX);
-    if (PyFloat_Check(obj)) {
-        double d, intpart, err;
-        /* volatile avoids unsafe optimization on float enabled by gcc -O3 */
-        volatile double floatpart;
+    double intpart, err;
+    /* volatile avoids unsafe optimization on float enabled by gcc -O3 */
+    volatile double floatpart;
+
+    floatpart = modf(d, &intpart);
+    if (floatpart < 0) {
+        floatpart = 1.0 + floatpart;
+        intpart -= 1.0;
+    }
 
-        d = PyFloat_AsDouble(obj);
-        floatpart = modf(d, &intpart);
-        if (floatpart < 0) {
-            floatpart = 1.0 + floatpart;
-            intpart -= 1.0;
+    floatpart *= denominator;
+    if (round == _PyTime_ROUND_CEILING) {
+        floatpart = ceil(floatpart);
+        if (floatpart >= denominator) {
+            floatpart = 0.0;
+            intpart += 1.0;
         }
+    }
+    else {
+        floatpart = floor(floatpart);
+    }
 
-        floatpart *= denominator;
-        if (round == _PyTime_ROUND_CEILING) {
-            floatpart = ceil(floatpart);
-            if (floatpart >= denominator) {
-                floatpart = 0.0;
-                intpart += 1.0;
-            }
-        }
-        else {
-            floatpart = floor(floatpart);
-        }
+    *sec = (time_t)intpart;
+    err = intpart - (double)*sec;
+    if (err <= -1.0 || err >= 1.0) {
+        error_time_t_overflow();
+        return -1;
+    }
 
-        *sec = (time_t)intpart;
-        err = intpart - (double)*sec;
-        if (err <= -1.0 || err >= 1.0) {
-            error_time_t_overflow();
-            return -1;
-        }
+    *numerator = (long)floatpart;
+    return 0;
+}
 
-        *numerator = (long)floatpart;
-        return 0;
+static int
+_PyTime_ObjectToDenominator(PyObject *obj, time_t *sec, long *numerator,
+                            double denominator, _PyTime_round_t round)
+{
+    assert(denominator <= LONG_MAX);
+    if (PyFloat_Check(obj)) {
+        double d = PyFloat_AsDouble(obj);
+        return _PyTime_DoubleToDenominator(d, sec, numerator,
+                                           denominator, round);
     }
     else {
         *sec = _PyLong_AsTime_t(obj);
@@ -220,30 +228,39 @@ _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv, int raise)
 }
 #endif
 
+static int
+_PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
+                        long to_nanoseconds)
+{
+    /* volatile avoids unsafe optimization on float enabled by gcc -O3 */
+    volatile double d, err;
+
+    /* convert to a number of nanoseconds */
+    d = value;
+    d *= to_nanoseconds;
+
+    if (round == _PyTime_ROUND_CEILING)
+        d = ceil(d);
+    else
+        d = floor(d);
+
+    *t = (_PyTime_t)d;
+    err = d - (double)*t;
+    if (fabs(err) >= 1.0) {
+        _PyTime_overflow();
+        return -1;
+    }
+    return 0;
+}
+
 static int
 _PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round,
                    long to_nanoseconds)
 {
     if (PyFloat_Check(obj)) {
-        /* volatile avoids unsafe optimization on float enabled by gcc -O3 */
-        volatile double d, err;
-
-        /* convert to a number of nanoseconds */
+        double d;
         d = PyFloat_AsDouble(obj);
-        d *= to_nanoseconds;
-
-        if (round == _PyTime_ROUND_CEILING)
-            d = ceil(d);
-        else
-            d = floor(d);
-
-        *t = (_PyTime_t)d;
-        err = d - (double)*t;
-        if (fabs(err) >= 1.0) {
-            _PyTime_overflow();
-            return -1;
-        }
-        return 0;
+        return _PyTime_FromFloatObject(t, d, round, to_nanoseconds);
     }
     else {
 #ifdef HAVE_LONG_LONG
-- 
cgit v1.2.1


From ea4bd213402a67d964b8edd7221d98eecc806be7 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 2 Sep 2015 00:50:43 +0200
Subject: Move assertion inside _PyTime_ObjectToTimeval()

Change also _PyTime_FromSeconds() assertion to ensure that the _PyTime_t type
is used.
---
 Python/pytime.c | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 17ef197225..fcac68a389 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -101,7 +101,8 @@ static int
 _PyTime_ObjectToDenominator(PyObject *obj, time_t *sec, long *numerator,
                             double denominator, _PyTime_round_t round)
 {
-    assert(denominator <= LONG_MAX);
+    assert(denominator <= (double)LONG_MAX);
+
     if (PyFloat_Check(obj)) {
         double d = PyFloat_AsDouble(obj);
         return _PyTime_DoubleToDenominator(d, sec, numerator,
@@ -149,14 +150,20 @@ int
 _PyTime_ObjectToTimespec(PyObject *obj, time_t *sec, long *nsec,
                          _PyTime_round_t round)
 {
-    return _PyTime_ObjectToDenominator(obj, sec, nsec, 1e9, round);
+    int res;
+    res = _PyTime_ObjectToDenominator(obj, sec, nsec, 1e9, round);
+    assert(0 <= *nsec && *nsec < SEC_TO_NS );
+    return res;
 }
 
 int
 _PyTime_ObjectToTimeval(PyObject *obj, time_t *sec, long *usec,
                         _PyTime_round_t round)
 {
-    return _PyTime_ObjectToDenominator(obj, sec, usec, 1e6, round);
+    int res;
+    res = _PyTime_ObjectToDenominator(obj, sec, usec, 1e6, round);
+    assert(0 <= *usec && *usec < SEC_TO_US );
+    return res;
 }
 
 static void
@@ -170,12 +177,13 @@ _PyTime_t
 _PyTime_FromSeconds(int seconds)
 {
     _PyTime_t t;
+    t = (_PyTime_t)seconds;
     /* ensure that integer overflow cannot happen, int type should have 32
        bits, whereas _PyTime_t type has at least 64 bits (SEC_TO_MS takes 30
        bits). */
-    assert((seconds >= 0 && seconds <= _PyTime_MAX / SEC_TO_NS)
-           || (seconds < 0 && seconds >= _PyTime_MIN / SEC_TO_NS));
-    t = (_PyTime_t)seconds * SEC_TO_NS;
+    assert((t >= 0 && t <= _PyTime_MAX / SEC_TO_NS)
+           || (t < 0 && t >= _PyTime_MIN / SEC_TO_NS));
+    t *= SEC_TO_NS;
     return t;
 }
 
-- 
cgit v1.2.1


From d0ee151e3b640eae2a63b1c13860837d3ece2cda Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 2 Sep 2015 01:43:56 +0200
Subject: Issue #23517: Add "half up" rounding mode to the _PyTime API

---
 Python/pytime.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 54 insertions(+), 10 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index fcac68a389..3294e0f49b 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -60,6 +60,17 @@ _PyLong_FromTime_t(time_t t)
 #endif
 }
 
+static double
+_PyTime_RoundHalfUp(double x)
+{
+    if (x >= 0.0)
+        x = floor(x + 0.5);
+    else
+        x = ceil(x - 0.5);
+    return x;
+}
+
+
 static int
 _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
                             double denominator, _PyTime_round_t round)
@@ -75,7 +86,9 @@ _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
     }
 
     floatpart *= denominator;
-    if (round == _PyTime_ROUND_CEILING) {
+    if (round == _PyTime_ROUND_HALF_UP)
+        floatpart = _PyTime_RoundHalfUp(floatpart);
+    else if (round == _PyTime_ROUND_CEILING) {
         floatpart = ceil(floatpart);
         if (floatpart >= denominator) {
             floatpart = 0.0;
@@ -124,7 +137,9 @@ _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round)
         double d, intpart, err;
 
         d = PyFloat_AsDouble(obj);
-        if (round == _PyTime_ROUND_CEILING)
+        if (round == _PyTime_ROUND_HALF_UP)
+            d = _PyTime_RoundHalfUp(d);
+        else if (round == _PyTime_ROUND_CEILING)
             d = ceil(d);
         else
             d = floor(d);
@@ -247,7 +262,9 @@ _PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
     d = value;
     d *= to_nanoseconds;
 
-    if (round == _PyTime_ROUND_CEILING)
+    if (round == _PyTime_ROUND_HALF_UP)
+        d = _PyTime_RoundHalfUp(d);
+    else if (round == _PyTime_ROUND_CEILING)
         d = ceil(d);
     else
         d = floor(d);
@@ -333,7 +350,19 @@ static _PyTime_t
 _PyTime_Divide(_PyTime_t t, _PyTime_t k, _PyTime_round_t round)
 {
     assert(k > 1);
-    if (round == _PyTime_ROUND_CEILING) {
+    if (round == _PyTime_ROUND_HALF_UP) {
+        _PyTime_t x, r;
+        x = t / k;
+        r = t % k;
+        if (Py_ABS(r) >= k / 2) {
+            if (t >= 0)
+                x++;
+            else
+                x--;
+        }
+        return x;
+    }
+    else if (round == _PyTime_ROUND_CEILING) {
         if (t >= 0)
             return (t + k - 1) / k;
         else
@@ -359,8 +388,10 @@ static int
 _PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
                        int raise)
 {
+    const long k = US_TO_NS;
     _PyTime_t secs, ns;
     int res = 0;
+    int usec;
 
     secs = t / SEC_TO_NS;
     ns = t % SEC_TO_NS;
@@ -392,20 +423,33 @@ _PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
         res = -1;
 #endif
 
-    if (round == _PyTime_ROUND_CEILING)
-        tv->tv_usec = (int)((ns + US_TO_NS - 1) / US_TO_NS);
+    if (round == _PyTime_ROUND_HALF_UP) {
+        _PyTime_t r;
+        usec = (int)(ns / k);
+        r = ns % k;
+        if (Py_ABS(r) >= k / 2) {
+            if (ns >= 0)
+                usec++;
+            else
+                usec--;
+        }
+    }
+    else if (round == _PyTime_ROUND_CEILING)
+        usec = (int)((ns + k - 1) / k);
     else
-        tv->tv_usec = (int)(ns / US_TO_NS);
+        usec = (int)(ns / k);
 
-    if (tv->tv_usec >= SEC_TO_US) {
-        tv->tv_usec -= SEC_TO_US;
+    if (usec >= SEC_TO_US) {
+        usec -= SEC_TO_US;
         tv->tv_sec += 1;
     }
 
     if (res && raise)
         _PyTime_overflow();
 
-    assert(0 <= tv->tv_usec && tv->tv_usec <= 999999);
+    assert(0 <= usec && usec <= 999999);
+
+    tv->tv_usec = usec;
     return res;
 }
 
-- 
cgit v1.2.1


From 03030b95ebb8b1583fa8d9b6859f10bf59cb83ad Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 2 Sep 2015 10:37:46 +0200
Subject: Issue #23517: Fix _PyTime_ObjectToDenominator()

* initialize numerator on overflow error ensure that numerator is smaller than
* denominator.
---
 Python/pytime.c | 35 +++++++++++++++++------------------
 1 file changed, 17 insertions(+), 18 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 3294e0f49b..8a2579b792 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -60,6 +60,7 @@ _PyLong_FromTime_t(time_t t)
 #endif
 }
 
+/* Round to nearest with ties going away from zero (_PyTime_ROUND_HALF_UP). */
 static double
 _PyTime_RoundHalfUp(double x)
 {
@@ -81,32 +82,31 @@ _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
 
     floatpart = modf(d, &intpart);
     if (floatpart < 0) {
-        floatpart = 1.0 + floatpart;
+        floatpart += 1.0;
         intpart -= 1.0;
     }
 
     floatpart *= denominator;
     if (round == _PyTime_ROUND_HALF_UP)
         floatpart = _PyTime_RoundHalfUp(floatpart);
-    else if (round == _PyTime_ROUND_CEILING) {
+    else if (round == _PyTime_ROUND_CEILING)
         floatpart = ceil(floatpart);
-        if (floatpart >= denominator) {
-            floatpart = 0.0;
-            intpart += 1.0;
-        }
-    }
-    else {
+    else
         floatpart = floor(floatpart);
+    if (floatpart >= denominator) {
+        floatpart -= denominator;
+        intpart += 1.0;
     }
+    assert(0.0 <= floatpart && floatpart < denominator);
 
     *sec = (time_t)intpart;
+    *numerator = (long)floatpart;
+
     err = intpart - (double)*sec;
     if (err <= -1.0 || err >= 1.0) {
         error_time_t_overflow();
         return -1;
     }
-
-    *numerator = (long)floatpart;
     return 0;
 }
 
@@ -123,9 +123,9 @@ _PyTime_ObjectToDenominator(PyObject *obj, time_t *sec, long *numerator,
     }
     else {
         *sec = _PyLong_AsTime_t(obj);
+        *numerator = 0;
         if (*sec == (time_t)-1 && PyErr_Occurred())
             return -1;
-        *numerator = 0;
         return 0;
     }
 }
@@ -167,7 +167,7 @@ _PyTime_ObjectToTimespec(PyObject *obj, time_t *sec, long *nsec,
 {
     int res;
     res = _PyTime_ObjectToDenominator(obj, sec, nsec, 1e9, round);
-    assert(0 <= *nsec && *nsec < SEC_TO_NS );
+    assert(0 <= *nsec && *nsec < SEC_TO_NS);
     return res;
 }
 
@@ -177,7 +177,7 @@ _PyTime_ObjectToTimeval(PyObject *obj, time_t *sec, long *usec,
 {
     int res;
     res = _PyTime_ObjectToDenominator(obj, sec, usec, 1e6, round);
-    assert(0 <= *usec && *usec < SEC_TO_US );
+    assert(0 <= *usec && *usec < SEC_TO_US);
     return res;
 }
 
@@ -444,12 +444,11 @@ _PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
         tv->tv_sec += 1;
     }
 
+    assert(0 <= usec && usec < SEC_TO_US);
+    tv->tv_usec = usec;
+
     if (res && raise)
         _PyTime_overflow();
-
-    assert(0 <= usec && usec <= 999999);
-
-    tv->tv_usec = usec;
     return res;
 }
 
@@ -484,7 +483,7 @@ _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts)
     }
     ts->tv_nsec = nsec;
 
-    assert(0 <= ts->tv_nsec && ts->tv_nsec <= 999999999);
+    assert(0 <= ts->tv_nsec && ts->tv_nsec < SEC_TO_NS);
     return 0;
 }
 #endif
-- 
cgit v1.2.1


From af05039c1f6f6ec4f969f0fff5b9d7bdcf3af0ee Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 2 Sep 2015 11:58:56 +0200
Subject: Issue #23517: Try to fix test_time on "x86 Ubuntu Shared 3.x"
 buildbot

---
 Python/pytime.c | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 8a2579b792..ffb390afe5 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -64,11 +64,13 @@ _PyLong_FromTime_t(time_t t)
 static double
 _PyTime_RoundHalfUp(double x)
 {
-    if (x >= 0.0)
-        x = floor(x + 0.5);
+    /* volatile avoids optimization changing how numbers are rounded */
+    volatile double d = x;
+    if (d >= 0.0)
+        d = floor(d + 0.5);
     else
-        x = ceil(x - 0.5);
-    return x;
+        d = ceil(d - 0.5);
+    return d;
 }
 
 
@@ -77,7 +79,7 @@ _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
                             double denominator, _PyTime_round_t round)
 {
     double intpart, err;
-    /* volatile avoids unsafe optimization on float enabled by gcc -O3 */
+    /* volatile avoids optimization changing how numbers are rounded */
     volatile double floatpart;
 
     floatpart = modf(d, &intpart);
@@ -134,7 +136,8 @@ int
 _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round)
 {
     if (PyFloat_Check(obj)) {
-        double d, intpart, err;
+        /* volatile avoids optimization changing how numbers are rounded */
+        volatile double d, intpart, err;
 
         d = PyFloat_AsDouble(obj);
         if (round == _PyTime_ROUND_HALF_UP)
@@ -255,7 +258,7 @@ static int
 _PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
                         long to_nanoseconds)
 {
-    /* volatile avoids unsafe optimization on float enabled by gcc -O3 */
+    /* volatile avoids optimization changing how numbers are rounded */
     volatile double d, err;
 
     /* convert to a number of nanoseconds */
-- 
cgit v1.2.1


From ea58c6adb1a11497266bc69f0629feb2fb541fa9 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 2 Sep 2015 19:16:07 +0200
Subject: Issue #23517: datetime.timedelta constructor now rounds microseconds
 to nearest with ties going away from zero (ROUND_HALF_UP), as Python 2 and
 Python older than 3.3, instead of rounding to nearest with ties going to
 nearest even integer (ROUND_HALF_EVEN).

---
 Python/pytime.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index ffb390afe5..02a1edfea0 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -60,8 +60,7 @@ _PyLong_FromTime_t(time_t t)
 #endif
 }
 
-/* Round to nearest with ties going away from zero (_PyTime_ROUND_HALF_UP). */
-static double
+double
 _PyTime_RoundHalfUp(double x)
 {
     /* volatile avoids optimization changing how numbers are rounded */
-- 
cgit v1.2.1


From 70192d08abe7e46c418bbbc309d32f8c936bcb4e Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 3 Sep 2015 16:25:45 +0200
Subject: Enhance _PyTime_AsTimespec()

Ensure that the tv_nsec field is set, even if the function fails
with an overflow.
---
 Python/pytime.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 8166ceccc5..cea3cf5d43 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -479,13 +479,13 @@ _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts)
         secs -= 1;
     }
     ts->tv_sec = (time_t)secs;
+    assert(0 <= nsec && nsec < SEC_TO_NS);
+    ts->tv_nsec = nsec;
+
     if ((_PyTime_t)ts->tv_sec != secs) {
         _PyTime_overflow();
         return -1;
     }
-    ts->tv_nsec = nsec;
-
-    assert(0 <= ts->tv_nsec && ts->tv_nsec < SEC_TO_NS);
     return 0;
 }
 #endif
-- 
cgit v1.2.1


From c894ad91051a6eb8e23be06dc1cc421a54d69907 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 3 Sep 2015 16:33:16 +0200
Subject: Don't abuse volatile keyword in pytime.c

Only use it on the most important number. This change fixes also a compiler
warning on modf().
---
 Python/pytime.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index cea3cf5d43..d226389a7c 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -135,8 +135,9 @@ int
 _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round)
 {
     if (PyFloat_Check(obj)) {
+        double intpart, err;
         /* volatile avoids optimization changing how numbers are rounded */
-        volatile double d, intpart, err;
+        volatile double d;
 
         d = PyFloat_AsDouble(obj);
         if (round == _PyTime_ROUND_HALF_UP)
@@ -257,8 +258,9 @@ static int
 _PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
                         long to_nanoseconds)
 {
+    double err;
     /* volatile avoids optimization changing how numbers are rounded */
-    volatile double d, err;
+    volatile double d;
 
     /* convert to a number of nanoseconds */
     d = value;
-- 
cgit v1.2.1


From 85ed934b48ca506799d4d531db87e5e3aea2fb96 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Fri, 4 Sep 2015 23:57:25 +0200
Subject: Issue #23517: Fix implementation of the ROUND_HALF_UP rounding mode
 in datetime.datetime.fromtimestamp() and
 datetime.datetime.utcfromtimestamp(). microseconds sign should be kept before
 rounding.

---
 Python/pytime.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index d226389a7c..036447365c 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -82,10 +82,6 @@ _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
     volatile double floatpart;
 
     floatpart = modf(d, &intpart);
-    if (floatpart < 0) {
-        floatpart += 1.0;
-        intpart -= 1.0;
-    }
 
     floatpart *= denominator;
     if (round == _PyTime_ROUND_HALF_UP)
@@ -98,6 +94,10 @@ _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
         floatpart -= denominator;
         intpart += 1.0;
     }
+    else if (floatpart < 0) {
+        floatpart += denominator;
+        intpart -= 1.0;
+    }
     assert(0.0 <= floatpart && floatpart < denominator);
 
     *sec = (time_t)intpart;
-- 
cgit v1.2.1


From fb8809cbfa9e3302900ffb10b732626ce864157c Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 9 Sep 2015 01:02:23 +0200
Subject: Issue #23517: fromtimestamp() and utcfromtimestamp() methods of
 datetime.datetime now round microseconds to nearest with ties going to
 nearest even integer (ROUND_HALF_EVEN), as round(float), instead of rounding
 towards -Infinity (ROUND_FLOOR).

pytime API: replace _PyTime_ROUND_HALF_UP with _PyTime_ROUND_HALF_EVEN. Fix
also _PyTime_Divide() for negative numbers.

_PyTime_AsTimeval_impl() now reuses _PyTime_Divide() instead of reimplementing
rounding modes.
---
 Python/pytime.c | 71 +++++++++++++++++++++++----------------------------------
 1 file changed, 29 insertions(+), 42 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 036447365c..9f7ee2d0ed 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -61,18 +61,15 @@ _PyLong_FromTime_t(time_t t)
 }
 
 double
-_PyTime_RoundHalfUp(double x)
+_PyTime_RoundHalfEven(double x)
 {
-    /* volatile avoids optimization changing how numbers are rounded */
-    volatile double d = x;
-    if (d >= 0.0)
-        d = floor(d + 0.5);
-    else
-        d = ceil(d - 0.5);
-    return d;
+    double rounded = round(x);
+    if (fabs(x-rounded) == 0.5)
+        /* halfway case: round to even */
+        rounded = 2.0*round(x/2.0);
+    return rounded;
 }
 
-
 static int
 _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
                             double denominator, _PyTime_round_t round)
@@ -84,8 +81,8 @@ _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
     floatpart = modf(d, &intpart);
 
     floatpart *= denominator;
-    if (round == _PyTime_ROUND_HALF_UP)
-        floatpart = _PyTime_RoundHalfUp(floatpart);
+    if (round == _PyTime_ROUND_HALF_EVEN)
+        floatpart = _PyTime_RoundHalfEven(floatpart);
     else if (round == _PyTime_ROUND_CEILING)
         floatpart = ceil(floatpart);
     else
@@ -140,8 +137,8 @@ _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round)
         volatile double d;
 
         d = PyFloat_AsDouble(obj);
-        if (round == _PyTime_ROUND_HALF_UP)
-            d = _PyTime_RoundHalfUp(d);
+        if (round == _PyTime_ROUND_HALF_EVEN)
+            d = _PyTime_RoundHalfEven(d);
         else if (round == _PyTime_ROUND_CEILING)
             d = ceil(d);
         else
@@ -266,8 +263,8 @@ _PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
     d = value;
     d *= to_nanoseconds;
 
-    if (round == _PyTime_ROUND_HALF_UP)
-        d = _PyTime_RoundHalfUp(d);
+    if (round == _PyTime_ROUND_HALF_EVEN)
+        d = _PyTime_RoundHalfEven(d);
     else if (round == _PyTime_ROUND_CEILING)
         d = ceil(d);
     else
@@ -351,14 +348,16 @@ _PyTime_AsNanosecondsObject(_PyTime_t t)
 }
 
 static _PyTime_t
-_PyTime_Divide(_PyTime_t t, _PyTime_t k, _PyTime_round_t round)
+_PyTime_Divide(const _PyTime_t t, const _PyTime_t k,
+               const _PyTime_round_t round)
 {
     assert(k > 1);
-    if (round == _PyTime_ROUND_HALF_UP) {
-        _PyTime_t x, r;
+    if (round == _PyTime_ROUND_HALF_EVEN) {
+        _PyTime_t x, r, abs_r;
         x = t / k;
         r = t % k;
-        if (Py_ABS(r) >= k / 2) {
+        abs_r = Py_ABS(r);
+        if (abs_r > k / 2 || (abs_r == k / 2 && (Py_ABS(x) & 1))) {
             if (t >= 0)
                 x++;
             else
@@ -369,11 +368,15 @@ _PyTime_Divide(_PyTime_t t, _PyTime_t k, _PyTime_round_t round)
     else if (round == _PyTime_ROUND_CEILING) {
         if (t >= 0)
             return (t + k - 1) / k;
+        else
+            return t / k;
+    }
+    else {
+        if (t >= 0)
+            return t / k;
         else
             return (t - (k - 1)) / k;
     }
-    else
-        return t / k;
 }
 
 _PyTime_t
@@ -392,17 +395,12 @@ static int
 _PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
                        int raise)
 {
-    const long k = US_TO_NS;
     _PyTime_t secs, ns;
     int res = 0;
     int usec;
 
     secs = t / SEC_TO_NS;
     ns = t % SEC_TO_NS;
-    if (ns < 0) {
-        ns += SEC_TO_NS;
-        secs -= 1;
-    }
 
 #ifdef MS_WINDOWS
     /* On Windows, timeval.tv_sec is a long (32 bit),
@@ -427,23 +425,12 @@ _PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
         res = -1;
 #endif
 
-    if (round == _PyTime_ROUND_HALF_UP) {
-        _PyTime_t r;
-        usec = (int)(ns / k);
-        r = ns % k;
-        if (Py_ABS(r) >= k / 2) {
-            if (ns >= 0)
-                usec++;
-            else
-                usec--;
-        }
+    usec = (int)_PyTime_Divide(ns, US_TO_NS, round);
+    if (usec < 0) {
+        usec += SEC_TO_US;
+        tv->tv_sec -= 1;
     }
-    else if (round == _PyTime_ROUND_CEILING)
-        usec = (int)((ns + k - 1) / k);
-    else
-        usec = (int)(ns / k);
-
-    if (usec >= SEC_TO_US) {
+    else if (usec >= SEC_TO_US) {
         usec -= SEC_TO_US;
         tv->tv_sec += 1;
     }
-- 
cgit v1.2.1


From 44e262519e28bd9149a791b4a0f1d5087595abc5 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 9 Sep 2015 22:28:09 +0200
Subject: Make _PyTime_RoundHalfEven() private again

---
 Python/pytime.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 9f7ee2d0ed..37dfabbb0a 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -60,7 +60,9 @@ _PyLong_FromTime_t(time_t t)
 #endif
 }
 
-double
+/* Round to nearest with ties going to nearest even integer
+   (_PyTime_ROUND_HALF_EVEN) */
+static double
 _PyTime_RoundHalfEven(double x)
 {
     double rounded = round(x);
-- 
cgit v1.2.1


From 3876e1b59e0f11407d2db9029b7741da8b3788d0 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 9 Sep 2015 22:28:58 +0200
Subject: pytime: add _PyTime_Round() helper to factorize code

---
 Python/pytime.c | 45 ++++++++++++++++++++-------------------------
 1 file changed, 20 insertions(+), 25 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 37dfabbb0a..973550600f 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -72,6 +72,17 @@ _PyTime_RoundHalfEven(double x)
     return rounded;
 }
 
+static double
+_PyTime_Round(double x, _PyTime_round_t round)
+{
+    if (round == _PyTime_ROUND_HALF_EVEN)
+        return _PyTime_RoundHalfEven(x);
+    else if (round == _PyTime_ROUND_CEILING)
+        return ceil(x);
+    else
+        return floor(x);
+}
+
 static int
 _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
                             double denominator, _PyTime_round_t round)
@@ -83,12 +94,7 @@ _PyTime_DoubleToDenominator(double d, time_t *sec, long *numerator,
     floatpart = modf(d, &intpart);
 
     floatpart *= denominator;
-    if (round == _PyTime_ROUND_HALF_EVEN)
-        floatpart = _PyTime_RoundHalfEven(floatpart);
-    else if (round == _PyTime_ROUND_CEILING)
-        floatpart = ceil(floatpart);
-    else
-        floatpart = floor(floatpart);
+    floatpart = _PyTime_Round(floatpart, round);
     if (floatpart >= denominator) {
         floatpart -= denominator;
         intpart += 1.0;
@@ -139,12 +145,7 @@ _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round)
         volatile double d;
 
         d = PyFloat_AsDouble(obj);
-        if (round == _PyTime_ROUND_HALF_EVEN)
-            d = _PyTime_RoundHalfEven(d);
-        else if (round == _PyTime_ROUND_CEILING)
-            d = ceil(d);
-        else
-            d = floor(d);
+        d = _PyTime_Round(d, round);
         (void)modf(d, &intpart);
 
         *sec = (time_t)intpart;
@@ -255,7 +256,7 @@ _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv, int raise)
 
 static int
 _PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
-                        long to_nanoseconds)
+                        long unit_to_ns)
 {
     double err;
     /* volatile avoids optimization changing how numbers are rounded */
@@ -263,14 +264,8 @@ _PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
 
     /* convert to a number of nanoseconds */
     d = value;
-    d *= to_nanoseconds;
-
-    if (round == _PyTime_ROUND_HALF_EVEN)
-        d = _PyTime_RoundHalfEven(d);
-    else if (round == _PyTime_ROUND_CEILING)
-        d = ceil(d);
-    else
-        d = floor(d);
+    d *= (double)unit_to_ns;
+    d = _PyTime_Round(d, round);
 
     *t = (_PyTime_t)d;
     err = d - (double)*t;
@@ -283,12 +278,12 @@ _PyTime_FromFloatObject(_PyTime_t *t, double value, _PyTime_round_t round,
 
 static int
 _PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round,
-                   long to_nanoseconds)
+                   long unit_to_ns)
 {
     if (PyFloat_Check(obj)) {
         double d;
         d = PyFloat_AsDouble(obj);
-        return _PyTime_FromFloatObject(t, d, round, to_nanoseconds);
+        return _PyTime_FromFloatObject(t, d, round, unit_to_ns);
     }
     else {
 #ifdef HAVE_LONG_LONG
@@ -305,8 +300,8 @@ _PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round,
                 _PyTime_overflow();
             return -1;
         }
-        *t = sec * to_nanoseconds;
-        if (*t / to_nanoseconds != sec) {
+        *t = sec * unit_to_ns;
+        if (*t / unit_to_ns != sec) {
             _PyTime_overflow();
             return -1;
         }
-- 
cgit v1.2.1


From 00d73959796abf8ab71adefa9bbc6f46d2ab9cba Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 9 Sep 2015 22:32:48 +0200
Subject: test_time: rewrite PyTime API rounding tests

Drop all hardcoded tests. Instead, reimplement each function in Python, usually
using decimal.Decimal for the rounding mode.

Add much more values to the dataset. Test various timestamp units from
picroseconds to seconds, in integer and float.

Enhance also _PyTime_AsSecondsDouble().
---
 Python/pytime.c | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 973550600f..4c940c98f1 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -324,12 +324,16 @@ _PyTime_FromMillisecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t roun
 double
 _PyTime_AsSecondsDouble(_PyTime_t t)
 {
-    _PyTime_t sec, ns;
-    /* Divide using integers to avoid rounding issues on the integer part.
-       1e-9 cannot be stored exactly in IEEE 64-bit. */
-    sec = t / SEC_TO_NS;
-    ns = t % SEC_TO_NS;
-    return (double)sec + (double)ns * 1e-9;
+    if (t % SEC_TO_NS == 0) {
+        _PyTime_t secs;
+        /* Divide using integers to avoid rounding issues on the integer part.
+           1e-9 cannot be stored exactly in IEEE 64-bit. */
+        secs = t / SEC_TO_NS;
+        return (double)secs;
+    }
+    else {
+        return (double)t / 1e9;
+    }
 }
 
 PyObject *
-- 
cgit v1.2.1


From 18124b247e83d18d2e2332877c0a481a90a97b0c Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 10 Sep 2015 09:10:14 +0200
Subject: Fix test_time on Windows

* Filter values which would overflow on conversion to the C long type
  (for timeval.tv_sec).
* Adjust also the message of OverflowError on PyTime conversions
* test_time: add debug information if a timestamp conversion fails
---
 Python/pytime.c | 28 ++++++++--------------------
 1 file changed, 8 insertions(+), 20 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 4c940c98f1..243f756f3d 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -288,18 +288,21 @@ _PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round,
     else {
 #ifdef HAVE_LONG_LONG
         PY_LONG_LONG sec;
-        sec = PyLong_AsLongLong(obj);
         assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+
+        sec = PyLong_AsLongLong(obj);
 #else
         long sec;
-        sec = PyLong_AsLong(obj);
         assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+
+        sec = PyLong_AsLong(obj);
 #endif
         if (sec == -1 && PyErr_Occurred()) {
             if (PyErr_ExceptionMatches(PyExc_OverflowError))
                 _PyTime_overflow();
             return -1;
         }
+
         *t = sec * unit_to_ns;
         if (*t / unit_to_ns != sec) {
             _PyTime_overflow();
@@ -404,27 +407,12 @@ _PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
     ns = t % SEC_TO_NS;
 
 #ifdef MS_WINDOWS
-    /* On Windows, timeval.tv_sec is a long (32 bit),
-       whereas time_t can be 64-bit. */
-    assert(sizeof(tv->tv_sec) == sizeof(long));
-#if SIZEOF_TIME_T > SIZEOF_LONG
-    if (secs > LONG_MAX) {
-        secs = LONG_MAX;
-        res = -1;
-    }
-    else if (secs < LONG_MIN) {
-        secs = LONG_MIN;
-        res = -1;
-    }
-#endif
     tv->tv_sec = (long)secs;
 #else
-    /* On OpenBSD 5.4, timeval.tv_sec is a long.
-       Example: long is 64-bit, whereas time_t is 32-bit. */
     tv->tv_sec = secs;
+#endif
     if ((_PyTime_t)tv->tv_sec != secs)
         res = -1;
-#endif
 
     usec = (int)_PyTime_Divide(ns, US_TO_NS, round);
     if (usec < 0) {
@@ -440,7 +428,7 @@ _PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
     tv->tv_usec = usec;
 
     if (res && raise)
-        _PyTime_overflow();
+        error_time_t_overflow();
     return res;
 }
 
@@ -473,7 +461,7 @@ _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts)
     ts->tv_nsec = nsec;
 
     if ((_PyTime_t)ts->tv_sec != secs) {
-        _PyTime_overflow();
+        error_time_t_overflow();
         return -1;
     }
     return 0;
-- 
cgit v1.2.1


From 038b36f15b87ad0cb61493ec79b83228990f870a Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 10 Sep 2015 11:48:00 +0200
Subject: Try to fix test_time.test_AsSecondsDouble() on "x86 Gentoo Non-Debug
 with X 3.x" buildbot

Use volatile keyword in _PyTime_Round()
---
 Python/pytime.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 243f756f3d..9470636fdc 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -75,12 +75,17 @@ _PyTime_RoundHalfEven(double x)
 static double
 _PyTime_Round(double x, _PyTime_round_t round)
 {
+    /* volatile avoids optimization changing how numbers are rounded */
+    volatile double d;
+
+    d = x;
     if (round == _PyTime_ROUND_HALF_EVEN)
-        return _PyTime_RoundHalfEven(x);
+        d = _PyTime_RoundHalfEven(d);
     else if (round == _PyTime_ROUND_CEILING)
-        return ceil(x);
+        d = ceil(d);
     else
-        return floor(x);
+        d = floor(d);
+    return d;
 }
 
 static int
-- 
cgit v1.2.1


From f5b952d0b1de0c175629903172a74ebed21b0020 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 10 Sep 2015 13:25:17 +0200
Subject: New try to fix test_time.test_AsSecondsDouble() on x86 buildbots.

Use volatile keyword in _PyTime_AsSecondsDouble()
---
 Python/pytime.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 9470636fdc..c82d5985b4 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -332,16 +332,21 @@ _PyTime_FromMillisecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t roun
 double
 _PyTime_AsSecondsDouble(_PyTime_t t)
 {
+    /* volatile avoids optimization changing how numbers are rounded */
+    volatile double d;
+
     if (t % SEC_TO_NS == 0) {
         _PyTime_t secs;
         /* Divide using integers to avoid rounding issues on the integer part.
            1e-9 cannot be stored exactly in IEEE 64-bit. */
         secs = t / SEC_TO_NS;
-        return (double)secs;
+        d = (double)secs;
     }
     else {
-        return (double)t / 1e9;
+        d = (double)t;
+        d /= 1e9;
     }
+    return d;
 }
 
 PyObject *
-- 
cgit v1.2.1


From 57057ccfd38eaa647ad2983e024e34833e0205e1 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 10 Sep 2015 15:55:07 +0200
Subject: pytime: add _PyTime_check_mul_overflow() macro to avoid undefined
 behaviour

Overflow test in test_FromSecondsObject() fails on FreeBSD 10.0 buildbot which
uses clang. clang implements more aggressive optimization which gives
different result than GCC on undefined behaviours.

Check if a multiplication will overflow, instead of checking if a
multiplicatin had overflowed, to avoid undefined behaviour.

Add also debug information if the test on overflow fails.
---
 Python/pytime.c | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index c82d5985b4..1b20dc797e 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -7,6 +7,11 @@
 #include <mach/mach_time.h>   /* mach_absolute_time(), mach_timebase_info() */
 #endif
 
+#define _PyTime_check_mul_overflow(a, b) \
+    (assert(b > 0), \
+     (_PyTime_t)(a) < _PyTime_MIN / (_PyTime_t)(b) \
+     || _PyTime_MAX / (_PyTime_t)(b) < (_PyTime_t)(a))
+
 /* To millisecond (10^-3) */
 #define SEC_TO_MS 1000
 
@@ -226,12 +231,15 @@ _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts, int raise)
     _PyTime_t t;
     int res = 0;
 
-    t = (_PyTime_t)ts->tv_sec * SEC_TO_NS;
-    if (t / SEC_TO_NS != ts->tv_sec) {
+    assert(sizeof(ts->tv_sec) <= sizeof(_PyTime_t));
+    t = (_PyTime_t)ts->tv_sec;
+
+    if (_PyTime_check_mul_overflow(t, SEC_TO_NS)) {
         if (raise)
             _PyTime_overflow();
         res = -1;
     }
+    t = t * SEC_TO_NS;
 
     t += ts->tv_nsec;
 
@@ -245,12 +253,15 @@ _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv, int raise)
     _PyTime_t t;
     int res = 0;
 
-    t = (_PyTime_t)tv->tv_sec * SEC_TO_NS;
-    if (t / SEC_TO_NS != tv->tv_sec) {
+    assert(sizeof(ts->tv_sec) <= sizeof(_PyTime_t));
+    t = (_PyTime_t)tv->tv_sec;
+
+    if (_PyTime_check_mul_overflow(t, SEC_TO_NS)) {
         if (raise)
             _PyTime_overflow();
         res = -1;
     }
+    t = t * SEC_TO_NS;
 
     t += (_PyTime_t)tv->tv_usec * US_TO_NS;
 
@@ -308,11 +319,11 @@ _PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round,
             return -1;
         }
 
-        *t = sec * unit_to_ns;
-        if (*t / unit_to_ns != sec) {
+        if (_PyTime_check_mul_overflow(sec, unit_to_ns)) {
             _PyTime_overflow();
             return -1;
         }
+        *t = sec * unit_to_ns;
         return 0;
     }
 }
@@ -587,19 +598,20 @@ _PyTime_GetSystemClockWithInfo(_PyTime_t *t, _Py_clock_info_t *info)
     return pygettimeofday_new(t, info, 1);
 }
 
-
 static int
 pymonotonic(_PyTime_t *tp, _Py_clock_info_t *info, int raise)
 {
 #if defined(MS_WINDOWS)
-    ULONGLONG result;
+    ULONGLONG ticks;
+    _PyTime_t t;
 
     assert(info == NULL || raise);
 
-    result = GetTickCount64();
+    ticks = GetTickCount64();
+    assert(sizeof(result) <= sizeof(_PyTime_t));
+    t = (_PyTime_t)ticks;
 
-    *tp = result * MS_TO_NS;
-    if (*tp / MS_TO_NS != result) {
+    if (_PyTime_check_mul_overflow(t, MS_TO_NS)) {
         if (raise) {
             _PyTime_overflow();
             return -1;
@@ -607,6 +619,7 @@ pymonotonic(_PyTime_t *tp, _Py_clock_info_t *info, int raise)
         /* Hello, time traveler! */
         assert(0);
     }
+    *tp = t * MS_TO_NS;
 
     if (info) {
         DWORD timeAdjustment, timeIncrement;
-- 
cgit v1.2.1


From 2409685d76c1dd6f121cd3417cf1c31009b7a77c Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 10 Sep 2015 16:00:06 +0200
Subject: pytime: oops, fix typos on Windows

---
 Python/pytime.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 1b20dc797e..9d0b0fafe1 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -253,7 +253,7 @@ _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv, int raise)
     _PyTime_t t;
     int res = 0;
 
-    assert(sizeof(ts->tv_sec) <= sizeof(_PyTime_t));
+    assert(sizeof(tv->tv_sec) <= sizeof(_PyTime_t));
     t = (_PyTime_t)tv->tv_sec;
 
     if (_PyTime_check_mul_overflow(t, SEC_TO_NS)) {
@@ -608,7 +608,7 @@ pymonotonic(_PyTime_t *tp, _Py_clock_info_t *info, int raise)
     assert(info == NULL || raise);
 
     ticks = GetTickCount64();
-    assert(sizeof(result) <= sizeof(_PyTime_t));
+    assert(sizeof(ticks) <= sizeof(_PyTime_t));
     t = (_PyTime_t)ticks;
 
     if (_PyTime_check_mul_overflow(t, MS_TO_NS)) {
-- 
cgit v1.2.1


From 00448c2fb0056c69988252dfb086fd1aa26fba7b Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Fri, 18 Sep 2015 13:23:02 +0200
Subject: Issue #25155: Add _PyTime_AsTimevalTime_t() function

On Windows, the tv_sec field of the timeval structure has the type C long,
whereas it has the type C time_t on all other platforms. A C long has a size of
32 bits (signed inter, 1 bit for the sign, 31 bits for the value) which is not
enough to store an Epoch timestamp after the year 2038.

Add the _PyTime_AsTimevalTime_t() function written for datetime.datetime.now():
convert a _PyTime_t timestamp to a (secs, us) tuple where secs type is time_t.
It allows to support dates after the year 2038 on Windows.

Enhance also _PyTime_AsTimeval_impl() to detect overflow on the number of
seconds when rounding the number of microseconds.
---
 Python/pytime.c | 79 +++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 60 insertions(+), 19 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 9d0b0fafe1..9889a3b53b 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -417,54 +417,95 @@ _PyTime_AsMicroseconds(_PyTime_t t, _PyTime_round_t round)
 }
 
 static int
-_PyTime_AsTimeval_impl(_PyTime_t t, struct timeval *tv, _PyTime_round_t round,
-                       int raise)
+_PyTime_AsTimeval_impl(_PyTime_t t, _PyTime_t *p_secs, int *p_us,
+                       _PyTime_round_t round)
 {
     _PyTime_t secs, ns;
-    int res = 0;
     int usec;
+    int res = 0;
 
     secs = t / SEC_TO_NS;
     ns = t % SEC_TO_NS;
 
-#ifdef MS_WINDOWS
-    tv->tv_sec = (long)secs;
-#else
-    tv->tv_sec = secs;
-#endif
-    if ((_PyTime_t)tv->tv_sec != secs)
-        res = -1;
-
     usec = (int)_PyTime_Divide(ns, US_TO_NS, round);
     if (usec < 0) {
         usec += SEC_TO_US;
-        tv->tv_sec -= 1;
+        if (secs != _PyTime_MIN)
+            secs -= 1;
+        else
+            res = -1;
     }
     else if (usec >= SEC_TO_US) {
         usec -= SEC_TO_US;
-        tv->tv_sec += 1;
+        if (secs != _PyTime_MAX)
+            secs += 1;
+        else
+            res = -1;
     }
-
     assert(0 <= usec && usec < SEC_TO_US);
-    tv->tv_usec = usec;
 
-    if (res && raise)
-        error_time_t_overflow();
+    *p_secs = secs;
+    *p_us = usec;
+
     return res;
 }
 
+static int
+_PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv,
+                             _PyTime_round_t round, int raise)
+{
+    _PyTime_t secs;
+    int us;
+    int res;
+
+    res = _PyTime_AsTimeval_impl(t, &secs, &us, round);
+
+#ifdef MS_WINDOWS
+    tv->tv_sec = (long)secs;
+#else
+    tv->tv_sec = secs;
+#endif
+    tv->tv_usec = us;
+
+    if (res < 0 || (_PyTime_t)tv->tv_sec != secs) {
+        if (raise)
+            error_time_t_overflow();
+        return -1;
+    }
+    return 0;
+}
+
 int
 _PyTime_AsTimeval(_PyTime_t t, struct timeval *tv, _PyTime_round_t round)
 {
-    return _PyTime_AsTimeval_impl(t, tv, round, 1);
+    return _PyTime_AsTimevalStruct_impl(t, tv, round, 1);
 }
 
 int
 _PyTime_AsTimeval_noraise(_PyTime_t t, struct timeval *tv, _PyTime_round_t round)
 {
-    return _PyTime_AsTimeval_impl(t, tv, round, 0);
+    return _PyTime_AsTimevalStruct_impl(t, tv, round, 0);
 }
 
+int
+_PyTime_AsTimevalTime_t(_PyTime_t t, time_t *p_secs, int *us,
+                        _PyTime_round_t round)
+{
+    _PyTime_t secs;
+    int res;
+
+    res = _PyTime_AsTimeval_impl(t, &secs, us, round);
+
+    *p_secs = secs;
+
+    if (res < 0 || (_PyTime_t)*p_secs != secs) {
+        error_time_t_overflow();
+        return -1;
+    }
+    return 0;
+}
+
+
 #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE)
 int
 _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts)
-- 
cgit v1.2.1


From ab51974e3b9722fd98eb2e54774875169c7ae41a Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Tue, 29 Sep 2015 13:41:46 +0200
Subject: Try to fix _PyTime_AsTimevalStruct_impl() on OpenBSD

It looks like the check for integer overflow doesn't work on x86 OpenBSD 5.8.
---
 Python/pytime.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 9889a3b53b..53611b1ec1 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -454,7 +454,7 @@ static int
 _PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv,
                              _PyTime_round_t round, int raise)
 {
-    _PyTime_t secs;
+    _PyTime_t secs, secs2;
     int us;
     int res;
 
@@ -467,7 +467,8 @@ _PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv,
 #endif
     tv->tv_usec = us;
 
-    if (res < 0 || (_PyTime_t)tv->tv_sec != secs) {
+    secs2 = (_PyTime_t)tv->tv_sec;
+    if (res < 0 || secs2 != secs) {
         if (raise)
             error_time_t_overflow();
         return -1;
-- 
cgit v1.2.1


From 5a6aa0da055b939140518cdcf2f187de533e3456 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Wed, 30 Sep 2015 22:50:12 +0200
Subject: Backout change 28d3bcb1bad6: "Try to fix
 _PyTime_AsTimevalStruct_impl() on OpenBSD", I'm not sure that the change was
 really needed. I read the test result of an old build because the OpenBSD was
 100 builds late.

---
 Python/pytime.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 53611b1ec1..9889a3b53b 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -454,7 +454,7 @@ static int
 _PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv,
                              _PyTime_round_t round, int raise)
 {
-    _PyTime_t secs, secs2;
+    _PyTime_t secs;
     int us;
     int res;
 
@@ -467,8 +467,7 @@ _PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv,
 #endif
     tv->tv_usec = us;
 
-    secs2 = (_PyTime_t)tv->tv_sec;
-    if (res < 0 || secs2 != secs) {
+    if (res < 0 || (_PyTime_t)tv->tv_sec != secs) {
         if (raise)
             error_time_t_overflow();
         return -1;
-- 
cgit v1.2.1


From c879d2c9d9e1633e31e70e0e4e4f5e79dcc87709 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Thu, 1 Oct 2015 08:44:03 +0200
Subject: Fix _PyTime_AsTimevalStruct_impl() on OpenBSD

On the x86 OpenBSD 5.8 buildbot, the integer overflow check is ignored. Copy
the tv_sec variable into a Py_time_t variable instead of "simply" casting it to
Py_time_t, to fix the integer overflow check.
---
 Python/pytime.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 9889a3b53b..53611b1ec1 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -454,7 +454,7 @@ static int
 _PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv,
                              _PyTime_round_t round, int raise)
 {
-    _PyTime_t secs;
+    _PyTime_t secs, secs2;
     int us;
     int res;
 
@@ -467,7 +467,8 @@ _PyTime_AsTimevalStruct_impl(_PyTime_t t, struct timeval *tv,
 #endif
     tv->tv_usec = us;
 
-    if (res < 0 || (_PyTime_t)tv->tv_sec != secs) {
+    secs2 = (_PyTime_t)tv->tv_sec;
+    if (res < 0 || secs2 != secs) {
         if (raise)
             error_time_t_overflow();
         return -1;
-- 
cgit v1.2.1


From ab9342460bf6d26c19d73c506195737a35529433 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Sat, 7 Nov 2015 15:42:38 +0200
Subject: Issue #25558: Use compile-time asserts.

---
 Python/pytime.c | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

(limited to 'Python/pytime.c')

diff --git a/Python/pytime.c b/Python/pytime.c
index 53611b1ec1..8a6cb551f0 100644
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -43,7 +43,7 @@ _PyLong_AsTime_t(PyObject *obj)
     val = PyLong_AsLongLong(obj);
 #else
     long val;
-    assert(sizeof(time_t) <= sizeof(long));
+    Py_BUILD_ASSERT(sizeof(time_t) <= sizeof(long));
     val = PyLong_AsLong(obj);
 #endif
     if (val == -1 && PyErr_Occurred()) {
@@ -60,7 +60,7 @@ _PyLong_FromTime_t(time_t t)
 #if defined(HAVE_LONG_LONG) && SIZEOF_TIME_T == SIZEOF_LONG_LONG
     return PyLong_FromLongLong((PY_LONG_LONG)t);
 #else
-    assert(sizeof(time_t) <= sizeof(long));
+    Py_BUILD_ASSERT(sizeof(time_t) <= sizeof(long));
     return PyLong_FromLong((long)t);
 #endif
 }
@@ -209,6 +209,8 @@ _PyTime_FromSeconds(int seconds)
     /* ensure that integer overflow cannot happen, int type should have 32
        bits, whereas _PyTime_t type has at least 64 bits (SEC_TO_MS takes 30
        bits). */
+    Py_BUILD_ASSERT(INT_MAX <= _PyTime_MAX / SEC_TO_NS);
+    Py_BUILD_ASSERT(INT_MIN >= _PyTime_MIN / SEC_TO_NS);
     assert((t >= 0 && t <= _PyTime_MAX / SEC_TO_NS)
            || (t < 0 && t >= _PyTime_MIN / SEC_TO_NS));
     t *= SEC_TO_NS;
@@ -219,7 +221,7 @@ _PyTime_t
 _PyTime_FromNanoseconds(PY_LONG_LONG ns)
 {
     _PyTime_t t;
-    assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+    Py_BUILD_ASSERT(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
     t = Py_SAFE_DOWNCAST(ns, PY_LONG_LONG, _PyTime_t);
     return t;
 }
@@ -231,7 +233,7 @@ _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts, int raise)
     _PyTime_t t;
     int res = 0;
 
-    assert(sizeof(ts->tv_sec) <= sizeof(_PyTime_t));
+    Py_BUILD_ASSERT(sizeof(ts->tv_sec) <= sizeof(_PyTime_t));
     t = (_PyTime_t)ts->tv_sec;
 
     if (_PyTime_check_mul_overflow(t, SEC_TO_NS)) {
@@ -253,7 +255,7 @@ _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv, int raise)
     _PyTime_t t;
     int res = 0;
 
-    assert(sizeof(tv->tv_sec) <= sizeof(_PyTime_t));
+    Py_BUILD_ASSERT(sizeof(tv->tv_sec) <= sizeof(_PyTime_t));
     t = (_PyTime_t)tv->tv_sec;
 
     if (_PyTime_check_mul_overflow(t, SEC_TO_NS)) {
@@ -304,12 +306,12 @@ _PyTime_FromObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round,
     else {
 #ifdef HAVE_LONG_LONG
         PY_LONG_LONG sec;
-        assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+        Py_BUILD_ASSERT(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
 
         sec = PyLong_AsLongLong(obj);
 #else
         long sec;
-        assert(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
+        Py_BUILD_ASSERT(sizeof(PY_LONG_LONG) <= sizeof(_PyTime_t));
 
         sec = PyLong_AsLong(obj);
 #endif
@@ -364,10 +366,10 @@ PyObject *
 _PyTime_AsNanosecondsObject(_PyTime_t t)
 {
 #ifdef HAVE_LONG_LONG
-    assert(sizeof(PY_LONG_LONG) >= sizeof(_PyTime_t));
+    Py_BUILD_ASSERT(sizeof(PY_LONG_LONG) >= sizeof(_PyTime_t));
     return PyLong_FromLongLong((PY_LONG_LONG)t);
 #else
-    assert(sizeof(long) >= sizeof(_PyTime_t));
+    Py_BUILD_ASSERT(sizeof(long) >= sizeof(_PyTime_t));
     return PyLong_FromLong((long)t);
 #endif
 }
@@ -650,7 +652,7 @@ pymonotonic(_PyTime_t *tp, _Py_clock_info_t *info, int raise)
     assert(info == NULL || raise);
 
     ticks = GetTickCount64();
-    assert(sizeof(ticks) <= sizeof(_PyTime_t));
+    Py_BUILD_ASSERT(sizeof(ticks) <= sizeof(_PyTime_t));
     t = (_PyTime_t)ticks;
 
     if (_PyTime_check_mul_overflow(t, MS_TO_NS)) {
@@ -774,8 +776,5 @@ _PyTime_Init(void)
     if (_PyTime_GetMonotonicClockWithInfo(&t, NULL) < 0)
         return -1;
 
-    /* check that _PyTime_FromSeconds() cannot overflow */
-    assert(INT_MAX <= _PyTime_MAX / SEC_TO_NS);
-    assert(INT_MIN >= _PyTime_MIN / SEC_TO_NS);
     return 0;
 }
-- 
cgit v1.2.1