Commit: 0e5d279d52ab9a24b3a9afed5f2b6949781defed - mingw-wsl-patches-win64 (hg)

Fork of Keith's WSL Patch Queue for my Win64 work

Commit MetaInfo

• Revision: 0e5d279d52ab9a24b3a9afed5f2b6949781defed (tree)
• Time: 2019-04-03 07:00:03
• Author: Keith Marshall <keith@user...>
• Commiter: Keith Marshall

Log Message

Add two Win64-specific MinGW Runtime patches.

Change Summary

• modified: series
• add: cpu-features-x86-64.patch
• add: win64-time-typedef.patch

Incremental Difference

diff -r bd9c2d0cd8e6 -r 0e5d279d52ab cpu-features-x86-64.patch
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cpu-features-x86-64.patch	Tue Apr 02 23:00:03 2019 +0100
@@ -0,0 +1,182 @@
+# HG changeset patch
+# Parent 66b461070c4b063621a1af46c9fbf17323ce536a
+Make CPU features initialization code x86-64 compliant.
+
+* cpu_features.sx (CPUID_FLAG) [__x86_64__]: Omit check.
+(CFI_OFFSET_BASE): New C preprocessor macro; use it with...
+(.cfi_def_cfa, .cfi_def_cfa_offset, .cfi_offset): ...these, to...
+[__x86_64__]: ...compute 64-bit offsets, as required, otherwise...
+[!__x86_64__]: ...equivalent of existing hard-coded 32-bit offsets.
+(FXSAVE_BUF_ALIGN) [__x86_64__]: Specify it as a 64-bit mask value.
+(FXSAVE_BUF_ALIGN) [!__x86_64__]: Retain existing 32-bit definition.
+(__cpu_features_init): Use x86-64 register names for "rsp", "rbp", and
+"rbx", where appropriate; map them, using C preprocessor defines...
+[!__x86_64__]: ...to "esp", "ebp", and "ebx" respectively.
+
+diff --git a/mingwrt/cpu_features.sx b/mingwrt/cpu_features.sx
+--- a/mingwrt/cpu_features.sx
++++ b/mingwrt/cpu_features.sx
+@@ -40,12 +40,37 @@
+ #define RH_FLAG(BITNUM)		(1 << ((BITNUM) - 8))
+ 
+ #define CPUID_FLAG		RX_FLAG(21)	/* EFLAGS bit 21 */
+ 
+ #define FXSAVE_BUFSIZ		       512
++#define FXTEST_BITS		0x0013C0DE
++
++#if __x86_64__
++/* For 64-bit CPUs, we need a 64-bit mask for 16-byte stack alignment,
++ * and .cfi_offset computations must be based on an 8-byte increment,
++ * (3-bit shift), per register push operation...
++ */
++#define FXSAVE_BUF_ALIGN	0xFFFFFFFFFFFFFFF0
++#define CFI_OFFSET_BASE(COUNT)	((COUNT) << 3)
++
++#else	/* !__x86_64__ */
++/* ...whereas, for 32-bit CPUs, we need only a 32-bit mask for 16-byte
++ * stack alignment, and .cfi_offset computations are based on a 4-byte
++ * increment, (2-bit shift), per register push.
++ */
+ #define FXSAVE_BUF_ALIGN	0xFFFFFFF0
+-#define FXTEST_BITS		0x0013C0DE
++#define CFI_OFFSET_BASE(COUNT)	((COUNT) << 2)
++
++/* Additionally, we've adopted the convention of using 64-bit register
++ * names, where appropriate; since these registers don't exist on 32-bit
++ * x86 CPUs, we must map them to corresponding 32-bit register names.
++ */
++#define rbp			ebp
++#define rbx			ebx
++#define rsp			esp
++
++#endif	/* !__x86_64__ */
+ 
+ /* FIXME: is this optimization really worthwhile here?  It breaks,
+  * with older GAS versions, (such as that commonly deployed in the
+  * GCC-3.4.5 era, and earlier)!
+  *
+@@ -70,11 +95,15 @@
+ .def	___cpu_features_init;	.scl	2;	.type	32;	.endef
+ 
+ ___cpu_features_init:
+ 
+ .cfi_startproc
+-/* Initialization requires use of the CPUID instruction; to check if it is
++/* Initialization requires use of the CPUID instruction; we may safely assume
++ * that it is always available, on 64-bit CPUs, but...
++ */
++#if !__x86_64__
++/* ...in the case of 32-bit CPUs, we cannot be sure; thus, to check if it is
+  * supported by the host CPU, we try to toggle the CPUID flag bit within the
+  * EFLAGS register, (ultimately leaving it unchanged).
+  */
+ 		pushf				/* save original flags state */
+ 		pushf				/* duplicate them in both... */
+@@ -95,18 +124,20 @@
+  */
+ 		xor	eax, edx		/* isolate CPUID_FLAG state  */
+ 		test	eax, CPUID_FLAG		/* did it change?	     */
+ 		je	90f			/* no: quit immediately      */
+ 
++#endif	/* !__x86_64__ */
++
+ /* If we're still here, then we may safely interrogate the CPU, using
+  * the CPUID instruction, to identify various CPU features which may, or
+  * may not, be supported, but first...
+  */
+-		push	ebx			/* ...we MUST preserve this! */
++		push	rbx			/* ...we MUST preserve this! */
+ 
+-.cfi_def_cfa_offset	8
+-.cfi_offset		ebx, -8
++.cfi_def_cfa_offset	CFI_OFFSET_BASE(2)
++.cfi_offset		ebx, -CFI_OFFSET_BASE(2)
+ 
+ /* First, we must perform a level zero CPUID enquiry, to determine the
+  * maximum level of interrogation which is supported.
+  */
+ 		xor	eax, eax		/* zero request level code   */
+@@ -168,48 +199,48 @@ 15:
+ /* We must create a local stack frame, with the stack pointer aligned to a
+  * sixteen byte boundary, in which to allocate an FXSAVE buffer; (failure to
+  * align this correctly will raise an unhandled exception, and GCC cannot be
+  * trusted to get this right in C language code).
+  */
+-		push	ebp
+-		mov	ebp, esp
++		push	rbp
++		mov	rbp, rsp
+ 
+-.cfi_def_cfa		ebp, 12
+-.cfi_offset		ebp, -12
++.cfi_def_cfa		rbp, CFI_OFFSET_BASE(3)
++.cfi_offset		rbp, -CFI_OFFSET_BASE(3)
+ 
+-		sub	esp, FXSAVE_BUFSIZ
+-		and	esp, FXSAVE_BUF_ALIGN
++		sub	rsp, FXSAVE_BUFSIZ
++		and	rsp, FXSAVE_BUF_ALIGN
+ 
+ /* Save the FPU state, and immediately attempt to restore it with some of
+  * the SSE specific control flags inverted.
+  */
+-		fxsave	[esp]
+-		mov	ebx, DWORD PTR 200[esp]
+-		xor	DWORD PTR 200[esp], FXTEST_BITS
+-		fxrstor	[esp]
++		fxsave	[rsp]
++		mov	ebx, DWORD PTR 200[rsp]
++		xor	DWORD PTR 200[rsp], FXTEST_BITS
++		fxrstor	[rsp]
+ 
+ /* Return the FXSAVE buffer to its original state, then overwrite it with
+  * the state just restored.
+  */
+-		mov	DWORD PTR 200[esp], ebx
+-		fxsave	[esp]
++		mov	DWORD PTR 200[rsp], ebx
++		fxsave	[rsp]
+ 
+ /* Explicitly restore the original FPU state, while noting (in EBX) the
+  * state of those SSE control flags, as retrieved from the FPU itself,
+  * after the attempt to change them.
+  */
+-		xchg	DWORD PTR 200[esp], ebx
+-		fxrstor	[esp]
++		xchg	DWORD PTR 200[rsp], ebx
++		fxrstor	[rsp]
+ 
+ /* Check if the operating system actually allowed the requested change of
+  * the SSE control flags, then discard the local stack frame.
+  */
+-		xor	ebx, DWORD PTR 200[esp]
++		xor	ebx, DWORD PTR 200[rsp]
+ 		leave
+ 
+-.cfi_restore		ebp
+-.cfi_def_cfa		esp, 8
++.cfi_restore		rbp
++.cfi_def_cfa		rsp, CFI_OFFSET_BASE(2)
+ 
+ 		cmp	ebx, FXTEST_BITS	/* SSE flags were changed?   */
+ 		jne	20f			/* no: skip SSE detection    */
+ 
+ /* If we're still here, then the operating system should support SSE;
+@@ -268,14 +299,14 @@ 30:		chk	CPUID_CAP(3DNOWP)
+  */
+ 		or	DWORD PTR ___cpu_features, eax
+ 
+ /* ...we restore the preserved state of the EBX register...
+  */
+-80:		pop	ebx
++80:		pop	rbx
+ 
+-.cfi_restore		ebx
+-.cfi_def_cfa_offset	4
++.cfi_restore		rbx
++.cfi_def_cfa_offset	CFI_OFFSET_BASE(1)
+ 
+ /* ...and return to the C runtime initialization procedure.
+  */
+ 90:		ret
+ 

diff -r bd9c2d0cd8e6 -r 0e5d279d52ab series
--- a/series	Tue Apr 02 22:55:20 2019 +0100
+++ b/series	Tue Apr 02 23:00:03 2019 +0100
@@ -1,3 +1,5 @@
+win64-time-typedef.patch #+win64
+cpu-features-x86-64.patch #+win64
 alloca-testing.patch #+void #-void
 winerror-winsock2-update.patch #+void #-void
 winnls-self-contained.patch #+self-contained

diff -r bd9c2d0cd8e6 -r 0e5d279d52ab win64-time-typedef.patch
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/win64-time-typedef.patch	Tue Apr 02 23:00:03 2019 +0100
@@ -0,0 +1,85 @@
+# HG changeset patch
+# Parent 14380a28681bc457a304fdab734113a16a40a0ba
+Correct time_t definition for Win64.
+
+* include/sys/types.h [_WIN64] (time_t): Map it to __time64_t.
+[_WIN64 && _USE_32BIT_TIME_T]: Emit misuse warning.
+
+diff --git a/mingwrt/include/sys/types.h b/mingwrt/include/sys/types.h
+--- a/mingwrt/include/sys/types.h
++++ b/mingwrt/include/sys/types.h
+@@ -5,11 +5,11 @@
+  *
+  * $Id$
+  *
+  * Written by Colin Peters <[e-mail]>
+  * Copyright (C) 1997-1999, 2001, 2003, 2004, 2008, 2011, 2014-2016,
+- *   MinGW.org Project.
++ *   2018, MinGW.org Project.
+  *
+  *
+  * Permission is hereby granted, free of charge, to any person obtaining a
+  * copy of this software and associated documentation files (the "Software"),
+  * to deal in the Software without restriction, including without limitation
+@@ -131,27 +131,52 @@
+ #endif
+ #undef __need_ssize_t
+ 
+ #if ! defined __have_typedef_time_t \
+  && ( defined _SYS_TYPES_H || defined __need_time_t )
+- /* Current versions of MSVC define time_t ambiguously, in terms of
+-  * one of the following unambiguous internal types:
++ /* FIXME: Is the following correct for linking with UCRTBASE.DLL?
++  *
++  * Current versions of MSVC define time_t, (ambiguously in 32-bit
++  * versions), in terms of one or other of the following unambiguous
++  * internal types:
+   */
+   typedef __int32 __time32_t;	/* unambiguous 32-bit time_t */
+   typedef __int64 __time64_t;	/* unambiguous 64-bit time_t */
+ 
+-# if __MSVCRT_VERSION__ < __MSVCR80_DLL || defined _USE_32BIT_TIME_T
+-  /* From MSVCR80.DLL onwards, Microsoft have royally messed up the
+-   * definition of time_t; maintain POSIX consistency, (as MSVCRT.DLL
+-   * itself does), unless the user is explicitly using one of these
+-   * brain damaged DLL variants, and has not elected to retain the
+-   * 32-bit time_t representation.
++# if defined _WIN64
++  /* According to MSDN, there is no ambiguity on the Win64 platform;
++   * time_t is always represented as a 64-bit data type...
++   */
++   typedef __time64_t time_t;
++
++#  ifdef _USE_32BIT_TIME_T
++   /* ...and this feature test, which MSDN documents as necessary
++    * to retain legacy 32-bit time_t on Win32, is unsupported...
++    */
++#   warning "_WIN64 does not support the _USE_32BIT_TIME_T feature."
++#   undef _USE_32BIT_TIME_T
++#  endif
++  /* ...whereas, on the 32-bit platform, time_t may be represented as
++   * either a 32-bit or a 64-bit data type.  According to current MSDN
++   * documentation, this ambiguity is resolved by the _USE_32BIT_TIME_T
++   * feature test macro; if defined, time_t is represented as a 32-bit
++   * data type, otherwise it becomes 64-bit.  However, this is untrue
++   * for MSVCRT.DLL, and for any non-free legacy MSVCRxx.DLL which
++   * predates MSVCR80.DLL; thus...
++   */
++# elif defined _USE_32BIT_TIME_T || __MSVCRT_VERSION__ < __MSVCR80_DLL
++  /* ...we resolve the ambiguity in favour of 32-bit time_t for all
++   * applications which specify _USE_32_BIT_TIME_T, and for all which
++   * fail to specify a linking preference for a non-free MSVCRxx.DLL
++   * from MSVCR80.DLL onwards...
+    */
+    typedef __time32_t time_t;
+ 
+ # else
+-  /* Microsoft's brain damaged default, from MSVCR80.DLL onwards.
++  /* ...we adopt the 64-bit default, which is applicable when linking
++   * with non-free MSVCRxx.DLL from MSVCR80.DLL onwards, provided that
++   * the _USE_32BIT_TIME_T feature has not been selected.
+    */
+    typedef __time64_t time_t;
+ # endif
+ # if __GCC__ < 4
+   /* Assume any compiler which is not GCC-4.x or newer may require