WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/lib/clang/16/include/wasm_simd128.h

Rev	Author	Line No.	Line
14	pmbaty	1	/*===---- wasm_simd128.h - WebAssembly portable SIMD intrinsics ------------===
		2	*
		3	* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
		4	* See https://llvm.org/LICENSE.txt for license information.
		5	* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
		6	*
		7	*===-----------------------------------------------------------------------===
		8	*/
		9
		10	#ifndef __WASM_SIMD128_H
		11	#define __WASM_SIMD128_H
		12
		13	#include <stdbool.h>
		14	#include <stdint.h>
		15
		16	// User-facing type
		17	typedef int32_t v128_t __attribute__((__vector_size__(16), __aligned__(16)));
		18
		19	// Internal types determined by clang builtin definitions
		20	typedef int32_t __v128_u __attribute__((__vector_size__(16), __aligned__(1)));
		21	typedef signed char __i8x16
		22	__attribute__((__vector_size__(16), __aligned__(16)));
		23	typedef unsigned char __u8x16
		24	__attribute__((__vector_size__(16), __aligned__(16)));
		25	typedef short __i16x8 __attribute__((__vector_size__(16), __aligned__(16)));
		26	typedef unsigned short __u16x8
		27	__attribute__((__vector_size__(16), __aligned__(16)));
		28	typedef int __i32x4 __attribute__((__vector_size__(16), __aligned__(16)));
		29	typedef unsigned int __u32x4
		30	__attribute__((__vector_size__(16), __aligned__(16)));
		31	typedef long long __i64x2 __attribute__((__vector_size__(16), __aligned__(16)));
		32	typedef unsigned long long __u64x2
		33	__attribute__((__vector_size__(16), __aligned__(16)));
		34	typedef float __f32x4 __attribute__((__vector_size__(16), __aligned__(16)));
		35	typedef double __f64x2 __attribute__((__vector_size__(16), __aligned__(16)));
		36
		37	typedef signed char __i8x8 __attribute__((__vector_size__(8), __aligned__(8)));
		38	typedef unsigned char __u8x8
		39	__attribute__((__vector_size__(8), __aligned__(8)));
		40	typedef short __i16x4 __attribute__((__vector_size__(8), __aligned__(8)));
		41	typedef unsigned short __u16x4
		42	__attribute__((__vector_size__(8), __aligned__(8)));
		43	typedef int __i32x2 __attribute__((__vector_size__(8), __aligned__(8)));
		44	typedef unsigned int __u32x2
		45	__attribute__((__vector_size__(8), __aligned__(8)));
		46	typedef float __f32x2 __attribute__((__vector_size__(8), __aligned__(8)));
		47
		48	#define __DEFAULT_FN_ATTRS \
		49	__attribute__((__always_inline__, __nodebug__, __target__("simd128"), \
		50	__min_vector_width__(128)))
		51
		52	#define __REQUIRE_CONSTANT(c) \
		53	__attribute__((__diagnose_if__(!__builtin_constant_p(c), \
		54	#c " must be constant", "error")))
		55
		56	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_load(const void *__mem) {
		57	// UB-free unaligned access copied from xmmintrin.h
		58	struct __wasm_v128_load_struct {
		59	__v128_u __v;
		60	} __attribute__((__packed__, __may_alias__));
		61	return ((const struct __wasm_v128_load_struct *)__mem)->__v;
		62	}
		63
		64	static __inline__ v128_t __DEFAULT_FN_ATTRS
		65	wasm_v128_load8_splat(const void *__mem) {
		66	struct __wasm_v128_load8_splat_struct {
		67	uint8_t __v;
		68	} __attribute__((__packed__, __may_alias__));
		69	uint8_t __v = ((const struct __wasm_v128_load8_splat_struct *)__mem)->__v;
		70	return (v128_t)(__u8x16){__v, __v, __v, __v, __v, __v, __v, __v,
		71	__v, __v, __v, __v, __v, __v, __v, __v};
		72	}
		73
		74	static __inline__ v128_t __DEFAULT_FN_ATTRS
		75	wasm_v128_load16_splat(const void *__mem) {
		76	struct __wasm_v128_load16_splat_struct {
		77	uint16_t __v;
		78	} __attribute__((__packed__, __may_alias__));
		79	uint16_t __v = ((const struct __wasm_v128_load16_splat_struct *)__mem)->__v;
		80	return (v128_t)(__u16x8){__v, __v, __v, __v, __v, __v, __v, __v};
		81	}
		82
		83	static __inline__ v128_t __DEFAULT_FN_ATTRS
		84	wasm_v128_load32_splat(const void *__mem) {
		85	struct __wasm_v128_load32_splat_struct {
		86	uint32_t __v;
		87	} __attribute__((__packed__, __may_alias__));
		88	uint32_t __v = ((const struct __wasm_v128_load32_splat_struct *)__mem)->__v;
		89	return (v128_t)(__u32x4){__v, __v, __v, __v};
		90	}
		91
		92	static __inline__ v128_t __DEFAULT_FN_ATTRS
		93	wasm_v128_load64_splat(const void *__mem) {
		94	struct __wasm_v128_load64_splat_struct {
		95	uint64_t __v;
		96	} __attribute__((__packed__, __may_alias__));
		97	uint64_t __v = ((const struct __wasm_v128_load64_splat_struct *)__mem)->__v;
		98	return (v128_t)(__u64x2){__v, __v};
		99	}
		100
		101	static __inline__ v128_t __DEFAULT_FN_ATTRS
		102	wasm_i16x8_load8x8(const void *__mem) {
		103	struct __wasm_i16x8_load8x8_struct {
		104	__i8x8 __v;
		105	} __attribute__((__packed__, __may_alias__));
		106	__i8x8 __v = ((const struct __wasm_i16x8_load8x8_struct *)__mem)->__v;
		107	return (v128_t) __builtin_convertvector(__v, __i16x8);
		108	}
		109
		110	static __inline__ v128_t __DEFAULT_FN_ATTRS
		111	wasm_u16x8_load8x8(const void *__mem) {
		112	struct __wasm_u16x8_load8x8_struct {
		113	__u8x8 __v;
		114	} __attribute__((__packed__, __may_alias__));
		115	__u8x8 __v = ((const struct __wasm_u16x8_load8x8_struct *)__mem)->__v;
		116	return (v128_t) __builtin_convertvector(__v, __u16x8);
		117	}
		118
		119	static __inline__ v128_t __DEFAULT_FN_ATTRS
		120	wasm_i32x4_load16x4(const void *__mem) {
		121	struct __wasm_i32x4_load16x4_struct {
		122	__i16x4 __v;
		123	} __attribute__((__packed__, __may_alias__));
		124	__i16x4 __v = ((const struct __wasm_i32x4_load16x4_struct *)__mem)->__v;
		125	return (v128_t) __builtin_convertvector(__v, __i32x4);
		126	}
		127
		128	static __inline__ v128_t __DEFAULT_FN_ATTRS
		129	wasm_u32x4_load16x4(const void *__mem) {
		130	struct __wasm_u32x4_load16x4_struct {
		131	__u16x4 __v;
		132	} __attribute__((__packed__, __may_alias__));
		133	__u16x4 __v = ((const struct __wasm_u32x4_load16x4_struct *)__mem)->__v;
		134	return (v128_t) __builtin_convertvector(__v, __u32x4);
		135	}
		136
		137	static __inline__ v128_t __DEFAULT_FN_ATTRS
		138	wasm_i64x2_load32x2(const void *__mem) {
		139	struct __wasm_i64x2_load32x2_struct {
		140	__i32x2 __v;
		141	} __attribute__((__packed__, __may_alias__));
		142	__i32x2 __v = ((const struct __wasm_i64x2_load32x2_struct *)__mem)->__v;
		143	return (v128_t) __builtin_convertvector(__v, __i64x2);
		144	}
		145
		146	static __inline__ v128_t __DEFAULT_FN_ATTRS
		147	wasm_u64x2_load32x2(const void *__mem) {
		148	struct __wasm_u64x2_load32x2_struct {
		149	__u32x2 __v;
		150	} __attribute__((__packed__, __may_alias__));
		151	__u32x2 __v = ((const struct __wasm_u64x2_load32x2_struct *)__mem)->__v;
		152	return (v128_t) __builtin_convertvector(__v, __u64x2);
		153	}
		154
		155	static __inline__ v128_t __DEFAULT_FN_ATTRS
		156	wasm_v128_load32_zero(const void *__mem) {
		157	struct __wasm_v128_load32_zero_struct {
		158	int32_t __v;
		159	} __attribute__((__packed__, __may_alias__));
		160	int32_t __v = ((const struct __wasm_v128_load32_zero_struct *)__mem)->__v;
		161	return (v128_t)(__i32x4){__v, 0, 0, 0};
		162	}
		163
		164	static __inline__ v128_t __DEFAULT_FN_ATTRS
		165	wasm_v128_load64_zero(const void *__mem) {
		166	struct __wasm_v128_load64_zero_struct {
		167	int64_t __v;
		168	} __attribute__((__packed__, __may_alias__));
		169	int64_t __v = ((const struct __wasm_v128_load64_zero_struct *)__mem)->__v;
		170	return (v128_t)(__i64x2){__v, 0};
		171	}
		172
		173	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_load8_lane(
		174	const void *__mem, v128_t __vec, int __i) __REQUIRE_CONSTANT(__i) {
		175	struct __wasm_v128_load8_lane_struct {
		176	int8_t __v;
		177	} __attribute__((__packed__, __may_alias__));
		178	int8_t __v = ((const struct __wasm_v128_load8_lane_struct *)__mem)->__v;
		179	__i8x16 __ret = (__i8x16)__vec;
		180	__ret[__i] = __v;
		181	return (v128_t)__ret;
		182	}
		183
		184	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_load16_lane(
		185	const void *__mem, v128_t __vec, int __i) __REQUIRE_CONSTANT(__i) {
		186	struct __wasm_v128_load16_lane_struct {
		187	int16_t __v;
		188	} __attribute__((__packed__, __may_alias__));
		189	int16_t __v = ((const struct __wasm_v128_load16_lane_struct *)__mem)->__v;
		190	__i16x8 __ret = (__i16x8)__vec;
		191	__ret[__i] = __v;
		192	return (v128_t)__ret;
		193	}
		194
		195	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_load32_lane(
		196	const void *__mem, v128_t __vec, int __i) __REQUIRE_CONSTANT(__i) {
		197	struct __wasm_v128_load32_lane_struct {
		198	int32_t __v;
		199	} __attribute__((__packed__, __may_alias__));
		200	int32_t __v = ((const struct __wasm_v128_load32_lane_struct *)__mem)->__v;
		201	__i32x4 __ret = (__i32x4)__vec;
		202	__ret[__i] = __v;
		203	return (v128_t)__ret;
		204	}
		205
		206	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_load64_lane(
		207	const void *__mem, v128_t __vec, int __i) __REQUIRE_CONSTANT(__i) {
		208	struct __wasm_v128_load64_lane_struct {
		209	int64_t __v;
		210	} __attribute__((__packed__, __may_alias__));
		211	int64_t __v = ((const struct __wasm_v128_load64_lane_struct *)__mem)->__v;
		212	__i64x2 __ret = (__i64x2)__vec;
		213	__ret[__i] = __v;
		214	return (v128_t)__ret;
		215	}
		216
		217	static __inline__ void __DEFAULT_FN_ATTRS wasm_v128_store(void *__mem,
		218	v128_t __a) {
		219	// UB-free unaligned access copied from xmmintrin.h
		220	struct __wasm_v128_store_struct {
		221	__v128_u __v;
		222	} __attribute__((__packed__, __may_alias__));
		223	((struct __wasm_v128_store_struct *)__mem)->__v = __a;
		224	}
		225
		226	static __inline__ void __DEFAULT_FN_ATTRS wasm_v128_store8_lane(void *__mem,
		227	v128_t __vec,
		228	int __i)
		229	__REQUIRE_CONSTANT(__i) {
		230	struct __wasm_v128_store8_lane_struct {
		231	int8_t __v;
		232	} __attribute__((__packed__, __may_alias__));
		233	((struct __wasm_v128_store8_lane_struct *)__mem)->__v = ((__i8x16)__vec)[__i];
		234	}
		235
		236	static __inline__ void __DEFAULT_FN_ATTRS wasm_v128_store16_lane(void *__mem,
		237	v128_t __vec,
		238	int __i)
		239	__REQUIRE_CONSTANT(__i) {
		240	struct __wasm_v128_store16_lane_struct {
		241	int16_t __v;
		242	} __attribute__((__packed__, __may_alias__));
		243	((struct __wasm_v128_store16_lane_struct *)__mem)->__v =
		244	((__i16x8)__vec)[__i];
		245	}
		246
		247	static __inline__ void __DEFAULT_FN_ATTRS wasm_v128_store32_lane(void *__mem,
		248	v128_t __vec,
		249	int __i)
		250	__REQUIRE_CONSTANT(__i) {
		251	struct __wasm_v128_store32_lane_struct {
		252	int32_t __v;
		253	} __attribute__((__packed__, __may_alias__));
		254	((struct __wasm_v128_store32_lane_struct *)__mem)->__v =
		255	((__i32x4)__vec)[__i];
		256	}
		257
		258	static __inline__ void __DEFAULT_FN_ATTRS wasm_v128_store64_lane(void *__mem,
		259	v128_t __vec,
		260	int __i)
		261	__REQUIRE_CONSTANT(__i) {
		262	struct __wasm_v128_store64_lane_struct {
		263	int64_t __v;
		264	} __attribute__((__packed__, __may_alias__));
		265	((struct __wasm_v128_store64_lane_struct *)__mem)->__v =
		266	((__i64x2)__vec)[__i];
		267	}
		268
		269	static __inline__ v128_t __DEFAULT_FN_ATTRS
		270	wasm_i8x16_make(int8_t __c0, int8_t __c1, int8_t __c2, int8_t __c3, int8_t __c4,
		271	int8_t __c5, int8_t __c6, int8_t __c7, int8_t __c8, int8_t __c9,
		272	int8_t __c10, int8_t __c11, int8_t __c12, int8_t __c13,
		273	int8_t __c14, int8_t __c15) {
		274	return (v128_t)(__i8x16){__c0, __c1, __c2, __c3, __c4, __c5,
		275	__c6, __c7, __c8, __c9, __c10, __c11,
		276	__c12, __c13, __c14, __c15};
		277	}
		278
		279	static __inline__ v128_t __DEFAULT_FN_ATTRS
		280	wasm_u8x16_make(uint8_t __c0, uint8_t __c1, uint8_t __c2, uint8_t __c3,
		281	uint8_t __c4, uint8_t __c5, uint8_t __c6, uint8_t __c7,
		282	uint8_t __c8, uint8_t __c9, uint8_t __c10, uint8_t __c11,
		283	uint8_t __c12, uint8_t __c13, uint8_t __c14, uint8_t __c15) {
		284	return (v128_t)(__u8x16){__c0, __c1, __c2, __c3, __c4, __c5,
		285	__c6, __c7, __c8, __c9, __c10, __c11,
		286	__c12, __c13, __c14, __c15};
		287	}
		288
		289	static __inline__ v128_t __DEFAULT_FN_ATTRS
		290	wasm_i16x8_make(int16_t __c0, int16_t __c1, int16_t __c2, int16_t __c3,
		291	int16_t __c4, int16_t __c5, int16_t __c6, int16_t __c7) {
		292	return (v128_t)(__i16x8){__c0, __c1, __c2, __c3, __c4, __c5, __c6, __c7};
		293	}
		294
		295	static __inline__ v128_t __DEFAULT_FN_ATTRS
		296	wasm_u16x8_make(uint16_t __c0, uint16_t __c1, uint16_t __c2, uint16_t __c3,
		297	uint16_t __c4, uint16_t __c5, uint16_t __c6, uint16_t __c7) {
		298	return (v128_t)(__u16x8){__c0, __c1, __c2, __c3, __c4, __c5, __c6, __c7};
		299	}
		300
		301	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_make(int32_t __c0,
		302	int32_t __c1,
		303	int32_t __c2,
		304	int32_t __c3) {
		305	return (v128_t)(__i32x4){__c0, __c1, __c2, __c3};
		306	}
		307
		308	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_make(uint32_t __c0,
		309	uint32_t __c1,
		310	uint32_t __c2,
		311	uint32_t __c3) {
		312	return (v128_t)(__u32x4){__c0, __c1, __c2, __c3};
		313	}
		314
		315	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_make(int64_t __c0,
		316	int64_t __c1) {
		317	return (v128_t)(__i64x2){__c0, __c1};
		318	}
		319
		320	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u64x2_make(uint64_t __c0,
		321	uint64_t __c1) {
		322	return (v128_t)(__u64x2){__c0, __c1};
		323	}
		324
		325	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_make(float __c0,
		326	float __c1,
		327	float __c2,
		328	float __c3) {
		329	return (v128_t)(__f32x4){__c0, __c1, __c2, __c3};
		330	}
		331
		332	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_make(double __c0,
		333	double __c1) {
		334	return (v128_t)(__f64x2){__c0, __c1};
		335	}
		336
		337	static __inline__ v128_t __DEFAULT_FN_ATTRS
		338	wasm_i8x16_const(int8_t __c0, int8_t __c1, int8_t __c2, int8_t __c3,
		339	int8_t __c4, int8_t __c5, int8_t __c6, int8_t __c7,
		340	int8_t __c8, int8_t __c9, int8_t __c10, int8_t __c11,
		341	int8_t __c12, int8_t __c13, int8_t __c14, int8_t __c15)
		342	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) __REQUIRE_CONSTANT(__c2)
		343	__REQUIRE_CONSTANT(__c3) __REQUIRE_CONSTANT(__c4)
		344	__REQUIRE_CONSTANT(__c5) __REQUIRE_CONSTANT(__c6)
		345	__REQUIRE_CONSTANT(__c7) __REQUIRE_CONSTANT(__c8)
		346	__REQUIRE_CONSTANT(__c9) __REQUIRE_CONSTANT(__c10)
		347	__REQUIRE_CONSTANT(__c11) __REQUIRE_CONSTANT(__c12)
		348	__REQUIRE_CONSTANT(__c13) __REQUIRE_CONSTANT(__c14)
		349	__REQUIRE_CONSTANT(__c15) {
		350	return (v128_t)(__i8x16){__c0, __c1, __c2, __c3, __c4, __c5,
		351	__c6, __c7, __c8, __c9, __c10, __c11,
		352	__c12, __c13, __c14, __c15};
		353	}
		354
		355	static __inline__ v128_t __DEFAULT_FN_ATTRS
		356	wasm_u8x16_const(uint8_t __c0, uint8_t __c1, uint8_t __c2, uint8_t __c3,
		357	uint8_t __c4, uint8_t __c5, uint8_t __c6, uint8_t __c7,
		358	uint8_t __c8, uint8_t __c9, uint8_t __c10, uint8_t __c11,
		359	uint8_t __c12, uint8_t __c13, uint8_t __c14, uint8_t __c15)
		360	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) __REQUIRE_CONSTANT(__c2)
		361	__REQUIRE_CONSTANT(__c3) __REQUIRE_CONSTANT(__c4)
		362	__REQUIRE_CONSTANT(__c5) __REQUIRE_CONSTANT(__c6)
		363	__REQUIRE_CONSTANT(__c7) __REQUIRE_CONSTANT(__c8)
		364	__REQUIRE_CONSTANT(__c9) __REQUIRE_CONSTANT(__c10)
		365	__REQUIRE_CONSTANT(__c11) __REQUIRE_CONSTANT(__c12)
		366	__REQUIRE_CONSTANT(__c13) __REQUIRE_CONSTANT(__c14)
		367	__REQUIRE_CONSTANT(__c15) {
		368	return (v128_t)(__u8x16){__c0, __c1, __c2, __c3, __c4, __c5,
		369	__c6, __c7, __c8, __c9, __c10, __c11,
		370	__c12, __c13, __c14, __c15};
		371	}
		372
		373	static __inline__ v128_t __DEFAULT_FN_ATTRS
		374	wasm_i16x8_const(int16_t __c0, int16_t __c1, int16_t __c2, int16_t __c3,
		375	int16_t __c4, int16_t __c5, int16_t __c6, int16_t __c7)
		376	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) __REQUIRE_CONSTANT(__c2)
		377	__REQUIRE_CONSTANT(__c3) __REQUIRE_CONSTANT(__c4)
		378	__REQUIRE_CONSTANT(__c5) __REQUIRE_CONSTANT(__c6)
		379	__REQUIRE_CONSTANT(__c7) {
		380	return (v128_t)(__i16x8){__c0, __c1, __c2, __c3, __c4, __c5, __c6, __c7};
		381	}
		382
		383	static __inline__ v128_t __DEFAULT_FN_ATTRS
		384	wasm_u16x8_const(uint16_t __c0, uint16_t __c1, uint16_t __c2, uint16_t __c3,
		385	uint16_t __c4, uint16_t __c5, uint16_t __c6, uint16_t __c7)
		386	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) __REQUIRE_CONSTANT(__c2)
		387	__REQUIRE_CONSTANT(__c3) __REQUIRE_CONSTANT(__c4)
		388	__REQUIRE_CONSTANT(__c5) __REQUIRE_CONSTANT(__c6)
		389	__REQUIRE_CONSTANT(__c7) {
		390	return (v128_t)(__u16x8){__c0, __c1, __c2, __c3, __c4, __c5, __c6, __c7};
		391	}
		392
		393	static __inline__ v128_t __DEFAULT_FN_ATTRS
		394	wasm_i32x4_const(int32_t __c0, int32_t __c1, int32_t __c2, int32_t __c3)
		395	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) __REQUIRE_CONSTANT(__c2)
		396	__REQUIRE_CONSTANT(__c3) {
		397	return (v128_t)(__i32x4){__c0, __c1, __c2, __c3};
		398	}
		399
		400	static __inline__ v128_t __DEFAULT_FN_ATTRS
		401	wasm_u32x4_const(uint32_t __c0, uint32_t __c1, uint32_t __c2, uint32_t __c3)
		402	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) __REQUIRE_CONSTANT(__c2)
		403	__REQUIRE_CONSTANT(__c3) {
		404	return (v128_t)(__u32x4){__c0, __c1, __c2, __c3};
		405	}
		406
		407	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_const(int64_t __c0,
		408	int64_t __c1)
		409	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) {
		410	return (v128_t)(__i64x2){__c0, __c1};
		411	}
		412
		413	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u64x2_const(uint64_t __c0,
		414	uint64_t __c1)
		415	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) {
		416	return (v128_t)(__u64x2){__c0, __c1};
		417	}
		418
		419	static __inline__ v128_t __DEFAULT_FN_ATTRS
		420	wasm_f32x4_const(float __c0, float __c1, float __c2, float __c3)
		421	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) __REQUIRE_CONSTANT(__c2)
		422	__REQUIRE_CONSTANT(__c3) {
		423	return (v128_t)(__f32x4){__c0, __c1, __c2, __c3};
		424	}
		425
		426	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_const(double __c0,
		427	double __c1)
		428	__REQUIRE_CONSTANT(__c0) __REQUIRE_CONSTANT(__c1) {
		429	return (v128_t)(__f64x2){__c0, __c1};
		430	}
		431
		432	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_const_splat(int8_t __c)
		433	__REQUIRE_CONSTANT(__c) {
		434	return (v128_t)(__i8x16){__c, __c, __c, __c, __c, __c, __c, __c,
		435	__c, __c, __c, __c, __c, __c, __c, __c};
		436	}
		437
		438	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_const_splat(uint8_t __c)
		439	__REQUIRE_CONSTANT(__c) {
		440	return (v128_t)(__u8x16){__c, __c, __c, __c, __c, __c, __c, __c,
		441	__c, __c, __c, __c, __c, __c, __c, __c};
		442	}
		443
		444	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_const_splat(int16_t __c)
		445	__REQUIRE_CONSTANT(__c) {
		446	return (v128_t)(__i16x8){__c, __c, __c, __c, __c, __c, __c, __c};
		447	}
		448
		449	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_const_splat(uint16_t __c)
		450	__REQUIRE_CONSTANT(__c) {
		451	return (v128_t)(__u16x8){__c, __c, __c, __c, __c, __c, __c, __c};
		452	}
		453
		454	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_const_splat(int32_t __c)
		455	__REQUIRE_CONSTANT(__c) {
		456	return (v128_t)(__i32x4){__c, __c, __c, __c};
		457	}
		458
		459	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_const_splat(uint32_t __c)
		460	__REQUIRE_CONSTANT(__c) {
		461	return (v128_t)(__u32x4){__c, __c, __c, __c};
		462	}
		463
		464	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_const_splat(int64_t __c)
		465	__REQUIRE_CONSTANT(__c) {
		466	return (v128_t)(__i64x2){__c, __c};
		467	}
		468
		469	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u64x2_const_splat(uint64_t __c)
		470	__REQUIRE_CONSTANT(__c) {
		471	return (v128_t)(__u64x2){__c, __c};
		472	}
		473
		474	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_const_splat(float __c)
		475	__REQUIRE_CONSTANT(__c) {
		476	return (v128_t)(__f32x4){__c, __c, __c, __c};
		477	}
		478
		479	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_const_splat(double __c)
		480	__REQUIRE_CONSTANT(__c) {
		481	return (v128_t)(__f64x2){__c, __c};
		482	}
		483
		484	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_splat(int8_t __a) {
		485	return (v128_t)(__i8x16){__a, __a, __a, __a, __a, __a, __a, __a,
		486	__a, __a, __a, __a, __a, __a, __a, __a};
		487	}
		488
		489	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_splat(uint8_t __a) {
		490	return (v128_t)(__u8x16){__a, __a, __a, __a, __a, __a, __a, __a,
		491	__a, __a, __a, __a, __a, __a, __a, __a};
		492	}
		493
		494	static __inline__ int8_t __DEFAULT_FN_ATTRS wasm_i8x16_extract_lane(v128_t __a,
		495	int __i)
		496	__REQUIRE_CONSTANT(__i) {
		497	return ((__i8x16)__a)[__i];
		498	}
		499
		500	static __inline__ uint8_t __DEFAULT_FN_ATTRS wasm_u8x16_extract_lane(v128_t __a,
		501	int __i)
		502	__REQUIRE_CONSTANT(__i) {
		503	return ((__u8x16)__a)[__i];
		504	}
		505
		506	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_replace_lane(v128_t __a,
		507	int __i,
		508	int8_t __b)
		509	__REQUIRE_CONSTANT(__i) {
		510	__i8x16 __v = (__i8x16)__a;
		511	__v[__i] = __b;
		512	return (v128_t)__v;
		513	}
		514
		515	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_replace_lane(v128_t __a,
		516	int __i,
		517	uint8_t __b)
		518	__REQUIRE_CONSTANT(__i) {
		519	__u8x16 __v = (__u8x16)__a;
		520	__v[__i] = __b;
		521	return (v128_t)__v;
		522	}
		523
		524	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_splat(int16_t __a) {
		525	return (v128_t)(__i16x8){__a, __a, __a, __a, __a, __a, __a, __a};
		526	}
		527
		528	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_splat(uint16_t __a) {
		529	return (v128_t)(__u16x8){__a, __a, __a, __a, __a, __a, __a, __a};
		530	}
		531
		532	static __inline__ int16_t __DEFAULT_FN_ATTRS wasm_i16x8_extract_lane(v128_t __a,
		533	int __i)
		534	__REQUIRE_CONSTANT(__i) {
		535	return ((__i16x8)__a)[__i];
		536	}
		537
		538	static __inline__ uint16_t __DEFAULT_FN_ATTRS
		539	wasm_u16x8_extract_lane(v128_t __a, int __i) __REQUIRE_CONSTANT(__i) {
		540	return ((__u16x8)__a)[__i];
		541	}
		542
		543	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_replace_lane(v128_t __a,
		544	int __i,
		545	int16_t __b)
		546	__REQUIRE_CONSTANT(__i) {
		547	__i16x8 __v = (__i16x8)__a;
		548	__v[__i] = __b;
		549	return (v128_t)__v;
		550	}
		551
		552	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_replace_lane(
		553	v128_t __a, int __i, uint16_t __b) __REQUIRE_CONSTANT(__i) {
		554	__u16x8 __v = (__u16x8)__a;
		555	__v[__i] = __b;
		556	return (v128_t)__v;
		557	}
		558
		559	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_splat(int32_t __a) {
		560	return (v128_t)(__i32x4){__a, __a, __a, __a};
		561	}
		562
		563	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_splat(uint32_t __a) {
		564	return (v128_t)(__u32x4){__a, __a, __a, __a};
		565	}
		566
		567	static __inline__ int32_t __DEFAULT_FN_ATTRS wasm_i32x4_extract_lane(v128_t __a,
		568	int __i)
		569	__REQUIRE_CONSTANT(__i) {
		570	return ((__i32x4)__a)[__i];
		571	}
		572
		573	static __inline__ uint32_t __DEFAULT_FN_ATTRS
		574	wasm_u32x4_extract_lane(v128_t __a, int __i) __REQUIRE_CONSTANT(__i) {
		575	return ((__u32x4)__a)[__i];
		576	}
		577
		578	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_replace_lane(v128_t __a,
		579	int __i,
		580	int32_t __b)
		581	__REQUIRE_CONSTANT(__i) {
		582	__i32x4 __v = (__i32x4)__a;
		583	__v[__i] = __b;
		584	return (v128_t)__v;
		585	}
		586
		587	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_replace_lane(
		588	v128_t __a, int __i, uint32_t __b) __REQUIRE_CONSTANT(__i) {
		589	__u32x4 __v = (__u32x4)__a;
		590	__v[__i] = __b;
		591	return (v128_t)__v;
		592	}
		593
		594	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_splat(int64_t __a) {
		595	return (v128_t)(__i64x2){__a, __a};
		596	}
		597
		598	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u64x2_splat(uint64_t __a) {
		599	return (v128_t)(__u64x2){__a, __a};
		600	}
		601
		602	static __inline__ int64_t __DEFAULT_FN_ATTRS wasm_i64x2_extract_lane(v128_t __a,
		603	int __i)
		604	__REQUIRE_CONSTANT(__i) {
		605	return ((__i64x2)__a)[__i];
		606	}
		607
		608	static __inline__ uint64_t __DEFAULT_FN_ATTRS
		609	wasm_u64x2_extract_lane(v128_t __a, int __i) __REQUIRE_CONSTANT(__i) {
		610	return ((__u64x2)__a)[__i];
		611	}
		612
		613	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_replace_lane(v128_t __a,
		614	int __i,
		615	int64_t __b)
		616	__REQUIRE_CONSTANT(__i) {
		617	__i64x2 __v = (__i64x2)__a;
		618	__v[__i] = __b;
		619	return (v128_t)__v;
		620	}
		621
		622	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u64x2_replace_lane(
		623	v128_t __a, int __i, uint64_t __b) __REQUIRE_CONSTANT(__i) {
		624	__u64x2 __v = (__u64x2)__a;
		625	__v[__i] = __b;
		626	return (v128_t)__v;
		627	}
		628
		629	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_splat(float __a) {
		630	return (v128_t)(__f32x4){__a, __a, __a, __a};
		631	}
		632
		633	static __inline__ float __DEFAULT_FN_ATTRS wasm_f32x4_extract_lane(v128_t __a,
		634	int __i)
		635	__REQUIRE_CONSTANT(__i) {
		636	return ((__f32x4)__a)[__i];
		637	}
		638
		639	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_replace_lane(v128_t __a,
		640	int __i,
		641	float __b)
		642	__REQUIRE_CONSTANT(__i) {
		643	__f32x4 __v = (__f32x4)__a;
		644	__v[__i] = __b;
		645	return (v128_t)__v;
		646	}
		647
		648	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_splat(double __a) {
		649	return (v128_t)(__f64x2){__a, __a};
		650	}
		651
		652	static __inline__ double __DEFAULT_FN_ATTRS wasm_f64x2_extract_lane(v128_t __a,
		653	int __i)
		654	__REQUIRE_CONSTANT(__i) {
		655	return ((__f64x2)__a)[__i];
		656	}
		657
		658	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_replace_lane(v128_t __a,
		659	int __i,
		660	double __b)
		661	__REQUIRE_CONSTANT(__i) {
		662	__f64x2 __v = (__f64x2)__a;
		663	__v[__i] = __b;
		664	return (v128_t)__v;
		665	}
		666
		667	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_eq(v128_t __a,
		668	v128_t __b) {
		669	return (v128_t)((__i8x16)__a == (__i8x16)__b);
		670	}
		671
		672	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_ne(v128_t __a,
		673	v128_t __b) {
		674	return (v128_t)((__i8x16)__a != (__i8x16)__b);
		675	}
		676
		677	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_lt(v128_t __a,
		678	v128_t __b) {
		679	return (v128_t)((__i8x16)__a < (__i8x16)__b);
		680	}
		681
		682	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_lt(v128_t __a,
		683	v128_t __b) {
		684	return (v128_t)((__u8x16)__a < (__u8x16)__b);
		685	}
		686
		687	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_gt(v128_t __a,
		688	v128_t __b) {
		689	return (v128_t)((__i8x16)__a > (__i8x16)__b);
		690	}
		691
		692	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_gt(v128_t __a,
		693	v128_t __b) {
		694	return (v128_t)((__u8x16)__a > (__u8x16)__b);
		695	}
		696
		697	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_le(v128_t __a,
		698	v128_t __b) {
		699	return (v128_t)((__i8x16)__a <= (__i8x16)__b);
		700	}
		701
		702	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_le(v128_t __a,
		703	v128_t __b) {
		704	return (v128_t)((__u8x16)__a <= (__u8x16)__b);
		705	}
		706
		707	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_ge(v128_t __a,
		708	v128_t __b) {
		709	return (v128_t)((__i8x16)__a >= (__i8x16)__b);
		710	}
		711
		712	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_ge(v128_t __a,
		713	v128_t __b) {
		714	return (v128_t)((__u8x16)__a >= (__u8x16)__b);
		715	}
		716
		717	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_eq(v128_t __a,
		718	v128_t __b) {
		719	return (v128_t)((__i16x8)__a == (__i16x8)__b);
		720	}
		721
		722	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_ne(v128_t __a,
		723	v128_t __b) {
		724	return (v128_t)((__u16x8)__a != (__u16x8)__b);
		725	}
		726
		727	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_lt(v128_t __a,
		728	v128_t __b) {
		729	return (v128_t)((__i16x8)__a < (__i16x8)__b);
		730	}
		731
		732	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_lt(v128_t __a,
		733	v128_t __b) {
		734	return (v128_t)((__u16x8)__a < (__u16x8)__b);
		735	}
		736
		737	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_gt(v128_t __a,
		738	v128_t __b) {
		739	return (v128_t)((__i16x8)__a > (__i16x8)__b);
		740	}
		741
		742	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_gt(v128_t __a,
		743	v128_t __b) {
		744	return (v128_t)((__u16x8)__a > (__u16x8)__b);
		745	}
		746
		747	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_le(v128_t __a,
		748	v128_t __b) {
		749	return (v128_t)((__i16x8)__a <= (__i16x8)__b);
		750	}
		751
		752	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_le(v128_t __a,
		753	v128_t __b) {
		754	return (v128_t)((__u16x8)__a <= (__u16x8)__b);
		755	}
		756
		757	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_ge(v128_t __a,
		758	v128_t __b) {
		759	return (v128_t)((__i16x8)__a >= (__i16x8)__b);
		760	}
		761
		762	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_ge(v128_t __a,
		763	v128_t __b) {
		764	return (v128_t)((__u16x8)__a >= (__u16x8)__b);
		765	}
		766
		767	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_eq(v128_t __a,
		768	v128_t __b) {
		769	return (v128_t)((__i32x4)__a == (__i32x4)__b);
		770	}
		771
		772	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_ne(v128_t __a,
		773	v128_t __b) {
		774	return (v128_t)((__i32x4)__a != (__i32x4)__b);
		775	}
		776
		777	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_lt(v128_t __a,
		778	v128_t __b) {
		779	return (v128_t)((__i32x4)__a < (__i32x4)__b);
		780	}
		781
		782	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_lt(v128_t __a,
		783	v128_t __b) {
		784	return (v128_t)((__u32x4)__a < (__u32x4)__b);
		785	}
		786
		787	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_gt(v128_t __a,
		788	v128_t __b) {
		789	return (v128_t)((__i32x4)__a > (__i32x4)__b);
		790	}
		791
		792	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_gt(v128_t __a,
		793	v128_t __b) {
		794	return (v128_t)((__u32x4)__a > (__u32x4)__b);
		795	}
		796
		797	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_le(v128_t __a,
		798	v128_t __b) {
		799	return (v128_t)((__i32x4)__a <= (__i32x4)__b);
		800	}
		801
		802	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_le(v128_t __a,
		803	v128_t __b) {
		804	return (v128_t)((__u32x4)__a <= (__u32x4)__b);
		805	}
		806
		807	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_ge(v128_t __a,
		808	v128_t __b) {
		809	return (v128_t)((__i32x4)__a >= (__i32x4)__b);
		810	}
		811
		812	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_ge(v128_t __a,
		813	v128_t __b) {
		814	return (v128_t)((__u32x4)__a >= (__u32x4)__b);
		815	}
		816
		817	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_eq(v128_t __a,
		818	v128_t __b) {
		819	return (v128_t)((__i64x2)__a == (__i64x2)__b);
		820	}
		821
		822	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_ne(v128_t __a,
		823	v128_t __b) {
		824	return (v128_t)((__i64x2)__a != (__i64x2)__b);
		825	}
		826
		827	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_lt(v128_t __a,
		828	v128_t __b) {
		829	return (v128_t)((__i64x2)__a < (__i64x2)__b);
		830	}
		831
		832	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_gt(v128_t __a,
		833	v128_t __b) {
		834	return (v128_t)((__i64x2)__a > (__i64x2)__b);
		835	}
		836
		837	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_le(v128_t __a,
		838	v128_t __b) {
		839	return (v128_t)((__i64x2)__a <= (__i64x2)__b);
		840	}
		841
		842	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_ge(v128_t __a,
		843	v128_t __b) {
		844	return (v128_t)((__i64x2)__a >= (__i64x2)__b);
		845	}
		846
		847	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_eq(v128_t __a,
		848	v128_t __b) {
		849	return (v128_t)((__f32x4)__a == (__f32x4)__b);
		850	}
		851
		852	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_ne(v128_t __a,
		853	v128_t __b) {
		854	return (v128_t)((__f32x4)__a != (__f32x4)__b);
		855	}
		856
		857	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_lt(v128_t __a,
		858	v128_t __b) {
		859	return (v128_t)((__f32x4)__a < (__f32x4)__b);
		860	}
		861
		862	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_gt(v128_t __a,
		863	v128_t __b) {
		864	return (v128_t)((__f32x4)__a > (__f32x4)__b);
		865	}
		866
		867	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_le(v128_t __a,
		868	v128_t __b) {
		869	return (v128_t)((__f32x4)__a <= (__f32x4)__b);
		870	}
		871
		872	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_ge(v128_t __a,
		873	v128_t __b) {
		874	return (v128_t)((__f32x4)__a >= (__f32x4)__b);
		875	}
		876
		877	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_eq(v128_t __a,
		878	v128_t __b) {
		879	return (v128_t)((__f64x2)__a == (__f64x2)__b);
		880	}
		881
		882	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_ne(v128_t __a,
		883	v128_t __b) {
		884	return (v128_t)((__f64x2)__a != (__f64x2)__b);
		885	}
		886
		887	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_lt(v128_t __a,
		888	v128_t __b) {
		889	return (v128_t)((__f64x2)__a < (__f64x2)__b);
		890	}
		891
		892	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_gt(v128_t __a,
		893	v128_t __b) {
		894	return (v128_t)((__f64x2)__a > (__f64x2)__b);
		895	}
		896
		897	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_le(v128_t __a,
		898	v128_t __b) {
		899	return (v128_t)((__f64x2)__a <= (__f64x2)__b);
		900	}
		901
		902	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_ge(v128_t __a,
		903	v128_t __b) {
		904	return (v128_t)((__f64x2)__a >= (__f64x2)__b);
		905	}
		906
		907	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_not(v128_t __a) {
		908	return ~__a;
		909	}
		910
		911	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_and(v128_t __a,
		912	v128_t __b) {
		913	return __a & __b;
		914	}
		915
		916	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_or(v128_t __a,
		917	v128_t __b) {
		918	return __a \| __b;
		919	}
		920
		921	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_xor(v128_t __a,
		922	v128_t __b) {
		923	return __a ^ __b;
		924	}
		925
		926	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_andnot(v128_t __a,
		927	v128_t __b) {
		928	return __a & ~__b;
		929	}
		930
		931	static __inline__ bool __DEFAULT_FN_ATTRS wasm_v128_any_true(v128_t __a) {
		932	return __builtin_wasm_any_true_v128((__i8x16)__a);
		933	}
		934
		935	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_v128_bitselect(v128_t __a,
		936	v128_t __b,
		937	v128_t __mask) {
		938	return (v128_t)__builtin_wasm_bitselect((__i32x4)__a, (__i32x4)__b,
		939	(__i32x4)__mask);
		940	}
		941
		942	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_abs(v128_t __a) {
		943	return (v128_t)__builtin_wasm_abs_i8x16((__i8x16)__a);
		944	}
		945
		946	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_neg(v128_t __a) {
		947	return (v128_t)(-(__u8x16)__a);
		948	}
		949
		950	static __inline__ bool __DEFAULT_FN_ATTRS wasm_i8x16_all_true(v128_t __a) {
		951	return __builtin_wasm_all_true_i8x16((__i8x16)__a);
		952	}
		953
		954	static __inline__ uint32_t __DEFAULT_FN_ATTRS wasm_i8x16_bitmask(v128_t __a) {
		955	return __builtin_wasm_bitmask_i8x16((__i8x16)__a);
		956	}
		957
		958	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_popcnt(v128_t __a) {
		959	return (v128_t)__builtin_wasm_popcnt_i8x16((__i8x16)__a);
		960	}
		961
		962	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_shl(v128_t __a,
		963	uint32_t __b) {
		964	return (v128_t)((__i8x16)__a << __b);
		965	}
		966
		967	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_shr(v128_t __a,
		968	uint32_t __b) {
		969	return (v128_t)((__i8x16)__a >> __b);
		970	}
		971
		972	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_shr(v128_t __a,
		973	uint32_t __b) {
		974	return (v128_t)((__u8x16)__a >> __b);
		975	}
		976
		977	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_add(v128_t __a,
		978	v128_t __b) {
		979	return (v128_t)((__u8x16)__a + (__u8x16)__b);
		980	}
		981
		982	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_add_sat(v128_t __a,
		983	v128_t __b) {
		984	return (v128_t)__builtin_wasm_add_sat_s_i8x16((__i8x16)__a, (__i8x16)__b);
		985	}
		986
		987	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_add_sat(v128_t __a,
		988	v128_t __b) {
		989	return (v128_t)__builtin_wasm_add_sat_u_i8x16((__u8x16)__a, (__u8x16)__b);
		990	}
		991
		992	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_sub(v128_t __a,
		993	v128_t __b) {
		994	return (v128_t)((__u8x16)__a - (__u8x16)__b);
		995	}
		996
		997	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_sub_sat(v128_t __a,
		998	v128_t __b) {
		999	return (v128_t)__builtin_wasm_sub_sat_s_i8x16((__i8x16)__a, (__i8x16)__b);
		1000	}
		1001
		1002	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_sub_sat(v128_t __a,
		1003	v128_t __b) {
		1004	return (v128_t)__builtin_wasm_sub_sat_u_i8x16((__u8x16)__a, (__u8x16)__b);
		1005	}
		1006
		1007	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_min(v128_t __a,
		1008	v128_t __b) {
		1009	return (v128_t)__builtin_wasm_min_s_i8x16((__i8x16)__a, (__i8x16)__b);
		1010	}
		1011
		1012	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_min(v128_t __a,
		1013	v128_t __b) {
		1014	return (v128_t)__builtin_wasm_min_u_i8x16((__u8x16)__a, (__u8x16)__b);
		1015	}
		1016
		1017	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_max(v128_t __a,
		1018	v128_t __b) {
		1019	return (v128_t)__builtin_wasm_max_s_i8x16((__i8x16)__a, (__i8x16)__b);
		1020	}
		1021
		1022	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_max(v128_t __a,
		1023	v128_t __b) {
		1024	return (v128_t)__builtin_wasm_max_u_i8x16((__u8x16)__a, (__u8x16)__b);
		1025	}
		1026
		1027	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u8x16_avgr(v128_t __a,
		1028	v128_t __b) {
		1029	return (v128_t)__builtin_wasm_avgr_u_i8x16((__u8x16)__a, (__u8x16)__b);
		1030	}
		1031
		1032	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_abs(v128_t __a) {
		1033	return (v128_t)__builtin_wasm_abs_i16x8((__i16x8)__a);
		1034	}
		1035
		1036	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_neg(v128_t __a) {
		1037	return (v128_t)(-(__u16x8)__a);
		1038	}
		1039
		1040	static __inline__ bool __DEFAULT_FN_ATTRS wasm_i16x8_all_true(v128_t __a) {
		1041	return __builtin_wasm_all_true_i16x8((__i16x8)__a);
		1042	}
		1043
		1044	static __inline__ uint32_t __DEFAULT_FN_ATTRS wasm_i16x8_bitmask(v128_t __a) {
		1045	return __builtin_wasm_bitmask_i16x8((__i16x8)__a);
		1046	}
		1047
		1048	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_shl(v128_t __a,
		1049	uint32_t __b) {
		1050	return (v128_t)((__i16x8)__a << __b);
		1051	}
		1052
		1053	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_shr(v128_t __a,
		1054	uint32_t __b) {
		1055	return (v128_t)((__i16x8)__a >> __b);
		1056	}
		1057
		1058	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_shr(v128_t __a,
		1059	uint32_t __b) {
		1060	return (v128_t)((__u16x8)__a >> __b);
		1061	}
		1062
		1063	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_add(v128_t __a,
		1064	v128_t __b) {
		1065	return (v128_t)((__u16x8)__a + (__u16x8)__b);
		1066	}
		1067
		1068	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_add_sat(v128_t __a,
		1069	v128_t __b) {
		1070	return (v128_t)__builtin_wasm_add_sat_s_i16x8((__i16x8)__a, (__i16x8)__b);
		1071	}
		1072
		1073	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_add_sat(v128_t __a,
		1074	v128_t __b) {
		1075	return (v128_t)__builtin_wasm_add_sat_u_i16x8((__u16x8)__a, (__u16x8)__b);
		1076	}
		1077
		1078	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_sub(v128_t __a,
		1079	v128_t __b) {
		1080	return (v128_t)((__i16x8)__a - (__i16x8)__b);
		1081	}
		1082
		1083	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_sub_sat(v128_t __a,
		1084	v128_t __b) {
		1085	return (v128_t)__builtin_wasm_sub_sat_s_i16x8((__i16x8)__a, (__i16x8)__b);
		1086	}
		1087
		1088	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_sub_sat(v128_t __a,
		1089	v128_t __b) {
		1090	return (v128_t)__builtin_wasm_sub_sat_u_i16x8((__u16x8)__a, (__u16x8)__b);
		1091	}
		1092
		1093	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_mul(v128_t __a,
		1094	v128_t __b) {
		1095	return (v128_t)((__u16x8)__a * (__u16x8)__b);
		1096	}
		1097
		1098	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_min(v128_t __a,
		1099	v128_t __b) {
		1100	return (v128_t)__builtin_wasm_min_s_i16x8((__i16x8)__a, (__i16x8)__b);
		1101	}
		1102
		1103	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_min(v128_t __a,
		1104	v128_t __b) {
		1105	return (v128_t)__builtin_wasm_min_u_i16x8((__u16x8)__a, (__u16x8)__b);
		1106	}
		1107
		1108	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_max(v128_t __a,
		1109	v128_t __b) {
		1110	return (v128_t)__builtin_wasm_max_s_i16x8((__i16x8)__a, (__i16x8)__b);
		1111	}
		1112
		1113	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_max(v128_t __a,
		1114	v128_t __b) {
		1115	return (v128_t)__builtin_wasm_max_u_i16x8((__u16x8)__a, (__u16x8)__b);
		1116	}
		1117
		1118	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u16x8_avgr(v128_t __a,
		1119	v128_t __b) {
		1120	return (v128_t)__builtin_wasm_avgr_u_i16x8((__u16x8)__a, (__u16x8)__b);
		1121	}
		1122
		1123	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_abs(v128_t __a) {
		1124	return (v128_t)__builtin_wasm_abs_i32x4((__i32x4)__a);
		1125	}
		1126
		1127	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_neg(v128_t __a) {
		1128	return (v128_t)(-(__u32x4)__a);
		1129	}
		1130
		1131	static __inline__ bool __DEFAULT_FN_ATTRS wasm_i32x4_all_true(v128_t __a) {
		1132	return __builtin_wasm_all_true_i32x4((__i32x4)__a);
		1133	}
		1134
		1135	static __inline__ uint32_t __DEFAULT_FN_ATTRS wasm_i32x4_bitmask(v128_t __a) {
		1136	return __builtin_wasm_bitmask_i32x4((__i32x4)__a);
		1137	}
		1138
		1139	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_shl(v128_t __a,
		1140	uint32_t __b) {
		1141	return (v128_t)((__i32x4)__a << __b);
		1142	}
		1143
		1144	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_shr(v128_t __a,
		1145	uint32_t __b) {
		1146	return (v128_t)((__i32x4)__a >> __b);
		1147	}
		1148
		1149	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_shr(v128_t __a,
		1150	uint32_t __b) {
		1151	return (v128_t)((__u32x4)__a >> __b);
		1152	}
		1153
		1154	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_add(v128_t __a,
		1155	v128_t __b) {
		1156	return (v128_t)((__u32x4)__a + (__u32x4)__b);
		1157	}
		1158
		1159	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_sub(v128_t __a,
		1160	v128_t __b) {
		1161	return (v128_t)((__u32x4)__a - (__u32x4)__b);
		1162	}
		1163
		1164	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_mul(v128_t __a,
		1165	v128_t __b) {
		1166	return (v128_t)((__u32x4)__a * (__u32x4)__b);
		1167	}
		1168
		1169	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_min(v128_t __a,
		1170	v128_t __b) {
		1171	return (v128_t)__builtin_wasm_min_s_i32x4((__i32x4)__a, (__i32x4)__b);
		1172	}
		1173
		1174	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_min(v128_t __a,
		1175	v128_t __b) {
		1176	return (v128_t)__builtin_wasm_min_u_i32x4((__u32x4)__a, (__u32x4)__b);
		1177	}
		1178
		1179	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_max(v128_t __a,
		1180	v128_t __b) {
		1181	return (v128_t)__builtin_wasm_max_s_i32x4((__i32x4)__a, (__i32x4)__b);
		1182	}
		1183
		1184	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u32x4_max(v128_t __a,
		1185	v128_t __b) {
		1186	return (v128_t)__builtin_wasm_max_u_i32x4((__u32x4)__a, (__u32x4)__b);
		1187	}
		1188
		1189	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i32x4_dot_i16x8(v128_t __a,
		1190	v128_t __b) {
		1191	return (v128_t)__builtin_wasm_dot_s_i32x4_i16x8((__i16x8)__a, (__i16x8)__b);
		1192	}
		1193
		1194	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_abs(v128_t __a) {
		1195	return (v128_t)__builtin_wasm_abs_i64x2((__i64x2)__a);
		1196	}
		1197
		1198	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_neg(v128_t __a) {
		1199	return (v128_t)(-(__u64x2)__a);
		1200	}
		1201
		1202	static __inline__ bool __DEFAULT_FN_ATTRS wasm_i64x2_all_true(v128_t __a) {
		1203	return __builtin_wasm_all_true_i64x2((__i64x2)__a);
		1204	}
		1205
		1206	static __inline__ uint32_t __DEFAULT_FN_ATTRS wasm_i64x2_bitmask(v128_t __a) {
		1207	return __builtin_wasm_bitmask_i64x2((__i64x2)__a);
		1208	}
		1209
		1210	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_shl(v128_t __a,
		1211	uint32_t __b) {
		1212	return (v128_t)((__i64x2)__a << (int64_t)__b);
		1213	}
		1214
		1215	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_shr(v128_t __a,
		1216	uint32_t __b) {
		1217	return (v128_t)((__i64x2)__a >> (int64_t)__b);
		1218	}
		1219
		1220	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_u64x2_shr(v128_t __a,
		1221	uint32_t __b) {
		1222	return (v128_t)((__u64x2)__a >> (int64_t)__b);
		1223	}
		1224
		1225	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_add(v128_t __a,
		1226	v128_t __b) {
		1227	return (v128_t)((__u64x2)__a + (__u64x2)__b);
		1228	}
		1229
		1230	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_sub(v128_t __a,
		1231	v128_t __b) {
		1232	return (v128_t)((__u64x2)__a - (__u64x2)__b);
		1233	}
		1234
		1235	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i64x2_mul(v128_t __a,
		1236	v128_t __b) {
		1237	return (v128_t)((__u64x2)__a * (__u64x2)__b);
		1238	}
		1239
		1240	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_abs(v128_t __a) {
		1241	return (v128_t)__builtin_wasm_abs_f32x4((__f32x4)__a);
		1242	}
		1243
		1244	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_neg(v128_t __a) {
		1245	return (v128_t)(-(__f32x4)__a);
		1246	}
		1247
		1248	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_sqrt(v128_t __a) {
		1249	return (v128_t)__builtin_wasm_sqrt_f32x4((__f32x4)__a);
		1250	}
		1251
		1252	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_ceil(v128_t __a) {
		1253	return (v128_t)__builtin_wasm_ceil_f32x4((__f32x4)__a);
		1254	}
		1255
		1256	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_floor(v128_t __a) {
		1257	return (v128_t)__builtin_wasm_floor_f32x4((__f32x4)__a);
		1258	}
		1259
		1260	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_trunc(v128_t __a) {
		1261	return (v128_t)__builtin_wasm_trunc_f32x4((__f32x4)__a);
		1262	}
		1263
		1264	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_nearest(v128_t __a) {
		1265	return (v128_t)__builtin_wasm_nearest_f32x4((__f32x4)__a);
		1266	}
		1267
		1268	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_add(v128_t __a,
		1269	v128_t __b) {
		1270	return (v128_t)((__f32x4)__a + (__f32x4)__b);
		1271	}
		1272
		1273	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_sub(v128_t __a,
		1274	v128_t __b) {
		1275	return (v128_t)((__f32x4)__a - (__f32x4)__b);
		1276	}
		1277
		1278	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_mul(v128_t __a,
		1279	v128_t __b) {
		1280	return (v128_t)((__f32x4)__a * (__f32x4)__b);
		1281	}
		1282
		1283	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_div(v128_t __a,
		1284	v128_t __b) {
		1285	return (v128_t)((__f32x4)__a / (__f32x4)__b);
		1286	}
		1287
		1288	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_min(v128_t __a,
		1289	v128_t __b) {
		1290	return (v128_t)__builtin_wasm_min_f32x4((__f32x4)__a, (__f32x4)__b);
		1291	}
		1292
		1293	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_max(v128_t __a,
		1294	v128_t __b) {
		1295	return (v128_t)__builtin_wasm_max_f32x4((__f32x4)__a, (__f32x4)__b);
		1296	}
		1297
		1298	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_pmin(v128_t __a,
		1299	v128_t __b) {
		1300	return (v128_t)__builtin_wasm_pmin_f32x4((__f32x4)__a, (__f32x4)__b);
		1301	}
		1302
		1303	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f32x4_pmax(v128_t __a,
		1304	v128_t __b) {
		1305	return (v128_t)__builtin_wasm_pmax_f32x4((__f32x4)__a, (__f32x4)__b);
		1306	}
		1307
		1308	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_abs(v128_t __a) {
		1309	return (v128_t)__builtin_wasm_abs_f64x2((__f64x2)__a);
		1310	}
		1311
		1312	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_neg(v128_t __a) {
		1313	return (v128_t)(-(__f64x2)__a);
		1314	}
		1315
		1316	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_sqrt(v128_t __a) {
		1317	return (v128_t)__builtin_wasm_sqrt_f64x2((__f64x2)__a);
		1318	}
		1319
		1320	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_ceil(v128_t __a) {
		1321	return (v128_t)__builtin_wasm_ceil_f64x2((__f64x2)__a);
		1322	}
		1323
		1324	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_floor(v128_t __a) {
		1325	return (v128_t)__builtin_wasm_floor_f64x2((__f64x2)__a);
		1326	}
		1327
		1328	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_trunc(v128_t __a) {
		1329	return (v128_t)__builtin_wasm_trunc_f64x2((__f64x2)__a);
		1330	}
		1331
		1332	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_nearest(v128_t __a) {
		1333	return (v128_t)__builtin_wasm_nearest_f64x2((__f64x2)__a);
		1334	}
		1335
		1336	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_add(v128_t __a,
		1337	v128_t __b) {
		1338	return (v128_t)((__f64x2)__a + (__f64x2)__b);
		1339	}
		1340
		1341	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_sub(v128_t __a,
		1342	v128_t __b) {
		1343	return (v128_t)((__f64x2)__a - (__f64x2)__b);
		1344	}
		1345
		1346	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_mul(v128_t __a,
		1347	v128_t __b) {
		1348	return (v128_t)((__f64x2)__a * (__f64x2)__b);
		1349	}
		1350
		1351	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_div(v128_t __a,
		1352	v128_t __b) {
		1353	return (v128_t)((__f64x2)__a / (__f64x2)__b);
		1354	}
		1355
		1356	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_min(v128_t __a,
		1357	v128_t __b) {
		1358	return (v128_t)__builtin_wasm_min_f64x2((__f64x2)__a, (__f64x2)__b);
		1359	}
		1360
		1361	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_max(v128_t __a,
		1362	v128_t __b) {
		1363	return (v128_t)__builtin_wasm_max_f64x2((__f64x2)__a, (__f64x2)__b);
		1364	}
		1365
		1366	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_pmin(v128_t __a,
		1367	v128_t __b) {
		1368	return (v128_t)__builtin_wasm_pmin_f64x2((__f64x2)__a, (__f64x2)__b);
		1369	}
		1370
		1371	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_f64x2_pmax(v128_t __a,
		1372	v128_t __b) {
		1373	return (v128_t)__builtin_wasm_pmax_f64x2((__f64x2)__a, (__f64x2)__b);
		1374	}
		1375
		1376	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1377	wasm_i32x4_trunc_sat_f32x4(v128_t __a) {
		1378	return (v128_t)__builtin_wasm_trunc_saturate_s_i32x4_f32x4((__f32x4)__a);
		1379	}
		1380
		1381	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1382	wasm_u32x4_trunc_sat_f32x4(v128_t __a) {
		1383	return (v128_t)__builtin_wasm_trunc_saturate_u_i32x4_f32x4((__f32x4)__a);
		1384	}
		1385
		1386	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1387	wasm_f32x4_convert_i32x4(v128_t __a) {
		1388	return (v128_t) __builtin_convertvector((__i32x4)__a, __f32x4);
		1389	}
		1390
		1391	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1392	wasm_f32x4_convert_u32x4(v128_t __a) {
		1393	return (v128_t) __builtin_convertvector((__u32x4)__a, __f32x4);
		1394	}
		1395
		1396	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1397	wasm_f64x2_convert_low_i32x4(v128_t __a) {
		1398	return (v128_t) __builtin_convertvector((__i32x2){__a[0], __a[1]}, __f64x2);
		1399	}
		1400
		1401	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1402	wasm_f64x2_convert_low_u32x4(v128_t __a) {
		1403	return (v128_t) __builtin_convertvector((__u32x2){__a[0], __a[1]}, __f64x2);
		1404	}
		1405
		1406	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1407	wasm_i32x4_trunc_sat_f64x2_zero(v128_t __a) {
		1408	return (v128_t)__builtin_wasm_trunc_sat_s_zero_f64x2_i32x4((__f64x2)__a);
		1409	}
		1410
		1411	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1412	wasm_u32x4_trunc_sat_f64x2_zero(v128_t __a) {
		1413	return (v128_t)__builtin_wasm_trunc_sat_u_zero_f64x2_i32x4((__f64x2)__a);
		1414	}
		1415
		1416	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1417	wasm_f32x4_demote_f64x2_zero(v128_t __a) {
		1418	return (v128_t) __builtin_convertvector(
		1419	__builtin_shufflevector((__f64x2)__a, (__f64x2){0, 0}, 0, 1, 2, 3),
		1420	__f32x4);
		1421	}
		1422
		1423	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1424	wasm_f64x2_promote_low_f32x4(v128_t __a) {
		1425	return (v128_t) __builtin_convertvector(
		1426	(__f32x2){((__f32x4)__a)[0], ((__f32x4)__a)[1]}, __f64x2);
		1427	}
		1428
		1429	#define wasm_i8x16_shuffle(__a, __b, __c0, __c1, __c2, __c3, __c4, __c5, __c6, \
		1430	__c7, __c8, __c9, __c10, __c11, __c12, __c13, \
		1431	__c14, __c15) \
		1432	((v128_t)__builtin_wasm_shuffle_i8x16( \
		1433	(__i8x16)(__a), (__i8x16)(__b), __c0, __c1, __c2, __c3, __c4, __c5, \
		1434	__c6, __c7, __c8, __c9, __c10, __c11, __c12, __c13, __c14, __c15))
		1435
		1436	#define wasm_i16x8_shuffle(__a, __b, __c0, __c1, __c2, __c3, __c4, __c5, __c6, \
		1437	__c7) \
		1438	((v128_t)__builtin_wasm_shuffle_i8x16( \
		1439	(__i8x16)(__a), (__i8x16)(__b), (__c0)2, (__c0)2 + 1, (__c1)*2, \
		1440	(__c1)2 + 1, (__c2)2, (__c2)2 + 1, (__c3)2, (__c3)2 + 1, (__c4)2, \
		1441	(__c4)2 + 1, (__c5)2, (__c5)2 + 1, (__c6)2, (__c6)2 + 1, (__c7)2, \
		1442	(__c7)*2 + 1))
		1443
		1444	#define wasm_i32x4_shuffle(__a, __b, __c0, __c1, __c2, __c3) \
		1445	((v128_t)__builtin_wasm_shuffle_i8x16( \
		1446	(__i8x16)(__a), (__i8x16)(__b), (__c0)4, (__c0)4 + 1, (__c0)*4 + 2, \
		1447	(__c0)4 + 3, (__c1)4, (__c1)4 + 1, (__c1)4 + 2, (__c1)*4 + 3, \
		1448	(__c2)4, (__c2)4 + 1, (__c2)4 + 2, (__c2)4 + 3, (__c3)*4, \
		1449	(__c3)4 + 1, (__c3)4 + 2, (__c3)*4 + 3))
		1450
		1451	#define wasm_i64x2_shuffle(__a, __b, __c0, __c1) \
		1452	((v128_t)__builtin_wasm_shuffle_i8x16( \
		1453	(__i8x16)(__a), (__i8x16)(__b), (__c0)8, (__c0)8 + 1, (__c0)*8 + 2, \
		1454	(__c0)8 + 3, (__c0)8 + 4, (__c0)8 + 5, (__c0)8 + 6, (__c0)*8 + 7, \
		1455	(__c1)8, (__c1)8 + 1, (__c1)8 + 2, (__c1)8 + 3, (__c1)*8 + 4, \
		1456	(__c1)8 + 5, (__c1)8 + 6, (__c1)*8 + 7))
		1457
		1458	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i8x16_swizzle(v128_t __a,
		1459	v128_t __b) {
		1460	return (v128_t)__builtin_wasm_swizzle_i8x16((__i8x16)__a, (__i8x16)__b);
		1461	}
		1462
		1463	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1464	wasm_i8x16_narrow_i16x8(v128_t __a, v128_t __b) {
		1465	return (v128_t)__builtin_wasm_narrow_s_i8x16_i16x8((__i16x8)__a,
		1466	(__i16x8)__b);
		1467	}
		1468
		1469	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1470	wasm_u8x16_narrow_i16x8(v128_t __a, v128_t __b) {
		1471	return (v128_t)__builtin_wasm_narrow_u_i8x16_i16x8((__i16x8)__a,
		1472	(__i16x8)__b);
		1473	}
		1474
		1475	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1476	wasm_i16x8_narrow_i32x4(v128_t __a, v128_t __b) {
		1477	return (v128_t)__builtin_wasm_narrow_s_i16x8_i32x4((__i32x4)__a,
		1478	(__i32x4)__b);
		1479	}
		1480
		1481	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1482	wasm_u16x8_narrow_i32x4(v128_t __a, v128_t __b) {
		1483	return (v128_t)__builtin_wasm_narrow_u_i16x8_i32x4((__i32x4)__a,
		1484	(__i32x4)__b);
		1485	}
		1486
		1487	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1488	wasm_i16x8_extend_low_i8x16(v128_t __a) {
		1489	return (v128_t) __builtin_convertvector(
		1490	(__i8x8){((__i8x16)__a)[0], ((__i8x16)__a)[1], ((__i8x16)__a)[2],
		1491	((__i8x16)__a)[3], ((__i8x16)__a)[4], ((__i8x16)__a)[5],
		1492	((__i8x16)__a)[6], ((__i8x16)__a)[7]},
		1493	__i16x8);
		1494	}
		1495
		1496	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1497	wasm_i16x8_extend_high_i8x16(v128_t __a) {
		1498	return (v128_t) __builtin_convertvector(
		1499	(__i8x8){((__i8x16)__a)[8], ((__i8x16)__a)[9], ((__i8x16)__a)[10],
		1500	((__i8x16)__a)[11], ((__i8x16)__a)[12], ((__i8x16)__a)[13],
		1501	((__i8x16)__a)[14], ((__i8x16)__a)[15]},
		1502	__i16x8);
		1503	}
		1504
		1505	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1506	wasm_u16x8_extend_low_u8x16(v128_t __a) {
		1507	return (v128_t) __builtin_convertvector(
		1508	(__u8x8){((__u8x16)__a)[0], ((__u8x16)__a)[1], ((__u8x16)__a)[2],
		1509	((__u8x16)__a)[3], ((__u8x16)__a)[4], ((__u8x16)__a)[5],
		1510	((__u8x16)__a)[6], ((__u8x16)__a)[7]},
		1511	__u16x8);
		1512	}
		1513
		1514	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1515	wasm_u16x8_extend_high_u8x16(v128_t __a) {
		1516	return (v128_t) __builtin_convertvector(
		1517	(__u8x8){((__u8x16)__a)[8], ((__u8x16)__a)[9], ((__u8x16)__a)[10],
		1518	((__u8x16)__a)[11], ((__u8x16)__a)[12], ((__u8x16)__a)[13],
		1519	((__u8x16)__a)[14], ((__u8x16)__a)[15]},
		1520	__u16x8);
		1521	}
		1522
		1523	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1524	wasm_i32x4_extend_low_i16x8(v128_t __a) {
		1525	return (v128_t) __builtin_convertvector(
		1526	(__i16x4){((__i16x8)__a)[0], ((__i16x8)__a)[1], ((__i16x8)__a)[2],
		1527	((__i16x8)__a)[3]},
		1528	__i32x4);
		1529	}
		1530
		1531	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1532	wasm_i32x4_extend_high_i16x8(v128_t __a) {
		1533	return (v128_t) __builtin_convertvector(
		1534	(__i16x4){((__i16x8)__a)[4], ((__i16x8)__a)[5], ((__i16x8)__a)[6],
		1535	((__i16x8)__a)[7]},
		1536	__i32x4);
		1537	}
		1538
		1539	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1540	wasm_u32x4_extend_low_u16x8(v128_t __a) {
		1541	return (v128_t) __builtin_convertvector(
		1542	(__u16x4){((__u16x8)__a)[0], ((__u16x8)__a)[1], ((__u16x8)__a)[2],
		1543	((__u16x8)__a)[3]},
		1544	__u32x4);
		1545	}
		1546
		1547	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1548	wasm_u32x4_extend_high_u16x8(v128_t __a) {
		1549	return (v128_t) __builtin_convertvector(
		1550	(__u16x4){((__u16x8)__a)[4], ((__u16x8)__a)[5], ((__u16x8)__a)[6],
		1551	((__u16x8)__a)[7]},
		1552	__u32x4);
		1553	}
		1554
		1555	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1556	wasm_i64x2_extend_low_i32x4(v128_t __a) {
		1557	return (v128_t) __builtin_convertvector(
		1558	(__i32x2){((__i32x4)__a)[0], ((__i32x4)__a)[1]}, __i64x2);
		1559	}
		1560
		1561	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1562	wasm_i64x2_extend_high_i32x4(v128_t __a) {
		1563	return (v128_t) __builtin_convertvector(
		1564	(__i32x2){((__i32x4)__a)[2], ((__i32x4)__a)[3]}, __i64x2);
		1565	}
		1566
		1567	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1568	wasm_u64x2_extend_low_u32x4(v128_t __a) {
		1569	return (v128_t) __builtin_convertvector(
		1570	(__u32x2){((__u32x4)__a)[0], ((__u32x4)__a)[1]}, __u64x2);
		1571	}
		1572
		1573	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1574	wasm_u64x2_extend_high_u32x4(v128_t __a) {
		1575	return (v128_t) __builtin_convertvector(
		1576	(__u32x2){((__u32x4)__a)[2], ((__u32x4)__a)[3]}, __u64x2);
		1577	}
		1578
		1579	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1580	wasm_i16x8_extadd_pairwise_i8x16(v128_t __a) {
		1581	return (v128_t)__builtin_wasm_extadd_pairwise_i8x16_s_i16x8((__i8x16)__a);
		1582	}
		1583
		1584	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1585	wasm_u16x8_extadd_pairwise_u8x16(v128_t __a) {
		1586	return (v128_t)__builtin_wasm_extadd_pairwise_i8x16_u_i16x8((__u8x16)__a);
		1587	}
		1588
		1589	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1590	wasm_i32x4_extadd_pairwise_i16x8(v128_t __a) {
		1591	return (v128_t)__builtin_wasm_extadd_pairwise_i16x8_s_i32x4((__i16x8)__a);
		1592	}
		1593
		1594	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1595	wasm_u32x4_extadd_pairwise_u16x8(v128_t __a) {
		1596	return (v128_t)__builtin_wasm_extadd_pairwise_i16x8_u_i32x4((__u16x8)__a);
		1597	}
		1598
		1599	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1600	wasm_i16x8_extmul_low_i8x16(v128_t __a, v128_t __b) {
		1601	return (v128_t)((__i16x8)wasm_i16x8_extend_low_i8x16(__a) *
		1602	(__i16x8)wasm_i16x8_extend_low_i8x16(__b));
		1603	}
		1604
		1605	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1606	wasm_i16x8_extmul_high_i8x16(v128_t __a, v128_t __b) {
		1607	return (v128_t)((__i16x8)wasm_i16x8_extend_high_i8x16(__a) *
		1608	(__i16x8)wasm_i16x8_extend_high_i8x16(__b));
		1609	}
		1610
		1611	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1612	wasm_u16x8_extmul_low_u8x16(v128_t __a, v128_t __b) {
		1613	return (v128_t)((__u16x8)wasm_u16x8_extend_low_u8x16(__a) *
		1614	(__u16x8)wasm_u16x8_extend_low_u8x16(__b));
		1615	}
		1616
		1617	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1618	wasm_u16x8_extmul_high_u8x16(v128_t __a, v128_t __b) {
		1619	return (v128_t)((__u16x8)wasm_u16x8_extend_high_u8x16(__a) *
		1620	(__u16x8)wasm_u16x8_extend_high_u8x16(__b));
		1621	}
		1622
		1623	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1624	wasm_i32x4_extmul_low_i16x8(v128_t __a, v128_t __b) {
		1625	return (v128_t)((__i32x4)wasm_i32x4_extend_low_i16x8(__a) *
		1626	(__i32x4)wasm_i32x4_extend_low_i16x8(__b));
		1627	}
		1628
		1629	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1630	wasm_i32x4_extmul_high_i16x8(v128_t __a, v128_t __b) {
		1631	return (v128_t)((__i32x4)wasm_i32x4_extend_high_i16x8(__a) *
		1632	(__i32x4)wasm_i32x4_extend_high_i16x8(__b));
		1633	}
		1634
		1635	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1636	wasm_u32x4_extmul_low_u16x8(v128_t __a, v128_t __b) {
		1637	return (v128_t)((__u32x4)wasm_u32x4_extend_low_u16x8(__a) *
		1638	(__u32x4)wasm_u32x4_extend_low_u16x8(__b));
		1639	}
		1640
		1641	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1642	wasm_u32x4_extmul_high_u16x8(v128_t __a, v128_t __b) {
		1643	return (v128_t)((__u32x4)wasm_u32x4_extend_high_u16x8(__a) *
		1644	(__u32x4)wasm_u32x4_extend_high_u16x8(__b));
		1645	}
		1646
		1647	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1648	wasm_i64x2_extmul_low_i32x4(v128_t __a, v128_t __b) {
		1649	return (v128_t)((__i64x2)wasm_i64x2_extend_low_i32x4(__a) *
		1650	(__i64x2)wasm_i64x2_extend_low_i32x4(__b));
		1651	}
		1652
		1653	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1654	wasm_i64x2_extmul_high_i32x4(v128_t __a, v128_t __b) {
		1655	return (v128_t)((__i64x2)wasm_i64x2_extend_high_i32x4(__a) *
		1656	(__i64x2)wasm_i64x2_extend_high_i32x4(__b));
		1657	}
		1658
		1659	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1660	wasm_u64x2_extmul_low_u32x4(v128_t __a, v128_t __b) {
		1661	return (v128_t)((__u64x2)wasm_u64x2_extend_low_u32x4(__a) *
		1662	(__u64x2)wasm_u64x2_extend_low_u32x4(__b));
		1663	}
		1664
		1665	static __inline__ v128_t __DEFAULT_FN_ATTRS
		1666	wasm_u64x2_extmul_high_u32x4(v128_t __a, v128_t __b) {
		1667	return (v128_t)((__u64x2)wasm_u64x2_extend_high_u32x4(__a) *
		1668	(__u64x2)wasm_u64x2_extend_high_u32x4(__b));
		1669	}
		1670
		1671	static __inline__ v128_t __DEFAULT_FN_ATTRS wasm_i16x8_q15mulr_sat(v128_t __a,
		1672	v128_t __b) {
		1673	return (v128_t)__builtin_wasm_q15mulr_sat_s_i16x8((__i16x8)__a, (__i16x8)__b);
		1674	}
		1675
		1676	// Old intrinsic names supported to ease transitioning to the standard names. Do
		1677	// not use these; they will be removed in the near future.
		1678
		1679	#define __DEPRECATED_FN_ATTRS(__replacement) \
		1680	__DEFAULT_FN_ATTRS __attribute__( \
		1681	(deprecated("use " __replacement " instead", __replacement)))
		1682
		1683	#define __WASM_STR(X) #X
		1684
		1685	#ifdef __DEPRECATED
		1686	#define __DEPRECATED_WASM_MACRO(__name, __replacement) \
		1687	_Pragma(__WASM_STR(GCC warning( \
		1688	"'" __name "' is deprecated: use '" __replacement "' instead")))
		1689	#else
		1690	#define __DEPRECATED_WASM_MACRO(__name, __replacement)
		1691	#endif
		1692
		1693	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_v128_load8_splat")
		1694	wasm_v8x16_load_splat(const void *__mem) {
		1695	return wasm_v128_load8_splat(__mem);
		1696	}
		1697
		1698	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_v128_load16_splat")
		1699	wasm_v16x8_load_splat(const void *__mem) {
		1700	return wasm_v128_load16_splat(__mem);
		1701	}
		1702
		1703	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_v128_load32_splat")
		1704	wasm_v32x4_load_splat(const void *__mem) {
		1705	return wasm_v128_load32_splat(__mem);
		1706	}
		1707
		1708	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_v128_load64_splat")
		1709	wasm_v64x2_load_splat(const void *__mem) {
		1710	return wasm_v128_load64_splat(__mem);
		1711	}
		1712
		1713	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i16x8_load8x8")
		1714	wasm_i16x8_load_8x8(const void *__mem) {
		1715	return wasm_i16x8_load8x8(__mem);
		1716	}
		1717
		1718	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u16x8_load8x8")
		1719	wasm_u16x8_load_8x8(const void *__mem) {
		1720	return wasm_u16x8_load8x8(__mem);
		1721	}
		1722
		1723	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i32x4_load16x4")
		1724	wasm_i32x4_load_16x4(const void *__mem) {
		1725	return wasm_i32x4_load16x4(__mem);
		1726	}
		1727
		1728	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u32x4_load16x4")
		1729	wasm_u32x4_load_16x4(const void *__mem) {
		1730	return wasm_u32x4_load16x4(__mem);
		1731	}
		1732
		1733	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i64x2_load32x2")
		1734	wasm_i64x2_load_32x2(const void *__mem) {
		1735	return wasm_i64x2_load32x2(__mem);
		1736	}
		1737
		1738	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u64x2_load32x2")
		1739	wasm_u64x2_load_32x2(const void *__mem) {
		1740	return wasm_u64x2_load32x2(__mem);
		1741	}
		1742
		1743	#define wasm_v8x16_shuffle(__a, __b, __c0, __c1, __c2, __c3, __c4, __c5, __c6, \
		1744	__c7, __c8, __c9, __c10, __c11, __c12, __c13, \
		1745	__c14, __c15) \
		1746	__DEPRECATED_WASM_MACRO("wasm_v8x16_shuffle", "wasm_i8x16_shuffle") \
		1747	wasm_i8x16_shuffle(__a, __b, __c0, __c1, __c2, __c3, __c4, __c5, __c6, __c7, \
		1748	__c8, __c9, __c10, __c11, __c12, __c13, __c14, __c15)
		1749
		1750	#define wasm_v16x8_shuffle(__a, __b, __c0, __c1, __c2, __c3, __c4, __c5, __c6, \
		1751	__c7) \
		1752	__DEPRECATED_WASM_MACRO("wasm_v16x8_shuffle", "wasm_i16x8_shuffle") \
		1753	wasm_i16x8_shuffle(__a, __b, __c0, __c1, __c2, __c3, __c4, __c5, __c6, __c7)
		1754
		1755	#define wasm_v32x4_shuffle(__a, __b, __c0, __c1, __c2, __c3) \
		1756	__DEPRECATED_WASM_MACRO("wasm_v32x4_shuffle", "wasm_i32x4_shuffle") \
		1757	wasm_i32x4_shuffle(__a, __b, __c0, __c1, __c2, __c3)
		1758
		1759	#define wasm_v64x2_shuffle(__a, __b, __c0, __c1) \
		1760	__DEPRECATED_WASM_MACRO("wasm_v64x2_shuffle", "wasm_i64x2_shuffle") \
		1761	wasm_i64x2_shuffle(__a, __b, __c0, __c1)
		1762
		1763	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i8x16_swizzle")
		1764	wasm_v8x16_swizzle(v128_t __a, v128_t __b) {
		1765	return wasm_i8x16_swizzle(__a, __b);
		1766	}
		1767
		1768	static __inline__ bool __DEPRECATED_FN_ATTRS("wasm_v128_any_true")
		1769	wasm_i8x16_any_true(v128_t __a) {
		1770	return wasm_v128_any_true(__a);
		1771	}
		1772
		1773	static __inline__ bool __DEPRECATED_FN_ATTRS("wasm_v128_any_true")
		1774	wasm_i16x8_any_true(v128_t __a) {
		1775	return wasm_v128_any_true(__a);
		1776	}
		1777
		1778	static __inline__ bool __DEPRECATED_FN_ATTRS("wasm_v128_any_true")
		1779	wasm_i32x4_any_true(v128_t __a) {
		1780	return wasm_v128_any_true(__a);
		1781	}
		1782
		1783	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i8x16_add_sat")
		1784	wasm_i8x16_add_saturate(v128_t __a, v128_t __b) {
		1785	return wasm_i8x16_add_sat(__a, __b);
		1786	}
		1787
		1788	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u8x16_add_sat")
		1789	wasm_u8x16_add_saturate(v128_t __a, v128_t __b) {
		1790	return wasm_u8x16_add_sat(__a, __b);
		1791	}
		1792
		1793	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i8x16_sub_sat")
		1794	wasm_i8x16_sub_saturate(v128_t __a, v128_t __b) {
		1795	return wasm_i8x16_sub_sat(__a, __b);
		1796	}
		1797
		1798	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u8x16_sub_sat")
		1799	wasm_u8x16_sub_saturate(v128_t __a, v128_t __b) {
		1800	return wasm_u8x16_sub_sat(__a, __b);
		1801	}
		1802
		1803	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i16x8_add_sat")
		1804	wasm_i16x8_add_saturate(v128_t __a, v128_t __b) {
		1805	return wasm_i16x8_add_sat(__a, __b);
		1806	}
		1807
		1808	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u16x8_add_sat")
		1809	wasm_u16x8_add_saturate(v128_t __a, v128_t __b) {
		1810	return wasm_u16x8_add_sat(__a, __b);
		1811	}
		1812
		1813	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i16x8_sub_sat")
		1814	wasm_i16x8_sub_saturate(v128_t __a, v128_t __b) {
		1815	return wasm_i16x8_sub_sat(__a, __b);
		1816	}
		1817
		1818	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u16x8_sub_sat")
		1819	wasm_u16x8_sub_saturate(v128_t __a, v128_t __b) {
		1820	return wasm_u16x8_sub_sat(__a, __b);
		1821	}
		1822
		1823	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i16x8_extend_low_i8x16")
		1824	wasm_i16x8_widen_low_i8x16(v128_t __a) {
		1825	return wasm_i16x8_extend_low_i8x16(__a);
		1826	}
		1827
		1828	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i16x8_extend_high_i8x16")
		1829	wasm_i16x8_widen_high_i8x16(v128_t __a) {
		1830	return wasm_i16x8_extend_high_i8x16(__a);
		1831	}
		1832
		1833	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u16x8_extend_low_u8x16")
		1834	wasm_i16x8_widen_low_u8x16(v128_t __a) {
		1835	return wasm_u16x8_extend_low_u8x16(__a);
		1836	}
		1837
		1838	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u16x8_extend_high_u8x16")
		1839	wasm_i16x8_widen_high_u8x16(v128_t __a) {
		1840	return wasm_u16x8_extend_high_u8x16(__a);
		1841	}
		1842
		1843	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i32x4_extend_low_i16x8")
		1844	wasm_i32x4_widen_low_i16x8(v128_t __a) {
		1845	return wasm_i32x4_extend_low_i16x8(__a);
		1846	}
		1847
		1848	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i32x4_extend_high_i16x8")
		1849	wasm_i32x4_widen_high_i16x8(v128_t __a) {
		1850	return wasm_i32x4_extend_high_i16x8(__a);
		1851	}
		1852
		1853	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u32x4_extend_low_u16x8")
		1854	wasm_i32x4_widen_low_u16x8(v128_t __a) {
		1855	return wasm_u32x4_extend_low_u16x8(__a);
		1856	}
		1857
		1858	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u32x4_extend_high_u16x8")
		1859	wasm_i32x4_widen_high_u16x8(v128_t __a) {
		1860	return wasm_u32x4_extend_high_u16x8(__a);
		1861	}
		1862
		1863	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_i32x4_trunc_sat_f32x4")
		1864	wasm_i32x4_trunc_saturate_f32x4(v128_t __a) {
		1865	return wasm_i32x4_trunc_sat_f32x4(__a);
		1866	}
		1867
		1868	static __inline__ v128_t __DEPRECATED_FN_ATTRS("wasm_u32x4_trunc_sat_f32x4")
		1869	wasm_u32x4_trunc_saturate_f32x4(v128_t __a) {
		1870	return wasm_u32x4_trunc_sat_f32x4(__a);
		1871	}
		1872
		1873	// Undefine helper macros
		1874	#undef __DEFAULT_FN_ATTRS
		1875	#undef __DEPRECATED_FN_ATTRS
		1876
		1877	#endif // __WASM_SIMD128_H

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/lib/clang/16/include/wasm_simd128.h – Rev 14