LCOV - code coverage report
Current view: top level - Python - pytime.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 132 378 34.9 %
Date: 2023-03-20 08:15:36 Functions: 31 60 51.7 %
Branches: 42 182 23.1 %

           Branch data     Line data    Source code
       1                 :            : #include "Python.h"
       2                 :            : #ifdef MS_WINDOWS
       3                 :            : #  include <winsock2.h>           // struct timeval
       4                 :            : #endif
       5                 :            : 
       6                 :            : #if defined(__APPLE__)
       7                 :            : #  include <mach/mach_time.h>     // mach_absolute_time(), mach_timebase_info()
       8                 :            : 
       9                 :            : #if defined(__APPLE__) && defined(__has_builtin)
      10                 :            : #  if __has_builtin(__builtin_available)
      11                 :            : #    define HAVE_CLOCK_GETTIME_RUNTIME __builtin_available(macOS 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *)
      12                 :            : #  endif
      13                 :            : #endif
      14                 :            : #endif
      15                 :            : 
      16                 :            : /* To millisecond (10^-3) */
      17                 :            : #define SEC_TO_MS 1000
      18                 :            : 
      19                 :            : /* To microseconds (10^-6) */
      20                 :            : #define MS_TO_US 1000
      21                 :            : #define SEC_TO_US (SEC_TO_MS * MS_TO_US)
      22                 :            : 
      23                 :            : /* To nanoseconds (10^-9) */
      24                 :            : #define US_TO_NS 1000
      25                 :            : #define MS_TO_NS (MS_TO_US * US_TO_NS)
      26                 :            : #define SEC_TO_NS (SEC_TO_MS * MS_TO_NS)
      27                 :            : 
      28                 :            : /* Conversion from nanoseconds */
      29                 :            : #define NS_TO_MS (1000 * 1000)
      30                 :            : #define NS_TO_US (1000)
      31                 :            : #define NS_TO_100NS (100)
      32                 :            : 
      33                 :            : #if SIZEOF_TIME_T == SIZEOF_LONG_LONG
      34                 :            : #  define PY_TIME_T_MAX LLONG_MAX
      35                 :            : #  define PY_TIME_T_MIN LLONG_MIN
      36                 :            : #elif SIZEOF_TIME_T == SIZEOF_LONG
      37                 :            : #  define PY_TIME_T_MAX LONG_MAX
      38                 :            : #  define PY_TIME_T_MIN LONG_MIN
      39                 :            : #else
      40                 :            : #  error "unsupported time_t size"
      41                 :            : #endif
      42                 :            : 
      43                 :            : #if PY_TIME_T_MAX + PY_TIME_T_MIN != -1
      44                 :            : #  error "time_t is not a two's complement integer type"
      45                 :            : #endif
      46                 :            : 
      47                 :            : #if _PyTime_MIN + _PyTime_MAX != -1
      48                 :            : #  error "_PyTime_t is not a two's complement integer type"
      49                 :            : #endif
      50                 :            : 
      51                 :            : 
      52                 :            : static void
      53                 :          0 : pytime_time_t_overflow(void)
      54                 :            : {
      55                 :          0 :     PyErr_SetString(PyExc_OverflowError,
      56                 :            :                     "timestamp out of range for platform time_t");
      57                 :          0 : }
      58                 :            : 
      59                 :            : 
      60                 :            : static void
      61                 :          0 : pytime_overflow(void)
      62                 :            : {
      63                 :          0 :     PyErr_SetString(PyExc_OverflowError,
      64                 :            :                     "timestamp too large to convert to C _PyTime_t");
      65                 :          0 : }
      66                 :            : 
      67                 :            : 
      68                 :            : static inline _PyTime_t
      69                 :      34731 : pytime_from_nanoseconds(_PyTime_t t)
      70                 :            : {
      71                 :            :     // _PyTime_t is a number of nanoseconds
      72                 :      34731 :     return t;
      73                 :            : }
      74                 :            : 
      75                 :            : 
      76                 :            : static inline _PyTime_t
      77                 :      18736 : pytime_as_nanoseconds(_PyTime_t t)
      78                 :            : {
      79                 :            :     // _PyTime_t is a number of nanoseconds: see pytime_from_nanoseconds()
      80                 :      18736 :     return t;
      81                 :            : }
      82                 :            : 
      83                 :            : 
      84                 :            : // Compute t1 + t2. Clamp to [_PyTime_MIN; _PyTime_MAX] on overflow.
      85                 :            : static inline int
      86                 :      32119 : pytime_add(_PyTime_t *t1, _PyTime_t t2)
      87                 :            : {
      88   [ +  +  -  + ]:      32119 :     if (t2 > 0 && *t1 > _PyTime_MAX - t2) {
      89                 :          0 :         *t1 = _PyTime_MAX;
      90                 :          0 :         return -1;
      91                 :            :     }
      92   [ +  +  -  + ]:      32119 :     else if (t2 < 0 && *t1 < _PyTime_MIN - t2) {
      93                 :          0 :         *t1 = _PyTime_MIN;
      94                 :          0 :         return -1;
      95                 :            :     }
      96                 :            :     else {
      97                 :      32119 :         *t1 += t2;
      98                 :      32119 :         return 0;
      99                 :            :     }
     100                 :            : }
     101                 :            : 
     102                 :            : 
     103                 :            : _PyTime_t
     104                 :      16014 : _PyTime_Add(_PyTime_t t1, _PyTime_t t2)
     105                 :            : {
     106                 :      16014 :     (void)pytime_add(&t1, t2);
     107                 :      16014 :     return t1;
     108                 :            : }
     109                 :            : 
     110                 :            : 
     111                 :            : static inline int
     112                 :      31816 : pytime_mul_check_overflow(_PyTime_t a, _PyTime_t b)
     113                 :            : {
     114         [ +  - ]:      31816 :     if (b != 0) {
     115                 :            :         assert(b > 0);
     116   [ +  -  -  + ]:      31816 :         return ((a < _PyTime_MIN / b) || (_PyTime_MAX / b < a));
     117                 :            :     }
     118                 :            :     else {
     119                 :          0 :         return 0;
     120                 :            :     }
     121                 :            : }
     122                 :            : 
     123                 :            : 
     124                 :            : // Compute t * k. Clamp to [_PyTime_MIN; _PyTime_MAX] on overflow.
     125                 :            : static inline int
     126                 :      31816 : pytime_mul(_PyTime_t *t, _PyTime_t k)
     127                 :            : {
     128                 :            :     assert(k >= 0);
     129         [ -  + ]:      31816 :     if (pytime_mul_check_overflow(*t, k)) {
     130         [ #  # ]:          0 :         *t = (*t >= 0) ? _PyTime_MAX : _PyTime_MIN;
     131                 :          0 :         return -1;
     132                 :            :     }
     133                 :            :     else {
     134                 :      31816 :         *t *= k;
     135                 :      31816 :         return 0;
     136                 :            :     }
     137                 :            : }
     138                 :            : 
     139                 :            : 
     140                 :            : // Compute t * k. Clamp to [_PyTime_MIN; _PyTime_MAX] on overflow.
     141                 :            : static inline _PyTime_t
     142                 :      15711 : _PyTime_Mul(_PyTime_t t, _PyTime_t k)
     143                 :            : {
     144                 :      15711 :     (void)pytime_mul(&t, k);
     145                 :      15711 :     return t;
     146                 :            : }
     147                 :            : 
     148                 :            : 
     149                 :            : 
     150                 :            : 
     151                 :            : _PyTime_t
     152                 :          0 : _PyTime_MulDiv(_PyTime_t ticks, _PyTime_t mul, _PyTime_t div)
     153                 :            : {
     154                 :            :     /* Compute (ticks * mul / div) in two parts to reduce the risk of integer
     155                 :            :        overflow: compute the integer part, and then the remaining part.
     156                 :            : 
     157                 :            :        (ticks * mul) / div == (ticks / div) * mul + (ticks % div) * mul / div
     158                 :            :     */
     159                 :            :     _PyTime_t intpart, remaining;
     160                 :          0 :     intpart = ticks / div;
     161                 :          0 :     ticks %= div;
     162                 :          0 :     remaining = _PyTime_Mul(ticks, mul) / div;
     163                 :            :     // intpart * mul + remaining
     164                 :          0 :     return _PyTime_Add(_PyTime_Mul(intpart, mul), remaining);
     165                 :            : }
     166                 :            : 
     167                 :            : 
     168                 :            : time_t
     169                 :          0 : _PyLong_AsTime_t(PyObject *obj)
     170                 :            : {
     171                 :            : #if SIZEOF_TIME_T == SIZEOF_LONG_LONG
     172                 :          0 :     long long val = PyLong_AsLongLong(obj);
     173                 :            : #elif SIZEOF_TIME_T <= SIZEOF_LONG
     174                 :            :     long val = PyLong_AsLong(obj);
     175                 :            : #else
     176                 :            : #   error "unsupported time_t size"
     177                 :            : #endif
     178   [ #  #  #  # ]:          0 :     if (val == -1 && PyErr_Occurred()) {
     179         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
     180                 :          0 :             pytime_time_t_overflow();
     181                 :            :         }
     182                 :          0 :         return -1;
     183                 :            :     }
     184                 :          0 :     return (time_t)val;
     185                 :            : }
     186                 :            : 
     187                 :            : 
     188                 :            : PyObject *
     189                 :       8349 : _PyLong_FromTime_t(time_t t)
     190                 :            : {
     191                 :            : #if SIZEOF_TIME_T == SIZEOF_LONG_LONG
     192                 :       8349 :     return PyLong_FromLongLong((long long)t);
     193                 :            : #elif SIZEOF_TIME_T <= SIZEOF_LONG
     194                 :            :     return PyLong_FromLong((long)t);
     195                 :            : #else
     196                 :            : #   error "unsupported time_t size"
     197                 :            : #endif
     198                 :            : }
     199                 :            : 
     200                 :            : 
     201                 :            : // Convert _PyTime_t to time_t.
     202                 :            : // Return 0 on success. Return -1 and clamp the value on overflow.
     203                 :            : static int
     204                 :      16014 : _PyTime_AsTime_t(_PyTime_t t, time_t *t2)
     205                 :            : {
     206                 :            : #if SIZEOF_TIME_T < _SIZEOF_PYTIME_T
     207                 :            :     if ((_PyTime_t)PY_TIME_T_MAX < t) {
     208                 :            :         *t2 = PY_TIME_T_MAX;
     209                 :            :         return -1;
     210                 :            :     }
     211                 :            :     if (t < (_PyTime_t)PY_TIME_T_MIN) {
     212                 :            :         *t2 = PY_TIME_T_MIN;
     213                 :            :         return -1;
     214                 :            :     }
     215                 :            : #endif
     216                 :      16014 :     *t2 = (time_t)t;
     217                 :      16014 :     return 0;
     218                 :            : }
     219                 :            : 
     220                 :            : 
     221                 :            : #ifdef MS_WINDOWS
     222                 :            : // Convert _PyTime_t to long.
     223                 :            : // Return 0 on success. Return -1 and clamp the value on overflow.
     224                 :            : static int
     225                 :            : _PyTime_AsLong(_PyTime_t t, long *t2)
     226                 :            : {
     227                 :            : #if SIZEOF_LONG < _SIZEOF_PYTIME_T
     228                 :            :     if ((_PyTime_t)LONG_MAX < t) {
     229                 :            :         *t2 = LONG_MAX;
     230                 :            :         return -1;
     231                 :            :     }
     232                 :            :     if (t < (_PyTime_t)LONG_MIN) {
     233                 :            :         *t2 = LONG_MIN;
     234                 :            :         return -1;
     235                 :            :     }
     236                 :            : #endif
     237                 :            :     *t2 = (long)t;
     238                 :            :     return 0;
     239                 :            : }
     240                 :            : #endif
     241                 :            : 
     242                 :            : 
     243                 :            : /* Round to nearest with ties going to nearest even integer
     244                 :            :    (_PyTime_ROUND_HALF_EVEN) */
     245                 :            : static double
     246                 :          0 : pytime_round_half_even(double x)
     247                 :            : {
     248                 :          0 :     double rounded = round(x);
     249         [ #  # ]:          0 :     if (fabs(x-rounded) == 0.5) {
     250                 :            :         /* halfway case: round to even */
     251                 :          0 :         rounded = 2.0 * round(x / 2.0);
     252                 :            :     }
     253                 :          0 :     return rounded;
     254                 :            : }
     255                 :            : 
     256                 :            : 
     257                 :            : static double
     258                 :          1 : pytime_round(double x, _PyTime_round_t round)
     259                 :            : {
     260                 :            :     /* volatile avoids optimization changing how numbers are rounded */
     261                 :            :     volatile double d;
     262                 :            : 
     263                 :          1 :     d = x;
     264         [ -  + ]:          1 :     if (round == _PyTime_ROUND_HALF_EVEN) {
     265                 :          0 :         d = pytime_round_half_even(d);
     266                 :            :     }
     267         [ -  + ]:          1 :     else if (round == _PyTime_ROUND_CEILING) {
     268                 :          0 :         d = ceil(d);
     269                 :            :     }
     270         [ -  + ]:          1 :     else if (round == _PyTime_ROUND_FLOOR) {
     271                 :          0 :         d = floor(d);
     272                 :            :     }
     273                 :            :     else {
     274                 :            :         assert(round == _PyTime_ROUND_UP);
     275         [ +  - ]:          1 :         d = (d >= 0.0) ? ceil(d) : floor(d);
     276                 :            :     }
     277                 :          1 :     return d;
     278                 :            : }
     279                 :            : 
     280                 :            : 
     281                 :            : static int
     282                 :          0 : pytime_double_to_denominator(double d, time_t *sec, long *numerator,
     283                 :            :                              long idenominator, _PyTime_round_t round)
     284                 :            : {
     285                 :          0 :     double denominator = (double)idenominator;
     286                 :            :     double intpart;
     287                 :            :     /* volatile avoids optimization changing how numbers are rounded */
     288                 :            :     volatile double floatpart;
     289                 :            : 
     290                 :          0 :     floatpart = modf(d, &intpart);
     291                 :            : 
     292                 :          0 :     floatpart *= denominator;
     293                 :          0 :     floatpart = pytime_round(floatpart, round);
     294         [ #  # ]:          0 :     if (floatpart >= denominator) {
     295                 :          0 :         floatpart -= denominator;
     296                 :          0 :         intpart += 1.0;
     297                 :            :     }
     298         [ #  # ]:          0 :     else if (floatpart < 0) {
     299                 :          0 :         floatpart += denominator;
     300                 :          0 :         intpart -= 1.0;
     301                 :            :     }
     302                 :            :     assert(0.0 <= floatpart && floatpart < denominator);
     303                 :            : 
     304                 :            :     /*
     305                 :            :        Conversion of an out-of-range value to time_t gives undefined behaviour
     306                 :            :        (C99 ยง6.3.1.4p1), so we must guard against it. However, checking that
     307                 :            :        `intpart` is in range is delicate: the obvious expression `intpart <=
     308                 :            :        PY_TIME_T_MAX` will first convert the value `PY_TIME_T_MAX` to a double,
     309                 :            :        potentially changing its value and leading to us failing to catch some
     310                 :            :        UB-inducing values. The code below works correctly under the mild
     311                 :            :        assumption that time_t is a two's complement integer type with no trap
     312                 :            :        representation, and that `PY_TIME_T_MIN` is within the representable
     313                 :            :        range of a C double.
     314                 :            : 
     315                 :            :        Note: we want the `if` condition below to be true for NaNs; therefore,
     316                 :            :        resist any temptation to simplify by applying De Morgan's laws.
     317                 :            :     */
     318   [ #  #  #  # ]:          0 :     if (!((double)PY_TIME_T_MIN <= intpart && intpart < -(double)PY_TIME_T_MIN)) {
     319                 :          0 :         pytime_time_t_overflow();
     320                 :          0 :         return -1;
     321                 :            :     }
     322                 :          0 :     *sec = (time_t)intpart;
     323                 :          0 :     *numerator = (long)floatpart;
     324                 :            :     assert(0 <= *numerator && *numerator < idenominator);
     325                 :          0 :     return 0;
     326                 :            : }
     327                 :            : 
     328                 :            : 
     329                 :            : static int
     330                 :          0 : pytime_object_to_denominator(PyObject *obj, time_t *sec, long *numerator,
     331                 :            :                              long denominator, _PyTime_round_t round)
     332                 :            : {
     333                 :            :     assert(denominator >= 1);
     334                 :            : 
     335         [ #  # ]:          0 :     if (PyFloat_Check(obj)) {
     336                 :          0 :         double d = PyFloat_AsDouble(obj);
     337         [ #  # ]:          0 :         if (Py_IS_NAN(d)) {
     338                 :          0 :             *numerator = 0;
     339                 :          0 :             PyErr_SetString(PyExc_ValueError, "Invalid value NaN (not a number)");
     340                 :          0 :             return -1;
     341                 :            :         }
     342                 :          0 :         return pytime_double_to_denominator(d, sec, numerator,
     343                 :            :                                             denominator, round);
     344                 :            :     }
     345                 :            :     else {
     346                 :          0 :         *sec = _PyLong_AsTime_t(obj);
     347                 :          0 :         *numerator = 0;
     348   [ #  #  #  # ]:          0 :         if (*sec == (time_t)-1 && PyErr_Occurred()) {
     349                 :          0 :             return -1;
     350                 :            :         }
     351                 :          0 :         return 0;
     352                 :            :     }
     353                 :            : }
     354                 :            : 
     355                 :            : 
     356                 :            : int
     357                 :          0 : _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round)
     358                 :            : {
     359         [ #  # ]:          0 :     if (PyFloat_Check(obj)) {
     360                 :            :         double intpart;
     361                 :            :         /* volatile avoids optimization changing how numbers are rounded */
     362                 :            :         volatile double d;
     363                 :            : 
     364                 :          0 :         d = PyFloat_AsDouble(obj);
     365         [ #  # ]:          0 :         if (Py_IS_NAN(d)) {
     366                 :          0 :             PyErr_SetString(PyExc_ValueError, "Invalid value NaN (not a number)");
     367                 :          0 :             return -1;
     368                 :            :         }
     369                 :            : 
     370                 :          0 :         d = pytime_round(d, round);
     371                 :          0 :         (void)modf(d, &intpart);
     372                 :            : 
     373                 :            :         /* See comments in pytime_double_to_denominator */
     374   [ #  #  #  # ]:          0 :         if (!((double)PY_TIME_T_MIN <= intpart && intpart < -(double)PY_TIME_T_MIN)) {
     375                 :          0 :             pytime_time_t_overflow();
     376                 :          0 :             return -1;
     377                 :            :         }
     378                 :          0 :         *sec = (time_t)intpart;
     379                 :          0 :         return 0;
     380                 :            :     }
     381                 :            :     else {
     382                 :          0 :         *sec = _PyLong_AsTime_t(obj);
     383   [ #  #  #  # ]:          0 :         if (*sec == (time_t)-1 && PyErr_Occurred()) {
     384                 :          0 :             return -1;
     385                 :            :         }
     386                 :          0 :         return 0;
     387                 :            :     }
     388                 :            : }
     389                 :            : 
     390                 :            : 
     391                 :            : int
     392                 :          0 : _PyTime_ObjectToTimespec(PyObject *obj, time_t *sec, long *nsec,
     393                 :            :                          _PyTime_round_t round)
     394                 :            : {
     395                 :          0 :     return pytime_object_to_denominator(obj, sec, nsec, SEC_TO_NS, round);
     396                 :            : }
     397                 :            : 
     398                 :            : 
     399                 :            : int
     400                 :          0 : _PyTime_ObjectToTimeval(PyObject *obj, time_t *sec, long *usec,
     401                 :            :                         _PyTime_round_t round)
     402                 :            : {
     403                 :          0 :     return pytime_object_to_denominator(obj, sec, usec, SEC_TO_US, round);
     404                 :            : }
     405                 :            : 
     406                 :            : 
     407                 :            : _PyTime_t
     408                 :       2611 : _PyTime_FromSeconds(int seconds)
     409                 :            : {
     410                 :            :     /* ensure that integer overflow cannot happen, int type should have 32
     411                 :            :        bits, whereas _PyTime_t type has at least 64 bits (SEC_TO_NS takes 30
     412                 :            :        bits). */
     413                 :            :     static_assert(INT_MAX <= _PyTime_MAX / SEC_TO_NS, "_PyTime_t overflow");
     414                 :            :     static_assert(INT_MIN >= _PyTime_MIN / SEC_TO_NS, "_PyTime_t underflow");
     415                 :            : 
     416                 :       2611 :     _PyTime_t t = (_PyTime_t)seconds;
     417                 :            :     assert((t >= 0 && t <= _PyTime_MAX / SEC_TO_NS)
     418                 :            :            || (t < 0 && t >= _PyTime_MIN / SEC_TO_NS));
     419                 :       2611 :     t *= SEC_TO_NS;
     420                 :       2611 :     return pytime_from_nanoseconds(t);
     421                 :            : }
     422                 :            : 
     423                 :            : 
     424                 :            : _PyTime_t
     425                 :        303 : _PyTime_FromNanoseconds(_PyTime_t ns)
     426                 :            : {
     427                 :        303 :     return pytime_from_nanoseconds(ns);
     428                 :            : }
     429                 :            : 
     430                 :            : 
     431                 :            : _PyTime_t
     432                 :      15711 : _PyTime_FromMicrosecondsClamp(_PyTime_t us)
     433                 :            : {
     434                 :      15711 :     _PyTime_t ns = _PyTime_Mul(us, US_TO_NS);
     435                 :      15711 :     return pytime_from_nanoseconds(ns);
     436                 :            : }
     437                 :            : 
     438                 :            : 
     439                 :            : int
     440                 :          0 : _PyTime_FromNanosecondsObject(_PyTime_t *tp, PyObject *obj)
     441                 :            : {
     442                 :            : 
     443         [ #  # ]:          0 :     if (!PyLong_Check(obj)) {
     444                 :          0 :         PyErr_Format(PyExc_TypeError, "expect int, got %s",
     445                 :          0 :                      Py_TYPE(obj)->tp_name);
     446                 :          0 :         return -1;
     447                 :            :     }
     448                 :            : 
     449                 :            :     static_assert(sizeof(long long) == sizeof(_PyTime_t),
     450                 :            :                   "_PyTime_t is not long long");
     451                 :          0 :     long long nsec = PyLong_AsLongLong(obj);
     452   [ #  #  #  # ]:          0 :     if (nsec == -1 && PyErr_Occurred()) {
     453         [ #  # ]:          0 :         if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
     454                 :          0 :             pytime_overflow();
     455                 :            :         }
     456                 :          0 :         return -1;
     457                 :            :     }
     458                 :            : 
     459                 :          0 :     _PyTime_t t = (_PyTime_t)nsec;
     460                 :          0 :     *tp = pytime_from_nanoseconds(t);
     461                 :          0 :     return 0;
     462                 :            : }
     463                 :            : 
     464                 :            : 
     465                 :            : #ifdef HAVE_CLOCK_GETTIME
     466                 :            : static int
     467                 :      16105 : pytime_fromtimespec(_PyTime_t *tp, struct timespec *ts, int raise_exc)
     468                 :            : {
     469                 :            :     _PyTime_t t, tv_nsec;
     470                 :            : 
     471                 :            :     static_assert(sizeof(ts->tv_sec) <= sizeof(_PyTime_t),
     472                 :            :                   "timespec.tv_sec is larger than _PyTime_t");
     473                 :      16105 :     t = (_PyTime_t)ts->tv_sec;
     474                 :            : 
     475                 :      16105 :     int res1 = pytime_mul(&t, SEC_TO_NS);
     476                 :            : 
     477                 :      16105 :     tv_nsec = ts->tv_nsec;
     478                 :      16105 :     int res2 = pytime_add(&t, tv_nsec);
     479                 :            : 
     480                 :      16105 :     *tp = pytime_from_nanoseconds(t);
     481                 :            : 
     482   [ +  +  +  -  :      16105 :     if (raise_exc && (res1 < 0 || res2 < 0)) {
                   -  + ]
     483                 :          0 :         pytime_overflow();
     484                 :          0 :         return -1;
     485                 :            :     }
     486                 :      16105 :     return 0;
     487                 :            : }
     488                 :            : 
     489                 :            : int
     490                 :          0 : _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts)
     491                 :            : {
     492                 :          0 :     return pytime_fromtimespec(tp, ts, 1);
     493                 :            : }
     494                 :            : #endif
     495                 :            : 
     496                 :            : 
     497                 :            : #ifndef MS_WINDOWS
     498                 :            : static int
     499                 :          0 : pytime_fromtimeval(_PyTime_t *tp, struct timeval *tv, int raise_exc)
     500                 :            : {
     501                 :            :     static_assert(sizeof(tv->tv_sec) <= sizeof(_PyTime_t),
     502                 :            :                   "timeval.tv_sec is larger than _PyTime_t");
     503                 :          0 :     _PyTime_t t = (_PyTime_t)tv->tv_sec;
     504                 :            : 
     505                 :          0 :     int res1 = pytime_mul(&t, SEC_TO_NS);
     506                 :            : 
     507                 :          0 :     _PyTime_t usec = (_PyTime_t)tv->tv_usec * US_TO_NS;
     508                 :          0 :     int res2 = pytime_add(&t, usec);
     509                 :            : 
     510                 :          0 :     *tp = pytime_from_nanoseconds(t);
     511                 :            : 
     512   [ #  #  #  #  :          0 :     if (raise_exc && (res1 < 0 || res2 < 0)) {
                   #  # ]
     513                 :          0 :         pytime_overflow();
     514                 :          0 :         return -1;
     515                 :            :     }
     516                 :          0 :     return 0;
     517                 :            : }
     518                 :            : 
     519                 :            : 
     520                 :            : int
     521                 :          0 : _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv)
     522                 :            : {
     523                 :          0 :     return pytime_fromtimeval(tp, tv, 1);
     524                 :            : }
     525                 :            : #endif
     526                 :            : 
     527                 :            : 
     528                 :            : static int
     529                 :          1 : pytime_from_double(_PyTime_t *tp, double value, _PyTime_round_t round,
     530                 :            :                    long unit_to_ns)
     531                 :            : {
     532                 :            :     /* volatile avoids optimization changing how numbers are rounded */
     533                 :            :     volatile double d;
     534                 :            : 
     535                 :            :     /* convert to a number of nanoseconds */
     536                 :          1 :     d = value;
     537                 :          1 :     d *= (double)unit_to_ns;
     538                 :          1 :     d = pytime_round(d, round);
     539                 :            : 
     540                 :            :     /* See comments in pytime_double_to_denominator */
     541   [ +  -  -  + ]:          1 :     if (!((double)_PyTime_MIN <= d && d < -(double)_PyTime_MIN)) {
     542                 :          0 :         pytime_time_t_overflow();
     543                 :          0 :         return -1;
     544                 :            :     }
     545                 :          1 :     _PyTime_t ns = (_PyTime_t)d;
     546                 :            : 
     547                 :          1 :     *tp = pytime_from_nanoseconds(ns);
     548                 :          1 :     return 0;
     549                 :            : }
     550                 :            : 
     551                 :            : 
     552                 :            : static int
     553                 :          1 : pytime_from_object(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round,
     554                 :            :                    long unit_to_ns)
     555                 :            : {
     556         [ +  - ]:          1 :     if (PyFloat_Check(obj)) {
     557                 :            :         double d;
     558                 :          1 :         d = PyFloat_AsDouble(obj);
     559         [ -  + ]:          1 :         if (Py_IS_NAN(d)) {
     560                 :          0 :             PyErr_SetString(PyExc_ValueError, "Invalid value NaN (not a number)");
     561                 :          0 :             return -1;
     562                 :            :         }
     563                 :          1 :         return pytime_from_double(tp, d, round, unit_to_ns);
     564                 :            :     }
     565                 :            :     else {
     566                 :          0 :         long long sec = PyLong_AsLongLong(obj);
     567   [ #  #  #  # ]:          0 :         if (sec == -1 && PyErr_Occurred()) {
     568         [ #  # ]:          0 :             if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
     569                 :          0 :                 pytime_overflow();
     570                 :            :             }
     571                 :          0 :             return -1;
     572                 :            :         }
     573                 :            : 
     574                 :            :         static_assert(sizeof(long long) <= sizeof(_PyTime_t),
     575                 :            :                       "_PyTime_t is smaller than long long");
     576                 :          0 :         _PyTime_t ns = (_PyTime_t)sec;
     577         [ #  # ]:          0 :         if (pytime_mul(&ns, unit_to_ns) < 0) {
     578                 :          0 :             pytime_overflow();
     579                 :          0 :             return -1;
     580                 :            :         }
     581                 :            : 
     582                 :          0 :         *tp = pytime_from_nanoseconds(ns);
     583                 :          0 :         return 0;
     584                 :            :     }
     585                 :            : }
     586                 :            : 
     587                 :            : 
     588                 :            : int
     589                 :          1 : _PyTime_FromSecondsObject(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round)
     590                 :            : {
     591                 :          1 :     return pytime_from_object(tp, obj, round, SEC_TO_NS);
     592                 :            : }
     593                 :            : 
     594                 :            : 
     595                 :            : int
     596                 :          0 : _PyTime_FromMillisecondsObject(_PyTime_t *tp, PyObject *obj, _PyTime_round_t round)
     597                 :            : {
     598                 :          0 :     return pytime_from_object(tp, obj, round, MS_TO_NS);
     599                 :            : }
     600                 :            : 
     601                 :            : 
     602                 :            : double
     603                 :        116 : _PyTime_AsSecondsDouble(_PyTime_t t)
     604                 :            : {
     605                 :            :     /* volatile avoids optimization changing how numbers are rounded */
     606                 :            :     volatile double d;
     607                 :            : 
     608                 :        116 :     _PyTime_t ns = pytime_as_nanoseconds(t);
     609         [ -  + ]:        116 :     if (ns % SEC_TO_NS == 0) {
     610                 :            :         /* Divide using integers to avoid rounding issues on the integer part.
     611                 :            :            1e-9 cannot be stored exactly in IEEE 64-bit. */
     612                 :          0 :         _PyTime_t secs = ns / SEC_TO_NS;
     613                 :          0 :         d = (double)secs;
     614                 :            :     }
     615                 :            :     else {
     616                 :        116 :         d = (double)ns;
     617                 :        116 :         d /= 1e9;
     618                 :            :     }
     619                 :        116 :     return d;
     620                 :            : }
     621                 :            : 
     622                 :            : 
     623                 :            : PyObject *
     624                 :          0 : _PyTime_AsNanosecondsObject(_PyTime_t t)
     625                 :            : {
     626                 :          0 :     _PyTime_t ns =  pytime_as_nanoseconds(t);
     627                 :            :     static_assert(sizeof(long long) >= sizeof(_PyTime_t),
     628                 :            :                   "_PyTime_t is larger than long long");
     629                 :          0 :     return PyLong_FromLongLong((long long)ns);
     630                 :            : }
     631                 :            : 
     632                 :            : 
     633                 :            : static _PyTime_t
     634                 :          5 : pytime_divide_round_up(const _PyTime_t t, const _PyTime_t k)
     635                 :            : {
     636                 :            :     assert(k > 1);
     637         [ +  - ]:          5 :     if (t >= 0) {
     638                 :            :         // Don't use (t + k - 1) / k to avoid integer overflow
     639                 :            :         // if t is equal to _PyTime_MAX
     640                 :          5 :         _PyTime_t q = t / k;
     641         [ -  + ]:          5 :         if (t % k) {
     642                 :          0 :             q += 1;
     643                 :            :         }
     644                 :          5 :         return q;
     645                 :            :     }
     646                 :            :     else {
     647                 :            :         // Don't use (t - (k - 1)) / k to avoid integer overflow
     648                 :            :         // if t is equals to _PyTime_MIN.
     649                 :          0 :         _PyTime_t q = t / k;
     650         [ #  # ]:          0 :         if (t % k) {
     651                 :          0 :             q -= 1;
     652                 :            :         }
     653                 :          0 :         return q;
     654                 :            :     }
     655                 :            : }
     656                 :            : 
     657                 :            : 
     658                 :            : static _PyTime_t
     659                 :       2606 : pytime_divide(const _PyTime_t t, const _PyTime_t k,
     660                 :            :               const _PyTime_round_t round)
     661                 :            : {
     662                 :            :     assert(k > 1);
     663         [ -  + ]:       2606 :     if (round == _PyTime_ROUND_HALF_EVEN) {
     664                 :          0 :         _PyTime_t x = t / k;
     665                 :          0 :         _PyTime_t r = t % k;
     666                 :          0 :         _PyTime_t abs_r = Py_ABS(r);
     667   [ #  #  #  #  :          0 :         if (abs_r > k / 2 || (abs_r == k / 2 && (Py_ABS(x) & 1))) {
                   #  # ]
     668         [ #  # ]:          0 :             if (t >= 0) {
     669                 :          0 :                 x++;
     670                 :            :             }
     671                 :            :             else {
     672                 :          0 :                 x--;
     673                 :            :             }
     674                 :            :         }
     675                 :          0 :         return x;
     676                 :            :     }
     677         [ +  + ]:       2606 :     else if (round == _PyTime_ROUND_CEILING) {
     678         [ +  + ]:       2605 :         if (t >= 0) {
     679                 :          4 :             return pytime_divide_round_up(t, k);
     680                 :            :         }
     681                 :            :         else {
     682                 :       2601 :             return t / k;
     683                 :            :         }
     684                 :            :     }
     685         [ -  + ]:          1 :     else if (round == _PyTime_ROUND_FLOOR){
     686         [ #  # ]:          0 :         if (t >= 0) {
     687                 :          0 :             return t / k;
     688                 :            :         }
     689                 :            :         else {
     690                 :          0 :             return pytime_divide_round_up(t, k);
     691                 :            :         }
     692                 :            :     }
     693                 :            :     else {
     694                 :            :         assert(round == _PyTime_ROUND_UP);
     695                 :          1 :         return pytime_divide_round_up(t, k);
     696                 :            :     }
     697                 :            : }
     698                 :            : 
     699                 :            : 
     700                 :            : // Compute (t / k, t % k) in (pq, pr).
     701                 :            : // Make sure that 0 <= pr < k.
     702                 :            : // Return 0 on success.
     703                 :            : // Return -1 on underflow and store (_PyTime_MIN, 0) in (pq, pr).
     704                 :            : static int
     705                 :      16014 : pytime_divmod(const _PyTime_t t, const _PyTime_t k,
     706                 :            :               _PyTime_t *pq, _PyTime_t *pr)
     707                 :            : {
     708                 :            :     assert(k > 1);
     709                 :      16014 :     _PyTime_t q = t / k;
     710                 :      16014 :     _PyTime_t r = t % k;
     711         [ -  + ]:      16014 :     if (r < 0) {
     712         [ #  # ]:          0 :         if (q == _PyTime_MIN) {
     713                 :          0 :             *pq = _PyTime_MIN;
     714                 :          0 :             *pr = 0;
     715                 :          0 :             return -1;
     716                 :            :         }
     717                 :          0 :         r += k;
     718                 :          0 :         q -= 1;
     719                 :            :     }
     720                 :            :     assert(0 <= r && r < k);
     721                 :            : 
     722                 :      16014 :     *pq = q;
     723                 :      16014 :     *pr = r;
     724                 :      16014 :     return 0;
     725                 :            : }
     726                 :            : 
     727                 :            : 
     728                 :            : _PyTime_t
     729                 :          0 : _PyTime_AsNanoseconds(_PyTime_t t)
     730                 :            : {
     731                 :          0 :     return pytime_as_nanoseconds(t);
     732                 :            : }
     733                 :            : 
     734                 :            : 
     735                 :            : #ifdef MS_WINDOWS
     736                 :            : _PyTime_t
     737                 :            : _PyTime_As100Nanoseconds(_PyTime_t t, _PyTime_round_t round)
     738                 :            : {
     739                 :            :     _PyTime_t ns = pytime_as_nanoseconds(t);
     740                 :            :     return pytime_divide(ns, NS_TO_100NS, round);
     741                 :            : }
     742                 :            : #endif
     743                 :            : 
     744                 :            : 
     745                 :            : _PyTime_t
     746                 :       2606 : _PyTime_AsMicroseconds(_PyTime_t t, _PyTime_round_t round)
     747                 :            : {
     748                 :       2606 :     _PyTime_t ns = pytime_as_nanoseconds(t);
     749                 :       2606 :     return pytime_divide(ns, NS_TO_US, round);
     750                 :            : }
     751                 :            : 
     752                 :            : 
     753                 :            : _PyTime_t
     754                 :          0 : _PyTime_AsMilliseconds(_PyTime_t t, _PyTime_round_t round)
     755                 :            : {
     756                 :          0 :     _PyTime_t ns = pytime_as_nanoseconds(t);
     757                 :          0 :     return pytime_divide(ns, NS_TO_MS, round);
     758                 :            : }
     759                 :            : 
     760                 :            : 
     761                 :            : static int
     762                 :          0 : pytime_as_timeval(_PyTime_t t, _PyTime_t *ptv_sec, int *ptv_usec,
     763                 :            :                   _PyTime_round_t round)
     764                 :            : {
     765                 :          0 :     _PyTime_t ns = pytime_as_nanoseconds(t);
     766                 :          0 :     _PyTime_t us = pytime_divide(ns, US_TO_NS, round);
     767                 :            : 
     768                 :            :     _PyTime_t tv_sec, tv_usec;
     769                 :          0 :     int res = pytime_divmod(us, SEC_TO_US, &tv_sec, &tv_usec);
     770                 :          0 :     *ptv_sec = tv_sec;
     771                 :          0 :     *ptv_usec = (int)tv_usec;
     772                 :          0 :     return res;
     773                 :            : }
     774                 :            : 
     775                 :            : 
     776                 :            : static int
     777                 :          0 : pytime_as_timeval_struct(_PyTime_t t, struct timeval *tv,
     778                 :            :                          _PyTime_round_t round, int raise_exc)
     779                 :            : {
     780                 :            :     _PyTime_t tv_sec;
     781                 :            :     int tv_usec;
     782                 :          0 :     int res = pytime_as_timeval(t, &tv_sec, &tv_usec, round);
     783                 :            :     int res2;
     784                 :            : #ifdef MS_WINDOWS
     785                 :            :     // On Windows, timeval.tv_sec type is long
     786                 :            :     res2 = _PyTime_AsLong(tv_sec, &tv->tv_sec);
     787                 :            : #else
     788                 :          0 :     res2 = _PyTime_AsTime_t(tv_sec, &tv->tv_sec);
     789                 :            : #endif
     790         [ #  # ]:          0 :     if (res2 < 0) {
     791                 :          0 :         tv_usec = 0;
     792                 :            :     }
     793                 :          0 :     tv->tv_usec = tv_usec;
     794                 :            : 
     795   [ #  #  #  #  :          0 :     if (raise_exc && (res < 0 || res2 < 0)) {
                   #  # ]
     796                 :          0 :         pytime_time_t_overflow();
     797                 :          0 :         return -1;
     798                 :            :     }
     799                 :          0 :     return 0;
     800                 :            : }
     801                 :            : 
     802                 :            : 
     803                 :            : int
     804                 :          0 : _PyTime_AsTimeval(_PyTime_t t, struct timeval *tv, _PyTime_round_t round)
     805                 :            : {
     806                 :          0 :     return pytime_as_timeval_struct(t, tv, round, 1);
     807                 :            : }
     808                 :            : 
     809                 :            : 
     810                 :            : void
     811                 :          0 : _PyTime_AsTimeval_clamp(_PyTime_t t, struct timeval *tv, _PyTime_round_t round)
     812                 :            : {
     813                 :          0 :     (void)pytime_as_timeval_struct(t, tv, round, 0);
     814                 :          0 : }
     815                 :            : 
     816                 :            : 
     817                 :            : int
     818                 :          0 : _PyTime_AsTimevalTime_t(_PyTime_t t, time_t *p_secs, int *us,
     819                 :            :                         _PyTime_round_t round)
     820                 :            : {
     821                 :            :     _PyTime_t secs;
     822         [ #  # ]:          0 :     if (pytime_as_timeval(t, &secs, us, round) < 0) {
     823                 :          0 :         pytime_time_t_overflow();
     824                 :          0 :         return -1;
     825                 :            :     }
     826                 :            : 
     827         [ #  # ]:          0 :     if (_PyTime_AsTime_t(secs, p_secs) < 0) {
     828                 :          0 :         pytime_time_t_overflow();
     829                 :          0 :         return -1;
     830                 :            :     }
     831                 :          0 :     return 0;
     832                 :            : }
     833                 :            : 
     834                 :            : 
     835                 :            : #if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE)
     836                 :            : static int
     837                 :      16014 : pytime_as_timespec(_PyTime_t t, struct timespec *ts, int raise_exc)
     838                 :            : {
     839                 :      16014 :     _PyTime_t ns = pytime_as_nanoseconds(t);
     840                 :            :     _PyTime_t tv_sec, tv_nsec;
     841                 :      16014 :     int res = pytime_divmod(ns, SEC_TO_NS, &tv_sec, &tv_nsec);
     842                 :            : 
     843                 :      16014 :     int res2 = _PyTime_AsTime_t(tv_sec, &ts->tv_sec);
     844         [ -  + ]:      16014 :     if (res2 < 0) {
     845                 :          0 :         tv_nsec = 0;
     846                 :            :     }
     847                 :      16014 :     ts->tv_nsec = tv_nsec;
     848                 :            : 
     849   [ -  +  -  -  :      16014 :     if (raise_exc && (res < 0 || res2 < 0)) {
                   -  - ]
     850                 :          0 :         pytime_time_t_overflow();
     851                 :          0 :         return -1;
     852                 :            :     }
     853                 :      16014 :     return 0;
     854                 :            : }
     855                 :            : 
     856                 :            : void
     857                 :      16014 : _PyTime_AsTimespec_clamp(_PyTime_t t, struct timespec *ts)
     858                 :            : {
     859                 :      16014 :     (void)pytime_as_timespec(t, ts, 0);
     860                 :      16014 : }
     861                 :            : 
     862                 :            : int
     863                 :          0 : _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts)
     864                 :            : {
     865                 :          0 :     return pytime_as_timespec(t, ts, 1);
     866                 :            : }
     867                 :            : #endif
     868                 :            : 
     869                 :            : 
     870                 :            : static int
     871                 :          3 : py_get_system_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
     872                 :            : {
     873                 :            :     assert(info == NULL || raise_exc);
     874                 :            : 
     875                 :            : #ifdef MS_WINDOWS
     876                 :            :     FILETIME system_time;
     877                 :            :     ULARGE_INTEGER large;
     878                 :            : 
     879                 :            :     GetSystemTimeAsFileTime(&system_time);
     880                 :            :     large.u.LowPart = system_time.dwLowDateTime;
     881                 :            :     large.u.HighPart = system_time.dwHighDateTime;
     882                 :            :     /* 11,644,473,600,000,000,000: number of nanoseconds between
     883                 :            :        the 1st january 1601 and the 1st january 1970 (369 years + 89 leap
     884                 :            :        days). */
     885                 :            :     _PyTime_t ns = large.QuadPart * 100 - 11644473600000000000;
     886                 :            :     *tp = pytime_from_nanoseconds(ns);
     887                 :            :     if (info) {
     888                 :            :         DWORD timeAdjustment, timeIncrement;
     889                 :            :         BOOL isTimeAdjustmentDisabled, ok;
     890                 :            : 
     891                 :            :         info->implementation = "GetSystemTimeAsFileTime()";
     892                 :            :         info->monotonic = 0;
     893                 :            :         ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
     894                 :            :                                      &isTimeAdjustmentDisabled);
     895                 :            :         if (!ok) {
     896                 :            :             PyErr_SetFromWindowsErr(0);
     897                 :            :             return -1;
     898                 :            :         }
     899                 :            :         info->resolution = timeIncrement * 1e-7;
     900                 :            :         info->adjustable = 1;
     901                 :            :     }
     902                 :            : 
     903                 :            : #else   /* MS_WINDOWS */
     904                 :            :     int err;
     905                 :            : #if defined(HAVE_CLOCK_GETTIME)
     906                 :            :     struct timespec ts;
     907                 :            : #endif
     908                 :            : 
     909                 :            : #if !defined(HAVE_CLOCK_GETTIME) || defined(__APPLE__)
     910                 :            :     struct timeval tv;
     911                 :            : #endif
     912                 :            : 
     913                 :            : #ifdef HAVE_CLOCK_GETTIME
     914                 :            : 
     915                 :            : #ifdef HAVE_CLOCK_GETTIME_RUNTIME
     916                 :            :     if (HAVE_CLOCK_GETTIME_RUNTIME) {
     917                 :            : #endif
     918                 :            : 
     919                 :          3 :     err = clock_gettime(CLOCK_REALTIME, &ts);
     920         [ -  + ]:          3 :     if (err) {
     921         [ #  # ]:          0 :         if (raise_exc) {
     922                 :          0 :             PyErr_SetFromErrno(PyExc_OSError);
     923                 :            :         }
     924                 :          0 :         return -1;
     925                 :            :     }
     926         [ -  + ]:          3 :     if (pytime_fromtimespec(tp, &ts, raise_exc) < 0) {
     927                 :          0 :         return -1;
     928                 :            :     }
     929                 :            : 
     930         [ -  + ]:          3 :     if (info) {
     931                 :            :         struct timespec res;
     932                 :          0 :         info->implementation = "clock_gettime(CLOCK_REALTIME)";
     933                 :          0 :         info->monotonic = 0;
     934                 :          0 :         info->adjustable = 1;
     935         [ #  # ]:          0 :         if (clock_getres(CLOCK_REALTIME, &res) == 0) {
     936                 :          0 :             info->resolution = (double)res.tv_sec + (double)res.tv_nsec * 1e-9;
     937                 :            :         }
     938                 :            :         else {
     939                 :          0 :             info->resolution = 1e-9;
     940                 :            :         }
     941                 :            :     }
     942                 :            : 
     943                 :            : #ifdef HAVE_CLOCK_GETTIME_RUNTIME
     944                 :            :     }
     945                 :            :     else {
     946                 :            : #endif
     947                 :            : 
     948                 :            : #endif
     949                 :            : 
     950                 :            : #if !defined(HAVE_CLOCK_GETTIME) || defined(HAVE_CLOCK_GETTIME_RUNTIME)
     951                 :            : 
     952                 :            :      /* test gettimeofday() */
     953                 :            :     err = gettimeofday(&tv, (struct timezone *)NULL);
     954                 :            :     if (err) {
     955                 :            :         if (raise_exc) {
     956                 :            :             PyErr_SetFromErrno(PyExc_OSError);
     957                 :            :         }
     958                 :            :         return -1;
     959                 :            :     }
     960                 :            :     if (pytime_fromtimeval(tp, &tv, raise_exc) < 0) {
     961                 :            :         return -1;
     962                 :            :     }
     963                 :            : 
     964                 :            :     if (info) {
     965                 :            :         info->implementation = "gettimeofday()";
     966                 :            :         info->resolution = 1e-6;
     967                 :            :         info->monotonic = 0;
     968                 :            :         info->adjustable = 1;
     969                 :            :     }
     970                 :            : 
     971                 :            : #if defined(HAVE_CLOCK_GETTIME_RUNTIME) && defined(HAVE_CLOCK_GETTIME)
     972                 :            :     } /* end of availibity block */
     973                 :            : #endif
     974                 :            : 
     975                 :            : #endif   /* !HAVE_CLOCK_GETTIME */
     976                 :            : #endif   /* !MS_WINDOWS */
     977                 :          3 :     return 0;
     978                 :            : }
     979                 :            : 
     980                 :            : 
     981                 :            : _PyTime_t
     982                 :          0 : _PyTime_GetSystemClock(void)
     983                 :            : {
     984                 :            :     _PyTime_t t;
     985         [ #  # ]:          0 :     if (py_get_system_clock(&t, NULL, 0) < 0) {
     986                 :            :         // If clock_gettime(CLOCK_REALTIME) or gettimeofday() fails:
     987                 :            :         // silently ignore the failure and return 0.
     988                 :          0 :         t = 0;
     989                 :            :     }
     990                 :          0 :     return t;
     991                 :            : }
     992                 :            : 
     993                 :            : 
     994                 :            : int
     995                 :          3 : _PyTime_GetSystemClockWithInfo(_PyTime_t *t, _Py_clock_info_t *info)
     996                 :            : {
     997                 :          3 :     return py_get_system_clock(t, info, 1);
     998                 :            : }
     999                 :            : 
    1000                 :            : 
    1001                 :            : #ifdef __APPLE__
    1002                 :            : static int
    1003                 :            : py_mach_timebase_info(_PyTime_t *pnumer, _PyTime_t *pdenom, int raise)
    1004                 :            : {
    1005                 :            :     static mach_timebase_info_data_t timebase;
    1006                 :            :     /* According to the Technical Q&A QA1398, mach_timebase_info() cannot
    1007                 :            :        fail: https://developer.apple.com/library/mac/#qa/qa1398/ */
    1008                 :            :     (void)mach_timebase_info(&timebase);
    1009                 :            : 
    1010                 :            :     /* Sanity check: should never occur in practice */
    1011                 :            :     if (timebase.numer < 1 || timebase.denom < 1) {
    1012                 :            :         if (raise) {
    1013                 :            :             PyErr_SetString(PyExc_RuntimeError,
    1014                 :            :                             "invalid mach_timebase_info");
    1015                 :            :         }
    1016                 :            :         return -1;
    1017                 :            :     }
    1018                 :            : 
    1019                 :            :     /* Check that timebase.numer and timebase.denom can be casted to
    1020                 :            :        _PyTime_t. In practice, timebase uses uint32_t, so casting cannot
    1021                 :            :        overflow. At the end, only make sure that the type is uint32_t
    1022                 :            :        (_PyTime_t is 64-bit long). */
    1023                 :            :     static_assert(sizeof(timebase.numer) <= sizeof(_PyTime_t),
    1024                 :            :                   "timebase.numer is larger than _PyTime_t");
    1025                 :            :     static_assert(sizeof(timebase.denom) <= sizeof(_PyTime_t),
    1026                 :            :                   "timebase.denom is larger than _PyTime_t");
    1027                 :            : 
    1028                 :            :     /* Make sure that _PyTime_MulDiv(ticks, timebase_numer, timebase_denom)
    1029                 :            :        cannot overflow.
    1030                 :            : 
    1031                 :            :        Known time bases:
    1032                 :            : 
    1033                 :            :        * (1, 1) on Intel
    1034                 :            :        * (1000000000, 33333335) or (1000000000, 25000000) on PowerPC
    1035                 :            : 
    1036                 :            :        None of these time bases can overflow with 64-bit _PyTime_t, but
    1037                 :            :        check for overflow, just in case. */
    1038                 :            :     if ((_PyTime_t)timebase.numer > _PyTime_MAX / (_PyTime_t)timebase.denom) {
    1039                 :            :         if (raise) {
    1040                 :            :             PyErr_SetString(PyExc_OverflowError,
    1041                 :            :                             "mach_timebase_info is too large");
    1042                 :            :         }
    1043                 :            :         return -1;
    1044                 :            :     }
    1045                 :            : 
    1046                 :            :     *pnumer = (_PyTime_t)timebase.numer;
    1047                 :            :     *pdenom = (_PyTime_t)timebase.denom;
    1048                 :            :     return 0;
    1049                 :            : }
    1050                 :            : #endif
    1051                 :            : 
    1052                 :            : 
    1053                 :            : static int
    1054                 :      16102 : py_get_monotonic_clock(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
    1055                 :            : {
    1056                 :            :     assert(info == NULL || raise_exc);
    1057                 :            : 
    1058                 :            : #if defined(MS_WINDOWS)
    1059                 :            :     ULONGLONG ticks = GetTickCount64();
    1060                 :            :     static_assert(sizeof(ticks) <= sizeof(_PyTime_t),
    1061                 :            :                   "ULONGLONG is larger than _PyTime_t");
    1062                 :            :     _PyTime_t t;
    1063                 :            :     if (ticks <= (ULONGLONG)_PyTime_MAX) {
    1064                 :            :         t = (_PyTime_t)ticks;
    1065                 :            :     }
    1066                 :            :     else {
    1067                 :            :         // GetTickCount64() maximum is larger than _PyTime_t maximum:
    1068                 :            :         // ULONGLONG is unsigned, whereas _PyTime_t is signed.
    1069                 :            :         t = _PyTime_MAX;
    1070                 :            :     }
    1071                 :            : 
    1072                 :            :     int res = pytime_mul(&t, MS_TO_NS);
    1073                 :            :     *tp = t;
    1074                 :            : 
    1075                 :            :     if (raise_exc && res < 0) {
    1076                 :            :         pytime_overflow();
    1077                 :            :         return -1;
    1078                 :            :     }
    1079                 :            : 
    1080                 :            :     if (info) {
    1081                 :            :         DWORD timeAdjustment, timeIncrement;
    1082                 :            :         BOOL isTimeAdjustmentDisabled, ok;
    1083                 :            :         info->implementation = "GetTickCount64()";
    1084                 :            :         info->monotonic = 1;
    1085                 :            :         ok = GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement,
    1086                 :            :                                      &isTimeAdjustmentDisabled);
    1087                 :            :         if (!ok) {
    1088                 :            :             PyErr_SetFromWindowsErr(0);
    1089                 :            :             return -1;
    1090                 :            :         }
    1091                 :            :         info->resolution = timeIncrement * 1e-7;
    1092                 :            :         info->adjustable = 0;
    1093                 :            :     }
    1094                 :            : 
    1095                 :            : #elif defined(__APPLE__)
    1096                 :            :     static _PyTime_t timebase_numer = 0;
    1097                 :            :     static _PyTime_t timebase_denom = 0;
    1098                 :            :     if (timebase_denom == 0) {
    1099                 :            :         if (py_mach_timebase_info(&timebase_numer, &timebase_denom, raise_exc) < 0) {
    1100                 :            :             return -1;
    1101                 :            :         }
    1102                 :            :     }
    1103                 :            : 
    1104                 :            :     if (info) {
    1105                 :            :         info->implementation = "mach_absolute_time()";
    1106                 :            :         info->resolution = (double)timebase_numer / (double)timebase_denom * 1e-9;
    1107                 :            :         info->monotonic = 1;
    1108                 :            :         info->adjustable = 0;
    1109                 :            :     }
    1110                 :            : 
    1111                 :            :     uint64_t uticks = mach_absolute_time();
    1112                 :            :     // unsigned => signed
    1113                 :            :     assert(uticks <= (uint64_t)_PyTime_MAX);
    1114                 :            :     _PyTime_t ticks = (_PyTime_t)uticks;
    1115                 :            : 
    1116                 :            :     _PyTime_t ns = _PyTime_MulDiv(ticks, timebase_numer, timebase_denom);
    1117                 :            :     *tp = pytime_from_nanoseconds(ns);
    1118                 :            : 
    1119                 :            : #elif defined(__hpux)
    1120                 :            :     hrtime_t time;
    1121                 :            : 
    1122                 :            :     time = gethrtime();
    1123                 :            :     if (time == -1) {
    1124                 :            :         if (raise_exc) {
    1125                 :            :             PyErr_SetFromErrno(PyExc_OSError);
    1126                 :            :         }
    1127                 :            :         return -1;
    1128                 :            :     }
    1129                 :            : 
    1130                 :            :     *tp = pytime_from_nanoseconds(time);
    1131                 :            : 
    1132                 :            :     if (info) {
    1133                 :            :         info->implementation = "gethrtime()";
    1134                 :            :         info->resolution = 1e-9;
    1135                 :            :         info->monotonic = 1;
    1136                 :            :         info->adjustable = 0;
    1137                 :            :     }
    1138                 :            : 
    1139                 :            : #else
    1140                 :            : 
    1141                 :            : #ifdef CLOCK_HIGHRES
    1142                 :            :     const clockid_t clk_id = CLOCK_HIGHRES;
    1143                 :            :     const char *implementation = "clock_gettime(CLOCK_HIGHRES)";
    1144                 :            : #else
    1145                 :      16102 :     const clockid_t clk_id = CLOCK_MONOTONIC;
    1146                 :      16102 :     const char *implementation = "clock_gettime(CLOCK_MONOTONIC)";
    1147                 :            : #endif
    1148                 :            : 
    1149                 :            :     struct timespec ts;
    1150         [ -  + ]:      16102 :     if (clock_gettime(clk_id, &ts) != 0) {
    1151         [ #  # ]:          0 :         if (raise_exc) {
    1152                 :          0 :             PyErr_SetFromErrno(PyExc_OSError);
    1153                 :          0 :             return -1;
    1154                 :            :         }
    1155                 :          0 :         return -1;
    1156                 :            :     }
    1157                 :            : 
    1158         [ -  + ]:      16102 :     if (pytime_fromtimespec(tp, &ts, raise_exc) < 0) {
    1159                 :          0 :         return -1;
    1160                 :            :     }
    1161                 :            : 
    1162         [ -  + ]:      16102 :     if (info) {
    1163                 :          0 :         info->monotonic = 1;
    1164                 :          0 :         info->implementation = implementation;
    1165                 :          0 :         info->adjustable = 0;
    1166                 :            :         struct timespec res;
    1167         [ #  # ]:          0 :         if (clock_getres(clk_id, &res) != 0) {
    1168                 :          0 :             PyErr_SetFromErrno(PyExc_OSError);
    1169                 :          0 :             return -1;
    1170                 :            :         }
    1171                 :          0 :         info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
    1172                 :            :     }
    1173                 :            : #endif
    1174                 :      16102 :     return 0;
    1175                 :            : }
    1176                 :            : 
    1177                 :            : 
    1178                 :            : _PyTime_t
    1179                 :      16014 : _PyTime_GetMonotonicClock(void)
    1180                 :            : {
    1181                 :            :     _PyTime_t t;
    1182         [ -  + ]:      16014 :     if (py_get_monotonic_clock(&t, NULL, 0) < 0) {
    1183                 :            :         // If mach_timebase_info(), clock_gettime() or gethrtime() fails:
    1184                 :            :         // silently ignore the failure and return 0.
    1185                 :          0 :         t = 0;
    1186                 :            :     }
    1187                 :      16014 :     return t;
    1188                 :            : }
    1189                 :            : 
    1190                 :            : 
    1191                 :            : int
    1192                 :         88 : _PyTime_GetMonotonicClockWithInfo(_PyTime_t *tp, _Py_clock_info_t *info)
    1193                 :            : {
    1194                 :         88 :     return py_get_monotonic_clock(tp, info, 1);
    1195                 :            : }
    1196                 :            : 
    1197                 :            : 
    1198                 :            : #ifdef MS_WINDOWS
    1199                 :            : static int
    1200                 :            : py_win_perf_counter_frequency(LONGLONG *pfrequency, int raise)
    1201                 :            : {
    1202                 :            :     LONGLONG frequency;
    1203                 :            : 
    1204                 :            :     LARGE_INTEGER freq;
    1205                 :            :     // Since Windows XP, the function cannot fail.
    1206                 :            :     (void)QueryPerformanceFrequency(&freq);
    1207                 :            :     frequency = freq.QuadPart;
    1208                 :            : 
    1209                 :            :     // Since Windows XP, frequency cannot be zero.
    1210                 :            :     assert(frequency >= 1);
    1211                 :            : 
    1212                 :            :     /* Make also sure that (ticks * SEC_TO_NS) cannot overflow in
    1213                 :            :        _PyTime_MulDiv(), with ticks < frequency.
    1214                 :            : 
    1215                 :            :        Known QueryPerformanceFrequency() values:
    1216                 :            : 
    1217                 :            :        * 10,000,000 (10 MHz): 100 ns resolution
    1218                 :            :        * 3,579,545 Hz (3.6 MHz): 279 ns resolution
    1219                 :            : 
    1220                 :            :        None of these frequencies can overflow with 64-bit _PyTime_t, but
    1221                 :            :        check for integer overflow just in case. */
    1222                 :            :     if (frequency > _PyTime_MAX / SEC_TO_NS) {
    1223                 :            :         if (raise) {
    1224                 :            :             PyErr_SetString(PyExc_OverflowError,
    1225                 :            :                             "QueryPerformanceFrequency is too large");
    1226                 :            :         }
    1227                 :            :         return -1;
    1228                 :            :     }
    1229                 :            : 
    1230                 :            :     *pfrequency = frequency;
    1231                 :            :     return 0;
    1232                 :            : }
    1233                 :            : 
    1234                 :            : 
    1235                 :            : static int
    1236                 :            : py_get_win_perf_counter(_PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
    1237                 :            : {
    1238                 :            :     assert(info == NULL || raise_exc);
    1239                 :            : 
    1240                 :            :     static LONGLONG frequency = 0;
    1241                 :            :     if (frequency == 0) {
    1242                 :            :         if (py_win_perf_counter_frequency(&frequency, raise_exc) < 0) {
    1243                 :            :             return -1;
    1244                 :            :         }
    1245                 :            :     }
    1246                 :            : 
    1247                 :            :     if (info) {
    1248                 :            :         info->implementation = "QueryPerformanceCounter()";
    1249                 :            :         info->resolution = 1.0 / (double)frequency;
    1250                 :            :         info->monotonic = 1;
    1251                 :            :         info->adjustable = 0;
    1252                 :            :     }
    1253                 :            : 
    1254                 :            :     LARGE_INTEGER now;
    1255                 :            :     QueryPerformanceCounter(&now);
    1256                 :            :     LONGLONG ticksll = now.QuadPart;
    1257                 :            : 
    1258                 :            :     /* Make sure that casting LONGLONG to _PyTime_t cannot overflow,
    1259                 :            :        both types are signed */
    1260                 :            :     _PyTime_t ticks;
    1261                 :            :     static_assert(sizeof(ticksll) <= sizeof(ticks),
    1262                 :            :                   "LONGLONG is larger than _PyTime_t");
    1263                 :            :     ticks = (_PyTime_t)ticksll;
    1264                 :            : 
    1265                 :            :     _PyTime_t ns = _PyTime_MulDiv(ticks, SEC_TO_NS, (_PyTime_t)frequency);
    1266                 :            :     *tp = pytime_from_nanoseconds(ns);
    1267                 :            :     return 0;
    1268                 :            : }
    1269                 :            : #endif  // MS_WINDOWS
    1270                 :            : 
    1271                 :            : 
    1272                 :            : int
    1273                 :         80 : _PyTime_GetPerfCounterWithInfo(_PyTime_t *t, _Py_clock_info_t *info)
    1274                 :            : {
    1275                 :            : #ifdef MS_WINDOWS
    1276                 :            :     return py_get_win_perf_counter(t, info, 1);
    1277                 :            : #else
    1278                 :         80 :     return _PyTime_GetMonotonicClockWithInfo(t, info);
    1279                 :            : #endif
    1280                 :            : }
    1281                 :            : 
    1282                 :            : 
    1283                 :            : _PyTime_t
    1284                 :          0 : _PyTime_GetPerfCounter(void)
    1285                 :            : {
    1286                 :            :     _PyTime_t t;
    1287                 :            :     int res;
    1288                 :            : #ifdef MS_WINDOWS
    1289                 :            :     res = py_get_win_perf_counter(&t, NULL, 0);
    1290                 :            : #else
    1291                 :          0 :     res = py_get_monotonic_clock(&t, NULL, 0);
    1292                 :            : #endif
    1293         [ #  # ]:          0 :     if (res  < 0) {
    1294                 :            :         // If py_win_perf_counter_frequency() or py_get_monotonic_clock()
    1295                 :            :         // fails: silently ignore the failure and return 0.
    1296                 :          0 :         t = 0;
    1297                 :            :     }
    1298                 :          0 :     return t;
    1299                 :            : }
    1300                 :            : 
    1301                 :            : 
    1302                 :            : int
    1303                 :         53 : _PyTime_localtime(time_t t, struct tm *tm)
    1304                 :            : {
    1305                 :            : #ifdef MS_WINDOWS
    1306                 :            :     int error;
    1307                 :            : 
    1308                 :            :     error = localtime_s(tm, &t);
    1309                 :            :     if (error != 0) {
    1310                 :            :         errno = error;
    1311                 :            :         PyErr_SetFromErrno(PyExc_OSError);
    1312                 :            :         return -1;
    1313                 :            :     }
    1314                 :            :     return 0;
    1315                 :            : #else /* !MS_WINDOWS */
    1316                 :            : 
    1317                 :            : #if defined(_AIX) && (SIZEOF_TIME_T < 8)
    1318                 :            :     /* bpo-34373: AIX does not return NULL if t is too small or too large */
    1319                 :            :     if (t < -2145916800 /* 1902-01-01 */
    1320                 :            :        || t > 2145916800 /* 2038-01-01 */) {
    1321                 :            :         errno = EINVAL;
    1322                 :            :         PyErr_SetString(PyExc_OverflowError,
    1323                 :            :                         "localtime argument out of range");
    1324                 :            :         return -1;
    1325                 :            :     }
    1326                 :            : #endif
    1327                 :            : 
    1328                 :         53 :     errno = 0;
    1329         [ -  + ]:         53 :     if (localtime_r(&t, tm) == NULL) {
    1330         [ #  # ]:          0 :         if (errno == 0) {
    1331                 :          0 :             errno = EINVAL;
    1332                 :            :         }
    1333                 :          0 :         PyErr_SetFromErrno(PyExc_OSError);
    1334                 :          0 :         return -1;
    1335                 :            :     }
    1336                 :         53 :     return 0;
    1337                 :            : #endif /* MS_WINDOWS */
    1338                 :            : }
    1339                 :            : 
    1340                 :            : 
    1341                 :            : int
    1342                 :          0 : _PyTime_gmtime(time_t t, struct tm *tm)
    1343                 :            : {
    1344                 :            : #ifdef MS_WINDOWS
    1345                 :            :     int error;
    1346                 :            : 
    1347                 :            :     error = gmtime_s(tm, &t);
    1348                 :            :     if (error != 0) {
    1349                 :            :         errno = error;
    1350                 :            :         PyErr_SetFromErrno(PyExc_OSError);
    1351                 :            :         return -1;
    1352                 :            :     }
    1353                 :            :     return 0;
    1354                 :            : #else /* !MS_WINDOWS */
    1355         [ #  # ]:          0 :     if (gmtime_r(&t, tm) == NULL) {
    1356                 :            : #ifdef EINVAL
    1357         [ #  # ]:          0 :         if (errno == 0) {
    1358                 :          0 :             errno = EINVAL;
    1359                 :            :         }
    1360                 :            : #endif
    1361                 :          0 :         PyErr_SetFromErrno(PyExc_OSError);
    1362                 :          0 :         return -1;
    1363                 :            :     }
    1364                 :          0 :     return 0;
    1365                 :            : #endif /* MS_WINDOWS */
    1366                 :            : }
    1367                 :            : 
    1368                 :            : 
    1369                 :            : _PyTime_t
    1370                 :          0 : _PyDeadline_Init(_PyTime_t timeout)
    1371                 :            : {
    1372                 :          0 :     _PyTime_t now = _PyTime_GetMonotonicClock();
    1373                 :          0 :     return _PyTime_Add(now, timeout);
    1374                 :            : }
    1375                 :            : 
    1376                 :            : 
    1377                 :            : _PyTime_t
    1378                 :          0 : _PyDeadline_Get(_PyTime_t deadline)
    1379                 :            : {
    1380                 :          0 :     _PyTime_t now = _PyTime_GetMonotonicClock();
    1381                 :          0 :     return deadline - now;
    1382                 :            : }

Generated by: LCOV version 1.14