Commit cd58b400110586bb0d0632dce0f667efbc3dbd88 | zig

author	Andrew Kelley <andrew@ziglang.org> 2017-09-30 18:20:12-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2017-09-30 18:20:55-04:00
log	cd58b400110586bb0d0632dce0f667efbc3dbd88
tree	fa0b6571c6c8fbfb8337e1fce54e63fad93f25b3
parent	ba3d21ca67af0ce47841bc2d0258903ccaf89a75

update C headers to clang 5.0.0

37 files changed, 5707 insertions(+), 1837 deletions(-)

CMakeLists.txt+3

 @@ -410,10 +410,12 @@ install(FILES "${CMAKE_SOURCE_DIR}/c_headers/avx512vlbwintrin.h" DESTINATION "${
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/avx512vlcdintrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/avx512vldqintrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/avx512vlintrin.h" DESTINATION "${C_HEADERS_DEST}")
+install(FILES "${CMAKE_SOURCE_DIR}/c_headers/avx512vpopcntdqintrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/avxintrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/bmi2intrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/bmiintrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/clflushoptintrin.h" DESTINATION "${C_HEADERS_DEST}")
+install(FILES "${CMAKE_SOURCE_DIR}/c_headers/clzerointrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/cpuid.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/cuda_wrappers/algorithm" DESTINATION "${C_HEADERS_DEST}/cuda_wrappers")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/cuda_wrappers/complex" DESTINATION "${C_HEADERS_DEST}/cuda_wrappers")
 @@ -432,6 +434,7 @@ install(FILES "${CMAKE_SOURCE_DIR}/c_headers/intrin.h" DESTINATION "${C_HEADERS_
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/inttypes.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/iso646.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/limits.h" DESTINATION "${C_HEADERS_DEST}")
+install(FILES "${CMAKE_SOURCE_DIR}/c_headers/lwpintrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/lzcntintrin.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/mm3dnow.h" DESTINATION "${C_HEADERS_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/c_headers/mm_malloc.h" DESTINATION "${C_HEADERS_DEST}")

c_headers/altivec.h+79-76

...	@@ -2887,87 +2887,79 @@ static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,	...	@@ -2887,87 +2887,79 @@ static __inline__ vector double __ATTRS_o_ai vec_cpsgn(vector double __a,
2887		2887
2888	/* vec_ctf */	2888	/* vec_ctf */
2889		2889
2890	static __inline__ vector float __ATTRS_o_ai vec_ctf(vector int __a, int __b) {
2891	return __builtin_altivec_vcfsx(__a, __b);
2892	}
2893
2894	static __inline__ vector float __ATTRS_o_ai vec_ctf(vector unsigned int __a,
2895	int __b) {
2896	return __builtin_altivec_vcfux((vector int)__a, __b);
2897	}
2898
2899	#ifdef __VSX__	2890	#ifdef __VSX__
2900	static __inline__ vector double __ATTRS_o_ai	2891	#define vec_ctf(__a, __b) \
2901	vec_ctf(vector unsigned long long __a, int __b) {	2892	_Generic((__a), vector int \
2902	vector double __ret = __builtin_convertvector(__a, vector double);	2893	: (vector float)__builtin_altivec_vcfsx((__a), (__b)), \
2903	__ret *= (vector double)(vector unsigned long long)((0x3ffULL - __b) << 52);	2894	vector unsigned int \
2904	return __ret;	2895	: (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)), \
2905	}	2896	vector unsigned long long \
2906		2897	: (__builtin_convertvector((vector unsigned long long)(__a), \
2907	static __inline__ vector double __ATTRS_o_ai	2898	vector double) * \
2908	vec_ctf(vector signed long long __a, int __b) {	2899	(vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
2909	vector double __ret = __builtin_convertvector(__a, vector double);	2900	<< 52)), \
2910	__ret *= (vector double)(vector unsigned long long)((0x3ffULL - __b) << 52);	2901	vector signed long long \
2911	return __ret;	2902	: (__builtin_convertvector((vector signed long long)(__a), \
2912	}	2903	vector double) * \
		2904	(vector double)(vector unsigned long long)((0x3ffULL - (__b)) \
		2905	<< 52)))
		2906	#else
		2907	#define vec_ctf(__a, __b) \
		2908	_Generic((__a), vector int \
		2909	: (vector float)__builtin_altivec_vcfsx((__a), (__b)), \
		2910	vector unsigned int \
		2911	: (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)))
2913	#endif	2912	#endif
2914		2913
2915	/* vec_vcfsx */	2914	/* vec_vcfsx */
2916		2915
2917	static __inline__ vector float __attribute__((__always_inline__))	2916	#define vec_vcfux __builtin_altivec_vcfux
2918	vec_vcfsx(vector int __a, int __b) {
2919	return __builtin_altivec_vcfsx(__a, __b);
2920	}
2921		2917
2922	/* vec_vcfux */	2918	/* vec_vcfux */
2923		2919
2924	static __inline__ vector float __attribute__((__always_inline__))	2920	#define vec_vcfsx(__a, __b) __builtin_altivec_vcfsx((vector int)(__a), (__b))
2925	vec_vcfux(vector unsigned int __a, int __b) {
2926	return __builtin_altivec_vcfux((vector int)__a, __b);
2927	}
2928		2921
2929	/* vec_cts */	2922	/* vec_cts */
2930		2923
2931	static __inline__ vector int __ATTRS_o_ai vec_cts(vector float __a, int __b) {
2932	return __builtin_altivec_vctsxs(__a, __b);
2933	}
2934
2935	#ifdef __VSX__	2924	#ifdef __VSX__
2936	static __inline__ vector signed long long __ATTRS_o_ai	2925	#define vec_cts(__a, __b) \
2937	vec_cts(vector double __a, int __b) {	2926	_Generic((__a), vector float \
2938	__a *= (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52);	2927	: __builtin_altivec_vctsxs((__a), (__b)), vector double \
2939	return __builtin_convertvector(__a, vector signed long long);	2928	: __extension__({ \
2940	}	2929	vector double __ret = \
		2930	(__a) * \
		2931	(vector double)(vector unsigned long long)((0x3ffULL + (__b)) \
		2932	<< 52); \
		2933	__builtin_convertvector(__ret, vector signed long long); \
		2934	}))
		2935	#else
		2936	#define vec_cts __builtin_altivec_vctsxs
2941	#endif	2937	#endif
2942		2938
2943	/* vec_vctsxs */	2939	/* vec_vctsxs */
2944		2940
2945	static __inline__ vector int __attribute__((__always_inline__))	2941	#define vec_vctsxs __builtin_altivec_vctsxs
2946	vec_vctsxs(vector float __a, int __b) {
2947	return __builtin_altivec_vctsxs(__a, __b);
2948	}
2949		2942
2950	/* vec_ctu */	2943	/* vec_ctu */
2951		2944
2952	static __inline__ vector unsigned int __ATTRS_o_ai vec_ctu(vector float __a,
2953	int __b) {
2954	return __builtin_altivec_vctuxs(__a, __b);
2955	}
2956
2957	#ifdef __VSX__	2945	#ifdef __VSX__
2958	static __inline__ vector unsigned long long __ATTRS_o_ai	2946	#define vec_ctu(__a, __b) \
2959	vec_ctu(vector double __a, int __b) {	2947	_Generic((__a), vector float \
2960	__a *= (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52);	2948	: __builtin_altivec_vctuxs((__a), (__b)), vector double \
2961	return __builtin_convertvector(__a, vector unsigned long long);	2949	: __extension__({ \
2962	}	2950	vector double __ret = \
		2951	(__a) * \
		2952	(vector double)(vector unsigned long long)((0x3ffULL + __b) \
		2953	<< 52); \
		2954	__builtin_convertvector(__ret, vector unsigned long long); \
		2955	}))
		2956	#else
		2957	#define vec_ctu __builtin_altivec_vctuxs
2963	#endif	2958	#endif
2964		2959
2965	/* vec_vctuxs */	2960	/* vec_vctuxs */
2966		2961
2967	static __inline__ vector unsigned int __attribute__((__always_inline__))	2962	#define vec_vctuxs __builtin_altivec_vctuxs
2968	vec_vctuxs(vector float __a, int __b) {
2969	return __builtin_altivec_vctuxs(__a, __b);
2970	}
2971		2963
2972	/* vec_signed */	2964	/* vec_signed */
2973		2965
...	@@ -8045,45 +8037,51 @@ static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,	...	@@ -8045,45 +8037,51 @@ static __inline__ vector float __ATTRS_o_ai vec_vsel(vector float __a,
8045		8037
8046	/* vec_sl */	8038	/* vec_sl */
8047		8039
8048	static __inline__ vector signed char __ATTRS_o_ai	8040	// vec_sl does modulo arithmetic on __b first, so __b is allowed to be more
8049	vec_sl(vector signed char __a, vector unsigned char __b) {	8041	// than the length of __a.
8050	return __a << (vector signed char)__b;
8051	}
8052
8053	static __inline__ vector unsigned char __ATTRS_o_ai	8042	static __inline__ vector unsigned char __ATTRS_o_ai
8054	vec_sl(vector unsigned char __a, vector unsigned char __b) {	8043	vec_sl(vector unsigned char __a, vector unsigned char __b) {
8055	return __a << __b;	8044	return __a << (__b %
		8045	(vector unsigned char)(sizeof(unsigned char) * __CHAR_BIT__));
8056	}	8046	}
8057		8047
8058	static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,	8048	static __inline__ vector signed char __ATTRS_o_ai
8059	vector unsigned short __b) {	8049	vec_sl(vector signed char __a, vector unsigned char __b) {
8060	return __a << (vector short)__b;	8050	return (vector signed char)vec_sl((vector unsigned char)__a, __b);
8061	}	8051	}
8062		8052
8063	static __inline__ vector unsigned short __ATTRS_o_ai	8053	static __inline__ vector unsigned short __ATTRS_o_ai
8064	vec_sl(vector unsigned short __a, vector unsigned short __b) {	8054	vec_sl(vector unsigned short __a, vector unsigned short __b) {
8065	return __a << __b;	8055	return __a << (__b % (vector unsigned short)(sizeof(unsigned short) *
		8056	__CHAR_BIT__));
8066	}	8057	}
8067		8058
8068	static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,	8059	static __inline__ vector short __ATTRS_o_ai vec_sl(vector short __a,
8069	vector unsigned int __b) {	8060	vector unsigned short __b) {
8070	return __a << (vector int)__b;	8061	return (vector short)vec_sl((vector unsigned short)__a, __b);
8071	}	8062	}
8072		8063
8073	static __inline__ vector unsigned int __ATTRS_o_ai	8064	static __inline__ vector unsigned int __ATTRS_o_ai
8074	vec_sl(vector unsigned int __a, vector unsigned int __b) {	8065	vec_sl(vector unsigned int __a, vector unsigned int __b) {
8075	return __a << __b;	8066	return __a << (__b %
		8067	(vector unsigned int)(sizeof(unsigned int) * __CHAR_BIT__));
8076	}	8068	}
8077		8069
8078	#ifdef __POWER8_VECTOR__	8070	static __inline__ vector int __ATTRS_o_ai vec_sl(vector int __a,
8079	static __inline__ vector signed long long __ATTRS_o_ai	8071	vector unsigned int __b) {
8080	vec_sl(vector signed long long __a, vector unsigned long long __b) {	8072	return (vector int)vec_sl((vector unsigned int)__a, __b);
8081	return __a << (vector long long)__b;
8082	}	8073	}
8083		8074
		8075	#ifdef __POWER8_VECTOR__
8084	static __inline__ vector unsigned long long __ATTRS_o_ai	8076	static __inline__ vector unsigned long long __ATTRS_o_ai
8085	vec_sl(vector unsigned long long __a, vector unsigned long long __b) {	8077	vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
8086	return __a << __b;	8078	return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
		8079	__CHAR_BIT__));
		8080	}
		8081
		8082	static __inline__ vector long long __ATTRS_o_ai
		8083	vec_sl(vector long long __a, vector unsigned long long __b) {
		8084	return (vector long long)vec_sl((vector unsigned long long)__a, __b);
8087	}	8085	}
8088	#endif	8086	#endif
8089		8087
...	@@ -12150,6 +12148,11 @@ static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,	...	@@ -12150,6 +12148,11 @@ static __inline__ void __ATTRS_o_ai vec_vsx_st(vector unsigned char __a,
12150		12148
12151	#endif	12149	#endif
12152		12150
		12151	#ifdef __VSX__
		12152	#define vec_xxpermdi __builtin_vsx_xxpermdi
		12153	#define vec_xxsldwi __builtin_vsx_xxsldwi
		12154	#endif
		12155
12153	/* vec_xor */	12156	/* vec_xor */
12154		12157
12155	#define __builtin_altivec_vxor vec_xor	12158	#define __builtin_altivec_vxor vec_xor

c_headers/arm_acle.h+316-2

...	@@ -224,6 +224,36 @@ __rbitl(unsigned long __t) {	...	@@ -224,6 +224,36 @@ __rbitl(unsigned long __t) {
224	#endif	224	#endif
225	}	225	}
226		226
		227	/*
		228	* 9.3 16-bit multiplications
		229	*/
		230	#if __ARM_FEATURE_DSP
		231	static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
		232	__smulbb(int32_t __a, int32_t __b) {
		233	return __builtin_arm_smulbb(__a, __b);
		234	}
		235	static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
		236	__smulbt(int32_t __a, int32_t __b) {
		237	return __builtin_arm_smulbt(__a, __b);
		238	}
		239	static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
		240	__smultb(int32_t __a, int32_t __b) {
		241	return __builtin_arm_smultb(__a, __b);
		242	}
		243	static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
		244	__smultt(int32_t __a, int32_t __b) {
		245	return __builtin_arm_smultt(__a, __b);
		246	}
		247	static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
		248	__smulwb(int32_t __a, int32_t __b) {
		249	return __builtin_arm_smulwb(__a, __b);
		250	}
		251	static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
		252	__smulwt(int32_t __a, int32_t __b) {
		253	return __builtin_arm_smulwt(__a, __b);
		254	}
		255	#endif
		256
227	/*	257	/*
228	* 9.4 Saturating intrinsics	258	* 9.4 Saturating intrinsics
229	*	259	*
...	@@ -231,13 +261,13 @@ __rbitl(unsigned long __t) {	...	@@ -231,13 +261,13 @@ __rbitl(unsigned long __t) {
231	* intrinsics are implemented and the flag is enabled.	261	* intrinsics are implemented and the flag is enabled.
232	*/	262	*/
233	/* 9.4.1 Width-specified saturation intrinsics */	263	/* 9.4.1 Width-specified saturation intrinsics */
234	#if __ARM_32BIT_STATE	264	#if __ARM_FEATURE_SAT
235	#define __ssat(x, y) __builtin_arm_ssat(x, y)	265	#define __ssat(x, y) __builtin_arm_ssat(x, y)
236	#define __usat(x, y) __builtin_arm_usat(x, y)	266	#define __usat(x, y) __builtin_arm_usat(x, y)
237	#endif	267	#endif
238		268
239	/* 9.4.2 Saturating addition and subtraction intrinsics */	269	/* 9.4.2 Saturating addition and subtraction intrinsics */
240	#if __ARM_32BIT_STATE	270	#if __ARM_FEATURE_DSP
241	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))	271	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
242	__qadd(int32_t __t, int32_t __v) {	272	__qadd(int32_t __t, int32_t __v) {
243	return __builtin_arm_qadd(__t, __v);	273	return __builtin_arm_qadd(__t, __v);
...	@@ -254,6 +284,290 @@ __qdbl(int32_t __t) {	...	@@ -254,6 +284,290 @@ __qdbl(int32_t __t) {
254	}	284	}
255	#endif	285	#endif
256		286
		287	/* 9.4.3 Accumultating multiplications */
		288	#if __ARM_FEATURE_DSP
		289	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		290	__smlabb(int32_t __a, int32_t __b, int32_t __c) {
		291	return __builtin_arm_smlabb(__a, __b, __c);
		292	}
		293	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		294	__smlabt(int32_t __a, int32_t __b, int32_t __c) {
		295	return __builtin_arm_smlabt(__a, __b, __c);
		296	}
		297	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		298	__smlatb(int32_t __a, int32_t __b, int32_t __c) {
		299	return __builtin_arm_smlatb(__a, __b, __c);
		300	}
		301	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		302	__smlatt(int32_t __a, int32_t __b, int32_t __c) {
		303	return __builtin_arm_smlatt(__a, __b, __c);
		304	}
		305	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		306	__smlawb(int32_t __a, int32_t __b, int32_t __c) {
		307	return __builtin_arm_smlawb(__a, __b, __c);
		308	}
		309	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		310	__smlawt(int32_t __a, int32_t __b, int32_t __c) {
		311	return __builtin_arm_smlawt(__a, __b, __c);
		312	}
		313	#endif
		314
		315
		316	/* 9.5.4 Parallel 16-bit saturation */
		317	#if __ARM_FEATURE_SIMD32
		318	#define __ssat16(x, y) __builtin_arm_ssat16(x, y)
		319	#define __usat16(x, y) __builtin_arm_usat16(x, y)
		320	#endif
		321
		322	/* 9.5.5 Packing and unpacking */
		323	#if __ARM_FEATURE_SIMD32
		324	typedef int32_t int8x4_t;
		325	typedef int32_t int16x2_t;
		326	typedef uint32_t uint8x4_t;
		327	typedef uint32_t uint16x2_t;
		328
		329	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		330	__sxtab16(int16x2_t __a, int8x4_t __b) {
		331	return __builtin_arm_sxtab16(__a, __b);
		332	}
		333	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		334	__sxtb16(int8x4_t __a) {
		335	return __builtin_arm_sxtb16(__a);
		336	}
		337	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		338	__uxtab16(int16x2_t __a, int8x4_t __b) {
		339	return __builtin_arm_uxtab16(__a, __b);
		340	}
		341	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		342	__uxtb16(int8x4_t __a) {
		343	return __builtin_arm_uxtb16(__a);
		344	}
		345	#endif
		346
		347	/* 9.5.6 Parallel selection */
		348	#if __ARM_FEATURE_SIMD32
		349	static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
		350	__sel(uint8x4_t __a, uint8x4_t __b) {
		351	return __builtin_arm_sel(__a, __b);
		352	}
		353	#endif
		354
		355	/* 9.5.7 Parallel 8-bit addition and subtraction */
		356	#if __ARM_FEATURE_SIMD32
		357	static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
		358	__qadd8(int8x4_t __a, int8x4_t __b) {
		359	return __builtin_arm_qadd8(__a, __b);
		360	}
		361	static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
		362	__qsub8(int8x4_t __a, int8x4_t __b) {
		363	return __builtin_arm_qsub8(__a, __b);
		364	}
		365	static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
		366	__sadd8(int8x4_t __a, int8x4_t __b) {
		367	return __builtin_arm_sadd8(__a, __b);
		368	}
		369	static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
		370	__shadd8(int8x4_t __a, int8x4_t __b) {
		371	return __builtin_arm_shadd8(__a, __b);
		372	}
		373	static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
		374	__shsub8(int8x4_t __a, int8x4_t __b) {
		375	return __builtin_arm_shsub8(__a, __b);
		376	}
		377	static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
		378	__ssub8(int8x4_t __a, int8x4_t __b) {
		379	return __builtin_arm_ssub8(__a, __b);
		380	}
		381	static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
		382	__uadd8(uint8x4_t __a, uint8x4_t __b) {
		383	return __builtin_arm_uadd8(__a, __b);
		384	}
		385	static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
		386	__uhadd8(uint8x4_t __a, uint8x4_t __b) {
		387	return __builtin_arm_uhadd8(__a, __b);
		388	}
		389	static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
		390	__uhsub8(uint8x4_t __a, uint8x4_t __b) {
		391	return __builtin_arm_uhsub8(__a, __b);
		392	}
		393	static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
		394	__uqadd8(uint8x4_t __a, uint8x4_t __b) {
		395	return __builtin_arm_uqadd8(__a, __b);
		396	}
		397	static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
		398	__uqsub8(uint8x4_t __a, uint8x4_t __b) {
		399	return __builtin_arm_uqsub8(__a, __b);
		400	}
		401	static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
		402	__usub8(uint8x4_t __a, uint8x4_t __b) {
		403	return __builtin_arm_usub8(__a, __b);
		404	}
		405	#endif
		406
		407	/* 9.5.8 Sum of 8-bit absolute differences */
		408	#if __ARM_FEATURE_SIMD32
		409	static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
		410	__usad8(uint8x4_t __a, uint8x4_t __b) {
		411	return __builtin_arm_usad8(__a, __b);
		412	}
		413	static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
		414	__usada8(uint8x4_t __a, uint8x4_t __b, uint32_t __c) {
		415	return __builtin_arm_usada8(__a, __b, __c);
		416	}
		417	#endif
		418
		419	/* 9.5.9 Parallel 16-bit addition and subtraction */
		420	#if __ARM_FEATURE_SIMD32
		421	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		422	__qadd16(int16x2_t __a, int16x2_t __b) {
		423	return __builtin_arm_qadd16(__a, __b);
		424	}
		425	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		426	__qasx(int16x2_t __a, int16x2_t __b) {
		427	return __builtin_arm_qasx(__a, __b);
		428	}
		429	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		430	__qsax(int16x2_t __a, int16x2_t __b) {
		431	return __builtin_arm_qsax(__a, __b);
		432	}
		433	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		434	__qsub16(int16x2_t __a, int16x2_t __b) {
		435	return __builtin_arm_qsub16(__a, __b);
		436	}
		437	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		438	__sadd16(int16x2_t __a, int16x2_t __b) {
		439	return __builtin_arm_sadd16(__a, __b);
		440	}
		441	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		442	__sasx(int16x2_t __a, int16x2_t __b) {
		443	return __builtin_arm_sasx(__a, __b);
		444	}
		445	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		446	__shadd16(int16x2_t __a, int16x2_t __b) {
		447	return __builtin_arm_shadd16(__a, __b);
		448	}
		449	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		450	__shasx(int16x2_t __a, int16x2_t __b) {
		451	return __builtin_arm_shasx(__a, __b);
		452	}
		453	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		454	__shsax(int16x2_t __a, int16x2_t __b) {
		455	return __builtin_arm_shsax(__a, __b);
		456	}
		457	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		458	__shsub16(int16x2_t __a, int16x2_t __b) {
		459	return __builtin_arm_shsub16(__a, __b);
		460	}
		461	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		462	__ssax(int16x2_t __a, int16x2_t __b) {
		463	return __builtin_arm_ssax(__a, __b);
		464	}
		465	static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
		466	__ssub16(int16x2_t __a, int16x2_t __b) {
		467	return __builtin_arm_ssub16(__a, __b);
		468	}
		469	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		470	__uadd16(uint16x2_t __a, uint16x2_t __b) {
		471	return __builtin_arm_uadd16(__a, __b);
		472	}
		473	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		474	__uasx(uint16x2_t __a, uint16x2_t __b) {
		475	return __builtin_arm_uasx(__a, __b);
		476	}
		477	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		478	__uhadd16(uint16x2_t __a, uint16x2_t __b) {
		479	return __builtin_arm_uhadd16(__a, __b);
		480	}
		481	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		482	__uhasx(uint16x2_t __a, uint16x2_t __b) {
		483	return __builtin_arm_uhasx(__a, __b);
		484	}
		485	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		486	__uhsax(uint16x2_t __a, uint16x2_t __b) {
		487	return __builtin_arm_uhsax(__a, __b);
		488	}
		489	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		490	__uhsub16(uint16x2_t __a, uint16x2_t __b) {
		491	return __builtin_arm_uhsub16(__a, __b);
		492	}
		493	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		494	__uqadd16(uint16x2_t __a, uint16x2_t __b) {
		495	return __builtin_arm_uqadd16(__a, __b);
		496	}
		497	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		498	__uqasx(uint16x2_t __a, uint16x2_t __b) {
		499	return __builtin_arm_uqasx(__a, __b);
		500	}
		501	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		502	__uqsax(uint16x2_t __a, uint16x2_t __b) {
		503	return __builtin_arm_uqsax(__a, __b);
		504	}
		505	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		506	__uqsub16(uint16x2_t __a, uint16x2_t __b) {
		507	return __builtin_arm_uqsub16(__a, __b);
		508	}
		509	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		510	__usax(uint16x2_t __a, uint16x2_t __b) {
		511	return __builtin_arm_usax(__a, __b);
		512	}
		513	static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
		514	__usub16(uint16x2_t __a, uint16x2_t __b) {
		515	return __builtin_arm_usub16(__a, __b);
		516	}
		517	#endif
		518
		519	/* 9.5.10 Parallel 16-bit multiplications */
		520	#if __ARM_FEATURE_SIMD32
		521	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		522	__smlad(int16x2_t __a, int16x2_t __b, int32_t __c) {
		523	return __builtin_arm_smlad(__a, __b, __c);
		524	}
		525	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		526	__smladx(int16x2_t __a, int16x2_t __b, int32_t __c) {
		527	return __builtin_arm_smladx(__a, __b, __c);
		528	}
		529	static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
		530	__smlald(int16x2_t __a, int16x2_t __b, int64_t __c) {
		531	return __builtin_arm_smlald(__a, __b, __c);
		532	}
		533	static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
		534	__smlaldx(int16x2_t __a, int16x2_t __b, int64_t __c) {
		535	return __builtin_arm_smlaldx(__a, __b, __c);
		536	}
		537	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		538	__smlsd(int16x2_t __a, int16x2_t __b, int32_t __c) {
		539	return __builtin_arm_smlsd(__a, __b, __c);
		540	}
		541	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		542	__smlsdx(int16x2_t __a, int16x2_t __b, int32_t __c) {
		543	return __builtin_arm_smlsdx(__a, __b, __c);
		544	}
		545	static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
		546	__smlsld(int16x2_t __a, int16x2_t __b, int64_t __c) {
		547	return __builtin_arm_smlsld(__a, __b, __c);
		548	}
		549	static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
		550	__smlsldx(int16x2_t __a, int16x2_t __b, int64_t __c) {
		551	return __builtin_arm_smlsldx(__a, __b, __c);
		552	}
		553	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		554	__smuad(int16x2_t __a, int16x2_t __b) {
		555	return __builtin_arm_smuad(__a, __b);
		556	}
		557	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		558	__smuadx(int16x2_t __a, int16x2_t __b) {
		559	return __builtin_arm_smuadx(__a, __b);
		560	}
		561	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		562	__smusd(int16x2_t __a, int16x2_t __b) {
		563	return __builtin_arm_smusd(__a, __b);
		564	}
		565	static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
		566	__smusdx(int16x2_t __a, int16x2_t __b) {
		567	return __builtin_arm_smusdx(__a, __b);
		568	}
		569	#endif
		570
257	/* 9.7 CRC32 intrinsics */	571	/* 9.7 CRC32 intrinsics */
258	#if __ARM_FEATURE_CRC32	572	#if __ARM_FEATURE_CRC32
259	static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))	573	static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))

c_headers/avx2intrin.h+2-1

...	@@ -832,7 +832,8 @@ _mm256_xor_si256(__m256i __a, __m256i __b)	...	@@ -832,7 +832,8 @@ _mm256_xor_si256(__m256i __a, __m256i __b)
832	static __inline__ __m256i __DEFAULT_FN_ATTRS	832	static __inline__ __m256i __DEFAULT_FN_ATTRS
833	_mm256_stream_load_si256(__m256i const *__V)	833	_mm256_stream_load_si256(__m256i const *__V)
834	{	834	{
835	return (__m256i)__builtin_ia32_movntdqa256((const __v4di *)__V);	835	typedef __v4di __v4di_aligned __attribute__((aligned(32)));
		836	return (__m256i)__builtin_nontemporal_load((const __v4di_aligned *)__V);
836	}	837	}
837		838
838	static __inline__ __m128 __DEFAULT_FN_ATTRS	839	static __inline__ __m128 __DEFAULT_FN_ATTRS

c_headers/avx512bwintrin.h+40-64

 @@ -504,115 +504,91 @@ _mm512_maskz_abs_epi16 (__mmask32 __U, __m512i __A)
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_packs_epi32 (__m512i __A, __m512i __B)
+_mm512_packs_epi32(__m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A,
+  return (__m512i)__builtin_ia32_packssdw512((__v16si)__A, (__v16si)__B);
-              (__v16si) __B,
-              (__v32hi) _mm512_setzero_hi(),
-              (__mmask32) -1);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_maskz_packs_epi32 (__mmask32 __M, __m512i __A, __m512i __B)
+_mm512_maskz_packs_epi32(__mmask32 __M, __m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A,
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
-              (__v16si) __B,
+                                       (__v32hi)_mm512_packs_epi32(__A, __B),
-              (__v32hi) _mm512_setzero_hi(),
+                                       (__v32hi)_mm512_setzero_hi());
-              __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_mask_packs_epi32 (__m512i __W, __mmask32 __M, __m512i __A,
+_mm512_mask_packs_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B)
-       __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packssdw512_mask ((__v16si) __A,
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
-              (__v16si) __B,
+                                       (__v32hi)_mm512_packs_epi32(__A, __B),
-              (__v32hi) __W,
+                                       (__v32hi)__W);
-              __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_packs_epi16 (__m512i __A, __m512i __B)
+_mm512_packs_epi16(__m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packsswb512_mask ((__v32hi) __A,
+  return (__m512i)__builtin_ia32_packsswb512((__v32hi)__A, (__v32hi) __B);
-              (__v32hi) __B,
-              (__v64qi) _mm512_setzero_qi(),
-              (__mmask64) -1);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_mask_packs_epi16 (__m512i __W, __mmask64 __M, __m512i __A,
+_mm512_mask_packs_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
-       __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packsswb512_mask ((__v32hi) __A,
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
-              (__v32hi) __B,
+                                        (__v64qi)_mm512_packs_epi16(__A, __B),
-              (__v64qi) __W,
+                                        (__v64qi)__W);
-              (__mmask64) __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_maskz_packs_epi16 (__mmask64 __M, __m512i __A, __m512i __B)
+_mm512_maskz_packs_epi16(__mmask64 __M, __m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packsswb512_mask ((__v32hi) __A,
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
-              (__v32hi) __B,
+                                        (__v64qi)_mm512_packs_epi16(__A, __B),
-              (__v64qi) _mm512_setzero_qi(),
+                                        (__v64qi)_mm512_setzero_qi());
-              __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_packus_epi32 (__m512i __A, __m512i __B)
+_mm512_packus_epi32(__m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A,
+  return (__m512i)__builtin_ia32_packusdw512((__v16si) __A, (__v16si) __B);
-              (__v16si) __B,
-              (__v32hi) _mm512_setzero_hi(),
-              (__mmask32) -1);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_maskz_packus_epi32 (__mmask32 __M, __m512i __A, __m512i __B)
+_mm512_maskz_packus_epi32(__mmask32 __M, __m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A,
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
-              (__v16si) __B,
+                                       (__v32hi)_mm512_packus_epi32(__A, __B),
-              (__v32hi) _mm512_setzero_hi(),
+                                       (__v32hi)_mm512_setzero_hi());
-              __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_mask_packus_epi32 (__m512i __W, __mmask32 __M, __m512i __A,
+_mm512_mask_packus_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B)
-        __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packusdw512_mask ((__v16si) __A,
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
-              (__v16si) __B,
+                                       (__v32hi)_mm512_packus_epi32(__A, __B),
-              (__v32hi) __W,
+                                       (__v32hi)__W);
-              __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_packus_epi16 (__m512i __A, __m512i __B)
+_mm512_packus_epi16(__m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packuswb512_mask ((__v32hi) __A,
+  return (__m512i)__builtin_ia32_packuswb512((__v32hi) __A, (__v32hi) __B);
-              (__v32hi) __B,
-              (__v64qi) _mm512_setzero_qi(),
-              (__mmask64) -1);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_mask_packus_epi16 (__m512i __W, __mmask64 __M, __m512i __A,
+_mm512_mask_packus_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
-        __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packuswb512_mask ((__v32hi) __A,
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
-              (__v32hi) __B,
+                                        (__v64qi)_mm512_packus_epi16(__A, __B),
-              (__v64qi) __W,
+                                        (__v64qi)__W);
-              (__mmask64) __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_maskz_packus_epi16 (__mmask64 __M, __m512i __A, __m512i __B)
+_mm512_maskz_packus_epi16(__mmask64 __M, __m512i __A, __m512i __B)
 {
-  return (__m512i) __builtin_ia32_packuswb512_mask ((__v32hi) __A,
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
-              (__v32hi) __B,
+                                        (__v64qi)_mm512_packus_epi16(__A, __B),
-              (__v64qi) _mm512_setzero_qi(),
+                                        (__v64qi)_mm512_setzero_qi());
-              (__mmask64) __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS

c_headers/avx512dqintrin.h+46-49

...	@@ -995,51 +995,50 @@ _mm512_maskz_broadcast_f32x2 (__mmask16 __M, __m128 __A)	...	@@ -995,51 +995,50 @@ _mm512_maskz_broadcast_f32x2 (__mmask16 __M, __m128 __A)
995	}	995	}
996		996
997	static __inline__ __m512 __DEFAULT_FN_ATTRS	997	static __inline__ __m512 __DEFAULT_FN_ATTRS
998	_mm512_broadcast_f32x8 (__m256 __A)	998	_mm512_broadcast_f32x8(__m256 __A)
999	{	999	{
1000	return (__m512) __builtin_ia32_broadcastf32x8_512_mask ((__v8sf) __A,	1000	return (__m512)__builtin_shufflevector((__v8sf)__A, (__v8sf)__A,
1001	_mm512_undefined_ps(),	1001	0, 1, 2, 3, 4, 5, 6, 7,
1002	(__mmask16) -1);	1002	0, 1, 2, 3, 4, 5, 6, 7);
1003	}	1003	}
1004		1004
1005	static __inline__ __m512 __DEFAULT_FN_ATTRS	1005	static __inline__ __m512 __DEFAULT_FN_ATTRS
1006	_mm512_mask_broadcast_f32x8 (__m512 __O, __mmask16 __M, __m256 __A)	1006	_mm512_mask_broadcast_f32x8(__m512 __O, __mmask16 __M, __m256 __A)
1007	{	1007	{
1008	return (__m512) __builtin_ia32_broadcastf32x8_512_mask ((__v8sf) __A,	1008	return (__m512)__builtin_ia32_selectps_512((__mmask8)__M,
1009	(__v16sf)__O,	1009	(__v16sf)_mm512_broadcast_f32x8(__A),
1010	__M);	1010	(__v16sf)__O);
1011	}	1011	}
1012		1012
1013	static __inline__ __m512 __DEFAULT_FN_ATTRS	1013	static __inline__ __m512 __DEFAULT_FN_ATTRS
1014	_mm512_maskz_broadcast_f32x8 (__mmask16 __M, __m256 __A)	1014	_mm512_maskz_broadcast_f32x8(__mmask16 __M, __m256 __A)
1015	{	1015	{
1016	return (__m512) __builtin_ia32_broadcastf32x8_512_mask ((__v8sf) __A,	1016	return (__m512)__builtin_ia32_selectps_512((__mmask8)__M,
1017	(__v16sf)_mm512_setzero_ps (),	1017	(__v16sf)_mm512_broadcast_f32x8(__A),
1018	__M);	1018	(__v16sf)_mm512_setzero_ps());
1019	}	1019	}
1020		1020
1021	static __inline__ __m512d __DEFAULT_FN_ATTRS	1021	static __inline__ __m512d __DEFAULT_FN_ATTRS
1022	_mm512_broadcast_f64x2 (__m128d __A)	1022	_mm512_broadcast_f64x2(__m128d __A)
1023	{	1023	{
1024	return (__m512d) __builtin_ia32_broadcastf64x2_512_mask ((__v2df) __A,	1024	return (__m512d)__builtin_shufflevector((__v2df)__A, (__v2df)__A,
1025	(__v8df)_mm512_undefined_pd(),	1025	0, 1, 0, 1, 0, 1, 0, 1);
1026	(__mmask8) -1);
1027	}	1026	}
1028		1027
1029	static __inline__ __m512d __DEFAULT_FN_ATTRS	1028	static __inline__ __m512d __DEFAULT_FN_ATTRS
1030	_mm512_mask_broadcast_f64x2 (__m512d __O, __mmask8 __M, __m128d __A)	1029	_mm512_mask_broadcast_f64x2(__m512d __O, __mmask8 __M, __m128d __A)
1031	{	1030	{
1032	return (__m512d) __builtin_ia32_broadcastf64x2_512_mask ((__v2df) __A,	1031	return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
1033	(__v8df)	1032	(__v8df)_mm512_broadcast_f64x2(__A),
1034	__O, __M);	1033	(__v8df)__O);
1035	}	1034	}
1036		1035
1037	static __inline__ __m512d __DEFAULT_FN_ATTRS	1036	static __inline__ __m512d __DEFAULT_FN_ATTRS
1038	_mm512_maskz_broadcast_f64x2 (__mmask8 __M, __m128d __A)	1037	_mm512_maskz_broadcast_f64x2(__mmask8 __M, __m128d __A)
1039	{	1038	{
1040	return (__m512d) __builtin_ia32_broadcastf64x2_512_mask ((__v2df) __A,	1039	return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
1041	(__v8df)_mm512_setzero_ps (),	1040	(__v8df)_mm512_broadcast_f64x2(__A),
1042	__M);	1041	(__v8df)_mm512_setzero_pd());
1043	}	1042	}
1044		1043
1045	static __inline__ __m512i __DEFAULT_FN_ATTRS	1044	static __inline__ __m512i __DEFAULT_FN_ATTRS
...	@@ -1067,52 +1066,50 @@ _mm512_maskz_broadcast_i32x2 (__mmask16 __M, __m128i __A)	...	@@ -1067,52 +1066,50 @@ _mm512_maskz_broadcast_i32x2 (__mmask16 __M, __m128i __A)
1067	}	1066	}
1068		1067
1069	static __inline__ __m512i __DEFAULT_FN_ATTRS	1068	static __inline__ __m512i __DEFAULT_FN_ATTRS
1070	_mm512_broadcast_i32x8 (__m256i __A)	1069	_mm512_broadcast_i32x8(__m256i __A)
1071	{	1070	{
1072	return (__m512i) __builtin_ia32_broadcasti32x8_512_mask ((__v8si) __A,	1071	return (__m512i)__builtin_shufflevector((__v8si)__A, (__v8si)__A,
1073	(__v16si)_mm512_setzero_si512(),	1072	0, 1, 2, 3, 4, 5, 6, 7,
1074	(__mmask16) -1);	1073	0, 1, 2, 3, 4, 5, 6, 7);
1075	}	1074	}
1076		1075
1077	static __inline__ __m512i __DEFAULT_FN_ATTRS	1076	static __inline__ __m512i __DEFAULT_FN_ATTRS
1078	_mm512_mask_broadcast_i32x8 (__m512i __O, __mmask16 __M, __m256i __A)	1077	_mm512_mask_broadcast_i32x8(__m512i __O, __mmask16 __M, __m256i __A)
1079	{	1078	{
1080	return (__m512i) __builtin_ia32_broadcasti32x8_512_mask ((__v8si) __A,	1079	return (__m512i)__builtin_ia32_selectd_512((__mmask8)__M,
1081	(__v16si)__O,	1080	(__v16si)_mm512_broadcast_i32x8(__A),
1082	__M);	1081	(__v16si)__O);
1083	}	1082	}
1084		1083
1085	static __inline__ __m512i __DEFAULT_FN_ATTRS	1084	static __inline__ __m512i __DEFAULT_FN_ATTRS
1086	_mm512_maskz_broadcast_i32x8 (__mmask16 __M, __m256i __A)	1085	_mm512_maskz_broadcast_i32x8(__mmask16 __M, __m256i __A)
1087	{	1086	{
1088	return (__m512i) __builtin_ia32_broadcasti32x8_512_mask ((__v8si) __A,	1087	return (__m512i)__builtin_ia32_selectd_512((__mmask8)__M,
1089	(__v16si)	1088	(__v16si)_mm512_broadcast_i32x8(__A),
1090	_mm512_setzero_si512 (),	1089	(__v16si)_mm512_setzero_si512());
1091	__M);
1092	}	1090	}
1093		1091
1094	static __inline__ __m512i __DEFAULT_FN_ATTRS	1092	static __inline__ __m512i __DEFAULT_FN_ATTRS
1095	_mm512_broadcast_i64x2 (__m128i __A)	1093	_mm512_broadcast_i64x2(__m128i __A)
1096	{	1094	{
1097	return (__m512i) __builtin_ia32_broadcasti64x2_512_mask ((__v2di) __A,	1095	return (__m512i)__builtin_shufflevector((__v2di)__A, (__v2di)__A,
1098	(__v8di)_mm512_setzero_si512(),	1096	0, 1, 0, 1, 0, 1, 0, 1);
1099	(__mmask8) -1);
1100	}	1097	}
1101		1098
1102	static __inline__ __m512i __DEFAULT_FN_ATTRS	1099	static __inline__ __m512i __DEFAULT_FN_ATTRS
1103	_mm512_mask_broadcast_i64x2 (__m512i __O, __mmask8 __M, __m128i __A)	1100	_mm512_mask_broadcast_i64x2(__m512i __O, __mmask8 __M, __m128i __A)
1104	{	1101	{
1105	return (__m512i) __builtin_ia32_broadcasti64x2_512_mask ((__v2di) __A,	1102	return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
1106	(__v8di)	1103	(__v8di)_mm512_broadcast_i64x2(__A),
1107	__O, __M);	1104	(__v8di)__O);
1108	}	1105	}
1109		1106
1110	static __inline__ __m512i __DEFAULT_FN_ATTRS	1107	static __inline__ __m512i __DEFAULT_FN_ATTRS
1111	_mm512_maskz_broadcast_i64x2 (__mmask8 __M, __m128i __A)	1108	_mm512_maskz_broadcast_i64x2(__mmask8 __M, __m128i __A)
1112	{	1109	{
1113	return (__m512i) __builtin_ia32_broadcasti64x2_512_mask ((__v2di) __A,	1110	return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
1114	(__v8di)_mm512_setzero_si512 (),	1111	(__v8di)_mm512_broadcast_i64x2(__A),
1115	__M);	1112	(__v8di)_mm512_setzero_si512());
1116	}	1113	}
1117		1114
1118	#define _mm512_extractf32x8_ps(A, imm) __extension__ ({ \	1115	#define _mm512_extractf32x8_ps(A, imm) __extension__ ({ \

c_headers/avx512fintrin.h+264-105

 @@ -528,6 +528,116 @@ _mm512_mask2int(__mmask16 __a)
   return (int)__a;
 }
+/// \brief Constructs a 512-bit floating-point vector of [8 x double] from a
+///    128-bit floating-point vector of [2 x double]. The lower 128 bits
+///    contain the value of the source vector. The upper 384 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 512-bit floating-point vector of [8 x double]. The lower 128 bits
+///    contain the value of the parameter. The upper 384 bits are set to zero.
+static __inline __m512d __DEFAULT_FN_ATTRS
+_mm512_zextpd128_pd512(__m128d __a)
+{
+  return __builtin_shufflevector((__v2df)__a, (__v2df)_mm_setzero_pd(), 0, 1, 2, 3, 2, 3, 2, 3);
+}
+/// \brief Constructs a 512-bit floating-point vector of [8 x double] from a
+///    256-bit floating-point vector of [4 x double]. The lower 256 bits
+///    contain the value of the source vector. The upper 256 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 512-bit floating-point vector of [8 x double]. The lower 256 bits
+///    contain the value of the parameter. The upper 256 bits are set to zero.
+static __inline __m512d __DEFAULT_FN_ATTRS
+_mm512_zextpd256_pd512(__m256d __a)
+{
+  return __builtin_shufflevector((__v4df)__a, (__v4df)_mm256_setzero_pd(), 0, 1, 2, 3, 4, 5, 6, 7);
+}
+/// \brief Constructs a 512-bit floating-point vector of [16 x float] from a
+///    128-bit floating-point vector of [4 x float]. The lower 128 bits contain
+///    the value of the source vector. The upper 384 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 512-bit floating-point vector of [16 x float]. The lower 128 bits
+///    contain the value of the parameter. The upper 384 bits are set to zero.
+static __inline __m512 __DEFAULT_FN_ATTRS
+_mm512_zextps128_ps512(__m128 __a)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)_mm_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7);
+}
+/// \brief Constructs a 512-bit floating-point vector of [16 x float] from a
+///    256-bit floating-point vector of [8 x float]. The lower 256 bits contain
+///    the value of the source vector. The upper 256 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 512-bit floating-point vector of [16 x float]. The lower 256 bits
+///    contain the value of the parameter. The upper 256 bits are set to zero.
+static __inline __m512 __DEFAULT_FN_ATTRS
+_mm512_zextps256_ps512(__m256 __a)
+{
+  return __builtin_shufflevector((__v8sf)__a, (__v8sf)_mm256_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+/// \brief Constructs a 512-bit integer vector from a 128-bit integer vector.
+///    The lower 128 bits contain the value of the source vector. The upper
+///    384 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 512-bit integer vector. The lower 128 bits contain the value of
+///    the parameter. The upper 384 bits are set to zero.
+static __inline __m512i __DEFAULT_FN_ATTRS
+_mm512_zextsi128_si512(__m128i __a)
+{
+  return __builtin_shufflevector((__v2di)__a, (__v2di)_mm_setzero_si128(), 0, 1, 2, 3, 2, 3, 2, 3);
+}
+/// \brief Constructs a 512-bit integer vector from a 256-bit integer vector.
+///    The lower 256 bits contain the value of the source vector. The upper
+///    256 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \returns A 512-bit integer vector. The lower 256 bits contain the value of
+///    the parameter. The upper 256 bits are set to zero.
+static __inline __m512i __DEFAULT_FN_ATTRS
+_mm512_zextsi256_si512(__m256i __a)
+{
+  return __builtin_shufflevector((__v4di)__a, (__v4di)_mm256_setzero_si256(), 0, 1, 2, 3, 4, 5, 6, 7);
+}
 /* Bitwise operators */
 static __inline__ __m512i __DEFAULT_FN_ATTRS
 _mm512_and_epi32(__m512i __a, __m512i __b)
 @@ -4179,7 +4289,7 @@ static __inline__ __m512i __DEFAULT_FN_ATTRS
 _mm512_maskz_cvtps_epu32 ( __mmask16 __U, __m512 __A)
 {
   return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A,
                   (__v16si)
                   _mm512_setzero_si512 (),
                   (__mmask16) __U ,
                   _MM_FROUND_CUR_DIRECTION);
 @@ -4229,6 +4339,18 @@ _mm512_maskz_cvtpd_epu32 (__mmask8 __U, __m512d __A)
                   _MM_FROUND_CUR_DIRECTION);
 }
+static __inline__ double __DEFAULT_FN_ATTRS
+_mm512_cvtsd_f64(__m512d __a)
+{
+  return __a[0];
+}
+static __inline__ float __DEFAULT_FN_ATTRS
+_mm512_cvtss_f32(__m512 __a)
+{
+  return __a[0];
+}
 /* Unpack and Interleave */
 static __inline __m512d __DEFAULT_FN_ATTRS
 @@ -4540,7 +4662,7 @@ _mm512_maskz_loadu_pd(__mmask8 __U, void const *__P)
 }
 static __inline __m512d __DEFAULT_FN_ATTRS
-_mm512_loadu_pd(double const *__p)
+_mm512_loadu_pd(void const *__p)
 {
   struct __loadu_pd {
     __m512d __v;
 @@ -4549,7 +4671,7 @@ _mm512_loadu_pd(double const *__p)
 }
 static __inline __m512 __DEFAULT_FN_ATTRS
-_mm512_loadu_ps(float const *__p)
+_mm512_loadu_ps(void const *__p)
 {
   struct __loadu_ps {
     __m512 __v;
 @@ -4558,7 +4680,7 @@ _mm512_loadu_ps(float const *__p)
 }
 static __inline __m512 __DEFAULT_FN_ATTRS
-_mm512_load_ps(float const *__p)
+_mm512_load_ps(void const *__p)
 {
   return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *)__p,
                                                   (__v16sf)
 @@ -4584,7 +4706,7 @@ _mm512_maskz_load_ps(__mmask16 __U, void const *__P)
 }
 static __inline __m512d __DEFAULT_FN_ATTRS
-_mm512_load_pd(double const *__p)
+_mm512_load_pd(void const *__p)
 {
   return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *)__p,
                                                    (__v8df)
 @@ -7278,107 +7400,97 @@ _mm_maskz_sqrt_ss (__mmask8 __U, __m128 __A, __m128 __B)
                                            (__mmask8)(U), (int)(R)); })
 static __inline__ __m512 __DEFAULT_FN_ATTRS
-_mm512_broadcast_f32x4 (__m128 __A)
+_mm512_broadcast_f32x4(__m128 __A)
 {
-  return (__m512) __builtin_ia32_broadcastf32x4_512 ((__v4sf) __A,
+  return (__m512)__builtin_shufflevector((__v4sf)__A, (__v4sf)__A,
-                 (__v16sf)
+                                         0, 1, 2, 3, 0, 1, 2, 3,
-                 _mm512_undefined_ps (),
+                                         0, 1, 2, 3, 0, 1, 2, 3);
-                 (__mmask16) -1);
 }
 static __inline__ __m512 __DEFAULT_FN_ATTRS
-_mm512_mask_broadcast_f32x4 (__m512 __O, __mmask16 __M, __m128 __A)
+_mm512_mask_broadcast_f32x4(__m512 __O, __mmask16 __M, __m128 __A)
 {
-  return (__m512) __builtin_ia32_broadcastf32x4_512 ((__v4sf) __A,
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
-                 (__v16sf) __O,
+                                           (__v16sf)_mm512_broadcast_f32x4(__A),
-                 __M);
+                                           (__v16sf)__O);
 }
 static __inline__ __m512 __DEFAULT_FN_ATTRS
-_mm512_maskz_broadcast_f32x4 (__mmask16 __M, __m128 __A)
+_mm512_maskz_broadcast_f32x4(__mmask16 __M, __m128 __A)
 {
-  return (__m512) __builtin_ia32_broadcastf32x4_512 ((__v4sf) __A,
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
-                 (__v16sf)
+                                           (__v16sf)_mm512_broadcast_f32x4(__A),
-                 _mm512_setzero_ps (),
+                                           (__v16sf)_mm512_setzero_ps());
-                 __M);
 }
 static __inline__ __m512d __DEFAULT_FN_ATTRS
-_mm512_broadcast_f64x4 (__m256d __A)
+_mm512_broadcast_f64x4(__m256d __A)
 {
-  return (__m512d) __builtin_ia32_broadcastf64x4_512 ((__v4df) __A,
+  return (__m512d)__builtin_shufflevector((__v4df)__A, (__v4df)__A,
-                  (__v8df)
+                                          0, 1, 2, 3, 0, 1, 2, 3);
-                  _mm512_undefined_pd (),
-                  (__mmask8) -1);
 }
 static __inline__ __m512d __DEFAULT_FN_ATTRS
-_mm512_mask_broadcast_f64x4 (__m512d __O, __mmask8 __M, __m256d __A)
+_mm512_mask_broadcast_f64x4(__m512d __O, __mmask8 __M, __m256d __A)
 {
-  return (__m512d) __builtin_ia32_broadcastf64x4_512 ((__v4df) __A,
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
-                  (__v8df) __O,
+                                            (__v8df)_mm512_broadcast_f64x4(__A),
-                  __M);
+                                            (__v8df)__O);
 }
 static __inline__ __m512d __DEFAULT_FN_ATTRS
-_mm512_maskz_broadcast_f64x4 (__mmask8 __M, __m256d __A)
+_mm512_maskz_broadcast_f64x4(__mmask8 __M, __m256d __A)
 {
-  return (__m512d) __builtin_ia32_broadcastf64x4_512 ((__v4df) __A,
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
-                  (__v8df)
+                                            (__v8df)_mm512_broadcast_f64x4(__A),
-                  _mm512_setzero_pd (),
+                                            (__v8df)_mm512_setzero_pd());
-                  __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_broadcast_i32x4 (__m128i __A)
+_mm512_broadcast_i32x4(__m128i __A)
 {
-  return (__m512i) __builtin_ia32_broadcasti32x4_512 ((__v4si) __A,
+  return (__m512i)__builtin_shufflevector((__v4si)__A, (__v4si)__A,
-                  (__v16si)
+                                          0, 1, 2, 3, 0, 1, 2, 3,
-                  _mm512_undefined_epi32 (),
+                                          0, 1, 2, 3, 0, 1, 2, 3);
-                  (__mmask16) -1);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_mask_broadcast_i32x4 (__m512i __O, __mmask16 __M, __m128i __A)
+_mm512_mask_broadcast_i32x4(__m512i __O, __mmask16 __M, __m128i __A)
 {
-  return (__m512i) __builtin_ia32_broadcasti32x4_512 ((__v4si) __A,
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
-                  (__v16si) __O,
+                                           (__v16si)_mm512_broadcast_i32x4(__A),
-                  __M);
+                                           (__v16si)__O);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_maskz_broadcast_i32x4 (__mmask16 __M, __m128i __A)
+_mm512_maskz_broadcast_i32x4(__mmask16 __M, __m128i __A)
 {
-  return (__m512i) __builtin_ia32_broadcasti32x4_512 ((__v4si) __A,
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
-                  (__v16si)
+                                           (__v16si)_mm512_broadcast_i32x4(__A),
-                  _mm512_setzero_si512 (),
+                                           (__v16si)_mm512_setzero_si512());
-                  __M);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_broadcast_i64x4 (__m256i __A)
+_mm512_broadcast_i64x4(__m256i __A)
 {
-  return (__m512i) __builtin_ia32_broadcasti64x4_512 ((__v4di) __A,
+  return (__m512i)__builtin_shufflevector((__v4di)__A, (__v4di)__A,
-                  (__v8di)
+                                          0, 1, 2, 3, 0, 1, 2, 3);
-                  _mm512_undefined_epi32 (),
-                  (__mmask8) -1);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_mask_broadcast_i64x4 (__m512i __O, __mmask8 __M, __m256i __A)
+_mm512_mask_broadcast_i64x4(__m512i __O, __mmask8 __M, __m256i __A)
 {
-  return (__m512i) __builtin_ia32_broadcasti64x4_512 ((__v4di) __A,
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
-                  (__v8di) __O,
+                                            (__v8di)_mm512_broadcast_i64x4(__A),
-                  __M);
+                                            (__v8di)__O);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
-_mm512_maskz_broadcast_i64x4 (__mmask8 __M, __m256i __A)
+_mm512_maskz_broadcast_i64x4(__mmask8 __M, __m256i __A)
 {
-  return (__m512i) __builtin_ia32_broadcasti64x4_512 ((__v4di) __A,
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
-                  (__v8di)
+                                            (__v8di)_mm512_broadcast_i64x4(__A),
-                  _mm512_setzero_si512 (),
+                                            (__v8di)_mm512_setzero_si512());
-                  __M);
 }
 static __inline__ __m512d __DEFAULT_FN_ATTRS
 @@ -7860,12 +7972,12 @@ _mm512_mask_cvtepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
                                    3 + ((imm) & 0x3) * 4); })
 #define _mm512_mask_extracti32x4_epi32(W, U, A, imm) __extension__ ({ \
-  (__m128i)__builtin_ia32_selectd_128((__mmask8)__U, \
+  (__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
                                 (__v4si)_mm512_extracti32x4_epi32((A), (imm)), \
-                                (__v4si)__W); })
+                                (__v4si)(W)); })
 #define _mm512_maskz_extracti32x4_epi32(U, A, imm) __extension__ ({ \
-  (__m128i)__builtin_ia32_selectd_128((__mmask8)__U, \
+  (__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
                                 (__v4si)_mm512_extracti32x4_epi32((A), (imm)), \
                                 (__v4si)_mm_setzero_si128()); })
 @@ -7878,12 +7990,12 @@ _mm512_mask_cvtepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
                                    ((imm) & 1) ? 7 : 3); })
 #define _mm512_mask_extracti64x4_epi64(W, U, A, imm) __extension__ ({ \
-  (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,      \
+  (__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
                                 (__v4di)_mm512_extracti64x4_epi64((A), (imm)), \
-                                (__v4di)__W); })
+                                (__v4di)(W)); })
 #define _mm512_maskz_extracti64x4_epi64(U, A, imm) __extension__ ({ \
-  (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,      \
+  (__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
                                 (__v4di)_mm512_extracti64x4_epi64((A), (imm)), \
                                 (__v4di)_mm256_setzero_si256()); })
 @@ -8159,11 +8271,11 @@ _mm512_maskz_getexp_ps (__mmask16 __U, __m512 __A)
                                        (__v8di)(__m512i)(index), (__mmask8)-1, \
                                        (int)(scale)); })
-#define _mm512_mask_i64gather_ps( __v1_old, __mask, __index,\
+#define _mm512_mask_i64gather_ps(v1_old, mask, index, addr, scale) __extension__({\
-                                  __addr, __scale) __extension__({\
+  (__m256)__builtin_ia32_gatherdiv16sf((__v8sf)(__m256)(v1_old),\
-__builtin_ia32_gatherdiv16sf ((__v8sf) __v1_old,\
+                                       (float const *)(addr), \
-                              __addr,(__v8di) __index, __mask, __scale);\
+                                       (__v8di)(__m512i)(index), \
-})
+                                       (__mmask8)(mask), (int)(scale)); })
 #define _mm512_i64gather_epi32(index, addr, scale) __extension__ ({\
   (__m256i)__builtin_ia32_gatherdiv16si((__v8si)_mm256_undefined_ps(), \
 @@ -8858,6 +8970,8 @@ _mm512_permutexvar_epi32 (__m512i __X, __m512i __Y)
                  (__mmask16) -1);
 }
+#define _mm512_permutevar_epi32 _mm512_permutexvar_epi32
 static __inline__ __m512i __DEFAULT_FN_ATTRS
 _mm512_mask_permutexvar_epi32 (__m512i __W, __mmask16 __M, __m512i __X,
              __m512i __Y)
 @@ -8868,6 +8982,8 @@ _mm512_mask_permutexvar_epi32 (__m512i __W, __mmask16 __M, __m512i __X,
                  __M);
 }
+#define _mm512_mask_permutevar_epi32 _mm512_mask_permutexvar_epi32
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
 _mm512_kand (__mmask16 __A, __mmask16 __B)
 {
 @@ -8919,25 +9035,29 @@ _mm512_kxor (__mmask16 __A, __mmask16 __B)
 static __inline__ void __DEFAULT_FN_ATTRS
 _mm512_stream_si512 (__m512i * __P, __m512i __A)
 {
-  __builtin_nontemporal_store((__v8di)__A, (__v8di*)__P);
+  typedef __v8di __v8di_aligned __attribute__((aligned(64)));
+  __builtin_nontemporal_store((__v8di_aligned)__A, (__v8di_aligned*)__P);
 }
 static __inline__ __m512i __DEFAULT_FN_ATTRS
 _mm512_stream_load_si512 (void *__P)
 {
-  return __builtin_ia32_movntdqa512 ((__v8di *)__P);
+  typedef __v8di __v8di_aligned __attribute__((aligned(64)));
+  return (__m512i) __builtin_nontemporal_load((const __v8di_aligned *)__P);
 }
 static __inline__ void __DEFAULT_FN_ATTRS
 _mm512_stream_pd (double *__P, __m512d __A)
 {
-  __builtin_nontemporal_store((__v8df)__A, (__v8df*)__P);
+  typedef __v8df __v8df_aligned __attribute__((aligned(64)));
+  __builtin_nontemporal_store((__v8df_aligned)__A, (__v8df_aligned*)__P);
 }
 static __inline__ void __DEFAULT_FN_ATTRS
 _mm512_stream_ps (float *__P, __m512 __A)
 {
-  __builtin_nontemporal_store((__v16sf)__A, (__v16sf*)__P);
+  typedef __v16sf __v16sf_aligned __attribute__((aligned(64)));
+  __builtin_nontemporal_store((__v16sf_aligned)__A, (__v16sf_aligned*)__P);
 }
 static __inline__ __m512d __DEFAULT_FN_ATTRS
 @@ -9101,39 +9221,39 @@ _mm512_maskz_moveldup_ps (__mmask16 __U, __m512 __A)
 static __inline__ __m128 __DEFAULT_FN_ATTRS
 _mm_mask_move_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
 {
   __m128 res = __A;
   res[0] = (__U & 1) ? __B[0] : __W[0];
   return res;
 }
 static __inline__ __m128 __DEFAULT_FN_ATTRS
 _mm_maskz_move_ss (__mmask8 __U, __m128 __A, __m128 __B)
 {
   __m128 res = __A;
   res[0] = (__U & 1) ? __B[0] : 0;
   return res;
 }
 static __inline__ __m128d __DEFAULT_FN_ATTRS
 _mm_mask_move_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
 {
   __m128d res = __A;
   res[0] = (__U & 1) ? __B[0] : __W[0];
   return res;
 }
 static __inline__ __m128d __DEFAULT_FN_ATTRS
 _mm_maskz_move_sd (__mmask8 __U, __m128d __A, __m128d __B)
 {
   __m128d res = __A;
   res[0] = (__U & 1) ? __B[0] : 0;
   return res;
 }
 static __inline__ void __DEFAULT_FN_ATTRS
 _mm_mask_store_ss (float * __W, __mmask8 __U, __m128 __A)
 {
   __builtin_ia32_storess128_mask ((__v16sf *)__W,
                 (__v16sf) _mm512_castps128_ps512(__A),
                 (__mmask16) __U & (__mmask16)1);
 }
 @@ -9141,7 +9261,7 @@ _mm_mask_store_ss (float * __W, __mmask8 __U, __m128 __A)
 static __inline__ void __DEFAULT_FN_ATTRS
 _mm_mask_store_sd (double * __W, __mmask8 __U, __m128d __A)
 {
   __builtin_ia32_storesd128_mask ((__v8df *)__W,
                 (__v8df) _mm512_castpd128_pd512(__A),
                 (__mmask8) __U & 1);
 }
 @@ -9490,7 +9610,7 @@ _mm_mask_cvtsd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128d __B)
 {
   return __builtin_ia32_cvtsd2ss_round_mask ((__v4sf)(__A),
                                              (__v2df)(__B),
                                              (__v4sf)(__W),
                                              (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
 }
 @@ -9499,7 +9619,7 @@ _mm_maskz_cvtsd_ss (__mmask8 __U, __m128 __A, __m128d __B)
 {
   return __builtin_ia32_cvtsd2ss_round_mask ((__v4sf)(__A),
                                              (__v2df)(__B),
                                              (__v4sf)_mm_setzero_ps(),
                                              (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
 }
 @@ -9564,7 +9684,7 @@ _mm_mask_cvtss_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128 __B)
   return __builtin_ia32_cvtss2sd_round_mask((__v2df)(__A),
                                               (__v4sf)(__B),
                                               (__v2df)(__W),
                                               (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
 }
 static __inline__ __m128d __DEFAULT_FN_ATTRS
 @@ -9572,8 +9692,8 @@ _mm_maskz_cvtss_sd (__mmask8 __U, __m128d __A, __m128 __B)
 {
   return __builtin_ia32_cvtss2sd_round_mask((__v2df)(__A),
                                               (__v4sf)(__B),
                                               (__v2df)_mm_setzero_pd(),
                                               (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
 }
 static __inline__ __m128d __DEFAULT_FN_ATTRS
 @@ -9635,6 +9755,45 @@ _mm512_mask_set1_epi64 (__m512i __O, __mmask8 __M, long long __A)
 }
 #endif
+static  __inline __m512i __DEFAULT_FN_ATTRS
+_mm512_set_epi8 (char __e63, char __e62, char __e61, char __e60, char __e59,
+    char __e58, char __e57, char __e56, char __e55, char __e54, char __e53,
+    char __e52, char __e51, char __e50, char __e49, char __e48, char __e47,
+    char __e46, char __e45, char __e44, char __e43, char __e42, char __e41,
+    char __e40, char __e39, char __e38, char __e37, char __e36, char __e35,
+    char __e34, char __e33, char __e32, char __e31, char __e30, char __e29,
+    char __e28, char __e27, char __e26, char __e25, char __e24, char __e23,
+    char __e22, char __e21, char __e20, char __e19, char __e18, char __e17,
+    char __e16, char __e15, char __e14, char __e13, char __e12, char __e11,
+    char __e10, char __e9, char __e8, char __e7, char __e6, char __e5,
+    char __e4, char __e3, char __e2, char __e1, char __e0) {
+  return __extension__ (__m512i)(__v64qi)
+    {__e0, __e1, __e2, __e3, __e4, __e5, __e6, __e7,
+     __e8, __e9, __e10, __e11, __e12, __e13, __e14, __e15,
+     __e16, __e17, __e18, __e19, __e20, __e21, __e22, __e23,
+     __e24, __e25, __e26, __e27, __e28, __e29, __e30, __e31,
+     __e32, __e33, __e34, __e35, __e36, __e37, __e38, __e39,
+     __e40, __e41, __e42, __e43, __e44, __e45, __e46, __e47,
+     __e48, __e49, __e50, __e51, __e52, __e53, __e54, __e55,
+     __e56, __e57, __e58, __e59, __e60, __e61, __e62, __e63};
+}
+static  __inline __m512i __DEFAULT_FN_ATTRS
+_mm512_set_epi16(short __e31, short __e30, short __e29, short __e28,
+    short __e27, short __e26, short __e25, short __e24, short __e23,
+    short __e22, short __e21, short __e20, short __e19, short __e18,
+    short __e17, short __e16, short __e15, short __e14, short __e13,
+    short __e12, short __e11, short __e10, short __e9, short __e8,
+    short __e7, short __e6, short __e5, short __e4, short __e3,
+    short __e2, short __e1, short __e0) {
+  return __extension__ (__m512i)(__v32hi)
+    {__e0, __e1, __e2, __e3, __e4, __e5, __e6, __e7,
+     __e8, __e9, __e10, __e11, __e12, __e13, __e14, __e15,
+     __e16, __e17, __e18, __e19, __e20, __e21, __e22, __e23,
+     __e24, __e25, __e26, __e27, __e28, __e29, __e30, __e31 };
+}
 static __inline __m512i __DEFAULT_FN_ATTRS
 _mm512_set_epi32 (int __A, int __B, int __C, int __D,
      int __E, int __F, int __G, int __H,
 @@ -9780,7 +9939,7 @@ static __inline__ double __DEFAULT_FN_ATTRS _mm512_reduce_mul_pd(__m512d __W) {
 }
 // Vec512 - Vector with size 512.
 // Vec512Neutral - All vector elements set to the identity element.
 // Identity element: {+,0},{*,1},{&,0xFFFFFFFFFFFFFFFF},{|,0}
 // Operator - Can be one of following: +,*,&,|
 // Mask - Intrinsic Mask
 @@ -9810,19 +9969,19 @@ _mm512_mask_reduce_mul_epi64(__mmask8 __M, __m512i __W) {
 static __inline__ long long __DEFAULT_FN_ATTRS
 _mm512_mask_reduce_and_epi64(__mmask8 __M, __m512i __W) {
   _mm512_mask_reduce_operator_64bit(__W, _mm512_set1_epi64(0xFFFFFFFFFFFFFFFF),
                                     &, __M,  i, i, q);
 }
 static __inline__ long long __DEFAULT_FN_ATTRS
 _mm512_mask_reduce_or_epi64(__mmask8 __M, __m512i __W) {
   _mm512_mask_reduce_operator_64bit(__W, _mm512_set1_epi64(0), |, __M,
                                     i, i, q);
 }
 static __inline__ double __DEFAULT_FN_ATTRS
 _mm512_mask_reduce_add_pd(__mmask8 __M, __m512d __W) {
   _mm512_mask_reduce_operator_64bit(__W, _mm512_set1_pd(0), +, __M,
                                     f, d, pd);
 }
 @@ -9884,17 +10043,17 @@ _mm512_reduce_add_epi32(__m512i __W) {
   _mm512_reduce_operator_32bit(__W, +, i, i);
 }
 static __inline__ int __DEFAULT_FN_ATTRS
 _mm512_reduce_mul_epi32(__m512i __W) {
   _mm512_reduce_operator_32bit(__W, *, i, i);
 }
 static __inline__ int __DEFAULT_FN_ATTRS
 _mm512_reduce_and_epi32(__m512i __W) {
   _mm512_reduce_operator_32bit(__W, &, i, i);
 }
 static __inline__ int __DEFAULT_FN_ATTRS
 _mm512_reduce_or_epi32(__m512i __W) {
   _mm512_reduce_operator_32bit(__W, |, i, i);
 }
 @@ -9910,7 +10069,7 @@ _mm512_reduce_mul_ps(__m512 __W) {
 }
 // Vec512 - Vector with size 512.
 // Vec512Neutral - All vector elements set to the identity element.
 // Identity element: {+,0},{*,1},{&,0xFFFFFFFF},{|,0}
 // Operator - Can be one of following: +,*,&,|
 // Mask - Intrinsic Mask
 @@ -9940,7 +10099,7 @@ _mm512_mask_reduce_mul_epi32( __mmask16 __M, __m512i __W) {
 static __inline__ int __DEFAULT_FN_ATTRS
 _mm512_mask_reduce_and_epi32( __mmask16 __M, __m512i __W) {
   _mm512_mask_reduce_operator_32bit(__W, _mm512_set1_epi32(0xFFFFFFFF), &, __M,
                                     i, i, d);
 }
 @@ -10003,7 +10162,7 @@ _mm512_mask_reduce_mul_ps(__mmask16 __M, __m512 __W) {
     return Vec512[0];                                                          \
   })
 static __inline__ long long __DEFAULT_FN_ATTRS
 _mm512_reduce_max_epi64(__m512i __V) {
   _mm512_reduce_maxMin_64bit(__V, max_epi64, i, i);
 }
 @@ -10013,7 +10172,7 @@ _mm512_reduce_max_epu64(__m512i __V) {
   _mm512_reduce_maxMin_64bit(__V, max_epu64, i, i);
 }
 static __inline__ double __DEFAULT_FN_ATTRS
 _mm512_reduce_max_pd(__m512d __V) {
   _mm512_reduce_maxMin_64bit(__V, max_pd, d, f);
 }
 @@ -10028,7 +10187,7 @@ _mm512_reduce_min_epu64(__m512i __V) {
   _mm512_reduce_maxMin_64bit(__V, min_epu64, i, i);
 }
 static __inline__ double __DEFAULT_FN_ATTRS
 _mm512_reduce_min_pd(__m512d __V) {
   _mm512_reduce_maxMin_64bit(__V, min_pd, d, f);
 }

c_headers/avx512vldqintrin.h+20-22

...	@@ -1000,27 +1000,26 @@ _mm256_maskz_broadcast_f32x2 (__mmask8 __M, __m128 __A)	...	@@ -1000,27 +1000,26 @@ _mm256_maskz_broadcast_f32x2 (__mmask8 __M, __m128 __A)
1000	}	1000	}
1001		1001
1002	static __inline__ __m256d __DEFAULT_FN_ATTRS	1002	static __inline__ __m256d __DEFAULT_FN_ATTRS
1003	_mm256_broadcast_f64x2 (__m128d __A)	1003	_mm256_broadcast_f64x2(__m128d __A)
1004	{	1004	{
1005	return (__m256d) __builtin_ia32_broadcastf64x2_256_mask ((__v2df) __A,	1005	return (__m256d)__builtin_shufflevector((__v2df)__A, (__v2df)__A,
1006	(__v4df)_mm256_undefined_pd(),	1006	0, 1, 0, 1);
1007	(__mmask8) -1);
1008	}	1007	}
1009		1008
1010	static __inline__ __m256d __DEFAULT_FN_ATTRS	1009	static __inline__ __m256d __DEFAULT_FN_ATTRS
1011	_mm256_mask_broadcast_f64x2 (__m256d __O, __mmask8 __M, __m128d __A)	1010	_mm256_mask_broadcast_f64x2(__m256d __O, __mmask8 __M, __m128d __A)
1012	{	1011	{
1013	return (__m256d) __builtin_ia32_broadcastf64x2_256_mask ((__v2df) __A,	1012	return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__M,
1014	(__v4df) __O,	1013	(__v4df)_mm256_broadcast_f64x2(__A),
1015	__M);	1014	(__v4df)__O);
1016	}	1015	}
1017		1016
1018	static __inline__ __m256d __DEFAULT_FN_ATTRS	1017	static __inline__ __m256d __DEFAULT_FN_ATTRS
1019	_mm256_maskz_broadcast_f64x2 (__mmask8 __M, __m128d __A)	1018	_mm256_maskz_broadcast_f64x2 (__mmask8 __M, __m128d __A)
1020	{	1019	{
1021	return (__m256d) __builtin_ia32_broadcastf64x2_256_mask ((__v2df) __A,	1020	return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__M,
1022	(__v4df) _mm256_setzero_ps (),	1021	(__v4df)_mm256_broadcast_f64x2(__A),
1023	__M);	1022	(__v4df)_mm256_setzero_pd());
1024	}	1023	}
1025		1024
1026	static __inline__ __m128i __DEFAULT_FN_ATTRS	1025	static __inline__ __m128i __DEFAULT_FN_ATTRS
...	@@ -1072,27 +1071,26 @@ _mm256_maskz_broadcast_i32x2 (__mmask8 __M, __m128i __A)	...	@@ -1072,27 +1071,26 @@ _mm256_maskz_broadcast_i32x2 (__mmask8 __M, __m128i __A)
1072	}	1071	}
1073		1072
1074	static __inline__ __m256i __DEFAULT_FN_ATTRS	1073	static __inline__ __m256i __DEFAULT_FN_ATTRS
1075	_mm256_broadcast_i64x2 (__m128i __A)	1074	_mm256_broadcast_i64x2(__m128i __A)
1076	{	1075	{
1077	return (__m256i) __builtin_ia32_broadcasti64x2_256_mask ((__v2di) __A,	1076	return (__m256i)__builtin_shufflevector((__v2di)__A, (__v2di)__A,
1078	(__v4di)_mm256_undefined_si256(),	1077	0, 1, 0, 1);
1079	(__mmask8) -1);
1080	}	1078	}
1081		1079
1082	static __inline__ __m256i __DEFAULT_FN_ATTRS	1080	static __inline__ __m256i __DEFAULT_FN_ATTRS
1083	_mm256_mask_broadcast_i64x2 (__m256i __O, __mmask8 __M, __m128i __A)	1081	_mm256_mask_broadcast_i64x2(__m256i __O, __mmask8 __M, __m128i __A)
1084	{	1082	{
1085	return (__m256i) __builtin_ia32_broadcasti64x2_256_mask ((__v2di) __A,	1083	return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
1086	(__v4di) __O,	1084	(__v4di)_mm256_broadcast_i64x2(__A),
1087	__M);	1085	(__v4di)__O);
1088	}	1086	}
1089		1087
1090	static __inline__ __m256i __DEFAULT_FN_ATTRS	1088	static __inline__ __m256i __DEFAULT_FN_ATTRS
1091	_mm256_maskz_broadcast_i64x2 (__mmask8 __M, __m128i __A)	1089	_mm256_maskz_broadcast_i64x2 (__mmask8 __M, __m128i __A)
1092	{	1090	{
1093	return (__m256i) __builtin_ia32_broadcasti64x2_256_mask ((__v2di) __A,	1091	return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
1094	(__v4di) _mm256_setzero_si256 (),	1092	(__v4di)_mm256_broadcast_i64x2(__A),
1095	__M);	1093	(__v4di)_mm256_setzero_si256());
1096	}	1094	}
1097		1095
1098	#define _mm256_extractf64x2_pd(A, imm) __extension__ ({ \	1096	#define _mm256_extractf64x2_pd(A, imm) __extension__ ({ \

c_headers/avx512vlintrin.h+21-24

...	@@ -7189,52 +7189,49 @@ _mm256_maskz_rsqrt14_ps (__mmask8 __U, __m256 __A)	...	@@ -7189,52 +7189,49 @@ _mm256_maskz_rsqrt14_ps (__mmask8 __U, __m256 __A)
7189	}	7189	}
7190		7190
7191	static __inline__ __m256 __DEFAULT_FN_ATTRS	7191	static __inline__ __m256 __DEFAULT_FN_ATTRS
7192	_mm256_broadcast_f32x4 (__m128 __A)	7192	_mm256_broadcast_f32x4(__m128 __A)
7193	{	7193	{
7194	return (__m256) __builtin_ia32_broadcastf32x4_256_mask ((__v4sf) __A,	7194	return (__m256)__builtin_shufflevector((__v4sf)__A, (__v4sf)__A,
7195	(__v8sf)_mm256_undefined_pd (),	7195	0, 1, 2, 3, 0, 1, 2, 3);
7196	(__mmask8) -1);
7197	}	7196	}
7198		7197
7199	static __inline__ __m256 __DEFAULT_FN_ATTRS	7198	static __inline__ __m256 __DEFAULT_FN_ATTRS
7200	_mm256_mask_broadcast_f32x4 (__m256 __O, __mmask8 __M, __m128 __A)	7199	_mm256_mask_broadcast_f32x4(__m256 __O, __mmask8 __M, __m128 __A)
7201	{	7200	{
7202	return (__m256) __builtin_ia32_broadcastf32x4_256_mask ((__v4sf) __A,	7201	return (__m256)__builtin_ia32_selectps_256((__mmask8)__M,
7203	(__v8sf) __O,	7202	(__v8sf)_mm256_broadcast_f32x4(__A),
7204	__M);	7203	(__v8sf)__O);
7205	}	7204	}
7206		7205
7207	static __inline__ __m256 __DEFAULT_FN_ATTRS	7206	static __inline__ __m256 __DEFAULT_FN_ATTRS
7208	_mm256_maskz_broadcast_f32x4 (__mmask8 __M, __m128 __A)	7207	_mm256_maskz_broadcast_f32x4 (__mmask8 __M, __m128 __A)
7209	{	7208	{
7210	return (__m256) __builtin_ia32_broadcastf32x4_256_mask ((__v4sf) __A,	7209	return (__m256)__builtin_ia32_selectps_256((__mmask8)__M,
7211	(__v8sf) _mm256_setzero_ps (),	7210	(__v8sf)_mm256_broadcast_f32x4(__A),
7212	__M);	7211	(__v8sf)_mm256_setzero_ps());
7213	}	7212	}
7214		7213
7215	static __inline__ __m256i __DEFAULT_FN_ATTRS	7214	static __inline__ __m256i __DEFAULT_FN_ATTRS
7216	_mm256_broadcast_i32x4 (__m128i __A)	7215	_mm256_broadcast_i32x4(__m128i __A)
7217	{	7216	{
7218	return (__m256i) __builtin_ia32_broadcasti32x4_256_mask ((__v4si) __A,	7217	return (__m256i)__builtin_shufflevector((__v4si)__A, (__v4si)__A,
7219	(__v8si)_mm256_undefined_si256 (),	7218	0, 1, 2, 3, 0, 1, 2, 3);
7220	(__mmask8) -1);
7221	}	7219	}
7222		7220
7223	static __inline__ __m256i __DEFAULT_FN_ATTRS	7221	static __inline__ __m256i __DEFAULT_FN_ATTRS
7224	_mm256_mask_broadcast_i32x4 (__m256i __O, __mmask8 __M, __m128i __A)	7222	_mm256_mask_broadcast_i32x4(__m256i __O, __mmask8 __M, __m128i __A)
7225	{	7223	{
7226	return (__m256i) __builtin_ia32_broadcasti32x4_256_mask ((__v4si) __A,	7224	return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
7227	(__v8si)	7225	(__v8si)_mm256_broadcast_i32x4(__A),
7228	__O, __M);	7226	(__v8si)__O);
7229	}	7227	}
7230		7228
7231	static __inline__ __m256i __DEFAULT_FN_ATTRS	7229	static __inline__ __m256i __DEFAULT_FN_ATTRS
7232	_mm256_maskz_broadcast_i32x4 (__mmask8 __M, __m128i __A)	7230	_mm256_maskz_broadcast_i32x4(__mmask8 __M, __m128i __A)
7233	{	7231	{
7234	return (__m256i) __builtin_ia32_broadcasti32x4_256_mask ((__v4si)	7232	return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
7235	__A,	7233	(__v8si)_mm256_broadcast_i32x4(__A),
7236	(__v8si) _mm256_setzero_si256 (),	7234	(__v8si)_mm256_setzero_si256());
7237	__M);
7238	}	7235	}
7239		7236
7240	static __inline__ __m256d __DEFAULT_FN_ATTRS	7237	static __inline__ __m256d __DEFAULT_FN_ATTRS

c_headers/avx512vpopcntdqintrin.h created+70

...	@@ -0,0 +1,70 @@
1	/*===------------- avx512vpopcntdqintrin.h - AVX512VPOPCNTDQ intrinsics
2	*------------------===
3	*
4	*
5	* Permission is hereby granted, free of charge, to any person obtaining a copy
6	* of this software and associated documentation files (the "Software"), to deal
7	* in the Software without restriction, including without limitation the rights
8	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9	* copies of the Software, and to permit persons to whom the Software is
10	* furnished to do so, subject to the following conditions:
11	*
12	* The above copyright notice and this permission notice shall be included in
13	* all copies or substantial portions of the Software.
14	*
15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21	* THE SOFTWARE.
22	*
23	*===-----------------------------------------------------------------------===
24	*/
25	#ifndef __IMMINTRIN_H
26	#error \
27	"Never use <avx512vpopcntdqintrin.h> directly; include <immintrin.h> instead."
28	#endif
29
30	#ifndef __AVX512VPOPCNTDQINTRIN_H
31	#define __AVX512VPOPCNTDQINTRIN_H
32
33	/* Define the default attributes for the functions in this file. */
34	#define __DEFAULT_FN_ATTRS \
35	__attribute__((__always_inline__, __nodebug__, __target__("avx512vpopcntd" \
36	"q")))
37
38	static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_popcnt_epi64(__m512i __A) {
39	return (__m512i)__builtin_ia32_vpopcntq_512((__v8di)__A);
40	}
41
42	static __inline__ __m512i __DEFAULT_FN_ATTRS
43	_mm512_mask_popcnt_epi64(__m512i __W, __mmask8 __U, __m512i __A) {
44	return (__m512i)__builtin_ia32_selectq_512(
45	(__mmask8)__U, (__v8di)_mm512_popcnt_epi64(__A), (__v8di)__W);
46	}
47
48	static __inline__ __m512i __DEFAULT_FN_ATTRS
49	_mm512_maskz_popcnt_epi64(__mmask8 __U, __m512i __A) {
50	return _mm512_mask_popcnt_epi64((__m512i)_mm512_setzero_si512(), __U, __A);
51	}
52
53	static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_popcnt_epi32(__m512i __A) {
54	return (__m512i)__builtin_ia32_vpopcntd_512((__v16si)__A);
55	}
56
57	static __inline__ __m512i __DEFAULT_FN_ATTRS
58	_mm512_mask_popcnt_epi32(__m512i __W, __mmask16 __U, __m512i __A) {
59	return (__m512i)__builtin_ia32_selectd_512(
60	(__mmask16)__U, (__v16si)_mm512_popcnt_epi32(__A), (__v16si)__W);
61	}
62
63	static __inline__ __m512i __DEFAULT_FN_ATTRS
64	_mm512_maskz_popcnt_epi32(__mmask16 __U, __m512i __A) {
65	return _mm512_mask_popcnt_epi32((__m512i)_mm512_setzero_si512(), __U, __A);
66	}
67
68	#undef __DEFAULT_FN_ATTRS
69
70	#endif

c_headers/avxintrin.h+407-139

 @@ -1458,12 +1458,13 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \brief Computes two dot products in parallel, using the lower and upper
 ///    halves of two [8 x float] vectors as input to the two computations, and
 ///    returning the two dot products in the lower and upper halves of the
-///    [8 x float] result. The immediate integer operand controls which input
+///    [8 x float] result.
-///    elements will contribute to the dot product, and where the final results
+///
-///    are returned. In general, for each dot product, the four corresponding
+///    The immediate integer operand controls which input elements will
-///    elements of the input vectors are multiplied; the first two and second
+///    contribute to the dot product, and where the final results are returned.
-///    two products are summed, then the two sums are added to form the final
+///    In general, for each dot product, the four corresponding elements of the
-///    result.
+///    input vectors are multiplied; the first two and second two products are
+///    summed, then the two sums are added to form the final result.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1497,15 +1498,16 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /* Vector shuffle */
 /// \brief Selects 8 float values from the 256-bit operands of [8 x float], as
-///    specified by the immediate value operand. The four selected elements in
+///    specified by the immediate value operand.
-///    each operand are copied to the destination according to the bits
+///
-///    specified in the immediate operand. The selected elements from the first
+///    The four selected elements in each operand are copied to the destination
-///    256-bit operand are copied to bits [63:0] and bits [191:128] of the
+///    according to the bits specified in the immediate operand. The selected
-///    destination, and the selected elements from the second 256-bit operand
+///    elements from the first 256-bit operand are copied to bits [63:0] and
-///    are copied to bits [127:64] and bits [255:192] of the destination. For
+///    bits [191:128] of the destination, and the selected elements from the
-///    example, if bits [7:0] of the immediate operand contain a value of 0xFF,
+///    second 256-bit operand are copied to bits [127:64] and bits [255:192] of
-///    the 256-bit destination vector would contain the following values: b[7],
+///    the destination. For example, if bits [7:0] of the immediate operand
-///    b[7], a[7], a[7], b[3], b[3], a[3], a[3].
+///    contain a value of 0xFF, the 256-bit destination vector would contain the
+///    following values: b[7], b[7], a[7], a[7], b[3], b[3], a[3], a[3].
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1557,13 +1559,14 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
                                   12 + (((mask) >> 6) & 0x3)); })
 /// \brief Selects four double-precision values from the 256-bit operands of
-///    [4 x double], as specified by the immediate value operand. The selected
+///    [4 x double], as specified by the immediate value operand.
-///    elements from the first 256-bit operand are copied to bits [63:0] and
+///
-///    bits [191:128] in the destination, and the selected elements from the
+///    The selected elements from the first 256-bit operand are copied to bits
-///    second 256-bit operand are copied to bits [127:64] and bits [255:192] in
+///    [63:0] and bits [191:128] in the destination, and the selected elements
-///    the destination. For example, if bits [3:0] of the immediate operand
+///    from the second 256-bit operand are copied to bits [127:64] and bits
-///    contain a value of 0xF, the 256-bit destination vector would contain the
+///    [255:192] in the destination. For example, if bits [3:0] of the immediate
-///    following values: b[3], a[3], b[1], a[1].
+///    operand contain a value of 0xF, the 256-bit destination vector would
+///    contain the following values: b[3], a[3], b[1], a[1].
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1613,9 +1616,9 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 #define _CMP_NEQ_UQ   0x04 /* Not-equal (unordered, non-signaling)  */
 #define _CMP_NLT_US   0x05 /* Not-less-than (unordered, signaling)  */
 #define _CMP_NLE_US   0x06 /* Not-less-than-or-equal (unordered, signaling)  */
-#define _CMP_ORD_Q    0x07 /* Ordered (nonsignaling)   */
+#define _CMP_ORD_Q    0x07 /* Ordered (non-signaling)   */
 #define _CMP_EQ_UQ    0x08 /* Equal (unordered, non-signaling)  */
-#define _CMP_NGE_US   0x09 /* Not-greater-than-or-equal (unord, signaling)  */
+#define _CMP_NGE_US   0x09 /* Not-greater-than-or-equal (unordered, signaling)  */
 #define _CMP_NGT_US   0x0a /* Not-greater-than (unordered, signaling)  */
 #define _CMP_FALSE_OQ 0x0b /* False (ordered, non-signaling)  */
 #define _CMP_NEQ_OQ   0x0c /* Not-equal (ordered, non-signaling)  */
 @@ -1628,10 +1631,10 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 #define _CMP_UNORD_S  0x13 /* Unordered (signaling)  */
 #define _CMP_NEQ_US   0x14 /* Not-equal (unordered, signaling)  */
 #define _CMP_NLT_UQ   0x15 /* Not-less-than (unordered, non-signaling)  */
-#define _CMP_NLE_UQ   0x16 /* Not-less-than-or-equal (unord, non-signaling)  */
+#define _CMP_NLE_UQ   0x16 /* Not-less-than-or-equal (unordered, non-signaling)  */
 #define _CMP_ORD_S    0x17 /* Ordered (signaling)  */
 #define _CMP_EQ_US    0x18 /* Equal (unordered, signaling)  */
-#define _CMP_NGE_UQ   0x19 /* Not-greater-than-or-equal (unord, non-sign)  */
+#define _CMP_NGE_UQ   0x19 /* Not-greater-than-or-equal (unordered, non-signaling)  */
 #define _CMP_NGT_UQ   0x1a /* Not-greater-than (unordered, non-signaling)  */
 #define _CMP_FALSE_OS 0x1b /* False (ordered, signaling)  */
 #define _CMP_NEQ_OS   0x1c /* Not-equal (ordered, signaling)  */
 @@ -1641,9 +1644,11 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \brief Compares each of the corresponding double-precision values of two
 ///    128-bit vectors of [2 x double], using the operation specified by the
-///    immediate integer operand. Returns a [2 x double] vector consisting of
+///    immediate integer operand.
-///    two doubles corresponding to the two comparison results: zero if the
+///
-///    comparison is false, and all 1's if the comparison is true.
+///    Returns a [2 x double] vector consisting of two doubles corresponding to
+///    the two comparison results: zero if the comparison is false, and all 1's
+///    if the comparison is true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1660,17 +1665,38 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    00h, 08h, 10h, 18h: Equal \n
+///    0x00 : Equal (ordered, non-signaling)
-///    01h, 09h, 11h, 19h: Less than \n
+///    0x01 : Less-than (ordered, signaling)
-///    02h, 0Ah, 12h, 1Ah: Less than or equal / Greater than or equal
+///    0x02 : Less-than-or-equal (ordered, signaling)
-///                        (swapped operands) \n
+///    0x03 : Unordered (non-signaling)
-///    03h, 0Bh, 13h, 1Bh: Unordered \n
+///    0x04 : Not-equal (unordered, non-signaling)
-///    04h, 0Ch, 14h, 1Ch: Not equal \n
+///    0x05 : Not-less-than (unordered, signaling)
-///    05h, 0Dh, 15h, 1Dh: Not less than / Not greater than
+///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///                        (swapped operands) \n
+///    0x07 : Ordered (non-signaling)
-///    06h, 0Eh, 16h, 1Eh: Not less than or equal / Not greater than or equal
+///    0x08 : Equal (unordered, non-signaling)
-///                        (swapped operands) \n
+///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    07h, 0Fh, 17h, 1Fh: Ordered
+///    0x0a : Not-greater-than (unordered, signaling)
+///    0x0b : False (ordered, non-signaling)
+///    0x0c : Not-equal (ordered, non-signaling)
+///    0x0d : Greater-than-or-equal (ordered, signaling)
+///    0x0e : Greater-than (ordered, signaling)
+///    0x0f : True (unordered, non-signaling)
+///    0x10 : Equal (ordered, signaling)
+///    0x11 : Less-than (ordered, non-signaling)
+///    0x12 : Less-than-or-equal (ordered, non-signaling)
+///    0x13 : Unordered (signaling)
+///    0x14 : Not-equal (unordered, signaling)
+///    0x15 : Not-less-than (unordered, non-signaling)
+///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
+///    0x17 : Ordered (signaling)
+///    0x18 : Equal (unordered, signaling)
+///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
+///    0x1a : Not-greater-than (unordered, non-signaling)
+///    0x1b : False (ordered, signaling)
+///    0x1c : Not-equal (ordered, signaling)
+///    0x1d : Greater-than-or-equal (ordered, non-signaling)
+///    0x1e : Greater-than (ordered, non-signaling)
+///    0x1f : True (unordered, signaling)
 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
 #define _mm_cmp_pd(a, b, c) __extension__ ({ \
   (__m128d)__builtin_ia32_cmppd((__v2df)(__m128d)(a), \
 @@ -1678,9 +1704,11 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \brief Compares each of the corresponding values of two 128-bit vectors of
 ///    [4 x float], using the operation specified by the immediate integer
-///    operand. Returns a [4 x float] vector consisting of four floats
+///    operand.
-///    corresponding to the four comparison results: zero if the comparison is
+///
-///    false, and all 1's if the comparison is true.
+///    Returns a [4 x float] vector consisting of four floats corresponding to
+///    the four comparison results: zero if the comparison is false, and all 1's
+///    if the comparison is true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1697,17 +1725,38 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    00h, 08h, 10h, 18h: Equal \n
+///    0x00 : Equal (ordered, non-signaling)
-///    01h, 09h, 11h, 19h: Less than \n
+///    0x01 : Less-than (ordered, signaling)
-///    02h, 0Ah, 12h, 1Ah: Less than or equal / Greater than or equal
+///    0x02 : Less-than-or-equal (ordered, signaling)
-///                        (swapped operands) \n
+///    0x03 : Unordered (non-signaling)
-///    03h, 0Bh, 13h, 1Bh: Unordered \n
+///    0x04 : Not-equal (unordered, non-signaling)
-///    04h, 0Ch, 14h, 1Ch: Not equal \n
+///    0x05 : Not-less-than (unordered, signaling)
-///    05h, 0Dh, 15h, 1Dh: Not less than / Not greater than
+///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///                        (swapped operands) \n
+///    0x07 : Ordered (non-signaling)
-///    06h, 0Eh, 16h, 1Eh: Not less than or equal / Not greater than or equal
+///    0x08 : Equal (unordered, non-signaling)
-///                        (swapped operands) \n
+///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    07h, 0Fh, 17h, 1Fh: Ordered
+///    0x0a : Not-greater-than (unordered, signaling)
+///    0x0b : False (ordered, non-signaling)
+///    0x0c : Not-equal (ordered, non-signaling)
+///    0x0d : Greater-than-or-equal (ordered, signaling)
+///    0x0e : Greater-than (ordered, signaling)
+///    0x0f : True (unordered, non-signaling)
+///    0x10 : Equal (ordered, signaling)
+///    0x11 : Less-than (ordered, non-signaling)
+///    0x12 : Less-than-or-equal (ordered, non-signaling)
+///    0x13 : Unordered (signaling)
+///    0x14 : Not-equal (unordered, signaling)
+///    0x15 : Not-less-than (unordered, non-signaling)
+///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
+///    0x17 : Ordered (signaling)
+///    0x18 : Equal (unordered, signaling)
+///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
+///    0x1a : Not-greater-than (unordered, non-signaling)
+///    0x1b : False (ordered, signaling)
+///    0x1c : Not-equal (ordered, signaling)
+///    0x1d : Greater-than-or-equal (ordered, non-signaling)
+///    0x1e : Greater-than (ordered, non-signaling)
+///    0x1f : True (unordered, signaling)
 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
 #define _mm_cmp_ps(a, b, c) __extension__ ({ \
   (__m128)__builtin_ia32_cmpps((__v4sf)(__m128)(a), \
 @@ -1715,9 +1764,11 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \brief Compares each of the corresponding double-precision values of two
 ///    256-bit vectors of [4 x double], using the operation specified by the
-///    immediate integer operand. Returns a [4 x double] vector consisting of
+///    immediate integer operand.
-///    four doubles corresponding to the four comparison results: zero if the
+///
-///    comparison is false, and all 1's if the comparison is true.
+///    Returns a [4 x double] vector consisting of four doubles corresponding to
+///    the four comparison results: zero if the comparison is false, and all 1's
+///    if the comparison is true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1734,17 +1785,38 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    00h, 08h, 10h, 18h: Equal \n
+///    0x00 : Equal (ordered, non-signaling)
-///    01h, 09h, 11h, 19h: Less than \n
+///    0x01 : Less-than (ordered, signaling)
-///    02h, 0Ah, 12h, 1Ah: Less than or equal / Greater than or equal
+///    0x02 : Less-than-or-equal (ordered, signaling)
-///                        (swapped operands) \n
+///    0x03 : Unordered (non-signaling)
-///    03h, 0Bh, 13h, 1Bh: Unordered \n
+///    0x04 : Not-equal (unordered, non-signaling)
-///    04h, 0Ch, 14h, 1Ch: Not equal \n
+///    0x05 : Not-less-than (unordered, signaling)
-///    05h, 0Dh, 15h, 1Dh: Not less than / Not greater than
+///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///                        (swapped operands) \n
+///    0x07 : Ordered (non-signaling)
-///    06h, 0Eh, 16h, 1Eh: Not less than or equal / Not greater than or equal
+///    0x08 : Equal (unordered, non-signaling)
-///                        (swapped operands) \n
+///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    07h, 0Fh, 17h, 1Fh: Ordered
+///    0x0a : Not-greater-than (unordered, signaling)
+///    0x0b : False (ordered, non-signaling)
+///    0x0c : Not-equal (ordered, non-signaling)
+///    0x0d : Greater-than-or-equal (ordered, signaling)
+///    0x0e : Greater-than (ordered, signaling)
+///    0x0f : True (unordered, non-signaling)
+///    0x10 : Equal (ordered, signaling)
+///    0x11 : Less-than (ordered, non-signaling)
+///    0x12 : Less-than-or-equal (ordered, non-signaling)
+///    0x13 : Unordered (signaling)
+///    0x14 : Not-equal (unordered, signaling)
+///    0x15 : Not-less-than (unordered, non-signaling)
+///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
+///    0x17 : Ordered (signaling)
+///    0x18 : Equal (unordered, signaling)
+///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
+///    0x1a : Not-greater-than (unordered, non-signaling)
+///    0x1b : False (ordered, signaling)
+///    0x1c : Not-equal (ordered, signaling)
+///    0x1d : Greater-than-or-equal (ordered, non-signaling)
+///    0x1e : Greater-than (ordered, non-signaling)
+///    0x1f : True (unordered, signaling)
 /// \returns A 256-bit vector of [4 x double] containing the comparison results.
 #define _mm256_cmp_pd(a, b, c) __extension__ ({ \
   (__m256d)__builtin_ia32_cmppd256((__v4df)(__m256d)(a), \
 @@ -1752,9 +1824,11 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \brief Compares each of the corresponding values of two 256-bit vectors of
 ///    [8 x float], using the operation specified by the immediate integer
-///    operand. Returns a [8 x float] vector consisting of eight floats
+///    operand.
-///    corresponding to the eight comparison results: zero if the comparison is
+///
-///    false, and all 1's if the comparison is true.
+///    Returns a [8 x float] vector consisting of eight floats corresponding to
+///    the eight comparison results: zero if the comparison is false, and all
+///    1's if the comparison is true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1771,17 +1845,38 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    00h, 08h, 10h, 18h: Equal \n
+///    0x00 : Equal (ordered, non-signaling)
-///    01h, 09h, 11h, 19h: Less than \n
+///    0x01 : Less-than (ordered, signaling)
-///    02h, 0Ah, 12h, 1Ah: Less than or equal / Greater than or equal
+///    0x02 : Less-than-or-equal (ordered, signaling)
-///                        (swapped operands) \n
+///    0x03 : Unordered (non-signaling)
-///    03h, 0Bh, 13h, 1Bh: Unordered \n
+///    0x04 : Not-equal (unordered, non-signaling)
-///    04h, 0Ch, 14h, 1Ch: Not equal \n
+///    0x05 : Not-less-than (unordered, signaling)
-///    05h, 0Dh, 15h, 1Dh: Not less than / Not greater than
+///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///                        (swapped operands) \n
+///    0x07 : Ordered (non-signaling)
-///    06h, 0Eh, 16h, 1Eh: Not less than or equal / Not greater than or equal
+///    0x08 : Equal (unordered, non-signaling)
-///                        (swapped operands) \n
+///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    07h, 0Fh, 17h, 1Fh: Ordered
+///    0x0a : Not-greater-than (unordered, signaling)
+///    0x0b : False (ordered, non-signaling)
+///    0x0c : Not-equal (ordered, non-signaling)
+///    0x0d : Greater-than-or-equal (ordered, signaling)
+///    0x0e : Greater-than (ordered, signaling)
+///    0x0f : True (unordered, non-signaling)
+///    0x10 : Equal (ordered, signaling)
+///    0x11 : Less-than (ordered, non-signaling)
+///    0x12 : Less-than-or-equal (ordered, non-signaling)
+///    0x13 : Unordered (signaling)
+///    0x14 : Not-equal (unordered, signaling)
+///    0x15 : Not-less-than (unordered, non-signaling)
+///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
+///    0x17 : Ordered (signaling)
+///    0x18 : Equal (unordered, signaling)
+///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
+///    0x1a : Not-greater-than (unordered, non-signaling)
+///    0x1b : False (ordered, signaling)
+///    0x1c : Not-equal (ordered, signaling)
+///    0x1d : Greater-than-or-equal (ordered, non-signaling)
+///    0x1e : Greater-than (ordered, non-signaling)
+///    0x1f : True (unordered, signaling)
 /// \returns A 256-bit vector of [8 x float] containing the comparison results.
 #define _mm256_cmp_ps(a, b, c) __extension__ ({ \
   (__m256)__builtin_ia32_cmpps256((__v8sf)(__m256)(a), \
 @@ -1789,8 +1884,10 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \brief Compares each of the corresponding scalar double-precision values of
 ///    two 128-bit vectors of [2 x double], using the operation specified by the
-///    immediate integer operand. If the result is true, all 64 bits of the
+///    immediate integer operand.
-///    destination vector are set; otherwise they are cleared.
+///
+///    If the result is true, all 64 bits of the destination vector are set;
+///    otherwise they are cleared.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1807,17 +1904,38 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    00h, 08h, 10h, 18h: Equal \n
+///    0x00 : Equal (ordered, non-signaling)
-///    01h, 09h, 11h, 19h: Less than \n
+///    0x01 : Less-than (ordered, signaling)
-///    02h, 0Ah, 12h, 1Ah: Less than or equal / Greater than or equal
+///    0x02 : Less-than-or-equal (ordered, signaling)
-///                        (swapped operands) \n
+///    0x03 : Unordered (non-signaling)
-///    03h, 0Bh, 13h, 1Bh: Unordered \n
+///    0x04 : Not-equal (unordered, non-signaling)
-///    04h, 0Ch, 14h, 1Ch: Not equal \n
+///    0x05 : Not-less-than (unordered, signaling)
-///    05h, 0Dh, 15h, 1Dh: Not less than / Not greater than
+///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///                        (swapped operands) \n
+///    0x07 : Ordered (non-signaling)
-///    06h, 0Eh, 16h, 1Eh: Not less than or equal / Not greater than or equal
+///    0x08 : Equal (unordered, non-signaling)
-///                        (swapped operands) \n
+///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    07h, 0Fh, 17h, 1Fh: Ordered
+///    0x0a : Not-greater-than (unordered, signaling)
+///    0x0b : False (ordered, non-signaling)
+///    0x0c : Not-equal (ordered, non-signaling)
+///    0x0d : Greater-than-or-equal (ordered, signaling)
+///    0x0e : Greater-than (ordered, signaling)
+///    0x0f : True (unordered, non-signaling)
+///    0x10 : Equal (ordered, signaling)
+///    0x11 : Less-than (ordered, non-signaling)
+///    0x12 : Less-than-or-equal (ordered, non-signaling)
+///    0x13 : Unordered (signaling)
+///    0x14 : Not-equal (unordered, signaling)
+///    0x15 : Not-less-than (unordered, non-signaling)
+///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
+///    0x17 : Ordered (signaling)
+///    0x18 : Equal (unordered, signaling)
+///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
+///    0x1a : Not-greater-than (unordered, non-signaling)
+///    0x1b : False (ordered, signaling)
+///    0x1c : Not-equal (ordered, signaling)
+///    0x1d : Greater-than-or-equal (ordered, non-signaling)
+///    0x1e : Greater-than (ordered, non-signaling)
+///    0x1f : True (unordered, signaling)
 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
 #define _mm_cmp_sd(a, b, c) __extension__ ({ \
   (__m128d)__builtin_ia32_cmpsd((__v2df)(__m128d)(a), \
 @@ -1825,8 +1943,10 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \brief Compares each of the corresponding scalar values of two 128-bit
 ///    vectors of [4 x float], using the operation specified by the immediate
-///    integer operand. If the result is true, all 32 bits of the destination
+///    integer operand.
-///    vector are set; otherwise they are cleared.
+///
+///    If the result is true, all 32 bits of the destination vector are set;
+///    otherwise they are cleared.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1843,17 +1963,38 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    00h, 08h, 10h, 18h: Equal \n
+///    0x00 : Equal (ordered, non-signaling)
-///    01h, 09h, 11h, 19h: Less than \n
+///    0x01 : Less-than (ordered, signaling)
-///    02h, 0Ah, 12h, 1Ah: Less than or equal / Greater than or equal
+///    0x02 : Less-than-or-equal (ordered, signaling)
-///                        (swapped operands) \n
+///    0x03 : Unordered (non-signaling)
-///    03h, 0Bh, 13h, 1Bh: Unordered \n
+///    0x04 : Not-equal (unordered, non-signaling)
-///    04h, 0Ch, 14h, 1Ch: Not equal \n
+///    0x05 : Not-less-than (unordered, signaling)
-///    05h, 0Dh, 15h, 1Dh: Not less than / Not greater than
+///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///                        (swapped operands) \n
+///    0x07 : Ordered (non-signaling)
-///    06h, 0Eh, 16h, 1Eh: Not less than or equal / Not greater than or equal
+///    0x08 : Equal (unordered, non-signaling)
-///                        (swapped operands) \n
+///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    07h, 0Fh, 17h, 1Fh: Ordered
+///    0x0a : Not-greater-than (unordered, signaling)
+///    0x0b : False (ordered, non-signaling)
+///    0x0c : Not-equal (ordered, non-signaling)
+///    0x0d : Greater-than-or-equal (ordered, signaling)
+///    0x0e : Greater-than (ordered, signaling)
+///    0x0f : True (unordered, non-signaling)
+///    0x10 : Equal (ordered, signaling)
+///    0x11 : Less-than (ordered, non-signaling)
+///    0x12 : Less-than-or-equal (ordered, non-signaling)
+///    0x13 : Unordered (signaling)
+///    0x14 : Not-equal (unordered, signaling)
+///    0x15 : Not-less-than (unordered, non-signaling)
+///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
+///    0x17 : Ordered (signaling)
+///    0x18 : Equal (unordered, signaling)
+///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
+///    0x1a : Not-greater-than (unordered, non-signaling)
+///    0x1b : False (ordered, signaling)
+///    0x1c : Not-equal (ordered, signaling)
+///    0x1d : Greater-than-or-equal (ordered, non-signaling)
+///    0x1e : Greater-than (ordered, non-signaling)
+///    0x1f : True (unordered, signaling)
 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
 #define _mm_cmp_ss(a, b, c) __extension__ ({ \
   (__m128)__builtin_ia32_cmpss((__v4sf)(__m128)(a), \
 @@ -2184,12 +2325,32 @@ _mm256_cvttps_epi32(__m256 __a)
   return (__m256i)__builtin_ia32_cvttps2dq256((__v8sf) __a);
 }
+/// \brief Returns the first element of the input vector of [4 x double].
+///
+/// \headerfile <avxintrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 64 bit double containing the first element of the input vector.
 static __inline double __DEFAULT_FN_ATTRS
 _mm256_cvtsd_f64(__m256d __a)
 {
  return __a[0];
 }
+/// \brief Returns the first element of the input vector of [8 x i32].
+///
+/// \headerfile <avxintrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \returns A 32 bit integer containing the first element of the input vector.
 static __inline int __DEFAULT_FN_ATTRS
 _mm256_cvtsi256_si32(__m256i __a)
 {
 @@ -2197,6 +2358,16 @@ _mm256_cvtsi256_si32(__m256i __a)
  return __b[0];
 }
+/// \brief Returns the first element of the input vector of [8 x float].
+///
+/// \headerfile <avxintrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 32 bit float containing the first element of the input vector.
 static __inline float __DEFAULT_FN_ATTRS
 _mm256_cvtss_f32(__m256 __a)
 {
 @@ -2380,7 +2551,9 @@ _mm256_unpacklo_ps(__m256 __a, __m256 __b)
 /// \brief Given two 128-bit floating-point vectors of [2 x double], perform an
 ///    element-by-element comparison of the double-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of double-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2407,7 +2580,9 @@ _mm_testz_pd(__m128d __a, __m128d __b)
 /// \brief Given two 128-bit floating-point vectors of [2 x double], perform an
 ///    element-by-element comparison of the double-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of double-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2434,7 +2609,9 @@ _mm_testc_pd(__m128d __a, __m128d __b)
 /// \brief Given two 128-bit floating-point vectors of [2 x double], perform an
 ///    element-by-element comparison of the double-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of double-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2462,7 +2639,9 @@ _mm_testnzc_pd(__m128d __a, __m128d __b)
 /// \brief Given two 128-bit floating-point vectors of [4 x float], perform an
 ///    element-by-element comparison of the single-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of single-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2489,7 +2668,9 @@ _mm_testz_ps(__m128 __a, __m128 __b)
 /// \brief Given two 128-bit floating-point vectors of [4 x float], perform an
 ///    element-by-element comparison of the single-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of single-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2516,7 +2697,9 @@ _mm_testc_ps(__m128 __a, __m128 __b)
 /// \brief Given two 128-bit floating-point vectors of [4 x float], perform an
 ///    element-by-element comparison of the single-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of single-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2544,7 +2727,9 @@ _mm_testnzc_ps(__m128 __a, __m128 __b)
 /// \brief Given two 256-bit floating-point vectors of [4 x double], perform an
 ///    element-by-element comparison of the double-precision elements in the
 ///    first source vector and the corresponding elements in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of double-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2571,7 +2756,9 @@ _mm256_testz_pd(__m256d __a, __m256d __b)
 /// \brief Given two 256-bit floating-point vectors of [4 x double], perform an
 ///    element-by-element comparison of the double-precision elements in the
 ///    first source vector and the corresponding elements in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of double-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2598,7 +2785,9 @@ _mm256_testc_pd(__m256d __a, __m256d __b)
 /// \brief Given two 256-bit floating-point vectors of [4 x double], perform an
 ///    element-by-element comparison of the double-precision elements in the
 ///    first source vector and the corresponding elements in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of double-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2626,7 +2815,9 @@ _mm256_testnzc_pd(__m256d __a, __m256d __b)
 /// \brief Given two 256-bit floating-point vectors of [8 x float], perform an
 ///    element-by-element comparison of the single-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of single-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2653,7 +2844,9 @@ _mm256_testz_ps(__m256 __a, __m256 __b)
 /// \brief Given two 256-bit floating-point vectors of [8 x float], perform an
 ///    element-by-element comparison of the single-precision element in the
 ///    first source vector and the corresponding element in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of single-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2680,7 +2873,9 @@ _mm256_testc_ps(__m256 __a, __m256 __b)
 /// \brief Given two 256-bit floating-point vectors of [8 x float], perform an
 ///    element-by-element comparison of the single-precision elements in the
 ///    first source vector and the corresponding elements in the second source
-///    vector. The EFLAGS register is updated as follows: \n
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of single-precision elements where the
 ///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
 ///    ZF flag is set to 1. \n
 @@ -2706,7 +2901,9 @@ _mm256_testnzc_ps(__m256 __a, __m256 __b)
 }
 /// \brief Given two 256-bit integer vectors, perform a bit-by-bit comparison
-///    of the two source vectors and update the EFLAGS register as follows: \n
+///    of the two source vectors.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of bits where both bits are 1, the ZF flag
 ///    is set to 0. Otherwise the ZF flag is set to 1. \n
 ///    If there is at least one pair of bits where the bit from the first source
 @@ -2730,7 +2927,9 @@ _mm256_testz_si256(__m256i __a, __m256i __b)
 }
 /// \brief Given two 256-bit integer vectors, perform a bit-by-bit comparison
-///    of the two source vectors and update the EFLAGS register as follows: \n
+///    of the two source vectors.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of bits where both bits are 1, the ZF flag
 ///    is set to 0. Otherwise the ZF flag is set to 1. \n
 ///    If there is at least one pair of bits where the bit from the first source
 @@ -2754,7 +2953,9 @@ _mm256_testc_si256(__m256i __a, __m256i __b)
 }
 /// \brief Given two 256-bit integer vectors, perform a bit-by-bit comparison
-///    of the two source vectors and update the EFLAGS register as follows: \n
+///    of the two source vectors.
+///
+///    The EFLAGS register is updated as follows: \n
 ///    If there is at least one pair of bits where both bits are 1, the ZF flag
 ///    is set to 0. Otherwise the ZF flag is set to 1. \n
 ///    If there is at least one pair of bits where the bit from the first source
 @@ -3389,7 +3590,8 @@ _mm_maskstore_ps(float *__p, __m128i __m, __m128 __a)
 static __inline void __DEFAULT_FN_ATTRS
 _mm256_stream_si256(__m256i *__a, __m256i __b)
 {
-  __builtin_nontemporal_store((__v4di)__b, (__v4di*)__a);
+  typedef __v4di __v4di_aligned __attribute__((aligned(32)));
+  __builtin_nontemporal_store((__v4di_aligned)__b, (__v4di_aligned*)__a);
 }
 /// \brief Moves double-precision values from a 256-bit vector of [4 x double]
 @@ -3402,13 +3604,14 @@ _mm256_stream_si256(__m256i *__a, __m256i __b)
 ///
 /// \param __a
 ///    A pointer to a 32-byte aligned memory location that will receive the
-///    integer values.
+///    double-precision floating-point values.
 /// \param __b
 ///    A 256-bit vector of [4 x double] containing the values to be moved.
 static __inline void __DEFAULT_FN_ATTRS
 _mm256_stream_pd(double *__a, __m256d __b)
 {
-  __builtin_nontemporal_store((__v4df)__b, (__v4df*)__a);
+  typedef __v4df __v4df_aligned __attribute__((aligned(32)));
+  __builtin_nontemporal_store((__v4df_aligned)__b, (__v4df_aligned*)__a);
 }
 /// \brief Moves single-precision floating point values from a 256-bit vector
 @@ -3428,7 +3631,8 @@ _mm256_stream_pd(double *__a, __m256d __b)
 static __inline void __DEFAULT_FN_ATTRS
 _mm256_stream_ps(float *__p, __m256 __a)
 {
-  __builtin_nontemporal_store((__v8sf)__a, (__v8sf*)__p);
+  typedef __v8sf __v8sf_aligned __attribute__((aligned(32)));
+  __builtin_nontemporal_store((__v8sf_aligned)__a, (__v8sf_aligned*)__p);
 }
 /* Create vectors */
 @@ -4310,9 +4514,10 @@ _mm256_castsi256_si128(__m256i __a)
 }
 /// \brief Constructs a 256-bit floating-point vector of [4 x double] from a
-///    128-bit floating-point vector of [2 x double]. The lower 128 bits
+///    128-bit floating-point vector of [2 x double].
-///    contain the value of the source vector. The contents of the upper 128
+///
-///    bits are undefined.
+///    The lower 128 bits contain the value of the source vector. The contents
+///    of the upper 128 bits are undefined.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -4330,9 +4535,10 @@ _mm256_castpd128_pd256(__m128d __a)
 }
 /// \brief Constructs a 256-bit floating-point vector of [8 x float] from a
-///    128-bit floating-point vector of [4 x float]. The lower 128 bits contain
+///    128-bit floating-point vector of [4 x float].
-///    the value of the source vector. The contents of the upper 128 bits are
+///
-///    undefined.
+///    The lower 128 bits contain the value of the source vector. The contents
+///    of the upper 128 bits are undefined.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -4350,6 +4556,7 @@ _mm256_castps128_ps256(__m128 __a)
 }
 /// \brief Constructs a 256-bit integer vector from a 128-bit integer vector.
+///
 ///    The lower 128 bits contain the value of the source vector. The contents
 ///    of the upper 128 bits are undefined.
 ///
 @@ -4367,6 +4574,61 @@ _mm256_castsi128_si256(__m128i __a)
   return __builtin_shufflevector((__v2di)__a, (__v2di)__a, 0, 1, -1, -1);
 }
+/// \brief Constructs a 256-bit floating-point vector of [4 x double] from a
+///    128-bit floating-point vector of [2 x double]. The lower 128 bits
+///    contain the value of the source vector. The upper 128 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 256-bit floating-point vector of [4 x double]. The lower 128 bits
+///    contain the value of the parameter. The upper 128 bits are set to zero.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_zextpd128_pd256(__m128d __a)
+{
+  return __builtin_shufflevector((__v2df)__a, (__v2df)_mm_setzero_pd(), 0, 1, 2, 3);
+}
+/// \brief Constructs a 256-bit floating-point vector of [8 x float] from a
+///    128-bit floating-point vector of [4 x float]. The lower 128 bits contain
+///    the value of the source vector. The upper 128 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 256-bit floating-point vector of [8 x float]. The lower 128 bits
+///    contain the value of the parameter. The upper 128 bits are set to zero.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_zextps128_ps256(__m128 __a)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)_mm_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7);
+}
+/// \brief Constructs a 256-bit integer vector from a 128-bit integer vector.
+///    The lower 128 bits contain the value of the source vector. The upper
+///    128 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 256-bit integer vector. The lower 128 bits contain the value of
+///    the parameter. The upper 128 bits are set to zero.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_zextsi128_si256(__m128i __a)
+{
+  return __builtin_shufflevector((__v2di)__a, (__v2di)_mm_setzero_si128(), 0, 1, 2, 3);
+}
 /*
    Vector insert.
    We use macros rather than inlines because we only want to accept
 @@ -4375,8 +4637,10 @@ _mm256_castsi128_si256(__m128i __a)
 /// \brief Constructs a new 256-bit vector of [8 x float] by first duplicating
 ///    a 256-bit vector of [8 x float] given in the first parameter, and then
 ///    replacing either the upper or the lower 128 bits with the contents of a
-///    128-bit vector of [4 x float] in the second parameter. The immediate
+///    128-bit vector of [4 x float] in the second parameter.
-///    integer parameter determines between the upper or the lower 128 bits.
+///
+///    The immediate integer parameter determines between the upper or the lower
+///    128 bits.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -4420,8 +4684,10 @@ _mm256_castsi128_si256(__m128i __a)
 /// \brief Constructs a new 256-bit vector of [4 x double] by first duplicating
 ///    a 256-bit vector of [4 x double] given in the first parameter, and then
 ///    replacing either the upper or the lower 128 bits with the contents of a
-///    128-bit vector of [2 x double] in the second parameter. The immediate
+///    128-bit vector of [2 x double] in the second parameter.
-///    integer parameter determines between the upper or the lower 128 bits.
+///
+///    The immediate integer parameter determines between the upper or the lower
+///    128 bits.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -4461,8 +4727,10 @@ _mm256_castsi128_si256(__m128i __a)
 /// \brief Constructs a new 256-bit integer vector by first duplicating a
 ///    256-bit integer vector given in the first parameter, and then replacing
 ///    either the upper or the lower 128 bits with the contents of a 128-bit
-///    integer vector in the second parameter. The immediate integer parameter
+///    integer vector in the second parameter.
-///    determines between the upper or the lower 128 bits.
+///
+///    The immediate integer parameter determines between the upper or the lower
+///    128 bits.
 ///
 /// \headerfile <x86intrin.h>
 ///

c_headers/bmiintrin.h+5-171

...	@@ -28,107 +28,17 @@	...	@@ -28,107 +28,17 @@
28	#ifndef __BMIINTRIN_H	28	#ifndef __BMIINTRIN_H
29	#define __BMIINTRIN_H	29	#define __BMIINTRIN_H
30		30
31	/// \brief Counts the number of trailing zero bits in the operand.
32	///
33	/// \headerfile <x86intrin.h>
34	///
35	/// \code
36	/// unsigned short _tzcnt_u16(unsigned short a);
37	/// \endcode
38	///
39	/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
40	///
41	/// \param a
42	/// An unsigned 16-bit integer whose trailing zeros are to be counted.
43	/// \returns An unsigned 16-bit integer containing the number of trailing zero
44	/// bits in the operand.
45	#define _tzcnt_u16(a) (__tzcnt_u16((a)))	31	#define _tzcnt_u16(a) (__tzcnt_u16((a)))
46		32
47	/// \brief Performs a bitwise AND of the second operand with the one's
48	/// complement of the first operand.
49	///
50	/// \headerfile <x86intrin.h>
51	///
52	/// \code
53	/// unsigned int _andn_u32(unsigned int a, unsigned int b);
54	/// \endcode
55	///
56	/// This intrinsic corresponds to the <c> ANDN </c> instruction.
57	///
58	/// \param a
59	/// An unsigned integer containing one of the operands.
60	/// \param b
61	/// An unsigned integer containing one of the operands.
62	/// \returns An unsigned integer containing the bitwise AND of the second
63	/// operand with the one's complement of the first operand.
64	#define _andn_u32(a, b) (__andn_u32((a), (b)))	33	#define _andn_u32(a, b) (__andn_u32((a), (b)))
65		34
66	/* _bextr_u32 != __bextr_u32 */	35	/* _bextr_u32 != __bextr_u32 */
67	/// \brief Clears all bits in the source except for the least significant bit
68	/// containing a value of 1 and returns the result.
69	///
70	/// \headerfile <x86intrin.h>
71	///
72	/// \code
73	/// unsigned int _blsi_u32(unsigned int a);
74	/// \endcode
75	///
76	/// This intrinsic corresponds to the <c> BLSI </c> instruction.
77	///
78	/// \param a
79	/// An unsigned integer whose bits are to be cleared.
80	/// \returns An unsigned integer containing the result of clearing the bits from
81	/// the source operand.
82	#define _blsi_u32(a) (__blsi_u32((a)))	36	#define _blsi_u32(a) (__blsi_u32((a)))
83		37
84	/// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
85	/// including the least siginificant bit that is set to 1 in the source
86	/// operand and returns the result.
87	///
88	/// \headerfile <x86intrin.h>
89	///
90	/// \code
91	/// unsigned int _blsmsk_u32(unsigned int a);
92	/// \endcode
93	///
94	/// This intrinsic corresponds to the <c> BLSMSK </c> instruction.
95	///
96	/// \param a
97	/// An unsigned integer used to create the mask.
98	/// \returns An unsigned integer containing the newly created mask.
99	#define _blsmsk_u32(a) (__blsmsk_u32((a)))	38	#define _blsmsk_u32(a) (__blsmsk_u32((a)))
100		39
101	/// \brief Clears the least siginificant bit that is set to 1 in the source
102	/// operand and returns the result.
103	///
104	/// \headerfile <x86intrin.h>
105	///
106	/// \code
107	/// unsigned int _blsr_u32(unsigned int a);
108	/// \endcode
109	///
110	/// This intrinsic corresponds to the <c> BLSR </c> instruction.
111	///
112	/// \param a
113	/// An unsigned integer containing the operand to be cleared.
114	/// \returns An unsigned integer containing the result of clearing the source
115	/// operand.
116	#define _blsr_u32(a) (__blsr_u32((a)))	40	#define _blsr_u32(a) (__blsr_u32((a)))
117		41
118	/// \brief Counts the number of trailing zero bits in the operand.
119	///
120	/// \headerfile <x86intrin.h>
121	///
122	/// \code
123	/// unsigned int _tzcnt_u32(unsigned int a);
124	/// \endcode
125	///
126	/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
127	///
128	/// \param a
129	/// An unsigned 32-bit integer whose trailing zeros are to be counted.
130	/// \returns An unsigned 32-bit integer containing the number of trailing zero
131	/// bits in the operand.
132	#define _tzcnt_u32(a) (__tzcnt_u32((a)))	42	#define _tzcnt_u32(a) (__tzcnt_u32((a)))
133		43
134	/* Define the default attributes for the functions in this file. */	44	/* Define the default attributes for the functions in this file. */
...	@@ -238,7 +148,7 @@ __blsi_u32(unsigned int __X)	...	@@ -238,7 +148,7 @@ __blsi_u32(unsigned int __X)
238	}	148	}
239		149
240	/// \brief Creates a mask whose bits are set to 1, using bit 0 up to and	150	/// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
241	/// including the least siginificant bit that is set to 1 in the source	151	/// including the least significant bit that is set to 1 in the source
242	/// operand and returns the result.	152	/// operand and returns the result.
243	///	153	///
244	/// \headerfile <x86intrin.h>	154	/// \headerfile <x86intrin.h>
...	@@ -254,7 +164,7 @@ __blsmsk_u32(unsigned int __X)	...	@@ -254,7 +164,7 @@ __blsmsk_u32(unsigned int __X)
254	return __X ^ (__X - 1);	164	return __X ^ (__X - 1);
255	}	165	}
256		166
257	/// \brief Clears the least siginificant bit that is set to 1 in the source	167	/// \brief Clears the least significant bit that is set to 1 in the source
258	/// operand and returns the result.	168	/// operand and returns the result.
259	///	169	///
260	/// \headerfile <x86intrin.h>	170	/// \headerfile <x86intrin.h>
...	@@ -305,91 +215,15 @@ _mm_tzcnt_32(unsigned int __X)	...	@@ -305,91 +215,15 @@ _mm_tzcnt_32(unsigned int __X)
305		215
306	#ifdef __x86_64__	216	#ifdef __x86_64__
307		217
308	/// \brief Performs a bitwise AND of the second operand with the one's
309	/// complement of the first operand.
310	///
311	/// \headerfile <x86intrin.h>
312	///
313	/// \code
314	/// unsigned long long _andn_u64 (unsigned long long a, unsigned long long b);
315	/// \endcode
316	///
317	/// This intrinsic corresponds to the <c> ANDN </c> instruction.
318	///
319	/// \param a
320	/// An unsigned 64-bit integer containing one of the operands.
321	/// \param b
322	/// An unsigned 64-bit integer containing one of the operands.
323	/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
324	/// operand with the one's complement of the first operand.
325	#define _andn_u64(a, b) (__andn_u64((a), (b)))	218	#define _andn_u64(a, b) (__andn_u64((a), (b)))
326		219
327	/* _bextr_u64 != __bextr_u64 */	220	/* _bextr_u64 != __bextr_u64 */
328	/// \brief Clears all bits in the source except for the least significant bit
329	/// containing a value of 1 and returns the result.
330	///
331	/// \headerfile <x86intrin.h>
332	///
333	/// \code
334	/// unsigned long long _blsi_u64(unsigned long long a);
335	/// \endcode
336	///
337	/// This intrinsic corresponds to the <c> BLSI </c> instruction.
338	///
339	/// \param a
340	/// An unsigned 64-bit integer whose bits are to be cleared.
341	/// \returns An unsigned 64-bit integer containing the result of clearing the
342	/// bits from the source operand.
343	#define _blsi_u64(a) (__blsi_u64((a)))	221	#define _blsi_u64(a) (__blsi_u64((a)))
344		222
345	/// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
346	/// including the least siginificant bit that is set to 1 in the source
347	/// operand and returns the result.
348	///
349	/// \headerfile <x86intrin.h>
350	///
351	/// \code
352	/// unsigned long long _blsmsk_u64(unsigned long long a);
353	/// \endcode
354	///
355	/// This intrinsic corresponds to the <c> BLSMSK </c> instruction.
356	///
357	/// \param a
358	/// An unsigned 64-bit integer used to create the mask.
359	/// \returns A unsigned 64-bit integer containing the newly created mask.
360	#define _blsmsk_u64(a) (__blsmsk_u64((a)))	223	#define _blsmsk_u64(a) (__blsmsk_u64((a)))
361		224
362	/// \brief Clears the least siginificant bit that is set to 1 in the source
363	/// operand and returns the result.
364	///
365	/// \headerfile <x86intrin.h>
366	///
367	/// \code
368	/// unsigned long long _blsr_u64(unsigned long long a);
369	/// \endcode
370	///
371	/// This intrinsic corresponds to the <c> BLSR </c> instruction.
372	///
373	/// \param a
374	/// An unsigned 64-bit integer containing the operand to be cleared.
375	/// \returns An unsigned 64-bit integer containing the result of clearing the
376	/// source operand.
377	#define _blsr_u64(a) (__blsr_u64((a)))	225	#define _blsr_u64(a) (__blsr_u64((a)))
378		226
379	/// \brief Counts the number of trailing zero bits in the operand.
380	///
381	/// \headerfile <x86intrin.h>
382	///
383	/// \code
384	/// unsigned long long _tzcnt_u64(unsigned long long a);
385	/// \endcode
386	///
387	/// This intrinsic corresponds to the <c> TZCNT </c> instruction.
388	///
389	/// \param a
390	/// An unsigned 64-bit integer whose trailing zeros are to be counted.
391	/// \returns An unsigned 64-bit integer containing the number of trailing zero
392	/// bits in the operand.
393	#define _tzcnt_u64(a) (__tzcnt_u64((a)))	227	#define _tzcnt_u64(a) (__tzcnt_u64((a)))
394		228
395	/// \brief Performs a bitwise AND of the second operand with the one's	229	/// \brief Performs a bitwise AND of the second operand with the one's
...	@@ -475,7 +309,7 @@ __blsi_u64(unsigned long long __X)	...	@@ -475,7 +309,7 @@ __blsi_u64(unsigned long long __X)
475	}	309	}
476		310
477	/// \brief Creates a mask whose bits are set to 1, using bit 0 up to and	311	/// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
478	/// including the least siginificant bit that is set to 1 in the source	312	/// including the least significant bit that is set to 1 in the source
479	/// operand and returns the result.	313	/// operand and returns the result.
480	///	314	///
481	/// \headerfile <x86intrin.h>	315	/// \headerfile <x86intrin.h>
...	@@ -484,14 +318,14 @@ __blsi_u64(unsigned long long __X)	...	@@ -484,14 +318,14 @@ __blsi_u64(unsigned long long __X)
484	///	318	///
485	/// \param __X	319	/// \param __X
486	/// An unsigned 64-bit integer used to create the mask.	320	/// An unsigned 64-bit integer used to create the mask.
487	/// \returns A unsigned 64-bit integer containing the newly created mask.	321	/// \returns An unsigned 64-bit integer containing the newly created mask.
488	static __inline__ unsigned long long __DEFAULT_FN_ATTRS	322	static __inline__ unsigned long long __DEFAULT_FN_ATTRS
489	__blsmsk_u64(unsigned long long __X)	323	__blsmsk_u64(unsigned long long __X)
490	{	324	{
491	return __X ^ (__X - 1);	325	return __X ^ (__X - 1);
492	}	326	}
493		327
494	/// \brief Clears the least siginificant bit that is set to 1 in the source	328	/// \brief Clears the least significant bit that is set to 1 in the source
495	/// operand and returns the result.	329	/// operand and returns the result.
496	///	330	///
497	/// \headerfile <x86intrin.h>	331	/// \headerfile <x86intrin.h>

c_headers/clzerointrin.h created+50

...	@@ -0,0 +1,50 @@
1	/*===----------------------- clzerointrin.h - CLZERO ----------------------===
2	*
3	* Permission is hereby granted, free of charge, to any person obtaining a copy
4	* of this software and associated documentation files (the "Software"), to deal
5	* in the Software without restriction, including without limitation the rights
6	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7	* copies of the Software, and to permit persons to whom the Software is
8	* furnished to do so, subject to the following conditions:
9	*
10	* The above copyright notice and this permission notice shall be included in
11	* all copies or substantial portions of the Software.
12	*
13	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19	* THE SOFTWARE.
20	*
21	*===-----------------------------------------------------------------------===
22	*/
23	#ifndef __X86INTRIN_H
24	#error "Never use <clzerointrin.h> directly; include <x86intrin.h> instead."
25	#endif
26
27	#ifndef _CLZEROINTRIN_H
28	#define _CLZEROINTRIN_H
29
30	/* Define the default attributes for the functions in this file. */
31	#define __DEFAULT_FN_ATTRS \
32	__attribute__((__always_inline__, __nodebug__, __target__("clzero")))
33
34	/// \brief Loads the cache line address and zero's out the cacheline
35	///
36	/// \headerfile <clzerointrin.h>
37	///
38	/// This intrinsic corresponds to the <c> CLZERO </c> instruction.
39	///
40	/// \param __line
41	/// A pointer to a cacheline which needs to be zeroed out.
42	static __inline__ void __DEFAULT_FN_ATTRS
43	_mm_clzero (void * __line)
44	{
45	__builtin_ia32_clzero ((void *)__line);
46	}
47
48	#undef __DEFAULT_FN_ATTRS
49
50	#endif /* _CLZEROINTRIN_H */

c_headers/cpuid.h+98-20

...	@@ -79,7 +79,7 @@	...	@@ -79,7 +79,7 @@
79	#define signature_VORTEX_edx 0x36387865	79	#define signature_VORTEX_edx 0x36387865
80	#define signature_VORTEX_ecx 0x436f5320	80	#define signature_VORTEX_ecx 0x436f5320
81		81
82	/* Features in %ecx for level 1 */	82	/* Features in %ecx for leaf 1 */
83	#define bit_SSE3 0x00000001	83	#define bit_SSE3 0x00000001
84	#define bit_PCLMULQDQ 0x00000002	84	#define bit_PCLMULQDQ 0x00000002
85	#define bit_PCLMUL bit_PCLMULQDQ /* for gcc compat */	85	#define bit_PCLMUL bit_PCLMULQDQ /* for gcc compat */
...	@@ -114,7 +114,7 @@	...	@@ -114,7 +114,7 @@
114	#define bit_F16C 0x20000000	114	#define bit_F16C 0x20000000
115	#define bit_RDRND 0x40000000	115	#define bit_RDRND 0x40000000
116		116
117	/* Features in %edx for level 1 */	117	/* Features in %edx for leaf 1 */
118	#define bit_FPU 0x00000001	118	#define bit_FPU 0x00000001
119	#define bit_VME 0x00000002	119	#define bit_VME 0x00000002
120	#define bit_DE 0x00000004	120	#define bit_DE 0x00000004
...	@@ -147,44 +147,95 @@	...	@@ -147,44 +147,95 @@
147	#define bit_TM 0x20000000	147	#define bit_TM 0x20000000
148	#define bit_PBE 0x80000000	148	#define bit_PBE 0x80000000
149		149
150	/* Features in %ebx for level 7 sub-leaf 0 */	150	/* Features in %ebx for leaf 7 sub-leaf 0 */
151	#define bit_FSGSBASE 0x00000001	151	#define bit_FSGSBASE 0x00000001
		152	#define bit_SGX 0x00000004
		153	#define bit_BMI 0x00000008
		154	#define bit_HLE 0x00000010
		155	#define bit_AVX2 0x00000020
152	#define bit_SMEP 0x00000080	156	#define bit_SMEP 0x00000080
		157	#define bit_BMI2 0x00000100
153	#define bit_ENH_MOVSB 0x00000200	158	#define bit_ENH_MOVSB 0x00000200
		159	#define bit_RTM 0x00000800
		160	#define bit_MPX 0x00004000
		161	#define bit_AVX512F 0x00010000
		162	#define bit_AVX512DQ 0x00020000
		163	#define bit_RDSEED 0x00040000
		164	#define bit_ADX 0x00080000
		165	#define bit_AVX512IFMA 0x00200000
		166	#define bit_CLFLUSHOPT 0x00800000
		167	#define bit_CLWB 0x01000000
		168	#define bit_AVX512PF 0x04000000
		169	#define bit_AVX51SER 0x08000000
		170	#define bit_AVX512CD 0x10000000
		171	#define bit_SHA 0x20000000
		172	#define bit_AVX512BW 0x40000000
		173	#define bit_AVX512VL 0x80000000
		174
		175	/* Features in %ecx for leaf 7 sub-leaf 0 */
		176	#define bit_PREFTCHWT1 0x00000001
		177	#define bit_AVX512VBMI 0x00000002
		178	#define bit_PKU 0x00000004
		179	#define bit_OSPKE 0x00000010
		180	#define bit_AVX512VPOPCNTDQ 0x00004000
		181	#define bit_RDPID 0x00400000
		182
		183	/* Features in %edx for leaf 7 sub-leaf 0 */
		184	#define bit_AVX5124VNNIW 0x00000004
		185	#define bit_AVX5124FMAPS 0x00000008
		186
		187	/* Features in %eax for leaf 13 sub-leaf 1 */
		188	#define bit_XSAVEOPT 0x00000001
		189	#define bit_XSAVEC 0x00000002
		190	#define bit_XSAVES 0x00000008
		191
		192	/* Features in %ecx for leaf 0x80000001 */
		193	#define bit_LAHF_LM 0x00000001
		194	#define bit_ABM 0x00000020
		195	#define bit_SSE4a 0x00000040
		196	#define bit_PRFCHW 0x00000100
		197	#define bit_XOP 0x00000800
		198	#define bit_LWP 0x00008000
		199	#define bit_FMA4 0x00010000
		200	#define bit_TBM 0x00200000
		201	#define bit_MWAITX 0x20000000
		202
		203	/* Features in %edx for leaf 0x80000001 */
		204	#define bit_MMXEXT 0x00400000
		205	#define bit_LM 0x20000000
		206	#define bit_3DNOWP 0x40000000
		207	#define bit_3DNOW 0x80000000
		208
		209	/* Features in %ebx for leaf 0x80000001 */
		210	#define bit_CLZERO 0x00000001
		211
154		212
155	#if __i386__	213	#if __i386__
156	#define __cpuid(__level, __eax, __ebx, __ecx, __edx) \	214	#define __cpuid(__leaf, __eax, __ebx, __ecx, __edx) \
157	__asm("cpuid" : "=a"(__eax), "=b" (__ebx), "=c"(__ecx), "=d"(__edx) \	215	__asm("cpuid" : "=a"(__eax), "=b" (__ebx), "=c"(__ecx), "=d"(__edx) \
158	: "0"(__level))	216	: "0"(__leaf))
159		217
160	#define __cpuid_count(__level, __count, __eax, __ebx, __ecx, __edx) \	218	#define __cpuid_count(__leaf, __count, __eax, __ebx, __ecx, __edx) \
161	__asm("cpuid" : "=a"(__eax), "=b" (__ebx), "=c"(__ecx), "=d"(__edx) \	219	__asm("cpuid" : "=a"(__eax), "=b" (__ebx), "=c"(__ecx), "=d"(__edx) \
162	: "0"(__level), "2"(__count))	220	: "0"(__leaf), "2"(__count))
163	#else	221	#else
164	/* x86-64 uses %rbx as the base register, so preserve it. */	222	/* x86-64 uses %rbx as the base register, so preserve it. */
165	#define __cpuid(__level, __eax, __ebx, __ecx, __edx) \	223	#define __cpuid(__leaf, __eax, __ebx, __ecx, __edx) \
166	__asm(" xchgq %%rbx,%q1\n" \	224	__asm(" xchgq %%rbx,%q1\n" \
167	" cpuid\n" \	225	" cpuid\n" \
168	" xchgq %%rbx,%q1" \	226	" xchgq %%rbx,%q1" \
169	: "=a"(__eax), "=r" (__ebx), "=c"(__ecx), "=d"(__edx) \	227	: "=a"(__eax), "=r" (__ebx), "=c"(__ecx), "=d"(__edx) \
170	: "0"(__level))	228	: "0"(__leaf))
171		229
172	#define __cpuid_count(__level, __count, __eax, __ebx, __ecx, __edx) \	230	#define __cpuid_count(__leaf, __count, __eax, __ebx, __ecx, __edx) \
173	__asm(" xchgq %%rbx,%q1\n" \	231	__asm(" xchgq %%rbx,%q1\n" \
174	" cpuid\n" \	232	" cpuid\n" \
175	" xchgq %%rbx,%q1" \	233	" xchgq %%rbx,%q1" \
176	: "=a"(__eax), "=r" (__ebx), "=c"(__ecx), "=d"(__edx) \	234	: "=a"(__eax), "=r" (__ebx), "=c"(__ecx), "=d"(__edx) \
177	: "0"(__level), "2"(__count))	235	: "0"(__leaf), "2"(__count))
178	#endif	236	#endif
179		237
180	static __inline int __get_cpuid (unsigned int __level, unsigned int *__eax,	238	static __inline int __get_cpuid_max (unsigned int __leaf, unsigned int *__sig)
181	unsigned int __ebx, unsigned int __ecx,
182	unsigned int *__edx) {
183	__cpuid(__level, __eax, __ebx, __ecx, __edx);
184	return 1;
185	}
186
187	static __inline int __get_cpuid_max (unsigned int __level, unsigned int *__sig)
188	{	239	{
189	unsigned int __eax, __ebx, __ecx, __edx;	240	unsigned int __eax, __ebx, __ecx, __edx;
190	#if __i386__	241	#if __i386__
...	@@ -208,8 +259,35 @@ static __inline int __get_cpuid_max (unsigned int __level, unsigned int *__sig)	...	@@ -208,8 +259,35 @@ static __inline int __get_cpuid_max (unsigned int __level, unsigned int *__sig)
208	return 0;	259	return 0;
209	#endif	260	#endif
210		261
211	__cpuid(__level, __eax, __ebx, __ecx, __edx);	262	__cpuid(__leaf, __eax, __ebx, __ecx, __edx);
212	if (__sig)	263	if (__sig)
213	*__sig = __ebx;	264	*__sig = __ebx;
214	return __eax;	265	return __eax;
215	}	266	}
		267
		268	static __inline int __get_cpuid (unsigned int __leaf, unsigned int *__eax,
		269	unsigned int __ebx, unsigned int __ecx,
		270	unsigned int *__edx)
		271	{
		272	unsigned int __max_leaf = __get_cpuid_max(__leaf & 0x80000000, 0);
		273
		274	if (__max_leaf == 0 \|\| __max_leaf < __leaf)
		275	return 0;
		276
		277	__cpuid(__leaf, __eax, __ebx, __ecx, __edx);
		278	return 1;
		279	}
		280
		281	static __inline int __get_cpuid_count (unsigned int __leaf,
		282	unsigned int __subleaf,
		283	unsigned int __eax, unsigned int __ebx,
		284	unsigned int __ecx, unsigned int __edx)
		285	{
		286	unsigned int __max_leaf = __get_cpuid_max(__leaf & 0x80000000, 0);
		287
		288	if (__max_leaf == 0 \|\| __max_leaf < __leaf)
		289	return 0;
		290
		291	__cpuid_count(__leaf, __subleaf, __eax, __ebx, __ecx, __edx);
		292	return 1;
		293	}

c_headers/emmintrin.h+251-114

 @@ -302,7 +302,7 @@ _mm_min_pd(__m128d __a, __m128d __b)
   return __builtin_ia32_minpd((__v2df)__a, (__v2df)__b);
 }
-/// \brief Compares lower 64-bits double-precision values of both operands, and
+/// \brief Compares lower 64-bit double-precision values of both operands, and
 ///    returns the greater of the pair of values in the lower 64-bits of the
 ///    result. The upper 64 bits of the result are copied from the upper double-
 ///    precision value of the first operand.
 @@ -462,8 +462,9 @@ _mm_cmplt_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are less than or equal to those in the second operand. Each
+///    operand are less than or equal to those in the second operand.
-///    comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -482,8 +483,9 @@ _mm_cmple_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are greater than those in the second operand. Each comparison
+///    operand are greater than those in the second operand.
-///    yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -502,8 +504,9 @@ _mm_cmpgt_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are greater than or equal to those in the second operand. Each
+///    operand are greater than or equal to those in the second operand.
-///    comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -522,9 +525,10 @@ _mm_cmpge_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are ordered with respect to those in the second operand. A pair
+///    operand are ordered with respect to those in the second operand.
-///    of double-precision values are "ordered" with respect to each other if
+///
-///    neither value is a NaN. Each comparison yields 0h for false,
+///    A pair of double-precision values are "ordered" with respect to each
+///    other if neither value is a NaN. Each comparison yields 0h for false,
 ///    FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 @@ -544,9 +548,10 @@ _mm_cmpord_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are unordered with respect to those in the second operand. A pair
+///    operand are unordered with respect to those in the second operand.
-///    of double-precision values are "unordered" with respect to each other if
+///
-///    one or both values are NaN. Each comparison yields 0h for false,
+///    A pair of double-precision values are "unordered" with respect to each
+///    other if one or both values are NaN. Each comparison yields 0h for false,
 ///    FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 @@ -567,8 +572,9 @@ _mm_cmpunord_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are unequal to those in the second operand. Each comparison
+///    operand are unequal to those in the second operand.
-///    yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -587,8 +593,9 @@ _mm_cmpneq_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are not less than those in the second operand. Each comparison
+///    operand are not less than those in the second operand.
-///    yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -607,8 +614,9 @@ _mm_cmpnlt_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are not less than or equal to those in the second operand. Each
+///    operand are not less than or equal to those in the second operand.
-///    comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -627,8 +635,9 @@ _mm_cmpnle_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
-///    operand are not greater than those in the second operand. Each
+///    operand are not greater than those in the second operand.
-///    comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -648,6 +657,7 @@ _mm_cmpngt_pd(__m128d __a, __m128d __b)
 /// \brief Compares each of the corresponding double-precision values of the
 ///    128-bit vectors of [2 x double] to determine if the values in the first
 ///    operand are not greater than or equal to those in the second operand.
+///
 ///    Each comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 @@ -666,8 +676,9 @@ _mm_cmpnge_pd(__m128d __a, __m128d __b)
 }
 /// \brief Compares the lower double-precision floating-point values in each of
-///    the two 128-bit floating-point vectors of [2 x double] for equality. The
+///    the two 128-bit floating-point vectors of [2 x double] for equality.
-///    comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -690,8 +701,9 @@ _mm_cmpeq_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is less than the corresponding value in
-///    the second parameter. The comparison yields 0h for false,
+///    the second parameter.
-///    FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -714,8 +726,9 @@ _mm_cmplt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is less than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0h for
+///    corresponding value in the second parameter.
-///    false, FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -738,8 +751,9 @@ _mm_cmple_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is greater than the corresponding value
-///    in the second parameter. The comparison yields 0h for false,
+///    in the second parameter.
-///    FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -763,8 +777,9 @@ _mm_cmpgt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is greater than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0h for
+///    corresponding value in the second parameter.
-///    false, FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -788,9 +803,11 @@ _mm_cmpge_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is "ordered" with respect to the
-///    corresponding value in the second parameter. The comparison yields 0h for
+///    corresponding value in the second parameter.
-///    false, FFFFFFFFFFFFFFFFh for true. A pair of double-precision values are
+///
-///    "ordered" with respect to each other if neither value is a NaN.
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true. A pair of
+///    double-precision values are "ordered" with respect to each other if
+///    neither value is a NaN.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -813,9 +830,11 @@ _mm_cmpord_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is "unordered" with respect to the
-///    corresponding value in the second parameter. The comparison yields 0h
+///    corresponding value in the second parameter.
-///    for false, FFFFFFFFFFFFFFFFh for true. A pair of double-precision values
+///
-///    are "unordered" with respect to each other if one or both values are NaN.
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true. A pair of
+///    double-precision values are "unordered" with respect to each other if one
+///    or both values are NaN.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -839,8 +858,9 @@ _mm_cmpunord_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is unequal to the corresponding value in
-///    the second parameter. The comparison yields 0h for false,
+///    the second parameter.
-///    FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -863,8 +883,9 @@ _mm_cmpneq_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is not less than the corresponding
-///    value in the second parameter. The comparison yields 0h for false,
+///    value in the second parameter.
-///    FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -887,8 +908,9 @@ _mm_cmpnlt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is not less than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0h
+///    corresponding value in the second parameter.
-///    for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -911,8 +933,9 @@ _mm_cmpnle_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is not greater than the corresponding
-///    value in the second parameter. The comparison yields 0h for false,
+///    value in the second parameter.
-///    FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -936,8 +959,9 @@ _mm_cmpngt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is not greater than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0h
+///    corresponding value in the second parameter.
-///    for false, FFFFFFFFFFFFFFFFh for true.
+///
+///    The comparison yields 0h for false, FFFFFFFFFFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -982,7 +1006,9 @@ _mm_comieq_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is less than the corresponding value in
-///    the second parameter. The comparison yields 0 for false, 1 for true.
+///    the second parameter.
+///
+///    The comparison yields 0 for false, 1 for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1004,8 +1030,9 @@ _mm_comilt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is less than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0 for
+///    corresponding value in the second parameter.
-///    false, 1 for true.
+///
+///    The comparison yields 0 for false, 1 for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1027,7 +1054,9 @@ _mm_comile_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is greater than the corresponding value
-///    in the second parameter. The comparison yields 0 for false, 1 for true.
+///    in the second parameter.
+///
+///    The comparison yields 0 for false, 1 for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1049,8 +1078,9 @@ _mm_comigt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is greater than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0 for
+///    corresponding value in the second parameter.
-///    false, 1 for true.
+///
+///    The comparison yields 0 for false, 1 for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1072,7 +1102,9 @@ _mm_comige_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is unequal to the corresponding value in
-///    the second parameter. The comparison yields 0 for false, 1 for true.
+///    the second parameter.
+///
+///    The comparison yields 0 for false, 1 for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1093,8 +1125,9 @@ _mm_comineq_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] for equality. The
-///    comparison yields 0 for false, 1 for true. If either of the two lower
+///    comparison yields 0 for false, 1 for true.
-///    double-precision values is NaN, 1 is returned.
+///
+///    If either of the two lower double-precision values is NaN, 1 is returned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1117,8 +1150,10 @@ _mm_ucomieq_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is less than the corresponding value in
-///    the second parameter. The comparison yields 0 for false, 1 for true. If
+///    the second parameter.
-///    either of the two lower double-precision values is NaN, 1 is returned.
+///
+///    The comparison yields 0 for false, 1 for true. If either of the two lower
+///    double-precision values is NaN, 1 is returned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1141,9 +1176,10 @@ _mm_ucomilt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is less than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0 for
+///    corresponding value in the second parameter.
-///    false, 1 for true. If either of the two lower double-precision values is
+///
-///    NaN, 1 is returned.
+///    The comparison yields 0 for false, 1 for true. If either of the two lower
+///    double-precision values is NaN, 1 is returned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1166,8 +1202,10 @@ _mm_ucomile_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is greater than the corresponding value
-///    in the second parameter. The comparison yields 0 for false, 1 for true.
+///    in the second parameter.
-///    If either of the two lower double-precision values is NaN, 0 is returned.
+///
+///    The comparison yields 0 for false, 1 for true. If either of the two lower
+///    double-precision values is NaN, 0 is returned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1190,9 +1228,10 @@ _mm_ucomigt_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is greater than or equal to the
-///    corresponding value in the second parameter. The comparison yields 0 for
+///    corresponding value in the second parameter.
-///    false, 1 for true.  If either of the two lower double-precision values
+///
-///    is NaN, 0 is returned.
+///    The comparison yields 0 for false, 1 for true.  If either of the two
+///    lower double-precision values is NaN, 0 is returned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1215,8 +1254,10 @@ _mm_ucomige_sd(__m128d __a, __m128d __b)
 /// \brief Compares the lower double-precision floating-point values in each of
 ///    the two 128-bit floating-point vectors of [2 x double] to determine if
 ///    the value in the first parameter is unequal to the corresponding value in
-///    the second parameter. The comparison yields 0 for false, 1 for true. If
+///    the second parameter.
-///    either of the two lower double-precision values is NaN, 0 is returned.
+///
+///    The comparison yields 0 for false, 1 for true. If either of the two lower
+///    double-precision values is NaN, 0 is returned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1278,8 +1319,9 @@ _mm_cvtps_pd(__m128 __a)
 /// \brief Converts the lower two integer elements of a 128-bit vector of
 ///    [4 x i32] into two double-precision floating-point values, returned in a
-///    128-bit vector of [2 x double]. The upper two elements of the input
+///    128-bit vector of [2 x double].
-///    vector are unused.
+///
+///    The upper two elements of the input vector are unused.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1287,7 +1329,9 @@ _mm_cvtps_pd(__m128 __a)
 ///
 /// \param __a
 ///    A 128-bit integer vector of [4 x i32]. The lower two integer elements are
-///    converted to double-precision values. The upper two elements are unused.
+///    converted to double-precision values.
+///
+///    The upper two elements are unused.
 /// \returns A 128-bit vector of [2 x double] containing the converted values.
 static __inline__ __m128d __DEFAULT_FN_ATTRS
 _mm_cvtepi32_pd(__m128i __a)
 @@ -1409,10 +1453,11 @@ _mm_cvtss_sd(__m128d __a, __m128 __b)
 /// \brief Converts the two double-precision floating-point elements of a
 ///    128-bit vector of [2 x double] into two signed 32-bit integer values,
-///    returned in the lower 64 bits of a 128-bit vector of [4 x i32]. If the
+///    returned in the lower 64 bits of a 128-bit vector of [4 x i32].
-///    result of either conversion is inexact, the result is truncated (rounded
+///
-///    towards zero) regardless of the current MXCSR setting. The upper 64 bits
+///    If the result of either conversion is inexact, the result is truncated
-///    of the result vector are set to zero.
+///    (rounded towards zero) regardless of the current MXCSR setting. The upper
+///    64 bits of the result vector are set to zero.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1466,9 +1511,10 @@ _mm_cvtpd_pi32(__m128d __a)
 /// \brief Converts the two double-precision floating-point elements of a
 ///    128-bit vector of [2 x double] into two signed 32-bit integer values,
-///    returned in a 64-bit vector of [2 x i32]. If the result of either
+///    returned in a 64-bit vector of [2 x i32].
-///    conversion is inexact, the result is truncated (rounded towards zero)
+///
-///    regardless of the current MXCSR setting.
+///    If the result of either conversion is inexact, the result is truncated
+///    (rounded towards zero) regardless of the current MXCSR setting.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1599,6 +1645,17 @@ _mm_loadu_pd(double const *__dp)
   return ((struct __loadu_pd*)__dp)->__v;
 }
+/// \brief Loads a 64-bit integer value to the low element of a 128-bit integer
+///    vector and clears the upper element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction.
+///
+/// \param __a
+///    A pointer to a 64-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns A 128-bit vector of [2 x i64] containing the loaded value.
 static __inline__ __m128i __DEFAULT_FN_ATTRS
 _mm_loadu_si64(void const *__a)
 {
 @@ -1609,6 +1666,17 @@ _mm_loadu_si64(void const *__a)
   return (__m128i){__u, 0L};
 }
+/// \brief Loads a 64-bit double-precision value to the low element of a
+///    128-bit integer vector and clears the upper element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSD / MOVSD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a memory location containing a double-precision value.
+///    The address of the memory location does not have to be aligned.
+/// \returns A 128-bit vector of [2 x double] containing the loaded value.
 static __inline__ __m128d __DEFAULT_FN_ATTRS
 _mm_load_sd(double const *__dp)
 {
 @@ -1728,6 +1796,24 @@ _mm_set1_pd(double __w)
   return (__m128d){ __w, __w };
 }
+/// \brief Constructs a 128-bit floating-point vector of [2 x double], with each
+///    of the two double-precision floating-point vector elements set to the
+///    specified double-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP / MOVLHPS </c> instruction.
+///
+/// \param __w
+///    A double-precision floating-point value used to initialize each vector
+///    element of the result.
+/// \returns An initialized 128-bit floating-point vector of [2 x double].
+static __inline__ __m128d __DEFAULT_FN_ATTRS
+_mm_set_pd1(double __w)
+{
+  return _mm_set1_pd(__w);
+}
 /// \brief Constructs a 128-bit floating-point vector of [2 x double]
 ///    initialized with the specified double-precision floating-point values.
 ///
 @@ -1787,7 +1873,7 @@ _mm_setzero_pd(void)
 /// \brief Constructs a 128-bit floating-point vector of [2 x double]. The lower
 ///    64 bits are set to the lower 64 bits of the second parameter. The upper
 ///    64 bits are set to the upper 64 bits of the first parameter.
-//
+///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VBLENDPD / BLENDPD </c> instruction.
 @@ -1825,12 +1911,38 @@ _mm_store_sd(double *__dp, __m128d __a)
   ((struct __mm_store_sd_struct*)__dp)->__u = __a[0];
 }
+/// \brief Moves packed double-precision values from a 128-bit vector of
+///    [2 x double] to a memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c>VMOVAPD / MOVAPS</c> instruction.
+///
+/// \param __dp
+///    A pointer to an aligned memory location that can store two
+///    double-precision values.
+/// \param __a
+///    A packed 128-bit vector of [2 x double] containing the values to be
+///    moved.
 static __inline__ void __DEFAULT_FN_ATTRS
 _mm_store_pd(double *__dp, __m128d __a)
 {
   *(__m128d*)__dp = __a;
 }
+/// \brief Moves the lower 64 bits of a 128-bit vector of [2 x double] twice to
+///    the upper and lower 64 bits of a memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c>VMOVDDUP + VMOVAPD / MOVLHPS + MOVAPS </c> instruction.
+///
+/// \param __dp
+///    A pointer to a memory location that can store two double-precision
+///    values.
+/// \param __a
+///    A 128-bit vector of [2 x double] whose lower 64 bits are copied to each
+///    of the values in \a dp.
 static __inline__ void __DEFAULT_FN_ATTRS
 _mm_store1_pd(double *__dp, __m128d __a)
 {
 @@ -1940,8 +2052,9 @@ _mm_storel_pd(double *__dp, __m128d __a)
 /// \brief Adds the corresponding elements of two 128-bit vectors of [16 x i8],
 ///    saving the lower 8 bits of each sum in the corresponding element of a
-///    128-bit result vector of [16 x i8]. The integer elements of both
+///    128-bit result vector of [16 x i8].
-///    parameters can be either signed or unsigned.
+///
+///    The integer elements of both parameters can be either signed or unsigned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1961,8 +2074,9 @@ _mm_add_epi8(__m128i __a, __m128i __b)
 /// \brief Adds the corresponding elements of two 128-bit vectors of [8 x i16],
 ///    saving the lower 16 bits of each sum in the corresponding element of a
-///    128-bit result vector of [8 x i16]. The integer elements of both
+///    128-bit result vector of [8 x i16].
-///    parameters can be either signed or unsigned.
+///
+///    The integer elements of both parameters can be either signed or unsigned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -1982,8 +2096,9 @@ _mm_add_epi16(__m128i __a, __m128i __b)
 /// \brief Adds the corresponding elements of two 128-bit vectors of [4 x i32],
 ///    saving the lower 32 bits of each sum in the corresponding element of a
-///    128-bit result vector of [4 x i32]. The integer elements of both
+///    128-bit result vector of [4 x i32].
-///    parameters can be either signed or unsigned.
+///
+///    The integer elements of both parameters can be either signed or unsigned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -2021,8 +2136,9 @@ _mm_add_si64(__m64 __a, __m64 __b)
 /// \brief Adds the corresponding elements of two 128-bit vectors of [2 x i64],
 ///    saving the lower 64 bits of each sum in the corresponding element of a
-///    128-bit result vector of [2 x i64]. The integer elements of both
+///    128-bit result vector of [2 x i64].
-///    parameters can be either signed or unsigned.
+///
+///    The integer elements of both parameters can be either signed or unsigned.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -2168,10 +2284,12 @@ _mm_avg_epu16(__m128i __a, __m128i __b)
 /// \brief Multiplies the corresponding elements of two 128-bit signed [8 x i16]
 ///    vectors, producing eight intermediate 32-bit signed integer products, and
 ///    adds the consecutive pairs of 32-bit products to form a 128-bit signed
-///    [4 x i32] vector. For example, bits [15:0] of both parameters are
+///    [4 x i32] vector.
-///    multiplied producing a 32-bit product, bits [31:16] of both parameters
+///
-///    are multiplied producing a 32-bit product, and the sum of those two
+///    For example, bits [15:0] of both parameters are multiplied producing a
-///    products becomes bits [31:0] of the result.
+///    32-bit product, bits [31:16] of both parameters are multiplied producing
+///    a 32-bit product, and the sum of those two products becomes bits [31:0]
+///    of the result.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -2369,7 +2487,7 @@ _mm_mul_epu32(__m128i __a, __m128i __b)
 /// \brief Computes the absolute differences of corresponding 8-bit integer
 ///    values in two 128-bit vectors. Sums the first 8 absolute differences, and
-///    separately sums the second 8 absolute differences. Packss these two
+///    separately sums the second 8 absolute differences. Packs these two
 ///    unsigned 16-bit integer sums into the upper and lower elements of a
 ///    [2 x i64] vector.
 ///
 @@ -3106,8 +3224,9 @@ _mm_cmpgt_epi8(__m128i __a, __m128i __b)
 /// \brief Compares each of the corresponding signed 16-bit values of the
 ///    128-bit integer vectors to determine if the values in the first operand
-///    are greater than those in the second operand. Each comparison yields 0h
+///    are greater than those in the second operand.
-///    for false, FFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -3126,8 +3245,9 @@ _mm_cmpgt_epi16(__m128i __a, __m128i __b)
 /// \brief Compares each of the corresponding signed 32-bit values of the
 ///    128-bit integer vectors to determine if the values in the first operand
-///    are greater than those in the second operand. Each comparison yields 0h
+///    are greater than those in the second operand.
-///    for false, FFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -3146,8 +3266,9 @@ _mm_cmpgt_epi32(__m128i __a, __m128i __b)
 /// \brief Compares each of the corresponding signed 8-bit values of the 128-bit
 ///    integer vectors to determine if the values in the first operand are less
-///    than those in the second operand. Each comparison yields 0h for false,
+///    than those in the second operand.
-///    FFh for true.
+///
+///    Each comparison yields 0h for false, FFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -3166,8 +3287,9 @@ _mm_cmplt_epi8(__m128i __a, __m128i __b)
 /// \brief Compares each of the corresponding signed 16-bit values of the
 ///    128-bit integer vectors to determine if the values in the first operand
-///    are less than those in the second operand. Each comparison yields 0h for
+///    are less than those in the second operand.
-///    false, FFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -3186,8 +3308,9 @@ _mm_cmplt_epi16(__m128i __a, __m128i __b)
 /// \brief Compares each of the corresponding signed 32-bit values of the
 ///    128-bit integer vectors to determine if the values in the first operand
-///    are less than those in the second operand. Each comparison yields 0h for
+///    are less than those in the second operand.
-///    false, FFFFFFFFh for true.
+///
+///    Each comparison yields 0h for false, FFFFFFFFh for true.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -3885,10 +4008,11 @@ _mm_storeu_si128(__m128i *__p, __m128i __b)
 /// \brief Moves bytes selected by the mask from the first operand to the
 ///    specified unaligned memory location. When a mask bit is 1, the
-///    corresponding byte is written, otherwise it is not written. To minimize
+///    corresponding byte is written, otherwise it is not written.
-///    caching, the date is flagged as non-temporal (unlikely to be used again
+///
-///    soon). Exception and trap behavior for elements not selected for storage
+///    To minimize caching, the date is flagged as non-temporal (unlikely to be
-///    to memory are implementation dependent.
+///    used again soon). Exception and trap behavior for elements not selected
+///    for storage to memory are implementation dependent.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -3932,8 +4056,10 @@ _mm_storel_epi64(__m128i *__p, __m128i __a)
 }
 /// \brief Stores a 128-bit floating point vector of [2 x double] to a 128-bit
-///    aligned memory location. To minimize caching, the data is flagged as
+///    aligned memory location.
-///    non-temporal (unlikely to be used again soon).
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon).
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -3950,6 +4076,7 @@ _mm_stream_pd(double *__p, __m128d __a)
 }
 /// \brief Stores a 128-bit integer vector to a 128-bit aligned memory location.
+///
 ///    To minimize caching, the data is flagged as non-temporal (unlikely to be
 ///    used again soon).
 ///
 @@ -3967,8 +4094,9 @@ _mm_stream_si128(__m128i *__p, __m128i __a)
   __builtin_nontemporal_store((__v2di)__a, (__v2di*)__p);
 }
-/// \brief Stores a 32-bit integer value in the specified memory location. To
+/// \brief Stores a 32-bit integer value in the specified memory location.
-///    minimize caching, the data is flagged as non-temporal (unlikely to be
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
 ///    used again soon).
 ///
 /// \headerfile <x86intrin.h>
 @@ -3986,8 +4114,9 @@ _mm_stream_si32(int *__p, int __a)
 }
 #ifdef __x86_64__
-/// \brief Stores a 64-bit integer value in the specified memory location. To
+/// \brief Stores a 64-bit integer value in the specified memory location.
-///    minimize caching, the data is flagged as non-temporal (unlikely to be
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
 ///    used again soon).
 ///
 /// \headerfile <x86intrin.h>
 @@ -4019,7 +4148,7 @@ extern "C" {
 /// \param __p
 ///    A pointer to the memory location used to identify the cache line to be
 ///    flushed.
-void _mm_clflush(void const *);
+void _mm_clflush(void const * __p);
 /// \brief Forces strong memory ordering (serialization) between load
 ///    instructions preceding this instruction and load instructions following
 @@ -4141,7 +4270,7 @@ _mm_packus_epi16(__m128i __a, __m128i __b)
 /// \param __a
 ///    A 128-bit integer vector.
 /// \param __imm
-///    An immediate value. Bits [3:0] selects values from \a __a to be assigned
+///    An immediate value. Bits [2:0] selects values from \a __a to be assigned
 ///    to bits[15:0] of the result. \n
 ///    000: assign values from bits [15:0] of \a __a. \n
 ///    001: assign values from bits [31:16] of \a __a. \n
 @@ -4788,4 +4917,12 @@ void _mm_pause(void);
 #define _MM_SHUFFLE2(x, y) (((x) << 1) | (y))
+#define _MM_DENORMALS_ZERO_ON   (0x0040)
+#define _MM_DENORMALS_ZERO_OFF  (0x0000)
+#define _MM_DENORMALS_ZERO_MASK (0x0040)
+#define _MM_GET_DENORMALS_ZERO_MODE() (_mm_getcsr() & _MM_DENORMALS_ZERO_MASK)
+#define _MM_SET_DENORMALS_ZERO_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_DENORMALS_ZERO_MASK) | (x)))
 #endif /* __EMMINTRIN_H */

c_headers/f16cintrin.h+5-5

c_headers/float.h+9

...	@@ -33,6 +33,15 @@	...	@@ -33,6 +33,15 @@
33	*/	33	*/
34	#if (defined(__APPLE__) \|\| (defined(__MINGW32__) \|\| defined(_MSC_VER))) && \	34	#if (defined(__APPLE__) \|\| (defined(__MINGW32__) \|\| defined(_MSC_VER))) && \
35	__STDC_HOSTED__ && __has_include_next(<float.h>)	35	__STDC_HOSTED__ && __has_include_next(<float.h>)
		36
		37	/* Prior to Apple's 10.7 SDK, float.h SDK header used to apply an extra level
		38	* of #include_next<float.h> to keep Metrowerks compilers happy. Avoid this
		39	* extra indirection.
		40	*/
		41	#ifdef __APPLE__
		42	#define _FLOAT_H_
		43	#endif
		44
36	# include_next <float.h>	45	# include_next <float.h>
37		46
38	/* Undefine anything that we'll be redefining below. */	47	/* Undefine anything that we'll be redefining below. */

c_headers/htmxlintrin.h+5-9

 @@ -35,14 +35,10 @@
 extern "C" {
 #endif
-#define _TEXASR_PTR(TM_BUF) \
+#define _TEXASR_PTR(TM_BUF) ((texasr_t *)((char *)(TM_BUF) + 0))
-  ((texasr_t *)((TM_BUF)+0))
+#define _TEXASRU_PTR(TM_BUF) ((texasru_t *)((char *)(TM_BUF) + 0))
-#define _TEXASRU_PTR(TM_BUF) \
+#define _TEXASRL_PTR(TM_BUF) ((texasrl_t *)((char *)(TM_BUF) + 4))
-  ((texasru_t *)((TM_BUF)+0))
+#define _TFIAR_PTR(TM_BUF) ((tfiar_t *)((char *)(TM_BUF) + 8))
-#define _TEXASRL_PTR(TM_BUF) \
-  ((texasrl_t *)((TM_BUF)+4))
-#define _TFIAR_PTR(TM_BUF) \
-  ((tfiar_t *)((TM_BUF)+8))
 typedef char TM_buff_type[16];
 @@ -178,7 +174,7 @@ extern __inline long
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 __TM_is_conflict(void* const __TM_buff)
 {
-  texasru_t texasru = *_TEXASRU_PTR (TM_buff);
+  texasru_t texasru = *_TEXASRU_PTR (__TM_buff);
   /* Return TEXASR bits 11 (Self-Induced Conflict) through
      14 (Translation Invalidation Conflict).  */
   return (_TEXASRU_EXTRACT_BITS (texasru, 14, 4)) ? 1 : 0;

c_headers/immintrin.h+13-9

 @@ -146,6 +146,10 @@ _mm256_cvtph_ps(__m128i __a)
 #include <avx512cdintrin.h>
 #endif
+#if !defined(_MSC_VER) || __has_feature(modules) || defined(__AVX512VPOPCNTDQ__)
+#include <avx512vpopcntdqintrin.h>
+#endif
 #if !defined(_MSC_VER) || __has_feature(modules) || defined(__AVX512DQ__)
 #include <avx512dqintrin.h>
 #endif
 @@ -208,6 +212,15 @@ _rdrand32_step(unsigned int *__p)
   return __builtin_ia32_rdrand32_step(__p);
 }
+#ifdef __x86_64__
+static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd")))
+_rdrand64_step(unsigned long long *__p)
+{
+  return __builtin_ia32_rdrand64_step(__p);
+}
+#endif
+#endif /* __RDRND__ */
 /* __bit_scan_forward */
 static __inline__ int __attribute__((__always_inline__, __nodebug__))
 _bit_scan_forward(int __A) {
 @@ -220,15 +233,6 @@ _bit_scan_reverse(int __A) {
   return 31 - __builtin_clz(__A);
 }
-#ifdef __x86_64__
-static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd")))
-_rdrand64_step(unsigned long long *__p)
-{
-  return __builtin_ia32_rdrand64_step(__p);
-}
-#endif
-#endif /* __RDRND__ */
 #if !defined(_MSC_VER) || __has_feature(modules) || defined(__FSGSBASE__)
 #ifdef __x86_64__
 static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))

c_headers/intrin.h-56

...	@@ -69,7 +69,6 @@ static __inline__	...	@@ -69,7 +69,6 @@ static __inline__
69	__int64 __emul(int, int);	69	__int64 __emul(int, int);
70	static __inline__	70	static __inline__
71	unsigned __int64 __emulu(unsigned int, unsigned int);	71	unsigned __int64 __emulu(unsigned int, unsigned int);
72	void __cdecl __fastfail(unsigned int);
73	unsigned int __getcallerseflags(void);	72	unsigned int __getcallerseflags(void);
74	static __inline__	73	static __inline__
75	void __halt(void);	74	void __halt(void);
...	@@ -80,16 +79,12 @@ void __incfsdword(unsigned long);	...	@@ -80,16 +79,12 @@ void __incfsdword(unsigned long);
80	void __incfsword(unsigned long);	79	void __incfsword(unsigned long);
81	unsigned long __indword(unsigned short);	80	unsigned long __indword(unsigned short);
82	void __indwordstring(unsigned short, unsigned long *, unsigned long);	81	void __indwordstring(unsigned short, unsigned long *, unsigned long);
83	void __int2c(void);
84	void __invlpg(void *);	82	void __invlpg(void *);
85	unsigned short __inword(unsigned short);	83	unsigned short __inword(unsigned short);
86	void __inwordstring(unsigned short, unsigned short *, unsigned long);	84	void __inwordstring(unsigned short, unsigned short *, unsigned long);
87	void __lidt(void *);	85	void __lidt(void *);
88	unsigned __int64 __ll_lshift(unsigned __int64, int);	86	unsigned __int64 __ll_lshift(unsigned __int64, int);
89	__int64 __ll_rshift(__int64, int);	87	__int64 __ll_rshift(__int64, int);
90	void __llwpcb(void *);
91	unsigned char __lwpins32(unsigned int, unsigned int, unsigned int);
92	void __lwpval32(unsigned int, unsigned int, unsigned int);
93	unsigned int __lzcnt(unsigned int);	88	unsigned int __lzcnt(unsigned int);
94	unsigned short __lzcnt16(unsigned short);	89	unsigned short __lzcnt16(unsigned short);
95	static __inline__	90	static __inline__
...	@@ -128,7 +123,6 @@ unsigned __int64 __readmsr(unsigned long);	...	@@ -128,7 +123,6 @@ unsigned __int64 __readmsr(unsigned long);
128	unsigned __int64 __readpmc(unsigned long);	123	unsigned __int64 __readpmc(unsigned long);
129	unsigned long __segmentlimit(unsigned long);	124	unsigned long __segmentlimit(unsigned long);
130	void __sidt(void *);	125	void __sidt(void *);
131	void *__slwpcb(void);
132	static __inline__	126	static __inline__
133	void __stosb(unsigned char *, unsigned char, size_t);	127	void __stosb(unsigned char *, unsigned char, size_t);
134	static __inline__	128	static __inline__
...	@@ -142,7 +136,6 @@ void __svm_stgi(void);	...	@@ -142,7 +136,6 @@ void __svm_stgi(void);
142	void __svm_vmload(size_t);	136	void __svm_vmload(size_t);
143	void __svm_vmrun(size_t);	137	void __svm_vmrun(size_t);
144	void __svm_vmsave(size_t);	138	void __svm_vmsave(size_t);
145	void __ud2(void);
146	unsigned __int64 __ull_rshift(unsigned __int64, int);	139	unsigned __int64 __ull_rshift(unsigned __int64, int);
147	void __vmx_off(void);	140	void __vmx_off(void);
148	void __vmx_vmptrst(unsigned __int64 *);	141	void __vmx_vmptrst(unsigned __int64 *);
...	@@ -176,7 +169,6 @@ void __cdecl _disable(void);	...	@@ -176,7 +169,6 @@ void __cdecl _disable(void);
176	void __cdecl _enable(void);	169	void __cdecl _enable(void);
177	long _InterlockedAddLargeStatistic(__int64 volatile *_Addend, long _Value);	170	long _InterlockedAddLargeStatistic(__int64 volatile *_Addend, long _Value);
178	unsigned char _interlockedbittestandreset(long volatile *, long);	171	unsigned char _interlockedbittestandreset(long volatile *, long);
179	static __inline__
180	unsigned char _interlockedbittestandset(long volatile *, long);	172	unsigned char _interlockedbittestandset(long volatile *, long);
181	long _InterlockedCompareExchange_HLEAcquire(long volatile *, long, long);	173	long _InterlockedCompareExchange_HLEAcquire(long volatile *, long, long);
182	long _InterlockedCompareExchange_HLERelease(long volatile *, long, long);	174	long _InterlockedCompareExchange_HLERelease(long volatile *, long, long);
...	@@ -231,8 +223,6 @@ void __incgsbyte(unsigned long);	...	@@ -231,8 +223,6 @@ void __incgsbyte(unsigned long);
231	void __incgsdword(unsigned long);	223	void __incgsdword(unsigned long);
232	void __incgsqword(unsigned long);	224	void __incgsqword(unsigned long);
233	void __incgsword(unsigned long);	225	void __incgsword(unsigned long);
234	unsigned char __lwpins64(unsigned __int64, unsigned int, unsigned int);
235	void __lwpval64(unsigned __int64, unsigned int, unsigned int);
236	unsigned __int64 __lzcnt64(unsigned __int64);	226	unsigned __int64 __lzcnt64(unsigned __int64);
237	static __inline__	227	static __inline__
238	void __movsq(unsigned long long , unsigned long long const , size_t);	228	void __movsq(unsigned long long , unsigned long long const , size_t);
...	@@ -372,11 +362,6 @@ _bittestandset(long *_BitBase, long _BitPos) {	...	@@ -372,11 +362,6 @@ _bittestandset(long *_BitBase, long _BitPos) {
372	_BitBase = _BitBase \| (1 << _BitPos);	362	_BitBase = _BitBase \| (1 << _BitPos);
373	return _Res;	363	return _Res;
374	}	364	}
375	static __inline__ unsigned char __DEFAULT_FN_ATTRS
376	_interlockedbittestandset(long volatile *_BitBase, long _BitPos) {
377	long _PrevVal = __atomic_fetch_or(_BitBase, 1l << _BitPos, __ATOMIC_SEQ_CST);
378	return (_PrevVal >> _BitPos) & 1;
379	}
380	#if defined(__arm__) \|\| defined(__aarch64__)	365	#if defined(__arm__) \|\| defined(__aarch64__)
381	static __inline__ unsigned char __DEFAULT_FN_ATTRS	366	static __inline__ unsigned char __DEFAULT_FN_ATTRS
382	_interlockedbittestandset_acq(long volatile *_BitBase, long _BitPos) {	367	_interlockedbittestandset_acq(long volatile *_BitBase, long _BitPos) {
...	@@ -872,48 +857,7 @@ _InterlockedCompareExchange64_rel(__int64 volatile *_Destination,	...	@@ -872,48 +857,7 @@ _InterlockedCompareExchange64_rel(__int64 volatile *_Destination,
872	return _Comparand;	857	return _Comparand;
873	}	858	}
874	#endif	859	#endif
875	/----------------------------------------------------------------------------\
876	\|* readfs, readgs
877	\|* (Pointers in address space #256 and #257 are relative to the GS and FS
878	\|* segment registers, respectively.)
879	\----------------------------------------------------------------------------/
880	#define __ptr_to_addr_space(__addr_space_nbr, __type, __offset) \
881	((volatile __type __attribute__((__address_space__(__addr_space_nbr)))*) \
882	(__offset))
883		860
884	#ifdef __i386__
885	static __inline__ unsigned char __DEFAULT_FN_ATTRS
886	__readfsbyte(unsigned long __offset) {
887	return *__ptr_to_addr_space(257, unsigned char, __offset);
888	}
889	static __inline__ unsigned short __DEFAULT_FN_ATTRS
890	__readfsword(unsigned long __offset) {
891	return *__ptr_to_addr_space(257, unsigned short, __offset);
892	}
893	static __inline__ unsigned __int64 __DEFAULT_FN_ATTRS
894	__readfsqword(unsigned long __offset) {
895	return *__ptr_to_addr_space(257, unsigned __int64, __offset);
896	}
897	#endif
898	#ifdef __x86_64__
899	static __inline__ unsigned char __DEFAULT_FN_ATTRS
900	__readgsbyte(unsigned long __offset) {
901	return *__ptr_to_addr_space(256, unsigned char, __offset);
902	}
903	static __inline__ unsigned short __DEFAULT_FN_ATTRS
904	__readgsword(unsigned long __offset) {
905	return *__ptr_to_addr_space(256, unsigned short, __offset);
906	}
907	static __inline__ unsigned long __DEFAULT_FN_ATTRS
908	__readgsdword(unsigned long __offset) {
909	return *__ptr_to_addr_space(256, unsigned long, __offset);
910	}
911	static __inline__ unsigned __int64 __DEFAULT_FN_ATTRS
912	__readgsqword(unsigned long __offset) {
913	return *__ptr_to_addr_space(256, unsigned __int64, __offset);
914	}
915	#endif
916	#undef __ptr_to_addr_space
917	/----------------------------------------------------------------------------\	861	/----------------------------------------------------------------------------\
918	\|* movs, stos	862	\|* movs, stos
919	\----------------------------------------------------------------------------/	863	\----------------------------------------------------------------------------/

c_headers/lwpintrin.h created+150

...	@@ -0,0 +1,150 @@
1	/*===---- lwpintrin.h - LWP intrinsics -------------------------------------===
2	*
3	* Permission is hereby granted, free of charge, to any person obtaining a copy
4	* of this software and associated documentation files (the "Software"), to deal
5	* in the Software without restriction, including without limitation the rights
6	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7	* copies of the Software, and to permit persons to whom the Software is
8	* furnished to do so, subject to the following conditions:
9	*
10	* The above copyright notice and this permission notice shall be included in
11	* all copies or substantial portions of the Software.
12	*
13	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19	* THE SOFTWARE.
20	*
21	*===-----------------------------------------------------------------------===
22	*/
23
24	#ifndef __X86INTRIN_H
25	#error "Never use <lwpintrin.h> directly; include <x86intrin.h> instead."
26	#endif
27
28	#ifndef __LWPINTRIN_H
29	#define __LWPINTRIN_H
30
31	/* Define the default attributes for the functions in this file. */
32	#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("lwp")))
33
34	/// \brief Parses the LWPCB at the specified address and enables
35	/// profiling if valid.
36	///
37	/// \headerfile <x86intrin.h>
38	///
39	/// This intrinsic corresponds to the <c> LLWPCB </c> instruction.
40	///
41	/// \param __addr
42	/// Address to the new Lightweight Profiling Control Block (LWPCB). If the
43	/// LWPCB is valid, writes the address into the LWP_CBADDR MSR and enables
44	/// Lightweight Profiling.
45	static __inline__ void __DEFAULT_FN_ATTRS
46	__llwpcb (void *__addr)
47	{
48	__builtin_ia32_llwpcb(__addr);
49	}
50
51	/// \brief Flushes the LWP state to memory and returns the address of the LWPCB.
52	///
53	/// \headerfile <x86intrin.h>
54	///
55	/// This intrinsic corresponds to the <c> SLWPCB </c> instruction.
56	///
57	/// \return
58	/// Address to the current Lightweight Profiling Control Block (LWPCB).
59	/// If LWP is not currently enabled, returns NULL.
60	static __inline__ void* __DEFAULT_FN_ATTRS
61	__slwpcb ()
62	{
63	return __builtin_ia32_slwpcb();
64	}
65
66	/// \brief Inserts programmed event record into the LWP event ring buffer
67	/// and advances the ring buffer pointer.
68	///
69	/// \headerfile <x86intrin.h>
70	///
71	/// This intrinsic corresponds to the <c> LWPINS </c> instruction.
72	///
73	/// \param DATA2
74	/// A 32-bit value is zero-extended and inserted into the 64-bit Data2 field.
75	/// \param DATA1
76	/// A 32-bit value is inserted into the 32-bit Data1 field.
77	/// \param FLAGS
78	/// A 32-bit immediate value is inserted into the 32-bit Flags field.
79	/// \returns If the ring buffer is full and LWP is running in Synchronized Mode,
80	/// the event record overwrites the last record in the buffer, the MissedEvents
81	/// counter in the LWPCB is incremented, the head pointer is not advanced, and
82	/// 1 is returned. Otherwise 0 is returned.
83	#define __lwpins32(DATA2, DATA1, FLAGS) \
84	(__builtin_ia32_lwpins32((unsigned int) (DATA2), (unsigned int) (DATA1), \
85	(unsigned int) (FLAGS)))
86
87	/// \brief Decrements the LWP programmed value sample event counter. If the result is
88	/// negative, inserts an event record into the LWP event ring buffer in memory
89	/// and advances the ring buffer pointer.
90	///
91	/// \headerfile <x86intrin.h>
92	///
93	/// This intrinsic corresponds to the <c> LWPVAL </c> instruction.
94	///
95	/// \param DATA2
96	/// A 32-bit value is zero-extended and inserted into the 64-bit Data2 field.
97	/// \param DATA1
98	/// A 32-bit value is inserted into the 32-bit Data1 field.
99	/// \param FLAGS
100	/// A 32-bit immediate value is inserted into the 32-bit Flags field.
101	#define __lwpval32(DATA2, DATA1, FLAGS) \
102	(__builtin_ia32_lwpval32((unsigned int) (DATA2), (unsigned int) (DATA1), \
103	(unsigned int) (FLAGS)))
104
105	#ifdef __x86_64__
106
107	/// \brief Inserts programmed event record into the LWP event ring buffer
108	/// and advances the ring buffer pointer.
109	///
110	/// \headerfile <x86intrin.h>
111	///
112	/// This intrinsic corresponds to the <c> LWPINS </c> instruction.
113	///
114	/// \param DATA2
115	/// A 64-bit value is inserted into the 64-bit Data2 field.
116	/// \param DATA1
117	/// A 32-bit value is inserted into the 32-bit Data1 field.
118	/// \param FLAGS
119	/// A 32-bit immediate value is inserted into the 32-bit Flags field.
120	/// \returns If the ring buffer is full and LWP is running in Synchronized Mode,
121	/// the event record overwrites the last record in the buffer, the MissedEvents
122	/// counter in the LWPCB is incremented, the head pointer is not advanced, and
123	/// 1 is returned. Otherwise 0 is returned.
124	#define __lwpins64(DATA2, DATA1, FLAGS) \
125	(__builtin_ia32_lwpins64((unsigned long long) (DATA2), (unsigned int) (DATA1), \
126	(unsigned int) (FLAGS)))
127
128	/// \brief Decrements the LWP programmed value sample event counter. If the result is
129	/// negative, inserts an event record into the LWP event ring buffer in memory
130	/// and advances the ring buffer pointer.
131	///
132	/// \headerfile <x86intrin.h>
133	///
134	/// This intrinsic corresponds to the <c> LWPVAL </c> instruction.
135	///
136	/// \param DATA2
137	/// A 64-bit value is and inserted into the 64-bit Data2 field.
138	/// \param DATA1
139	/// A 32-bit value is inserted into the 32-bit Data1 field.
140	/// \param FLAGS
141	/// A 32-bit immediate value is inserted into the 32-bit Flags field.
142	#define __lwpval64(DATA2, DATA1, FLAGS) \
143	(__builtin_ia32_lwpval64((unsigned long long) (DATA2), (unsigned int) (DATA1), \
144	(unsigned int) (FLAGS)))
145
146	#endif
147
148	#undef __DEFAULT_FN_ATTRS
149
150	#endif /* __LWPINTRIN_H */

c_headers/mmintrin.h+63-42

...	@@ -211,7 +211,7 @@ _mm_packs_pu16(__m64 __m1, __m64 __m2)	...	@@ -211,7 +211,7 @@ _mm_packs_pu16(__m64 __m1, __m64 __m2)
211	/// This intrinsic corresponds to the <c> PUNPCKHBW </c> instruction.	211	/// This intrinsic corresponds to the <c> PUNPCKHBW </c> instruction.
212	///	212	///
213	/// \param __m1	213	/// \param __m1
214	/// A 64-bit integer vector of [8 x i8]. \n	214	/// A 64-bit integer vector of [8 x i8]. \n
215	/// Bits [39:32] are written to bits [7:0] of the result. \n	215	/// Bits [39:32] are written to bits [7:0] of the result. \n
216	/// Bits [47:40] are written to bits [23:16] of the result. \n	216	/// Bits [47:40] are written to bits [23:16] of the result. \n
217	/// Bits [55:48] are written to bits [39:32] of the result. \n	217	/// Bits [55:48] are written to bits [39:32] of the result. \n
...	@@ -608,10 +608,11 @@ _mm_subs_pi16(__m64 __m1, __m64 __m2)	...	@@ -608,10 +608,11 @@ _mm_subs_pi16(__m64 __m1, __m64 __m2)
608		608
609	/// \brief Subtracts each 8-bit unsigned integer element of the second 64-bit	609	/// \brief Subtracts each 8-bit unsigned integer element of the second 64-bit
610	/// integer vector of [8 x i8] from the corresponding 8-bit unsigned integer	610	/// integer vector of [8 x i8] from the corresponding 8-bit unsigned integer
611	/// element of the first 64-bit integer vector of [8 x i8]. If an element of	611	/// element of the first 64-bit integer vector of [8 x i8].
612	/// the first vector is less than the corresponding element of the second	612	///
613	/// vector, the result is saturated to 0. The results are packed into a	613	/// If an element of the first vector is less than the corresponding element
614	/// 64-bit integer vector of [8 x i8].	614	/// of the second vector, the result is saturated to 0. The results are
		615	/// packed into a 64-bit integer vector of [8 x i8].
615	///	616	///
616	/// \headerfile <x86intrin.h>	617	/// \headerfile <x86intrin.h>
617	///	618	///
...	@@ -631,10 +632,11 @@ _mm_subs_pu8(__m64 __m1, __m64 __m2)	...	@@ -631,10 +632,11 @@ _mm_subs_pu8(__m64 __m1, __m64 __m2)
631		632
632	/// \brief Subtracts each 16-bit unsigned integer element of the second 64-bit	633	/// \brief Subtracts each 16-bit unsigned integer element of the second 64-bit
633	/// integer vector of [4 x i16] from the corresponding 16-bit unsigned	634	/// integer vector of [4 x i16] from the corresponding 16-bit unsigned
634	/// integer element of the first 64-bit integer vector of [4 x i16]. If an	635	/// integer element of the first 64-bit integer vector of [4 x i16].
635	/// element of the first vector is less than the corresponding element of the	636	///
636	/// second vector, the result is saturated to 0. The results are packed into	637	/// If an element of the first vector is less than the corresponding element
637	/// a 64-bit integer vector of [4 x i16].	638	/// of the second vector, the result is saturated to 0. The results are
		639	/// packed into a 64-bit integer vector of [4 x i16].
638	///	640	///
639	/// \headerfile <x86intrin.h>	641	/// \headerfile <x86intrin.h>
640	///	642	///
...	@@ -657,9 +659,11 @@ _mm_subs_pu16(__m64 __m1, __m64 __m2)	...	@@ -657,9 +659,11 @@ _mm_subs_pu16(__m64 __m1, __m64 __m2)
657	/// element of the second 64-bit integer vector of [4 x i16] and get four	659	/// element of the second 64-bit integer vector of [4 x i16] and get four
658	/// 32-bit products. Adds adjacent pairs of products to get two 32-bit sums.	660	/// 32-bit products. Adds adjacent pairs of products to get two 32-bit sums.
659	/// The lower 32 bits of these two sums are packed into a 64-bit integer	661	/// The lower 32 bits of these two sums are packed into a 64-bit integer
660	/// vector of [2 x i32]. For example, bits [15:0] of both parameters are	662	/// vector of [2 x i32].
661	/// multiplied, bits [31:16] of both parameters are multiplied, and the sum	663	///
662	/// of both results is written to bits [31:0] of the result.	664	/// For example, bits [15:0] of both parameters are multiplied, bits [31:16]
		665	/// of both parameters are multiplied, and the sum of both results is written
		666	/// to bits [31:0] of the result.
663	///	667	///
664	/// \headerfile <x86intrin.h>	668	/// \headerfile <x86intrin.h>
665	///	669	///
...	@@ -851,10 +855,11 @@ _mm_slli_si64(__m64 __m, int __count)	...	@@ -851,10 +855,11 @@ _mm_slli_si64(__m64 __m, int __count)
851		855
852	/// \brief Right-shifts each 16-bit integer element of the first parameter,	856	/// \brief Right-shifts each 16-bit integer element of the first parameter,
853	/// which is a 64-bit integer vector of [4 x i16], by the number of bits	857	/// which is a 64-bit integer vector of [4 x i16], by the number of bits
854	/// specified by the second parameter, which is a 64-bit integer. High-order	858	/// specified by the second parameter, which is a 64-bit integer.
855	/// bits are filled with the sign bit of the initial value of each 16-bit	859	///
856	/// element. The 16-bit results are packed into a 64-bit integer vector of	860	/// High-order bits are filled with the sign bit of the initial value of each
857	/// [4 x i16].	861	/// 16-bit element. The 16-bit results are packed into a 64-bit integer
		862	/// vector of [4 x i16].
858	///	863	///
859	/// \headerfile <x86intrin.h>	864	/// \headerfile <x86intrin.h>
860	///	865	///
...	@@ -874,6 +879,7 @@ _mm_sra_pi16(__m64 __m, __m64 __count)	...	@@ -874,6 +879,7 @@ _mm_sra_pi16(__m64 __m, __m64 __count)
874		879
875	/// \brief Right-shifts each 16-bit integer element of a 64-bit integer vector	880	/// \brief Right-shifts each 16-bit integer element of a 64-bit integer vector
876	/// of [4 x i16] by the number of bits specified by a 32-bit integer.	881	/// of [4 x i16] by the number of bits specified by a 32-bit integer.
		882	///
877	/// High-order bits are filled with the sign bit of the initial value of each	883	/// High-order bits are filled with the sign bit of the initial value of each
878	/// 16-bit element. The 16-bit results are packed into a 64-bit integer	884	/// 16-bit element. The 16-bit results are packed into a 64-bit integer
879	/// vector of [4 x i16].	885	/// vector of [4 x i16].
...	@@ -896,10 +902,11 @@ _mm_srai_pi16(__m64 __m, int __count)	...	@@ -896,10 +902,11 @@ _mm_srai_pi16(__m64 __m, int __count)
896		902
897	/// \brief Right-shifts each 32-bit integer element of the first parameter,	903	/// \brief Right-shifts each 32-bit integer element of the first parameter,
898	/// which is a 64-bit integer vector of [2 x i32], by the number of bits	904	/// which is a 64-bit integer vector of [2 x i32], by the number of bits
899	/// specified by the second parameter, which is a 64-bit integer. High-order	905	/// specified by the second parameter, which is a 64-bit integer.
900	/// bits are filled with the sign bit of the initial value of each 32-bit	906	///
901	/// element. The 32-bit results are packed into a 64-bit integer vector of	907	/// High-order bits are filled with the sign bit of the initial value of each
902	/// [2 x i32].	908	/// 32-bit element. The 32-bit results are packed into a 64-bit integer
		909	/// vector of [2 x i32].
903	///	910	///
904	/// \headerfile <x86intrin.h>	911	/// \headerfile <x86intrin.h>
905	///	912	///
...	@@ -919,6 +926,7 @@ _mm_sra_pi32(__m64 __m, __m64 __count)	...	@@ -919,6 +926,7 @@ _mm_sra_pi32(__m64 __m, __m64 __count)
919		926
920	/// \brief Right-shifts each 32-bit integer element of a 64-bit integer vector	927	/// \brief Right-shifts each 32-bit integer element of a 64-bit integer vector
921	/// of [2 x i32] by the number of bits specified by a 32-bit integer.	928	/// of [2 x i32] by the number of bits specified by a 32-bit integer.
		929	///
922	/// High-order bits are filled with the sign bit of the initial value of each	930	/// High-order bits are filled with the sign bit of the initial value of each
923	/// 32-bit element. The 32-bit results are packed into a 64-bit integer	931	/// 32-bit element. The 32-bit results are packed into a 64-bit integer
924	/// vector of [2 x i32].	932	/// vector of [2 x i32].
...	@@ -941,9 +949,10 @@ _mm_srai_pi32(__m64 __m, int __count)	...	@@ -941,9 +949,10 @@ _mm_srai_pi32(__m64 __m, int __count)
941		949
942	/// \brief Right-shifts each 16-bit integer element of the first parameter,	950	/// \brief Right-shifts each 16-bit integer element of the first parameter,
943	/// which is a 64-bit integer vector of [4 x i16], by the number of bits	951	/// which is a 64-bit integer vector of [4 x i16], by the number of bits
944	/// specified by the second parameter, which is a 64-bit integer. High-order	952	/// specified by the second parameter, which is a 64-bit integer.
945	/// bits are cleared. The 16-bit results are packed into a 64-bit integer	953	///
946	/// vector of [4 x i16].	954	/// High-order bits are cleared. The 16-bit results are packed into a 64-bit
		955	/// integer vector of [4 x i16].
947	///	956	///
948	/// \headerfile <x86intrin.h>	957	/// \headerfile <x86intrin.h>
949	///	958	///
...	@@ -963,6 +972,7 @@ _mm_srl_pi16(__m64 __m, __m64 __count)	...	@@ -963,6 +972,7 @@ _mm_srl_pi16(__m64 __m, __m64 __count)
963		972
964	/// \brief Right-shifts each 16-bit integer element of a 64-bit integer vector	973	/// \brief Right-shifts each 16-bit integer element of a 64-bit integer vector
965	/// of [4 x i16] by the number of bits specified by a 32-bit integer.	974	/// of [4 x i16] by the number of bits specified by a 32-bit integer.
		975	///
966	/// High-order bits are cleared. The 16-bit results are packed into a 64-bit	976	/// High-order bits are cleared. The 16-bit results are packed into a 64-bit
967	/// integer vector of [4 x i16].	977	/// integer vector of [4 x i16].
968	///	978	///
...	@@ -984,9 +994,10 @@ _mm_srli_pi16(__m64 __m, int __count)	...	@@ -984,9 +994,10 @@ _mm_srli_pi16(__m64 __m, int __count)
984		994
985	/// \brief Right-shifts each 32-bit integer element of the first parameter,	995	/// \brief Right-shifts each 32-bit integer element of the first parameter,
986	/// which is a 64-bit integer vector of [2 x i32], by the number of bits	996	/// which is a 64-bit integer vector of [2 x i32], by the number of bits
987	/// specified by the second parameter, which is a 64-bit integer. High-order	997	/// specified by the second parameter, which is a 64-bit integer.
988	/// bits are cleared. The 32-bit results are packed into a 64-bit integer	998	///
989	/// vector of [2 x i32].	999	/// High-order bits are cleared. The 32-bit results are packed into a 64-bit
		1000	/// integer vector of [2 x i32].
990	///	1001	///
991	/// \headerfile <x86intrin.h>	1002	/// \headerfile <x86intrin.h>
992	///	1003	///
...	@@ -1006,6 +1017,7 @@ _mm_srl_pi32(__m64 __m, __m64 __count)	...	@@ -1006,6 +1017,7 @@ _mm_srl_pi32(__m64 __m, __m64 __count)
1006		1017
1007	/// \brief Right-shifts each 32-bit integer element of a 64-bit integer vector	1018	/// \brief Right-shifts each 32-bit integer element of a 64-bit integer vector
1008	/// of [2 x i32] by the number of bits specified by a 32-bit integer.	1019	/// of [2 x i32] by the number of bits specified by a 32-bit integer.
		1020	///
1009	/// High-order bits are cleared. The 32-bit results are packed into a 64-bit	1021	/// High-order bits are cleared. The 32-bit results are packed into a 64-bit
1010	/// integer vector of [2 x i32].	1022	/// integer vector of [2 x i32].
1011	///	1023	///
...	@@ -1026,8 +1038,9 @@ _mm_srli_pi32(__m64 __m, int __count)	...	@@ -1026,8 +1038,9 @@ _mm_srli_pi32(__m64 __m, int __count)
1026	}	1038	}
1027		1039
1028	/// \brief Right-shifts the first 64-bit integer parameter by the number of bits	1040	/// \brief Right-shifts the first 64-bit integer parameter by the number of bits
1029	/// specified by the second 64-bit integer parameter. High-order bits are	1041	/// specified by the second 64-bit integer parameter.
1030	/// cleared.	1042	///
		1043	/// High-order bits are cleared.
1031	///	1044	///
1032	/// \headerfile <x86intrin.h>	1045	/// \headerfile <x86intrin.h>
1033	///	1046	///
...	@@ -1046,7 +1059,9 @@ _mm_srl_si64(__m64 __m, __m64 __count)	...	@@ -1046,7 +1059,9 @@ _mm_srl_si64(__m64 __m, __m64 __count)
1046		1059
1047	/// \brief Right-shifts the first parameter, which is a 64-bit integer, by the	1060	/// \brief Right-shifts the first parameter, which is a 64-bit integer, by the
1048	/// number of bits specified by the second parameter, which is a 32-bit	1061	/// number of bits specified by the second parameter, which is a 32-bit
1049	/// integer. High-order bits are cleared.	1062	/// integer.
		1063	///
		1064	/// High-order bits are cleared.
1050	///	1065	///
1051	/// \headerfile <x86intrin.h>	1066	/// \headerfile <x86intrin.h>
1052	///	1067	///
...	@@ -1140,8 +1155,9 @@ _mm_xor_si64(__m64 __m1, __m64 __m2)	...	@@ -1140,8 +1155,9 @@ _mm_xor_si64(__m64 __m1, __m64 __m2)
1140		1155
1141	/// \brief Compares the 8-bit integer elements of two 64-bit integer vectors of	1156	/// \brief Compares the 8-bit integer elements of two 64-bit integer vectors of
1142	/// [8 x i8] to determine if the element of the first vector is equal to the	1157	/// [8 x i8] to determine if the element of the first vector is equal to the
1143	/// corresponding element of the second vector. The comparison yields 0 for	1158	/// corresponding element of the second vector.
1144	/// false, 0xFF for true.	1159	///
		1160	/// The comparison yields 0 for false, 0xFF for true.
1145	///	1161	///
1146	/// \headerfile <x86intrin.h>	1162	/// \headerfile <x86intrin.h>
1147	///	1163	///
...	@@ -1161,8 +1177,9 @@ _mm_cmpeq_pi8(__m64 __m1, __m64 __m2)	...	@@ -1161,8 +1177,9 @@ _mm_cmpeq_pi8(__m64 __m1, __m64 __m2)
1161		1177
1162	/// \brief Compares the 16-bit integer elements of two 64-bit integer vectors of	1178	/// \brief Compares the 16-bit integer elements of two 64-bit integer vectors of
1163	/// [4 x i16] to determine if the element of the first vector is equal to the	1179	/// [4 x i16] to determine if the element of the first vector is equal to the
1164	/// corresponding element of the second vector. The comparison yields 0 for	1180	/// corresponding element of the second vector.
1165	/// false, 0xFFFF for true.	1181	///
		1182	/// The comparison yields 0 for false, 0xFFFF for true.
1166	///	1183	///
1167	/// \headerfile <x86intrin.h>	1184	/// \headerfile <x86intrin.h>
1168	///	1185	///
...	@@ -1182,8 +1199,9 @@ _mm_cmpeq_pi16(__m64 __m1, __m64 __m2)	...	@@ -1182,8 +1199,9 @@ _mm_cmpeq_pi16(__m64 __m1, __m64 __m2)
1182		1199
1183	/// \brief Compares the 32-bit integer elements of two 64-bit integer vectors of	1200	/// \brief Compares the 32-bit integer elements of two 64-bit integer vectors of
1184	/// [2 x i32] to determine if the element of the first vector is equal to the	1201	/// [2 x i32] to determine if the element of the first vector is equal to the
1185	/// corresponding element of the second vector. The comparison yields 0 for	1202	/// corresponding element of the second vector.
1186	/// false, 0xFFFFFFFF for true.	1203	///
		1204	/// The comparison yields 0 for false, 0xFFFFFFFF for true.
1187	///	1205	///
1188	/// \headerfile <x86intrin.h>	1206	/// \headerfile <x86intrin.h>
1189	///	1207	///
...	@@ -1203,8 +1221,9 @@ _mm_cmpeq_pi32(__m64 __m1, __m64 __m2)	...	@@ -1203,8 +1221,9 @@ _mm_cmpeq_pi32(__m64 __m1, __m64 __m2)
1203		1221
1204	/// \brief Compares the 8-bit integer elements of two 64-bit integer vectors of	1222	/// \brief Compares the 8-bit integer elements of two 64-bit integer vectors of
1205	/// [8 x i8] to determine if the element of the first vector is greater than	1223	/// [8 x i8] to determine if the element of the first vector is greater than
1206	/// the corresponding element of the second vector. The comparison yields 0	1224	/// the corresponding element of the second vector.
1207	/// for false, 0xFF for true.	1225	///
		1226	/// The comparison yields 0 for false, 0xFF for true.
1208	///	1227	///
1209	/// \headerfile <x86intrin.h>	1228	/// \headerfile <x86intrin.h>
1210	///	1229	///
...	@@ -1224,8 +1243,9 @@ _mm_cmpgt_pi8(__m64 __m1, __m64 __m2)	...	@@ -1224,8 +1243,9 @@ _mm_cmpgt_pi8(__m64 __m1, __m64 __m2)
1224		1243
1225	/// \brief Compares the 16-bit integer elements of two 64-bit integer vectors of	1244	/// \brief Compares the 16-bit integer elements of two 64-bit integer vectors of
1226	/// [4 x i16] to determine if the element of the first vector is greater than	1245	/// [4 x i16] to determine if the element of the first vector is greater than
1227	/// the corresponding element of the second vector. The comparison yields 0	1246	/// the corresponding element of the second vector.
1228	/// for false, 0xFFFF for true.	1247	///
		1248	/// The comparison yields 0 for false, 0xFFFF for true.
1229	///	1249	///
1230	/// \headerfile <x86intrin.h>	1250	/// \headerfile <x86intrin.h>
1231	///	1251	///
...	@@ -1245,8 +1265,9 @@ _mm_cmpgt_pi16(__m64 __m1, __m64 __m2)	...	@@ -1245,8 +1265,9 @@ _mm_cmpgt_pi16(__m64 __m1, __m64 __m2)
1245		1265
1246	/// \brief Compares the 32-bit integer elements of two 64-bit integer vectors of	1266	/// \brief Compares the 32-bit integer elements of two 64-bit integer vectors of
1247	/// [2 x i32] to determine if the element of the first vector is greater than	1267	/// [2 x i32] to determine if the element of the first vector is greater than
1248	/// the corresponding element of the second vector. The comparison yields 0	1268	/// the corresponding element of the second vector.
1249	/// for false, 0xFFFFFFFF for true.	1269	///
		1270	/// The comparison yields 0 for false, 0xFFFFFFFF for true.
1250	///	1271	///
1251	/// \headerfile <x86intrin.h>	1272	/// \headerfile <x86intrin.h>
1252	///	1273	///
...	@@ -1268,7 +1289,7 @@ _mm_cmpgt_pi32(__m64 __m1, __m64 __m2)	...	@@ -1268,7 +1289,7 @@ _mm_cmpgt_pi32(__m64 __m1, __m64 __m2)
1268	///	1289	///
1269	/// \headerfile <x86intrin.h>	1290	/// \headerfile <x86intrin.h>
1270	///	1291	///
1271	/// This intrinsic corresponds to the the <c> VXORPS / XORPS </c> instruction.	1292	/// This intrinsic corresponds to the <c> VXORPS / XORPS </c> instruction.
1272	///	1293	///
1273	/// \returns An initialized 64-bit integer vector with all elements set to zero.	1294	/// \returns An initialized 64-bit integer vector with all elements set to zero.
1274	static __inline__ __m64 __DEFAULT_FN_ATTRS	1295	static __inline__ __m64 __DEFAULT_FN_ATTRS

c_headers/module.modulemap+1

...	@@ -61,6 +61,7 @@ module _Builtin_intrinsics [system] [extern_c] {	...	@@ -61,6 +61,7 @@ module _Builtin_intrinsics [system] [extern_c] {
61	textual header "xopintrin.h"	61	textual header "xopintrin.h"
62	textual header "fma4intrin.h"	62	textual header "fma4intrin.h"
63	textual header "mwaitxintrin.h"	63	textual header "mwaitxintrin.h"
		64	textual header "clzerointrin.h"
64		65
65	explicit module mm_malloc {	66	explicit module mm_malloc {
66	requires !freestanding	67	requires !freestanding

c_headers/opencl-c.h+120-778

...	@@ -16,6 +16,12 @@	...	@@ -16,6 +16,12 @@
16	#endif //cl_khr_depth_images	16	#endif //cl_khr_depth_images
17	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0	17	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
18		18
		19	#if __OPENCL_C_VERSION__ < CL_VERSION_2_0
		20	#ifdef cl_khr_3d_image_writes
		21	#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
		22	#endif //cl_khr_3d_image_writes
		23	#endif //__OPENCL_C_VERSION__ < CL_VERSION_2_0
		24
19	#define __ovld __attribute__((overloadable))	25	#define __ovld __attribute__((overloadable))
20	#define __conv __attribute__((convergent))	26	#define __conv __attribute__((convergent))
21		27
...	@@ -6578,777 +6584,85 @@ half16 __ovld __cnfn convert_half16_rtz(double16);	...	@@ -6578,777 +6584,85 @@ half16 __ovld __cnfn convert_half16_rtz(double16);
6578	* OpenCL v1.1/1.2/2.0 s6.2.4.2 - as_type operators	6584	* OpenCL v1.1/1.2/2.0 s6.2.4.2 - as_type operators
6579	* Reinterprets a data type as another data type of the same size	6585	* Reinterprets a data type as another data type of the same size
6580	*/	6586	*/
6581	char __ovld __cnfn as_char(char);	6587	#define as_char(x) __builtin_astype((x), char)
6582	char __ovld __cnfn as_char(uchar);	6588	#define as_char2(x) __builtin_astype((x), char2)
6583		6589	#define as_char3(x) __builtin_astype((x), char3)
6584	char2 __ovld __cnfn as_char2(char2);	6590	#define as_char4(x) __builtin_astype((x), char4)
6585	char2 __ovld __cnfn as_char2(uchar2);	6591	#define as_char8(x) __builtin_astype((x), char8)
6586	char2 __ovld __cnfn as_char2(short);	6592	#define as_char16(x) __builtin_astype((x), char16)
6587	char2 __ovld __cnfn as_char2(ushort);	6593
6588		6594	#define as_uchar(x) __builtin_astype((x), uchar)
6589	char3 __ovld __cnfn as_char3(char3);	6595	#define as_uchar2(x) __builtin_astype((x), uchar2)
6590	char3 __ovld __cnfn as_char3(char4);	6596	#define as_uchar3(x) __builtin_astype((x), uchar3)
6591	char3 __ovld __cnfn as_char3(uchar3);	6597	#define as_uchar4(x) __builtin_astype((x), uchar4)
6592	char3 __ovld __cnfn as_char3(uchar4);	6598	#define as_uchar8(x) __builtin_astype((x), uchar8)
6593	char3 __ovld __cnfn as_char3(short2);	6599	#define as_uchar16(x) __builtin_astype((x), uchar16)
6594	char3 __ovld __cnfn as_char3(ushort2);	6600
6595	char3 __ovld __cnfn as_char3(int);	6601	#define as_short(x) __builtin_astype((x), short)
6596	char3 __ovld __cnfn as_char3(uint);	6602	#define as_short2(x) __builtin_astype((x), short2)
6597	char3 __ovld __cnfn as_char3(float);	6603	#define as_short3(x) __builtin_astype((x), short3)
6598		6604	#define as_short4(x) __builtin_astype((x), short4)
6599	char4 __ovld __cnfn as_char4(char3);	6605	#define as_short8(x) __builtin_astype((x), short8)
6600	char4 __ovld __cnfn as_char4(char4);	6606	#define as_short16(x) __builtin_astype((x), short16)
6601	char4 __ovld __cnfn as_char4(uchar3);	6607
6602	char4 __ovld __cnfn as_char4(uchar4);	6608	#define as_ushort(x) __builtin_astype((x), ushort)
6603	char4 __ovld __cnfn as_char4(short2);	6609	#define as_ushort2(x) __builtin_astype((x), ushort2)
6604	char4 __ovld __cnfn as_char4(ushort2);	6610	#define as_ushort3(x) __builtin_astype((x), ushort3)
6605	char4 __ovld __cnfn as_char4(int);	6611	#define as_ushort4(x) __builtin_astype((x), ushort4)
6606	char4 __ovld __cnfn as_char4(uint);	6612	#define as_ushort8(x) __builtin_astype((x), ushort8)
6607	char4 __ovld __cnfn as_char4(float);	6613	#define as_ushort16(x) __builtin_astype((x), ushort16)
6608		6614
6609	char8 __ovld __cnfn as_char8(char8);	6615	#define as_int(x) __builtin_astype((x), int)
6610	char8 __ovld __cnfn as_char8(uchar8);	6616	#define as_int2(x) __builtin_astype((x), int2)
6611	char8 __ovld __cnfn as_char8(short3);	6617	#define as_int3(x) __builtin_astype((x), int3)
6612	char8 __ovld __cnfn as_char8(short4);	6618	#define as_int4(x) __builtin_astype((x), int4)
6613	char8 __ovld __cnfn as_char8(ushort3);	6619	#define as_int8(x) __builtin_astype((x), int8)
6614	char8 __ovld __cnfn as_char8(ushort4);	6620	#define as_int16(x) __builtin_astype((x), int16)
6615	char8 __ovld __cnfn as_char8(int2);	6621
6616	char8 __ovld __cnfn as_char8(uint2);	6622	#define as_uint(x) __builtin_astype((x), uint)
6617	char8 __ovld __cnfn as_char8(long);	6623	#define as_uint2(x) __builtin_astype((x), uint2)
6618	char8 __ovld __cnfn as_char8(ulong);	6624	#define as_uint3(x) __builtin_astype((x), uint3)
6619	char8 __ovld __cnfn as_char8(float2);	6625	#define as_uint4(x) __builtin_astype((x), uint4)
6620		6626	#define as_uint8(x) __builtin_astype((x), uint8)
6621	char16 __ovld __cnfn as_char16(char16);	6627	#define as_uint16(x) __builtin_astype((x), uint16)
6622	char16 __ovld __cnfn as_char16(uchar16);	6628
6623	char16 __ovld __cnfn as_char16(short8);	6629	#define as_long(x) __builtin_astype((x), long)
6624	char16 __ovld __cnfn as_char16(ushort8);	6630	#define as_long2(x) __builtin_astype((x), long2)
6625	char16 __ovld __cnfn as_char16(int3);	6631	#define as_long3(x) __builtin_astype((x), long3)
6626	char16 __ovld __cnfn as_char16(int4);	6632	#define as_long4(x) __builtin_astype((x), long4)
6627	char16 __ovld __cnfn as_char16(uint3);	6633	#define as_long8(x) __builtin_astype((x), long8)
6628	char16 __ovld __cnfn as_char16(uint4);	6634	#define as_long16(x) __builtin_astype((x), long16)
6629	char16 __ovld __cnfn as_char16(long2);	6635
6630	char16 __ovld __cnfn as_char16(ulong2);	6636	#define as_ulong(x) __builtin_astype((x), ulong)
6631	char16 __ovld __cnfn as_char16(float3);	6637	#define as_ulong2(x) __builtin_astype((x), ulong2)
6632	char16 __ovld __cnfn as_char16(float4);	6638	#define as_ulong3(x) __builtin_astype((x), ulong3)
6633		6639	#define as_ulong4(x) __builtin_astype((x), ulong4)
6634	uchar __ovld __cnfn as_uchar(char);	6640	#define as_ulong8(x) __builtin_astype((x), ulong8)
6635	uchar __ovld __cnfn as_uchar(uchar);	6641	#define as_ulong16(x) __builtin_astype((x), ulong16)
6636		6642
6637	uchar2 __ovld __cnfn as_uchar2(char2);	6643	#define as_float(x) __builtin_astype((x), float)
6638	uchar2 __ovld __cnfn as_uchar2(uchar2);	6644	#define as_float2(x) __builtin_astype((x), float2)
6639	uchar2 __ovld __cnfn as_uchar2(short);	6645	#define as_float3(x) __builtin_astype((x), float3)
6640	uchar2 __ovld __cnfn as_uchar2(ushort);	6646	#define as_float4(x) __builtin_astype((x), float4)
6641		6647	#define as_float8(x) __builtin_astype((x), float8)
6642	uchar3 __ovld __cnfn as_uchar3(char3);	6648	#define as_float16(x) __builtin_astype((x), float16)
6643	uchar3 __ovld __cnfn as_uchar3(char4);
6644	uchar3 __ovld __cnfn as_uchar3(uchar3);
6645	uchar3 __ovld __cnfn as_uchar3(uchar4);
6646	uchar3 __ovld __cnfn as_uchar3(short2);
6647	uchar3 __ovld __cnfn as_uchar3(ushort2);
6648	uchar3 __ovld __cnfn as_uchar3(int);
6649	uchar3 __ovld __cnfn as_uchar3(uint);
6650	uchar3 __ovld __cnfn as_uchar3(float);
6651
6652	uchar4 __ovld __cnfn as_uchar4(char3);
6653	uchar4 __ovld __cnfn as_uchar4(char4);
6654	uchar4 __ovld __cnfn as_uchar4(uchar3);
6655	uchar4 __ovld __cnfn as_uchar4(uchar4);
6656	uchar4 __ovld __cnfn as_uchar4(short2);
6657	uchar4 __ovld __cnfn as_uchar4(ushort2);
6658	uchar4 __ovld __cnfn as_uchar4(int);
6659	uchar4 __ovld __cnfn as_uchar4(uint);
6660	uchar4 __ovld __cnfn as_uchar4(float);
6661
6662	uchar8 __ovld __cnfn as_uchar8(char8);
6663	uchar8 __ovld __cnfn as_uchar8(uchar8);
6664	uchar8 __ovld __cnfn as_uchar8(short3);
6665	uchar8 __ovld __cnfn as_uchar8(short4);
6666	uchar8 __ovld __cnfn as_uchar8(ushort3);
6667	uchar8 __ovld __cnfn as_uchar8(ushort4);
6668	uchar8 __ovld __cnfn as_uchar8(int2);
6669	uchar8 __ovld __cnfn as_uchar8(uint2);
6670	uchar8 __ovld __cnfn as_uchar8(long);
6671	uchar8 __ovld __cnfn as_uchar8(ulong);
6672	uchar8 __ovld __cnfn as_uchar8(float2);
6673
6674	uchar16 __ovld __cnfn as_uchar16(char16);
6675	uchar16 __ovld __cnfn as_uchar16(uchar16);
6676	uchar16 __ovld __cnfn as_uchar16(short8);
6677	uchar16 __ovld __cnfn as_uchar16(ushort8);
6678	uchar16 __ovld __cnfn as_uchar16(int3);
6679	uchar16 __ovld __cnfn as_uchar16(int4);
6680	uchar16 __ovld __cnfn as_uchar16(uint3);
6681	uchar16 __ovld __cnfn as_uchar16(uint4);
6682	uchar16 __ovld __cnfn as_uchar16(long2);
6683	uchar16 __ovld __cnfn as_uchar16(ulong2);
6684	uchar16 __ovld __cnfn as_uchar16(float3);
6685	uchar16 __ovld __cnfn as_uchar16(float4);
6686
6687	short __ovld __cnfn as_short(char2);
6688	short __ovld __cnfn as_short(uchar2);
6689	short __ovld __cnfn as_short(short);
6690	short __ovld __cnfn as_short(ushort);
6691
6692	short2 __ovld __cnfn as_short2(char3);
6693	short2 __ovld __cnfn as_short2(char4);
6694	short2 __ovld __cnfn as_short2(uchar3);
6695	short2 __ovld __cnfn as_short2(uchar4);
6696	short2 __ovld __cnfn as_short2(short2);
6697	short2 __ovld __cnfn as_short2(ushort2);
6698	short2 __ovld __cnfn as_short2(int);
6699	short2 __ovld __cnfn as_short2(uint);
6700	short2 __ovld __cnfn as_short2(float);
6701
6702	short3 __ovld __cnfn as_short3(char8);
6703	short3 __ovld __cnfn as_short3(uchar8);
6704	short3 __ovld __cnfn as_short3(short3);
6705	short3 __ovld __cnfn as_short3(short4);
6706	short3 __ovld __cnfn as_short3(ushort3);
6707	short3 __ovld __cnfn as_short3(ushort4);
6708	short3 __ovld __cnfn as_short3(int2);
6709	short3 __ovld __cnfn as_short3(uint2);
6710	short3 __ovld __cnfn as_short3(long);
6711	short3 __ovld __cnfn as_short3(ulong);
6712	short3 __ovld __cnfn as_short3(float2);
6713
6714	short4 __ovld __cnfn as_short4(char8);
6715	short4 __ovld __cnfn as_short4(uchar8);
6716	short4 __ovld __cnfn as_short4(short3);
6717	short4 __ovld __cnfn as_short4(short4);
6718	short4 __ovld __cnfn as_short4(ushort3);
6719	short4 __ovld __cnfn as_short4(ushort4);
6720	short4 __ovld __cnfn as_short4(int2);
6721	short4 __ovld __cnfn as_short4(uint2);
6722	short4 __ovld __cnfn as_short4(long);
6723	short4 __ovld __cnfn as_short4(ulong);
6724	short4 __ovld __cnfn as_short4(float2);
6725
6726	short8 __ovld __cnfn as_short8(char16);
6727	short8 __ovld __cnfn as_short8(uchar16);
6728	short8 __ovld __cnfn as_short8(short8);
6729	short8 __ovld __cnfn as_short8(ushort8);
6730	short8 __ovld __cnfn as_short8(int3);
6731	short8 __ovld __cnfn as_short8(int4);
6732	short8 __ovld __cnfn as_short8(uint3);
6733	short8 __ovld __cnfn as_short8(uint4);
6734	short8 __ovld __cnfn as_short8(long2);
6735	short8 __ovld __cnfn as_short8(ulong2);
6736	short8 __ovld __cnfn as_short8(float3);
6737	short8 __ovld __cnfn as_short8(float4);
6738
6739	short16 __ovld __cnfn as_short16(short16);
6740	short16 __ovld __cnfn as_short16(ushort16);
6741	short16 __ovld __cnfn as_short16(int8);
6742	short16 __ovld __cnfn as_short16(uint8);
6743	short16 __ovld __cnfn as_short16(long3);
6744	short16 __ovld __cnfn as_short16(long4);
6745	short16 __ovld __cnfn as_short16(ulong3);
6746	short16 __ovld __cnfn as_short16(ulong4);
6747	short16 __ovld __cnfn as_short16(float8);
6748
6749	ushort __ovld __cnfn as_ushort(char2);
6750	ushort __ovld __cnfn as_ushort(uchar2);
6751	ushort __ovld __cnfn as_ushort(short);
6752	ushort __ovld __cnfn as_ushort(ushort);
6753
6754	ushort2 __ovld __cnfn as_ushort2(char3);
6755	ushort2 __ovld __cnfn as_ushort2(char4);
6756	ushort2 __ovld __cnfn as_ushort2(uchar3);
6757	ushort2 __ovld __cnfn as_ushort2(uchar4);
6758	ushort2 __ovld __cnfn as_ushort2(short2);
6759	ushort2 __ovld __cnfn as_ushort2(ushort2);
6760	ushort2 __ovld __cnfn as_ushort2(int);
6761	ushort2 __ovld __cnfn as_ushort2(uint);
6762	ushort2 __ovld __cnfn as_ushort2(float);
6763
6764	ushort3 __ovld __cnfn as_ushort3(char8);
6765	ushort3 __ovld __cnfn as_ushort3(uchar8);
6766	ushort3 __ovld __cnfn as_ushort3(short3);
6767	ushort3 __ovld __cnfn as_ushort3(short4);
6768	ushort3 __ovld __cnfn as_ushort3(ushort3);
6769	ushort3 __ovld __cnfn as_ushort3(ushort4);
6770	ushort3 __ovld __cnfn as_ushort3(int2);
6771	ushort3 __ovld __cnfn as_ushort3(uint2);
6772	ushort3 __ovld __cnfn as_ushort3(long);
6773	ushort3 __ovld __cnfn as_ushort3(ulong);
6774	ushort3 __ovld __cnfn as_ushort3(float2);
6775
6776	ushort4 __ovld __cnfn as_ushort4(char8);
6777	ushort4 __ovld __cnfn as_ushort4(uchar8);
6778	ushort4 __ovld __cnfn as_ushort4(short3);
6779	ushort4 __ovld __cnfn as_ushort4(short4);
6780	ushort4 __ovld __cnfn as_ushort4(ushort3);
6781	ushort4 __ovld __cnfn as_ushort4(ushort4);
6782	ushort4 __ovld __cnfn as_ushort4(int2);
6783	ushort4 __ovld __cnfn as_ushort4(uint2);
6784	ushort4 __ovld __cnfn as_ushort4(long);
6785	ushort4 __ovld __cnfn as_ushort4(ulong);
6786	ushort4 __ovld __cnfn as_ushort4(float2);
6787
6788	ushort8 __ovld __cnfn as_ushort8(char16);
6789	ushort8 __ovld __cnfn as_ushort8(uchar16);
6790	ushort8 __ovld __cnfn as_ushort8(short8);
6791	ushort8 __ovld __cnfn as_ushort8(ushort8);
6792	ushort8 __ovld __cnfn as_ushort8(int3);
6793	ushort8 __ovld __cnfn as_ushort8(int4);
6794	ushort8 __ovld __cnfn as_ushort8(uint3);
6795	ushort8 __ovld __cnfn as_ushort8(uint4);
6796	ushort8 __ovld __cnfn as_ushort8(long2);
6797	ushort8 __ovld __cnfn as_ushort8(ulong2);
6798	ushort8 __ovld __cnfn as_ushort8(float3);
6799	ushort8 __ovld __cnfn as_ushort8(float4);
6800
6801	ushort16 __ovld __cnfn as_ushort16(short16);
6802	ushort16 __ovld __cnfn as_ushort16(ushort16);
6803	ushort16 __ovld __cnfn as_ushort16(int8);
6804	ushort16 __ovld __cnfn as_ushort16(uint8);
6805	ushort16 __ovld __cnfn as_ushort16(long3);
6806	ushort16 __ovld __cnfn as_ushort16(long4);
6807	ushort16 __ovld __cnfn as_ushort16(ulong3);
6808	ushort16 __ovld __cnfn as_ushort16(ulong4);
6809	ushort16 __ovld __cnfn as_ushort16(float8);
6810
6811	int __ovld __cnfn as_int(char3);
6812	int __ovld __cnfn as_int(char4);
6813	int __ovld __cnfn as_int(uchar3);
6814	int __ovld __cnfn as_int(uchar4);
6815	int __ovld __cnfn as_int(short2);
6816	int __ovld __cnfn as_int(ushort2);
6817	int __ovld __cnfn as_int(int);
6818	int __ovld __cnfn as_int(uint);
6819	int __ovld __cnfn as_int(float);
6820
6821	int2 __ovld __cnfn as_int2(char8);
6822	int2 __ovld __cnfn as_int2(uchar8);
6823	int2 __ovld __cnfn as_int2(short3);
6824	int2 __ovld __cnfn as_int2(short4);
6825	int2 __ovld __cnfn as_int2(ushort3);
6826	int2 __ovld __cnfn as_int2(ushort4);
6827	int2 __ovld __cnfn as_int2(int2);
6828	int2 __ovld __cnfn as_int2(uint2);
6829	int2 __ovld __cnfn as_int2(long);
6830	int2 __ovld __cnfn as_int2(ulong);
6831	int2 __ovld __cnfn as_int2(float2);
6832
6833	int3 __ovld __cnfn as_int3(char16);
6834	int3 __ovld __cnfn as_int3(uchar16);
6835	int3 __ovld __cnfn as_int3(short8);
6836	int3 __ovld __cnfn as_int3(ushort8);
6837	int3 __ovld __cnfn as_int3(int3);
6838	int3 __ovld __cnfn as_int3(int4);
6839	int3 __ovld __cnfn as_int3(uint3);
6840	int3 __ovld __cnfn as_int3(uint4);
6841	int3 __ovld __cnfn as_int3(long2);
6842	int3 __ovld __cnfn as_int3(ulong2);
6843	int3 __ovld __cnfn as_int3(float3);
6844	int3 __ovld __cnfn as_int3(float4);
6845
6846	int4 __ovld __cnfn as_int4(char16);
6847	int4 __ovld __cnfn as_int4(uchar16);
6848	int4 __ovld __cnfn as_int4(short8);
6849	int4 __ovld __cnfn as_int4(ushort8);
6850	int4 __ovld __cnfn as_int4(int3);
6851	int4 __ovld __cnfn as_int4(int4);
6852	int4 __ovld __cnfn as_int4(uint3);
6853	int4 __ovld __cnfn as_int4(uint4);
6854	int4 __ovld __cnfn as_int4(long2);
6855	int4 __ovld __cnfn as_int4(ulong2);
6856	int4 __ovld __cnfn as_int4(float3);
6857	int4 __ovld __cnfn as_int4(float4);
6858
6859	int8 __ovld __cnfn as_int8(short16);
6860	int8 __ovld __cnfn as_int8(ushort16);
6861	int8 __ovld __cnfn as_int8(int8);
6862	int8 __ovld __cnfn as_int8(uint8);
6863	int8 __ovld __cnfn as_int8(long3);
6864	int8 __ovld __cnfn as_int8(long4);
6865	int8 __ovld __cnfn as_int8(ulong3);
6866	int8 __ovld __cnfn as_int8(ulong4);
6867	int8 __ovld __cnfn as_int8(float8);
6868
6869	int16 __ovld __cnfn as_int16(int16);
6870	int16 __ovld __cnfn as_int16(uint16);
6871	int16 __ovld __cnfn as_int16(long8);
6872	int16 __ovld __cnfn as_int16(ulong8);
6873	int16 __ovld __cnfn as_int16(float16);
6874
6875	uint __ovld __cnfn as_uint(char3);
6876	uint __ovld __cnfn as_uint(char4);
6877	uint __ovld __cnfn as_uint(uchar3);
6878	uint __ovld __cnfn as_uint(uchar4);
6879	uint __ovld __cnfn as_uint(short2);
6880	uint __ovld __cnfn as_uint(ushort2);
6881	uint __ovld __cnfn as_uint(int);
6882	uint __ovld __cnfn as_uint(uint);
6883	uint __ovld __cnfn as_uint(float);
6884
6885	uint2 __ovld __cnfn as_uint2(char8);
6886	uint2 __ovld __cnfn as_uint2(uchar8);
6887	uint2 __ovld __cnfn as_uint2(short3);
6888	uint2 __ovld __cnfn as_uint2(short4);
6889	uint2 __ovld __cnfn as_uint2(ushort3);
6890	uint2 __ovld __cnfn as_uint2(ushort4);
6891	uint2 __ovld __cnfn as_uint2(int2);
6892	uint2 __ovld __cnfn as_uint2(uint2);
6893	uint2 __ovld __cnfn as_uint2(long);
6894	uint2 __ovld __cnfn as_uint2(ulong);
6895	uint2 __ovld __cnfn as_uint2(float2);
6896
6897	uint3 __ovld __cnfn as_uint3(char16);
6898	uint3 __ovld __cnfn as_uint3(uchar16);
6899	uint3 __ovld __cnfn as_uint3(short8);
6900	uint3 __ovld __cnfn as_uint3(ushort8);
6901	uint3 __ovld __cnfn as_uint3(int3);
6902	uint3 __ovld __cnfn as_uint3(int4);
6903	uint3 __ovld __cnfn as_uint3(uint3);
6904	uint3 __ovld __cnfn as_uint3(uint4);
6905	uint3 __ovld __cnfn as_uint3(long2);
6906	uint3 __ovld __cnfn as_uint3(ulong2);
6907	uint3 __ovld __cnfn as_uint3(float3);
6908	uint3 __ovld __cnfn as_uint3(float4);
6909
6910	uint4 __ovld __cnfn as_uint4(char16);
6911	uint4 __ovld __cnfn as_uint4(uchar16);
6912	uint4 __ovld __cnfn as_uint4(short8);
6913	uint4 __ovld __cnfn as_uint4(ushort8);
6914	uint4 __ovld __cnfn as_uint4(int3);
6915	uint4 __ovld __cnfn as_uint4(int4);
6916	uint4 __ovld __cnfn as_uint4(uint3);
6917	uint4 __ovld __cnfn as_uint4(uint4);
6918	uint4 __ovld __cnfn as_uint4(long2);
6919	uint4 __ovld __cnfn as_uint4(ulong2);
6920	uint4 __ovld __cnfn as_uint4(float3);
6921	uint4 __ovld __cnfn as_uint4(float4);
6922
6923	uint8 __ovld __cnfn as_uint8(short16);
6924	uint8 __ovld __cnfn as_uint8(ushort16);
6925	uint8 __ovld __cnfn as_uint8(int8);
6926	uint8 __ovld __cnfn as_uint8(uint8);
6927	uint8 __ovld __cnfn as_uint8(long3);
6928	uint8 __ovld __cnfn as_uint8(long4);
6929	uint8 __ovld __cnfn as_uint8(ulong3);
6930	uint8 __ovld __cnfn as_uint8(ulong4);
6931	uint8 __ovld __cnfn as_uint8(float8);
6932
6933	uint16 __ovld __cnfn as_uint16(int16);
6934	uint16 __ovld __cnfn as_uint16(uint16);
6935	uint16 __ovld __cnfn as_uint16(long8);
6936	uint16 __ovld __cnfn as_uint16(ulong8);
6937	uint16 __ovld __cnfn as_uint16(float16);
6938
6939	long __ovld __cnfn as_long(char8);
6940	long __ovld __cnfn as_long(uchar8);
6941	long __ovld __cnfn as_long(short3);
6942	long __ovld __cnfn as_long(short4);
6943	long __ovld __cnfn as_long(ushort3);
6944	long __ovld __cnfn as_long(ushort4);
6945	long __ovld __cnfn as_long(int2);
6946	long __ovld __cnfn as_long(uint2);
6947	long __ovld __cnfn as_long(long);
6948	long __ovld __cnfn as_long(ulong);
6949	long __ovld __cnfn as_long(float2);
6950
6951	long2 __ovld __cnfn as_long2(char16);
6952	long2 __ovld __cnfn as_long2(uchar16);
6953	long2 __ovld __cnfn as_long2(short8);
6954	long2 __ovld __cnfn as_long2(ushort8);
6955	long2 __ovld __cnfn as_long2(int3);
6956	long2 __ovld __cnfn as_long2(int4);
6957	long2 __ovld __cnfn as_long2(uint3);
6958	long2 __ovld __cnfn as_long2(uint4);
6959	long2 __ovld __cnfn as_long2(long2);
6960	long2 __ovld __cnfn as_long2(ulong2);
6961	long2 __ovld __cnfn as_long2(float3);
6962	long2 __ovld __cnfn as_long2(float4);
6963
6964	long3 __ovld __cnfn as_long3(short16);
6965	long3 __ovld __cnfn as_long3(ushort16);
6966	long3 __ovld __cnfn as_long3(int8);
6967	long3 __ovld __cnfn as_long3(uint8);
6968	long3 __ovld __cnfn as_long3(long3);
6969	long3 __ovld __cnfn as_long3(long4);
6970	long3 __ovld __cnfn as_long3(ulong3);
6971	long3 __ovld __cnfn as_long3(ulong4);
6972	long3 __ovld __cnfn as_long3(float8);
6973
6974	long4 __ovld __cnfn as_long4(short16);
6975	long4 __ovld __cnfn as_long4(ushort16);
6976	long4 __ovld __cnfn as_long4(int8);
6977	long4 __ovld __cnfn as_long4(uint8);
6978	long4 __ovld __cnfn as_long4(long3);
6979	long4 __ovld __cnfn as_long4(long4);
6980	long4 __ovld __cnfn as_long4(ulong3);
6981	long4 __ovld __cnfn as_long4(ulong4);
6982	long4 __ovld __cnfn as_long4(float8);
6983
6984	long8 __ovld __cnfn as_long8(int16);
6985	long8 __ovld __cnfn as_long8(uint16);
6986	long8 __ovld __cnfn as_long8(long8);
6987	long8 __ovld __cnfn as_long8(ulong8);
6988	long8 __ovld __cnfn as_long8(float16);
6989
6990	long16 __ovld __cnfn as_long16(long16);
6991	long16 __ovld __cnfn as_long16(ulong16);
6992
6993	ulong __ovld __cnfn as_ulong(char8);
6994	ulong __ovld __cnfn as_ulong(uchar8);
6995	ulong __ovld __cnfn as_ulong(short3);
6996	ulong __ovld __cnfn as_ulong(short4);
6997	ulong __ovld __cnfn as_ulong(ushort3);
6998	ulong __ovld __cnfn as_ulong(ushort4);
6999	ulong __ovld __cnfn as_ulong(int2);
7000	ulong __ovld __cnfn as_ulong(uint2);
7001	ulong __ovld __cnfn as_ulong(long);
7002	ulong __ovld __cnfn as_ulong(ulong);
7003	ulong __ovld __cnfn as_ulong(float2);
7004
7005	ulong2 __ovld __cnfn as_ulong2(char16);
7006	ulong2 __ovld __cnfn as_ulong2(uchar16);
7007	ulong2 __ovld __cnfn as_ulong2(short8);
7008	ulong2 __ovld __cnfn as_ulong2(ushort8);
7009	ulong2 __ovld __cnfn as_ulong2(int3);
7010	ulong2 __ovld __cnfn as_ulong2(int4);
7011	ulong2 __ovld __cnfn as_ulong2(uint3);
7012	ulong2 __ovld __cnfn as_ulong2(uint4);
7013	ulong2 __ovld __cnfn as_ulong2(long2);
7014	ulong2 __ovld __cnfn as_ulong2(ulong2);
7015	ulong2 __ovld __cnfn as_ulong2(float3);
7016	ulong2 __ovld __cnfn as_ulong2(float4);
7017
7018	ulong3 __ovld __cnfn as_ulong3(short16);
7019	ulong3 __ovld __cnfn as_ulong3(ushort16);
7020	ulong3 __ovld __cnfn as_ulong3(int8);
7021	ulong3 __ovld __cnfn as_ulong3(uint8);
7022	ulong3 __ovld __cnfn as_ulong3(long3);
7023	ulong3 __ovld __cnfn as_ulong3(long4);
7024	ulong3 __ovld __cnfn as_ulong3(ulong3);
7025	ulong3 __ovld __cnfn as_ulong3(ulong4);
7026	ulong3 __ovld __cnfn as_ulong3(float8);
7027
7028	ulong4 __ovld __cnfn as_ulong4(short16);
7029	ulong4 __ovld __cnfn as_ulong4(ushort16);
7030	ulong4 __ovld __cnfn as_ulong4(int8);
7031	ulong4 __ovld __cnfn as_ulong4(uint8);
7032	ulong4 __ovld __cnfn as_ulong4(long3);
7033	ulong4 __ovld __cnfn as_ulong4(long4);
7034	ulong4 __ovld __cnfn as_ulong4(ulong3);
7035	ulong4 __ovld __cnfn as_ulong4(ulong4);
7036	ulong4 __ovld __cnfn as_ulong4(float8);
7037
7038	ulong8 __ovld __cnfn as_ulong8(int16);
7039	ulong8 __ovld __cnfn as_ulong8(uint16);
7040	ulong8 __ovld __cnfn as_ulong8(long8);
7041	ulong8 __ovld __cnfn as_ulong8(ulong8);
7042	ulong8 __ovld __cnfn as_ulong8(float16);
7043
7044	ulong16 __ovld __cnfn as_ulong16(long16);
7045	ulong16 __ovld __cnfn as_ulong16(ulong16);
7046
7047	float __ovld __cnfn as_float(char3);
7048	float __ovld __cnfn as_float(char4);
7049	float __ovld __cnfn as_float(uchar3);
7050	float __ovld __cnfn as_float(uchar4);
7051	float __ovld __cnfn as_float(short2);
7052	float __ovld __cnfn as_float(ushort2);
7053	float __ovld __cnfn as_float(int);
7054	float __ovld __cnfn as_float(uint);
7055	float __ovld __cnfn as_float(float);
7056
7057	float2 __ovld __cnfn as_float2(char8);
7058	float2 __ovld __cnfn as_float2(uchar8);
7059	float2 __ovld __cnfn as_float2(short3);
7060	float2 __ovld __cnfn as_float2(short4);
7061	float2 __ovld __cnfn as_float2(ushort3);
7062	float2 __ovld __cnfn as_float2(ushort4);
7063	float2 __ovld __cnfn as_float2(int2);
7064	float2 __ovld __cnfn as_float2(uint2);
7065	float2 __ovld __cnfn as_float2(long);
7066	float2 __ovld __cnfn as_float2(ulong);
7067	float2 __ovld __cnfn as_float2(float2);
7068
7069	float3 __ovld __cnfn as_float3(char16);
7070	float3 __ovld __cnfn as_float3(uchar16);
7071	float3 __ovld __cnfn as_float3(short8);
7072	float3 __ovld __cnfn as_float3(ushort8);
7073	float3 __ovld __cnfn as_float3(int3);
7074	float3 __ovld __cnfn as_float3(int4);
7075	float3 __ovld __cnfn as_float3(uint3);
7076	float3 __ovld __cnfn as_float3(uint4);
7077	float3 __ovld __cnfn as_float3(long2);
7078	float3 __ovld __cnfn as_float3(ulong2);
7079	float3 __ovld __cnfn as_float3(float3);
7080	float3 __ovld __cnfn as_float3(float4);
7081
7082	float4 __ovld __cnfn as_float4(char16);
7083	float4 __ovld __cnfn as_float4(uchar16);
7084	float4 __ovld __cnfn as_float4(short8);
7085	float4 __ovld __cnfn as_float4(ushort8);
7086	float4 __ovld __cnfn as_float4(int3);
7087	float4 __ovld __cnfn as_float4(int4);
7088	float4 __ovld __cnfn as_float4(uint3);
7089	float4 __ovld __cnfn as_float4(uint4);
7090	float4 __ovld __cnfn as_float4(long2);
7091	float4 __ovld __cnfn as_float4(ulong2);
7092	float4 __ovld __cnfn as_float4(float3);
7093	float4 __ovld __cnfn as_float4(float4);
7094
7095	float8 __ovld __cnfn as_float8(short16);
7096	float8 __ovld __cnfn as_float8(ushort16);
7097	float8 __ovld __cnfn as_float8(int8);
7098	float8 __ovld __cnfn as_float8(uint8);
7099	float8 __ovld __cnfn as_float8(long3);
7100	float8 __ovld __cnfn as_float8(long4);
7101	float8 __ovld __cnfn as_float8(ulong3);
7102	float8 __ovld __cnfn as_float8(ulong4);
7103	float8 __ovld __cnfn as_float8(float8);
7104
7105	float16 __ovld __cnfn as_float16(int16);
7106	float16 __ovld __cnfn as_float16(uint16);
7107	float16 __ovld __cnfn as_float16(long8);
7108	float16 __ovld __cnfn as_float16(ulong8);
7109	float16 __ovld __cnfn as_float16(float16);
7110		6649
7111	#ifdef cl_khr_fp64	6650	#ifdef cl_khr_fp64
7112	char8 __ovld __cnfn as_char8(double);	6651	#define as_double(x) __builtin_astype((x), double)
7113	char16 __ovld __cnfn as_char16(double2);	6652	#define as_double2(x) __builtin_astype((x), double2)
7114	uchar8 __ovld __cnfn as_uchar8(double);	6653	#define as_double3(x) __builtin_astype((x), double3)
7115	uchar16 __ovld __cnfn as_uchar16(double2);	6654	#define as_double4(x) __builtin_astype((x), double4)
7116	short3 __ovld __cnfn as_short3(double);	6655	#define as_double8(x) __builtin_astype((x), double8)
7117	short4 __ovld __cnfn as_short4(double);	6656	#define as_double16(x) __builtin_astype((x), double16)
7118	short8 __ovld __cnfn as_short8(double2);
7119	short16 __ovld __cnfn as_short16(double3);
7120	short16 __ovld __cnfn as_short16(double4);
7121	ushort3 __ovld __cnfn as_ushort3(double);
7122	ushort4 __ovld __cnfn as_ushort4(double);
7123	ushort8 __ovld __cnfn as_ushort8(double2);
7124	ushort16 __ovld __cnfn as_ushort16(double3);
7125	ushort16 __ovld __cnfn as_ushort16(double4);
7126	int2 __ovld __cnfn as_int2(double);
7127	int3 __ovld __cnfn as_int3(double2);
7128	int4 __ovld __cnfn as_int4(double2);
7129	int8 __ovld __cnfn as_int8(double3);
7130	int8 __ovld __cnfn as_int8(double4);
7131	int16 __ovld __cnfn as_int16(double8);
7132	uint2 __ovld __cnfn as_uint2(double);
7133	uint3 __ovld __cnfn as_uint3(double2);
7134	uint4 __ovld __cnfn as_uint4(double2);
7135	uint8 __ovld __cnfn as_uint8(double3);
7136	uint8 __ovld __cnfn as_uint8(double4);
7137	uint16 __ovld __cnfn as_uint16(double8);
7138	long __ovld __cnfn as_long(double);
7139	long2 __ovld __cnfn as_long2(double2);
7140	long3 __ovld __cnfn as_long3(double3);
7141	long3 __ovld __cnfn as_long3(double4);
7142	long4 __ovld __cnfn as_long4(double3);
7143	long4 __ovld __cnfn as_long4(double4);
7144	long8 __ovld __cnfn as_long8(double8);
7145	long16 __ovld __cnfn as_long16(double16);
7146	ulong __ovld __cnfn as_ulong(double);
7147	ulong2 __ovld __cnfn as_ulong2(double2);
7148	ulong3 __ovld __cnfn as_ulong3(double3);
7149	ulong3 __ovld __cnfn as_ulong3(double4);
7150	ulong4 __ovld __cnfn as_ulong4(double3);
7151	ulong4 __ovld __cnfn as_ulong4(double4);
7152	ulong8 __ovld __cnfn as_ulong8(double8);
7153	ulong16 __ovld __cnfn as_ulong16(double16);
7154	float2 __ovld __cnfn as_float2(double);
7155	float3 __ovld __cnfn as_float3(double2);
7156	float4 __ovld __cnfn as_float4(double2);
7157	float8 __ovld __cnfn as_float8(double3);
7158	float8 __ovld __cnfn as_float8(double4);
7159	float16 __ovld __cnfn as_float16(double8);
7160	double __ovld __cnfn as_double(char8);
7161	double __ovld __cnfn as_double(uchar8);
7162	double __ovld __cnfn as_double(short3);
7163	double __ovld __cnfn as_double(short4);
7164	double __ovld __cnfn as_double(ushort3);
7165	double __ovld __cnfn as_double(ushort4);
7166	double __ovld __cnfn as_double(int2);
7167	double __ovld __cnfn as_double(uint2);
7168	double __ovld __cnfn as_double(long);
7169	double __ovld __cnfn as_double(ulong);
7170	double __ovld __cnfn as_double(float2);
7171	double __ovld __cnfn as_double(double);
7172	double2 __ovld __cnfn as_double2(char16);
7173	double2 __ovld __cnfn as_double2(uchar16);
7174	double2 __ovld __cnfn as_double2(short8);
7175	double2 __ovld __cnfn as_double2(ushort8);
7176	double2 __ovld __cnfn as_double2(int3);
7177	double2 __ovld __cnfn as_double2(int4);
7178	double2 __ovld __cnfn as_double2(uint3);
7179	double2 __ovld __cnfn as_double2(uint4);
7180	double2 __ovld __cnfn as_double2(long2);
7181	double2 __ovld __cnfn as_double2(ulong2);
7182	double2 __ovld __cnfn as_double2(float3);
7183	double2 __ovld __cnfn as_double2(float4);
7184	double2 __ovld __cnfn as_double2(double2);
7185	double3 __ovld __cnfn as_double3(short16);
7186	double3 __ovld __cnfn as_double3(ushort16);
7187	double3 __ovld __cnfn as_double3(int8);
7188	double3 __ovld __cnfn as_double3(uint8);
7189	double3 __ovld __cnfn as_double3(long3);
7190	double3 __ovld __cnfn as_double3(long4);
7191	double3 __ovld __cnfn as_double3(ulong3);
7192	double3 __ovld __cnfn as_double3(ulong4);
7193	double3 __ovld __cnfn as_double3(float8);
7194	double3 __ovld __cnfn as_double3(double3);
7195	double3 __ovld __cnfn as_double3(double4);
7196	double4 __ovld __cnfn as_double4(short16);
7197	double4 __ovld __cnfn as_double4(ushort16);
7198	double4 __ovld __cnfn as_double4(int8);
7199	double4 __ovld __cnfn as_double4(uint8);
7200	double4 __ovld __cnfn as_double4(long3);
7201	double4 __ovld __cnfn as_double4(long4);
7202	double4 __ovld __cnfn as_double4(ulong3);
7203	double4 __ovld __cnfn as_double4(ulong4);
7204	double4 __ovld __cnfn as_double4(float8);
7205	double4 __ovld __cnfn as_double4(double3);
7206	double4 __ovld __cnfn as_double4(double4);
7207	double8 __ovld __cnfn as_double8(int16);
7208	double8 __ovld __cnfn as_double8(uint16);
7209	double8 __ovld __cnfn as_double8(long8);
7210	double8 __ovld __cnfn as_double8(ulong8);
7211	double8 __ovld __cnfn as_double8(float16);
7212	double8 __ovld __cnfn as_double8(double8);
7213	double16 __ovld __cnfn as_double16(long16);
7214	double16 __ovld __cnfn as_double16(ulong16);
7215	double16 __ovld __cnfn as_double16(double16);
7216	#endif //cl_khr_fp64	6657	#endif //cl_khr_fp64
7217		6658
7218	#ifdef cl_khr_fp16	6659	#ifdef cl_khr_fp16
7219	char2 __ovld __cnfn as_char2(half);	6660	#define as_half(x) __builtin_astype((x), half)
7220	char3 __ovld __cnfn as_char3(half2);	6661	#define as_half2(x) __builtin_astype((x), half2)
7221	char4 __ovld __cnfn as_char4(half2);	6662	#define as_half3(x) __builtin_astype((x), half3)
7222	char8 __ovld __cnfn as_char8(half3);	6663	#define as_half4(x) __builtin_astype((x), half4)
7223	char8 __ovld __cnfn as_char8(half4);	6664	#define as_half8(x) __builtin_astype((x), half8)
7224	char16 __ovld __cnfn as_char16(half8);	6665	#define as_half16(x) __builtin_astype((x), half16)
7225	uchar2 __ovld __cnfn as_uchar2(half);
7226	uchar3 __ovld __cnfn as_uchar3(half2);
7227	uchar4 __ovld __cnfn as_uchar4(half2);
7228	uchar8 __ovld __cnfn as_uchar8(half3);
7229	uchar8 __ovld __cnfn as_uchar8(half4);
7230	uchar16 __ovld __cnfn as_uchar16(half8);
7231	short __ovld __cnfn as_short(half);
7232	short2 __ovld __cnfn as_short2(half2);
7233	short3 __ovld __cnfn as_short3(half3);
7234	short3 __ovld __cnfn as_short3(half4);
7235	short4 __ovld __cnfn as_short4(half3);
7236	short4 __ovld __cnfn as_short4(half4);
7237	short8 __ovld __cnfn as_short8(half8);
7238	short16 __ovld __cnfn as_short16(half16);
7239	ushort __ovld __cnfn as_ushort(half);
7240	ushort2 __ovld __cnfn as_ushort2(half2);
7241	ushort3 __ovld __cnfn as_ushort3(half3);
7242	ushort3 __ovld __cnfn as_ushort3(half4);
7243	ushort4 __ovld __cnfn as_ushort4(half3);
7244	ushort4 __ovld __cnfn as_ushort4(half4);
7245	ushort8 __ovld __cnfn as_ushort8(half8);
7246	ushort16 __ovld __cnfn as_ushort16(half16);
7247	int __ovld __cnfn as_int(half2);
7248	int2 __ovld __cnfn as_int2(half3);
7249	int2 __ovld __cnfn as_int2(half4);
7250	int3 __ovld __cnfn as_int3(half8);
7251	int4 __ovld __cnfn as_int4(half8);
7252	int8 __ovld __cnfn as_int8(half16);
7253	uint __ovld __cnfn as_uint(half2);
7254	uint2 __ovld __cnfn as_uint2(half3);
7255	uint2 __ovld __cnfn as_uint2(half4);
7256	uint3 __ovld __cnfn as_uint3(half8);
7257	uint4 __ovld __cnfn as_uint4(half8);
7258	uint8 __ovld __cnfn as_uint8(half16);
7259	long __ovld __cnfn as_long(half3);
7260	long __ovld __cnfn as_long(half4);
7261	long2 __ovld __cnfn as_long2(half8);
7262	long3 __ovld __cnfn as_long3(half16);
7263	long4 __ovld __cnfn as_long4(half16);
7264	ulong __ovld __cnfn as_ulong(half3);
7265	ulong __ovld __cnfn as_ulong(half4);
7266	ulong2 __ovld __cnfn as_ulong2(half8);
7267	ulong3 __ovld __cnfn as_ulong3(half16);
7268	ulong4 __ovld __cnfn as_ulong4(half16);
7269	half __ovld __cnfn as_half(char2);
7270	half __ovld __cnfn as_half(uchar2);
7271	half __ovld __cnfn as_half(short);
7272	half __ovld __cnfn as_half(ushort);
7273	half __ovld __cnfn as_half(half);
7274	half2 __ovld __cnfn as_half2(char3);
7275	half2 __ovld __cnfn as_half2(char4);
7276	half2 __ovld __cnfn as_half2(uchar3);
7277	half2 __ovld __cnfn as_half2(uchar4);
7278	half2 __ovld __cnfn as_half2(short2);
7279	half2 __ovld __cnfn as_half2(ushort2);
7280	half2 __ovld __cnfn as_half2(int);
7281	half2 __ovld __cnfn as_half2(uint);
7282	half2 __ovld __cnfn as_half2(half2);
7283	half2 __ovld __cnfn as_half2(float);
7284	half3 __ovld __cnfn as_half3(char8);
7285	half3 __ovld __cnfn as_half3(uchar8);
7286	half3 __ovld __cnfn as_half3(short3);
7287	half3 __ovld __cnfn as_half3(short4);
7288	half3 __ovld __cnfn as_half3(ushort3);
7289	half3 __ovld __cnfn as_half3(ushort4);
7290	half3 __ovld __cnfn as_half3(int2);
7291	half3 __ovld __cnfn as_half3(uint2);
7292	half3 __ovld __cnfn as_half3(long);
7293	half3 __ovld __cnfn as_half3(ulong);
7294	half3 __ovld __cnfn as_half3(half3);
7295	half3 __ovld __cnfn as_half3(half4);
7296	half3 __ovld __cnfn as_half3(float2);
7297	half4 __ovld __cnfn as_half4(char8);
7298	half4 __ovld __cnfn as_half4(uchar8);
7299	half4 __ovld __cnfn as_half4(short3);
7300	half4 __ovld __cnfn as_half4(short4);
7301	half4 __ovld __cnfn as_half4(ushort3);
7302	half4 __ovld __cnfn as_half4(ushort4);
7303	half4 __ovld __cnfn as_half4(int2);
7304	half4 __ovld __cnfn as_half4(uint2);
7305	half4 __ovld __cnfn as_half4(long);
7306	half4 __ovld __cnfn as_half4(ulong);
7307	half4 __ovld __cnfn as_half4(half3);
7308	half4 __ovld __cnfn as_half4(half4);
7309	half4 __ovld __cnfn as_half4(float2);
7310	half8 __ovld __cnfn as_half8(char16);
7311	half8 __ovld __cnfn as_half8(uchar16);
7312	half8 __ovld __cnfn as_half8(short8);
7313	half8 __ovld __cnfn as_half8(ushort8);
7314	half8 __ovld __cnfn as_half8(int3);
7315	half8 __ovld __cnfn as_half8(int4);
7316	half8 __ovld __cnfn as_half8(uint3);
7317	half8 __ovld __cnfn as_half8(uint4);
7318	half8 __ovld __cnfn as_half8(long2);
7319	half8 __ovld __cnfn as_half8(ulong2);
7320	half8 __ovld __cnfn as_half8(half8);
7321	half8 __ovld __cnfn as_half8(float3);
7322	half8 __ovld __cnfn as_half8(float4);
7323	half16 __ovld __cnfn as_half16(short16);
7324	half16 __ovld __cnfn as_half16(ushort16);
7325	half16 __ovld __cnfn as_half16(int8);
7326	half16 __ovld __cnfn as_half16(uint8);
7327	half16 __ovld __cnfn as_half16(long3);
7328	half16 __ovld __cnfn as_half16(long4);
7329	half16 __ovld __cnfn as_half16(ulong3);
7330	half16 __ovld __cnfn as_half16(ulong4);
7331	half16 __ovld __cnfn as_half16(half16);
7332	half16 __ovld __cnfn as_half16(float8);
7333	float __ovld __cnfn as_float(half2);
7334	float2 __ovld __cnfn as_float2(half3);
7335	float2 __ovld __cnfn as_float2(half4);
7336	float3 __ovld __cnfn as_float3(half8);
7337	float4 __ovld __cnfn as_float4(half8);
7338	float8 __ovld __cnfn as_float8(half16);
7339
7340	#ifdef cl_khr_fp64
7341	half3 __ovld __cnfn as_half3(double);
7342	half4 __ovld __cnfn as_half4(double);
7343	half8 __ovld __cnfn as_half8(double2);
7344	half16 __ovld __cnfn as_half16(double3);
7345	half16 __ovld __cnfn as_half16(double4);
7346	double __ovld __cnfn as_double(half3);
7347	double __ovld __cnfn as_double(half4);
7348	double2 __ovld __cnfn as_double2(half8);
7349	double3 __ovld __cnfn as_double3(half16);
7350	double4 __ovld __cnfn as_double4(half16);
7351	#endif //cl_khr_fp64
7352	#endif //cl_khr_fp16	6666	#endif //cl_khr_fp16
7353		6667
7354	// OpenCL v1.1 s6.9, v1.2/2.0 s6.10 - Function qualifiers	6668	// OpenCL v1.1 s6.9, v1.2/2.0 s6.10 - Function qualifiers
...	@@ -14389,10 +13703,10 @@ float __ovld atomic_xchg(volatile __local float *p, float val);	...	@@ -14389,10 +13703,10 @@ float __ovld atomic_xchg(volatile __local float *p, float val);
14389		13703
14390	#if defined(cl_khr_global_int32_base_atomics)	13704	#if defined(cl_khr_global_int32_base_atomics)
14391	int __ovld atom_xchg(volatile __global int *p, int val);	13705	int __ovld atom_xchg(volatile __global int *p, int val);
14392	int __ovld atom_xchg(volatile __local int *p, int val);	13706	unsigned int __ovld atom_xchg(volatile __global unsigned int *p, unsigned int val);
14393	#endif	13707	#endif
14394	#if defined(cl_khr_local_int32_base_atomics)	13708	#if defined(cl_khr_local_int32_base_atomics)
14395	unsigned int __ovld atom_xchg(volatile __global unsigned int *p, unsigned int val);	13709	int __ovld atom_xchg(volatile __local int *p, int val);
14396	unsigned int __ovld atom_xchg(volatile __local unsigned int *p, unsigned int val);	13710	unsigned int __ovld atom_xchg(volatile __local unsigned int *p, unsigned int val);
14397	#endif	13711	#endif
14398		13712
...	@@ -14509,8 +13823,6 @@ unsigned int __ovld atom_min(volatile __local unsigned int *p, unsigned int val)	...	@@ -14509,8 +13823,6 @@ unsigned int __ovld atom_min(volatile __local unsigned int *p, unsigned int val)
14509	#if defined(cl_khr_int64_extended_atomics)	13823	#if defined(cl_khr_int64_extended_atomics)
14510	long __ovld atom_min(volatile __global long *p, long val);	13824	long __ovld atom_min(volatile __global long *p, long val);
14511	unsigned long __ovld atom_min(volatile __global unsigned long *p, unsigned long val);	13825	unsigned long __ovld atom_min(volatile __global unsigned long *p, unsigned long val);
14512	#endif
14513	#if defined(cl_khr_local_int32_extended_atomics)
14514	long __ovld atom_min(volatile __local long *p, long val);	13826	long __ovld atom_min(volatile __local long *p, long val);
14515	unsigned long __ovld atom_min(volatile __local unsigned long *p, unsigned long val);	13827	unsigned long __ovld atom_min(volatile __local unsigned long *p, unsigned long val);
14516	#endif	13828	#endif
...	@@ -15650,6 +14962,7 @@ float __purefn __ovld read_imagef(read_only image2d_array_msaa_depth_t image, in	...	@@ -15650,6 +14962,7 @@ float __purefn __ovld read_imagef(read_only image2d_array_msaa_depth_t image, in
15650	#endif //cl_khr_gl_msaa_sharing	14962	#endif //cl_khr_gl_msaa_sharing
15651		14963
15652	// OpenCL Extension v2.0 s9.18 - Mipmaps	14964	// OpenCL Extension v2.0 s9.18 - Mipmaps
		14965	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
15653	#ifdef cl_khr_mipmap_image	14966	#ifdef cl_khr_mipmap_image
15654		14967
15655	float4 __purefn __ovld read_imagef(read_only image1d_t image, sampler_t sampler, float coord, float lod);	14968	float4 __purefn __ovld read_imagef(read_only image1d_t image, sampler_t sampler, float coord, float lod);
...	@@ -15725,6 +15038,7 @@ int4 __purefn __ovld read_imagei(read_only image3d_t image, sampler_t sampler, f	...	@@ -15725,6 +15038,7 @@ int4 __purefn __ovld read_imagei(read_only image3d_t image, sampler_t sampler, f
15725	uint4 __purefn __ovld read_imageui(read_only image3d_t image, sampler_t sampler, float4 coord, float lod);	15038	uint4 __purefn __ovld read_imageui(read_only image3d_t image, sampler_t sampler, float4 coord, float lod);
15726		15039
15727	#endif //cl_khr_mipmap_image	15040	#endif //cl_khr_mipmap_image
		15041	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
15728		15042
15729	/**	15043	/**
15730	* Sampler-less Image Access	15044	* Sampler-less Image Access
...	@@ -15823,6 +15137,7 @@ float __purefn __ovld read_imagef(read_write image2d_msaa_depth_t image, int2 co	...	@@ -15823,6 +15137,7 @@ float __purefn __ovld read_imagef(read_write image2d_msaa_depth_t image, int2 co
15823	float __purefn __ovld read_imagef(read_write image2d_array_msaa_depth_t image, int4 coord, int sample);	15137	float __purefn __ovld read_imagef(read_write image2d_array_msaa_depth_t image, int4 coord, int sample);
15824	#endif //cl_khr_gl_msaa_sharing	15138	#endif //cl_khr_gl_msaa_sharing
15825		15139
		15140	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
15826	#ifdef cl_khr_mipmap_image	15141	#ifdef cl_khr_mipmap_image
15827	float4 __purefn __ovld read_imagef(read_write image1d_t image, sampler_t sampler, float coord, float lod);	15142	float4 __purefn __ovld read_imagef(read_write image1d_t image, sampler_t sampler, float coord, float lod);
15828	int4 __purefn __ovld read_imagei(read_write image1d_t image, sampler_t sampler, float coord, float lod);	15143	int4 __purefn __ovld read_imagei(read_write image1d_t image, sampler_t sampler, float coord, float lod);
...	@@ -15896,6 +15211,7 @@ float4 __purefn __ovld read_imagef(read_write image3d_t image, sampler_t sampler	...	@@ -15896,6 +15211,7 @@ float4 __purefn __ovld read_imagef(read_write image3d_t image, sampler_t sampler
15896	int4 __purefn __ovld read_imagei(read_write image3d_t image, sampler_t sampler, float4 coord, float lod);	15211	int4 __purefn __ovld read_imagei(read_write image3d_t image, sampler_t sampler, float4 coord, float lod);
15897	uint4 __purefn __ovld read_imageui(read_write image3d_t image, sampler_t sampler, float4 coord, float lod);	15212	uint4 __purefn __ovld read_imageui(read_write image3d_t image, sampler_t sampler, float4 coord, float lod);
15898	#endif //cl_khr_mipmap_image	15213	#endif //cl_khr_mipmap_image
		15214	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
15899		15215
15900	// Image read functions returning half4 type	15216	// Image read functions returning half4 type
15901	#ifdef cl_khr_fp16	15217	#ifdef cl_khr_fp16
...	@@ -15995,9 +15311,11 @@ void __ovld write_imagef(write_only image1d_array_t image_array, int2 coord, flo	...	@@ -15995,9 +15311,11 @@ void __ovld write_imagef(write_only image1d_array_t image_array, int2 coord, flo
15995	void __ovld write_imagei(write_only image1d_array_t image_array, int2 coord, int4 color);	15311	void __ovld write_imagei(write_only image1d_array_t image_array, int2 coord, int4 color);
15996	void __ovld write_imageui(write_only image1d_array_t image_array, int2 coord, uint4 color);	15312	void __ovld write_imageui(write_only image1d_array_t image_array, int2 coord, uint4 color);
15997		15313
		15314	#ifdef cl_khr_3d_image_writes
15998	void __ovld write_imagef(write_only image3d_t image, int4 coord, float4 color);	15315	void __ovld write_imagef(write_only image3d_t image, int4 coord, float4 color);
15999	void __ovld write_imagei(write_only image3d_t image, int4 coord, int4 color);	15316	void __ovld write_imagei(write_only image3d_t image, int4 coord, int4 color);
16000	void __ovld write_imageui(write_only image3d_t image, int4 coord, uint4 color);	15317	void __ovld write_imageui(write_only image3d_t image, int4 coord, uint4 color);
		15318	#endif
16001		15319
16002	#ifdef cl_khr_depth_images	15320	#ifdef cl_khr_depth_images
16003	void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, float color);	15321	void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, float color);
...	@@ -16005,6 +15323,7 @@ void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, flo	...	@@ -16005,6 +15323,7 @@ void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, flo
16005	#endif //cl_khr_depth_images	15323	#endif //cl_khr_depth_images
16006		15324
16007	// OpenCL Extension v2.0 s9.18 - Mipmaps	15325	// OpenCL Extension v2.0 s9.18 - Mipmaps
		15326	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
16008	#ifdef cl_khr_mipmap_image	15327	#ifdef cl_khr_mipmap_image
16009	void __ovld write_imagef(write_only image1d_t image, int coord, int lod, float4 color);	15328	void __ovld write_imagef(write_only image1d_t image, int coord, int lod, float4 color);
16010	void __ovld write_imagei(write_only image1d_t image, int coord, int lod, int4 color);	15329	void __ovld write_imagei(write_only image1d_t image, int coord, int lod, int4 color);
...	@@ -16025,16 +15344,21 @@ void __ovld write_imageui(write_only image2d_array_t image_array, int4 coord, in	...	@@ -16025,16 +15344,21 @@ void __ovld write_imageui(write_only image2d_array_t image_array, int4 coord, in
16025	void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, int lod, float color);	15344	void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, int lod, float color);
16026	void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, int lod, float color);	15345	void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, int lod, float color);
16027		15346
		15347	#ifdef cl_khr_3d_image_writes
16028	void __ovld write_imagef(write_only image3d_t image, int4 coord, int lod, float4 color);	15348	void __ovld write_imagef(write_only image3d_t image, int4 coord, int lod, float4 color);
16029	void __ovld write_imagei(write_only image3d_t image, int4 coord, int lod, int4 color);	15349	void __ovld write_imagei(write_only image3d_t image, int4 coord, int lod, int4 color);
16030	void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4 color);	15350	void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4 color);
		15351	#endif
16031	#endif //cl_khr_mipmap_image	15352	#endif //cl_khr_mipmap_image
		15353	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
16032		15354
16033	// Image write functions for half4 type	15355	// Image write functions for half4 type
16034	#ifdef cl_khr_fp16	15356	#ifdef cl_khr_fp16
16035	void __ovld write_imageh(write_only image1d_t image, int coord, half4 color);	15357	void __ovld write_imageh(write_only image1d_t image, int coord, half4 color);
16036	void __ovld write_imageh(write_only image2d_t image, int2 coord, half4 color);	15358	void __ovld write_imageh(write_only image2d_t image, int2 coord, half4 color);
		15359	#ifdef cl_khr_3d_image_writes
16037	void __ovld write_imageh(write_only image3d_t image, int4 coord, half4 color);	15360	void __ovld write_imageh(write_only image3d_t image, int4 coord, half4 color);
		15361	#endif
16038	void __ovld write_imageh(write_only image1d_array_t image, int2 coord, half4 color);	15362	void __ovld write_imageh(write_only image1d_array_t image, int2 coord, half4 color);
16039	void __ovld write_imageh(write_only image2d_array_t image, int4 coord, half4 color);	15363	void __ovld write_imageh(write_only image2d_array_t image, int4 coord, half4 color);
16040	void __ovld write_imageh(write_only image1d_buffer_t image, int coord, half4 color);	15364	void __ovld write_imageh(write_only image1d_buffer_t image, int coord, half4 color);
...	@@ -16062,15 +15386,18 @@ void __ovld write_imagef(read_write image1d_array_t image_array, int2 coord, flo	...	@@ -16062,15 +15386,18 @@ void __ovld write_imagef(read_write image1d_array_t image_array, int2 coord, flo
16062	void __ovld write_imagei(read_write image1d_array_t image_array, int2 coord, int4 color);	15386	void __ovld write_imagei(read_write image1d_array_t image_array, int2 coord, int4 color);
16063	void __ovld write_imageui(read_write image1d_array_t image_array, int2 coord, uint4 color);	15387	void __ovld write_imageui(read_write image1d_array_t image_array, int2 coord, uint4 color);
16064		15388
		15389	#ifdef cl_khr_3d_image_writes
16065	void __ovld write_imagef(read_write image3d_t image, int4 coord, float4 color);	15390	void __ovld write_imagef(read_write image3d_t image, int4 coord, float4 color);
16066	void __ovld write_imagei(read_write image3d_t image, int4 coord, int4 color);	15391	void __ovld write_imagei(read_write image3d_t image, int4 coord, int4 color);
16067	void __ovld write_imageui(read_write image3d_t image, int4 coord, uint4 color);	15392	void __ovld write_imageui(read_write image3d_t image, int4 coord, uint4 color);
		15393	#endif
16068		15394
16069	#ifdef cl_khr_depth_images	15395	#ifdef cl_khr_depth_images
16070	void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, float color);	15396	void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, float color);
16071	void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, float color);	15397	void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, float color);
16072	#endif //cl_khr_depth_images	15398	#endif //cl_khr_depth_images
16073		15399
		15400	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
16074	#ifdef cl_khr_mipmap_image	15401	#ifdef cl_khr_mipmap_image
16075	void __ovld write_imagef(read_write image1d_t image, int coord, int lod, float4 color);	15402	void __ovld write_imagef(read_write image1d_t image, int coord, int lod, float4 color);
16076	void __ovld write_imagei(read_write image1d_t image, int coord, int lod, int4 color);	15403	void __ovld write_imagei(read_write image1d_t image, int coord, int lod, int4 color);
...	@@ -16091,16 +15418,21 @@ void __ovld write_imageui(read_write image2d_array_t image_array, int4 coord, in	...	@@ -16091,16 +15418,21 @@ void __ovld write_imageui(read_write image2d_array_t image_array, int4 coord, in
16091	void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, int lod, float color);	15418	void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, int lod, float color);
16092	void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, int lod, float color);	15419	void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, int lod, float color);
16093		15420
		15421	#ifdef cl_khr_3d_image_writes
16094	void __ovld write_imagef(read_write image3d_t image, int4 coord, int lod, float4 color);	15422	void __ovld write_imagef(read_write image3d_t image, int4 coord, int lod, float4 color);
16095	void __ovld write_imagei(read_write image3d_t image, int4 coord, int lod, int4 color);	15423	void __ovld write_imagei(read_write image3d_t image, int4 coord, int lod, int4 color);
16096	void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4 color);	15424	void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4 color);
		15425	#endif
16097	#endif //cl_khr_mipmap_image	15426	#endif //cl_khr_mipmap_image
		15427	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
16098		15428
16099	// Image write functions for half4 type	15429	// Image write functions for half4 type
16100	#ifdef cl_khr_fp16	15430	#ifdef cl_khr_fp16
16101	void __ovld write_imageh(read_write image1d_t image, int coord, half4 color);	15431	void __ovld write_imageh(read_write image1d_t image, int coord, half4 color);
16102	void __ovld write_imageh(read_write image2d_t image, int2 coord, half4 color);	15432	void __ovld write_imageh(read_write image2d_t image, int2 coord, half4 color);
		15433	#ifdef cl_khr_3d_image_writes
16103	void __ovld write_imageh(read_write image3d_t image, int4 coord, half4 color);	15434	void __ovld write_imageh(read_write image3d_t image, int4 coord, half4 color);
		15435	#endif
16104	void __ovld write_imageh(read_write image1d_array_t image, int2 coord, half4 color);	15436	void __ovld write_imageh(read_write image1d_array_t image, int2 coord, half4 color);
16105	void __ovld write_imageh(read_write image2d_array_t image, int4 coord, half4 color);	15437	void __ovld write_imageh(read_write image2d_array_t image, int4 coord, half4 color);
16106	void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 color);	15438	void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 color);
...	@@ -16118,7 +15450,9 @@ void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 col	...	@@ -16118,7 +15450,9 @@ void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 col
16118	int __ovld __cnfn get_image_width(read_only image1d_t image);	15450	int __ovld __cnfn get_image_width(read_only image1d_t image);
16119	int __ovld __cnfn get_image_width(read_only image1d_buffer_t image);	15451	int __ovld __cnfn get_image_width(read_only image1d_buffer_t image);
16120	int __ovld __cnfn get_image_width(read_only image2d_t image);	15452	int __ovld __cnfn get_image_width(read_only image2d_t image);
		15453	#ifdef cl_khr_3d_image_writes
16121	int __ovld __cnfn get_image_width(read_only image3d_t image);	15454	int __ovld __cnfn get_image_width(read_only image3d_t image);
		15455	#endif
16122	int __ovld __cnfn get_image_width(read_only image1d_array_t image);	15456	int __ovld __cnfn get_image_width(read_only image1d_array_t image);
16123	int __ovld __cnfn get_image_width(read_only image2d_array_t image);	15457	int __ovld __cnfn get_image_width(read_only image2d_array_t image);
16124	#ifdef cl_khr_depth_images	15458	#ifdef cl_khr_depth_images
...	@@ -16135,7 +15469,9 @@ int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t image);	...	@@ -16135,7 +15469,9 @@ int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t image);
16135	int __ovld __cnfn get_image_width(write_only image1d_t image);	15469	int __ovld __cnfn get_image_width(write_only image1d_t image);
16136	int __ovld __cnfn get_image_width(write_only image1d_buffer_t image);	15470	int __ovld __cnfn get_image_width(write_only image1d_buffer_t image);
16137	int __ovld __cnfn get_image_width(write_only image2d_t image);	15471	int __ovld __cnfn get_image_width(write_only image2d_t image);
		15472	#ifdef cl_khr_3d_image_writes
16138	int __ovld __cnfn get_image_width(write_only image3d_t image);	15473	int __ovld __cnfn get_image_width(write_only image3d_t image);
		15474	#endif
16139	int __ovld __cnfn get_image_width(write_only image1d_array_t image);	15475	int __ovld __cnfn get_image_width(write_only image1d_array_t image);
16140	int __ovld __cnfn get_image_width(write_only image2d_array_t image);	15476	int __ovld __cnfn get_image_width(write_only image2d_array_t image);
16141	#ifdef cl_khr_depth_images	15477	#ifdef cl_khr_depth_images
...	@@ -16186,7 +15522,9 @@ int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t image);	...	@@ -16186,7 +15522,9 @@ int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t image);
16186	#endif //cl_khr_gl_msaa_sharing	15522	#endif //cl_khr_gl_msaa_sharing
16187		15523
16188	int __ovld __cnfn get_image_height(write_only image2d_t image);	15524	int __ovld __cnfn get_image_height(write_only image2d_t image);
		15525	#ifdef cl_khr_3d_image_writes
16189	int __ovld __cnfn get_image_height(write_only image3d_t image);	15526	int __ovld __cnfn get_image_height(write_only image3d_t image);
		15527	#endif
16190	int __ovld __cnfn get_image_height(write_only image2d_array_t image);	15528	int __ovld __cnfn get_image_height(write_only image2d_array_t image);
16191	#ifdef cl_khr_depth_images	15529	#ifdef cl_khr_depth_images
16192	int __ovld __cnfn get_image_height(write_only image2d_depth_t image);	15530	int __ovld __cnfn get_image_height(write_only image2d_depth_t image);
...	@@ -16220,13 +15558,16 @@ int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t image);	...	@@ -16220,13 +15558,16 @@ int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t image);
16220	*/	15558	*/
16221	int __ovld __cnfn get_image_depth(read_only image3d_t image);	15559	int __ovld __cnfn get_image_depth(read_only image3d_t image);
16222		15560
		15561	#ifdef cl_khr_3d_image_writes
16223	int __ovld __cnfn get_image_depth(write_only image3d_t image);	15562	int __ovld __cnfn get_image_depth(write_only image3d_t image);
		15563	#endif
16224		15564
16225	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0	15565	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
16226	int __ovld __cnfn get_image_depth(read_write image3d_t image);	15566	int __ovld __cnfn get_image_depth(read_write image3d_t image);
16227	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0	15567	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
16228		15568
16229	// OpenCL Extension v2.0 s9.18 - Mipmaps	15569	// OpenCL Extension v2.0 s9.18 - Mipmaps
		15570	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
16230	#ifdef cl_khr_mipmap_image	15571	#ifdef cl_khr_mipmap_image
16231	/**	15572	/**
16232	* Return the image miplevels.	15573	* Return the image miplevels.
...	@@ -16238,13 +15579,13 @@ int __ovld get_image_num_mip_levels(read_only image3d_t image);	...	@@ -16238,13 +15579,13 @@ int __ovld get_image_num_mip_levels(read_only image3d_t image);
16238		15579
16239	int __ovld get_image_num_mip_levels(write_only image1d_t image);	15580	int __ovld get_image_num_mip_levels(write_only image1d_t image);
16240	int __ovld get_image_num_mip_levels(write_only image2d_t image);	15581	int __ovld get_image_num_mip_levels(write_only image2d_t image);
		15582	#ifdef cl_khr_3d_image_writes
16241	int __ovld get_image_num_mip_levels(write_only image3d_t image);	15583	int __ovld get_image_num_mip_levels(write_only image3d_t image);
		15584	#endif
16242		15585
16243	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
16244	int __ovld get_image_num_mip_levels(read_write image1d_t image);	15586	int __ovld get_image_num_mip_levels(read_write image1d_t image);
16245	int __ovld get_image_num_mip_levels(read_write image2d_t image);	15587	int __ovld get_image_num_mip_levels(read_write image2d_t image);
16246	int __ovld get_image_num_mip_levels(read_write image3d_t image);	15588	int __ovld get_image_num_mip_levels(read_write image3d_t image);
16247	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
16248		15589
16249	int __ovld get_image_num_mip_levels(read_only image1d_array_t image);	15590	int __ovld get_image_num_mip_levels(read_only image1d_array_t image);
16250	int __ovld get_image_num_mip_levels(read_only image2d_array_t image);	15591	int __ovld get_image_num_mip_levels(read_only image2d_array_t image);
...	@@ -16256,14 +15597,13 @@ int __ovld get_image_num_mip_levels(write_only image2d_array_t image);	...	@@ -16256,14 +15597,13 @@ int __ovld get_image_num_mip_levels(write_only image2d_array_t image);
16256	int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t image);	15597	int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t image);
16257	int __ovld get_image_num_mip_levels(write_only image2d_depth_t image);	15598	int __ovld get_image_num_mip_levels(write_only image2d_depth_t image);
16258		15599
16259	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
16260	int __ovld get_image_num_mip_levels(read_write image1d_array_t image);	15600	int __ovld get_image_num_mip_levels(read_write image1d_array_t image);
16261	int __ovld get_image_num_mip_levels(read_write image2d_array_t image);	15601	int __ovld get_image_num_mip_levels(read_write image2d_array_t image);
16262	int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t image);	15602	int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t image);
16263	int __ovld get_image_num_mip_levels(read_write image2d_depth_t image);	15603	int __ovld get_image_num_mip_levels(read_write image2d_depth_t image);
16264	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
16265		15604
16266	#endif //cl_khr_mipmap_image	15605	#endif //cl_khr_mipmap_image
		15606	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
16267		15607
16268	/**	15608	/**
16269	* Return the channel data type. Valid values are:	15609	* Return the channel data type. Valid values are:
...	@@ -16324,7 +15664,9 @@ int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth	...	@@ -16324,7 +15664,9 @@ int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth
16324	int __ovld __cnfn get_image_channel_data_type(write_only image1d_t image);	15664	int __ovld __cnfn get_image_channel_data_type(write_only image1d_t image);
16325	int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t image);	15665	int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t image);
16326	int __ovld __cnfn get_image_channel_data_type(write_only image2d_t image);	15666	int __ovld __cnfn get_image_channel_data_type(write_only image2d_t image);
		15667	#ifdef cl_khr_3d_image_writes
16327	int __ovld __cnfn get_image_channel_data_type(write_only image3d_t image);	15668	int __ovld __cnfn get_image_channel_data_type(write_only image3d_t image);
		15669	#endif
16328	int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t image);	15670	int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t image);
16329	int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_t image);	15671	int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_t image);
16330	#ifdef cl_khr_depth_images	15672	#ifdef cl_khr_depth_images
...	@@ -16418,7 +15760,9 @@ int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t i	...	@@ -16418,7 +15760,9 @@ int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t i
16418	int __ovld __cnfn get_image_channel_order(write_only image1d_t image);	15760	int __ovld __cnfn get_image_channel_order(write_only image1d_t image);
16419	int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t image);	15761	int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t image);
16420	int __ovld __cnfn get_image_channel_order(write_only image2d_t image);	15762	int __ovld __cnfn get_image_channel_order(write_only image2d_t image);
		15763	#ifdef cl_khr_3d_image_writes
16421	int __ovld __cnfn get_image_channel_order(write_only image3d_t image);	15764	int __ovld __cnfn get_image_channel_order(write_only image3d_t image);
		15765	#endif
16422	int __ovld __cnfn get_image_channel_order(write_only image1d_array_t image);	15766	int __ovld __cnfn get_image_channel_order(write_only image1d_array_t image);
16423	int __ovld __cnfn get_image_channel_order(write_only image2d_array_t image);	15767	int __ovld __cnfn get_image_channel_order(write_only image2d_array_t image);
16424	#ifdef cl_khr_depth_images	15768	#ifdef cl_khr_depth_images
...	@@ -16504,7 +15848,9 @@ int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t image);	...	@@ -16504,7 +15848,9 @@ int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t image);
16504	* component and the w component is 0.	15848	* component and the w component is 0.
16505	*/	15849	*/
16506	int4 __ovld __cnfn get_image_dim(read_only image3d_t image);	15850	int4 __ovld __cnfn get_image_dim(read_only image3d_t image);
		15851	#ifdef cl_khr_3d_image_writes
16507	int4 __ovld __cnfn get_image_dim(write_only image3d_t image);	15852	int4 __ovld __cnfn get_image_dim(write_only image3d_t image);
		15853	#endif
16508	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0	15854	#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
16509	int4 __ovld __cnfn get_image_dim(read_write image3d_t image);	15855	int4 __ovld __cnfn get_image_dim(read_write image3d_t image);
16510	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0	15856	#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0
...	@@ -16714,16 +16060,12 @@ typedef int clk_profiling_info;	...	@@ -16714,16 +16060,12 @@ typedef int clk_profiling_info;
16714		16060
16715	#define MAX_WORK_DIM 3	16061	#define MAX_WORK_DIM 3
16716		16062
16717	// ToDo: Remove definition of ndrange_t in Clang as an opaque type and add back
16718	// the following ndrange_t definition.
16719	#if 0
16720	typedef struct {	16063	typedef struct {
16721	unsigned int workDimension;	16064	unsigned int workDimension;
16722	size_t globalWorkOffset[MAX_WORK_DIM];	16065	size_t globalWorkOffset[MAX_WORK_DIM];
16723	size_t globalWorkSize[MAX_WORK_DIM];	16066	size_t globalWorkSize[MAX_WORK_DIM];
16724	size_t localWorkSize[MAX_WORK_DIM];	16067	size_t localWorkSize[MAX_WORK_DIM];
16725	} ndrange_t;	16068	} ndrange_t;
16726	#endif
16727		16069
16728	ndrange_t __ovld ndrange_1D(size_t);	16070	ndrange_t __ovld ndrange_1D(size_t);
16729	ndrange_t __ovld ndrange_1D(size_t, size_t);	16071	ndrange_t __ovld ndrange_1D(size_t, size_t);

c_headers/pmmintrin.h+7-13

 @@ -31,9 +31,11 @@
   __attribute__((__always_inline__, __nodebug__, __target__("sse3")))
 /// \brief Loads data from an unaligned memory location to elements in a 128-bit
-///    vector. If the address of the data is not 16-byte aligned, the
+///    vector.
-///    instruction may read two adjacent aligned blocks of memory to retrieve
+///
-///    the requested data.
+///    If the address of the data is not 16-byte aligned, the instruction may
+///    read two adjacent aligned blocks of memory to retrieve the requested
+///    data.
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -115,7 +117,7 @@ _mm_hsub_ps(__m128 __a, __m128 __b)
 /// \brief Moves and duplicates high-order (odd-indexed) values from a 128-bit
 ///    vector of [4 x float] to float values stored in a 128-bit vector of
 ///    [4 x float].
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -136,7 +138,7 @@ _mm_movehdup_ps(__m128 __a)
 }
 /// \brief Duplicates low-order (even-indexed) values from a 128-bit vector of
 ///    [4 x float] to float values stored in a 128-bit vector of [4 x float].
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -257,14 +259,6 @@ _mm_movedup_pd(__m128d __a)
   return __builtin_shufflevector((__v2df)__a, (__v2df)__a, 0, 0);
 }
-#define _MM_DENORMALS_ZERO_ON   (0x0040)
-#define _MM_DENORMALS_ZERO_OFF  (0x0000)
-#define _MM_DENORMALS_ZERO_MASK (0x0040)
-#define _MM_GET_DENORMALS_ZERO_MODE() (_mm_getcsr() & _MM_DENORMALS_ZERO_MASK)
-#define _MM_SET_DENORMALS_ZERO_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_DENORMALS_ZERO_MASK) | (x)))
 /// \brief Establishes a linear address memory range to be monitored and puts
 ///    the processor in the monitor event pending state. Data stored in the
 ///    monitored address range causes the processor to exit the pending state.

c_headers/prfchwintrin.h+26

...	@@ -29,12 +29,38 @@	...	@@ -29,12 +29,38 @@
29	#define __PRFCHWINTRIN_H	29	#define __PRFCHWINTRIN_H
30		30
31	#if defined(__PRFCHW__) \|\| defined(__3dNOW__)	31	#if defined(__PRFCHW__) \|\| defined(__3dNOW__)
		32	/// \brief Loads a memory sequence containing the specified memory address into
		33	/// all data cache levels. The cache-coherency state is set to exclusive.
		34	/// Data can be read from and written to the cache line without additional
		35	/// delay.
		36	///
		37	/// \headerfile <x86intrin.h>
		38	///
		39	/// This intrinsic corresponds to the \c PREFETCHT0 instruction.
		40	///
		41	/// \param __P
		42	/// A pointer specifying the memory address to be prefetched.
32	static __inline__ void __attribute__((__always_inline__, __nodebug__))	43	static __inline__ void __attribute__((__always_inline__, __nodebug__))
33	_m_prefetch(void *__P)	44	_m_prefetch(void *__P)
34	{	45	{
35	__builtin_prefetch (__P, 0, 3 /* _MM_HINT_T0 */);	46	__builtin_prefetch (__P, 0, 3 /* _MM_HINT_T0 */);
36	}	47	}
37		48
		49	/// \brief Loads a memory sequence containing the specified memory address into
		50	/// the L1 data cache and sets the cache-coherency to modified. This
		51	/// provides a hint to the processor that the cache line will be modified.
		52	/// It is intended for use when the cache line will be written to shortly
		53	/// after the prefetch is performed.
		54	///
		55	/// Note that the effect of this intrinsic is dependent on the processor
		56	/// implementation.
		57	///
		58	/// \headerfile <x86intrin.h>
		59	///
		60	/// This intrinsic corresponds to the \c PREFETCHW instruction.
		61	///
		62	/// \param __P
		63	/// A pointer specifying the memory address to be prefetched.
38	static __inline__ void __attribute__((__always_inline__, __nodebug__))	64	static __inline__ void __attribute__((__always_inline__, __nodebug__))
39	_m_prefetchw(void *__P)	65	_m_prefetchw(void *__P)
40	{	66	{

c_headers/smmintrin.h+1959-1

...	@@ -46,37 +46,379 @@	...	@@ -46,37 +46,379 @@
46	#define _MM_FROUND_RINT (_MM_FROUND_RAISE_EXC \| _MM_FROUND_CUR_DIRECTION)	46	#define _MM_FROUND_RINT (_MM_FROUND_RAISE_EXC \| _MM_FROUND_CUR_DIRECTION)
47	#define _MM_FROUND_NEARBYINT (_MM_FROUND_NO_EXC \| _MM_FROUND_CUR_DIRECTION)	47	#define _MM_FROUND_NEARBYINT (_MM_FROUND_NO_EXC \| _MM_FROUND_CUR_DIRECTION)
48		48
		49	/// \brief Rounds up each element of the 128-bit vector of [4 x float] to an
		50	/// integer and returns the rounded values in a 128-bit vector of
		51	/// [4 x float].
		52	///
		53	/// \headerfile <x86intrin.h>
		54	///
		55	/// \code
		56	/// __m128 _mm_ceil_ps(__m128 X);
		57	/// \endcode
		58	///
		59	/// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction.
		60	///
		61	/// \param X
		62	/// A 128-bit vector of [4 x float] values to be rounded up.
		63	/// \returns A 128-bit vector of [4 x float] containing the rounded values.
49	#define _mm_ceil_ps(X) _mm_round_ps((X), _MM_FROUND_CEIL)	64	#define _mm_ceil_ps(X) _mm_round_ps((X), _MM_FROUND_CEIL)
		65
		66	/// \brief Rounds up each element of the 128-bit vector of [2 x double] to an
		67	/// integer and returns the rounded values in a 128-bit vector of
		68	/// [2 x double].
		69	///
		70	/// \headerfile <x86intrin.h>
		71	///
		72	/// \code
		73	/// __m128d _mm_ceil_pd(__m128d X);
		74	/// \endcode
		75	///
		76	/// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction.
		77	///
		78	/// \param X
		79	/// A 128-bit vector of [2 x double] values to be rounded up.
		80	/// \returns A 128-bit vector of [2 x double] containing the rounded values.
50	#define _mm_ceil_pd(X) _mm_round_pd((X), _MM_FROUND_CEIL)	81	#define _mm_ceil_pd(X) _mm_round_pd((X), _MM_FROUND_CEIL)
		82
		83	/// \brief Copies three upper elements of the first 128-bit vector operand to
		84	/// the corresponding three upper elements of the 128-bit result vector of
		85	/// [4 x float]. Rounds up the lowest element of the second 128-bit vector
		86	/// operand to an integer and copies it to the lowest element of the 128-bit
		87	/// result vector of [4 x float].
		88	///
		89	/// \headerfile <x86intrin.h>
		90	///
		91	/// \code
		92	/// __m128 _mm_ceil_ss(__m128 X, __m128 Y);
		93	/// \endcode
		94	///
		95	/// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction.
		96	///
		97	/// \param X
		98	/// A 128-bit vector of [4 x float]. The values stored in bits [127:32] are
		99	/// copied to the corresponding bits of the result.
		100	/// \param Y
		101	/// A 128-bit vector of [4 x float]. The value stored in bits [31:0] is
		102	/// rounded up to the nearest integer and copied to the corresponding bits
		103	/// of the result.
		104	/// \returns A 128-bit vector of [4 x float] containing the copied and rounded
		105	/// values.
51	#define _mm_ceil_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_CEIL)	106	#define _mm_ceil_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_CEIL)
		107
		108	/// \brief Copies the upper element of the first 128-bit vector operand to the
		109	/// corresponding upper element of the 128-bit result vector of [2 x double].
		110	/// Rounds up the lower element of the second 128-bit vector operand to an
		111	/// integer and copies it to the lower element of the 128-bit result vector
		112	/// of [2 x double].
		113	///
		114	/// \headerfile <x86intrin.h>
		115	///
		116	/// \code
		117	/// __m128d _mm_ceil_sd(__m128d X, __m128d Y);
		118	/// \endcode
		119	///
		120	/// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction.
		121	///
		122	/// \param X
		123	/// A 128-bit vector of [2 x double]. The value stored in bits [127:64] is
		124	/// copied to the corresponding bits of the result.
		125	/// \param Y
		126	/// A 128-bit vector of [2 x double]. The value stored in bits [63:0] is
		127	/// rounded up to the nearest integer and copied to the corresponding bits
		128	/// of the result.
		129	/// \returns A 128-bit vector of [2 x double] containing the copied and rounded
		130	/// values.
52	#define _mm_ceil_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_CEIL)	131	#define _mm_ceil_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_CEIL)
53		132
		133	/// \brief Rounds down each element of the 128-bit vector of [4 x float] to an
		134	/// an integer and returns the rounded values in a 128-bit vector of
		135	/// [4 x float].
		136	///
		137	/// \headerfile <x86intrin.h>
		138	///
		139	/// \code
		140	/// __m128 _mm_floor_ps(__m128 X);
		141	/// \endcode
		142	///
		143	/// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction.
		144	///
		145	/// \param X
		146	/// A 128-bit vector of [4 x float] values to be rounded down.
		147	/// \returns A 128-bit vector of [4 x float] containing the rounded values.
54	#define _mm_floor_ps(X) _mm_round_ps((X), _MM_FROUND_FLOOR)	148	#define _mm_floor_ps(X) _mm_round_ps((X), _MM_FROUND_FLOOR)
		149
		150	/// \brief Rounds down each element of the 128-bit vector of [2 x double] to an
		151	/// integer and returns the rounded values in a 128-bit vector of
		152	/// [2 x double].
		153	///
		154	/// \headerfile <x86intrin.h>
		155	///
		156	/// \code
		157	/// __m128d _mm_floor_pd(__m128d X);
		158	/// \endcode
		159	///
		160	/// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction.
		161	///
		162	/// \param X
		163	/// A 128-bit vector of [2 x double].
		164	/// \returns A 128-bit vector of [2 x double] containing the rounded values.
55	#define _mm_floor_pd(X) _mm_round_pd((X), _MM_FROUND_FLOOR)	165	#define _mm_floor_pd(X) _mm_round_pd((X), _MM_FROUND_FLOOR)
		166
		167	/// \brief Copies three upper elements of the first 128-bit vector operand to
		168	/// the corresponding three upper elements of the 128-bit result vector of
		169	/// [4 x float]. Rounds down the lowest element of the second 128-bit vector
		170	/// operand to an integer and copies it to the lowest element of the 128-bit
		171	/// result vector of [4 x float].
		172	///
		173	/// \headerfile <x86intrin.h>
		174	///
		175	/// \code
		176	/// __m128 _mm_floor_ss(__m128 X, __m128 Y);
		177	/// \endcode
		178	///
		179	/// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction.
		180	///
		181	/// \param X
		182	/// A 128-bit vector of [4 x float]. The values stored in bits [127:32] are
		183	/// copied to the corresponding bits of the result.
		184	/// \param Y
		185	/// A 128-bit vector of [4 x float]. The value stored in bits [31:0] is
		186	/// rounded down to the nearest integer and copied to the corresponding bits
		187	/// of the result.
		188	/// \returns A 128-bit vector of [4 x float] containing the copied and rounded
		189	/// values.
56	#define _mm_floor_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_FLOOR)	190	#define _mm_floor_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_FLOOR)
		191
		192	/// \brief Copies the upper element of the first 128-bit vector operand to the
		193	/// corresponding upper element of the 128-bit result vector of [2 x double].
		194	/// Rounds down the lower element of the second 128-bit vector operand to an
		195	/// integer and copies it to the lower element of the 128-bit result vector
		196	/// of [2 x double].
		197	///
		198	/// \headerfile <x86intrin.h>
		199	///
		200	/// \code
		201	/// __m128d _mm_floor_sd(__m128d X, __m128d Y);
		202	/// \endcode
		203	///
		204	/// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction.
		205	///
		206	/// \param X
		207	/// A 128-bit vector of [2 x double]. The value stored in bits [127:64] is
		208	/// copied to the corresponding bits of the result.
		209	/// \param Y
		210	/// A 128-bit vector of [2 x double]. The value stored in bits [63:0] is
		211	/// rounded down to the nearest integer and copied to the corresponding bits
		212	/// of the result.
		213	/// \returns A 128-bit vector of [2 x double] containing the copied and rounded
		214	/// values.
57	#define _mm_floor_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_FLOOR)	215	#define _mm_floor_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_FLOOR)
58		216
		217	/// \brief Rounds each element of the 128-bit vector of [4 x float] to an
		218	/// integer value according to the rounding control specified by the second
		219	/// argument and returns the rounded values in a 128-bit vector of
		220	/// [4 x float].
		221	///
		222	/// \headerfile <x86intrin.h>
		223	///
		224	/// \code
		225	/// __m128 _mm_round_ps(__m128 X, const int M);
		226	/// \endcode
		227	///
		228	/// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction.
		229	///
		230	/// \param X
		231	/// A 128-bit vector of [4 x float].
		232	/// \param M
		233	/// An integer value that specifies the rounding operation. \n
		234	/// Bits [7:4] are reserved. \n
		235	/// Bit [3] is a precision exception value: \n
		236	/// 0: A normal PE exception is used \n
		237	/// 1: The PE field is not updated \n
		238	/// Bit [2] is the rounding control source: \n
		239	/// 0: Use bits [1:0] of \a M \n
		240	/// 1: Use the current MXCSR setting \n
		241	/// Bits [1:0] contain the rounding control definition: \n
		242	/// 00: Nearest \n
		243	/// 01: Downward (toward negative infinity) \n
		244	/// 10: Upward (toward positive infinity) \n
		245	/// 11: Truncated
		246	/// \returns A 128-bit vector of [4 x float] containing the rounded values.
59	#define _mm_round_ps(X, M) __extension__ ({ \	247	#define _mm_round_ps(X, M) __extension__ ({ \
60	(__m128)__builtin_ia32_roundps((__v4sf)(__m128)(X), (M)); })	248	(__m128)__builtin_ia32_roundps((__v4sf)(__m128)(X), (M)); })
61		249
		250	/// \brief Copies three upper elements of the first 128-bit vector operand to
		251	/// the corresponding three upper elements of the 128-bit result vector of
		252	/// [4 x float]. Rounds the lowest element of the second 128-bit vector
		253	/// operand to an integer value according to the rounding control specified
		254	/// by the third argument and copies it to the lowest element of the 128-bit
		255	/// result vector of [4 x float].
		256	///
		257	/// \headerfile <x86intrin.h>
		258	///
		259	/// \code
		260	/// __m128 _mm_round_ss(__m128 X, __m128 Y, const int M);
		261	/// \endcode
		262	///
		263	/// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction.
		264	///
		265	/// \param X
		266	/// A 128-bit vector of [4 x float]. The values stored in bits [127:32] are
		267	/// copied to the corresponding bits of the result.
		268	/// \param Y
		269	/// A 128-bit vector of [4 x float]. The value stored in bits [31:0] is
		270	/// rounded to the nearest integer using the specified rounding control and
		271	/// copied to the corresponding bits of the result.
		272	/// \param M
		273	/// An integer value that specifies the rounding operation. \n
		274	/// Bits [7:4] are reserved. \n
		275	/// Bit [3] is a precision exception value: \n
		276	/// 0: A normal PE exception is used \n
		277	/// 1: The PE field is not updated \n
		278	/// Bit [2] is the rounding control source: \n
		279	/// 0: Use bits [1:0] of \a M \n
		280	/// 1: Use the current MXCSR setting \n
		281	/// Bits [1:0] contain the rounding control definition: \n
		282	/// 00: Nearest \n
		283	/// 01: Downward (toward negative infinity) \n
		284	/// 10: Upward (toward positive infinity) \n
		285	/// 11: Truncated
		286	/// \returns A 128-bit vector of [4 x float] containing the copied and rounded
		287	/// values.
62	#define _mm_round_ss(X, Y, M) __extension__ ({ \	288	#define _mm_round_ss(X, Y, M) __extension__ ({ \
63	(__m128)__builtin_ia32_roundss((__v4sf)(__m128)(X), \	289	(__m128)__builtin_ia32_roundss((__v4sf)(__m128)(X), \
64	(__v4sf)(__m128)(Y), (M)); })	290	(__v4sf)(__m128)(Y), (M)); })
65		291
		292	/// \brief Rounds each element of the 128-bit vector of [2 x double] to an
		293	/// integer value according to the rounding control specified by the second
		294	/// argument and returns the rounded values in a 128-bit vector of
		295	/// [2 x double].
		296	///
		297	/// \headerfile <x86intrin.h>
		298	///
		299	/// \code
		300	/// __m128d _mm_round_pd(__m128d X, const int M);
		301	/// \endcode
		302	///
		303	/// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction.
		304	///
		305	/// \param X
		306	/// A 128-bit vector of [2 x double].
		307	/// \param M
		308	/// An integer value that specifies the rounding operation. \n
		309	/// Bits [7:4] are reserved. \n
		310	/// Bit [3] is a precision exception value: \n
		311	/// 0: A normal PE exception is used \n
		312	/// 1: The PE field is not updated \n
		313	/// Bit [2] is the rounding control source: \n
		314	/// 0: Use bits [1:0] of \a M \n
		315	/// 1: Use the current MXCSR setting \n
		316	/// Bits [1:0] contain the rounding control definition: \n
		317	/// 00: Nearest \n
		318	/// 01: Downward (toward negative infinity) \n
		319	/// 10: Upward (toward positive infinity) \n
		320	/// 11: Truncated
		321	/// \returns A 128-bit vector of [2 x double] containing the rounded values.
66	#define _mm_round_pd(X, M) __extension__ ({ \	322	#define _mm_round_pd(X, M) __extension__ ({ \
67	(__m128d)__builtin_ia32_roundpd((__v2df)(__m128d)(X), (M)); })	323	(__m128d)__builtin_ia32_roundpd((__v2df)(__m128d)(X), (M)); })
68		324
		325	/// \brief Copies the upper element of the first 128-bit vector operand to the
		326	/// corresponding upper element of the 128-bit result vector of [2 x double].
		327	/// Rounds the lower element of the second 128-bit vector operand to an
		328	/// integer value according to the rounding control specified by the third
		329	/// argument and copies it to the lower element of the 128-bit result vector
		330	/// of [2 x double].
		331	///
		332	/// \headerfile <x86intrin.h>
		333	///
		334	/// \code
		335	/// __m128d _mm_round_sd(__m128d X, __m128d Y, const int M);
		336	/// \endcode
		337	///
		338	/// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction.
		339	///
		340	/// \param X
		341	/// A 128-bit vector of [2 x double]. The value stored in bits [127:64] is
		342	/// copied to the corresponding bits of the result.
		343	/// \param Y
		344	/// A 128-bit vector of [2 x double]. The value stored in bits [63:0] is
		345	/// rounded to the nearest integer using the specified rounding control and
		346	/// copied to the corresponding bits of the result.
		347	/// \param M
		348	/// An integer value that specifies the rounding operation. \n
		349	/// Bits [7:4] are reserved. \n
		350	/// Bit [3] is a precision exception value: \n
		351	/// 0: A normal PE exception is used \n
		352	/// 1: The PE field is not updated \n
		353	/// Bit [2] is the rounding control source: \n
		354	/// 0: Use bits [1:0] of \a M \n
		355	/// 1: Use the current MXCSR setting \n
		356	/// Bits [1:0] contain the rounding control definition: \n
		357	/// 00: Nearest \n
		358	/// 01: Downward (toward negative infinity) \n
		359	/// 10: Upward (toward positive infinity) \n
		360	/// 11: Truncated
		361	/// \returns A 128-bit vector of [2 x double] containing the copied and rounded
		362	/// values.
69	#define _mm_round_sd(X, Y, M) __extension__ ({ \	363	#define _mm_round_sd(X, Y, M) __extension__ ({ \
70	(__m128d)__builtin_ia32_roundsd((__v2df)(__m128d)(X), \	364	(__m128d)__builtin_ia32_roundsd((__v2df)(__m128d)(X), \
71	(__v2df)(__m128d)(Y), (M)); })	365	(__v2df)(__m128d)(Y), (M)); })
72		366
73	/* SSE4 Packed Blending Intrinsics. */	367	/* SSE4 Packed Blending Intrinsics. */
		368	/// \brief Returns a 128-bit vector of [2 x double] where the values are
		369	/// selected from either the first or second operand as specified by the
		370	/// third operand, the control mask.
		371	///
		372	/// \headerfile <x86intrin.h>
		373	///
		374	/// \code
		375	/// __m128d _mm_blend_pd(__m128d V1, __m128d V2, const int M);
		376	/// \endcode
		377	///
		378	/// This intrinsic corresponds to the <c> VBLENDPD / BLENDPD </c> instruction.
		379	///
		380	/// \param V1
		381	/// A 128-bit vector of [2 x double].
		382	/// \param V2
		383	/// A 128-bit vector of [2 x double].
		384	/// \param M
		385	/// An immediate integer operand, with mask bits [1:0] specifying how the
		386	/// values are to be copied. The position of the mask bit corresponds to the
		387	/// index of a copied value. When a mask bit is 0, the corresponding 64-bit
		388	/// element in operand \a V1 is copied to the same position in the result.
		389	/// When a mask bit is 1, the corresponding 64-bit element in operand \a V2
		390	/// is copied to the same position in the result.
		391	/// \returns A 128-bit vector of [2 x double] containing the copied values.
74	#define _mm_blend_pd(V1, V2, M) __extension__ ({ \	392	#define _mm_blend_pd(V1, V2, M) __extension__ ({ \
75	(__m128d)__builtin_shufflevector((__v2df)(__m128d)(V1), \	393	(__m128d)__builtin_shufflevector((__v2df)(__m128d)(V1), \
76	(__v2df)(__m128d)(V2), \	394	(__v2df)(__m128d)(V2), \
77	(((M) & 0x01) ? 2 : 0), \	395	(((M) & 0x01) ? 2 : 0), \
78	(((M) & 0x02) ? 3 : 1)); })	396	(((M) & 0x02) ? 3 : 1)); })
79		397
		398	/// \brief Returns a 128-bit vector of [4 x float] where the values are selected
		399	/// from either the first or second operand as specified by the third
		400	/// operand, the control mask.
		401	///
		402	/// \headerfile <x86intrin.h>
		403	///
		404	/// \code
		405	/// __m128 _mm_blend_ps(__m128 V1, __m128 V2, const int M);
		406	/// \endcode
		407	///
		408	/// This intrinsic corresponds to the <c> VBLENDPS / BLENDPS </c> instruction.
		409	///
		410	/// \param V1
		411	/// A 128-bit vector of [4 x float].
		412	/// \param V2
		413	/// A 128-bit vector of [4 x float].
		414	/// \param M
		415	/// An immediate integer operand, with mask bits [3:0] specifying how the
		416	/// values are to be copied. The position of the mask bit corresponds to the
		417	/// index of a copied value. When a mask bit is 0, the corresponding 32-bit
		418	/// element in operand \a V1 is copied to the same position in the result.
		419	/// When a mask bit is 1, the corresponding 32-bit element in operand \a V2
		420	/// is copied to the same position in the result.
		421	/// \returns A 128-bit vector of [4 x float] containing the copied values.
80	#define _mm_blend_ps(V1, V2, M) __extension__ ({ \	422	#define _mm_blend_ps(V1, V2, M) __extension__ ({ \
81	(__m128)__builtin_shufflevector((__v4sf)(__m128)(V1), (__v4sf)(__m128)(V2), \	423	(__m128)__builtin_shufflevector((__v4sf)(__m128)(V1), (__v4sf)(__m128)(V2), \
82	(((M) & 0x01) ? 4 : 0), \	424	(((M) & 0x01) ? 4 : 0), \
...	@@ -84,6 +426,26 @@	...	@@ -84,6 +426,26 @@
84	(((M) & 0x04) ? 6 : 2), \	426	(((M) & 0x04) ? 6 : 2), \
85	(((M) & 0x08) ? 7 : 3)); })	427	(((M) & 0x08) ? 7 : 3)); })
86		428
		429	/// \brief Returns a 128-bit vector of [2 x double] where the values are
		430	/// selected from either the first or second operand as specified by the
		431	/// third operand, the control mask.
		432	///
		433	/// \headerfile <x86intrin.h>
		434	///
		435	/// This intrinsic corresponds to the <c> VBLENDVPD / BLENDVPD </c> instruction.
		436	///
		437	/// \param __V1
		438	/// A 128-bit vector of [2 x double].
		439	/// \param __V2
		440	/// A 128-bit vector of [2 x double].
		441	/// \param __M
		442	/// A 128-bit vector operand, with mask bits 127 and 63 specifying how the
		443	/// values are to be copied. The position of the mask bit corresponds to the
		444	/// most significant bit of a copied value. When a mask bit is 0, the
		445	/// corresponding 64-bit element in operand \a __V1 is copied to the same
		446	/// position in the result. When a mask bit is 1, the corresponding 64-bit
		447	/// element in operand \a __V2 is copied to the same position in the result.
		448	/// \returns A 128-bit vector of [2 x double] containing the copied values.
87	static __inline__ __m128d __DEFAULT_FN_ATTRS	449	static __inline__ __m128d __DEFAULT_FN_ATTRS
88	_mm_blendv_pd (__m128d __V1, __m128d __V2, __m128d __M)	450	_mm_blendv_pd (__m128d __V1, __m128d __V2, __m128d __M)
89	{	451	{
...	@@ -91,6 +453,26 @@ _mm_blendv_pd (__m128d __V1, __m128d __V2, __m128d __M)	...	@@ -91,6 +453,26 @@ _mm_blendv_pd (__m128d __V1, __m128d __V2, __m128d __M)
91	(__v2df)__M);	453	(__v2df)__M);
92	}	454	}
93		455
		456	/// \brief Returns a 128-bit vector of [4 x float] where the values are
		457	/// selected from either the first or second operand as specified by the
		458	/// third operand, the control mask.
		459	///
		460	/// \headerfile <x86intrin.h>
		461	///
		462	/// This intrinsic corresponds to the <c> VBLENDVPS / BLENDVPS </c> instruction.
		463	///
		464	/// \param __V1
		465	/// A 128-bit vector of [4 x float].
		466	/// \param __V2
		467	/// A 128-bit vector of [4 x float].
		468	/// \param __M
		469	/// A 128-bit vector operand, with mask bits 127, 95, 63, and 31 specifying
		470	/// how the values are to be copied. The position of the mask bit corresponds
		471	/// to the most significant bit of a copied value. When a mask bit is 0, the
		472	/// corresponding 32-bit element in operand \a __V1 is copied to the same
		473	/// position in the result. When a mask bit is 1, the corresponding 32-bit
		474	/// element in operand \a __V2 is copied to the same position in the result.
		475	/// \returns A 128-bit vector of [4 x float] containing the copied values.
94	static __inline__ __m128 __DEFAULT_FN_ATTRS	476	static __inline__ __m128 __DEFAULT_FN_ATTRS
95	_mm_blendv_ps (__m128 __V1, __m128 __V2, __m128 __M)	477	_mm_blendv_ps (__m128 __V1, __m128 __V2, __m128 __M)
96	{	478	{
...	@@ -98,6 +480,26 @@ _mm_blendv_ps (__m128 __V1, __m128 __V2, __m128 __M)	...	@@ -98,6 +480,26 @@ _mm_blendv_ps (__m128 __V1, __m128 __V2, __m128 __M)
98	(__v4sf)__M);	480	(__v4sf)__M);
99	}	481	}
100		482
		483	/// \brief Returns a 128-bit vector of [16 x i8] where the values are selected
		484	/// from either of the first or second operand as specified by the third
		485	/// operand, the control mask.
		486	///
		487	/// \headerfile <x86intrin.h>
		488	///
		489	/// This intrinsic corresponds to the <c> VPBLENDVB / PBLENDVB </c> instruction.
		490	///
		491	/// \param __V1
		492	/// A 128-bit vector of [16 x i8].
		493	/// \param __V2
		494	/// A 128-bit vector of [16 x i8].
		495	/// \param __M
		496	/// A 128-bit vector operand, with mask bits 127, 119, 111 ... 7 specifying
		497	/// how the values are to be copied. The position of the mask bit corresponds
		498	/// to the most significant bit of a copied value. When a mask bit is 0, the
		499	/// corresponding 8-bit element in operand \a __V1 is copied to the same
		500	/// position in the result. When a mask bit is 1, the corresponding 8-bit
		501	/// element in operand \a __V2 is copied to the same position in the result.
		502	/// \returns A 128-bit vector of [16 x i8] containing the copied values.
101	static __inline__ __m128i __DEFAULT_FN_ATTRS	503	static __inline__ __m128i __DEFAULT_FN_ATTRS
102	_mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M)	504	_mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M)
103	{	505	{
...	@@ -105,6 +507,30 @@ _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M)	...	@@ -105,6 +507,30 @@ _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M)
105	(__v16qi)__M);	507	(__v16qi)__M);
106	}	508	}
107		509
		510	/// \brief Returns a 128-bit vector of [8 x i16] where the values are selected
		511	/// from either of the first or second operand as specified by the third
		512	/// operand, the control mask.
		513	///
		514	/// \headerfile <x86intrin.h>
		515	///
		516	/// \code
		517	/// __m128i _mm_blend_epi16(__m128i V1, __m128i V2, const int M);
		518	/// \endcode
		519	///
		520	/// This intrinsic corresponds to the <c> VPBLENDW / PBLENDW </c> instruction.
		521	///
		522	/// \param V1
		523	/// A 128-bit vector of [8 x i16].
		524	/// \param V2
		525	/// A 128-bit vector of [8 x i16].
		526	/// \param M
		527	/// An immediate integer operand, with mask bits [7:0] specifying how the
		528	/// values are to be copied. The position of the mask bit corresponds to the
		529	/// index of a copied value. When a mask bit is 0, the corresponding 16-bit
		530	/// element in operand \a V1 is copied to the same position in the result.
		531	/// When a mask bit is 1, the corresponding 16-bit element in operand \a V2
		532	/// is copied to the same position in the result.
		533	/// \returns A 128-bit vector of [8 x i16] containing the copied values.
108	#define _mm_blend_epi16(V1, V2, M) __extension__ ({ \	534	#define _mm_blend_epi16(V1, V2, M) __extension__ ({ \
109	(__m128i)__builtin_shufflevector((__v8hi)(__m128i)(V1), \	535	(__m128i)__builtin_shufflevector((__v8hi)(__m128i)(V1), \
110	(__v8hi)(__m128i)(V2), \	536	(__v8hi)(__m128i)(V2), \
...	@@ -118,12 +544,39 @@ _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M)	...	@@ -118,12 +544,39 @@ _mm_blendv_epi8 (__m128i __V1, __m128i __V2, __m128i __M)
118	(((M) & 0x80) ? 15 : 7)); })	544	(((M) & 0x80) ? 15 : 7)); })
119		545
120	/* SSE4 Dword Multiply Instructions. */	546	/* SSE4 Dword Multiply Instructions. */
		547	/// \brief Multiples corresponding elements of two 128-bit vectors of [4 x i32]
		548	/// and returns the lower 32 bits of the each product in a 128-bit vector of
		549	/// [4 x i32].
		550	///
		551	/// \headerfile <x86intrin.h>
		552	///
		553	/// This intrinsic corresponds to the <c> VPMULLD / PMULLD </c> instruction.
		554	///
		555	/// \param __V1
		556	/// A 128-bit integer vector.
		557	/// \param __V2
		558	/// A 128-bit integer vector.
		559	/// \returns A 128-bit integer vector containing the products of both operands.
121	static __inline__ __m128i __DEFAULT_FN_ATTRS	560	static __inline__ __m128i __DEFAULT_FN_ATTRS
122	_mm_mullo_epi32 (__m128i __V1, __m128i __V2)	561	_mm_mullo_epi32 (__m128i __V1, __m128i __V2)
123	{	562	{
124	return (__m128i) ((__v4su)__V1 * (__v4su)__V2);	563	return (__m128i) ((__v4su)__V1 * (__v4su)__V2);
125	}	564	}
126		565
		566	/// \brief Multiplies corresponding even-indexed elements of two 128-bit
		567	/// vectors of [4 x i32] and returns a 128-bit vector of [2 x i64]
		568	/// containing the products.
		569	///
		570	/// \headerfile <x86intrin.h>
		571	///
		572	/// This intrinsic corresponds to the <c> VPMULDQ / PMULDQ </c> instruction.
		573	///
		574	/// \param __V1
		575	/// A 128-bit vector of [4 x i32].
		576	/// \param __V2
		577	/// A 128-bit vector of [4 x i32].
		578	/// \returns A 128-bit vector of [2 x i64] containing the products of both
		579	/// operands.
127	static __inline__ __m128i __DEFAULT_FN_ATTRS	580	static __inline__ __m128i __DEFAULT_FN_ATTRS
128	_mm_mul_epi32 (__m128i __V1, __m128i __V2)	581	_mm_mul_epi32 (__m128i __V1, __m128i __V2)
129	{	582	{
...	@@ -131,64 +584,243 @@ _mm_mul_epi32 (__m128i __V1, __m128i __V2)	...	@@ -131,64 +584,243 @@ _mm_mul_epi32 (__m128i __V1, __m128i __V2)
131	}	584	}
132		585
133	/* SSE4 Floating Point Dot Product Instructions. */	586	/* SSE4 Floating Point Dot Product Instructions. */
		587	/// \brief Computes the dot product of the two 128-bit vectors of [4 x float]
		588	/// and returns it in the elements of the 128-bit result vector of
		589	/// [4 x float].
		590	///
		591	/// The immediate integer operand controls which input elements
		592	/// will contribute to the dot product, and where the final results are
		593	/// returned.
		594	///
		595	/// \headerfile <x86intrin.h>
		596	///
		597	/// \code
		598	/// __m128 _mm_dp_ps(__m128 X, __m128 Y, const int M);
		599	/// \endcode
		600	///
		601	/// This intrinsic corresponds to the <c> VDPPS / DPPS </c> instruction.
		602	///
		603	/// \param X
		604	/// A 128-bit vector of [4 x float].
		605	/// \param Y
		606	/// A 128-bit vector of [4 x float].
		607	/// \param M
		608	/// An immediate integer operand. Mask bits [7:4] determine which elements
		609	/// of the input vectors are used, with bit [4] corresponding to the lowest
		610	/// element and bit [7] corresponding to the highest element of each [4 x
		611	/// float] vector. If a bit is set, the corresponding elements from the two
		612	/// input vectors are used as an input for dot product; otherwise that input
		613	/// is treated as zero. Bits [3:0] determine which elements of the result
		614	/// will receive a copy of the final dot product, with bit [0] corresponding
		615	/// to the lowest element and bit [3] corresponding to the highest element of
		616	/// each [4 x float] subvector. If a bit is set, the dot product is returned
		617	/// in the corresponding element; otherwise that element is set to zero.
		618	/// \returns A 128-bit vector of [4 x float] containing the dot product.
134	#define _mm_dp_ps(X, Y, M) __extension__ ({ \	619	#define _mm_dp_ps(X, Y, M) __extension__ ({ \
135	(__m128) __builtin_ia32_dpps((__v4sf)(__m128)(X), \	620	(__m128) __builtin_ia32_dpps((__v4sf)(__m128)(X), \
136	(__v4sf)(__m128)(Y), (M)); })	621	(__v4sf)(__m128)(Y), (M)); })
137		622
		623	/// \brief Computes the dot product of the two 128-bit vectors of [2 x double]
		624	/// and returns it in the elements of the 128-bit result vector of
		625	/// [2 x double].
		626	///
		627	/// The immediate integer operand controls which input
		628	/// elements will contribute to the dot product, and where the final results
		629	/// are returned.
		630	///
		631	/// \headerfile <x86intrin.h>
		632	///
		633	/// \code
		634	/// __m128d _mm_dp_pd(__m128d X, __m128d Y, const int M);
		635	/// \endcode
		636	///
		637	/// This intrinsic corresponds to the <c> VDPPD / DPPD </c> instruction.
		638	///
		639	/// \param X
		640	/// A 128-bit vector of [2 x double].
		641	/// \param Y
		642	/// A 128-bit vector of [2 x double].
		643	/// \param M
		644	/// An immediate integer operand. Mask bits [5:4] determine which elements
		645	/// of the input vectors are used, with bit [4] corresponding to the lowest
		646	/// element and bit [5] corresponding to the highest element of each of [2 x
		647	/// double] vector. If a bit is set, the corresponding elements from the two
		648	/// input vectors are used as an input for dot product; otherwise that input
		649	/// is treated as zero. Bits [1:0] determine which elements of the result
		650	/// will receive a copy of the final dot product, with bit [0] corresponding
		651	/// to the lowest element and bit [3] corresponding to the highest element of
		652	/// each [2 x double] vector. If a bit is set, the dot product is returned in
		653	/// the corresponding element; otherwise that element is set to zero.
138	#define _mm_dp_pd(X, Y, M) __extension__ ({\	654	#define _mm_dp_pd(X, Y, M) __extension__ ({\
139	(__m128d) __builtin_ia32_dppd((__v2df)(__m128d)(X), \	655	(__m128d) __builtin_ia32_dppd((__v2df)(__m128d)(X), \
140	(__v2df)(__m128d)(Y), (M)); })	656	(__v2df)(__m128d)(Y), (M)); })
141		657
142	/* SSE4 Streaming Load Hint Instruction. */	658	/* SSE4 Streaming Load Hint Instruction. */
		659	/// \brief Loads integer values from a 128-bit aligned memory location to a
		660	/// 128-bit integer vector.
		661	///
		662	/// \headerfile <x86intrin.h>
		663	///
		664	/// This intrinsic corresponds to the <c> VMOVNTDQA / MOVNTDQA </c> instruction.
		665	///
		666	/// \param __V
		667	/// A pointer to a 128-bit aligned memory location that contains the integer
		668	/// values.
		669	/// \returns A 128-bit integer vector containing the data stored at the
		670	/// specified memory location.
143	static __inline__ __m128i __DEFAULT_FN_ATTRS	671	static __inline__ __m128i __DEFAULT_FN_ATTRS
144	_mm_stream_load_si128 (__m128i const *__V)	672	_mm_stream_load_si128 (__m128i const *__V)
145	{	673	{
146	return (__m128i) __builtin_ia32_movntdqa ((const __v2di *) __V);	674	return (__m128i) __builtin_nontemporal_load ((const __v2di *) __V);
147	}	675	}
148		676
149	/* SSE4 Packed Integer Min/Max Instructions. */	677	/* SSE4 Packed Integer Min/Max Instructions. */
		678	/// \brief Compares the corresponding elements of two 128-bit vectors of
		679	/// [16 x i8] and returns a 128-bit vector of [16 x i8] containing the lesser
		680	/// of the two values.
		681	///
		682	/// \headerfile <x86intrin.h>
		683	///
		684	/// This intrinsic corresponds to the <c> VPMINSB / PMINSB </c> instruction.
		685	///
		686	/// \param __V1
		687	/// A 128-bit vector of [16 x i8].
		688	/// \param __V2
		689	/// A 128-bit vector of [16 x i8]
		690	/// \returns A 128-bit vector of [16 x i8] containing the lesser values.
150	static __inline__ __m128i __DEFAULT_FN_ATTRS	691	static __inline__ __m128i __DEFAULT_FN_ATTRS
151	_mm_min_epi8 (__m128i __V1, __m128i __V2)	692	_mm_min_epi8 (__m128i __V1, __m128i __V2)
152	{	693	{
153	return (__m128i) __builtin_ia32_pminsb128 ((__v16qi) __V1, (__v16qi) __V2);	694	return (__m128i) __builtin_ia32_pminsb128 ((__v16qi) __V1, (__v16qi) __V2);
154	}	695	}
155		696
		697	/// \brief Compares the corresponding elements of two 128-bit vectors of
		698	/// [16 x i8] and returns a 128-bit vector of [16 x i8] containing the
		699	/// greater value of the two.
		700	///
		701	/// \headerfile <x86intrin.h>
		702	///
		703	/// This intrinsic corresponds to the <c> VPMAXSB / PMAXSB </c> instruction.
		704	///
		705	/// \param __V1
		706	/// A 128-bit vector of [16 x i8].
		707	/// \param __V2
		708	/// A 128-bit vector of [16 x i8].
		709	/// \returns A 128-bit vector of [16 x i8] containing the greater values.
156	static __inline__ __m128i __DEFAULT_FN_ATTRS	710	static __inline__ __m128i __DEFAULT_FN_ATTRS
157	_mm_max_epi8 (__m128i __V1, __m128i __V2)	711	_mm_max_epi8 (__m128i __V1, __m128i __V2)
158	{	712	{
159	return (__m128i) __builtin_ia32_pmaxsb128 ((__v16qi) __V1, (__v16qi) __V2);	713	return (__m128i) __builtin_ia32_pmaxsb128 ((__v16qi) __V1, (__v16qi) __V2);
160	}	714	}
161		715
		716	/// \brief Compares the corresponding elements of two 128-bit vectors of
		717	/// [8 x u16] and returns a 128-bit vector of [8 x u16] containing the lesser
		718	/// value of the two.
		719	///
		720	/// \headerfile <x86intrin.h>
		721	///
		722	/// This intrinsic corresponds to the <c> VPMINUW / PMINUW </c> instruction.
		723	///
		724	/// \param __V1
		725	/// A 128-bit vector of [8 x u16].
		726	/// \param __V2
		727	/// A 128-bit vector of [8 x u16].
		728	/// \returns A 128-bit vector of [8 x u16] containing the lesser values.
162	static __inline__ __m128i __DEFAULT_FN_ATTRS	729	static __inline__ __m128i __DEFAULT_FN_ATTRS
163	_mm_min_epu16 (__m128i __V1, __m128i __V2)	730	_mm_min_epu16 (__m128i __V1, __m128i __V2)
164	{	731	{
165	return (__m128i) __builtin_ia32_pminuw128 ((__v8hi) __V1, (__v8hi) __V2);	732	return (__m128i) __builtin_ia32_pminuw128 ((__v8hi) __V1, (__v8hi) __V2);
166	}	733	}
167		734
		735	/// \brief Compares the corresponding elements of two 128-bit vectors of
		736	/// [8 x u16] and returns a 128-bit vector of [8 x u16] containing the
		737	/// greater value of the two.
		738	///
		739	/// \headerfile <x86intrin.h>
		740	///
		741	/// This intrinsic corresponds to the <c> VPMAXUW / PMAXUW </c> instruction.
		742	///
		743	/// \param __V1
		744	/// A 128-bit vector of [8 x u16].
		745	/// \param __V2
		746	/// A 128-bit vector of [8 x u16].
		747	/// \returns A 128-bit vector of [8 x u16] containing the greater values.
168	static __inline__ __m128i __DEFAULT_FN_ATTRS	748	static __inline__ __m128i __DEFAULT_FN_ATTRS
169	_mm_max_epu16 (__m128i __V1, __m128i __V2)	749	_mm_max_epu16 (__m128i __V1, __m128i __V2)
170	{	750	{
171	return (__m128i) __builtin_ia32_pmaxuw128 ((__v8hi) __V1, (__v8hi) __V2);	751	return (__m128i) __builtin_ia32_pmaxuw128 ((__v8hi) __V1, (__v8hi) __V2);
172	}	752	}
173		753
		754	/// \brief Compares the corresponding elements of two 128-bit vectors of
		755	/// [4 x i32] and returns a 128-bit vector of [4 x i32] containing the lesser
		756	/// value of the two.
		757	///
		758	/// \headerfile <x86intrin.h>
		759	///
		760	/// This intrinsic corresponds to the <c> VPMINSD / PMINSD </c> instruction.
		761	///
		762	/// \param __V1
		763	/// A 128-bit vector of [4 x i32].
		764	/// \param __V2
		765	/// A 128-bit vector of [4 x i32].
		766	/// \returns A 128-bit vector of [4 x i32] containing the lesser values.
174	static __inline__ __m128i __DEFAULT_FN_ATTRS	767	static __inline__ __m128i __DEFAULT_FN_ATTRS
175	_mm_min_epi32 (__m128i __V1, __m128i __V2)	768	_mm_min_epi32 (__m128i __V1, __m128i __V2)
176	{	769	{
177	return (__m128i) __builtin_ia32_pminsd128 ((__v4si) __V1, (__v4si) __V2);	770	return (__m128i) __builtin_ia32_pminsd128 ((__v4si) __V1, (__v4si) __V2);
178	}	771	}
179		772
		773	/// \brief Compares the corresponding elements of two 128-bit vectors of
		774	/// [4 x i32] and returns a 128-bit vector of [4 x i32] containing the
		775	/// greater value of the two.
		776	///
		777	/// \headerfile <x86intrin.h>
		778	///
		779	/// This intrinsic corresponds to the <c> VPMAXSD / PMAXSD </c> instruction.
		780	///
		781	/// \param __V1
		782	/// A 128-bit vector of [4 x i32].
		783	/// \param __V2
		784	/// A 128-bit vector of [4 x i32].
		785	/// \returns A 128-bit vector of [4 x i32] containing the greater values.
180	static __inline__ __m128i __DEFAULT_FN_ATTRS	786	static __inline__ __m128i __DEFAULT_FN_ATTRS
181	_mm_max_epi32 (__m128i __V1, __m128i __V2)	787	_mm_max_epi32 (__m128i __V1, __m128i __V2)
182	{	788	{
183	return (__m128i) __builtin_ia32_pmaxsd128 ((__v4si) __V1, (__v4si) __V2);	789	return (__m128i) __builtin_ia32_pmaxsd128 ((__v4si) __V1, (__v4si) __V2);
184	}	790	}
185		791
		792	/// \brief Compares the corresponding elements of two 128-bit vectors of
		793	/// [4 x u32] and returns a 128-bit vector of [4 x u32] containing the lesser
		794	/// value of the two.
		795	///
		796	/// \headerfile <x86intrin.h>
		797	///
		798	/// This intrinsic corresponds to the <c> VPMINUD / PMINUD </c> instruction.
		799	///
		800	/// \param __V1
		801	/// A 128-bit vector of [4 x u32].
		802	/// \param __V2
		803	/// A 128-bit vector of [4 x u32].
		804	/// \returns A 128-bit vector of [4 x u32] containing the lesser values.
186	static __inline__ __m128i __DEFAULT_FN_ATTRS	805	static __inline__ __m128i __DEFAULT_FN_ATTRS
187	_mm_min_epu32 (__m128i __V1, __m128i __V2)	806	_mm_min_epu32 (__m128i __V1, __m128i __V2)
188	{	807	{
189	return (__m128i) __builtin_ia32_pminud128((__v4si) __V1, (__v4si) __V2);	808	return (__m128i) __builtin_ia32_pminud128((__v4si) __V1, (__v4si) __V2);
190	}	809	}
191		810
		811	/// \brief Compares the corresponding elements of two 128-bit vectors of
		812	/// [4 x u32] and returns a 128-bit vector of [4 x u32] containing the
		813	/// greater value of the two.
		814	///
		815	/// \headerfile <x86intrin.h>
		816	///
		817	/// This intrinsic corresponds to the <c> VPMAXUD / PMAXUD </c> instruction.
		818	///
		819	/// \param __V1
		820	/// A 128-bit vector of [4 x u32].
		821	/// \param __V2
		822	/// A 128-bit vector of [4 x u32].
		823	/// \returns A 128-bit vector of [4 x u32] containing the greater values.
192	static __inline__ __m128i __DEFAULT_FN_ATTRS	824	static __inline__ __m128i __DEFAULT_FN_ATTRS
193	_mm_max_epu32 (__m128i __V1, __m128i __V2)	825	_mm_max_epu32 (__m128i __V1, __m128i __V2)
194	{	826	{
...	@@ -196,7 +828,70 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2)	...	@@ -196,7 +828,70 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2)
196	}	828	}
197		829
198	/* SSE4 Insertion and Extraction from XMM Register Instructions. */	830	/* SSE4 Insertion and Extraction from XMM Register Instructions. */
		831	/// \brief Takes the first argument \a X and inserts an element from the second
		832	/// argument \a Y as selected by the third argument \a N. That result then
		833	/// has elements zeroed out also as selected by the third argument \a N. The
		834	/// resulting 128-bit vector of [4 x float] is then returned.
		835	///
		836	/// \headerfile <x86intrin.h>
		837	///
		838	/// \code
		839	/// __m128 _mm_insert_ps(__m128 X, __m128 Y, const int N);
		840	/// \endcode
		841	///
		842	/// This intrinsic corresponds to the <c> VINSERTPS </c> instruction.
		843	///
		844	/// \param X
		845	/// A 128-bit vector source operand of [4 x float]. With the exception of
		846	/// those bits in the result copied from parameter \a Y and zeroed by bits
		847	/// [3:0] of \a N, all bits from this parameter are copied to the result.
		848	/// \param Y
		849	/// A 128-bit vector source operand of [4 x float]. One single-precision
		850	/// floating-point element from this source, as determined by the immediate
		851	/// parameter, is copied to the result.
		852	/// \param N
		853	/// Specifies which bits from operand \a Y will be copied, which bits in the
		854	/// result they will be be copied to, and which bits in the result will be
		855	/// cleared. The following assignments are made: \n
		856	/// Bits [7:6] specify the bits to copy from operand \a Y: \n
		857	/// 00: Selects bits [31:0] from operand \a Y. \n
		858	/// 01: Selects bits [63:32] from operand \a Y. \n
		859	/// 10: Selects bits [95:64] from operand \a Y. \n
		860	/// 11: Selects bits [127:96] from operand \a Y. \n
		861	/// Bits [5:4] specify the bits in the result to which the selected bits
		862	/// from operand \a Y are copied: \n
		863	/// 00: Copies the selected bits from \a Y to result bits [31:0]. \n
		864	/// 01: Copies the selected bits from \a Y to result bits [63:32]. \n
		865	/// 10: Copies the selected bits from \a Y to result bits [95:64]. \n
		866	/// 11: Copies the selected bits from \a Y to result bits [127:96]. \n
		867	/// Bits[3:0]: If any of these bits are set, the corresponding result
		868	/// element is cleared.
		869	/// \returns A 128-bit vector of [4 x float] containing the copied single-
		870	/// precision floating point elements from the operands.
199	#define _mm_insert_ps(X, Y, N) __builtin_ia32_insertps128((X), (Y), (N))	871	#define _mm_insert_ps(X, Y, N) __builtin_ia32_insertps128((X), (Y), (N))
		872
		873	/// \brief Extracts a 32-bit integer from a 128-bit vector of [4 x float] and
		874	/// returns it, using the immediate value parameter \a N as a selector.
		875	///
		876	/// \headerfile <x86intrin.h>
		877	///
		878	/// \code
		879	/// int _mm_extract_ps(__m128 X, const int N);
		880	/// \endcode
		881	///
		882	/// This intrinsic corresponds to the <c> VEXTRACTPS / EXTRACTPS </c>
		883	/// instruction.
		884	///
		885	/// \param X
		886	/// A 128-bit vector of [4 x float].
		887	/// \param N
		888	/// An immediate value. Bits [1:0] determines which bits from the argument
		889	/// \a X are extracted and returned: \n
		890	/// 00: Bits [31:0] of parameter \a X are returned. \n
		891	/// 01: Bits [63:32] of parameter \a X are returned. \n
		892	/// 10: Bits [95:64] of parameter \a X are returned. \n
		893	/// 11: Bits [127:96] of parameter \a X are returned.
		894	/// \returns A 32-bit integer containing the extracted 32 bits of float data.
200	#define _mm_extract_ps(X, N) (__extension__ \	895	#define _mm_extract_ps(X, N) (__extension__ \
201	({ union { int __i; float __f; } __t; \	896	({ union { int __i; float __f; } __t; \
202	__v4sf __a = (__v4sf)(__m128)(X); \	897	__v4sf __a = (__v4sf)(__m128)(X); \
...	@@ -217,15 +912,111 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2)	...	@@ -217,15 +912,111 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2)
217	_MM_MK_INSERTPS_NDX((N), 0, 0x0e))	912	_MM_MK_INSERTPS_NDX((N), 0, 0x0e))
218		913
219	/* Insert int into packed integer array at index. */	914	/* Insert int into packed integer array at index. */
		915	/// \brief Constructs a 128-bit vector of [16 x i8] by first making a copy of
		916	/// the 128-bit integer vector parameter, and then inserting the lower 8 bits
		917	/// of an integer parameter \a I into an offset specified by the immediate
		918	/// value parameter \a N.
		919	///
		920	/// \headerfile <x86intrin.h>
		921	///
		922	/// \code
		923	/// __m128i _mm_insert_epi8(__m128i X, int I, const int N);
		924	/// \endcode
		925	///
		926	/// This intrinsic corresponds to the <c> VPINSRB / PINSRB </c> instruction.
		927	///
		928	/// \param X
		929	/// A 128-bit integer vector of [16 x i8]. This vector is copied to the
		930	/// result and then one of the sixteen elements in the result vector is
		931	/// replaced by the lower 8 bits of \a I.
		932	/// \param I
		933	/// An integer. The lower 8 bits of this operand are written to the result
		934	/// beginning at the offset specified by \a N.
		935	/// \param N
		936	/// An immediate value. Bits [3:0] specify the bit offset in the result at
		937	/// which the lower 8 bits of \a I are written. \n
		938	/// 0000: Bits [7:0] of the result are used for insertion. \n
		939	/// 0001: Bits [15:8] of the result are used for insertion. \n
		940	/// 0010: Bits [23:16] of the result are used for insertion. \n
		941	/// 0011: Bits [31:24] of the result are used for insertion. \n
		942	/// 0100: Bits [39:32] of the result are used for insertion. \n
		943	/// 0101: Bits [47:40] of the result are used for insertion. \n
		944	/// 0110: Bits [55:48] of the result are used for insertion. \n
		945	/// 0111: Bits [63:56] of the result are used for insertion. \n
		946	/// 1000: Bits [71:64] of the result are used for insertion. \n
		947	/// 1001: Bits [79:72] of the result are used for insertion. \n
		948	/// 1010: Bits [87:80] of the result are used for insertion. \n
		949	/// 1011: Bits [95:88] of the result are used for insertion. \n
		950	/// 1100: Bits [103:96] of the result are used for insertion. \n
		951	/// 1101: Bits [111:104] of the result are used for insertion. \n
		952	/// 1110: Bits [119:112] of the result are used for insertion. \n
		953	/// 1111: Bits [127:120] of the result are used for insertion.
		954	/// \returns A 128-bit integer vector containing the constructed values.
220	#define _mm_insert_epi8(X, I, N) (__extension__ \	955	#define _mm_insert_epi8(X, I, N) (__extension__ \
221	({ __v16qi __a = (__v16qi)(__m128i)(X); \	956	({ __v16qi __a = (__v16qi)(__m128i)(X); \
222	__a[(N) & 15] = (I); \	957	__a[(N) & 15] = (I); \
223	(__m128i)__a;}))	958	(__m128i)__a;}))
		959
		960	/// \brief Constructs a 128-bit vector of [4 x i32] by first making a copy of
		961	/// the 128-bit integer vector parameter, and then inserting the 32-bit
		962	/// integer parameter \a I at the offset specified by the immediate value
		963	/// parameter \a N.
		964	///
		965	/// \headerfile <x86intrin.h>
		966	///
		967	/// \code
		968	/// __m128i _mm_insert_epi32(__m128i X, int I, const int N);
		969	/// \endcode
		970	///
		971	/// This intrinsic corresponds to the <c> VPINSRD / PINSRD </c> instruction.
		972	///
		973	/// \param X
		974	/// A 128-bit integer vector of [4 x i32]. This vector is copied to the
		975	/// result and then one of the four elements in the result vector is
		976	/// replaced by \a I.
		977	/// \param I
		978	/// A 32-bit integer that is written to the result beginning at the offset
		979	/// specified by \a N.
		980	/// \param N
		981	/// An immediate value. Bits [1:0] specify the bit offset in the result at
		982	/// which the integer \a I is written. \n
		983	/// 00: Bits [31:0] of the result are used for insertion. \n
		984	/// 01: Bits [63:32] of the result are used for insertion. \n
		985	/// 10: Bits [95:64] of the result are used for insertion. \n
		986	/// 11: Bits [127:96] of the result are used for insertion.
		987	/// \returns A 128-bit integer vector containing the constructed values.
224	#define _mm_insert_epi32(X, I, N) (__extension__ \	988	#define _mm_insert_epi32(X, I, N) (__extension__ \
225	({ __v4si __a = (__v4si)(__m128i)(X); \	989	({ __v4si __a = (__v4si)(__m128i)(X); \
226	__a[(N) & 3] = (I); \	990	__a[(N) & 3] = (I); \
227	(__m128i)__a;}))	991	(__m128i)__a;}))
		992
228	#ifdef __x86_64__	993	#ifdef __x86_64__
		994	/// \brief Constructs a 128-bit vector of [2 x i64] by first making a copy of
		995	/// the 128-bit integer vector parameter, and then inserting the 64-bit
		996	/// integer parameter \a I, using the immediate value parameter \a N as an
		997	/// insertion location selector.
		998	///
		999	/// \headerfile <x86intrin.h>
		1000	///
		1001	/// \code
		1002	/// __m128i _mm_insert_epi64(__m128i X, long long I, const int N);
		1003	/// \endcode
		1004	///
		1005	/// This intrinsic corresponds to the <c> VPINSRQ / PINSRQ </c> instruction.
		1006	///
		1007	/// \param X
		1008	/// A 128-bit integer vector of [2 x i64]. This vector is copied to the
		1009	/// result and then one of the two elements in the result vector is replaced
		1010	/// by \a I.
		1011	/// \param I
		1012	/// A 64-bit integer that is written to the result beginning at the offset
		1013	/// specified by \a N.
		1014	/// \param N
		1015	/// An immediate value. Bit [0] specifies the bit offset in the result at
		1016	/// which the integer \a I is written. \n
		1017	/// 0: Bits [63:0] of the result are used for insertion. \n
		1018	/// 1: Bits [127:64] of the result are used for insertion. \n
		1019	/// \returns A 128-bit integer vector containing the constructed values.
229	#define _mm_insert_epi64(X, I, N) (__extension__ \	1020	#define _mm_insert_epi64(X, I, N) (__extension__ \
230	({ __v2di __a = (__v2di)(__m128i)(X); \	1021	({ __v2di __a = (__v2di)(__m128i)(X); \
231	__a[(N) & 1] = (I); \	1022	__a[(N) & 1] = (I); \
...	@@ -235,42 +1026,219 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2)	...	@@ -235,42 +1026,219 @@ _mm_max_epu32 (__m128i __V1, __m128i __V2)
235	/* Extract int from packed integer array at index. This returns the element	1026	/* Extract int from packed integer array at index. This returns the element
236	* as a zero extended value, so it is unsigned.	1027	* as a zero extended value, so it is unsigned.
237	*/	1028	*/
		1029	/// \brief Extracts an 8-bit element from the 128-bit integer vector of
		1030	/// [16 x i8], using the immediate value parameter \a N as a selector.
		1031	///
		1032	/// \headerfile <x86intrin.h>
		1033	///
		1034	/// \code
		1035	/// int _mm_extract_epi8(__m128i X, const int N);
		1036	/// \endcode
		1037	///
		1038	/// This intrinsic corresponds to the <c> VPEXTRB / PEXTRB </c> instruction.
		1039	///
		1040	/// \param X
		1041	/// A 128-bit integer vector.
		1042	/// \param N
		1043	/// An immediate value. Bits [3:0] specify which 8-bit vector element from
		1044	/// the argument \a X to extract and copy to the result. \n
		1045	/// 0000: Bits [7:0] of parameter \a X are extracted. \n
		1046	/// 0001: Bits [15:8] of the parameter \a X are extracted. \n
		1047	/// 0010: Bits [23:16] of the parameter \a X are extracted. \n
		1048	/// 0011: Bits [31:24] of the parameter \a X are extracted. \n
		1049	/// 0100: Bits [39:32] of the parameter \a X are extracted. \n
		1050	/// 0101: Bits [47:40] of the parameter \a X are extracted. \n
		1051	/// 0110: Bits [55:48] of the parameter \a X are extracted. \n
		1052	/// 0111: Bits [63:56] of the parameter \a X are extracted. \n
		1053	/// 1000: Bits [71:64] of the parameter \a X are extracted. \n
		1054	/// 1001: Bits [79:72] of the parameter \a X are extracted. \n
		1055	/// 1010: Bits [87:80] of the parameter \a X are extracted. \n
		1056	/// 1011: Bits [95:88] of the parameter \a X are extracted. \n
		1057	/// 1100: Bits [103:96] of the parameter \a X are extracted. \n
		1058	/// 1101: Bits [111:104] of the parameter \a X are extracted. \n
		1059	/// 1110: Bits [119:112] of the parameter \a X are extracted. \n
		1060	/// 1111: Bits [127:120] of the parameter \a X are extracted.
		1061	/// \returns An unsigned integer, whose lower 8 bits are selected from the
		1062	/// 128-bit integer vector parameter and the remaining bits are assigned
		1063	/// zeros.
238	#define _mm_extract_epi8(X, N) (__extension__ \	1064	#define _mm_extract_epi8(X, N) (__extension__ \
239	({ __v16qi __a = (__v16qi)(__m128i)(X); \	1065	({ __v16qi __a = (__v16qi)(__m128i)(X); \
240	(int)(unsigned char) __a[(N) & 15];}))	1066	(int)(unsigned char) __a[(N) & 15];}))
		1067
		1068	/// \brief Extracts a 32-bit element from the 128-bit integer vector of
		1069	/// [4 x i32], using the immediate value parameter \a N as a selector.
		1070	///
		1071	/// \headerfile <x86intrin.h>
		1072	///
		1073	/// \code
		1074	/// int _mm_extract_epi32(__m128i X, const int N);
		1075	/// \endcode
		1076	///
		1077	/// This intrinsic corresponds to the <c> VPEXTRD / PEXTRD </c> instruction.
		1078	///
		1079	/// \param X
		1080	/// A 128-bit integer vector.
		1081	/// \param N
		1082	/// An immediate value. Bits [1:0] specify which 32-bit vector element from
		1083	/// the argument \a X to extract and copy to the result. \n
		1084	/// 00: Bits [31:0] of the parameter \a X are extracted. \n
		1085	/// 01: Bits [63:32] of the parameter \a X are extracted. \n
		1086	/// 10: Bits [95:64] of the parameter \a X are extracted. \n
		1087	/// 11: Bits [127:96] of the parameter \a X are exracted.
		1088	/// \returns An integer, whose lower 32 bits are selected from the 128-bit
		1089	/// integer vector parameter and the remaining bits are assigned zeros.
241	#define _mm_extract_epi32(X, N) (__extension__ \	1090	#define _mm_extract_epi32(X, N) (__extension__ \
242	({ __v4si __a = (__v4si)(__m128i)(X); \	1091	({ __v4si __a = (__v4si)(__m128i)(X); \
243	(int)__a[(N) & 3];}))	1092	(int)__a[(N) & 3];}))
		1093
244	#ifdef __x86_64__	1094	#ifdef __x86_64__
		1095	/// \brief Extracts a 64-bit element from the 128-bit integer vector of
		1096	/// [2 x i64], using the immediate value parameter \a N as a selector.
		1097	///
		1098	/// \headerfile <x86intrin.h>
		1099	///
		1100	/// \code
		1101	/// long long _mm_extract_epi64(__m128i X, const int N);
		1102	/// \endcode
		1103	///
		1104	/// This intrinsic corresponds to the <c> VPEXTRQ / PEXTRQ </c> instruction.
		1105	///
		1106	/// \param X
		1107	/// A 128-bit integer vector.
		1108	/// \param N
		1109	/// An immediate value. Bit [0] specifies which 64-bit vector element from
		1110	/// the argument \a X to return. \n
		1111	/// 0: Bits [63:0] are returned. \n
		1112	/// 1: Bits [127:64] are returned. \n
		1113	/// \returns A 64-bit integer.
245	#define _mm_extract_epi64(X, N) (__extension__ \	1114	#define _mm_extract_epi64(X, N) (__extension__ \
246	({ __v2di __a = (__v2di)(__m128i)(X); \	1115	({ __v2di __a = (__v2di)(__m128i)(X); \
247	(long long)__a[(N) & 1];}))	1116	(long long)__a[(N) & 1];}))
248	#endif /* __x86_64 */	1117	#endif /* __x86_64 */
249		1118
250	/* SSE4 128-bit Packed Integer Comparisons. */	1119	/* SSE4 128-bit Packed Integer Comparisons. */
		1120	/// \brief Tests whether the specified bits in a 128-bit integer vector are all
		1121	/// zeros.
		1122	///
		1123	/// \headerfile <x86intrin.h>
		1124	///
		1125	/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
		1126	///
		1127	/// \param __M
		1128	/// A 128-bit integer vector containing the bits to be tested.
		1129	/// \param __V
		1130	/// A 128-bit integer vector selecting which bits to test in operand \a __M.
		1131	/// \returns TRUE if the specified bits are all zeros; FALSE otherwise.
251	static __inline__ int __DEFAULT_FN_ATTRS	1132	static __inline__ int __DEFAULT_FN_ATTRS
252	_mm_testz_si128(__m128i __M, __m128i __V)	1133	_mm_testz_si128(__m128i __M, __m128i __V)
253	{	1134	{
254	return __builtin_ia32_ptestz128((__v2di)__M, (__v2di)__V);	1135	return __builtin_ia32_ptestz128((__v2di)__M, (__v2di)__V);
255	}	1136	}
256		1137
		1138	/// \brief Tests whether the specified bits in a 128-bit integer vector are all
		1139	/// ones.
		1140	///
		1141	/// \headerfile <x86intrin.h>
		1142	///
		1143	/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
		1144	///
		1145	/// \param __M
		1146	/// A 128-bit integer vector containing the bits to be tested.
		1147	/// \param __V
		1148	/// A 128-bit integer vector selecting which bits to test in operand \a __M.
		1149	/// \returns TRUE if the specified bits are all ones; FALSE otherwise.
257	static __inline__ int __DEFAULT_FN_ATTRS	1150	static __inline__ int __DEFAULT_FN_ATTRS
258	_mm_testc_si128(__m128i __M, __m128i __V)	1151	_mm_testc_si128(__m128i __M, __m128i __V)
259	{	1152	{
260	return __builtin_ia32_ptestc128((__v2di)__M, (__v2di)__V);	1153	return __builtin_ia32_ptestc128((__v2di)__M, (__v2di)__V);
261	}	1154	}
262		1155
		1156	/// \brief Tests whether the specified bits in a 128-bit integer vector are
		1157	/// neither all zeros nor all ones.
		1158	///
		1159	/// \headerfile <x86intrin.h>
		1160	///
		1161	/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
		1162	///
		1163	/// \param __M
		1164	/// A 128-bit integer vector containing the bits to be tested.
		1165	/// \param __V
		1166	/// A 128-bit integer vector selecting which bits to test in operand \a __M.
		1167	/// \returns TRUE if the specified bits are neither all zeros nor all ones;
		1168	/// FALSE otherwise.
263	static __inline__ int __DEFAULT_FN_ATTRS	1169	static __inline__ int __DEFAULT_FN_ATTRS
264	_mm_testnzc_si128(__m128i __M, __m128i __V)	1170	_mm_testnzc_si128(__m128i __M, __m128i __V)
265	{	1171	{
266	return __builtin_ia32_ptestnzc128((__v2di)__M, (__v2di)__V);	1172	return __builtin_ia32_ptestnzc128((__v2di)__M, (__v2di)__V);
267	}	1173	}
268		1174
		1175	/// \brief Tests whether the specified bits in a 128-bit integer vector are all
		1176	/// ones.
		1177	///
		1178	/// \headerfile <x86intrin.h>
		1179	///
		1180	/// \code
		1181	/// int _mm_test_all_ones(__m128i V);
		1182	/// \endcode
		1183	///
		1184	/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
		1185	///
		1186	/// \param V
		1187	/// A 128-bit integer vector containing the bits to be tested.
		1188	/// \returns TRUE if the bits specified in the operand are all set to 1; FALSE
		1189	/// otherwise.
269	#define _mm_test_all_ones(V) _mm_testc_si128((V), _mm_cmpeq_epi32((V), (V)))	1190	#define _mm_test_all_ones(V) _mm_testc_si128((V), _mm_cmpeq_epi32((V), (V)))
		1191
		1192	/// \brief Tests whether the specified bits in a 128-bit integer vector are
		1193	/// neither all zeros nor all ones.
		1194	///
		1195	/// \headerfile <x86intrin.h>
		1196	///
		1197	/// \code
		1198	/// int _mm_test_mix_ones_zeros(__m128i M, __m128i V);
		1199	/// \endcode
		1200	///
		1201	/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
		1202	///
		1203	/// \param M
		1204	/// A 128-bit integer vector containing the bits to be tested.
		1205	/// \param V
		1206	/// A 128-bit integer vector selecting which bits to test in operand \a M.
		1207	/// \returns TRUE if the specified bits are neither all zeros nor all ones;
		1208	/// FALSE otherwise.
270	#define _mm_test_mix_ones_zeros(M, V) _mm_testnzc_si128((M), (V))	1209	#define _mm_test_mix_ones_zeros(M, V) _mm_testnzc_si128((M), (V))
		1210
		1211	/// \brief Tests whether the specified bits in a 128-bit integer vector are all
		1212	/// zeros.
		1213	///
		1214	/// \headerfile <x86intrin.h>
		1215	///
		1216	/// \code
		1217	/// int _mm_test_all_zeros(__m128i M, __m128i V);
		1218	/// \endcode
		1219	///
		1220	/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
		1221	///
		1222	/// \param M
		1223	/// A 128-bit integer vector containing the bits to be tested.
		1224	/// \param V
		1225	/// A 128-bit integer vector selecting which bits to test in operand \a M.
		1226	/// \returns TRUE if the specified bits are all zeros; FALSE otherwise.
271	#define _mm_test_all_zeros(M, V) _mm_testz_si128 ((M), (V))	1227	#define _mm_test_all_zeros(M, V) _mm_testz_si128 ((M), (V))
272		1228
273	/* SSE4 64-bit Packed Integer Comparisons. */	1229	/* SSE4 64-bit Packed Integer Comparisons. */
		1230	/// \brief Compares each of the corresponding 64-bit values of the 128-bit
		1231	/// integer vectors for equality.
		1232	///
		1233	/// \headerfile <x86intrin.h>
		1234	///
		1235	/// This intrinsic corresponds to the <c> VPCMPEQQ / PCMPEQQ </c> instruction.
		1236	///
		1237	/// \param __V1
		1238	/// A 128-bit integer vector.
		1239	/// \param __V2
		1240	/// A 128-bit integer vector.
		1241	/// \returns A 128-bit integer vector containing the comparison results.
274	static __inline__ __m128i __DEFAULT_FN_ATTRS	1242	static __inline__ __m128i __DEFAULT_FN_ATTRS
275	_mm_cmpeq_epi64(__m128i __V1, __m128i __V2)	1243	_mm_cmpeq_epi64(__m128i __V1, __m128i __V2)
276	{	1244	{
...	@@ -278,6 +1246,19 @@ _mm_cmpeq_epi64(__m128i __V1, __m128i __V2)	...	@@ -278,6 +1246,19 @@ _mm_cmpeq_epi64(__m128i __V1, __m128i __V2)
278	}	1246	}
279		1247
280	/* SSE4 Packed Integer Sign-Extension. */	1248	/* SSE4 Packed Integer Sign-Extension. */
		1249	/// \brief Sign-extends each of the lower eight 8-bit integer elements of a
		1250	/// 128-bit vector of [16 x i8] to 16-bit values and returns them in a
		1251	/// 128-bit vector of [8 x i16]. The upper eight elements of the input vector
		1252	/// are unused.
		1253	///
		1254	/// \headerfile <x86intrin.h>
		1255	///
		1256	/// This intrinsic corresponds to the <c> VPMOVSXBW / PMOVSXBW </c> instruction.
		1257	///
		1258	/// \param __V
		1259	/// A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are sign-
		1260	/// extended to 16-bit values.
		1261	/// \returns A 128-bit vector of [8 x i16] containing the sign-extended values.
281	static __inline__ __m128i __DEFAULT_FN_ATTRS	1262	static __inline__ __m128i __DEFAULT_FN_ATTRS
282	_mm_cvtepi8_epi16(__m128i __V)	1263	_mm_cvtepi8_epi16(__m128i __V)
283	{	1264	{
...	@@ -286,6 +1267,19 @@ _mm_cvtepi8_epi16(__m128i __V)	...	@@ -286,6 +1267,19 @@ _mm_cvtepi8_epi16(__m128i __V)
286	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3, 4, 5, 6, 7), __v8hi);	1267	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3, 4, 5, 6, 7), __v8hi);
287	}	1268	}
288		1269
		1270	/// \brief Sign-extends each of the lower four 8-bit integer elements of a
		1271	/// 128-bit vector of [16 x i8] to 32-bit values and returns them in a
		1272	/// 128-bit vector of [4 x i32]. The upper twelve elements of the input
		1273	/// vector are unused.
		1274	///
		1275	/// \headerfile <x86intrin.h>
		1276	///
		1277	/// This intrinsic corresponds to the <c> VPMOVSXBD / PMOVSXBD </c> instruction.
		1278	///
		1279	/// \param __V
		1280	/// A 128-bit vector of [16 x i8]. The lower four 8-bit elements are sign-
		1281	/// extended to 32-bit values.
		1282	/// \returns A 128-bit vector of [4 x i32] containing the sign-extended values.
289	static __inline__ __m128i __DEFAULT_FN_ATTRS	1283	static __inline__ __m128i __DEFAULT_FN_ATTRS
290	_mm_cvtepi8_epi32(__m128i __V)	1284	_mm_cvtepi8_epi32(__m128i __V)
291	{	1285	{
...	@@ -294,6 +1288,19 @@ _mm_cvtepi8_epi32(__m128i __V)	...	@@ -294,6 +1288,19 @@ _mm_cvtepi8_epi32(__m128i __V)
294	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3), __v4si);	1288	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3), __v4si);
295	}	1289	}
296		1290
		1291	/// \brief Sign-extends each of the lower two 8-bit integer elements of a
		1292	/// 128-bit integer vector of [16 x i8] to 64-bit values and returns them in
		1293	/// a 128-bit vector of [2 x i64]. The upper fourteen elements of the input
		1294	/// vector are unused.
		1295	///
		1296	/// \headerfile <x86intrin.h>
		1297	///
		1298	/// This intrinsic corresponds to the <c> VPMOVSXBQ / PMOVSXBQ </c> instruction.
		1299	///
		1300	/// \param __V
		1301	/// A 128-bit vector of [16 x i8]. The lower two 8-bit elements are sign-
		1302	/// extended to 64-bit values.
		1303	/// \returns A 128-bit vector of [2 x i64] containing the sign-extended values.
297	static __inline__ __m128i __DEFAULT_FN_ATTRS	1304	static __inline__ __m128i __DEFAULT_FN_ATTRS
298	_mm_cvtepi8_epi64(__m128i __V)	1305	_mm_cvtepi8_epi64(__m128i __V)
299	{	1306	{
...	@@ -302,18 +1309,57 @@ _mm_cvtepi8_epi64(__m128i __V)	...	@@ -302,18 +1309,57 @@ _mm_cvtepi8_epi64(__m128i __V)
302	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1), __v2di);	1309	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1), __v2di);
303	}	1310	}
304		1311
		1312	/// \brief Sign-extends each of the lower four 16-bit integer elements of a
		1313	/// 128-bit integer vector of [8 x i16] to 32-bit values and returns them in
		1314	/// a 128-bit vector of [4 x i32]. The upper four elements of the input
		1315	/// vector are unused.
		1316	///
		1317	/// \headerfile <x86intrin.h>
		1318	///
		1319	/// This intrinsic corresponds to the <c> VPMOVSXWD / PMOVSXWD </c> instruction.
		1320	///
		1321	/// \param __V
		1322	/// A 128-bit vector of [8 x i16]. The lower four 16-bit elements are sign-
		1323	/// extended to 32-bit values.
		1324	/// \returns A 128-bit vector of [4 x i32] containing the sign-extended values.
305	static __inline__ __m128i __DEFAULT_FN_ATTRS	1325	static __inline__ __m128i __DEFAULT_FN_ATTRS
306	_mm_cvtepi16_epi32(__m128i __V)	1326	_mm_cvtepi16_epi32(__m128i __V)
307	{	1327	{
308	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1, 2, 3), __v4si);	1328	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1, 2, 3), __v4si);
309	}	1329	}
310		1330
		1331	/// \brief Sign-extends each of the lower two 16-bit integer elements of a
		1332	/// 128-bit integer vector of [8 x i16] to 64-bit values and returns them in
		1333	/// a 128-bit vector of [2 x i64]. The upper six elements of the input
		1334	/// vector are unused.
		1335	///
		1336	/// \headerfile <x86intrin.h>
		1337	///
		1338	/// This intrinsic corresponds to the <c> VPMOVSXWQ / PMOVSXWQ </c> instruction.
		1339	///
		1340	/// \param __V
		1341	/// A 128-bit vector of [8 x i16]. The lower two 16-bit elements are sign-
		1342	/// extended to 64-bit values.
		1343	/// \returns A 128-bit vector of [2 x i64] containing the sign-extended values.
311	static __inline__ __m128i __DEFAULT_FN_ATTRS	1344	static __inline__ __m128i __DEFAULT_FN_ATTRS
312	_mm_cvtepi16_epi64(__m128i __V)	1345	_mm_cvtepi16_epi64(__m128i __V)
313	{	1346	{
314	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1), __v2di);	1347	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1), __v2di);
315	}	1348	}
316		1349
		1350	/// \brief Sign-extends each of the lower two 32-bit integer elements of a
		1351	/// 128-bit integer vector of [4 x i32] to 64-bit values and returns them in
		1352	/// a 128-bit vector of [2 x i64]. The upper two elements of the input vector
		1353	/// are unused.
		1354	///
		1355	/// \headerfile <x86intrin.h>
		1356	///
		1357	/// This intrinsic corresponds to the <c> VPMOVSXDQ / PMOVSXDQ </c> instruction.
		1358	///
		1359	/// \param __V
		1360	/// A 128-bit vector of [4 x i32]. The lower two 32-bit elements are sign-
		1361	/// extended to 64-bit values.
		1362	/// \returns A 128-bit vector of [2 x i64] containing the sign-extended values.
317	static __inline__ __m128i __DEFAULT_FN_ATTRS	1363	static __inline__ __m128i __DEFAULT_FN_ATTRS
318	_mm_cvtepi32_epi64(__m128i __V)	1364	_mm_cvtepi32_epi64(__m128i __V)
319	{	1365	{
...	@@ -321,36 +1367,114 @@ _mm_cvtepi32_epi64(__m128i __V)	...	@@ -321,36 +1367,114 @@ _mm_cvtepi32_epi64(__m128i __V)
321	}	1367	}
322		1368
323	/* SSE4 Packed Integer Zero-Extension. */	1369	/* SSE4 Packed Integer Zero-Extension. */
		1370	/// \brief Zero-extends each of the lower eight 8-bit integer elements of a
		1371	/// 128-bit vector of [16 x i8] to 16-bit values and returns them in a
		1372	/// 128-bit vector of [8 x i16]. The upper eight elements of the input vector
		1373	/// are unused.
		1374	///
		1375	/// \headerfile <x86intrin.h>
		1376	///
		1377	/// This intrinsic corresponds to the <c> VPMOVZXBW / PMOVZXBW </c> instruction.
		1378	///
		1379	/// \param __V
		1380	/// A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are zero-
		1381	/// extended to 16-bit values.
		1382	/// \returns A 128-bit vector of [8 x i16] containing the zero-extended values.
324	static __inline__ __m128i __DEFAULT_FN_ATTRS	1383	static __inline__ __m128i __DEFAULT_FN_ATTRS
325	_mm_cvtepu8_epi16(__m128i __V)	1384	_mm_cvtepu8_epi16(__m128i __V)
326	{	1385	{
327	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3, 4, 5, 6, 7), __v8hi);	1386	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3, 4, 5, 6, 7), __v8hi);
328	}	1387	}
329		1388
		1389	/// \brief Zero-extends each of the lower four 8-bit integer elements of a
		1390	/// 128-bit vector of [16 x i8] to 32-bit values and returns them in a
		1391	/// 128-bit vector of [4 x i32]. The upper twelve elements of the input
		1392	/// vector are unused.
		1393	///
		1394	/// \headerfile <x86intrin.h>
		1395	///
		1396	/// This intrinsic corresponds to the <c> VPMOVZXBD / PMOVZXBD </c> instruction.
		1397	///
		1398	/// \param __V
		1399	/// A 128-bit vector of [16 x i8]. The lower four 8-bit elements are zero-
		1400	/// extended to 32-bit values.
		1401	/// \returns A 128-bit vector of [4 x i32] containing the zero-extended values.
330	static __inline__ __m128i __DEFAULT_FN_ATTRS	1402	static __inline__ __m128i __DEFAULT_FN_ATTRS
331	_mm_cvtepu8_epi32(__m128i __V)	1403	_mm_cvtepu8_epi32(__m128i __V)
332	{	1404	{
333	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3), __v4si);	1405	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3), __v4si);
334	}	1406	}
335		1407
		1408	/// \brief Zero-extends each of the lower two 8-bit integer elements of a
		1409	/// 128-bit integer vector of [16 x i8] to 64-bit values and returns them in
		1410	/// a 128-bit vector of [2 x i64]. The upper fourteen elements of the input
		1411	/// vector are unused.
		1412	///
		1413	/// \headerfile <x86intrin.h>
		1414	///
		1415	/// This intrinsic corresponds to the <c> VPMOVZXBQ / PMOVZXBQ </c> instruction.
		1416	///
		1417	/// \param __V
		1418	/// A 128-bit vector of [16 x i8]. The lower two 8-bit elements are zero-
		1419	/// extended to 64-bit values.
		1420	/// \returns A 128-bit vector of [2 x i64] containing the zero-extended values.
336	static __inline__ __m128i __DEFAULT_FN_ATTRS	1421	static __inline__ __m128i __DEFAULT_FN_ATTRS
337	_mm_cvtepu8_epi64(__m128i __V)	1422	_mm_cvtepu8_epi64(__m128i __V)
338	{	1423	{
339	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1), __v2di);	1424	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1), __v2di);
340	}	1425	}
341		1426
		1427	/// \brief Zero-extends each of the lower four 16-bit integer elements of a
		1428	/// 128-bit integer vector of [8 x i16] to 32-bit values and returns them in
		1429	/// a 128-bit vector of [4 x i32]. The upper four elements of the input
		1430	/// vector are unused.
		1431	///
		1432	/// \headerfile <x86intrin.h>
		1433	///
		1434	/// This intrinsic corresponds to the <c> VPMOVZXWD / PMOVZXWD </c> instruction.
		1435	///
		1436	/// \param __V
		1437	/// A 128-bit vector of [8 x i16]. The lower four 16-bit elements are zero-
		1438	/// extended to 32-bit values.
		1439	/// \returns A 128-bit vector of [4 x i32] containing the zero-extended values.
342	static __inline__ __m128i __DEFAULT_FN_ATTRS	1440	static __inline__ __m128i __DEFAULT_FN_ATTRS
343	_mm_cvtepu16_epi32(__m128i __V)	1441	_mm_cvtepu16_epi32(__m128i __V)
344	{	1442	{
345	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1, 2, 3), __v4si);	1443	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1, 2, 3), __v4si);
346	}	1444	}
347		1445
		1446	/// \brief Zero-extends each of the lower two 16-bit integer elements of a
		1447	/// 128-bit integer vector of [8 x i16] to 64-bit values and returns them in
		1448	/// a 128-bit vector of [2 x i64]. The upper six elements of the input vector
		1449	/// are unused.
		1450	///
		1451	/// \headerfile <x86intrin.h>
		1452	///
		1453	/// This intrinsic corresponds to the <c> VPMOVZXWQ / PMOVZXWQ </c> instruction.
		1454	///
		1455	/// \param __V
		1456	/// A 128-bit vector of [8 x i16]. The lower two 16-bit elements are zero-
		1457	/// extended to 64-bit values.
		1458	/// \returns A 128-bit vector of [2 x i64] containing the zero-extended values.
348	static __inline__ __m128i __DEFAULT_FN_ATTRS	1459	static __inline__ __m128i __DEFAULT_FN_ATTRS
349	_mm_cvtepu16_epi64(__m128i __V)	1460	_mm_cvtepu16_epi64(__m128i __V)
350	{	1461	{
351	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1), __v2di);	1462	return (__m128i)__builtin_convertvector(__builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1), __v2di);
352	}	1463	}
353		1464
		1465	/// \brief Zero-extends each of the lower two 32-bit integer elements of a
		1466	/// 128-bit integer vector of [4 x i32] to 64-bit values and returns them in
		1467	/// a 128-bit vector of [2 x i64]. The upper two elements of the input vector
		1468	/// are unused.
		1469	///
		1470	/// \headerfile <x86intrin.h>
		1471	///
		1472	/// This intrinsic corresponds to the <c> VPMOVZXDQ / PMOVZXDQ </c> instruction.
		1473	///
		1474	/// \param __V
		1475	/// A 128-bit vector of [4 x i32]. The lower two 32-bit elements are zero-
		1476	/// extended to 64-bit values.
		1477	/// \returns A 128-bit vector of [2 x i64] containing the zero-extended values.
354	static __inline__ __m128i __DEFAULT_FN_ATTRS	1478	static __inline__ __m128i __DEFAULT_FN_ATTRS
355	_mm_cvtepu32_epi64(__m128i __V)	1479	_mm_cvtepu32_epi64(__m128i __V)
356	{	1480	{
...	@@ -358,6 +1482,28 @@ _mm_cvtepu32_epi64(__m128i __V)	...	@@ -358,6 +1482,28 @@ _mm_cvtepu32_epi64(__m128i __V)
358	}	1482	}
359		1483
360	/* SSE4 Pack with Unsigned Saturation. */	1484	/* SSE4 Pack with Unsigned Saturation. */
		1485	/// \brief Converts 32-bit signed integers from both 128-bit integer vector
		1486	/// operands into 16-bit unsigned integers, and returns the packed result.
		1487	/// Values greater than 0xFFFF are saturated to 0xFFFF. Values less than
		1488	/// 0x0000 are saturated to 0x0000.
		1489	///
		1490	/// \headerfile <x86intrin.h>
		1491	///
		1492	/// This intrinsic corresponds to the <c> VPACKUSDW / PACKUSDW </c> instruction.
		1493	///
		1494	/// \param __V1
		1495	/// A 128-bit vector of [4 x i32]. Each 32-bit element is treated as a
		1496	/// signed integer and is converted to a 16-bit unsigned integer with
		1497	/// saturation. Values greater than 0xFFFF are saturated to 0xFFFF. Values
		1498	/// less than 0x0000 are saturated to 0x0000. The converted [4 x i16] values
		1499	/// are written to the lower 64 bits of the result.
		1500	/// \param __V2
		1501	/// A 128-bit vector of [4 x i32]. Each 32-bit element is treated as a
		1502	/// signed integer and is converted to a 16-bit unsigned integer with
		1503	/// saturation. Values greater than 0xFFFF are saturated to 0xFFFF. Values
		1504	/// less than 0x0000 are saturated to 0x0000. The converted [4 x i16] values
		1505	/// are written to the higher 64 bits of the result.
		1506	/// \returns A 128-bit vector of [8 x i16] containing the converted values.
361	static __inline__ __m128i __DEFAULT_FN_ATTRS	1507	static __inline__ __m128i __DEFAULT_FN_ATTRS
362	_mm_packus_epi32(__m128i __V1, __m128i __V2)	1508	_mm_packus_epi32(__m128i __V1, __m128i __V2)
363	{	1509	{
...	@@ -365,10 +1511,58 @@ _mm_packus_epi32(__m128i __V1, __m128i __V2)	...	@@ -365,10 +1511,58 @@ _mm_packus_epi32(__m128i __V1, __m128i __V2)
365	}	1511	}
366		1512
367	/* SSE4 Multiple Packed Sums of Absolute Difference. */	1513	/* SSE4 Multiple Packed Sums of Absolute Difference. */
		1514	/// \brief Subtracts 8-bit unsigned integer values and computes the absolute
		1515	/// values of the differences to the corresponding bits in the destination.
		1516	/// Then sums of the absolute differences are returned according to the bit
		1517	/// fields in the immediate operand.
		1518	///
		1519	/// \headerfile <x86intrin.h>
		1520	///
		1521	/// \code
		1522	/// __m128i _mm_mpsadbw_epu8(__m128i X, __m128i Y, const int M);
		1523	/// \endcode
		1524	///
		1525	/// This intrinsic corresponds to the <c> VMPSADBW / MPSADBW </c> instruction.
		1526	///
		1527	/// \param X
		1528	/// A 128-bit vector of [16 x i8].
		1529	/// \param Y
		1530	/// A 128-bit vector of [16 x i8].
		1531	/// \param M
		1532	/// An 8-bit immediate operand specifying how the absolute differences are to
		1533	/// be calculated, according to the following algorithm:
		1534	/// \code
		1535	/// // M2 represents bit 2 of the immediate operand
		1536	/// // M10 represents bits [1:0] of the immediate operand
		1537	/// i = M2 * 4
		1538	/// j = M10 * 4
		1539	/// for (k = 0; k < 8; k = k + 1) {
		1540	/// d0 = abs(X[i + k + 0] - Y[j + 0])
		1541	/// d1 = abs(X[i + k + 1] - Y[j + 1])
		1542	/// d2 = abs(X[i + k + 2] - Y[j + 2])
		1543	/// d3 = abs(X[i + k + 3] - Y[j + 3])
		1544	/// r[k] = d0 + d1 + d2 + d3
		1545	/// }
		1546	/// \endcode
		1547	/// \returns A 128-bit integer vector containing the sums of the sets of
		1548	/// absolute differences between both operands.
368	#define _mm_mpsadbw_epu8(X, Y, M) __extension__ ({ \	1549	#define _mm_mpsadbw_epu8(X, Y, M) __extension__ ({ \
369	(__m128i) __builtin_ia32_mpsadbw128((__v16qi)(__m128i)(X), \	1550	(__m128i) __builtin_ia32_mpsadbw128((__v16qi)(__m128i)(X), \
370	(__v16qi)(__m128i)(Y), (M)); })	1551	(__v16qi)(__m128i)(Y), (M)); })
371		1552
		1553	/// \brief Finds the minimum unsigned 16-bit element in the input 128-bit
		1554	/// vector of [8 x u16] and returns it and along with its index.
		1555	///
		1556	/// \headerfile <x86intrin.h>
		1557	///
		1558	/// This intrinsic corresponds to the <c> VPHMINPOSUW / PHMINPOSUW </c>
		1559	/// instruction.
		1560	///
		1561	/// \param __V
		1562	/// A 128-bit vector of [8 x u16].
		1563	/// \returns A 128-bit value where bits [15:0] contain the minimum value found
		1564	/// in parameter \a __V, bits [18:16] contain the index of the minimum value
		1565	/// and the remaining bits are set to 0.
372	static __inline__ __m128i __DEFAULT_FN_ATTRS	1566	static __inline__ __m128i __DEFAULT_FN_ATTRS
373	_mm_minpos_epu16(__m128i __V)	1567	_mm_minpos_epu16(__m128i __V)
374	{	1568	{
...	@@ -410,61 +1604,769 @@ _mm_minpos_epu16(__m128i __V)	...	@@ -410,61 +1604,769 @@ _mm_minpos_epu16(__m128i __V)
410	#define _SIDD_UNIT_MASK 0x40	1604	#define _SIDD_UNIT_MASK 0x40
411		1605
412	/* SSE4.2 Packed Comparison Intrinsics. */	1606	/* SSE4.2 Packed Comparison Intrinsics. */
		1607	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1608	/// data with implicitly defined lengths that is contained in source operands
		1609	/// \a A and \a B. Returns a 128-bit integer vector representing the result
		1610	/// mask of the comparison.
		1611	///
		1612	/// \headerfile <x86intrin.h>
		1613	///
		1614	/// \code
		1615	/// __m128i _mm_cmpistrm(__m128i A, __m128i B, const int M);
		1616	/// \endcode
		1617	///
		1618	/// This intrinsic corresponds to the <c> VPCMPISTRM / PCMPISTRM </c>
		1619	/// instruction.
		1620	///
		1621	/// \param A
		1622	/// A 128-bit integer vector containing one of the source operands to be
		1623	/// compared.
		1624	/// \param B
		1625	/// A 128-bit integer vector containing one of the source operands to be
		1626	/// compared.
		1627	/// \param M
		1628	/// An 8-bit immediate operand specifying whether the characters are bytes or
		1629	/// words, the type of comparison to perform, and the format of the return
		1630	/// value. \n
		1631	/// Bits [1:0]: Determine source data format. \n
		1632	/// 00: 16 unsigned bytes \n
		1633	/// 01: 8 unsigned words \n
		1634	/// 10: 16 signed bytes \n
		1635	/// 11: 8 signed words \n
		1636	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		1637	/// 00: Subset: Each character in \a B is compared for equality with all
		1638	/// the characters in \a A. \n
		1639	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		1640	/// basis is greater than or equal for even-indexed elements in \a A,
		1641	/// and less than or equal for odd-indexed elements in \a A. \n
		1642	/// 10: Match: Compare each pair of corresponding characters in \a A and
		1643	/// \a B for equality. \n
		1644	/// 11: Substring: Search \a B for substring matches of \a A. \n
		1645	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		1646	/// mask of the comparison results. \n
		1647	/// 00: No effect. \n
		1648	/// 01: Negate the bit mask. \n
		1649	/// 10: No effect. \n
		1650	/// 11: Negate the bit mask only for bits with an index less than or equal
		1651	/// to the size of \a A or \a B. \n
		1652	/// Bit [6]: Determines whether the result is zero-extended or expanded to 16
		1653	/// bytes. \n
		1654	/// 0: The result is zero-extended to 16 bytes. \n
		1655	/// 1: The result is expanded to 16 bytes (this expansion is performed by
		1656	/// repeating each bit 8 or 16 times).
		1657	/// \returns Returns a 128-bit integer vector representing the result mask of
		1658	/// the comparison.
413	#define _mm_cmpistrm(A, B, M) \	1659	#define _mm_cmpistrm(A, B, M) \
414	(__m128i)__builtin_ia32_pcmpistrm128((__v16qi)(__m128i)(A), \	1660	(__m128i)__builtin_ia32_pcmpistrm128((__v16qi)(__m128i)(A), \
415	(__v16qi)(__m128i)(B), (int)(M))	1661	(__v16qi)(__m128i)(B), (int)(M))
		1662
		1663	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1664	/// data with implicitly defined lengths that is contained in source operands
		1665	/// \a A and \a B. Returns an integer representing the result index of the
		1666	/// comparison.
		1667	///
		1668	/// \headerfile <x86intrin.h>
		1669	///
		1670	/// \code
		1671	/// int _mm_cmpistri(__m128i A, __m128i B, const int M);
		1672	/// \endcode
		1673	///
		1674	/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
		1675	/// instruction.
		1676	///
		1677	/// \param A
		1678	/// A 128-bit integer vector containing one of the source operands to be
		1679	/// compared.
		1680	/// \param B
		1681	/// A 128-bit integer vector containing one of the source operands to be
		1682	/// compared.
		1683	/// \param M
		1684	/// An 8-bit immediate operand specifying whether the characters are bytes or
		1685	/// words, the type of comparison to perform, and the format of the return
		1686	/// value. \n
		1687	/// Bits [1:0]: Determine source data format. \n
		1688	/// 00: 16 unsigned bytes \n
		1689	/// 01: 8 unsigned words \n
		1690	/// 10: 16 signed bytes \n
		1691	/// 11: 8 signed words \n
		1692	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		1693	/// 00: Subset: Each character in \a B is compared for equality with all
		1694	/// the characters in \a A. \n
		1695	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		1696	/// basis is greater than or equal for even-indexed elements in \a A,
		1697	/// and less than or equal for odd-indexed elements in \a A. \n
		1698	/// 10: Match: Compare each pair of corresponding characters in \a A and
		1699	/// \a B for equality. \n
		1700	/// 11: Substring: Search B for substring matches of \a A. \n
		1701	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		1702	/// mask of the comparison results. \n
		1703	/// 00: No effect. \n
		1704	/// 01: Negate the bit mask. \n
		1705	/// 10: No effect. \n
		1706	/// 11: Negate the bit mask only for bits with an index less than or equal
		1707	/// to the size of \a A or \a B. \n
		1708	/// Bit [6]: Determines whether the index of the lowest set bit or the
		1709	/// highest set bit is returned. \n
		1710	/// 0: The index of the least significant set bit. \n
		1711	/// 1: The index of the most significant set bit. \n
		1712	/// \returns Returns an integer representing the result index of the comparison.
416	#define _mm_cmpistri(A, B, M) \	1713	#define _mm_cmpistri(A, B, M) \
417	(int)__builtin_ia32_pcmpistri128((__v16qi)(__m128i)(A), \	1714	(int)__builtin_ia32_pcmpistri128((__v16qi)(__m128i)(A), \
418	(__v16qi)(__m128i)(B), (int)(M))	1715	(__v16qi)(__m128i)(B), (int)(M))
419		1716
		1717	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1718	/// data with explicitly defined lengths that is contained in source operands
		1719	/// \a A and \a B. Returns a 128-bit integer vector representing the result
		1720	/// mask of the comparison.
		1721	///
		1722	/// \headerfile <x86intrin.h>
		1723	///
		1724	/// \code
		1725	/// __m128i _mm_cmpestrm(__m128i A, int LA, __m128i B, int LB, const int M);
		1726	/// \endcode
		1727	///
		1728	/// This intrinsic corresponds to the <c> VPCMPESTRM / PCMPESTRM </c>
		1729	/// instruction.
		1730	///
		1731	/// \param A
		1732	/// A 128-bit integer vector containing one of the source operands to be
		1733	/// compared.
		1734	/// \param LA
		1735	/// An integer that specifies the length of the string in \a A.
		1736	/// \param B
		1737	/// A 128-bit integer vector containing one of the source operands to be
		1738	/// compared.
		1739	/// \param LB
		1740	/// An integer that specifies the length of the string in \a B.
		1741	/// \param M
		1742	/// An 8-bit immediate operand specifying whether the characters are bytes or
		1743	/// words, the type of comparison to perform, and the format of the return
		1744	/// value. \n
		1745	/// Bits [1:0]: Determine source data format. \n
		1746	/// 00: 16 unsigned bytes \n
		1747	/// 01: 8 unsigned words \n
		1748	/// 10: 16 signed bytes \n
		1749	/// 11: 8 signed words \n
		1750	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		1751	/// 00: Subset: Each character in \a B is compared for equality with all
		1752	/// the characters in \a A. \n
		1753	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		1754	/// basis is greater than or equal for even-indexed elements in \a A,
		1755	/// and less than or equal for odd-indexed elements in \a A. \n
		1756	/// 10: Match: Compare each pair of corresponding characters in \a A and
		1757	/// \a B for equality. \n
		1758	/// 11: Substring: Search \a B for substring matches of \a A. \n
		1759	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		1760	/// mask of the comparison results. \n
		1761	/// 00: No effect. \n
		1762	/// 01: Negate the bit mask. \n
		1763	/// 10: No effect. \n
		1764	/// 11: Negate the bit mask only for bits with an index less than or equal
		1765	/// to the size of \a A or \a B. \n
		1766	/// Bit [6]: Determines whether the result is zero-extended or expanded to 16
		1767	/// bytes. \n
		1768	/// 0: The result is zero-extended to 16 bytes. \n
		1769	/// 1: The result is expanded to 16 bytes (this expansion is performed by
		1770	/// repeating each bit 8 or 16 times). \n
		1771	/// \returns Returns a 128-bit integer vector representing the result mask of
		1772	/// the comparison.
420	#define _mm_cmpestrm(A, LA, B, LB, M) \	1773	#define _mm_cmpestrm(A, LA, B, LB, M) \
421	(__m128i)__builtin_ia32_pcmpestrm128((__v16qi)(__m128i)(A), (int)(LA), \	1774	(__m128i)__builtin_ia32_pcmpestrm128((__v16qi)(__m128i)(A), (int)(LA), \
422	(__v16qi)(__m128i)(B), (int)(LB), \	1775	(__v16qi)(__m128i)(B), (int)(LB), \
423	(int)(M))	1776	(int)(M))
		1777
		1778	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1779	/// data with explicitly defined lengths that is contained in source operands
		1780	/// \a A and \a B. Returns an integer representing the result index of the
		1781	/// comparison.
		1782	///
		1783	/// \headerfile <x86intrin.h>
		1784	///
		1785	/// \code
		1786	/// int _mm_cmpestri(__m128i A, int LA, __m128i B, int LB, const int M);
		1787	/// \endcode
		1788	///
		1789	/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
		1790	/// instruction.
		1791	///
		1792	/// \param A
		1793	/// A 128-bit integer vector containing one of the source operands to be
		1794	/// compared.
		1795	/// \param LA
		1796	/// An integer that specifies the length of the string in \a A.
		1797	/// \param B
		1798	/// A 128-bit integer vector containing one of the source operands to be
		1799	/// compared.
		1800	/// \param LB
		1801	/// An integer that specifies the length of the string in \a B.
		1802	/// \param M
		1803	/// An 8-bit immediate operand specifying whether the characters are bytes or
		1804	/// words, the type of comparison to perform, and the format of the return
		1805	/// value. \n
		1806	/// Bits [1:0]: Determine source data format. \n
		1807	/// 00: 16 unsigned bytes \n
		1808	/// 01: 8 unsigned words \n
		1809	/// 10: 16 signed bytes \n
		1810	/// 11: 8 signed words \n
		1811	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		1812	/// 00: Subset: Each character in \a B is compared for equality with all
		1813	/// the characters in \a A. \n
		1814	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		1815	/// basis is greater than or equal for even-indexed elements in \a A,
		1816	/// and less than or equal for odd-indexed elements in \a A. \n
		1817	/// 10: Match: Compare each pair of corresponding characters in \a A and
		1818	/// \a B for equality. \n
		1819	/// 11: Substring: Search B for substring matches of \a A. \n
		1820	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		1821	/// mask of the comparison results. \n
		1822	/// 00: No effect. \n
		1823	/// 01: Negate the bit mask. \n
		1824	/// 10: No effect. \n
		1825	/// 11: Negate the bit mask only for bits with an index less than or equal
		1826	/// to the size of \a A or \a B. \n
		1827	/// Bit [6]: Determines whether the index of the lowest set bit or the
		1828	/// highest set bit is returned. \n
		1829	/// 0: The index of the least significant set bit. \n
		1830	/// 1: The index of the most significant set bit. \n
		1831	/// \returns Returns an integer representing the result index of the comparison.
424	#define _mm_cmpestri(A, LA, B, LB, M) \	1832	#define _mm_cmpestri(A, LA, B, LB, M) \
425	(int)__builtin_ia32_pcmpestri128((__v16qi)(__m128i)(A), (int)(LA), \	1833	(int)__builtin_ia32_pcmpestri128((__v16qi)(__m128i)(A), (int)(LA), \
426	(__v16qi)(__m128i)(B), (int)(LB), \	1834	(__v16qi)(__m128i)(B), (int)(LB), \
427	(int)(M))	1835	(int)(M))
428		1836
429	/* SSE4.2 Packed Comparison Intrinsics and EFlag Reading. */	1837	/* SSE4.2 Packed Comparison Intrinsics and EFlag Reading. */
		1838	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1839	/// data with implicitly defined lengths that is contained in source operands
		1840	/// \a A and \a B. Returns 1 if the bit mask is zero and the length of the
		1841	/// string in \a B is the maximum, otherwise, returns 0.
		1842	///
		1843	/// \headerfile <x86intrin.h>
		1844	///
		1845	/// \code
		1846	/// int _mm_cmpistra(__m128i A, __m128i B, const int M);
		1847	/// \endcode
		1848	///
		1849	/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
		1850	/// instruction.
		1851	///
		1852	/// \param A
		1853	/// A 128-bit integer vector containing one of the source operands to be
		1854	/// compared.
		1855	/// \param B
		1856	/// A 128-bit integer vector containing one of the source operands to be
		1857	/// compared.
		1858	/// \param M
		1859	/// An 8-bit immediate operand specifying whether the characters are bytes or
		1860	/// words and the type of comparison to perform. \n
		1861	/// Bits [1:0]: Determine source data format. \n
		1862	/// 00: 16 unsigned bytes \n
		1863	/// 01: 8 unsigned words \n
		1864	/// 10: 16 signed bytes \n
		1865	/// 11: 8 signed words \n
		1866	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		1867	/// 00: Subset: Each character in \a B is compared for equality with all
		1868	/// the characters in \a A. \n
		1869	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		1870	/// basis is greater than or equal for even-indexed elements in \a A,
		1871	/// and less than or equal for odd-indexed elements in \a A. \n
		1872	/// 10: Match: Compare each pair of corresponding characters in \a A and
		1873	/// \a B for equality. \n
		1874	/// 11: Substring: Search \a B for substring matches of \a A. \n
		1875	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		1876	/// mask of the comparison results. \n
		1877	/// 00: No effect. \n
		1878	/// 01: Negate the bit mask. \n
		1879	/// 10: No effect. \n
		1880	/// 11: Negate the bit mask only for bits with an index less than or equal
		1881	/// to the size of \a A or \a B. \n
		1882	/// \returns Returns 1 if the bit mask is zero and the length of the string in
		1883	/// \a B is the maximum; otherwise, returns 0.
430	#define _mm_cmpistra(A, B, M) \	1884	#define _mm_cmpistra(A, B, M) \
431	(int)__builtin_ia32_pcmpistria128((__v16qi)(__m128i)(A), \	1885	(int)__builtin_ia32_pcmpistria128((__v16qi)(__m128i)(A), \
432	(__v16qi)(__m128i)(B), (int)(M))	1886	(__v16qi)(__m128i)(B), (int)(M))
		1887
		1888	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1889	/// data with implicitly defined lengths that is contained in source operands
		1890	/// \a A and \a B. Returns 1 if the bit mask is non-zero, otherwise, returns
		1891	/// 0.
		1892	///
		1893	/// \headerfile <x86intrin.h>
		1894	///
		1895	/// \code
		1896	/// int _mm_cmpistrc(__m128i A, __m128i B, const int M);
		1897	/// \endcode
		1898	///
		1899	/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
		1900	/// instruction.
		1901	///
		1902	/// \param A
		1903	/// A 128-bit integer vector containing one of the source operands to be
		1904	/// compared.
		1905	/// \param B
		1906	/// A 128-bit integer vector containing one of the source operands to be
		1907	/// compared.
		1908	/// \param M
		1909	/// An 8-bit immediate operand specifying whether the characters are bytes or
		1910	/// words and the type of comparison to perform. \n
		1911	/// Bits [1:0]: Determine source data format. \n
		1912	/// 00: 16 unsigned bytes \n
		1913	/// 01: 8 unsigned words \n
		1914	/// 10: 16 signed bytes \n
		1915	/// 11: 8 signed words \n
		1916	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		1917	/// 00: Subset: Each character in \a B is compared for equality with all
		1918	/// the characters in \a A. \n
		1919	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		1920	/// basis is greater than or equal for even-indexed elements in \a A,
		1921	/// and less than or equal for odd-indexed elements in \a A. \n
		1922	/// 10: Match: Compare each pair of corresponding characters in \a A and
		1923	/// \a B for equality. \n
		1924	/// 11: Substring: Search B for substring matches of \a A. \n
		1925	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		1926	/// mask of the comparison results. \n
		1927	/// 00: No effect. \n
		1928	/// 01: Negate the bit mask. \n
		1929	/// 10: No effect. \n
		1930	/// 11: Negate the bit mask only for bits with an index less than or equal
		1931	/// to the size of \a A or \a B.
		1932	/// \returns Returns 1 if the bit mask is non-zero, otherwise, returns 0.
433	#define _mm_cmpistrc(A, B, M) \	1933	#define _mm_cmpistrc(A, B, M) \
434	(int)__builtin_ia32_pcmpistric128((__v16qi)(__m128i)(A), \	1934	(int)__builtin_ia32_pcmpistric128((__v16qi)(__m128i)(A), \
435	(__v16qi)(__m128i)(B), (int)(M))	1935	(__v16qi)(__m128i)(B), (int)(M))
		1936
		1937	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1938	/// data with implicitly defined lengths that is contained in source operands
		1939	/// \a A and \a B. Returns bit 0 of the resulting bit mask.
		1940	///
		1941	/// \headerfile <x86intrin.h>
		1942	///
		1943	/// \code
		1944	/// int _mm_cmpistro(__m128i A, __m128i B, const int M);
		1945	/// \endcode
		1946	///
		1947	/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
		1948	/// instruction.
		1949	///
		1950	/// \param A
		1951	/// A 128-bit integer vector containing one of the source operands to be
		1952	/// compared.
		1953	/// \param B
		1954	/// A 128-bit integer vector containing one of the source operands to be
		1955	/// compared.
		1956	/// \param M
		1957	/// An 8-bit immediate operand specifying whether the characters are bytes or
		1958	/// words and the type of comparison to perform. \n
		1959	/// Bits [1:0]: Determine source data format. \n
		1960	/// 00: 16 unsigned bytes \n
		1961	/// 01: 8 unsigned words \n
		1962	/// 10: 16 signed bytes \n
		1963	/// 11: 8 signed words \n
		1964	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		1965	/// 00: Subset: Each character in \a B is compared for equality with all
		1966	/// the characters in \a A. \n
		1967	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		1968	/// basis is greater than or equal for even-indexed elements in \a A,
		1969	/// and less than or equal for odd-indexed elements in \a A. \n
		1970	/// 10: Match: Compare each pair of corresponding characters in \a A and
		1971	/// \a B for equality. \n
		1972	/// 11: Substring: Search B for substring matches of \a A. \n
		1973	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		1974	/// mask of the comparison results. \n
		1975	/// 00: No effect. \n
		1976	/// 01: Negate the bit mask. \n
		1977	/// 10: No effect. \n
		1978	/// 11: Negate the bit mask only for bits with an index less than or equal
		1979	/// to the size of \a A or \a B. \n
		1980	/// \returns Returns bit 0 of the resulting bit mask.
436	#define _mm_cmpistro(A, B, M) \	1981	#define _mm_cmpistro(A, B, M) \
437	(int)__builtin_ia32_pcmpistrio128((__v16qi)(__m128i)(A), \	1982	(int)__builtin_ia32_pcmpistrio128((__v16qi)(__m128i)(A), \
438	(__v16qi)(__m128i)(B), (int)(M))	1983	(__v16qi)(__m128i)(B), (int)(M))
		1984
		1985	/// \brief Uses the immediate operand \a M to perform a comparison of string
		1986	/// data with implicitly defined lengths that is contained in source operands
		1987	/// \a A and \a B. Returns 1 if the length of the string in \a A is less than
		1988	/// the maximum, otherwise, returns 0.
		1989	///
		1990	/// \headerfile <x86intrin.h>
		1991	///
		1992	/// \code
		1993	/// int _mm_cmpistrs(__m128i A, __m128i B, const int M);
		1994	/// \endcode
		1995	///
		1996	/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
		1997	/// instruction.
		1998	///
		1999	/// \param A
		2000	/// A 128-bit integer vector containing one of the source operands to be
		2001	/// compared.
		2002	/// \param B
		2003	/// A 128-bit integer vector containing one of the source operands to be
		2004	/// compared.
		2005	/// \param M
		2006	/// An 8-bit immediate operand specifying whether the characters are bytes or
		2007	/// words and the type of comparison to perform. \n
		2008	/// Bits [1:0]: Determine source data format. \n
		2009	/// 00: 16 unsigned bytes \n
		2010	/// 01: 8 unsigned words \n
		2011	/// 10: 16 signed bytes \n
		2012	/// 11: 8 signed words \n
		2013	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		2014	/// 00: Subset: Each character in \a B is compared for equality with all
		2015	/// the characters in \a A. \n
		2016	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		2017	/// basis is greater than or equal for even-indexed elements in \a A,
		2018	/// and less than or equal for odd-indexed elements in \a A. \n
		2019	/// 10: Match: Compare each pair of corresponding characters in \a A and
		2020	/// \a B for equality. \n
		2021	/// 11: Substring: Search \a B for substring matches of \a A. \n
		2022	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		2023	/// mask of the comparison results. \n
		2024	/// 00: No effect. \n
		2025	/// 01: Negate the bit mask. \n
		2026	/// 10: No effect. \n
		2027	/// 11: Negate the bit mask only for bits with an index less than or equal
		2028	/// to the size of \a A or \a B. \n
		2029	/// \returns Returns 1 if the length of the string in \a A is less than the
		2030	/// maximum, otherwise, returns 0.
439	#define _mm_cmpistrs(A, B, M) \	2031	#define _mm_cmpistrs(A, B, M) \
440	(int)__builtin_ia32_pcmpistris128((__v16qi)(__m128i)(A), \	2032	(int)__builtin_ia32_pcmpistris128((__v16qi)(__m128i)(A), \
441	(__v16qi)(__m128i)(B), (int)(M))	2033	(__v16qi)(__m128i)(B), (int)(M))
		2034
		2035	/// \brief Uses the immediate operand \a M to perform a comparison of string
		2036	/// data with implicitly defined lengths that is contained in source operands
		2037	/// \a A and \a B. Returns 1 if the length of the string in \a B is less than
		2038	/// the maximum, otherwise, returns 0.
		2039	///
		2040	/// \headerfile <x86intrin.h>
		2041	///
		2042	/// \code
		2043	/// int _mm_cmpistrz(__m128i A, __m128i B, const int M);
		2044	/// \endcode
		2045	///
		2046	/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
		2047	/// instruction.
		2048	///
		2049	/// \param A
		2050	/// A 128-bit integer vector containing one of the source operands to be
		2051	/// compared.
		2052	/// \param B
		2053	/// A 128-bit integer vector containing one of the source operands to be
		2054	/// compared.
		2055	/// \param M
		2056	/// An 8-bit immediate operand specifying whether the characters are bytes or
		2057	/// words and the type of comparison to perform. \n
		2058	/// Bits [1:0]: Determine source data format. \n
		2059	/// 00: 16 unsigned bytes \n
		2060	/// 01: 8 unsigned words \n
		2061	/// 10: 16 signed bytes \n
		2062	/// 11: 8 signed words \n
		2063	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		2064	/// 00: Subset: Each character in \a B is compared for equality with all
		2065	/// the characters in \a A. \n
		2066	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		2067	/// basis is greater than or equal for even-indexed elements in \a A,
		2068	/// and less than or equal for odd-indexed elements in \a A. \n
		2069	/// 10: Match: Compare each pair of corresponding characters in \a A and
		2070	/// \a B for equality. \n
		2071	/// 11: Substring: Search \a B for substring matches of \a A. \n
		2072	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		2073	/// mask of the comparison results. \n
		2074	/// 00: No effect. \n
		2075	/// 01: Negate the bit mask. \n
		2076	/// 10: No effect. \n
		2077	/// 11: Negate the bit mask only for bits with an index less than or equal
		2078	/// to the size of \a A or \a B.
		2079	/// \returns Returns 1 if the length of the string in \a B is less than the
		2080	/// maximum, otherwise, returns 0.
442	#define _mm_cmpistrz(A, B, M) \	2081	#define _mm_cmpistrz(A, B, M) \
443	(int)__builtin_ia32_pcmpistriz128((__v16qi)(__m128i)(A), \	2082	(int)__builtin_ia32_pcmpistriz128((__v16qi)(__m128i)(A), \
444	(__v16qi)(__m128i)(B), (int)(M))	2083	(__v16qi)(__m128i)(B), (int)(M))
445		2084
		2085	/// \brief Uses the immediate operand \a M to perform a comparison of string
		2086	/// data with explicitly defined lengths that is contained in source operands
		2087	/// \a A and \a B. Returns 1 if the bit mask is zero and the length of the
		2088	/// string in \a B is the maximum, otherwise, returns 0.
		2089	///
		2090	/// \headerfile <x86intrin.h>
		2091	///
		2092	/// \code
		2093	/// int _mm_cmpestra(__m128i A, int LA, __m128i B, int LB, const int M);
		2094	/// \endcode
		2095	///
		2096	/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
		2097	/// instruction.
		2098	///
		2099	/// \param A
		2100	/// A 128-bit integer vector containing one of the source operands to be
		2101	/// compared.
		2102	/// \param LA
		2103	/// An integer that specifies the length of the string in \a A.
		2104	/// \param B
		2105	/// A 128-bit integer vector containing one of the source operands to be
		2106	/// compared.
		2107	/// \param LB
		2108	/// An integer that specifies the length of the string in \a B.
		2109	/// \param M
		2110	/// An 8-bit immediate operand specifying whether the characters are bytes or
		2111	/// words and the type of comparison to perform. \n
		2112	/// Bits [1:0]: Determine source data format. \n
		2113	/// 00: 16 unsigned bytes \n
		2114	/// 01: 8 unsigned words \n
		2115	/// 10: 16 signed bytes \n
		2116	/// 11: 8 signed words \n
		2117	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		2118	/// 00: Subset: Each character in \a B is compared for equality with all
		2119	/// the characters in \a A. \n
		2120	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		2121	/// basis is greater than or equal for even-indexed elements in \a A,
		2122	/// and less than or equal for odd-indexed elements in \a A. \n
		2123	/// 10: Match: Compare each pair of corresponding characters in \a A and
		2124	/// \a B for equality. \n
		2125	/// 11: Substring: Search \a B for substring matches of \a A. \n
		2126	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		2127	/// mask of the comparison results. \n
		2128	/// 00: No effect. \n
		2129	/// 01: Negate the bit mask. \n
		2130	/// 10: No effect. \n
		2131	/// 11: Negate the bit mask only for bits with an index less than or equal
		2132	/// to the size of \a A or \a B.
		2133	/// \returns Returns 1 if the bit mask is zero and the length of the string in
		2134	/// \a B is the maximum, otherwise, returns 0.
446	#define _mm_cmpestra(A, LA, B, LB, M) \	2135	#define _mm_cmpestra(A, LA, B, LB, M) \
447	(int)__builtin_ia32_pcmpestria128((__v16qi)(__m128i)(A), (int)(LA), \	2136	(int)__builtin_ia32_pcmpestria128((__v16qi)(__m128i)(A), (int)(LA), \
448	(__v16qi)(__m128i)(B), (int)(LB), \	2137	(__v16qi)(__m128i)(B), (int)(LB), \
449	(int)(M))	2138	(int)(M))
		2139
		2140	/// \brief Uses the immediate operand \a M to perform a comparison of string
		2141	/// data with explicitly defined lengths that is contained in source operands
		2142	/// \a A and \a B. Returns 1 if the resulting mask is non-zero, otherwise,
		2143	/// returns 0.
		2144	///
		2145	/// \headerfile <x86intrin.h>
		2146	///
		2147	/// \code
		2148	/// int _mm_cmpestrc(__m128i A, int LA, __m128i B, int LB, const int M);
		2149	/// \endcode
		2150	///
		2151	/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
		2152	/// instruction.
		2153	///
		2154	/// \param A
		2155	/// A 128-bit integer vector containing one of the source operands to be
		2156	/// compared.
		2157	/// \param LA
		2158	/// An integer that specifies the length of the string in \a A.
		2159	/// \param B
		2160	/// A 128-bit integer vector containing one of the source operands to be
		2161	/// compared.
		2162	/// \param LB
		2163	/// An integer that specifies the length of the string in \a B.
		2164	/// \param M
		2165	/// An 8-bit immediate operand specifying whether the characters are bytes or
		2166	/// words and the type of comparison to perform. \n
		2167	/// Bits [1:0]: Determine source data format. \n
		2168	/// 00: 16 unsigned bytes \n
		2169	/// 01: 8 unsigned words \n
		2170	/// 10: 16 signed bytes \n
		2171	/// 11: 8 signed words \n
		2172	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		2173	/// 00: Subset: Each character in \a B is compared for equality with all
		2174	/// the characters in \a A. \n
		2175	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		2176	/// basis is greater than or equal for even-indexed elements in \a A,
		2177	/// and less than or equal for odd-indexed elements in \a A. \n
		2178	/// 10: Match: Compare each pair of corresponding characters in \a A and
		2179	/// \a B for equality. \n
		2180	/// 11: Substring: Search \a B for substring matches of \a A. \n
		2181	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		2182	/// mask of the comparison results. \n
		2183	/// 00: No effect. \n
		2184	/// 01: Negate the bit mask. \n
		2185	/// 10: No effect. \n
		2186	/// 11: Negate the bit mask only for bits with an index less than or equal
		2187	/// to the size of \a A or \a B. \n
		2188	/// \returns Returns 1 if the resulting mask is non-zero, otherwise, returns 0.
450	#define _mm_cmpestrc(A, LA, B, LB, M) \	2189	#define _mm_cmpestrc(A, LA, B, LB, M) \
451	(int)__builtin_ia32_pcmpestric128((__v16qi)(__m128i)(A), (int)(LA), \	2190	(int)__builtin_ia32_pcmpestric128((__v16qi)(__m128i)(A), (int)(LA), \
452	(__v16qi)(__m128i)(B), (int)(LB), \	2191	(__v16qi)(__m128i)(B), (int)(LB), \
453	(int)(M))	2192	(int)(M))
		2193
		2194	/// \brief Uses the immediate operand \a M to perform a comparison of string
		2195	/// data with explicitly defined lengths that is contained in source operands
		2196	/// \a A and \a B. Returns bit 0 of the resulting bit mask.
		2197	///
		2198	/// \headerfile <x86intrin.h>
		2199	///
		2200	/// \code
		2201	/// int _mm_cmpestro(__m128i A, int LA, __m128i B, int LB, const int M);
		2202	/// \endcode
		2203	///
		2204	/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
		2205	/// instruction.
		2206	///
		2207	/// \param A
		2208	/// A 128-bit integer vector containing one of the source operands to be
		2209	/// compared.
		2210	/// \param LA
		2211	/// An integer that specifies the length of the string in \a A.
		2212	/// \param B
		2213	/// A 128-bit integer vector containing one of the source operands to be
		2214	/// compared.
		2215	/// \param LB
		2216	/// An integer that specifies the length of the string in \a B.
		2217	/// \param M
		2218	/// An 8-bit immediate operand specifying whether the characters are bytes or
		2219	/// words and the type of comparison to perform. \n
		2220	/// Bits [1:0]: Determine source data format. \n
		2221	/// 00: 16 unsigned bytes \n
		2222	/// 01: 8 unsigned words \n
		2223	/// 10: 16 signed bytes \n
		2224	/// 11: 8 signed words \n
		2225	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		2226	/// 00: Subset: Each character in \a B is compared for equality with all
		2227	/// the characters in \a A. \n
		2228	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		2229	/// basis is greater than or equal for even-indexed elements in \a A,
		2230	/// and less than or equal for odd-indexed elements in \a A. \n
		2231	/// 10: Match: Compare each pair of corresponding characters in \a A and
		2232	/// \a B for equality. \n
		2233	/// 11: Substring: Search \a B for substring matches of \a A. \n
		2234	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		2235	/// mask of the comparison results. \n
		2236	/// 00: No effect. \n
		2237	/// 01: Negate the bit mask. \n
		2238	/// 10: No effect. \n
		2239	/// 11: Negate the bit mask only for bits with an index less than or equal
		2240	/// to the size of \a A or \a B.
		2241	/// \returns Returns bit 0 of the resulting bit mask.
454	#define _mm_cmpestro(A, LA, B, LB, M) \	2242	#define _mm_cmpestro(A, LA, B, LB, M) \
455	(int)__builtin_ia32_pcmpestrio128((__v16qi)(__m128i)(A), (int)(LA), \	2243	(int)__builtin_ia32_pcmpestrio128((__v16qi)(__m128i)(A), (int)(LA), \
456	(__v16qi)(__m128i)(B), (int)(LB), \	2244	(__v16qi)(__m128i)(B), (int)(LB), \
457	(int)(M))	2245	(int)(M))
		2246
		2247	/// \brief Uses the immediate operand \a M to perform a comparison of string
		2248	/// data with explicitly defined lengths that is contained in source operands
		2249	/// \a A and \a B. Returns 1 if the length of the string in \a A is less than
		2250	/// the maximum, otherwise, returns 0.
		2251	///
		2252	/// \headerfile <x86intrin.h>
		2253	///
		2254	/// \code
		2255	/// int _mm_cmpestrs(__m128i A, int LA, __m128i B, int LB, const int M);
		2256	/// \endcode
		2257	///
		2258	/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
		2259	/// instruction.
		2260	///
		2261	/// \param A
		2262	/// A 128-bit integer vector containing one of the source operands to be
		2263	/// compared.
		2264	/// \param LA
		2265	/// An integer that specifies the length of the string in \a A.
		2266	/// \param B
		2267	/// A 128-bit integer vector containing one of the source operands to be
		2268	/// compared.
		2269	/// \param LB
		2270	/// An integer that specifies the length of the string in \a B.
		2271	/// \param M
		2272	/// An 8-bit immediate operand specifying whether the characters are bytes or
		2273	/// words and the type of comparison to perform. \n
		2274	/// Bits [1:0]: Determine source data format. \n
		2275	/// 00: 16 unsigned bytes \n
		2276	/// 01: 8 unsigned words \n
		2277	/// 10: 16 signed bytes \n
		2278	/// 11: 8 signed words \n
		2279	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		2280	/// 00: Subset: Each character in \a B is compared for equality with all
		2281	/// the characters in \a A. \n
		2282	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		2283	/// basis is greater than or equal for even-indexed elements in \a A,
		2284	/// and less than or equal for odd-indexed elements in \a A. \n
		2285	/// 10: Match: Compare each pair of corresponding characters in \a A and
		2286	/// \a B for equality. \n
		2287	/// 11: Substring: Search \a B for substring matches of \a A. \n
		2288	/// Bits [5:4]: Determine whether to perform a one's complement in the bit
		2289	/// mask of the comparison results. \n
		2290	/// 00: No effect. \n
		2291	/// 01: Negate the bit mask. \n
		2292	/// 10: No effect. \n
		2293	/// 11: Negate the bit mask only for bits with an index less than or equal
		2294	/// to the size of \a A or \a B. \n
		2295	/// \returns Returns 1 if the length of the string in \a A is less than the
		2296	/// maximum, otherwise, returns 0.
458	#define _mm_cmpestrs(A, LA, B, LB, M) \	2297	#define _mm_cmpestrs(A, LA, B, LB, M) \
459	(int)__builtin_ia32_pcmpestris128((__v16qi)(__m128i)(A), (int)(LA), \	2298	(int)__builtin_ia32_pcmpestris128((__v16qi)(__m128i)(A), (int)(LA), \
460	(__v16qi)(__m128i)(B), (int)(LB), \	2299	(__v16qi)(__m128i)(B), (int)(LB), \
461	(int)(M))	2300	(int)(M))
		2301
		2302	/// \brief Uses the immediate operand \a M to perform a comparison of string
		2303	/// data with explicitly defined lengths that is contained in source operands
		2304	/// \a A and \a B. Returns 1 if the length of the string in \a B is less than
		2305	/// the maximum, otherwise, returns 0.
		2306	///
		2307	/// \headerfile <x86intrin.h>
		2308	///
		2309	/// \code
		2310	/// int _mm_cmpestrz(__m128i A, int LA, __m128i B, int LB, const int M);
		2311	/// \endcode
		2312	///
		2313	/// This intrinsic corresponds to the <c> VPCMPESTRI </c> instruction.
		2314	///
		2315	/// \param A
		2316	/// A 128-bit integer vector containing one of the source operands to be
		2317	/// compared.
		2318	/// \param LA
		2319	/// An integer that specifies the length of the string in \a A.
		2320	/// \param B
		2321	/// A 128-bit integer vector containing one of the source operands to be
		2322	/// compared.
		2323	/// \param LB
		2324	/// An integer that specifies the length of the string in \a B.
		2325	/// \param M
		2326	/// An 8-bit immediate operand specifying whether the characters are bytes or
		2327	/// words and the type of comparison to perform. \n
		2328	/// Bits [1:0]: Determine source data format. \n
		2329	/// 00: 16 unsigned bytes \n
		2330	/// 01: 8 unsigned words \n
		2331	/// 10: 16 signed bytes \n
		2332	/// 11: 8 signed words \n
		2333	/// Bits [3:2]: Determine comparison type and aggregation method. \n
		2334	/// 00: Subset: Each character in \a B is compared for equality with all
		2335	/// the characters in \a A. \n
		2336	/// 01: Ranges: Each character in \a B is compared to \a A. The comparison
		2337	/// basis is greater than or equal for even-indexed elements in \a A,
		2338	/// and less than or equal for odd-indexed elements in \a A. \n
		2339	/// 10: Match: Compare each pair of corresponding characters in \a A and
		2340	/// \a B for equality. \n
		2341	/// 11: Substring: Search \a B for substring matches of \a A. \n
		2342	/// Bits [5:4]: Determine whether to perform a one's complement on the bit
		2343	/// mask of the comparison results. \n
		2344	/// 00: No effect. \n
		2345	/// 01: Negate the bit mask. \n
		2346	/// 10: No effect. \n
		2347	/// 11: Negate the bit mask only for bits with an index less than or equal
		2348	/// to the size of \a A or \a B.
		2349	/// \returns Returns 1 if the length of the string in \a B is less than the
		2350	/// maximum, otherwise, returns 0.
462	#define _mm_cmpestrz(A, LA, B, LB, M) \	2351	#define _mm_cmpestrz(A, LA, B, LB, M) \
463	(int)__builtin_ia32_pcmpestriz128((__v16qi)(__m128i)(A), (int)(LA), \	2352	(int)__builtin_ia32_pcmpestriz128((__v16qi)(__m128i)(A), (int)(LA), \
464	(__v16qi)(__m128i)(B), (int)(LB), \	2353	(__v16qi)(__m128i)(B), (int)(LB), \
465	(int)(M))	2354	(int)(M))
466		2355
467	/* SSE4.2 Compare Packed Data -- Greater Than. */	2356	/* SSE4.2 Compare Packed Data -- Greater Than. */
		2357	/// \brief Compares each of the corresponding 64-bit values of the 128-bit
		2358	/// integer vectors to determine if the values in the first operand are
		2359	/// greater than those in the second operand.
		2360	///
		2361	/// \headerfile <x86intrin.h>
		2362	///
		2363	/// This intrinsic corresponds to the <c> VPCMPGTQ / PCMPGTQ </c> instruction.
		2364	///
		2365	/// \param __V1
		2366	/// A 128-bit integer vector.
		2367	/// \param __V2
		2368	/// A 128-bit integer vector.
		2369	/// \returns A 128-bit integer vector containing the comparison results.
468	static __inline__ __m128i __DEFAULT_FN_ATTRS	2370	static __inline__ __m128i __DEFAULT_FN_ATTRS
469	_mm_cmpgt_epi64(__m128i __V1, __m128i __V2)	2371	_mm_cmpgt_epi64(__m128i __V1, __m128i __V2)
470	{	2372	{
...	@@ -472,18 +2374,60 @@ _mm_cmpgt_epi64(__m128i __V1, __m128i __V2)	...	@@ -472,18 +2374,60 @@ _mm_cmpgt_epi64(__m128i __V1, __m128i __V2)
472	}	2374	}
473		2375
474	/* SSE4.2 Accumulate CRC32. */	2376	/* SSE4.2 Accumulate CRC32. */
		2377	/// \brief Adds the unsigned integer operand to the CRC-32C checksum of the
		2378	/// unsigned char operand.
		2379	///
		2380	/// \headerfile <x86intrin.h>
		2381	///
		2382	/// This intrinsic corresponds to the <c> CRC32B </c> instruction.
		2383	///
		2384	/// \param __C
		2385	/// An unsigned integer operand to add to the CRC-32C checksum of operand
		2386	/// \a __D.
		2387	/// \param __D
		2388	/// An unsigned 8-bit integer operand used to compute the CRC-32C checksum.
		2389	/// \returns The result of adding operand \a __C to the CRC-32C checksum of
		2390	/// operand \a __D.
475	static __inline__ unsigned int __DEFAULT_FN_ATTRS	2391	static __inline__ unsigned int __DEFAULT_FN_ATTRS
476	_mm_crc32_u8(unsigned int __C, unsigned char __D)	2392	_mm_crc32_u8(unsigned int __C, unsigned char __D)
477	{	2393	{
478	return __builtin_ia32_crc32qi(__C, __D);	2394	return __builtin_ia32_crc32qi(__C, __D);
479	}	2395	}
480		2396
		2397	/// \brief Adds the unsigned integer operand to the CRC-32C checksum of the
		2398	/// unsigned short operand.
		2399	///
		2400	/// \headerfile <x86intrin.h>
		2401	///
		2402	/// This intrinsic corresponds to the <c> CRC32W </c> instruction.
		2403	///
		2404	/// \param __C
		2405	/// An unsigned integer operand to add to the CRC-32C checksum of operand
		2406	/// \a __D.
		2407	/// \param __D
		2408	/// An unsigned 16-bit integer operand used to compute the CRC-32C checksum.
		2409	/// \returns The result of adding operand \a __C to the CRC-32C checksum of
		2410	/// operand \a __D.
481	static __inline__ unsigned int __DEFAULT_FN_ATTRS	2411	static __inline__ unsigned int __DEFAULT_FN_ATTRS
482	_mm_crc32_u16(unsigned int __C, unsigned short __D)	2412	_mm_crc32_u16(unsigned int __C, unsigned short __D)
483	{	2413	{
484	return __builtin_ia32_crc32hi(__C, __D);	2414	return __builtin_ia32_crc32hi(__C, __D);
485	}	2415	}
486		2416
		2417	/// \brief Adds the first unsigned integer operand to the CRC-32C checksum of
		2418	/// the second unsigned integer operand.
		2419	///
		2420	/// \headerfile <x86intrin.h>
		2421	///
		2422	/// This intrinsic corresponds to the <c> CRC32L </c> instruction.
		2423	///
		2424	/// \param __C
		2425	/// An unsigned integer operand to add to the CRC-32C checksum of operand
		2426	/// \a __D.
		2427	/// \param __D
		2428	/// An unsigned 32-bit integer operand used to compute the CRC-32C checksum.
		2429	/// \returns The result of adding operand \a __C to the CRC-32C checksum of
		2430	/// operand \a __D.
487	static __inline__ unsigned int __DEFAULT_FN_ATTRS	2431	static __inline__ unsigned int __DEFAULT_FN_ATTRS
488	_mm_crc32_u32(unsigned int __C, unsigned int __D)	2432	_mm_crc32_u32(unsigned int __C, unsigned int __D)
489	{	2433	{
...	@@ -491,6 +2435,20 @@ _mm_crc32_u32(unsigned int __C, unsigned int __D)	...	@@ -491,6 +2435,20 @@ _mm_crc32_u32(unsigned int __C, unsigned int __D)
491	}	2435	}
492		2436
493	#ifdef __x86_64__	2437	#ifdef __x86_64__
		2438	/// \brief Adds the unsigned integer operand to the CRC-32C checksum of the
		2439	/// unsigned 64-bit integer operand.
		2440	///
		2441	/// \headerfile <x86intrin.h>
		2442	///
		2443	/// This intrinsic corresponds to the <c> CRC32Q </c> instruction.
		2444	///
		2445	/// \param __C
		2446	/// An unsigned integer operand to add to the CRC-32C checksum of operand
		2447	/// \a __D.
		2448	/// \param __D
		2449	/// An unsigned 64-bit integer operand used to compute the CRC-32C checksum.
		2450	/// \returns The result of adding operand \a __C to the CRC-32C checksum of
		2451	/// operand \a __D.
494	static __inline__ unsigned long long __DEFAULT_FN_ATTRS	2452	static __inline__ unsigned long long __DEFAULT_FN_ATTRS
495	_mm_crc32_u64(unsigned long long __C, unsigned long long __D)	2453	_mm_crc32_u64(unsigned long long __C, unsigned long long __D)
496	{	2454	{

c_headers/stdarg.h+1-3

 @@ -43,14 +43,12 @@ typedef __builtin_va_list va_list;
 #define va_copy(dest, src)  __builtin_va_copy(dest, src)
 #endif
-/* Hack required to make standard headers work, at least on Ubuntu */
 #ifndef __GNUC_VA_LIST
 #define __GNUC_VA_LIST 1
-#endif
 typedef __builtin_va_list __gnuc_va_list;
 /* zig: added because glibc stdio.h was duplicately defining va_list
  */
 #define _VA_LIST_DEFINED
+#endif
 #endif /* __STDARG_H */

c_headers/stdatomic.h+10-10

...	@@ -40,16 +40,16 @@ extern "C" {	...	@@ -40,16 +40,16 @@ extern "C" {
40		40
41	/* 7.17.1 Introduction */	41	/* 7.17.1 Introduction */
42		42
43	#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE	43	#define ATOMIC_BOOL_LOCK_FREE __CLANG_ATOMIC_BOOL_LOCK_FREE
44	#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE	44	#define ATOMIC_CHAR_LOCK_FREE __CLANG_ATOMIC_CHAR_LOCK_FREE
45	#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE	45	#define ATOMIC_CHAR16_T_LOCK_FREE __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
46	#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE	46	#define ATOMIC_CHAR32_T_LOCK_FREE __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
47	#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE	47	#define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
48	#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE	48	#define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE
49	#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE	49	#define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE
50	#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE	50	#define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE
51	#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE	51	#define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
52	#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE	52	#define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE
53		53
54	/* 7.17.2 Initialization */	54	/* 7.17.2 Initialization */
55		55

c_headers/stdint.h+13-16

 @@ -255,19 +255,16 @@ typedef __uint_least8_t uint_fast8_t;
  */
 #define __stdint_join3(a,b,c) a ## b ## c
-#define  __intn_t(n) __stdint_join3( int, n, _t)
-#define __uintn_t(n) __stdint_join3(uint, n, _t)
 #ifndef _INTPTR_T
 #ifndef __intptr_t_defined
-typedef  __intn_t(__INTPTR_WIDTH__)  intptr_t;
+typedef __INTPTR_TYPE__ intptr_t;
 #define __intptr_t_defined
 #define _INTPTR_T
 #endif
 #endif
 #ifndef _UINTPTR_T
-typedef __uintn_t(__INTPTR_WIDTH__) uintptr_t;
+typedef __UINTPTR_TYPE__ uintptr_t;
 #define _UINTPTR_T
 #endif
 @@ -659,12 +656,12 @@ typedef __UINTMAX_TYPE__ uintmax_t;
 /* C99 7.18.2.4 Limits of integer types capable of holding object pointers. */
 /* C99 7.18.3 Limits of other integer types. */
-#define  INTPTR_MIN  __INTN_MIN(__INTPTR_WIDTH__)
+#define  INTPTR_MIN  (-__INTPTR_MAX__-1)
-#define  INTPTR_MAX  __INTN_MAX(__INTPTR_WIDTH__)
+#define  INTPTR_MAX    __INTPTR_MAX__
-#define UINTPTR_MAX __UINTN_MAX(__INTPTR_WIDTH__)
+#define UINTPTR_MAX   __UINTPTR_MAX__
-#define PTRDIFF_MIN  __INTN_MIN(__PTRDIFF_WIDTH__)
+#define PTRDIFF_MIN (-__PTRDIFF_MAX__-1)
-#define PTRDIFF_MAX  __INTN_MAX(__PTRDIFF_WIDTH__)
+#define PTRDIFF_MAX   __PTRDIFF_MAX__
-#define    SIZE_MAX __UINTN_MAX(__SIZE_WIDTH__)
+#define    SIZE_MAX      __SIZE_MAX__
 /* ISO9899:2011 7.20 (C11 Annex K): Define RSIZE_MAX if __STDC_WANT_LIB_EXT1__
  * is enabled. */
 @@ -673,9 +670,9 @@ typedef __UINTMAX_TYPE__ uintmax_t;
 #endif
 /* C99 7.18.2.5 Limits of greatest-width integer types. */
-#define INTMAX_MIN   __INTN_MIN(__INTMAX_WIDTH__)
+#define  INTMAX_MIN (-__INTMAX_MAX__-1)
-#define INTMAX_MAX   __INTN_MAX(__INTMAX_WIDTH__)
+#define  INTMAX_MAX   __INTMAX_MAX__
-#define UINTMAX_MAX __UINTN_MAX(__INTMAX_WIDTH__)
+#define UINTMAX_MAX  __UINTMAX_MAX__
 /* C99 7.18.3 Limits of other integer types. */
 #define SIG_ATOMIC_MIN __INTN_MIN(__SIG_ATOMIC_WIDTH__)
 @@ -700,8 +697,8 @@ typedef __UINTMAX_TYPE__ uintmax_t;
 #endif
 /* 7.18.4.2 Macros for greatest-width integer constants. */
-#define INTMAX_C(v)   __INTN_C(__INTMAX_WIDTH__, v)
+#define  INTMAX_C(v) __int_c(v,  __INTMAX_C_SUFFIX__)
-#define UINTMAX_C(v) __UINTN_C(__INTMAX_WIDTH__, v)
+#define UINTMAX_C(v) __int_c(v, __UINTMAX_C_SUFFIX__)
 #endif /* __STDC_HOSTED__ */
 #endif /* __CLANG_STDINT_H */

c_headers/tgmath.h+13-3

 @@ -22,12 +22,21 @@
  *
 \*===----------------------------------------------------------------------===*/
-#ifndef __TGMATH_H
+#ifndef __CLANG_TGMATH_H
-#define __TGMATH_H
+#define __CLANG_TGMATH_H
 /* C99 7.22 Type-generic math <tgmath.h>. */
 #include <math.h>
+/*
+ * Allow additional definitions and implementation-defined values on Apple
+ * platforms. This is done after #include <math.h> to avoid depcycle conflicts
+ * between libcxx and darwin in C++ modules builds.
+ */
+#if defined(__APPLE__) && __STDC_HOSTED__ && __has_include_next(<tgmath.h>)
+#  include_next <tgmath.h>
+#else
 /* C++ handles type genericity with overloading in math.h. */
 #ifndef __cplusplus
 #include <complex.h>
 @@ -1371,4 +1380,5 @@ static long double
 #undef _TG_ATTRS
 #endif /* __cplusplus */
-#endif /* __TGMATH_H */
+#endif /* __has_include_next */
+#endif /* __CLANG_TGMATH_H */

c_headers/tmmintrin.h+48-40

...	@@ -469,10 +469,11 @@ _mm_hsubs_pi16(__m64 __a, __m64 __b)	...	@@ -469,10 +469,11 @@ _mm_hsubs_pi16(__m64 __a, __m64 __b)
469	/// values contained in the first source operand and packed 8-bit signed	469	/// values contained in the first source operand and packed 8-bit signed
470	/// integer values contained in the second source operand, adds pairs of	470	/// integer values contained in the second source operand, adds pairs of
471	/// contiguous products with signed saturation, and writes the 16-bit sums to	471	/// contiguous products with signed saturation, and writes the 16-bit sums to
472	/// the corresponding bits in the destination. For example, bits [7:0] of	472	/// the corresponding bits in the destination.
473	/// both operands are multiplied, bits [15:8] of both operands are	473	///
474	/// multiplied, and the sum of both results is written to bits [15:0] of the	474	/// For example, bits [7:0] of both operands are multiplied, bits [15:8] of
475	/// destination.	475	/// both operands are multiplied, and the sum of both results is written to
		476	/// bits [15:0] of the destination.
476	///	477	///
477	/// \headerfile <x86intrin.h>	478	/// \headerfile <x86intrin.h>
478	///	479	///
...	@@ -502,10 +503,11 @@ _mm_maddubs_epi16(__m128i __a, __m128i __b)	...	@@ -502,10 +503,11 @@ _mm_maddubs_epi16(__m128i __a, __m128i __b)
502	/// values contained in the first source operand and packed 8-bit signed	503	/// values contained in the first source operand and packed 8-bit signed
503	/// integer values contained in the second source operand, adds pairs of	504	/// integer values contained in the second source operand, adds pairs of
504	/// contiguous products with signed saturation, and writes the 16-bit sums to	505	/// contiguous products with signed saturation, and writes the 16-bit sums to
505	/// the corresponding bits in the destination. For example, bits [7:0] of	506	/// the corresponding bits in the destination.
506	/// both operands are multiplied, bits [15:8] of both operands are	507	///
507	/// multiplied, and the sum of both results is written to bits [15:0] of the	508	/// For example, bits [7:0] of both operands are multiplied, bits [15:8] of
508	/// destination.	509	/// both operands are multiplied, and the sum of both results is written to
		510	/// bits [15:0] of the destination.
509	///	511	///
510	/// \headerfile <x86intrin.h>	512	/// \headerfile <x86intrin.h>
511	///	513	///
...	@@ -619,13 +621,14 @@ _mm_shuffle_pi8(__m64 __a, __m64 __b)	...	@@ -619,13 +621,14 @@ _mm_shuffle_pi8(__m64 __a, __m64 __b)
619	}	621	}
620		622
621	/// \brief For each 8-bit integer in the first source operand, perform one of	623	/// \brief For each 8-bit integer in the first source operand, perform one of
622	/// the following actions as specified by the second source operand: If the	624	/// the following actions as specified by the second source operand.
623	/// byte in the second source is negative, calculate the two's complement of	625	///
624	/// the corresponding byte in the first source, and write that value to the	626	/// If the byte in the second source is negative, calculate the two's
625	/// destination. If the byte in the second source is positive, copy the	627	/// complement of the corresponding byte in the first source, and write that
626	/// corresponding byte from the first source to the destination. If the byte	628	/// value to the destination. If the byte in the second source is positive,
627	/// in the second source is zero, clear the corresponding byte in the	629	/// copy the corresponding byte from the first source to the destination. If
628	/// destination.	630	/// the byte in the second source is zero, clear the corresponding byte in
		631	/// the destination.
629	///	632	///
630	/// \headerfile <x86intrin.h>	633	/// \headerfile <x86intrin.h>
631	///	634	///
...	@@ -644,13 +647,14 @@ _mm_sign_epi8(__m128i __a, __m128i __b)	...	@@ -644,13 +647,14 @@ _mm_sign_epi8(__m128i __a, __m128i __b)
644	}	647	}
645		648
646	/// \brief For each 16-bit integer in the first source operand, perform one of	649	/// \brief For each 16-bit integer in the first source operand, perform one of
647	/// the following actions as specified by the second source operand: If the	650	/// the following actions as specified by the second source operand.
648	/// word in the second source is negative, calculate the two's complement of	651	///
649	/// the corresponding word in the first source, and write that value to the	652	/// If the word in the second source is negative, calculate the two's
650	/// destination. If the word in the second source is positive, copy the	653	/// complement of the corresponding word in the first source, and write that
651	/// corresponding word from the first source to the destination. If the word	654	/// value to the destination. If the word in the second source is positive,
652	/// in the second source is zero, clear the corresponding word in the	655	/// copy the corresponding word from the first source to the destination. If
653	/// destination.	656	/// the word in the second source is zero, clear the corresponding word in
		657	/// the destination.
654	///	658	///
655	/// \headerfile <x86intrin.h>	659	/// \headerfile <x86intrin.h>
656	///	660	///
...	@@ -669,8 +673,9 @@ _mm_sign_epi16(__m128i __a, __m128i __b)	...	@@ -669,8 +673,9 @@ _mm_sign_epi16(__m128i __a, __m128i __b)
669	}	673	}
670		674
671	/// \brief For each 32-bit integer in the first source operand, perform one of	675	/// \brief For each 32-bit integer in the first source operand, perform one of
672	/// the following actions as specified by the second source operand: If the	676	/// the following actions as specified by the second source operand.
673	/// doubleword in the second source is negative, calculate the two's	677	///
		678	/// If the doubleword in the second source is negative, calculate the two's
674	/// complement of the corresponding word in the first source, and write that	679	/// complement of the corresponding word in the first source, and write that
675	/// value to the destination. If the doubleword in the second source is	680	/// value to the destination. If the doubleword in the second source is
676	/// positive, copy the corresponding word from the first source to the	681	/// positive, copy the corresponding word from the first source to the
...	@@ -694,13 +699,14 @@ _mm_sign_epi32(__m128i __a, __m128i __b)	...	@@ -694,13 +699,14 @@ _mm_sign_epi32(__m128i __a, __m128i __b)
694	}	699	}
695		700
696	/// \brief For each 8-bit integer in the first source operand, perform one of	701	/// \brief For each 8-bit integer in the first source operand, perform one of
697	/// the following actions as specified by the second source operand: If the	702	/// the following actions as specified by the second source operand.
698	/// byte in the second source is negative, calculate the two's complement of	703	///
699	/// the corresponding byte in the first source, and write that value to the	704	/// If the byte in the second source is negative, calculate the two's
700	/// destination. If the byte in the second source is positive, copy the	705	/// complement of the corresponding byte in the first source, and write that
701	/// corresponding byte from the first source to the destination. If the byte	706	/// value to the destination. If the byte in the second source is positive,
702	/// in the second source is zero, clear the corresponding byte in the	707	/// copy the corresponding byte from the first source to the destination. If
703	/// destination.	708	/// the byte in the second source is zero, clear the corresponding byte in
		709	/// the destination.
704	///	710	///
705	/// \headerfile <x86intrin.h>	711	/// \headerfile <x86intrin.h>
706	///	712	///
...	@@ -719,13 +725,14 @@ _mm_sign_pi8(__m64 __a, __m64 __b)	...	@@ -719,13 +725,14 @@ _mm_sign_pi8(__m64 __a, __m64 __b)
719	}	725	}
720		726
721	/// \brief For each 16-bit integer in the first source operand, perform one of	727	/// \brief For each 16-bit integer in the first source operand, perform one of
722	/// the following actions as specified by the second source operand: If the	728	/// the following actions as specified by the second source operand.
723	/// word in the second source is negative, calculate the two's complement of	729	///
724	/// the corresponding word in the first source, and write that value to the	730	/// If the word in the second source is negative, calculate the two's
725	/// destination. If the word in the second source is positive, copy the	731	/// complement of the corresponding word in the first source, and write that
726	/// corresponding word from the first source to the destination. If the word	732	/// value to the destination. If the word in the second source is positive,
727	/// in the second source is zero, clear the corresponding word in the	733	/// copy the corresponding word from the first source to the destination. If
728	/// destination.	734	/// the word in the second source is zero, clear the corresponding word in
		735	/// the destination.
729	///	736	///
730	/// \headerfile <x86intrin.h>	737	/// \headerfile <x86intrin.h>
731	///	738	///
...	@@ -744,8 +751,9 @@ _mm_sign_pi16(__m64 __a, __m64 __b)	...	@@ -744,8 +751,9 @@ _mm_sign_pi16(__m64 __a, __m64 __b)
744	}	751	}
745		752
746	/// \brief For each 32-bit integer in the first source operand, perform one of	753	/// \brief For each 32-bit integer in the first source operand, perform one of
747	/// the following actions as specified by the second source operand: If the	754	/// the following actions as specified by the second source operand.
748	/// doubleword in the second source is negative, calculate the two's	755	///
		756	/// If the doubleword in the second source is negative, calculate the two's
749	/// complement of the corresponding doubleword in the first source, and	757	/// complement of the corresponding doubleword in the first source, and
750	/// write that value to the destination. If the doubleword in the second	758	/// write that value to the destination. If the doubleword in the second
751	/// source is positive, copy the corresponding doubleword from the first	759	/// source is positive, copy the corresponding doubleword from the first

c_headers/vecintrin.h+1548-24

 @@ -116,6 +116,13 @@ vec_extract(vector unsigned long long __vec, int __index) {
   return __vec[__index & 1];
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai float
+vec_extract(vector float __vec, int __index) {
+  return __vec[__index & 3];
+}
+#endif
 static inline __ATTRS_o_ai double
 vec_extract(vector double __vec, int __index) {
   return __vec[__index & 1];
 @@ -129,6 +136,7 @@ vec_insert(signed char __scalar, vector signed char __vec, int __index) {
   return __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_insert(unsigned char __scalar, vector bool char __vec, int __index) {
   vector unsigned char __newvec = (vector unsigned char)__vec;
 @@ -148,6 +156,7 @@ vec_insert(signed short __scalar, vector signed short __vec, int __index) {
   return __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_insert(unsigned short __scalar, vector bool short __vec, int __index) {
   vector unsigned short __newvec = (vector unsigned short)__vec;
 @@ -167,6 +176,7 @@ vec_insert(signed int __scalar, vector signed int __vec, int __index) {
   return __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_insert(unsigned int __scalar, vector bool int __vec, int __index) {
   vector unsigned int __newvec = (vector unsigned int)__vec;
 @@ -187,6 +197,7 @@ vec_insert(signed long long __scalar, vector signed long long __vec,
   return __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_insert(unsigned long long __scalar, vector bool long long __vec,
            int __index) {
 @@ -202,6 +213,14 @@ vec_insert(unsigned long long __scalar, vector unsigned long long __vec,
   return __vec;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_insert(float __scalar, vector float __vec, int __index) {
+  __vec[__index & 1] = __scalar;
+  return __vec;
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_insert(double __scalar, vector double __vec, int __index) {
   __vec[__index & 1] = __scalar;
 @@ -282,6 +301,16 @@ vec_promote(unsigned long long __scalar, int __index) {
   return __vec;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_promote(float __scalar, int __index) {
+  const vector float __zero = (vector float)0;
+  vector float __vec = __builtin_shufflevector(__zero, __zero, -1, -1, -1, -1);
+  __vec[__index & 3] = __scalar;
+  return __vec;
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_promote(double __scalar, int __index) {
   const vector double __zero = (vector double)0;
 @@ -348,6 +377,15 @@ vec_insert_and_zero(const unsigned long long *__ptr) {
   return __vec;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_insert_and_zero(const float *__ptr) {
+  vector float __vec = (vector float)0;
+  __vec[0] = *__ptr;
+  return __vec;
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_insert_and_zero(const double *__ptr) {
   vector double __vec = (vector double)0;
 @@ -441,6 +479,15 @@ vec_perm(vector bool long long __a, vector bool long long __b,
            (vector unsigned char)__a, (vector unsigned char)__b, __c);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_perm(vector float __a, vector float __b,
+         vector unsigned char __c) {
+  return (vector float)__builtin_s390_vperm(
+           (vector unsigned char)__a, (vector unsigned char)__b, __c);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_perm(vector double __a, vector double __b,
          vector unsigned char __c) {
 @@ -450,18 +497,22 @@ vec_perm(vector double __a, vector double __b,
 /*-- vec_permi --------------------------------------------------------------*/
+// This prototype is deprecated.
 extern __ATTRS_o vector signed long long
 vec_permi(vector signed long long __a, vector signed long long __b, int __c)
   __constant_range(__c, 0, 3);
+// This prototype is deprecated.
 extern __ATTRS_o vector unsigned long long
 vec_permi(vector unsigned long long __a, vector unsigned long long __b, int __c)
   __constant_range(__c, 0, 3);
+// This prototype is deprecated.
 extern __ATTRS_o vector bool long long
 vec_permi(vector bool long long __a, vector bool long long __b, int __c)
   __constant_range(__c, 0, 3);
+// This prototype is deprecated.
 extern __ATTRS_o vector double
 vec_permi(vector double __a, vector double __b, int __c)
   __constant_range(__c, 0, 3);
 @@ -471,6 +522,15 @@ vec_permi(vector double __a, vector double __b, int __c)
                       (vector unsigned long long)(Y), \
                       (((Z) & 2) << 1) | ((Z) & 1)))
+/*-- vec_bperm_u128 ---------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_ai vector unsigned long long
+vec_bperm_u128(vector unsigned char __a, vector unsigned char __b) {
+  return __builtin_s390_vbperm(__a, __b);
+}
+#endif
 /*-- vec_sel ----------------------------------------------------------------*/
 static inline __ATTRS_o_ai vector signed char
 @@ -614,6 +674,22 @@ vec_sel(vector unsigned long long __a, vector unsigned long long __b,
           (~(vector unsigned long long)__c & __a));
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_sel(vector float __a, vector float __b, vector unsigned int __c) {
+  return (vector float)((__c & (vector unsigned int)__b) |
+                        (~__c & (vector unsigned int)__a));
+}
+static inline __ATTRS_o_ai vector float
+vec_sel(vector float __a, vector float __b, vector bool int __c) {
+  vector unsigned int __ac = (vector unsigned int)__a;
+  vector unsigned int __bc = (vector unsigned int)__b;
+  vector unsigned int __cc = (vector unsigned int)__c;
+  return (vector float)((__cc & __bc) | (~__cc & __ac));
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_sel(vector double __a, vector double __b, vector unsigned long long __c) {
   return (vector double)((__c & (vector unsigned long long)__b) |
 @@ -687,6 +763,17 @@ vec_gather_element(vector unsigned long long __vec,
   return __vec;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_gather_element(vector float __vec, vector unsigned int __offset,
+                   const float *__ptr, int __index)
+  __constant_range(__index, 0, 3) {
+  __vec[__index] = *(const float *)(
+    (__INTPTR_TYPE__)__ptr + (__INTPTR_TYPE__)__offset[__index]);
+  return __vec;
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_gather_element(vector double __vec, vector unsigned long long __offset,
                    const double *__ptr, int __index)
 @@ -749,6 +836,16 @@ vec_scatter_element(vector unsigned long long __vec,
     __vec[__index];
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai void
+vec_scatter_element(vector float __vec, vector unsigned int __offset,
+                    float *__ptr, int __index)
+  __constant_range(__index, 0, 3) {
+  *(float *)((__INTPTR_TYPE__)__ptr + __offset[__index]) =
+    __vec[__index];
+}
+#endif
 static inline __ATTRS_o_ai void
 vec_scatter_element(vector double __vec, vector unsigned long long __offset,
                     double *__ptr, int __index)
 @@ -757,48 +854,111 @@ vec_scatter_element(vector double __vec, vector unsigned long long __offset,
     __vec[__index];
 }
+/*-- vec_xl -----------------------------------------------------------------*/
+static inline __ATTRS_o_ai vector signed char
+vec_xl(long __offset, const signed char *__ptr) {
+  return *(const vector signed char *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+static inline __ATTRS_o_ai vector unsigned char
+vec_xl(long __offset, const unsigned char *__ptr) {
+  return *(const vector unsigned char *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+static inline __ATTRS_o_ai vector signed short
+vec_xl(long __offset, const signed short *__ptr) {
+  return *(const vector signed short *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+static inline __ATTRS_o_ai vector unsigned short
+vec_xl(long __offset, const unsigned short *__ptr) {
+  return *(const vector unsigned short *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+static inline __ATTRS_o_ai vector signed int
+vec_xl(long __offset, const signed int *__ptr) {
+  return *(const vector signed int *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+static inline __ATTRS_o_ai vector unsigned int
+vec_xl(long __offset, const unsigned int *__ptr) {
+  return *(const vector unsigned int *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+static inline __ATTRS_o_ai vector signed long long
+vec_xl(long __offset, const signed long long *__ptr) {
+  return *(const vector signed long long *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+static inline __ATTRS_o_ai vector unsigned long long
+vec_xl(long __offset, const unsigned long long *__ptr) {
+  return *(const vector unsigned long long *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_xl(long __offset, const float *__ptr) {
+  return *(const vector float *)((__INTPTR_TYPE__)__ptr + __offset);
+}
+#endif
+static inline __ATTRS_o_ai vector double
+vec_xl(long __offset, const double *__ptr) {
+  return *(const vector double *)((__INTPTR_TYPE__)__ptr + __offset);
+}
 /*-- vec_xld2 ---------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_xld2(long __offset, const signed char *__ptr) {
   return *(const vector signed char *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_xld2(long __offset, const unsigned char *__ptr) {
   return *(const vector unsigned char *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_xld2(long __offset, const signed short *__ptr) {
   return *(const vector signed short *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_xld2(long __offset, const unsigned short *__ptr) {
   return *(const vector unsigned short *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_xld2(long __offset, const signed int *__ptr) {
   return *(const vector signed int *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_xld2(long __offset, const unsigned int *__ptr) {
   return *(const vector unsigned int *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_xld2(long __offset, const signed long long *__ptr) {
   return *(const vector signed long long *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_xld2(long __offset, const unsigned long long *__ptr) {
   return *(const vector unsigned long long *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector double
 vec_xld2(long __offset, const double *__ptr) {
   return *(const vector double *)((__INTPTR_TYPE__)__ptr + __offset);
 @@ -806,74 +966,145 @@ vec_xld2(long __offset, const double *__ptr) {
 /*-- vec_xlw4 ---------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_xlw4(long __offset, const signed char *__ptr) {
   return *(const vector signed char *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_xlw4(long __offset, const unsigned char *__ptr) {
   return *(const vector unsigned char *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_xlw4(long __offset, const signed short *__ptr) {
   return *(const vector signed short *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_xlw4(long __offset, const unsigned short *__ptr) {
   return *(const vector unsigned short *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_xlw4(long __offset, const signed int *__ptr) {
   return *(const vector signed int *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_xlw4(long __offset, const unsigned int *__ptr) {
   return *(const vector unsigned int *)((__INTPTR_TYPE__)__ptr + __offset);
 }
+/*-- vec_xst ----------------------------------------------------------------*/
+static inline __ATTRS_o_ai void
+vec_xst(vector signed char __vec, long __offset, signed char *__ptr) {
+  *(vector signed char *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+static inline __ATTRS_o_ai void
+vec_xst(vector unsigned char __vec, long __offset, unsigned char *__ptr) {
+  *(vector unsigned char *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+static inline __ATTRS_o_ai void
+vec_xst(vector signed short __vec, long __offset, signed short *__ptr) {
+  *(vector signed short *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+static inline __ATTRS_o_ai void
+vec_xst(vector unsigned short __vec, long __offset, unsigned short *__ptr) {
+  *(vector unsigned short *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+static inline __ATTRS_o_ai void
+vec_xst(vector signed int __vec, long __offset, signed int *__ptr) {
+  *(vector signed int *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+static inline __ATTRS_o_ai void
+vec_xst(vector unsigned int __vec, long __offset, unsigned int *__ptr) {
+  *(vector unsigned int *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+static inline __ATTRS_o_ai void
+vec_xst(vector signed long long __vec, long __offset,
+          signed long long *__ptr) {
+  *(vector signed long long *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+static inline __ATTRS_o_ai void
+vec_xst(vector unsigned long long __vec, long __offset,
+          unsigned long long *__ptr) {
+  *(vector unsigned long long *)((__INTPTR_TYPE__)__ptr + __offset) =
+    __vec;
+}
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai void
+vec_xst(vector float __vec, long __offset, float *__ptr) {
+  *(vector float *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
+#endif
+static inline __ATTRS_o_ai void
+vec_xst(vector double __vec, long __offset, double *__ptr) {
+  *(vector double *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
+}
 /*-- vec_xstd2 --------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector signed char __vec, long __offset, signed char *__ptr) {
   *(vector signed char *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector unsigned char __vec, long __offset, unsigned char *__ptr) {
   *(vector unsigned char *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector signed short __vec, long __offset, signed short *__ptr) {
   *(vector signed short *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector unsigned short __vec, long __offset, unsigned short *__ptr) {
   *(vector unsigned short *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector signed int __vec, long __offset, signed int *__ptr) {
   *(vector signed int *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector unsigned int __vec, long __offset, unsigned int *__ptr) {
   *(vector unsigned int *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector signed long long __vec, long __offset,
           signed long long *__ptr) {
   *(vector signed long long *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector unsigned long long __vec, long __offset,
           unsigned long long *__ptr) {
 @@ -881,6 +1112,7 @@ vec_xstd2(vector unsigned long long __vec, long __offset,
     __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstd2(vector double __vec, long __offset, double *__ptr) {
   *(vector double *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 @@ -888,31 +1120,37 @@ vec_xstd2(vector double __vec, long __offset, double *__ptr) {
 /*-- vec_xstw4 --------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstw4(vector signed char __vec, long __offset, signed char *__ptr) {
   *(vector signed char *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstw4(vector unsigned char __vec, long __offset, unsigned char *__ptr) {
   *(vector unsigned char *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstw4(vector signed short __vec, long __offset, signed short *__ptr) {
   *(vector signed short *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstw4(vector unsigned short __vec, long __offset, unsigned short *__ptr) {
   *(vector unsigned short *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstw4(vector signed int __vec, long __offset, signed int *__ptr) {
   *(vector signed int *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai void
 vec_xstw4(vector unsigned int __vec, long __offset, unsigned int *__ptr) {
   *(vector unsigned int *)((__INTPTR_TYPE__)__ptr + __offset) = __vec;
 @@ -952,6 +1190,12 @@ extern __ATTRS_o vector unsigned long long
 vec_load_bndry(const unsigned long long *__ptr, unsigned short __len)
   __constant_pow2_range(__len, 64, 4096);
+#if __ARCH__ >= 12
+extern __ATTRS_o vector float
+vec_load_bndry(const float *__ptr, unsigned short __len)
+  __constant_pow2_range(__len, 64, 4096);
+#endif
 extern __ATTRS_o vector double
 vec_load_bndry(const double *__ptr, unsigned short __len)
   __constant_pow2_range(__len, 64, 4096);
 @@ -1007,11 +1251,27 @@ vec_load_len(const unsigned long long *__ptr, unsigned int __len) {
   return (vector unsigned long long)__builtin_s390_vll(__len, __ptr);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_load_len(const float *__ptr, unsigned int __len) {
+  return (vector float)__builtin_s390_vll(__len, __ptr);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_load_len(const double *__ptr, unsigned int __len) {
   return (vector double)__builtin_s390_vll(__len, __ptr);
 }
+/*-- vec_load_len_r ---------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_ai vector unsigned char
+vec_load_len_r(const unsigned char *__ptr, unsigned int __len) {
+  return (vector unsigned char)__builtin_s390_vlrl(__len, __ptr);
+}
+#endif
 /*-- vec_store_len ----------------------------------------------------------*/
 static inline __ATTRS_o_ai void
 @@ -1062,12 +1322,30 @@ vec_store_len(vector unsigned long long __vec, unsigned long long *__ptr,
   __builtin_s390_vstl((vector signed char)__vec, __len, __ptr);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai void
+vec_store_len(vector float __vec, float *__ptr,
+              unsigned int __len) {
+  __builtin_s390_vstl((vector signed char)__vec, __len, __ptr);
+}
+#endif
 static inline __ATTRS_o_ai void
 vec_store_len(vector double __vec, double *__ptr,
               unsigned int __len) {
   __builtin_s390_vstl((vector signed char)__vec, __len, __ptr);
 }
+/*-- vec_store_len_r --------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_ai void
+vec_store_len_r(vector unsigned char __vec, unsigned char *__ptr,
+                unsigned int __len) {
+  __builtin_s390_vstrl((vector signed char)__vec, __len, __ptr);
+}
+#endif
 /*-- vec_load_pair ----------------------------------------------------------*/
 static inline __ATTRS_o_ai vector signed long long
 @@ -1232,6 +1510,14 @@ vec_splat(vector unsigned long long __vec, int __index)
   return (vector unsigned long long)__vec[__index];
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_splat(vector float __vec, int __index)
+  __constant_range(__index, 0, 3) {
+  return (vector float)__vec[__index];
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_splat(vector double __vec, int __index)
   __constant_range(__index, 0, 1) {
 @@ -1332,6 +1618,13 @@ vec_splats(unsigned long long __scalar) {
   return (vector unsigned long long)__scalar;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_splats(float __scalar) {
+  return (vector float)__scalar;
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_splats(double __scalar) {
   return (vector double)__scalar;
 @@ -1425,6 +1718,13 @@ vec_mergeh(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector unsigned long long)(__a[0], __b[0]);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_mergeh(vector float __a, vector float __b) {
+  return (vector float)(__a[0], __b[0], __a[1], __b[1]);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_mergeh(vector double __a, vector double __b) {
   return (vector double)(__a[0], __b[0]);
 @@ -1501,6 +1801,13 @@ vec_mergel(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector unsigned long long)(__a[1], __b[1]);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_mergel(vector float __a, vector float __b) {
+  return (vector float)(__a[2], __b[2], __a[3], __b[3]);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_mergel(vector double __a, vector double __b) {
   return (vector double)(__a[1], __b[1]);
 @@ -1866,6 +2173,13 @@ vec_cmpeq(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector bool long long)(__a == __b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool int
+vec_cmpeq(vector float __a, vector float __b) {
+  return (vector bool int)(__a == __b);
+}
+#endif
 static inline __ATTRS_o_ai vector bool long long
 vec_cmpeq(vector double __a, vector double __b) {
   return (vector bool long long)(__a == __b);
 @@ -1913,6 +2227,13 @@ vec_cmpge(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector bool long long)(__a >= __b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool int
+vec_cmpge(vector float __a, vector float __b) {
+  return (vector bool int)(__a >= __b);
+}
+#endif
 static inline __ATTRS_o_ai vector bool long long
 vec_cmpge(vector double __a, vector double __b) {
   return (vector bool long long)(__a >= __b);
 @@ -1960,6 +2281,13 @@ vec_cmpgt(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector bool long long)(__a > __b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool int
+vec_cmpgt(vector float __a, vector float __b) {
+  return (vector bool int)(__a > __b);
+}
+#endif
 static inline __ATTRS_o_ai vector bool long long
 vec_cmpgt(vector double __a, vector double __b) {
   return (vector bool long long)(__a > __b);
 @@ -2007,6 +2335,13 @@ vec_cmple(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector bool long long)(__a <= __b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool int
+vec_cmple(vector float __a, vector float __b) {
+  return (vector bool int)(__a <= __b);
+}
+#endif
 static inline __ATTRS_o_ai vector bool long long
 vec_cmple(vector double __a, vector double __b) {
   return (vector bool long long)(__a <= __b);
 @@ -2054,6 +2389,13 @@ vec_cmplt(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector bool long long)(__a < __b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool int
+vec_cmplt(vector float __a, vector float __b) {
+  return (vector bool int)(__a < __b);
+}
+#endif
 static inline __ATTRS_o_ai vector bool long long
 vec_cmplt(vector double __a, vector double __b) {
   return (vector bool long long)(__a < __b);
 @@ -2068,6 +2410,7 @@ vec_all_eq(vector signed char __a, vector signed char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -2075,6 +2418,7 @@ vec_all_eq(vector signed char __a, vector bool char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -2090,6 +2434,7 @@ vec_all_eq(vector unsigned char __a, vector unsigned char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -2098,6 +2443,7 @@ vec_all_eq(vector unsigned char __a, vector bool char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -2121,6 +2467,7 @@ vec_all_eq(vector signed short __a, vector signed short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -2128,6 +2475,7 @@ vec_all_eq(vector signed short __a, vector bool short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -2143,6 +2491,7 @@ vec_all_eq(vector unsigned short __a, vector unsigned short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -2151,6 +2500,7 @@ vec_all_eq(vector unsigned short __a, vector bool short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -2174,6 +2524,7 @@ vec_all_eq(vector signed int __a, vector signed int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -2181,6 +2532,7 @@ vec_all_eq(vector signed int __a, vector bool int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -2196,6 +2548,7 @@ vec_all_eq(vector unsigned int __a, vector unsigned int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -2204,6 +2557,7 @@ vec_all_eq(vector unsigned int __a, vector bool int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -2227,6 +2581,7 @@ vec_all_eq(vector signed long long __a, vector signed long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -2234,6 +2589,7 @@ vec_all_eq(vector signed long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -2249,6 +2605,7 @@ vec_all_eq(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -2257,6 +2614,7 @@ vec_all_eq(vector unsigned long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_eq(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -2273,6 +2631,15 @@ vec_all_eq(vector bool long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_eq(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfcesbs(__a, __b, &__cc);
+  return __cc == 0;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_all_eq(vector double __a, vector double __b) {
   int __cc;
 @@ -2289,6 +2656,7 @@ vec_all_ne(vector signed char __a, vector signed char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -2296,6 +2664,7 @@ vec_all_ne(vector signed char __a, vector bool char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -2311,6 +2680,7 @@ vec_all_ne(vector unsigned char __a, vector unsigned char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -2319,6 +2689,7 @@ vec_all_ne(vector unsigned char __a, vector bool char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -2342,6 +2713,7 @@ vec_all_ne(vector signed short __a, vector signed short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -2349,6 +2721,7 @@ vec_all_ne(vector signed short __a, vector bool short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -2364,6 +2737,7 @@ vec_all_ne(vector unsigned short __a, vector unsigned short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -2372,6 +2746,7 @@ vec_all_ne(vector unsigned short __a, vector bool short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -2395,6 +2770,7 @@ vec_all_ne(vector signed int __a, vector signed int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -2402,6 +2778,7 @@ vec_all_ne(vector signed int __a, vector bool int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -2417,6 +2794,7 @@ vec_all_ne(vector unsigned int __a, vector unsigned int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -2425,6 +2803,7 @@ vec_all_ne(vector unsigned int __a, vector bool int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -2448,6 +2827,7 @@ vec_all_ne(vector signed long long __a, vector signed long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -2455,6 +2835,7 @@ vec_all_ne(vector signed long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -2470,6 +2851,7 @@ vec_all_ne(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -2478,6 +2860,7 @@ vec_all_ne(vector unsigned long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ne(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -2494,6 +2877,15 @@ vec_all_ne(vector bool long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_ne(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfcesbs(__a, __b, &__cc);
+  return __cc == 3;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_all_ne(vector double __a, vector double __b) {
   int __cc;
 @@ -2510,6 +2902,7 @@ vec_all_ge(vector signed char __a, vector signed char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -2517,6 +2910,7 @@ vec_all_ge(vector signed char __a, vector bool char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -2531,6 +2925,7 @@ vec_all_ge(vector unsigned char __a, vector unsigned char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -2538,6 +2933,7 @@ vec_all_ge(vector unsigned char __a, vector bool char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -2545,6 +2941,7 @@ vec_all_ge(vector bool char __a, vector unsigned char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -2560,6 +2957,7 @@ vec_all_ge(vector signed short __a, vector signed short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -2567,6 +2965,7 @@ vec_all_ge(vector signed short __a, vector bool short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -2581,6 +2980,7 @@ vec_all_ge(vector unsigned short __a, vector unsigned short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -2588,6 +2988,7 @@ vec_all_ge(vector unsigned short __a, vector bool short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -2595,6 +2996,7 @@ vec_all_ge(vector bool short __a, vector unsigned short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -2610,6 +3012,7 @@ vec_all_ge(vector signed int __a, vector signed int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -2617,6 +3020,7 @@ vec_all_ge(vector signed int __a, vector bool int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -2631,6 +3035,7 @@ vec_all_ge(vector unsigned int __a, vector unsigned int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -2638,6 +3043,7 @@ vec_all_ge(vector unsigned int __a, vector bool int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -2645,6 +3051,7 @@ vec_all_ge(vector bool int __a, vector unsigned int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -2660,6 +3067,7 @@ vec_all_ge(vector signed long long __a, vector signed long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -2667,6 +3075,7 @@ vec_all_ge(vector signed long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -2681,6 +3090,7 @@ vec_all_ge(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -2688,6 +3098,7 @@ vec_all_ge(vector unsigned long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -2695,6 +3106,7 @@ vec_all_ge(vector bool long long __a, vector unsigned long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_ge(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -2703,6 +3115,15 @@ vec_all_ge(vector bool long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_ge(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__a, __b, &__cc);
+  return __cc == 0;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_all_ge(vector double __a, vector double __b) {
   int __cc;
 @@ -2719,6 +3140,7 @@ vec_all_gt(vector signed char __a, vector signed char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -2726,6 +3148,7 @@ vec_all_gt(vector signed char __a, vector bool char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -2740,6 +3163,7 @@ vec_all_gt(vector unsigned char __a, vector unsigned char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -2747,6 +3171,7 @@ vec_all_gt(vector unsigned char __a, vector bool char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -2754,6 +3179,7 @@ vec_all_gt(vector bool char __a, vector unsigned char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -2769,6 +3195,7 @@ vec_all_gt(vector signed short __a, vector signed short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -2776,6 +3203,7 @@ vec_all_gt(vector signed short __a, vector bool short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -2790,6 +3218,7 @@ vec_all_gt(vector unsigned short __a, vector unsigned short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -2797,6 +3226,7 @@ vec_all_gt(vector unsigned short __a, vector bool short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -2804,6 +3234,7 @@ vec_all_gt(vector bool short __a, vector unsigned short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -2819,6 +3250,7 @@ vec_all_gt(vector signed int __a, vector signed int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -2826,6 +3258,7 @@ vec_all_gt(vector signed int __a, vector bool int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -2840,6 +3273,7 @@ vec_all_gt(vector unsigned int __a, vector unsigned int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -2847,6 +3281,7 @@ vec_all_gt(vector unsigned int __a, vector bool int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -2854,6 +3289,7 @@ vec_all_gt(vector bool int __a, vector unsigned int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -2869,6 +3305,7 @@ vec_all_gt(vector signed long long __a, vector signed long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -2876,6 +3313,7 @@ vec_all_gt(vector signed long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -2890,6 +3328,7 @@ vec_all_gt(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -2897,6 +3336,7 @@ vec_all_gt(vector unsigned long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -2904,6 +3344,7 @@ vec_all_gt(vector bool long long __a, vector unsigned long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_gt(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -2912,6 +3353,15 @@ vec_all_gt(vector bool long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_gt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__a, __b, &__cc);
+  return __cc == 0;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_all_gt(vector double __a, vector double __b) {
   int __cc;
 @@ -2928,6 +3378,7 @@ vec_all_le(vector signed char __a, vector signed char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -2935,6 +3386,7 @@ vec_all_le(vector signed char __a, vector bool char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -2949,6 +3401,7 @@ vec_all_le(vector unsigned char __a, vector unsigned char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -2956,6 +3409,7 @@ vec_all_le(vector unsigned char __a, vector bool char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -2963,6 +3417,7 @@ vec_all_le(vector bool char __a, vector unsigned char __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -2978,6 +3433,7 @@ vec_all_le(vector signed short __a, vector signed short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -2985,6 +3441,7 @@ vec_all_le(vector signed short __a, vector bool short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -2999,6 +3456,7 @@ vec_all_le(vector unsigned short __a, vector unsigned short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -3006,6 +3464,7 @@ vec_all_le(vector unsigned short __a, vector bool short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -3013,6 +3472,7 @@ vec_all_le(vector bool short __a, vector unsigned short __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -3028,6 +3488,7 @@ vec_all_le(vector signed int __a, vector signed int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -3035,6 +3496,7 @@ vec_all_le(vector signed int __a, vector bool int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -3049,6 +3511,7 @@ vec_all_le(vector unsigned int __a, vector unsigned int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -3056,6 +3519,7 @@ vec_all_le(vector unsigned int __a, vector bool int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -3063,6 +3527,7 @@ vec_all_le(vector bool int __a, vector unsigned int __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -3078,6 +3543,7 @@ vec_all_le(vector signed long long __a, vector signed long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -3085,6 +3551,7 @@ vec_all_le(vector signed long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -3099,6 +3566,7 @@ vec_all_le(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -3106,6 +3574,7 @@ vec_all_le(vector unsigned long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -3113,6 +3582,7 @@ vec_all_le(vector bool long long __a, vector unsigned long long __b) {
   return __cc == 3;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_le(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -3121,6 +3591,15 @@ vec_all_le(vector bool long long __a, vector bool long long __b) {
   return __cc == 3;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_le(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__b, __a, &__cc);
+  return __cc == 0;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_all_le(vector double __a, vector double __b) {
   int __cc;
 @@ -3137,6 +3616,7 @@ vec_all_lt(vector signed char __a, vector signed char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -3144,6 +3624,7 @@ vec_all_lt(vector signed char __a, vector bool char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -3158,6 +3639,7 @@ vec_all_lt(vector unsigned char __a, vector unsigned char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -3165,6 +3647,7 @@ vec_all_lt(vector unsigned char __a, vector bool char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -3172,6 +3655,7 @@ vec_all_lt(vector bool char __a, vector unsigned char __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -3187,6 +3671,7 @@ vec_all_lt(vector signed short __a, vector signed short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -3194,6 +3679,7 @@ vec_all_lt(vector signed short __a, vector bool short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -3208,6 +3694,7 @@ vec_all_lt(vector unsigned short __a, vector unsigned short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -3215,6 +3702,7 @@ vec_all_lt(vector unsigned short __a, vector bool short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -3222,6 +3710,7 @@ vec_all_lt(vector bool short __a, vector unsigned short __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -3237,6 +3726,7 @@ vec_all_lt(vector signed int __a, vector signed int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -3244,6 +3734,7 @@ vec_all_lt(vector signed int __a, vector bool int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -3258,6 +3749,7 @@ vec_all_lt(vector unsigned int __a, vector unsigned int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -3265,6 +3757,7 @@ vec_all_lt(vector unsigned int __a, vector bool int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -3272,6 +3765,7 @@ vec_all_lt(vector bool int __a, vector unsigned int __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -3287,6 +3781,7 @@ vec_all_lt(vector signed long long __a, vector signed long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -3294,6 +3789,7 @@ vec_all_lt(vector signed long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -3308,6 +3804,7 @@ vec_all_lt(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -3315,6 +3812,7 @@ vec_all_lt(vector unsigned long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -3322,6 +3820,7 @@ vec_all_lt(vector bool long long __a, vector unsigned long long __b) {
   return __cc == 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_all_lt(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -3330,6 +3829,15 @@ vec_all_lt(vector bool long long __a, vector bool long long __b) {
   return __cc == 0;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_lt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__b, __a, &__cc);
+  return __cc == 0;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_all_lt(vector double __a, vector double __b) {
   int __cc;
 @@ -3339,7 +3847,16 @@ vec_all_lt(vector double __a, vector double __b) {
 /*-- vec_all_nge ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_nge(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__a, __b, &__cc);
+  return __cc == 3;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_all_nge(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchedbs(__a, __b, &__cc);
 @@ -3348,7 +3865,16 @@ vec_all_nge(vector double __a, vector double __b) {
 /*-- vec_all_ngt ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_ngt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__a, __b, &__cc);
+  return __cc == 3;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_all_ngt(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchdbs(__a, __b, &__cc);
 @@ -3357,7 +3883,16 @@ vec_all_ngt(vector double __a, vector double __b) {
 /*-- vec_all_nle ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_nle(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__b, __a, &__cc);
+  return __cc == 3;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_all_nle(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchedbs(__b, __a, &__cc);
 @@ -3366,7 +3901,16 @@ vec_all_nle(vector double __a, vector double __b) {
 /*-- vec_all_nlt ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_nlt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__b, __a, &__cc);
+  return __cc == 3;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_all_nlt(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchdbs(__b, __a, &__cc);
 @@ -3375,7 +3919,16 @@ vec_all_nlt(vector double __a, vector double __b) {
 /*-- vec_all_nan ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_nan(vector float __a) {
+  int __cc;
+  __builtin_s390_vftcisb(__a, 15, &__cc);
+  return __cc == 0;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_all_nan(vector double __a) {
   int __cc;
   __builtin_s390_vftcidb(__a, 15, &__cc);
 @@ -3384,7 +3937,16 @@ vec_all_nan(vector double __a) {
 /*-- vec_all_numeric --------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_all_numeric(vector float __a) {
+  int __cc;
+  __builtin_s390_vftcisb(__a, 15, &__cc);
+  return __cc == 3;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_all_numeric(vector double __a) {
   int __cc;
   __builtin_s390_vftcidb(__a, 15, &__cc);
 @@ -3400,6 +3962,7 @@ vec_any_eq(vector signed char __a, vector signed char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -3407,6 +3970,7 @@ vec_any_eq(vector signed char __a, vector bool char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -3422,6 +3986,7 @@ vec_any_eq(vector unsigned char __a, vector unsigned char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -3430,6 +3995,7 @@ vec_any_eq(vector unsigned char __a, vector bool char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -3453,6 +4019,7 @@ vec_any_eq(vector signed short __a, vector signed short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -3460,6 +4027,7 @@ vec_any_eq(vector signed short __a, vector bool short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -3475,6 +4043,7 @@ vec_any_eq(vector unsigned short __a, vector unsigned short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -3483,6 +4052,7 @@ vec_any_eq(vector unsigned short __a, vector bool short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -3506,6 +4076,7 @@ vec_any_eq(vector signed int __a, vector signed int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -3513,6 +4084,7 @@ vec_any_eq(vector signed int __a, vector bool int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -3528,6 +4100,7 @@ vec_any_eq(vector unsigned int __a, vector unsigned int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -3536,6 +4109,7 @@ vec_any_eq(vector unsigned int __a, vector bool int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -3559,6 +4133,7 @@ vec_any_eq(vector signed long long __a, vector signed long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -3566,6 +4141,7 @@ vec_any_eq(vector signed long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -3581,6 +4157,7 @@ vec_any_eq(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -3589,6 +4166,7 @@ vec_any_eq(vector unsigned long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_eq(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -3605,6 +4183,15 @@ vec_any_eq(vector bool long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_eq(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfcesbs(__a, __b, &__cc);
+  return __cc <= 1;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_any_eq(vector double __a, vector double __b) {
   int __cc;
 @@ -3621,6 +4208,7 @@ vec_any_ne(vector signed char __a, vector signed char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -3628,6 +4216,7 @@ vec_any_ne(vector signed char __a, vector bool char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -3643,6 +4232,7 @@ vec_any_ne(vector unsigned char __a, vector unsigned char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -3651,6 +4241,7 @@ vec_any_ne(vector unsigned char __a, vector bool char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -3674,6 +4265,7 @@ vec_any_ne(vector signed short __a, vector signed short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -3681,6 +4273,7 @@ vec_any_ne(vector signed short __a, vector bool short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -3696,6 +4289,7 @@ vec_any_ne(vector unsigned short __a, vector unsigned short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -3704,6 +4298,7 @@ vec_any_ne(vector unsigned short __a, vector bool short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -3727,6 +4322,7 @@ vec_any_ne(vector signed int __a, vector signed int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -3734,6 +4330,7 @@ vec_any_ne(vector signed int __a, vector bool int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -3749,6 +4346,7 @@ vec_any_ne(vector unsigned int __a, vector unsigned int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -3757,6 +4355,7 @@ vec_any_ne(vector unsigned int __a, vector bool int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -3780,6 +4379,7 @@ vec_any_ne(vector signed long long __a, vector signed long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -3787,6 +4387,7 @@ vec_any_ne(vector signed long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -3802,6 +4403,7 @@ vec_any_ne(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -3810,6 +4412,7 @@ vec_any_ne(vector unsigned long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ne(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -3826,6 +4429,15 @@ vec_any_ne(vector bool long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_ne(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfcesbs(__a, __b, &__cc);
+  return __cc != 0;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_any_ne(vector double __a, vector double __b) {
   int __cc;
 @@ -3842,6 +4454,7 @@ vec_any_ge(vector signed char __a, vector signed char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -3849,6 +4462,7 @@ vec_any_ge(vector signed char __a, vector bool char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -3863,6 +4477,7 @@ vec_any_ge(vector unsigned char __a, vector unsigned char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -3870,6 +4485,7 @@ vec_any_ge(vector unsigned char __a, vector bool char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -3877,6 +4493,7 @@ vec_any_ge(vector bool char __a, vector unsigned char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -3892,6 +4509,7 @@ vec_any_ge(vector signed short __a, vector signed short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -3899,6 +4517,7 @@ vec_any_ge(vector signed short __a, vector bool short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -3913,6 +4532,7 @@ vec_any_ge(vector unsigned short __a, vector unsigned short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -3920,6 +4540,7 @@ vec_any_ge(vector unsigned short __a, vector bool short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -3927,6 +4548,7 @@ vec_any_ge(vector bool short __a, vector unsigned short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -3942,6 +4564,7 @@ vec_any_ge(vector signed int __a, vector signed int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -3949,6 +4572,7 @@ vec_any_ge(vector signed int __a, vector bool int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -3963,6 +4587,7 @@ vec_any_ge(vector unsigned int __a, vector unsigned int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -3970,6 +4595,7 @@ vec_any_ge(vector unsigned int __a, vector bool int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -3977,6 +4603,7 @@ vec_any_ge(vector bool int __a, vector unsigned int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -3992,6 +4619,7 @@ vec_any_ge(vector signed long long __a, vector signed long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -3999,6 +4627,7 @@ vec_any_ge(vector signed long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -4013,6 +4642,7 @@ vec_any_ge(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -4020,6 +4650,7 @@ vec_any_ge(vector unsigned long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -4027,6 +4658,7 @@ vec_any_ge(vector bool long long __a, vector unsigned long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_ge(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -4035,6 +4667,15 @@ vec_any_ge(vector bool long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_ge(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__a, __b, &__cc);
+  return __cc <= 1;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_any_ge(vector double __a, vector double __b) {
   int __cc;
 @@ -4051,6 +4692,7 @@ vec_any_gt(vector signed char __a, vector signed char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -4058,6 +4700,7 @@ vec_any_gt(vector signed char __a, vector bool char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -4072,6 +4715,7 @@ vec_any_gt(vector unsigned char __a, vector unsigned char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -4079,6 +4723,7 @@ vec_any_gt(vector unsigned char __a, vector bool char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -4086,6 +4731,7 @@ vec_any_gt(vector bool char __a, vector unsigned char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -4101,6 +4747,7 @@ vec_any_gt(vector signed short __a, vector signed short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -4108,6 +4755,7 @@ vec_any_gt(vector signed short __a, vector bool short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -4122,6 +4770,7 @@ vec_any_gt(vector unsigned short __a, vector unsigned short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -4129,6 +4778,7 @@ vec_any_gt(vector unsigned short __a, vector bool short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -4136,6 +4786,7 @@ vec_any_gt(vector bool short __a, vector unsigned short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -4151,6 +4802,7 @@ vec_any_gt(vector signed int __a, vector signed int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -4158,6 +4810,7 @@ vec_any_gt(vector signed int __a, vector bool int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -4172,6 +4825,7 @@ vec_any_gt(vector unsigned int __a, vector unsigned int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -4179,6 +4833,7 @@ vec_any_gt(vector unsigned int __a, vector bool int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -4186,6 +4841,7 @@ vec_any_gt(vector bool int __a, vector unsigned int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -4201,6 +4857,7 @@ vec_any_gt(vector signed long long __a, vector signed long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -4208,6 +4865,7 @@ vec_any_gt(vector signed long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -4222,6 +4880,7 @@ vec_any_gt(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -4229,6 +4888,7 @@ vec_any_gt(vector unsigned long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -4236,6 +4896,7 @@ vec_any_gt(vector bool long long __a, vector unsigned long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_gt(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -4244,6 +4905,15 @@ vec_any_gt(vector bool long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_gt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__a, __b, &__cc);
+  return __cc <= 1;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_any_gt(vector double __a, vector double __b) {
   int __cc;
 @@ -4260,6 +4930,7 @@ vec_any_le(vector signed char __a, vector signed char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -4267,6 +4938,7 @@ vec_any_le(vector signed char __a, vector bool char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -4281,6 +4953,7 @@ vec_any_le(vector unsigned char __a, vector unsigned char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -4288,6 +4961,7 @@ vec_any_le(vector unsigned char __a, vector bool char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -4295,6 +4969,7 @@ vec_any_le(vector bool char __a, vector unsigned char __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -4310,6 +4985,7 @@ vec_any_le(vector signed short __a, vector signed short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -4317,6 +4993,7 @@ vec_any_le(vector signed short __a, vector bool short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -4331,6 +5008,7 @@ vec_any_le(vector unsigned short __a, vector unsigned short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -4338,6 +5016,7 @@ vec_any_le(vector unsigned short __a, vector bool short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -4345,6 +5024,7 @@ vec_any_le(vector bool short __a, vector unsigned short __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -4360,6 +5040,7 @@ vec_any_le(vector signed int __a, vector signed int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -4367,6 +5048,7 @@ vec_any_le(vector signed int __a, vector bool int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -4381,6 +5063,7 @@ vec_any_le(vector unsigned int __a, vector unsigned int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -4388,6 +5071,7 @@ vec_any_le(vector unsigned int __a, vector bool int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -4395,6 +5079,7 @@ vec_any_le(vector bool int __a, vector unsigned int __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -4410,6 +5095,7 @@ vec_any_le(vector signed long long __a, vector signed long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -4417,6 +5103,7 @@ vec_any_le(vector signed long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -4431,6 +5118,7 @@ vec_any_le(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -4438,6 +5126,7 @@ vec_any_le(vector unsigned long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -4445,6 +5134,7 @@ vec_any_le(vector bool long long __a, vector unsigned long long __b) {
   return __cc != 0;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_le(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -4453,6 +5143,15 @@ vec_any_le(vector bool long long __a, vector bool long long __b) {
   return __cc != 0;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_le(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__b, __a, &__cc);
+  return __cc <= 1;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_any_le(vector double __a, vector double __b) {
   int __cc;
 @@ -4469,6 +5168,7 @@ vec_any_lt(vector signed char __a, vector signed char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector signed char __a, vector bool char __b) {
   int __cc;
 @@ -4476,6 +5176,7 @@ vec_any_lt(vector signed char __a, vector bool char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool char __a, vector signed char __b) {
   int __cc;
 @@ -4490,6 +5191,7 @@ vec_any_lt(vector unsigned char __a, vector unsigned char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector unsigned char __a, vector bool char __b) {
   int __cc;
 @@ -4497,6 +5199,7 @@ vec_any_lt(vector unsigned char __a, vector bool char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool char __a, vector unsigned char __b) {
   int __cc;
 @@ -4504,6 +5207,7 @@ vec_any_lt(vector bool char __a, vector unsigned char __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool char __a, vector bool char __b) {
   int __cc;
 @@ -4519,6 +5223,7 @@ vec_any_lt(vector signed short __a, vector signed short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector signed short __a, vector bool short __b) {
   int __cc;
 @@ -4526,6 +5231,7 @@ vec_any_lt(vector signed short __a, vector bool short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool short __a, vector signed short __b) {
   int __cc;
 @@ -4540,6 +5246,7 @@ vec_any_lt(vector unsigned short __a, vector unsigned short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector unsigned short __a, vector bool short __b) {
   int __cc;
 @@ -4547,6 +5254,7 @@ vec_any_lt(vector unsigned short __a, vector bool short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool short __a, vector unsigned short __b) {
   int __cc;
 @@ -4554,6 +5262,7 @@ vec_any_lt(vector bool short __a, vector unsigned short __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool short __a, vector bool short __b) {
   int __cc;
 @@ -4569,6 +5278,7 @@ vec_any_lt(vector signed int __a, vector signed int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector signed int __a, vector bool int __b) {
   int __cc;
 @@ -4576,6 +5286,7 @@ vec_any_lt(vector signed int __a, vector bool int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool int __a, vector signed int __b) {
   int __cc;
 @@ -4590,6 +5301,7 @@ vec_any_lt(vector unsigned int __a, vector unsigned int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector unsigned int __a, vector bool int __b) {
   int __cc;
 @@ -4597,6 +5309,7 @@ vec_any_lt(vector unsigned int __a, vector bool int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool int __a, vector unsigned int __b) {
   int __cc;
 @@ -4604,6 +5317,7 @@ vec_any_lt(vector bool int __a, vector unsigned int __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool int __a, vector bool int __b) {
   int __cc;
 @@ -4619,6 +5333,7 @@ vec_any_lt(vector signed long long __a, vector signed long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector signed long long __a, vector bool long long __b) {
   int __cc;
 @@ -4626,6 +5341,7 @@ vec_any_lt(vector signed long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool long long __a, vector signed long long __b) {
   int __cc;
 @@ -4640,6 +5356,7 @@ vec_any_lt(vector unsigned long long __a, vector unsigned long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector unsigned long long __a, vector bool long long __b) {
   int __cc;
 @@ -4647,6 +5364,7 @@ vec_any_lt(vector unsigned long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool long long __a, vector unsigned long long __b) {
   int __cc;
 @@ -4654,6 +5372,7 @@ vec_any_lt(vector bool long long __a, vector unsigned long long __b) {
   return __cc <= 1;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai int
 vec_any_lt(vector bool long long __a, vector bool long long __b) {
   int __cc;
 @@ -4662,6 +5381,15 @@ vec_any_lt(vector bool long long __a, vector bool long long __b) {
   return __cc <= 1;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_lt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__b, __a, &__cc);
+  return __cc <= 1;
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_any_lt(vector double __a, vector double __b) {
   int __cc;
 @@ -4671,7 +5399,16 @@ vec_any_lt(vector double __a, vector double __b) {
 /*-- vec_any_nge ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_nge(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__a, __b, &__cc);
+  return __cc != 0;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_any_nge(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchedbs(__a, __b, &__cc);
 @@ -4680,7 +5417,16 @@ vec_any_nge(vector double __a, vector double __b) {
 /*-- vec_any_ngt ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_ngt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__a, __b, &__cc);
+  return __cc != 0;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_any_ngt(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchdbs(__a, __b, &__cc);
 @@ -4689,7 +5435,16 @@ vec_any_ngt(vector double __a, vector double __b) {
 /*-- vec_any_nle ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_nle(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchesbs(__b, __a, &__cc);
+  return __cc != 0;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_any_nle(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchedbs(__b, __a, &__cc);
 @@ -4698,7 +5453,16 @@ vec_any_nle(vector double __a, vector double __b) {
 /*-- vec_any_nlt ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_nlt(vector float __a, vector float __b) {
+  int __cc;
+  __builtin_s390_vfchsbs(__b, __a, &__cc);
+  return __cc != 0;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_any_nlt(vector double __a, vector double __b) {
   int __cc;
   __builtin_s390_vfchdbs(__b, __a, &__cc);
 @@ -4707,7 +5471,16 @@ vec_any_nlt(vector double __a, vector double __b) {
 /*-- vec_any_nan ------------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_nan(vector float __a) {
+  int __cc;
+  __builtin_s390_vftcisb(__a, 15, &__cc);
+  return __cc != 3;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_any_nan(vector double __a) {
   int __cc;
   __builtin_s390_vftcidb(__a, 15, &__cc);
 @@ -4716,7 +5489,16 @@ vec_any_nan(vector double __a) {
 /*-- vec_any_numeric --------------------------------------------------------*/
-static inline __ATTRS_ai int
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_any_numeric(vector float __a) {
+  int __cc;
+  __builtin_s390_vftcisb(__a, 15, &__cc);
+  return __cc != 0;
+}
+#endif
+static inline __ATTRS_o_ai int
 vec_any_numeric(vector double __a) {
   int __cc;
   __builtin_s390_vftcidb(__a, 15, &__cc);
 @@ -4735,11 +5517,13 @@ vec_andc(vector signed char __a, vector signed char __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_andc(vector bool char __a, vector signed char __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_andc(vector signed char __a, vector bool char __b) {
   return __a & ~__b;
 @@ -4750,11 +5534,13 @@ vec_andc(vector unsigned char __a, vector unsigned char __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_andc(vector bool char __a, vector unsigned char __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_andc(vector unsigned char __a, vector bool char __b) {
   return __a & ~__b;
 @@ -4770,11 +5556,13 @@ vec_andc(vector signed short __a, vector signed short __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_andc(vector bool short __a, vector signed short __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_andc(vector signed short __a, vector bool short __b) {
   return __a & ~__b;
 @@ -4785,11 +5573,13 @@ vec_andc(vector unsigned short __a, vector unsigned short __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_andc(vector bool short __a, vector unsigned short __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_andc(vector unsigned short __a, vector bool short __b) {
   return __a & ~__b;
 @@ -4805,11 +5595,13 @@ vec_andc(vector signed int __a, vector signed int __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_andc(vector bool int __a, vector signed int __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_andc(vector signed int __a, vector bool int __b) {
   return __a & ~__b;
 @@ -4820,11 +5612,13 @@ vec_andc(vector unsigned int __a, vector unsigned int __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_andc(vector bool int __a, vector unsigned int __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_andc(vector unsigned int __a, vector bool int __b) {
   return __a & ~__b;
 @@ -4840,11 +5634,13 @@ vec_andc(vector signed long long __a, vector signed long long __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_andc(vector bool long long __a, vector signed long long __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_andc(vector signed long long __a, vector bool long long __b) {
   return __a & ~__b;
 @@ -4855,28 +5651,40 @@ vec_andc(vector unsigned long long __a, vector unsigned long long __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_andc(vector bool long long __a, vector unsigned long long __b) {
   return __a & ~__b;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_andc(vector unsigned long long __a, vector bool long long __b) {
   return __a & ~__b;
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_andc(vector float __a, vector float __b) {
+  return (vector float)((vector unsigned int)__a &
+                         ~(vector unsigned int)__b);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_andc(vector double __a, vector double __b) {
   return (vector double)((vector unsigned long long)__a &
                          ~(vector unsigned long long)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector double
 vec_andc(vector bool long long __a, vector double __b) {
   return (vector double)((vector unsigned long long)__a &
                          ~(vector unsigned long long)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector double
 vec_andc(vector double __a, vector bool long long __b) {
   return (vector double)((vector unsigned long long)__a &
 @@ -4895,11 +5703,13 @@ vec_nor(vector signed char __a, vector signed char __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_nor(vector bool char __a, vector signed char __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_nor(vector signed char __a, vector bool char __b) {
   return ~(__a | __b);
 @@ -4910,11 +5720,13 @@ vec_nor(vector unsigned char __a, vector unsigned char __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_nor(vector bool char __a, vector unsigned char __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_nor(vector unsigned char __a, vector bool char __b) {
   return ~(__a | __b);
 @@ -4930,11 +5742,13 @@ vec_nor(vector signed short __a, vector signed short __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_nor(vector bool short __a, vector signed short __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_nor(vector signed short __a, vector bool short __b) {
   return ~(__a | __b);
 @@ -4945,11 +5759,13 @@ vec_nor(vector unsigned short __a, vector unsigned short __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_nor(vector bool short __a, vector unsigned short __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_nor(vector unsigned short __a, vector bool short __b) {
   return ~(__a | __b);
 @@ -4965,11 +5781,13 @@ vec_nor(vector signed int __a, vector signed int __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_nor(vector bool int __a, vector signed int __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_nor(vector signed int __a, vector bool int __b) {
   return ~(__a | __b);
 @@ -4980,11 +5798,13 @@ vec_nor(vector unsigned int __a, vector unsigned int __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_nor(vector bool int __a, vector unsigned int __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_nor(vector unsigned int __a, vector bool int __b) {
   return ~(__a | __b);
 @@ -5000,11 +5820,13 @@ vec_nor(vector signed long long __a, vector signed long long __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_nor(vector bool long long __a, vector signed long long __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_nor(vector signed long long __a, vector bool long long __b) {
   return ~(__a | __b);
 @@ -5015,34 +5837,274 @@ vec_nor(vector unsigned long long __a, vector unsigned long long __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_nor(vector bool long long __a, vector unsigned long long __b) {
   return ~(__a | __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_nor(vector unsigned long long __a, vector bool long long __b) {
   return ~(__a | __b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_nor(vector float __a, vector float __b) {
+  return (vector float)~((vector unsigned int)__a |
+                         (vector unsigned int)__b);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_nor(vector double __a, vector double __b) {
   return (vector double)~((vector unsigned long long)__a |
                           (vector unsigned long long)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector double
 vec_nor(vector bool long long __a, vector double __b) {
   return (vector double)~((vector unsigned long long)__a |
                           (vector unsigned long long)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector double
 vec_nor(vector double __a, vector bool long long __b) {
   return (vector double)~((vector unsigned long long)__a |
                           (vector unsigned long long)__b);
 }
+/*-- vec_orc ----------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool char
+vec_orc(vector bool char __a, vector bool char __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector signed char
+vec_orc(vector signed char __a, vector signed char __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector unsigned char
+vec_orc(vector unsigned char __a, vector unsigned char __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector bool short
+vec_orc(vector bool short __a, vector bool short __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector signed short
+vec_orc(vector signed short __a, vector signed short __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector unsigned short
+vec_orc(vector unsigned short __a, vector unsigned short __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector bool int
+vec_orc(vector bool int __a, vector bool int __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector signed int
+vec_orc(vector signed int __a, vector signed int __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector unsigned int
+vec_orc(vector unsigned int __a, vector unsigned int __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector bool long long
+vec_orc(vector bool long long __a, vector bool long long __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector signed long long
+vec_orc(vector signed long long __a, vector signed long long __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector unsigned long long
+vec_orc(vector unsigned long long __a, vector unsigned long long __b) {
+  return __a | ~__b;
+}
+static inline __ATTRS_o_ai vector float
+vec_orc(vector float __a, vector float __b) {
+  return (vector float)((vector unsigned int)__a &
+                        ~(vector unsigned int)__b);
+}
+static inline __ATTRS_o_ai vector double
+vec_orc(vector double __a, vector double __b) {
+  return (vector double)((vector unsigned long long)__a &
+                         ~(vector unsigned long long)__b);
+}
+#endif
+/*-- vec_nand ---------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool char
+vec_nand(vector bool char __a, vector bool char __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector signed char
+vec_nand(vector signed char __a, vector signed char __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector unsigned char
+vec_nand(vector unsigned char __a, vector unsigned char __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector bool short
+vec_nand(vector bool short __a, vector bool short __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector signed short
+vec_nand(vector signed short __a, vector signed short __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector unsigned short
+vec_nand(vector unsigned short __a, vector unsigned short __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector bool int
+vec_nand(vector bool int __a, vector bool int __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector signed int
+vec_nand(vector signed int __a, vector signed int __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector unsigned int
+vec_nand(vector unsigned int __a, vector unsigned int __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector bool long long
+vec_nand(vector bool long long __a, vector bool long long __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector signed long long
+vec_nand(vector signed long long __a, vector signed long long __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector unsigned long long
+vec_nand(vector unsigned long long __a, vector unsigned long long __b) {
+  return ~(__a & __b);
+}
+static inline __ATTRS_o_ai vector float
+vec_nand(vector float __a, vector float __b) {
+  return (vector float)~((vector unsigned int)__a &
+                         (vector unsigned int)__b);
+}
+static inline __ATTRS_o_ai vector double
+vec_nand(vector double __a, vector double __b) {
+  return (vector double)~((vector unsigned long long)__a &
+                          (vector unsigned long long)__b);
+}
+#endif
+/*-- vec_eqv ----------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector bool char
+vec_eqv(vector bool char __a, vector bool char __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector signed char
+vec_eqv(vector signed char __a, vector signed char __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector unsigned char
+vec_eqv(vector unsigned char __a, vector unsigned char __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector bool short
+vec_eqv(vector bool short __a, vector bool short __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector signed short
+vec_eqv(vector signed short __a, vector signed short __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector unsigned short
+vec_eqv(vector unsigned short __a, vector unsigned short __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector bool int
+vec_eqv(vector bool int __a, vector bool int __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector signed int
+vec_eqv(vector signed int __a, vector signed int __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector unsigned int
+vec_eqv(vector unsigned int __a, vector unsigned int __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector bool long long
+vec_eqv(vector bool long long __a, vector bool long long __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector signed long long
+vec_eqv(vector signed long long __a, vector signed long long __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector unsigned long long
+vec_eqv(vector unsigned long long __a, vector unsigned long long __b) {
+  return ~(__a ^ __b);
+}
+static inline __ATTRS_o_ai vector float
+vec_eqv(vector float __a, vector float __b) {
+  return (vector float)~((vector unsigned int)__a ^
+                         (vector unsigned int)__b);
+}
+static inline __ATTRS_o_ai vector double
+vec_eqv(vector double __a, vector double __b) {
+  return (vector double)~((vector unsigned long long)__a ^
+                          (vector unsigned long long)__b);
+}
+#endif
 /*-- vec_cntlz --------------------------------------------------------------*/
 static inline __ATTRS_o_ai vector unsigned char
 @@ -5323,30 +6385,35 @@ vec_sll(vector signed char __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_sll(vector signed char __a, vector unsigned short __b) {
   return (vector signed char)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_sll(vector signed char __a, vector unsigned int __b) {
   return (vector signed char)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_sll(vector bool char __a, vector unsigned char __b) {
   return (vector bool char)__builtin_s390_vsl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_sll(vector bool char __a, vector unsigned short __b) {
   return (vector bool char)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_sll(vector bool char __a, vector unsigned int __b) {
   return (vector bool char)__builtin_s390_vsl(
 @@ -5358,11 +6425,13 @@ vec_sll(vector unsigned char __a, vector unsigned char __b) {
   return __builtin_s390_vsl(__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_sll(vector unsigned char __a, vector unsigned short __b) {
   return __builtin_s390_vsl(__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_sll(vector unsigned char __a, vector unsigned int __b) {
   return __builtin_s390_vsl(__a, (vector unsigned char)__b);
 @@ -5374,30 +6443,35 @@ vec_sll(vector signed short __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_sll(vector signed short __a, vector unsigned short __b) {
   return (vector signed short)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_sll(vector signed short __a, vector unsigned int __b) {
   return (vector signed short)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_sll(vector bool short __a, vector unsigned char __b) {
   return (vector bool short)__builtin_s390_vsl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_sll(vector bool short __a, vector unsigned short __b) {
   return (vector bool short)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_sll(vector bool short __a, vector unsigned int __b) {
   return (vector bool short)__builtin_s390_vsl(
 @@ -5410,12 +6484,14 @@ vec_sll(vector unsigned short __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_sll(vector unsigned short __a, vector unsigned short __b) {
   return (vector unsigned short)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_sll(vector unsigned short __a, vector unsigned int __b) {
   return (vector unsigned short)__builtin_s390_vsl(
 @@ -5428,30 +6504,35 @@ vec_sll(vector signed int __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_sll(vector signed int __a, vector unsigned short __b) {
   return (vector signed int)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_sll(vector signed int __a, vector unsigned int __b) {
   return (vector signed int)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_sll(vector bool int __a, vector unsigned char __b) {
   return (vector bool int)__builtin_s390_vsl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_sll(vector bool int __a, vector unsigned short __b) {
   return (vector bool int)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_sll(vector bool int __a, vector unsigned int __b) {
   return (vector bool int)__builtin_s390_vsl(
 @@ -5464,12 +6545,14 @@ vec_sll(vector unsigned int __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_sll(vector unsigned int __a, vector unsigned short __b) {
   return (vector unsigned int)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_sll(vector unsigned int __a, vector unsigned int __b) {
   return (vector unsigned int)__builtin_s390_vsl(
 @@ -5482,30 +6565,35 @@ vec_sll(vector signed long long __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_sll(vector signed long long __a, vector unsigned short __b) {
   return (vector signed long long)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_sll(vector signed long long __a, vector unsigned int __b) {
   return (vector signed long long)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_sll(vector bool long long __a, vector unsigned char __b) {
   return (vector bool long long)__builtin_s390_vsl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_sll(vector bool long long __a, vector unsigned short __b) {
   return (vector bool long long)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_sll(vector bool long long __a, vector unsigned int __b) {
   return (vector bool long long)__builtin_s390_vsl(
 @@ -5518,12 +6606,14 @@ vec_sll(vector unsigned long long __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_sll(vector unsigned long long __a, vector unsigned short __b) {
   return (vector unsigned long long)__builtin_s390_vsl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_sll(vector unsigned long long __a, vector unsigned int __b) {
   return (vector unsigned long long)__builtin_s390_vsl(
 @@ -5626,6 +6716,20 @@ vec_slb(vector unsigned long long __a, vector unsigned long long __b) {
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_slb(vector float __a, vector signed int __b) {
+  return (vector float)__builtin_s390_vslb(
+    (vector unsigned char)__a, (vector unsigned char)__b);
+}
+static inline __ATTRS_o_ai vector float
+vec_slb(vector float __a, vector unsigned int __b) {
+  return (vector float)__builtin_s390_vslb(
+    (vector unsigned char)__a, (vector unsigned char)__b);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_slb(vector double __a, vector signed long long __b) {
   return (vector double)__builtin_s390_vslb(
 @@ -5644,6 +6748,10 @@ extern __ATTRS_o vector signed char
 vec_sld(vector signed char __a, vector signed char __b, int __c)
   __constant_range(__c, 0, 15);
+extern __ATTRS_o vector bool char
+vec_sld(vector bool char __a, vector bool char __b, int __c)
+  __constant_range(__c, 0, 15);
 extern __ATTRS_o vector unsigned char
 vec_sld(vector unsigned char __a, vector unsigned char __b, int __c)
   __constant_range(__c, 0, 15);
 @@ -5652,6 +6760,10 @@ extern __ATTRS_o vector signed short
 vec_sld(vector signed short __a, vector signed short __b, int __c)
   __constant_range(__c, 0, 15);
+extern __ATTRS_o vector bool short
+vec_sld(vector bool short __a, vector bool short __b, int __c)
+  __constant_range(__c, 0, 15);
 extern __ATTRS_o vector unsigned short
 vec_sld(vector unsigned short __a, vector unsigned short __b, int __c)
   __constant_range(__c, 0, 15);
 @@ -5660,6 +6772,10 @@ extern __ATTRS_o vector signed int
 vec_sld(vector signed int __a, vector signed int __b, int __c)
   __constant_range(__c, 0, 15);
+extern __ATTRS_o vector bool int
+vec_sld(vector bool int __a, vector bool int __b, int __c)
+  __constant_range(__c, 0, 15);
 extern __ATTRS_o vector unsigned int
 vec_sld(vector unsigned int __a, vector unsigned int __b, int __c)
   __constant_range(__c, 0, 15);
 @@ -5668,10 +6784,20 @@ extern __ATTRS_o vector signed long long
 vec_sld(vector signed long long __a, vector signed long long __b, int __c)
   __constant_range(__c, 0, 15);
+extern __ATTRS_o vector bool long long
+vec_sld(vector bool long long __a, vector bool long long __b, int __c)
+  __constant_range(__c, 0, 15);
 extern __ATTRS_o vector unsigned long long
 vec_sld(vector unsigned long long __a, vector unsigned long long __b, int __c)
   __constant_range(__c, 0, 15);
+#if __ARCH__ >= 12
+extern __ATTRS_o vector float
+vec_sld(vector float __a, vector float __b, int __c)
+  __constant_range(__c, 0, 15);
+#endif
 extern __ATTRS_o vector double
 vec_sld(vector double __a, vector double __b, int __c)
   __constant_range(__c, 0, 15);
 @@ -5714,6 +6840,7 @@ extern __ATTRS_o vector unsigned long long
 vec_sldw(vector unsigned long long __a, vector unsigned long long __b, int __c)
   __constant_range(__c, 0, 3);
+// This prototype is deprecated.
 extern __ATTRS_o vector double
 vec_sldw(vector double __a, vector double __b, int __c)
   __constant_range(__c, 0, 3);
 @@ -5730,30 +6857,35 @@ vec_sral(vector signed char __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_sral(vector signed char __a, vector unsigned short __b) {
   return (vector signed char)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_sral(vector signed char __a, vector unsigned int __b) {
   return (vector signed char)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_sral(vector bool char __a, vector unsigned char __b) {
   return (vector bool char)__builtin_s390_vsra(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_sral(vector bool char __a, vector unsigned short __b) {
   return (vector bool char)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_sral(vector bool char __a, vector unsigned int __b) {
   return (vector bool char)__builtin_s390_vsra(
 @@ -5765,11 +6897,13 @@ vec_sral(vector unsigned char __a, vector unsigned char __b) {
   return __builtin_s390_vsra(__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_sral(vector unsigned char __a, vector unsigned short __b) {
   return __builtin_s390_vsra(__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_sral(vector unsigned char __a, vector unsigned int __b) {
   return __builtin_s390_vsra(__a, (vector unsigned char)__b);
 @@ -5781,30 +6915,35 @@ vec_sral(vector signed short __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_sral(vector signed short __a, vector unsigned short __b) {
   return (vector signed short)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_sral(vector signed short __a, vector unsigned int __b) {
   return (vector signed short)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_sral(vector bool short __a, vector unsigned char __b) {
   return (vector bool short)__builtin_s390_vsra(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_sral(vector bool short __a, vector unsigned short __b) {
   return (vector bool short)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_sral(vector bool short __a, vector unsigned int __b) {
   return (vector bool short)__builtin_s390_vsra(
 @@ -5817,12 +6956,14 @@ vec_sral(vector unsigned short __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_sral(vector unsigned short __a, vector unsigned short __b) {
   return (vector unsigned short)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_sral(vector unsigned short __a, vector unsigned int __b) {
   return (vector unsigned short)__builtin_s390_vsra(
 @@ -5835,30 +6976,35 @@ vec_sral(vector signed int __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_sral(vector signed int __a, vector unsigned short __b) {
   return (vector signed int)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_sral(vector signed int __a, vector unsigned int __b) {
   return (vector signed int)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_sral(vector bool int __a, vector unsigned char __b) {
   return (vector bool int)__builtin_s390_vsra(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_sral(vector bool int __a, vector unsigned short __b) {
   return (vector bool int)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_sral(vector bool int __a, vector unsigned int __b) {
   return (vector bool int)__builtin_s390_vsra(
 @@ -5871,12 +7017,14 @@ vec_sral(vector unsigned int __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_sral(vector unsigned int __a, vector unsigned short __b) {
   return (vector unsigned int)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_sral(vector unsigned int __a, vector unsigned int __b) {
   return (vector unsigned int)__builtin_s390_vsra(
 @@ -5889,30 +7037,35 @@ vec_sral(vector signed long long __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_sral(vector signed long long __a, vector unsigned short __b) {
   return (vector signed long long)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_sral(vector signed long long __a, vector unsigned int __b) {
   return (vector signed long long)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_sral(vector bool long long __a, vector unsigned char __b) {
   return (vector bool long long)__builtin_s390_vsra(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_sral(vector bool long long __a, vector unsigned short __b) {
   return (vector bool long long)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_sral(vector bool long long __a, vector unsigned int __b) {
   return (vector bool long long)__builtin_s390_vsra(
 @@ -5925,12 +7078,14 @@ vec_sral(vector unsigned long long __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_sral(vector unsigned long long __a, vector unsigned short __b) {
   return (vector unsigned long long)__builtin_s390_vsra(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_sral(vector unsigned long long __a, vector unsigned int __b) {
   return (vector unsigned long long)__builtin_s390_vsra(
 @@ -6033,6 +7188,20 @@ vec_srab(vector unsigned long long __a, vector unsigned long long __b) {
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_srab(vector float __a, vector signed int __b) {
+  return (vector float)__builtin_s390_vsrab(
+    (vector unsigned char)__a, (vector unsigned char)__b);
+}
+static inline __ATTRS_o_ai vector float
+vec_srab(vector float __a, vector unsigned int __b) {
+  return (vector float)__builtin_s390_vsrab(
+    (vector unsigned char)__a, (vector unsigned char)__b);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_srab(vector double __a, vector signed long long __b) {
   return (vector double)__builtin_s390_vsrab(
 @@ -6053,30 +7222,35 @@ vec_srl(vector signed char __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_srl(vector signed char __a, vector unsigned short __b) {
   return (vector signed char)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_srl(vector signed char __a, vector unsigned int __b) {
   return (vector signed char)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_srl(vector bool char __a, vector unsigned char __b) {
   return (vector bool char)__builtin_s390_vsrl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_srl(vector bool char __a, vector unsigned short __b) {
   return (vector bool char)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool char
 vec_srl(vector bool char __a, vector unsigned int __b) {
   return (vector bool char)__builtin_s390_vsrl(
 @@ -6088,11 +7262,13 @@ vec_srl(vector unsigned char __a, vector unsigned char __b) {
   return __builtin_s390_vsrl(__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_srl(vector unsigned char __a, vector unsigned short __b) {
   return __builtin_s390_vsrl(__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_srl(vector unsigned char __a, vector unsigned int __b) {
   return __builtin_s390_vsrl(__a, (vector unsigned char)__b);
 @@ -6104,30 +7280,35 @@ vec_srl(vector signed short __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_srl(vector signed short __a, vector unsigned short __b) {
   return (vector signed short)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_srl(vector signed short __a, vector unsigned int __b) {
   return (vector signed short)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_srl(vector bool short __a, vector unsigned char __b) {
   return (vector bool short)__builtin_s390_vsrl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_srl(vector bool short __a, vector unsigned short __b) {
   return (vector bool short)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool short
 vec_srl(vector bool short __a, vector unsigned int __b) {
   return (vector bool short)__builtin_s390_vsrl(
 @@ -6140,12 +7321,14 @@ vec_srl(vector unsigned short __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_srl(vector unsigned short __a, vector unsigned short __b) {
   return (vector unsigned short)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_srl(vector unsigned short __a, vector unsigned int __b) {
   return (vector unsigned short)__builtin_s390_vsrl(
 @@ -6158,30 +7341,35 @@ vec_srl(vector signed int __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_srl(vector signed int __a, vector unsigned short __b) {
   return (vector signed int)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_srl(vector signed int __a, vector unsigned int __b) {
   return (vector signed int)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_srl(vector bool int __a, vector unsigned char __b) {
   return (vector bool int)__builtin_s390_vsrl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_srl(vector bool int __a, vector unsigned short __b) {
   return (vector bool int)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool int
 vec_srl(vector bool int __a, vector unsigned int __b) {
   return (vector bool int)__builtin_s390_vsrl(
 @@ -6194,12 +7382,14 @@ vec_srl(vector unsigned int __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_srl(vector unsigned int __a, vector unsigned short __b) {
   return (vector unsigned int)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_srl(vector unsigned int __a, vector unsigned int __b) {
   return (vector unsigned int)__builtin_s390_vsrl(
 @@ -6212,30 +7402,35 @@ vec_srl(vector signed long long __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_srl(vector signed long long __a, vector unsigned short __b) {
   return (vector signed long long)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_srl(vector signed long long __a, vector unsigned int __b) {
   return (vector signed long long)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_srl(vector bool long long __a, vector unsigned char __b) {
   return (vector bool long long)__builtin_s390_vsrl(
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_srl(vector bool long long __a, vector unsigned short __b) {
   return (vector bool long long)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector bool long long
 vec_srl(vector bool long long __a, vector unsigned int __b) {
   return (vector bool long long)__builtin_s390_vsrl(
 @@ -6248,12 +7443,14 @@ vec_srl(vector unsigned long long __a, vector unsigned char __b) {
     (vector unsigned char)__a, __b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_srl(vector unsigned long long __a, vector unsigned short __b) {
   return (vector unsigned long long)__builtin_s390_vsrl(
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_srl(vector unsigned long long __a, vector unsigned int __b) {
   return (vector unsigned long long)__builtin_s390_vsrl(
 @@ -6356,6 +7553,20 @@ vec_srb(vector unsigned long long __a, vector unsigned long long __b) {
     (vector unsigned char)__a, (vector unsigned char)__b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_srb(vector float __a, vector signed int __b) {
+  return (vector float)__builtin_s390_vsrlb(
+    (vector unsigned char)__a, (vector unsigned char)__b);
+}
+static inline __ATTRS_o_ai vector float
+vec_srb(vector float __a, vector unsigned int __b) {
+  return (vector float)__builtin_s390_vsrlb(
+    (vector unsigned char)__a, (vector unsigned char)__b);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_srb(vector double __a, vector signed long long __b) {
   return (vector double)__builtin_s390_vsrlb(
 @@ -6390,6 +7601,13 @@ vec_abs(vector signed long long __a) {
   return vec_sel(__a, -__a, vec_cmplt(__a, (vector signed long long)0));
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_abs(vector float __a) {
+  return __builtin_s390_vflpsb(__a);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_abs(vector double __a) {
   return __builtin_s390_vflpdb(__a);
 @@ -6397,7 +7615,14 @@ vec_abs(vector double __a) {
 /*-- vec_nabs ---------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_nabs(vector float __a) {
+  return __builtin_s390_vflnsb(__a);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_nabs(vector double __a) {
   return __builtin_s390_vflndb(__a);
 }
 @@ -6409,12 +7634,14 @@ vec_max(vector signed char __a, vector signed char __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_max(vector signed char __a, vector bool char __b) {
   vector signed char __bc = (vector signed char)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_max(vector bool char __a, vector signed char __b) {
   vector signed char __ac = (vector signed char)__a;
 @@ -6426,12 +7653,14 @@ vec_max(vector unsigned char __a, vector unsigned char __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_max(vector unsigned char __a, vector bool char __b) {
   vector unsigned char __bc = (vector unsigned char)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_max(vector bool char __a, vector unsigned char __b) {
   vector unsigned char __ac = (vector unsigned char)__a;
 @@ -6443,12 +7672,14 @@ vec_max(vector signed short __a, vector signed short __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_max(vector signed short __a, vector bool short __b) {
   vector signed short __bc = (vector signed short)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_max(vector bool short __a, vector signed short __b) {
   vector signed short __ac = (vector signed short)__a;
 @@ -6460,12 +7691,14 @@ vec_max(vector unsigned short __a, vector unsigned short __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_max(vector unsigned short __a, vector bool short __b) {
   vector unsigned short __bc = (vector unsigned short)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_max(vector bool short __a, vector unsigned short __b) {
   vector unsigned short __ac = (vector unsigned short)__a;
 @@ -6477,12 +7710,14 @@ vec_max(vector signed int __a, vector signed int __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_max(vector signed int __a, vector bool int __b) {
   vector signed int __bc = (vector signed int)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_max(vector bool int __a, vector signed int __b) {
   vector signed int __ac = (vector signed int)__a;
 @@ -6494,12 +7729,14 @@ vec_max(vector unsigned int __a, vector unsigned int __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_max(vector unsigned int __a, vector bool int __b) {
   vector unsigned int __bc = (vector unsigned int)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_max(vector bool int __a, vector unsigned int __b) {
   vector unsigned int __ac = (vector unsigned int)__a;
 @@ -6511,12 +7748,14 @@ vec_max(vector signed long long __a, vector signed long long __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_max(vector signed long long __a, vector bool long long __b) {
   vector signed long long __bc = (vector signed long long)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_max(vector bool long long __a, vector signed long long __b) {
   vector signed long long __ac = (vector signed long long)__a;
 @@ -6528,21 +7767,34 @@ vec_max(vector unsigned long long __a, vector unsigned long long __b) {
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_max(vector unsigned long long __a, vector bool long long __b) {
   vector unsigned long long __bc = (vector unsigned long long)__b;
   return vec_sel(__bc, __a, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_max(vector bool long long __a, vector unsigned long long __b) {
   vector unsigned long long __ac = (vector unsigned long long)__a;
   return vec_sel(__b, __ac, vec_cmpgt(__ac, __b));
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_max(vector float __a, vector float __b) {
+  return __builtin_s390_vfmaxsb(__a, __b, 0);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_max(vector double __a, vector double __b) {
+#if __ARCH__ >= 12
+  return __builtin_s390_vfmaxdb(__a, __b, 0);
+#else
   return vec_sel(__b, __a, vec_cmpgt(__a, __b));
+#endif
 }
 /*-- vec_min ----------------------------------------------------------------*/
 @@ -6552,12 +7804,14 @@ vec_min(vector signed char __a, vector signed char __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_min(vector signed char __a, vector bool char __b) {
   vector signed char __bc = (vector signed char)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed char
 vec_min(vector bool char __a, vector signed char __b) {
   vector signed char __ac = (vector signed char)__a;
 @@ -6569,12 +7823,14 @@ vec_min(vector unsigned char __a, vector unsigned char __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_min(vector unsigned char __a, vector bool char __b) {
   vector unsigned char __bc = (vector unsigned char)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned char
 vec_min(vector bool char __a, vector unsigned char __b) {
   vector unsigned char __ac = (vector unsigned char)__a;
 @@ -6586,12 +7842,14 @@ vec_min(vector signed short __a, vector signed short __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_min(vector signed short __a, vector bool short __b) {
   vector signed short __bc = (vector signed short)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed short
 vec_min(vector bool short __a, vector signed short __b) {
   vector signed short __ac = (vector signed short)__a;
 @@ -6603,12 +7861,14 @@ vec_min(vector unsigned short __a, vector unsigned short __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_min(vector unsigned short __a, vector bool short __b) {
   vector unsigned short __bc = (vector unsigned short)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned short
 vec_min(vector bool short __a, vector unsigned short __b) {
   vector unsigned short __ac = (vector unsigned short)__a;
 @@ -6620,12 +7880,14 @@ vec_min(vector signed int __a, vector signed int __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_min(vector signed int __a, vector bool int __b) {
   vector signed int __bc = (vector signed int)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed int
 vec_min(vector bool int __a, vector signed int __b) {
   vector signed int __ac = (vector signed int)__a;
 @@ -6637,12 +7899,14 @@ vec_min(vector unsigned int __a, vector unsigned int __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_min(vector unsigned int __a, vector bool int __b) {
   vector unsigned int __bc = (vector unsigned int)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned int
 vec_min(vector bool int __a, vector unsigned int __b) {
   vector unsigned int __ac = (vector unsigned int)__a;
 @@ -6654,12 +7918,14 @@ vec_min(vector signed long long __a, vector signed long long __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_min(vector signed long long __a, vector bool long long __b) {
   vector signed long long __bc = (vector signed long long)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_min(vector bool long long __a, vector signed long long __b) {
   vector signed long long __ac = (vector signed long long)__a;
 @@ -6671,21 +7937,34 @@ vec_min(vector unsigned long long __a, vector unsigned long long __b) {
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_min(vector unsigned long long __a, vector bool long long __b) {
   vector unsigned long long __bc = (vector unsigned long long)__b;
   return vec_sel(__a, __bc, vec_cmpgt(__a, __bc));
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_min(vector bool long long __a, vector unsigned long long __b) {
   vector unsigned long long __ac = (vector unsigned long long)__a;
   return vec_sel(__ac, __b, vec_cmpgt(__ac, __b));
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_min(vector float __a, vector float __b) {
+  return __builtin_s390_vfminsb(__a, __b, 0);
+}
+#endif
 static inline __ATTRS_o_ai vector double
 vec_min(vector double __a, vector double __b) {
+#if __ARCH__ >= 12
+  return __builtin_s390_vfmindb(__a, __b, 0);
+#else
   return vec_sel(__a, __b, vec_cmpgt(__a, __b));
+#endif
 }
 /*-- vec_add_u128 -----------------------------------------------------------*/
 @@ -7126,6 +8405,13 @@ vec_mulo(vector unsigned int __a, vector unsigned int __b) {
   return __builtin_s390_vmlof(__a, __b);
 }
+/*-- vec_msum_u128 ----------------------------------------------------------*/
+#if __ARCH__ >= 12
+#define vec_msum_u128(X, Y, Z, W) \
+  ((vector unsigned char)__builtin_s390_vmslg((X), (Y), (Z), (W)));
+#endif
 /*-- vec_sub_u128 -----------------------------------------------------------*/
 static inline __ATTRS_ai vector unsigned char
 @@ -7263,6 +8549,14 @@ vec_test_mask(vector unsigned long long __a, vector unsigned long long __b) {
                             (vector unsigned char)__b);
 }
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai int
+vec_test_mask(vector float __a, vector unsigned int __b) {
+  return __builtin_s390_vtm((vector unsigned char)__a,
+                            (vector unsigned char)__b);
+}
+#endif
 static inline __ATTRS_o_ai int
 vec_test_mask(vector double __a, vector unsigned long long __b) {
   return __builtin_s390_vtm((vector unsigned char)__a,
 @@ -7271,27 +8565,77 @@ vec_test_mask(vector double __a, vector unsigned long long __b) {
 /*-- vec_madd ---------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_madd(vector float __a, vector float __b, vector float __c) {
+  return __builtin_s390_vfmasb(__a, __b, __c);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_madd(vector double __a, vector double __b, vector double __c) {
   return __builtin_s390_vfmadb(__a, __b, __c);
 }
 /*-- vec_msub ---------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_msub(vector float __a, vector float __b, vector float __c) {
+  return __builtin_s390_vfmssb(__a, __b, __c);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_msub(vector double __a, vector double __b, vector double __c) {
   return __builtin_s390_vfmsdb(__a, __b, __c);
 }
+/*-- vec_nmadd ---------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_nmadd(vector float __a, vector float __b, vector float __c) {
+  return __builtin_s390_vfnmasb(__a, __b, __c);
+}
+static inline __ATTRS_o_ai vector double
+vec_nmadd(vector double __a, vector double __b, vector double __c) {
+  return __builtin_s390_vfnmadb(__a, __b, __c);
+}
+#endif
+/*-- vec_nmsub ---------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_nmsub(vector float __a, vector float __b, vector float __c) {
+  return __builtin_s390_vfnmssb(__a, __b, __c);
+}
+static inline __ATTRS_o_ai vector double
+vec_nmsub(vector double __a, vector double __b, vector double __c) {
+  return __builtin_s390_vfnmsdb(__a, __b, __c);
+}
+#endif
 /*-- vec_sqrt ---------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_sqrt(vector float __a) {
+  return __builtin_s390_vfsqsb(__a);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_sqrt(vector double __a) {
   return __builtin_s390_vfsqdb(__a);
 }
 /*-- vec_ld2f ---------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_ai vector double
 vec_ld2f(const float *__ptr) {
   typedef float __v2f32 __attribute__((__vector_size__(8)));
 @@ -7300,6 +8644,7 @@ vec_ld2f(const float *__ptr) {
 /*-- vec_st2f ---------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_ai void
 vec_st2f(vector double __a, float *__ptr) {
   typedef float __v2f32 __attribute__((__vector_size__(8)));
 @@ -7308,6 +8653,7 @@ vec_st2f(vector double __a, float *__ptr) {
 /*-- vec_ctd ----------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector double
 vec_ctd(vector signed long long __a, int __b)
   __constant_range(__b, 0, 31) {
 @@ -7316,6 +8662,7 @@ vec_ctd(vector signed long long __a, int __b)
   return __conv;
 }
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector double
 vec_ctd(vector unsigned long long __a, int __b)
   __constant_range(__b, 0, 31) {
 @@ -7326,6 +8673,7 @@ vec_ctd(vector unsigned long long __a, int __b)
 /*-- vec_ctsl ---------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector signed long long
 vec_ctsl(vector double __a, int __b)
   __constant_range(__b, 0, 31) {
 @@ -7335,6 +8683,7 @@ vec_ctsl(vector double __a, int __b)
 /*-- vec_ctul ---------------------------------------------------------------*/
+// This prototype is deprecated.
 static inline __ATTRS_o_ai vector unsigned long long
 vec_ctul(vector double __a, int __b)
   __constant_range(__b, 0, 31) {
 @@ -7342,16 +8691,79 @@ vec_ctul(vector double __a, int __b)
   return __builtin_convertvector(__a, vector unsigned long long);
 }
-/*-- vec_roundp -------------------------------------------------------------*/
+/*-- vec_doublee ------------------------------------------------------------*/
+#if __ARCH__ >= 12
 static inline __ATTRS_ai vector double
+vec_doublee(vector float __a) {
+  typedef float __v2f32 __attribute__((__vector_size__(8)));
+  __v2f32 __pack = __builtin_shufflevector(__a, __a, 0, 2);
+  return __builtin_convertvector(__pack, vector double);
+}
+#endif
+/*-- vec_floate -------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_ai vector float
+vec_floate(vector double __a) {
+  typedef float __v2f32 __attribute__((__vector_size__(8)));
+  __v2f32 __pack = __builtin_convertvector(__a, __v2f32);
+  return __builtin_shufflevector(__pack, __pack, 0, -1, 1, -1);
+}
+#endif
+/*-- vec_double -------------------------------------------------------------*/
+static inline __ATTRS_o_ai vector double
+vec_double(vector signed long long __a) {
+  return __builtin_convertvector(__a, vector double);
+}
+static inline __ATTRS_o_ai vector double
+vec_double(vector unsigned long long __a) {
+  return __builtin_convertvector(__a, vector double);
+}
+/*-- vec_signed -------------------------------------------------------------*/
+static inline __ATTRS_o_ai vector signed long long
+vec_signed(vector double __a) {
+  return __builtin_convertvector(__a, vector signed long long);
+}
+/*-- vec_unsigned -----------------------------------------------------------*/
+static inline __ATTRS_o_ai vector unsigned long long
+vec_unsigned(vector double __a) {
+  return __builtin_convertvector(__a, vector unsigned long long);
+}
+/*-- vec_roundp -------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_roundp(vector float __a) {
+  return __builtin_s390_vfisb(__a, 4, 6);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_roundp(vector double __a) {
   return __builtin_s390_vfidb(__a, 4, 6);
 }
 /*-- vec_ceil ---------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_ceil(vector float __a) {
+  // On this platform, vec_ceil never triggers the IEEE-inexact exception.
+  return __builtin_s390_vfisb(__a, 4, 6);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_ceil(vector double __a) {
   // On this platform, vec_ceil never triggers the IEEE-inexact exception.
   return __builtin_s390_vfidb(__a, 4, 6);
 @@ -7359,14 +8771,29 @@ vec_ceil(vector double __a) {
 /*-- vec_roundm -------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_roundm(vector float __a) {
+  return __builtin_s390_vfisb(__a, 4, 7);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_roundm(vector double __a) {
   return __builtin_s390_vfidb(__a, 4, 7);
 }
 /*-- vec_floor --------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_floor(vector float __a) {
+  // On this platform, vec_floor never triggers the IEEE-inexact exception.
+  return __builtin_s390_vfisb(__a, 4, 7);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_floor(vector double __a) {
   // On this platform, vec_floor never triggers the IEEE-inexact exception.
   return __builtin_s390_vfidb(__a, 4, 7);
 @@ -7374,14 +8801,29 @@ vec_floor(vector double __a) {
 /*-- vec_roundz -------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_roundz(vector float __a) {
+  return __builtin_s390_vfisb(__a, 4, 5);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_roundz(vector double __a) {
   return __builtin_s390_vfidb(__a, 4, 5);
 }
 /*-- vec_trunc --------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_trunc(vector float __a) {
+  // On this platform, vec_trunc never triggers the IEEE-inexact exception.
+  return __builtin_s390_vfisb(__a, 4, 5);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_trunc(vector double __a) {
   // On this platform, vec_trunc never triggers the IEEE-inexact exception.
   return __builtin_s390_vfidb(__a, 4, 5);
 @@ -7389,22 +8831,104 @@ vec_trunc(vector double __a) {
 /*-- vec_roundc -------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_roundc(vector float __a) {
+  return __builtin_s390_vfisb(__a, 4, 0);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_roundc(vector double __a) {
   return __builtin_s390_vfidb(__a, 4, 0);
 }
+/*-- vec_rint ---------------------------------------------------------------*/
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_rint(vector float __a) {
+  // vec_rint may trigger the IEEE-inexact exception.
+  return __builtin_s390_vfisb(__a, 0, 0);
+}
+#endif
+static inline __ATTRS_o_ai vector double
+vec_rint(vector double __a) {
+  // vec_rint may trigger the IEEE-inexact exception.
+  return __builtin_s390_vfidb(__a, 0, 0);
+}
 /*-- vec_round --------------------------------------------------------------*/
-static inline __ATTRS_ai vector double
+#if __ARCH__ >= 12
+static inline __ATTRS_o_ai vector float
+vec_round(vector float __a) {
+  return __builtin_s390_vfisb(__a, 4, 4);
+}
+#endif
+static inline __ATTRS_o_ai vector double
 vec_round(vector double __a) {
   return __builtin_s390_vfidb(__a, 4, 4);
 }
 /*-- vec_fp_test_data_class -------------------------------------------------*/
+#if __ARCH__ >= 12
+extern __ATTRS_o vector bool int
+vec_fp_test_data_class(vector float __a, int __b, int *__c)
+  __constant_range(__b, 0, 4095);
+extern __ATTRS_o vector bool long long
+vec_fp_test_data_class(vector double __a, int __b, int *__c)
+  __constant_range(__b, 0, 4095);
+#define vec_fp_test_data_class(X, Y, Z) \
+  ((__typeof__((vec_fp_test_data_class)((X), (Y), (Z)))) \
+   __extension__ ({ \
+     vector unsigned char __res; \
+     vector unsigned char __x = (vector unsigned char)(X); \
+     int *__z = (Z); \
+     switch (sizeof ((X)[0])) { \
+     case 4:  __res = (vector unsigned char) \
+                      __builtin_s390_vftcisb((vector float)__x, (Y), __z); \
+              break; \
+     default: __res = (vector unsigned char) \
+                      __builtin_s390_vftcidb((vector double)__x, (Y), __z); \
+              break; \
+     } __res; }))
+#else
 #define vec_fp_test_data_class(X, Y, Z) \
   ((vector bool long long)__builtin_s390_vftcidb((X), (Y), (Z)))
+#endif
+#define __VEC_CLASS_FP_ZERO_P (1 << 11)
+#define __VEC_CLASS_FP_ZERO_N (1 << 10)
+#define __VEC_CLASS_FP_ZERO (__VEC_CLASS_FP_ZERO_P | __VEC_CLASS_FP_ZERO_N)
+#define __VEC_CLASS_FP_NORMAL_P (1 << 9)
+#define __VEC_CLASS_FP_NORMAL_N (1 << 8)
+#define __VEC_CLASS_FP_NORMAL (__VEC_CLASS_FP_NORMAL_P | \
+                               __VEC_CLASS_FP_NORMAL_N)
+#define __VEC_CLASS_FP_SUBNORMAL_P (1 << 7)
+#define __VEC_CLASS_FP_SUBNORMAL_N (1 << 6)
+#define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | \
+                                  __VEC_CLASS_FP_SUBNORMAL_N)
+#define __VEC_CLASS_FP_INFINITY_P (1 << 5)
+#define __VEC_CLASS_FP_INFINITY_N (1 << 4)
+#define __VEC_CLASS_FP_INFINITY (__VEC_CLASS_FP_INFINITY_P | \
+                                 __VEC_CLASS_FP_INFINITY_N)
+#define __VEC_CLASS_FP_QNAN_P (1 << 3)
+#define __VEC_CLASS_FP_QNAN_N (1 << 2)
+#define __VEC_CLASS_FP_QNAN (__VEC_CLASS_FP_QNAN_P | __VEC_CLASS_FP_QNAN_N)
+#define __VEC_CLASS_FP_SNAN_P (1 << 1)
+#define __VEC_CLASS_FP_SNAN_N (1 << 0)
+#define __VEC_CLASS_FP_SNAN (__VEC_CLASS_FP_SNAN_P | __VEC_CLASS_FP_SNAN_N)
+#define __VEC_CLASS_FP_NAN (__VEC_CLASS_FP_QNAN | __VEC_CLASS_FP_SNAN)
+#define __VEC_CLASS_FP_NOT_NORMAL (__VEC_CLASS_FP_NAN | \
+                                   __VEC_CLASS_FP_SUBNORMAL | \
+                                   __VEC_CLASS_FP_ZERO | \
+                                   __VEC_CLASS_FP_INFINITY)
 /*-- vec_cp_until_zero ------------------------------------------------------*/

c_headers/x86intrin.h+7-1

 @@ -72,6 +72,10 @@
 #include <tbmintrin.h>
 #endif
+#if !defined(_MSC_VER) || __has_feature(modules) || defined(__LWP__)
+#include <lwpintrin.h>
+#endif
 #if !defined(_MSC_VER) || __has_feature(modules) || defined(__F16C__)
 #include <f16cintrin.h>
 #endif
 @@ -80,6 +84,8 @@
 #include <mwaitxintrin.h>
 #endif
-/* FIXME: LWP */
+#if !defined(_MSC_VER) || __has_feature(modules) || defined(__CLZERO__)
+#include <clzerointrin.h>
+#endif
 #endif /* __X86INTRIN_H */

c_headers/xmmintrin.h+34-37

 @@ -2067,7 +2067,7 @@ _mm_storer_ps(float *__p, __m128 __a)
 ///    _MM_HINT_T1: Move data using the T1 hint. The PREFETCHT1 instruction will
 ///    be generated. \n
 ///    _MM_HINT_T2: Move data using the T2 hint. The PREFETCHT2 instruction will
 ///    be generated.
 #define _mm_prefetch(a, sel) (__builtin_prefetch((void *)(a), 0, (sel)))
 #endif
 @@ -2099,7 +2099,7 @@ _mm_stream_pi(__m64 *__p, __m64 __a)
 ///
 /// \param __p
 ///    A pointer to a 128-bit aligned memory location that will receive the
-///    integer values.
+///    single-precision floating-point values.
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing the values to be moved.
 static __inline__ void __DEFAULT_FN_ATTRS
 @@ -2133,7 +2133,7 @@ void _mm_sfence(void);
 /// \headerfile <x86intrin.h>
 ///
 /// \code
-/// void _mm_extract_pi(__m64 a, int n);
+/// int _mm_extract_pi16(__m64 a, int n);
 /// \endcode
 ///
 /// This intrinsic corresponds to the <c> VPEXTRW / PEXTRW </c> instruction.
 @@ -2157,7 +2157,7 @@ void _mm_sfence(void);
 /// \headerfile <x86intrin.h>
 ///
 /// \code
-/// void _mm_insert_pi(__m64 a, int d, int n);
+/// __m64 _mm_insert_pi16(__m64 a, int d, int n);
 /// \endcode
 ///
 /// This intrinsic corresponds to the <c> VPINSRW / PINSRW </c> instruction.
 @@ -2331,8 +2331,10 @@ _mm_mulhi_pu16(__m64 __a, __m64 __b)
 /// \brief Conditionally copies the values from each 8-bit element in the first
 ///    64-bit integer vector operand to the specified memory location, as
 ///    specified by the most significant bit in the corresponding element in the
-///    second 64-bit integer vector operand. To minimize caching, the data is
+///    second 64-bit integer vector operand.
-///    flagged as non-temporal (unlikely to be used again soon).
+///
+///    To minimize caching, the data is flagged as non-temporal
+///    (unlikely to be used again soon).
 ///
 /// \headerfile <x86intrin.h>
 ///
 @@ -2435,17 +2437,17 @@ extern "C" {
 ///      For checking exception masks: _MM_MASK_UNDERFLOW, _MM_MASK_OVERFLOW,
 ///      _MM_MASK_INVALID, _MM_MASK_DENORM, _MM_MASK_DIV_ZERO, _MM_MASK_INEXACT.
 ///      There is a convenience wrapper _MM_GET_EXCEPTION_MASK().
 ///    </li>
 ///    <li>
 ///      For checking rounding modes: _MM_ROUND_NEAREST, _MM_ROUND_DOWN,
 ///      _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO. There is a convenience wrapper
 ///      _MM_GET_ROUNDING_MODE(x) where x is one of these macros.
 ///    </li>
 ///    <li>
 ///      For checking flush-to-zero mode: _MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_OFF.
 ///      There is a convenience wrapper _MM_GET_FLUSH_ZERO_MODE().
 ///    </li>
 ///    <li>
 ///      For checking denormals-are-zero mode: _MM_DENORMALS_ZERO_ON,
 ///      _MM_DENORMALS_ZERO_OFF. There is a convenience wrapper
 ///      _MM_GET_DENORMALS_ZERO_MODE().
 @@ -2468,11 +2470,11 @@ extern "C" {
 unsigned int _mm_getcsr(void);
 /// \brief Sets the MXCSR register with the 32-bit unsigned integer value.
 ///
 ///    There are several groups of macros associated with this intrinsic,
 ///    including:
 ///    <ul>
 ///    <li>
 ///      For setting exception states: _MM_EXCEPT_INVALID, _MM_EXCEPT_DIV_ZERO,
 ///      _MM_EXCEPT_DENORM, _MM_EXCEPT_OVERFLOW, _MM_EXCEPT_UNDERFLOW,
 ///      _MM_EXCEPT_INEXACT. There is a convenience wrapper
 @@ -2517,7 +2519,7 @@ unsigned int _mm_getcsr(void);
 ///
 /// \param __i
 ///    A 32-bit unsigned integer value to be written to the MXCSR register.
-void _mm_setcsr(unsigned int);
+void _mm_setcsr(unsigned int __i);
 #if defined(__cplusplus)
 } // extern "C"
 @@ -2540,7 +2542,7 @@ void _mm_setcsr(unsigned int);
 ///    A 128-bit vector of [4 x float].
 /// \param mask
 ///    An immediate value containing an 8-bit value specifying which elements to
-///    copy from \ a and \a b. \n
+///    copy from \a a and \a b. \n
 ///    Bits [3:0] specify the values copied from operand \a a. \n
 ///    Bits [7:4] specify the values copied from operand \a b. \n
 ///    The destinations within the 128-bit destination are assigned values as
 @@ -2678,8 +2680,7 @@ _mm_movelh_ps(__m128 __a, __m128 __b)
 ///
 /// \headerfile <x86intrin.h>
 ///
-/// This intrinsic corresponds to the <c> CVTPI2PS + \c COMPOSITE </c>
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
-///   instruction.
 ///
 /// \param __a
 ///    A 64-bit vector of [4 x i16]. The elements of the destination are copied
 @@ -2709,8 +2710,7 @@ _mm_cvtpi16_ps(__m64 __a)
 ///
 /// \headerfile <x86intrin.h>
 ///
-/// This intrinsic corresponds to the <c> CVTPI2PS + \c COMPOSITE </c>
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
-///   instruction.
 ///
 /// \param __a
 ///    A 64-bit vector of 16-bit unsigned integer values. The elements of the
 @@ -2739,8 +2739,7 @@ _mm_cvtpu16_ps(__m64 __a)
 ///
 /// \headerfile <x86intrin.h>
 ///
-/// This intrinsic corresponds to the <c> CVTPI2PS + \c COMPOSITE </c>
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
-///   instruction.
 ///
 /// \param __a
 ///    A 64-bit vector of [8 x i8]. The elements of the destination are copied
 @@ -2764,8 +2763,7 @@ _mm_cvtpi8_ps(__m64 __a)
 ///
 /// \headerfile <x86intrin.h>
 ///
-/// This intrinsic corresponds to the <c> CVTPI2PS + \c COMPOSITE </c>
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
-///   instruction.
 ///
 /// \param __a
 ///    A 64-bit vector of unsigned 8-bit integer values. The elements of the
 @@ -2789,8 +2787,7 @@ _mm_cvtpu8_ps(__m64 __a)
 ///
 /// \headerfile <x86intrin.h>
 ///
-/// This intrinsic corresponds to the <c> CVTPI2PS + \c COMPOSITE </c>
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
-///   instruction.
 ///
 /// \param __a
 ///    A 64-bit vector of [2 x i32]. The lower elements of the destination are
 @@ -2815,16 +2812,16 @@ _mm_cvtpi32x2_ps(__m64 __a, __m64 __b)
 /// \brief Converts each single-precision floating-point element of a 128-bit
 ///    floating-point vector of [4 x float] into a 16-bit signed integer, and
-///    packs the results into a 64-bit integer vector of [4 x i16]. If the
+///    packs the results into a 64-bit integer vector of [4 x i16].
-///    floating-point element is NaN or infinity, or if the floating-point
+///
-///    element is greater than 0x7FFFFFFF or less than -0x8000, it is converted
+///    If the floating-point element is NaN or infinity, or if the
-///    to 0x8000. Otherwise if the floating-point element is greater than
+///    floating-point element is greater than 0x7FFFFFFF or less than -0x8000,
-///    0x7FFF, it is converted to 0x7FFF.
+///    it is converted to 0x8000. Otherwise if the floating-point element is
+///    greater than 0x7FFF, it is converted to 0x7FFF.
 ///
 /// \headerfile <x86intrin.h>
 ///
-/// This intrinsic corresponds to the <c> CVTPS2PI + \c COMPOSITE </c>
+/// This intrinsic corresponds to the <c> CVTPS2PI + COMPOSITE </c> instruction.
-///   instruction.
 ///
 /// \param __a
 ///    A 128-bit floating-point vector of [4 x float].
 @@ -2845,16 +2842,16 @@ _mm_cvtps_pi16(__m128 __a)
 /// \brief Converts each single-precision floating-point element of a 128-bit
 ///    floating-point vector of [4 x float] into an 8-bit signed integer, and
 ///    packs the results into the lower 32 bits of a 64-bit integer vector of
-///    [8 x i8]. The upper 32 bits of the vector are set to 0. If the
+///    [8 x i8]. The upper 32 bits of the vector are set to 0.
-///    floating-point element is NaN or infinity, or if the floating-point
+///
-///    element is greater than 0x7FFFFFFF or less than -0x80, it is converted
+///    If the floating-point element is NaN or infinity, or if the
-///    to 0x80. Otherwise if the floating-point element is greater than 0x7F,
+///    floating-point element is greater than 0x7FFFFFFF or less than -0x80, it
-///    it is converted to 0x7F.
+///    is converted to 0x80. Otherwise if the floating-point element is greater
+///    than 0x7F, it is converted to 0x7F.
 ///
 /// \headerfile <x86intrin.h>
 ///
-/// This intrinsic corresponds to the <c> CVTPS2PI + \c COMPOSITE </c>
+/// This intrinsic corresponds to the <c> CVTPS2PI + COMPOSITE </c> instruction.
-///   instruction.
 ///
 /// \param __a
 ///    128-bit floating-point vector of [4 x float].

c_headers/xopintrin.h+2-2

...	@@ -198,13 +198,13 @@ _mm_hsubq_epi32(__m128i __A)	...	@@ -198,13 +198,13 @@ _mm_hsubq_epi32(__m128i __A)
198	static __inline__ __m128i __DEFAULT_FN_ATTRS	198	static __inline__ __m128i __DEFAULT_FN_ATTRS
199	_mm_cmov_si128(__m128i __A, __m128i __B, __m128i __C)	199	_mm_cmov_si128(__m128i __A, __m128i __B, __m128i __C)
200	{	200	{
201	return (__m128i)__builtin_ia32_vpcmov((__v2di)__A, (__v2di)__B, (__v2di)__C);	201	return (__m128i)(((__v2du)__A & (__v2du)__C) \| ((__v2du)__B & ~(__v2du)__C));
202	}	202	}
203		203
204	static __inline__ __m256i __DEFAULT_FN_ATTRS	204	static __inline__ __m256i __DEFAULT_FN_ATTRS
205	_mm256_cmov_si256(__m256i __A, __m256i __B, __m256i __C)	205	_mm256_cmov_si256(__m256i __A, __m256i __B, __m256i __C)
206	{	206	{
207	return (__m256i)__builtin_ia32_vpcmov_256((__v4di)__A, (__v4di)__B, (__v4di)__C);	207	return (__m256i)(((__v4du)__A & (__v4du)__C) \| ((__v4du)__B & ~(__v4du)__C));
208	}	208	}
209		209
210	static __inline__ __m128i __DEFAULT_FN_ATTRS	210	static __inline__ __m128i __DEFAULT_FN_ATTRS

doc/targets.md+1-1

...	@@ -2,7 +2,7 @@	...	@@ -2,7 +2,7 @@
2		2
3	Create bootstrap code in std/bootstrap.zig and add conditional compilation	3	Create bootstrap code in std/bootstrap.zig and add conditional compilation
4	logic. This code is responsible for the real executable entry point, calling	4	logic. This code is responsible for the real executable entry point, calling
5	main(argc, argv, env) and making the exit syscall when main returns.	5	main() and making the exit syscall when main returns.
6		6
7	How to pass a byvalue struct parameter in the C calling convention is	7	How to pass a byvalue struct parameter in the C calling convention is
8	target-specific. Add logic for how to do function prototypes and function calls	8	target-specific. Add logic for how to do function prototypes and function calls

...	@@ -72,9 +72,9 @@ _cvtsh_ss(unsigned short __a)	...	@@ -72,9 +72,9 @@ _cvtsh_ss(unsigned short __a)
72	/// 011: Truncate \n	72	/// 011: Truncate \n
73	/// 1XX: Use MXCSR.RC for rounding	73	/// 1XX: Use MXCSR.RC for rounding
74	/// \returns The converted 16-bit half-precision float value.	74	/// \returns The converted 16-bit half-precision float value.
75	#define _cvtss_sh(a, imm) \	75	#define _cvtss_sh(a, imm) __extension__ ({ \
76	((unsigned short)(((__v8hi)__builtin_ia32_vcvtps2ph((__v4sf){a, 0, 0, 0}, \	76	(unsigned short)(((__v8hi)__builtin_ia32_vcvtps2ph((__v4sf){a, 0, 0, 0}, \
77	(imm)))[0]))	77	(imm)))[0]); })
78		78
79	/// \brief Converts a 128-bit vector containing 32-bit float values into a	79	/// \brief Converts a 128-bit vector containing 32-bit float values into a
80	/// 128-bit vector containing 16-bit half-precision float values.	80	/// 128-bit vector containing 16-bit half-precision float values.
...	@@ -99,8 +99,8 @@ _cvtsh_ss(unsigned short __a)	...	@@ -99,8 +99,8 @@ _cvtsh_ss(unsigned short __a)
99	/// \returns A 128-bit vector containing converted 16-bit half-precision float	99	/// \returns A 128-bit vector containing converted 16-bit half-precision float
100	/// values. The lower 64 bits are used to store the converted 16-bit	100	/// values. The lower 64 bits are used to store the converted 16-bit
101	/// half-precision floating-point values.	101	/// half-precision floating-point values.
102	#define _mm_cvtps_ph(a, imm) \	102	#define _mm_cvtps_ph(a, imm) __extension__ ({ \
103	((__m128i)__builtin_ia32_vcvtps2ph((__v4sf)(__m128)(a), (imm)))	103	(__m128i)__builtin_ia32_vcvtps2ph((__v4sf)(__m128)(a), (imm)); })
104		104
105	/// \brief Converts a 128-bit vector containing 16-bit half-precision float	105	/// \brief Converts a 128-bit vector containing 16-bit half-precision float
106	/// values into a 128-bit vector containing 32-bit float values.	106	/// values into a 128-bit vector containing 32-bit float values.