From patchwork Wed Sep 26 07:42:43 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Albert ARIBAUD X-Patchwork-Id: 29539 Received: (qmail 120195 invoked by alias); 26 Sep 2018 07:42:50 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 119418 invoked by uid 89); 26 Sep 2018 07:42:49 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.2 spammy= X-HELO: smtp3-g21.free.fr From: "Albert ARIBAUD (3ADEV)" To: libc-alpha@sourceware.org Cc: "Albert ARIBAUD (3ADEV)" Subject: [PATCH v2] Y2038: make __difftime compatible with 64-bit time Date: Wed, 26 Sep 2018 09:42:43 +0200 Message-Id: <20180926074243.13653-1-albert.aribaud@3adev.fr> Provide a 64-bit-time version of __difftime (but do not assume __time64_t is a signed int so that Gnulib can reuse the code) and make the 32-bit version a wrapper of it. Current difftime expects two time_t arguments and returns a double. To preserve source-code compatibility, its 64-bit-time equivalent expects two __time64_t arguments but still returns a double. * include/time.h (__difftime64): Add. * time/difftime.c (subtract): convert to 64-bit time. * time/difftime.c (__difftime64): Add. * time/difftime.c (__difftime): Wrap around __difftime64. --- include/time.h | 6 ++++++ time/difftime.c | 31 ++++++++++++++++++++++--------- 2 files changed, 28 insertions(+), 9 deletions(-) diff --git a/include/time.h b/include/time.h index 68e1624f0c..0325772b8e 100644 --- a/include/time.h +++ b/include/time.h @@ -124,6 +124,12 @@ extern char * __strptime_internal (const char *rp, const char *fmt, struct tm *tm, void *statep, locale_t locparam) attribute_hidden; +#if __TIMESIZE == 64 +# define __difftime64 __difftime +#else +extern double __difftime64 (__time64_t time1, __time64_t time0); +#endif + extern double __difftime (time_t time1, time_t time0); /* Use in the clock_* functions. Size of the field representing the diff --git a/time/difftime.c b/time/difftime.c index 7c5dd9898b..e3a4e57b44 100644 --- a/time/difftime.c +++ b/time/difftime.c @@ -31,9 +31,9 @@ time_t is known to be an integer type. */ static double -subtract (time_t time1, time_t time0) +subtract (__time64_t time1, __time64_t time0) { - if (! TYPE_SIGNED (time_t)) + if (! TYPE_SIGNED (__time64_t)) return time1 - time0; else { @@ -76,9 +76,9 @@ subtract (time_t time1, time_t time0) 1 is unsigned in C, so it need not be compared to zero. */ uintmax_t hdt = dt / 2; - time_t ht1 = time1 / 2; - time_t ht0 = time0 / 2; - time_t dht = ht1 - ht0; + __time64_t ht1 = time1 / 2; + __time64_t ht0 = time0 / 2; + __time64_t dht = ht1 - ht0; if (2 < dht - hdt + 1) { @@ -99,18 +99,18 @@ subtract (time_t time1, time_t time0) /* Return the difference between TIME1 and TIME0. */ double -__difftime (time_t time1, time_t time0) +__difftime64 (__time64_t time1, __time64_t time0) { /* Convert to double and then subtract if no double-rounding error could result. */ - if (TYPE_BITS (time_t) <= DBL_MANT_DIG - || (TYPE_FLOATING (time_t) && sizeof (time_t) < sizeof (long double))) + if (TYPE_BITS (__time64_t) <= DBL_MANT_DIG + || (TYPE_FLOATING (__time64_t) && sizeof (__time64_t) < sizeof (long double))) return (double) time1 - (double) time0; /* Likewise for long double. */ - if (TYPE_BITS (time_t) <= LDBL_MANT_DIG || TYPE_FLOATING (time_t)) + if (TYPE_BITS (__time64_t) <= LDBL_MANT_DIG || TYPE_FLOATING (__time64_t)) return (long double) time1 - (long double) time0; /* Subtract the smaller integer from the larger, convert the difference to @@ -118,4 +118,17 @@ __difftime (time_t time1, time_t time0) return time1 < time0 ? - subtract (time0, time1) : subtract (time1, time0); } + +/* Provide a 32-bit wrapper if needed */ + +#if __TIMESIZE != 64 + +double +__difftime (time_t time1, time_t time0) +{ + return __difftime64 (time1, time0); +} + +#endif + strong_alias (__difftime, difftime)