aarch64: Port NEON lane get/set intrinsics to pragma-based framework

Port the following intrinsics to the pragma-based framework:

* vget_lane
* vget_high
* vget_low
* vset_lane
* vdup_lane
* vcopy_lane

gcc/ChangeLog:

	* config/aarch64/aarch64-simd-pragma-builtins.def (
	vcopy_lane_mf8, vcopyq_lane_mf8, vcopy_laneq_mf8,
	vcopyq_laneq_mf8, vdup_lane_mf8, vdupq_lane_mf8,
	vdup_laneq_mf8, vdupq_laneq_mf8, vset_lane_mf8,
	vsetq_lane_mf8): Delete entries.
	* config/aarch64/aarch64-builtins.cc
	(AARCH64_SIMD_VGET_LOW_BUILTINS,
	AARCH64_SIMD_VGET_HIGH_BUILTINS, VGET_LOW_BUILTIN,
	VGET_HIGH_BUILTIN): Delete macros.
	(enum aarch64_builtins): Delete
	`AARCH64_SIMD_BUILTIN_LANE_CHECK`.
	(aarch64_init_simd_builtin_functions): Delete code that
	registers `__builtin_aarch64_im_lane_boundsi`.
	(aarch64_pragma_builtins_checker::check): Delete cases for
	`UNSPEC_DUP_LANE`, `UNSPEC_GET_LANE` and `UNSPEC_VEC_COPY`.
	(aarch64_simd_expand_builtin): Delete case for
	`AARCH64_SIMD_BUILTIN_LANE_CHECK`.
	(aarch64_expand_pragma_builtin): Delete cases for
	`UNSPEC_DUP_LANE` and `UNSPEC_VEC_COPY`.
	(aarch64_general_fold_builtin): Delete cases for
	`AARCH64_SIMD_VGET_LOW_BUILTINS`,
	`AARCH64_SIMD_VGET_HIGH_BUILTINS` and
	`AARCH64_SIMD_BUILTIN_LANE_CHECK`.
	(aarch64_gimple_fold_pragma_builtin): Delete cases for
	`UNSPEC_DUP_LANE` and `UNSPEC_VEC_COPY`.
	(aarch64_general_gimple_fold_builtin): Delete cases for
	`AARCH64_SIMD_BUILTIN_LANE_CHECK`.
	* config/aarch64/aarch64.md (UNSPEC_DUP_LANE): Delete unspec.
	* config/aarch64/aarch64-neon-builtins-shapes.cc (range, lane):
	New functions.
	(struct neon_shape): Add new fields for additional checks, and
	call them in `check()`.
	* config/aarch64/aarch64-acle-builtins.cc
	(gimple_folder::force_val, gimple_folder::assign): New
	functions.
	* config/aarch64/aarch64-acle-builtins.h (TYPES_all_neon,
	TYPES_bhsd_neon, TYPES_neon_copy_lane): New type lists.
	* config/aarch64/iterators.md (VALL_F16_NO_V2Q): Add `V4BF` and `V8BF`.
	* config/aarch64/aarch64-neon-builtins-base.def (vget_lane,
	vgetq_lane, vget_high, vget_low, vset_lane, vsetq_lane,
	vdup_lane, vdupq_lane, vdup_laneq, vdupq_laneq, vcopy_lane,
	vcopy_laneq, vcopyq_lane, vcopyq_laneq): New function groups.
	* config/aarch64/aarch64-neon-builtins-base.cc (build_lane_get,
	build_lane_set, build_vec_dup): New functions.
	(struct gimple_get_lane, struct gimple_get_half, struct
	gimple_set_lane, struct gimple_copy_lane, struct gimple_dup,
	struct gimple_dup_lane): New structs.
	(vget_lane, vgetq_lane, vset_lane, vsetq_lane, vcopy_lane,
	vcopyq_lane, vcopy_laneq, vcopyq_laneq, vdup_lane, vdupq_lane,
	vdupq_lane, vdupq_laneq): New function bases.
	* config/aarch64/arm_neon.h (__aarch64_vdup_lane_p8,
	__aarch64_vdup_lane_p16, __aarch64_vdup_lane_p64,
	__aarch64_vdup_lane_s8, __aarch64_vdup_lane_s16,
	__aarch64_vdup_lane_s32, __aarch64_vdup_lane_s64,
	__aarch64_vdup_lane_u8, __aarch64_vdup_lane_u16,
	__aarch64_vdup_lane_u32, __aarch64_vdup_lane_u64,
	__aarch64_vdup_laneq_p8, __aarch64_vdup_laneq_p16,
	__aarch64_vdup_laneq_p64, __aarch64_vdup_laneq_s8,
	__aarch64_vdup_laneq_s16, __aarch64_vdup_laneq_s32,
	__aarch64_vdup_laneq_s64, __aarch64_vdup_laneq_u8,
	__aarch64_vdup_laneq_u16, __aarch64_vdup_laneq_u32,
	__aarch64_vdup_laneq_u64, __aarch64_vdupq_lane_p8,
	__aarch64_vdupq_lane_p16, __aarch64_vdupq_lane_p64,
	__aarch64_vdupq_lane_s8, __aarch64_vdupq_lane_s16,
	__aarch64_vdupq_lane_s32, __aarch64_vdupq_lane_s64,
	__aarch64_vdupq_lane_u8, __aarch64_vdupq_lane_u16,
	__aarch64_vdupq_lane_u32, __aarch64_vdupq_lane_u64,
	__aarch64_vdupq_laneq_p8, __aarch64_vdupq_laneq_p16,
	__aarch64_vdupq_laneq_p64, __aarch64_vdupq_laneq_s8,
	__aarch64_vdupq_laneq_s16, __aarch64_vdupq_laneq_s32,
	__aarch64_vdupq_laneq_s64, __aarch64_vdupq_laneq_u8,
	__aarch64_vdupq_laneq_u16, __aarch64_vdupq_laneq_u32,
	__aarch64_vdupq_laneq_u64, __AARCH64_LANE_CHECK,
	__aarch64_vget_lane_any, __aarch64_vset_lane_any): Delete
	macros.
	(vget_lane_f16, vget_lane_f32, vget_lane_f64, vget_lane_p8,
	vget_lane_p16, vget_lane_p64, vget_lane_s8, vget_lane_s16,
	vget_lane_s32, vget_lane_s64, vget_lane_u8, vget_lane_u16,
	vget_lane_u32, vget_lane_u64, vgetq_lane_f16, vgetq_lane_f32,
	vgetq_lane_f64, vgetq_lane_p8, vgetq_lane_p16, vgetq_lane_p64,
	vgetq_lane_s8, vgetq_lane_s16, vgetq_lane_s32, vgetq_lane_s64,
	vgetq_lane_u8, vgetq_lane_u16, vgetq_lane_u32, vgetq_lane_u64,
	vset_lane_f16, vset_lane_f32, vset_lane_f64, vset_lane_p8,
	vset_lane_p16, vset_lane_p64, vset_lane_s8, vset_lane_s16,
	vset_lane_s32, vset_lane_s64, vset_lane_u8, vset_lane_u16,
	vset_lane_u32, vset_lane_u64, vsetq_lane_f16, vsetq_lane_f32,
	vsetq_lane_f64, vsetq_lane_p8, vsetq_lane_p16, vsetq_lane_p64,
	vsetq_lane_s8, vsetq_lane_s16, vsetq_lane_s32, vsetq_lane_s64,
	vsetq_lane_u8, vsetq_lane_u16, vsetq_lane_u32, vsetq_lane_u64,
	vcopy_lane_f32, vcopy_lane_f64, vcopy_lane_p8, vcopy_lane_p16,
	vcopy_lane_p64, vcopy_lane_s8, vcopy_lane_s16, vcopy_lane_s32,
	vcopy_lane_s64, vcopy_lane_u8, vcopy_lane_u16, vcopy_lane_u32,
	vcopy_lane_u64, vcopy_laneq_f32, vcopy_laneq_f64,
	vcopy_laneq_p8, vcopy_laneq_p16, vcopy_laneq_p64,
	vcopy_laneq_s8, vcopy_laneq_s16, vcopy_laneq_s32,
	vcopy_laneq_s64, vcopy_laneq_u8, vcopy_laneq_u16,
	vcopy_laneq_u32, vcopy_laneq_u64, vcopyq_lane_f32,
	vcopyq_lane_f64, vcopyq_lane_p8, vcopyq_lane_p16,
	vcopyq_lane_p64, vcopyq_lane_s8, vcopyq_lane_s16,
	vcopyq_lane_s32, vcopyq_lane_s64, vcopyq_lane_u8,
	vcopyq_lane_u16, vcopyq_lane_u32, vcopyq_lane_u64,
	vcopyq_laneq_f32, vcopyq_laneq_f64, vcopyq_laneq_p8,
	vcopyq_laneq_p16, vcopyq_laneq_p64, vcopyq_laneq_s8,
	vcopyq_laneq_s16, vcopyq_laneq_s32, vcopyq_laneq_s64,
	vcopyq_laneq_u8, vcopyq_laneq_u16, vcopyq_laneq_u32,
	vcopyq_laneq_u64, vdup_lane_f16, vdup_lane_f32, vdup_lane_f64,
	vdup_lane_p8, vdup_lane_p16, vdup_lane_p64, vdup_lane_s8,
	vdup_lane_s16, vdup_lane_s32, vdup_lane_s64, vdup_lane_u8,
	vdup_lane_u16, vdup_lane_u32, vdup_lane_u64, vdup_laneq_f16,
	vdup_laneq_f32, vdup_laneq_f64, vdup_laneq_p8, vdup_laneq_p16,
	vdup_laneq_p64, vdup_laneq_s8, vdup_laneq_s16, vdup_laneq_s32,
	vdup_laneq_s64, vdup_laneq_u8, vdup_laneq_u16, vdup_laneq_u32,
	vdup_laneq_u64, vdupq_lane_f16, vdupq_lane_f32,
	vdupq_lane_f64, vdupq_lane_p8, vdupq_lane_p16, vdupq_lane_p64,
	vdupq_lane_s8, vdupq_lane_s16, vdupq_lane_s32, vdupq_lane_s64,
	vdupq_lane_u8, vdupq_lane_u16, vdupq_lane_u32, vdupq_lane_u64,
	vdupq_laneq_f16, vdupq_laneq_f32, vdupq_laneq_f64,
	vdupq_laneq_p8, vdupq_laneq_p16, vdupq_laneq_p64,
	vdupq_laneq_s8, vdupq_laneq_s16, vdupq_laneq_s32,
	vdupq_laneq_s64, vdupq_laneq_u8, vdupq_laneq_u16,
	vdupq_laneq_u32, vdupq_laneq_u64, vmulq_lane_f64,
	vset_lane_bf16, vsetq_lane_bf16, vget_lane_bf16,
	vgetq_lane_bf16, vdup_lane_bf16, vdup_laneq_bf16,
	vdupq_lane_bf16, vdupq_laneq_bf16, vcopy_lane_bf16,
	vcopyq_lane_bf16, vcopy_laneq_bf16, vcopyq_laneq_bf16): Delete
	functions.

gcc/testsuite/ChangeLog:

	* gcc.target/aarch64/simd/mf8_data_2.c: Fix test.
	* gcc.target/aarch64/simd/fold_to_highpart_6.c: Fix test.
	* g++.target/aarch64/lane-bound-1.C: Fix test.
	* gcc.target/aarch64/advsimd-intrinsics/bf16_vect_copy_lane_1.c:
	Fix test.
	* gcc.target/aarch64/lane-bound-3.c: Fix test.
	* gcc.target/aarch64/pr113573.c: Fix test.
	* gcc.target/aarch64/simd/vset_lane_s16_const_1.c: Fix test.
	* gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_1.c,
	gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_2.c,
	gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_1.c,
	gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_2.c,
	gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_1.c,
	gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_2.c,
	gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_1.c,
	gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_2.c: Replace with...
	gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_indices.c: ...this.
	* gcc.target/aarch64/simd/vget_lane_f32_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_f64_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_p16_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_p8_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_s16_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_s32_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_s64_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_s8_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_u16_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_u32_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_u64_indices_1.c,
	gcc.target/aarch64/simd/vget_lane_u8_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_f32_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_f64_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_p16_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_p8_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_s16_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_s32_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_s64_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_s8_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_u16_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_u32_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_u64_indices_1.c,
	gcc.target/aarch64/simd/vgetq_lane_u8_indices_1.c: Replace with...
	* gcc.target/aarch64/simd/vget_lane_indices.c: ...this.
	* gcc.target/aarch64/neon/arm_neon_test.h(VEC_LEN): New macro.
	* gcc.target/aarch64/neon/vcopy_lane.c: New test.
	* gcc.target/aarch64/neon/vdup_lane.c: New test.
	* gcc.target/aarch64/neon/vget_lane.c: New test.
	* gcc.target/aarch64/neon/vset_lane.c: New test.

diff --git a/gcc/config/aarch64/aarch64-acle-builtins.cc b/gcc/config/aarch64/aarch64-acle-builtins.cc
index f441509ea0e614f22829c729113c9b26eddce31c..426316001ced864081e798b50c7dcb3281a77834 100644 (file)
--- a/gcc/config/aarch64/aarch64-acle-builtins.cc
+++ b/gcc/config/aarch64/aarch64-acle-builtins.cc
@@ -2542,18 +2542,21 @@ function_checker::require_immediate (unsigned int argno,
   gcc_assert (argno < m_nargs);
   tree arg = m_args[argno];
 
-  /* The type and range are unsigned, so read the argument as an
-     unsigned rather than signed HWI.  */
-  if (!tree_fits_uhwi_p (arg))
+  if (tree_fits_shwi_p (arg))
+    {
+      value_out = tree_to_shwi (arg);
+      return true;
+    }
+  else if (tree_fits_uhwi_p (arg))
+    {
+      value_out = tree_to_uhwi (arg);
+      return true;
+    }
+  else
     {
       report_non_ice (location, fndecl, argno);
       return false;
     }
-
-  /* ...but treat VALUE_OUT as signed for error reporting, since printing
-     -1 is more user-friendly than the maximum uint64_t value.  */
-  value_out = tree_to_uhwi (arg);
-  return true;
 }
 
 /* Check that argument REL_ARGNO is an integer constant expression that
@@ -3106,6 +3109,28 @@ gimple_folder::force_val (tree expr)
   return var;
 }
 
+/* Insert a `lhs = rhs` statement before the current statement.
+   Returns the new statement.  */
+gassign *
+gimple_folder::assign (tree lhs, tree rhs)
+{
+  auto stmt = gimple_build_assign (lhs, rhs);
+  gsi_insert_before (this->gsi, stmt, GSI_SAME_STMT);
+  return stmt;
+}
+
+/* Insert a `lhs = code<rhs1, rhs2, rhs3>` statement before the current
+   statement.
+   Returns the new statement.  */
+gassign *
+gimple_folder::assign (tree lhs, tree_code code, tree rhs1, tree rhs2,
+                      tree rhs3)
+{
+  auto stmt = gimple_build_assign (lhs, code, rhs1, rhs2, rhs3);
+  gsi_insert_before (this->gsi, stmt, GSI_SAME_STMT);
+  return stmt;
+}
+
 function_expander::function_expander (const function_instance &instance,
                                      tree fndecl, tree call_expr_in,
                                      rtx possible_target_in)

diff --git a/gcc/config/aarch64/aarch64-acle-builtins.h b/gcc/config/aarch64/aarch64-acle-builtins.h
index 150f73d21b7f1ffc949c46606dcc5e99db3a4dd6..d817bf057a5be5936fa6e2a124cc1136987bd57e 100644 (file)
--- a/gcc/config/aarch64/aarch64-acle-builtins.h
+++ b/gcc/config/aarch64/aarch64-acle-builtins.h
@@ -1309,6 +1309,10 @@ function_expander::result_mode () const
   D (s16, s8), D (s32, s16), D (s64, s32), \
   D (u16, u8), D (u32, u16), D (u64, u32)
 
+/* _mf8.  */
+#define TYPES_b_float(S, D, T) \
+  S (mf8)
+
 /* _bf16.  */
 #define TYPES_h_bfloat(S, D, T) \
   S (bf16)
@@ -1767,6 +1771,10 @@ function_expander::result_mode () const
 #define TYPES_za(S, D, T) \
   S (za)
 
+/* _p16 _s16 _u16 _f16 _bf16.  */
+#define TYPES_h_neon(S, D, T) \
+  S (p16), S (s16), S (u16), S (f16), S (bf16)
+
 /* _p8  _s8  _u8  _mf8
    _p16 _s16 _u16 _f16 _bf16
        _s32 _u32 _f32
@@ -1792,6 +1800,19 @@ function_expander::result_mode () const
   TYPES_all_integer (S, D, T), \
   TYPES_all_float (S, D, T)
 
+/* _p8  _s8  _u8  _mf8
+   _p16 _s16 _u16 _bf16
+       _s32 _u32 _f32
+   _p64 _s64 _u64 _f64.  */
+#define TYPES_neon_copy_lane(S, D, T) \
+  TYPES_bhd_poly (S, D, T), \
+  TYPES_all_integer (S, D, T), \
+  S (mf8), S (bf16), S (f32), S (f64)
+
+/* _p8 _s8 _u8.  */
+#define TYPES_b_neon(S, D, T) \
+  S (p8), S (s8), S (u8)
+
 /* Describe a tuple of type suffixes in which only the first is used.  */
 #define DEF_VECTOR_TYPE(X) \
   { TYPE_SUFFIX_ ## X, NUM_TYPE_SUFFIXES, NUM_TYPE_SUFFIXES }
@@ -1926,10 +1947,14 @@ DEF_SVE_TYPES_ARRAY (mop_i16i64_signed);
 DEF_SVE_TYPES_ARRAY (mop_i16i64_unsigned);
 DEF_SVE_TYPES_ARRAY (za);
 
+DEF_SVE_TYPES_ARRAY (b_float);
 DEF_SVE_TYPES_ARRAY (all_neon);
+DEF_SVE_TYPES_ARRAY (b_neon);
+DEF_SVE_TYPES_ARRAY (h_neon);
 DEF_SVE_TYPES_ARRAY (bhd_poly);
 DEF_SVE_TYPES_ARRAY (bhdq_poly);
 DEF_SVE_TYPES_ARRAY (bhsd_neon);
+DEF_SVE_TYPES_ARRAY (neon_copy_lane);
 
 static const group_suffix_index groups_none[] = {
   GROUP_none, NUM_GROUP_SUFFIXES

diff --git a/gcc/config/aarch64/aarch64-builtins.cc b/gcc/config/aarch64/aarch64-builtins.cc
index 6497db6f1b06772a7c576496788a20c4ca8b4484..177eb387ea0b21698712f26e2991adc9b8b892b8 100644 (file)
--- a/gcc/config/aarch64/aarch64-builtins.cc
+++ b/gcc/config/aarch64/aarch64-builtins.cc
@@ -704,42 +704,6 @@ static aarch64_simd_builtin_datum aarch64_simd_builtin_data[] = {
   VREINTERPRET_BUILTINS \
   VREINTERPRETQ_BUILTINS
 
-#define AARCH64_SIMD_VGET_LOW_BUILTINS \
-  VGET_LOW_BUILTIN(mf8) \
-  VGET_LOW_BUILTIN(f16) \
-  VGET_LOW_BUILTIN(f32) \
-  VGET_LOW_BUILTIN(f64) \
-  VGET_LOW_BUILTIN(p8) \
-  VGET_LOW_BUILTIN(p16) \
-  VGET_LOW_BUILTIN(p64) \
-  VGET_LOW_BUILTIN(s8) \
-  VGET_LOW_BUILTIN(s16) \
-  VGET_LOW_BUILTIN(s32) \
-  VGET_LOW_BUILTIN(s64) \
-  VGET_LOW_BUILTIN(u8) \
-  VGET_LOW_BUILTIN(u16) \
-  VGET_LOW_BUILTIN(u32) \
-  VGET_LOW_BUILTIN(u64) \
-  VGET_LOW_BUILTIN(bf16)
-
-#define AARCH64_SIMD_VGET_HIGH_BUILTINS \
-  VGET_HIGH_BUILTIN(mf8) \
-  VGET_HIGH_BUILTIN(f16) \
-  VGET_HIGH_BUILTIN(f32) \
-  VGET_HIGH_BUILTIN(f64) \
-  VGET_HIGH_BUILTIN(p8) \
-  VGET_HIGH_BUILTIN(p16) \
-  VGET_HIGH_BUILTIN(p64) \
-  VGET_HIGH_BUILTIN(s8) \
-  VGET_HIGH_BUILTIN(s16) \
-  VGET_HIGH_BUILTIN(s32) \
-  VGET_HIGH_BUILTIN(s64) \
-  VGET_HIGH_BUILTIN(u8) \
-  VGET_HIGH_BUILTIN(u16) \
-  VGET_HIGH_BUILTIN(u32) \
-  VGET_HIGH_BUILTIN(u64) \
-  VGET_HIGH_BUILTIN(bf16)
-
 #include "aarch64-builtin-pairs.def"
 
 #define LO_HI_PAIRINGS \
@@ -789,12 +753,6 @@ typedef struct
 #define VREINTERPRET_BUILTIN(A, B, L) \
   AARCH64_SIMD_BUILTIN_VREINTERPRET##L##_##A##_##B,
 
-#define VGET_LOW_BUILTIN(A) \
-  AARCH64_SIMD_BUILTIN_VGET_LOW_##A,
-
-#define VGET_HIGH_BUILTIN(A)                     \
-  AARCH64_SIMD_BUILTIN_VGET_HIGH_##A,
-
 #undef VAR1
 #define VAR1(T, N, MAP, FLAG, A) \
   AARCH64_SIMD_BUILTIN_##T##_##N##A,
@@ -834,8 +792,6 @@ enum aarch64_builtins
   AARCH64_CRC32_BUILTIN_MAX,
   /* SIMD intrinsic builtins.  */
   AARCH64_SIMD_VREINTERPRET_BUILTINS
-  AARCH64_SIMD_VGET_LOW_BUILTINS
-  AARCH64_SIMD_VGET_HIGH_BUILTINS
   /* ARMv8.3-A Pointer Authentication Builtins.  */
   AARCH64_PAUTH_BUILTIN_AUTIA1716,
   AARCH64_PAUTH_BUILTIN_PACIA1716,
@@ -948,35 +904,10 @@ static aarch64_fcmla_laneq_builtin_datum aarch64_fcmla_lane_builtin_data[] = {
      && SIMD_INTR_QUAL(A) == SIMD_INTR_QUAL(B) \
   },
 
-#undef VGET_LOW_BUILTIN
-#define VGET_LOW_BUILTIN(A) \
-  {"vget_low_" #A, \
-   AARCH64_SIMD_BUILTIN_VGET_LOW_##A, \
-   2, \
-   { SIMD_INTR_MODE(A, d), SIMD_INTR_MODE(A, q) }, \
-   { SIMD_INTR_QUAL(A), SIMD_INTR_QUAL(A) }, \
-   FLAG_DEFAULT, \
-   false \
-  },
-
-#undef VGET_HIGH_BUILTIN
-#define VGET_HIGH_BUILTIN(A) \
-  {"vget_high_" #A, \
-   AARCH64_SIMD_BUILTIN_VGET_HIGH_##A, \
-   2, \
-   { SIMD_INTR_MODE(A, d), SIMD_INTR_MODE(A, q) }, \
-   { SIMD_INTR_QUAL(A), SIMD_INTR_QUAL(A) }, \
-   FLAG_DEFAULT, \
-   false \
-  },
-
 static const aarch64_simd_intrinsic_datum aarch64_simd_intrinsic_data[] = {
   AARCH64_SIMD_VREINTERPRET_BUILTINS
-  AARCH64_SIMD_VGET_LOW_BUILTINS
-  AARCH64_SIMD_VGET_HIGH_BUILTINS
 };
 
-
 #undef CRC32_BUILTIN
 
 static GTY(()) tree aarch64_builtin_decls[AARCH64_BUILTIN_MAX];
@@ -2897,8 +2828,6 @@ aarch64_pragma_builtins_checker::check ()
 
   switch (builtin_data.unspec)
     {
-    case UNSPEC_DUP_LANE:
-    case UNSPEC_GET_LANE:
     case UNSPEC_LD2_LANE:
     case UNSPEC_LD3_LANE:
     case UNSPEC_LD4_LANE:
@@ -2943,11 +2872,6 @@ aarch64_pragma_builtins_checker::check ()
        return require_immediate_range (nargs - 1, 0, high);
       }
 
-    case UNSPEC_VEC_COPY:
-      /* & rather than && so that we report errors against both indices.  */
-      return (require_immediate_lane_index (1, 0)
-             & require_immediate_lane_index (3, 2));
-
     default:
       return true;
     }
@@ -3187,12 +3111,12 @@ aarch64_simd_expand_builtin (int fcode, tree exp, rtx target)
          && UINTVAL (totalsize) != 0)
        {
          rtx lane_idx = expand_normal (CALL_EXPR_ARG (exp, 2));
-          if (CONST_INT_P (lane_idx))
+         if (CONST_INT_P (lane_idx))
            aarch64_simd_lane_bounds (lane_idx, 0,
                                      UINTVAL (totalsize)
                                       / UINTVAL (elementsize),
                                      exp);
-          else
+         else
            error_at (EXPR_LOCATION (exp),
                      "lane index must be a constant immediate");
        }
@@ -4294,13 +4218,6 @@ aarch64_expand_pragma_builtin (tree exp, rtx target,
        aarch64_dereference_pointer (&ops[1], GET_MODE_INNER (ops[0].mode));
       return expand_vector_broadcast (ops[0].mode, ops[1].value);
 
-    case UNSPEC_DUP_LANE:
-      aarch64_canonicalize_lane (&ops[2], ops[1].mode);
-      if (ops[0].mode == ops[1].mode)
-       icode = code_for_aarch64_dup_lane (ops[0].mode);
-      else
-       icode = code_for_aarch64_dup_lane (ops[0].mode, ops[0].mode);
-      break;
 
     case UNSPEC_EXT:
       icode = code_for_aarch64_ext (ops[0].mode);
@@ -4375,11 +4292,6 @@ aarch64_expand_pragma_builtin (tree exp, rtx target,
        gcc_unreachable ();
       break;
 
-    case UNSPEC_GET_LANE:
-      aarch64_canonicalize_lane (&ops[2], ops[1].mode);
-      icode = code_for_aarch64_get_lane (ops[1].mode);
-      break;
-
     case UNSPEC_LD1:
       icode = code_for_aarch64_ld1 (ops[0].mode);
       break;
@@ -4493,18 +4405,6 @@ aarch64_expand_pragma_builtin (tree exp, rtx target,
     case UNSPEC_UZP:
       return aarch64_expand_permute_pair (ops, UNSPEC_UZP1, UNSPEC_UZP2);
 
-    case UNSPEC_VEC_COPY:
-      {
-       aarch64_convert_to_lane_mask (&ops[2], ops[1].mode);
-       aarch64_canonicalize_lane (&ops[4], ops[3].mode);
-       if (ops[1].mode == ops[3].mode)
-         icode = code_for_aarch64_simd_vec_copy_lane (ops[1].mode);
-       else
-         icode = code_for_aarch64_simd_vec_copy_lane (ops[1].mode,
-                                                      ops[1].mode);
-       break;
-      }
-
     case UNSPEC_ZIP:
       return aarch64_expand_permute_pair (ops, UNSPEC_ZIP1, UNSPEC_ZIP2);
 
@@ -4817,14 +4717,6 @@ aarch64_fold_builtin_lane_check (tree arg0, tree arg1, tree arg2)
 #define VREINTERPRET_BUILTIN(A, B, L) \
   case AARCH64_SIMD_BUILTIN_VREINTERPRET##L##_##A##_##B:
 
-#undef VGET_LOW_BUILTIN
-#define VGET_LOW_BUILTIN(A) \
-  case AARCH64_SIMD_BUILTIN_VGET_LOW_##A:
-
-#undef VGET_HIGH_BUILTIN
-#define VGET_HIGH_BUILTIN(A) \
-  case AARCH64_SIMD_BUILTIN_VGET_HIGH_##A:
-
 /* Try to fold a call to the built-in function with subcode FCODE.  The
    function is passed the N_ARGS arguments in ARGS and it returns a value
    of type TYPE.  Return the new expression on success and NULL_TREE on
@@ -4843,20 +4735,6 @@ aarch64_general_fold_builtin (unsigned int fcode, tree type,
        return fold_build1 (FLOAT_EXPR, type, args[0]);
       AARCH64_SIMD_VREINTERPRET_BUILTINS
        return fold_build1 (VIEW_CONVERT_EXPR, type, args[0]);
-      AARCH64_SIMD_VGET_LOW_BUILTINS
-       {
-         auto pos = BYTES_BIG_ENDIAN ? 64 : 0;
-
-         return fold_build3 (BIT_FIELD_REF, type, args[0], bitsize_int (64),
-                             bitsize_int (pos));
-       }
-      AARCH64_SIMD_VGET_HIGH_BUILTINS
-       {
-         auto pos = BYTES_BIG_ENDIAN ? 0 : 64;
-
-         return fold_build3 (BIT_FIELD_REF, type, args[0], bitsize_int (64),
-                             bitsize_int (pos));
-       }
       case AARCH64_SIMD_BUILTIN_LANE_CHECK:
        gcc_assert (n_args == 3);
        if (aarch64_fold_builtin_lane_check (args[0], args[1], args[2]))
@@ -5192,14 +5070,11 @@ aarch64_gimple_fold_pragma_builtin
   switch (builtin_data.unspec)
     {
     case UNSPEC_DUP:
-    case UNSPEC_DUP_LANE:
       {
        tree arg = gimple_call_arg (stmt, 0);
        tree type = types[0].type ();
        if (builtin_data.signature == aarch64_builtin_signatures::load)
          arg = aarch64_dereference (arg, TREE_TYPE (type));
-       else if (builtin_data.unspec == UNSPEC_DUP_LANE)
-         arg = aarch64_get_lane (arg, gimple_call_arg (stmt, 1));
        arg = aarch64_force_gimple_val (gsi, arg);
 
        tree dup = build_vector_from_val (type, arg);
@@ -5212,13 +5087,6 @@ aarch64_gimple_fold_pragma_builtin
        return aarch64_fold_permute (stmt, 2, aarch64_ext_index, index);
       }
 
-    case UNSPEC_GET_LANE:
-      {
-       tree val = aarch64_get_lane (gimple_call_arg (stmt, 0),
-                                    gimple_call_arg (stmt, 1));
-       return gimple_build_assign (gimple_call_lhs (stmt), val);
-      }
-
     case UNSPEC_LD1:
       return aarch64_fold_load (stmt, types[0].type ());
 
@@ -5278,16 +5146,6 @@ aarch64_gimple_fold_pragma_builtin
     case UNSPEC_UZP2:
       return aarch64_fold_permute (stmt, 2, aarch64_uzp_index, 1);
 
-    case UNSPEC_VEC_COPY:
-      {
-       tree elt = aarch64_get_lane (gimple_call_arg (stmt, 2),
-                                    gimple_call_arg (stmt, 3));
-       elt = aarch64_force_gimple_val (gsi, elt);
-       return aarch64_set_lane (gimple_call_lhs (stmt), elt,
-                                gimple_call_arg (stmt, 0),
-                                gimple_call_arg (stmt, 1));
-      }
-
     case UNSPEC_ZIP1:
       return aarch64_fold_permute (stmt, 2, aarch64_zip_index, 0);
 

diff --git a/gcc/config/aarch64/aarch64-neon-builtins-base.cc b/gcc/config/aarch64/aarch64-neon-builtins-base.cc
index d69b65d5ca60a464ce25d3a0291f7fee70eecebf..4971a6ed48e60fa7890dfea24cf169d1b1235a7c 100644 (file)
--- a/gcc/config/aarch64/aarch64-neon-builtins-base.cc
+++ b/gcc/config/aarch64/aarch64-neon-builtins-base.cc
@@ -45,6 +45,48 @@
 #include "gimple-fold.h"
 
 namespace aarch64_acle {
+/* Convert a lane index to the correct index for the target endianness.
+   For little-endian targets, this is a no-op.
+   For big-endian targets, this is `len - index - 1`.  */
+tree
+convert_lane_index (poly_uint64 len, tree index)
+{
+  auto index_type = TREE_TYPE (index);
+  return !BYTES_BIG_ENDIAN
+          ? index
+          : fold_build2 (MINUS_EXPR, index_type,
+                         fold_build2 (MINUS_EXPR, index_type,
+                                      build_int_cst_type (index_type, len),
+                                      index),
+                         build_one_cst (index_type));
+}
+
+/* Build a `VEC[INDEX]` expression.  */
+tree
+build_lane_get (tree vec, tree index)
+{
+  auto vec_type = TREE_TYPE (vec);
+  auto vec_len = TYPE_VECTOR_SUBPARTS (vec_type);
+  auto elem_type = TREE_TYPE (vec_type);
+  auto elem_size = TYPE_SIZE (elem_type);
+  auto offset = fold_build2 (MULT_EXPR, bitsizetype, elem_size,
+                            convert_lane_index (vec_len, index));
+  return fold_build3 (BIT_FIELD_REF, elem_type, vec, elem_size, offset);
+}
+
+/* Build a `VEC[INDEX] = ELEM;` statement.
+   Returns an expression representing the updated VEC.  */
+tree
+build_lane_set (tree vec, tree index, tree elem)
+{
+  auto vec_type = TREE_TYPE (vec);
+  auto vec_len = TYPE_VECTOR_SUBPARTS (vec_type);
+  auto elem_type = TREE_TYPE (vec_type);
+  auto elem_size = TYPE_SIZE (elem_type);
+  auto offset = fold_build2 (MULT_EXPR, bitsizetype, elem_size,
+                            convert_lane_index (vec_len, index));
+  return fold_build3 (BIT_INSERT_EXPR, vec_type, vec, elem, offset);
+}
 
 /* Build an expression for a vector with all lanes set to `ELEM`.  */
 tree
@@ -63,41 +105,6 @@ class gimple_function_base : public function_base
   gimple *fold (gimple_folder &) const override { gcc_unreachable (); }
 };
 
-struct gimple_create : public gimple_function_base
-{
-  gimple *fold (gimple_folder &f) const override
-  {
-    auto arg = gimple_call_arg (f.call, 0);
-    return gimple_build_assign (f.lhs, fold_build1 (VIEW_CONVERT_EXPR,
-                                                   TREE_TYPE (f.lhs), arg));
-  }
-};
-
-struct gimple_combine : public gimple_function_base
-{
-  gimple *fold (gimple_folder &f) const override
-  {
-    auto arg1 = gimple_call_arg (f.call, 0);
-    auto arg2 = gimple_call_arg (f.call, 1);
-    auto arg_type = TREE_TYPE (arg1);
-    auto elem_type = TREE_TYPE (arg_type);
-    auto ret_type = TREE_TYPE (f.lhs);
-
-    if (known_eq (TYPE_VECTOR_SUBPARTS (arg_type), 1U))
-      {
-       arg1 = f.force_val (fold_build1 (VIEW_CONVERT_EXPR, elem_type, arg1));
-       arg2 = f.force_val (fold_build1 (VIEW_CONVERT_EXPR, elem_type, arg2));
-      }
-
-    if (BYTES_BIG_ENDIAN)
-      std::swap (arg1, arg2);
-
-    return gimple_build_assign (f.lhs,
-                               build_constructor_va (ret_type, 2, NULL_TREE,
-                                                     arg1, NULL_TREE, arg2));
-  }
-};
-
 /* For intrinsics that map to a single GIMPLE expression with no argument
    preparation necessary.  */
 class gimple_expr : public gimple_function_base
@@ -144,6 +151,93 @@ public:
   }
 };
 
+struct gimple_create : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto arg = gimple_call_arg (f.call, 0);
+    return gimple_build_assign (f.lhs, fold_build1 (VIEW_CONVERT_EXPR,
+                                                   TREE_TYPE (f.lhs), arg));
+  }
+};
+
+struct gimple_combine : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto arg1 = gimple_call_arg (f.call, 0);
+    auto arg2 = gimple_call_arg (f.call, 1);
+    auto arg_type = TREE_TYPE (arg1);
+    auto elem_type = TREE_TYPE (arg_type);
+    auto ret_type = TREE_TYPE (f.lhs);
+
+    if (known_eq (TYPE_VECTOR_SUBPARTS (arg_type), 1U))
+      {
+       arg1 = f.force_val (fold_build1 (VIEW_CONVERT_EXPR, elem_type, arg1));
+       arg2 = f.force_val (fold_build1 (VIEW_CONVERT_EXPR, elem_type, arg2));
+      }
+
+    if (BYTES_BIG_ENDIAN)
+      std::swap (arg1, arg2);
+
+    return gimple_build_assign (f.lhs,
+                               build_constructor_va (ret_type, 2, NULL_TREE,
+                                                     arg1, NULL_TREE, arg2));
+  }
+};
+
+struct gimple_get_lane : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto src = gimple_call_arg (f.call, 0);
+    auto lane = gimple_call_arg (f.call, 1);
+    return gimple_build_assign (f.lhs, build_lane_get (src, lane));
+  }
+};
+
+template <bool high_half_p>
+struct gimple_get_half : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto src = gimple_call_arg (f.call, 0);
+    auto half
+      = fold_build3 (BIT_FIELD_REF, TREE_TYPE (f.lhs), src, bitsize_int (64),
+                    bitsize_int (high_half_p ^ BYTES_BIG_ENDIAN ? 64 : 0));
+    return gimple_build_assign (f.lhs, half);
+  }
+};
+
+struct gimple_set_lane : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto elem = gimple_call_arg (f.call, 0);
+    auto src = gimple_call_arg (f.call, 1);
+    auto lane = gimple_call_arg (f.call, 2);
+    return gimple_build_assign (f.lhs, build_lane_set (src, lane, elem));
+  }
+};
+
+struct gimple_copy_lane : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto vec1 = gimple_call_arg (f.call, 0);
+    auto lane1 = gimple_call_arg (f.call, 1);
+    auto vec2 = gimple_call_arg (f.call, 2);
+    auto lane2 = gimple_call_arg (f.call, 3);
+
+    // tmp1 = vec2[lane2]
+    auto tmp1 = f.force_val (build_lane_get (vec2, lane2));
+
+    // vec1[lane1] = tmp1
+    // lhs = vec1
+    return gimple_build_assign (f.lhs, build_lane_set (vec1, lane1, tmp1));
+  }
+};
+
 struct gimple_dup : public gimple_function_base
 {
   gimple *fold (gimple_folder &f) const override
@@ -162,6 +256,46 @@ NEON_FUNCTION (vdupq_n,            gimple_dup,)
 NEON_FUNCTION (vmov_n,         gimple_dup,)
 NEON_FUNCTION (vmovq_n,                gimple_dup,)
 
+struct gimple_dup_lane : public gimple_function_base
+{
+  gimple *fold (gimple_folder &f) const override
+  {
+    auto vec = gimple_call_arg (f.call, 0);
+    auto lane = gimple_call_arg (f.call, 1);
+    auto type = TREE_TYPE (f.lhs);
+
+    // tmp1 = vec[lane]
+    auto tmp1 = f.force_val (build_lane_get (vec, lane));
+
+    // lhs = VEC_DUP (vec[lane])
+    return gimple_build_assign (f.lhs, build_vec_dup (type, tmp1));
+  }
+};
+
+// Lane get/set
+NEON_FUNCTION (vget_lane,    gimple_get_lane,)
+NEON_FUNCTION (vgetq_lane,   gimple_get_lane,)
+NEON_FUNCTION (vget_low,     gimple_get_half<false>,)
+NEON_FUNCTION (vget_high,    gimple_get_half<true>,)
+NEON_FUNCTION (vset_lane,    gimple_set_lane,)
+NEON_FUNCTION (vsetq_lane,   gimple_set_lane,)
+NEON_FUNCTION (vcopy_lane,   gimple_copy_lane,)
+NEON_FUNCTION (vcopy_laneq,  gimple_copy_lane,)
+NEON_FUNCTION (vcopyq_laneq, gimple_copy_lane,)
+NEON_FUNCTION (vcopyq_lane,  gimple_copy_lane,)
+NEON_FUNCTION (vdup_lane,    gimple_dup_lane,)
+NEON_FUNCTION (vdupq_lane,   gimple_dup_lane,)
+NEON_FUNCTION (vdup_laneq,   gimple_dup_lane,)
+NEON_FUNCTION (vdupq_laneq,  gimple_dup_lane,)
+NEON_FUNCTION (vdupb_lane,   gimple_get_lane,)
+NEON_FUNCTION (vdupb_laneq,  gimple_get_lane,)
+NEON_FUNCTION (vduph_lane,   gimple_get_lane,)
+NEON_FUNCTION (vduph_laneq,  gimple_get_lane,)
+NEON_FUNCTION (vdups_lane,   gimple_get_lane,)
+NEON_FUNCTION (vdups_laneq,  gimple_get_lane,)
+NEON_FUNCTION (vdupd_lane,   gimple_get_lane,)
+NEON_FUNCTION (vdupd_laneq,  gimple_get_lane,)
+
 // Lanewise arithmetic
 NEON_FUNCTION (vaddd, gimple_expr, (PLUS_EXPR))
 NEON_FUNCTION (vadd,  gimple_expr, (PLUS_EXPR, PLUS_EXPR, BIT_XOR_EXPR))

diff --git a/gcc/config/aarch64/aarch64-neon-builtins-base.def b/gcc/config/aarch64/aarch64-neon-builtins-base.def
index 3ea0432da0e914a9d672aa59d2c66ed8049c1c6d..c0f98be70174b6a26cefa49cf85ea93dc6c588a6 100644 (file)
--- a/gcc/config/aarch64/aarch64-neon-builtins-base.def
+++ b/gcc/config/aarch64/aarch64-neon-builtins-base.def
@@ -21,10 +21,38 @@
 #define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD)
 DEF_NEON_FUNCTION (vcreate,     all_neon,  ("D0,su64"))
 DEF_NEON_FUNCTION (vcombine,    all_neon,  ("Q0,D0,D0"))
+DEF_NEON_FUNCTION (vget_lane,   all_neon,  ("s0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vgetq_lane,  all_neon,  ("s0,Q0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vget_high,   all_neon,  ("D0,Q0"))
+DEF_NEON_FUNCTION (vget_low,    all_neon,  ("D0,Q0"))
+DEF_NEON_FUNCTION (vset_lane,   all_neon,  ("D0,s0,D0,ss32", lane<2>))
+DEF_NEON_FUNCTION (vsetq_lane,  all_neon,  ("Q0,s0,Q0,ss32", lane<2>))
+DEF_NEON_FUNCTION (vdup_lane,   all_neon,  ("D0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupq_lane,  all_neon,  ("Q0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdup_laneq,  all_neon,  ("D0,Q0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupq_laneq, all_neon,  ("Q0,Q0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupb_lane,  b_neon,    ("s0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupb_laneq, b_neon,    ("s0,Q0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupb_lane,  b_float,   ("s0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupb_laneq, b_float,   ("s0,Q0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vduph_lane,  h_neon,    ("s0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vduph_laneq, h_neon,    ("s0,Q0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdups_lane,  s_data,    ("s0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdups_laneq, s_data,    ("s0,Q0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupd_lane,  d_data,    ("s0,D0,ss32",    lane<1>))
+DEF_NEON_FUNCTION (vdupd_laneq, d_data,    ("s0,Q0,ss32",    lane<1>))
 DEF_NEON_FUNCTION (vdup_n,      all_neon,  ("D0,s0"))
 DEF_NEON_FUNCTION (vdupq_n,     all_neon,  ("Q0,s0"))
 DEF_NEON_FUNCTION (vmov_n,      bhsd_neon, ("D0,s0"))
 DEF_NEON_FUNCTION (vmovq_n,     bhsd_neon, ("Q0,s0"))
+DEF_NEON_FUNCTION (vcopy_lane,  neon_copy_lane,
+                  ("D0,D0,ss32,D0,ss32", lane<1>, lane<3>))
+DEF_NEON_FUNCTION (vcopy_laneq, neon_copy_lane,
+                  ("D0,D0,ss32,Q0,ss32", lane<1>, lane<3>))
+DEF_NEON_FUNCTION (vcopyq_lane, neon_copy_lane,
+                  ("Q0,Q0,ss32,D0,ss32", lane<1>, lane<3>))
+DEF_NEON_FUNCTION (vcopyq_laneq, neon_copy_lane,
+                  ("Q0,Q0,ss32,Q0,ss32", lane<1>, lane<3>))
 #undef REQUIRED_EXTENSIONS
 
 // Lanewise arithmetic

diff --git a/gcc/config/aarch64/aarch64-neon-builtins-shapes.cc b/gcc/config/aarch64/aarch64-neon-builtins-shapes.cc
index 7946a7675eb5902736977bb6fe9fd96af41fa066..a5b402777c067e9e9a5106aa7be0b94ccdeb7a12 100644 (file)
--- a/gcc/config/aarch64/aarch64-neon-builtins-shapes.cc
+++ b/gcc/config/aarch64/aarch64-neon-builtins-shapes.cc
@@ -37,16 +37,68 @@
 
 using namespace aarch64_acle;
 
+/* Require that the parameter at PARAM_INDEX is in the range MIN to MAX
+   (inclusive).  */
+template <unsigned int PARAM_INDEX, int MIN, int MAX>
+bool
+range (function_checker &c)
+{
+  return c.require_immediate_range (PARAM_INDEX, MIN, MAX);
+}
+
+/* Require that the parameter at PARAM_INDEX is a valid lane index for the
+   vector at PARAM_INDEX - 1.  */
+template <unsigned int PARAM_INDEX>
+bool
+lane (function_checker &c)
+{
+  auto vec_param_index = PARAM_INDEX - 1;
+  auto fn_type = TREE_TYPE (c.fndecl);
+  auto args = TYPE_ARG_TYPES (fn_type);
+
+  for (auto i = 0U; i < vec_param_index; i++)
+    args = TREE_CHAIN (args);
+  auto arg_type = TREE_VALUE (args);
+
+  unsigned element_count;
+  if (VECTOR_TYPE_P (arg_type))
+    element_count = TYPE_VECTOR_SUBPARTS (arg_type).to_constant ();
+  else
+    {
+      auto field = tuple_type_field (arg_type);
+      auto array_type = TREE_TYPE (field);
+      auto vec_type = TREE_TYPE (array_type);
+      element_count = TYPE_VECTOR_SUBPARTS (vec_type).to_constant ();
+    }
+  return c.require_immediate_range (PARAM_INDEX, 0, element_count - 1);
+}
+
+
+/* A checker that always returns true.  */
+bool
+trivial (function_checker &)
+{
+  return true;
+}
+
+using check_fn_t = bool (*) (function_checker &);
+
 /* All NEON functions are non-overloaded, so we don't need bespoke
   function shapes.  Instead, we can just use a single shape for all NEON
-  functions, parameterised by a signature.  */
+  functions, parameterised by a signature and optional validity checkers.  */
 struct neon_shape : public function_shape
 {
-  constexpr neon_shape (const char *signature)
-    : m_signature (signature)
+  constexpr neon_shape (const char *signature,
+                       check_fn_t check_fn1 = trivial,
+                       check_fn_t check_fn2 = trivial)
+    : m_signature (signature),
+      m_check_fn1 (check_fn1),
+      m_check_fn2 (check_fn2)
   {}
 
   const char *m_signature;
+  check_fn_t m_check_fn1;
+  check_fn_t m_check_fn2;
 
   void build (function_builder &b,
              const function_group_info &group) const override
@@ -54,7 +106,12 @@ struct neon_shape : public function_shape
     aarch64_acle::build_all (b, this->m_signature, group, MODE_none);
   }
 
-  bool check (function_checker &) const override { return true; }
+  bool check (function_checker &c) const override
+  {
+    /* Use strict `&` rather than short-circuiting `&&` so that we report errors
+       from both checkers.  */
+    return this->m_check_fn1 (c) & this->m_check_fn2 (c);
+  }
 
   bool explicit_type_suffix_p (unsigned int) const override { return true; }
   tree resolve (function_resolver &) const override { gcc_unreachable (); }

diff --git a/gcc/config/aarch64/aarch64-simd-pragma-builtins.def b/gcc/config/aarch64/aarch64-simd-pragma-builtins.def
index c17a0a1c600e4c499bfdc19c557c5f147573349e..e9e7e163def39fc0110a5504dc266a8016ac46bb 100644 (file)
--- a/gcc/config/aarch64/aarch64-simd-pragma-builtins.def
+++ b/gcc/config/aarch64/aarch64-simd-pragma-builtins.def
@@ -202,24 +202,6 @@ ENTRY_TERNARY (vbsl_mf8, mf8, u8, mf8, mf8, UNSPEC_BSL, QUIET)
 ENTRY_TERNARY (vbslq_mf8, mf8q, u8q, mf8q, mf8q, UNSPEC_BSL, QUIET)
 #undef REQUIRED_EXTENSIONS
 
-// copy_lane
-#define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD)
-ENTRY_BINARY_TWO_LANES (vcopy_lane_mf8, mf8, mf8, mf8,
-                       UNSPEC_VEC_COPY, QUIET)
-ENTRY_BINARY_TWO_LANES (vcopyq_lane_mf8, mf8q, mf8q, mf8,
-                       UNSPEC_VEC_COPY, QUIET)
-ENTRY_BINARY_TWO_LANES (vcopy_laneq_mf8, mf8, mf8, mf8q,
-                       UNSPEC_VEC_COPY, QUIET)
-ENTRY_BINARY_TWO_LANES (vcopyq_laneq_mf8, mf8q, mf8q, mf8q,
-                       UNSPEC_VEC_COPY, QUIET)
-#undef REQUIRED_EXTENSIONS
-
-// dupb_lane
-#define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD)
-ENTRY_UNARY_LANE (vdupb_lane_mf8, mf8_scalar, mf8, UNSPEC_GET_LANE, QUIET)
-ENTRY_UNARY_LANE (vdupb_laneq_mf8, mf8_scalar, mf8q, UNSPEC_GET_LANE, QUIET)
-#undef REQUIRED_EXTENSIONS
-
 // ext
 #define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD)
 ENTRY_BINARY_LANE (vext_mf8, mf8, mf8, mf8, UNSPEC_EXT, QUIET)
@@ -297,12 +279,6 @@ ENTRY_UNARY (vrev16_mf8, mf8, mf8, UNSPEC_REV16, QUIET)
 ENTRY_UNARY (vrev16q_mf8, mf8q, mf8q, UNSPEC_REV16, QUIET)
 #undef REQUIRED_EXTENSIONS
 
-// set_lane
-#define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD)
-ENTRY_BINARY_LANE (vset_lane_mf8, mf8, mf8_scalar, mf8, UNSPEC_SET_LANE, QUIET)
-ENTRY_BINARY_LANE (vsetq_lane_mf8, mf8q, mf8_scalar, mf8q, UNSPEC_SET_LANE, QUIET)
-#undef REQUIRED_EXTENSIONS
-
 // st1
 #define REQUIRED_EXTENSIONS nonstreaming_only (AARCH64_FL_SIMD)
 ENTRY_STORE (vst1_mf8, mf8_scalar_ptr, mf8, UNSPEC_ST1)

diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md
index 6f1ec6bf361678cfacf05ccfeb53f657d74f3dbd..d1c4744a965ce9e69c2535805cdd380fecaf9334 100644 (file)
--- a/gcc/config/aarch64/aarch64.md
+++ b/gcc/config/aarch64/aarch64.md
@@ -240,7 +240,6 @@
     UNSPEC_CRC32W
     UNSPEC_CRC32X
     UNSPEC_DUP
-    UNSPEC_DUP_LANE
     UNSPEC_FCVTZS
     UNSPEC_FCVTZU
     UNSPEC_FJCVTZS
@@ -259,7 +258,6 @@
     UNSPEC_FRINTP
     UNSPEC_FRINTX
     UNSPEC_FRINTZ
-    UNSPEC_GET_LANE
     UNSPEC_GOTSMALLPIC
     UNSPEC_GOTSMALLPIC28K
     UNSPEC_GOTSMALLTLS
@@ -357,7 +355,6 @@
     UNSPEC_UNPACKSLO
     UNSPEC_UNPACKULO
     UNSPEC_PACK
-    UNSPEC_VEC_COPY
     UNSPEC_WHILEGE
     UNSPEC_WHILEGT
     UNSPEC_WHILEHI

diff --git a/gcc/config/aarch64/arm_neon.h b/gcc/config/aarch64/arm_neon.h
index 6146acf8e819c9684310d567817695a96e05f490..69cd3efb2b76b910534e0622c7e8b5b64331b0d5 100644 (file)
--- a/gcc/config/aarch64/arm_neon.h
+++ b/gcc/config/aarch64/arm_neon.h
@@ -49,28 +49,6 @@
    __aarch64_vdup_lane_any (f32, , __a, __b)
 #define __aarch64_vdup_lane_f64(__a, __b) \
    __aarch64_vdup_lane_any (f64, , __a, __b)
-#define __aarch64_vdup_lane_p8(__a, __b) \
-   __aarch64_vdup_lane_any (p8, , __a, __b)
-#define __aarch64_vdup_lane_p16(__a, __b) \
-   __aarch64_vdup_lane_any (p16, , __a, __b)
-#define __aarch64_vdup_lane_p64(__a, __b) \
-   __aarch64_vdup_lane_any (p64, , __a, __b)
-#define __aarch64_vdup_lane_s8(__a, __b) \
-   __aarch64_vdup_lane_any (s8, , __a, __b)
-#define __aarch64_vdup_lane_s16(__a, __b) \
-   __aarch64_vdup_lane_any (s16, , __a, __b)
-#define __aarch64_vdup_lane_s32(__a, __b) \
-   __aarch64_vdup_lane_any (s32, , __a, __b)
-#define __aarch64_vdup_lane_s64(__a, __b) \
-  __aarch64_vdup_lane_any (s64, , __a, __b)
-#define __aarch64_vdup_lane_u8(__a, __b) \
-   __aarch64_vdup_lane_any (u8, , __a, __b)
-#define __aarch64_vdup_lane_u16(__a, __b) \
-   __aarch64_vdup_lane_any (u16, , __a, __b)
-#define __aarch64_vdup_lane_u32(__a, __b) \
-   __aarch64_vdup_lane_any (u32, , __a, __b)
-#define __aarch64_vdup_lane_u64(__a, __b) \
-   __aarch64_vdup_lane_any (u64, , __a, __b)
 
 /* __aarch64_vdup_laneq internal macros.  */
 #define __aarch64_vdup_laneq_f16(__a, __b) \
@@ -79,28 +57,6 @@
    __aarch64_vdup_lane_any (f32, , __a, __b)
 #define __aarch64_vdup_laneq_f64(__a, __b) \
    __aarch64_vdup_lane_any (f64, , __a, __b)
-#define __aarch64_vdup_laneq_p8(__a, __b) \
-   __aarch64_vdup_lane_any (p8, , __a, __b)
-#define __aarch64_vdup_laneq_p16(__a, __b) \
-   __aarch64_vdup_lane_any (p16, , __a, __b)
-#define __aarch64_vdup_laneq_p64(__a, __b) \
-   __aarch64_vdup_lane_any (p64, , __a, __b)
-#define __aarch64_vdup_laneq_s8(__a, __b) \
-   __aarch64_vdup_lane_any (s8, , __a, __b)
-#define __aarch64_vdup_laneq_s16(__a, __b) \
-   __aarch64_vdup_lane_any (s16, , __a, __b)
-#define __aarch64_vdup_laneq_s32(__a, __b) \
-   __aarch64_vdup_lane_any (s32, , __a, __b)
-#define __aarch64_vdup_laneq_s64(__a, __b) \
-   __aarch64_vdup_lane_any (s64, , __a, __b)
-#define __aarch64_vdup_laneq_u8(__a, __b) \
-   __aarch64_vdup_lane_any (u8, , __a, __b)
-#define __aarch64_vdup_laneq_u16(__a, __b) \
-   __aarch64_vdup_lane_any (u16, , __a, __b)
-#define __aarch64_vdup_laneq_u32(__a, __b) \
-   __aarch64_vdup_lane_any (u32, , __a, __b)
-#define __aarch64_vdup_laneq_u64(__a, __b) \
-   __aarch64_vdup_lane_any (u64, , __a, __b)
 
 /* __aarch64_vdupq_lane internal macros.  */
 #define __aarch64_vdupq_lane_f16(__a, __b) \
@@ -109,28 +65,6 @@
    __aarch64_vdup_lane_any (f32, q, __a, __b)
 #define __aarch64_vdupq_lane_f64(__a, __b) \
    __aarch64_vdup_lane_any (f64, q, __a, __b)
-#define __aarch64_vdupq_lane_p8(__a, __b) \
-   __aarch64_vdup_lane_any (p8, q, __a, __b)
-#define __aarch64_vdupq_lane_p16(__a, __b) \
-   __aarch64_vdup_lane_any (p16, q, __a, __b)
-#define __aarch64_vdupq_lane_p64(__a, __b) \
-   __aarch64_vdup_lane_any (p64, q, __a, __b)
-#define __aarch64_vdupq_lane_s8(__a, __b) \
-   __aarch64_vdup_lane_any (s8, q, __a, __b)
-#define __aarch64_vdupq_lane_s16(__a, __b) \
-   __aarch64_vdup_lane_any (s16, q, __a, __b)
-#define __aarch64_vdupq_lane_s32(__a, __b) \
-   __aarch64_vdup_lane_any (s32, q, __a, __b)
-#define __aarch64_vdupq_lane_s64(__a, __b) \
-   __aarch64_vdup_lane_any (s64, q, __a, __b)
-#define __aarch64_vdupq_lane_u8(__a, __b) \
-   __aarch64_vdup_lane_any (u8, q, __a, __b)
-#define __aarch64_vdupq_lane_u16(__a, __b) \
-   __aarch64_vdup_lane_any (u16, q, __a, __b)
-#define __aarch64_vdupq_lane_u32(__a, __b) \
-   __aarch64_vdup_lane_any (u32, q, __a, __b)
-#define __aarch64_vdupq_lane_u64(__a, __b) \
-   __aarch64_vdup_lane_any (u64, q, __a, __b)
 
 /* __aarch64_vdupq_laneq internal macros.  */
 #define __aarch64_vdupq_laneq_f16(__a, __b) \
@@ -139,28 +73,6 @@
    __aarch64_vdup_lane_any (f32, q, __a, __b)
 #define __aarch64_vdupq_laneq_f64(__a, __b) \
    __aarch64_vdup_lane_any (f64, q, __a, __b)
-#define __aarch64_vdupq_laneq_p8(__a, __b) \
-   __aarch64_vdup_lane_any (p8, q, __a, __b)
-#define __aarch64_vdupq_laneq_p16(__a, __b) \
-   __aarch64_vdup_lane_any (p16, q, __a, __b)
-#define __aarch64_vdupq_laneq_p64(__a, __b) \
-   __aarch64_vdup_lane_any (p64, q, __a, __b)
-#define __aarch64_vdupq_laneq_s8(__a, __b) \
-   __aarch64_vdup_lane_any (s8, q, __a, __b)
-#define __aarch64_vdupq_laneq_s16(__a, __b) \
-   __aarch64_vdup_lane_any (s16, q, __a, __b)
-#define __aarch64_vdupq_laneq_s32(__a, __b) \
-   __aarch64_vdup_lane_any (s32, q, __a, __b)
-#define __aarch64_vdupq_laneq_s64(__a, __b) \
-   __aarch64_vdup_lane_any (s64, q, __a, __b)
-#define __aarch64_vdupq_laneq_u8(__a, __b) \
-   __aarch64_vdup_lane_any (u8, q, __a, __b)
-#define __aarch64_vdupq_laneq_u16(__a, __b) \
-   __aarch64_vdup_lane_any (u16, q, __a, __b)
-#define __aarch64_vdupq_laneq_u32(__a, __b) \
-   __aarch64_vdup_lane_any (u32, q, __a, __b)
-#define __aarch64_vdupq_laneq_u64(__a, __b) \
-   __aarch64_vdup_lane_any (u64, q, __a, __b)
 
 /* Internal macro for lane indices.  */
 
@@ -2349,8507 +2261,7034 @@ vqrdmulhq_s32 (int32x4_t __a, int32x4_t __b)
   return (int32x4_t) __builtin_aarch64_sqrdmulhv4si (__a, __b);
 }
 
-/* vget_lane  */
+/* Start of temporary inline asm implementations.  */
 
-__extension__ extern __inline float16_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_f16 (float16x4_t __a, const int __b)
+vaba_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabav8qi (__a, __b, __c);
 }
 
-__extension__ extern __inline float32_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_f32 (float32x2_t __a, const int __b)
+vaba_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabav4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline float64_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_f64 (float64x1_t __a, const int __b)
+vaba_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabav2si (__a, __b, __c);
 }
 
-__extension__ extern __inline poly8_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_p8 (poly8x8_t __a, const int __b)
+vaba_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabav8qi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline poly16_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_p16 (poly16x4_t __a, const int __b)
+vaba_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabav4hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline poly64_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_p64 (poly64x1_t __a, const int __b)
+vaba_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabav2si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int8_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_s8 (int8x8_t __a, const int __b)
+vabal_high_s8 (int16x8_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabal2v16qi (__a, __b, __c);
 }
 
-__extension__ extern __inline int16_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_s16 (int16x4_t __a, const int __b)
+vabal_high_s16 (int32x4_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabal2v8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_s32 (int32x2_t __a, const int __b)
+vabal_high_s32 (int64x2_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabal2v4si (__a, __b, __c);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_s64 (int64x1_t __a, const int __b)
+vabal_high_u8 (uint16x8_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabal2v16qi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_u8 (uint8x8_t __a, const int __b)
+vabal_high_u16 (uint32x4_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabal2v8hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_u16 (uint16x4_t __a, const int __b)
+vabal_high_u32 (uint64x2_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabal2v4si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_u32 (uint32x2_t __a, const int __b)
+vabal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabalv8qi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_u64 (uint64x1_t __a, const int __b)
+vabal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabalv4hi (__a, __b, __c);
 }
 
-/* vgetq_lane  */
-
-__extension__ extern __inline float16_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_f16 (float16x8_t __a, const int __b)
+vabal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabalv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline float32_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_f32 (float32x4_t __a, const int __b)
+vabal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabalv8qi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline float64_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_f64 (float64x2_t __a, const int __b)
+vabal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabalv4hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline poly8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_p8 (poly8x16_t __a, const int __b)
+vabal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabalv2si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline poly16_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_p16 (poly16x8_t __a, const int __b)
+vabaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabav16qi (__a, __b, __c);
 }
 
-__extension__ extern __inline poly64_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_p64 (poly64x2_t __a, const int __b)
+vabaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabav8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline int8_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_s8 (int8x16_t __a, const int __b)
+vabaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_sabav4si (__a, __b, __c);
 }
 
-__extension__ extern __inline int16_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_s16 (int16x8_t __a, const int __b)
+vabaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabav16qi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_s32 (int32x4_t __a, const int __b)
+vabaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabav8hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_s64 (int64x2_t __a, const int __b)
+vabaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_uabav4si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_u8 (uint8x16_t __a, const int __b)
+vabd_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return  __builtin_aarch64_sabdv8qi (__a, __b);
 }
 
-__extension__ extern __inline uint16_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_u16 (uint16x8_t __a, const int __b)
+vabd_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return  __builtin_aarch64_sabdv4hi (__a, __b);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_u32 (uint32x4_t __a, const int __b)
+vabd_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return  __builtin_aarch64_sabdv2si (__a, __b);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_u64 (uint64x2_t __a, const int __b)
+vabd_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return  __builtin_aarch64_uabdv8qi_uuu (__a, __b);
 }
 
-/* vset_lane  */
-
-__extension__ extern __inline float16x4_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_f16 (float16_t __elem, float16x4_t __vec, const int __index)
+vabd_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_uabdv4hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_f32 (float32_t __elem, float32x2_t __vec, const int __index)
+vabd_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_uabdv2si_uuu (__a, __b);
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_f64 (float64_t __elem, float64x1_t __vec, const int __index)
+vabdl_high_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_sabdl2v16qi (__a, __b);
 }
 
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_p8 (poly8_t __elem, poly8x8_t __vec, const int __index)
+vabdl_high_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_sabdl2v8hi (__a, __b);
 }
 
-__extension__ extern __inline poly16x4_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_p16 (poly16_t __elem, poly16x4_t __vec, const int __index)
+vabdl_high_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_sabdl2v4si (__a, __b);
 }
 
-__extension__ extern __inline poly64x1_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_p64 (poly64_t __elem, poly64x1_t __vec, const int __index)
+vabdl_high_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uabdl2v16qi_uuu (__a, __b);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_s8 (int8_t __elem, int8x8_t __vec, const int __index)
+vabdl_high_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uabdl2v8hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_s16 (int16_t __elem, int16x4_t __vec, const int __index)
+vabdl_high_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uabdl2v4si_uuu (__a, __b);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_s32 (int32_t __elem, int32x2_t __vec, const int __index)
+vabdl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_sabdlv8qi (__a, __b);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_s64 (int64_t __elem, int64x1_t __vec, const int __index)
+vabdl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_sabdlv4hi (__a, __b);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_u8 (uint8_t __elem, uint8x8_t __vec, const int __index)
+vabdl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_sabdlv2si (__a, __b);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_u16 (uint16_t __elem, uint16x4_t __vec, const int __index)
+vabdl_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uabdlv8qi_uuu (__a, __b);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_u32 (uint32_t __elem, uint32x2_t __vec, const int __index)
+vabdl_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uabdlv4hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_u64 (uint64_t __elem, uint64x1_t __vec, const int __index)
+vabdl_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uabdlv2si_uuu (__a, __b);
 }
 
-/* vsetq_lane  */
-
-__extension__ extern __inline float16x8_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_f16 (float16_t __elem, float16x8_t __vec, const int __index)
+vabdq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_sabdv16qi (__a, __b);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_f32 (float32_t __elem, float32x4_t __vec, const int __index)
+vabdq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_sabdv8hi (__a, __b);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_f64 (float64_t __elem, float64x2_t __vec, const int __index)
+vabdq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_sabdv4si (__a, __b);
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_p8 (poly8_t __elem, poly8x16_t __vec, const int __index)
+vabdq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_uabdv16qi_uuu (__a, __b);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_p16 (poly16_t __elem, poly16x8_t __vec, const int __index)
+vabdq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_uabdv8hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline poly64x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_p64 (poly64_t __elem, poly64x2_t __vec, const int __index)
+vabdq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return  __builtin_aarch64_uabdv4si_uuu (__a, __b);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_s8 (int8_t __elem, int8x16_t __vec, const int __index)
+vaddlv_s8 (int8x8_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_saddlvv8qi (__a);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_s16 (int16_t __elem, int16x8_t __vec, const int __index)
+vaddlv_s16 (int16x4_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_saddlvv4hi (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_s32 (int32_t __elem, int32x4_t __vec, const int __index)
+vaddlv_u8 (uint8x8_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uaddlvv8qi_uu (__a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_s64 (int64_t __elem, int64x2_t __vec, const int __index)
+vaddlv_u16 (uint16x4_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uaddlvv4hi_uu (__a);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_u8 (uint8_t __elem, uint8x16_t __vec, const int __index)
+vaddlvq_s8 (int8x16_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_saddlvv16qi (__a);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_u16 (uint16_t __elem, uint16x8_t __vec, const int __index)
+vaddlvq_s16 (int16x8_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_saddlvv8hi (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_u32 (uint32_t __elem, uint32x4_t __vec, const int __index)
+vaddlvq_s32 (int32x4_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_saddlvv4si (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_u64 (uint64_t __elem, uint64x2_t __vec, const int __index)
+vaddlvq_u8 (uint8x16_t __a)
 {
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
+  return __builtin_aarch64_uaddlvv16qi_uu (__a);
 }
 
-/* Start of temporary inline asm implementations.  */
-
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaba_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
+vaddlvq_u16 (uint16x8_t __a)
 {
-  return __builtin_aarch64_sabav8qi (__a, __b, __c);
+  return __builtin_aarch64_uaddlvv8hi_uu (__a);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaba_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
+vaddlvq_u32 (uint32x4_t __a)
 {
-  return __builtin_aarch64_sabav4hi (__a, __b, __c);
+  return __builtin_aarch64_uaddlvv4si_uu (__a);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaba_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
+vcvtx_f32_f64 (float64x2_t __a)
 {
-  return __builtin_aarch64_sabav2si (__a, __b, __c);
+  return __builtin_aarch64_float_trunc_rodd_lo_v2sf (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaba_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
+vcvtx_high_f32_f64 (float32x2_t __a, float64x2_t __b)
 {
-  return __builtin_aarch64_uabav8qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_float_trunc_rodd_hi_v4sf (__a, __b);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaba_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
+vcvtxd_f32_f64 (float64_t __a)
 {
-  return __builtin_aarch64_uabav4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_float_trunc_rodd_df (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaba_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
+vmla_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c)
 {
-  return __builtin_aarch64_uabav2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_float_mla_nv2sf (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_high_s8 (int16x8_t __a, int8x16_t __b, int8x16_t __c)
+vmla_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return __builtin_aarch64_sabal2v16qi (__a, __b, __c);
+  return __builtin_aarch64_mla_nv4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_high_s16 (int32x4_t __a, int16x8_t __b, int16x8_t __c)
+vmla_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return __builtin_aarch64_sabal2v8hi (__a, __b, __c);
+  return __builtin_aarch64_mla_nv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_high_s32 (int64x2_t __a, int32x4_t __b, int32x4_t __c)
+vmla_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return __builtin_aarch64_sabal2v4si (__a, __b, __c);
+  return __builtin_aarch64_mla_nv4hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_high_u8 (uint16x8_t __a, uint8x16_t __b, uint8x16_t __c)
+vmla_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return __builtin_aarch64_uabal2v16qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mla_nv2si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_high_u16 (uint32x4_t __a, uint16x8_t __b, uint16x8_t __c)
+vmla_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return __builtin_aarch64_uabal2v8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlav8qi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_high_u32 (uint64x2_t __a, uint32x4_t __b, uint32x4_t __c)
+vmla_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return __builtin_aarch64_uabal2v4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlav4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
+vmla_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return __builtin_aarch64_sabalv8qi (__a, __b, __c);
+  return __builtin_aarch64_mlav2si (__a, __b, __c);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
+vmla_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return __builtin_aarch64_sabalv4hi (__a, __b, __c);
+  return __builtin_aarch64_mlav8qi_uuuu (__a, __b,  __c);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
+vmla_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return __builtin_aarch64_sabalv2si (__a, __b, __c);
+  return __builtin_aarch64_mlav4hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
+vmla_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return __builtin_aarch64_uabalv8qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlav2si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
+vmlal_high_lane_s16(int32x4_t __a, int16x8_t __b, int16x4_t __v,
+                   const int __lane)
 {
-  return __builtin_aarch64_uabalv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_smlal_hi_lanev8hi (__a, __b, __v, __lane);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
+vmlal_high_lane_s32(int64x2_t __a, int32x4_t __b, int32x2_t __v,
+                   const int __lane)
 {
-  return __builtin_aarch64_uabalv2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_smlal_hi_lanev4si (__a, __b, __v, __lane);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
+vmlal_high_lane_u16(uint32x4_t __a, uint16x8_t __b, uint16x4_t __v,
+                   const int __lane)
 {
-  return __builtin_aarch64_sabav16qi (__a, __b, __c);
+  return __builtin_aarch64_umlal_hi_lanev8hi_uuuus (__a, __b, __v, __lane);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
+vmlal_high_lane_u32(uint64x2_t __a, uint32x4_t __b, uint32x2_t __v,
+                   const int __lane)
 {
-  return __builtin_aarch64_sabav8hi (__a, __b, __c);
+  return __builtin_aarch64_umlal_hi_lanev4si_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
-{
-  return __builtin_aarch64_sabav4si (__a, __b, __c);
-}
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
+vmlal_high_laneq_s16(int32x4_t __a, int16x8_t __b, int16x8_t __v,
+                    const int __lane)
 {
-  return __builtin_aarch64_uabav16qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_smlal_hi_laneqv8hi (__a, __b, __v, __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
+vmlal_high_laneq_s32(int64x2_t __a, int32x4_t __b, int32x4_t __v,
+                    const int __lane)
 {
-  return __builtin_aarch64_uabav8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_smlal_hi_laneqv4si (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
-{
-  return __builtin_aarch64_uabav4si_uuuu (__a, __b, __c);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_s8 (int8x8_t __a, int8x8_t __b)
+vmlal_high_laneq_u16(uint32x4_t __a, uint16x8_t __b, uint16x8_t __v,
+                    const int __lane)
 {
-  return  __builtin_aarch64_sabdv8qi (__a, __b);
+  return __builtin_aarch64_umlal_hi_laneqv8hi_uuuus (__a, __b, __v, __lane);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_s16 (int16x4_t __a, int16x4_t __b)
+vmlal_high_laneq_u32(uint64x2_t __a, uint32x4_t __b, uint32x4_t __v,
+                    const int __lane)
 {
-  return  __builtin_aarch64_sabdv4hi (__a, __b);
+  return __builtin_aarch64_umlal_hi_laneqv4si_uuuus (__a, __b, __v, __lane);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_s32 (int32x2_t __a, int32x2_t __b)
+vmlal_high_n_s16 (int32x4_t __a, int16x8_t __b, int16_t __c)
 {
-  return  __builtin_aarch64_sabdv2si (__a, __b);
+  return __builtin_aarch64_smlal_hi_nv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_u8 (uint8x8_t __a, uint8x8_t __b)
+vmlal_high_n_s32 (int64x2_t __a, int32x4_t __b, int32_t __c)
 {
-  return  __builtin_aarch64_uabdv8qi_uuu (__a, __b);
+  return __builtin_aarch64_smlal_hi_nv4si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_u16 (uint16x4_t __a, uint16x4_t __b)
+vmlal_high_n_u16 (uint32x4_t __a, uint16x8_t __b, uint16_t __c)
 {
-  return  __builtin_aarch64_uabdv4hi_uuu (__a, __b);
+  return __builtin_aarch64_umlal_hi_nv8hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_u32 (uint32x2_t __a, uint32x2_t __b)
+vmlal_high_n_u32 (uint64x2_t __a, uint32x4_t __b, uint32_t __c)
 {
-  return  __builtin_aarch64_uabdv2si_uuu (__a, __b);
+  return __builtin_aarch64_umlal_hi_nv4si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_high_s8 (int8x16_t __a, int8x16_t __b)
+vmlal_high_s8 (int16x8_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return __builtin_aarch64_sabdl2v16qi (__a, __b);
+  return __builtin_aarch64_smlal_hiv16qi (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_high_s16 (int16x8_t __a, int16x8_t __b)
+vmlal_high_s16 (int32x4_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return __builtin_aarch64_sabdl2v8hi (__a, __b);
+  return __builtin_aarch64_smlal_hiv8hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_high_s32 (int32x4_t __a, int32x4_t __b)
+vmlal_high_s32 (int64x2_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return __builtin_aarch64_sabdl2v4si (__a, __b);
+  return __builtin_aarch64_smlal_hiv4si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_high_u8 (uint8x16_t __a, uint8x16_t __b)
+vmlal_high_u8 (uint16x8_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return __builtin_aarch64_uabdl2v16qi_uuu (__a, __b);
+  return __builtin_aarch64_umlal_hiv16qi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_high_u16 (uint16x8_t __a, uint16x8_t __b)
+vmlal_high_u16 (uint32x4_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return __builtin_aarch64_uabdl2v8hi_uuu (__a, __b);
+  return __builtin_aarch64_umlal_hiv8hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_high_u32 (uint32x4_t __a, uint32x4_t __b)
+vmlal_high_u32 (uint64x2_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return __builtin_aarch64_uabdl2v4si_uuu (__a, __b);
+  return __builtin_aarch64_umlal_hiv4si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_s8 (int8x8_t __a, int8x8_t __b)
+vmlal_lane_s16 (int32x4_t __acc, int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return __builtin_aarch64_sabdlv8qi (__a, __b);
+  return __builtin_aarch64_vec_smlal_lane_v4hi (__acc, __a, __b, __c);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_s16 (int16x4_t __a, int16x4_t __b)
+vmlal_lane_s32 (int64x2_t __acc, int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return __builtin_aarch64_sabdlv4hi (__a, __b);
+  return __builtin_aarch64_vec_smlal_lane_v2si (__acc, __a, __b, __c);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_s32 (int32x2_t __a, int32x2_t __b)
+vmlal_lane_u16 (uint32x4_t __acc, uint16x4_t __a, uint16x4_t __b, const int __c)
 {
-  return __builtin_aarch64_sabdlv2si (__a, __b);
+  return __builtin_aarch64_vec_umlal_lane_v4hi_uuuus (__acc, __a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_u8 (uint8x8_t __a, uint8x8_t __b)
+vmlal_lane_u32 (uint64x2_t __acc, uint32x2_t __a, uint32x2_t __b, const int __c)
 {
-  return __builtin_aarch64_uabdlv8qi_uuu (__a, __b);
+  return __builtin_aarch64_vec_umlal_lane_v2si_uuuus (__acc, __a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_u16 (uint16x4_t __a, uint16x4_t __b)
+vmlal_laneq_s16 (int32x4_t __acc, int16x4_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_uabdlv4hi_uuu (__a, __b);
+  return __builtin_aarch64_vec_smlal_laneq_v4hi (__acc, __a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdl_u32 (uint32x2_t __a, uint32x2_t __b)
+vmlal_laneq_s32 (int64x2_t __acc, int32x2_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_uabdlv2si_uuu (__a, __b);
+  return __builtin_aarch64_vec_smlal_laneq_v2si (__acc, __a, __b, __c);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_s8 (int8x16_t __a, int8x16_t __b)
+vmlal_laneq_u16 (uint32x4_t __acc, uint16x4_t __a, uint16x8_t __b, const int __c)
 {
-  return  __builtin_aarch64_sabdv16qi (__a, __b);
+  return __builtin_aarch64_vec_umlal_laneq_v4hi_uuuus (__acc, __a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_s16 (int16x8_t __a, int16x8_t __b)
+vmlal_laneq_u32 (uint64x2_t __acc, uint32x2_t __a, uint32x4_t __b, const int __c)
 {
-  return  __builtin_aarch64_sabdv8hi (__a, __b);
+  return __builtin_aarch64_vec_umlal_laneq_v2si_uuuus (__acc, __a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_s32 (int32x4_t __a, int32x4_t __b)
+vmlal_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return  __builtin_aarch64_sabdv4si (__a, __b);
+  return __builtin_aarch64_smlal_nv4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_u8 (uint8x16_t __a, uint8x16_t __b)
+vmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return  __builtin_aarch64_uabdv16qi_uuu (__a, __b);
+  return __builtin_aarch64_smlal_nv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_u16 (uint16x8_t __a, uint16x8_t __b)
+vmlal_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return  __builtin_aarch64_uabdv8hi_uuu (__a, __b);
+  return __builtin_aarch64_umlal_nv4hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_u32 (uint32x4_t __a, uint32x4_t __b)
+vmlal_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return  __builtin_aarch64_uabdv4si_uuu (__a, __b);
+  return __builtin_aarch64_umlal_nv2si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int16_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlv_s8 (int8x8_t __a)
+vmlal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return __builtin_aarch64_saddlvv8qi (__a);
+  return __builtin_aarch64_smlalv8qi (__a, __b, __c);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlv_s16 (int16x4_t __a)
+vmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return __builtin_aarch64_saddlvv4hi (__a);
+  return __builtin_aarch64_smlalv4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlv_u8 (uint8x8_t __a)
+vmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return __builtin_aarch64_uaddlvv8qi_uu (__a);
+  return __builtin_aarch64_smlalv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlv_u16 (uint16x4_t __a)
+vmlal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return __builtin_aarch64_uaddlvv4hi_uu (__a);
+  return __builtin_aarch64_umlalv8qi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlvq_s8 (int8x16_t __a)
+vmlal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return __builtin_aarch64_saddlvv16qi (__a);
+  return __builtin_aarch64_umlalv4hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlvq_s16 (int16x8_t __a)
+vmlal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return __builtin_aarch64_saddlvv8hi (__a);
+  return __builtin_aarch64_umlalv2si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlvq_s32 (int32x4_t __a)
+vmlaq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c)
 {
-  return __builtin_aarch64_saddlvv4si (__a);
+  return __builtin_aarch64_float_mla_nv4sf (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlvq_u8 (uint8x16_t __a)
+vmlaq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c)
 {
-  return __builtin_aarch64_uaddlvv16qi_uu (__a);
+  return __builtin_aarch64_mla_nv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlvq_u16 (uint16x8_t __a)
+vmlaq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c)
 {
-  return __builtin_aarch64_uaddlvv8hi_uu (__a);
+  return __builtin_aarch64_mla_nv4si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlvq_u32 (uint32x4_t __a)
+vmlaq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c)
 {
-  return __builtin_aarch64_uaddlvv4si_uu (__a);
+  return __builtin_aarch64_mla_nv8hi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtx_f32_f64 (float64x2_t __a)
+vmlaq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c)
 {
-  return __builtin_aarch64_float_trunc_rodd_lo_v2sf (__a);
+  return __builtin_aarch64_mla_nv4si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtx_high_f32_f64 (float32x2_t __a, float64x2_t __b)
+vmlaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return __builtin_aarch64_float_trunc_rodd_hi_v4sf (__a, __b);
+  return __builtin_aarch64_mlav16qi (__a, __b, __c);
 }
 
-__extension__ extern __inline float32_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtxd_f32_f64 (float64_t __a)
+vmlaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return __builtin_aarch64_float_trunc_rodd_df (__a);
+  return __builtin_aarch64_mlav8hi (__a, __b, __c);
+}
+
+__extension__ extern __inline int32x4_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmlaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
+{
+  return __builtin_aarch64_mlav4si (__a, __b, __c);
+}
+
+__extension__ extern __inline uint8x16_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmlaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
+{
+  return __builtin_aarch64_mlav16qi_uuuu (__a, __b, __c);
+}
+
+__extension__ extern __inline uint16x8_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmlaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
+{
+  return __builtin_aarch64_mlav8hi_uuuu (__a, __b, __c);
+}
+
+__extension__ extern __inline uint32x4_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmlaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
+{
+  return __builtin_aarch64_mlav4si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c)
+vmls_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c)
 {
-  return __builtin_aarch64_float_mla_nv2sf (__a, __b, __c);
+  return __builtin_aarch64_float_mls_nv2sf (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c)
+vmls_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return __builtin_aarch64_mla_nv4hi (__a, __b, __c);
+  return __builtin_aarch64_mls_nv4hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c)
+vmls_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return __builtin_aarch64_mla_nv2si (__a, __b, __c);
+  return __builtin_aarch64_mls_nv2si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c)
+vmls_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return __builtin_aarch64_mla_nv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mls_nv4hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c)
+vmls_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return __builtin_aarch64_mla_nv2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mls_nv2si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
+vmls_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return __builtin_aarch64_mlav8qi (__a, __b, __c);
+  return __builtin_aarch64_mlsv8qi (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
+vmls_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return __builtin_aarch64_mlav4hi (__a, __b, __c);
+  return __builtin_aarch64_mlsv4hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
+vmls_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return __builtin_aarch64_mlav2si (__a, __b, __c);
+  return __builtin_aarch64_mlsv2si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
+vmls_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return __builtin_aarch64_mlav8qi_uuuu (__a, __b,  __c);
+  return __builtin_aarch64_mlsv8qi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
+vmls_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return __builtin_aarch64_mlav4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlsv4hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmla_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
+vmls_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return __builtin_aarch64_mlav2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlsv2si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_lane_s16(int32x4_t __a, int16x8_t __b, int16x4_t __v,
+vmlsl_high_lane_s16(int32x4_t __a, int16x8_t __b, int16x4_t __v,
                    const int __lane)
 {
-  return __builtin_aarch64_smlal_hi_lanev8hi (__a, __b, __v, __lane);
+  return __builtin_aarch64_smlsl_hi_lanev8hi (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_lane_s32(int64x2_t __a, int32x4_t __b, int32x2_t __v,
+vmlsl_high_lane_s32(int64x2_t __a, int32x4_t __b, int32x2_t __v,
                    const int __lane)
 {
-  return __builtin_aarch64_smlal_hi_lanev4si (__a, __b, __v, __lane);
+  return __builtin_aarch64_smlsl_hi_lanev4si (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_lane_u16(uint32x4_t __a, uint16x8_t __b, uint16x4_t __v,
+vmlsl_high_lane_u16(uint32x4_t __a, uint16x8_t __b, uint16x4_t __v,
                    const int __lane)
 {
-  return __builtin_aarch64_umlal_hi_lanev8hi_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umlsl_hi_lanev8hi_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_lane_u32(uint64x2_t __a, uint32x4_t __b, uint32x2_t __v,
+vmlsl_high_lane_u32(uint64x2_t __a, uint32x4_t __b, uint32x2_t __v,
                    const int __lane)
 {
-  return __builtin_aarch64_umlal_hi_lanev4si_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umlsl_hi_lanev4si_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_laneq_s16(int32x4_t __a, int16x8_t __b, int16x8_t __v,
+vmlsl_high_laneq_s16(int32x4_t __a, int16x8_t __b, int16x8_t __v,
                     const int __lane)
 {
-  return __builtin_aarch64_smlal_hi_laneqv8hi (__a, __b, __v, __lane);
+  return __builtin_aarch64_smlsl_hi_laneqv8hi (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_laneq_s32(int64x2_t __a, int32x4_t __b, int32x4_t __v,
+vmlsl_high_laneq_s32(int64x2_t __a, int32x4_t __b, int32x4_t __v,
                     const int __lane)
 {
-  return __builtin_aarch64_smlal_hi_laneqv4si (__a, __b, __v, __lane);
+  return __builtin_aarch64_smlsl_hi_laneqv4si (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_laneq_u16(uint32x4_t __a, uint16x8_t __b, uint16x8_t __v,
+vmlsl_high_laneq_u16(uint32x4_t __a, uint16x8_t __b, uint16x8_t __v,
                     const int __lane)
 {
-  return __builtin_aarch64_umlal_hi_laneqv8hi_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umlsl_hi_laneqv8hi_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_laneq_u32(uint64x2_t __a, uint32x4_t __b, uint32x4_t __v,
+vmlsl_high_laneq_u32(uint64x2_t __a, uint32x4_t __b, uint32x4_t __v,
                     const int __lane)
 {
-  return __builtin_aarch64_umlal_hi_laneqv4si_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umlsl_hi_laneqv4si_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_n_s16 (int32x4_t __a, int16x8_t __b, int16_t __c)
+vmlsl_high_n_s16 (int32x4_t __a, int16x8_t __b, int16_t __c)
 {
-  return __builtin_aarch64_smlal_hi_nv8hi (__a, __b, __c);
+  return __builtin_aarch64_smlsl_hi_nv8hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_n_s32 (int64x2_t __a, int32x4_t __b, int32_t __c)
+vmlsl_high_n_s32 (int64x2_t __a, int32x4_t __b, int32_t __c)
 {
-  return __builtin_aarch64_smlal_hi_nv4si (__a, __b, __c);
+  return __builtin_aarch64_smlsl_hi_nv4si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_n_u16 (uint32x4_t __a, uint16x8_t __b, uint16_t __c)
+vmlsl_high_n_u16 (uint32x4_t __a, uint16x8_t __b, uint16_t __c)
 {
-  return __builtin_aarch64_umlal_hi_nv8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlsl_hi_nv8hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_n_u32 (uint64x2_t __a, uint32x4_t __b, uint32_t __c)
+vmlsl_high_n_u32 (uint64x2_t __a, uint32x4_t __b, uint32_t __c)
 {
-  return __builtin_aarch64_umlal_hi_nv4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlsl_hi_nv4si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_s8 (int16x8_t __a, int8x16_t __b, int8x16_t __c)
+vmlsl_high_s8 (int16x8_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return __builtin_aarch64_smlal_hiv16qi (__a, __b, __c);
+  return __builtin_aarch64_smlsl_hiv16qi (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_s16 (int32x4_t __a, int16x8_t __b, int16x8_t __c)
+vmlsl_high_s16 (int32x4_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return __builtin_aarch64_smlal_hiv8hi (__a, __b, __c);
+  return __builtin_aarch64_smlsl_hiv8hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_s32 (int64x2_t __a, int32x4_t __b, int32x4_t __c)
+vmlsl_high_s32 (int64x2_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return __builtin_aarch64_smlal_hiv4si (__a, __b, __c);
+  return __builtin_aarch64_smlsl_hiv4si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_u8 (uint16x8_t __a, uint8x16_t __b, uint8x16_t __c)
+vmlsl_high_u8 (uint16x8_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return __builtin_aarch64_umlal_hiv16qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlsl_hiv16qi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_u16 (uint32x4_t __a, uint16x8_t __b, uint16x8_t __c)
+vmlsl_high_u16 (uint32x4_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return __builtin_aarch64_umlal_hiv8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlsl_hiv8hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_high_u32 (uint64x2_t __a, uint32x4_t __b, uint32x4_t __c)
+vmlsl_high_u32 (uint64x2_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return __builtin_aarch64_umlal_hiv4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlsl_hiv4si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_lane_s16 (int32x4_t __acc, int16x4_t __a, int16x4_t __b, const int __c)
+vmlsl_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlal_lane_v4hi (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_smlsl_lane_v4hi (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_lane_s32 (int64x2_t __acc, int32x2_t __a, int32x2_t __b, const int __c)
+vmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlal_lane_v2si (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_smlsl_lane_v2si (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_lane_u16 (uint32x4_t __acc, uint16x4_t __a, uint16x4_t __b, const int __c)
+vmlsl_lane_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __v,
+                const int __lane)
 {
-  return __builtin_aarch64_vec_umlal_lane_v4hi_uuuus (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_umlsl_lane_v4hi_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_lane_u32 (uint64x2_t __acc, uint32x2_t __a, uint32x2_t __b, const int __c)
+vmlsl_lane_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __v,
+                const int __lane)
 {
-  return __builtin_aarch64_vec_umlal_lane_v2si_uuuus (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_umlsl_lane_v2si_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_laneq_s16 (int32x4_t __acc, int16x4_t __a, int16x8_t __b, const int __c)
+vmlsl_laneq_s16 (int32x4_t __a, int16x4_t __b, int16x8_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlal_laneq_v4hi (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_smlsl_laneq_v4hi (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_laneq_s32 (int64x2_t __acc, int32x2_t __a, int32x4_t __b, const int __c)
+vmlsl_laneq_s32 (int64x2_t __a, int32x2_t __b, int32x4_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlal_laneq_v2si (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_smlsl_laneq_v2si (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_laneq_u16 (uint32x4_t __acc, uint16x4_t __a, uint16x8_t __b, const int __c)
+vmlsl_laneq_u16 (uint32x4_t __a, uint16x4_t __b, uint16x8_t __v,
+                 const int __lane)
 {
-  return __builtin_aarch64_vec_umlal_laneq_v4hi_uuuus (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_umlsl_laneq_v4hi_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_laneq_u32 (uint64x2_t __acc, uint32x2_t __a, uint32x4_t __b, const int __c)
+vmlsl_laneq_u32 (uint64x2_t __a, uint32x2_t __b, uint32x4_t __v,
+                 const int __lane)
 {
-  return __builtin_aarch64_vec_umlal_laneq_v2si_uuuus (__acc, __a, __b, __c);
+  return __builtin_aarch64_vec_umlsl_laneq_v2si_uuuus (__a, __b, __v, __lane);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
+vmlsl_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return __builtin_aarch64_smlal_nv4hi (__a, __b, __c);
+  return __builtin_aarch64_smlsl_nv4hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
+vmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return __builtin_aarch64_smlal_nv2si (__a, __b, __c);
+  return __builtin_aarch64_smlsl_nv2si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c)
+vmlsl_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return __builtin_aarch64_umlal_nv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlsl_nv4hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c)
+vmlsl_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return __builtin_aarch64_umlal_nv2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlsl_nv2si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
+vmlsl_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return __builtin_aarch64_smlalv8qi (__a, __b, __c);
+  return __builtin_aarch64_smlslv8qi (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
+vmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return __builtin_aarch64_smlalv4hi (__a, __b, __c);
+  return __builtin_aarch64_smlslv4hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
+vmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return __builtin_aarch64_smlalv2si (__a, __b, __c);
+  return __builtin_aarch64_smlslv2si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
+vmlsl_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return __builtin_aarch64_umlalv8qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlslv8qi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
+vmlsl_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return __builtin_aarch64_umlalv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlslv4hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
+vmlsl_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return __builtin_aarch64_umlalv2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umlslv2si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c)
+vmlsq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c)
 {
-  return __builtin_aarch64_float_mla_nv4sf (__a, __b, __c);
+  return __builtin_aarch64_float_mls_nv4sf (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c)
+vmlsq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c)
 {
-  return __builtin_aarch64_mla_nv8hi (__a, __b, __c);
+  return __builtin_aarch64_mls_nv8hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c)
+vmlsq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c)
 {
-  return __builtin_aarch64_mla_nv4si (__a, __b, __c);
+  return __builtin_aarch64_mls_nv4si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c)
+vmlsq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c)
 {
-  return __builtin_aarch64_mla_nv8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mls_nv8hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c)
+vmlsq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c)
 {
-  return __builtin_aarch64_mla_nv4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mls_nv4si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
+vmlsq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return __builtin_aarch64_mlav16qi (__a, __b, __c);
+  return __builtin_aarch64_mlsv16qi (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
+vmlsq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return __builtin_aarch64_mlav8hi (__a, __b, __c);
+  return __builtin_aarch64_mlsv8hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
+vmlsq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return __builtin_aarch64_mlav4si (__a, __b, __c);
+  return __builtin_aarch64_mlsv4si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
+vmlsq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return __builtin_aarch64_mlav16qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlsv16qi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
+vmlsq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return __builtin_aarch64_mlav8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlsv8hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
+vmlsq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return __builtin_aarch64_mlav4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_mlsv4si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c)
+vmovl_high_s8 (int8x16_t __a)
 {
-  return __builtin_aarch64_float_mls_nv2sf (__a, __b, __c);
+  return __builtin_aarch64_vec_unpacks_hi_v16qi (__a);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c)
+vmovl_high_s16 (int16x8_t __a)
 {
-  return __builtin_aarch64_mls_nv4hi (__a, __b, __c);
+  return __builtin_aarch64_vec_unpacks_hi_v8hi (__a);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c)
+vmovl_high_s32 (int32x4_t __a)
 {
-  return __builtin_aarch64_mls_nv2si (__a, __b, __c);
+  return __builtin_aarch64_vec_unpacks_hi_v4si (__a);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c)
+vmovl_high_u8 (uint8x16_t __a)
 {
-  return __builtin_aarch64_mls_nv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_vec_unpacku_hi_v16qi_uu (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c)
+vmovl_high_u16 (uint16x8_t __a)
 {
-  return __builtin_aarch64_mls_nv2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_vec_unpacku_hi_v8hi_uu (__a);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
+vmovl_high_u32 (uint32x4_t __a)
 {
-  return __builtin_aarch64_mlsv8qi (__a, __b, __c);
+  return __builtin_aarch64_vec_unpacku_hi_v4si_uu (__a);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
+vmovl_s8 (int8x8_t __a)
 {
-  return __builtin_aarch64_mlsv4hi (__a, __b, __c);
+  return __builtin_aarch64_sxtlv8hi (__a);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
+vmovl_s16 (int16x4_t __a)
 {
-  return __builtin_aarch64_mlsv2si (__a, __b, __c);
+  return __builtin_aarch64_sxtlv4si (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
+vmovl_s32 (int32x2_t __a)
 {
-  return __builtin_aarch64_mlsv8qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_sxtlv2di (__a);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
+vmovl_u8 (uint8x8_t __a)
 {
-  return __builtin_aarch64_mlsv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_uxtlv8hi_uu (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmls_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
+vmovl_u16 (uint16x4_t __a)
 {
-  return __builtin_aarch64_mlsv2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_uxtlv4si_uu (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_lane_s16(int32x4_t __a, int16x8_t __b, int16x4_t __v,
-                   const int __lane)
+vmovl_u32 (uint32x2_t __a)
 {
-  return __builtin_aarch64_smlsl_hi_lanev8hi (__a, __b, __v, __lane);
+  return __builtin_aarch64_uxtlv2di_uu (__a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_lane_s32(int64x2_t __a, int32x4_t __b, int32x2_t __v,
-                   const int __lane)
+vmovn_high_s16 (int8x8_t __a, int16x8_t __b)
 {
-  return __builtin_aarch64_smlsl_hi_lanev4si (__a, __b, __v, __lane);
+  return __builtin_aarch64_xtn2v8hi (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_lane_u16(uint32x4_t __a, uint16x8_t __b, uint16x4_t __v,
-                   const int __lane)
+vmovn_high_s32 (int16x4_t __a, int32x4_t __b)
 {
-  return __builtin_aarch64_umlsl_hi_lanev8hi_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_xtn2v4si (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_lane_u32(uint64x2_t __a, uint32x4_t __b, uint32x2_t __v,
-                   const int __lane)
+vmovn_high_s64 (int32x2_t __a, int64x2_t __b)
 {
-  return __builtin_aarch64_umlsl_hi_lanev4si_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_xtn2v2di (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_laneq_s16(int32x4_t __a, int16x8_t __b, int16x8_t __v,
-                    const int __lane)
+vmovn_high_u16 (uint8x8_t __a, uint16x8_t __b)
 {
-  return __builtin_aarch64_smlsl_hi_laneqv8hi (__a, __b, __v, __lane);
+  return __builtin_aarch64_xtn2v8hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_laneq_s32(int64x2_t __a, int32x4_t __b, int32x4_t __v,
-                    const int __lane)
+vmovn_high_u32 (uint16x4_t __a, uint32x4_t __b)
 {
-  return __builtin_aarch64_smlsl_hi_laneqv4si (__a, __b, __v, __lane);
+  return __builtin_aarch64_xtn2v4si_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_laneq_u16(uint32x4_t __a, uint16x8_t __b, uint16x8_t __v,
-                    const int __lane)
+vmovn_high_u64 (uint32x2_t __a, uint64x2_t __b)
 {
-  return __builtin_aarch64_umlsl_hi_laneqv8hi_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_xtn2v2di_uuu (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_laneq_u32(uint64x2_t __a, uint32x4_t __b, uint32x4_t __v,
-                    const int __lane)
+vmovn_s16 (int16x8_t __a)
 {
-  return __builtin_aarch64_umlsl_hi_laneqv4si_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_xtnv8hi (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_n_s16 (int32x4_t __a, int16x8_t __b, int16_t __c)
+vmovn_s32 (int32x4_t __a)
 {
-  return __builtin_aarch64_smlsl_hi_nv8hi (__a, __b, __c);
+  return __builtin_aarch64_xtnv4si (__a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_n_s32 (int64x2_t __a, int32x4_t __b, int32_t __c)
+vmovn_s64 (int64x2_t __a)
 {
-  return __builtin_aarch64_smlsl_hi_nv4si (__a, __b, __c);
+  return __builtin_aarch64_xtnv2di (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_n_u16 (uint32x4_t __a, uint16x8_t __b, uint16_t __c)
+vmovn_u16 (uint16x8_t __a)
 {
-  return __builtin_aarch64_umlsl_hi_nv8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_xtnv8hi_uu (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_n_u32 (uint64x2_t __a, uint32x4_t __b, uint32_t __c)
+vmovn_u32 (uint32x4_t __a)
 {
-  return __builtin_aarch64_umlsl_hi_nv4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_xtnv4si_uu (__a);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_s8 (int16x8_t __a, int8x16_t __b, int8x16_t __c)
+vmovn_u64 (uint64x2_t __a)
 {
-  return __builtin_aarch64_smlsl_hiv16qi (__a, __b, __c);
+  return __builtin_aarch64_xtnv2di_uu (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_s16 (int32x4_t __a, int16x8_t __b, int16x8_t __c)
+vshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return __builtin_aarch64_smlsl_hiv8hi (__a, __b, __c);
+  return __builtin_aarch64_shrn_nv8hi (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_s32 (int64x2_t __a, int32x4_t __b, int32x4_t __c)
+vshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_smlsl_hiv4si (__a, __b, __c);
+  return __builtin_aarch64_shrn_nv4si (__a, __b);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_u8 (uint16x8_t __a, uint8x16_t __b, uint8x16_t __c)
+vshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_umlsl_hiv16qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_shrn_nv2di (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_u16 (uint32x4_t __a, uint16x8_t __b, uint16x8_t __c)
+vshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return __builtin_aarch64_umlsl_hiv8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_shrn_nv8hi_uus (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_high_u32 (uint64x2_t __a, uint32x4_t __b, uint32x4_t __c)
+vshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_umlsl_hiv4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_shrn_nv4si_uus (__a, __b);
+}
+
+__extension__ extern __inline uint32x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vshrn_n_u64 (uint64x2_t __a, const int __b)
+{
+  return __builtin_aarch64_shrn_nv2di_uus (__a, __b);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __v, const int __lane)
+vmull_high_lane_s16 (int16x8_t __a, int16x4_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlsl_lane_v4hi (__a, __b, __v, __lane);
+  return __builtin_aarch64_smull_hi_lanev8hi (__a, __v, __lane);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __v, const int __lane)
+vmull_high_lane_s32 (int32x4_t __a, int32x2_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlsl_lane_v2si (__a, __b, __v, __lane);
+  return __builtin_aarch64_smull_hi_lanev4si (__a, __v, __lane);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_lane_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __v,
-                const int __lane)
+vmull_high_lane_u16 (uint16x8_t __a, uint16x4_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_umlsl_lane_v4hi_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umull_hi_lanev8hi_uuus (__a, __v, __lane);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_lane_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __v,
-                const int __lane)
+vmull_high_lane_u32 (uint32x4_t __a, uint32x2_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_umlsl_lane_v2si_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umull_hi_lanev4si_uuus (__a, __v, __lane);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_laneq_s16 (int32x4_t __a, int16x4_t __b, int16x8_t __v, const int __lane)
+vmull_high_laneq_s16 (int16x8_t __a, int16x8_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlsl_laneq_v4hi (__a, __b, __v, __lane);
+  return __builtin_aarch64_smull_hi_laneqv8hi (__a, __v, __lane);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_laneq_s32 (int64x2_t __a, int32x2_t __b, int32x4_t __v, const int __lane)
+vmull_high_laneq_s32 (int32x4_t __a, int32x4_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_smlsl_laneq_v2si (__a, __b, __v, __lane);
+  return __builtin_aarch64_smull_hi_laneqv4si (__a, __v, __lane);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_laneq_u16 (uint32x4_t __a, uint16x4_t __b, uint16x8_t __v,
-                 const int __lane)
+vmull_high_laneq_u16 (uint16x8_t __a, uint16x8_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_umlsl_laneq_v4hi_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umull_hi_laneqv8hi_uuus (__a, __v, __lane);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_laneq_u32 (uint64x2_t __a, uint32x2_t __b, uint32x4_t __v,
-                 const int __lane)
+vmull_high_laneq_u32 (uint32x4_t __a, uint32x4_t __v, const int __lane)
 {
-  return __builtin_aarch64_vec_umlsl_laneq_v2si_uuuus (__a, __b, __v, __lane);
+  return __builtin_aarch64_umull_hi_laneqv4si_uuus (__a, __v, __lane);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
+vmull_high_n_s16 (int16x8_t __a, int16_t __b)
 {
-  return __builtin_aarch64_smlsl_nv4hi (__a, __b, __c);
+  return __builtin_aarch64_smull_hi_nv8hi (__a, __b);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
+vmull_high_n_s32 (int32x4_t __a, int32_t __b)
 {
-  return __builtin_aarch64_smlsl_nv2si (__a, __b, __c);
+  return __builtin_aarch64_smull_hi_nv4si (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c)
+vmull_high_n_u16 (uint16x8_t __a, uint16_t __b)
 {
-  return __builtin_aarch64_umlsl_nv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umull_hi_nv8hi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c)
+vmull_high_n_u32 (uint32x4_t __a, uint32_t __b)
 {
-  return __builtin_aarch64_umlsl_nv2si_uuuu (__a, __b, __c);
+ return __builtin_aarch64_umull_hi_nv4si_uuu (__a, __b);
+}
+
+__extension__ extern __inline poly16x8_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmull_high_p8 (poly8x16_t __a, poly8x16_t __b)
+{
+  return __builtin_aarch64_pmull_hiv16qi_ppp (__a, __b);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
+vmull_high_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return __builtin_aarch64_smlslv8qi (__a, __b, __c);
+  return __builtin_aarch64_vec_widen_smult_hi_v16qi (__a, __b);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
+vmull_high_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return __builtin_aarch64_smlslv4hi (__a, __b, __c);
+  return __builtin_aarch64_vec_widen_smult_hi_v8hi (__a, __b);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
+vmull_high_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return __builtin_aarch64_smlslv2si (__a, __b, __c);
+  return __builtin_aarch64_vec_widen_smult_hi_v4si (__a, __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
+vmull_high_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return __builtin_aarch64_umlslv8qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_vec_widen_umult_hi_v16qi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
+vmull_high_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return __builtin_aarch64_umlslv4hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_vec_widen_umult_hi_v8hi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsl_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
+vmull_high_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return __builtin_aarch64_umlslv2si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_vec_widen_umult_hi_v4si_uuu (__a, __b);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c)
+vmull_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return __builtin_aarch64_float_mls_nv4sf (__a, __b, __c);
+  return __builtin_aarch64_vec_smult_lane_v4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c)
+vmull_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return __builtin_aarch64_mls_nv8hi (__a, __b, __c);
+  return __builtin_aarch64_vec_smult_lane_v2si (__a, __b, __c);
+}
+
+__extension__ extern __inline uint32x4_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmull_lane_u16 (uint16x4_t __a, uint16x4_t __b, const int __c)
+{
+  return __builtin_aarch64_vec_umult_lane_v4hi_uuus (__a, __b, __c);
+}
+
+__extension__ extern __inline uint64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmull_lane_u32 (uint32x2_t __a, uint32x2_t __b, const int __c)
+{
+  return __builtin_aarch64_vec_umult_lane_v2si_uuus (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c)
+vmull_laneq_s16 (int16x4_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_mls_nv4si (__a, __b, __c);
+  return __builtin_aarch64_vec_smult_laneq_v4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c)
+vmull_laneq_s32 (int32x2_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_mls_nv8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_vec_smult_laneq_v2si (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c)
+vmull_laneq_u16 (uint16x4_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_mls_nv4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_vec_umult_laneq_v4hi_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
+vmull_laneq_u32 (uint32x2_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_mlsv16qi (__a, __b, __c);
+  return __builtin_aarch64_vec_umult_laneq_v2si_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
+vmull_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return __builtin_aarch64_mlsv8hi (__a, __b, __c);
+  return __builtin_aarch64_smull_nv4hi (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
+vmull_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return __builtin_aarch64_mlsv4si (__a, __b, __c);
+  return __builtin_aarch64_smull_nv2si (__a, __b);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
+vmull_n_u16 (uint16x4_t __a, uint16_t __b)
 {
-  return __builtin_aarch64_mlsv16qi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umull_nv4hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
+vmull_n_u32 (uint32x2_t __a, uint32_t __b)
 {
-  return __builtin_aarch64_mlsv8hi_uuuu (__a, __b, __c);
+  return __builtin_aarch64_umull_nv2si_uuu (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline poly16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmlsq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
+vmull_p8 (poly8x8_t __a, poly8x8_t __b)
 {
-  return __builtin_aarch64_mlsv4si_uuuu (__a, __b, __c);
+  return __builtin_aarch64_pmullv8qi_ppp (__a, __b);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_high_s8 (int8x16_t __a)
+vmull_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return __builtin_aarch64_vec_unpacks_hi_v16qi (__a);
+  return __builtin_aarch64_intrinsic_vec_smult_lo_v8qi (__a, __b);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_high_s16 (int16x8_t __a)
+vmull_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return __builtin_aarch64_vec_unpacks_hi_v8hi (__a);
+  return __builtin_aarch64_intrinsic_vec_smult_lo_v4hi (__a, __b);
 }
 
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_high_s32 (int32x4_t __a)
+vmull_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return __builtin_aarch64_vec_unpacks_hi_v4si (__a);
+  return __builtin_aarch64_intrinsic_vec_smult_lo_v2si (__a, __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_high_u8 (uint8x16_t __a)
+vmull_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return __builtin_aarch64_vec_unpacku_hi_v16qi_uu (__a);
+  return __builtin_aarch64_intrinsic_vec_umult_lo_v8qi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_high_u16 (uint16x8_t __a)
+vmull_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return __builtin_aarch64_vec_unpacku_hi_v8hi_uu (__a);
+  return __builtin_aarch64_intrinsic_vec_umult_lo_v4hi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_high_u32 (uint32x4_t __a)
-{
-  return __builtin_aarch64_vec_unpacku_hi_v4si_uu (__a);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_s8 (int8x8_t __a)
+vmull_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return __builtin_aarch64_sxtlv8hi (__a);
+  return __builtin_aarch64_intrinsic_vec_umult_lo_v2si_uuu (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_s16 (int16x4_t __a)
+vpadal_s8 (int16x4_t __a, int8x8_t __b)
 {
-  return __builtin_aarch64_sxtlv4si (__a);
+  return __builtin_aarch64_sadalpv8qi (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_s32 (int32x2_t __a)
+vpadal_s16 (int32x2_t __a, int16x4_t __b)
 {
-  return __builtin_aarch64_sxtlv2di (__a);
+  return __builtin_aarch64_sadalpv4hi (__a, __b);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_u8 (uint8x8_t __a)
+vpadal_s32 (int64x1_t __a, int32x2_t __b)
 {
-  return __builtin_aarch64_uxtlv8hi_uu (__a);
+  return (int64x1_t) __builtin_aarch64_sadalpv2si (__a[0], __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_u16 (uint16x4_t __a)
+vpadal_u8 (uint16x4_t __a, uint8x8_t __b)
 {
-  return __builtin_aarch64_uxtlv4si_uu (__a);
+  return __builtin_aarch64_uadalpv8qi_uuu (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovl_u32 (uint32x2_t __a)
+vpadal_u16 (uint32x2_t __a, uint16x4_t __b)
 {
-  return __builtin_aarch64_uxtlv2di_uu (__a);
+  return __builtin_aarch64_uadalpv4hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_high_s16 (int8x8_t __a, int16x8_t __b)
+vpadal_u32 (uint64x1_t __a, uint32x2_t __b)
 {
-  return __builtin_aarch64_xtn2v8hi (__a, __b);
+  return (uint64x1_t) __builtin_aarch64_uadalpv2si_uuu (__a[0], __b);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_high_s32 (int16x4_t __a, int32x4_t __b)
+vpadalq_s8 (int16x8_t __a, int8x16_t __b)
 {
-  return __builtin_aarch64_xtn2v4si (__a, __b);
+  return __builtin_aarch64_sadalpv16qi (__a, __b);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_high_s64 (int32x2_t __a, int64x2_t __b)
+vpadalq_s16 (int32x4_t __a, int16x8_t __b)
 {
-  return __builtin_aarch64_xtn2v2di (__a, __b);
+  return __builtin_aarch64_sadalpv8hi (__a, __b);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_high_u16 (uint8x8_t __a, uint16x8_t __b)
+vpadalq_s32 (int64x2_t __a, int32x4_t __b)
 {
-  return __builtin_aarch64_xtn2v8hi_uuu (__a, __b);
+  return __builtin_aarch64_sadalpv4si (__a, __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_high_u32 (uint16x4_t __a, uint32x4_t __b)
+vpadalq_u8 (uint16x8_t __a, uint8x16_t __b)
 {
-  return __builtin_aarch64_xtn2v4si_uuu (__a, __b);
+  return __builtin_aarch64_uadalpv16qi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_high_u64 (uint32x2_t __a, uint64x2_t __b)
+vpadalq_u16 (uint32x4_t __a, uint16x8_t __b)
 {
-  return __builtin_aarch64_xtn2v2di_uuu (__a, __b);
+  return __builtin_aarch64_uadalpv8hi_uuu (__a, __b);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_s16 (int16x8_t __a)
+vpadalq_u32 (uint64x2_t __a, uint32x4_t __b)
 {
-  return __builtin_aarch64_xtnv8hi (__a);
+  return __builtin_aarch64_uadalpv4si_uuu (__a, __b);
 }
 
 __extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_s32 (int32x4_t __a)
+vpaddl_s8 (int8x8_t __a)
 {
-  return __builtin_aarch64_xtnv4si (__a);
+  return __builtin_aarch64_saddlpv8qi (__a);
 }
 
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_s64 (int64x2_t __a)
+vpaddl_s16 (int16x4_t __a)
 {
-  return __builtin_aarch64_xtnv2di (__a);
+  return __builtin_aarch64_saddlpv4hi (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_u16 (uint16x8_t __a)
+vpaddl_s32 (int32x2_t __a)
 {
-  return __builtin_aarch64_xtnv8hi_uu (__a);
+  return (int64x1_t) __builtin_aarch64_saddlpv2si (__a);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_u32 (uint32x4_t __a)
+vpaddl_u8 (uint8x8_t __a)
 {
-  return __builtin_aarch64_xtnv4si_uu (__a);
+  return __builtin_aarch64_uaddlpv8qi_uu (__a);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmovn_u64 (uint64x2_t __a)
+vpaddl_u16 (uint16x4_t __a)
 {
-  return __builtin_aarch64_xtnv2di_uu (__a);
+  return __builtin_aarch64_uaddlpv4hi_uu (__a);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_n_s16 (int16x8_t __a, const int __b)
+vpaddl_u32 (uint32x2_t __a)
 {
-  return __builtin_aarch64_shrn_nv8hi (__a, __b);
+  return (uint64x1_t) __builtin_aarch64_uaddlpv2si_uu (__a);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_n_s32 (int32x4_t __a, const int __b)
+vpaddlq_s8 (int8x16_t __a)
 {
-  return __builtin_aarch64_shrn_nv4si (__a, __b);
+  return __builtin_aarch64_saddlpv16qi (__a);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_n_s64 (int64x2_t __a, const int __b)
+vpaddlq_s16 (int16x8_t __a)
 {
-  return __builtin_aarch64_shrn_nv2di (__a, __b);
+  return __builtin_aarch64_saddlpv8hi (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_n_u16 (uint16x8_t __a, const int __b)
+vpaddlq_s32 (int32x4_t __a)
 {
-  return __builtin_aarch64_shrn_nv8hi_uus (__a, __b);
+  return __builtin_aarch64_saddlpv4si (__a);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_n_u32 (uint32x4_t __a, const int __b)
+vpaddlq_u8 (uint8x16_t __a)
 {
-  return __builtin_aarch64_shrn_nv4si_uus (__a, __b);
+  return __builtin_aarch64_uaddlpv16qi_uu (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_n_u64 (uint64x2_t __a, const int __b)
+vpaddlq_u16 (uint16x8_t __a)
 {
-  return __builtin_aarch64_shrn_nv2di_uus (__a, __b);
+  return __builtin_aarch64_uaddlpv8hi_uu (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_lane_s16 (int16x8_t __a, int16x4_t __v, const int __lane)
+vpaddlq_u32 (uint32x4_t __a)
 {
-  return __builtin_aarch64_smull_hi_lanev8hi (__a, __v, __lane);
+  return __builtin_aarch64_uaddlpv4si_uu (__a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_lane_s32 (int32x4_t __a, int32x2_t __v, const int __lane)
+vpaddq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return __builtin_aarch64_smull_hi_lanev4si (__a, __v, __lane);
+  return __builtin_aarch64_addpv16qi (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_lane_u16 (uint16x8_t __a, uint16x4_t __v, const int __lane)
+vpaddq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return __builtin_aarch64_umull_hi_lanev8hi_uuus (__a, __v, __lane);
+  return __builtin_aarch64_addpv8hi (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_lane_u32 (uint32x4_t __a, uint32x2_t __v, const int __lane)
+vpaddq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return __builtin_aarch64_umull_hi_lanev4si_uuus (__a, __v, __lane);
+  return __builtin_aarch64_addpv4si (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_laneq_s16 (int16x8_t __a, int16x8_t __v, const int __lane)
+vpaddq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return __builtin_aarch64_smull_hi_laneqv8hi (__a, __v, __lane);
+  return __builtin_aarch64_addpv2di (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_laneq_s32 (int32x4_t __a, int32x4_t __v, const int __lane)
+vpaddq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return __builtin_aarch64_smull_hi_laneqv4si (__a, __v, __lane);
+  return __builtin_aarch64_addpv16qi_uuu (__a, __b);
+}
+
+__extension__ extern __inline uint16x8_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vpaddq_u16 (uint16x8_t __a, uint16x8_t __b)
+{
+  return __builtin_aarch64_addpv8hi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_laneq_u16 (uint16x8_t __a, uint16x8_t __v, const int __lane)
+vpaddq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return __builtin_aarch64_umull_hi_laneqv8hi_uuus (__a, __v, __lane);
+  return __builtin_aarch64_addpv4si_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_laneq_u32 (uint32x4_t __a, uint32x4_t __v, const int __lane)
+vpaddq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return __builtin_aarch64_umull_hi_laneqv4si_uuus (__a, __v, __lane);
+  return __builtin_aarch64_addpv2di_uuu (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_n_s16 (int16x8_t __a, int16_t __b)
+vqdmulh_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return __builtin_aarch64_smull_hi_nv8hi (__a, __b);
+  return __builtin_aarch64_sqdmulh_nv4hi (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_n_s32 (int32x4_t __a, int32_t __b)
+vqdmulh_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return __builtin_aarch64_smull_hi_nv4si (__a, __b);
+  return __builtin_aarch64_sqdmulh_nv2si (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_n_u16 (uint16x8_t __a, uint16_t __b)
+vqdmulhq_n_s16 (int16x8_t __a, int16_t __b)
 {
-  return __builtin_aarch64_umull_hi_nv8hi_uuu (__a, __b);
+  return __builtin_aarch64_sqdmulh_nv8hi (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_n_u32 (uint32x4_t __a, uint32_t __b)
+vqdmulhq_n_s32 (int32x4_t __a, int32_t __b)
 {
- return __builtin_aarch64_umull_hi_nv4si_uuu (__a, __b);
+  return __builtin_aarch64_sqdmulh_nv4si (__a, __b);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_p8 (poly8x16_t __a, poly8x16_t __b)
+vqmovn_high_s16 (int8x8_t __a, int16x8_t __b)
 {
-  return __builtin_aarch64_pmull_hiv16qi_ppp (__a, __b);
+  return __builtin_aarch64_sqxtn2v8hi (__a, __b);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_s8 (int8x16_t __a, int8x16_t __b)
+vqmovn_high_s32 (int16x4_t __a, int32x4_t __b)
 {
-  return __builtin_aarch64_vec_widen_smult_hi_v16qi (__a, __b);
+  return __builtin_aarch64_sqxtn2v4si (__a, __b);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_s16 (int16x8_t __a, int16x8_t __b)
+vqmovn_high_s64 (int32x2_t __a, int64x2_t __b)
 {
-  return __builtin_aarch64_vec_widen_smult_hi_v8hi (__a, __b);
+  return __builtin_aarch64_sqxtn2v2di (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_s32 (int32x4_t __a, int32x4_t __b)
+vqmovn_high_u16 (uint8x8_t __a, uint16x8_t __b)
 {
-  return __builtin_aarch64_vec_widen_smult_hi_v4si (__a, __b);
+  return __builtin_aarch64_uqxtn2v8hi_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_u8 (uint8x16_t __a, uint8x16_t __b)
+vqmovn_high_u32 (uint16x4_t __a, uint32x4_t __b)
 {
-  return __builtin_aarch64_vec_widen_umult_hi_v16qi_uuu (__a, __b);
+  return __builtin_aarch64_uqxtn2v4si_uuu (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_u16 (uint16x8_t __a, uint16x8_t __b)
+vqmovn_high_u64 (uint32x2_t __a, uint64x2_t __b)
 {
-  return __builtin_aarch64_vec_widen_umult_hi_v8hi_uuu (__a, __b);
+  return __builtin_aarch64_uqxtn2v2di_uuu (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_u32 (uint32x4_t __a, uint32x4_t __b)
+vqmovun_high_s16 (uint8x8_t __a, int16x8_t __b)
 {
-  return __builtin_aarch64_vec_widen_umult_hi_v4si_uuu (__a, __b);
+  return __builtin_aarch64_sqxtun2v8hi_uus (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c)
+vqmovun_high_s32 (uint16x4_t __a, int32x4_t __b)
 {
-  return __builtin_aarch64_vec_smult_lane_v4hi (__a, __b, __c);
+  return __builtin_aarch64_sqxtun2v4si_uus (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)
+vqmovun_high_s64 (uint32x2_t __a, int64x2_t __b)
 {
-  return __builtin_aarch64_vec_smult_lane_v2si (__a, __b, __c);
+  return __builtin_aarch64_sqxtun2v2di_uus (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_lane_u16 (uint16x4_t __a, uint16x4_t __b, const int __c)
+vqrdmulh_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return __builtin_aarch64_vec_umult_lane_v4hi_uuus (__a, __b, __c);
+  return __builtin_aarch64_sqrdmulh_nv4hi (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_lane_u32 (uint32x2_t __a, uint32x2_t __b, const int __c)
+vqrdmulh_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return __builtin_aarch64_vec_umult_lane_v2si_uuus (__a, __b, __c);
+  return __builtin_aarch64_sqrdmulh_nv2si (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_laneq_s16 (int16x4_t __a, int16x8_t __b, const int __c)
+vqrdmulhq_n_s16 (int16x8_t __a, int16_t __b)
 {
-  return __builtin_aarch64_vec_smult_laneq_v4hi (__a, __b, __c);
+  return __builtin_aarch64_sqrdmulh_nv8hi (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_laneq_s32 (int32x2_t __a, int32x4_t __b, const int __c)
+vqrdmulhq_n_s32 (int32x4_t __a, int32_t __b)
 {
-  return __builtin_aarch64_vec_smult_laneq_v2si (__a, __b, __c);
+  return __builtin_aarch64_sqrdmulh_nv4si (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_laneq_u16 (uint16x4_t __a, uint16x8_t __b, const int __c)
+vqrshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_vec_umult_laneq_v4hi_uuus (__a, __b, __c);
+  return __builtin_aarch64_sqrshrn2_nv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_laneq_u32 (uint32x2_t __a, uint32x4_t __b, const int __c)
+vqrshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_vec_umult_laneq_v2si_uuus (__a, __b, __c);
+  return __builtin_aarch64_sqrshrn2_nv4si (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_n_s16 (int16x4_t __a, int16_t __b)
+vqrshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_smull_nv4hi (__a, __b);
+  return __builtin_aarch64_sqrshrn2_nv2di (__a, __b, __c);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_n_s32 (int32x2_t __a, int32_t __b)
+vqrshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_smull_nv2si (__a, __b);
+  return __builtin_aarch64_uqrshrn2_nv8hi_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_n_u16 (uint16x4_t __a, uint16_t __b)
+vqrshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_umull_nv4hi_uuu (__a, __b);
+  return __builtin_aarch64_uqrshrn2_nv4si_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_n_u32 (uint32x2_t __a, uint32_t __b)
+vqrshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_umull_nv2si_uuu (__a, __b);
+  return __builtin_aarch64_uqrshrn2_nv2di_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_p8 (poly8x8_t __a, poly8x8_t __b)
+vqrshrun_high_n_s16 (uint8x8_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_pmullv8qi_ppp (__a, __b);
+  return __builtin_aarch64_sqrshrun2_nv8hi_uuss (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_s8 (int8x8_t __a, int8x8_t __b)
+vqrshrun_high_n_s32 (uint16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_intrinsic_vec_smult_lo_v8qi (__a, __b);
+  return __builtin_aarch64_sqrshrun2_nv4si_uuss (__a, __b, __c);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_s16 (int16x4_t __a, int16x4_t __b)
+vqrshrun_high_n_s64 (uint32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_intrinsic_vec_smult_lo_v4hi (__a, __b);
+  return __builtin_aarch64_sqrshrun2_nv2di_uuss (__a, __b, __c);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_s32 (int32x2_t __a, int32x2_t __b)
+vqshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_intrinsic_vec_smult_lo_v2si (__a, __b);
+  return __builtin_aarch64_sqsshrn2_nv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_u8 (uint8x8_t __a, uint8x8_t __b)
+vqshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_intrinsic_vec_umult_lo_v8qi_uuu (__a, __b);
+  return __builtin_aarch64_sqsshrn2_nv4si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_u16 (uint16x4_t __a, uint16x4_t __b)
+vqshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_intrinsic_vec_umult_lo_v4hi_uuu (__a, __b);
+  return __builtin_aarch64_sqsshrn2_nv2di (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_u32 (uint32x2_t __a, uint32x2_t __b)
+vqshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_intrinsic_vec_umult_lo_v2si_uuu (__a, __b);
+  return __builtin_aarch64_uqushrn2_nv8hi_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadal_s8 (int16x4_t __a, int8x8_t __b)
+vqshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_sadalpv8qi (__a, __b);
+  return __builtin_aarch64_uqushrn2_nv4si_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadal_s16 (int32x2_t __a, int16x4_t __b)
+vqshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_sadalpv4hi (__a, __b);
+  return __builtin_aarch64_uqushrn2_nv2di_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadal_s32 (int64x1_t __a, int32x2_t __b)
+vqshrun_high_n_s16 (uint8x8_t __a, int16x8_t __b, const int __c)
 {
-  return (int64x1_t) __builtin_aarch64_sadalpv2si (__a[0], __b);
+  return __builtin_aarch64_sqshrun2_nv8hi_uuss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadal_u8 (uint16x4_t __a, uint8x8_t __b)
+vqshrun_high_n_s32 (uint16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_uadalpv8qi_uuu (__a, __b);
+  return __builtin_aarch64_sqshrun2_nv4si_uuss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadal_u16 (uint32x2_t __a, uint16x4_t __b)
+vqshrun_high_n_s64 (uint32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_uadalpv4hi_uuu (__a, __b);
+  return __builtin_aarch64_sqshrun2_nv2di_uuss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadal_u32 (uint64x1_t __a, uint32x2_t __b)
+vrshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
 {
-  return (uint64x1_t) __builtin_aarch64_uadalpv2si_uuu (__a[0], __b);
+  return __builtin_aarch64_rshrn2_nv8hi (__a, __b, __c);
 }
 
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadalq_s8 (int16x8_t __a, int8x16_t __b)
+vrshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_sadalpv16qi (__a, __b);
+  return __builtin_aarch64_rshrn2_nv4si (__a, __b, __c);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadalq_s16 (int32x4_t __a, int16x8_t __b)
+vrshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_sadalpv8hi (__a, __b);
+  return __builtin_aarch64_rshrn2_nv2di (__a, __b, __c);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadalq_s32 (int64x2_t __a, int32x4_t __b)
+vrshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_sadalpv4si (__a, __b);
+  return __builtin_aarch64_rshrn2_nv8hi_uuus (__a, __b, __c);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadalq_u8 (uint16x8_t __a, uint8x16_t __b)
+vrshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_uadalpv16qi_uuu (__a, __b);
+  return __builtin_aarch64_rshrn2_nv4si_uuus (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadalq_u16 (uint32x4_t __a, uint16x8_t __b)
+vrshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_uadalpv8hi_uuu (__a, __b);
+  return __builtin_aarch64_rshrn2_nv2di_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpadalq_u32 (uint64x2_t __a, uint32x4_t __b)
+vrshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return __builtin_aarch64_uadalpv4si_uuu (__a, __b);
+  return __builtin_aarch64_rshrn_nv8hi (__a, __b);
 }
 
 __extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddl_s8 (int8x8_t __a)
+vrshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_saddlpv8qi (__a);
+  return __builtin_aarch64_rshrn_nv4si (__a, __b);
 }
 
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddl_s16 (int16x4_t __a)
+vrshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_saddlpv4hi (__a);
+  return __builtin_aarch64_rshrn_nv2di (__a, __b);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddl_s32 (int32x2_t __a)
+vrshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (int64x1_t) __builtin_aarch64_saddlpv2si (__a);
+  return __builtin_aarch64_rshrn_nv8hi_uus (__a, __b);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddl_u8 (uint8x8_t __a)
+vrshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_uaddlpv8qi_uu (__a);
+  return __builtin_aarch64_rshrn_nv4si_uus (__a, __b);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddl_u16 (uint16x4_t __a)
-{
-  return __builtin_aarch64_uaddlpv4hi_uu (__a);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddl_u32 (uint32x2_t __a)
+vrshrn_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint64x1_t) __builtin_aarch64_uaddlpv2si_uu (__a);
+  return __builtin_aarch64_rshrn_nv2di_uus (__a, __b);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddlq_s8 (int8x16_t __a)
+vrsqrte_u32 (uint32x2_t __a)
 {
-  return __builtin_aarch64_saddlpv16qi (__a);
+  return __builtin_aarch64_ursqrtev2si_uu (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddlq_s16 (int16x8_t __a)
+vrsqrteq_u32 (uint32x4_t __a)
 {
-  return __builtin_aarch64_saddlpv8hi (__a);
+  return __builtin_aarch64_ursqrtev4si_uu (__a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddlq_s32 (int32x4_t __a)
+vshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_saddlpv4si (__a);
+  return __builtin_aarch64_ushrn2_nv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddlq_u8 (uint8x16_t __a)
+vshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_uaddlpv16qi_uu (__a);
+  return __builtin_aarch64_ushrn2_nv4si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddlq_u16 (uint16x8_t __a)
+vshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_uaddlpv8hi_uu (__a);
+  return __builtin_aarch64_ushrn2_nv2di (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddlq_u32 (uint32x4_t __a)
+vshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_uaddlpv4si_uu (__a);
+  return __builtin_aarch64_ushrn2_nv8hi_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_s8 (int8x16_t __a, int8x16_t __b)
+vshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv16qi (__a, __b);
+  return __builtin_aarch64_ushrn2_nv4si_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_s16 (int16x8_t __a, int16x8_t __b)
+vshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv8hi (__a, __b);
+  return __builtin_aarch64_ushrn2_nv2di_uuus (__a, __b, __c);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_s32 (int32x4_t __a, int32x4_t __b)
+vsli_n_p8 (poly8x8_t __a, poly8x8_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv4si (__a, __b);
+  return __builtin_aarch64_ssli_nv8qi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline poly16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_s64 (int64x2_t __a, int64x2_t __b)
+vsli_n_p16 (poly16x4_t __a, poly16x4_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv2di (__a, __b);
+  return __builtin_aarch64_ssli_nv4hi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline poly8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_u8 (uint8x16_t __a, uint8x16_t __b)
+vsliq_n_p8 (poly8x16_t __a, poly8x16_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv16qi_uuu (__a, __b);
+  return __builtin_aarch64_ssli_nv16qi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline poly16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_u16 (uint16x8_t __a, uint16x8_t __b)
+vsliq_n_p16 (poly16x8_t __a, poly16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv8hi_uuu (__a, __b);
+  return __builtin_aarch64_ssli_nv8hi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_u32 (uint32x4_t __a, uint32x4_t __b)
+vsri_n_p8 (poly8x8_t __a, poly8x8_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv4si_uuu (__a, __b);
+  return __builtin_aarch64_ssri_nv8qi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline poly16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vpaddq_u64 (uint64x2_t __a, uint64x2_t __b)
+vsri_n_p16 (poly16x4_t __a, poly16x4_t __b, const int __c)
 {
-  return __builtin_aarch64_addpv2di_uuu (__a, __b);
+  return __builtin_aarch64_ssri_nv4hi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline poly64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulh_n_s16 (int16x4_t __a, int16_t __b)
+vsri_n_p64 (poly64x1_t __a, poly64x1_t __b, const int __c)
 {
-  return __builtin_aarch64_sqdmulh_nv4hi (__a, __b);
+  return (poly64x1_t) __builtin_aarch64_ssri_ndi_ppps (__a[0], __b[0], __c);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline poly8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulh_n_s32 (int32x2_t __a, int32_t __b)
+vsriq_n_p8 (poly8x16_t __a, poly8x16_t __b, const int __c)
 {
-  return __builtin_aarch64_sqdmulh_nv2si (__a, __b);
+  return __builtin_aarch64_ssri_nv16qi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline poly16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulhq_n_s16 (int16x8_t __a, int16_t __b)
+vsriq_n_p16 (poly16x8_t __a, poly16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_sqdmulh_nv8hi (__a, __b);
+  return __builtin_aarch64_ssri_nv8hi_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline poly64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulhq_n_s32 (int32x4_t __a, int32_t __b)
+vsriq_n_p64 (poly64x2_t __a, poly64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_sqdmulh_nv4si (__a, __b);
+  return __builtin_aarch64_ssri_nv2di_ppps (__a, __b, __c);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovn_high_s16 (int8x8_t __a, int16x8_t __b)
+vtst_p8 (poly8x8_t __a, poly8x8_t __b)
 {
-  return __builtin_aarch64_sqxtn2v8hi (__a, __b);
+  return (uint8x8_t) ((((uint8x8_t) __a) & ((uint8x8_t) __b))
+                      != 0);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovn_high_s32 (int16x4_t __a, int32x4_t __b)
+vtst_p16 (poly16x4_t __a, poly16x4_t __b)
 {
-  return __builtin_aarch64_sqxtn2v4si (__a, __b);
+  return (uint16x4_t) ((((uint16x4_t) __a) & ((uint16x4_t) __b))
+                      != 0);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovn_high_s64 (int32x2_t __a, int64x2_t __b)
+vtst_p64 (poly64x1_t __a, poly64x1_t __b)
 {
-  return __builtin_aarch64_sqxtn2v2di (__a, __b);
+  return (uint64x1_t) ((__a & __b) != __AARCH64_INT64_C (0));
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovn_high_u16 (uint8x8_t __a, uint16x8_t __b)
+vtstq_p8 (poly8x16_t __a, poly8x16_t __b)
 {
-  return __builtin_aarch64_uqxtn2v8hi_uuu (__a, __b);
+  return (uint8x16_t) ((((uint8x16_t) __a) & ((uint8x16_t) __b))
+                      != 0);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovn_high_u32 (uint16x4_t __a, uint32x4_t __b)
+vtstq_p16 (poly16x8_t __a, poly16x8_t __b)
 {
-  return __builtin_aarch64_uqxtn2v4si_uuu (__a, __b);
+  return (uint16x8_t) ((((uint16x8_t) __a) & ((uint16x8_t) __b))
+                      != 0);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovn_high_u64 (uint32x2_t __a, uint64x2_t __b)
+vtstq_p64 (poly64x2_t __a, poly64x2_t __b)
 {
-  return __builtin_aarch64_uqxtn2v2di_uuu (__a, __b);
+  return (uint64x2_t) ((((uint64x2_t) __a) & ((uint64x2_t) __b))
+                      != __AARCH64_INT64_C (0));
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovun_high_s16 (uint8x8_t __a, int16x8_t __b)
+vst2_lane_f16 (float16_t *__ptr, float16x4x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqxtun2v8hi_uus (__a, __b);
+  __builtin_aarch64_st2_lanev4hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovun_high_s32 (uint16x4_t __a, int32x4_t __b)
+vst2_lane_f32 (float32_t *__ptr, float32x2x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqxtun2v4si_uus (__a, __b);
+  __builtin_aarch64_st2_lanev2sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqmovun_high_s64 (uint32x2_t __a, int64x2_t __b)
+vst2_lane_f64 (float64_t *__ptr, float64x1x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqxtun2v2di_uus (__a, __b);
+  __builtin_aarch64_st2_lanedf ((__builtin_aarch64_simd_df *) __ptr, __val,
+                               __lane);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulh_n_s16 (int16x4_t __a, int16_t __b)
+vst2_lane_p8 (poly8_t *__ptr, poly8x8x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrdmulh_nv4hi (__a, __b);
+  __builtin_aarch64_st2_lanev8qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulh_n_s32 (int32x2_t __a, int32_t __b)
+vst2_lane_p16 (poly16_t *__ptr, poly16x4x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrdmulh_nv2si (__a, __b);
+  __builtin_aarch64_st2_lanev4hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulhq_n_s16 (int16x8_t __a, int16_t __b)
+vst2_lane_p64 (poly64_t *__ptr, poly64x1x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrdmulh_nv8hi (__a, __b);
+  __builtin_aarch64_st2_lanedi_sps ((__builtin_aarch64_simd_di *) __ptr,
+                                   __val, __lane);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulhq_n_s32 (int32x4_t __a, int32_t __b)
+vst2_lane_s8 (int8_t *__ptr, int8x8x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrdmulh_nv4si (__a, __b);
+  __builtin_aarch64_st2_lanev8qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
+vst2_lane_s16 (int16_t *__ptr, int16x4x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrshrn2_nv8hi (__a, __b, __c);
+  __builtin_aarch64_st2_lanev4hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
+vst2_lane_s32 (int32_t *__ptr, int32x2x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrshrn2_nv4si (__a, __b, __c);
+  __builtin_aarch64_st2_lanev2si ((__builtin_aarch64_simd_si *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
+vst2_lane_s64 (int64_t *__ptr, int64x1x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrshrn2_nv2di (__a, __b, __c);
+  __builtin_aarch64_st2_lanedi ((__builtin_aarch64_simd_di *) __ptr, __val,
+                               __lane);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
+vst2_lane_u8 (uint8_t *__ptr, uint8x8x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_uqrshrn2_nv8hi_uuus (__a, __b, __c);
+  __builtin_aarch64_st2_lanev8qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
+vst2_lane_u16 (uint16_t *__ptr, uint16x4x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_uqrshrn2_nv4si_uuus (__a, __b, __c);
+  __builtin_aarch64_st2_lanev4hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
+vst2_lane_u32 (uint32_t *__ptr, uint32x2x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_uqrshrn2_nv2di_uuus (__a, __b, __c);
+  __builtin_aarch64_st2_lanev2si_sus ((__builtin_aarch64_simd_si *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrun_high_n_s16 (uint8x8_t __a, int16x8_t __b, const int __c)
+vst2_lane_u64 (uint64_t *__ptr, uint64x1x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrshrun2_nv8hi_uuss (__a, __b, __c);
+  __builtin_aarch64_st2_lanedi_sus ((__builtin_aarch64_simd_di *) __ptr, __val,
+                                   __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrun_high_n_s32 (uint16x4_t __a, int32x4_t __b, const int __c)
+vst2q_lane_f16 (float16_t *__ptr, float16x8x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrshrun2_nv4si_uuss (__a, __b, __c);
+  __builtin_aarch64_st2_lanev8hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrshrun_high_n_s64 (uint32x2_t __a, int64x2_t __b, const int __c)
+vst2q_lane_f32 (float32_t *__ptr, float32x4x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqrshrun2_nv2di_uuss (__a, __b, __c);
+  __builtin_aarch64_st2_lanev4sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
+vst2q_lane_f64 (float64_t *__ptr, float64x2x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqsshrn2_nv8hi (__a, __b, __c);
+  __builtin_aarch64_st2_lanev2df ((__builtin_aarch64_simd_df *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
+vst2q_lane_p8 (poly8_t *__ptr, poly8x16x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqsshrn2_nv4si (__a, __b, __c);
+  __builtin_aarch64_st2_lanev16qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
+                                      __val, __lane);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
+vst2q_lane_p16 (poly16_t *__ptr, poly16x8x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqsshrn2_nv2di (__a, __b, __c);
+  __builtin_aarch64_st2_lanev8hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
+vst2q_lane_p64 (poly64_t *__ptr, poly64x2x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_uqushrn2_nv8hi_uuus (__a, __b, __c);
+  __builtin_aarch64_st2_lanev2di_sps ((__builtin_aarch64_simd_di *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
+vst2q_lane_s8 (int8_t *__ptr, int8x16x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_uqushrn2_nv4si_uuus (__a, __b, __c);
+  __builtin_aarch64_st2_lanev16qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
+                                  __lane);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
+vst2q_lane_s16 (int16_t *__ptr, int16x8x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_uqushrn2_nv2di_uuus (__a, __b, __c);
+  __builtin_aarch64_st2_lanev8hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrun_high_n_s16 (uint8x8_t __a, int16x8_t __b, const int __c)
+vst2q_lane_s32 (int32_t *__ptr, int32x4x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqshrun2_nv8hi_uuss (__a, __b, __c);
+  __builtin_aarch64_st2_lanev4si ((__builtin_aarch64_simd_si *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrun_high_n_s32 (uint16x4_t __a, int32x4_t __b, const int __c)
+vst2q_lane_s64 (int64_t *__ptr, int64x2x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqshrun2_nv4si_uuss (__a, __b, __c);
+  __builtin_aarch64_st2_lanev2di ((__builtin_aarch64_simd_di *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqshrun_high_n_s64 (uint32x2_t __a, int64x2_t __b, const int __c)
+vst2q_lane_u8 (uint8_t *__ptr, uint8x16x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_sqshrun2_nv2di_uuss (__a, __b, __c);
+  __builtin_aarch64_st2_lanev16qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
+                                      __val, __lane);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
+vst2q_lane_u16 (uint16_t *__ptr, uint16x8x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn2_nv8hi (__a, __b, __c);
+  __builtin_aarch64_st2_lanev8hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
+vst2q_lane_u32 (uint32_t *__ptr, uint32x4x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn2_nv4si (__a, __b, __c);
+  __builtin_aarch64_st2_lanev4si_sus ((__builtin_aarch64_simd_si *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
+vst2q_lane_u64 (uint64_t *__ptr, uint64x2x2_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn2_nv2di (__a, __b, __c);
+  __builtin_aarch64_st2_lanev2di_sus ((__builtin_aarch64_simd_di *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
+vst3_lane_f16 (float16_t *__ptr, float16x4x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn2_nv8hi_uuus (__a, __b, __c);
+  __builtin_aarch64_st3_lanev4hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
+vst3_lane_f32 (float32_t *__ptr, float32x2x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn2_nv4si_uuus (__a, __b, __c);
+  __builtin_aarch64_st3_lanev2sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
+vst3_lane_f64 (float64_t *__ptr, float64x1x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn2_nv2di_uuus (__a, __b, __c);
+  __builtin_aarch64_st3_lanedf ((__builtin_aarch64_simd_df *) __ptr, __val,
+                               __lane);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_n_s16 (int16x8_t __a, const int __b)
+vst3_lane_p8 (poly8_t *__ptr, poly8x8x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn_nv8hi (__a, __b);
+  __builtin_aarch64_st3_lanev8qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_n_s32 (int32x4_t __a, const int __b)
+vst3_lane_p16 (poly16_t *__ptr, poly16x4x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn_nv4si (__a, __b);
+  __builtin_aarch64_st3_lanev4hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_n_s64 (int64x2_t __a, const int __b)
+vst3_lane_p64 (poly64_t *__ptr, poly64x1x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn_nv2di (__a, __b);
+  __builtin_aarch64_st3_lanedi_sps ((__builtin_aarch64_simd_di *) __ptr, __val,
+                                   __lane);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_n_u16 (uint16x8_t __a, const int __b)
+vst3_lane_s8 (int8_t *__ptr, int8x8x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_rshrn_nv8hi_uus (__a, __b);
-}
-
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_n_u32 (uint32x4_t __a, const int __b)
-{
-  return __builtin_aarch64_rshrn_nv4si_uus (__a, __b);
-}
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrshrn_n_u64 (uint64x2_t __a, const int __b)
-{
-  return __builtin_aarch64_rshrn_nv2di_uus (__a, __b);
-}
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrsqrte_u32 (uint32x2_t __a)
-{
-  return __builtin_aarch64_ursqrtev2si_uu (__a);
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vrsqrteq_u32 (uint32x4_t __a)
-{
-  return __builtin_aarch64_ursqrtev4si_uu (__a);
-}
-
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
-{
-  return __builtin_aarch64_ushrn2_nv8hi (__a, __b, __c);
+  __builtin_aarch64_st3_lanev8qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
+vst3_lane_s16 (int16_t *__ptr, int16x4x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ushrn2_nv4si (__a, __b, __c);
+  __builtin_aarch64_st3_lanev4hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
+vst3_lane_s32 (int32_t *__ptr, int32x2x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ushrn2_nv2di (__a, __b, __c);
+  __builtin_aarch64_st3_lanev2si ((__builtin_aarch64_simd_si *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
+vst3_lane_s64 (int64_t *__ptr, int64x1x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ushrn2_nv8hi_uuus (__a, __b, __c);
+  __builtin_aarch64_st3_lanedi ((__builtin_aarch64_simd_di *) __ptr, __val,
+                               __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
+vst3_lane_u8 (uint8_t *__ptr, uint8x8x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ushrn2_nv4si_uuus (__a, __b, __c);
+  __builtin_aarch64_st3_lanev8qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
+vst3_lane_u16 (uint16_t *__ptr, uint16x4x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ushrn2_nv2di_uuus (__a, __b, __c);
+  __builtin_aarch64_st3_lanev4hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsli_n_p8 (poly8x8_t __a, poly8x8_t __b, const int __c)
+vst3_lane_u32 (uint32_t *__ptr, uint32x2x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssli_nv8qi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev2si_sus ((__builtin_aarch64_simd_si *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline poly16x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsli_n_p16 (poly16x4_t __a, poly16x4_t __b, const int __c)
+vst3_lane_u64 (uint64_t *__ptr, uint64x1x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssli_nv4hi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanedi_sus ((__builtin_aarch64_simd_di *) __ptr, __val,
+                                   __lane);
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsliq_n_p8 (poly8x16_t __a, poly8x16_t __b, const int __c)
+vst3q_lane_f16 (float16_t *__ptr, float16x8x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssli_nv16qi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev8hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsliq_n_p16 (poly16x8_t __a, poly16x8_t __b, const int __c)
+vst3q_lane_f32 (float32_t *__ptr, float32x4x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssli_nv8hi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev4sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsri_n_p8 (poly8x8_t __a, poly8x8_t __b, const int __c)
+vst3q_lane_f64 (float64_t *__ptr, float64x2x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssri_nv8qi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev2df ((__builtin_aarch64_simd_df *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline poly16x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsri_n_p16 (poly16x4_t __a, poly16x4_t __b, const int __c)
+vst3q_lane_p8 (poly8_t *__ptr, poly8x16x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssri_nv4hi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev16qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
+                                      __val, __lane);
 }
 
-__extension__ extern __inline poly64x1_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsri_n_p64 (poly64x1_t __a, poly64x1_t __b, const int __c)
+vst3q_lane_p16 (poly16_t *__ptr, poly16x8x3_t __val, const int __lane)
 {
-  return (poly64x1_t) __builtin_aarch64_ssri_ndi_ppps (__a[0], __b[0], __c);
+  __builtin_aarch64_st3_lanev8hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsriq_n_p8 (poly8x16_t __a, poly8x16_t __b, const int __c)
+vst3q_lane_p64 (poly64_t *__ptr, poly64x2x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssri_nv16qi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev2di_sps ((__builtin_aarch64_simd_di *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsriq_n_p16 (poly16x8_t __a, poly16x8_t __b, const int __c)
+vst3q_lane_s8 (int8_t *__ptr, int8x16x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssri_nv8hi_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev16qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
+                                  __lane);
 }
 
-__extension__ extern __inline poly64x2_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsriq_n_p64 (poly64x2_t __a, poly64x2_t __b, const int __c)
+vst3q_lane_s16 (int16_t *__ptr, int16x8x3_t __val, const int __lane)
 {
-  return __builtin_aarch64_ssri_nv2di_ppps (__a, __b, __c);
+  __builtin_aarch64_st3_lanev8hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtst_p8 (poly8x8_t __a, poly8x8_t __b)
+vst3q_lane_s32 (int32_t *__ptr, int32x4x3_t __val, const int __lane)
 {
-  return (uint8x8_t) ((((uint8x8_t) __a) & ((uint8x8_t) __b))
-                      != 0);
+  __builtin_aarch64_st3_lanev4si ((__builtin_aarch64_simd_si *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtst_p16 (poly16x4_t __a, poly16x4_t __b)
+vst3q_lane_s64 (int64_t *__ptr, int64x2x3_t __val, const int __lane)
 {
-  return (uint16x4_t) ((((uint16x4_t) __a) & ((uint16x4_t) __b))
-                      != 0);
+  __builtin_aarch64_st3_lanev2di ((__builtin_aarch64_simd_di *) __ptr, __val,
+                                 __lane);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtst_p64 (poly64x1_t __a, poly64x1_t __b)
+vst3q_lane_u8 (uint8_t *__ptr, uint8x16x3_t __val, const int __lane)
 {
-  return (uint64x1_t) ((__a & __b) != __AARCH64_INT64_C (0));
+  __builtin_aarch64_st3_lanev16qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
+                                      __val, __lane);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtstq_p8 (poly8x16_t __a, poly8x16_t __b)
+vst3q_lane_u16 (uint16_t *__ptr, uint16x8x3_t __val, const int __lane)
 {
-  return (uint8x16_t) ((((uint8x16_t) __a) & ((uint8x16_t) __b))
-                      != 0);
+  __builtin_aarch64_st3_lanev8hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtstq_p16 (poly16x8_t __a, poly16x8_t __b)
+vst3q_lane_u32 (uint32_t *__ptr, uint32x4x3_t __val, const int __lane)
 {
-  return (uint16x8_t) ((((uint16x8_t) __a) & ((uint16x8_t) __b))
-                      != 0);
+  __builtin_aarch64_st3_lanev4si_sus ((__builtin_aarch64_simd_si *) __ptr,
+                                     __val, __lane);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtstq_p64 (poly64x2_t __a, poly64x2_t __b)
+vst3q_lane_u64 (uint64_t *__ptr, uint64x2x3_t __val, const int __lane)
 {
-  return (uint64x2_t) ((((uint64x2_t) __a) & ((uint64x2_t) __b))
-                      != __AARCH64_INT64_C (0));
+  __builtin_aarch64_st3_lanev2di_sus ((__builtin_aarch64_simd_di *) __ptr,
+                                     __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_f16 (float16_t *__ptr, float16x4x2_t __val, const int __lane)
+vst4_lane_f16 (float16_t *__ptr, float16x4x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev4hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
+  __builtin_aarch64_st4_lanev4hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_f32 (float32_t *__ptr, float32x2x2_t __val, const int __lane)
+vst4_lane_f32 (float32_t *__ptr, float32x2x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev2sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
+  __builtin_aarch64_st4_lanev2sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_f64 (float64_t *__ptr, float64x1x2_t __val, const int __lane)
+vst4_lane_f64 (float64_t *__ptr, float64x1x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanedf ((__builtin_aarch64_simd_df *) __ptr, __val,
+  __builtin_aarch64_st4_lanedf ((__builtin_aarch64_simd_df *) __ptr, __val,
                                __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_p8 (poly8_t *__ptr, poly8x8x2_t __val, const int __lane)
+vst4_lane_p8 (poly8_t *__ptr, poly8x8x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev8qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
+  __builtin_aarch64_st4_lanev8qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_p16 (poly16_t *__ptr, poly16x4x2_t __val, const int __lane)
+vst4_lane_p16 (poly16_t *__ptr, poly16x4x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev4hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
+  __builtin_aarch64_st4_lanev4hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_p64 (poly64_t *__ptr, poly64x1x2_t __val, const int __lane)
+vst4_lane_p64 (poly64_t *__ptr, poly64x1x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanedi_sps ((__builtin_aarch64_simd_di *) __ptr,
-                                   __val, __lane);
+  __builtin_aarch64_st4_lanedi_sps ((__builtin_aarch64_simd_di *) __ptr, __val,
+                                   __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_s8 (int8_t *__ptr, int8x8x2_t __val, const int __lane)
+vst4_lane_s8 (int8_t *__ptr, int8x8x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev8qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
+  __builtin_aarch64_st4_lanev8qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_s16 (int16_t *__ptr, int16x4x2_t __val, const int __lane)
+vst4_lane_s16 (int16_t *__ptr, int16x4x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev4hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
+  __builtin_aarch64_st4_lanev4hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_s32 (int32_t *__ptr, int32x2x2_t __val, const int __lane)
+vst4_lane_s32 (int32_t *__ptr, int32x2x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev2si ((__builtin_aarch64_simd_si *) __ptr, __val,
+  __builtin_aarch64_st4_lanev2si ((__builtin_aarch64_simd_si *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_s64 (int64_t *__ptr, int64x1x2_t __val, const int __lane)
+vst4_lane_s64 (int64_t *__ptr, int64x1x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanedi ((__builtin_aarch64_simd_di *) __ptr, __val,
+  __builtin_aarch64_st4_lanedi ((__builtin_aarch64_simd_di *) __ptr, __val,
                                __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_u8 (uint8_t *__ptr, uint8x8x2_t __val, const int __lane)
+vst4_lane_u8 (uint8_t *__ptr, uint8x8x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev8qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
+  __builtin_aarch64_st4_lanev8qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_u16 (uint16_t *__ptr, uint16x4x2_t __val, const int __lane)
+vst4_lane_u16 (uint16_t *__ptr, uint16x4x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev4hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
+  __builtin_aarch64_st4_lanev4hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_u32 (uint32_t *__ptr, uint32x2x2_t __val, const int __lane)
+vst4_lane_u32 (uint32_t *__ptr, uint32x2x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev2si_sus ((__builtin_aarch64_simd_si *) __ptr,
+  __builtin_aarch64_st4_lanev2si_sus ((__builtin_aarch64_simd_si *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2_lane_u64 (uint64_t *__ptr, uint64x1x2_t __val, const int __lane)
+vst4_lane_u64 (uint64_t *__ptr, uint64x1x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanedi_sus ((__builtin_aarch64_simd_di *) __ptr, __val,
+  __builtin_aarch64_st4_lanedi_sus ((__builtin_aarch64_simd_di *) __ptr, __val,
                                    __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_f16 (float16_t *__ptr, float16x8x2_t __val, const int __lane)
+vst4q_lane_f16 (float16_t *__ptr, float16x8x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev8hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
+  __builtin_aarch64_st4_lanev8hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_f32 (float32_t *__ptr, float32x4x2_t __val, const int __lane)
+vst4q_lane_f32 (float32_t *__ptr, float32x4x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev4sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
+  __builtin_aarch64_st4_lanev4sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_f64 (float64_t *__ptr, float64x2x2_t __val, const int __lane)
+vst4q_lane_f64 (float64_t *__ptr, float64x2x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev2df ((__builtin_aarch64_simd_df *) __ptr, __val,
+  __builtin_aarch64_st4_lanev2df ((__builtin_aarch64_simd_df *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_p8 (poly8_t *__ptr, poly8x16x2_t __val, const int __lane)
+vst4q_lane_p8 (poly8_t *__ptr, poly8x16x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev16qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
+  __builtin_aarch64_st4_lanev16qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
                                       __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_p16 (poly16_t *__ptr, poly16x8x2_t __val, const int __lane)
+vst4q_lane_p16 (poly16_t *__ptr, poly16x8x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev8hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
+  __builtin_aarch64_st4_lanev8hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_p64 (poly64_t *__ptr, poly64x2x2_t __val, const int __lane)
+vst4q_lane_p64 (poly64_t *__ptr, poly64x2x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev2di_sps ((__builtin_aarch64_simd_di *) __ptr,
+  __builtin_aarch64_st4_lanev2di_sps ((__builtin_aarch64_simd_di *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_s8 (int8_t *__ptr, int8x16x2_t __val, const int __lane)
+vst4q_lane_s8 (int8_t *__ptr, int8x16x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev16qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
+  __builtin_aarch64_st4_lanev16qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
                                   __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_s16 (int16_t *__ptr, int16x8x2_t __val, const int __lane)
+vst4q_lane_s16 (int16_t *__ptr, int16x8x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev8hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
+  __builtin_aarch64_st4_lanev8hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_s32 (int32_t *__ptr, int32x4x2_t __val, const int __lane)
+vst4q_lane_s32 (int32_t *__ptr, int32x4x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev4si ((__builtin_aarch64_simd_si *) __ptr, __val,
+  __builtin_aarch64_st4_lanev4si ((__builtin_aarch64_simd_si *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_s64 (int64_t *__ptr, int64x2x2_t __val, const int __lane)
+vst4q_lane_s64 (int64_t *__ptr, int64x2x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev2di ((__builtin_aarch64_simd_di *) __ptr, __val,
+  __builtin_aarch64_st4_lanev2di ((__builtin_aarch64_simd_di *) __ptr, __val,
                                  __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_u8 (uint8_t *__ptr, uint8x16x2_t __val, const int __lane)
+vst4q_lane_u8 (uint8_t *__ptr, uint8x16x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev16qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
+  __builtin_aarch64_st4_lanev16qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
                                       __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_u16 (uint16_t *__ptr, uint16x8x2_t __val, const int __lane)
+vst4q_lane_u16 (uint16_t *__ptr, uint16x8x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev8hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
+  __builtin_aarch64_st4_lanev8hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_u32 (uint32_t *__ptr, uint32x4x2_t __val, const int __lane)
+vst4q_lane_u32 (uint32_t *__ptr, uint32x4x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev4si_sus ((__builtin_aarch64_simd_si *) __ptr,
+  __builtin_aarch64_st4_lanev4si_sus ((__builtin_aarch64_simd_si *) __ptr,
                                      __val, __lane);
 }
 
 __extension__ extern __inline void
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst2q_lane_u64 (uint64_t *__ptr, uint64x2x2_t __val, const int __lane)
+vst4q_lane_u64 (uint64_t *__ptr, uint64x2x4_t __val, const int __lane)
 {
-  __builtin_aarch64_st2_lanev2di_sus ((__builtin_aarch64_simd_di *) __ptr,
+  __builtin_aarch64_st4_lanev2di_sus ((__builtin_aarch64_simd_di *) __ptr,
                                      __val, __lane);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_f16 (float16_t *__ptr, float16x4x3_t __val, const int __lane)
+vaddlv_s32 (int32x2_t __a)
 {
-  __builtin_aarch64_st3_lanev4hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_saddlvv2si (__a);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_f32 (float32_t *__ptr, float32x2x3_t __val, const int __lane)
+vaddlv_u32 (uint32x2_t __a)
 {
-  __builtin_aarch64_st3_lanev2sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_uaddlvv2si_uu (__a);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_f64 (float64_t *__ptr, float64x1x3_t __val, const int __lane)
+vqdmulh_laneq_s16 (int16x4_t __a, int16x8_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanedf ((__builtin_aarch64_simd_df *) __ptr, __val,
-                               __lane);
+  return __builtin_aarch64_sqdmulh_laneqv4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_p8 (poly8_t *__ptr, poly8x8x3_t __val, const int __lane)
+vqdmulh_laneq_s32 (int32x2_t __a, int32x4_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanev8qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_sqdmulh_laneqv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_p16 (poly16_t *__ptr, poly16x4x3_t __val, const int __lane)
+vqdmulhq_laneq_s16 (int16x8_t __a, int16x8_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanev4hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_sqdmulh_laneqv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_p64 (poly64_t *__ptr, poly64x1x3_t __val, const int __lane)
+vqdmulhq_laneq_s32 (int32x4_t __a, int32x4_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanedi_sps ((__builtin_aarch64_simd_di *) __ptr, __val,
-                                   __lane);
+  return __builtin_aarch64_sqdmulh_laneqv4si (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_s8 (int8_t *__ptr, int8x8x3_t __val, const int __lane)
+vqrdmulh_laneq_s16 (int16x4_t __a, int16x8_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanev8qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
-                                 __lane);
+  return  __builtin_aarch64_sqrdmulh_laneqv4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_s16 (int16_t *__ptr, int16x4x3_t __val, const int __lane)
+vqrdmulh_laneq_s32 (int32x2_t __a, int32x4_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanev4hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_sqrdmulh_laneqv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_s32 (int32_t *__ptr, int32x2x3_t __val, const int __lane)
+vqrdmulhq_laneq_s16 (int16x8_t __a, int16x8_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanev2si ((__builtin_aarch64_simd_si *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_sqrdmulh_laneqv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_s64 (int64_t *__ptr, int64x1x3_t __val, const int __lane)
+vqrdmulhq_laneq_s32 (int32x4_t __a, int32x4_t __b, const int __c)
 {
-  __builtin_aarch64_st3_lanedi ((__builtin_aarch64_simd_di *) __ptr, __val,
-                               __lane);
+  return __builtin_aarch64_sqrdmulh_laneqv4si (__a, __b, __c);
 }
 
-__extension__ extern __inline void
+/* Table intrinsics.  */
+
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_u8 (uint8_t *__ptr, uint8x8x3_t __val, const int __lane)
+vqtbl1_p8 (poly8x16_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev8qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_qtbl1v8qi_ppu (__tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_u16 (uint16_t *__ptr, uint16x4x3_t __val, const int __lane)
+vqtbl1_s8 (int8x16_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev4hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_qtbl1v8qi_ssu (__tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_u32 (uint32_t *__ptr, uint32x2x3_t __val, const int __lane)
+vqtbl1_u8 (uint8x16_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev2si_sus ((__builtin_aarch64_simd_si *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_qtbl1v8qi_uuu (__tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3_lane_u64 (uint64_t *__ptr, uint64x1x3_t __val, const int __lane)
+vqtbl1q_p8 (poly8x16_t __tab, uint8x16_t __idx)
 {
-  __builtin_aarch64_st3_lanedi_sus ((__builtin_aarch64_simd_di *) __ptr, __val,
-                                   __lane);
+  return __builtin_aarch64_qtbl1v16qi_ppu (__tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_f16 (float16_t *__ptr, float16x8x3_t __val, const int __lane)
+vqtbl1q_s8 (int8x16_t __tab, uint8x16_t __idx)
 {
-  __builtin_aarch64_st3_lanev8hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_qtbl1v16qi_ssu (__tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_f32 (float32_t *__ptr, float32x4x3_t __val, const int __lane)
+vqtbl1q_u8 (uint8x16_t __tab, uint8x16_t __idx)
 {
-  __builtin_aarch64_st3_lanev4sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_qtbl1v16qi_uuu (__tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_f64 (float64_t *__ptr, float64x2x3_t __val, const int __lane)
+vqtbx1_s8 (int8x8_t __r, int8x16_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev2df ((__builtin_aarch64_simd_df *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_qtbx1v8qi_sssu (__r, __tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_p8 (poly8_t *__ptr, poly8x16x3_t __val, const int __lane)
+vqtbx1_u8 (uint8x8_t __r, uint8x16_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev16qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
-                                      __val, __lane);
+  return __builtin_aarch64_qtbx1v8qi_uuuu (__r, __tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_p16 (poly16_t *__ptr, poly16x8x3_t __val, const int __lane)
+vqtbx1_p8 (poly8x8_t __r, poly8x16_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev8hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_qtbx1v8qi_pppu (__r, __tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_p64 (poly64_t *__ptr, poly64x2x3_t __val, const int __lane)
+vqtbx1q_s8 (int8x16_t __r, int8x16_t __tab, uint8x16_t __idx)
 {
-  __builtin_aarch64_st3_lanev2di_sps ((__builtin_aarch64_simd_di *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_qtbx1v16qi_sssu (__r, __tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_s8 (int8_t *__ptr, int8x16x3_t __val, const int __lane)
+vqtbx1q_u8 (uint8x16_t __r, uint8x16_t __tab, uint8x16_t __idx)
 {
-  __builtin_aarch64_st3_lanev16qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
-                                  __lane);
+  return __builtin_aarch64_qtbx1v16qi_uuuu (__r, __tab, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_s16 (int16_t *__ptr, int16x8x3_t __val, const int __lane)
+vqtbx1q_p8 (poly8x16_t __r, poly8x16_t __tab, uint8x16_t __idx)
 {
-  __builtin_aarch64_st3_lanev8hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_qtbx1v16qi_pppu (__r, __tab, __idx);
 }
 
-__extension__ extern __inline void
+/* V7 legacy table intrinsics.  */
+
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_s32 (int32_t *__ptr, int32x4x3_t __val, const int __lane)
+vtbl1_s8 (int8x8_t __tab, int8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev4si ((__builtin_aarch64_simd_si *) __ptr, __val,
-                                 __lane);
+  int8x16_t __temp = vcombine_s8 (__tab,
+                                 vcreate_s8 (__AARCH64_UINT64_C (0x0)));
+  return __builtin_aarch64_qtbl1v8qi (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_s64 (int64_t *__ptr, int64x2x3_t __val, const int __lane)
+vtbl1_u8 (uint8x8_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev2di ((__builtin_aarch64_simd_di *) __ptr, __val,
-                                 __lane);
+  uint8x16_t __temp = vcombine_u8 (__tab,
+                                  vcreate_u8 (__AARCH64_UINT64_C (0x0)));
+  return __builtin_aarch64_qtbl1v8qi_uuu (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_u8 (uint8_t *__ptr, uint8x16x3_t __val, const int __lane)
+vtbl1_p8 (poly8x8_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev16qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
-                                      __val, __lane);
+  poly8x16_t __temp = vcombine_p8 (__tab,
+                                  vcreate_p8 (__AARCH64_UINT64_C (0x0)));
+  return __builtin_aarch64_qtbl1v8qi_ppu (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_u16 (uint16_t *__ptr, uint16x8x3_t __val, const int __lane)
+vtbl2_s8 (int8x8x2_t __tab, int8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev8hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
+  int8x16_t __temp = vcombine_s8 (__tab.val[0], __tab.val[1]);
+  return __builtin_aarch64_qtbl1v8qi (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_u32 (uint32_t *__ptr, uint32x4x3_t __val, const int __lane)
+vtbl2_u8 (uint8x8x2_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev4si_sus ((__builtin_aarch64_simd_si *) __ptr,
-                                     __val, __lane);
+  uint8x16_t __temp = vcombine_u8 (__tab.val[0], __tab.val[1]);
+  return __builtin_aarch64_qtbl1v8qi_uuu (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst3q_lane_u64 (uint64_t *__ptr, uint64x2x3_t __val, const int __lane)
+vtbl2_p8 (poly8x8x2_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st3_lanev2di_sus ((__builtin_aarch64_simd_di *) __ptr,
-                                     __val, __lane);
+  poly8x16_t __temp = vcombine_p8 (__tab.val[0], __tab.val[1]);
+  return __builtin_aarch64_qtbl1v8qi_ppu (__temp, __idx);
 }
 
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_f16 (float16_t *__ptr, float16x4x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev4hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
-                                 __lane);
-}
-
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_f32 (float32_t *__ptr, float32x2x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev2sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
-                                 __lane);
-}
-
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_f64 (float64_t *__ptr, float64x1x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanedf ((__builtin_aarch64_simd_df *) __ptr, __val,
-                               __lane);
-}
-
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_p8 (poly8_t *__ptr, poly8x8x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev8qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
-                                     __val, __lane);
-}
-
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_p16 (poly16_t *__ptr, poly16x4x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev4hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
-}
-
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_p64 (poly64_t *__ptr, poly64x1x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanedi_sps ((__builtin_aarch64_simd_di *) __ptr, __val,
-                                   __lane);
-}
-
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_s8 (int8_t *__ptr, int8x8x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev8qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
-                                 __lane);
-}
-
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_s16 (int16_t *__ptr, int16x4x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev4hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
-                                 __lane);
-}
-
-__extension__ extern __inline void
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_s32 (int32_t *__ptr, int32x2x4_t __val, const int __lane)
+vtbl3_s8 (int8x8x3_t __tab, int8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanev2si ((__builtin_aarch64_simd_si *) __ptr, __val,
-                                 __lane);
+  int8x16x2_t __temp;
+  __temp.val[0] = vcombine_s8 (__tab.val[0], __tab.val[1]);
+  __temp.val[1] = vcombine_s8 (__tab.val[2],
+                              vcreate_s8 (__AARCH64_UINT64_C (0x0)));
+  return __builtin_aarch64_qtbl2v8qi (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_s64 (int64_t *__ptr, int64x1x4_t __val, const int __lane)
+vtbl3_u8 (uint8x8x3_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanedi ((__builtin_aarch64_simd_di *) __ptr, __val,
-                               __lane);
+  uint8x16x2_t __temp;
+  __temp.val[0] = vcombine_u8 (__tab.val[0], __tab.val[1]);
+  __temp.val[1] = vcombine_u8 (__tab.val[2],
+                              vcreate_u8 (__AARCH64_UINT64_C (0x0)));
+  return __builtin_aarch64_qtbl2v8qi_uuu (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_u8 (uint8_t *__ptr, uint8x8x4_t __val, const int __lane)
+vtbl3_p8 (poly8x8x3_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanev8qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
-                                     __val, __lane);
+  poly8x16x2_t __temp;
+  __temp.val[0] = vcombine_p8 (__tab.val[0], __tab.val[1]);
+  __temp.val[1] = vcombine_p8 (__tab.val[2],
+                              vcreate_p8 (__AARCH64_UINT64_C (0x0)));
+  return __builtin_aarch64_qtbl2v8qi_ppu (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_u16 (uint16_t *__ptr, uint16x4x4_t __val, const int __lane)
+vtbl4_s8 (int8x8x4_t __tab, int8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanev4hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
+  int8x16x2_t __temp;
+  __temp.val[0] = vcombine_s8 (__tab.val[0], __tab.val[1]);
+  __temp.val[1] = vcombine_s8 (__tab.val[2], __tab.val[3]);
+  return __builtin_aarch64_qtbl2v8qi (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_u32 (uint32_t *__ptr, uint32x2x4_t __val, const int __lane)
+vtbl4_u8 (uint8x8x4_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanev2si_sus ((__builtin_aarch64_simd_si *) __ptr,
-                                     __val, __lane);
+  uint8x16x2_t __temp;
+  __temp.val[0] = vcombine_u8 (__tab.val[0], __tab.val[1]);
+  __temp.val[1] = vcombine_u8 (__tab.val[2], __tab.val[3]);
+  return __builtin_aarch64_qtbl2v8qi_uuu (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4_lane_u64 (uint64_t *__ptr, uint64x1x4_t __val, const int __lane)
+vtbl4_p8 (poly8x8x4_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanedi_sus ((__builtin_aarch64_simd_di *) __ptr, __val,
-                                   __lane);
+  poly8x16x2_t __temp;
+  __temp.val[0] = vcombine_p8 (__tab.val[0], __tab.val[1]);
+  __temp.val[1] = vcombine_p8 (__tab.val[2], __tab.val[3]);
+  return __builtin_aarch64_qtbl2v8qi_ppu (__temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_f16 (float16_t *__ptr, float16x8x4_t __val, const int __lane)
+vtbx2_s8 (int8x8_t __r, int8x8x2_t __tab, int8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanev8hf ((__builtin_aarch64_simd_hf *) __ptr, __val,
-                                 __lane);
+  int8x16_t __temp = vcombine_s8 (__tab.val[0], __tab.val[1]);
+  return __builtin_aarch64_qtbx1v8qi (__r, __temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_f32 (float32_t *__ptr, float32x4x4_t __val, const int __lane)
+vtbx2_u8 (uint8x8_t __r, uint8x8x2_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanev4sf ((__builtin_aarch64_simd_sf *) __ptr, __val,
-                                 __lane);
+  uint8x16_t __temp = vcombine_u8 (__tab.val[0], __tab.val[1]);
+  return __builtin_aarch64_qtbx1v8qi_uuuu (__r, __temp, __idx);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_f64 (float64_t *__ptr, float64x2x4_t __val, const int __lane)
+vtbx2_p8 (poly8x8_t __r, poly8x8x2_t __tab, uint8x8_t __idx)
 {
-  __builtin_aarch64_st4_lanev2df ((__builtin_aarch64_simd_df *) __ptr, __val,
-                                 __lane);
+  poly8x16_t __temp = vcombine_p8 (__tab.val[0], __tab.val[1]);
+  return __builtin_aarch64_qtbx1v8qi_pppu (__r, __temp, __idx);
 }
 
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_p8 (poly8_t *__ptr, poly8x16x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev16qi_sps ((__builtin_aarch64_simd_qi *) __ptr,
-                                      __val, __lane);
-}
+/* End of temporary inline asm.  */
 
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_p16 (poly16_t *__ptr, poly16x8x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev8hi_sps ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
-}
+/* Start of optimal implementations in approved order.  */
 
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_p64 (poly64_t *__ptr, poly64x2x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev2di_sps ((__builtin_aarch64_simd_di *) __ptr,
-                                     __val, __lane);
-}
+/* vabd.  */
 
-__extension__ extern __inline void
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_s8 (int8_t *__ptr, int8x16x4_t __val, const int __lane)
+vabds_f32 (float32_t __a, float32_t __b)
 {
-  __builtin_aarch64_st4_lanev16qi ((__builtin_aarch64_simd_qi *) __ptr, __val,
-                                  __lane);
+  return __builtin_aarch64_fabdsf (__a, __b);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline float64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_s16 (int16_t *__ptr, int16x8x4_t __val, const int __lane)
+vabdd_f64 (float64_t __a, float64_t __b)
 {
-  __builtin_aarch64_st4_lanev8hi ((__builtin_aarch64_simd_hi *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_fabddf (__a, __b);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_s32 (int32_t *__ptr, int32x4x4_t __val, const int __lane)
+vabd_f32 (float32x2_t __a, float32x2_t __b)
 {
-  __builtin_aarch64_st4_lanev4si ((__builtin_aarch64_simd_si *) __ptr, __val,
-                                 __lane);
+  return __builtin_aarch64_fabdv2sf (__a, __b);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline float64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_s64 (int64_t *__ptr, int64x2x4_t __val, const int __lane)
+vabd_f64 (float64x1_t __a, float64x1_t __b)
 {
-  __builtin_aarch64_st4_lanev2di ((__builtin_aarch64_simd_di *) __ptr, __val,
-                                 __lane);
+  return (float64x1_t) {vabdd_f64 (vget_lane_f64 (__a, 0),
+                                  vget_lane_f64 (__b, 0))};
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_u8 (uint8_t *__ptr, uint8x16x4_t __val, const int __lane)
+vabdq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  __builtin_aarch64_st4_lanev16qi_sus ((__builtin_aarch64_simd_qi *) __ptr,
-                                      __val, __lane);
+  return __builtin_aarch64_fabdv4sf (__a, __b);
 }
 
-__extension__ extern __inline void
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_u16 (uint16_t *__ptr, uint16x8x4_t __val, const int __lane)
+vabdq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  __builtin_aarch64_st4_lanev8hi_sus ((__builtin_aarch64_simd_hi *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_fabdv2df (__a, __b);
 }
 
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_u32 (uint32_t *__ptr, uint32x4x4_t __val, const int __lane)
-{
-  __builtin_aarch64_st4_lanev4si_sus ((__builtin_aarch64_simd_si *) __ptr,
-                                     __val, __lane);
-}
+/* vabs  */
 
-__extension__ extern __inline void
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vst4q_lane_u64 (uint64_t *__ptr, uint64x2x4_t __val, const int __lane)
+vabs_f32 (float32x2_t __a)
 {
-  __builtin_aarch64_st4_lanev2di_sus ((__builtin_aarch64_simd_di *) __ptr,
-                                     __val, __lane);
+  return __builtin_aarch64_absv2sf (__a);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline float64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlv_s32 (int32x2_t __a)
+vabs_f64 (float64x1_t __a)
 {
-  return __builtin_aarch64_saddlvv2si (__a);
+  return (float64x1_t) {__builtin_fabs (__a[0])};
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddlv_u32 (uint32x2_t __a)
+vabs_s8 (int8x8_t __a)
 {
-  return __builtin_aarch64_uaddlvv2si_uu (__a);
+  return __builtin_aarch64_absv8qi (__a);
 }
 
 __extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulh_laneq_s16 (int16x4_t __a, int16x8_t __b, const int __c)
-{
-  return __builtin_aarch64_sqdmulh_laneqv4hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulh_laneq_s32 (int32x2_t __a, int32x4_t __b, const int __c)
+vabs_s16 (int16x4_t __a)
 {
-  return __builtin_aarch64_sqdmulh_laneqv2si (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulhq_laneq_s16 (int16x8_t __a, int16x8_t __b, const int __c)
-{
-  return __builtin_aarch64_sqdmulh_laneqv8hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqdmulhq_laneq_s32 (int32x4_t __a, int32x4_t __b, const int __c)
-{
-  return __builtin_aarch64_sqdmulh_laneqv4si (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulh_laneq_s16 (int16x4_t __a, int16x8_t __b, const int __c)
-{
-  return  __builtin_aarch64_sqrdmulh_laneqv4hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulh_laneq_s32 (int32x2_t __a, int32x4_t __b, const int __c)
-{
-  return __builtin_aarch64_sqrdmulh_laneqv2si (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulhq_laneq_s16 (int16x8_t __a, int16x8_t __b, const int __c)
-{
-  return __builtin_aarch64_sqrdmulh_laneqv8hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmulhq_laneq_s32 (int32x4_t __a, int32x4_t __b, const int __c)
-{
-  return __builtin_aarch64_sqrdmulh_laneqv4si (__a, __b, __c);
-}
-
-/* Table intrinsics.  */
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbl1_p8 (poly8x16_t __tab, uint8x8_t __idx)
-{
-  return __builtin_aarch64_qtbl1v8qi_ppu (__tab, __idx);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbl1_s8 (int8x16_t __tab, uint8x8_t __idx)
-{
-  return __builtin_aarch64_qtbl1v8qi_ssu (__tab, __idx);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbl1_u8 (uint8x16_t __tab, uint8x8_t __idx)
-{
-  return __builtin_aarch64_qtbl1v8qi_uuu (__tab, __idx);
-}
-
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbl1q_p8 (poly8x16_t __tab, uint8x16_t __idx)
-{
-  return __builtin_aarch64_qtbl1v16qi_ppu (__tab, __idx);
-}
-
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbl1q_s8 (int8x16_t __tab, uint8x16_t __idx)
-{
-  return __builtin_aarch64_qtbl1v16qi_ssu (__tab, __idx);
-}
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbl1q_u8 (uint8x16_t __tab, uint8x16_t __idx)
-{
-  return __builtin_aarch64_qtbl1v16qi_uuu (__tab, __idx);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbx1_s8 (int8x8_t __r, int8x16_t __tab, uint8x8_t __idx)
-{
-  return __builtin_aarch64_qtbx1v8qi_sssu (__r, __tab, __idx);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbx1_u8 (uint8x8_t __r, uint8x16_t __tab, uint8x8_t __idx)
-{
-  return __builtin_aarch64_qtbx1v8qi_uuuu (__r, __tab, __idx);
-}
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbx1_p8 (poly8x8_t __r, poly8x16_t __tab, uint8x8_t __idx)
-{
-  return __builtin_aarch64_qtbx1v8qi_pppu (__r, __tab, __idx);
-}
-
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbx1q_s8 (int8x16_t __r, int8x16_t __tab, uint8x16_t __idx)
-{
-  return __builtin_aarch64_qtbx1v16qi_sssu (__r, __tab, __idx);
-}
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbx1q_u8 (uint8x16_t __r, uint8x16_t __tab, uint8x16_t __idx)
-{
-  return __builtin_aarch64_qtbx1v16qi_uuuu (__r, __tab, __idx);
-}
-
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqtbx1q_p8 (poly8x16_t __r, poly8x16_t __tab, uint8x16_t __idx)
-{
-  return __builtin_aarch64_qtbx1v16qi_pppu (__r, __tab, __idx);
-}
-
-/* V7 legacy table intrinsics.  */
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl1_s8 (int8x8_t __tab, int8x8_t __idx)
-{
-  int8x16_t __temp = vcombine_s8 (__tab,
-                                 vcreate_s8 (__AARCH64_UINT64_C (0x0)));
-  return __builtin_aarch64_qtbl1v8qi (__temp, __idx);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl1_u8 (uint8x8_t __tab, uint8x8_t __idx)
-{
-  uint8x16_t __temp = vcombine_u8 (__tab,
-                                  vcreate_u8 (__AARCH64_UINT64_C (0x0)));
-  return __builtin_aarch64_qtbl1v8qi_uuu (__temp, __idx);
-}
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl1_p8 (poly8x8_t __tab, uint8x8_t __idx)
-{
-  poly8x16_t __temp = vcombine_p8 (__tab,
-                                  vcreate_p8 (__AARCH64_UINT64_C (0x0)));
-  return __builtin_aarch64_qtbl1v8qi_ppu (__temp, __idx);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl2_s8 (int8x8x2_t __tab, int8x8_t __idx)
-{
-  int8x16_t __temp = vcombine_s8 (__tab.val[0], __tab.val[1]);
-  return __builtin_aarch64_qtbl1v8qi (__temp, __idx);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl2_u8 (uint8x8x2_t __tab, uint8x8_t __idx)
-{
-  uint8x16_t __temp = vcombine_u8 (__tab.val[0], __tab.val[1]);
-  return __builtin_aarch64_qtbl1v8qi_uuu (__temp, __idx);
-}
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl2_p8 (poly8x8x2_t __tab, uint8x8_t __idx)
-{
-  poly8x16_t __temp = vcombine_p8 (__tab.val[0], __tab.val[1]);
-  return __builtin_aarch64_qtbl1v8qi_ppu (__temp, __idx);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl3_s8 (int8x8x3_t __tab, int8x8_t __idx)
-{
-  int8x16x2_t __temp;
-  __temp.val[0] = vcombine_s8 (__tab.val[0], __tab.val[1]);
-  __temp.val[1] = vcombine_s8 (__tab.val[2],
-                              vcreate_s8 (__AARCH64_UINT64_C (0x0)));
-  return __builtin_aarch64_qtbl2v8qi (__temp, __idx);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl3_u8 (uint8x8x3_t __tab, uint8x8_t __idx)
-{
-  uint8x16x2_t __temp;
-  __temp.val[0] = vcombine_u8 (__tab.val[0], __tab.val[1]);
-  __temp.val[1] = vcombine_u8 (__tab.val[2],
-                              vcreate_u8 (__AARCH64_UINT64_C (0x0)));
-  return __builtin_aarch64_qtbl2v8qi_uuu (__temp, __idx);
-}
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl3_p8 (poly8x8x3_t __tab, uint8x8_t __idx)
-{
-  poly8x16x2_t __temp;
-  __temp.val[0] = vcombine_p8 (__tab.val[0], __tab.val[1]);
-  __temp.val[1] = vcombine_p8 (__tab.val[2],
-                              vcreate_p8 (__AARCH64_UINT64_C (0x0)));
-  return __builtin_aarch64_qtbl2v8qi_ppu (__temp, __idx);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl4_s8 (int8x8x4_t __tab, int8x8_t __idx)
-{
-  int8x16x2_t __temp;
-  __temp.val[0] = vcombine_s8 (__tab.val[0], __tab.val[1]);
-  __temp.val[1] = vcombine_s8 (__tab.val[2], __tab.val[3]);
-  return __builtin_aarch64_qtbl2v8qi (__temp, __idx);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl4_u8 (uint8x8x4_t __tab, uint8x8_t __idx)
-{
-  uint8x16x2_t __temp;
-  __temp.val[0] = vcombine_u8 (__tab.val[0], __tab.val[1]);
-  __temp.val[1] = vcombine_u8 (__tab.val[2], __tab.val[3]);
-  return __builtin_aarch64_qtbl2v8qi_uuu (__temp, __idx);
-}
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbl4_p8 (poly8x8x4_t __tab, uint8x8_t __idx)
-{
-  poly8x16x2_t __temp;
-  __temp.val[0] = vcombine_p8 (__tab.val[0], __tab.val[1]);
-  __temp.val[1] = vcombine_p8 (__tab.val[2], __tab.val[3]);
-  return __builtin_aarch64_qtbl2v8qi_ppu (__temp, __idx);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbx2_s8 (int8x8_t __r, int8x8x2_t __tab, int8x8_t __idx)
-{
-  int8x16_t __temp = vcombine_s8 (__tab.val[0], __tab.val[1]);
-  return __builtin_aarch64_qtbx1v8qi (__r, __temp, __idx);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbx2_u8 (uint8x8_t __r, uint8x8x2_t __tab, uint8x8_t __idx)
-{
-  uint8x16_t __temp = vcombine_u8 (__tab.val[0], __tab.val[1]);
-  return __builtin_aarch64_qtbx1v8qi_uuuu (__r, __temp, __idx);
-}
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vtbx2_p8 (poly8x8_t __r, poly8x8x2_t __tab, uint8x8_t __idx)
-{
-  poly8x16_t __temp = vcombine_p8 (__tab.val[0], __tab.val[1]);
-  return __builtin_aarch64_qtbx1v8qi_pppu (__r, __temp, __idx);
-}
-
-/* End of temporary inline asm.  */
-
-/* Start of optimal implementations in approved order.  */
-
-/* vabd.  */
-
-__extension__ extern __inline float32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabds_f32 (float32_t __a, float32_t __b)
-{
-  return __builtin_aarch64_fabdsf (__a, __b);
-}
-
-__extension__ extern __inline float64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdd_f64 (float64_t __a, float64_t __b)
-{
-  return __builtin_aarch64_fabddf (__a, __b);
-}
-
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_f32 (float32x2_t __a, float32x2_t __b)
-{
-  return __builtin_aarch64_fabdv2sf (__a, __b);
-}
-
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabd_f64 (float64x1_t __a, float64x1_t __b)
-{
-  return (float64x1_t) {vabdd_f64 (vget_lane_f64 (__a, 0),
-                                  vget_lane_f64 (__b, 0))};
-}
-
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_f32 (float32x4_t __a, float32x4_t __b)
-{
-  return __builtin_aarch64_fabdv4sf (__a, __b);
-}
-
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabdq_f64 (float64x2_t __a, float64x2_t __b)
-{
-  return __builtin_aarch64_fabdv2df (__a, __b);
-}
-
-/* vabs  */
-
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_f32 (float32x2_t __a)
-{
-  return __builtin_aarch64_absv2sf (__a);
-}
-
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_f64 (float64x1_t __a)
-{
-  return (float64x1_t) {__builtin_fabs (__a[0])};
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s8 (int8x8_t __a)
-{
-  return __builtin_aarch64_absv8qi (__a);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s16 (int16x4_t __a)
-{
-  return __builtin_aarch64_absv4hi (__a);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s32 (int32x2_t __a)
-{
-  return __builtin_aarch64_absv2si (__a);
-}
-
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabs_s64 (int64x1_t __a)
-{
-  return (int64x1_t) {__builtin_aarch64_absdi (__a[0])};
-}
-
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_f32 (float32x4_t __a)
-{
-  return __builtin_aarch64_absv4sf (__a);
-}
-
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_f64 (float64x2_t __a)
-{
-  return __builtin_aarch64_absv2df (__a);
-}
-
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s8 (int8x16_t __a)
-{
-  return __builtin_aarch64_absv16qi (__a);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s16 (int16x8_t __a)
-{
-  return __builtin_aarch64_absv8hi (__a);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s32 (int32x4_t __a)
-{
-  return __builtin_aarch64_absv4si (__a);
-}
-
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsq_s64 (int64x2_t __a)
-{
-  return __builtin_aarch64_absv2di (__a);
-}
-
-/* Try to avoid moving between integer and vector registers.
-   For why the cast to unsigned is needed check the vnegd_s64 intrinsic.
-   There is a testcase related to this issue:
-   gcc.target/aarch64/vabsd_s64.c.  */
-
-__extension__ extern __inline int64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vabsd_s64 (int64_t __a)
-{
-  return __a < 0 ? - (uint64_t) __a : __a;
-}
-
-/* vadd */
-
-__extension__ extern __inline int64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddd_s64 (int64_t __a, int64_t __b)
-{
-  return __a + __b;
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddd_u64 (uint64_t __a, uint64_t __b)
-{
-  return __a + __b;
-}
-
-/* vaddv */
-
-__extension__ extern __inline int8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddv_s8 (int8x8_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v8qi (__a);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddv_s16 (int16x4_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v4hi (__a);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddv_s32 (int32x2_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v2si (__a);
-}
-
-__extension__ extern __inline uint8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddv_u8 (uint8x8_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v8qi_uu (__a);
-}
-
-__extension__ extern __inline uint16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddv_u16 (uint16x4_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v4hi_uu (__a);
-}
-
-__extension__ extern __inline uint32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddv_u32 (uint32x2_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v2si_uu (__a);
-}
-
-__extension__ extern __inline int8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_s8 (int8x16_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v16qi (__a);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_s16 (int16x8_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v8hi (__a);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_s32 (int32x4_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v4si (__a);
-}
-
-__extension__ extern __inline int64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_s64 (int64x2_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v2di (__a);
-}
-
-__extension__ extern __inline uint8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_u8 (uint8x16_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v16qi_uu (__a);
-}
-
-__extension__ extern __inline uint16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_u16 (uint16x8_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v8hi_uu (__a);
-}
-
-__extension__ extern __inline uint32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_u32 (uint32x4_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v4si_uu (__a);
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_u64 (uint64x2_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v2di_uu (__a);
-}
-
-__extension__ extern __inline float32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddv_f32 (float32x2_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v2sf (__a);
-}
-
-__extension__ extern __inline float32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_f32 (float32x4_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v4sf (__a);
-}
-
-__extension__ extern __inline float64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaddvq_f64 (float64x2_t __a)
-{
-  return __builtin_aarch64_reduc_plus_scal_v2df (__a);
-}
-
-/* vbsl  */
-
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_f16 (uint16x4_t __a, float16x4_t __b, float16x4_t __c)
-{
-  return __builtin_aarch64_simd_bslv4hf_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_f32 (uint32x2_t __a, float32x2_t __b, float32x2_t __c)
-{
-  return __builtin_aarch64_simd_bslv2sf_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_f64 (uint64x1_t __a, float64x1_t __b, float64x1_t __c)
-{
-  return (float64x1_t)
-    { __builtin_aarch64_simd_bsldf_suss (__a[0], __b[0], __c[0]) };
-}
-
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_p8 (uint8x8_t __a, poly8x8_t __b, poly8x8_t __c)
-{
-  return __builtin_aarch64_simd_bslv8qi_pupp (__a, __b, __c);
-}
-
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_p16 (uint16x4_t __a, poly16x4_t __b, poly16x4_t __c)
-{
-  return __builtin_aarch64_simd_bslv4hi_pupp (__a, __b, __c);
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_p64 (uint64x1_t __a, poly64x1_t __b, poly64x1_t __c)
-{
-  return (poly64x1_t)
-      {__builtin_aarch64_simd_bsldi_pupp (__a[0], __b[0], __c[0])};
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_s8 (uint8x8_t __a, int8x8_t __b, int8x8_t __c)
-{
-  return __builtin_aarch64_simd_bslv8qi_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_s16 (uint16x4_t __a, int16x4_t __b, int16x4_t __c)
-{
-  return __builtin_aarch64_simd_bslv4hi_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_s32 (uint32x2_t __a, int32x2_t __b, int32x2_t __c)
-{
-  return __builtin_aarch64_simd_bslv2si_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_s64 (uint64x1_t __a, int64x1_t __b, int64x1_t __c)
-{
-  return (int64x1_t)
-      {__builtin_aarch64_simd_bsldi_suss (__a[0], __b[0], __c[0])};
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
-{
-  return __builtin_aarch64_simd_bslv8qi_uuuu (__a, __b, __c);
-}
-
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
-{
-  return __builtin_aarch64_simd_bslv4hi_uuuu (__a, __b, __c);
-}
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
-{
-  return __builtin_aarch64_simd_bslv2si_uuuu (__a, __b, __c);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbsl_u64 (uint64x1_t __a, uint64x1_t __b, uint64x1_t __c)
-{
-  return (uint64x1_t)
-      {__builtin_aarch64_simd_bsldi_uuuu (__a[0], __b[0], __c[0])};
-}
-
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_f16 (uint16x8_t __a, float16x8_t __b, float16x8_t __c)
-{
-  return __builtin_aarch64_simd_bslv8hf_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_f32 (uint32x4_t __a, float32x4_t __b, float32x4_t __c)
-{
-  return __builtin_aarch64_simd_bslv4sf_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_f64 (uint64x2_t __a, float64x2_t __b, float64x2_t __c)
-{
-  return __builtin_aarch64_simd_bslv2df_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_p8 (uint8x16_t __a, poly8x16_t __b, poly8x16_t __c)
-{
-  return __builtin_aarch64_simd_bslv16qi_pupp (__a, __b, __c);
-}
-
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_p16 (uint16x8_t __a, poly16x8_t __b, poly16x8_t __c)
-{
-  return __builtin_aarch64_simd_bslv8hi_pupp (__a, __b, __c);
-}
-
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_s8 (uint8x16_t __a, int8x16_t __b, int8x16_t __c)
-{
-  return __builtin_aarch64_simd_bslv16qi_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_s16 (uint16x8_t __a, int16x8_t __b, int16x8_t __c)
-{
-  return __builtin_aarch64_simd_bslv8hi_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_p64 (uint64x2_t __a, poly64x2_t __b, poly64x2_t __c)
-{
-  return __builtin_aarch64_simd_bslv2di_pupp (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_s32 (uint32x4_t __a, int32x4_t __b, int32x4_t __c)
-{
-  return __builtin_aarch64_simd_bslv4si_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_s64 (uint64x2_t __a, int64x2_t __b, int64x2_t __c)
-{
-  return __builtin_aarch64_simd_bslv2di_suss (__a, __b, __c);
-}
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
-{
-  return __builtin_aarch64_simd_bslv16qi_uuuu (__a, __b, __c);
-}
-
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
-{
-  return __builtin_aarch64_simd_bslv8hi_uuuu (__a, __b, __c);
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
-{
-  return __builtin_aarch64_simd_bslv4si_uuuu (__a, __b, __c);
-}
-
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vbslq_u64 (uint64x2_t __a, uint64x2_t __b, uint64x2_t __c)
-{
-  return __builtin_aarch64_simd_bslv2di_uuuu (__a, __b, __c);
-}
-
-/* ARMv8.1-A intrinsics.  */
-#pragma GCC push_options
-#pragma GCC target ("+nothing+rdma")
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlah_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
-{
-  return __builtin_aarch64_sqrdmlahv4hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlah_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
-{
-  return __builtin_aarch64_sqrdmlahv2si (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
-{
-  return __builtin_aarch64_sqrdmlahv8hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
-{
-  return __builtin_aarch64_sqrdmlahv4si (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlsh_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
-{
-  return __builtin_aarch64_sqrdmlshv4hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlsh_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
-{
-  return __builtin_aarch64_sqrdmlshv2si (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
-{
-  return __builtin_aarch64_sqrdmlshv8hi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
-{
-  return __builtin_aarch64_sqrdmlshv4si (__a, __b, __c);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlah_laneq_s16 (int16x4_t __a, int16x4_t __b, int16x8_t __c, const int __d)
-{
-  return  __builtin_aarch64_sqrdmlah_laneqv4hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlah_laneq_s32 (int32x2_t __a, int32x2_t __b, int32x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_laneqv2si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahq_laneq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_laneqv8hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahq_laneq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_laneqv4si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlsh_laneq_s16 (int16x4_t __a, int16x4_t __b, int16x8_t __c, const int __d)
-{
-  return  __builtin_aarch64_sqrdmlsh_laneqv4hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlsh_laneq_s32 (int32x2_t __a, int32x2_t __b, int32x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_laneqv2si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshq_laneq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_laneqv8hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshq_laneq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_laneqv4si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlah_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
-{
-  return  __builtin_aarch64_sqrdmlah_lanev4hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlah_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_lanev2si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_lanev8hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_lanev4si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahh_s16 (int16_t __a, int16_t __b, int16_t __c)
-{
-  return (int16_t) __builtin_aarch64_sqrdmlahhi (__a, __b, __c);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahh_lane_s16 (int16_t __a, int16_t __b, int16x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_lanehi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahh_laneq_s16 (int16_t __a, int16_t __b, int16x8_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_laneqhi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahs_s32 (int32_t __a, int32_t __b, int32_t __c)
-{
-  return (int32_t) __builtin_aarch64_sqrdmlahsi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahs_lane_s32 (int32_t __a, int32_t __b, int32x2_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_lanesi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlahs_laneq_s32 (int32_t __a, int32_t __b, int32x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlah_laneqsi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlsh_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
-{
-  return  __builtin_aarch64_sqrdmlsh_lanev4hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlsh_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_lanev2si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_lanev8hi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_lanev4si (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshh_s16 (int16_t __a, int16_t __b, int16_t __c)
-{
-  return (int16_t) __builtin_aarch64_sqrdmlshhi (__a, __b, __c);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshh_lane_s16 (int16_t __a, int16_t __b, int16x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_lanehi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshh_laneq_s16 (int16_t __a, int16_t __b, int16x8_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_laneqhi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshs_s32 (int32_t __a, int32_t __b, int32_t __c)
-{
-  return (int32_t) __builtin_aarch64_sqrdmlshsi (__a, __b, __c);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshs_lane_s32 (int32_t __a, int32_t __b, int32x2_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_lanesi (__a, __b, __c, __d);
-}
-
-__extension__ extern __inline int32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vqrdmlshs_laneq_s32 (int32_t __a, int32_t __b, int32x4_t __c, const int __d)
-{
-  return __builtin_aarch64_sqrdmlsh_laneqsi (__a, __b, __c, __d);
-}
-#pragma GCC pop_options
-
-#pragma GCC push_options
-#pragma GCC target ("+nothing+aes")
-/* vaes  */
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaeseq_u8 (uint8x16_t data, uint8x16_t key)
-{
-  return __builtin_aarch64_crypto_aesev16qi_uuu (data, key);
-}
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaesdq_u8 (uint8x16_t data, uint8x16_t key)
-{
-  return __builtin_aarch64_crypto_aesdv16qi_uuu (data, key);
-}
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaesmcq_u8 (uint8x16_t data)
-{
-  return __builtin_aarch64_crypto_aesmcv16qi_uu (data);
-}
-
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vaesimcq_u8 (uint8x16_t data)
-{
-  return __builtin_aarch64_crypto_aesimcv16qi_uu (data);
-}
-
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_p64 (poly64_t __a, poly64_t __b)
-{
-  return
-    __builtin_aarch64_crypto_pmulldi_ppp (__a, __b);
-}
-
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_p64 (poly64x2_t __a, poly64x2_t __b)
-{
-  return __builtin_aarch64_crypto_pmullv2di_ppp (__a, __b);
-}
-
-#pragma GCC pop_options
-
-/* vcage  */
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcage_f64 (float64x1_t __a, float64x1_t __b)
-{
-  return vcreate_u64 (__builtin_aarch64_facgedf_uss (__a[0], __b[0]));
-}
-
-__extension__ extern __inline uint32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcages_f32 (float32_t __a, float32_t __b)
-{
-  return __builtin_aarch64_facgesf_uss  (__a, __b);
-}
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcage_f32 (float32x2_t __a, float32x2_t __b)
-{
-  return __builtin_aarch64_facgev2sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcageq_f32 (float32x4_t __a, float32x4_t __b)
-{
-  return __builtin_aarch64_facgev4sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcaged_f64 (float64_t __a, float64_t __b)
-{
-  return __builtin_aarch64_facgedf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcageq_f64 (float64x2_t __a, float64x2_t __b)
-{
-  return __builtin_aarch64_facgev2df_uss (__a, __b);
-}
-
-/* vcagt  */
-
-__extension__ extern __inline uint32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcagts_f32 (float32_t __a, float32_t __b)
-{
-  return __builtin_aarch64_facgtsf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcagt_f32 (float32x2_t __a, float32x2_t __b)
-{
-  return __builtin_aarch64_facgtv2sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcagt_f64 (float64x1_t __a, float64x1_t __b)
-{
-  return vcreate_u64 (__builtin_aarch64_facgtdf_uss (__a[0], __b[0]));
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcagtq_f32 (float32x4_t __a, float32x4_t __b)
-{
-  return __builtin_aarch64_facgtv4sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcagtd_f64 (float64_t __a, float64_t __b)
-{
-  return __builtin_aarch64_facgtdf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcagtq_f64 (float64x2_t __a, float64x2_t __b)
-{
-  return __builtin_aarch64_facgtv2df_uss (__a, __b);
-}
-
-/* vcale  */
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcale_f32 (float32x2_t __a, float32x2_t __b)
-{
-  return __builtin_aarch64_faclev2sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcale_f64 (float64x1_t __a, float64x1_t __b)
-{
-  return vcreate_u64 (__builtin_aarch64_facledf_uss (__a[0], __b[0]));
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcaled_f64 (float64_t __a, float64_t __b)
-{
-  return __builtin_aarch64_facledf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcales_f32 (float32_t __a, float32_t __b)
-{
-  return __builtin_aarch64_faclesf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcaleq_f32 (float32x4_t __a, float32x4_t __b)
-{
-  return __builtin_aarch64_faclev4sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcaleq_f64 (float64x2_t __a, float64x2_t __b)
-{
-  return __builtin_aarch64_faclev2df_uss (__a, __b);
-}
-
-/* vcalt  */
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcalt_f32 (float32x2_t __a, float32x2_t __b)
-{
-  return __builtin_aarch64_facltv2sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcalt_f64 (float64x1_t __a, float64x1_t __b)
-{
-  return vcreate_u64 (__builtin_aarch64_facltdf_uss (__a[0], __b[0]));
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcaltd_f64 (float64_t __a, float64_t __b)
-{
-  return __builtin_aarch64_facltdf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcaltq_f32 (float32x4_t __a, float32x4_t __b)
-{
-  return __builtin_aarch64_facltv4sf_uss (__a, __b);
-}
-
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcaltq_f64 (float64x2_t __a, float64x2_t __b)
-{
-  return __builtin_aarch64_facltv2df_uss (__a, __b);
-}
-
-__extension__ extern __inline uint32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcalts_f32 (float32_t __a, float32_t __b)
-{
-  return __builtin_aarch64_facltsf_uss (__a, __b);
-}
-
-/* vceq - vector.  */
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_f32 (float32x2_t __a, float32x2_t __b)
-{
-  return (uint32x2_t) (__a == __b);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_f64 (float64x1_t __a, float64x1_t __b)
-{
-  return (uint64x1_t) (__a == __b);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_p8 (poly8x8_t __a, poly8x8_t __b)
-{
-  return (uint8x8_t) (__a == __b);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_p64 (poly64x1_t __a, poly64x1_t __b)
-{
-  return (uint64x1_t) (__a == __b);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_s8 (int8x8_t __a, int8x8_t __b)
-{
-  return (uint8x8_t) (__a == __b);
-}
-
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_s16 (int16x4_t __a, int16x4_t __b)
-{
-  return (uint16x4_t) (__a == __b);
-}
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_s32 (int32x2_t __a, int32x2_t __b)
-{
-  return (uint32x2_t) (__a == __b);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_s64 (int64x1_t __a, int64x1_t __b)
-{
-  return (uint64x1_t) (__a == __b);
-}
-
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_u8 (uint8x8_t __a, uint8x8_t __b)
-{
-  return (__a == __b);
-}
-
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_u16 (uint16x4_t __a, uint16x4_t __b)
-{
-  return (__a == __b);
-}
-
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_u32 (uint32x2_t __a, uint32x2_t __b)
-{
-  return (__a == __b);
-}
-
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceq_u64 (uint64x1_t __a, uint64x1_t __b)
-{
-  return (__a == __b);
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_f32 (float32x4_t __a, float32x4_t __b)
-{
-  return (uint32x4_t) (__a == __b);
+  return __builtin_aarch64_absv4hi (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_f64 (float64x2_t __a, float64x2_t __b)
+vabs_s32 (int32x2_t __a)
 {
-  return (uint64x2_t) (__a == __b);
+  return __builtin_aarch64_absv2si (__a);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_p8 (poly8x16_t __a, poly8x16_t __b)
+vabs_s64 (int64x1_t __a)
 {
-  return (uint8x16_t) (__a == __b);
+  return (int64x1_t) {__builtin_aarch64_absdi (__a[0])};
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_s8 (int8x16_t __a, int8x16_t __b)
+vabsq_f32 (float32x4_t __a)
 {
-  return (uint8x16_t) (__a == __b);
+  return __builtin_aarch64_absv4sf (__a);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_s16 (int16x8_t __a, int16x8_t __b)
+vabsq_f64 (float64x2_t __a)
 {
-  return (uint16x8_t) (__a == __b);
+  return __builtin_aarch64_absv2df (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_s32 (int32x4_t __a, int32x4_t __b)
+vabsq_s8 (int8x16_t __a)
 {
-  return (uint32x4_t) (__a == __b);
+  return __builtin_aarch64_absv16qi (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_s64 (int64x2_t __a, int64x2_t __b)
+vabsq_s16 (int16x8_t __a)
 {
-  return (uint64x2_t) (__a == __b);
+  return __builtin_aarch64_absv8hi (__a);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_u8 (uint8x16_t __a, uint8x16_t __b)
+vabsq_s32 (int32x4_t __a)
 {
-  return (__a == __b);
+  return __builtin_aarch64_absv4si (__a);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_u16 (uint16x8_t __a, uint16x8_t __b)
+vabsq_s64 (int64x2_t __a)
 {
-  return (__a == __b);
+  return __builtin_aarch64_absv2di (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+/* Try to avoid moving between integer and vector registers.
+   For why the cast to unsigned is needed check the vnegd_s64 intrinsic.
+   There is a testcase related to this issue:
+   gcc.target/aarch64/vabsd_s64.c.  */
+
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_u32 (uint32x4_t __a, uint32x4_t __b)
+vabsd_s64 (int64_t __a)
 {
-  return (__a == __b);
+  return __a < 0 ? - (uint64_t) __a : __a;
 }
 
-__extension__ extern __inline uint64x2_t
+/* vadd */
+
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_u64 (uint64x2_t __a, uint64x2_t __b)
+vaddd_s64 (int64_t __a, int64_t __b)
 {
-  return (__a == __b);
+  return __a + __b;
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqq_p64 (poly64x2_t __a, poly64x2_t __b)
+vaddd_u64 (uint64_t __a, uint64_t __b)
 {
-  return (__a == __b);
+  return __a + __b;
 }
 
-/* vceq - scalar.  */
+/* vaddv */
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqs_f32 (float32_t __a, float32_t __b)
+vaddv_s8 (int8x8_t __a)
 {
-  return __a == __b ? -1 : 0;
+  return __builtin_aarch64_reduc_plus_scal_v8qi (__a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqd_s64 (int64_t __a, int64_t __b)
+vaddv_s16 (int16x4_t __a)
 {
-  return __a == __b ? -1ll : 0ll;
+  return __builtin_aarch64_reduc_plus_scal_v4hi (__a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqd_u64 (uint64_t __a, uint64_t __b)
+vaddv_s32 (int32x2_t __a)
 {
-  return __a == __b ? -1ll : 0ll;
+  return __builtin_aarch64_reduc_plus_scal_v2si (__a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqd_f64 (float64_t __a, float64_t __b)
+vaddv_u8 (uint8x8_t __a)
 {
-  return __a == __b ? -1ll : 0ll;
+  return __builtin_aarch64_reduc_plus_scal_v8qi_uu (__a);
 }
 
-/* vceqz - vector.  */
-
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_f32 (float32x2_t __a)
+vaddv_u16 (uint16x4_t __a)
 {
-  return (uint32x2_t) (__a == 0.0f);
+  return __builtin_aarch64_reduc_plus_scal_v4hi_uu (__a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_f64 (float64x1_t __a)
+vaddv_u32 (uint32x2_t __a)
 {
-  return (uint64x1_t) (__a == (float64x1_t) {0.0});
+  return __builtin_aarch64_reduc_plus_scal_v2si_uu (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_p8 (poly8x8_t __a)
+vaddvq_s8 (int8x16_t __a)
 {
-  return (uint8x8_t) (__a == 0);
+  return __builtin_aarch64_reduc_plus_scal_v16qi (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_s8 (int8x8_t __a)
+vaddvq_s16 (int16x8_t __a)
 {
-  return (uint8x8_t) (__a == 0);
+  return __builtin_aarch64_reduc_plus_scal_v8hi (__a);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_s16 (int16x4_t __a)
+vaddvq_s32 (int32x4_t __a)
 {
-  return (uint16x4_t) (__a == 0);
+  return __builtin_aarch64_reduc_plus_scal_v4si (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_s32 (int32x2_t __a)
+vaddvq_s64 (int64x2_t __a)
 {
-  return (uint32x2_t) (__a == 0);
+  return __builtin_aarch64_reduc_plus_scal_v2di (__a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_s64 (int64x1_t __a)
+vaddvq_u8 (uint8x16_t __a)
 {
-  return (uint64x1_t) (__a == __AARCH64_INT64_C (0));
+  return __builtin_aarch64_reduc_plus_scal_v16qi_uu (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline uint16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_u8 (uint8x8_t __a)
+vaddvq_u16 (uint16x8_t __a)
 {
-  return (__a == 0);
+  return __builtin_aarch64_reduc_plus_scal_v8hi_uu (__a);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_u16 (uint16x4_t __a)
+vaddvq_u32 (uint32x4_t __a)
 {
-  return (__a == 0);
+  return __builtin_aarch64_reduc_plus_scal_v4si_uu (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_u32 (uint32x2_t __a)
+vaddvq_u64 (uint64x2_t __a)
 {
-  return (__a == 0);
+  return __builtin_aarch64_reduc_plus_scal_v2di_uu (__a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_u64 (uint64x1_t __a)
+vaddv_f32 (float32x2_t __a)
 {
-  return (__a == __AARCH64_UINT64_C (0));
+  return __builtin_aarch64_reduc_plus_scal_v2sf (__a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqz_p64 (poly64x1_t __a)
+vaddvq_f32 (float32x4_t __a)
 {
-  return (__a == __AARCH64_UINT64_C (0));
+  return __builtin_aarch64_reduc_plus_scal_v4sf (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline float64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_f32 (float32x4_t __a)
+vaddvq_f64 (float64x2_t __a)
 {
-  return (uint32x4_t) (__a == 0.0f);
+  return __builtin_aarch64_reduc_plus_scal_v2df (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+/* vbsl  */
+
+__extension__ extern __inline float16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_f64 (float64x2_t __a)
+vbsl_f16 (uint16x4_t __a, float16x4_t __b, float16x4_t __c)
 {
-  return (uint64x2_t) (__a == 0.0f);
+  return __builtin_aarch64_simd_bslv4hf_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_p8 (poly8x16_t __a)
+vbsl_f32 (uint32x2_t __a, float32x2_t __b, float32x2_t __c)
 {
-  return (uint8x16_t) (__a == 0);
+  return __builtin_aarch64_simd_bslv2sf_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline float64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_s8 (int8x16_t __a)
+vbsl_f64 (uint64x1_t __a, float64x1_t __b, float64x1_t __c)
 {
-  return (uint8x16_t) (__a == 0);
+  return (float64x1_t)
+    { __builtin_aarch64_simd_bsldf_suss (__a[0], __b[0], __c[0]) };
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_s16 (int16x8_t __a)
+vbsl_p8 (uint8x8_t __a, poly8x8_t __b, poly8x8_t __c)
 {
-  return (uint16x8_t) (__a == 0);
+  return __builtin_aarch64_simd_bslv8qi_pupp (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline poly16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_s32 (int32x4_t __a)
+vbsl_p16 (uint16x4_t __a, poly16x4_t __b, poly16x4_t __c)
 {
-  return (uint32x4_t) (__a == 0);
+  return __builtin_aarch64_simd_bslv4hi_pupp (__a, __b, __c);
+}
+__extension__ extern __inline poly64x1_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vbsl_p64 (uint64x1_t __a, poly64x1_t __b, poly64x1_t __c)
+{
+  return (poly64x1_t)
+      {__builtin_aarch64_simd_bsldi_pupp (__a[0], __b[0], __c[0])};
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_s64 (int64x2_t __a)
+vbsl_s8 (uint8x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return (uint64x2_t) (__a == __AARCH64_INT64_C (0));
+  return __builtin_aarch64_simd_bslv8qi_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_u8 (uint8x16_t __a)
+vbsl_s16 (uint16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (__a == 0);
+  return __builtin_aarch64_simd_bslv4hi_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_u16 (uint16x8_t __a)
+vbsl_s32 (uint32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (__a == 0);
+  return __builtin_aarch64_simd_bslv2si_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_u32 (uint32x4_t __a)
+vbsl_s64 (uint64x1_t __a, int64x1_t __b, int64x1_t __c)
 {
-  return (__a == 0);
+  return (int64x1_t)
+      {__builtin_aarch64_simd_bsldi_suss (__a[0], __b[0], __c[0])};
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_u64 (uint64x2_t __a)
+vbsl_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return (__a == __AARCH64_UINT64_C (0));
+  return __builtin_aarch64_simd_bslv8qi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzq_p64 (poly64x2_t __a)
+vbsl_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return (__a == __AARCH64_UINT64_C (0));
+  return __builtin_aarch64_simd_bslv4hi_uuuu (__a, __b, __c);
 }
 
-/* vceqz - scalar.  */
-
-__extension__ extern __inline uint32_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzs_f32 (float32_t __a)
+vbsl_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return __a == 0.0f ? -1 : 0;
+  return __builtin_aarch64_simd_bslv2si_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzd_s64 (int64_t __a)
+vbsl_u64 (uint64x1_t __a, uint64x1_t __b, uint64x1_t __c)
 {
-  return __a == 0 ? -1ll : 0ll;
+  return (uint64x1_t)
+      {__builtin_aarch64_simd_bsldi_uuuu (__a[0], __b[0], __c[0])};
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline float16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzd_u64 (uint64_t __a)
+vbslq_f16 (uint16x8_t __a, float16x8_t __b, float16x8_t __c)
 {
-  return __a == 0 ? -1ll : 0ll;
+  return __builtin_aarch64_simd_bslv8hf_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vceqzd_f64 (float64_t __a)
+vbslq_f32 (uint32x4_t __a, float32x4_t __b, float32x4_t __c)
 {
-  return __a == 0.0 ? -1ll : 0ll;
+  return __builtin_aarch64_simd_bslv4sf_suss (__a, __b, __c);
 }
 
-/* vcge - vector.  */
-
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_f32 (float32x2_t __a, float32x2_t __b)
+vbslq_f64 (uint64x2_t __a, float64x2_t __b, float64x2_t __c)
 {
-  return (uint32x2_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv2df_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline poly8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_f64 (float64x1_t __a, float64x1_t __b)
+vbslq_p8 (uint8x16_t __a, poly8x16_t __b, poly8x16_t __c)
 {
-  return (uint64x1_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv16qi_pupp (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline poly16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_s8 (int8x8_t __a, int8x8_t __b)
+vbslq_p16 (uint16x8_t __a, poly16x8_t __b, poly16x8_t __c)
 {
-  return (uint8x8_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv8hi_pupp (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_s16 (int16x4_t __a, int16x4_t __b)
+vbslq_s8 (uint8x16_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return (uint16x4_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv16qi_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_s32 (int32x2_t __a, int32x2_t __b)
+vbslq_s16 (uint16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return (uint32x2_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv8hi_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline poly64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_s64 (int64x1_t __a, int64x1_t __b)
+vbslq_p64 (uint64x2_t __a, poly64x2_t __b, poly64x2_t __c)
 {
-  return (uint64x1_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv2di_pupp (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_u8 (uint8x8_t __a, uint8x8_t __b)
+vbslq_s32 (uint32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_simd_bslv4si_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_u16 (uint16x4_t __a, uint16x4_t __b)
+vbslq_s64 (uint64x2_t __a, int64x2_t __b, int64x2_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_simd_bslv2di_suss (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_u32 (uint32x2_t __a, uint32x2_t __b)
+vbslq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_simd_bslv16qi_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcge_u64 (uint64x1_t __a, uint64x1_t __b)
+vbslq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_simd_bslv8hi_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_f32 (float32x4_t __a, float32x4_t __b)
+vbslq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return (uint32x4_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv4si_uuuu (__a, __b, __c);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_f64 (float64x2_t __a, float64x2_t __b)
+vbslq_u64 (uint64x2_t __a, uint64x2_t __b, uint64x2_t __c)
 {
-  return (uint64x2_t) (__a >= __b);
+  return __builtin_aarch64_simd_bslv2di_uuuu (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x16_t
+/* ARMv8.1-A intrinsics.  */
+#pragma GCC push_options
+#pragma GCC target ("+nothing+rdma")
+
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_s8 (int8x16_t __a, int8x16_t __b)
+vqrdmlah_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (uint8x16_t) (__a >= __b);
+  return __builtin_aarch64_sqrdmlahv4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_s16 (int16x8_t __a, int16x8_t __b)
+vqrdmlah_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (uint16x8_t) (__a >= __b);
+  return __builtin_aarch64_sqrdmlahv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_s32 (int32x4_t __a, int32x4_t __b)
+vqrdmlahq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return (uint32x4_t) (__a >= __b);
+  return __builtin_aarch64_sqrdmlahv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_s64 (int64x2_t __a, int64x2_t __b)
+vqrdmlahq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return (uint64x2_t) (__a >= __b);
+  return __builtin_aarch64_sqrdmlahv4si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_u8 (uint8x16_t __a, uint8x16_t __b)
+vqrdmlsh_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_sqrdmlshv4hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_u16 (uint16x8_t __a, uint16x8_t __b)
+vqrdmlsh_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_sqrdmlshv2si (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_u32 (uint32x4_t __a, uint32x4_t __b)
+vqrdmlshq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_sqrdmlshv8hi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgeq_u64 (uint64x2_t __a, uint64x2_t __b)
+vqrdmlshq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return (__a >= __b);
+  return __builtin_aarch64_sqrdmlshv4si (__a, __b, __c);
 }
 
-/* vcge - scalar.  */
-
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcges_f32 (float32_t __a, float32_t __b)
+vqrdmlah_laneq_s16 (int16x4_t __a, int16x4_t __b, int16x8_t __c, const int __d)
 {
-  return __a >= __b ? -1 : 0;
+  return  __builtin_aarch64_sqrdmlah_laneqv4hi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcged_s64 (int64_t __a, int64_t __b)
+vqrdmlah_laneq_s32 (int32x2_t __a, int32x2_t __b, int32x4_t __c, const int __d)
 {
-  return __a >= __b ? -1ll : 0ll;
+  return __builtin_aarch64_sqrdmlah_laneqv2si (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcged_u64 (uint64_t __a, uint64_t __b)
+vqrdmlahq_laneq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c, const int __d)
 {
-  return __a >= __b ? -1ll : 0ll;
+  return __builtin_aarch64_sqrdmlah_laneqv8hi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcged_f64 (float64_t __a, float64_t __b)
+vqrdmlahq_laneq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c, const int __d)
 {
-  return __a >= __b ? -1ll : 0ll;
+  return __builtin_aarch64_sqrdmlah_laneqv4si (__a, __b, __c, __d);
 }
 
-/* vcgez - vector.  */
-
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgez_f32 (float32x2_t __a)
+vqrdmlsh_laneq_s16 (int16x4_t __a, int16x4_t __b, int16x8_t __c, const int __d)
 {
-  return (uint32x2_t) (__a >= 0.0f);
+  return  __builtin_aarch64_sqrdmlsh_laneqv4hi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgez_f64 (float64x1_t __a)
+vqrdmlsh_laneq_s32 (int32x2_t __a, int32x2_t __b, int32x4_t __c, const int __d)
 {
-  return (uint64x1_t) (__a[0] >= (float64x1_t) {0.0});
+  return __builtin_aarch64_sqrdmlsh_laneqv2si (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgez_s8 (int8x8_t __a)
+vqrdmlshq_laneq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c, const int __d)
 {
-  return (uint8x8_t) (__a >= 0);
+  return __builtin_aarch64_sqrdmlsh_laneqv8hi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgez_s16 (int16x4_t __a)
+vqrdmlshq_laneq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c, const int __d)
 {
-  return (uint16x4_t) (__a >= 0);
+  return __builtin_aarch64_sqrdmlsh_laneqv4si (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgez_s32 (int32x2_t __a)
+vqrdmlah_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return (uint32x2_t) (__a >= 0);
+  return  __builtin_aarch64_sqrdmlah_lanev4hi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgez_s64 (int64x1_t __a)
+vqrdmlah_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (uint64x1_t) (__a >= __AARCH64_INT64_C (0));
+  return __builtin_aarch64_sqrdmlah_lanev2si (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezq_f32 (float32x4_t __a)
+vqrdmlahq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d)
 {
-  return (uint32x4_t) (__a >= 0.0f);
+  return __builtin_aarch64_sqrdmlah_lanev8hi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezq_f64 (float64x2_t __a)
+vqrdmlahq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d)
 {
-  return (uint64x2_t) (__a >= 0.0);
+  return __builtin_aarch64_sqrdmlah_lanev4si (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezq_s8 (int8x16_t __a)
+vqrdmlahh_s16 (int16_t __a, int16_t __b, int16_t __c)
 {
-  return (uint8x16_t) (__a >= 0);
+  return (int16_t) __builtin_aarch64_sqrdmlahhi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezq_s16 (int16x8_t __a)
+vqrdmlahh_lane_s16 (int16_t __a, int16_t __b, int16x4_t __c, const int __d)
 {
-  return (uint16x8_t) (__a >= 0);
+  return __builtin_aarch64_sqrdmlah_lanehi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezq_s32 (int32x4_t __a)
+vqrdmlahh_laneq_s16 (int16_t __a, int16_t __b, int16x8_t __c, const int __d)
 {
-  return (uint32x4_t) (__a >= 0);
+  return __builtin_aarch64_sqrdmlah_laneqhi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezq_s64 (int64x2_t __a)
+vqrdmlahs_s32 (int32_t __a, int32_t __b, int32_t __c)
 {
-  return (uint64x2_t) (__a >= __AARCH64_INT64_C (0));
+  return (int32_t) __builtin_aarch64_sqrdmlahsi (__a, __b, __c);
 }
 
-/* vcgez - scalar.  */
-
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezs_f32 (float32_t __a)
+vqrdmlahs_lane_s32 (int32_t __a, int32_t __b, int32x2_t __c, const int __d)
 {
-  return __a >= 0.0f ? -1 : 0;
+  return __builtin_aarch64_sqrdmlah_lanesi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezd_s64 (int64_t __a)
+vqrdmlahs_laneq_s32 (int32_t __a, int32_t __b, int32x4_t __c, const int __d)
 {
-  return __a >= 0 ? -1ll : 0ll;
+  return __builtin_aarch64_sqrdmlah_laneqsi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgezd_f64 (float64_t __a)
+vqrdmlsh_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return __a >= 0.0 ? -1ll : 0ll;
+  return  __builtin_aarch64_sqrdmlsh_lanev4hi (__a, __b, __c, __d);
 }
 
-/* vcgt - vector.  */
-
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_f32 (float32x2_t __a, float32x2_t __b)
+vqrdmlsh_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (uint32x2_t) (__a > __b);
+  return __builtin_aarch64_sqrdmlsh_lanev2si (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_f64 (float64x1_t __a, float64x1_t __b)
+vqrdmlshq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d)
 {
-  return (uint64x1_t) (__a > __b);
+  return __builtin_aarch64_sqrdmlsh_lanev8hi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_s8 (int8x8_t __a, int8x8_t __b)
+vqrdmlshq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d)
 {
-  return (uint8x8_t) (__a > __b);
+  return __builtin_aarch64_sqrdmlsh_lanev4si (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_s16 (int16x4_t __a, int16x4_t __b)
+vqrdmlshh_s16 (int16_t __a, int16_t __b, int16_t __c)
 {
-  return (uint16x4_t) (__a > __b);
+  return (int16_t) __builtin_aarch64_sqrdmlshhi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_s32 (int32x2_t __a, int32x2_t __b)
+vqrdmlshh_lane_s16 (int16_t __a, int16_t __b, int16x4_t __c, const int __d)
 {
-  return (uint32x2_t) (__a > __b);
+  return __builtin_aarch64_sqrdmlsh_lanehi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline int16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_s64 (int64x1_t __a, int64x1_t __b)
+vqrdmlshh_laneq_s16 (int16_t __a, int16_t __b, int16x8_t __c, const int __d)
 {
-  return (uint64x1_t) (__a > __b);
+  return __builtin_aarch64_sqrdmlsh_laneqhi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_u8 (uint8x8_t __a, uint8x8_t __b)
+vqrdmlshs_s32 (int32_t __a, int32_t __b, int32_t __c)
 {
-  return (__a > __b);
+  return (int32_t) __builtin_aarch64_sqrdmlshsi (__a, __b, __c);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_u16 (uint16x4_t __a, uint16x4_t __b)
+vqrdmlshs_lane_s32 (int32_t __a, int32_t __b, int32x2_t __c, const int __d)
 {
-  return (__a > __b);
+  return __builtin_aarch64_sqrdmlsh_lanesi (__a, __b, __c, __d);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_u32 (uint32x2_t __a, uint32x2_t __b)
+vqrdmlshs_laneq_s32 (int32_t __a, int32_t __b, int32x4_t __c, const int __d)
 {
-  return (__a > __b);
+  return __builtin_aarch64_sqrdmlsh_laneqsi (__a, __b, __c, __d);
 }
+#pragma GCC pop_options
 
-__extension__ extern __inline uint64x1_t
+#pragma GCC push_options
+#pragma GCC target ("+nothing+aes")
+/* vaes  */
+
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgt_u64 (uint64x1_t __a, uint64x1_t __b)
+vaeseq_u8 (uint8x16_t data, uint8x16_t key)
 {
-  return (__a > __b);
+  return __builtin_aarch64_crypto_aesev16qi_uuu (data, key);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_f32 (float32x4_t __a, float32x4_t __b)
+vaesdq_u8 (uint8x16_t data, uint8x16_t key)
 {
-  return (uint32x4_t) (__a > __b);
+  return __builtin_aarch64_crypto_aesdv16qi_uuu (data, key);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_f64 (float64x2_t __a, float64x2_t __b)
+vaesmcq_u8 (uint8x16_t data)
 {
-  return (uint64x2_t) (__a > __b);
+  return __builtin_aarch64_crypto_aesmcv16qi_uu (data);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_s8 (int8x16_t __a, int8x16_t __b)
+vaesimcq_u8 (uint8x16_t data)
 {
-  return (uint8x16_t) (__a > __b);
+  return __builtin_aarch64_crypto_aesimcv16qi_uu (data);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline poly128_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_s16 (int16x8_t __a, int16x8_t __b)
+vmull_p64 (poly64_t __a, poly64_t __b)
 {
-  return (uint16x8_t) (__a > __b);
+  return
+    __builtin_aarch64_crypto_pmulldi_ppp (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline poly128_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_s32 (int32x4_t __a, int32x4_t __b)
+vmull_high_p64 (poly64x2_t __a, poly64x2_t __b)
 {
-  return (uint32x4_t) (__a > __b);
+  return __builtin_aarch64_crypto_pmullv2di_ppp (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+#pragma GCC pop_options
+
+/* vcage  */
+
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_s64 (int64x2_t __a, int64x2_t __b)
+vcage_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return (uint64x2_t) (__a > __b);
+  return vcreate_u64 (__builtin_aarch64_facgedf_uss (__a[0], __b[0]));
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_u8 (uint8x16_t __a, uint8x16_t __b)
+vcages_f32 (float32_t __a, float32_t __b)
 {
-  return (__a > __b);
+  return __builtin_aarch64_facgesf_uss  (__a, __b);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_u16 (uint16x8_t __a, uint16x8_t __b)
+vcage_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (__a > __b);
+  return __builtin_aarch64_facgev2sf_uss (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_u32 (uint32x4_t __a, uint32x4_t __b)
+vcageq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (__a > __b);
+  return __builtin_aarch64_facgev4sf_uss (__a, __b);
+}
+
+__extension__ extern __inline uint64_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vcaged_f64 (float64_t __a, float64_t __b)
+{
+  return __builtin_aarch64_facgedf_uss (__a, __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtq_u64 (uint64x2_t __a, uint64x2_t __b)
+vcageq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return (__a > __b);
+  return __builtin_aarch64_facgev2df_uss (__a, __b);
 }
 
-/* vcgt - scalar.  */
+/* vcagt  */
 
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgts_f32 (float32_t __a, float32_t __b)
+vcagts_f32 (float32_t __a, float32_t __b)
 {
-  return __a > __b ? -1 : 0;
+  return __builtin_aarch64_facgtsf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtd_s64 (int64_t __a, int64_t __b)
+vcagt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return __a > __b ? -1ll : 0ll;
+  return __builtin_aarch64_facgtv2sf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtd_u64 (uint64_t __a, uint64_t __b)
+vcagt_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return __a > __b ? -1ll : 0ll;
+  return vcreate_u64 (__builtin_aarch64_facgtdf_uss (__a[0], __b[0]));
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtd_f64 (float64_t __a, float64_t __b)
+vcagtq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return __a > __b ? -1ll : 0ll;
+  return __builtin_aarch64_facgtv4sf_uss (__a, __b);
 }
 
-/* vcgtz - vector.  */
-
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtz_f32 (float32x2_t __a)
+vcagtd_f64 (float64_t __a, float64_t __b)
 {
-  return (uint32x2_t) (__a > 0.0f);
+  return __builtin_aarch64_facgtdf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtz_f64 (float64x1_t __a)
+vcagtq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return (uint64x1_t) (__a > (float64x1_t) {0.0});
+  return __builtin_aarch64_facgtv2df_uss (__a, __b);
 }
 
-__extension__ extern __inline uint8x8_t
+/* vcale  */
+
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtz_s8 (int8x8_t __a)
+vcale_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint8x8_t) (__a > 0);
+  return __builtin_aarch64_faclev2sf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtz_s16 (int16x4_t __a)
+vcale_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return (uint16x4_t) (__a > 0);
+  return vcreate_u64 (__builtin_aarch64_facledf_uss (__a[0], __b[0]));
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtz_s32 (int32x2_t __a)
+vcaled_f64 (float64_t __a, float64_t __b)
 {
-  return (uint32x2_t) (__a > 0);
+  return __builtin_aarch64_facledf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtz_s64 (int64x1_t __a)
+vcales_f32 (float32_t __a, float32_t __b)
 {
-  return (uint64x1_t) (__a > __AARCH64_INT64_C (0));
+  return __builtin_aarch64_faclesf_uss (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzq_f32 (float32x4_t __a)
+vcaleq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t) (__a > 0.0f);
+  return __builtin_aarch64_faclev4sf_uss (__a, __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzq_f64 (float64x2_t __a)
+vcaleq_f64 (float64x2_t __a, float64x2_t __b)
 {
-    return (uint64x2_t) (__a > 0.0);
+  return __builtin_aarch64_faclev2df_uss (__a, __b);
 }
 
-__extension__ extern __inline uint8x16_t
+/* vcalt  */
+
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzq_s8 (int8x16_t __a)
+vcalt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint8x16_t) (__a > 0);
+  return __builtin_aarch64_facltv2sf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzq_s16 (int16x8_t __a)
+vcalt_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return (uint16x8_t) (__a > 0);
+  return vcreate_u64 (__builtin_aarch64_facltdf_uss (__a[0], __b[0]));
+}
+
+__extension__ extern __inline uint64_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vcaltd_f64 (float64_t __a, float64_t __b)
+{
+  return __builtin_aarch64_facltdf_uss (__a, __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzq_s32 (int32x4_t __a)
+vcaltq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t) (__a > 0);
+  return __builtin_aarch64_facltv4sf_uss (__a, __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzq_s64 (int64x2_t __a)
+vcaltq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return (uint64x2_t) (__a > __AARCH64_INT64_C (0));
+  return __builtin_aarch64_facltv2df_uss (__a, __b);
 }
 
-/* vcgtz - scalar.  */
-
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzs_f32 (float32_t __a)
+vcalts_f32 (float32_t __a, float32_t __b)
 {
-  return __a > 0.0f ? -1 : 0;
+  return __builtin_aarch64_facltsf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint64_t
+/* vceq - vector.  */
+
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzd_s64 (int64_t __a)
+vceq_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return __a > 0 ? -1ll : 0ll;
+  return (uint32x2_t) (__a == __b);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcgtzd_f64 (float64_t __a)
+vceq_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return __a > 0.0 ? -1ll : 0ll;
+  return (uint64x1_t) (__a == __b);
 }
 
-/* vcle - vector.  */
-
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_f32 (float32x2_t __a, float32x2_t __b)
+vceq_p8 (poly8x8_t __a, poly8x8_t __b)
 {
-  return (uint32x2_t) (__a <= __b);
+  return (uint8x8_t) (__a == __b);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_f64 (float64x1_t __a, float64x1_t __b)
+vceq_p64 (poly64x1_t __a, poly64x1_t __b)
 {
-  return (uint64x1_t) (__a <= __b);
+  return (uint64x1_t) (__a == __b);
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_s8 (int8x8_t __a, int8x8_t __b)
+vceq_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t) (__a <= __b);
+  return (uint8x8_t) (__a == __b);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_s16 (int16x4_t __a, int16x4_t __b)
+vceq_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t) (__a <= __b);
+  return (uint16x4_t) (__a == __b);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_s32 (int32x2_t __a, int32x2_t __b)
+vceq_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t) (__a <= __b);
+  return (uint32x2_t) (__a == __b);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_s64 (int64x1_t __a, int64x1_t __b)
+vceq_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (uint64x1_t) (__a <= __b);
+  return (uint64x1_t) (__a == __b);
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_u8 (uint8x8_t __a, uint8x8_t __b)
+vceq_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_u16 (uint16x4_t __a, uint16x4_t __b)
+vceq_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_u32 (uint32x2_t __a, uint32x2_t __b)
+vceq_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcle_u64 (uint64x1_t __a, uint64x1_t __b)
+vceq_u64 (uint64x1_t __a, uint64x1_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_f32 (float32x4_t __a, float32x4_t __b)
+vceqq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t) (__a <= __b);
+  return (uint32x4_t) (__a == __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_f64 (float64x2_t __a, float64x2_t __b)
+vceqq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return (uint64x2_t) (__a <= __b);
+  return (uint64x2_t) (__a == __b);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_s8 (int8x16_t __a, int8x16_t __b)
+vceqq_p8 (poly8x16_t __a, poly8x16_t __b)
 {
-  return (uint8x16_t) (__a <= __b);
+  return (uint8x16_t) (__a == __b);
+}
+
+__extension__ extern __inline uint8x16_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqq_s8 (int8x16_t __a, int8x16_t __b)
+{
+  return (uint8x16_t) (__a == __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_s16 (int16x8_t __a, int16x8_t __b)
+vceqq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t) (__a <= __b);
+  return (uint16x8_t) (__a == __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_s32 (int32x4_t __a, int32x4_t __b)
+vceqq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t) (__a <= __b);
+  return (uint32x4_t) (__a == __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_s64 (int64x2_t __a, int64x2_t __b)
+vceqq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (uint64x2_t) (__a <= __b);
+  return (uint64x2_t) (__a == __b);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_u8 (uint8x16_t __a, uint8x16_t __b)
+vceqq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_u16 (uint16x8_t __a, uint16x8_t __b)
+vceqq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_u32 (uint32x4_t __a, uint32x4_t __b)
+vceqq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcleq_u64 (uint64x2_t __a, uint64x2_t __b)
+vceqq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (__a <= __b);
+  return (__a == __b);
 }
 
-/* vcle - scalar.  */
+__extension__ extern __inline uint64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqq_p64 (poly64x2_t __a, poly64x2_t __b)
+{
+  return (__a == __b);
+}
+
+/* vceq - scalar.  */
 
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcles_f32 (float32_t __a, float32_t __b)
+vceqs_f32 (float32_t __a, float32_t __b)
 {
-  return __a <= __b ? -1 : 0;
+  return __a == __b ? -1 : 0;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcled_s64 (int64_t __a, int64_t __b)
+vceqd_s64 (int64_t __a, int64_t __b)
 {
-  return __a <= __b ? -1ll : 0ll;
+  return __a == __b ? -1ll : 0ll;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcled_u64 (uint64_t __a, uint64_t __b)
+vceqd_u64 (uint64_t __a, uint64_t __b)
 {
-  return __a <= __b ? -1ll : 0ll;
+  return __a == __b ? -1ll : 0ll;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcled_f64 (float64_t __a, float64_t __b)
+vceqd_f64 (float64_t __a, float64_t __b)
 {
-  return __a <= __b ? -1ll : 0ll;
+  return __a == __b ? -1ll : 0ll;
 }
 
-/* vclez - vector.  */
+/* vceqz - vector.  */
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclez_f32 (float32x2_t __a)
+vceqz_f32 (float32x2_t __a)
 {
-  return (uint32x2_t) (__a <= 0.0f);
+  return (uint32x2_t) (__a == 0.0f);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclez_f64 (float64x1_t __a)
+vceqz_f64 (float64x1_t __a)
 {
-  return (uint64x1_t) (__a <= (float64x1_t) {0.0});
+  return (uint64x1_t) (__a == (float64x1_t) {0.0});
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclez_s8 (int8x8_t __a)
+vceqz_p8 (poly8x8_t __a)
 {
-  return (uint8x8_t) (__a <= 0);
+  return (uint8x8_t) (__a == 0);
+}
+
+__extension__ extern __inline uint8x8_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqz_s8 (int8x8_t __a)
+{
+  return (uint8x8_t) (__a == 0);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclez_s16 (int16x4_t __a)
+vceqz_s16 (int16x4_t __a)
 {
-  return (uint16x4_t) (__a <= 0);
+  return (uint16x4_t) (__a == 0);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclez_s32 (int32x2_t __a)
+vceqz_s32 (int32x2_t __a)
 {
-  return (uint32x2_t) (__a <= 0);
+  return (uint32x2_t) (__a == 0);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclez_s64 (int64x1_t __a)
+vceqz_s64 (int64x1_t __a)
 {
-  return (uint64x1_t) (__a <= __AARCH64_INT64_C (0));
+  return (uint64x1_t) (__a == __AARCH64_INT64_C (0));
+}
+
+__extension__ extern __inline uint8x8_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqz_u8 (uint8x8_t __a)
+{
+  return (__a == 0);
+}
+
+__extension__ extern __inline uint16x4_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqz_u16 (uint16x4_t __a)
+{
+  return (__a == 0);
+}
+
+__extension__ extern __inline uint32x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqz_u32 (uint32x2_t __a)
+{
+  return (__a == 0);
+}
+
+__extension__ extern __inline uint64x1_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqz_u64 (uint64x1_t __a)
+{
+  return (__a == __AARCH64_UINT64_C (0));
+}
+
+__extension__ extern __inline uint64x1_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqz_p64 (poly64x1_t __a)
+{
+  return (__a == __AARCH64_UINT64_C (0));
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezq_f32 (float32x4_t __a)
+vceqzq_f32 (float32x4_t __a)
 {
-  return (uint32x4_t) (__a <= 0.0f);
+  return (uint32x4_t) (__a == 0.0f);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezq_f64 (float64x2_t __a)
+vceqzq_f64 (float64x2_t __a)
 {
-  return (uint64x2_t) (__a <= 0.0);
+  return (uint64x2_t) (__a == 0.0f);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezq_s8 (int8x16_t __a)
+vceqzq_p8 (poly8x16_t __a)
 {
-  return (uint8x16_t) (__a <= 0);
+  return (uint8x16_t) (__a == 0);
+}
+
+__extension__ extern __inline uint8x16_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqzq_s8 (int8x16_t __a)
+{
+  return (uint8x16_t) (__a == 0);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezq_s16 (int16x8_t __a)
+vceqzq_s16 (int16x8_t __a)
 {
-  return (uint16x8_t) (__a <= 0);
+  return (uint16x8_t) (__a == 0);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezq_s32 (int32x4_t __a)
+vceqzq_s32 (int32x4_t __a)
+{
+  return (uint32x4_t) (__a == 0);
+}
+
+__extension__ extern __inline uint64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqzq_s64 (int64x2_t __a)
+{
+  return (uint64x2_t) (__a == __AARCH64_INT64_C (0));
+}
+
+__extension__ extern __inline uint8x16_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqzq_u8 (uint8x16_t __a)
+{
+  return (__a == 0);
+}
+
+__extension__ extern __inline uint16x8_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqzq_u16 (uint16x8_t __a)
+{
+  return (__a == 0);
+}
+
+__extension__ extern __inline uint32x4_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqzq_u32 (uint32x4_t __a)
+{
+  return (__a == 0);
+}
+
+__extension__ extern __inline uint64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqzq_u64 (uint64x2_t __a)
 {
-  return (uint32x4_t) (__a <= 0);
+  return (__a == __AARCH64_UINT64_C (0));
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezq_s64 (int64x2_t __a)
+vceqzq_p64 (poly64x2_t __a)
 {
-  return (uint64x2_t) (__a <= __AARCH64_INT64_C (0));
+  return (__a == __AARCH64_UINT64_C (0));
 }
 
-/* vclez - scalar.  */
+/* vceqz - scalar.  */
 
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezs_f32 (float32_t __a)
+vceqzs_f32 (float32_t __a)
 {
-  return __a <= 0.0f ? -1 : 0;
+  return __a == 0.0f ? -1 : 0;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezd_s64 (int64_t __a)
+vceqzd_s64 (int64_t __a)
 {
-  return __a <= 0 ? -1ll : 0ll;
+  return __a == 0 ? -1ll : 0ll;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclezd_f64 (float64_t __a)
+vceqzd_u64 (uint64_t __a)
 {
-  return __a <= 0.0 ? -1ll : 0ll;
+  return __a == 0 ? -1ll : 0ll;
 }
 
-/* vclt - vector.  */
+__extension__ extern __inline uint64_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vceqzd_f64 (float64_t __a)
+{
+  return __a == 0.0 ? -1ll : 0ll;
+}
+
+/* vcge - vector.  */
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_f32 (float32x2_t __a, float32x2_t __b)
+vcge_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t) (__a < __b);
+  return (uint32x2_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_f64 (float64x1_t __a, float64x1_t __b)
+vcge_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return (uint64x1_t) (__a < __b);
+  return (uint64x1_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_s8 (int8x8_t __a, int8x8_t __b)
+vcge_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t) (__a < __b);
+  return (uint8x8_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_s16 (int16x4_t __a, int16x4_t __b)
+vcge_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t) (__a < __b);
+  return (uint16x4_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_s32 (int32x2_t __a, int32x2_t __b)
+vcge_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t) (__a < __b);
+  return (uint32x2_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_s64 (int64x1_t __a, int64x1_t __b)
+vcge_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (uint64x1_t) (__a < __b);
+  return (uint64x1_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_u8 (uint8x8_t __a, uint8x8_t __b)
+vcge_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_u16 (uint16x4_t __a, uint16x4_t __b)
+vcge_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_u32 (uint32x2_t __a, uint32x2_t __b)
+vcge_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclt_u64 (uint64x1_t __a, uint64x1_t __b)
+vcge_u64 (uint64x1_t __a, uint64x1_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_f32 (float32x4_t __a, float32x4_t __b)
+vcgeq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t) (__a < __b);
+  return (uint32x4_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_f64 (float64x2_t __a, float64x2_t __b)
+vcgeq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return (uint64x2_t) (__a < __b);
+  return (uint64x2_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_s8 (int8x16_t __a, int8x16_t __b)
+vcgeq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t) (__a < __b);
+  return (uint8x16_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_s16 (int16x8_t __a, int16x8_t __b)
+vcgeq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t) (__a < __b);
+  return (uint16x8_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_s32 (int32x4_t __a, int32x4_t __b)
+vcgeq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t) (__a < __b);
+  return (uint32x4_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_s64 (int64x2_t __a, int64x2_t __b)
+vcgeq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (uint64x2_t) (__a < __b);
+  return (uint64x2_t) (__a >= __b);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_u8 (uint8x16_t __a, uint8x16_t __b)
+vcgeq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_u16 (uint16x8_t __a, uint16x8_t __b)
+vcgeq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_u32 (uint32x4_t __a, uint32x4_t __b)
+vcgeq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltq_u64 (uint64x2_t __a, uint64x2_t __b)
+vcgeq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (__a < __b);
+  return (__a >= __b);
 }
 
-/* vclt - scalar.  */
+/* vcge - scalar.  */
 
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclts_f32 (float32_t __a, float32_t __b)
+vcges_f32 (float32_t __a, float32_t __b)
 {
-  return __a < __b ? -1 : 0;
+  return __a >= __b ? -1 : 0;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltd_s64 (int64_t __a, int64_t __b)
+vcged_s64 (int64_t __a, int64_t __b)
 {
-  return __a < __b ? -1ll : 0ll;
+  return __a >= __b ? -1ll : 0ll;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltd_u64 (uint64_t __a, uint64_t __b)
+vcged_u64 (uint64_t __a, uint64_t __b)
 {
-  return __a < __b ? -1ll : 0ll;
+  return __a >= __b ? -1ll : 0ll;
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltd_f64 (float64_t __a, float64_t __b)
+vcged_f64 (float64_t __a, float64_t __b)
 {
-  return __a < __b ? -1ll : 0ll;
+  return __a >= __b ? -1ll : 0ll;
 }
 
-/* vcltz - vector.  */
+/* vcgez - vector.  */
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltz_f32 (float32x2_t __a)
+vcgez_f32 (float32x2_t __a)
 {
-  return (uint32x2_t) (__a < 0.0f);
+  return (uint32x2_t) (__a >= 0.0f);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltz_f64 (float64x1_t __a)
+vcgez_f64 (float64x1_t __a)
 {
-  return (uint64x1_t) (__a < (float64x1_t) {0.0});
+  return (uint64x1_t) (__a[0] >= (float64x1_t) {0.0});
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltz_s8 (int8x8_t __a)
+vcgez_s8 (int8x8_t __a)
 {
-  return (uint8x8_t) (__a < 0);
+  return (uint8x8_t) (__a >= 0);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltz_s16 (int16x4_t __a)
+vcgez_s16 (int16x4_t __a)
 {
-  return (uint16x4_t) (__a < 0);
+  return (uint16x4_t) (__a >= 0);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltz_s32 (int32x2_t __a)
+vcgez_s32 (int32x2_t __a)
 {
-  return (uint32x2_t) (__a < 0);
+  return (uint32x2_t) (__a >= 0);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltz_s64 (int64x1_t __a)
+vcgez_s64 (int64x1_t __a)
 {
-  return (uint64x1_t) (__a < __AARCH64_INT64_C (0));
+  return (uint64x1_t) (__a >= __AARCH64_INT64_C (0));
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzq_f32 (float32x4_t __a)
+vcgezq_f32 (float32x4_t __a)
 {
-  return (uint32x4_t) (__a < 0.0f);
+  return (uint32x4_t) (__a >= 0.0f);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzq_f64 (float64x2_t __a)
+vcgezq_f64 (float64x2_t __a)
 {
-  return (uint64x2_t) (__a < 0.0);
+  return (uint64x2_t) (__a >= 0.0);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzq_s8 (int8x16_t __a)
-{
-  return (uint8x16_t) (__a < 0);
-}
-
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzq_s16 (int16x8_t __a)
-{
-  return (uint16x8_t) (__a < 0);
-}
-
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzq_s32 (int32x4_t __a)
-{
-  return (uint32x4_t) (__a < 0);
-}
-
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzq_s64 (int64x2_t __a)
-{
-  return (uint64x2_t) (__a < __AARCH64_INT64_C (0));
-}
-
-/* vcltz - scalar.  */
-
-__extension__ extern __inline uint32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzs_f32 (float32_t __a)
-{
-  return __a < 0.0f ? -1 : 0;
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzd_s64 (int64_t __a)
-{
-  return __a < 0 ? -1ll : 0ll;
-}
-
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcltzd_f64 (float64_t __a)
-{
-  return __a < 0.0 ? -1ll : 0ll;
-}
-
-/* vcls.  */
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcls_s8 (int8x8_t __a)
-{
-  return __builtin_aarch64_clrsbv8qi (__a);
-}
-
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcls_s16 (int16x4_t __a)
-{
-  return __builtin_aarch64_clrsbv4hi (__a);
-}
-
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcls_s32 (int32x2_t __a)
-{
-  return __builtin_aarch64_clrsbv2si (__a);
-}
-
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclsq_s8 (int8x16_t __a)
-{
-  return __builtin_aarch64_clrsbv16qi (__a);
-}
-
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclsq_s16 (int16x8_t __a)
-{
-  return __builtin_aarch64_clrsbv8hi (__a);
-}
-
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclsq_s32 (int32x4_t __a)
-{
-  return __builtin_aarch64_clrsbv4si (__a);
-}
-
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcls_u8 (uint8x8_t __a)
+vcgezq_s8 (int8x16_t __a)
 {
-  return __builtin_aarch64_clrsbv8qi ((int8x8_t) __a);
+  return (uint8x16_t) (__a >= 0);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcls_u16 (uint16x4_t __a)
+vcgezq_s16 (int16x8_t __a)
 {
-  return __builtin_aarch64_clrsbv4hi ((int16x4_t) __a);
+  return (uint16x8_t) (__a >= 0);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcls_u32 (uint32x2_t __a)
+vcgezq_s32 (int32x4_t __a)
 {
-  return __builtin_aarch64_clrsbv2si ((int32x2_t) __a);
+  return (uint32x4_t) (__a >= 0);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclsq_u8 (uint8x16_t __a)
+vcgezq_s64 (int64x2_t __a)
 {
-  return __builtin_aarch64_clrsbv16qi ((int8x16_t) __a);
+  return (uint64x2_t) (__a >= __AARCH64_INT64_C (0));
 }
 
-__extension__ extern __inline int16x8_t
+/* vcgez - scalar.  */
+
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclsq_u16 (uint16x8_t __a)
+vcgezs_f32 (float32_t __a)
 {
-  return __builtin_aarch64_clrsbv8hi ((int16x8_t) __a);
+  return __a >= 0.0f ? -1 : 0;
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclsq_u32 (uint32x4_t __a)
+vcgezd_s64 (int64_t __a)
 {
-  return __builtin_aarch64_clrsbv4si ((int32x4_t) __a);
+  return __a >= 0 ? -1ll : 0ll;
 }
 
-/* vclz.  */
-
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclz_s8 (int8x8_t __a)
+vcgezd_f64 (float64_t __a)
 {
-  return __builtin_aarch64_clzv8qi (__a);
+  return __a >= 0.0 ? -1ll : 0ll;
 }
 
-__extension__ extern __inline int16x4_t
+/* vcgt - vector.  */
+
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclz_s16 (int16x4_t __a)
+vcgt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return __builtin_aarch64_clzv4hi (__a);
+  return (uint32x2_t) (__a > __b);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclz_s32 (int32x2_t __a)
+vcgt_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return __builtin_aarch64_clzv2si (__a);
+  return (uint64x1_t) (__a > __b);
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclz_u8 (uint8x8_t __a)
+vcgt_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_aarch64_clzv8qi ((int8x8_t)__a);
+  return (uint8x8_t) (__a > __b);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclz_u16 (uint16x4_t __a)
+vcgt_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_aarch64_clzv4hi ((int16x4_t)__a);
+  return (uint16x4_t) (__a > __b);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclz_u32 (uint32x2_t __a)
+vcgt_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_aarch64_clzv2si ((int32x2_t)__a);
+  return (uint32x2_t) (__a > __b);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclzq_s8 (int8x16_t __a)
+vcgt_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return __builtin_aarch64_clzv16qi (__a);
+  return (uint64x1_t) (__a > __b);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclzq_s16 (int16x8_t __a)
+vcgt_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return __builtin_aarch64_clzv8hi (__a);
+  return (__a > __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclzq_s32 (int32x4_t __a)
+vcgt_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return __builtin_aarch64_clzv4si (__a);
+  return (__a > __b);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclzq_u8 (uint8x16_t __a)
+vcgt_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint8x16_t)__builtin_aarch64_clzv16qi ((int8x16_t)__a);
+  return (__a > __b);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclzq_u16 (uint16x8_t __a)
+vcgt_u64 (uint64x1_t __a, uint64x1_t __b)
 {
-  return (uint16x8_t)__builtin_aarch64_clzv8hi ((int16x8_t)__a);
+  return (__a > __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vclzq_u32 (uint32x4_t __a)
+vcgtq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_aarch64_clzv4si ((int32x4_t)__a);
+  return (uint32x4_t) (__a > __b);
 }
 
-/* vcnt.  */
-
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcnt_p8 (poly8x8_t __a)
+vcgtq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return (poly8x8_t) __builtin_aarch64_popcountv8qi ((int8x8_t) __a);
+  return (uint64x2_t) (__a > __b);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcnt_s8 (int8x8_t __a)
+vcgtq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return __builtin_aarch64_popcountv8qi (__a);
+  return (uint8x16_t) (__a > __b);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcnt_u8 (uint8x8_t __a)
+vcgtq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint8x8_t) __builtin_aarch64_popcountv8qi ((int8x8_t) __a);
+  return (uint16x8_t) (__a > __b);
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcntq_p8 (poly8x16_t __a)
+vcgtq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (poly8x16_t) __builtin_aarch64_popcountv16qi ((int8x16_t) __a);
+  return (uint32x4_t) (__a > __b);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcntq_s8 (int8x16_t __a)
+vcgtq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return __builtin_aarch64_popcountv16qi (__a);
+  return (uint64x2_t) (__a > __b);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcntq_u8 (uint8x16_t __a)
+vcgtq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t) __builtin_aarch64_popcountv16qi ((int8x16_t) __a);
+  return (__a > __b);
 }
 
-/* vcopy_lane.  */
-
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_f32 (float32x2_t __a, const int __lane1,
-               float32x2_t __b, const int __lane2)
+vcgtq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (__a > __b);
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_f64 (float64x1_t __a, const int __lane1,
-               float64x1_t __b, const int __lane2)
+vcgtq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (__a > __b);
 }
 
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_p8 (poly8x8_t __a, const int __lane1,
-              poly8x8_t __b, const int __lane2)
+vcgtq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                __a, __lane1);
+  return (__a > __b);
 }
 
-__extension__ extern __inline poly16x4_t
+/* vcgt - scalar.  */
+
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_p16 (poly16x4_t __a, const int __lane1,
-               poly16x4_t __b, const int __lane2)
+vcgts_f32 (float32_t __a, float32_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return __a > __b ? -1 : 0;
 }
 
-__extension__ extern __inline poly64x1_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_p64 (poly64x1_t __a, const int __lane1,
-               poly64x1_t __b, const int __lane2)
+vcgtd_s64 (int64_t __a, int64_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return __a > __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_s8 (int8x8_t __a, const int __lane1,
-              int8x8_t __b, const int __lane2)
+vcgtd_u64 (uint64_t __a, uint64_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                __a, __lane1);
+  return __a > __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_s16 (int16x4_t __a, const int __lane1,
-               int16x4_t __b, const int __lane2)
+vcgtd_f64 (float64_t __a, float64_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return __a > __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline int32x2_t
+/* vcgtz - vector.  */
+
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_s32 (int32x2_t __a, const int __lane1,
-               int32x2_t __b, const int __lane2)
+vcgtz_f32 (float32x2_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint32x2_t) (__a > 0.0f);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_s64 (int64x1_t __a, const int __lane1,
-               int64x1_t __b, const int __lane2)
+vcgtz_f64 (float64x1_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint64x1_t) (__a > (float64x1_t) {0.0});
 }
 
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_u8 (uint8x8_t __a, const int __lane1,
-              uint8x8_t __b, const int __lane2)
+vcgtz_s8 (int8x8_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                __a, __lane1);
+  return (uint8x8_t) (__a > 0);
 }
 
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_u16 (uint16x4_t __a, const int __lane1,
-               uint16x4_t __b, const int __lane2)
+vcgtz_s16 (int16x4_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint16x4_t) (__a > 0);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_u32 (uint32x2_t __a, const int __lane1,
-               uint32x2_t __b, const int __lane2)
+vcgtz_s32 (int32x2_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint32x2_t) (__a > 0);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_u64 (uint64x1_t __a, const int __lane1,
-               uint64x1_t __b, const int __lane2)
+vcgtz_s64 (int64x1_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint64x1_t) (__a > __AARCH64_INT64_C (0));
 }
 
-/* vcopy_laneq.  */
-
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_f32 (float32x2_t __a, const int __lane1,
-                float32x4_t __b, const int __lane2)
+vcgtzq_f32 (float32x4_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint32x4_t) (__a > 0.0f);
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_f64 (float64x1_t __a, const int __lane1,
-                float64x2_t __b, const int __lane2)
+vcgtzq_f64 (float64x2_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+    return (uint64x2_t) (__a > 0.0);
 }
 
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_p8 (poly8x8_t __a, const int __lane1,
-               poly8x16_t __b, const int __lane2)
+vcgtzq_s8 (int8x16_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                __a, __lane1);
+  return (uint8x16_t) (__a > 0);
 }
 
-__extension__ extern __inline poly16x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_p16 (poly16x4_t __a, const int __lane1,
-                poly16x8_t __b, const int __lane2)
+vcgtzq_s16 (int16x8_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint16x8_t) (__a > 0);
 }
 
-__extension__ extern __inline poly64x1_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_p64 (poly64x1_t __a, const int __lane1,
-                poly64x2_t __b, const int __lane2)
+vcgtzq_s32 (int32x4_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint32x4_t) (__a > 0);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_s8 (int8x8_t __a, const int __lane1,
-               int8x16_t __b, const int __lane2)
+vcgtzq_s64 (int64x2_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                __a, __lane1);
+  return (uint64x2_t) (__a > __AARCH64_INT64_C (0));
 }
 
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_s16 (int16x4_t __a, const int __lane1,
-                int16x8_t __b, const int __lane2)
-{
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
-}
+/* vcgtz - scalar.  */
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_s32 (int32x2_t __a, const int __lane1,
-                int32x4_t __b, const int __lane2)
+vcgtzs_f32 (float32_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return __a > 0.0f ? -1 : 0;
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_s64 (int64x1_t __a, const int __lane1,
-                int64x2_t __b, const int __lane2)
+vcgtzd_s64 (int64_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return __a > 0 ? -1ll : 0ll;
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_u8 (uint8x8_t __a, const int __lane1,
-               uint8x16_t __b, const int __lane2)
+vcgtzd_f64 (float64_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                __a, __lane1);
+  return __a > 0.0 ? -1ll : 0ll;
 }
 
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_u16 (uint16x4_t __a, const int __lane1,
-                uint16x8_t __b, const int __lane2)
-{
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
-}
+/* vcle - vector.  */
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_u32 (uint32x2_t __a, const int __lane1,
-                uint32x4_t __b, const int __lane2)
+vcle_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint32x2_t) (__a <= __b);
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_u64 (uint64x1_t __a, const int __lane1,
-                uint64x2_t __b, const int __lane2)
+vcle_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint64x1_t) (__a <= __b);
 }
 
-/* vcopyq_lane.  */
+__extension__ extern __inline uint8x8_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vcle_s8 (int8x8_t __a, int8x8_t __b)
+{
+  return (uint8x8_t) (__a <= __b);
+}
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_f32 (float32x4_t __a, const int __lane1,
-                float32x2_t __b, const int __lane2)
+vcle_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint16x4_t) (__a <= __b);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_f64 (float64x2_t __a, const int __lane1,
-                float64x1_t __b, const int __lane2)
+vcle_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint32x2_t) (__a <= __b);
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_p8 (poly8x16_t __a, const int __lane1,
-               poly8x8_t __b, const int __lane2)
+vcle_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint64x1_t) (__a <= __b);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_p16 (poly16x8_t __a, const int __lane1,
-                poly16x4_t __b, const int __lane2)
+vcle_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline poly64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_p64 (poly64x2_t __a, const int __lane1,
-                poly64x1_t __b, const int __lane2)
+vcle_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_s8 (int8x16_t __a, const int __lane1,
-               int8x8_t __b, const int __lane2)
+vcle_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_s16 (int16x8_t __a, const int __lane1,
-                int16x4_t __b, const int __lane2)
+vcle_u64 (uint64x1_t __a, uint64x1_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_s32 (int32x4_t __a, const int __lane1,
-                int32x2_t __b, const int __lane2)
+vcleq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint32x4_t) (__a <= __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_s64 (int64x2_t __a, const int __lane1,
-                int64x1_t __b, const int __lane2)
+vcleq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint64x2_t) (__a <= __b);
 }
 
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_u8 (uint8x16_t __a, const int __lane1,
-               uint8x8_t __b, const int __lane2)
+vcleq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint8x16_t) (__a <= __b);
 }
 
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_u16 (uint16x8_t __a, const int __lane1,
-                uint16x4_t __b, const int __lane2)
+vcleq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint16x8_t) (__a <= __b);
 }
 
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_u32 (uint32x4_t __a, const int __lane1,
-                uint32x2_t __b, const int __lane2)
+vcleq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint32x4_t) (__a <= __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_u64 (uint64x2_t __a, const int __lane1,
-                uint64x1_t __b, const int __lane2)
+vcleq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint64x2_t) (__a <= __b);
 }
 
-/* vcopyq_laneq.  */
-
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_f32 (float32x4_t __a, const int __lane1,
-                 float32x4_t __b, const int __lane2)
+vcleq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_f64 (float64x2_t __a, const int __lane1,
-                 float64x2_t __b, const int __lane2)
+vcleq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_p8 (poly8x16_t __a, const int __lane1,
-                poly8x16_t __b, const int __lane2)
+vcleq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_p16 (poly16x8_t __a, const int __lane1,
-                 poly16x8_t __b, const int __lane2)
+vcleq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (__a <= __b);
 }
 
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_p64 (poly64x2_t __a, const int __lane1,
-                 poly64x2_t __b, const int __lane2)
-{
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
-}
+/* vcle - scalar.  */
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_s8 (int8x16_t __a, const int __lane1,
-                int8x16_t __b, const int __lane2)
+vcles_f32 (float32_t __a, float32_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return __a <= __b ? -1 : 0;
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_s16 (int16x8_t __a, const int __lane1,
-                 int16x8_t __b, const int __lane2)
+vcled_s64 (int64_t __a, int64_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return __a <= __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_s32 (int32x4_t __a, const int __lane1,
-                 int32x4_t __b, const int __lane2)
+vcled_u64 (uint64_t __a, uint64_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return __a <= __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_s64 (int64x2_t __a, const int __lane1,
-                 int64x2_t __b, const int __lane2)
+vcled_f64 (float64_t __a, float64_t __b)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return __a <= __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline uint8x16_t
+/* vclez - vector.  */
+
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_u8 (uint8x16_t __a, const int __lane1,
-                uint8x16_t __b, const int __lane2)
+vclez_f32 (float32x2_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
+  return (uint32x2_t) (__a <= 0.0f);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_u16 (uint16x8_t __a, const int __lane1,
-                 uint16x8_t __b, const int __lane2)
+vclez_f64 (float64x1_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint64x1_t) (__a <= (float64x1_t) {0.0});
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_u32 (uint32x4_t __a, const int __lane1,
-                 uint32x4_t __b, const int __lane2)
+vclez_s8 (int8x8_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint8x8_t) (__a <= 0);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_u64 (uint64x2_t __a, const int __lane1,
-                 uint64x2_t __b, const int __lane2)
+vclez_s16 (int16x4_t __a)
 {
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                  __a, __lane1);
+  return (uint16x4_t) (__a <= 0);
 }
 
-/* vcvt (double -> float).  */
-
-__extension__ extern __inline float16x4_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f16_f32 (float32x4_t __a)
+vclez_s32 (int32x2_t __a)
 {
-  return __builtin_aarch64_float_truncate_lo_v4hf (__a);
+  return (uint32x2_t) (__a <= 0);
 }
 
-__extension__ extern __inline float16x8_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_high_f16_f32 (float16x4_t __a, float32x4_t __b)
+vclez_s64 (int64x1_t __a)
 {
-  return __builtin_aarch64_float_truncate_hi_v8hf (__a, __b);
+  return (uint64x1_t) (__a <= __AARCH64_INT64_C (0));
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f32_f64 (float64x2_t __a)
+vclezq_f32 (float32x4_t __a)
 {
-  return __builtin_aarch64_float_truncate_lo_v2sf (__a);
+  return (uint32x4_t) (__a <= 0.0f);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_high_f32_f64 (float32x2_t __a, float64x2_t __b)
+vclezq_f64 (float64x2_t __a)
 {
-  return __builtin_aarch64_float_truncate_hi_v4sf (__a, __b);
+  return (uint64x2_t) (__a <= 0.0);
 }
 
-/* vcvt (float -> double).  */
-
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f32_f16 (float16x4_t __a)
+vclezq_s8 (int8x16_t __a)
 {
-  return __builtin_aarch64_float_extend_lo_v4sf (__a);
+  return (uint8x16_t) (__a <= 0);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f64_f32 (float32x2_t __a)
+vclezq_s16 (int16x8_t __a)
 {
-
-  return __builtin_aarch64_float_extend_lo_v2df (__a);
+  return (uint16x8_t) (__a <= 0);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_high_f32_f16 (float16x8_t __a)
+vclezq_s32 (int32x4_t __a)
 {
-  return __builtin_aarch64_vec_unpacks_hi_v8hf (__a);
+  return (uint32x4_t) (__a <= 0);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_high_f64_f32 (float32x4_t __a)
+vclezq_s64 (int64x2_t __a)
 {
-  return __builtin_aarch64_vec_unpacks_hi_v4sf (__a);
+  return (uint64x2_t) (__a <= __AARCH64_INT64_C (0));
 }
 
-/* vcvt (<u>fixed-point -> float).  */
+/* vclez - scalar.  */
 
-__extension__ extern __inline float64_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_n_f64_s64 (int64_t __a, const int __b)
+vclezs_f32 (float32_t __a)
 {
-  return __builtin_aarch64_scvtfdi (__a, __b);
+  return __a <= 0.0f ? -1 : 0;
 }
 
-__extension__ extern __inline float64_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_n_f64_u64 (uint64_t __a, const int __b)
+vclezd_s64 (int64_t __a)
 {
-  return __builtin_aarch64_ucvtfdi_sus (__a, __b);
+  return __a <= 0 ? -1ll : 0ll;
 }
 
-__extension__ extern __inline float32_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_n_f32_s32 (int32_t __a, const int __b)
+vclezd_f64 (float64_t __a)
 {
-  return __builtin_aarch64_scvtfsi (__a, __b);
+  return __a <= 0.0 ? -1ll : 0ll;
 }
 
-__extension__ extern __inline float32_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_n_f32_u32 (uint32_t __a, const int __b)
-{
-  return __builtin_aarch64_ucvtfsi_sus (__a, __b);
-}
+/* vclt - vector.  */
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_f32_s32 (int32x2_t __a, const int __b)
+vclt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return __builtin_aarch64_scvtfv2si (__a, __b);
+  return (uint32x2_t) (__a < __b);
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_f32_u32 (uint32x2_t __a, const int __b)
+vclt_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return __builtin_aarch64_ucvtfv2si_sus (__a, __b);
+  return (uint64x1_t) (__a < __b);
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_f64_s64 (int64x1_t __a, const int __b)
+vclt_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (float64x1_t)
-    { __builtin_aarch64_scvtfdi (vget_lane_s64 (__a, 0), __b) };
+  return (uint8x8_t) (__a < __b);
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_f64_u64 (uint64x1_t __a, const int __b)
+vclt_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (float64x1_t)
-    { __builtin_aarch64_ucvtfdi_sus (vget_lane_u64 (__a, 0), __b) };
+  return (uint16x4_t) (__a < __b);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_f32_s32 (int32x4_t __a, const int __b)
+vclt_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return __builtin_aarch64_scvtfv4si (__a, __b);
+  return (uint32x2_t) (__a < __b);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_f32_u32 (uint32x4_t __a, const int __b)
+vclt_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return __builtin_aarch64_ucvtfv4si_sus (__a, __b);
+  return (uint64x1_t) (__a < __b);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_f64_s64 (int64x2_t __a, const int __b)
+vclt_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return __builtin_aarch64_scvtfv2di (__a, __b);
+  return (__a < __b);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_f64_u64 (uint64x2_t __a, const int __b)
+vclt_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return __builtin_aarch64_ucvtfv2di_sus (__a, __b);
+  return (__a < __b);
 }
 
-/* vcvt (float -> <u>fixed-point).  */
-
-__extension__ extern __inline int64_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_n_s64_f64 (float64_t __a, const int __b)
+vclt_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return __builtin_aarch64_fcvtzsdf (__a, __b);
+  return (__a < __b);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_n_u64_f64 (float64_t __a, const int __b)
+vclt_u64 (uint64x1_t __a, uint64x1_t __b)
 {
-  return __builtin_aarch64_fcvtzudf_uss (__a, __b);
+  return (__a < __b);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_n_s32_f32 (float32_t __a, const int __b)
+vcltq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return __builtin_aarch64_fcvtzssf (__a, __b);
+  return (uint32x4_t) (__a < __b);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_n_u32_f32 (float32_t __a, const int __b)
+vcltq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return __builtin_aarch64_fcvtzusf_uss (__a, __b);
+  return (uint64x2_t) (__a < __b);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_s32_f32 (float32x2_t __a, const int __b)
+vcltq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return __builtin_aarch64_fcvtzsv2sf (__a, __b);
+  return (uint8x16_t) (__a < __b);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_u32_f32 (float32x2_t __a, const int __b)
+vcltq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return __builtin_aarch64_fcvtzuv2sf_uss (__a, __b);
+  return (uint16x8_t) (__a < __b);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_s64_f64 (float64x1_t __a, const int __b)
+vcltq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int64x1_t)
-    { __builtin_aarch64_fcvtzsdf (vget_lane_f64 (__a, 0), __b) };
+  return (uint32x4_t) (__a < __b);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_n_u64_f64 (float64x1_t __a, const int __b)
+vcltq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (uint64x1_t)
-    { __builtin_aarch64_fcvtzudf_uss (vget_lane_f64 (__a, 0), __b) };
+  return (uint64x2_t) (__a < __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_s32_f32 (float32x4_t __a, const int __b)
+vcltq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return __builtin_aarch64_fcvtzsv4sf (__a, __b);
+  return (__a < __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_u32_f32 (float32x4_t __a, const int __b)
+vcltq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return __builtin_aarch64_fcvtzuv4sf_uss (__a, __b);
+  return (__a < __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_s64_f64 (float64x2_t __a, const int __b)
+vcltq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return __builtin_aarch64_fcvtzsv2df (__a, __b);
+  return (__a < __b);
 }
 
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_n_u64_f64 (float64x2_t __a, const int __b)
+vcltq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return __builtin_aarch64_fcvtzuv2df_uss (__a, __b);
+  return (__a < __b);
 }
 
-/* vcvt  (<u>int -> float)  */
+/* vclt - scalar.  */
 
-__extension__ extern __inline float64_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_f64_s64 (int64_t __a)
+vclts_f32 (float32_t __a, float32_t __b)
 {
-  return (float64_t) __a;
+  return __a < __b ? -1 : 0;
 }
 
-__extension__ extern __inline float64_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_f64_u64 (uint64_t __a)
+vcltd_s64 (int64_t __a, int64_t __b)
 {
-  return (float64_t) __a;
+  return __a < __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline float32_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_f32_s32 (int32_t __a)
+vcltd_u64 (uint64_t __a, uint64_t __b)
 {
-  return (float32_t) __a;
+  return __a < __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline float32_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_f32_u32 (uint32_t __a)
+vcltd_f64 (float64_t __a, float64_t __b)
 {
-  return (float32_t) __a;
+  return __a < __b ? -1ll : 0ll;
 }
 
-__extension__ extern __inline float32x2_t
+/* vcltz - vector.  */
+
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f32_s32 (int32x2_t __a)
+vcltz_f32 (float32x2_t __a)
 {
-  return __builtin_aarch64_floatv2siv2sf (__a);
+  return (uint32x2_t) (__a < 0.0f);
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f32_u32 (uint32x2_t __a)
+vcltz_f64 (float64x1_t __a)
 {
-  return __builtin_aarch64_floatunsv2siv2sf ((int32x2_t) __a);
+  return (uint64x1_t) (__a < (float64x1_t) {0.0});
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f64_s64 (int64x1_t __a)
+vcltz_s8 (int8x8_t __a)
 {
-  return (float64x1_t) { vget_lane_s64 (__a, 0) };
+  return (uint8x8_t) (__a < 0);
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_f64_u64 (uint64x1_t __a)
+vcltz_s16 (int16x4_t __a)
 {
-  return (float64x1_t) { vget_lane_u64 (__a, 0) };
+  return (uint16x4_t) (__a < 0);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_f32_s32 (int32x4_t __a)
+vcltz_s32 (int32x2_t __a)
 {
-  return __builtin_aarch64_floatv4siv4sf (__a);
+  return (uint32x2_t) (__a < 0);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_f32_u32 (uint32x4_t __a)
+vcltz_s64 (int64x1_t __a)
 {
-  return __builtin_aarch64_floatunsv4siv4sf ((int32x4_t) __a);
+  return (uint64x1_t) (__a < __AARCH64_INT64_C (0));
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_f64_s64 (int64x2_t __a)
+vcltzq_f32 (float32x4_t __a)
 {
-  return __builtin_aarch64_floatv2div2df (__a);
+  return (uint32x4_t) (__a < 0.0f);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_f64_u64 (uint64x2_t __a)
+vcltzq_f64 (float64x2_t __a)
 {
-  return __builtin_aarch64_floatunsv2div2df ((int64x2_t) __a);
+  return (uint64x2_t) (__a < 0.0);
 }
 
-/* vcvt (float -> <u>int)  */
+__extension__ extern __inline uint8x16_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vcltzq_s8 (int8x16_t __a)
+{
+  return (uint8x16_t) (__a < 0);
+}
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_s64_f64 (float64_t __a)
+vcltzq_s16 (int16x8_t __a)
 {
-  return (int64_t) __a;
+  return (uint16x8_t) (__a < 0);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_s32_f64 (float64_t __a)
+vcltzq_s32 (int32x4_t __a)
 {
-  return (int32_t) __a;
+  return (uint32x4_t) (__a < 0);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_u64_f64 (float64_t __a)
+vcltzq_s64 (int64x2_t __a)
 {
-  return (uint64_t) __a;
+  return (uint64x2_t) (__a < __AARCH64_INT64_C (0));
 }
 
+/* vcltz - scalar.  */
+
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtd_u32_f64 (float64_t __a)
+vcltzs_f32 (float32_t __a)
 {
-  return (uint32_t) __a;
+  return __a < 0.0f ? -1 : 0;
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_s32_f32 (float32_t __a)
+vcltzd_s64 (int64_t __a)
 {
-  return (int32_t) __a;
+  return __a < 0 ? -1ll : 0ll;
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_s64_f32 (float32_t __a)
+vcltzd_f64 (float64_t __a)
 {
-  return (int64_t) __a;
+  return __a < 0.0 ? -1ll : 0ll;
 }
 
-__extension__ extern __inline uint32_t
+/* vcls.  */
+
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_u32_f32 (float32_t __a)
+vcls_s8 (int8x8_t __a)
 {
-  return (uint32_t) __a;
+  return __builtin_aarch64_clrsbv8qi (__a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvts_u64_f32 (float32_t __a)
+vcls_s16 (int16x4_t __a)
 {
-  return (uint64_t) __a;
+  return __builtin_aarch64_clrsbv4hi (__a);
 }
 
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_s32_f32 (float32x2_t __a)
+vcls_s32 (int32x2_t __a)
 {
-  return __builtin_aarch64_lbtruncv2sfv2si (__a);
+  return __builtin_aarch64_clrsbv2si (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_u32_f32 (float32x2_t __a)
+vclsq_s8 (int8x16_t __a)
 {
-  return __builtin_aarch64_lbtruncuv2sfv2si_us (__a);
+  return __builtin_aarch64_clrsbv16qi (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_s32_f32 (float32x4_t __a)
+vclsq_s16 (int16x8_t __a)
 {
-  return __builtin_aarch64_lbtruncv4sfv4si (__a);
+  return __builtin_aarch64_clrsbv8hi (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_u32_f32 (float32x4_t __a)
+vclsq_s32 (int32x4_t __a)
 {
-  return __builtin_aarch64_lbtruncuv4sfv4si_us (__a);
+  return __builtin_aarch64_clrsbv4si (__a);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_s64_f64 (float64x1_t __a)
+vcls_u8 (uint8x8_t __a)
 {
-  return (int64x1_t) {vcvtd_s64_f64 (__a[0])};
+  return __builtin_aarch64_clrsbv8qi ((int8x8_t) __a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvt_u64_f64 (float64x1_t __a)
+vcls_u16 (uint16x4_t __a)
 {
-  return (uint64x1_t) {vcvtd_u64_f64 (__a[0])};
+  return __builtin_aarch64_clrsbv4hi ((int16x4_t) __a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_s64_f64 (float64x2_t __a)
+vcls_u32 (uint32x2_t __a)
 {
-  return __builtin_aarch64_lbtruncv2dfv2di (__a);
+  return __builtin_aarch64_clrsbv2si ((int32x2_t) __a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtq_u64_f64 (float64x2_t __a)
+vclsq_u8 (uint8x16_t __a)
 {
-  return __builtin_aarch64_lbtruncuv2dfv2di_us (__a);
+  return __builtin_aarch64_clrsbv16qi ((int8x16_t) __a);
 }
 
-/* vcvta  */
-
-__extension__ extern __inline int64_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtad_s64_f64 (float64_t __a)
+vclsq_u16 (uint16x8_t __a)
 {
-  return __builtin_aarch64_lrounddfdi (__a);
+  return __builtin_aarch64_clrsbv8hi ((int16x8_t) __a);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtad_s32_f64 (float64_t __a)
+vclsq_u32 (uint32x4_t __a)
 {
-  return __builtin_aarch64_lrounddfsi (__a);
+  return __builtin_aarch64_clrsbv4si ((int32x4_t) __a);
 }
 
-__extension__ extern __inline uint64_t
+/* vclz.  */
+
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtad_u64_f64 (float64_t __a)
+vclz_s8 (int8x8_t __a)
 {
-  return __builtin_aarch64_lroundudfdi_us (__a);
+  return __builtin_aarch64_clzv8qi (__a);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtad_u32_f64 (float64_t __a)
+vclz_s16 (int16x4_t __a)
 {
-  return __builtin_aarch64_lroundudfsi_us (__a);
+  return __builtin_aarch64_clzv4hi (__a);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtas_s32_f32 (float32_t __a)
+vclz_s32 (int32x2_t __a)
 {
-  return __builtin_aarch64_lroundsfsi (__a);
+  return __builtin_aarch64_clzv2si (__a);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtas_s64_f32 (float32_t __a)
+vclz_u8 (uint8x8_t __a)
 {
-  return __builtin_aarch64_lroundsfdi (__a);
+  return (uint8x8_t)__builtin_aarch64_clzv8qi ((int8x8_t)__a);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtas_u32_f32 (float32_t __a)
+vclz_u16 (uint16x4_t __a)
 {
-  return __builtin_aarch64_lroundusfsi_us (__a);
+  return (uint16x4_t)__builtin_aarch64_clzv4hi ((int16x4_t)__a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtas_u64_f32 (float32_t __a)
+vclz_u32 (uint32x2_t __a)
 {
-  return __builtin_aarch64_lroundusfdi_us (__a);
+  return (uint32x2_t)__builtin_aarch64_clzv2si ((int32x2_t)__a);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvta_s32_f32 (float32x2_t __a)
+vclzq_s8 (int8x16_t __a)
 {
-  return __builtin_aarch64_lroundv2sfv2si (__a);
+  return __builtin_aarch64_clzv16qi (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvta_u32_f32 (float32x2_t __a)
+vclzq_s16 (int16x8_t __a)
 {
-  return __builtin_aarch64_lrounduv2sfv2si_us (__a);
+  return __builtin_aarch64_clzv8hi (__a);
 }
 
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtaq_s32_f32 (float32x4_t __a)
+vclzq_s32 (int32x4_t __a)
 {
-  return __builtin_aarch64_lroundv4sfv4si (__a);
+  return __builtin_aarch64_clzv4si (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtaq_u32_f32 (float32x4_t __a)
+vclzq_u8 (uint8x16_t __a)
 {
-  return __builtin_aarch64_lrounduv4sfv4si_us (__a);
+  return (uint8x16_t)__builtin_aarch64_clzv16qi ((int8x16_t)__a);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvta_s64_f64 (float64x1_t __a)
+vclzq_u16 (uint16x8_t __a)
 {
-  return (int64x1_t) {vcvtad_s64_f64 (__a[0])};
+  return (uint16x8_t)__builtin_aarch64_clzv8hi ((int16x8_t)__a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvta_u64_f64 (float64x1_t __a)
+vclzq_u32 (uint32x4_t __a)
 {
-  return (uint64x1_t) {vcvtad_u64_f64 (__a[0])};
+  return (uint32x4_t)__builtin_aarch64_clzv4si ((int32x4_t)__a);
 }
 
-__extension__ extern __inline int64x2_t
+/* vcnt.  */
+
+__extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtaq_s64_f64 (float64x2_t __a)
+vcnt_p8 (poly8x8_t __a)
 {
-  return __builtin_aarch64_lroundv2dfv2di (__a);
+  return (poly8x8_t) __builtin_aarch64_popcountv8qi ((int8x8_t) __a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtaq_u64_f64 (float64x2_t __a)
+vcnt_s8 (int8x8_t __a)
 {
-  return __builtin_aarch64_lrounduv2dfv2di_us (__a);
+  return __builtin_aarch64_popcountv8qi (__a);
 }
 
-/* vcvtm  */
-
-__extension__ extern __inline int64_t
+__extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmd_s64_f64 (float64_t __a)
+vcnt_u8 (uint8x8_t __a)
 {
-  return __builtin_llfloor (__a);
+  return (uint8x8_t) __builtin_aarch64_popcountv8qi ((int8x8_t) __a);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline poly8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmd_s32_f64 (float64_t __a)
+vcntq_p8 (poly8x16_t __a)
 {
-  return __builtin_aarch64_lfloordfsi (__a);
+  return (poly8x16_t) __builtin_aarch64_popcountv16qi ((int8x16_t) __a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmd_u64_f64 (float64_t __a)
+vcntq_s8 (int8x16_t __a)
 {
-  return __builtin_aarch64_lfloorudfdi_us (__a);
+  return __builtin_aarch64_popcountv16qi (__a);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmd_u32_f64 (float64_t __a)
+vcntq_u8 (uint8x16_t __a)
 {
-  return __builtin_aarch64_lfloorudfsi_us (__a);
+  return (uint8x16_t) __builtin_aarch64_popcountv16qi ((int8x16_t) __a);
 }
 
-__extension__ extern __inline int32_t
+/* vcvt (double -> float).  */
+
+__extension__ extern __inline float16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtms_s32_f32 (float32_t __a)
+vcvt_f16_f32 (float32x4_t __a)
 {
-  return __builtin_ifloorf (__a);
+  return __builtin_aarch64_float_truncate_lo_v4hf (__a);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline float16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtms_s64_f32 (float32_t __a)
+vcvt_high_f16_f32 (float16x4_t __a, float32x4_t __b)
 {
-  return __builtin_aarch64_lfloorsfdi (__a);
+  return __builtin_aarch64_float_truncate_hi_v8hf (__a, __b);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtms_u32_f32 (float32_t __a)
+vcvt_f32_f64 (float64x2_t __a)
 {
-  return __builtin_aarch64_lfloorusfsi_us (__a);
+  return __builtin_aarch64_float_truncate_lo_v2sf (__a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtms_u64_f32 (float32_t __a)
+vcvt_high_f32_f64 (float32x2_t __a, float64x2_t __b)
 {
-  return __builtin_aarch64_lfloorusfdi_us (__a);
+  return __builtin_aarch64_float_truncate_hi_v4sf (__a, __b);
 }
 
-__extension__ extern __inline int32x2_t
+/* vcvt (float -> double).  */
+
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtm_s32_f32 (float32x2_t __a)
+vcvt_f32_f16 (float16x4_t __a)
 {
-  return __builtin_aarch64_lfloorv2sfv2si (__a);
+  return __builtin_aarch64_float_extend_lo_v4sf (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtm_u32_f32 (float32x2_t __a)
+vcvt_f64_f32 (float32x2_t __a)
 {
-  return __builtin_aarch64_lflooruv2sfv2si_us (__a);
+
+  return __builtin_aarch64_float_extend_lo_v2df (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmq_s32_f32 (float32x4_t __a)
+vcvt_high_f32_f16 (float16x8_t __a)
 {
-  return __builtin_aarch64_lfloorv4sfv4si (__a);
+  return __builtin_aarch64_vec_unpacks_hi_v8hf (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmq_u32_f32 (float32x4_t __a)
+vcvt_high_f64_f32 (float32x4_t __a)
 {
-  return __builtin_aarch64_lflooruv4sfv4si_us (__a);
+  return __builtin_aarch64_vec_unpacks_hi_v4sf (__a);
 }
 
-__extension__ extern __inline int64x1_t
+/* vcvt (<u>fixed-point -> float).  */
+
+__extension__ extern __inline float64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtm_s64_f64 (float64x1_t __a)
+vcvtd_n_f64_s64 (int64_t __a, const int __b)
 {
-  return (int64x1_t) {vcvtmd_s64_f64 (__a[0])};
+  return __builtin_aarch64_scvtfdi (__a, __b);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline float64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtm_u64_f64 (float64x1_t __a)
+vcvtd_n_f64_u64 (uint64_t __a, const int __b)
 {
-  return (uint64x1_t) {vcvtmd_u64_f64 (__a[0])};
+  return __builtin_aarch64_ucvtfdi_sus (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmq_s64_f64 (float64x2_t __a)
+vcvts_n_f32_s32 (int32_t __a, const int __b)
 {
-  return __builtin_aarch64_lfloorv2dfv2di (__a);
+  return __builtin_aarch64_scvtfsi (__a, __b);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtmq_u64_f64 (float64x2_t __a)
+vcvts_n_f32_u32 (uint32_t __a, const int __b)
 {
-  return __builtin_aarch64_lflooruv2dfv2di_us (__a);
+  return __builtin_aarch64_ucvtfsi_sus (__a, __b);
 }
 
-/* vcvtn  */
-
-__extension__ extern __inline int64_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnd_s64_f64 (float64_t __a)
+vcvt_n_f32_s32 (int32x2_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintndfdi (__a);
+  return __builtin_aarch64_scvtfv2si (__a, __b);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnd_s32_f64 (float64_t __a)
+vcvt_n_f32_u32 (uint32x2_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintndfsi (__a);
+  return __builtin_aarch64_ucvtfv2si_sus (__a, __b);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline float64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnd_u64_f64 (float64_t __a)
+vcvt_n_f64_s64 (int64x1_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnudfdi_us (__a);
+  return (float64x1_t)
+    { __builtin_aarch64_scvtfdi (vget_lane_s64 (__a, 0), __b) };
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline float64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnd_u32_f64 (float64_t __a)
+vcvt_n_f64_u64 (uint64x1_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnudfsi_us (__a);
+  return (float64x1_t)
+    { __builtin_aarch64_ucvtfdi_sus (vget_lane_u64 (__a, 0), __b) };
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtns_s32_f32 (float32_t __a)
+vcvtq_n_f32_s32 (int32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnsfsi (__a);
+  return __builtin_aarch64_scvtfv4si (__a, __b);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtns_s64_f32 (float32_t __a)
+vcvtq_n_f32_u32 (uint32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnsfdi (__a);
+  return __builtin_aarch64_ucvtfv4si_sus (__a, __b);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtns_u32_f32 (float32_t __a)
+vcvtq_n_f64_s64 (int64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnusfsi_us (__a);
+  return __builtin_aarch64_scvtfv2di (__a, __b);
 }
-__extension__ extern __inline uint64_t
+
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtns_u64_f32 (float32_t __a)
+vcvtq_n_f64_u64 (uint64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnusfdi_us (__a);
+  return __builtin_aarch64_ucvtfv2di_sus (__a, __b);
 }
 
-__extension__ extern __inline int32x2_t
+/* vcvt (float -> <u>fixed-point).  */
+
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtn_s32_f32 (float32x2_t __a)
+vcvtd_n_s64_f64 (float64_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnv2sfv2si (__a);
+  return __builtin_aarch64_fcvtzsdf (__a, __b);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtn_u32_f32 (float32x2_t __a)
+vcvtd_n_u64_f64 (float64_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnuv2sfv2si_us (__a);
+  return __builtin_aarch64_fcvtzudf_uss (__a, __b);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnq_s32_f32 (float32x4_t __a)
+vcvts_n_s32_f32 (float32_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnv4sfv4si (__a);
+  return __builtin_aarch64_fcvtzssf (__a, __b);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnq_u32_f32 (float32x4_t __a)
+vcvts_n_u32_f32 (float32_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnuv4sfv4si_us (__a);
+  return __builtin_aarch64_fcvtzusf_uss (__a, __b);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtn_s64_f64 (float64x1_t __a)
+vcvt_n_s32_f32 (float32x2_t __a, const int __b)
 {
-  return (int64x1_t) {vcvtnd_s64_f64 (__a[0])};
+  return __builtin_aarch64_fcvtzsv2sf (__a, __b);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtn_u64_f64 (float64x1_t __a)
+vcvt_n_u32_f32 (float32x2_t __a, const int __b)
 {
-  return (uint64x1_t) {vcvtnd_u64_f64 (__a[0])};
+  return __builtin_aarch64_fcvtzuv2sf_uss (__a, __b);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnq_s64_f64 (float64x2_t __a)
+vcvt_n_s64_f64 (float64x1_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnv2dfv2di (__a);
+  return (int64x1_t)
+    { __builtin_aarch64_fcvtzsdf (vget_lane_f64 (__a, 0), __b) };
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtnq_u64_f64 (float64x2_t __a)
+vcvt_n_u64_f64 (float64x1_t __a, const int __b)
 {
-  return __builtin_aarch64_lfrintnuv2dfv2di_us (__a);
+  return (uint64x1_t)
+    { __builtin_aarch64_fcvtzudf_uss (vget_lane_f64 (__a, 0), __b) };
 }
 
-/* vcvtp  */
-
-__extension__ extern __inline int64_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpd_s64_f64 (float64_t __a)
+vcvtq_n_s32_f32 (float32x4_t __a, const int __b)
 {
-  return __builtin_llceil (__a);
+  return __builtin_aarch64_fcvtzsv4sf (__a, __b);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpd_s32_f64 (float64_t __a)
+vcvtq_n_u32_f32 (float32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_lceildfsi (__a);
+  return __builtin_aarch64_fcvtzuv4sf_uss (__a, __b);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpd_u64_f64 (float64_t __a)
+vcvtq_n_s64_f64 (float64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_lceiludfdi_us (__a);
+  return __builtin_aarch64_fcvtzsv2df (__a, __b);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpd_u32_f64 (float64_t __a)
+vcvtq_n_u64_f64 (float64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_lceiludfsi_us (__a);
+  return __builtin_aarch64_fcvtzuv2df_uss (__a, __b);
 }
 
-__extension__ extern __inline int32_t
+/* vcvt  (<u>int -> float)  */
+
+__extension__ extern __inline float64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtps_s32_f32 (float32_t __a)
+vcvtd_f64_s64 (int64_t __a)
 {
-  return __builtin_iceilf (__a);
+  return (float64_t) __a;
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline float64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtps_s64_f32 (float32_t __a)
+vcvtd_f64_u64 (uint64_t __a)
 {
-  return __builtin_aarch64_lceilsfdi (__a);
+  return (float64_t) __a;
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtps_u32_f32 (float32_t __a)
+vcvts_f32_s32 (int32_t __a)
 {
-  return __builtin_aarch64_lceilusfsi_us (__a);
+  return (float32_t) __a;
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline float32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtps_u64_f32 (float32_t __a)
+vcvts_f32_u32 (uint32_t __a)
 {
-  return __builtin_aarch64_lceilusfdi_us (__a);
+  return (float32_t) __a;
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtp_s32_f32 (float32x2_t __a)
+vcvt_f32_s32 (int32x2_t __a)
 {
-  return __builtin_aarch64_lceilv2sfv2si (__a);
+  return __builtin_aarch64_floatv2siv2sf (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtp_u32_f32 (float32x2_t __a)
+vcvt_f32_u32 (uint32x2_t __a)
 {
-  return __builtin_aarch64_lceiluv2sfv2si_us (__a);
+  return __builtin_aarch64_floatunsv2siv2sf ((int32x2_t) __a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline float64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpq_s32_f32 (float32x4_t __a)
+vcvt_f64_s64 (int64x1_t __a)
 {
-  return __builtin_aarch64_lceilv4sfv4si (__a);
+  return (float64x1_t) { vget_lane_s64 (__a, 0) };
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline float64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpq_u32_f32 (float32x4_t __a)
+vcvt_f64_u64 (uint64x1_t __a)
 {
-  return __builtin_aarch64_lceiluv4sfv4si_us (__a);
+  return (float64x1_t) { vget_lane_u64 (__a, 0) };
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtp_s64_f64 (float64x1_t __a)
+vcvtq_f32_s32 (int32x4_t __a)
 {
-  return (int64x1_t) {vcvtpd_s64_f64 (__a[0])};
+  return __builtin_aarch64_floatv4siv4sf (__a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline float32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtp_u64_f64 (float64x1_t __a)
+vcvtq_f32_u32 (uint32x4_t __a)
 {
-  return (uint64x1_t) {vcvtpd_u64_f64 (__a[0])};
+  return __builtin_aarch64_floatunsv4siv4sf ((int32x4_t) __a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpq_s64_f64 (float64x2_t __a)
+vcvtq_f64_s64 (int64x2_t __a)
 {
-  return __builtin_aarch64_lceilv2dfv2di (__a);
+  return __builtin_aarch64_floatv2div2df (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline float64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcvtpq_u64_f64 (float64x2_t __a)
+vcvtq_f64_u64 (uint64x2_t __a)
 {
-  return __builtin_aarch64_lceiluv2dfv2di_us (__a);
+  return __builtin_aarch64_floatunsv2div2df ((int64x2_t) __a);
 }
 
-/* vdup_lane  */
+/* vcvt (float -> <u>int)  */
 
-__extension__ extern __inline float16x4_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_f16 (float16x4_t __a, const int __b)
+vcvtd_s64_f64 (float64_t __a)
 {
-  return __aarch64_vdup_lane_f16 (__a, __b);
+  return (int64_t) __a;
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_f32 (float32x2_t __a, const int __b)
+vcvtd_s32_f64 (float64_t __a)
 {
-  return __aarch64_vdup_lane_f32 (__a, __b);
+  return (int32_t) __a;
 }
 
-__extension__ extern __inline float64x1_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_f64 (float64x1_t __a, const int __b)
+vcvtd_u64_f64 (float64_t __a)
 {
-  return __aarch64_vdup_lane_f64 (__a, __b);
+  return (uint64_t) __a;
 }
 
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_p8 (poly8x8_t __a, const int __b)
+vcvtd_u32_f64 (float64_t __a)
 {
-  return __aarch64_vdup_lane_p8 (__a, __b);
+  return (uint32_t) __a;
 }
 
-__extension__ extern __inline poly16x4_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_p16 (poly16x4_t __a, const int __b)
+vcvts_s32_f32 (float32_t __a)
 {
-  return __aarch64_vdup_lane_p16 (__a, __b);
+  return (int32_t) __a;
 }
 
-__extension__ extern __inline poly64x1_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_p64 (poly64x1_t __a, const int __b)
+vcvts_s64_f32 (float32_t __a)
 {
-  return __aarch64_vdup_lane_p64 (__a, __b);
+  return (int64_t) __a;
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_s8 (int8x8_t __a, const int __b)
+vcvts_u32_f32 (float32_t __a)
 {
-  return __aarch64_vdup_lane_s8 (__a, __b);
+  return (uint32_t) __a;
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_s16 (int16x4_t __a, const int __b)
+vcvts_u64_f32 (float32_t __a)
 {
-  return __aarch64_vdup_lane_s16 (__a, __b);
+  return (uint64_t) __a;
 }
 
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_s32 (int32x2_t __a, const int __b)
+vcvt_s32_f32 (float32x2_t __a)
 {
-  return __aarch64_vdup_lane_s32 (__a, __b);
+  return __builtin_aarch64_lbtruncv2sfv2si (__a);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_s64 (int64x1_t __a, const int __b)
+vcvt_u32_f32 (float32x2_t __a)
 {
-  return __aarch64_vdup_lane_s64 (__a, __b);
+  return __builtin_aarch64_lbtruncuv2sfv2si_us (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_u8 (uint8x8_t __a, const int __b)
+vcvtq_s32_f32 (float32x4_t __a)
 {
-  return __aarch64_vdup_lane_u8 (__a, __b);
+  return __builtin_aarch64_lbtruncv4sfv4si (__a);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_u16 (uint16x4_t __a, const int __b)
+vcvtq_u32_f32 (float32x4_t __a)
 {
-  return __aarch64_vdup_lane_u16 (__a, __b);
+  return __builtin_aarch64_lbtruncuv4sfv4si_us (__a);
 }
 
-__extension__ extern __inline uint32x2_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_u32 (uint32x2_t __a, const int __b)
+vcvt_s64_f64 (float64x1_t __a)
 {
-  return __aarch64_vdup_lane_u32 (__a, __b);
+  return (int64x1_t) {vcvtd_s64_f64 (__a[0])};
 }
 
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_u64 (uint64x1_t __a, const int __b)
+vcvt_u64_f64 (float64x1_t __a)
 {
-  return __aarch64_vdup_lane_u64 (__a, __b);
+  return (uint64x1_t) {vcvtd_u64_f64 (__a[0])};
 }
 
-/* vdup_laneq  */
-
-__extension__ extern __inline float16x4_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_f16 (float16x8_t __a, const int __b)
+vcvtq_s64_f64 (float64x2_t __a)
 {
-  return __aarch64_vdup_laneq_f16 (__a, __b);
+  return __builtin_aarch64_lbtruncv2dfv2di (__a);
 }
 
-__extension__ extern __inline float32x2_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_f32 (float32x4_t __a, const int __b)
+vcvtq_u64_f64 (float64x2_t __a)
 {
-  return __aarch64_vdup_laneq_f32 (__a, __b);
+  return __builtin_aarch64_lbtruncuv2dfv2di_us (__a);
 }
 
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_f64 (float64x2_t __a, const int __b)
-{
-  return __aarch64_vdup_laneq_f64 (__a, __b);
-}
+/* vcvta  */
 
-__extension__ extern __inline poly8x8_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_p8 (poly8x16_t __a, const int __b)
+vcvtad_s64_f64 (float64_t __a)
 {
-  return __aarch64_vdup_laneq_p8 (__a, __b);
+  return __builtin_aarch64_lrounddfdi (__a);
 }
 
-__extension__ extern __inline poly16x4_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_p16 (poly16x8_t __a, const int __b)
+vcvtad_s32_f64 (float64_t __a)
 {
-  return __aarch64_vdup_laneq_p16 (__a, __b);
+  return __builtin_aarch64_lrounddfsi (__a);
 }
 
-__extension__ extern __inline poly64x1_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_p64 (poly64x2_t __a, const int __b)
+vcvtad_u64_f64 (float64_t __a)
 {
-  return __aarch64_vdup_laneq_p64 (__a, __b);
+  return __builtin_aarch64_lroundudfdi_us (__a);
 }
 
-__extension__ extern __inline int8x8_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_s8 (int8x16_t __a, const int __b)
+vcvtad_u32_f64 (float64_t __a)
 {
-  return __aarch64_vdup_laneq_s8 (__a, __b);
+  return __builtin_aarch64_lroundudfsi_us (__a);
 }
 
-__extension__ extern __inline int16x4_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_s16 (int16x8_t __a, const int __b)
+vcvtas_s32_f32 (float32_t __a)
 {
-  return __aarch64_vdup_laneq_s16 (__a, __b);
+  return __builtin_aarch64_lroundsfsi (__a);
 }
 
-__extension__ extern __inline int32x2_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_s32 (int32x4_t __a, const int __b)
+vcvtas_s64_f32 (float32_t __a)
 {
-  return __aarch64_vdup_laneq_s32 (__a, __b);
+  return __builtin_aarch64_lroundsfdi (__a);
 }
 
-__extension__ extern __inline int64x1_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_s64 (int64x2_t __a, const int __b)
+vcvtas_u32_f32 (float32_t __a)
 {
-  return __aarch64_vdup_laneq_s64 (__a, __b);
+  return __builtin_aarch64_lroundusfsi_us (__a);
 }
 
-__extension__ extern __inline uint8x8_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_u8 (uint8x16_t __a, const int __b)
+vcvtas_u64_f32 (float32_t __a)
 {
-  return __aarch64_vdup_laneq_u8 (__a, __b);
+  return __builtin_aarch64_lroundusfdi_us (__a);
 }
 
-__extension__ extern __inline uint16x4_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_u16 (uint16x8_t __a, const int __b)
+vcvta_s32_f32 (float32x2_t __a)
 {
-  return __aarch64_vdup_laneq_u16 (__a, __b);
+  return __builtin_aarch64_lroundv2sfv2si (__a);
 }
 
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_u32 (uint32x4_t __a, const int __b)
+vcvta_u32_f32 (float32x2_t __a)
 {
-  return __aarch64_vdup_laneq_u32 (__a, __b);
+  return __builtin_aarch64_lrounduv2sfv2si_us (__a);
 }
 
-__extension__ extern __inline uint64x1_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_u64 (uint64x2_t __a, const int __b)
+vcvtaq_s32_f32 (float32x4_t __a)
 {
-  return __aarch64_vdup_laneq_u64 (__a, __b);
+  return __builtin_aarch64_lroundv4sfv4si (__a);
 }
 
-/* vdupq_lane  */
-
-__extension__ extern __inline float16x8_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_f16 (float16x4_t __a, const int __b)
+vcvtaq_u32_f32 (float32x4_t __a)
 {
-  return __aarch64_vdupq_lane_f16 (__a, __b);
+  return __builtin_aarch64_lrounduv4sfv4si_us (__a);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_f32 (float32x2_t __a, const int __b)
+vcvta_s64_f64 (float64x1_t __a)
 {
-  return __aarch64_vdupq_lane_f32 (__a, __b);
+  return (int64x1_t) {vcvtad_s64_f64 (__a[0])};
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_f64 (float64x1_t __a, const int __b)
+vcvta_u64_f64 (float64x1_t __a)
 {
-  return __aarch64_vdupq_lane_f64 (__a, __b);
+  return (uint64x1_t) {vcvtad_u64_f64 (__a[0])};
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_p8 (poly8x8_t __a, const int __b)
+vcvtaq_s64_f64 (float64x2_t __a)
 {
-  return __aarch64_vdupq_lane_p8 (__a, __b);
+  return __builtin_aarch64_lroundv2dfv2di (__a);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_p16 (poly16x4_t __a, const int __b)
+vcvtaq_u64_f64 (float64x2_t __a)
 {
-  return __aarch64_vdupq_lane_p16 (__a, __b);
+  return __builtin_aarch64_lrounduv2dfv2di_us (__a);
 }
 
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_p64 (poly64x1_t __a, const int __b)
-{
-  return __aarch64_vdupq_lane_p64 (__a, __b);
-}
+/* vcvtm  */
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_s8 (int8x8_t __a, const int __b)
+vcvtmd_s64_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_lane_s8 (__a, __b);
+  return __builtin_llfloor (__a);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_s16 (int16x4_t __a, const int __b)
+vcvtmd_s32_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_lane_s16 (__a, __b);
+  return __builtin_aarch64_lfloordfsi (__a);
 }
 
-__extension__ extern __inline int32x4_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_s32 (int32x2_t __a, const int __b)
+vcvtmd_u64_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_lane_s32 (__a, __b);
+  return __builtin_aarch64_lfloorudfdi_us (__a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_s64 (int64x1_t __a, const int __b)
+vcvtmd_u32_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_lane_s64 (__a, __b);
+  return __builtin_aarch64_lfloorudfsi_us (__a);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_u8 (uint8x8_t __a, const int __b)
+vcvtms_s32_f32 (float32_t __a)
 {
-  return __aarch64_vdupq_lane_u8 (__a, __b);
+  return __builtin_ifloorf (__a);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_u16 (uint16x4_t __a, const int __b)
+vcvtms_s64_f32 (float32_t __a)
 {
-  return __aarch64_vdupq_lane_u16 (__a, __b);
+  return __builtin_aarch64_lfloorsfdi (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_u32 (uint32x2_t __a, const int __b)
+vcvtms_u32_f32 (float32_t __a)
 {
-  return __aarch64_vdupq_lane_u32 (__a, __b);
+  return __builtin_aarch64_lfloorusfsi_us (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_u64 (uint64x1_t __a, const int __b)
+vcvtms_u64_f32 (float32_t __a)
 {
-  return __aarch64_vdupq_lane_u64 (__a, __b);
+  return __builtin_aarch64_lfloorusfdi_us (__a);
 }
 
-/* vdupq_laneq  */
-
-__extension__ extern __inline float16x8_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_f16 (float16x8_t __a, const int __b)
+vcvtm_s32_f32 (float32x2_t __a)
 {
-  return __aarch64_vdupq_laneq_f16 (__a, __b);
+  return __builtin_aarch64_lfloorv2sfv2si (__a);
 }
 
-__extension__ extern __inline float32x4_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_f32 (float32x4_t __a, const int __b)
+vcvtm_u32_f32 (float32x2_t __a)
 {
-  return __aarch64_vdupq_laneq_f32 (__a, __b);
+  return __builtin_aarch64_lflooruv2sfv2si_us (__a);
 }
 
-__extension__ extern __inline float64x2_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_f64 (float64x2_t __a, const int __b)
+vcvtmq_s32_f32 (float32x4_t __a)
 {
-  return __aarch64_vdupq_laneq_f64 (__a, __b);
+  return __builtin_aarch64_lfloorv4sfv4si (__a);
 }
 
-__extension__ extern __inline poly8x16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_p8 (poly8x16_t __a, const int __b)
+vcvtmq_u32_f32 (float32x4_t __a)
 {
-  return __aarch64_vdupq_laneq_p8 (__a, __b);
+  return __builtin_aarch64_lflooruv4sfv4si_us (__a);
 }
 
-__extension__ extern __inline poly16x8_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_p16 (poly16x8_t __a, const int __b)
+vcvtm_s64_f64 (float64x1_t __a)
 {
-  return __aarch64_vdupq_laneq_p16 (__a, __b);
+  return (int64x1_t) {vcvtmd_s64_f64 (__a[0])};
 }
 
-__extension__ extern __inline poly64x2_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_p64 (poly64x2_t __a, const int __b)
+vcvtm_u64_f64 (float64x1_t __a)
 {
-  return __aarch64_vdupq_laneq_p64 (__a, __b);
+  return (uint64x1_t) {vcvtmd_u64_f64 (__a[0])};
 }
 
-__extension__ extern __inline int8x16_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_s8 (int8x16_t __a, const int __b)
+vcvtmq_s64_f64 (float64x2_t __a)
 {
-  return __aarch64_vdupq_laneq_s8 (__a, __b);
+  return __builtin_aarch64_lfloorv2dfv2di (__a);
 }
 
-__extension__ extern __inline int16x8_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_s16 (int16x8_t __a, const int __b)
+vcvtmq_u64_f64 (float64x2_t __a)
 {
-  return __aarch64_vdupq_laneq_s16 (__a, __b);
+  return __builtin_aarch64_lflooruv2dfv2di_us (__a);
 }
 
-__extension__ extern __inline int32x4_t
+/* vcvtn  */
+
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_s32 (int32x4_t __a, const int __b)
+vcvtnd_s64_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_laneq_s32 (__a, __b);
+  return __builtin_aarch64_lfrintndfdi (__a);
 }
 
-__extension__ extern __inline int64x2_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_s64 (int64x2_t __a, const int __b)
+vcvtnd_s32_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_laneq_s64 (__a, __b);
+  return __builtin_aarch64_lfrintndfsi (__a);
 }
 
-__extension__ extern __inline uint8x16_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_u8 (uint8x16_t __a, const int __b)
+vcvtnd_u64_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_laneq_u8 (__a, __b);
+  return __builtin_aarch64_lfrintnudfdi_us (__a);
 }
 
-__extension__ extern __inline uint16x8_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_u16 (uint16x8_t __a, const int __b)
+vcvtnd_u32_f64 (float64_t __a)
 {
-  return __aarch64_vdupq_laneq_u16 (__a, __b);
+  return __builtin_aarch64_lfrintnudfsi_us (__a);
 }
 
-__extension__ extern __inline uint32x4_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_u32 (uint32x4_t __a, const int __b)
+vcvtns_s32_f32 (float32_t __a)
 {
-  return __aarch64_vdupq_laneq_u32 (__a, __b);
+  return __builtin_aarch64_lfrintnsfsi (__a);
 }
 
-__extension__ extern __inline uint64x2_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_u64 (uint64x2_t __a, const int __b)
+vcvtns_s64_f32 (float32_t __a)
 {
-  return __aarch64_vdupq_laneq_u64 (__a, __b);
+  return __builtin_aarch64_lfrintnsfdi (__a);
 }
 
-/* vdupb_lane  */
-__extension__ extern __inline poly8_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupb_lane_p8 (poly8x8_t __a, const int __b)
+vcvtns_u32_f32 (float32_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnusfsi_us (__a);
 }
-
-__extension__ extern __inline int8_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupb_lane_s8 (int8x8_t __a, const int __b)
+vcvtns_u64_f32 (float32_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnusfdi_us (__a);
 }
 
-__extension__ extern __inline uint8_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupb_lane_u8 (uint8x8_t __a, const int __b)
+vcvtn_s32_f32 (float32x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnv2sfv2si (__a);
 }
 
-/* vduph_lane  */
-
-__extension__ extern __inline float16_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_lane_f16 (float16x4_t __a, const int __b)
+vcvtn_u32_f32 (float32x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnuv2sfv2si_us (__a);
 }
 
-__extension__ extern __inline poly16_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_lane_p16 (poly16x4_t __a, const int __b)
+vcvtnq_s32_f32 (float32x4_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnv4sfv4si (__a);
 }
 
-__extension__ extern __inline int16_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_lane_s16 (int16x4_t __a, const int __b)
+vcvtnq_u32_f32 (float32x4_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnuv4sfv4si_us (__a);
 }
 
-__extension__ extern __inline uint16_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_lane_u16 (uint16x4_t __a, const int __b)
+vcvtn_s64_f64 (float64x1_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return (int64x1_t) {vcvtnd_s64_f64 (__a[0])};
 }
 
-/* vdups_lane  */
-
-__extension__ extern __inline float32_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdups_lane_f32 (float32x2_t __a, const int __b)
+vcvtn_u64_f64 (float64x1_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return (uint64x1_t) {vcvtnd_u64_f64 (__a[0])};
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdups_lane_s32 (int32x2_t __a, const int __b)
+vcvtnq_s64_f64 (float64x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnv2dfv2di (__a);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdups_lane_u32 (uint32x2_t __a, const int __b)
+vcvtnq_u64_f64 (float64x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lfrintnuv2dfv2di_us (__a);
 }
 
-/* vdupd_lane  */
-__extension__ extern __inline float64_t
+/* vcvtp  */
+
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupd_lane_f64 (float64x1_t __a, const int __b)
+vcvtpd_s64_f64 (float64_t __a)
 {
-  __AARCH64_LANE_CHECK (__a, __b);
-  return __a[0];
+  return __builtin_llceil (__a);
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupd_lane_s64 (int64x1_t __a, const int __b)
+vcvtpd_s32_f64 (float64_t __a)
 {
-  __AARCH64_LANE_CHECK (__a, __b);
-  return __a[0];
+  return __builtin_aarch64_lceildfsi (__a);
 }
 
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupd_lane_u64 (uint64x1_t __a, const int __b)
+vcvtpd_u64_f64 (float64_t __a)
 {
-  __AARCH64_LANE_CHECK (__a, __b);
-  return __a[0];
+  return __builtin_aarch64_lceiludfdi_us (__a);
 }
 
-/* vdupb_laneq  */
-__extension__ extern __inline poly8_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupb_laneq_p8 (poly8x16_t __a, const int __b)
+vcvtpd_u32_f64 (float64_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceiludfsi_us (__a);
 }
 
-__extension__ extern __inline int8_t
+__extension__ extern __inline int32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupb_laneq_s8 (int8x16_t __a, const int __b)
+vcvtps_s32_f32 (float32_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_iceilf (__a);
 }
 
-__extension__ extern __inline uint8_t
+__extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupb_laneq_u8 (uint8x16_t __a, const int __b)
+vcvtps_s64_f32 (float32_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceilsfdi (__a);
 }
 
-/* vduph_laneq  */
-
-__extension__ extern __inline float16_t
+__extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_laneq_f16 (float16x8_t __a, const int __b)
+vcvtps_u32_f32 (float32_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceilusfsi_us (__a);
 }
 
-__extension__ extern __inline poly16_t
+__extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_laneq_p16 (poly16x8_t __a, const int __b)
+vcvtps_u64_f32 (float32_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceilusfdi_us (__a);
 }
 
-__extension__ extern __inline int16_t
+__extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_laneq_s16 (int16x8_t __a, const int __b)
+vcvtp_s32_f32 (float32x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceilv2sfv2si (__a);
 }
 
-__extension__ extern __inline uint16_t
+__extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_laneq_u16 (uint16x8_t __a, const int __b)
+vcvtp_u32_f32 (float32x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceiluv2sfv2si_us (__a);
 }
 
-/* vdups_laneq  */
-
-__extension__ extern __inline float32_t
+__extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdups_laneq_f32 (float32x4_t __a, const int __b)
+vcvtpq_s32_f32 (float32x4_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceilv4sfv4si (__a);
 }
 
-__extension__ extern __inline int32_t
+__extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdups_laneq_s32 (int32x4_t __a, const int __b)
+vcvtpq_u32_f32 (float32x4_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceiluv4sfv4si_us (__a);
 }
 
-__extension__ extern __inline uint32_t
+__extension__ extern __inline int64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdups_laneq_u32 (uint32x4_t __a, const int __b)
+vcvtp_s64_f64 (float64x1_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return (int64x1_t) {vcvtpd_s64_f64 (__a[0])};
 }
 
-/* vdupd_laneq  */
-__extension__ extern __inline float64_t
+__extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupd_laneq_f64 (float64x2_t __a, const int __b)
+vcvtp_u64_f64 (float64x1_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return (uint64x1_t) {vcvtpd_u64_f64 (__a[0])};
 }
 
-__extension__ extern __inline int64_t
+__extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupd_laneq_s64 (int64x2_t __a, const int __b)
+vcvtpq_s64_f64 (float64x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceilv2dfv2di (__a);
 }
 
-__extension__ extern __inline uint64_t
+__extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupd_laneq_u64 (uint64x2_t __a, const int __b)
+vcvtpq_u64_f64 (float64x2_t __a)
 {
-  return __aarch64_vget_lane_any (__a, __b);
+  return __builtin_aarch64_lceiluv2dfv2di_us (__a);
 }
 
 /* vext  */
@@ -27146,76 +25585,6 @@ vrnd64xq_f64 (float64x2_t __a)
 #pragma GCC push_options
 #pragma GCC target ("+nothing+bf16")
 
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vset_lane_bf16 (bfloat16_t __elem, bfloat16x4_t __vec, const int __index)
-{
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
-}
-
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vsetq_lane_bf16 (bfloat16_t __elem, bfloat16x8_t __vec, const int __index)
-{
-  return __aarch64_vset_lane_any (__elem, __vec, __index);
-}
-
-__extension__ extern __inline bfloat16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vget_lane_bf16 (bfloat16x4_t __a, const int __b)
-{
-  return __aarch64_vget_lane_any (__a, __b);
-}
-
-__extension__ extern __inline bfloat16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vgetq_lane_bf16 (bfloat16x8_t __a, const int __b)
-{
-  return __aarch64_vget_lane_any (__a, __b);
-}
-
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_lane_bf16 (bfloat16x4_t __a, const int __b)
-{
-  return vdup_n_bf16 (__aarch64_vget_lane_any (__a, __b));
-}
-
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdup_laneq_bf16 (bfloat16x8_t __a, const int __b)
-{
-  return vdup_n_bf16 (__aarch64_vget_lane_any (__a, __b));
-}
-
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_lane_bf16 (bfloat16x4_t __a, const int __b)
-{
-  return vdupq_n_bf16 (__aarch64_vget_lane_any (__a, __b));
-}
-
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vdupq_laneq_bf16 (bfloat16x8_t __a, const int __b)
-{
-  return vdupq_n_bf16 (__aarch64_vget_lane_any (__a, __b));
-}
-
-__extension__ extern __inline bfloat16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_lane_bf16 (bfloat16x4_t __a, const int __b)
-{
-  return __aarch64_vget_lane_any (__a, __b);
-}
-
-__extension__ extern __inline bfloat16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vduph_laneq_bf16 (bfloat16x8_t __a, const int __b)
-{
-  return __aarch64_vget_lane_any (__a, __b);
-}
-
 /* vld */
 
 __extension__ extern __inline bfloat16x4_t
@@ -27642,42 +26011,6 @@ vcvtq_high_bf16_f32 (bfloat16x8_t __inactive, float32x4_t __a)
   return __builtin_aarch64_bfcvtn2v8bf (__inactive, __a);
 }
 
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_lane_bf16 (bfloat16x4_t __a, const int __lane1,
-                bfloat16x4_t __b, const int __lane2)
-{
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
-}
-
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_lane_bf16 (bfloat16x8_t __a, const int __lane1,
-                 bfloat16x4_t __b, const int __lane2)
-{
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
-}
-
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopy_laneq_bf16 (bfloat16x4_t __a, const int __lane1,
-                 bfloat16x8_t __b, const int __lane2)
-{
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
-}
-
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vcopyq_laneq_bf16 (bfloat16x8_t __a, const int __lane1,
-                  bfloat16x8_t __b, const int __lane2)
-{
-  return __aarch64_vset_lane_any (__aarch64_vget_lane_any (__b, __lane2),
-                                 __a, __lane1);
-}
-
 __extension__ extern __inline bfloat16x4x2_t
 __attribute__ ((__always_inline__, __gnu_inline__,__artificial__))
 vld2_lane_bf16 (const bfloat16_t * __ptr, bfloat16x4x2_t __b, const int __c)
@@ -27888,54 +26221,14 @@ vusmmlaq_s32 (int32x4_t __r, uint8x16_t __a, int8x16_t __b)
 #undef __aarch64_vdup_lane_f16
 #undef __aarch64_vdup_lane_f32
 #undef __aarch64_vdup_lane_f64
-#undef __aarch64_vdup_lane_p8
-#undef __aarch64_vdup_lane_p16
-#undef __aarch64_vdup_lane_s8
-#undef __aarch64_vdup_lane_s16
-#undef __aarch64_vdup_lane_s32
-#undef __aarch64_vdup_lane_s64
-#undef __aarch64_vdup_lane_u8
-#undef __aarch64_vdup_lane_u16
-#undef __aarch64_vdup_lane_u32
-#undef __aarch64_vdup_lane_u64
 #undef __aarch64_vdup_laneq_f16
 #undef __aarch64_vdup_laneq_f32
 #undef __aarch64_vdup_laneq_f64
-#undef __aarch64_vdup_laneq_p8
-#undef __aarch64_vdup_laneq_p16
-#undef __aarch64_vdup_laneq_s8
-#undef __aarch64_vdup_laneq_s16
-#undef __aarch64_vdup_laneq_s32
-#undef __aarch64_vdup_laneq_s64
-#undef __aarch64_vdup_laneq_u8
-#undef __aarch64_vdup_laneq_u16
-#undef __aarch64_vdup_laneq_u32
-#undef __aarch64_vdup_laneq_u64
 #undef __aarch64_vdupq_lane_f16
 #undef __aarch64_vdupq_lane_f32
 #undef __aarch64_vdupq_lane_f64
-#undef __aarch64_vdupq_lane_p8
-#undef __aarch64_vdupq_lane_p16
-#undef __aarch64_vdupq_lane_s8
-#undef __aarch64_vdupq_lane_s16
-#undef __aarch64_vdupq_lane_s32
-#undef __aarch64_vdupq_lane_s64
-#undef __aarch64_vdupq_lane_u8
-#undef __aarch64_vdupq_lane_u16
-#undef __aarch64_vdupq_lane_u32
-#undef __aarch64_vdupq_lane_u64
 #undef __aarch64_vdupq_laneq_f16
 #undef __aarch64_vdupq_laneq_f32
 #undef __aarch64_vdupq_laneq_f64
-#undef __aarch64_vdupq_laneq_p8
-#undef __aarch64_vdupq_laneq_p16
-#undef __aarch64_vdupq_laneq_s8
-#undef __aarch64_vdupq_laneq_s16
-#undef __aarch64_vdupq_laneq_s32
-#undef __aarch64_vdupq_laneq_s64
-#undef __aarch64_vdupq_laneq_u8
-#undef __aarch64_vdupq_laneq_u16
-#undef __aarch64_vdupq_laneq_u32
-#undef __aarch64_vdupq_laneq_u64
 
 #endif

diff --git a/gcc/config/aarch64/iterators.md b/gcc/config/aarch64/iterators.md
index 2d1522a348ac02d4ab27bdbc79f112651b8a9bf2..131b786942fa77be052e82e22f7772435e5e6085 100644 (file)
--- a/gcc/config/aarch64/iterators.md
+++ b/gcc/config/aarch64/iterators.md
@@ -266,7 +266,7 @@
 
 ;; The VALL_F16 modes except the 128-bit 2-element ones.
 (define_mode_iterator VALL_F16_NO_V2Q [V8QI V16QI V4HI V8HI V2SI V4SI
-                               V4HF V8HF V2SF V4SF])
+                               V4HF V8HF V4BF V8BF V2SF V4SF])
 
 ;; All Advanced SIMD modes barring HF modes, plus DI.
 (define_mode_iterator VALLDI [V8QI V16QI V4HI V8HI V2SI V4SI V2DI V2SF V4SF V2DF DI])

diff --git a/gcc/testsuite/g++.target/aarch64/lane-bound-1.C b/gcc/testsuite/g++.target/aarch64/lane-bound-1.C
index cb3e99816a1cf108c1eaf15f737dd34715ea1a2d..0312ad96986055182e0b050574eb4d663b3f8f00 100644 (file)
--- a/gcc/testsuite/g++.target/aarch64/lane-bound-1.C
+++ b/gcc/testsuite/g++.target/aarch64/lane-bound-1.C
@@ -12,7 +12,7 @@ void hh(uint64x2_t c, int __b)
 {
   try {
     vgetq_lane_u64(c, __b);
-    // { dg-error "must be a constant immediate" "" { target *-*-* } 0 }
+    // { dg-error "must be an integer constant expression" "" { target *-*-* } 0 }
   } catch (...)
   {
         removeme(); // { dg-bogus "declared with attribute error" }

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/bf16_vect_copy_lane_1.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/bf16_vect_copy_lane_1.c
index d5aa215c21a3f7086ec22a39a028b352e3cd5aca..b9d55d43f5c4c5371d1475e65f3e788e690521a0 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/bf16_vect_copy_lane_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/bf16_vect_copy_lane_1.c
@@ -28,5 +28,4 @@ test_vcopyq_laneq_bf16 (bfloat16x8_t a, bfloat16x8_t b)
   return vcopyq_laneq_bf16 (a, 1, b, 2);
 }
 
-/* { dg-final { scan-assembler-times "ins\\tv0.h\\\[1\\\], v1.h\\\[2\\\]" 2 } } */
-/* { dg-final { scan-assembler-times "ins\\tv0.h\\\[1\\\], v1.h\\\[0\\\]" 2 } } */
+/* { dg-final { scan-assembler-times "ins\\tv0.h\\\[1\\\], v1.h\\\[2\\\]" 4 } } */

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_1.c
deleted file mode 100644 (file)
index 7057980..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_1.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x4_t
-test_vcopy_lane_bf16 (bfloat16x4_t a, bfloat16x4_t b)
-{
-  bfloat16x4_t res;
-  res = vcopy_lane_bf16 (a, 0, b, 4);
-  res = vcopy_lane_bf16 (a, 0, b, -1);
-  return res;
-}
-
-/* { dg-error "lane -1 out of range 0 - 3" "" { target *-*-* } 0 } */
-/* { dg-error "lane 4 out of range 0 - 3" "" { target *-*-* } 0 } */

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_2.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_2.c
deleted file mode 100644 (file)
index a8ef930..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_bf16_indices_2.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x4_t
-test_vcopy_lane_bf16 (bfloat16x4_t a, bfloat16x4_t b)
-{
-  bfloat16x4_t res;
-  res = vcopy_lane_bf16 (a, -1, b, 2);
-  res = vcopy_lane_bf16 (a, 4, b, 2);
-  return res;
-}
-
-/* { dg-error "lane -1 out of range 0 - 3" "" { target *-*-* } 0 } */
-/* { dg-error "lane 4 out of range 0 - 3" "" { target *-*-* } 0 } */

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_indices.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_indices.c
new file mode 100644 (file)
index 0000000..a289659
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_lane_indices.c
@@ -0,0 +1,68 @@
+/* { dg-do assemble } */
+
+#include <arm_neon.h>
+
+#define VEC_LEN(VEC) (sizeof (VEC) / sizeof ((VEC)[0]))
+
+#define TEST_VCOPY_LANE(NAME, ARG1_TYPE, ARG2_TYPE) \
+  ARG1_TYPE test_##NAME (ARG1_TYPE arg1, ARG2_TYPE arg2) { return NAME (arg1, VEC_LEN (arg1), arg2, VEC_LEN (arg2)); }
+
+TEST_VCOPY_LANE (vcopy_lane_u8, uint8x8_t, uint8x8_t)         /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_s8, int8x8_t, int8x8_t)           /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_p8, poly8x8_t, poly8x8_t)         /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_u16, uint16x4_t, uint16x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_s16, int16x4_t, int16x4_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_p16, poly16x4_t, poly16x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_bf16, bfloat16x4_t, bfloat16x4_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_u32, uint32x2_t, uint32x2_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_s32, int32x2_t, int32x2_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_f32, float32x2_t, float32x2_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_u64, uint64x1_t, uint64x1_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_s64, int64x1_t, int64x1_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_f64, float64x1_t, float64x1_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_lane_p64, poly64x1_t, poly64x1_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VCOPY_LANE (vcopy_laneq_u8, uint8x8_t, uint8x16_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_s8, int8x8_t, int8x16_t)          /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_p8, poly8x8_t, poly8x16_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_u16, uint16x4_t, uint16x8_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_s16, int16x4_t, int16x8_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_p16, poly16x4_t, poly16x8_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_bf16, bfloat16x4_t, bfloat16x8_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_u32, uint32x2_t, uint32x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_s32, int32x2_t, int32x4_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_f32, float32x2_t, float32x4_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_u64, uint64x1_t, uint64x2_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_s64, int64x1_t, int64x2_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_f64, float64x1_t, float64x2_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopy_laneq_p64, poly64x1_t, poly64x2_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopy_laneq_[a-z0-9]+', [^\n]+} } */
+
+TEST_VCOPY_LANE (vcopyq_lane_u8, uint8x16_t, uint8x8_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_s8, int8x16_t, int8x8_t)          /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_p8, poly8x16_t, poly8x8_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_u16, uint16x8_t, uint16x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_s16, int16x8_t, int16x4_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_p16, poly16x8_t, poly16x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_bf16, bfloat16x8_t, bfloat16x4_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_u32, uint32x4_t, uint32x2_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_s32, int32x4_t, int32x2_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_f32, float32x4_t, float32x2_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_u64, uint64x2_t, uint64x1_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_s64, int64x2_t, int64x1_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_f64, float64x2_t, float64x1_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_lane_p64, poly64x2_t, poly64x1_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VCOPY_LANE (vcopyq_laneq_u8, uint8x16_t, uint8x16_t)       /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_s8, int8x16_t, int8x16_t)         /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_p8, poly8x16_t, poly8x16_t)       /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_u16, uint16x8_t, uint16x8_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_s16, int16x8_t, int16x8_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_p16, poly16x8_t, poly16x8_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_bf16, bfloat16x8_t, bfloat16x8_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_u32, uint32x4_t, uint32x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_s32, int32x4_t, int32x4_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_f32, float32x4_t, float32x4_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_u64, uint64x2_t, uint64x2_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_s64, int64x2_t, int64x2_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_f64, float64x2_t, float64x2_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */
+TEST_VCOPY_LANE (vcopyq_laneq_p64, poly64x2_t, poly64x2_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vcopyq_laneq_[a-z0-9]+', [^\n]+} } */

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_1.c
deleted file mode 100644 (file)
index c156204..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x4_t
-test_vcopy_laneq_bf16 (bfloat16x4_t a, bfloat16x8_t b)
-{
-  bfloat16x4_t res;
-  /* { dg-error "lane -1 out of range 0 - 3" "" { target *-*-* } 0 } */
-  res = vcopy_laneq_bf16 (a, -1, b, 2);
-  /* { dg-error "lane 4 out of range 0 - 3" "" { target *-*-* } 0 } */
-  res = vcopy_laneq_bf16 (a, 4, b, 2);
-  return res;
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_2.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_2.c
deleted file mode 100644 (file)
index 036690b..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopy_laneq_bf16_indices_2.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x4_t
-test_vcopy_laneq_bf16 (bfloat16x4_t a, bfloat16x8_t b)
-{
-  bfloat16x4_t res;
-  /* { dg-error "lane -1 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopy_laneq_bf16 (a, 1, b, -1);
-  /* { dg-error "lane 8 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopy_laneq_bf16 (a, 1, b, 8);
-  return res;
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_1.c
deleted file mode 100644 (file)
index 15fce1b..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x8_t
-test_vcopyq_lane_bf16 (bfloat16x8_t a, bfloat16x4_t b)
-{
-  bfloat16x8_t res;
-  /* { dg-error "lane -1 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopyq_lane_bf16 (a, -1, b, 2);
-  /* { dg-error "lane 8 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopyq_lane_bf16 (a, 8, b, 2);
-  return res;
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_2.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_2.c
deleted file mode 100644 (file)
index 6e8004a..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_lane_bf16_indices_2.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x8_t
-test_vcopyq_lane_bf16 (bfloat16x8_t a, bfloat16x4_t b)
-{
-  bfloat16x8_t res;
-  /* { dg-error "lane -1 out of range 0 - 3" "" { target *-*-* } 0 } */
-  res = vcopyq_lane_bf16 (a, 2, b, -1);
-  /* { dg-error "lane 4 out of range 0 - 3" "" { target *-*-* } 0 } */
-  res = vcopyq_lane_bf16 (a, 2, b, 4);
-  return res;
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_1.c
deleted file mode 100644 (file)
index 2a26b42..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x8_t
-test_vcopyq_laneq_bf16 (bfloat16x8_t a, bfloat16x8_t b)
-{
-  bfloat16x8_t res;
-  /* { dg-error "lane -1 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopyq_laneq_bf16 (a, -1, b, 2);
-  /* { dg-error "lane 8 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopyq_laneq_bf16 (a, 8, b, 2);
-  return res;
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_2.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_2.c
deleted file mode 100644 (file)
index 421cb2a..0000000
--- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vcopyq_laneq_bf16_indices_2.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do compile { target { aarch64*-*-* } } } */
-/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */
-/* { dg-require-effective-target arm_v8_2a_bf16_neon_ok } */
-/* { dg-add-options arm_v8_2a_bf16_neon }  */
-
-#include <arm_neon.h>
-
-bfloat16x8_t
-test_vcopyq_laneq_bf16 (bfloat16x8_t a, bfloat16x8_t b)
-{
-  bfloat16x8_t res;
-  /* { dg-error "lane -1 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopyq_laneq_bf16 (a, 2, b, -1);
-  /* { dg-error "lane 8 out of range 0 - 7" "" { target *-*-* } 0 } */
-  res = vcopyq_laneq_bf16 (a, 2, b, 8);
-  return res;
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/lane-bound-3.c b/gcc/testsuite/gcc.target/aarch64/lane-bound-3.c
index 9e0dad372cb975d9423d8edd817ae72a7fbf08b9..2d83b34a58a155fc2f92648b2fd01ef3c01442d7 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/lane-bound-3.c
+++ b/gcc/testsuite/gcc.target/aarch64/lane-bound-3.c
@@ -12,9 +12,7 @@
 __attribute__((always_inline))
 static inline
 void h(uint64x2_t c, int __b) {
-   /* Use vgetq_lane_u64 to get a 
-     __builtin_aarch64_im_lane_boundsi */
-   vgetq_lane_u64(c, __b);
+    __builtin_aarch64_im_lane_boundsi (sizeof (c), sizeof (c[0]), __b);
 
   __builtin_unreachable();
 }

diff --git a/gcc/testsuite/gcc.target/aarch64/neon/arm_neon_test.h b/gcc/testsuite/gcc.target/aarch64/neon/arm_neon_test.h
index 7d9371e0104735944c417c441363ec2853922db9..844eef49d372d0c04d504b7b7d6632a584bd680e 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/neon/arm_neon_test.h
+++ b/gcc/testsuite/gcc.target/aarch64/neon/arm_neon_test.h
@@ -2,6 +2,8 @@
 
 #pragma GCC target "+simd+fp16+bf16+sha3"
 
+#define VEC_LEN(VEC) (sizeof (VEC) / sizeof (VEC[0]))
+
 #define TEST_UNARY(NAME, RET_TYPE, ARG_1_TYPE)                                 \
   RET_TYPE test_##NAME (ARG_1_TYPE a) { return NAME (a); }
 

diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vcopy_lane.c b/gcc/testsuite/gcc.target/aarch64/neon/vcopy_lane.c
new file mode 100644 (file)
index 0000000..5079b39
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vcopy_lane.c
@@ -0,0 +1,438 @@
+/* { dg-do compile } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "arm_neon_test.h"
+
+#define TEST_COPY_LANE(NAME, TYPE1, TYPE2)                                     \
+  TYPE1 test_##NAME (TYPE1 dst, TYPE2 src)                                     \
+  {                                                                            \
+    return NAME (dst, VEC_LEN (dst) - 1, src, VEC_LEN (src) - 1);              \
+  }
+
+/*
+** test_vcopy_lane_p8:
+** ins v0\.b\[7\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_p8, poly8x8_t, poly8x8_t)
+
+/*
+** test_vcopy_lane_mf8:
+** ins v0\.b\[7\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_mf8, mfloat8x8_t, mfloat8x8_t)
+
+/*
+** test_vcopy_lane_s8:
+** ins v0\.b\[7\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_s8, int8x8_t, int8x8_t)
+
+/*
+** test_vcopy_lane_u8:
+** ins v0\.b\[7\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_u8, uint8x8_t, uint8x8_t)
+
+/*
+** test_vcopy_laneq_p8:
+** ins v0\.b\[7\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_p8, poly8x8_t, poly8x16_t)
+
+/*
+** test_vcopy_laneq_mf8:
+** ins v0\.b\[7\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_mf8, mfloat8x8_t, mfloat8x16_t)
+
+/*
+** test_vcopy_laneq_s8:
+** ins v0\.b\[7\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_s8, int8x8_t, int8x16_t)
+
+/*
+** test_vcopy_laneq_u8:
+** ins v0\.b\[7\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_u8, uint8x8_t, uint8x16_t)
+
+/*
+** test_vcopyq_lane_p8:
+** ins v0\.b\[15\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_p8, poly8x16_t, poly8x8_t)
+
+/*
+** test_vcopyq_lane_mf8:
+** ins v0\.b\[15\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_mf8, mfloat8x16_t, mfloat8x8_t)
+
+/*
+** test_vcopyq_lane_s8:
+** ins v0\.b\[15\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_s8, int8x16_t, int8x8_t)
+
+/*
+** test_vcopyq_lane_u8:
+** ins v0\.b\[15\], v1\.b\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_u8, uint8x16_t, uint8x8_t)
+
+/*
+** test_vcopyq_laneq_p8:
+** ins v0\.b\[15\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_p8, poly8x16_t, poly8x16_t)
+
+/*
+** test_vcopyq_laneq_mf8:
+** ins v0\.b\[15\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_mf8, mfloat8x16_t, mfloat8x16_t)
+
+/*
+** test_vcopyq_laneq_s8:
+** ins v0\.b\[15\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_s8, int8x16_t, int8x16_t)
+
+/*
+** test_vcopyq_laneq_u8:
+** ins v0\.b\[15\], v1\.b\[15\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_u8, uint8x16_t, uint8x16_t)
+
+/*
+** test_vcopy_lane_bf16:
+** ins v0\.h\[3\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_bf16, bfloat16x4_t, bfloat16x4_t)
+
+/*
+** test_vcopy_lane_p16:
+** ins v0\.h\[3\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_p16, poly16x4_t, poly16x4_t)
+
+/*
+** test_vcopy_lane_s16:
+** ins v0\.h\[3\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_s16, int16x4_t, int16x4_t)
+
+/*
+** test_vcopy_lane_u16:
+** ins v0\.h\[3\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_u16, uint16x4_t, uint16x4_t)
+
+/*
+** test_vcopy_laneq_bf16:
+** ins v0\.h\[3\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_bf16, bfloat16x4_t, bfloat16x8_t)
+
+/*
+** test_vcopy_laneq_p16:
+** ins v0\.h\[3\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_p16, poly16x4_t, poly16x8_t)
+/*
+** test_vcopy_laneq_s16:
+** ins v0\.h\[3\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_s16, int16x4_t, int16x8_t)
+
+/*
+** test_vcopy_laneq_u16:
+** ins v0\.h\[3\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_u16, uint16x4_t, uint16x8_t)
+
+/*
+** test_vcopyq_lane_bf16:
+** ins v0\.h\[7\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_bf16, bfloat16x8_t, bfloat16x4_t)
+
+/*
+** test_vcopyq_lane_p16:
+** ins v0\.h\[7\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_p16, poly16x8_t, poly16x4_t)
+
+/*
+** test_vcopyq_lane_s16:
+** ins v0\.h\[7\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_s16, int16x8_t, int16x4_t)
+
+/*
+** test_vcopyq_lane_u16:
+** ins v0\.h\[7\], v1\.h\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_u16, uint16x8_t, uint16x4_t)
+
+/*
+** test_vcopyq_laneq_bf16:
+** ins v0\.h\[7\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_bf16, bfloat16x8_t, bfloat16x8_t)
+
+/*
+** test_vcopyq_laneq_p16:
+** ins v0\.h\[7\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_p16, poly16x8_t, poly16x8_t)
+
+/*
+** test_vcopyq_laneq_s16:
+** ins v0\.h\[7\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_s16, int16x8_t, int16x8_t)
+
+/*
+** test_vcopyq_laneq_u16:
+** ins v0\.h\[7\], v1\.h\[7\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_u16, uint16x8_t, uint16x8_t)
+
+// FIXME: these functions generate suboptimal code on big-endian:
+// ins v1.s[0], v0.s[0]
+// mov v0.16b, v1.16b
+// ret
+
+/*
+** test_vcopy_lane_f32: { xfail { aarch64_big_endian || { any-opts "-mbig-endian" } } }
+** ins v0\.s\[1\], v1\.s\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_f32, float32x2_t, float32x2_t)
+
+/*
+** test_vcopy_lane_s32: { xfail { aarch64_big_endian || { any-opts "-mbig-endian" } } }
+** ins v0\.s\[1\], v1\.s\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_s32, int32x2_t, int32x2_t)
+
+/*
+** test_vcopy_lane_u32: { xfail { aarch64_big_endian || { any-opts "-mbig-endian" } } }
+** ins v0\.s\[1\], v1\.s\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_u32, uint32x2_t, uint32x2_t)
+
+/*
+** test_vcopy_laneq_f32:
+** ins v0\.s\[1\], v1\.s\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_f32, float32x2_t, float32x4_t)
+
+/*
+** test_vcopy_laneq_s32:
+** ins v0\.s\[1\], v1\.s\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_s32, int32x2_t, int32x4_t)
+
+/*
+** test_vcopy_laneq_u32:
+** ins v0\.s\[1\], v1\.s\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_u32, uint32x2_t, uint32x4_t)
+
+/*
+** test_vcopyq_lane_f32:
+** ins v0\.s\[3\], v1\.s\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_f32, float32x4_t, float32x2_t)
+
+/*
+** test_vcopyq_lane_s32:
+** ins v0\.s\[3\], v1\.s\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_s32, int32x4_t, int32x2_t)
+
+/*
+** test_vcopyq_lane_u32:
+** ins v0\.s\[3\], v1\.s\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_u32, uint32x4_t, uint32x2_t)
+
+/*
+** test_vcopyq_laneq_f32:
+** ins v0\.s\[3\], v1\.s\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_f32, float32x4_t, float32x4_t)
+
+/*
+** test_vcopyq_laneq_s32:
+** ins v0\.s\[3\], v1\.s\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_s32, int32x4_t, int32x4_t)
+
+/*
+** test_vcopyq_laneq_u32:
+** ins v0\.s\[3\], v1\.s\[3\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_u32, uint32x4_t, uint32x4_t)
+
+/*
+** test_vcopy_lane_f64:
+** fmov        d0, d1
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_f64, float64x1_t, float64x1_t)
+
+/*
+** test_vcopy_lane_p64:
+** fmov        d0, d1
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_p64, poly64x1_t, poly64x1_t)
+
+/*
+** test_vcopy_lane_s64:
+** fmov        d0, d1
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_s64, int64x1_t, int64x1_t)
+
+/*
+** test_vcopy_lane_u64:
+** fmov        d0, d1
+** ret
+*/
+TEST_COPY_LANE (vcopy_lane_u64, uint64x1_t, uint64x1_t)
+
+/*
+** test_vcopy_laneq_f64:
+** dup d0, v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_f64, float64x1_t, float64x2_t)
+
+/*
+** test_vcopy_laneq_p64:
+** dup d0, v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_p64, poly64x1_t, poly64x2_t)
+/*
+** test_vcopy_laneq_s64:
+** dup d0, v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_s64, int64x1_t, int64x2_t)
+
+/*
+** test_vcopy_laneq_u64:
+** dup d0, v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopy_laneq_u64, uint64x1_t, uint64x2_t)
+
+/*
+** test_vcopyq_lane_f64:
+** ins v0\.d\[1\], v1\.d\[0\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_f64, float64x2_t, float64x1_t)
+
+/*
+** test_vcopyq_lane_u64:
+** ins v0\.d\[1\], v1\.d\[0\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_p64, poly64x2_t, poly64x1_t)
+
+/*
+** test_vcopyq_lane_u64:
+** ins v0\.d\[1\], v1\.d\[0\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_s64, int64x2_t, int64x1_t)
+
+/*
+** test_vcopyq_lane_u64:
+** ins v0\.d\[1\], v1\.d\[0\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_lane_u64, uint64x2_t, uint64x1_t)
+
+// FIXME: these functions generate suboptimal code on big-endian:
+// ins v1.d[0], v0.d[0]
+// mov v0.16b, v1.16b
+// ret
+
+/*
+** test_vcopyq_laneq_f64: { xfail { aarch64_big_endian || { any-opts "-mbig-endian" } } }
+** ins v0\.d\[1\], v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_f64, float64x2_t, float64x2_t)
+
+/*
+** test_vcopyq_laneq_p64: { xfail { aarch64_big_endian || { any-opts "-mbig-endian" } } }
+** ins v0\.d\[1\], v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_p64, poly64x2_t, poly64x2_t)
+
+/*
+** test_vcopyq_laneq_s64: { xfail { aarch64_big_endian || { any-opts "-mbig-endian" } } }
+** ins v0\.d\[1\], v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_s64, int64x2_t, int64x2_t)
+
+/*
+** test_vcopyq_laneq_u64: { xfail { aarch64_big_endian || { any-opts "-mbig-endian" } } }
+** ins v0\.d\[1\], v1\.d\[1\]
+** ret
+*/
+TEST_COPY_LANE (vcopyq_laneq_u64, uint64x2_t, uint64x2_t)

diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vdup_lane.c b/gcc/testsuite/gcc.target/aarch64/neon/vdup_lane.c
new file mode 100644 (file)
index 0000000..e2e8a53
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vdup_lane.c
@@ -0,0 +1,647 @@
+/* { dg-do compile } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "arm_neon_test.h"
+
+#define TEST_DUP_LANE(NAME, TYPE1, TYPE2)                                      \
+  TYPE1 test_##NAME (TYPE2 vec2) { return NAME (vec2, 0); }
+
+/*
+** test_vdup_lane_p8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_p8, poly8x8_t, poly8x8_t)
+
+/*
+** test_vdup_lane_mf8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_mf8, mfloat8x8_t, mfloat8x8_t)
+
+/*
+** test_vdup_lane_u8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_u8, uint8x8_t, uint8x8_t)
+
+/*
+** test_vdup_lane_s8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_s8, int8x8_t, int8x8_t)
+
+/*
+** test_vdup_laneq_p8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_p8, poly8x8_t, poly8x16_t)
+
+/*
+** test_vdup_laneq_mf8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_mf8, mfloat8x8_t, mfloat8x16_t)
+
+/*
+** test_vdup_laneq_u8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_u8, uint8x8_t, uint8x16_t)
+
+/*
+** test_vdup_laneq_s8:
+** dup v0\.8b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_s8, int8x8_t, int8x16_t)
+
+/*
+** test_vdupq_lane_p8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_p8, poly8x16_t, poly8x8_t)
+
+/*
+** test_vdupq_lane_mf8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_mf8, mfloat8x16_t, mfloat8x8_t)
+
+/*
+** test_vdupq_lane_u8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_u8, uint8x16_t, uint8x8_t)
+
+/*
+** test_vdupq_lane_s8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_s8, int8x16_t, int8x8_t)
+
+/*
+** test_vdupq_laneq_p8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_p8, poly8x16_t, poly8x16_t)
+
+/*
+** test_vdupq_laneq_mf8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_mf8, mfloat8x16_t, mfloat8x16_t)
+
+/*
+** test_vdupq_laneq_u8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_u8, uint8x16_t, uint8x16_t)
+
+/*
+** test_vdupq_laneq_s8:
+** dup v0\.16b, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_s8, int8x16_t, int8x16_t)
+
+/*
+** test_vdup_lane_p16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_p16, poly16x4_t, poly16x4_t)
+
+/*
+** test_vdup_lane_u16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_u16, uint16x4_t, uint16x4_t)
+
+/*
+** test_vdup_lane_s16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_s16, int16x4_t, int16x4_t)
+
+/*
+** test_vdup_lane_f16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_f16, float16x4_t, float16x4_t)
+
+/*
+** test_vdup_lane_bf16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_bf16, bfloat16x4_t, bfloat16x4_t)
+
+/*
+** test_vdup_laneq_p16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_p16, poly16x4_t, poly16x8_t)
+
+/*
+** test_vdup_laneq_u16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_u16, uint16x4_t, uint16x8_t)
+
+/*
+** test_vdup_laneq_s16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_s16, int16x4_t, int16x8_t)
+
+/*
+** test_vdup_laneq_f16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_f16, float16x4_t, float16x8_t)
+
+/*
+** test_vdup_laneq_bf16:
+** dup v0\.4h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_bf16, bfloat16x4_t, bfloat16x8_t)
+
+/*
+** test_vdupq_lane_p16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_p16, poly16x8_t, poly16x4_t)
+
+/*
+** test_vdupq_lane_u16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_u16, uint16x8_t, uint16x4_t)
+
+/*
+** test_vdupq_lane_s16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_s16, int16x8_t, int16x4_t)
+
+/*
+** test_vdupq_lane_f16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_f16, float16x8_t, float16x4_t)
+
+/*
+** test_vdupq_lane_bf16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_bf16, bfloat16x8_t, bfloat16x4_t)
+
+/*
+** test_vdupq_laneq_p16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_p16, poly16x8_t, poly16x8_t)
+
+/*
+** test_vdupq_laneq_u16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_u16, uint16x8_t, uint16x8_t)
+
+/*
+** test_vdupq_laneq_s16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_s16, int16x8_t, int16x8_t)
+
+/*
+** test_vdupq_laneq_f16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_f16, float16x8_t, float16x8_t)
+
+/*
+** test_vdupq_laneq_bf16:
+** dup v0\.8h, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_bf16, bfloat16x8_t, bfloat16x8_t)
+
+/*
+** test_vdup_lane_u32:
+** dup v0\.2s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_u32, uint32x2_t, uint32x2_t)
+
+/*
+** test_vdup_lane_s32:
+** dup v0\.2s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_s32, int32x2_t, int32x2_t)
+
+/*
+** test_vdup_lane_f32:
+** dup v0\.2s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_f32, float32x2_t, float32x2_t)
+
+/*
+** test_vdup_laneq_u32:
+** dup v0\.2s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_u32, uint32x2_t, uint32x4_t)
+
+/*
+** test_vdup_laneq_s32:
+** dup v0\.2s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_s32, int32x2_t, int32x4_t)
+
+/*
+** test_vdup_laneq_f32:
+** dup v0\.2s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_f32, float32x2_t, float32x4_t)
+
+/*
+** test_vdupq_lane_u32:
+** dup v0\.4s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_u32, uint32x4_t, uint32x2_t)
+
+/*
+** test_vdupq_lane_s32:
+** dup v0\.4s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_s32, int32x4_t, int32x2_t)
+
+/*
+** test_vdupq_lane_f32:
+** dup v0\.4s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_f32, float32x4_t, float32x2_t)
+
+/*
+** test_vdupq_laneq_u32:
+** dup v0\.4s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_u32, uint32x4_t, uint32x4_t)
+
+/*
+** test_vdupq_laneq_s32:
+** dup v0\.4s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_s32, int32x4_t, int32x4_t)
+
+/*
+** test_vdupq_laneq_f32:
+** dup v0\.4s, v0\.s\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_f32, float32x4_t, float32x4_t)
+
+/*
+** test_vdup_lane_p64:
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_p64, poly64x1_t, poly64x1_t)
+
+/*
+** test_vdup_lane_u64:
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_u64, uint64x1_t, uint64x1_t)
+
+/*
+** test_vdup_lane_s64:
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_s64, int64x1_t, int64x1_t)
+
+/*
+** test_vdup_lane_f64:
+** ret
+*/
+TEST_DUP_LANE (vdup_lane_f64, float64x1_t, float64x1_t)
+
+/*
+** test_vdup_laneq_p64:
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_p64, poly64x1_t, poly64x2_t)
+
+/*
+** test_vdup_laneq_u64:
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_u64, uint64x1_t, uint64x2_t)
+
+/*
+** test_vdup_laneq_s64:
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_s64, int64x1_t, int64x2_t)
+
+/*
+** test_vdup_laneq_f64:
+** ret
+*/
+TEST_DUP_LANE (vdup_laneq_f64, float64x1_t, float64x2_t)
+
+/*
+** test_vdupq_lane_p64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_p64, poly64x2_t, poly64x1_t)
+
+/*
+** test_vdupq_lane_u64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_u64, uint64x2_t, uint64x1_t)
+
+/*
+** test_vdupq_lane_s64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_s64, int64x2_t, int64x1_t)
+
+/*
+** test_vdupq_lane_f64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_lane_f64, float64x2_t, float64x1_t)
+
+/*
+** test_vdupq_laneq_p64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_p64, poly64x2_t, poly64x2_t)
+
+/*
+** test_vdupq_laneq_u64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_u64, uint64x2_t, uint64x2_t)
+
+/*
+** test_vdupq_laneq_s64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_s64, int64x2_t, int64x2_t)
+
+/*
+** test_vdupq_laneq_f64:
+** dup v0\.2d, v0\.d\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupq_laneq_f64, float64x2_t, float64x2_t)
+
+/*
+** test_vdupb_lane_p8:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupb_lane_p8, poly8_t, poly8x8_t)
+
+/*
+** test_vdupb_laneq_p8:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupb_laneq_p8, poly8_t, poly8x16_t)
+
+/*
+** test_vdupb_lane_mf8:
+** ret
+*/
+TEST_DUP_LANE (vdupb_lane_mf8, mfloat8_t, mfloat8x8_t)
+
+/*
+** test_vdupb_laneq_mf8:
+** ret
+*/
+TEST_DUP_LANE (vdupb_laneq_mf8, mfloat8_t, mfloat8x16_t)
+
+/*
+** test_vdupb_lane_u8:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupb_lane_u8, uint8_t, uint8x8_t)
+
+/*
+** test_vdupb_laneq_u8:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupb_laneq_u8, uint8_t, uint8x16_t)
+
+/*
+** test_vdupb_lane_s8:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupb_lane_s8, int8_t, int8x8_t)
+
+/*
+** test_vdupb_laneq_s8:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_DUP_LANE (vdupb_laneq_s8, int8_t, int8x16_t)
+
+/*
+** test_vduph_lane_u16:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vduph_lane_u16, uint16_t, uint16x4_t)
+
+/*
+** test_vduph_laneq_u16:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vduph_laneq_u16, uint16_t, uint16x8_t)
+
+/*
+** test_vduph_lane_s16:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vduph_lane_s16, int16_t, int16x4_t)
+
+/*
+** test_vduph_laneq_s16:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vduph_laneq_s16, int16_t, int16x8_t)
+
+/*
+** test_vduph_lane_f16:
+** ret
+*/
+TEST_DUP_LANE (vduph_lane_f16, float16_t, float16x4_t)
+
+/*
+** test_vduph_laneq_f16:
+** ret
+*/
+TEST_DUP_LANE (vduph_laneq_f16, float16_t, float16x8_t)
+
+/*
+** test_vduph_lane_bf16:
+** ret
+*/
+TEST_DUP_LANE (vduph_lane_bf16, bfloat16_t, bfloat16x4_t)
+
+/*
+** test_vduph_laneq_bf16:
+** ret
+*/
+TEST_DUP_LANE (vduph_laneq_bf16, bfloat16_t, bfloat16x8_t)
+
+/*
+** test_vduph_lane_p16:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vduph_lane_p16, poly16_t, poly16x4_t)
+
+/*
+** test_vduph_laneq_p16:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_DUP_LANE (vduph_laneq_p16, poly16_t, poly16x8_t)
+
+/*
+** test_vdups_lane_u32:
+** fmov        w0, s0
+** ret
+*/
+TEST_DUP_LANE (vdups_lane_u32, uint32_t, uint32x2_t)
+
+/*
+** test_vdups_laneq_u32:
+** fmov        w0, s0
+** ret
+*/
+TEST_DUP_LANE (vdups_laneq_u32, uint32_t, uint32x4_t)
+
+/*
+** test_vdups_lane_s32:
+** fmov        w0, s0
+** ret
+*/
+TEST_DUP_LANE (vdups_lane_s32, int32_t, int32x2_t)
+
+/*
+** test_vdups_laneq_s32:
+** fmov        w0, s0
+** ret
+*/
+TEST_DUP_LANE (vdups_laneq_s32, int32_t, int32x4_t)
+
+/*
+** test_vdups_lane_f32:
+** ret
+*/
+TEST_DUP_LANE (vdups_lane_f32, float32_t, float32x2_t)
+
+/*
+** test_vdups_laneq_f32:
+** ret
+*/
+TEST_DUP_LANE (vdups_laneq_f32, float32_t, float32x4_t)
+
+/*
+** test_vdupd_lane_u64:
+** fmov        x0, d0
+** ret
+*/
+TEST_DUP_LANE (vdupd_lane_u64, uint64_t, uint64x1_t)
+
+/*
+** test_vdupd_laneq_u64:
+** fmov        x0, d0
+** ret
+*/
+TEST_DUP_LANE (vdupd_laneq_u64, uint64_t, uint64x2_t)
+
+/*
+** test_vdupd_lane_s64:
+** fmov        x0, d0
+** ret
+*/
+TEST_DUP_LANE (vdupd_lane_s64, int64_t, int64x1_t)
+
+/*
+** test_vdupd_laneq_s64:
+** fmov        x0, d0
+** ret
+*/
+TEST_DUP_LANE (vdupd_laneq_s64, int64_t, int64x2_t)
+
+/*
+** test_vdupd_lane_f64:
+** ret
+*/
+TEST_DUP_LANE (vdupd_lane_f64, float64_t, float64x1_t)
+
+/*
+** test_vdupd_laneq_f64:
+** ret
+*/
+TEST_DUP_LANE (vdupd_laneq_f64, float64_t, float64x2_t)

diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vget_high.c b/gcc/testsuite/gcc.target/aarch64/neon/vget_high.c
new file mode 100644 (file)
index 0000000..d14ba61
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vget_high.c
@@ -0,0 +1,116 @@
+/* { dg-do compile } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "arm_neon_test.h"
+
+/*
+** test_vget_high_u8:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_u8, uint8x8_t, uint8x16_t)
+
+/*
+** test_vget_high_s8:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_s8, int8x8_t, int8x16_t)
+
+/*
+** test_vget_high_p8:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_p8, poly8x8_t, poly8x16_t)
+
+/*
+** test_vget_high_mf8:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_mf8, mfloat8x8_t, mfloat8x16_t)
+
+/*
+** test_vget_high_u16:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_u16, uint16x4_t, uint16x8_t)
+
+/*
+** test_vget_high_s16:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_s16, int16x4_t, int16x8_t)
+
+/*
+** test_vget_high_p16:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_p16, poly16x4_t, poly16x8_t)
+
+/*
+** test_vget_high_f16:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_f16, float16x4_t, float16x8_t)
+
+/*
+** test_vget_high_bf16:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_bf16, bfloat16x4_t, bfloat16x8_t)
+
+/*
+** test_vget_high_u32:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_u32, uint32x2_t, uint32x4_t)
+
+/*
+** test_vget_high_s32:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_s32, int32x2_t, int32x4_t)
+
+/*
+** test_vget_high_f32:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_f32, float32x2_t, float32x4_t)
+
+/*
+** test_vget_high_u64:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_u64, uint64x1_t, uint64x2_t)
+
+/*
+** test_vget_high_s64:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_s64, int64x1_t, int64x2_t)
+
+/*
+** test_vget_high_p64:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_p64, poly64x1_t, poly64x2_t)
+
+/*
+** test_vget_high_f64:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_UNARY (vget_high_f64, float64x1_t, float64x2_t)

diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vget_lane.c b/gcc/testsuite/gcc.target/aarch64/neon/vget_lane.c
new file mode 100644 (file)
index 0000000..136ad00
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vget_lane.c
@@ -0,0 +1,449 @@
+/* { dg-do compile } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "arm_neon_test.h"
+
+#define TEST_GET_FIRST_LANE(NAME, RET_TYPE, ARG_TYPE)                          \
+  RET_TYPE test_##NAME##_first (ARG_TYPE arg1) { return NAME (arg1, 0); }
+
+#define TEST_GET_LAST_LANE(NAME, RET_TYPE, ARG_TYPE)                           \
+  RET_TYPE test_##NAME##_last (ARG_TYPE arg1)                                  \
+  {                                                                            \
+    return NAME (arg1, VEC_LEN (arg1) - 1);                                    \
+  }
+
+/*
+** test_vget_lane_u8_first:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_u8, uint8_t, uint8x8_t)
+
+/*
+** test_vget_lane_s8_first:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_s8, int8_t, int8x8_t)
+
+/*
+** test_vget_lane_p8_first:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_p8, poly8_t, poly8x8_t)
+
+/*
+** test_vget_lane_mf8_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_mf8, mfloat8_t, mfloat8x8_t)
+
+/*
+** test_vgetq_lane_u8_first:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_u8, uint8_t, uint8x16_t)
+
+/*
+** test_vgetq_lane_s8_first:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_s8, int8_t, int8x16_t)
+
+/*
+** test_vgetq_lane_p8_first:
+** umov        w0, v0\.b\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_p8, poly8_t, poly8x16_t)
+
+/*
+** test_vgetq_lane_mf8_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_mf8, mfloat8_t, mfloat8x16_t)
+
+/*
+** test_vget_lane_u16_first:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_u16, uint16_t, uint16x4_t)
+
+/*
+** test_vget_lane_s16_first:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_s16, int16_t, int16x4_t)
+
+/*
+** test_vget_lane_p16_first:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_p16, poly16_t, poly16x4_t)
+
+/*
+** test_vget_lane_f16_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_f16, float16_t, float16x4_t)
+
+/*
+** test_vget_lane_bf16_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_bf16, bfloat16_t, bfloat16x4_t)
+
+/*
+** test_vgetq_lane_u16_first:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_u16, uint16_t, uint16x8_t)
+
+/*
+** test_vgetq_lane_s16_first:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_s16, int16_t, int16x8_t)
+
+/*
+** test_vgetq_lane_p16_first:
+** umov        w0, v0\.h\[0\]
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_p16, poly16_t, poly16x8_t)
+
+/*
+** test_vgetq_lane_f16_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_f16, float16_t, float16x8_t)
+
+/*
+** test_vgetq_lane_bf16_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_bf16, bfloat16_t, bfloat16x8_t)
+
+/*
+** test_vget_lane_u32_first:
+** fmov        w0, s0
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_u32, uint32_t, uint32x2_t)
+
+/*
+** test_vget_lane_s32_first:
+** fmov        w0, s0
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_s32, int32_t, int32x2_t)
+
+/*
+** test_vget_lane_f32_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_f32, float32_t, float32x2_t)
+
+/*
+** test_vgetq_lane_u32_first:
+** fmov        w0, s0
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_u32, uint32_t, uint32x4_t)
+
+/*
+** test_vgetq_lane_s32_first:
+** fmov        w0, s0
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_s32, int32_t, int32x4_t)
+
+/*
+** test_vgetq_lane_f32_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_f32, float32_t, float32x4_t)
+
+/*
+** test_vget_lane_u64_first:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_u64, uint64_t, uint64x1_t)
+
+/*
+** test_vget_lane_s64_first:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_s64, int64_t, int64x1_t)
+
+/*
+** test_vget_lane_p64_first:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_p64, poly64_t, poly64x1_t)
+
+/*
+** test_vget_lane_f64_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vget_lane_f64, float64_t, float64x1_t)
+
+/*
+** test_vgetq_lane_u64_first:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_u64, uint64_t, uint64x2_t)
+
+/*
+** test_vgetq_lane_s64_first:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_s64, int64_t, int64x2_t)
+
+/*
+** test_vgetq_lane_p64_first:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_p64, poly64_t, poly64x2_t)
+
+/*
+** test_vgetq_lane_f64_first:
+** ret
+*/
+TEST_GET_FIRST_LANE (vgetq_lane_f64, float64_t, float64x2_t)
+
+/*
+** test_vget_lane_u8_last:
+** umov        w0, v0\.b\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_u8, uint8_t, uint8x8_t)
+
+/*
+** test_vget_lane_s8_last:
+** umov        w0, v0\.b\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_s8, int8_t, int8x8_t)
+
+/*
+** test_vget_lane_p8_last:
+** umov        w0, v0\.b\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_p8, poly8_t, poly8x8_t)
+
+/*
+** test_vget_lane_mf8_last:
+** dup b0, v0\.b\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_mf8, mfloat8_t, mfloat8x8_t)
+
+/*
+** test_vgetq_lane_u8_last:
+** umov        w0, v0\.b\[15\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_u8, uint8_t, uint8x16_t)
+
+/*
+** test_vgetq_lane_s8_last:
+** umov        w0, v0\.b\[15\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_s8, int8_t, int8x16_t)
+
+/*
+** test_vgetq_lane_p8_last:
+** umov        w0, v0\.b\[15\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_p8, poly8_t, poly8x16_t)
+
+/*
+** test_vgetq_lane_mf8_last:
+** dup b0, v0\.b\[15\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_mf8, mfloat8_t, mfloat8x16_t)
+
+/*
+** test_vget_lane_u16_last:
+** umov        w0, v0\.h\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_u16, uint16_t, uint16x4_t)
+
+/*
+** test_vget_lane_s16_last:
+** umov        w0, v0\.h\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_s16, int16_t, int16x4_t)
+
+/*
+** test_vget_lane_p16_last:
+** umov        w0, v0\.h\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_p16, poly16_t, poly16x4_t)
+
+/*
+** test_vget_lane_f16_last:
+** dup h0, v0\.h\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_f16, float16_t, float16x4_t)
+
+/*
+** test_vget_lane_bf16_last:
+** dup h0, v0\.h\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_bf16, bfloat16_t, bfloat16x4_t)
+
+/*
+** test_vgetq_lane_u16_last:
+** umov        w0, v0\.h\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_u16, uint16_t, uint16x8_t)
+
+/*
+** test_vgetq_lane_s16_last:
+** umov        w0, v0\.h\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_s16, int16_t, int16x8_t)
+
+/*
+** test_vgetq_lane_p16_last:
+** umov        w0, v0\.h\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_p16, poly16_t, poly16x8_t)
+
+/*
+** test_vgetq_lane_f16_last:
+** dup h0, v0\.h\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_f16, float16_t, float16x8_t)
+
+/*
+** test_vgetq_lane_bf16_last:
+** dup h0, v0\.h\[7\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_bf16, bfloat16_t, bfloat16x8_t)
+
+/*
+** test_vget_lane_u32_last:
+** umov        w0, v0\.s\[1\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_u32, uint32_t, uint32x2_t)
+
+/*
+** test_vget_lane_s32_last:
+** umov        w0, v0\.s\[1\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_s32, int32_t, int32x2_t)
+
+/*
+** test_vget_lane_f32_last:
+** dup s0, v0\.s\[1\]
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_f32, float32_t, float32x2_t)
+
+/*
+** test_vgetq_lane_u32_last:
+** umov        w0, v0\.s\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_u32, uint32_t, uint32x4_t)
+
+/*
+** test_vgetq_lane_s32_last:
+** umov        w0, v0\.s\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_s32, int32_t, int32x4_t)
+
+/*
+** test_vgetq_lane_f32_last:
+** dup s0, v0\.s\[3\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_f32, float32_t, float32x4_t)
+
+/*
+** test_vget_lane_u64_last:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_u64, uint64_t, uint64x1_t)
+
+/*
+** test_vget_lane_s64_last:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_s64, int64_t, int64x1_t)
+
+/*
+** test_vget_lane_p64_last:
+** fmov        x0, d0
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_p64, poly64_t, poly64x1_t)
+
+/*
+** test_vget_lane_f64_last:
+** ret
+*/
+TEST_GET_LAST_LANE (vget_lane_f64, float64_t, float64x1_t)
+/*
+** test_vgetq_lane_u64_last:
+** umov        x0, v0\.d\[1\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_u64, uint64_t, uint64x2_t)
+
+/*
+** test_vgetq_lane_s64_last:
+** umov        x0, v0\.d\[1\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_s64, int64_t, int64x2_t)
+
+/*
+** test_vgetq_lane_p64_last:
+** umov        x0, v0\.d\[1\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_p64, poly64_t, poly64x2_t)
+
+/*
+** test_vgetq_lane_f64_last:
+** dup d0, v0\.d\[1\]
+** ret
+*/
+TEST_GET_LAST_LANE (vgetq_lane_f64, float64_t, float64x2_t)

diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vget_low.c b/gcc/testsuite/gcc.target/aarch64/neon/vget_low.c
new file mode 100644 (file)
index 0000000..bc6dea5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vget_low.c
@@ -0,0 +1,100 @@
+/* { dg-do compile } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "arm_neon_test.h"
+
+/*
+** test_vget_low_u8:
+** ret
+*/
+TEST_UNARY (vget_low_u8, uint8x8_t, uint8x16_t)
+
+/*
+** test_vget_low_s8:
+** ret
+*/
+TEST_UNARY (vget_low_s8, int8x8_t, int8x16_t)
+
+/*
+** test_vget_low_p8:
+** ret
+*/
+TEST_UNARY (vget_low_p8, poly8x8_t, poly8x16_t)
+
+/*
+** test_vget_low_mf8:
+** ret
+*/
+TEST_UNARY (vget_low_mf8, mfloat8x8_t, mfloat8x16_t)
+
+/*
+** test_vget_low_u16:
+** ret
+*/
+TEST_UNARY (vget_low_u16, uint16x4_t, uint16x8_t)
+
+/*
+** test_vget_low_s16:
+** ret
+*/
+TEST_UNARY (vget_low_s16, int16x4_t, int16x8_t)
+
+/*
+** test_vget_low_p16:
+** ret
+*/
+TEST_UNARY (vget_low_p16, poly16x4_t, poly16x8_t)
+
+/*
+** test_vget_low_f16:
+** ret
+*/
+TEST_UNARY (vget_low_f16, float16x4_t, float16x8_t)
+
+/*
+** test_vget_low_bf16:
+** ret
+*/
+TEST_UNARY (vget_low_bf16, bfloat16x4_t, bfloat16x8_t)
+
+/*
+** test_vget_low_u32:
+** ret
+*/
+TEST_UNARY (vget_low_u32, uint32x2_t, uint32x4_t)
+
+/*
+** test_vget_low_s32:
+** ret
+*/
+TEST_UNARY (vget_low_s32, int32x2_t, int32x4_t)
+
+/*
+** test_vget_low_f32:
+** ret
+*/
+TEST_UNARY (vget_low_f32, float32x2_t, float32x4_t)
+
+/*
+** test_vget_low_u64:
+** ret
+*/
+TEST_UNARY (vget_low_u64, uint64x1_t, uint64x2_t)
+
+/*
+** test_vget_low_s64:
+** ret
+*/
+TEST_UNARY (vget_low_s64, int64x1_t, int64x2_t)
+
+/*
+** test_vget_low_p64:
+** ret
+*/
+TEST_UNARY (vget_low_p64, poly64x1_t, poly64x2_t)
+
+/*
+** test_vget_low_f64:
+** ret
+*/
+TEST_UNARY (vget_low_f64, float64x1_t, float64x2_t)

diff --git a/gcc/testsuite/gcc.target/aarch64/neon/vset_lane.c b/gcc/testsuite/gcc.target/aarch64/neon/vset_lane.c
new file mode 100644 (file)
index 0000000..a0264c8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/neon/vset_lane.c
@@ -0,0 +1,234 @@
+/* { dg-do compile } */
+/* { dg-final { check-function-bodies "**" "" } } */
+
+#include "arm_neon_test.h"
+
+#define TEST_SET_LANE(NAME, ELEM_TYPE, VEC_TYPE)                               \
+  VEC_TYPE test_##NAME (VEC_TYPE vec, ELEM_TYPE elem)                          \
+  {                                                                            \
+    return NAME (elem, vec, 0);                                                \
+  }
+
+/*
+** test_vset_lane_f16:
+** ins v0\.h\[0\], v1\.h\[0\]
+** ret
+*/
+TEST_SET_LANE (vset_lane_f16, float16_t, float16x4_t)
+
+/*
+** test_vset_lane_f32:
+** ins v0\.s\[0\], v1\.s\[0\]
+** ret
+*/
+TEST_SET_LANE (vset_lane_f32, float32_t, float32x2_t)
+
+/*
+** test_vset_lane_f64:
+** fmov        d0, d1
+** ret
+*/
+TEST_SET_LANE (vset_lane_f64, float64_t, float64x1_t)
+
+/*
+** test_vset_lane_p8:
+** ins v0\.b\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_p8, poly8_t, poly8x8_t)
+
+/*
+** test_vset_lane_mf8:
+** ins v0\.b\[0\], v1\.b\[0\]
+** ret
+*/
+TEST_SET_LANE (vset_lane_mf8, mfloat8_t, mfloat8x8_t)
+
+/*
+** test_vset_lane_p16:
+** ins v0\.h\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_p16, poly16_t, poly16x4_t)
+
+/*
+** test_vset_lane_p64:
+** fmov        d0, x0
+** ret
+*/
+TEST_SET_LANE (vset_lane_p64, poly64_t, poly64x1_t)
+
+/*
+** test_vset_lane_s8:
+** ins v0\.b\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_s8, int8_t, int8x8_t)
+
+/*
+** test_vset_lane_s16:
+** ins v0\.h\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_s16, int16_t, int16x4_t)
+
+/*
+** test_vset_lane_s32:
+** ins v0\.s\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_s32, int32_t, int32x2_t)
+
+/*
+** test_vset_lane_s64:
+** fmov        d0, x0
+** ret
+*/
+TEST_SET_LANE (vset_lane_s64, int64_t, int64x1_t)
+
+/*
+** test_vset_lane_u8:
+** ins v0\.b\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_u8, uint8_t, uint8x8_t)
+
+/*
+** test_vset_lane_u16:
+** ins v0\.h\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_u16, uint16_t, uint16x4_t)
+
+/*
+** test_vset_lane_u32:
+** ins v0\.s\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vset_lane_u32, uint32_t, uint32x2_t)
+
+/*
+** test_vset_lane_u64:
+** fmov        d0, x0
+** ret
+*/
+TEST_SET_LANE (vset_lane_u64, uint64_t, uint64x1_t)
+
+/*
+** test_vsetq_lane_f16:
+** ins v0\.h\[0\], v1\.h\[0\]
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_f16, float16_t, float16x8_t)
+
+/*
+** test_vsetq_lane_f32:
+** ins v0\.s\[0\], v1\.s\[0\]
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_f32, float32_t, float32x4_t)
+
+/*
+** test_vsetq_lane_f64:
+** ins v0\.d\[0\], v1\.d\[0\]
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_f64, float64_t, float64x2_t)
+
+/*
+** test_vsetq_lane_p8:
+** ins v0\.b\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_p8, poly8_t, poly8x16_t)
+
+/*
+** test_vsetq_lane_mf8:
+** ins v0\.b\[0\], v1\.b\[0\]
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_mf8, mfloat8_t, mfloat8x16_t)
+
+/*
+** test_vsetq_lane_p16:
+** ins v0\.h\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_p16, poly16_t, poly16x8_t)
+
+/*
+** test_vsetq_lane_p64:
+** ins v0\.d\[0\], x0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_p64, poly64_t, poly64x2_t)
+
+/*
+** test_vsetq_lane_s8:
+** ins v0\.b\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_s8, int8_t, int8x16_t)
+
+/*
+** test_vsetq_lane_s16:
+** ins v0\.h\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_s16, int16_t, int16x8_t)
+
+/*
+** test_vsetq_lane_s32:
+** ins v0\.s\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_s32, int32_t, int32x4_t)
+
+/*
+** test_vsetq_lane_s64:
+** ins v0\.d\[0\], x0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_s64, int64_t, int64x2_t)
+
+/*
+** test_vsetq_lane_u8:
+** ins v0\.b\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_u8, uint8_t, uint8x16_t)
+
+/*
+** test_vsetq_lane_u16:
+** ins v0\.h\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_u16, uint16_t, uint16x8_t)
+
+/*
+** test_vsetq_lane_u32:
+** ins v0\.s\[0\], w0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_u32, uint32_t, uint32x4_t)
+
+/*
+** test_vsetq_lane_u64:
+** ins v0\.d\[0\], x0
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_u64, uint64_t, uint64x2_t)
+
+/*
+** test_vset_lane_bf16:
+** ins v0\.h\[0\], v1\.h\[0\]
+** ret
+*/
+TEST_SET_LANE (vset_lane_bf16, bfloat16_t, bfloat16x4_t)
+
+/*
+** test_vsetq_lane_bf16:
+** ins v0\.h\[0\], v1\.h\[0\]
+** ret
+*/
+TEST_SET_LANE (vsetq_lane_bf16, bfloat16_t, bfloat16x8_t)

diff --git a/gcc/testsuite/gcc.target/aarch64/pr113573.c b/gcc/testsuite/gcc.target/aarch64/pr113573.c
index 30175c4cb5c801109162edd971ce389f9515ff5b..068b108447535b37a55e93c9308ccf95c3ee69c5 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/pr113573.c
+++ b/gcc/testsuite/gcc.target/aarch64/pr113573.c
@@ -5,36 +5,46 @@ typedef __Uint8x8_t uint8x8_t;
 typedef __Uint16x4_t uint16x4_t;
 typedef __Int16x8_t int16x8_t;
 typedef __Uint16x8_t uint16x8_t;
+
 int jsimd_extbgrx_ycc_convert_neon_image_width,
-    jsimd_extbgrx_ycc_convert_neon___trans_tmp_1;
+  jsimd_extbgrx_ycc_convert_neon___trans_tmp_1;
+
 uint16x4_t jsimd_extbgrx_ycc_convert_neon___trans_tmp_2;
-uint16x8_t vcombine_u16();
-uint16x8_t vmovl_u8(uint8x8_t __a) {
-  return __builtin_aarch64_uxtlv8hi_uu(__a);
+uint16x8_t foo1 (...);
+
+uint16x8_t
+foo2 (uint8x8_t __a)
+{
+  return __builtin_aarch64_uxtlv8hi_uu (__a);
 }
-__inline int __attribute__((__gnu_inline__)) vmull_laneq_u16();
-uint8x8x4_t vld4_u8();
-void jsimd_extbgrx_ycc_convert_neon() {
+
+__inline int __attribute__ ((__gnu_inline__)) foo3 (...);
+
+uint8x8x4_t foo4 (...);
+void
+jsimd_extbgrx_ycc_convert_neon ()
+{
   int scaled_128_5 = jsimd_extbgrx_ycc_convert_neon___trans_tmp_1,
       cols_remaining = jsimd_extbgrx_ycc_convert_neon_image_width;
   for (;;)
-    if (cols_remaining) {
-      uint8x8x4_t input_pixels = vld4_u8();
-      uint16x8_t r = vmovl_u8(input_pixels.val[2]);
-      uint16x8_t g = vmovl_u8(input_pixels.val[1]);
-      uint16x8_t b = vmovl_u8(input_pixels.val[0]);
-      int y_l = vmull_laneq_u16(r);
-      uint16x8_t __a = g;
-      jsimd_extbgrx_ycc_convert_neon___trans_tmp_2 =
-          (uint16x4_t)vget_low_s16((int16x8_t)__a);
-      __a = b;
-      int cb_l = scaled_128_5;
-      int cb_h = scaled_128_5;
-      int cr_l = scaled_128_5;
-      int cr_h = scaled_128_5;
-      uint16x8_t y_u16 = vcombine_u16(y_l);
-      uint16x8_t cb_u16 = vcombine_u16(cb_l, cb_h);
-      uint16x8_t cr_u16 = vcombine_u16(cr_l, cr_h);
-      __a = y_u16 = cb_u16 = cr_u16;
-    }
+    if (cols_remaining)
+      {
+       uint8x8x4_t input_pixels = foo4 ();
+       uint16x8_t r = foo2 (input_pixels.val[2]);
+       uint16x8_t g = foo2 (input_pixels.val[1]);
+       uint16x8_t b = foo2 (input_pixels.val[0]);
+       int y_l = foo3 (r);
+       uint16x8_t __a = g;
+       jsimd_extbgrx_ycc_convert_neon___trans_tmp_2 =
+         (uint16x4_t) vget_low_s16 ((int16x8_t) __a);
+       __a = b;
+       int cb_l = scaled_128_5;
+       int cb_h = scaled_128_5;
+       int cr_l = scaled_128_5;
+       int cr_h = scaled_128_5;
+       uint16x8_t y_u16 = foo1 (y_l);
+       uint16x8_t cb_u16 = foo1 (cb_l, cb_h);
+       uint16x8_t cr_u16 = foo1 (cr_l, cr_h);
+       __a = y_u16 = cb_u16 = cr_u16;
+      }
 }

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/fold_to_highpart_6.c b/gcc/testsuite/gcc.target/aarch64/simd/fold_to_highpart_6.c
index 83ef2148fd84f806c243226f2bb4f4b6b1fdba7a..b6030fc58256c003d39342974c21392812b0e5a0 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/simd/fold_to_highpart_6.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/fold_to_highpart_6.c
@@ -11,6 +11,13 @@ typedef int16_t int16x16_t __attribute__ ((vector_size (32)));
 
 int8x16_t z;
 
+/*
+** test_addressable:
+**     adrp    x([0-9]+), \.LANCHOR0
+**     ldr     q([0-9]+), \[x\1, #?:lo12:\.LANCHOR0\]
+**     sxtl2   v0\.8h, v\2\.16b
+**     ret
+*/
 int16x8_t
 test_addressable ()
 {
@@ -19,7 +26,7 @@ test_addressable ()
 
 /*
 ** test_scalable_type:
-**     sxtl2   v0.8h, v0.16b
+**     sxtl2   v0\.8h, v0\.16b
 **     ret
 */
 int16x8_t
@@ -28,17 +35,26 @@ test_scalable_type (svint8_t scalable)
   return vmovl_s8 (vget_high_s8 (svget_neonq_s8 (scalable)));
 }
 
+/*
+** test_scalar_type:
+**     fmov    d([0-9]+), x1
+**     sxtl    v0\.8h, v\1\.8b
+**     ret
+*/
 int16x8_t
 test_scalar_type (__int128_t foo)
 {
   return vmovl_s8 (vget_high_s8 (vreinterpretq_s8_p128 (foo)));
 }
 
+/*
+** test_256b_type:
+**     ldr     d([0-9]+), \[x0, #?8\]
+**     sxtl    v0\.4s, v\1\.4h
+**     ret
+*/
 int32x4_t
 test_256b_type (int16x16_t foo)
 {
   return vmovl_s16 ((int16x4_t) { foo[4], foo[5], foo[6], foo[7] });
 }
-
-/* { dg-final { scan-assembler-times {sxtl2\t} 1 } } */
-/* { dg-final { scan-assembler-times {sxtl\t} 3 } } */

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/mf8_data_2.c b/gcc/testsuite/gcc.target/aarch64/simd/mf8_data_2.c
index 0f923f247d4a042acfa0a3affb2a5811762e6292..f69165219a84b0ad9d9a52787d8d2a0c35c09e2c 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/simd/mf8_data_2.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/mf8_data_2.c
@@ -14,7 +14,6 @@ void test(mfloat8x8_t x8, mfloat8x16_t x16,
   vcopy_lane_mf8(x8, 0, x8, -1); /* { dg-error {passing -1 to argument 4 of 'vcopy_lane_mf8', which expects a value in the range \[0, 7\]} } */
   vcopy_lane_mf8(x8, 0, x8, 8); /* { dg-error {passing 8 to argument 4 of 'vcopy_lane_mf8', which expects a value in the range \[0, 7\]} } */
   vcopy_lane_mf8(x8, 100, x8, 100); /* { dg-error {passing 100 to argument 2 of 'vcopy_lane_mf8', which expects a value in the range \[0, 7\]} } */
-  /* { dg-error {passing 100 to argument 4 of 'vcopy_lane_mf8', which expects a value in the range \[0, 7\]} "" { target *-*-* } .-1 } */
 
   vcopy_laneq_mf8(x8, -1, x16, 0); /* { dg-error {passing -1 to argument 2 of 'vcopy_laneq_mf8', which expects a value in the range \[0, 7\]} } */
   vcopy_laneq_mf8(x8, 8, x16, 0); /* { dg-error {passing 8 to argument 2 of 'vcopy_laneq_mf8', which expects a value in the range \[0, 7\]} } */

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_f32_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_f32_indices_1.c
deleted file mode 100644 (file)
index d16a3e8..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_f32_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-float32_t
-test_vget_lane_f32_before (float32x2_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vget_lane_f32 (in, -1);
-}
-
-float32_t
-test_vget_lane_f32_beyond (float32x2_t in)
-{
-  /* { dg-error "lane 2 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vget_lane_f32 (in, 2);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_f64_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_f64_indices_1.c
deleted file mode 100644 (file)
index 0e90429..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_f64_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-float64_t
-test_vget_lane_f64_before (float64x1_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 0" "" {target *-*-*} 0 } */
-  return vget_lane_f64 (in, -1);
-}
-
-float64_t
-test_vget_lane_f64_beyond (float64x1_t in)
-{
-  /* { dg-error "lane 1 out of range 0 - 0" "" {target *-*-*} 0 } */
-  return vget_lane_f64 (in, 1);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_indices.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_indices.c
new file mode 100644 (file)
index 0000000..fc30f37
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_indices.c
@@ -0,0 +1,46 @@
+/* { dg-do assemble } */
+
+#include <arm_neon.h>
+
+#define VEC_LEN(VEC) (sizeof (VEC) / sizeof ((VEC)[0]))
+
+#define TEST_VGET_LANE(NAME, RET_TYPE, ARG_TYPE)                               \
+  RET_TYPE test_##NAME (ARG_TYPE arg) { return NAME (arg, VEC_LEN (arg)); }
+
+TEST_VGET_LANE (vget_lane_u8, uint8_t, uint8x8_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_s8, int8_t, int8x8_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_p8, poly8_t, poly8x8_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VGET_LANE (vget_lane_u16, uint16_t, uint16x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_s16, int16_t, int16x4_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_p16, poly16_t, poly16x4_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_f16, float16_t, float16x4_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_bf16, bfloat16_t, bfloat16x4_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VGET_LANE (vget_lane_u32, uint32_t, uint32x2_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_s32, int32_t, int32x2_t)     /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_f32, float32_t, float32x2_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VGET_LANE (vget_lane_u64, uint64_t, uint64x1_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_s64, int64_t, int64x1_t)     /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_f64, float64_t, float64x1_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vget_lane_p64, poly64_t, poly64x1_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vget_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VGET_LANE (vgetq_lane_u8, uint8_t, uint8x16_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_s8, int8_t, int8x16_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_p8, poly8_t, poly8x16_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VGET_LANE (vgetq_lane_u16, uint16_t, uint16x8_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_s16, int16_t, int16x8_t)        /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_p16, poly16_t, poly16x8_t)      /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_f16, float16_t, float16x8_t)    /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_bf16, bfloat16_t, bfloat16x8_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VGET_LANE (vgetq_lane_u32, uint32_t, uint32x4_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_s32, int32_t, int32x4_t)     /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_f32, float32_t, float32x4_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+
+TEST_VGET_LANE (vgetq_lane_u64, uint64_t, uint64x2_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_s64, int64_t, int64x2_t)     /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_f64, float64_t, float64x2_t) /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
+TEST_VGET_LANE (vgetq_lane_p64, poly64_t, poly64x2_t)   /* { dg-error {passing [0-9]+ to argument [0-9]+ of 'vgetq_lane_[a-z0-9]+', [^\n]+} } */
\ No newline at end of file

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_p16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_p16_indices_1.c
deleted file mode 100644 (file)
index bcf2539..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_p16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-poly16_t
-test_vget_lane_p16_before (poly16x4_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vget_lane_p16 (in, -1);
-}
-
-poly16_t
-test_vget_lane_p16_beyond (poly16x4_t in)
-{
-  /* { dg-error "lane 4 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vget_lane_p16 (in, 4);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_p8_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_p8_indices_1.c
deleted file mode 100644 (file)
index 5dc8dc4..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_p8_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-poly8_t
-test_vget_lane_p8_before (poly8x8_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vget_lane_p8 (in, -1);
-}
-
-poly8_t
-test_vget_lane_p8_beyond (poly8x8_t in)
-{
-  /* { dg-error "lane 8 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vget_lane_p8 (in, 8);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s16_indices_1.c
deleted file mode 100644 (file)
index c65fb40..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int16_t
-test_vget_lane_s16_before (int16x4_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vget_lane_s16 (in, -1);
-}
-
-int16_t
-test_vget_lane_s16_beyond (int16x4_t in)
-{
-  /* { dg-error "lane 4 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vget_lane_s16 (in, 4);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s32_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s32_indices_1.c
deleted file mode 100644 (file)
index 1f95137..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s32_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int32_t
-test_vget_lane_s32_before (int32x2_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vget_lane_s32 (in, -1);
-}
-
-int32_t
-test_vget_lane_s32_beyond (int32x2_t in)
-{
-  /* { dg-error "lane 2 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vget_lane_s32 (in, 2);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s64_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s64_indices_1.c
deleted file mode 100644 (file)
index e449797..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s64_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int64_t
-test_vget_lane_s64_before (int64x1_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 0" "" {target *-*-*} 0 } */
-  return vget_lane_s64 (in, -1);
-}
-
-int64_t
-test_vget_lane_s64_beyond (int64x1_t in)
-{
-  /* { dg-error "lane 1 out of range 0 - 0" "" {target *-*-*} 0 } */
-  return vget_lane_s64 (in, 1);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s8_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s8_indices_1.c
deleted file mode 100644 (file)
index 77e9486..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_s8_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int8_t
-test_vget_lane_s8_before (int8x8_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vget_lane_s8 (in, -1);
-}
-
-int8_t
-test_vget_lane_s8_beyond (int8x8_t in)
-{
-  /* { dg-error "lane 8 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vget_lane_s8 (in, 8);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u16_indices_1.c
deleted file mode 100644 (file)
index 77fb3c8..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint16_t
-test_vget_lane_u16_before (uint16x4_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vget_lane_u16 (in, -1);
-}
-
-uint16_t
-test_vget_lane_u16_beyond (uint16x4_t in)
-{
-  /* { dg-error "lane 4 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vget_lane_u16 (in, 4);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u32_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u32_indices_1.c
deleted file mode 100644 (file)
index e670626..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u32_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint32_t
-test_vget_lane_u32_before (uint32x2_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vget_lane_u32 (in, -1);
-}
-
-uint32_t
-test_vget_lane_u32_beyond (uint32x2_t in)
-{
-  /* { dg-error "lane 2 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vget_lane_u32 (in, 2);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u64_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u64_indices_1.c
deleted file mode 100644 (file)
index 44d5a4d..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u64_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint64_t
-test_vget_lane_u64_before (uint64x1_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 0" "" {target *-*-*} 0 } */
-  return vget_lane_u64 (in, -1);
-}
-
-uint64_t
-test_vget_lane_u64_beyond (uint64x1_t in)
-{
-  /* { dg-error "lane 1 out of range 0 - 0" "" {target *-*-*} 0 } */
-  return vget_lane_u64 (in, 1);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u8_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u8_indices_1.c
deleted file mode 100644 (file)
index b452d56..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vget_lane_u8_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint8_t
-test_vget_lane_u8_before (uint8x8_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vget_lane_u8 (in, -1);
-}
-
-uint8_t
-test_vget_lane_u8_beyond (uint8x8_t in)
-{
-  /* { dg-error "lane 8 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vget_lane_u8 (in, 8);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_f32_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_f32_indices_1.c
deleted file mode 100644 (file)
index 8a50ed2..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_f32_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-float32_t
-test_vgetq_lane_f32_before (float32x4_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vgetq_lane_f32 (in, -1);
-}
-
-float32_t
-test_vgetq_lane_f32_beyond (float32x4_t in)
-{
-  /* { dg-error "lane 4 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vgetq_lane_f32 (in, 4);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_f64_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_f64_indices_1.c
deleted file mode 100644 (file)
index 492b1ae..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_f64_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-float64_t
-test_vgetq_lane_f64_before (float64x2_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vgetq_lane_f64 (in, -1);
-}
-
-float64_t
-test_vgetq_lane_f64_beyond (float64x2_t in)
-{
-  /* { dg-error "lane 2 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vgetq_lane_f64 (in, 2);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_p16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_p16_indices_1.c
deleted file mode 100644 (file)
index caa41b2..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_p16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-poly16_t
-test_vgetq_lane_p16_before (poly16x8_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vgetq_lane_p16 (in, -1);
-}
-
-poly16_t
-test_vgetq_lane_p16_beyond (poly16x8_t in)
-{
-  /* { dg-error "lane 8 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vgetq_lane_p16 (in, 8);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_p8_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_p8_indices_1.c
deleted file mode 100644 (file)
index 38caa27..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_p8_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-poly8_t
-test_vgetq_lane_p8_before (poly8x16_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 15" "" {target *-*-*} 0 } */
-  return vgetq_lane_p8 (in, -1);
-}
-
-poly8_t
-test_vgetq_lane_p8_beyond (poly8x16_t in)
-{
-  /* { dg-error "lane 16 out of range 0 - 15" "" {target *-*-*} 0 } */
-  return vgetq_lane_p8 (in, 16);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s16_indices_1.c
deleted file mode 100644 (file)
index 0f4e4f5..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int16_t
-test_vgetq_lane_s16_before (int16x8_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vgetq_lane_s16 (in, -1);
-}
-
-int16_t
-test_vgetq_lane_s16_beyond (int16x8_t in)
-{
-  /* { dg-error "lane 8 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vgetq_lane_s16 (in, 8);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s32_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s32_indices_1.c
deleted file mode 100644 (file)
index 68133b4..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s32_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int32_t
-test_vgetq_lane_s32_before (int32x4_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vgetq_lane_s32 (in, -1);
-}
-
-int32_t
-test_vgetq_lane_s32_beyond (int32x4_t in)
-{
-  /* { dg-error "lane 4 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vgetq_lane_s32 (in, 4);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s64_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s64_indices_1.c
deleted file mode 100644 (file)
index 4ac607f..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s64_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int64_t
-test_vgetq_lane_s64_before (int64x2_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vgetq_lane_s64 (in, -1);
-}
-
-int64_t
-test_vgetq_lane_s64_beyond (int64x2_t in)
-{
-  /* { dg-error "lane 2 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vgetq_lane_s64 (in, 2);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s8_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s8_indices_1.c
deleted file mode 100644 (file)
index 0e44dbc..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_s8_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-int8_t
-test_vgetq_lane_s8_before (int8x16_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 15" "" {target *-*-*} 0 } */
-  return vgetq_lane_s8 (in, -1);
-}
-
-int8_t
-test_vgetq_lane_s8_beyond (int8x16_t in)
-{
-  /* { dg-error "lane 16 out of range 0 - 15" "" {target *-*-*} 0 } */
-  return vgetq_lane_s8 (in, 16);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u16_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u16_indices_1.c
deleted file mode 100644 (file)
index 5ccea06..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u16_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint16_t
-test_vgetq_lane_u16_before (uint16x8_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vgetq_lane_u16 (in, -1);
-}
-
-uint16_t
-test_vgetq_lane_u16_beyond (uint16x8_t in)
-{
-  /* { dg-error "lane 8 out of range 0 - 7" "" {target *-*-*} 0 } */
-  return vgetq_lane_u16 (in, 8);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u32_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u32_indices_1.c
deleted file mode 100644 (file)
index bfbf081..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u32_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint32_t
-test_vgetq_lane_u32_before (uint32x4_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vgetq_lane_u32 (in, -1);
-}
-
-uint32_t
-test_vgetq_lane_u32_beyond (uint32x4_t in)
-{
-  /* { dg-error "lane 4 out of range 0 - 3" "" {target *-*-*} 0 } */
-  return vgetq_lane_u32 (in, 4);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u64_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u64_indices_1.c
deleted file mode 100644 (file)
index a0d426e..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u64_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint64_t
-test_vgetq_lane_u64_before (uint64x2_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vgetq_lane_u64 (in, -1);
-}
-
-uint64_t
-test_vgetq_lane_u64_beyond (uint64x2_t in)
-{
-  /* { dg-error "lane 2 out of range 0 - 1" "" {target *-*-*} 0 } */
-  return vgetq_lane_u64 (in, 2);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u8_indices_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u8_indices_1.c
deleted file mode 100644 (file)
index c9ad663..0000000
--- a/gcc/testsuite/gcc.target/aarch64/simd/vgetq_lane_u8_indices_1.c
+++ /dev/null
@@ -1,17 +0,0 @@
-/* { dg-do assemble } */
-
-#include <arm_neon.h>
-
-uint8_t
-test_vgetq_lane_u8_before (uint8x16_t in)
-{
-  /* { dg-error "lane -1 out of range 0 - 15" "" {target *-*-*} 0 } */
-  return vgetq_lane_u8 (in, -1);
-}
-
-uint8_t
-test_vgetq_lane_u8_beyond (uint8x16_t in)
-{
-  /* { dg-error "lane 16 out of range 0 - 15" "" {target *-*-*} 0 } */
-  return vgetq_lane_u8 (in, 16);
-}

diff --git a/gcc/testsuite/gcc.target/aarch64/simd/vset_lane_s16_const_1.c b/gcc/testsuite/gcc.target/aarch64/simd/vset_lane_s16_const_1.c
index b28d67f74b076412e5dc4982449735aa227322bb..e50bf312b543d2d0bf73f98b9572b203e57fe6b7 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/simd/vset_lane_s16_const_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/simd/vset_lane_s16_const_1.c
@@ -9,7 +9,7 @@ int
 main (int argc, char **argv)
 {
   int16x4_t in = vcreate_s16 (0xdeadbeef00000000ULL);
-  /* { dg-error "must be a constant immediate" "" { target *-*-* } 0 } */
+  /* { dg-error "must be an integer constant expression" "" { target *-*-* } 0 } */
   int16x4_t out = vset_lane_s16 (65535, in, argc);
   return vget_lane_s16 (out, 0);
 }