Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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
  1878.