From patchwork Fri Oct 19 04:35:28 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Albert ARIBAUD (3ADEV)" X-Patchwork-Id: 986520 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=sourceware.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=libc-alpha-return-96526-incoming=patchwork.ozlabs.org@sourceware.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=3adev.fr Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.b="D7995LS5"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 42btQD6PRXz9sCm for ; Fri, 19 Oct 2018 15:35:48 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id; q=dns; s= default; b=nClH0k/4QYZ9VgcCrXIbXa+1aB2s+dWLiS9z2C28h3GgHPIJhYJbz ua2+1/n4JEJ6uU/qswho/C/FEe1ppE4MI16x+rhXCkp3mXlyvjxPgXDOkDoj0ajT +s064CAjA5NiZj2eSUA/GywtKuPz0dik4lSA7DDjzKSLbmWah1zZJc= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id; s=default; bh=FHr4+eWaWSxXQJBFuNASPdY3sgQ=; b=D7995LS5EQCUiEylsqOw2rsU3FVl YdAJt+m+fqSy2QW1QKJ9E0WO5mdTMvqNYBipx+WKS4uDHh6CfZtH4ES4DUNxnNpI RMWsbw9iO2YvRv1gSs0i5eKyq396KVWDoyAEw9Y4WNBgkOKKTkt0uPXik2fXKCfj GQMnN0l6U2tAoCs= Received: (qmail 92650 invoked by alias); 19 Oct 2018 04:35:42 -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 92608 invoked by uid 89); 19 Oct 2018 04:35:39 -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, KAM_SHORT, RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.2 spammy=H*Ad:D*fr X-HELO: smtp3-g21.free.fr From: "Albert ARIBAUD (3ADEV)" To: libc-alpha@sourceware.org Cc: "Albert ARIBAUD (3ADEV)" Subject: [PATCH v11 1/3] Y2038: provide size of default time_t for target architecture Date: Fri, 19 Oct 2018 06:35:28 +0200 Message-Id: <20181019043530.30366-1-albert.aribaud@3adev.fr> To determine whether the default time_t interfaces are 32-bit and so need conversions, or are 64-bit and so are compatible with the internal 64-bit type without conversions, a macro giving the size of the default time_t is also required. This macro is called __TIMESIZE. This macro can then be used instead of __WORDSIZE in msq-pad.h and shm-pad.h files, which in turn allows removing their x86 variants, and in sem-pad.h files but keeping the x86 variant. This patch was tested by running 'make check' on branch master then applying this patch 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. * bits/timesize.h: New file. * stdlib/Makefile (headers): Add bits/timesize.h. * sysdeps/unix/sysv/linux/bits/msq-pad.h: Replace __WORDSIZE with __TIMESIZE. * sysdeps/unix/sysv/linux/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/mips/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/msq-pad.h: Delete file. * sysdeps/unix/sysv/linux/x86/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/timesize.h: New file. --- .../linux/x86/bits/shm-pad.h => bits/timesize.h | 16 ++++------------ stdlib/Makefile | 2 +- sysdeps/unix/sysv/linux/bits/msq-pad.h | 4 ++-- sysdeps/unix/sysv/linux/bits/sem-pad.h | 4 ++-- sysdeps/unix/sysv/linux/bits/shm-pad.h | 4 ++-- sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h | 4 ++-- sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h | 4 ++-- sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h | 6 +++--- sysdeps/unix/sysv/linux/mips/bits/msq-pad.h | 6 +++--- sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h | 4 ++-- sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h | 4 ++-- sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h | 6 +++--- sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h | 4 ++-- sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h | 4 ++-- sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h | 4 ++-- .../linux/x86/bits/{msq-pad.h => timesize.h} | 15 ++++++--------- 16 files changed, 40 insertions(+), 51 deletions(-) rename sysdeps/unix/sysv/linux/x86/bits/shm-pad.h => bits/timesize.h (68%) rename sysdeps/unix/sysv/linux/x86/bits/{msq-pad.h => timesize.h} (74%) diff --git a/sysdeps/unix/sysv/linux/x86/bits/shm-pad.h b/bits/timesize.h similarity index 68% rename from sysdeps/unix/sysv/linux/x86/bits/shm-pad.h rename to bits/timesize.h index 277a70fe6c..cc47ff165f 100644 --- a/sysdeps/unix/sysv/linux/x86/bits/shm-pad.h +++ b/bits/timesize.h @@ -1,4 +1,4 @@ -/* Define where padding goes in struct shmid_ds. x86 version. +/* Bit size of the time_t type at glibc build time, general case. Copyright (C) 2018 Free Software Foundation, Inc. This file is part of the GNU C Library. @@ -16,15 +16,7 @@ License along with the GNU C Library; if not, see . */ -#ifndef _SYS_SHM_H -# error "Never use directly; include instead." -#endif +#include -#ifdef __x86_64__ -# define __SHM_PAD_AFTER_TIME 0 -#else -# define __SHM_PAD_AFTER_TIME 1 -#endif -#define __SHM_PAD_BEFORE_TIME 0 -#define __SHM_SEGSZ_AFTER_TIME 0 -#define __SHM_PAD_BETWEEN_TIME_AND_SEGSZ 0 +/* Size in bits of the 'time_t' type of the default ABI. */ +#define __TIMESIZE __WORDSIZE diff --git a/stdlib/Makefile b/stdlib/Makefile index 01194bbf7c..1773a341b5 100644 --- a/stdlib/Makefile +++ b/stdlib/Makefile @@ -24,7 +24,7 @@ include ../Makeconfig headers := stdlib.h bits/stdlib.h bits/stdlib-ldbl.h bits/stdlib-float.h \ monetary.h bits/monetary-ldbl.h \ - inttypes.h stdint.h bits/wordsize.h \ + inttypes.h stdint.h bits/wordsize.h bits/timesize.h \ errno.h sys/errno.h bits/errno.h bits/types/error_t.h \ ucontext.h sys/ucontext.h bits/indirect-return.h \ alloca.h fmtmsg.h \ diff --git a/sysdeps/unix/sysv/linux/bits/msq-pad.h b/sysdeps/unix/sysv/linux/bits/msq-pad.h index 97dee0beff..53f367dfa2 100644 --- a/sysdeps/unix/sysv/linux/bits/msq-pad.h +++ b/sysdeps/unix/sysv/linux/bits/msq-pad.h @@ -20,12 +20,12 @@ # error "Never use directly; include instead." #endif -#include +#include /* On most architectures, padding goes after time fields for 32-bit systems and is omitted for 64-bit systems. Some architectures pad before time fields instead, or omit padding despite being 32-bit. */ -#define __MSQ_PAD_AFTER_TIME (__WORDSIZE == 32) +#define __MSQ_PAD_AFTER_TIME (__TIMESIZE == 32) #define __MSQ_PAD_BEFORE_TIME 0 diff --git a/sysdeps/unix/sysv/linux/bits/sem-pad.h b/sysdeps/unix/sysv/linux/bits/sem-pad.h index c57fea4ac8..488b591d5a 100644 --- a/sysdeps/unix/sysv/linux/bits/sem-pad.h +++ b/sysdeps/unix/sysv/linux/bits/sem-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include /* On most architectures, padding goes after time fields for 32-bit systems and is omitted for 64-bit systems. Some architectures pad @@ -29,5 +29,5 @@ used for struct semid64_ds in , as glibc does not do layout conversions for this structure. */ -#define __SEM_PAD_AFTER_TIME (__WORDSIZE == 32) +#define __SEM_PAD_AFTER_TIME (__TIMESIZE == 32) #define __SEM_PAD_BEFORE_TIME 0 diff --git a/sysdeps/unix/sysv/linux/bits/shm-pad.h b/sysdeps/unix/sysv/linux/bits/shm-pad.h index 9233c95a9f..d3cc5ebde6 100644 --- a/sysdeps/unix/sysv/linux/bits/shm-pad.h +++ b/sysdeps/unix/sysv/linux/bits/shm-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include /* On most architectures, padding goes after time fields for 32-bit systems and is omitted for 64-bit systems. Some architectures pad @@ -31,7 +31,7 @@ layout used for struct shmid64_ds in , as glibc does not do layout conversions for this structure. */ -#define __SHM_PAD_AFTER_TIME (__WORDSIZE == 32) +#define __SHM_PAD_AFTER_TIME (__TIMESIZE == 32) #define __SHM_PAD_BEFORE_TIME 0 #define __SHM_SEGSZ_AFTER_TIME 0 #define __SHM_PAD_BETWEEN_TIME_AND_SEGSZ 0 diff --git a/sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h b/sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h index 10b26b7ea6..05db3fd65b 100644 --- a/sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h +++ b/sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include #define __MSQ_PAD_AFTER_TIME 0 -#define __MSQ_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __MSQ_PAD_BEFORE_TIME (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h b/sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h index a938c2c92b..f250f64426 100644 --- a/sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h +++ b/sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include #define __SEM_PAD_AFTER_TIME 0 -#define __SEM_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __SEM_PAD_BEFORE_TIME (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h b/sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h index 6a9c5ddce2..8764bde08b 100644 --- a/sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h +++ b/sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h @@ -20,9 +20,9 @@ # error "Never use directly; include instead." #endif -#include +#include #define __SHM_PAD_AFTER_TIME 0 -#define __SHM_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __SHM_PAD_BEFORE_TIME (__TIMESIZE == 32) #define __SHM_SEGSZ_AFTER_TIME 1 -#define __SHM_PAD_BETWEEN_TIME_AND_SEGSZ (__WORDSIZE == 32) +#define __SHM_PAD_BETWEEN_TIME_AND_SEGSZ (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/mips/bits/msq-pad.h b/sysdeps/unix/sysv/linux/mips/bits/msq-pad.h index 1ddfb0d271..530babe3f9 100644 --- a/sysdeps/unix/sysv/linux/mips/bits/msq-pad.h +++ b/sysdeps/unix/sysv/linux/mips/bits/msq-pad.h @@ -20,12 +20,12 @@ # error "Never use directly; include instead." #endif -#include +#include #ifdef __MIPSEL__ -# define __MSQ_PAD_AFTER_TIME (__WORDSIZE == 32) +# define __MSQ_PAD_AFTER_TIME (__TIMESIZE == 32) # define __MSQ_PAD_BEFORE_TIME 0 #else # define __MSQ_PAD_AFTER_TIME 0 -# define __MSQ_PAD_BEFORE_TIME (__WORDSIZE == 32) +# define __MSQ_PAD_BEFORE_TIME (__TIMESIZE == 32) #endif diff --git a/sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h b/sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h index 9680176abb..d19dfd5126 100644 --- a/sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h +++ b/sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include #define __MSQ_PAD_AFTER_TIME 0 -#define __MSQ_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __MSQ_PAD_BEFORE_TIME (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h b/sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h index d4c9a93956..d7571cc755 100644 --- a/sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h +++ b/sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include #define __SEM_PAD_AFTER_TIME 0 -#define __SEM_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __SEM_PAD_BEFORE_TIME (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h b/sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h index 69a7e4a648..c8c2d44775 100644 --- a/sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h +++ b/sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h @@ -20,9 +20,9 @@ # error "Never use directly; include instead." #endif -#include +#include #define __SHM_PAD_AFTER_TIME 0 -#define __SHM_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __SHM_PAD_BEFORE_TIME (__TIMESIZE == 32) #define __SHM_SEGSZ_AFTER_TIME 1 -#define __SHM_PAD_BETWEEN_TIME_AND_SEGSZ (__WORDSIZE == 32) +#define __SHM_PAD_BETWEEN_TIME_AND_SEGSZ (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h b/sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h index 3dfeb07a48..72324e8428 100644 --- a/sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h +++ b/sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include #define __MSQ_PAD_AFTER_TIME 0 -#define __MSQ_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __MSQ_PAD_BEFORE_TIME (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h b/sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h index b85f6b70a2..27266d48d5 100644 --- a/sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h +++ b/sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h @@ -20,7 +20,7 @@ # error "Never use directly; include instead." #endif -#include +#include #define __SEM_PAD_AFTER_TIME 0 -#define __SEM_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __SEM_PAD_BEFORE_TIME (__TIMESIZE == 32) diff --git a/sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h b/sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h index c4d0c2feb8..fa3cc18a05 100644 --- a/sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h +++ b/sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h @@ -20,9 +20,9 @@ # error "Never use directly; include instead." #endif -#include +#include #define __SHM_PAD_AFTER_TIME 0 -#define __SHM_PAD_BEFORE_TIME (__WORDSIZE == 32) +#define __SHM_PAD_BEFORE_TIME (__TIMESIZE == 32) #define __SHM_SEGSZ_AFTER_TIME 1 #define __SHM_PAD_BETWEEN_TIME_AND_SEGSZ 0 diff --git a/sysdeps/unix/sysv/linux/x86/bits/msq-pad.h b/sysdeps/unix/sysv/linux/x86/bits/timesize.h similarity index 74% rename from sysdeps/unix/sysv/linux/x86/bits/msq-pad.h rename to sysdeps/unix/sysv/linux/x86/bits/timesize.h index 5d46956c77..8b88ab84b0 100644 --- a/sysdeps/unix/sysv/linux/x86/bits/msq-pad.h +++ b/sysdeps/unix/sysv/linux/x86/bits/timesize.h @@ -1,4 +1,4 @@ -/* Define where padding goes in struct msqid_ds. x86 version. +/* Bit size of the time_t type at glibc build time, x86-64 and x32 case. Copyright (C) 2018 Free Software Foundation, Inc. This file is part of the GNU C Library. @@ -16,13 +16,10 @@ License along with the GNU C Library; if not, see . */ -#ifndef _SYS_MSG_H -# error "Never use directly; include instead." -#endif - -#ifdef __x86_64__ -# define __MSQ_PAD_AFTER_TIME 0 +#if defined __x86_64__ && defined __ILP32__ +/* For x32, time is 64-bit even though word size is 32-bit. */ +# define __TIMESIZE 64 #else -# define __MSQ_PAD_AFTER_TIME 1 +/* For others, time size is word size. */ +# define __TIMESIZE __WORDSIZE #endif -#define __MSQ_PAD_BEFORE_TIME 0 From patchwork Fri Oct 19 04:35:29 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Albert ARIBAUD (3ADEV)" X-Patchwork-Id: 986521 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=sourceware.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=libc-alpha-return-96527-incoming=patchwork.ozlabs.org@sourceware.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=3adev.fr Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.b="pCZj5ulc"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 42btQP5sTVz9sCm for ; Fri, 19 Oct 2018 15:35:57 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; q=dns; s=default; b=Zc266RtPMT6HZEXVzLvkHqMe1bfs9QE RbWVi8NQZSvD3Nju8FeWUY7b+kw3wylBbWqaJih+PNgn+UEo+u9T5SUfisrsPNq9 H5rNIxemuFZilNftnMxPsZT/UU6AmNQ9iK+7GjmNlg00WB57sfa5oaBkNEayfQ7q F66dYxQkED0M= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; s=default; bh=PI+glPzVZ+ON9pnKsFXWz69YbSY=; b=pCZj5 ulcPVB3zFq9xQDpg/Wu5FlR07c3y9N0OfzJaNgDJl6xcOP6tYUV9al34EGAmPcCY gIKDupVa0eHWLJcO9l3WZiSoupGtvIgmbZtjDtIGYcOs6K7XjSLPqs9cFIYiq9Tx m3VjuLL3UQ3HGMezSRikYmODnaInB8CPWpsI0E= Received: (qmail 92661 invoked by alias); 19 Oct 2018 04:35:43 -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 92616 invoked by uid 89); 19 Oct 2018 04:35:40 -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, KAM_SHORT, RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.2 spammy=1138, leap, UD:random.h, randomh X-HELO: smtp3-g21.free.fr From: "Albert ARIBAUD (3ADEV)" To: libc-alpha@sourceware.org Cc: "Albert ARIBAUD (3ADEV)" Subject: [PATCH v11 2/3] Y2038: Add 64-bit time for all architectures Date: Fri, 19 Oct 2018 06:35:29 +0200 Message-Id: <20181019043530.30366-2-albert.aribaud@3adev.fr> In-Reply-To: <20181019043530.30366-1-albert.aribaud@3adev.fr> References: <20181019043530.30366-1-albert.aribaud@3adev.fr> glibc support for 64-bit time_t on 32-bit architectures will involve: - Using 64-bit times inside glibc, with conversions to and from 32-bit times taking place as necessary for interfaces using such times. - Adding 64-bit-time support in the glibc public API. This support should be dynamic, i.e. glibc should provide both 32-bit and 64-bit implementations and let user code choose at compile time whether to use the 32-bit or 64-bit interfaces. This requires a glibc-internal name for a type for times that are always 64-bit. Based on __TIMESIZE, a new macro is defined, __TIME64_T_TYPE, which is always the right __*_T_TYPE to hold a 64-bit-time. __TIME64_T_TYPE equals __TIME_T_TYPE if __TIMESIZE equals 64 and equals __SQUAD_T_TYPE otherwise. __time64_t can then replace uses of internal_time_t. This patch was tested by running 'make check' on branch master then applying this patch and its predecessor 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. * bit/time64.h: New file. * include/time.h: Replace internal_time_t with __time64_t. * posix/bits/types (__time64_t): Add. * stdlib/Makefile: Add bits/timesize.h to includes. * stdlib/Makefile: Add bits/time64.h to includes. * time/tzfile.c: Replace internal_time_t with __time64_t. --- bits/time64.h | 36 ++++++++++++++++++++++++++++++++++++ include/time.h | 7 +------ posix/bits/types.h | 8 ++++++++ stdlib/Makefile | 2 +- time/tzfile.c | 18 +++++++++--------- 5 files changed, 55 insertions(+), 16 deletions(-) create mode 100644 bits/time64.h diff --git a/bits/time64.h b/bits/time64.h new file mode 100644 index 0000000000..c8a9c7db5f --- /dev/null +++ b/bits/time64.h @@ -0,0 +1,36 @@ +/* bits/time64.h -- underlying types for __time64_t. Generic version. + Copyright (C) 2018 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _BITS_TYPES_H +# error "Never include directly; use instead." +#endif + +#ifndef _BITS_TIME64_H +#define _BITS_TIME64_H 1 + +/* Define __TIME64_T_TYPE so that it is always a 64-bit type. */ + +#if __TIMESIZE == 64 +/* If we already have 64-bit time type then use it. */ +# define __TIME64_T_TYPE __TIME_T_TYPE +#else +/* Define a 64-bit time type alongsize the 32-bit one. */ +# define __TIME64_T_TYPE __SQUAD_TYPE +#endif + +#endif /* bits/time64.h */ diff --git a/include/time.h b/include/time.h index e30c5fc3b1..e99711a556 100644 --- a/include/time.h +++ b/include/time.h @@ -26,10 +26,6 @@ extern __typeof (clock_getcpuclockid) __clock_getcpuclockid; /* Now define the internal interfaces. */ struct tm; -/* time_t variant for representing time zone data, independent of - time_t. */ -typedef __int64_t internal_time_t; - /* Defined in mktime.c. */ extern const unsigned short int __mon_yday[2][13] attribute_hidden; @@ -43,7 +39,7 @@ extern int __use_tzfile attribute_hidden; extern void __tzfile_read (const char *file, size_t extra, char **extrap) attribute_hidden; -extern void __tzfile_compute (internal_time_t timer, int use_localtime, +extern void __tzfile_compute (__time64_t timer, int use_localtime, long int *leap_correct, int *leap_hit, struct tm *tp) attribute_hidden; extern void __tzfile_default (const char *std, const char *dst, @@ -101,7 +97,6 @@ extern char * __strptime_internal (const char *rp, const char *fmt, extern double __difftime (time_t time1, time_t time0); - /* Use in the clock_* functions. Size of the field representing the actual clock ID. */ #define CLOCK_IDFIELD_SIZE 3 diff --git a/posix/bits/types.h b/posix/bits/types.h index 5e22ce41bf..cda0a70dd8 100644 --- a/posix/bits/types.h +++ b/posix/bits/types.h @@ -25,6 +25,7 @@ #include #include +#include /* Convenience types. */ typedef unsigned char __u_char; @@ -138,6 +139,7 @@ __extension__ typedef unsigned long long int __uintmax_t; # error #endif #include /* Defines __*_T_TYPE macros. */ +#include /* Defines __TIME*_T_TYPE macros. */ __STD_TYPE __DEV_T_TYPE __dev_t; /* Type of device numbers. */ @@ -211,6 +213,12 @@ __STD_TYPE __U32_TYPE __socklen_t; It is not currently necessary for this to be machine-specific. */ typedef int __sig_atomic_t; +#if __TIMESIZE == 64 +# define __time64_t __time_t +#else +__STD_TYPE __TIME64_T_TYPE __time64_t; /* Seconds since the Epoch. */ +#endif + #undef __STD_TYPE #endif /* bits/types.h */ diff --git a/stdlib/Makefile b/stdlib/Makefile index 1773a341b5..14921186e0 100644 --- a/stdlib/Makefile +++ b/stdlib/Makefile @@ -29,7 +29,7 @@ headers := stdlib.h bits/stdlib.h bits/stdlib-ldbl.h bits/stdlib-float.h \ ucontext.h sys/ucontext.h bits/indirect-return.h \ alloca.h fmtmsg.h \ bits/stdlib-bsearch.h sys/random.h bits/stdint-intn.h \ - bits/stdint-uintn.h + bits/stdint-uintn.h bits/time64.h bits/timesize.h \ routines := \ atof atoi atol atoll \ diff --git a/time/tzfile.c b/time/tzfile.c index 72ef75f074..844a68de8c 100644 --- a/time/tzfile.c +++ b/time/tzfile.c @@ -44,12 +44,12 @@ struct ttinfo struct leap { - internal_time_t transition; /* Time the transition takes effect. */ + __time64_t transition; /* Time the transition takes effect. */ long int change; /* Seconds of correction to apply. */ }; static size_t num_transitions; -libc_freeres_ptr (static internal_time_t *transitions); +libc_freeres_ptr (static __time64_t *transitions); static unsigned char *type_idxs; static size_t num_types; static struct ttinfo *types; @@ -113,8 +113,8 @@ __tzfile_read (const char *file, size_t extra, char **extrap) size_t tzspec_len; char *new = NULL; - _Static_assert (sizeof (internal_time_t) == 8, - "internal_time_t must be eight bytes"); + _Static_assert (sizeof (__time64_t) == 8, + "__time64_t must be eight bytes"); __use_tzfile = 0; @@ -217,9 +217,9 @@ __tzfile_read (const char *file, size_t extra, char **extrap) if (__builtin_expect (num_transitions > ((SIZE_MAX - (__alignof__ (struct ttinfo) - 1)) - / (sizeof (internal_time_t) + 1)), 0)) + / (sizeof (__time64_t) + 1)), 0)) goto lose; - total_size = num_transitions * (sizeof (internal_time_t) + 1); + total_size = num_transitions * (sizeof (__time64_t) + 1); total_size = ((total_size + __alignof__ (struct ttinfo) - 1) & ~(__alignof__ (struct ttinfo) - 1)); types_idx = total_size; @@ -276,7 +276,7 @@ __tzfile_read (const char *file, size_t extra, char **extrap) goto lose; type_idxs = (unsigned char *) transitions + (num_transitions - * sizeof (internal_time_t)); + * sizeof (__time64_t)); types = (struct ttinfo *) ((char *) transitions + types_idx); zone_names = (char *) types + num_types * sizeof (struct ttinfo); leaps = (struct leap *) ((char *) transitions + leaps_idx); @@ -578,7 +578,7 @@ __tzfile_default (const char *std, const char *dst, } void -__tzfile_compute (internal_time_t timer, int use_localtime, +__tzfile_compute (__time64_t timer, int use_localtime, long int *leap_correct, int *leap_hit, struct tm *tp) { @@ -667,7 +667,7 @@ __tzfile_compute (internal_time_t timer, int use_localtime, initial search spot from it. Half of a gregorian year has on average 365.2425 * 86400 / 2 = 15778476 seconds. The value i can be truncated if size_t is smaller than - internal_time_t, but this is harmless because it is just + __time64_t, but this is harmless because it is just a guess. */ i = (transitions[num_transitions - 1] - timer) / 15778476; if (i < num_transitions) From patchwork Fri Oct 19 04:35:30 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Albert ARIBAUD (3ADEV)" X-Patchwork-Id: 986522 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=sourceware.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=libc-alpha-return-96528-incoming=patchwork.ozlabs.org@sourceware.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=3adev.fr Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.b="k+fPRxld"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 42btQZ61T3z9sCm for ; Fri, 19 Oct 2018 15:36:06 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; q=dns; s=default; b=PKPsg7rjHAtiwuwt0WTkeyYNoIafc1S qHP6sNrGghMrrGImp+avtd9WQc1duZ87veS44L02TF+tAv5/Ng7K5zXUfaxKhLt+ OOuVMtmGTBxVEtyAc/F85FZvuzBvZEhWeIBgy+SNJ+8PgszDlFPDRADDPDr6QVTv GEIldZ+xUt3c= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; s=default; bh=jK7KNGGnNLIuRZMBwwjSgy+gNeI=; b=k+fPR xldZ/DC9bbqc9zAtm9/q3i1aT8SErKutKAykdjxlxFMXZAkdll4UOaVSuhqdFe89 41sZJhe0HuNDlpxTZ+w+s0Is365eAbD5LSizxjybDeVJSBkCmJsYo/AI4QKHOk75 Ujxvsig3tCaUwlUJxcWXZFu0+kYSgArG5TTib0= Received: (qmail 92940 invoked by alias); 19 Oct 2018 04:35:44 -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 92780 invoked by uid 89); 19 Oct 2018 04:35:43 -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, KAM_SHORT, RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.2 spammy=2150, 4167, DAYS, Turn X-HELO: smtp3-g21.free.fr From: "Albert ARIBAUD (3ADEV)" To: libc-alpha@sourceware.org Cc: "Albert ARIBAUD (3ADEV)" Subject: [PATCH v11 3/3] Y2038: make __tz_convert compatible with 64-bit-time Date: Fri, 19 Oct 2018 06:35:30 +0200 Message-Id: <20181019043530.30366-3-albert.aribaud@3adev.fr> In-Reply-To: <20181019043530.30366-1-albert.aribaud@3adev.fr> References: <20181019043530.30366-1-albert.aribaud@3adev.fr> Now that __time_64_t exists, we can switch internal function __tz_convert from 32-bit to 64-bit time. This involves switching some other internal functions and turning some implementations which use these into wrappers between public 32-bit and internal 64-bit time. 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. * include/time.h (__tz_compute): replace time_t with __time64_t * include/time.h (__ctime64): Add. * include/time.h (__ctime64_r): Likewise. * include/time.h (__localtime64): Likewise. * include/time.h (__localtime64_r): Likewise. * include/time.h (__gmtime64): Likewise. * include/time.h (__gmtime64_r): Likewise. * include/time.h (__offtime): Replace const time_t* argument with __time64_t. * include/time.h (__tz_convert): Likewise. * time/ctime.c (__ctime64): Add. * time/ctime.c (__ctime): Turn into a wrapper. * time/ctime_r.c (__ctime64_r): Add. * time/ctime_r.c (__ctime_r): Turn into a wrapper. * time/gmtime.c (__gmtime64): Add. * time/gmtime.c (__gmtime): Turn into a wrapper. * time/gmtime.c (__gmtime64_r): Add. * time/gmtime.c (__gmtime_r): Turn into a wrapper. * time/localtime.c (__localtime64): Add. * time/localtime.c (__localtime): Turn into a wrapper. * time/localtime.c (__localtime64_r): Add. * time/localtime.c (__localtime_r): Turn into a wrapper. * time/offtime.c (__offtime): Replace const time_t* argument with __time64_t. * time/offtime.c (__offtime): Turn all time_t variables into __time64_t ones. * time/tzfile.c (__tzfile_compute): fix call to __offtime. * time/tzset.c: Turn all time_t variables into __time64_t ones. * time/tzset.c (__tz_convert): fix call to __tzfile_compute. * time/tzset.c (__tz_convert): fix call to __tz_compute. --- include/time.h | 44 +++++++++++++++++++++++++++++++++++++++----- time/ctime.c | 17 +++++++++++++++-- time/ctime_r.c | 17 +++++++++++++++-- time/gmtime.c | 37 +++++++++++++++++++++++++++++++++---- time/localtime.c | 37 +++++++++++++++++++++++++++++++++---- time/offtime.c | 12 ++++++------ time/tzfile.c | 14 ++++---------- time/tzset.c | 27 ++++++++++----------------- 8 files changed, 155 insertions(+), 50 deletions(-) diff --git a/include/time.h b/include/time.h index e99711a556..2710b4521a 100644 --- a/include/time.h +++ b/include/time.h @@ -46,7 +46,7 @@ extern void __tzfile_default (const char *std, const char *dst, long int stdoff, long int dstoff) attribute_hidden; extern void __tzset_parse_tz (const char *tz) attribute_hidden; -extern void __tz_compute (time_t timer, struct tm *tm, int use_localtime) +extern void __tz_compute (__time64_t timer, struct tm *tm, int use_localtime) __THROW attribute_hidden; /* Subroutine of `mktime'. Return the `time_t' representation of TP and @@ -56,18 +56,52 @@ extern time_t __mktime_internal (struct tm *__tp, struct tm *(*__func) (const time_t *, struct tm *), long int *__offset) attribute_hidden; + +/* nis/nis_print.c needs ctime, so even if ctime is not declared here, + we define __ctime64 as ctime so that nis/nis_print.c can get linked + against a function called ctime. */ +#if __TIMESIZE == 64 +# define __ctime64 ctime +#endif + +#if __TIMESIZE == 64 +# define __ctime64_r ctime_r +#endif + +#if __TIMESIZE == 64 +# define __localtime64 localtime +#else +extern struct tm *__localtime64 (const __time64_t *__timer); +libc_hidden_proto (__localtime64) +#endif + extern struct tm *__localtime_r (const time_t *__timer, struct tm *__tp) attribute_hidden; +#if __TIMESIZE == 64 +# define __localtime64_r __localtime_r +#else +extern struct tm *__localtime64_r (const __time64_t *__timer, + struct tm *__tp) attribute_hidden; +#endif + extern struct tm *__gmtime_r (const time_t *__restrict __timer, struct tm *__restrict __tp); libc_hidden_proto (__gmtime_r) -/* Compute the `struct tm' representation of *T, +#if __TIMESIZE == 64 +# define __gmtime64 gmtime +# define __gmtime64_r __gmtime_r +#else +extern struct tm *__gmtime64_r (const __time64_t *__restrict __timer, + struct tm *__restrict __tp); +#endif + +/* Compute the `struct tm' representation of T, offset OFFSET seconds east of UTC, and store year, yday, mon, mday, wday, hour, min, sec into *TP. Return nonzero if successful. */ -extern int __offtime (const time_t *__timer, +extern int __offtime (__time64_t __timer, long int __offset, struct tm *__tp) attribute_hidden; @@ -76,8 +110,8 @@ extern char *__asctime_r (const struct tm *__tp, char *__buf) extern void __tzset (void) attribute_hidden; /* Prototype for the internal function to get information based on TZ. */ -extern struct tm *__tz_convert (const time_t *timer, int use_localtime, - struct tm *tp) attribute_hidden; +extern struct tm *__tz_convert (__time64_t timer, int use_localtime, + struct tm *tp) attribute_hidden; extern int __nanosleep (const struct timespec *__requested_time, struct timespec *__remaining); diff --git a/time/ctime.c b/time/ctime.c index 1222614f29..286c6b579c 100644 --- a/time/ctime.c +++ b/time/ctime.c @@ -20,9 +20,22 @@ /* Return a string as returned by asctime which is the representation of *T in that form. */ char * -ctime (const time_t *t) +__ctime64 (const __time64_t *t) { /* The C Standard says ctime (t) is equivalent to asctime (localtime (t)). In particular, ctime and asctime must yield the same pointer. */ - return asctime (localtime (t)); + return asctime (__localtime64 (t)); } + +/* Provide a 32-bit wrapper if needed */ + +#if __TIMESIZE != 64 + +char * +ctime (const time_t *t) +{ + __time64_t t64 = *t; + return __ctime64 (&t64); +} + +#endif diff --git a/time/ctime_r.c b/time/ctime_r.c index c111146d76..84089599a7 100644 --- a/time/ctime_r.c +++ b/time/ctime_r.c @@ -22,8 +22,21 @@ /* Return a string as returned by asctime which is the representation of *T in that form. Reentrant version. */ char * -ctime_r (const time_t *t, char *buf) +__ctime64_r (const __time64_t *t, char *buf) { struct tm tm; - return __asctime_r (__localtime_r (t, &tm), buf); + return __asctime_r (__localtime64_r (t, &tm), buf); } + +/* Provide a 32-bit wrapper if needed */ + +#if __TIMESIZE != 64 + +char * +ctime_r (const time_t *t, char *buf) +{ + __time64_t t64 = *t; + return __ctime64_r (&t64, buf); +} + +#endif diff --git a/time/gmtime.c b/time/gmtime.c index dc33b3e68a..d485a38c6f 100644 --- a/time/gmtime.c +++ b/time/gmtime.c @@ -18,20 +18,49 @@ #include -/* Return the `struct tm' representation of *T in UTC, +/* Return the `struct tm' representation of T in UTC, using *TP to store the result. */ +struct tm * +__gmtime64_r (const __time64_t *t, struct tm *tp) +{ + return __tz_convert (*t, 0, tp); +} + +/* Provide a 32-bit wrapper if needed */ + +#if __TIMESIZE != 64 + struct tm * __gmtime_r (const time_t *t, struct tm *tp) { - return __tz_convert (t, 0, tp); + __time64_t t64 = *t; + return __gmtime64_r (&t64, tp); } + +#endif + +/* This always works because either __TIMESIZE != 64 and __gmtime_r exists + or __TIMESIZE == 64 and the definition of __gmtime64_r above actually + defined __gmtime_r. */ libc_hidden_def (__gmtime_r) weak_alias (__gmtime_r, gmtime_r) +/* Return the `struct tm' representation of 64-bit-time *T in UTC. */ +struct tm * +__gmtime64 (const __time64_t *t) +{ + return __tz_convert (*t, 0, &_tmbuf); +} + +/* Provide a 32-bit wrapper if needed */ + +#if __TIMESIZE != 64 -/* Return the `struct tm' representation of *T in UTC. */ struct tm * gmtime (const time_t *t) { - return __tz_convert (t, 0, &_tmbuf); + __time64_t t64 = *t; + return __gmtime64 (&t64); } + +#endif diff --git a/time/localtime.c b/time/localtime.c index 8684a8a971..8e3b76e6cb 100644 --- a/time/localtime.c +++ b/time/localtime.c @@ -21,21 +21,50 @@ /* The C Standard says that localtime and gmtime return the same pointer. */ struct tm _tmbuf; - /* Return the `struct tm' representation of *T in local time, using *TP to store the result. */ +struct tm * +__localtime64_r (const __time64_t *t, struct tm *tp) +{ + return __tz_convert (*t, 1, tp); +} + +/* Provide a 32-bit wrapper if needed */ + +#if __TIMESIZE != 64 + struct tm * __localtime_r (const time_t *t, struct tm *tp) { - return __tz_convert (t, 1, tp); + __time64_t t64 = *t; + return __localtime64_r (&t64, tp); } -weak_alias (__localtime_r, localtime_r) +#endif + +/* This always works because either __TIMESIZE != 64 and __localtime_r + exists or __TIMESIZE == 64 and the definition of __localtime64_r above + actually defined __localtime_r. */ +weak_alias (__localtime_r, localtime_r) /* Return the `struct tm' representation of *T in local time. */ +struct tm * +__localtime64 (const __time64_t *t) +{ + return __tz_convert (*t, 1, &_tmbuf); +} +libc_hidden_def (__localtime64) + +/* Provide a 32-bit wrapper if needed */ + +#if __TIMESIZE != 64 + struct tm * localtime (const time_t *t) { - return __tz_convert (t, 1, &_tmbuf); + __time64_t t64 = *t; + return __localtime64 (&t64); } libc_hidden_def (localtime) + +#endif diff --git a/time/offtime.c b/time/offtime.c index 04c48389fc..3309fcd484 100644 --- a/time/offtime.c +++ b/time/offtime.c @@ -21,18 +21,18 @@ #define SECS_PER_HOUR (60 * 60) #define SECS_PER_DAY (SECS_PER_HOUR * 24) -/* Compute the `struct tm' representation of *T, +/* Compute the `struct tm' representation of T, offset OFFSET seconds east of UTC, and store year, yday, mon, mday, wday, hour, min, sec into *TP. Return nonzero if successful. */ int -__offtime (const time_t *t, long int offset, struct tm *tp) +__offtime (__time64_t t, long int offset, struct tm *tp) { - time_t days, rem, y; + __time64_t days, rem, y; const unsigned short int *ip; - days = *t / SECS_PER_DAY; - rem = *t % SECS_PER_DAY; + days = t / SECS_PER_DAY; + rem = t % SECS_PER_DAY; rem += offset; while (rem < 0) { @@ -60,7 +60,7 @@ __offtime (const time_t *t, long int offset, struct tm *tp) while (days < 0 || days >= (__isleap (y) ? 366 : 365)) { /* Guess a corrected year, assuming 365 days per year. */ - time_t yg = y + days / 365 - (days % 365 < 0); + __time64_t yg = y + days / 365 - (days % 365 < 0); /* Adjust DAYS and Y to match the guessed year. */ days -= ((yg - y) * 365 diff --git a/time/tzfile.c b/time/tzfile.c index 844a68de8c..3920525bf3 100644 --- a/time/tzfile.c +++ b/time/tzfile.c @@ -633,16 +633,10 @@ __tzfile_compute (__time64_t timer, int use_localtime, /* Convert to broken down structure. If this fails do not use the string. */ - { - time_t truncated = timer; - if (__glibc_unlikely (truncated != timer - || ! __offtime (&truncated, 0, tp))) - goto use_last; - } - - /* Use the rules from the TZ string to compute the change. - timer fits into time_t due to the truncation check - above. */ + if (__glibc_unlikely (! __offtime (timer, 0, tp))) + goto use_last; + + /* Use the rules from the TZ string to compute the change. */ __tz_compute (timer, tp, 1); /* If tzspec comes from posixrules loaded by __tzfile_default, diff --git a/time/tzset.c b/time/tzset.c index a828b9fb75..834cc3ccec 100644 --- a/time/tzset.c +++ b/time/tzset.c @@ -16,7 +16,6 @@ . */ #include -#include #include #include #include @@ -27,7 +26,7 @@ #include -#define SECSPERDAY ((time_t) 86400) +#define SECSPERDAY ((__time64_t) 86400) char *__tzname[2] = { (char *) "GMT", (char *) "GMT" }; int __daylight = 0; @@ -55,7 +54,7 @@ typedef struct /* We cache the computed time of change for a given year so we don't have to recompute it. */ - time_t change; /* When to change to this zone. */ + __time64_t change; /* When to change to this zone. */ int computed_for; /* Year above is computed for. */ } tz_rule; @@ -416,7 +415,7 @@ tzset_internal (int always) tz_rules[0].name = tz_rules[1].name = "UTC"; if (J0 != 0) tz_rules[0].type = tz_rules[1].type = J0; - tz_rules[0].change = tz_rules[1].change = (time_t) -1; + tz_rules[0].change = tz_rules[1].change = -1; update_vars (); return; } @@ -424,13 +423,13 @@ tzset_internal (int always) __tzset_parse_tz (tz); } -/* Figure out the exact time (as a time_t) in YEAR +/* Figure out the exact time (as a __time64_t) in YEAR when the change described by RULE will occur and put it in RULE->change, saving YEAR in RULE->computed_for. */ static void compute_change (tz_rule *rule, int year) { - time_t t; + __time64_t t; if (year != -1 && rule->computed_for == year) /* Operations on times in 2 BC will be slower. Oh well. */ @@ -516,7 +515,7 @@ compute_change (tz_rule *rule, int year) /* Figure out the correct timezone for TM and set `__tzname', `__timezone', and `__daylight' accordingly. */ void -__tz_compute (time_t timer, struct tm *tm, int use_localtime) +__tz_compute (__time64_t timer, struct tm *tm, int use_localtime) { compute_change (&tz_rules[0], 1900 + tm->tm_year); compute_change (&tz_rules[1], 1900 + tm->tm_year); @@ -562,20 +561,14 @@ __tzset (void) } weak_alias (__tzset, tzset) -/* Return the `struct tm' representation of *TIMER in the local timezone. +/* Return the `struct tm' representation of TIMER in the local timezone. Use local time if USE_LOCALTIME is nonzero, UTC otherwise. */ struct tm * -__tz_convert (const time_t *timer, int use_localtime, struct tm *tp) +__tz_convert (__time64_t timer, int use_localtime, struct tm *tp) { long int leap_correction; int leap_extra_secs; - if (timer == NULL) - { - __set_errno (EINVAL); - return NULL; - } - __libc_lock_lock (tzset_lock); /* Update internal database according to current TZ setting. @@ -584,14 +577,14 @@ __tz_convert (const time_t *timer, int use_localtime, struct tm *tp) tzset_internal (tp == &_tmbuf && use_localtime); if (__use_tzfile) - __tzfile_compute (*timer, use_localtime, &leap_correction, + __tzfile_compute (timer, use_localtime, &leap_correction, &leap_extra_secs, tp); else { if (! __offtime (timer, 0, tp)) tp = NULL; else - __tz_compute (*timer, tp, use_localtime); + __tz_compute (timer, tp, use_localtime); leap_correction = 0L; leap_extra_secs = 0; }