[v5] Y2038: make __difftime compatible with 64-bit time

Message ID 20181220204041.9377-1-albert.aribaud@3adev.fr
State New
Headers show
Series
  • [v5] Y2038: make __difftime compatible with 64-bit time
Related show

Commit Message

Albert ARIBAUD (3ADEV) Dec. 20, 2018, 8:40 p.m.
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.

This patch was tested by running 'make check' on branch
master then applying this patch and its two predecessors and
running 'make check' again, and checking that both 'make check'
yield identical results. This was done on x86_64-linux-gnu and
i686-linux-gnu.

This patch was also functionally tested with an ad hoc userland
C program which checks the result of difftime for various pairs
of 32-bit and, for 64-bit builds, of 64-bit time_t values too.
The program was built and run against a glibc with and without
the patch, and the results compared to ensure the patch does
not change the behavior of difftime.

* 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.
---
v5: fixed erroneously duplicated strong_alias
v4: added period and double space where missing
    added libc_hidden_proto and libc_hidden_def
v3: specified which tests were done
v2: add more explanations and partial changelog

 include/time.h  |  7 +++++++
 time/difftime.c | 34 +++++++++++++++++++++++++---------
 2 files changed, 32 insertions(+), 9 deletions(-)

Comments

Joseph Myers Dec. 20, 2018, 8:49 p.m. | #1
This version is OK.
H.J. Lu Dec. 21, 2018, 6:47 p.m. | #2
On Thu, Dec 20, 2018 at 12:40 PM Albert ARIBAUD (3ADEV)
<albert.aribaud@3adev.fr> wrote:
>
> 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.
>
> This patch was tested by running 'make check' on branch
> master then applying this patch and its two predecessors and
> running 'make check' again, and checking that both 'make check'
> yield identical results. This was done on x86_64-linux-gnu and
> i686-linux-gnu.
>
> This patch was also functionally tested with an ad hoc userland
> C program which checks the result of difftime for various pairs
> of 32-bit and, for 64-bit builds, of 64-bit time_t values too.
> The program was built and run against a glibc with and without
> the patch, and the results compared to ensure the patch does
> not change the behavior of difftime.
>
> * 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.
> ---

This caused:

https://sourceware.org/bugzilla/show_bug.cgi?id=24023
Joseph Myers Dec. 21, 2018, 6:55 p.m. | #3
On Fri, 21 Dec 2018, H.J. Lu wrote:

> This caused:
> 
> https://sourceware.org/bugzilla/show_bug.cgi?id=24023

I am testing this patch and will commit if the tests pass.


Update nios2, sparc32 localplt.data for difftime changes (bug 24023).

The recent difftime changes introduced localplt test failures on nios2
and sparc32, two configurations where some soft-fp functions are
defined in / exported from libc.so, and where the difftime changes
affected the particular set of floating-point operations used in
libc.so.  This patch adds those functions to localplt.data, alongside
other such functions already there.  (In the sparc32 case, and more
generally on any platform where long double is a software
floating-point type, it would probably be more efficient to avoid
using long double at all in difftime, but that's a pre-existing
issue.)

Tested with build-many-glibcs.py for its nios2 and sparcv9
configurations.

2018-12-21  Joseph Myers  <joseph@codesourcery.com>

	[BZ #24023]
	* sysdeps/unix/sysv/linux/nios2/localplt.data: Allow __floatundidf
	PLT reference in libc.so.
	* sysdeps/unix/sysv/linux/sparc/sparc32/localplt.data: Allow
	_Q_lltoq and _Q_qtod PLT references in libc.so.

diff --git a/sysdeps/unix/sysv/linux/nios2/localplt.data b/sysdeps/unix/sysv/linux/nios2/localplt.data
index 4430a5891e..3805ed56b9 100644
--- a/sysdeps/unix/sysv/linux/nios2/localplt.data
+++ b/sysdeps/unix/sysv/linux/nios2/localplt.data
@@ -26,6 +26,7 @@ libc.so: __divsf3
 libc.so: __nedf2
 libc.so: __eqdf2
 libc.so: __extendsfdf2
+libc.so: __floatundidf ?
 libm.so: matherr
 # The main malloc is interposed into the dynamic linker, for
 # allocations after the initial link (when dlopen is used).
diff --git a/sysdeps/unix/sysv/linux/sparc/sparc32/localplt.data b/sysdeps/unix/sysv/linux/sparc/sparc32/localplt.data
index 1668f4017e..6bf10ff858 100644
--- a/sysdeps/unix/sysv/linux/sparc/sparc32/localplt.data
+++ b/sysdeps/unix/sysv/linux/sparc/sparc32/localplt.data
@@ -8,8 +8,10 @@ libc.so: _Q_fle ?
 libc.so: _Q_flt ?
 libc.so: _Q_fne ?
 libc.so: _Q_itoq ?
+libc.so: _Q_lltoq ?
 libc.so: _Q_mul ?
 libc.so: _Q_sub ?
+libc.so: _Q_qtod ?
 libc.so: _Unwind_Find_FDE
 libc.so: calloc
 libc.so: free

Patch

diff --git a/include/time.h b/include/time.h
index a10a59a628..f935e9dd3e 100644
--- a/include/time.h
+++ b/include/time.h
@@ -141,6 +141,13 @@  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);
+libc_hidden_proto (__difftime64)
+#endif
+
 extern double __difftime (time_t time1, time_t time0);
 
 
diff --git a/time/difftime.c b/time/difftime.c
index 7c5dd9898b..5243cbd9cb 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,20 @@  __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
+
+libc_hidden_def (__difftime64)
+
+double
+__difftime (time_t time1, time_t time0)
+{
+  return __difftime64 (time1, time0);
+}
+
+#endif
+
 strong_alias (__difftime, difftime)
+