[ARM Refactor Builtins: 1/8] Remove arm_neon.h's "Magic Words"

gcc/testsuite/

	* gcc.target/arm/pr51968.c (foo): Do not try to pass "Magic Word".

gcc/

	* config/arm/arm.c (arm_expand_neon_builtin): Remove "Magic Word"
	parameter, rearrange switch statement accordingly.
	(arm_evpc_neon_vrev): Remove "Magic Word".
	* config/arm/unspecs.md (unspec): Split many UNSPECs to
	rounding, or signed/unsigned variants.
	* config/arm/neon.md: Remove "Magic Word" code.
	* config/arm/iterators.md (VPF): New.
	(VADDL): Likewise.
	(VADDW): Likewise.
	(VHADD): Likewise.
	(VQADD): Likewise.
	(VADDHN): Likewise.
	(VMLAL): Likewise.
	(VMLAL_LANE): Likewise.
	(VLMSL): Likewise.
	(VMLSL_LANE): Likewise.
	(VQDMULH): Likewise,
	(VQDMULH_LANE): Likewise.
	(VMULL): Likewise.
	(VMULL_LANE): Likewise.
	(VSUBL): Likewise.
	(VSUBW): Likewise.
	(VHSUB): Likewise.
	(VQSUB): Likewise.
	(VSUBHN): Likewise.
	(VABD): Likewise.
	(VABDL): Likewise.
	(VMAXMIN): Likewise.
	(VMAXMINF): Likewise.
	(VPADDL): Likewise.
	(VPADAL): Likewise.
	(VPMAXMIN): Likewise.
	(VPMAXMINF): Likewise.
	(VCVT_US): Likewise.
	(VCVT_US_N): Likewise.
	(VQMOVN): Likewise.
	(VMOVL): Likewise.
	(VSHL): Likewise.
	(VQSHL): Likewise.
	(VSHR_N): Likewise.
	(VSHRN_N): Likewise.
	(VQSHRN_N): Likewise.
	(VQSHRUN_N): Likewise.
	(VQSHL_N): Likewise.
	(VSHLL_N): Likewise.
	(VSRA_N): Likewise.
	(pf): Likewise.
	(sup): Likewise.
	(r): Liekwise.
	(maxmin): Likewise.
	(shift_op): Likewise.
	* config/arm/arm_neon_builtins.def: Split many patterns.
	* config/arm/arm_neon.h (vaddl_s8): Remove "Magic Word" code.

From-SVN: r217693

9 files changed, 2835 insertions, 1397 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 95f5fa3..430373e 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,1185 @@
+2014-11-18  James Greenhalgh  <james.greenhalgh@arm.com>
+
+	* config/arm/arm.c (arm_expand_neon_builtin): Remove "Magic Word"
+	parameter, rearrange switch statement accordingly.
+	(arm_evpc_neon_vrev): Remove "Magic Word".
+	* config/arm/unspecs.md (unspec): Split many UNSPECs to
+	rounding, or signed/unsigned variants.
+	* config/arm/neon.md (vcond<mode><mode>): Remove "Magic Word" code.
+	(vcondu<mode><mode>): Likewise.
+	(neon_vadd): Remove "Magic Word" operand.
+	(neon_vaddl): Remove "Magic Word" operand, convert to use
+	signed/unsigned iterator.
+	(neon_vaddw): Likewise.
+	(neon_vhadd): Likewise, also iterate over "rounding" forms.
+	(neon_vqadd): Remove "Magic Word" operand, convert to use
+	signed/unsigned iterator.
+	(neon_v<r>addhn): Remove "Magic Word" operand, convert to iterate
+	over "rounding" forms.
+	(neon_vmul): Remove "Magic Word" operand, iterate over
+	polynomial/float instruction forms.
+	(neon_vmla): Remove "Magic Word" operand.
+	(neon_vfma): Likewise.
+	(neon_vfms): Likewise.
+	(neon_vmls): Likewise.
+	(neon_vmlal): Remove "Magic Word" operand, iterate over
+	signed/unsigned forms.
+	(neon_vmlsl): Likewise.
+	(neon_vqdmulh): Remove "Magic Word" operand, iterate over "rounding"
+	forms.
+	(neon_vqdmlal): Remove "Magic Word" operand, iterate over
+	signed/unsigned forms.
+	(neon_vqdmlsl): Likewise.
+	(neon_vmull): Likewise.
+	(neon_vqdmull): Remove "Magic Word" operand.
+	(neon_vsub): Remove "Magic Word" operand.
+	(neon_vsubl): Remove "Magic Word" operand, convert to use
+	signed/unsigned iterator.
+	(neon_vsubw): Likewise.
+	(neon_vhsub): Likewise.
+	(neon_vqsub): Likewise.
+	(neon_v<r>subhn): Remove "Magic Word" operand, convert to iterate
+	over "rounding" forms.
+	(neon_vceq): Remove "Magic Word" operand.
+	(neon_vcge): Likewise.
+	(neon_vcgeu): Likewise.
+	(neon_vcgt): Likewise.
+	(neon_vcgtu): Likewise.
+	(neon_vcle): Likewise.
+	(neon_vclt): Likewise.
+	(neon_vcage): Likewise.
+	(neon_vcagt): Likewise.
+	(neon_vabd): Remove "Magic Word" operand, iterate over
+	signed/unsigned forms, and split out...
+	(neon_vabdf): ...this as new.
+	(neon_vabdl): Remove "Magic Word" operand, iterate over
+	signed/unsigned forms.
+	(neon_vaba): Likewise.
+	(neon_vmax): Remove "Magic Word" operand, iterate over
+	signed/unsigned and max/min forms, and split out...
+	(neon_v<maxmin>f): ...this as new.
+	(neon_vmin): Delete.
+	(neon_vpadd): Remove "Magic Word" operand.
+	(neon_vpaddl): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vpadal): Likewise.
+	(neon_vpmax): Remove "Magic Word" operand, iterate over
+	signed/unsigned and max/min forms, and split out...
+	(neon_vp<maxmin>f): ...this as new.
+	(neon_vpmin): Delete.
+	(neon_vrecps): Remove "Magic Word" operand.
+	(neon_vrsqrts): Likewise.
+	(neon_vabs): Likewise.
+	(neon_vqabs): Likewise.
+	(neon_vneg): Likewise.
+	(neon_vqneg): Likewise.
+	(neon_vcls): Likewise.
+	(neon_vcnt): Likewise.
+	(neon_vrecpe): Likewise.
+	(neon_vrsqrte): Likewise.
+	(neon_vmvn): Likewise.
+	(neon_vget_lane): Likewise.
+	(neon_vget_laneu): New.
+	(neon_vget_lanedi): Remove "Magic Word" operand.
+	(neon_vget_lanev2di): Likewise.
+	(neon_vcvt): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vcvt_n): Likewise.
+	(neon_vmovn): Remove "Magic Word" operand.
+	(neon_vqmovn): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vmovun): Remove "Magic Word" operand.
+	(neon_vmovl): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vmul_lane): Remove "Magic Word" operand.
+	(neon_vmull_lane): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vqdmull_lane): Remove "Magic Word" operand.
+	(neon_vqdmulh_lane): Remove "Magic Word" operand, iterate over
+	rounding variants.
+	(neon_vmla_lane): Remove "Magic Word" operand.
+	(neon_vmlal_lane): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vqdmlal_lane): Remove "Magic Word" operand.
+	(neon_vmls_lane): Likewise.
+	(neon_vmlsl_lane): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vqdmlsl_lane): Remove "Magic Word" operand.
+	(neon_vmul_n): Remove "Magic Word" operand.
+	(neon_vmull_n): Rename to...
+	(neon_vmulls_n): ...this, remove "Magic Word" operand.
+	(neon_vmullu_n): New.
+	(neon_vqdmull_n): Remove "Magic Word" operand.
+	(neon_vqdmulh_n): Likewise.
+	(neon_vqrdmulh_n): New.
+	(neon_vmla_n): Remove "Magic Word" operand.
+	(neon_vmls_n): Likewise.
+	(neon_vmlal_n): Rename to...
+	(neon_vmlals_n): ...this, remove "Magic Word" operand.
+	(neon_vmlalu_n): New.
+	(neon_vqdmlal_n): Remove "Magic Word" operand.
+	(neon_vmlsl_n): Rename to...
+	(neon_vmlsls_n): ...this, remove "Magic Word" operand.
+	(neon_vmlslu_n): New.
+	(neon_vqdmlsl_n): Remove "Magic Word" operand.
+	(neon_vrev64): Remove "Magic Word" operand.
+	(neon_vrev32): Likewise.
+	(neon_vrev16): Likewise.
+	(neon_vshl): Remove "Magic Word" operand, iterate over
+	signed/unsigned and "rounding" forms.
+	(neon_vqshl): Likewise.
+	(neon_vshr_n): Likewise.
+	(neon_vshrn_n): Remove "Magic Word" operand, iterate over
+	"rounding" forms.
+	(neon_vqshrn_n): Remove "Magic Word" operand, iterate over
+	signed/unsigned and "rounding" forms.
+	(neon_vqshrun_n): Remove "Magic Word" operand, iterate over
+	"rounding" forms.
+	(neon_vshl_n): Remove "Magic Word" operand.
+	(neon_vqshl_n): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vqshlu_n): Remove "Magic Word" operand.
+	(neon_vshll_n): Remove "Magic Word" operand, iterate over
+	signed/unsigned variants.
+	(neon_vsra_n): Remove "Magic Word" operand, iterate over
+	signed/unsigned and "rounding" forms.
+	* config/arm/iterators.md (VPF): New.
+	(VADDL): Likewise.
+	(VADDW): Likewise.
+	(VHADD): Likewise.
+	(VQADD): Likewise.
+	(VADDHN): Likewise.
+	(VMLAL): Likewise.
+	(VMLAL_LANE): Likewise.
+	(VLMSL): Likewise.
+	(VMLSL_LANE): Likewise.
+	(VQDMULH): Likewise,
+	(VQDMULH_LANE): Likewise.
+	(VMULL): Likewise.
+	(VMULL_LANE): Likewise.
+	(VSUBL): Likewise.
+	(VSUBW): Likewise.
+	(VHSUB): Likewise.
+	(VQSUB): Likewise.
+	(VSUBHN): Likewise.
+	(VABD): Likewise.
+	(VABDL): Likewise.
+	(VMAXMIN): Likewise.
+	(VMAXMINF): Likewise.
+	(VPADDL): Likewise.
+	(VPADAL): Likewise.
+	(VPMAXMIN): Likewise.
+	(VPMAXMINF): Likewise.
+	(VCVT_US): Likewise.
+	(VCVT_US_N): Likewise.
+	(VQMOVN): Likewise.
+	(VMOVL): Likewise.
+	(VSHL): Likewise.
+	(VQSHL): Likewise.
+	(VSHR_N): Likewise.
+	(VSHRN_N): Likewise.
+	(VQSHRN_N): Likewise.
+	(VQSHRUN_N): Likewise.
+	(VQSHL_N): Likewise.
+	(VSHLL_N): Likewise.
+	(VSRA_N): Likewise.
+	(pf): Likewise.
+	(sup): Likewise.
+	(r): Liekwise.
+	(maxmin): Likewise.
+	(shift_op): Likewise.
+	* config/arm/arm_neon_builtins.def (vaddl): Split to...
+	(vaddls): ...this and...
+	(vaddlu): ...this.
+	(vaddw): Split to...
+	(vaddws): ...this and...
+	(vaddwu): ...this.
+	(vhadd): Split to...
+	(vhadds): ...this and...
+	(vhaddu): ...this and...
+	(vrhadds): ...this and...
+	(vrhaddu): ...this.
+	(vqadd): Split to...
+	(vqadds): ...this and...
+	(vqaddu): ...this.
+	(vaddhn): Split to itself and...
+	(vraddhn): ...this.
+	(vmul): Split to...
+	(vmulf): ...this and...
+	(vmulp): ...this.
+	(vmlal): Split to...
+	(vmlals): ...this and...
+	(vmlalu): ...this.
+	(vmlsl): Split to...
+	(vmlsls): ...this and...
+	(vmlslu): ...this.
+	(vqdmulh): Split to itself and...
+	(vqrdmulh): ...this.
+	(vmull): Split to...
+	(vmullp): ...this and...
+	(vmulls): ...this and...
+	(vmullu): ...this.
+	(vmull_n): Split to...
+	(vmulls_n): ...this and...
+	(vmullu_n): ...this.
+	(vmull_lane): Split to...
+	(vmulls_lane): ...this and...
+	(vmullu_lane): ...this.
+	(vqdmulh_n): Split to itself and...
+	(vqrdmulh_n): ...this.
+	(vqdmulh_lane): Split to itself and...
+	(vqrdmulh_lane): ...this.
+	(vshl): Split to...
+	(vshls): ...this and...
+	(vshlu): ...this and...
+	(vrshls): ...this and...
+	(vrshlu): ...this.
+	(vqshl): Split to...
+	(vqshls): ...this and...
+	(vqrshlu): ...this and...
+	(vqrshls): ...this and...
+	(vqrshlu): ...this.
+	(vshr_n): Split to...
+	(vshrs_n): ...this and...
+	(vshru_n): ...this and...
+	(vrshrs_n): ...this and...
+	(vrshru_n): ...this.
+	(vshrn_n): Split to itself and...
+	(vrshrn_n): ...this.
+	(vqshrn_n): Split to...
+	(vqshrns_n): ...this and...
+	(vqshrnu_n): ...this and...
+	(vqrshrns_n): ...this and...
+	(vqrshrnu_n): ...this.
+	(vqshrun_n): Split to itself and...
+	(vqrshrun_n): ...this.
+	(vqshl_n): Split to...
+	(vqshl_s_n): ...this and...
+	(vqshl_u_n): ...this.
+	(vshll_n): Split to...
+	(vshlls_n): ...this and...
+	(vshllu_n): ...this.
+	(vsra_n): Split to...
+	(vsras_n): ...this and...
+	(vsrau_n): ...this and.
+	(vrsras_n): ...this and...
+	(vrsrau_n): ...this and.
+	(vsubl): Split to...
+	(vsubls): ...this and...
+	(vsublu): ...this.
+	(vsubw): Split to...
+	(vsubws): ...this and...
+	(vsubwu): ...this.
+	(vqsub): Split to...
+	(vqsubs): ...this and...
+	(vqsubu): ...this.
+	(vhsub): Split to...
+	(vhsubs): ...this and...
+	(vhsubu): ...this.
+	(vsubhn): Split to itself and...
+	(vrsubhn): ...this.
+	(vabd): Split to...
+	(vabds): ...this and...
+	(vabdu): ...this and...
+	(vabdf): ...this.
+	(vabdl): Split to...
+	(vabdls): ...this and...
+	(vabdlu): ...this.
+	(vaba): Split to...
+	(vabas): ...this and...
+	(vabau): ...this and...
+	(vabal): Split to...
+	(vabals): ...this and...
+	(vabalu): ...this.
+	(vmax): Split to...
+	(vmaxs): ...this and...
+	(vmaxu): ...this and...
+	(vmaxf): ...this.
+	(vmin): Split to...
+	(vmins): ...this and...
+	(vminu): ...this and...
+	(vminf): ...this.
+	(vpmax): Split to...
+	(vpmaxs): ...this and...
+	(vpmaxu): ...this and...
+	(vpmaxf): ...this.
+	(vpmin): Split to...
+	(vpmins): ...this and...
+	(vpminu): ...this and...
+	(vpminf): ...this.
+	(vpaddl): Split to...
+	(vpaddls): ...this and...
+	(vpaddlu): ...this.
+	(vpadal): Split to...
+	(vpadals): ...this and...
+	(vpadalu): ...this.
+	(vget_laneu): New.
+	(vqmovn): Split to...
+	(vqmovns): ...this and...
+	(vqmovnu): ...this.
+	(vmovl): Split to...
+	(vmovls): ...this and...
+	(vmovlu): ...this.
+	(vmlal_lane): Split to...
+	(vmlals_lane): ...this and...
+	(vmlalu_lane): ...this.
+	(vmlsl_lane): Split to...
+	(vmlsls_lane): ...this and...
+	(vmlslu_lane): ...this.
+	(vmlal_n): Split to...
+	(vmlals_n): ...this and...
+	(vmlalu_n): ...this.
+	(vmlsl_n): Split to...
+	(vmlsls_n): ...this and...
+	(vmlslu_n): ...this.
+	(vext): Make type "SHIFTINSERT".
+	(vcvt): Split to...
+	(vcvts): ...this and...
+	(vcvtu): ...this.
+	(vcvt_n): Split to...
+	(vcvts_n): ...this and...
+	(vcvtu_n): ...this.
+	* config/arm/arm_neon.h (vaddl_s8): Remove "Magic Word".
+	(vaddl_s16): Likewise.
+	(vaddl_s32): Likewise.
+	(vaddl_u8): Likewise.
+	(vaddl_u16): Likewise.
+	(vaddl_u32): Likewise.
+	(vaddw_s8): Likewise.
+	(vaddw_s16): Likewise.
+	(vaddw_s32): Likewise.
+	(vaddw_u8): Likewise.
+	(vaddw_u16): Likewise.
+	(vaddw_u32): Likewise.
+	(vhadd_s8): Likewise.
+	(vhadd_s16): Likewise.
+	(vhadd_s32): Likewise.
+	(vhadd_u8): Likewise.
+	(vhadd_u16): Likewise.
+	(vhadd_u32): Likewise.
+	(vhaddq_s8): Likewise.
+	(vhaddq_s16): Likewise.
+	(vhaddq_s32): Likewise.
+	(vhaddq_u8): Likewise.
+	(vhaddq_u16): Likewise.
+	(vrhadd_s8): Likewise.
+	(vrhadd_s16): Likewise.
+	(vrhadd_s32): Likewise.
+	(vrhadd_u8): Likewise.
+	(vrhadd_u16): Likewise.
+	(vrhadd_u32): Likewise.
+	(vrhaddq_s8): Likewise.
+	(vrhaddq_s16): Likewise.
+	(vrhaddq_s32): Likewise.
+	(vrhaddq_u8): Likewise.
+	(vrhaddq_u16): Likewise.
+	(vrhaddq_u32): Likewise.
+	(vqadd_s8): Likewise.
+	(vqadd_s16): Likewise.
+	(vqadd_s32): Likewise.
+	(vqadd_s64): Likewise.
+	(vqadd_u8): Likewise.
+	(vqadd_u16): Likewise.
+	(vqadd_u32): Likewise.
+	(vqadd_u64): Likewise.
+	(vqaddq_s8): Likewise.
+	(vqaddq_s16): Likewise.
+	(vqaddq_s32): Likewise.
+	(vqaddq_s64): Likewise.
+	(vqaddq_u8): Likewise.
+	(vqaddq_u16): Likewise.
+	(vqaddq_u32): Likewise.
+	(vqaddq_u64): Likewise.
+	(vaddhn_s16): Likewise.
+	(vaddhn_s32): Likewise.
+	(vaddhn_s64): Likewise.
+	(vaddhn_u16): Likewise.
+	(vaddhn_u32): Likewise.
+	(vaddhn_u64): Likewise.
+	(vraddhn_s16): Likewise.
+	(vraddhn_s32): Likewise.
+	(vraddhn_s64): Likewise.
+	(vraddhn_u16): Likewise.
+	(vraddhn_u32): Likewise.
+	(vraddhn_u64): Likewise.
+	(vmul_p8): Likewise.
+	(vmulq_p8): Likewise.
+	(vqdmulh_s16): Likewise.
+	(vqdmulh_s32): Likewise.
+	(vqdmulhq_s16): Likewise.
+	(vqdmulhq_s32): Likewise.
+	(vqrdmulh_s16): Likewise.
+	(vqrdmulh_s32): Likewise.
+	(vqrdmulhq_s16): Likewise.
+	(vqrdmulhq_s32): Likewise.
+	(vmull_s8): Likewise.
+	(vmull_s16): Likewise.
+	(vmull_s32): Likewise.
+	(vmull_u8): Likewise.
+	(vmull_u16): Likewise.
+	(vmull_u32): Likewise.
+	(vmull_p8): Likewise.
+	(vqdmull_s16): Likewise.
+	(vqdmull_s32): Likewise.
+	(vmla_s8): Likewise.
+	(vmla_s16): Likewise.
+	(vmla_s32): Likewise.
+	(vmla_f32): Likewise.
+	(vmla_u8): Likewise.
+	(vmla_u16): Likewise.
+	(vmla_u32): Likewise.
+	(vmlaq_s8): Likewise.
+	(vmlaq_s16): Likewise.
+	(vmlaq_s32): Likewise.
+	(vmlaq_f32): Likewise.
+	(vmlaq_u8): Likewise.
+	(vmlaq_u16): Likewise.
+	(vmlaq_u32): Likewise.
+	(vmlal_s8): Likewise.
+	(vmlal_s16): Likewise.
+	(vmlal_s32): Likewise.
+	(vmlal_u8): Likewise.
+	(vmlal_u16): Likewise.
+	(vmlal_u32): Likewise.
+	(vqdmlal_s16): Likewise.
+	(vqdmlal_s32): Likewise.
+	(vmls_s8): Likewise.
+	(vmls_s16): Likewise.
+	(vmls_s32): Likewise.
+	(vmls_f32): Likewise.
+	(vmls_u8): Likewise.
+	(vmls_u16): Likewise.
+	(vmls_u32): Likewise.
+	(vmlsq_s8): Likewise.
+	(vmlsq_s16): Likewise.
+	(vmlsq_s32): Likewise.
+	(vmlsq_f32): Likewise.
+	(vmlsq_u8): Likewise.
+	(vmlsq_u16): Likewise.
+	(vmlsq_u32): Likewise.
+	(vmlsl_s8): Likewise.
+	(vmlsl_s16): Likewise.
+	(vmlsl_s32): Likewise.
+	(vmlsl_u8): Likewise.
+	(vmlsl_u16): Likewise.
+	(vmlsl_u32): Likewise.
+	(vqdmlsl_s16): Likewise.
+	(vqdmlsl_s32): Likewise.
+	(vfma_f32): Likewise.
+	(vfmaq_f32): Likewise.
+	(vfms_f32): Likewise.
+	(vfmsq_f32): Likewise.
+	(vsubl_s8): Likewise.
+	(vsubl_s16): Likewise.
+	(vsubl_s32): Likewise.
+	(vsubl_u8): Likewise.
+	(vsubl_u16): Likewise.
+	(vsubl_u32): Likewise.
+	(vsubw_s8): Likewise.
+	(vsubw_s16): Likewise.
+	(vsubw_s32): Likewise.
+	(vsubw_u8): Likewise.
+	(vsubw_u16): Likewise.
+	(vsubw_u32): Likewise.
+	(vhsub_s8): Likewise.
+	(vhsub_s16): Likewise.
+	(vhsub_s32): Likewise.
+	(vhsub_u8): Likewise.
+	(vhsub_u16): Likewise.
+	(vhsub_u32): Likewise.
+	(vhsubq_s8): Likewise.
+	(vhsubq_s16): Likewise.
+	(vhsubq_s32): Likewise.
+	(vhsubq_u8): Likewise.
+	(vhsubq_u16): Likewise.
+	(vhsubq_u32): Likewise.
+	(vqsub_s8): Likewise.
+	(vqsub_s16): Likewise.
+	(vqsub_s32): Likewise.
+	(vqsub_s64): Likewise.
+	(vqsub_u8): Likewise.
+	(vqsub_u16): Likewise.
+	(vqsub_u32): Likewise.
+	(vqsub_u64): Likewise.
+	(vqsubq_s8): Likewise.
+	(vqsubq_s16): Likewise.
+	(vqsubq_s32): Likewise.
+	(vqsubq_s64): Likewise.
+	(vqsubq_u8): Likewise.
+	(vqsubq_u16): Likewise.
+	(vqsubq_u32): Likewise.
+	(vqsubq_u64): Likewise.
+	(vsubhn_s16): Likewise.
+	(vsubhn_s32): Likewise.
+	(vsubhn_s64): Likewise.
+	(vsubhn_u16): Likewise.
+	(vsubhn_u32): Likewise.
+	(vsubhn_u64): Likewise.
+	(vrsubhn_s16): Likewise.
+	(vrsubhn_s32): Likewise.
+	(vrsubhn_s64): Likewise.
+	(vrsubhn_u16): Likewise.
+	(vrsubhn_u32): Likewise.
+	(vrsubhn_u64): Likewise.
+	(vceq_s8): Likewise.
+	(vceq_s16): Likewise.
+	(vceq_s32): Likewise.
+	(vceq_f32): Likewise.
+	(vceq_u8): Likewise.
+	(vceq_u16): Likewise.
+	(vceq_u32): Likewise.
+	(vceq_p8): Likewise.
+	(vceqq_s8): Likewise.
+	(vceqq_s16): Likewise.
+	(vceqq_s32): Likewise.
+	(vceqq_f32): Likewise.
+	(vceqq_u8): Likewise.
+	(vceqq_u16): Likewise.
+	(vceqq_u32): Likewise.
+	(vceqq_p8): Likewise.
+	(vcge_s8): Likewise.
+	(vcge_s16): Likewise.
+	(vcge_s32): Likewise.
+	(vcge_f32): Likewise.
+	(vcge_u8): Likewise.
+	(vcge_u16): Likewise.
+	(vcge_u32): Likewise.
+	(vcgeq_s8): Likewise.
+	(vcgeq_s16): Likewise.
+	(vcgeq_s32): Likewise.
+	(vcgeq_f32): Likewise.
+	(vcgeq_u8): Likewise.
+	(vcgeq_u16): Likewise.
+	(vcgeq_u32): Likewise.
+	(vcle_s8): Likewise.
+	(vcle_s16): Likewise.
+	(vcle_s32): Likewise.
+	(vcle_f32): Likewise.
+	(vcle_u8): Likewise.
+	(vcle_u16): Likewise.
+	(vcle_u32): Likewise.
+	(vcleq_s8): Likewise.
+	(vcleq_s16): Likewise.
+	(vcleq_s32): Likewise.
+	(vcleq_f32): Likewise.
+	(vcleq_u8): Likewise.
+	(vcleq_u16): Likewise.
+	(vcleq_u32): Likewise.
+	(vcgt_s8): Likewise.
+	(vcgt_s16): Likewise.
+	(vcgt_s32): Likewise.
+	(vcgt_f32): Likewise.
+	(vcgt_u8): Likewise.
+	(vcgt_u16): Likewise.
+	(vcgt_u32): Likewise.
+	(vcgtq_s8): Likewise.
+	(vcgtq_s16): Likewise.
+	(vcgtq_s32): Likewise.
+	(vcgtq_f32): Likewise.
+	(vcgtq_u8): Likewise.
+	(vcgtq_u16): Likewise.
+	(vcgtq_u32): Likewise.
+	(vclt_s8): Likewise.
+	(vclt_s16): Likewise.
+	(vclt_s32): Likewise.
+	(vclt_f32): Likewise.
+	(vclt_u8): Likewise.
+	(vclt_u16): Likewise.
+	(vclt_u32): Likewise.
+	(vcltq_s8): Likewise.
+	(vcltq_s16): Likewise.
+	(vcltq_s32): Likewise.
+	(vcltq_f32): Likewise.
+	(vcltq_u8): Likewise.
+	(vcltq_u16): Likewise.
+	(vcltq_u32): Likewise.
+	(vcage_f32): Likewise.
+	(vcageq_f32): Likewise.
+	(vcale_f32): Likewise.
+	(vcaleq_f32): Likewise.
+	(vcagt_f32): Likewise.
+	(vcagtq_f32): Likewise.
+	(vcalt_f32): Likewise.
+	(vcaltq_f32): Likewise.
+	(vtst_s8): Likewise.
+	(vtst_s16): Likewise.
+	(vtst_s32): Likewise.
+	(vtst_u8): Likewise.
+	(vtst_u16): Likewise.
+	(vtst_u32): Likewise.
+	(vtst_p8): Likewise.
+	(vtstq_s8): Likewise.
+	(vtstq_s16): Likewise.
+	(vtstq_s32): Likewise.
+	(vtstq_u8): Likewise.
+	(vtstq_u16): Likewise.
+	(vtstq_u32): Likewise.
+	(vtstq_p8): Likewise.
+	(vabd_s8): Likewise.
+	(vabd_s16): Likewise.
+	(vabd_s32): Likewise.
+	(vabd_f32): Likewise.
+	(vabd_u8): Likewise.
+	(vabd_u16): Likewise.
+	(vabd_u32): Likewise.
+	(vabdq_s8): Likewise.
+	(vabdq_s16): Likewise.
+	(vabdq_s32): Likewise.
+	(vabdq_f32): Likewise.
+	(vabdq_u8): Likewise.
+	(vabdq_u16): Likewise.
+	(vabdq_u32): Likewise.
+	(vabdl_s8): Likewise.
+	(vabdl_s16): Likewise.
+	(vabdl_s32): Likewise.
+	(vabdl_u8): Likewise.
+	(vabdl_u16): Likewise.
+	(vabdl_u32): Likewise.
+	(vaba_s8): Likewise.
+	(vaba_s16): Likewise.
+	(vaba_s32): Likewise.
+	(vaba_u8): Likewise.
+	(vaba_u16): Likewise.
+	(vaba_u32): Likewise.
+	(vabaq_s8): Likewise.
+	(vabaq_s16): Likewise.
+	(vabaq_s32): Likewise.
+	(vabaq_u8): Likewise.
+	(vabaq_u16): Likewise.
+	(vabaq_u32): Likewise.
+	(vabal_s8): Likewise.
+	(vabal_s16): Likewise.
+	(vabal_s32): Likewise.
+	(vabal_u8): Likewise.
+	(vabal_u16): Likewise.
+	(vabal_u32): Likewise.
+	(vmax_s8): Likewise.
+	(vmax_s16): Likewise.
+	(vmax_s32): Likewise.
+	(vmax_f32): Likewise.
+	(vmax_u8): Likewise.
+	(vmax_u16): Likewise.
+	(vmax_u32): Likewise.
+	(vmaxq_s8): Likewise.
+	(vmaxq_s16): Likewise.
+	(vmaxq_s32): Likewise.
+	(vmaxq_f32): Likewise.
+	(vmaxq_u8): Likewise.
+	(vmaxq_u16): Likewise.
+	(vmaxq_u32): Likewise.
+	(vmin_s8): Likewise.
+	(vmin_s16): Likewise.
+	(vmin_s32): Likewise.
+	(vmin_f32): Likewise.
+	(vmin_u8): Likewise.
+	(vmin_u16): Likewise.
+	(vmin_u32): Likewise.
+	(vminq_s8): Likewise.
+	(vminq_s16): Likewise.
+	(vminq_s32): Likewise.
+	(vminq_f32): Likewise.
+	(vminq_u8): Likewise.
+	(vminq_u16): Likewise.
+	(vminq_u32): Likewise.
+	(vpadd_s8): Likewise.
+	(vpadd_s16): Likewise.
+	(vpadd_s32): Likewise.
+	(vpadd_f32): Likewise.
+	(vpadd_u8): Likewise.
+	(vpadd_u16): Likewise.
+	(vpadd_u32): Likewise.
+	(vpaddl_s8): Likewise.
+	(vpaddl_s16): Likewise.
+	(vpaddl_s32): Likewise.
+	(vpaddl_u8): Likewise.
+	(vpaddl_u16): Likewise.
+	(vpaddl_u32): Likewise.
+	(vpaddlq_s8): Likewise.
+	(vpaddlq_s16): Likewise.
+	(vpaddlq_s32): Likewise.
+	(vpaddlq_u8): Likewise.
+	(vpaddlq_u16): Likewise.
+	(vpaddlq_u32): Likewise.
+	(vpadal_s8): Likewise.
+	(vpadal_s16): Likewise.
+	(vpadal_s32): Likewise.
+	(vpadal_u8): Likewise.
+	(vpadal_u16): Likewise.
+	(vpadal_u32): Likewise.
+	(vpadalq_s8): Likewise.
+	(vpadalq_s16): Likewise.
+	(vpadalq_s32): Likewise.
+	(vpadalq_u8): Likewise.
+	(vpadalq_u16): Likewise.
+	(vpadalq_u32): Likewise.
+	(vpmax_s8): Likewise.
+	(vpmax_s16): Likewise.
+	(vpmax_s32): Likewise.
+	(vpmax_f32): Likewise.
+	(vpmax_u8): Likewise.
+	(vpmax_u16): Likewise.
+	(vpmax_u32): Likewise.
+	(vpmin_s8): Likewise.
+	(vpmin_s16): Likewise.
+	(vpmin_s32): Likewise.
+	(vpmin_f32): Likewise.
+	(vpmin_u8): Likewise.
+	(vpmin_u16): Likewise.
+	(vpmin_u32): Likewise.
+	(vrecps_f32): Likewise.
+	(vrecpsq_f32): Likewise.
+	(vrsqrts_f32): Likewise.
+	(vrsqrtsq_f32): Likewise.
+	(vshl_s8): Likewise.
+	(vshl_s16): Likewise.
+	(vshl_s32): Likewise.
+	(vshl_s64): Likewise.
+	(vshl_u8): Likewise.
+	(vshl_u16): Likewise.
+	(vshl_u32): Likewise.
+	(vshl_u64): Likewise.
+	(vshlq_s8): Likewise.
+	(vshlq_s16): Likewise.
+	(vshlq_s32): Likewise.
+	(vshlq_s64): Likewise.
+	(vshlq_u8): Likewise.
+	(vshlq_u16): Likewise.
+	(vshlq_u32): Likewise.
+	(vshlq_u64): Likewise.
+	(vrshl_s8): Likewise.
+	(vrshl_s16): Likewise.
+	(vrshl_s32): Likewise.
+	(vrshl_s64): Likewise.
+	(vrshl_u8): Likewise.
+	(vrshl_u16): Likewise.
+	(vrshl_u32): Likewise.
+	(vrshl_u64): Likewise.
+	(vrshlq_s8): Likewise.
+	(vrshlq_s16): Likewise.
+	(vrshlq_s32): Likewise.
+	(vrshlq_s64): Likewise.
+	(vrshlq_u8): Likewise.
+	(vrshlq_u16): Likewise.
+	(vrshlq_u32): Likewise.
+	(vrshlq_u64): Likewise.
+	(vqshl_s8): Likewise.
+	(vqshl_s16): Likewise.
+	(vqshl_s32): Likewise.
+	(vqshl_s64): Likewise.
+	(vqshl_u8): Likewise.
+	(vqshl_u16): Likewise.
+	(vqshl_u32): Likewise.
+	(vqshl_u64): Likewise.
+	(vqshlq_s8): Likewise.
+	(vqshlq_s16): Likewise.
+	(vqshlq_s32): Likewise.
+	(vqshlq_s64): Likewise.
+	(vqshlq_u8): Likewise.
+	(vqshlq_u16): Likewise.
+	(vqshlq_u32): Likewise.
+	(vqshlq_u64): Likewise.
+	(vqrshl_s8): Likewise.
+	(vqrshl_s16): Likewise.
+	(vqrshl_s32): Likewise.
+	(vqrshl_s64): Likewise.
+	(vqrshl_u8): Likewise.
+	(vqrshl_u16): Likewise.
+	(vqrshl_u32): Likewise.
+	(vqrshl_u64): Likewise.
+	(vqrshlq_s8): Likewise.
+	(vqrshlq_s16): Likewise.
+	(vqrshlq_s32): Likewise.
+	(vqrshlq_s64): Likewise.
+	(vqrshlq_u8): Likewise.
+	(vqrshlq_u16): Likewise.
+	(vqrshlq_u32): Likewise.
+	(vqrshlq_u64): Likewise.
+	(vshr_n_s8): Likewise.
+	(vshr_n_s16): Likewise.
+	(vshr_n_s32): Likewise.
+	(vshr_n_s64): Likewise.
+	(vshr_n_u8): Likewise.
+	(vshr_n_u16): Likewise.
+	(vshr_n_u32): Likewise.
+	(vshr_n_u64): Likewise.
+	(vshrq_n_s8): Likewise.
+	(vshrq_n_s16): Likewise.
+	(vshrq_n_s32): Likewise.
+	(vshrq_n_s64): Likewise.
+	(vshrq_n_u8): Likewise.
+	(vshrq_n_u16): Likewise.
+	(vshrq_n_u32): Likewise.
+	(vshrq_n_u64): Likewise.
+	(vrshr_n_s8): Likewise.
+	(vrshr_n_s16): Likewise.
+	(vrshr_n_s32): Likewise.
+	(vrshr_n_s64): Likewise.
+	(vrshr_n_u8): Likewise.
+	(vrshr_n_u16): Likewise.
+	(vrshr_n_u32): Likewise.
+	(vrshr_n_u64): Likewise.
+	(vrshrq_n_s8): Likewise.
+	(vrshrq_n_s16): Likewise.
+	(vrshrq_n_s32): Likewise.
+	(vrshrq_n_s64): Likewise.
+	(vrshrq_n_u8): Likewise.
+	(vrshrq_n_u16): Likewise.
+	(vrshrq_n_u32): Likewise.
+	(vrshrq_n_u64): Likewise.
+	(vshrn_n_s16): Likewise.
+	(vshrn_n_s32): Likewise.
+	(vshrn_n_s64): Likewise.
+	(vshrn_n_u16): Likewise.
+	(vshrn_n_u32): Likewise.
+	(vshrn_n_u64): Likewise.
+	(vrshrn_n_s16): Likewise.
+	(vrshrn_n_s32): Likewise.
+	(vrshrn_n_s64): Likewise.
+	(vrshrn_n_u16): Likewise.
+	(vrshrn_n_u32): Likewise.
+	(vrshrn_n_u64): Likewise.
+	(vqshrn_n_s16): Likewise.
+	(vqshrn_n_s32): Likewise.
+	(vqshrn_n_s64): Likewise.
+	(vqshrn_n_u16): Likewise.
+	(vqshrn_n_u32): Likewise.
+	(vqshrn_n_u64): Likewise.
+	(vqrshrn_n_s16): Likewise.
+	(vqrshrn_n_s32): Likewise.
+	(vqrshrn_n_s64): Likewise.
+	(vqrshrn_n_u16): Likewise.
+	(vqrshrn_n_u32): Likewise.
+	(vqrshrn_n_u64): Likewise.
+	(vqshrun_n_s16): Likewise.
+	(vqshrun_n_s32): Likewise.
+	(vqshrun_n_s64): Likewise.
+	(vqrshrun_n_s16): Likewise.
+	(vqrshrun_n_s32): Likewise.
+	(vqrshrun_n_s64): Likewise.
+	(vshl_n_s8): Likewise.
+	(vshl_n_s16): Likewise.
+	(vshl_n_s32): Likewise.
+	(vshl_n_s64): Likewise.
+	(vshl_n_u8): Likewise.
+	(vshl_n_u16): Likewise.
+	(vshl_n_u32): Likewise.
+	(vshl_n_u64): Likewise.
+	(vshlq_n_s8): Likewise.
+	(vshlq_n_s16): Likewise.
+	(vshlq_n_s32): Likewise.
+	(vshlq_n_s64): Likewise.
+	(vshlq_n_u8): Likewise.
+	(vshlq_n_u16): Likewise.
+	(vshlq_n_u32): Likewise.
+	(vshlq_n_u64): Likewise.
+	(vqshl_n_s8): Likewise.
+	(vqshl_n_s16): Likewise.
+	(vqshl_n_s32): Likewise.
+	(vqshl_n_s64): Likewise.
+	(vqshl_n_u8): Likewise.
+	(vqshl_n_u16): Likewise.
+	(vqshl_n_u32): Likewise.
+	(vqshl_n_u64): Likewise.
+	(vqshlq_n_s8): Likewise.
+	(vqshlq_n_s16): Likewise.
+	(vqshlq_n_s32): Likewise.
+	(vqshlq_n_s64): Likewise.
+	(vqshlq_n_u8): Likewise.
+	(vqshlq_n_u16): Likewise.
+	(vqshlq_n_u32): Likewise.
+	(vqshlq_n_u64): Likewise.
+	(vqshlu_n_s8): Likewise.
+	(vqshlu_n_s16): Likewise.
+	(vqshlu_n_s32): Likewise.
+	(vqshlu_n_s64): Likewise.
+	(vqshluq_n_s8): Likewise.
+	(vqshluq_n_s16): Likewise.
+	(vqshluq_n_s32): Likewise.
+	(vqshluq_n_s64): Likewise.
+	(vshll_n_s8): Likewise.
+	(vshll_n_s16): Likewise.
+	(vshll_n_s32): Likewise.
+	(vshll_n_u8): Likewise.
+	(vshll_n_u16): Likewise.
+	(vshll_n_u32): Likewise.
+	(vsra_n_s8): Likewise.
+	(vsra_n_s16): Likewise.
+	(vsra_n_s32): Likewise.
+	(vsra_n_s64): Likewise.
+	(vsra_n_u8): Likewise.
+	(vsra_n_u16): Likewise.
+	(vsra_n_u32): Likewise.
+	(vsra_n_u64): Likewise.
+	(vsraq_n_s8): Likewise.
+	(vsraq_n_s16): Likewise.
+	(vsraq_n_s32): Likewise.
+	(vsraq_n_s64): Likewise.
+	(vsraq_n_u8): Likewise.
+	(vsraq_n_u16): Likewise.
+	(vsraq_n_u32): Likewise.
+	(vsraq_n_u64): Likewise.
+	(vrsra_n_s8): Likewise.
+	(vrsra_n_s16): Likewise.
+	(vrsra_n_s32): Likewise.
+	(vrsra_n_s64): Likewise.
+	(vrsra_n_u8): Likewise.
+	(vrsra_n_u16): Likewise.
+	(vrsra_n_u32): Likewise.
+	(vrsra_n_u64): Likewise.
+	(vrsraq_n_s8): Likewise.
+	(vrsraq_n_s16): Likewise.
+	(vrsraq_n_s32): Likewise.
+	(vrsraq_n_s64): Likewise.
+	(vrsraq_n_u8): Likewise.
+	(vrsraq_n_u16): Likewise.
+	(vrsraq_n_u32): Likewise.
+	(vrsraq_n_u64): Likewise.
+	(vabs_s8): Likewise.
+	(vabs_s16): Likewise.
+	(vabs_s32): Likewise.
+	(vabs_f32): Likewise.
+	(vabsq_s8): Likewise.
+	(vabsq_s16): Likewise.
+	(vabsq_s32): Likewise.
+	(vabsq_f32): Likewise.
+	(vqabs_s8): Likewise.
+	(vqabs_s16): Likewise.
+	(vqabs_s32): Likewise.
+	(vqabsq_s8): Likewise.
+	(vqabsq_s16): Likewise.
+	(vqabsq_s32): Likewise.
+	(vneg_s8): Likewise.
+	(vneg_s16): Likewise.
+	(vneg_s32): Likewise.
+	(vneg_f32): Likewise.
+	(vnegq_s8): Likewise.
+	(vnegq_s16): Likewise.
+	(vnegq_s32): Likewise.
+	(vnegq_f32): Likewise.
+	(vqneg_s8): Likewise.
+	(vqneg_s16): Likewise.
+	(vqneg_s32): Likewise.
+	(vqnegq_s8): Likewise.
+	(vqnegq_s16): Likewise.
+	(vqnegq_s32): Likewise.
+	(vmvn_s8): Likewise.
+	(vmvn_s16): Likewise.
+	(vmvn_s32): Likewise.
+	(vmvn_u8): Likewise.
+	(vmvn_u16): Likewise.
+	(vmvn_u32): Likewise.
+	(vmvn_p8): Likewise.
+	(vmvnq_s8): Likewise.
+	(vmvnq_s16): Likewise.
+	(vmvnq_s32): Likewise.
+	(vmvnq_u8): Likewise.
+	(vmvnq_u16): Likewise.
+	(vmvnq_u32): Likewise.
+	(vmvnq_p8): Likewise.
+	(vcls_s8): Likewise.
+	(vcls_s16): Likewise.
+	(vcls_s32): Likewise.
+	(vclsq_s8): Likewise.
+	(vclsq_s16): Likewise.
+	(vclsq_s32): Likewise.
+	(vclz_s8): Likewise.
+	(vclz_s16): Likewise.
+	(vclz_s32): Likewise.
+	(vclz_u8): Likewise.
+	(vclz_u16): Likewise.
+	(vclz_u32): Likewise.
+	(vclzq_s8): Likewise.
+	(vclzq_s16): Likewise.
+	(vclzq_s32): Likewise.
+	(vclzq_u8): Likewise.
+	(vclzq_u16): Likewise.
+	(vclzq_u32): Likewise.
+	(vcnt_s8): Likewise.
+	(vcnt_u8): Likewise.
+	(vcnt_p8): Likewise.
+	(vcntq_s8): Likewise.
+	(vcntq_u8): Likewise.
+	(vcntq_p8): Likewise.
+	(vrecpe_f32): Likewise.
+	(vrecpe_u32): Likewise.
+	(vrecpeq_f32): Likewise.
+	(vrecpeq_u32): Likewise.
+	(vrsqrte_f32): Likewise.
+	(vrsqrte_u32): Likewise.
+	(vrsqrteq_f32): Likewise.
+	(vrsqrteq_u32): Likewise.
+	(vget_lane_s8): Likewise.
+	(vget_lane_s16): Likewise.
+	(vget_lane_s32): Likewise.
+	(vget_lane_f32): Likewise.
+	(vget_lane_u8): Likewise.
+	(vget_lane_u16): Likewise.
+	(vget_lane_u32): Likewise.
+	(vget_lane_p8): Likewise.
+	(vget_lane_p16): Likewise.
+	(vget_lane_s64): Likewise.
+	(vget_lane_u64): Likewise.
+	(vgetq_lane_s8): Likewise.
+	(vgetq_lane_s16): Likewise.
+	(vgetq_lane_s32): Likewise.
+	(vgetq_lane_f32): Likewise.
+	(vgetq_lane_u8): Likewise.
+	(vgetq_lane_u16): Likewise.
+	(vgetq_lane_u32): Likewise.
+	(vgetq_lane_p8): Likewise.
+	(vgetq_lane_p16): Likewise.
+	(vgetq_lane_s64): Likewise.
+	(vgetq_lane_u64): Likewise.
+	(vcvt_s32_f32): Likewise.
+	(vcvt_f32_s32): Likewise.
+	(vcvt_f32_u32): Likewise.
+	(vcvt_u32_f32): Likewise.
+	(vcvtq_s32_f32): Likewise.
+	(vcvtq_f32_s32): Likewise.
+	(vcvtq_f32_u32): Likewise.
+	(vcvtq_u32_f32): Likewise.
+	(vcvt_n_s32_f32): Likewise.
+	(vcvt_n_f32_s32): Likewise.
+	(vcvt_n_f32_u32): Likewise.
+	(vcvt_n_u32_f32): Likewise.
+	(vcvtq_n_s32_f32): Likewise.
+	(vcvtq_n_f32_s32): Likewise.
+	(vcvtq_n_f32_u32): Likewise.
+	(vcvtq_n_u32_f32): Likewise.
+	(vmovn_s16): Likewise.
+	(vmovn_s32): Likewise.
+	(vmovn_s64): Likewise.
+	(vmovn_u16): Likewise.
+	(vmovn_u32): Likewise.
+	(vmovn_u64): Likewise.
+	(vqmovn_s16): Likewise.
+	(vqmovn_s32): Likewise.
+	(vqmovn_s64): Likewise.
+	(vqmovn_u16): Likewise.
+	(vqmovn_u32): Likewise.
+	(vqmovn_u64): Likewise.
+	(vqmovun_s16): Likewise.
+	(vqmovun_s32): Likewise.
+	(vqmovun_s64): Likewise.
+	(vmovl_s8): Likewise.
+	(vmovl_s16): Likewise.
+	(vmovl_s32): Likewise.
+	(vmovl_u8): Likewise.
+	(vmovl_u16): Likewise.
+	(vmovl_u32): Likewise.
+	(vmul_lane_s16): Likewise.
+	(vmul_lane_s32): Likewise.
+	(vmul_lane_f32): Likewise.
+	(vmul_lane_u16): Likewise.
+	(vmul_lane_u32): Likewise.
+	(vmulq_lane_s16): Likewise.
+	(vmulq_lane_s32): Likewise.
+	(vmulq_lane_f32): Likewise.
+	(vmulq_lane_u16): Likewise.
+	(vmulq_lane_u32): Likewise.
+	(vmla_lane_s16): Likewise.
+	(vmla_lane_s32): Likewise.
+	(vmla_lane_f32): Likewise.
+	(vmla_lane_u16): Likewise.
+	(vmla_lane_u32): Likewise.
+	(vmlaq_lane_s16): Likewise.
+	(vmlaq_lane_s32): Likewise.
+	(vmlaq_lane_f32): Likewise.
+	(vmlaq_lane_u16): Likewise.
+	(vmlaq_lane_u32): Likewise.
+	(vmlal_lane_s16): Likewise.
+	(vmlal_lane_s32): Likewise.
+	(vmlal_lane_u16): Likewise.
+	(vmlal_lane_u32): Likewise.
+	(vqdmlal_lane_s16): Likewise.
+	(vqdmlal_lane_s32): Likewise.
+	(vmls_lane_s16): Likewise.
+	(vmls_lane_s32): Likewise.
+	(vmls_lane_f32): Likewise.
+	(vmls_lane_u16): Likewise.
+	(vmls_lane_u32): Likewise.
+	(vmlsq_lane_s16): Likewise.
+	(vmlsq_lane_s32): Likewise.
+	(vmlsq_lane_f32): Likewise.
+	(vmlsq_lane_u16): Likewise.
+	(vmlsq_lane_u32): Likewise.
+	(vmlsl_lane_s16): Likewise.
+	(vmlsl_lane_s32): Likewise.
+	(vmlsl_lane_u16): Likewise.
+	(vmlsl_lane_u32): Likewise.
+	(vqdmlsl_lane_s16): Likewise.
+	(vqdmlsl_lane_s32): Likewise.
+	(vmull_lane_s16): Likewise.
+	(vmull_lane_s32): Likewise.
+	(vmull_lane_u16): Likewise.
+	(vmull_lane_u32): Likewise.
+	(vqdmull_lane_s16): Likewise.
+	(vqdmull_lane_s32): Likewise.
+	(vqdmulhq_lane_s16): Likewise.
+	(vqdmulhq_lane_s32): Likewise.
+	(vqdmulh_lane_s16): Likewise.
+	(vqdmulh_lane_s32): Likewise.
+	(vqrdmulhq_lane_s16): Likewise.
+	(vqrdmulhq_lane_s32): Likewise.
+	(vqrdmulh_lane_s16): Likewise.
+	(vqrdmulh_lane_s32): Likewise.
+	(vmul_n_s16): Likewise.
+	(vmul_n_s32): Likewise.
+	(vmul_n_f32): Likewise.
+	(vmul_n_u16): Likewise.
+	(vmul_n_u32): Likewise.
+	(vmulq_n_s16): Likewise.
+	(vmulq_n_s32): Likewise.
+	(vmulq_n_f32): Likewise.
+	(vmulq_n_u16): Likewise.
+	(vmulq_n_u32): Likewise.
+	(vmull_n_s16): Likewise.
+	(vmull_n_s32): Likewise.
+	(vmull_n_u16): Likewise.
+	(vmull_n_u32): Likewise.
+	(vqdmull_n_s16): Likewise.
+	(vqdmull_n_s32): Likewise.
+	(vqdmulhq_n_s16): Likewise.
+	(vqdmulhq_n_s32): Likewise.
+	(vqdmulh_n_s16): Likewise.
+	(vqdmulh_n_s32): Likewise.
+	(vqrdmulhq_n_s16): Likewise.
+	(vqrdmulhq_n_s32): Likewise.
+	(vqrdmulh_n_s16): Likewise.
+	(vqrdmulh_n_s32): Likewise.
+	(vmla_n_s16): Likewise.
+	(vmla_n_s32): Likewise.
+	(vmla_n_f32): Likewise.
+	(vmla_n_u16): Likewise.
+	(vmla_n_u32): Likewise.
+	(vmlaq_n_s16): Likewise.
+	(vmlaq_n_s32): Likewise.
+	(vmlaq_n_f32): Likewise.
+	(vmlaq_n_u16): Likewise.
+	(vmlaq_n_u32): Likewise.
+	(vmlal_n_s16): Likewise.
+	(vmlal_n_s32): Likewise.
+	(vmlal_n_u16): Likewise.
+	(vmlal_n_u32): Likewise.
+	(vqdmlal_n_s16): Likewise.
+	(vqdmlal_n_s32): Likewise.
+	(vmls_n_s16): Likewise.
+	(vmls_n_s32): Likewise.
+	(vmls_n_f32): Likewise.
+	(vmls_n_u16): Likewise.
+	(vmls_n_u32): Likewise.
+	(vmlsq_n_s16): Likewise.
+	(vmlsq_n_s32): Likewise.
+	(vmlsq_n_f32): Likewise.
+	(vmlsq_n_u16): Likewise.
+	(vmlsq_n_u32): Likewise.
+	(vmlsl_n_s16): Likewise.
+	(vmlsl_n_s32): Likewise.
+	(vmlsl_n_u16): Likewise.
+	(vmlsl_n_u32): Likewise.
+	(vqdmlsl_n_s16): Likewise.
+	(vqdmlsl_n_s32): Likewise.
+
 2014-11-18  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
 
 	* config/arm/arm.c (arm_new_rtx_costs, case PLUS, MINUS):
diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
index f9c82a5..36ce387 100644
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -25535,29 +25535,26 @@ arm_expand_neon_builtin (int fcode, tree exp, rtx target)
     case NEON_CONVERT:
     case NEON_DUPLANE:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
-        NEON_ARG_COPY_TO_REG, NEON_ARG_CONSTANT, NEON_ARG_STOP);
+        NEON_ARG_COPY_TO_REG, NEON_ARG_STOP);
 
     case NEON_BINOP:
-    case NEON_SETLANE:
+    case NEON_LOGICBINOP:
     case NEON_SCALARMUL:
     case NEON_SCALARMULL:
     case NEON_SCALARMULH:
-    case NEON_SHIFTINSERT:
-    case NEON_LOGICBINOP:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
-        NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG, NEON_ARG_CONSTANT,
-        NEON_ARG_STOP);
+        NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG, NEON_ARG_STOP);
 
     case NEON_TERNOP:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
         NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG,
-        NEON_ARG_CONSTANT, NEON_ARG_STOP);
+        NEON_ARG_STOP);
 
     case NEON_GETLANE:
     case NEON_FIXCONV:
     case NEON_SHIFTIMM:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
-        NEON_ARG_COPY_TO_REG, NEON_ARG_CONSTANT, NEON_ARG_CONSTANT,
+        NEON_ARG_COPY_TO_REG, NEON_ARG_CONSTANT,
         NEON_ARG_STOP);
 
     case NEON_CREATE:
@@ -25583,24 +25580,26 @@ arm_expand_neon_builtin (int fcode, tree exp, rtx target)
     case NEON_LANEMUL:
     case NEON_LANEMULL:
     case NEON_LANEMULH:
+    case NEON_SETLANE:
+    case NEON_SHIFTINSERT:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
         NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG, NEON_ARG_CONSTANT,
-        NEON_ARG_CONSTANT, NEON_ARG_STOP);
+        NEON_ARG_STOP);
 
     case NEON_LANEMAC:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
         NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG,
-        NEON_ARG_CONSTANT, NEON_ARG_CONSTANT, NEON_ARG_STOP);
+        NEON_ARG_CONSTANT, NEON_ARG_STOP);
 
     case NEON_SHIFTACC:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
         NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG, NEON_ARG_CONSTANT,
-        NEON_ARG_CONSTANT, NEON_ARG_STOP);
+        NEON_ARG_STOP);
 
     case NEON_SCALARMAC:
       return arm_expand_neon_args (target, icode, 1, type_mode, exp, fcode,
 	NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG, NEON_ARG_COPY_TO_REG,
-        NEON_ARG_CONSTANT, NEON_ARG_STOP);
+        NEON_ARG_STOP);
 
     case NEON_SELECT:
     case NEON_VTBX:
@@ -31003,7 +31002,7 @@ static bool
 arm_evpc_neon_vrev (struct expand_vec_perm_d *d)
 {
   unsigned int i, j, diff, nelt = d->nelt;
-  rtx (*gen)(rtx, rtx, rtx);
+  rtx (*gen)(rtx, rtx);
 
   if (!d->one_vector_p)
     return false;
@@ -31067,9 +31066,7 @@ arm_evpc_neon_vrev (struct expand_vec_perm_d *d)
   if (d->testing_p)
     return true;
 
-  /* ??? The third operand is an artifact of the builtin infrastructure
-     and is ignored by the actual instruction.  */
-  emit_insn (gen (d->target, d->op0, const0_rtx));
+  emit_insn (gen (d->target, d->op0));
   return true;
 }
 
diff --git a/gcc/config/arm/arm_neon.h b/gcc/config/arm/arm_neon.h
index 47f6c5e..d27d970 100644
--- a/gcc/config/arm/arm_neon.h
+++ b/gcc/config/arm/arm_neon.h
@@ -477,7 +477,7 @@ vadd_f32 (float32x2_t __a, float32x2_t __b)
 #ifdef __FAST_MATH
   return __a + __b;
 #else
-  return (float32x2_t) __builtin_neon_vaddv2sf (__a, __b, 3);
+  return (float32x2_t) __builtin_neon_vaddv2sf (__a, __b);
 #endif
 }
 
@@ -541,7 +541,7 @@ vaddq_f32 (float32x4_t __a, float32x4_t __b)
 #ifdef __FAST_MATH
   return __a + __b;
 #else
-  return (float32x4_t) __builtin_neon_vaddv4sf (__a, __b, 3);
+  return (float32x4_t) __builtin_neon_vaddv4sf (__a, __b);
 #endif
 }
 
@@ -572,385 +572,385 @@ vaddq_u64 (uint64x2_t __a, uint64x2_t __b)
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vaddl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vaddlv8qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vaddlsv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vaddl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vaddlv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vaddlsv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vaddl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vaddlv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vaddlsv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vaddl_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vaddlv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vaddluv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vaddl_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vaddlv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vaddluv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vaddl_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vaddlv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vaddluv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vaddw_s8 (int16x8_t __a, int8x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vaddwv8qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vaddwsv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vaddw_s16 (int32x4_t __a, int16x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vaddwv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vaddwsv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vaddw_s32 (int64x2_t __a, int32x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vaddwv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vaddwsv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vaddw_u8 (uint16x8_t __a, uint8x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vaddwv8qi ((int16x8_t) __a, (int8x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vaddwuv8qi ((int16x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vaddw_u16 (uint32x4_t __a, uint16x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vaddwv4hi ((int32x4_t) __a, (int16x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vaddwuv4hi ((int32x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vaddw_u32 (uint64x2_t __a, uint32x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vaddwv2si ((int64x2_t) __a, (int32x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vaddwuv2si ((int64x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vhadd_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vhaddv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vhaddsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vhadd_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vhaddv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vhaddsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vhadd_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vhaddv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vhaddsv2si (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vhadd_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vhaddv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vhadduv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vhadd_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vhaddv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vhadduv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vhadd_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vhaddv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vhadduv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vhaddq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vhaddv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vhaddsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vhaddq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vhaddv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vhaddsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vhaddq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vhaddv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vhaddsv4si (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vhaddq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vhaddv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vhadduv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vhaddq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vhaddv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vhadduv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vhaddq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vhaddv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vhadduv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vrhadd_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vhaddv8qi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vrhaddsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vrhadd_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vhaddv4hi (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vrhaddsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vrhadd_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vhaddv2si (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vrhaddsv2si (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vrhadd_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vhaddv8qi ((int8x8_t) __a, (int8x8_t) __b, 4);
+  return (uint8x8_t)__builtin_neon_vrhadduv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vrhadd_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vhaddv4hi ((int16x4_t) __a, (int16x4_t) __b, 4);
+  return (uint16x4_t)__builtin_neon_vrhadduv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrhadd_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vhaddv2si ((int32x2_t) __a, (int32x2_t) __b, 4);
+  return (uint32x2_t)__builtin_neon_vrhadduv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vrhaddq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vhaddv16qi (__a, __b, 5);
+  return (int8x16_t)__builtin_neon_vrhaddsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vrhaddq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vhaddv8hi (__a, __b, 5);
+  return (int16x8_t)__builtin_neon_vrhaddsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vrhaddq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vhaddv4si (__a, __b, 5);
+  return (int32x4_t)__builtin_neon_vrhaddsv4si (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vrhaddq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vhaddv16qi ((int8x16_t) __a, (int8x16_t) __b, 4);
+  return (uint8x16_t)__builtin_neon_vrhadduv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vrhaddq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vhaddv8hi ((int16x8_t) __a, (int16x8_t) __b, 4);
+  return (uint16x8_t)__builtin_neon_vrhadduv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vrhaddq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vhaddv4si ((int32x4_t) __a, (int32x4_t) __b, 4);
+  return (uint32x4_t)__builtin_neon_vrhadduv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqadd_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vqaddv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vqaddsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqadd_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqaddv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vqaddsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqadd_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqaddv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vqaddsv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vqadd_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (int64x1_t)__builtin_neon_vqadddi (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vqaddsdi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqadd_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vqaddv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vqadduv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqadd_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vqaddv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vqadduv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqadd_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vqaddv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vqadduv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vqadd_u64 (uint64x1_t __a, uint64x1_t __b)
 {
-  return (uint64x1_t)__builtin_neon_vqadddi ((int64x1_t) __a, (int64x1_t) __b, 0);
+  return (uint64x1_t)__builtin_neon_vqaddudi ((int64x1_t) __a, (int64x1_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vqaddq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vqaddv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vqaddsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqaddq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqaddv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vqaddsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqaddq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqaddv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vqaddsv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqaddq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vqaddv2di (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vqaddsv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vqaddq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vqaddv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vqadduv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vqaddq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vqaddv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vqadduv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vqaddq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vqaddv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vqadduv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vqaddq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vqaddv2di ((int64x2_t) __a, (int64x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vqadduv2di ((int64x2_t) __a, (int64x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vaddhn_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vaddhnv8hi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vaddhnv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vaddhn_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vaddhnv4si (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vaddhnv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vaddhn_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vaddhnv2di (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vaddhnv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vaddhn_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vaddhnv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vaddhnv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vaddhn_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vaddhnv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vaddhnv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vaddhn_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vaddhnv2di ((int64x2_t) __a, (int64x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vaddhnv2di ((int64x2_t) __a, (int64x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vraddhn_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vaddhnv8hi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vraddhnv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vraddhn_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vaddhnv4si (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vraddhnv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vraddhn_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vaddhnv2di (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vraddhnv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vraddhn_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vaddhnv8hi ((int16x8_t) __a, (int16x8_t) __b, 4);
+  return (uint8x8_t)__builtin_neon_vraddhnv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vraddhn_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vaddhnv4si ((int32x4_t) __a, (int32x4_t) __b, 4);
+  return (uint16x4_t)__builtin_neon_vraddhnv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vraddhn_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vaddhnv2di ((int64x2_t) __a, (int64x2_t) __b, 4);
+  return (uint32x2_t)__builtin_neon_vraddhnv2di ((int64x2_t) __a, (int64x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
@@ -977,7 +977,7 @@ vmul_f32 (float32x2_t __a, float32x2_t __b)
 #ifdef __FAST_MATH
   return __a * __b;
 #else
-  return (float32x2_t) __builtin_neon_vmulv2sf (__a, __b, 3);
+  return (float32x2_t) __builtin_neon_vmulfv2sf (__a, __b);
 #endif
 
 }
@@ -1024,7 +1024,7 @@ vmulq_f32 (float32x4_t __a, float32x4_t __b)
 #ifdef __FAST_MATH
   return __a * __b;
 #else
-  return (float32x4_t) __builtin_neon_vmulv4sf (__a, __b, 3);
+  return (float32x4_t) __builtin_neon_vmulfv4sf (__a, __b);
 #endif
 }
 
@@ -1049,386 +1049,386 @@ vmulq_u32 (uint32x4_t __a, uint32x4_t __b)
 __extension__ static __inline poly8x8_t __attribute__ ((__always_inline__))
 vmul_p8 (poly8x8_t __a, poly8x8_t __b)
 {
-  return (poly8x8_t)__builtin_neon_vmulv8qi ((int8x8_t) __a, (int8x8_t) __b, 2);
+  return (poly8x8_t)__builtin_neon_vmulpv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline poly8x16_t __attribute__ ((__always_inline__))
 vmulq_p8 (poly8x16_t __a, poly8x16_t __b)
 {
-  return (poly8x16_t)__builtin_neon_vmulv16qi ((int8x16_t) __a, (int8x16_t) __b, 2);
+  return (poly8x16_t)__builtin_neon_vmulpv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqdmulh_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqdmulhv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vqdmulhv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqdmulh_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqdmulhv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vqdmulhv2si (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqdmulhq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqdmulhv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vqdmulhv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmulhq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqdmulhv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vqdmulhv4si (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqrdmulh_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqdmulhv4hi (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vqrdmulhv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqrdmulh_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqdmulhv2si (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vqrdmulhv2si (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqrdmulhq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqdmulhv8hi (__a, __b, 5);
+  return (int16x8_t)__builtin_neon_vqrdmulhv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqrdmulhq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqdmulhv4si (__a, __b, 5);
+  return (int32x4_t)__builtin_neon_vqrdmulhv4si (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmull_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vmullv8qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vmullsv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmull_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vmullv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vmullsv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmull_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vmullv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vmullsv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmull_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vmullv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vmulluv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmull_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vmullv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vmulluv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmull_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vmullv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vmulluv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline poly16x8_t __attribute__ ((__always_inline__))
 vmull_p8 (poly8x8_t __a, poly8x8_t __b)
 {
-  return (poly16x8_t)__builtin_neon_vmullv8qi ((int8x8_t) __a, (int8x8_t) __b, 2);
+  return (poly16x8_t)__builtin_neon_vmullpv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmull_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqdmullv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vqdmullv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmull_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vqdmullv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vqdmullv2si (__a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vmla_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return (int8x8_t)__builtin_neon_vmlav8qi (__a, __b, __c, 1);
+  return (int8x8_t)__builtin_neon_vmlav8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmla_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int16x4_t)__builtin_neon_vmlav4hi (__a, __b, __c, 1);
+  return (int16x4_t)__builtin_neon_vmlav4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmla_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int32x2_t)__builtin_neon_vmlav2si (__a, __b, __c, 1);
+  return (int32x2_t)__builtin_neon_vmlav2si (__a, __b, __c);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmla_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)
 {
-  return (float32x2_t)__builtin_neon_vmlav2sf (__a, __b, __c, 3);
+  return (float32x2_t)__builtin_neon_vmlav2sf (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vmla_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return (uint8x8_t)__builtin_neon_vmlav8qi ((int8x8_t) __a, (int8x8_t) __b, (int8x8_t) __c, 0);
+  return (uint8x8_t)__builtin_neon_vmlav8qi ((int8x8_t) __a, (int8x8_t) __b, (int8x8_t) __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmla_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return (uint16x4_t)__builtin_neon_vmlav4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, 0);
+  return (uint16x4_t)__builtin_neon_vmlav4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmla_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return (uint32x2_t)__builtin_neon_vmlav2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, 0);
+  return (uint32x2_t)__builtin_neon_vmlav2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vmlaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return (int8x16_t)__builtin_neon_vmlav16qi (__a, __b, __c, 1);
+  return (int8x16_t)__builtin_neon_vmlav16qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return (int16x8_t)__builtin_neon_vmlav8hi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vmlav8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmlav4si (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vmlav4si (__a, __b, __c);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmlaq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c)
 {
-  return (float32x4_t)__builtin_neon_vmlav4sf (__a, __b, __c, 3);
+  return (float32x4_t)__builtin_neon_vmlav4sf (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vmlaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return (uint8x16_t)__builtin_neon_vmlav16qi ((int8x16_t) __a, (int8x16_t) __b, (int8x16_t) __c, 0);
+  return (uint8x16_t)__builtin_neon_vmlav16qi ((int8x16_t) __a, (int8x16_t) __b, (int8x16_t) __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vmlav8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x8_t) __c, 0);
+  return (uint16x8_t)__builtin_neon_vmlav8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x8_t) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmlav4si ((int32x4_t) __a, (int32x4_t) __b, (int32x4_t) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmlav4si ((int32x4_t) __a, (int32x4_t) __b, (int32x4_t) __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return (int16x8_t)__builtin_neon_vmlalv8qi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vmlalsv8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmlalv4hi (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vmlalsv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int64x2_t)__builtin_neon_vmlalv2si (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vmlalsv2si (__a, __b, __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vmlalv8qi ((int16x8_t) __a, (int8x8_t) __b, (int8x8_t) __c, 0);
+  return (uint16x8_t)__builtin_neon_vmlaluv8qi ((int16x8_t) __a, (int8x8_t) __b, (int8x8_t) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmlalv4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmlaluv4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmlal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return (uint64x2_t)__builtin_neon_vmlalv2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, 0);
+  return (uint64x2_t)__builtin_neon_vmlaluv2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vqdmlalv4hi (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vqdmlalv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int64x2_t)__builtin_neon_vqdmlalv2si (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vqdmlalv2si (__a, __b, __c);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vmls_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return (int8x8_t)__builtin_neon_vmlsv8qi (__a, __b, __c, 1);
+  return (int8x8_t)__builtin_neon_vmlsv8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmls_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int16x4_t)__builtin_neon_vmlsv4hi (__a, __b, __c, 1);
+  return (int16x4_t)__builtin_neon_vmlsv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmls_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int32x2_t)__builtin_neon_vmlsv2si (__a, __b, __c, 1);
+  return (int32x2_t)__builtin_neon_vmlsv2si (__a, __b, __c);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmls_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)
 {
-  return (float32x2_t)__builtin_neon_vmlsv2sf (__a, __b, __c, 3);
+  return (float32x2_t)__builtin_neon_vmlsv2sf (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vmls_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return (uint8x8_t)__builtin_neon_vmlsv8qi ((int8x8_t) __a, (int8x8_t) __b, (int8x8_t) __c, 0);
+  return (uint8x8_t)__builtin_neon_vmlsv8qi ((int8x8_t) __a, (int8x8_t) __b, (int8x8_t) __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmls_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return (uint16x4_t)__builtin_neon_vmlsv4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, 0);
+  return (uint16x4_t)__builtin_neon_vmlsv4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmls_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return (uint32x2_t)__builtin_neon_vmlsv2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, 0);
+  return (uint32x2_t)__builtin_neon_vmlsv2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vmlsq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return (int8x16_t)__builtin_neon_vmlsv16qi (__a, __b, __c, 1);
+  return (int8x16_t)__builtin_neon_vmlsv16qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlsq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return (int16x8_t)__builtin_neon_vmlsv8hi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vmlsv8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlsq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmlsv4si (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vmlsv4si (__a, __b, __c);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmlsq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c)
 {
-  return (float32x4_t)__builtin_neon_vmlsv4sf (__a, __b, __c, 3);
+  return (float32x4_t)__builtin_neon_vmlsv4sf (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vmlsq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return (uint8x16_t)__builtin_neon_vmlsv16qi ((int8x16_t) __a, (int8x16_t) __b, (int8x16_t) __c, 0);
+  return (uint8x16_t)__builtin_neon_vmlsv16qi ((int8x16_t) __a, (int8x16_t) __b, (int8x16_t) __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlsq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vmlsv8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x8_t) __c, 0);
+  return (uint16x8_t)__builtin_neon_vmlsv8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x8_t) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlsq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmlsv4si ((int32x4_t) __a, (int32x4_t) __b, (int32x4_t) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmlsv4si ((int32x4_t) __a, (int32x4_t) __b, (int32x4_t) __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlsl_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return (int16x8_t)__builtin_neon_vmlslv8qi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vmlslsv8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmlslv4hi (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vmlslsv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int64x2_t)__builtin_neon_vmlslv2si (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vmlslsv2si (__a, __b, __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlsl_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vmlslv8qi ((int16x8_t) __a, (int8x8_t) __b, (int8x8_t) __c, 0);
+  return (uint16x8_t)__builtin_neon_vmlsluv8qi ((int16x8_t) __a, (int8x8_t) __b, (int8x8_t) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlsl_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmlslv4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmlsluv4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmlsl_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return (uint64x2_t)__builtin_neon_vmlslv2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, 0);
+  return (uint64x2_t)__builtin_neon_vmlsluv2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vqdmlslv4hi (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vqdmlslv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int64x2_t)__builtin_neon_vqdmlslv2si (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vqdmlslv2si (__a, __b, __c);
 }
 
 #ifdef __ARM_FEATURE_FMA
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vfma_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)
 {
-  return (float32x2_t)__builtin_neon_vfmav2sf (__a, __b, __c, 3);
+  return (float32x2_t)__builtin_neon_vfmav2sf (__a, __b, __c);
 }
 
 #endif
@@ -1436,7 +1436,7 @@ vfma_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vfmaq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c)
 {
-  return (float32x4_t)__builtin_neon_vfmav4sf (__a, __b, __c, 3);
+  return (float32x4_t)__builtin_neon_vfmav4sf (__a, __b, __c);
 }
 
 #endif
@@ -1444,7 +1444,7 @@ vfmaq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c)
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vfms_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)
 {
-  return (float32x2_t)__builtin_neon_vfmsv2sf (__a, __b, __c, 3);
+  return (float32x2_t)__builtin_neon_vfmsv2sf (__a, __b, __c);
 }
 
 #endif
@@ -1452,7 +1452,7 @@ vfms_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vfmsq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c)
 {
-  return (float32x4_t)__builtin_neon_vfmsv4sf (__a, __b, __c, 3);
+  return (float32x4_t)__builtin_neon_vfmsv4sf (__a, __b, __c);
 }
 
 #endif
@@ -1561,7 +1561,7 @@ vsub_f32 (float32x2_t __a, float32x2_t __b)
 #ifdef __FAST_MATH
   return __a - __b;
 #else
-  return (float32x2_t) __builtin_neon_vsubv2sf (__a, __b, 3);
+  return (float32x2_t) __builtin_neon_vsubv2sf (__a, __b);
 #endif
 }
 
@@ -1625,7 +1625,7 @@ vsubq_f32 (float32x4_t __a, float32x4_t __b)
 #ifdef __FAST_MATH
   return __a - __b;
 #else
-  return (float32x4_t) __builtin_neon_vsubv4sf (__a, __b, 3);
+  return (float32x4_t) __builtin_neon_vsubv4sf (__a, __b);
 #endif
 }
 
@@ -1656,2791 +1656,2791 @@ vsubq_u64 (uint64x2_t __a, uint64x2_t __b)
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vsubl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vsublv8qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vsublsv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vsubl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vsublv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vsublsv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vsubl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vsublv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vsublsv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vsubl_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vsublv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vsubluv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vsubl_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vsublv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vsubluv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vsubl_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vsublv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vsubluv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vsubw_s8 (int16x8_t __a, int8x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vsubwv8qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vsubwsv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vsubw_s16 (int32x4_t __a, int16x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vsubwv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vsubwsv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vsubw_s32 (int64x2_t __a, int32x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vsubwv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vsubwsv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vsubw_u8 (uint16x8_t __a, uint8x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vsubwv8qi ((int16x8_t) __a, (int8x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vsubwuv8qi ((int16x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vsubw_u16 (uint32x4_t __a, uint16x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vsubwv4hi ((int32x4_t) __a, (int16x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vsubwuv4hi ((int32x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vsubw_u32 (uint64x2_t __a, uint32x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vsubwv2si ((int64x2_t) __a, (int32x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vsubwuv2si ((int64x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vhsub_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vhsubv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vhsubsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vhsub_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vhsubv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vhsubsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vhsub_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vhsubv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vhsubsv2si (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vhsub_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vhsubv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vhsubuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vhsub_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vhsubv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vhsubuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vhsub_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vhsubv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vhsubuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vhsubq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vhsubv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vhsubsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vhsubq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vhsubv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vhsubsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vhsubq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vhsubv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vhsubsv4si (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vhsubq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vhsubv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vhsubuv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vhsubq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vhsubv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vhsubuv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vhsubq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vhsubv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vhsubuv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqsub_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vqsubv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vqsubsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqsub_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqsubv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vqsubsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqsub_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqsubv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vqsubsv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vqsub_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (int64x1_t)__builtin_neon_vqsubdi (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vqsubsdi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqsub_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vqsubv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vqsubuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqsub_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vqsubv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vqsubuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqsub_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vqsubv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vqsubuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vqsub_u64 (uint64x1_t __a, uint64x1_t __b)
 {
-  return (uint64x1_t)__builtin_neon_vqsubdi ((int64x1_t) __a, (int64x1_t) __b, 0);
+  return (uint64x1_t)__builtin_neon_vqsubudi ((int64x1_t) __a, (int64x1_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vqsubq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vqsubv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vqsubsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqsubq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqsubv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vqsubsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqsubq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqsubv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vqsubsv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqsubq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vqsubv2di (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vqsubsv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vqsubq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vqsubv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vqsubuv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vqsubq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vqsubv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vqsubuv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vqsubq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vqsubv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vqsubuv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vqsubq_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vqsubv2di ((int64x2_t) __a, (int64x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vqsubuv2di ((int64x2_t) __a, (int64x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vsubhn_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vsubhnv8hi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vsubhnv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vsubhn_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vsubhnv4si (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vsubhnv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vsubhn_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vsubhnv2di (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vsubhnv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vsubhn_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vsubhnv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vsubhnv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vsubhn_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vsubhnv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vsubhnv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vsubhn_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vsubhnv2di ((int64x2_t) __a, (int64x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vsubhnv2di ((int64x2_t) __a, (int64x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vrsubhn_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vsubhnv8hi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vrsubhnv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vrsubhn_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vsubhnv4si (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vrsubhnv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vrsubhn_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vsubhnv2di (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vrsubhnv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vrsubhn_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vsubhnv8hi ((int16x8_t) __a, (int16x8_t) __b, 4);
+  return (uint8x8_t)__builtin_neon_vrsubhnv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vrsubhn_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vsubhnv4si ((int32x4_t) __a, (int32x4_t) __b, 4);
+  return (uint16x4_t)__builtin_neon_vrsubhnv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrsubhn_u64 (uint64x2_t __a, uint64x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vsubhnv2di ((int64x2_t) __a, (int64x2_t) __b, 4);
+  return (uint32x2_t)__builtin_neon_vrsubhnv2di ((int64x2_t) __a, (int64x2_t) __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vceq_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vceqv8qi (__a, __b, 1);
+  return (uint8x8_t)__builtin_neon_vceqv8qi (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vceq_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vceqv4hi (__a, __b, 1);
+  return (uint16x4_t)__builtin_neon_vceqv4hi (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vceq_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vceqv2si (__a, __b, 1);
+  return (uint32x2_t)__builtin_neon_vceqv2si (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vceq_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vceqv2sf (__a, __b, 3);
+  return (uint32x2_t)__builtin_neon_vceqv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vceq_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vceqv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vceqv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vceq_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vceqv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vceqv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vceq_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vceqv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vceqv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vceq_p8 (poly8x8_t __a, poly8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vceqv8qi ((int8x8_t) __a, (int8x8_t) __b, 2);
+  return (uint8x8_t)__builtin_neon_vceqv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vceqq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vceqv16qi (__a, __b, 1);
+  return (uint8x16_t)__builtin_neon_vceqv16qi (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vceqq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vceqv8hi (__a, __b, 1);
+  return (uint16x8_t)__builtin_neon_vceqv8hi (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vceqq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vceqv4si (__a, __b, 1);
+  return (uint32x4_t)__builtin_neon_vceqv4si (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vceqq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vceqv4sf (__a, __b, 3);
+  return (uint32x4_t)__builtin_neon_vceqv4sf (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vceqq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vceqv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vceqv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vceqq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vceqv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vceqv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vceqq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vceqv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vceqv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vceqq_p8 (poly8x16_t __a, poly8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vceqv16qi ((int8x16_t) __a, (int8x16_t) __b, 2);
+  return (uint8x16_t)__builtin_neon_vceqv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vcge_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgev8qi (__a, __b, 1);
+  return (uint8x8_t)__builtin_neon_vcgev8qi (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vcge_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgev4hi (__a, __b, 1);
+  return (uint16x4_t)__builtin_neon_vcgev4hi (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcge_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgev2si (__a, __b, 1);
+  return (uint32x2_t)__builtin_neon_vcgev2si (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcge_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgev2sf (__a, __b, 3);
+  return (uint32x2_t)__builtin_neon_vcgev2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vcge_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgeuv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vcgeuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vcge_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgeuv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vcgeuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcge_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgeuv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vcgeuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcgeq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgev16qi (__a, __b, 1);
+  return (uint8x16_t)__builtin_neon_vcgev16qi (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcgeq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgev8hi (__a, __b, 1);
+  return (uint16x8_t)__builtin_neon_vcgev8hi (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcgeq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgev4si (__a, __b, 1);
+  return (uint32x4_t)__builtin_neon_vcgev4si (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcgeq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgev4sf (__a, __b, 3);
+  return (uint32x4_t)__builtin_neon_vcgev4sf (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcgeq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgeuv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vcgeuv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcgeq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgeuv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vcgeuv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcgeq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgeuv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vcgeuv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vcle_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgev8qi (__b, __a, 1);
+  return (uint8x8_t)__builtin_neon_vcgev8qi (__b, __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vcle_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgev4hi (__b, __a, 1);
+  return (uint16x4_t)__builtin_neon_vcgev4hi (__b, __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcle_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgev2si (__b, __a, 1);
+  return (uint32x2_t)__builtin_neon_vcgev2si (__b, __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcle_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgev2sf (__b, __a, 3);
+  return (uint32x2_t)__builtin_neon_vcgev2sf (__b, __a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vcle_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgeuv8qi ((int8x8_t) __b, (int8x8_t) __a, 0);
+  return (uint8x8_t)__builtin_neon_vcgeuv8qi ((int8x8_t) __b, (int8x8_t) __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vcle_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgeuv4hi ((int16x4_t) __b, (int16x4_t) __a, 0);
+  return (uint16x4_t)__builtin_neon_vcgeuv4hi ((int16x4_t) __b, (int16x4_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcle_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgeuv2si ((int32x2_t) __b, (int32x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vcgeuv2si ((int32x2_t) __b, (int32x2_t) __a);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcleq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgev16qi (__b, __a, 1);
+  return (uint8x16_t)__builtin_neon_vcgev16qi (__b, __a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcleq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgev8hi (__b, __a, 1);
+  return (uint16x8_t)__builtin_neon_vcgev8hi (__b, __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcleq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgev4si (__b, __a, 1);
+  return (uint32x4_t)__builtin_neon_vcgev4si (__b, __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcleq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgev4sf (__b, __a, 3);
+  return (uint32x4_t)__builtin_neon_vcgev4sf (__b, __a);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcleq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgeuv16qi ((int8x16_t) __b, (int8x16_t) __a, 0);
+  return (uint8x16_t)__builtin_neon_vcgeuv16qi ((int8x16_t) __b, (int8x16_t) __a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcleq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgeuv8hi ((int16x8_t) __b, (int16x8_t) __a, 0);
+  return (uint16x8_t)__builtin_neon_vcgeuv8hi ((int16x8_t) __b, (int16x8_t) __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcleq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgeuv4si ((int32x4_t) __b, (int32x4_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vcgeuv4si ((int32x4_t) __b, (int32x4_t) __a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vcgt_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgtv8qi (__a, __b, 1);
+  return (uint8x8_t)__builtin_neon_vcgtv8qi (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vcgt_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgtv4hi (__a, __b, 1);
+  return (uint16x4_t)__builtin_neon_vcgtv4hi (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcgt_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgtv2si (__a, __b, 1);
+  return (uint32x2_t)__builtin_neon_vcgtv2si (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcgt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgtv2sf (__a, __b, 3);
+  return (uint32x2_t)__builtin_neon_vcgtv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vcgt_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgtuv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vcgtuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vcgt_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgtuv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vcgtuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcgt_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgtuv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vcgtuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcgtq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgtv16qi (__a, __b, 1);
+  return (uint8x16_t)__builtin_neon_vcgtv16qi (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcgtq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgtv8hi (__a, __b, 1);
+  return (uint16x8_t)__builtin_neon_vcgtv8hi (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcgtq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgtv4si (__a, __b, 1);
+  return (uint32x4_t)__builtin_neon_vcgtv4si (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcgtq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgtv4sf (__a, __b, 3);
+  return (uint32x4_t)__builtin_neon_vcgtv4sf (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcgtq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgtuv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vcgtuv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcgtq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgtuv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vcgtuv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcgtq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgtuv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vcgtuv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vclt_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgtv8qi (__b, __a, 1);
+  return (uint8x8_t)__builtin_neon_vcgtv8qi (__b, __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vclt_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgtv4hi (__b, __a, 1);
+  return (uint16x4_t)__builtin_neon_vcgtv4hi (__b, __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vclt_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgtv2si (__b, __a, 1);
+  return (uint32x2_t)__builtin_neon_vcgtv2si (__b, __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vclt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgtv2sf (__b, __a, 3);
+  return (uint32x2_t)__builtin_neon_vcgtv2sf (__b, __a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vclt_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vcgtuv8qi ((int8x8_t) __b, (int8x8_t) __a, 0);
+  return (uint8x8_t)__builtin_neon_vcgtuv8qi ((int8x8_t) __b, (int8x8_t) __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vclt_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vcgtuv4hi ((int16x4_t) __b, (int16x4_t) __a, 0);
+  return (uint16x4_t)__builtin_neon_vcgtuv4hi ((int16x4_t) __b, (int16x4_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vclt_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcgtuv2si ((int32x2_t) __b, (int32x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vcgtuv2si ((int32x2_t) __b, (int32x2_t) __a);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcltq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgtv16qi (__b, __a, 1);
+  return (uint8x16_t)__builtin_neon_vcgtv16qi (__b, __a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcltq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgtv8hi (__b, __a, 1);
+  return (uint16x8_t)__builtin_neon_vcgtv8hi (__b, __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcltq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgtv4si (__b, __a, 1);
+  return (uint32x4_t)__builtin_neon_vcgtv4si (__b, __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcltq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgtv4sf (__b, __a, 3);
+  return (uint32x4_t)__builtin_neon_vcgtv4sf (__b, __a);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcltq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vcgtuv16qi ((int8x16_t) __b, (int8x16_t) __a, 0);
+  return (uint8x16_t)__builtin_neon_vcgtuv16qi ((int8x16_t) __b, (int8x16_t) __a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vcltq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vcgtuv8hi ((int16x8_t) __b, (int16x8_t) __a, 0);
+  return (uint16x8_t)__builtin_neon_vcgtuv8hi ((int16x8_t) __b, (int16x8_t) __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcltq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcgtuv4si ((int32x4_t) __b, (int32x4_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vcgtuv4si ((int32x4_t) __b, (int32x4_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcage_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcagev2sf (__a, __b, 3);
+  return (uint32x2_t)__builtin_neon_vcagev2sf (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcageq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcagev4sf (__a, __b, 3);
+  return (uint32x4_t)__builtin_neon_vcagev4sf (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcale_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcagev2sf (__b, __a, 3);
+  return (uint32x2_t)__builtin_neon_vcagev2sf (__b, __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcaleq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcagev4sf (__b, __a, 3);
+  return (uint32x4_t)__builtin_neon_vcagev4sf (__b, __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcagt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcagtv2sf (__a, __b, 3);
+  return (uint32x2_t)__builtin_neon_vcagtv2sf (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcagtq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcagtv4sf (__a, __b, 3);
+  return (uint32x4_t)__builtin_neon_vcagtv4sf (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcalt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vcagtv2sf (__b, __a, 3);
+  return (uint32x2_t)__builtin_neon_vcagtv2sf (__b, __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcaltq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vcagtv4sf (__b, __a, 3);
+  return (uint32x4_t)__builtin_neon_vcagtv4sf (__b, __a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vtst_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vtstv8qi (__a, __b, 1);
+  return (uint8x8_t)__builtin_neon_vtstv8qi (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vtst_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vtstv4hi (__a, __b, 1);
+  return (uint16x4_t)__builtin_neon_vtstv4hi (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vtst_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vtstv2si (__a, __b, 1);
+  return (uint32x2_t)__builtin_neon_vtstv2si (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vtst_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vtstv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vtstv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vtst_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vtstv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vtstv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vtst_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vtstv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vtstv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vtst_p8 (poly8x8_t __a, poly8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vtstv8qi ((int8x8_t) __a, (int8x8_t) __b, 2);
+  return (uint8x8_t)__builtin_neon_vtstv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vtstq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vtstv16qi (__a, __b, 1);
+  return (uint8x16_t)__builtin_neon_vtstv16qi (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vtstq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vtstv8hi (__a, __b, 1);
+  return (uint16x8_t)__builtin_neon_vtstv8hi (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vtstq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vtstv4si (__a, __b, 1);
+  return (uint32x4_t)__builtin_neon_vtstv4si (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vtstq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vtstv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vtstv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vtstq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vtstv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vtstv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vtstq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vtstv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vtstv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vtstq_p8 (poly8x16_t __a, poly8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vtstv16qi ((int8x16_t) __a, (int8x16_t) __b, 2);
+  return (uint8x16_t)__builtin_neon_vtstv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vabd_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vabdv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vabdsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vabd_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vabdv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vabdsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vabd_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vabdv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vabdsv2si (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vabd_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vabdv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vabdfv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vabd_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vabdv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vabduv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vabd_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vabdv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vabduv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vabd_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vabdv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vabduv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vabdq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vabdv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vabdsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vabdq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vabdv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vabdsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vabdq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vabdv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vabdsv4si (__a, __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vabdq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (float32x4_t)__builtin_neon_vabdv4sf (__a, __b, 3);
+  return (float32x4_t)__builtin_neon_vabdfv4sf (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vabdq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vabdv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vabduv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vabdq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vabdv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vabduv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vabdq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vabdv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vabduv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vabdl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vabdlv8qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vabdlsv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vabdl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vabdlv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vabdlsv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vabdl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vabdlv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vabdlsv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vabdl_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vabdlv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vabdluv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vabdl_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vabdlv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vabdluv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vabdl_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vabdlv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vabdluv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vaba_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return (int8x8_t)__builtin_neon_vabav8qi (__a, __b, __c, 1);
+  return (int8x8_t)__builtin_neon_vabasv8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vaba_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int16x4_t)__builtin_neon_vabav4hi (__a, __b, __c, 1);
+  return (int16x4_t)__builtin_neon_vabasv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vaba_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int32x2_t)__builtin_neon_vabav2si (__a, __b, __c, 1);
+  return (int32x2_t)__builtin_neon_vabasv2si (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vaba_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return (uint8x8_t)__builtin_neon_vabav8qi ((int8x8_t) __a, (int8x8_t) __b, (int8x8_t) __c, 0);
+  return (uint8x8_t)__builtin_neon_vabauv8qi ((int8x8_t) __a, (int8x8_t) __b, (int8x8_t) __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vaba_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return (uint16x4_t)__builtin_neon_vabav4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, 0);
+  return (uint16x4_t)__builtin_neon_vabauv4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vaba_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return (uint32x2_t)__builtin_neon_vabav2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, 0);
+  return (uint32x2_t)__builtin_neon_vabauv2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vabaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c)
 {
-  return (int8x16_t)__builtin_neon_vabav16qi (__a, __b, __c, 1);
+  return (int8x16_t)__builtin_neon_vabasv16qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vabaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c)
 {
-  return (int16x8_t)__builtin_neon_vabav8hi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vabasv8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vabaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vabav4si (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vabasv4si (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vabaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c)
 {
-  return (uint8x16_t)__builtin_neon_vabav16qi ((int8x16_t) __a, (int8x16_t) __b, (int8x16_t) __c, 0);
+  return (uint8x16_t)__builtin_neon_vabauv16qi ((int8x16_t) __a, (int8x16_t) __b, (int8x16_t) __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vabaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vabav8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x8_t) __c, 0);
+  return (uint16x8_t)__builtin_neon_vabauv8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x8_t) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vabaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vabav4si ((int32x4_t) __a, (int32x4_t) __b, (int32x4_t) __c, 0);
+  return (uint32x4_t)__builtin_neon_vabauv4si ((int32x4_t) __a, (int32x4_t) __b, (int32x4_t) __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vabal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c)
 {
-  return (int16x8_t)__builtin_neon_vabalv8qi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vabalsv8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vabal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c)
 {
-  return (int32x4_t)__builtin_neon_vabalv4hi (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vabalsv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vabal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c)
 {
-  return (int64x2_t)__builtin_neon_vabalv2si (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vabalsv2si (__a, __b, __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vabal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vabalv8qi ((int16x8_t) __a, (int8x8_t) __b, (int8x8_t) __c, 0);
+  return (uint16x8_t)__builtin_neon_vabaluv8qi ((int16x8_t) __a, (int8x8_t) __b, (int8x8_t) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vabal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vabalv4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, 0);
+  return (uint32x4_t)__builtin_neon_vabaluv4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vabal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c)
 {
-  return (uint64x2_t)__builtin_neon_vabalv2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, 0);
+  return (uint64x2_t)__builtin_neon_vabaluv2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vmax_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vmaxv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vmaxsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmax_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vmaxv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vmaxsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmax_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vmaxv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vmaxsv2si (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmax_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vmaxv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vmaxfv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vmax_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vmaxv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vmaxuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmax_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vmaxv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vmaxuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmax_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vmaxv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vmaxuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vmaxq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vmaxv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vmaxsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmaxq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vmaxv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vmaxsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmaxq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vmaxv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vmaxsv4si (__a, __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmaxq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (float32x4_t)__builtin_neon_vmaxv4sf (__a, __b, 3);
+  return (float32x4_t)__builtin_neon_vmaxfv4sf (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vmaxq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vmaxv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vmaxuv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmaxq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vmaxv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vmaxuv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmaxq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vmaxv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vmaxuv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vmin_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vminv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vminsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmin_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vminv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vminsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmin_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vminv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vminsv2si (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmin_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vminv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vminfv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vmin_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vminv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vminuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmin_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vminv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vminuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmin_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vminv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vminuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vminq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vminv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vminsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vminq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vminv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vminsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vminq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vminv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vminsv4si (__a, __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vminq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (float32x4_t)__builtin_neon_vminv4sf (__a, __b, 3);
+  return (float32x4_t)__builtin_neon_vminfv4sf (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vminq_u8 (uint8x16_t __a, uint8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vminv16qi ((int8x16_t) __a, (int8x16_t) __b, 0);
+  return (uint8x16_t)__builtin_neon_vminuv16qi ((int8x16_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vminq_u16 (uint16x8_t __a, uint16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vminv8hi ((int16x8_t) __a, (int16x8_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vminuv8hi ((int16x8_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vminq_u32 (uint32x4_t __a, uint32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vminv4si ((int32x4_t) __a, (int32x4_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vminuv4si ((int32x4_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vpadd_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vpaddv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vpaddv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vpadd_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vpaddv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vpaddv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vpadd_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vpaddv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vpaddv2si (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vpadd_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vpaddv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vpaddv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vpadd_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vpaddv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vpaddv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vpadd_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vpaddv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vpaddv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vpadd_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vpaddv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vpaddv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vpaddl_s8 (int8x8_t __a)
 {
-  return (int16x4_t)__builtin_neon_vpaddlv8qi (__a, 1);
+  return (int16x4_t)__builtin_neon_vpaddlsv8qi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vpaddl_s16 (int16x4_t __a)
 {
-  return (int32x2_t)__builtin_neon_vpaddlv4hi (__a, 1);
+  return (int32x2_t)__builtin_neon_vpaddlsv4hi (__a);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vpaddl_s32 (int32x2_t __a)
 {
-  return (int64x1_t)__builtin_neon_vpaddlv2si (__a, 1);
+  return (int64x1_t)__builtin_neon_vpaddlsv2si (__a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vpaddl_u8 (uint8x8_t __a)
 {
-  return (uint16x4_t)__builtin_neon_vpaddlv8qi ((int8x8_t) __a, 0);
+  return (uint16x4_t)__builtin_neon_vpaddluv8qi ((int8x8_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vpaddl_u16 (uint16x4_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vpaddlv4hi ((int16x4_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vpaddluv4hi ((int16x4_t) __a);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vpaddl_u32 (uint32x2_t __a)
 {
-  return (uint64x1_t)__builtin_neon_vpaddlv2si ((int32x2_t) __a, 0);
+  return (uint64x1_t)__builtin_neon_vpaddluv2si ((int32x2_t) __a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vpaddlq_s8 (int8x16_t __a)
 {
-  return (int16x8_t)__builtin_neon_vpaddlv16qi (__a, 1);
+  return (int16x8_t)__builtin_neon_vpaddlsv16qi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vpaddlq_s16 (int16x8_t __a)
 {
-  return (int32x4_t)__builtin_neon_vpaddlv8hi (__a, 1);
+  return (int32x4_t)__builtin_neon_vpaddlsv8hi (__a);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vpaddlq_s32 (int32x4_t __a)
 {
-  return (int64x2_t)__builtin_neon_vpaddlv4si (__a, 1);
+  return (int64x2_t)__builtin_neon_vpaddlsv4si (__a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vpaddlq_u8 (uint8x16_t __a)
 {
-  return (uint16x8_t)__builtin_neon_vpaddlv16qi ((int8x16_t) __a, 0);
+  return (uint16x8_t)__builtin_neon_vpaddluv16qi ((int8x16_t) __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vpaddlq_u16 (uint16x8_t __a)
 {
-  return (uint32x4_t)__builtin_neon_vpaddlv8hi ((int16x8_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vpaddluv8hi ((int16x8_t) __a);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vpaddlq_u32 (uint32x4_t __a)
 {
-  return (uint64x2_t)__builtin_neon_vpaddlv4si ((int32x4_t) __a, 0);
+  return (uint64x2_t)__builtin_neon_vpaddluv4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vpadal_s8 (int16x4_t __a, int8x8_t __b)
 {
-  return (int16x4_t)__builtin_neon_vpadalv8qi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vpadalsv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vpadal_s16 (int32x2_t __a, int16x4_t __b)
 {
-  return (int32x2_t)__builtin_neon_vpadalv4hi (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vpadalsv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vpadal_s32 (int64x1_t __a, int32x2_t __b)
 {
-  return (int64x1_t)__builtin_neon_vpadalv2si (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vpadalsv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vpadal_u8 (uint16x4_t __a, uint8x8_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vpadalv8qi ((int16x4_t) __a, (int8x8_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vpadaluv8qi ((int16x4_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vpadal_u16 (uint32x2_t __a, uint16x4_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vpadalv4hi ((int32x2_t) __a, (int16x4_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vpadaluv4hi ((int32x2_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vpadal_u32 (uint64x1_t __a, uint32x2_t __b)
 {
-  return (uint64x1_t)__builtin_neon_vpadalv2si ((int64x1_t) __a, (int32x2_t) __b, 0);
+  return (uint64x1_t)__builtin_neon_vpadaluv2si ((int64x1_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vpadalq_s8 (int16x8_t __a, int8x16_t __b)
 {
-  return (int16x8_t)__builtin_neon_vpadalv16qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vpadalsv16qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vpadalq_s16 (int32x4_t __a, int16x8_t __b)
 {
-  return (int32x4_t)__builtin_neon_vpadalv8hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vpadalsv8hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vpadalq_s32 (int64x2_t __a, int32x4_t __b)
 {
-  return (int64x2_t)__builtin_neon_vpadalv4si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vpadalsv4si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vpadalq_u8 (uint16x8_t __a, uint8x16_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vpadalv16qi ((int16x8_t) __a, (int8x16_t) __b, 0);
+  return (uint16x8_t)__builtin_neon_vpadaluv16qi ((int16x8_t) __a, (int8x16_t) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vpadalq_u16 (uint32x4_t __a, uint16x8_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vpadalv8hi ((int32x4_t) __a, (int16x8_t) __b, 0);
+  return (uint32x4_t)__builtin_neon_vpadaluv8hi ((int32x4_t) __a, (int16x8_t) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vpadalq_u32 (uint64x2_t __a, uint32x4_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vpadalv4si ((int64x2_t) __a, (int32x4_t) __b, 0);
+  return (uint64x2_t)__builtin_neon_vpadaluv4si ((int64x2_t) __a, (int32x4_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vpmax_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vpmaxv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vpmaxsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vpmax_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vpmaxv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vpmaxsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vpmax_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vpmaxv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vpmaxsv2si (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vpmax_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vpmaxv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vpmaxfv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vpmax_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vpmaxv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vpmaxuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vpmax_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vpmaxv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vpmaxuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vpmax_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vpmaxv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vpmaxuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vpmin_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vpminv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vpminsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vpmin_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vpminv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vpminsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vpmin_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vpminv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vpminsv2si (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vpmin_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vpminv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vpminfv2sf (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vpmin_u8 (uint8x8_t __a, uint8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vpminv8qi ((int8x8_t) __a, (int8x8_t) __b, 0);
+  return (uint8x8_t)__builtin_neon_vpminuv8qi ((int8x8_t) __a, (int8x8_t) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vpmin_u16 (uint16x4_t __a, uint16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vpminv4hi ((int16x4_t) __a, (int16x4_t) __b, 0);
+  return (uint16x4_t)__builtin_neon_vpminuv4hi ((int16x4_t) __a, (int16x4_t) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vpmin_u32 (uint32x2_t __a, uint32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vpminv2si ((int32x2_t) __a, (int32x2_t) __b, 0);
+  return (uint32x2_t)__builtin_neon_vpminuv2si ((int32x2_t) __a, (int32x2_t) __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vrecps_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vrecpsv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vrecpsv2sf (__a, __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vrecpsq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (float32x4_t)__builtin_neon_vrecpsv4sf (__a, __b, 3);
+  return (float32x4_t)__builtin_neon_vrecpsv4sf (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vrsqrts_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return (float32x2_t)__builtin_neon_vrsqrtsv2sf (__a, __b, 3);
+  return (float32x2_t)__builtin_neon_vrsqrtsv2sf (__a, __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vrsqrtsq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return (float32x4_t)__builtin_neon_vrsqrtsv4sf (__a, __b, 3);
+  return (float32x4_t)__builtin_neon_vrsqrtsv4sf (__a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vshl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vshlv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vshlsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vshl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vshlv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vshlsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vshl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vshlv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vshlsv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vshl_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (int64x1_t)__builtin_neon_vshldi (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vshlsdi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vshl_u8 (uint8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vshlv8qi ((int8x8_t) __a, __b, 0);
+  return (uint8x8_t)__builtin_neon_vshluv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vshl_u16 (uint16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vshlv4hi ((int16x4_t) __a, __b, 0);
+  return (uint16x4_t)__builtin_neon_vshluv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vshl_u32 (uint32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vshlv2si ((int32x2_t) __a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vshluv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vshl_u64 (uint64x1_t __a, int64x1_t __b)
 {
-  return (uint64x1_t)__builtin_neon_vshldi ((int64x1_t) __a, __b, 0);
+  return (uint64x1_t)__builtin_neon_vshludi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vshlq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vshlv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vshlsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vshlq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vshlv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vshlsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vshlq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vshlv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vshlsv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vshlq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vshlv2di (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vshlsv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vshlq_u8 (uint8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vshlv16qi ((int8x16_t) __a, __b, 0);
+  return (uint8x16_t)__builtin_neon_vshluv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vshlq_u16 (uint16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vshlv8hi ((int16x8_t) __a, __b, 0);
+  return (uint16x8_t)__builtin_neon_vshluv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vshlq_u32 (uint32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vshlv4si ((int32x4_t) __a, __b, 0);
+  return (uint32x4_t)__builtin_neon_vshluv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vshlq_u64 (uint64x2_t __a, int64x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vshlv2di ((int64x2_t) __a, __b, 0);
+  return (uint64x2_t)__builtin_neon_vshluv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vrshl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vshlv8qi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vrshlsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vrshl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vshlv4hi (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vrshlsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vrshl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vshlv2si (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vrshlsv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vrshl_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (int64x1_t)__builtin_neon_vshldi (__a, __b, 5);
+  return (int64x1_t)__builtin_neon_vrshlsdi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vrshl_u8 (uint8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vshlv8qi ((int8x8_t) __a, __b, 4);
+  return (uint8x8_t)__builtin_neon_vrshluv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vrshl_u16 (uint16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vshlv4hi ((int16x4_t) __a, __b, 4);
+  return (uint16x4_t)__builtin_neon_vrshluv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrshl_u32 (uint32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vshlv2si ((int32x2_t) __a, __b, 4);
+  return (uint32x2_t)__builtin_neon_vrshluv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vrshl_u64 (uint64x1_t __a, int64x1_t __b)
 {
-  return (uint64x1_t)__builtin_neon_vshldi ((int64x1_t) __a, __b, 4);
+  return (uint64x1_t)__builtin_neon_vrshludi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vrshlq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vshlv16qi (__a, __b, 5);
+  return (int8x16_t)__builtin_neon_vrshlsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vrshlq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vshlv8hi (__a, __b, 5);
+  return (int16x8_t)__builtin_neon_vrshlsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vrshlq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vshlv4si (__a, __b, 5);
+  return (int32x4_t)__builtin_neon_vrshlsv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vrshlq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vshlv2di (__a, __b, 5);
+  return (int64x2_t)__builtin_neon_vrshlsv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vrshlq_u8 (uint8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vshlv16qi ((int8x16_t) __a, __b, 4);
+  return (uint8x16_t)__builtin_neon_vrshluv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vrshlq_u16 (uint16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vshlv8hi ((int16x8_t) __a, __b, 4);
+  return (uint16x8_t)__builtin_neon_vrshluv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vrshlq_u32 (uint32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vshlv4si ((int32x4_t) __a, __b, 4);
+  return (uint32x4_t)__builtin_neon_vrshluv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vrshlq_u64 (uint64x2_t __a, int64x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vshlv2di ((int64x2_t) __a, __b, 4);
+  return (uint64x2_t)__builtin_neon_vrshluv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqshl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vqshlv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vqshlsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqshl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqshlv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vqshlsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqshl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqshlv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vqshlsv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vqshl_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (int64x1_t)__builtin_neon_vqshldi (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vqshlsdi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqshl_u8 (uint8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshlv8qi ((int8x8_t) __a, __b, 0);
+  return (uint8x8_t)__builtin_neon_vqshluv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqshl_u16 (uint16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshlv4hi ((int16x4_t) __a, __b, 0);
+  return (uint16x4_t)__builtin_neon_vqshluv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqshl_u32 (uint32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshlv2si ((int32x2_t) __a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vqshluv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vqshl_u64 (uint64x1_t __a, int64x1_t __b)
 {
-  return (uint64x1_t)__builtin_neon_vqshldi ((int64x1_t) __a, __b, 0);
+  return (uint64x1_t)__builtin_neon_vqshludi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vqshlq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vqshlv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vqshlsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqshlq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqshlv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vqshlsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqshlq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqshlv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vqshlsv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqshlq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vqshlv2di (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vqshlsv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vqshlq_u8 (uint8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vqshlv16qi ((int8x16_t) __a, __b, 0);
+  return (uint8x16_t)__builtin_neon_vqshluv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vqshlq_u16 (uint16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vqshlv8hi ((int16x8_t) __a, __b, 0);
+  return (uint16x8_t)__builtin_neon_vqshluv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vqshlq_u32 (uint32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vqshlv4si ((int32x4_t) __a, __b, 0);
+  return (uint32x4_t)__builtin_neon_vqshluv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vqshlq_u64 (uint64x2_t __a, int64x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vqshlv2di ((int64x2_t) __a, __b, 0);
+  return (uint64x2_t)__builtin_neon_vqshluv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqrshl_s8 (int8x8_t __a, int8x8_t __b)
 {
-  return (int8x8_t)__builtin_neon_vqshlv8qi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vqrshlsv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqrshl_s16 (int16x4_t __a, int16x4_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqshlv4hi (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vqrshlsv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqrshl_s32 (int32x2_t __a, int32x2_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqshlv2si (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vqrshlsv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vqrshl_s64 (int64x1_t __a, int64x1_t __b)
 {
-  return (int64x1_t)__builtin_neon_vqshldi (__a, __b, 5);
+  return (int64x1_t)__builtin_neon_vqrshlsdi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqrshl_u8 (uint8x8_t __a, int8x8_t __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshlv8qi ((int8x8_t) __a, __b, 4);
+  return (uint8x8_t)__builtin_neon_vqrshluv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqrshl_u16 (uint16x4_t __a, int16x4_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshlv4hi ((int16x4_t) __a, __b, 4);
+  return (uint16x4_t)__builtin_neon_vqrshluv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqrshl_u32 (uint32x2_t __a, int32x2_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshlv2si ((int32x2_t) __a, __b, 4);
+  return (uint32x2_t)__builtin_neon_vqrshluv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vqrshl_u64 (uint64x1_t __a, int64x1_t __b)
 {
-  return (uint64x1_t)__builtin_neon_vqshldi ((int64x1_t) __a, __b, 4);
+  return (uint64x1_t)__builtin_neon_vqrshludi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vqrshlq_s8 (int8x16_t __a, int8x16_t __b)
 {
-  return (int8x16_t)__builtin_neon_vqshlv16qi (__a, __b, 5);
+  return (int8x16_t)__builtin_neon_vqrshlsv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqrshlq_s16 (int16x8_t __a, int16x8_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqshlv8hi (__a, __b, 5);
+  return (int16x8_t)__builtin_neon_vqrshlsv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqrshlq_s32 (int32x4_t __a, int32x4_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqshlv4si (__a, __b, 5);
+  return (int32x4_t)__builtin_neon_vqrshlsv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqrshlq_s64 (int64x2_t __a, int64x2_t __b)
 {
-  return (int64x2_t)__builtin_neon_vqshlv2di (__a, __b, 5);
+  return (int64x2_t)__builtin_neon_vqrshlsv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vqrshlq_u8 (uint8x16_t __a, int8x16_t __b)
 {
-  return (uint8x16_t)__builtin_neon_vqshlv16qi ((int8x16_t) __a, __b, 4);
+  return (uint8x16_t)__builtin_neon_vqrshluv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vqrshlq_u16 (uint16x8_t __a, int16x8_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vqshlv8hi ((int16x8_t) __a, __b, 4);
+  return (uint16x8_t)__builtin_neon_vqrshluv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vqrshlq_u32 (uint32x4_t __a, int32x4_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vqshlv4si ((int32x4_t) __a, __b, 4);
+  return (uint32x4_t)__builtin_neon_vqrshluv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vqrshlq_u64 (uint64x2_t __a, int64x2_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vqshlv2di ((int64x2_t) __a, __b, 4);
+  return (uint64x2_t)__builtin_neon_vqrshluv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vshr_n_s8 (int8x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vshr_nv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vshrs_nv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vshr_n_s16 (int16x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vshr_nv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vshrs_nv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vshr_n_s32 (int32x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vshr_nv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vshrs_nv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vshr_n_s64 (int64x1_t __a, const int __b)
 {
-  return (int64x1_t)__builtin_neon_vshr_ndi (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vshrs_ndi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vshr_n_u8 (uint8x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vshr_nv8qi ((int8x8_t) __a, __b, 0);
+  return (uint8x8_t)__builtin_neon_vshru_nv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vshr_n_u16 (uint16x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vshr_nv4hi ((int16x4_t) __a, __b, 0);
+  return (uint16x4_t)__builtin_neon_vshru_nv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vshr_n_u32 (uint32x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vshr_nv2si ((int32x2_t) __a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vshru_nv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vshr_n_u64 (uint64x1_t __a, const int __b)
 {
-  return (uint64x1_t)__builtin_neon_vshr_ndi ((int64x1_t) __a, __b, 0);
+  return (uint64x1_t)__builtin_neon_vshru_ndi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vshrq_n_s8 (int8x16_t __a, const int __b)
 {
-  return (int8x16_t)__builtin_neon_vshr_nv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vshrs_nv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vshrq_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int16x8_t)__builtin_neon_vshr_nv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vshrs_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vshrq_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int32x4_t)__builtin_neon_vshr_nv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vshrs_nv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vshrq_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int64x2_t)__builtin_neon_vshr_nv2di (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vshrs_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vshrq_n_u8 (uint8x16_t __a, const int __b)
 {
-  return (uint8x16_t)__builtin_neon_vshr_nv16qi ((int8x16_t) __a, __b, 0);
+  return (uint8x16_t)__builtin_neon_vshru_nv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vshrq_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint16x8_t)__builtin_neon_vshr_nv8hi ((int16x8_t) __a, __b, 0);
+  return (uint16x8_t)__builtin_neon_vshru_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vshrq_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint32x4_t)__builtin_neon_vshr_nv4si ((int32x4_t) __a, __b, 0);
+  return (uint32x4_t)__builtin_neon_vshru_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vshrq_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint64x2_t)__builtin_neon_vshr_nv2di ((int64x2_t) __a, __b, 0);
+  return (uint64x2_t)__builtin_neon_vshru_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vrshr_n_s8 (int8x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vshr_nv8qi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vrshrs_nv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vrshr_n_s16 (int16x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vshr_nv4hi (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vrshrs_nv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vrshr_n_s32 (int32x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vshr_nv2si (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vrshrs_nv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vrshr_n_s64 (int64x1_t __a, const int __b)
 {
-  return (int64x1_t)__builtin_neon_vshr_ndi (__a, __b, 5);
+  return (int64x1_t)__builtin_neon_vrshrs_ndi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vrshr_n_u8 (uint8x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vshr_nv8qi ((int8x8_t) __a, __b, 4);
+  return (uint8x8_t)__builtin_neon_vrshru_nv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vrshr_n_u16 (uint16x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vshr_nv4hi ((int16x4_t) __a, __b, 4);
+  return (uint16x4_t)__builtin_neon_vrshru_nv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrshr_n_u32 (uint32x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vshr_nv2si ((int32x2_t) __a, __b, 4);
+  return (uint32x2_t)__builtin_neon_vrshru_nv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vrshr_n_u64 (uint64x1_t __a, const int __b)
 {
-  return (uint64x1_t)__builtin_neon_vshr_ndi ((int64x1_t) __a, __b, 4);
+  return (uint64x1_t)__builtin_neon_vrshru_ndi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vrshrq_n_s8 (int8x16_t __a, const int __b)
 {
-  return (int8x16_t)__builtin_neon_vshr_nv16qi (__a, __b, 5);
+  return (int8x16_t)__builtin_neon_vrshrs_nv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vrshrq_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int16x8_t)__builtin_neon_vshr_nv8hi (__a, __b, 5);
+  return (int16x8_t)__builtin_neon_vrshrs_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vrshrq_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int32x4_t)__builtin_neon_vshr_nv4si (__a, __b, 5);
+  return (int32x4_t)__builtin_neon_vrshrs_nv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vrshrq_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int64x2_t)__builtin_neon_vshr_nv2di (__a, __b, 5);
+  return (int64x2_t)__builtin_neon_vrshrs_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vrshrq_n_u8 (uint8x16_t __a, const int __b)
 {
-  return (uint8x16_t)__builtin_neon_vshr_nv16qi ((int8x16_t) __a, __b, 4);
+  return (uint8x16_t)__builtin_neon_vrshru_nv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vrshrq_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint16x8_t)__builtin_neon_vshr_nv8hi ((int16x8_t) __a, __b, 4);
+  return (uint16x8_t)__builtin_neon_vrshru_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vrshrq_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint32x4_t)__builtin_neon_vshr_nv4si ((int32x4_t) __a, __b, 4);
+  return (uint32x4_t)__builtin_neon_vrshru_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vrshrq_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint64x2_t)__builtin_neon_vshr_nv2di ((int64x2_t) __a, __b, 4);
+  return (uint64x2_t)__builtin_neon_vrshru_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vshrn_nv8hi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vshrn_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vshrn_nv4si (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vshrn_nv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vshrn_nv2di (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vshrn_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vshrn_nv8hi ((int16x8_t) __a, __b, 0);
+  return (uint8x8_t)__builtin_neon_vshrn_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vshrn_nv4si ((int32x4_t) __a, __b, 0);
+  return (uint16x4_t)__builtin_neon_vshrn_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vshrn_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vshrn_nv2di ((int64x2_t) __a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vshrn_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vrshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vshrn_nv8hi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vrshrn_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vrshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vshrn_nv4si (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vrshrn_nv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vrshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vshrn_nv2di (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vrshrn_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vrshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vshrn_nv8hi ((int16x8_t) __a, __b, 4);
+  return (uint8x8_t)__builtin_neon_vrshrn_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vrshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vshrn_nv4si ((int32x4_t) __a, __b, 4);
+  return (uint16x4_t)__builtin_neon_vrshrn_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrshrn_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vshrn_nv2di ((int64x2_t) __a, __b, 4);
+  return (uint32x2_t)__builtin_neon_vrshrn_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vqshrn_nv8hi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vqshrns_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vqshrn_nv4si (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vqshrns_nv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vqshrn_nv2di (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vqshrns_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshrn_nv8hi ((int16x8_t) __a, __b, 0);
+  return (uint8x8_t)__builtin_neon_vqshrnu_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshrn_nv4si ((int32x4_t) __a, __b, 0);
+  return (uint16x4_t)__builtin_neon_vqshrnu_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqshrn_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshrn_nv2di ((int64x2_t) __a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vqshrnu_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqrshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vqshrn_nv8hi (__a, __b, 5);
+  return (int8x8_t)__builtin_neon_vqrshrns_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqrshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vqshrn_nv4si (__a, __b, 5);
+  return (int16x4_t)__builtin_neon_vqrshrns_nv4si (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqrshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vqshrn_nv2di (__a, __b, 5);
+  return (int32x2_t)__builtin_neon_vqrshrns_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqrshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshrn_nv8hi ((int16x8_t) __a, __b, 4);
+  return (uint8x8_t)__builtin_neon_vqrshrnu_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqrshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshrn_nv4si ((int32x4_t) __a, __b, 4);
+  return (uint16x4_t)__builtin_neon_vqrshrnu_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqrshrn_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshrn_nv2di ((int64x2_t) __a, __b, 4);
+  return (uint32x2_t)__builtin_neon_vqrshrnu_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqshrun_n_s16 (int16x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshrun_nv8hi (__a, __b, 1);
+  return (uint8x8_t)__builtin_neon_vqshrun_nv8hi (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqshrun_n_s32 (int32x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshrun_nv4si (__a, __b, 1);
+  return (uint16x4_t)__builtin_neon_vqshrun_nv4si (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqshrun_n_s64 (int64x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshrun_nv2di (__a, __b, 1);
+  return (uint32x2_t)__builtin_neon_vqshrun_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqrshrun_n_s16 (int16x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshrun_nv8hi (__a, __b, 5);
+  return (uint8x8_t)__builtin_neon_vqrshrun_nv8hi (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqrshrun_n_s32 (int32x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshrun_nv4si (__a, __b, 5);
+  return (uint16x4_t)__builtin_neon_vqrshrun_nv4si (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqrshrun_n_s64 (int64x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshrun_nv2di (__a, __b, 5);
+  return (uint32x2_t)__builtin_neon_vqrshrun_nv2di (__a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vshl_n_s8 (int8x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vshl_nv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vshl_nv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vshl_n_s16 (int16x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vshl_nv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vshl_nv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vshl_n_s32 (int32x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vshl_nv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vshl_nv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vshl_n_s64 (int64x1_t __a, const int __b)
 {
-  return (int64x1_t)__builtin_neon_vshl_ndi (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vshl_ndi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vshl_n_u8 (uint8x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vshl_nv8qi ((int8x8_t) __a, __b, 0);
+  return (uint8x8_t)__builtin_neon_vshl_nv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vshl_n_u16 (uint16x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vshl_nv4hi ((int16x4_t) __a, __b, 0);
+  return (uint16x4_t)__builtin_neon_vshl_nv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vshl_n_u32 (uint32x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vshl_nv2si ((int32x2_t) __a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vshl_nv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vshl_n_u64 (uint64x1_t __a, const int __b)
 {
-  return (uint64x1_t)__builtin_neon_vshl_ndi ((int64x1_t) __a, __b, 0);
+  return (uint64x1_t)__builtin_neon_vshl_ndi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vshlq_n_s8 (int8x16_t __a, const int __b)
 {
-  return (int8x16_t)__builtin_neon_vshl_nv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vshl_nv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vshlq_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int16x8_t)__builtin_neon_vshl_nv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vshl_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vshlq_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int32x4_t)__builtin_neon_vshl_nv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vshl_nv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vshlq_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int64x2_t)__builtin_neon_vshl_nv2di (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vshl_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vshlq_n_u8 (uint8x16_t __a, const int __b)
 {
-  return (uint8x16_t)__builtin_neon_vshl_nv16qi ((int8x16_t) __a, __b, 0);
+  return (uint8x16_t)__builtin_neon_vshl_nv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vshlq_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint16x8_t)__builtin_neon_vshl_nv8hi ((int16x8_t) __a, __b, 0);
+  return (uint16x8_t)__builtin_neon_vshl_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vshlq_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint32x4_t)__builtin_neon_vshl_nv4si ((int32x4_t) __a, __b, 0);
+  return (uint32x4_t)__builtin_neon_vshl_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vshlq_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint64x2_t)__builtin_neon_vshl_nv2di ((int64x2_t) __a, __b, 0);
+  return (uint64x2_t)__builtin_neon_vshl_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqshl_n_s8 (int8x8_t __a, const int __b)
 {
-  return (int8x8_t)__builtin_neon_vqshl_nv8qi (__a, __b, 1);
+  return (int8x8_t)__builtin_neon_vqshl_s_nv8qi (__a, __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqshl_n_s16 (int16x4_t __a, const int __b)
 {
-  return (int16x4_t)__builtin_neon_vqshl_nv4hi (__a, __b, 1);
+  return (int16x4_t)__builtin_neon_vqshl_s_nv4hi (__a, __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqshl_n_s32 (int32x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vqshl_nv2si (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vqshl_s_nv2si (__a, __b);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vqshl_n_s64 (int64x1_t __a, const int __b)
 {
-  return (int64x1_t)__builtin_neon_vqshl_ndi (__a, __b, 1);
+  return (int64x1_t)__builtin_neon_vqshl_s_ndi (__a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqshl_n_u8 (uint8x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshl_nv8qi ((int8x8_t) __a, __b, 0);
+  return (uint8x8_t)__builtin_neon_vqshl_u_nv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqshl_n_u16 (uint16x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshl_nv4hi ((int16x4_t) __a, __b, 0);
+  return (uint16x4_t)__builtin_neon_vqshl_u_nv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqshl_n_u32 (uint32x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshl_nv2si ((int32x2_t) __a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vqshl_u_nv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vqshl_n_u64 (uint64x1_t __a, const int __b)
 {
-  return (uint64x1_t)__builtin_neon_vqshl_ndi ((int64x1_t) __a, __b, 0);
+  return (uint64x1_t)__builtin_neon_vqshl_u_ndi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vqshlq_n_s8 (int8x16_t __a, const int __b)
 {
-  return (int8x16_t)__builtin_neon_vqshl_nv16qi (__a, __b, 1);
+  return (int8x16_t)__builtin_neon_vqshl_s_nv16qi (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqshlq_n_s16 (int16x8_t __a, const int __b)
 {
-  return (int16x8_t)__builtin_neon_vqshl_nv8hi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vqshl_s_nv8hi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqshlq_n_s32 (int32x4_t __a, const int __b)
 {
-  return (int32x4_t)__builtin_neon_vqshl_nv4si (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vqshl_s_nv4si (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqshlq_n_s64 (int64x2_t __a, const int __b)
 {
-  return (int64x2_t)__builtin_neon_vqshl_nv2di (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vqshl_s_nv2di (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vqshlq_n_u8 (uint8x16_t __a, const int __b)
 {
-  return (uint8x16_t)__builtin_neon_vqshl_nv16qi ((int8x16_t) __a, __b, 0);
+  return (uint8x16_t)__builtin_neon_vqshl_u_nv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vqshlq_n_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint16x8_t)__builtin_neon_vqshl_nv8hi ((int16x8_t) __a, __b, 0);
+  return (uint16x8_t)__builtin_neon_vqshl_u_nv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vqshlq_n_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint32x4_t)__builtin_neon_vqshl_nv4si ((int32x4_t) __a, __b, 0);
+  return (uint32x4_t)__builtin_neon_vqshl_u_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vqshlq_n_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint64x2_t)__builtin_neon_vqshl_nv2di ((int64x2_t) __a, __b, 0);
+  return (uint64x2_t)__builtin_neon_vqshl_u_nv2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqshlu_n_s8 (int8x8_t __a, const int __b)
 {
-  return (uint8x8_t)__builtin_neon_vqshlu_nv8qi (__a, __b, 1);
+  return (uint8x8_t)__builtin_neon_vqshlu_nv8qi (__a, __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqshlu_n_s16 (int16x4_t __a, const int __b)
 {
-  return (uint16x4_t)__builtin_neon_vqshlu_nv4hi (__a, __b, 1);
+  return (uint16x4_t)__builtin_neon_vqshlu_nv4hi (__a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqshlu_n_s32 (int32x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vqshlu_nv2si (__a, __b, 1);
+  return (uint32x2_t)__builtin_neon_vqshlu_nv2si (__a, __b);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vqshlu_n_s64 (int64x1_t __a, const int __b)
 {
-  return (uint64x1_t)__builtin_neon_vqshlu_ndi (__a, __b, 1);
+  return (uint64x1_t)__builtin_neon_vqshlu_ndi (__a, __b);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vqshluq_n_s8 (int8x16_t __a, const int __b)
 {
-  return (uint8x16_t)__builtin_neon_vqshlu_nv16qi (__a, __b, 1);
+  return (uint8x16_t)__builtin_neon_vqshlu_nv16qi (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vqshluq_n_s16 (int16x8_t __a, const int __b)
 {
-  return (uint16x8_t)__builtin_neon_vqshlu_nv8hi (__a, __b, 1);
+  return (uint16x8_t)__builtin_neon_vqshlu_nv8hi (__a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vqshluq_n_s32 (int32x4_t __a, const int __b)
 {
-  return (uint32x4_t)__builtin_neon_vqshlu_nv4si (__a, __b, 1);
+  return (uint32x4_t)__builtin_neon_vqshlu_nv4si (__a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vqshluq_n_s64 (int64x2_t __a, const int __b)
 {
-  return (uint64x2_t)__builtin_neon_vqshlu_nv2di (__a, __b, 1);
+  return (uint64x2_t)__builtin_neon_vqshlu_nv2di (__a, __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vshll_n_s8 (int8x8_t __a, const int __b)
 {
-  return (int16x8_t)__builtin_neon_vshll_nv8qi (__a, __b, 1);
+  return (int16x8_t)__builtin_neon_vshlls_nv8qi (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vshll_n_s16 (int16x4_t __a, const int __b)
 {
-  return (int32x4_t)__builtin_neon_vshll_nv4hi (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vshlls_nv4hi (__a, __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vshll_n_s32 (int32x2_t __a, const int __b)
 {
-  return (int64x2_t)__builtin_neon_vshll_nv2si (__a, __b, 1);
+  return (int64x2_t)__builtin_neon_vshlls_nv2si (__a, __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vshll_n_u8 (uint8x8_t __a, const int __b)
 {
-  return (uint16x8_t)__builtin_neon_vshll_nv8qi ((int8x8_t) __a, __b, 0);
+  return (uint16x8_t)__builtin_neon_vshllu_nv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vshll_n_u16 (uint16x4_t __a, const int __b)
 {
-  return (uint32x4_t)__builtin_neon_vshll_nv4hi ((int16x4_t) __a, __b, 0);
+  return (uint32x4_t)__builtin_neon_vshllu_nv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vshll_n_u32 (uint32x2_t __a, const int __b)
 {
-  return (uint64x2_t)__builtin_neon_vshll_nv2si ((int32x2_t) __a, __b, 0);
+  return (uint64x2_t)__builtin_neon_vshllu_nv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vsra_n_s8 (int8x8_t __a, int8x8_t __b, const int __c)
 {
-  return (int8x8_t)__builtin_neon_vsra_nv8qi (__a, __b, __c, 1);
+  return (int8x8_t)__builtin_neon_vsras_nv8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vsra_n_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x4_t)__builtin_neon_vsra_nv4hi (__a, __b, __c, 1);
+  return (int16x4_t)__builtin_neon_vsras_nv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vsra_n_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x2_t)__builtin_neon_vsra_nv2si (__a, __b, __c, 1);
+  return (int32x2_t)__builtin_neon_vsras_nv2si (__a, __b, __c);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vsra_n_s64 (int64x1_t __a, int64x1_t __b, const int __c)
 {
-  return (int64x1_t)__builtin_neon_vsra_ndi (__a, __b, __c, 1);
+  return (int64x1_t)__builtin_neon_vsras_ndi (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vsra_n_u8 (uint8x8_t __a, uint8x8_t __b, const int __c)
 {
-  return (uint8x8_t)__builtin_neon_vsra_nv8qi ((int8x8_t) __a, (int8x8_t) __b, __c, 0);
+  return (uint8x8_t)__builtin_neon_vsrau_nv8qi ((int8x8_t) __a, (int8x8_t) __b, __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vsra_n_u16 (uint16x4_t __a, uint16x4_t __b, const int __c)
 {
-  return (uint16x4_t)__builtin_neon_vsra_nv4hi ((int16x4_t) __a, (int16x4_t) __b, __c, 0);
+  return (uint16x4_t)__builtin_neon_vsrau_nv4hi ((int16x4_t) __a, (int16x4_t) __b, __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vsra_n_u32 (uint32x2_t __a, uint32x2_t __b, const int __c)
 {
-  return (uint32x2_t)__builtin_neon_vsra_nv2si ((int32x2_t) __a, (int32x2_t) __b, __c, 0);
+  return (uint32x2_t)__builtin_neon_vsrau_nv2si ((int32x2_t) __a, (int32x2_t) __b, __c);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vsra_n_u64 (uint64x1_t __a, uint64x1_t __b, const int __c)
 {
-  return (uint64x1_t)__builtin_neon_vsra_ndi ((int64x1_t) __a, (int64x1_t) __b, __c, 0);
+  return (uint64x1_t)__builtin_neon_vsrau_ndi ((int64x1_t) __a, (int64x1_t) __b, __c);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vsraq_n_s8 (int8x16_t __a, int8x16_t __b, const int __c)
 {
-  return (int8x16_t)__builtin_neon_vsra_nv16qi (__a, __b, __c, 1);
+  return (int8x16_t)__builtin_neon_vsras_nv16qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vsraq_n_s16 (int16x8_t __a, int16x8_t __b, const int __c)
 {
-  return (int16x8_t)__builtin_neon_vsra_nv8hi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vsras_nv8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vsraq_n_s32 (int32x4_t __a, int32x4_t __b, const int __c)
 {
-  return (int32x4_t)__builtin_neon_vsra_nv4si (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vsras_nv4si (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vsraq_n_s64 (int64x2_t __a, int64x2_t __b, const int __c)
 {
-  return (int64x2_t)__builtin_neon_vsra_nv2di (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vsras_nv2di (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vsraq_n_u8 (uint8x16_t __a, uint8x16_t __b, const int __c)
 {
-  return (uint8x16_t)__builtin_neon_vsra_nv16qi ((int8x16_t) __a, (int8x16_t) __b, __c, 0);
+  return (uint8x16_t)__builtin_neon_vsrau_nv16qi ((int8x16_t) __a, (int8x16_t) __b, __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vsraq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c)
 {
-  return (uint16x8_t)__builtin_neon_vsra_nv8hi ((int16x8_t) __a, (int16x8_t) __b, __c, 0);
+  return (uint16x8_t)__builtin_neon_vsrau_nv8hi ((int16x8_t) __a, (int16x8_t) __b, __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vsraq_n_u32 (uint32x4_t __a, uint32x4_t __b, const int __c)
 {
-  return (uint32x4_t)__builtin_neon_vsra_nv4si ((int32x4_t) __a, (int32x4_t) __b, __c, 0);
+  return (uint32x4_t)__builtin_neon_vsrau_nv4si ((int32x4_t) __a, (int32x4_t) __b, __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vsraq_n_u64 (uint64x2_t __a, uint64x2_t __b, const int __c)
 {
-  return (uint64x2_t)__builtin_neon_vsra_nv2di ((int64x2_t) __a, (int64x2_t) __b, __c, 0);
+  return (uint64x2_t)__builtin_neon_vsrau_nv2di ((int64x2_t) __a, (int64x2_t) __b, __c);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vrsra_n_s8 (int8x8_t __a, int8x8_t __b, const int __c)
 {
-  return (int8x8_t)__builtin_neon_vsra_nv8qi (__a, __b, __c, 5);
+  return (int8x8_t)__builtin_neon_vrsras_nv8qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vrsra_n_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x4_t)__builtin_neon_vsra_nv4hi (__a, __b, __c, 5);
+  return (int16x4_t)__builtin_neon_vrsras_nv4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vrsra_n_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x2_t)__builtin_neon_vsra_nv2si (__a, __b, __c, 5);
+  return (int32x2_t)__builtin_neon_vrsras_nv2si (__a, __b, __c);
 }
 
 __extension__ static __inline int64x1_t __attribute__ ((__always_inline__))
 vrsra_n_s64 (int64x1_t __a, int64x1_t __b, const int __c)
 {
-  return (int64x1_t)__builtin_neon_vsra_ndi (__a, __b, __c, 5);
+  return (int64x1_t)__builtin_neon_vrsras_ndi (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vrsra_n_u8 (uint8x8_t __a, uint8x8_t __b, const int __c)
 {
-  return (uint8x8_t)__builtin_neon_vsra_nv8qi ((int8x8_t) __a, (int8x8_t) __b, __c, 4);
+  return (uint8x8_t)__builtin_neon_vrsrau_nv8qi ((int8x8_t) __a, (int8x8_t) __b, __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vrsra_n_u16 (uint16x4_t __a, uint16x4_t __b, const int __c)
 {
-  return (uint16x4_t)__builtin_neon_vsra_nv4hi ((int16x4_t) __a, (int16x4_t) __b, __c, 4);
+  return (uint16x4_t)__builtin_neon_vrsrau_nv4hi ((int16x4_t) __a, (int16x4_t) __b, __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrsra_n_u32 (uint32x2_t __a, uint32x2_t __b, const int __c)
 {
-  return (uint32x2_t)__builtin_neon_vsra_nv2si ((int32x2_t) __a, (int32x2_t) __b, __c, 4);
+  return (uint32x2_t)__builtin_neon_vrsrau_nv2si ((int32x2_t) __a, (int32x2_t) __b, __c);
 }
 
 __extension__ static __inline uint64x1_t __attribute__ ((__always_inline__))
 vrsra_n_u64 (uint64x1_t __a, uint64x1_t __b, const int __c)
 {
-  return (uint64x1_t)__builtin_neon_vsra_ndi ((int64x1_t) __a, (int64x1_t) __b, __c, 4);
+  return (uint64x1_t)__builtin_neon_vrsrau_ndi ((int64x1_t) __a, (int64x1_t) __b, __c);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vrsraq_n_s8 (int8x16_t __a, int8x16_t __b, const int __c)
 {
-  return (int8x16_t)__builtin_neon_vsra_nv16qi (__a, __b, __c, 5);
+  return (int8x16_t)__builtin_neon_vrsras_nv16qi (__a, __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vrsraq_n_s16 (int16x8_t __a, int16x8_t __b, const int __c)
 {
-  return (int16x8_t)__builtin_neon_vsra_nv8hi (__a, __b, __c, 5);
+  return (int16x8_t)__builtin_neon_vrsras_nv8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vrsraq_n_s32 (int32x4_t __a, int32x4_t __b, const int __c)
 {
-  return (int32x4_t)__builtin_neon_vsra_nv4si (__a, __b, __c, 5);
+  return (int32x4_t)__builtin_neon_vrsras_nv4si (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vrsraq_n_s64 (int64x2_t __a, int64x2_t __b, const int __c)
 {
-  return (int64x2_t)__builtin_neon_vsra_nv2di (__a, __b, __c, 5);
+  return (int64x2_t)__builtin_neon_vrsras_nv2di (__a, __b, __c);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vrsraq_n_u8 (uint8x16_t __a, uint8x16_t __b, const int __c)
 {
-  return (uint8x16_t)__builtin_neon_vsra_nv16qi ((int8x16_t) __a, (int8x16_t) __b, __c, 4);
+  return (uint8x16_t)__builtin_neon_vrsrau_nv16qi ((int8x16_t) __a, (int8x16_t) __b, __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vrsraq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c)
 {
-  return (uint16x8_t)__builtin_neon_vsra_nv8hi ((int16x8_t) __a, (int16x8_t) __b, __c, 4);
+  return (uint16x8_t)__builtin_neon_vrsrau_nv8hi ((int16x8_t) __a, (int16x8_t) __b, __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vrsraq_n_u32 (uint32x4_t __a, uint32x4_t __b, const int __c)
 {
-  return (uint32x4_t)__builtin_neon_vsra_nv4si ((int32x4_t) __a, (int32x4_t) __b, __c, 4);
+  return (uint32x4_t)__builtin_neon_vrsrau_nv4si ((int32x4_t) __a, (int32x4_t) __b, __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vrsraq_n_u64 (uint64x2_t __a, uint64x2_t __b, const int __c)
 {
-  return (uint64x2_t)__builtin_neon_vsra_nv2di ((int64x2_t) __a, (int64x2_t) __b, __c, 4);
+  return (uint64x2_t)__builtin_neon_vrsrau_nv2di ((int64x2_t) __a, (int64x2_t) __b, __c);
 }
 
 #ifdef __ARM_FEATURE_CRYPTO
@@ -4718,577 +4718,577 @@ vsliq_n_p16 (poly16x8_t __a, poly16x8_t __b, const int __c)
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vabs_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vabsv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vabsv8qi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vabs_s16 (int16x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vabsv4hi (__a, 1);
+  return (int16x4_t)__builtin_neon_vabsv4hi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vabs_s32 (int32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vabsv2si (__a, 1);
+  return (int32x2_t)__builtin_neon_vabsv2si (__a);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vabs_f32 (float32x2_t __a)
 {
-  return (float32x2_t)__builtin_neon_vabsv2sf (__a, 3);
+  return (float32x2_t)__builtin_neon_vabsv2sf (__a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vabsq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vabsv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vabsv16qi (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vabsq_s16 (int16x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vabsv8hi (__a, 1);
+  return (int16x8_t)__builtin_neon_vabsv8hi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vabsq_s32 (int32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vabsv4si (__a, 1);
+  return (int32x4_t)__builtin_neon_vabsv4si (__a);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vabsq_f32 (float32x4_t __a)
 {
-  return (float32x4_t)__builtin_neon_vabsv4sf (__a, 3);
+  return (float32x4_t)__builtin_neon_vabsv4sf (__a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqabs_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vqabsv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vqabsv8qi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqabs_s16 (int16x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vqabsv4hi (__a, 1);
+  return (int16x4_t)__builtin_neon_vqabsv4hi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqabs_s32 (int32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vqabsv2si (__a, 1);
+  return (int32x2_t)__builtin_neon_vqabsv2si (__a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vqabsq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vqabsv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vqabsv16qi (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqabsq_s16 (int16x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vqabsv8hi (__a, 1);
+  return (int16x8_t)__builtin_neon_vqabsv8hi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqabsq_s32 (int32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vqabsv4si (__a, 1);
+  return (int32x4_t)__builtin_neon_vqabsv4si (__a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vneg_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vnegv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vnegv8qi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vneg_s16 (int16x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vnegv4hi (__a, 1);
+  return (int16x4_t)__builtin_neon_vnegv4hi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vneg_s32 (int32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vnegv2si (__a, 1);
+  return (int32x2_t)__builtin_neon_vnegv2si (__a);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vneg_f32 (float32x2_t __a)
 {
-  return (float32x2_t)__builtin_neon_vnegv2sf (__a, 3);
+  return (float32x2_t)__builtin_neon_vnegv2sf (__a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vnegq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vnegv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vnegv16qi (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vnegq_s16 (int16x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vnegv8hi (__a, 1);
+  return (int16x8_t)__builtin_neon_vnegv8hi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vnegq_s32 (int32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vnegv4si (__a, 1);
+  return (int32x4_t)__builtin_neon_vnegv4si (__a);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vnegq_f32 (float32x4_t __a)
 {
-  return (float32x4_t)__builtin_neon_vnegv4sf (__a, 3);
+  return (float32x4_t)__builtin_neon_vnegv4sf (__a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqneg_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vqnegv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vqnegv8qi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqneg_s16 (int16x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vqnegv4hi (__a, 1);
+  return (int16x4_t)__builtin_neon_vqnegv4hi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqneg_s32 (int32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vqnegv2si (__a, 1);
+  return (int32x2_t)__builtin_neon_vqnegv2si (__a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vqnegq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vqnegv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vqnegv16qi (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqnegq_s16 (int16x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vqnegv8hi (__a, 1);
+  return (int16x8_t)__builtin_neon_vqnegv8hi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqnegq_s32 (int32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vqnegv4si (__a, 1);
+  return (int32x4_t)__builtin_neon_vqnegv4si (__a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vmvn_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vmvnv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vmvnv8qi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmvn_s16 (int16x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vmvnv4hi (__a, 1);
+  return (int16x4_t)__builtin_neon_vmvnv4hi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmvn_s32 (int32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vmvnv2si (__a, 1);
+  return (int32x2_t)__builtin_neon_vmvnv2si (__a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vmvn_u8 (uint8x8_t __a)
 {
-  return (uint8x8_t)__builtin_neon_vmvnv8qi ((int8x8_t) __a, 0);
+  return (uint8x8_t)__builtin_neon_vmvnv8qi ((int8x8_t) __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmvn_u16 (uint16x4_t __a)
 {
-  return (uint16x4_t)__builtin_neon_vmvnv4hi ((int16x4_t) __a, 0);
+  return (uint16x4_t)__builtin_neon_vmvnv4hi ((int16x4_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmvn_u32 (uint32x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vmvnv2si ((int32x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vmvnv2si ((int32x2_t) __a);
 }
 
 __extension__ static __inline poly8x8_t __attribute__ ((__always_inline__))
 vmvn_p8 (poly8x8_t __a)
 {
-  return (poly8x8_t)__builtin_neon_vmvnv8qi ((int8x8_t) __a, 2);
+  return (poly8x8_t)__builtin_neon_vmvnv8qi ((int8x8_t) __a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vmvnq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vmvnv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vmvnv16qi (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmvnq_s16 (int16x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vmvnv8hi (__a, 1);
+  return (int16x8_t)__builtin_neon_vmvnv8hi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmvnq_s32 (int32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vmvnv4si (__a, 1);
+  return (int32x4_t)__builtin_neon_vmvnv4si (__a);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vmvnq_u8 (uint8x16_t __a)
 {
-  return (uint8x16_t)__builtin_neon_vmvnv16qi ((int8x16_t) __a, 0);
+  return (uint8x16_t)__builtin_neon_vmvnv16qi ((int8x16_t) __a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmvnq_u16 (uint16x8_t __a)
 {
-  return (uint16x8_t)__builtin_neon_vmvnv8hi ((int16x8_t) __a, 0);
+  return (uint16x8_t)__builtin_neon_vmvnv8hi ((int16x8_t) __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmvnq_u32 (uint32x4_t __a)
 {
-  return (uint32x4_t)__builtin_neon_vmvnv4si ((int32x4_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vmvnv4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline poly8x16_t __attribute__ ((__always_inline__))
 vmvnq_p8 (poly8x16_t __a)
 {
-  return (poly8x16_t)__builtin_neon_vmvnv16qi ((int8x16_t) __a, 2);
+  return (poly8x16_t)__builtin_neon_vmvnv16qi ((int8x16_t) __a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vcls_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vclsv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vclsv8qi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vcls_s16 (int16x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vclsv4hi (__a, 1);
+  return (int16x4_t)__builtin_neon_vclsv4hi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vcls_s32 (int32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vclsv2si (__a, 1);
+  return (int32x2_t)__builtin_neon_vclsv2si (__a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vclsq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vclsv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vclsv16qi (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vclsq_s16 (int16x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vclsv8hi (__a, 1);
+  return (int16x8_t)__builtin_neon_vclsv8hi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vclsq_s32 (int32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vclsv4si (__a, 1);
+  return (int32x4_t)__builtin_neon_vclsv4si (__a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vclz_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vclzv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vclzv8qi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vclz_s16 (int16x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vclzv4hi (__a, 1);
+  return (int16x4_t)__builtin_neon_vclzv4hi (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vclz_s32 (int32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vclzv2si (__a, 1);
+  return (int32x2_t)__builtin_neon_vclzv2si (__a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vclz_u8 (uint8x8_t __a)
 {
-  return (uint8x8_t)__builtin_neon_vclzv8qi ((int8x8_t) __a, 0);
+  return (uint8x8_t)__builtin_neon_vclzv8qi ((int8x8_t) __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vclz_u16 (uint16x4_t __a)
 {
-  return (uint16x4_t)__builtin_neon_vclzv4hi ((int16x4_t) __a, 0);
+  return (uint16x4_t)__builtin_neon_vclzv4hi ((int16x4_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vclz_u32 (uint32x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vclzv2si ((int32x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vclzv2si ((int32x2_t) __a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vclzq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vclzv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vclzv16qi (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vclzq_s16 (int16x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vclzv8hi (__a, 1);
+  return (int16x8_t)__builtin_neon_vclzv8hi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vclzq_s32 (int32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vclzv4si (__a, 1);
+  return (int32x4_t)__builtin_neon_vclzv4si (__a);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vclzq_u8 (uint8x16_t __a)
 {
-  return (uint8x16_t)__builtin_neon_vclzv16qi ((int8x16_t) __a, 0);
+  return (uint8x16_t)__builtin_neon_vclzv16qi ((int8x16_t) __a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vclzq_u16 (uint16x8_t __a)
 {
-  return (uint16x8_t)__builtin_neon_vclzv8hi ((int16x8_t) __a, 0);
+  return (uint16x8_t)__builtin_neon_vclzv8hi ((int16x8_t) __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vclzq_u32 (uint32x4_t __a)
 {
-  return (uint32x4_t)__builtin_neon_vclzv4si ((int32x4_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vclzv4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vcnt_s8 (int8x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vcntv8qi (__a, 1);
+  return (int8x8_t)__builtin_neon_vcntv8qi (__a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vcnt_u8 (uint8x8_t __a)
 {
-  return (uint8x8_t)__builtin_neon_vcntv8qi ((int8x8_t) __a, 0);
+  return (uint8x8_t)__builtin_neon_vcntv8qi ((int8x8_t) __a);
 }
 
 __extension__ static __inline poly8x8_t __attribute__ ((__always_inline__))
 vcnt_p8 (poly8x8_t __a)
 {
-  return (poly8x8_t)__builtin_neon_vcntv8qi ((int8x8_t) __a, 2);
+  return (poly8x8_t)__builtin_neon_vcntv8qi ((int8x8_t) __a);
 }
 
 __extension__ static __inline int8x16_t __attribute__ ((__always_inline__))
 vcntq_s8 (int8x16_t __a)
 {
-  return (int8x16_t)__builtin_neon_vcntv16qi (__a, 1);
+  return (int8x16_t)__builtin_neon_vcntv16qi (__a);
 }
 
 __extension__ static __inline uint8x16_t __attribute__ ((__always_inline__))
 vcntq_u8 (uint8x16_t __a)
 {
-  return (uint8x16_t)__builtin_neon_vcntv16qi ((int8x16_t) __a, 0);
+  return (uint8x16_t)__builtin_neon_vcntv16qi ((int8x16_t) __a);
 }
 
 __extension__ static __inline poly8x16_t __attribute__ ((__always_inline__))
 vcntq_p8 (poly8x16_t __a)
 {
-  return (poly8x16_t)__builtin_neon_vcntv16qi ((int8x16_t) __a, 2);
+  return (poly8x16_t)__builtin_neon_vcntv16qi ((int8x16_t) __a);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vrecpe_f32 (float32x2_t __a)
 {
-  return (float32x2_t)__builtin_neon_vrecpev2sf (__a, 3);
+  return (float32x2_t)__builtin_neon_vrecpev2sf (__a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrecpe_u32 (uint32x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vrecpev2si ((int32x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vrecpev2si ((int32x2_t) __a);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vrecpeq_f32 (float32x4_t __a)
 {
-  return (float32x4_t)__builtin_neon_vrecpev4sf (__a, 3);
+  return (float32x4_t)__builtin_neon_vrecpev4sf (__a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vrecpeq_u32 (uint32x4_t __a)
 {
-  return (uint32x4_t)__builtin_neon_vrecpev4si ((int32x4_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vrecpev4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vrsqrte_f32 (float32x2_t __a)
 {
-  return (float32x2_t)__builtin_neon_vrsqrtev2sf (__a, 3);
+  return (float32x2_t)__builtin_neon_vrsqrtev2sf (__a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vrsqrte_u32 (uint32x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vrsqrtev2si ((int32x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vrsqrtev2si ((int32x2_t) __a);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vrsqrteq_f32 (float32x4_t __a)
 {
-  return (float32x4_t)__builtin_neon_vrsqrtev4sf (__a, 3);
+  return (float32x4_t)__builtin_neon_vrsqrtev4sf (__a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vrsqrteq_u32 (uint32x4_t __a)
 {
-  return (uint32x4_t)__builtin_neon_vrsqrtev4si ((int32x4_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vrsqrtev4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline int8_t __attribute__ ((__always_inline__))
 vget_lane_s8 (int8x8_t __a, const int __b)
 {
-  return (int8_t)__builtin_neon_vget_lanev8qi (__a, __b, 1);
+  return (int8_t)__builtin_neon_vget_lanev8qi (__a, __b);
 }
 
 __extension__ static __inline int16_t __attribute__ ((__always_inline__))
 vget_lane_s16 (int16x4_t __a, const int __b)
 {
-  return (int16_t)__builtin_neon_vget_lanev4hi (__a, __b, 1);
+  return (int16_t)__builtin_neon_vget_lanev4hi (__a, __b);
 }
 
 __extension__ static __inline int32_t __attribute__ ((__always_inline__))
 vget_lane_s32 (int32x2_t __a, const int __b)
 {
-  return (int32_t)__builtin_neon_vget_lanev2si (__a, __b, 1);
+  return (int32_t)__builtin_neon_vget_lanev2si (__a, __b);
 }
 
 __extension__ static __inline float32_t __attribute__ ((__always_inline__))
 vget_lane_f32 (float32x2_t __a, const int __b)
 {
-  return (float32_t)__builtin_neon_vget_lanev2sf (__a, __b, 3);
+  return (float32_t)__builtin_neon_vget_lanev2sf (__a, __b);
 }
 
 __extension__ static __inline uint8_t __attribute__ ((__always_inline__))
 vget_lane_u8 (uint8x8_t __a, const int __b)
 {
-  return (uint8_t)__builtin_neon_vget_lanev8qi ((int8x8_t) __a, __b, 0);
+  return (uint8_t)__builtin_neon_vget_laneuv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline uint16_t __attribute__ ((__always_inline__))
 vget_lane_u16 (uint16x4_t __a, const int __b)
 {
-  return (uint16_t)__builtin_neon_vget_lanev4hi ((int16x4_t) __a, __b, 0);
+  return (uint16_t)__builtin_neon_vget_laneuv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32_t __attribute__ ((__always_inline__))
 vget_lane_u32 (uint32x2_t __a, const int __b)
 {
-  return (uint32_t)__builtin_neon_vget_lanev2si ((int32x2_t) __a, __b, 0);
+  return (uint32_t)__builtin_neon_vget_laneuv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline poly8_t __attribute__ ((__always_inline__))
 vget_lane_p8 (poly8x8_t __a, const int __b)
 {
-  return (poly8_t)__builtin_neon_vget_lanev8qi ((int8x8_t) __a, __b, 2);
+  return (poly8_t)__builtin_neon_vget_laneuv8qi ((int8x8_t) __a, __b);
 }
 
 __extension__ static __inline poly16_t __attribute__ ((__always_inline__))
 vget_lane_p16 (poly16x4_t __a, const int __b)
 {
-  return (poly16_t)__builtin_neon_vget_lanev4hi ((int16x4_t) __a, __b, 2);
+  return (poly16_t)__builtin_neon_vget_laneuv4hi ((int16x4_t) __a, __b);
 }
 
 __extension__ static __inline int64_t __attribute__ ((__always_inline__))
 vget_lane_s64 (int64x1_t __a, const int __b)
 {
-  return (int64_t)__builtin_neon_vget_lanedi (__a, __b, 1);
+  return (int64_t)__builtin_neon_vget_lanedi (__a, __b);
 }
 
 __extension__ static __inline uint64_t __attribute__ ((__always_inline__))
 vget_lane_u64 (uint64x1_t __a, const int __b)
 {
-  return (uint64_t)__builtin_neon_vget_lanedi ((int64x1_t) __a, __b, 0);
+  return (uint64_t)__builtin_neon_vget_lanedi ((int64x1_t) __a, __b);
 }
 
 __extension__ static __inline int8_t __attribute__ ((__always_inline__))
 vgetq_lane_s8 (int8x16_t __a, const int __b)
 {
-  return (int8_t)__builtin_neon_vget_lanev16qi (__a, __b, 1);
+  return (int8_t)__builtin_neon_vget_lanev16qi (__a, __b);
 }
 
 __extension__ static __inline int16_t __attribute__ ((__always_inline__))
 vgetq_lane_s16 (int16x8_t __a, const int __b)
 {
-  return (int16_t)__builtin_neon_vget_lanev8hi (__a, __b, 1);
+  return (int16_t)__builtin_neon_vget_lanev8hi (__a, __b);
 }
 
 __extension__ static __inline int32_t __attribute__ ((__always_inline__))
 vgetq_lane_s32 (int32x4_t __a, const int __b)
 {
-  return (int32_t)__builtin_neon_vget_lanev4si (__a, __b, 1);
+  return (int32_t)__builtin_neon_vget_lanev4si (__a, __b);
 }
 
 __extension__ static __inline float32_t __attribute__ ((__always_inline__))
 vgetq_lane_f32 (float32x4_t __a, const int __b)
 {
-  return (float32_t)__builtin_neon_vget_lanev4sf (__a, __b, 3);
+  return (float32_t)__builtin_neon_vget_lanev4sf (__a, __b);
 }
 
 __extension__ static __inline uint8_t __attribute__ ((__always_inline__))
 vgetq_lane_u8 (uint8x16_t __a, const int __b)
 {
-  return (uint8_t)__builtin_neon_vget_lanev16qi ((int8x16_t) __a, __b, 0);
+  return (uint8_t)__builtin_neon_vget_laneuv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline uint16_t __attribute__ ((__always_inline__))
 vgetq_lane_u16 (uint16x8_t __a, const int __b)
 {
-  return (uint16_t)__builtin_neon_vget_lanev8hi ((int16x8_t) __a, __b, 0);
+  return (uint16_t)__builtin_neon_vget_laneuv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline uint32_t __attribute__ ((__always_inline__))
 vgetq_lane_u32 (uint32x4_t __a, const int __b)
 {
-  return (uint32_t)__builtin_neon_vget_lanev4si ((int32x4_t) __a, __b, 0);
+  return (uint32_t)__builtin_neon_vget_laneuv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline poly8_t __attribute__ ((__always_inline__))
 vgetq_lane_p8 (poly8x16_t __a, const int __b)
 {
-  return (poly8_t)__builtin_neon_vget_lanev16qi ((int8x16_t) __a, __b, 2);
+  return (poly8_t)__builtin_neon_vget_laneuv16qi ((int8x16_t) __a, __b);
 }
 
 __extension__ static __inline poly16_t __attribute__ ((__always_inline__))
 vgetq_lane_p16 (poly16x8_t __a, const int __b)
 {
-  return (poly16_t)__builtin_neon_vget_lanev8hi ((int16x8_t) __a, __b, 2);
+  return (poly16_t)__builtin_neon_vget_laneuv8hi ((int16x8_t) __a, __b);
 }
 
 __extension__ static __inline int64_t __attribute__ ((__always_inline__))
 vgetq_lane_s64 (int64x2_t __a, const int __b)
 {
-  return (int64_t)__builtin_neon_vget_lanev2di (__a, __b, 1);
+  return (int64_t)__builtin_neon_vget_lanev2di (__a, __b);
 }
 
 __extension__ static __inline uint64_t __attribute__ ((__always_inline__))
 vgetq_lane_u64 (uint64x2_t __a, const int __b)
 {
-  return (uint64_t)__builtin_neon_vget_lanev2di ((int64x2_t) __a, __b, 0);
+  return (uint64_t)__builtin_neon_vget_lanev2di ((int64x2_t) __a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
@@ -6150,49 +6150,49 @@ vget_low_u64 (uint64x2_t __a)
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vcvt_s32_f32 (float32x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vcvtv2sf (__a, 1);
+  return (int32x2_t)__builtin_neon_vcvtsv2sf (__a);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vcvt_f32_s32 (int32x2_t __a)
 {
-  return (float32x2_t)__builtin_neon_vcvtv2si (__a, 1);
+  return (float32x2_t)__builtin_neon_vcvtsv2si (__a);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vcvt_f32_u32 (uint32x2_t __a)
 {
-  return (float32x2_t)__builtin_neon_vcvtv2si ((int32x2_t) __a, 0);
+  return (float32x2_t)__builtin_neon_vcvtuv2si ((int32x2_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcvt_u32_f32 (float32x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vcvtv2sf (__a, 0);
+  return (uint32x2_t)__builtin_neon_vcvtuv2sf (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vcvtq_s32_f32 (float32x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vcvtv4sf (__a, 1);
+  return (int32x4_t)__builtin_neon_vcvtsv4sf (__a);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vcvtq_f32_s32 (int32x4_t __a)
 {
-  return (float32x4_t)__builtin_neon_vcvtv4si (__a, 1);
+  return (float32x4_t)__builtin_neon_vcvtsv4si (__a);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vcvtq_f32_u32 (uint32x4_t __a)
 {
-  return (float32x4_t)__builtin_neon_vcvtv4si ((int32x4_t) __a, 0);
+  return (float32x4_t)__builtin_neon_vcvtuv4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcvtq_u32_f32 (float32x4_t __a)
 {
-  return (uint32x4_t)__builtin_neon_vcvtv4sf (__a, 0);
+  return (uint32x4_t)__builtin_neon_vcvtuv4sf (__a);
 }
 
 #if ((__ARM_FP & 0x2) != 0)
@@ -6214,175 +6214,175 @@ vcvt_f32_f16 (float16x4_t __a)
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vcvt_n_s32_f32 (float32x2_t __a, const int __b)
 {
-  return (int32x2_t)__builtin_neon_vcvt_nv2sf (__a, __b, 1);
+  return (int32x2_t)__builtin_neon_vcvts_nv2sf (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vcvt_n_f32_s32 (int32x2_t __a, const int __b)
 {
-  return (float32x2_t)__builtin_neon_vcvt_nv2si (__a, __b, 1);
+  return (float32x2_t)__builtin_neon_vcvts_nv2si (__a, __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vcvt_n_f32_u32 (uint32x2_t __a, const int __b)
 {
-  return (float32x2_t)__builtin_neon_vcvt_nv2si ((int32x2_t) __a, __b, 0);
+  return (float32x2_t)__builtin_neon_vcvtu_nv2si ((int32x2_t) __a, __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vcvt_n_u32_f32 (float32x2_t __a, const int __b)
 {
-  return (uint32x2_t)__builtin_neon_vcvt_nv2sf (__a, __b, 0);
+  return (uint32x2_t)__builtin_neon_vcvtu_nv2sf (__a, __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vcvtq_n_s32_f32 (float32x4_t __a, const int __b)
 {
-  return (int32x4_t)__builtin_neon_vcvt_nv4sf (__a, __b, 1);
+  return (int32x4_t)__builtin_neon_vcvts_nv4sf (__a, __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vcvtq_n_f32_s32 (int32x4_t __a, const int __b)
 {
-  return (float32x4_t)__builtin_neon_vcvt_nv4si (__a, __b, 1);
+  return (float32x4_t)__builtin_neon_vcvts_nv4si (__a, __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vcvtq_n_f32_u32 (uint32x4_t __a, const int __b)
 {
-  return (float32x4_t)__builtin_neon_vcvt_nv4si ((int32x4_t) __a, __b, 0);
+  return (float32x4_t)__builtin_neon_vcvtu_nv4si ((int32x4_t) __a, __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vcvtq_n_u32_f32 (float32x4_t __a, const int __b)
 {
-  return (uint32x4_t)__builtin_neon_vcvt_nv4sf (__a, __b, 0);
+  return (uint32x4_t)__builtin_neon_vcvtu_nv4sf (__a, __b);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vmovn_s16 (int16x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vmovnv8hi (__a, 1);
+  return (int8x8_t)__builtin_neon_vmovnv8hi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmovn_s32 (int32x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vmovnv4si (__a, 1);
+  return (int16x4_t)__builtin_neon_vmovnv4si (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmovn_s64 (int64x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vmovnv2di (__a, 1);
+  return (int32x2_t)__builtin_neon_vmovnv2di (__a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vmovn_u16 (uint16x8_t __a)
 {
-  return (uint8x8_t)__builtin_neon_vmovnv8hi ((int16x8_t) __a, 0);
+  return (uint8x8_t)__builtin_neon_vmovnv8hi ((int16x8_t) __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmovn_u32 (uint32x4_t __a)
 {
-  return (uint16x4_t)__builtin_neon_vmovnv4si ((int32x4_t) __a, 0);
+  return (uint16x4_t)__builtin_neon_vmovnv4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmovn_u64 (uint64x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vmovnv2di ((int64x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vmovnv2di ((int64x2_t) __a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
 vqmovn_s16 (int16x8_t __a)
 {
-  return (int8x8_t)__builtin_neon_vqmovnv8hi (__a, 1);
+  return (int8x8_t)__builtin_neon_vqmovnsv8hi (__a);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqmovn_s32 (int32x4_t __a)
 {
-  return (int16x4_t)__builtin_neon_vqmovnv4si (__a, 1);
+  return (int16x4_t)__builtin_neon_vqmovnsv4si (__a);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqmovn_s64 (int64x2_t __a)
 {
-  return (int32x2_t)__builtin_neon_vqmovnv2di (__a, 1);
+  return (int32x2_t)__builtin_neon_vqmovnsv2di (__a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqmovn_u16 (uint16x8_t __a)
 {
-  return (uint8x8_t)__builtin_neon_vqmovnv8hi ((int16x8_t) __a, 0);
+  return (uint8x8_t)__builtin_neon_vqmovnuv8hi ((int16x8_t) __a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqmovn_u32 (uint32x4_t __a)
 {
-  return (uint16x4_t)__builtin_neon_vqmovnv4si ((int32x4_t) __a, 0);
+  return (uint16x4_t)__builtin_neon_vqmovnuv4si ((int32x4_t) __a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqmovn_u64 (uint64x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vqmovnv2di ((int64x2_t) __a, 0);
+  return (uint32x2_t)__builtin_neon_vqmovnuv2di ((int64x2_t) __a);
 }
 
 __extension__ static __inline uint8x8_t __attribute__ ((__always_inline__))
 vqmovun_s16 (int16x8_t __a)
 {
-  return (uint8x8_t)__builtin_neon_vqmovunv8hi (__a, 1);
+  return (uint8x8_t)__builtin_neon_vqmovunv8hi (__a);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vqmovun_s32 (int32x4_t __a)
 {
-  return (uint16x4_t)__builtin_neon_vqmovunv4si (__a, 1);
+  return (uint16x4_t)__builtin_neon_vqmovunv4si (__a);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vqmovun_s64 (int64x2_t __a)
 {
-  return (uint32x2_t)__builtin_neon_vqmovunv2di (__a, 1);
+  return (uint32x2_t)__builtin_neon_vqmovunv2di (__a);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmovl_s8 (int8x8_t __a)
 {
-  return (int16x8_t)__builtin_neon_vmovlv8qi (__a, 1);
+  return (int16x8_t)__builtin_neon_vmovlsv8qi (__a);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmovl_s16 (int16x4_t __a)
 {
-  return (int32x4_t)__builtin_neon_vmovlv4hi (__a, 1);
+  return (int32x4_t)__builtin_neon_vmovlsv4hi (__a);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmovl_s32 (int32x2_t __a)
 {
-  return (int64x2_t)__builtin_neon_vmovlv2si (__a, 1);
+  return (int64x2_t)__builtin_neon_vmovlsv2si (__a);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmovl_u8 (uint8x8_t __a)
 {
-  return (uint16x8_t)__builtin_neon_vmovlv8qi ((int8x8_t) __a, 0);
+  return (uint16x8_t)__builtin_neon_vmovluv8qi ((int8x8_t) __a);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmovl_u16 (uint16x4_t __a)
 {
-  return (uint32x4_t)__builtin_neon_vmovlv4hi ((int16x4_t) __a, 0);
+  return (uint32x4_t)__builtin_neon_vmovluv4hi ((int16x4_t) __a);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmovl_u32 (uint32x2_t __a)
 {
-  return (uint64x2_t)__builtin_neon_vmovlv2si ((int32x2_t) __a, 0);
+  return (uint64x2_t)__builtin_neon_vmovluv2si ((int32x2_t) __a);
 }
 
 __extension__ static __inline int8x8_t __attribute__ ((__always_inline__))
@@ -6550,673 +6550,673 @@ vtbx4_p8 (poly8x8_t __a, poly8x8x4_t __b, uint8x8_t __c)
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmul_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x4_t)__builtin_neon_vmul_lanev4hi (__a, __b, __c, 1);
+  return (int16x4_t)__builtin_neon_vmul_lanev4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmul_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x2_t)__builtin_neon_vmul_lanev2si (__a, __b, __c, 1);
+  return (int32x2_t)__builtin_neon_vmul_lanev2si (__a, __b, __c);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmul_lane_f32 (float32x2_t __a, float32x2_t __b, const int __c)
 {
-  return (float32x2_t)__builtin_neon_vmul_lanev2sf (__a, __b, __c, 3);
+  return (float32x2_t)__builtin_neon_vmul_lanev2sf (__a, __b, __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmul_lane_u16 (uint16x4_t __a, uint16x4_t __b, const int __c)
 {
-  return (uint16x4_t)__builtin_neon_vmul_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, __c, 0);
+  return (uint16x4_t)__builtin_neon_vmul_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmul_lane_u32 (uint32x2_t __a, uint32x2_t __b, const int __c)
 {
-  return (uint32x2_t)__builtin_neon_vmul_lanev2si ((int32x2_t) __a, (int32x2_t) __b, __c, 0);
+  return (uint32x2_t)__builtin_neon_vmul_lanev2si ((int32x2_t) __a, (int32x2_t) __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmulq_lane_s16 (int16x8_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x8_t)__builtin_neon_vmul_lanev8hi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vmul_lanev8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmulq_lane_s32 (int32x4_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x4_t)__builtin_neon_vmul_lanev4si (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vmul_lanev4si (__a, __b, __c);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmulq_lane_f32 (float32x4_t __a, float32x2_t __b, const int __c)
 {
-  return (float32x4_t)__builtin_neon_vmul_lanev4sf (__a, __b, __c, 3);
+  return (float32x4_t)__builtin_neon_vmul_lanev4sf (__a, __b, __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmulq_lane_u16 (uint16x8_t __a, uint16x4_t __b, const int __c)
 {
-  return (uint16x8_t)__builtin_neon_vmul_lanev8hi ((int16x8_t) __a, (int16x4_t) __b, __c, 0);
+  return (uint16x8_t)__builtin_neon_vmul_lanev8hi ((int16x8_t) __a, (int16x4_t) __b, __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmulq_lane_u32 (uint32x4_t __a, uint32x2_t __b, const int __c)
 {
-  return (uint32x4_t)__builtin_neon_vmul_lanev4si ((int32x4_t) __a, (int32x2_t) __b, __c, 0);
+  return (uint32x4_t)__builtin_neon_vmul_lanev4si ((int32x4_t) __a, (int32x2_t) __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmla_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return (int16x4_t)__builtin_neon_vmla_lanev4hi (__a, __b, __c, __d, 1);
+  return (int16x4_t)__builtin_neon_vmla_lanev4hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmla_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (int32x2_t)__builtin_neon_vmla_lanev2si (__a, __b, __c, __d, 1);
+  return (int32x2_t)__builtin_neon_vmla_lanev2si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmla_lane_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c, const int __d)
 {
-  return (float32x2_t)__builtin_neon_vmla_lanev2sf (__a, __b, __c, __d, 3);
+  return (float32x2_t)__builtin_neon_vmla_lanev2sf (__a, __b, __c, __d);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmla_lane_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d)
 {
-  return (uint16x4_t)__builtin_neon_vmla_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d, 0);
+  return (uint16x4_t)__builtin_neon_vmla_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmla_lane_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d)
 {
-  return (uint32x2_t)__builtin_neon_vmla_lanev2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d, 0);
+  return (uint32x2_t)__builtin_neon_vmla_lanev2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlaq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d)
 {
-  return (int16x8_t)__builtin_neon_vmla_lanev8hi (__a, __b, __c, __d, 1);
+  return (int16x8_t)__builtin_neon_vmla_lanev8hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlaq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d)
 {
-  return (int32x4_t)__builtin_neon_vmla_lanev4si (__a, __b, __c, __d, 1);
+  return (int32x4_t)__builtin_neon_vmla_lanev4si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmlaq_lane_f32 (float32x4_t __a, float32x4_t __b, float32x2_t __c, const int __d)
 {
-  return (float32x4_t)__builtin_neon_vmla_lanev4sf (__a, __b, __c, __d, 3);
+  return (float32x4_t)__builtin_neon_vmla_lanev4sf (__a, __b, __c, __d);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlaq_lane_u16 (uint16x8_t __a, uint16x8_t __b, uint16x4_t __c, const int __d)
 {
-  return (uint16x8_t)__builtin_neon_vmla_lanev8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x4_t) __c, __d, 0);
+  return (uint16x8_t)__builtin_neon_vmla_lanev8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x4_t) __c, __d);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlaq_lane_u32 (uint32x4_t __a, uint32x4_t __b, uint32x2_t __c, const int __d)
 {
-  return (uint32x4_t)__builtin_neon_vmla_lanev4si ((int32x4_t) __a, (int32x4_t) __b, (int32x2_t) __c, __d, 0);
+  return (uint32x4_t)__builtin_neon_vmla_lanev4si ((int32x4_t) __a, (int32x4_t) __b, (int32x2_t) __c, __d);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlal_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return (int32x4_t)__builtin_neon_vmlal_lanev4hi (__a, __b, __c, __d, 1);
+  return (int32x4_t)__builtin_neon_vmlals_lanev4hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmlal_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (int64x2_t)__builtin_neon_vmlal_lanev2si (__a, __b, __c, __d, 1);
+  return (int64x2_t)__builtin_neon_vmlals_lanev2si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlal_lane_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d)
 {
-  return (uint32x4_t)__builtin_neon_vmlal_lanev4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d, 0);
+  return (uint32x4_t)__builtin_neon_vmlalu_lanev4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmlal_lane_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d)
 {
-  return (uint64x2_t)__builtin_neon_vmlal_lanev2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d, 0);
+  return (uint64x2_t)__builtin_neon_vmlalu_lanev2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmlal_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return (int32x4_t)__builtin_neon_vqdmlal_lanev4hi (__a, __b, __c, __d, 1);
+  return (int32x4_t)__builtin_neon_vqdmlal_lanev4hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmlal_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (int64x2_t)__builtin_neon_vqdmlal_lanev2si (__a, __b, __c, __d, 1);
+  return (int64x2_t)__builtin_neon_vqdmlal_lanev2si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmls_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return (int16x4_t)__builtin_neon_vmls_lanev4hi (__a, __b, __c, __d, 1);
+  return (int16x4_t)__builtin_neon_vmls_lanev4hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmls_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (int32x2_t)__builtin_neon_vmls_lanev2si (__a, __b, __c, __d, 1);
+  return (int32x2_t)__builtin_neon_vmls_lanev2si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmls_lane_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c, const int __d)
 {
-  return (float32x2_t)__builtin_neon_vmls_lanev2sf (__a, __b, __c, __d, 3);
+  return (float32x2_t)__builtin_neon_vmls_lanev2sf (__a, __b, __c, __d);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmls_lane_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d)
 {
-  return (uint16x4_t)__builtin_neon_vmls_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d, 0);
+  return (uint16x4_t)__builtin_neon_vmls_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmls_lane_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d)
 {
-  return (uint32x2_t)__builtin_neon_vmls_lanev2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d, 0);
+  return (uint32x2_t)__builtin_neon_vmls_lanev2si ((int32x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlsq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d)
 {
-  return (int16x8_t)__builtin_neon_vmls_lanev8hi (__a, __b, __c, __d, 1);
+  return (int16x8_t)__builtin_neon_vmls_lanev8hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlsq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d)
 {
-  return (int32x4_t)__builtin_neon_vmls_lanev4si (__a, __b, __c, __d, 1);
+  return (int32x4_t)__builtin_neon_vmls_lanev4si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmlsq_lane_f32 (float32x4_t __a, float32x4_t __b, float32x2_t __c, const int __d)
 {
-  return (float32x4_t)__builtin_neon_vmls_lanev4sf (__a, __b, __c, __d, 3);
+  return (float32x4_t)__builtin_neon_vmls_lanev4sf (__a, __b, __c, __d);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlsq_lane_u16 (uint16x8_t __a, uint16x8_t __b, uint16x4_t __c, const int __d)
 {
-  return (uint16x8_t)__builtin_neon_vmls_lanev8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x4_t) __c, __d, 0);
+  return (uint16x8_t)__builtin_neon_vmls_lanev8hi ((int16x8_t) __a, (int16x8_t) __b, (int16x4_t) __c, __d);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlsq_lane_u32 (uint32x4_t __a, uint32x4_t __b, uint32x2_t __c, const int __d)
 {
-  return (uint32x4_t)__builtin_neon_vmls_lanev4si ((int32x4_t) __a, (int32x4_t) __b, (int32x2_t) __c, __d, 0);
+  return (uint32x4_t)__builtin_neon_vmls_lanev4si ((int32x4_t) __a, (int32x4_t) __b, (int32x2_t) __c, __d);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlsl_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return (int32x4_t)__builtin_neon_vmlsl_lanev4hi (__a, __b, __c, __d, 1);
+  return (int32x4_t)__builtin_neon_vmlsls_lanev4hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (int64x2_t)__builtin_neon_vmlsl_lanev2si (__a, __b, __c, __d, 1);
+  return (int64x2_t)__builtin_neon_vmlsls_lanev2si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlsl_lane_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d)
 {
-  return (uint32x4_t)__builtin_neon_vmlsl_lanev4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d, 0);
+  return (uint32x4_t)__builtin_neon_vmlslu_lanev4hi ((int32x4_t) __a, (int16x4_t) __b, (int16x4_t) __c, __d);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmlsl_lane_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d)
 {
-  return (uint64x2_t)__builtin_neon_vmlsl_lanev2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d, 0);
+  return (uint64x2_t)__builtin_neon_vmlslu_lanev2si ((int64x2_t) __a, (int32x2_t) __b, (int32x2_t) __c, __d);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmlsl_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d)
 {
-  return (int32x4_t)__builtin_neon_vqdmlsl_lanev4hi (__a, __b, __c, __d, 1);
+  return (int32x4_t)__builtin_neon_vqdmlsl_lanev4hi (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d)
 {
-  return (int64x2_t)__builtin_neon_vqdmlsl_lanev2si (__a, __b, __c, __d, 1);
+  return (int64x2_t)__builtin_neon_vqdmlsl_lanev2si (__a, __b, __c, __d);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmull_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return (int32x4_t)__builtin_neon_vmull_lanev4hi (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vmulls_lanev4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmull_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return (int64x2_t)__builtin_neon_vmull_lanev2si (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vmulls_lanev2si (__a, __b, __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmull_lane_u16 (uint16x4_t __a, uint16x4_t __b, const int __c)
 {
-  return (uint32x4_t)__builtin_neon_vmull_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, __c, 0);
+  return (uint32x4_t)__builtin_neon_vmullu_lanev4hi ((int16x4_t) __a, (int16x4_t) __b, __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmull_lane_u32 (uint32x2_t __a, uint32x2_t __b, const int __c)
 {
-  return (uint64x2_t)__builtin_neon_vmull_lanev2si ((int32x2_t) __a, (int32x2_t) __b, __c, 0);
+  return (uint64x2_t)__builtin_neon_vmullu_lanev2si ((int32x2_t) __a, (int32x2_t) __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmull_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return (int32x4_t)__builtin_neon_vqdmull_lanev4hi (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vqdmull_lanev4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmull_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return (int64x2_t)__builtin_neon_vqdmull_lanev2si (__a, __b, __c, 1);
+  return (int64x2_t)__builtin_neon_vqdmull_lanev2si (__a, __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqdmulhq_lane_s16 (int16x8_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x8_t)__builtin_neon_vqdmulh_lanev8hi (__a, __b, __c, 1);
+  return (int16x8_t)__builtin_neon_vqdmulh_lanev8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmulhq_lane_s32 (int32x4_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x4_t)__builtin_neon_vqdmulh_lanev4si (__a, __b, __c, 1);
+  return (int32x4_t)__builtin_neon_vqdmulh_lanev4si (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqdmulh_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x4_t)__builtin_neon_vqdmulh_lanev4hi (__a, __b, __c, 1);
+  return (int16x4_t)__builtin_neon_vqdmulh_lanev4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqdmulh_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x2_t)__builtin_neon_vqdmulh_lanev2si (__a, __b, __c, 1);
+  return (int32x2_t)__builtin_neon_vqdmulh_lanev2si (__a, __b, __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqrdmulhq_lane_s16 (int16x8_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x8_t)__builtin_neon_vqdmulh_lanev8hi (__a, __b, __c, 5);
+  return (int16x8_t)__builtin_neon_vqrdmulh_lanev8hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqrdmulhq_lane_s32 (int32x4_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x4_t)__builtin_neon_vqdmulh_lanev4si (__a, __b, __c, 5);
+  return (int32x4_t)__builtin_neon_vqrdmulh_lanev4si (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqrdmulh_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c)
 {
-  return (int16x4_t)__builtin_neon_vqdmulh_lanev4hi (__a, __b, __c, 5);
+  return (int16x4_t)__builtin_neon_vqrdmulh_lanev4hi (__a, __b, __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqrdmulh_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)
 {
-  return (int32x2_t)__builtin_neon_vqdmulh_lanev2si (__a, __b, __c, 5);
+  return (int32x2_t)__builtin_neon_vqrdmulh_lanev2si (__a, __b, __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmul_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return (int16x4_t)__builtin_neon_vmul_nv4hi (__a, (__builtin_neon_hi) __b, 1);
+  return (int16x4_t)__builtin_neon_vmul_nv4hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmul_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return (int32x2_t)__builtin_neon_vmul_nv2si (__a, (__builtin_neon_si) __b, 1);
+  return (int32x2_t)__builtin_neon_vmul_nv2si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmul_n_f32 (float32x2_t __a, float32_t __b)
 {
-  return (float32x2_t)__builtin_neon_vmul_nv2sf (__a, (__builtin_neon_sf) __b, 3);
+  return (float32x2_t)__builtin_neon_vmul_nv2sf (__a, (__builtin_neon_sf) __b);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmul_n_u16 (uint16x4_t __a, uint16_t __b)
 {
-  return (uint16x4_t)__builtin_neon_vmul_nv4hi ((int16x4_t) __a, (__builtin_neon_hi) __b, 0);
+  return (uint16x4_t)__builtin_neon_vmul_nv4hi ((int16x4_t) __a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmul_n_u32 (uint32x2_t __a, uint32_t __b)
 {
-  return (uint32x2_t)__builtin_neon_vmul_nv2si ((int32x2_t) __a, (__builtin_neon_si) __b, 0);
+  return (uint32x2_t)__builtin_neon_vmul_nv2si ((int32x2_t) __a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmulq_n_s16 (int16x8_t __a, int16_t __b)
 {
-  return (int16x8_t)__builtin_neon_vmul_nv8hi (__a, (__builtin_neon_hi) __b, 1);
+  return (int16x8_t)__builtin_neon_vmul_nv8hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmulq_n_s32 (int32x4_t __a, int32_t __b)
 {
-  return (int32x4_t)__builtin_neon_vmul_nv4si (__a, (__builtin_neon_si) __b, 1);
+  return (int32x4_t)__builtin_neon_vmul_nv4si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmulq_n_f32 (float32x4_t __a, float32_t __b)
 {
-  return (float32x4_t)__builtin_neon_vmul_nv4sf (__a, (__builtin_neon_sf) __b, 3);
+  return (float32x4_t)__builtin_neon_vmul_nv4sf (__a, (__builtin_neon_sf) __b);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmulq_n_u16 (uint16x8_t __a, uint16_t __b)
 {
-  return (uint16x8_t)__builtin_neon_vmul_nv8hi ((int16x8_t) __a, (__builtin_neon_hi) __b, 0);
+  return (uint16x8_t)__builtin_neon_vmul_nv8hi ((int16x8_t) __a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmulq_n_u32 (uint32x4_t __a, uint32_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vmul_nv4si ((int32x4_t) __a, (__builtin_neon_si) __b, 0);
+  return (uint32x4_t)__builtin_neon_vmul_nv4si ((int32x4_t) __a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmull_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return (int32x4_t)__builtin_neon_vmull_nv4hi (__a, (__builtin_neon_hi) __b, 1);
+  return (int32x4_t)__builtin_neon_vmulls_nv4hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmull_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return (int64x2_t)__builtin_neon_vmull_nv2si (__a, (__builtin_neon_si) __b, 1);
+  return (int64x2_t)__builtin_neon_vmulls_nv2si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmull_n_u16 (uint16x4_t __a, uint16_t __b)
 {
-  return (uint32x4_t)__builtin_neon_vmull_nv4hi ((int16x4_t) __a, (__builtin_neon_hi) __b, 0);
+  return (uint32x4_t)__builtin_neon_vmullu_nv4hi ((int16x4_t) __a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmull_n_u32 (uint32x2_t __a, uint32_t __b)
 {
-  return (uint64x2_t)__builtin_neon_vmull_nv2si ((int32x2_t) __a, (__builtin_neon_si) __b, 0);
+  return (uint64x2_t)__builtin_neon_vmullu_nv2si ((int32x2_t) __a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmull_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqdmull_nv4hi (__a, (__builtin_neon_hi) __b, 1);
+  return (int32x4_t)__builtin_neon_vqdmull_nv4hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmull_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return (int64x2_t)__builtin_neon_vqdmull_nv2si (__a, (__builtin_neon_si) __b, 1);
+  return (int64x2_t)__builtin_neon_vqdmull_nv2si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqdmulhq_n_s16 (int16x8_t __a, int16_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqdmulh_nv8hi (__a, (__builtin_neon_hi) __b, 1);
+  return (int16x8_t)__builtin_neon_vqdmulh_nv8hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmulhq_n_s32 (int32x4_t __a, int32_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqdmulh_nv4si (__a, (__builtin_neon_si) __b, 1);
+  return (int32x4_t)__builtin_neon_vqdmulh_nv4si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqdmulh_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqdmulh_nv4hi (__a, (__builtin_neon_hi) __b, 1);
+  return (int16x4_t)__builtin_neon_vqdmulh_nv4hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqdmulh_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqdmulh_nv2si (__a, (__builtin_neon_si) __b, 1);
+  return (int32x2_t)__builtin_neon_vqdmulh_nv2si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vqrdmulhq_n_s16 (int16x8_t __a, int16_t __b)
 {
-  return (int16x8_t)__builtin_neon_vqdmulh_nv8hi (__a, (__builtin_neon_hi) __b, 5);
+  return (int16x8_t)__builtin_neon_vqrdmulh_nv8hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqrdmulhq_n_s32 (int32x4_t __a, int32_t __b)
 {
-  return (int32x4_t)__builtin_neon_vqdmulh_nv4si (__a, (__builtin_neon_si) __b, 5);
+  return (int32x4_t)__builtin_neon_vqrdmulh_nv4si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vqrdmulh_n_s16 (int16x4_t __a, int16_t __b)
 {
-  return (int16x4_t)__builtin_neon_vqdmulh_nv4hi (__a, (__builtin_neon_hi) __b, 5);
+  return (int16x4_t)__builtin_neon_vqrdmulh_nv4hi (__a, (__builtin_neon_hi) __b);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vqrdmulh_n_s32 (int32x2_t __a, int32_t __b)
 {
-  return (int32x2_t)__builtin_neon_vqdmulh_nv2si (__a, (__builtin_neon_si) __b, 5);
+  return (int32x2_t)__builtin_neon_vqrdmulh_nv2si (__a, (__builtin_neon_si) __b);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmla_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return (int16x4_t)__builtin_neon_vmla_nv4hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int16x4_t)__builtin_neon_vmla_nv4hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmla_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return (int32x2_t)__builtin_neon_vmla_nv2si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int32x2_t)__builtin_neon_vmla_nv2si (__a, __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmla_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c)
 {
-  return (float32x2_t)__builtin_neon_vmla_nv2sf (__a, __b, (__builtin_neon_sf) __c, 3);
+  return (float32x2_t)__builtin_neon_vmla_nv2sf (__a, __b, (__builtin_neon_sf) __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmla_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return (uint16x4_t)__builtin_neon_vmla_nv4hi ((int16x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c, 0);
+  return (uint16x4_t)__builtin_neon_vmla_nv4hi ((int16x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmla_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return (uint32x2_t)__builtin_neon_vmla_nv2si ((int32x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c, 0);
+  return (uint32x2_t)__builtin_neon_vmla_nv2si ((int32x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlaq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c)
 {
-  return (int16x8_t)__builtin_neon_vmla_nv8hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int16x8_t)__builtin_neon_vmla_nv8hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlaq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmla_nv4si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int32x4_t)__builtin_neon_vmla_nv4si (__a, __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmlaq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c)
 {
-  return (float32x4_t)__builtin_neon_vmla_nv4sf (__a, __b, (__builtin_neon_sf) __c, 3);
+  return (float32x4_t)__builtin_neon_vmla_nv4sf (__a, __b, (__builtin_neon_sf) __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlaq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vmla_nv8hi ((int16x8_t) __a, (int16x8_t) __b, (__builtin_neon_hi) __c, 0);
+  return (uint16x8_t)__builtin_neon_vmla_nv8hi ((int16x8_t) __a, (int16x8_t) __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlaq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmla_nv4si ((int32x4_t) __a, (int32x4_t) __b, (__builtin_neon_si) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmla_nv4si ((int32x4_t) __a, (int32x4_t) __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlal_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmlal_nv4hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int32x4_t)__builtin_neon_vmlals_nv4hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return (int64x2_t)__builtin_neon_vmlal_nv2si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int64x2_t)__builtin_neon_vmlals_nv2si (__a, __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlal_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmlal_nv4hi ((int32x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmlalu_nv4hi ((int32x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmlal_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return (uint64x2_t)__builtin_neon_vmlal_nv2si ((int64x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c, 0);
+  return (uint64x2_t)__builtin_neon_vmlalu_nv2si ((int64x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmlal_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return (int32x4_t)__builtin_neon_vqdmlal_nv4hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int32x4_t)__builtin_neon_vqdmlal_nv4hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return (int64x2_t)__builtin_neon_vqdmlal_nv2si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int64x2_t)__builtin_neon_vqdmlal_nv2si (__a, __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline int16x4_t __attribute__ ((__always_inline__))
 vmls_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return (int16x4_t)__builtin_neon_vmls_nv4hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int16x4_t)__builtin_neon_vmls_nv4hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int32x2_t __attribute__ ((__always_inline__))
 vmls_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return (int32x2_t)__builtin_neon_vmls_nv2si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int32x2_t)__builtin_neon_vmls_nv2si (__a, __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline float32x2_t __attribute__ ((__always_inline__))
 vmls_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c)
 {
-  return (float32x2_t)__builtin_neon_vmls_nv2sf (__a, __b, (__builtin_neon_sf) __c, 3);
+  return (float32x2_t)__builtin_neon_vmls_nv2sf (__a, __b, (__builtin_neon_sf) __c);
 }
 
 __extension__ static __inline uint16x4_t __attribute__ ((__always_inline__))
 vmls_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return (uint16x4_t)__builtin_neon_vmls_nv4hi ((int16x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c, 0);
+  return (uint16x4_t)__builtin_neon_vmls_nv4hi ((int16x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline uint32x2_t __attribute__ ((__always_inline__))
 vmls_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return (uint32x2_t)__builtin_neon_vmls_nv2si ((int32x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c, 0);
+  return (uint32x2_t)__builtin_neon_vmls_nv2si ((int32x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline int16x8_t __attribute__ ((__always_inline__))
 vmlsq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c)
 {
-  return (int16x8_t)__builtin_neon_vmls_nv8hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int16x8_t)__builtin_neon_vmls_nv8hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlsq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmls_nv4si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int32x4_t)__builtin_neon_vmls_nv4si (__a, __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline float32x4_t __attribute__ ((__always_inline__))
 vmlsq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c)
 {
-  return (float32x4_t)__builtin_neon_vmls_nv4sf (__a, __b, (__builtin_neon_sf) __c, 3);
+  return (float32x4_t)__builtin_neon_vmls_nv4sf (__a, __b, (__builtin_neon_sf) __c);
 }
 
 __extension__ static __inline uint16x8_t __attribute__ ((__always_inline__))
 vmlsq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c)
 {
-  return (uint16x8_t)__builtin_neon_vmls_nv8hi ((int16x8_t) __a, (int16x8_t) __b, (__builtin_neon_hi) __c, 0);
+  return (uint16x8_t)__builtin_neon_vmls_nv8hi ((int16x8_t) __a, (int16x8_t) __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlsq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmls_nv4si ((int32x4_t) __a, (int32x4_t) __b, (__builtin_neon_si) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmls_nv4si ((int32x4_t) __a, (int32x4_t) __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vmlsl_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return (int32x4_t)__builtin_neon_vmlsl_nv4hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int32x4_t)__builtin_neon_vmlsls_nv4hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return (int64x2_t)__builtin_neon_vmlsl_nv2si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int64x2_t)__builtin_neon_vmlsls_nv2si (__a, __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline uint32x4_t __attribute__ ((__always_inline__))
 vmlsl_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c)
 {
-  return (uint32x4_t)__builtin_neon_vmlsl_nv4hi ((int32x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c, 0);
+  return (uint32x4_t)__builtin_neon_vmlslu_nv4hi ((int32x4_t) __a, (int16x4_t) __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline uint64x2_t __attribute__ ((__always_inline__))
 vmlsl_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c)
 {
-  return (uint64x2_t)__builtin_neon_vmlsl_nv2si ((int64x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c, 0);
+  return (uint64x2_t)__builtin_neon_vmlslu_nv2si ((int64x2_t) __a, (int32x2_t) __b, (__builtin_neon_si) __c);
 }
 
 __extension__ static __inline int32x4_t __attribute__ ((__always_inline__))
 vqdmlsl_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c)
 {
-  return (int32x4_t)__builtin_neon_vqdmlsl_nv4hi (__a, __b, (__builtin_neon_hi) __c, 1);
+  return (int32x4_t)__builtin_neon_vqdmlsl_nv4hi (__a, __b, (__builtin_neon_hi) __c);
 }
 
 __extension__ static __inline int64x2_t __attribute__ ((__always_inline__))
 vqdmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c)
 {
-  return (int64x2_t)__builtin_neon_vqdmlsl_nv2si (__a, __b, (__builtin_neon_si) __c, 1);
+  return (int64x2_t)__builtin_neon_vqdmlsl_nv2si (__a, __b, (__builtin_neon_si) __c);
 }
 
 #ifdef __ARM_FEATURE_CRYPTO
diff --git a/gcc/config/arm/arm_neon_builtins.def b/gcc/config/arm/arm_neon_builtins.def
index 229caca..5451524 100644
--- a/gcc/config/arm/arm_neon_builtins.def
+++ b/gcc/config/arm/arm_neon_builtins.def
@@ -19,46 +19,87 @@
    <http://www.gnu.org/licenses/>.  */
 
 VAR2 (BINOP, vadd, v2sf, v4sf),
-VAR3 (BINOP, vaddl, v8qi, v4hi, v2si),
-VAR3 (BINOP, vaddw, v8qi, v4hi, v2si),
-VAR6 (BINOP, vhadd, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
-VAR8 (BINOP, vqadd, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR3 (BINOP, vaddls, v8qi, v4hi, v2si),
+VAR3 (BINOP, vaddlu, v8qi, v4hi, v2si),
+VAR3 (BINOP, vaddws, v8qi, v4hi, v2si),
+VAR3 (BINOP, vaddwu, v8qi, v4hi, v2si),
+VAR6 (BINOP, vhaddu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vhadds, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vrhaddu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vrhadds, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR8 (BINOP, vqadds, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vqaddu, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
 VAR3 (BINOP, vaddhn, v8hi, v4si, v2di),
-VAR8 (BINOP, vmul, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
+VAR3 (BINOP, vraddhn, v8hi, v4si, v2di),
+VAR2 (BINOP, vmulf, v2sf, v4sf),
+VAR2 (BINOP, vmulp, v8qi, v16qi),
 VAR8 (TERNOP, vmla, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
-VAR3 (TERNOP, vmlal, v8qi, v4hi, v2si),
+VAR3 (TERNOP, vmlals, v8qi, v4hi, v2si),
+VAR3 (TERNOP, vmlalu, v8qi, v4hi, v2si),
 VAR2 (TERNOP, vfma, v2sf, v4sf),
 VAR2 (TERNOP, vfms, v2sf, v4sf),
 VAR8 (TERNOP, vmls, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
-VAR3 (TERNOP, vmlsl, v8qi, v4hi, v2si),
+VAR3 (TERNOP, vmlsls, v8qi, v4hi, v2si),
+VAR3 (TERNOP, vmlslu, v8qi, v4hi, v2si),
 VAR4 (BINOP, vqdmulh, v4hi, v2si, v8hi, v4si),
+VAR4 (BINOP, vqrdmulh, v4hi, v2si, v8hi, v4si),
 VAR2 (TERNOP, vqdmlal, v4hi, v2si),
 VAR2 (TERNOP, vqdmlsl, v4hi, v2si),
-VAR3 (BINOP, vmull, v8qi, v4hi, v2si),
-VAR2 (SCALARMULL, vmull_n, v4hi, v2si),
-VAR2 (LANEMULL, vmull_lane, v4hi, v2si),
+VAR3 (BINOP, vmullp, v8qi, v4hi, v2si),
+VAR3 (BINOP, vmulls, v8qi, v4hi, v2si),
+VAR3 (BINOP, vmullu, v8qi, v4hi, v2si),
+VAR2 (SCALARMULL, vmulls_n, v4hi, v2si),
+VAR2 (SCALARMULL, vmullu_n, v4hi, v2si),
+VAR2 (LANEMULL, vmulls_lane, v4hi, v2si),
+VAR2 (LANEMULL, vmullu_lane, v4hi, v2si),
 VAR2 (SCALARMULL, vqdmull_n, v4hi, v2si),
 VAR2 (LANEMULL, vqdmull_lane, v4hi, v2si),
 VAR4 (SCALARMULH, vqdmulh_n, v4hi, v2si, v8hi, v4si),
+VAR4 (SCALARMULH, vqrdmulh_n, v4hi, v2si, v8hi, v4si),
 VAR4 (LANEMULH, vqdmulh_lane, v4hi, v2si, v8hi, v4si),
+VAR4 (LANEMULH, vqrdmulh_lane, v4hi, v2si, v8hi, v4si),
 VAR2 (BINOP, vqdmull, v4hi, v2si),
-VAR8 (BINOP, vshl, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
-VAR8 (BINOP, vqshl, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
-VAR8 (SHIFTIMM, vshr_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vshls, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vshlu, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vrshls, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vrshlu, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vqshls, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vqshlu, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vqrshls, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vqrshlu, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTIMM, vshrs_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTIMM, vshru_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTIMM, vrshrs_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTIMM, vrshru_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
 VAR3 (SHIFTIMM, vshrn_n, v8hi, v4si, v2di),
-VAR3 (SHIFTIMM, vqshrn_n, v8hi, v4si, v2di),
+VAR3 (SHIFTIMM, vrshrn_n, v8hi, v4si, v2di),
+VAR3 (SHIFTIMM, vqshrns_n, v8hi, v4si, v2di),
+VAR3 (SHIFTIMM, vqshrnu_n, v8hi, v4si, v2di),
+VAR3 (SHIFTIMM, vqrshrns_n, v8hi, v4si, v2di),
+VAR3 (SHIFTIMM, vqrshrnu_n, v8hi, v4si, v2di),
 VAR3 (SHIFTIMM, vqshrun_n, v8hi, v4si, v2di),
+VAR3 (SHIFTIMM, vqrshrun_n, v8hi, v4si, v2di),
 VAR8 (SHIFTIMM, vshl_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
-VAR8 (SHIFTIMM, vqshl_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTIMM, vqshl_s_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTIMM, vqshl_u_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
 VAR8 (SHIFTIMM, vqshlu_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
-VAR3 (SHIFTIMM, vshll_n, v8qi, v4hi, v2si),
-VAR8 (SHIFTACC, vsra_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR3 (SHIFTIMM, vshlls_n, v8qi, v4hi, v2si),
+VAR3 (SHIFTIMM, vshllu_n, v8qi, v4hi, v2si),
+VAR8 (SHIFTACC, vsras_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTACC, vsrau_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTACC, vrsras_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (SHIFTACC, vrsrau_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
 VAR2 (BINOP, vsub, v2sf, v4sf),
-VAR3 (BINOP, vsubl, v8qi, v4hi, v2si),
-VAR3 (BINOP, vsubw, v8qi, v4hi, v2si),
-VAR8 (BINOP, vqsub, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
-VAR6 (BINOP, vhsub, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR3 (BINOP, vsubls, v8qi, v4hi, v2si),
+VAR3 (BINOP, vsublu, v8qi, v4hi, v2si),
+VAR3 (BINOP, vsubws, v8qi, v4hi, v2si),
+VAR3 (BINOP, vsubwu, v8qi, v4hi, v2si),
+VAR8 (BINOP, vqsubs, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR8 (BINOP, vqsubu, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
+VAR6 (BINOP, vhsubs, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vhsubu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
 VAR3 (BINOP, vsubhn, v8hi, v4si, v2di),
+VAR3 (BINOP, vrsubhn, v8hi, v4si, v2di),
 VAR8 (BINOP, vceq, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
 VAR8 (BINOP, vcge, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
 VAR6 (BINOP, vcgeu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
@@ -67,17 +108,36 @@ VAR6 (BINOP, vcgtu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
 VAR2 (BINOP, vcage, v2sf, v4sf),
 VAR2 (BINOP, vcagt, v2sf, v4sf),
 VAR6 (BINOP, vtst, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
-VAR8 (BINOP, vabd, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
-VAR3 (BINOP, vabdl, v8qi, v4hi, v2si),
-VAR6 (TERNOP, vaba, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
-VAR3 (TERNOP, vabal, v8qi, v4hi, v2si),
-VAR8 (BINOP, vmax, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
-VAR8 (BINOP, vmin, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
+VAR6 (BINOP, vabds, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vabdu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR2 (BINOP, vabdf, v2sf, v4sf),
+VAR3 (BINOP, vabdls, v8qi, v4hi, v2si),
+VAR3 (BINOP, vabdlu, v8qi, v4hi, v2si),
+
+VAR6 (TERNOP, vabas, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (TERNOP, vabau, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR3 (TERNOP, vabals, v8qi, v4hi, v2si),
+VAR3 (TERNOP, vabalu, v8qi, v4hi, v2si),
+
+VAR6 (BINOP, vmaxs, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vmaxu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR2 (BINOP, vmaxf, v2sf, v4sf),
+VAR6 (BINOP, vmins, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vminu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR2 (BINOP, vminf, v2sf, v4sf),
+
+VAR3 (BINOP, vpmaxs, v8qi, v4hi, v2si),
+VAR3 (BINOP, vpmaxu, v8qi, v4hi, v2si),
+VAR1 (BINOP, vpmaxf, v2sf),
+VAR3 (BINOP, vpmins, v8qi, v4hi, v2si),
+VAR3 (BINOP, vpminu, v8qi, v4hi, v2si),
+VAR1 (BINOP, vpminf, v2sf),
+
 VAR4 (BINOP, vpadd, v8qi, v4hi, v2si, v2sf),
-VAR6 (UNOP, vpaddl, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
-VAR6 (BINOP, vpadal, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
-VAR4 (BINOP, vpmax, v8qi, v4hi, v2si, v2sf),
-VAR4 (BINOP, vpmin, v8qi, v4hi, v2si, v2sf),
+VAR6 (UNOP, vpaddls, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (UNOP, vpaddlu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vpadals, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
+VAR6 (BINOP, vpadalu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
 VAR2 (BINOP, vrecps, v2sf, v4sf),
 VAR2 (BINOP, vrsqrts, v2sf, v4sf),
 VAR8 (SHIFTINSERT, vsri_n, v8qi, v4hi, v2si, di, v16qi, v8hi, v4si, v2di),
@@ -96,41 +156,50 @@ VAR6 (UNOP, vmvn, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
   /* FIXME: vget_lane supports more variants than this!  */
 VAR10 (GETLANE, vget_lane,
 	 v8qi, v4hi, v2si, v2sf, di, v16qi, v8hi, v4si, v4sf, v2di),
+VAR6 (GETLANE, vget_laneu, v8qi, v4hi, v2si, v16qi, v8hi, v4si),
 VAR10 (SETLANE, vset_lane,
 	 v8qi, v4hi, v2si, v2sf, di, v16qi, v8hi, v4si, v4sf, v2di),
 VAR5 (CREATE, vcreate, v8qi, v4hi, v2si, v2sf, di),
 VAR10 (DUP, vdup_n,
 	 v8qi, v4hi, v2si, v2sf, di, v16qi, v8hi, v4si, v4sf, v2di),
-VAR10 (DUPLANE, vdup_lane,
+VAR10 (BINOP, vdup_lane,
 	 v8qi, v4hi, v2si, v2sf, di, v16qi, v8hi, v4si, v4sf, v2di),
 VAR5 (COMBINE, vcombine, v8qi, v4hi, v2si, v2sf, di),
 VAR5 (SPLIT, vget_high, v16qi, v8hi, v4si, v4sf, v2di),
 VAR5 (SPLIT, vget_low, v16qi, v8hi, v4si, v4sf, v2di),
 VAR3 (UNOP, vmovn, v8hi, v4si, v2di),
-VAR3 (UNOP, vqmovn, v8hi, v4si, v2di),
+VAR3 (UNOP, vqmovns, v8hi, v4si, v2di),
+VAR3 (UNOP, vqmovnu, v8hi, v4si, v2di),
 VAR3 (UNOP, vqmovun, v8hi, v4si, v2di),
-VAR3 (UNOP, vmovl, v8qi, v4hi, v2si),
+VAR3 (UNOP, vmovls, v8qi, v4hi, v2si),
+VAR3 (UNOP, vmovlu, v8qi, v4hi, v2si),
 VAR6 (LANEMUL, vmul_lane, v4hi, v2si, v2sf, v8hi, v4si, v4sf),
 VAR6 (LANEMAC, vmla_lane, v4hi, v2si, v2sf, v8hi, v4si, v4sf),
-VAR2 (LANEMAC, vmlal_lane, v4hi, v2si),
+VAR2 (LANEMAC, vmlals_lane, v4hi, v2si),
+VAR2 (LANEMAC, vmlalu_lane, v4hi, v2si),
 VAR2 (LANEMAC, vqdmlal_lane, v4hi, v2si),
 VAR6 (LANEMAC, vmls_lane, v4hi, v2si, v2sf, v8hi, v4si, v4sf),
-VAR2 (LANEMAC, vmlsl_lane, v4hi, v2si),
+VAR2 (LANEMAC, vmlsls_lane, v4hi, v2si),
+VAR2 (LANEMAC, vmlslu_lane, v4hi, v2si),
 VAR2 (LANEMAC, vqdmlsl_lane, v4hi, v2si),
 VAR6 (SCALARMUL, vmul_n, v4hi, v2si, v2sf, v8hi, v4si, v4sf),
 VAR6 (SCALARMAC, vmla_n, v4hi, v2si, v2sf, v8hi, v4si, v4sf),
-VAR2 (SCALARMAC, vmlal_n, v4hi, v2si),
+VAR2 (SCALARMAC, vmlals_n, v4hi, v2si),
+VAR2 (SCALARMAC, vmlalu_n, v4hi, v2si),
 VAR2 (SCALARMAC, vqdmlal_n, v4hi, v2si),
 VAR6 (SCALARMAC, vmls_n, v4hi, v2si, v2sf, v8hi, v4si, v4sf),
-VAR2 (SCALARMAC, vmlsl_n, v4hi, v2si),
+VAR2 (SCALARMAC, vmlsls_n, v4hi, v2si),
+VAR2 (SCALARMAC, vmlslu_n, v4hi, v2si),
 VAR2 (SCALARMAC, vqdmlsl_n, v4hi, v2si),
-VAR10 (BINOP, vext,
+VAR10 (SHIFTINSERT, vext,
 	 v8qi, v4hi, v2si, v2sf, di, v16qi, v8hi, v4si, v4sf, v2di),
 VAR8 (UNOP, vrev64, v8qi, v4hi, v2si, v2sf, v16qi, v8hi, v4si, v4sf),
 VAR4 (UNOP, vrev32, v8qi, v4hi, v16qi, v8hi),
 VAR2 (UNOP, vrev16, v8qi, v16qi),
-VAR4 (CONVERT, vcvt, v2si, v2sf, v4si, v4sf),
-VAR4 (FIXCONV, vcvt_n, v2si, v2sf, v4si, v4sf),
+VAR4 (CONVERT, vcvts, v2si, v2sf, v4si, v4sf),
+VAR4 (CONVERT, vcvtu, v2si, v2sf, v4si, v4sf),
+VAR4 (FIXCONV, vcvts_n, v2si, v2sf, v4si, v4sf),
+VAR4 (FIXCONV, vcvtu_n, v2si, v2sf, v4si, v4sf),
 VAR1 (FLOAT_WIDEN, vcvtv4sf, v4hf),
 VAR1 (FLOAT_NARROW, vcvtv4hf, v4sf),
 VAR10 (SELECT, vbsl,
diff --git a/gcc/config/arm/iterators.md b/gcc/config/arm/iterators.md
index 021372a..bf0329a 100644
--- a/gcc/config/arm/iterators.md
+++ b/gcc/config/arm/iterators.md
@@ -169,6 +169,9 @@
 
 (define_mode_iterator QMUL [HQ HA])
 
+;; Modes for polynomial or float values.
+(define_mode_iterator VPF [V8QI V16QI V2SF V4SF])
+
 ;;----------------------------------------------------------------------------
 ;; Code iterators
 ;;----------------------------------------------------------------------------
@@ -225,6 +228,92 @@
 
 (define_int_iterator NEON_VCVT [UNSPEC_NVRINTP UNSPEC_NVRINTM UNSPEC_NVRINTA])
 
+(define_int_iterator VADDL [UNSPEC_VADDL_S UNSPEC_VADDL_U])
+
+(define_int_iterator VADDW [UNSPEC_VADDW_S UNSPEC_VADDW_U])
+
+(define_int_iterator VHADD [UNSPEC_VRHADD_S UNSPEC_VRHADD_U
+			    UNSPEC_VHADD_S UNSPEC_VHADD_U])
+
+(define_int_iterator VQADD [UNSPEC_VQADD_S UNSPEC_VQADD_U])
+
+(define_int_iterator VADDHN [UNSPEC_VADDHN UNSPEC_VRADDHN])
+
+(define_int_iterator VMLAL [UNSPEC_VMLAL_S UNSPEC_VMLAL_U])
+
+(define_int_iterator VMLAL_LANE [UNSPEC_VMLAL_S_LANE UNSPEC_VMLAL_U_LANE])
+
+(define_int_iterator VMLSL [UNSPEC_VMLSL_S UNSPEC_VMLSL_U])
+
+(define_int_iterator VMLSL_LANE [UNSPEC_VMLSL_S_LANE UNSPEC_VMLSL_U_LANE])
+
+(define_int_iterator VQDMULH [UNSPEC_VQDMULH UNSPEC_VQRDMULH])
+
+(define_int_iterator VQDMULH_LANE [UNSPEC_VQDMULH_LANE UNSPEC_VQRDMULH_LANE])
+
+(define_int_iterator VMULL [UNSPEC_VMULL_S UNSPEC_VMULL_U UNSPEC_VMULL_P])
+
+(define_int_iterator VMULL_LANE [UNSPEC_VMULL_S_LANE UNSPEC_VMULL_U_LANE])
+
+(define_int_iterator VSUBL [UNSPEC_VSUBL_S UNSPEC_VSUBL_U])
+
+(define_int_iterator VSUBW [UNSPEC_VSUBW_S UNSPEC_VSUBW_U])
+
+(define_int_iterator VHSUB [UNSPEC_VHSUB_S UNSPEC_VHSUB_U])
+
+(define_int_iterator VQSUB [UNSPEC_VQSUB_S UNSPEC_VQSUB_U])
+
+(define_int_iterator VSUBHN [UNSPEC_VSUBHN UNSPEC_VRSUBHN])
+
+(define_int_iterator VABD [UNSPEC_VABD_S UNSPEC_VABD_U])
+
+(define_int_iterator VABDL [UNSPEC_VABDL_S UNSPEC_VABDL_U])
+
+(define_int_iterator VMAXMIN [UNSPEC_VMAX UNSPEC_VMAX_U
+			      UNSPEC_VMIN UNSPEC_VMIN_U])
+
+(define_int_iterator VMAXMINF [UNSPEC_VMAX UNSPEC_VMIN])
+
+(define_int_iterator VPADDL [UNSPEC_VPADDL_S UNSPEC_VPADDL_U])
+
+(define_int_iterator VPADAL [UNSPEC_VPADAL_S UNSPEC_VPADAL_U])
+
+(define_int_iterator VPMAXMIN [UNSPEC_VPMAX UNSPEC_VPMAX_U
+			       UNSPEC_VPMIN UNSPEC_VPMIN_U])
+
+(define_int_iterator VPMAXMINF [UNSPEC_VPMAX UNSPEC_VPMIN])
+
+(define_int_iterator VCVT_US [UNSPEC_VCVT_S UNSPEC_VCVT_U])
+
+(define_int_iterator VCVT_US_N [UNSPEC_VCVT_S_N UNSPEC_VCVT_U_N])
+
+(define_int_iterator VQMOVN [UNSPEC_VQMOVN_S UNSPEC_VQMOVN_U])
+
+(define_int_iterator VMOVL [UNSPEC_VMOVL_S UNSPEC_VMOVL_U])
+
+(define_int_iterator VSHL [UNSPEC_VSHL_S UNSPEC_VSHL_U
+			   UNSPEC_VRSHL_S UNSPEC_VRSHL_U])
+
+(define_int_iterator VQSHL [UNSPEC_VQSHL_S UNSPEC_VQSHL_U
+			    UNSPEC_VQRSHL_S UNSPEC_VQRSHL_U])
+
+(define_int_iterator VSHR_N [UNSPEC_VSHR_S_N UNSPEC_VSHR_U_N
+			     UNSPEC_VRSHR_S_N UNSPEC_VRSHR_U_N])
+
+(define_int_iterator VSHRN_N [UNSPEC_VSHRN_N UNSPEC_VRSHRN_N])
+
+(define_int_iterator VQSHRN_N [UNSPEC_VQSHRN_S_N UNSPEC_VQSHRN_U_N
+			       UNSPEC_VQRSHRN_S_N UNSPEC_VQRSHRN_U_N])
+
+(define_int_iterator VQSHRUN_N [UNSPEC_VQSHRUN_N UNSPEC_VQRSHRUN_N])
+
+(define_int_iterator VQSHL_N [UNSPEC_VQSHL_S_N UNSPEC_VQSHL_U_N])
+
+(define_int_iterator VSHLL_N [UNSPEC_VSHLL_S_N UNSPEC_VSHLL_U_N])
+
+(define_int_iterator VSRA_N [UNSPEC_VSRA_S_N UNSPEC_VSRA_U_N
+			     UNSPEC_VRSRA_S_N UNSPEC_VRSRA_U_N])
+
 (define_int_iterator CRC [UNSPEC_CRC32B UNSPEC_CRC32H UNSPEC_CRC32W
                           UNSPEC_CRC32CB UNSPEC_CRC32CH UNSPEC_CRC32CW])
 
@@ -504,6 +593,8 @@
                      (DI "")   (V2DI "_q")
                      (DF "")   (V2DF "_q")])
 
+(define_mode_attr pf [(V8QI "p") (V16QI "p") (V2SF "f") (V4SF "f")])
+
 ;;----------------------------------------------------------------------------
 ;; Code attributes
 ;;----------------------------------------------------------------------------
@@ -541,6 +632,82 @@
 ;; Int attributes
 ;;----------------------------------------------------------------------------
 
+;; Mapping between vector UNSPEC operations and the signed ('s'),
+;; unsigned ('u'), poly ('p') or float ('f') nature of their data type.
+(define_int_attr sup [
+  (UNSPEC_VADDL_S "s") (UNSPEC_VADDL_U "u")
+  (UNSPEC_VADDW_S "s") (UNSPEC_VADDW_U "u")
+  (UNSPEC_VRHADD_S "s") (UNSPEC_VRHADD_U "u")
+  (UNSPEC_VHADD_S "s") (UNSPEC_VHADD_U "u")
+  (UNSPEC_VQADD_S "s") (UNSPEC_VQADD_U "u")
+  (UNSPEC_VMLAL_S "s") (UNSPEC_VMLAL_U "u")
+  (UNSPEC_VMLAL_S_LANE "s") (UNSPEC_VMLAL_U_LANE "u")
+  (UNSPEC_VMLSL_S "s") (UNSPEC_VMLSL_U "u")
+  (UNSPEC_VMLSL_S_LANE "s") (UNSPEC_VMLSL_U_LANE "u")
+  (UNSPEC_VMULL_S "s") (UNSPEC_VMULL_U "u") (UNSPEC_VMULL_P "p")
+  (UNSPEC_VMULL_S_LANE "s") (UNSPEC_VMULL_U_LANE "u")
+  (UNSPEC_VSUBL_S "s") (UNSPEC_VSUBL_U "u")
+  (UNSPEC_VSUBW_S "s") (UNSPEC_VSUBW_U "u")
+  (UNSPEC_VHSUB_S "s") (UNSPEC_VHSUB_U "u")
+  (UNSPEC_VQSUB_S "s") (UNSPEC_VQSUB_U "u")
+  (UNSPEC_VABD_S "s") (UNSPEC_VABD_U "u")
+  (UNSPEC_VABDL_S "s") (UNSPEC_VABDL_U "u")
+  (UNSPEC_VMAX "s") (UNSPEC_VMAX_U "u")
+  (UNSPEC_VMIN "s") (UNSPEC_VMIN_U "u")
+  (UNSPEC_VPADDL_S "s") (UNSPEC_VPADDL_U "u")
+  (UNSPEC_VPADAL_S "s") (UNSPEC_VPADAL_U "u")
+  (UNSPEC_VPMAX "s") (UNSPEC_VPMAX_U "u")
+  (UNSPEC_VPMIN "s") (UNSPEC_VPMIN_U "u")
+  (UNSPEC_VCVT_S "s") (UNSPEC_VCVT_U "u")
+  (UNSPEC_VCVT_S_N "s") (UNSPEC_VCVT_U_N "u")
+  (UNSPEC_VQMOVN_S "s") (UNSPEC_VQMOVN_U "u")
+  (UNSPEC_VMOVL_S "s") (UNSPEC_VMOVL_U "u")
+  (UNSPEC_VSHL_S "s") (UNSPEC_VSHL_U "u")
+  (UNSPEC_VRSHL_S "s") (UNSPEC_VRSHL_U "u")
+  (UNSPEC_VQSHL_S "s") (UNSPEC_VQSHL_U "u")
+  (UNSPEC_VQRSHL_S "s") (UNSPEC_VQRSHL_U "u")
+  (UNSPEC_VSHR_S_N "s") (UNSPEC_VSHR_U_N "u")
+  (UNSPEC_VRSHR_S_N "s") (UNSPEC_VRSHR_U_N "u")
+  (UNSPEC_VQSHRN_S_N "s") (UNSPEC_VQSHRN_U_N "u")
+  (UNSPEC_VQRSHRN_S_N "s") (UNSPEC_VQRSHRN_U_N "u")
+  (UNSPEC_VQSHL_S_N "s") (UNSPEC_VQSHL_U_N "u")
+  (UNSPEC_VSHLL_S_N "s") (UNSPEC_VSHLL_U_N "u")
+  (UNSPEC_VSRA_S_N "s") (UNSPEC_VSRA_U_N "u")
+  (UNSPEC_VRSRA_S_N "s") (UNSPEC_VRSRA_U_N "u")
+
+])
+
+(define_int_attr r [
+  (UNSPEC_VRHADD_S "r") (UNSPEC_VRHADD_U "r")
+  (UNSPEC_VHADD_S "") (UNSPEC_VHADD_U "")
+  (UNSPEC_VADDHN "") (UNSPEC_VRADDHN "r")
+  (UNSPEC_VQDMULH "") (UNSPEC_VQRDMULH "r")
+  (UNSPEC_VQDMULH_LANE "") (UNSPEC_VQRDMULH_LANE "r")
+  (UNSPEC_VSUBHN "") (UNSPEC_VRSUBHN "r")
+])
+
+(define_int_attr maxmin [
+  (UNSPEC_VMAX "max") (UNSPEC_VMAX_U "max")
+  (UNSPEC_VMIN "min") (UNSPEC_VMIN_U "min")
+  (UNSPEC_VPMAX "max") (UNSPEC_VPMAX_U "max")
+  (UNSPEC_VPMIN "min") (UNSPEC_VPMIN_U "min")
+])
+
+(define_int_attr shift_op [
+  (UNSPEC_VSHL_S "shl") (UNSPEC_VSHL_U "shl")
+  (UNSPEC_VRSHL_S "rshl") (UNSPEC_VRSHL_U "rshl")
+  (UNSPEC_VQSHL_S "qshl") (UNSPEC_VQSHL_U "qshl")
+  (UNSPEC_VQRSHL_S "qrshl") (UNSPEC_VQRSHL_U "qrshl")
+  (UNSPEC_VSHR_S_N "shr") (UNSPEC_VSHR_U_N "shr")
+  (UNSPEC_VRSHR_S_N "rshr") (UNSPEC_VRSHR_U_N "rshr")
+  (UNSPEC_VSHRN_N "shrn") (UNSPEC_VRSHRN_N "rshrn")
+  (UNSPEC_VQRSHRN_S_N "qrshrn") (UNSPEC_VQRSHRN_U_N "qrshrn")
+  (UNSPEC_VQSHRN_S_N "qshrn") (UNSPEC_VQSHRN_U_N "qshrn")
+  (UNSPEC_VQSHRUN_N "qshrun") (UNSPEC_VQRSHRUN_N "qrshrun")
+  (UNSPEC_VSRA_S_N "sra") (UNSPEC_VSRA_U_N "sra")
+  (UNSPEC_VRSRA_S_N "rsra") (UNSPEC_VRSRA_U_N "rsra")
+])
+
 ;; Standard names for floating point to integral rounding instructions.
 (define_int_attr vrint_pattern [(UNSPEC_VRINTZ "btrunc") (UNSPEC_VRINTP "ceil")
                          (UNSPEC_VRINTA "round") (UNSPEC_VRINTM "floor")
diff --git a/gcc/config/arm/neon.md b/gcc/config/arm/neon.md
index e7f5abe..22318de 100644
--- a/gcc/config/arm/neon.md
+++ b/gcc/config/arm/neon.md
@@ -1627,17 +1627,14 @@
 	  (match_operand:VDQW 2 "s_register_operand" "")))]
   "TARGET_NEON && (!<Is_float_mode> || flag_unsafe_math_optimizations)"
 {
-  HOST_WIDE_INT magic_word = (<MODE>mode == V2SFmode || <MODE>mode == V4SFmode)
-			     ? 3 : 1;
-  rtx magic_rtx = GEN_INT (magic_word);
   int inverse = 0;
   int use_zero_form = 0;
   int swap_bsl_operands = 0;
   rtx mask = gen_reg_rtx (<V_cmp_result>mode);
   rtx tmp = gen_reg_rtx (<V_cmp_result>mode);
 
-  rtx (*base_comparison) (rtx, rtx, rtx, rtx);
-  rtx (*complimentary_comparison) (rtx, rtx, rtx, rtx);
+  rtx (*base_comparison) (rtx, rtx, rtx);
+  rtx (*complimentary_comparison) (rtx, rtx, rtx);
 
   switch (GET_CODE (operands[3]))
     {
@@ -1724,9 +1721,9 @@
 	}
 
       if (!inverse)
-	emit_insn (base_comparison (mask, operands[4], operands[5], magic_rtx));
+	emit_insn (base_comparison (mask, operands[4], operands[5]));
       else
-	emit_insn (complimentary_comparison (mask, operands[5], operands[4], magic_rtx));
+	emit_insn (complimentary_comparison (mask, operands[5], operands[4]));
       break;
     case UNLT:
     case UNLE:
@@ -1746,9 +1743,9 @@
 	 a NE b -> !(a EQ b)  */
 
       if (inverse)
-	emit_insn (base_comparison (mask, operands[4], operands[5], magic_rtx));
+	emit_insn (base_comparison (mask, operands[4], operands[5]));
       else
-	emit_insn (complimentary_comparison (mask, operands[5], operands[4], magic_rtx));
+	emit_insn (complimentary_comparison (mask, operands[5], operands[4]));
 
       swap_bsl_operands = 1;
       break;
@@ -1757,8 +1754,8 @@
 	 true iff !(a != b && a ORDERED b), swapping the operands to BSL
 	 will then give us (a == b ||  a UNORDERED b) as intended.  */
 
-      emit_insn (gen_neon_vcgt<mode> (mask, operands[4], operands[5], magic_rtx));
-      emit_insn (gen_neon_vcgt<mode> (tmp, operands[5], operands[4], magic_rtx));
+      emit_insn (gen_neon_vcgt<mode> (mask, operands[4], operands[5]));
+      emit_insn (gen_neon_vcgt<mode> (tmp, operands[5], operands[4]));
       emit_insn (gen_ior<v_cmp_result>3 (mask, mask, tmp));
       swap_bsl_operands = 1;
       break;
@@ -1768,8 +1765,8 @@
      swap_bsl_operands = 1;
      /* Fall through.  */
     case ORDERED:
-      emit_insn (gen_neon_vcgt<mode> (tmp, operands[4], operands[5], magic_rtx));
-      emit_insn (gen_neon_vcge<mode> (mask, operands[5], operands[4], magic_rtx));
+      emit_insn (gen_neon_vcgt<mode> (tmp, operands[4], operands[5]));
+      emit_insn (gen_neon_vcge<mode> (mask, operands[5], operands[4]));
       emit_insn (gen_ior<v_cmp_result>3 (mask, mask, tmp));
       break;
     default:
@@ -1808,41 +1805,33 @@
   switch (GET_CODE (operands[3]))
     {
     case GEU:
-      emit_insn (gen_neon_vcge<mode> (mask, operands[4], operands[5],
-				      const0_rtx));
+      emit_insn (gen_neon_vcgeu<mode> (mask, operands[4], operands[5]));
       break;
     
     case GTU:
-      emit_insn (gen_neon_vcgt<mode> (mask, operands[4], operands[5],
-				      const0_rtx));
+      emit_insn (gen_neon_vcgtu<mode> (mask, operands[4], operands[5]));
       break;
     
     case EQ:
-      emit_insn (gen_neon_vceq<mode> (mask, operands[4], operands[5],
-				      const0_rtx));
+      emit_insn (gen_neon_vceq<mode> (mask, operands[4], operands[5]));
       break;
     
     case LEU:
       if (immediate_zero)
-	emit_insn (gen_neon_vcle<mode> (mask, operands[4], operands[5],
-					const0_rtx));
+	emit_insn (gen_neon_vcle<mode> (mask, operands[4], operands[5]));
       else
-	emit_insn (gen_neon_vcge<mode> (mask, operands[5], operands[4],
-					const0_rtx));
+	emit_insn (gen_neon_vcgeu<mode> (mask, operands[5], operands[4]));
       break;
     
     case LTU:
       if (immediate_zero)
-        emit_insn (gen_neon_vclt<mode> (mask, operands[4], operands[5],
-					const0_rtx));
+        emit_insn (gen_neon_vclt<mode> (mask, operands[4], operands[5]));
       else
-	emit_insn (gen_neon_vcgt<mode> (mask, operands[5], operands[4],
-					const0_rtx));
+	emit_insn (gen_neon_vcgtu<mode> (mask, operands[5], operands[4]));
       break;
     
     case NE:
-      emit_insn (gen_neon_vceq<mode> (mask, operands[4], operands[5],
-				      const0_rtx));
+      emit_insn (gen_neon_vceq<mode> (mask, operands[4], operands[5]));
       inverse = 1;
       break;
     
@@ -1867,8 +1856,7 @@
 (define_expand "neon_vadd<mode>"
   [(match_operand:VCVTF 0 "s_register_operand" "=w")
    (match_operand:VCVTF 1 "s_register_operand" "w")
-   (match_operand:VCVTF 2 "s_register_operand" "w")
-   (match_operand:SI 3 "immediate_operand" "i")]
+   (match_operand:VCVTF 2 "s_register_operand" "w")]
   "TARGET_NEON"
 {
   if (!<Is_float_mode> || flag_unsafe_math_optimizations)
@@ -1904,77 +1892,66 @@
                     (const_string "neon_add<q>")))]
 )
 
-; operand 3 represents in bits:
-;  bit 0: signed (vs unsigned).
-;  bit 1: rounding (vs none).
-
-(define_insn "neon_vaddl<mode>"
+(define_insn "neon_vaddl<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:VDI 1 "s_register_operand" "w")
-		           (match_operand:VDI 2 "s_register_operand" "w")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-                          UNSPEC_VADDL))]
+		           (match_operand:VDI 2 "s_register_operand" "w")]
+                          VADDL))]
   "TARGET_NEON"
-  "vaddl.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
+  "vaddl.<sup>%#<V_sz_elem>\t%q0, %P1, %P2"
   [(set_attr "type" "neon_add_long")]
 )
 
-(define_insn "neon_vaddw<mode>"
+(define_insn "neon_vaddw<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "w")
-		           (match_operand:VDI 2 "s_register_operand" "w")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-                          UNSPEC_VADDW))]
+		           (match_operand:VDI 2 "s_register_operand" "w")]
+                          VADDW))]
   "TARGET_NEON"
-  "vaddw.%T3%#<V_sz_elem>\t%q0, %q1, %P2"
+  "vaddw.<sup>%#<V_sz_elem>\t%q0, %q1, %P2"
   [(set_attr "type" "neon_add_widen")]
 )
 
 ; vhadd and vrhadd.
 
-(define_insn "neon_vhadd<mode>"
+(define_insn "neon_v<r>hadd<sup><mode>"
   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
-		       (match_operand:VDQIW 2 "s_register_operand" "w")
-		       (match_operand:SI 3 "immediate_operand" "i")]
-		      UNSPEC_VHADD))]
+		       (match_operand:VDQIW 2 "s_register_operand" "w")]
+		      VHADD))]
   "TARGET_NEON"
-  "v%O3hadd.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "v<r>hadd.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_add_halve_q")]
 )
 
-(define_insn "neon_vqadd<mode>"
+(define_insn "neon_vqadd<sup><mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
         (unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:VDQIX 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-                     UNSPEC_VQADD))]
+		       (match_operand:VDQIX 2 "s_register_operand" "w")]
+                     VQADD))]
   "TARGET_NEON"
-  "vqadd.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "vqadd.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_qadd<q>")]
 )
 
-(define_insn "neon_vaddhn<mode>"
+(define_insn "neon_v<r>addhn<mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
         (unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-		            (match_operand:VN 2 "s_register_operand" "w")
-                            (match_operand:SI 3 "immediate_operand" "i")]
-                           UNSPEC_VADDHN))]
+		            (match_operand:VN 2 "s_register_operand" "w")]
+                           VADDHN))]
   "TARGET_NEON"
-  "v%O3addhn.<V_if_elem>\t%P0, %q1, %q2"
+  "v<r>addhn.<V_if_elem>\t%P0, %q1, %q2"
   [(set_attr "type" "neon_add_halve_narrow_q")]
 )
 
-;; We cannot replace this unspec with mul<mode>3 because of the odd 
-;; polynomial multiplication case that can specified by operand 3.
-(define_insn "neon_vmul<mode>"
-  [(set (match_operand:VDQW 0 "s_register_operand" "=w")
-        (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
-		      (match_operand:VDQW 2 "s_register_operand" "w")
-		      (match_operand:SI 3 "immediate_operand" "i")]
+;; Polynomial and Float multiplication.
+(define_insn "neon_vmul<pf><mode>"
+  [(set (match_operand:VPF 0 "s_register_operand" "=w")
+        (unspec:VPF [(match_operand:VPF 1 "s_register_operand" "w")
+		      (match_operand:VPF 2 "s_register_operand" "w")]
 		     UNSPEC_VMUL))]
   "TARGET_NEON"
-  "vmul.%F3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "vmul.<pf>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set (attr "type")
       (if_then_else (match_test "<Is_float_mode>")
                     (const_string "neon_fp_mul_s<q>")
@@ -1985,8 +1962,7 @@
   [(match_operand:VDQW 0 "s_register_operand" "=w")
    (match_operand:VDQW 1 "s_register_operand" "0")
    (match_operand:VDQW 2 "s_register_operand" "w")
-   (match_operand:VDQW 3 "s_register_operand" "w")
-   (match_operand:SI 4 "immediate_operand" "i")]
+   (match_operand:VDQW 3 "s_register_operand" "w")]
   "TARGET_NEON"
 {
   if (!<Is_float_mode> || flag_unsafe_math_optimizations)
@@ -2002,8 +1978,7 @@
   [(match_operand:VCVTF 0 "s_register_operand")
    (match_operand:VCVTF 1 "s_register_operand")
    (match_operand:VCVTF 2 "s_register_operand")
-   (match_operand:VCVTF 3 "s_register_operand")
-   (match_operand:SI 4 "immediate_operand")]
+   (match_operand:VCVTF 3 "s_register_operand")]
   "TARGET_NEON && TARGET_FMA"
 {
   emit_insn (gen_fma<mode>4_intrinsic (operands[0], operands[2], operands[3],
@@ -2015,8 +1990,7 @@
   [(match_operand:VCVTF 0 "s_register_operand")
    (match_operand:VCVTF 1 "s_register_operand")
    (match_operand:VCVTF 2 "s_register_operand")
-   (match_operand:VCVTF 3 "s_register_operand")
-   (match_operand:SI 4 "immediate_operand")]
+   (match_operand:VCVTF 3 "s_register_operand")]
   "TARGET_NEON && TARGET_FMA"
 {
   emit_insn (gen_fmsub<mode>4_intrinsic (operands[0], operands[2], operands[3],
@@ -2040,15 +2014,14 @@
                     (const_string "neon_mla_<V_elem_ch><q>")))]
 )
 
-(define_insn "neon_vmlal<mode>"
+(define_insn "neon_vmlal<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
 		           (match_operand:VW 2 "s_register_operand" "w")
-		           (match_operand:VW 3 "s_register_operand" "w")
-                           (match_operand:SI 4 "immediate_operand" "i")]
-                          UNSPEC_VMLAL))]
+		           (match_operand:VW 3 "s_register_operand" "w")]
+                          VMLAL))]
   "TARGET_NEON"
-  "vmlal.%T4%#<V_sz_elem>\t%q0, %P2, %P3"
+  "vmlal.<sup>%#<V_sz_elem>\t%q0, %P2, %P3"
   [(set_attr "type" "neon_mla_<V_elem_ch>_long")]
 )
 
@@ -2056,8 +2029,7 @@
   [(match_operand:VDQW 0 "s_register_operand" "=w")
    (match_operand:VDQW 1 "s_register_operand" "0")
    (match_operand:VDQW 2 "s_register_operand" "w")
-   (match_operand:VDQW 3 "s_register_operand" "w")
-   (match_operand:SI 4 "immediate_operand" "i")]
+   (match_operand:VDQW 3 "s_register_operand" "w")]
   "TARGET_NEON"
 {
   if (!<Is_float_mode> || flag_unsafe_math_optimizations)
@@ -2085,26 +2057,25 @@
                     (const_string "neon_mla_<V_elem_ch><q>")))]
 )
 
-(define_insn "neon_vmlsl<mode>"
+(define_insn "neon_vmlsl<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
 		           (match_operand:VW 2 "s_register_operand" "w")
-		           (match_operand:VW 3 "s_register_operand" "w")
-                           (match_operand:SI 4 "immediate_operand" "i")]
-                          UNSPEC_VMLSL))]
+		           (match_operand:VW 3 "s_register_operand" "w")]
+                          VMLSL))]
   "TARGET_NEON"
-  "vmlsl.%T4%#<V_sz_elem>\t%q0, %P2, %P3"
+  "vmlsl.<sup>%#<V_sz_elem>\t%q0, %P2, %P3"
   [(set_attr "type" "neon_mla_<V_elem_ch>_long")]
 )
 
-(define_insn "neon_vqdmulh<mode>"
+;; vqdmulh, vqrdmulh
+(define_insn "neon_vq<r>dmulh<mode>"
   [(set (match_operand:VMDQI 0 "s_register_operand" "=w")
         (unspec:VMDQI [(match_operand:VMDQI 1 "s_register_operand" "w")
-		       (match_operand:VMDQI 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-                      UNSPEC_VQDMULH))]
+		       (match_operand:VMDQI 2 "s_register_operand" "w")]
+                      VQDMULH))]
   "TARGET_NEON"
-  "vq%O3dmulh.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "vq<r>dmulh.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_sat_mul_<V_elem_ch><q>")]
 )
 
@@ -2112,8 +2083,7 @@
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
 		           (match_operand:VMDI 2 "s_register_operand" "w")
-		           (match_operand:VMDI 3 "s_register_operand" "w")
-                           (match_operand:SI 4 "immediate_operand" "i")]
+		           (match_operand:VMDI 3 "s_register_operand" "w")]
                           UNSPEC_VQDMLAL))]
   "TARGET_NEON"
   "vqdmlal.<V_s_elem>\t%q0, %P2, %P3"
@@ -2124,30 +2094,27 @@
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
 		           (match_operand:VMDI 2 "s_register_operand" "w")
-		           (match_operand:VMDI 3 "s_register_operand" "w")
-                           (match_operand:SI 4 "immediate_operand" "i")]
+		           (match_operand:VMDI 3 "s_register_operand" "w")]
                           UNSPEC_VQDMLSL))]
   "TARGET_NEON"
   "vqdmlsl.<V_s_elem>\t%q0, %P2, %P3"
   [(set_attr "type" "neon_sat_mla_<V_elem_ch>_long")]
 )
 
-(define_insn "neon_vmull<mode>"
+(define_insn "neon_vmull<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")
-		           (match_operand:VW 2 "s_register_operand" "w")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-                          UNSPEC_VMULL))]
+		           (match_operand:VW 2 "s_register_operand" "w")]
+                          VMULL))]
   "TARGET_NEON"
-  "vmull.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
+  "vmull.<sup>%#<V_sz_elem>\t%q0, %P1, %P2"
   [(set_attr "type" "neon_mul_<V_elem_ch>_long")]
 )
 
 (define_insn "neon_vqdmull<mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:VMDI 1 "s_register_operand" "w")
-		           (match_operand:VMDI 2 "s_register_operand" "w")
-                           (match_operand:SI 3 "immediate_operand" "i")]
+		           (match_operand:VMDI 2 "s_register_operand" "w")]
                           UNSPEC_VQDMULL))]
   "TARGET_NEON"
   "vqdmull.<V_s_elem>\t%q0, %P1, %P2"
@@ -2157,8 +2124,7 @@
 (define_expand "neon_vsub<mode>"
   [(match_operand:VCVTF 0 "s_register_operand" "=w")
    (match_operand:VCVTF 1 "s_register_operand" "w")
-   (match_operand:VCVTF 2 "s_register_operand" "w")
-   (match_operand:SI 3 "immediate_operand" "i")]
+   (match_operand:VCVTF 2 "s_register_operand" "w")]
   "TARGET_NEON"
 {
   if (!<Is_float_mode> || flag_unsafe_math_optimizations)
@@ -2184,58 +2150,53 @@
                     (const_string "neon_sub<q>")))]
 )
 
-(define_insn "neon_vsubl<mode>"
+(define_insn "neon_vsubl<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:VDI 1 "s_register_operand" "w")
-		           (match_operand:VDI 2 "s_register_operand" "w")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-                          UNSPEC_VSUBL))]
+		           (match_operand:VDI 2 "s_register_operand" "w")]
+                          VSUBL))]
   "TARGET_NEON"
-  "vsubl.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
+  "vsubl.<sup>%#<V_sz_elem>\t%q0, %P1, %P2"
   [(set_attr "type" "neon_sub_long")]
 )
 
-(define_insn "neon_vsubw<mode>"
+(define_insn "neon_vsubw<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "w")
-		           (match_operand:VDI 2 "s_register_operand" "w")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-			  UNSPEC_VSUBW))]
+		           (match_operand:VDI 2 "s_register_operand" "w")]
+			  VSUBW))]
   "TARGET_NEON"
-  "vsubw.%T3%#<V_sz_elem>\t%q0, %q1, %P2"
+  "vsubw.<sup>%#<V_sz_elem>\t%q0, %q1, %P2"
   [(set_attr "type" "neon_sub_widen")]
 )
 
-(define_insn "neon_vqsub<mode>"
+(define_insn "neon_vqsub<sup><mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
         (unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:VDQIX 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-		      UNSPEC_VQSUB))]
+		       (match_operand:VDQIX 2 "s_register_operand" "w")]
+		      VQSUB))]
   "TARGET_NEON"
-  "vqsub.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "vqsub.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_qsub<q>")]
 )
 
-(define_insn "neon_vhsub<mode>"
+(define_insn "neon_vhsub<sup><mode>"
   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
-		       (match_operand:VDQIW 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-		      UNSPEC_VHSUB))]
+		       (match_operand:VDQIW 2 "s_register_operand" "w")]
+		      VHSUB))]
   "TARGET_NEON"
-  "vhsub.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "vhsub.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_sub_halve<q>")]
 )
 
-(define_insn "neon_vsubhn<mode>"
+(define_insn "neon_v<r>subhn<mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
         (unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-		            (match_operand:VN 2 "s_register_operand" "w")
-                            (match_operand:SI 3 "immediate_operand" "i")]
-                           UNSPEC_VSUBHN))]
+		            (match_operand:VN 2 "s_register_operand" "w")]
+                           VSUBHN))]
   "TARGET_NEON"
-  "v%O3subhn.<V_if_elem>\t%P0, %q1, %q2"
+  "v<r>subhn.<V_if_elem>\t%P0, %q1, %q2"
   [(set_attr "type" "neon_sub_halve_narrow_q")]
 )
 
@@ -2243,8 +2204,7 @@
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w,w")
         (unspec:<V_cmp_result>
 	  [(match_operand:VDQW 1 "s_register_operand" "w,w")
-	   (match_operand:VDQW 2 "reg_or_zero_operand" "w,Dz")
-	   (match_operand:SI 3 "immediate_operand" "i,i")]
+	   (match_operand:VDQW 2 "reg_or_zero_operand" "w,Dz")]
           UNSPEC_VCEQ))]
   "TARGET_NEON"
   "@
@@ -2262,13 +2222,12 @@
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w,w")
         (unspec:<V_cmp_result>
 	  [(match_operand:VDQW 1 "s_register_operand" "w,w")
-	   (match_operand:VDQW 2 "reg_or_zero_operand" "w,Dz")
-	   (match_operand:SI 3 "immediate_operand" "i,i")]
+	   (match_operand:VDQW 2 "reg_or_zero_operand" "w,Dz")]
           UNSPEC_VCGE))]
   "TARGET_NEON"
   "@
-  vcge.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2
-  vcge.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, #0"
+  vcge.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2
+  vcge.<V_s_elem>\t%<V_reg>0, %<V_reg>1, #0"
   [(set (attr "type")
      (if_then_else (match_test "<Is_float_mode>")
                    (const_string "neon_fp_compare_s<q>")
@@ -2281,11 +2240,10 @@
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
         (unspec:<V_cmp_result>
 	  [(match_operand:VDQIW 1 "s_register_operand" "w")
-	   (match_operand:VDQIW 2 "s_register_operand" "w")
-           (match_operand:SI 3 "immediate_operand" "i")]
+	   (match_operand:VDQIW 2 "s_register_operand" "w")]
           UNSPEC_VCGEU))]
   "TARGET_NEON"
-  "vcge.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "vcge.u%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_compare<q>")]
 )
 
@@ -2293,13 +2251,12 @@
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w,w")
         (unspec:<V_cmp_result>
 	  [(match_operand:VDQW 1 "s_register_operand" "w,w")
-	   (match_operand:VDQW 2 "reg_or_zero_operand" "w,Dz")
-           (match_operand:SI 3 "immediate_operand" "i,i")]
+	   (match_operand:VDQW 2 "reg_or_zero_operand" "w,Dz")]
           UNSPEC_VCGT))]
   "TARGET_NEON"
   "@
-  vcgt.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2
-  vcgt.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, #0"
+  vcgt.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2
+  vcgt.<V_s_elem>\t%<V_reg>0, %<V_reg>1, #0"
   [(set (attr "type")
      (if_then_else (match_test "<Is_float_mode>")
                    (const_string "neon_fp_compare_s<q>")
@@ -2312,11 +2269,10 @@
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
         (unspec:<V_cmp_result>
 	  [(match_operand:VDQIW 1 "s_register_operand" "w")
-	   (match_operand:VDQIW 2 "s_register_operand" "w")
-           (match_operand:SI 3 "immediate_operand" "i")]
+	   (match_operand:VDQIW 2 "s_register_operand" "w")]
           UNSPEC_VCGTU))]
   "TARGET_NEON"
-  "vcgt.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "vcgt.u%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_compare<q>")]
 )
 
@@ -2327,11 +2283,10 @@
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
         (unspec:<V_cmp_result>
 	  [(match_operand:VDQW 1 "s_register_operand" "w")
-	   (match_operand:VDQW 2 "zero_operand" "Dz")
-	   (match_operand:SI 3 "immediate_operand" "i")]
+	   (match_operand:VDQW 2 "zero_operand" "Dz")]
           UNSPEC_VCLE))]
   "TARGET_NEON"
-  "vcle.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, #0"
+  "vcle.<V_s_elem>\t%<V_reg>0, %<V_reg>1, #0"
   [(set (attr "type")
       (if_then_else (match_test "<Is_float_mode>")
                     (const_string "neon_fp_compare_s<q>")
@@ -2344,11 +2299,10 @@
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
         (unspec:<V_cmp_result>
 	  [(match_operand:VDQW 1 "s_register_operand" "w")
-	   (match_operand:VDQW 2 "zero_operand" "Dz")
-	   (match_operand:SI 3 "immediate_operand" "i")]
+	   (match_operand:VDQW 2 "zero_operand" "Dz")]
           UNSPEC_VCLT))]
   "TARGET_NEON"
-  "vclt.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, #0"
+  "vclt.<V_s_elem>\t%<V_reg>0, %<V_reg>1, #0"
   [(set (attr "type")
       (if_then_else (match_test "<Is_float_mode>")
                     (const_string "neon_fp_compare_s<q>")
@@ -2360,8 +2314,7 @@
 (define_insn "neon_vcage<mode>"
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
         (unspec:<V_cmp_result> [(match_operand:VCVTF 1 "s_register_operand" "w")
-		                (match_operand:VCVTF 2 "s_register_operand" "w")
-                                (match_operand:SI 3 "immediate_operand" "i")]
+		                (match_operand:VCVTF 2 "s_register_operand" "w")]
                                UNSPEC_VCAGE))]
   "TARGET_NEON"
   "vacge.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
@@ -2371,8 +2324,7 @@
 (define_insn "neon_vcagt<mode>"
   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
         (unspec:<V_cmp_result> [(match_operand:VCVTF 1 "s_register_operand" "w")
-		                (match_operand:VCVTF 2 "s_register_operand" "w")
-                                (match_operand:SI 3 "immediate_operand" "i")]
+		                (match_operand:VCVTF 2 "s_register_operand" "w")]
                                UNSPEC_VCAGT))]
   "TARGET_NEON"
   "vacgt.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
@@ -2382,96 +2334,89 @@
 (define_insn "neon_vtst<mode>"
   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
-		       (match_operand:VDQIW 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
+		       (match_operand:VDQIW 2 "s_register_operand" "w")]
 		      UNSPEC_VTST))]
   "TARGET_NEON"
   "vtst.<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_tst<q>")]
 )
 
-(define_insn "neon_vabd<mode>"
-  [(set (match_operand:VDQW 0 "s_register_operand" "=w")
-        (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
-		      (match_operand:VDQW 2 "s_register_operand" "w")
-		      (match_operand:SI 3 "immediate_operand" "i")]
-		     UNSPEC_VABD))]
+(define_insn "neon_vabd<sup><mode>"
+  [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
+        (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
+		      (match_operand:VDQIW 2 "s_register_operand" "w")]
+		     VABD))]
   "TARGET_NEON"
-  "vabd.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
-  [(set (attr "type")
-     (if_then_else (match_test "<Is_float_mode>")
-                   (const_string "neon_fp_abd_s<q>")
-                   (const_string "neon_abd<q>")))]
+  "vabd.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  [(set_attr "type" "neon_abd<q>")]
 )
 
-(define_insn "neon_vabdl<mode>"
+(define_insn "neon_vabdf<mode>"
+  [(set (match_operand:VCVTF 0 "s_register_operand" "=w")
+        (unspec:VCVTF [(match_operand:VCVTF 1 "s_register_operand" "w")
+		      (match_operand:VCVTF 2 "s_register_operand" "w")]
+		     UNSPEC_VABD_F))]
+  "TARGET_NEON"
+  "vabd.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  [(set_attr "type" "neon_fp_abd_s<q>")]
+)
+
+(define_insn "neon_vabdl<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")
-		           (match_operand:VW 2 "s_register_operand" "w")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-                          UNSPEC_VABDL))]
+		           (match_operand:VW 2 "s_register_operand" "w")]
+                          VABDL))]
   "TARGET_NEON"
-  "vabdl.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
+  "vabdl.<sup>%#<V_sz_elem>\t%q0, %P1, %P2"
   [(set_attr "type" "neon_abd_long")]
 )
 
-(define_insn "neon_vaba<mode>"
+(define_insn "neon_vaba<sup><mode>"
   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
         (plus:VDQIW (unspec:VDQIW [(match_operand:VDQIW 2 "s_register_operand" "w")
-		                   (match_operand:VDQIW 3 "s_register_operand" "w")
-                                   (match_operand:SI 4 "immediate_operand" "i")]
-		                  UNSPEC_VABD)
+		                   (match_operand:VDQIW 3 "s_register_operand" "w")]
+		                  VABD)
 		    (match_operand:VDQIW 1 "s_register_operand" "0")))]
   "TARGET_NEON"
-  "vaba.%T4%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2, %<V_reg>3"
+  "vaba.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2, %<V_reg>3"
   [(set_attr "type" "neon_arith_acc<q>")]
 )
 
-(define_insn "neon_vabal<mode>"
+(define_insn "neon_vabal<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
         (plus:<V_widen> (unspec:<V_widen> [(match_operand:VW 2 "s_register_operand" "w")
-                                           (match_operand:VW 3 "s_register_operand" "w")
-                                           (match_operand:SI 4 "immediate_operand" "i")]
-					   UNSPEC_VABDL)
+                                           (match_operand:VW 3 "s_register_operand" "w")]
+					   VABDL)
 			 (match_operand:<V_widen> 1 "s_register_operand" "0")))]
   "TARGET_NEON"
-  "vabal.%T4%#<V_sz_elem>\t%q0, %P2, %P3"
+  "vabal.<sup>%#<V_sz_elem>\t%q0, %P2, %P3"
   [(set_attr "type" "neon_arith_acc<q>")]
 )
 
-(define_insn "neon_vmax<mode>"
-  [(set (match_operand:VDQW 0 "s_register_operand" "=w")
-        (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
-		      (match_operand:VDQW 2 "s_register_operand" "w")
-		      (match_operand:SI 3 "immediate_operand" "i")]
-                     UNSPEC_VMAX))]
+(define_insn "neon_v<maxmin><sup><mode>"
+  [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
+        (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
+		      (match_operand:VDQIW 2 "s_register_operand" "w")]
+                     VMAXMIN))]
   "TARGET_NEON"
-  "vmax.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
-  [(set (attr "type")
-    (if_then_else (match_test "<Is_float_mode>")
-                  (const_string "neon_fp_minmax_s<q>")
-                  (const_string "neon_minmax<q>")))]
+  "v<maxmin>.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  [(set_attr "type" "neon_minmax<q>")]
 )
 
-(define_insn "neon_vmin<mode>"
-  [(set (match_operand:VDQW 0 "s_register_operand" "=w")
-        (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
-		      (match_operand:VDQW 2 "s_register_operand" "w")
-		      (match_operand:SI 3 "immediate_operand" "i")]
-                     UNSPEC_VMIN))]
+(define_insn "neon_v<maxmin>f<mode>"
+  [(set (match_operand:VCVTF 0 "s_register_operand" "=w")
+        (unspec:VCVTF [(match_operand:VCVTF 1 "s_register_operand" "w")
+		      (match_operand:VCVTF 2 "s_register_operand" "w")]
+                     VMAXMINF))]
   "TARGET_NEON"
-  "vmin.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
-  [(set (attr "type")
-    (if_then_else (match_test "<Is_float_mode>")
-                  (const_string "neon_fp_minmax_s<q>")
-                  (const_string "neon_minmax<q>")))]
+  "v<maxmin>.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  [(set_attr "type" "neon_fp_minmax_s<q>")]
 )
 
 (define_expand "neon_vpadd<mode>"
   [(match_operand:VD 0 "s_register_operand" "=w")
    (match_operand:VD 1 "s_register_operand" "w")
-   (match_operand:VD 2 "s_register_operand" "w")
-   (match_operand:SI 3 "immediate_operand" "i")]
+   (match_operand:VD 2 "s_register_operand" "w")]
   "TARGET_NEON"
 {
   emit_insn (gen_neon_vpadd_internal<mode> (operands[0], operands[1],
@@ -2479,60 +2424,49 @@
   DONE;
 })
 
-(define_insn "neon_vpaddl<mode>"
+(define_insn "neon_vpaddl<sup><mode>"
   [(set (match_operand:<V_double_width> 0 "s_register_operand" "=w")
-        (unspec:<V_double_width> [(match_operand:VDQIW 1 "s_register_operand" "w")
-                                  (match_operand:SI 2 "immediate_operand" "i")]
-                                 UNSPEC_VPADDL))]
+        (unspec:<V_double_width> [(match_operand:VDQIW 1 "s_register_operand" "w")]
+                                 VPADDL))]
   "TARGET_NEON"
-  "vpaddl.%T2%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1"
+  "vpaddl.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1"
   [(set_attr "type" "neon_reduc_add_long")]
 )
 
-(define_insn "neon_vpadal<mode>"
+(define_insn "neon_vpadal<sup><mode>"
   [(set (match_operand:<V_double_width> 0 "s_register_operand" "=w")
         (unspec:<V_double_width> [(match_operand:<V_double_width> 1 "s_register_operand" "0")
-                                  (match_operand:VDQIW 2 "s_register_operand" "w")
-                                  (match_operand:SI 3 "immediate_operand" "i")]
-                                 UNSPEC_VPADAL))]
+                                  (match_operand:VDQIW 2 "s_register_operand" "w")]
+                                 VPADAL))]
   "TARGET_NEON"
-  "vpadal.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2"
+  "vpadal.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2"
   [(set_attr "type" "neon_reduc_add_acc")]
 )
 
-(define_insn "neon_vpmax<mode>"
-  [(set (match_operand:VD 0 "s_register_operand" "=w")
-        (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
-		    (match_operand:VD 2 "s_register_operand" "w")
-                    (match_operand:SI 3 "immediate_operand" "i")]
-                   UNSPEC_VPMAX))]
+(define_insn "neon_vp<maxmin><sup><mode>"
+  [(set (match_operand:VDI 0 "s_register_operand" "=w")
+        (unspec:VDI [(match_operand:VDI 1 "s_register_operand" "w")
+		    (match_operand:VDI 2 "s_register_operand" "w")]
+                   VPMAXMIN))]
   "TARGET_NEON"
-  "vpmax.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
-  [(set (attr "type")
-    (if_then_else (match_test "<Is_float_mode>")
-                  (const_string "neon_fp_reduc_minmax_s<q>")
-                  (const_string "neon_reduc_minmax<q>")))]
+  "vp<maxmin>.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  [(set_attr "type" "neon_reduc_minmax<q>")]
 )
 
-(define_insn "neon_vpmin<mode>"
-  [(set (match_operand:VD 0 "s_register_operand" "=w")
-        (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
-		    (match_operand:VD 2 "s_register_operand" "w")
-                    (match_operand:SI 3 "immediate_operand" "i")]
-                   UNSPEC_VPMIN))]
+(define_insn "neon_vp<maxmin>f<mode>"
+  [(set (match_operand:VCVTF 0 "s_register_operand" "=w")
+        (unspec:VCVTF [(match_operand:VCVTF 1 "s_register_operand" "w")
+		    (match_operand:VCVTF 2 "s_register_operand" "w")]
+                   VPMAXMINF))]
   "TARGET_NEON"
-  "vpmin.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
-  [(set (attr "type")
-    (if_then_else (match_test "<Is_float_mode>")
-                  (const_string "neon_fp_reduc_minmax_s<q>")
-                  (const_string "neon_reduc_minmax<q>")))]
+  "vp<maxmin>.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  [(set_attr "type" "neon_fp_reduc_minmax_s<q>")]
 )
 
 (define_insn "neon_vrecps<mode>"
   [(set (match_operand:VCVTF 0 "s_register_operand" "=w")
         (unspec:VCVTF [(match_operand:VCVTF 1 "s_register_operand" "w")
-		       (match_operand:VCVTF 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
+		       (match_operand:VCVTF 2 "s_register_operand" "w")]
                       UNSPEC_VRECPS))]
   "TARGET_NEON"
   "vrecps.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
@@ -2542,8 +2476,7 @@
 (define_insn "neon_vrsqrts<mode>"
   [(set (match_operand:VCVTF 0 "s_register_operand" "=w")
         (unspec:VCVTF [(match_operand:VCVTF 1 "s_register_operand" "w")
-		       (match_operand:VCVTF 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
+		       (match_operand:VCVTF 2 "s_register_operand" "w")]
                       UNSPEC_VRSQRTS))]
   "TARGET_NEON"
   "vrsqrts.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
@@ -2552,8 +2485,7 @@
 
 (define_expand "neon_vabs<mode>"
   [(match_operand:VDQW 0 "s_register_operand" "")
-   (match_operand:VDQW 1 "s_register_operand" "")
-   (match_operand:SI 2 "immediate_operand" "")]
+   (match_operand:VDQW 1 "s_register_operand" "")]
   "TARGET_NEON"
 {
   emit_insn (gen_abs<mode>2 (operands[0], operands[1]));
@@ -2562,8 +2494,7 @@
 
 (define_insn "neon_vqabs<mode>"
   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
-	(unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
-		       (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")]
 		      UNSPEC_VQABS))]
   "TARGET_NEON"
   "vqabs.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
@@ -2580,8 +2511,7 @@
 
 (define_expand "neon_vneg<mode>"
   [(match_operand:VDQW 0 "s_register_operand" "")
-   (match_operand:VDQW 1 "s_register_operand" "")
-   (match_operand:SI 2 "immediate_operand" "")]
+   (match_operand:VDQW 1 "s_register_operand" "")]
   "TARGET_NEON"
 {
   emit_insn (gen_neg<mode>2 (operands[0], operands[1]));
@@ -2617,8 +2547,7 @@
 
 (define_insn "neon_vqneg<mode>"
   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
-	(unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
-		       (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")]
 		      UNSPEC_VQNEG))]
   "TARGET_NEON"
   "vqneg.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
@@ -2627,8 +2556,7 @@
 
 (define_insn "neon_vcls<mode>"
   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
-	(unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
-		       (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")]
 		      UNSPEC_VCLS))]
   "TARGET_NEON"
   "vcls.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
@@ -2645,8 +2573,7 @@
 
 (define_expand "neon_vclz<mode>"
   [(match_operand:VDQIW 0 "s_register_operand" "")
-   (match_operand:VDQIW 1 "s_register_operand" "")
-   (match_operand:SI 2 "immediate_operand" "")]
+   (match_operand:VDQIW 1 "s_register_operand" "")]
   "TARGET_NEON"
 {
   emit_insn (gen_clz<mode>2 (operands[0], operands[1]));
@@ -2663,8 +2590,7 @@
 
 (define_expand "neon_vcnt<mode>"
   [(match_operand:VE 0 "s_register_operand" "=w")
-   (match_operand:VE 1 "s_register_operand" "w")
-   (match_operand:SI 2 "immediate_operand" "i")]
+   (match_operand:VE 1 "s_register_operand" "w")]
   "TARGET_NEON"
 {
   emit_insn (gen_popcount<mode>2 (operands[0], operands[1]));
@@ -2673,8 +2599,7 @@
 
 (define_insn "neon_vrecpe<mode>"
   [(set (match_operand:V32 0 "s_register_operand" "=w")
-	(unspec:V32 [(match_operand:V32 1 "s_register_operand" "w")
-                     (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:V32 [(match_operand:V32 1 "s_register_operand" "w")]
                     UNSPEC_VRECPE))]
   "TARGET_NEON"
   "vrecpe.<V_u_elem>\t%<V_reg>0, %<V_reg>1"
@@ -2683,8 +2608,7 @@
 
 (define_insn "neon_vrsqrte<mode>"
   [(set (match_operand:V32 0 "s_register_operand" "=w")
-	(unspec:V32 [(match_operand:V32 1 "s_register_operand" "w")
-                     (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:V32 [(match_operand:V32 1 "s_register_operand" "w")]
                     UNSPEC_VRSQRTE))]
   "TARGET_NEON"
   "vrsqrte.<V_u_elem>\t%<V_reg>0, %<V_reg>1"
@@ -2693,8 +2617,7 @@
 
 (define_expand "neon_vmvn<mode>"
   [(match_operand:VDQIW 0 "s_register_operand" "")
-   (match_operand:VDQIW 1 "s_register_operand" "")
-   (match_operand:SI 2 "immediate_operand" "")]
+   (match_operand:VDQIW 1 "s_register_operand" "")]
   "TARGET_NEON"
 {
   emit_insn (gen_one_cmpl<mode>2 (operands[0], operands[1]));
@@ -2796,13 +2719,9 @@
 (define_expand "neon_vget_lane<mode>"
   [(match_operand:<V_ext> 0 "s_register_operand" "")
    (match_operand:VDQW 1 "s_register_operand" "")
-   (match_operand:SI 2 "immediate_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:SI 2 "immediate_operand" "")]
   "TARGET_NEON"
 {
-  HOST_WIDE_INT magic = INTVAL (operands[3]);
-  rtx insn;
-
   neon_lane_bounds (operands[2], 0, GET_MODE_NUNITS (<MODE>mode));
 
   if (BYTES_BIG_ENDIAN)
@@ -2819,29 +2738,50 @@
       operands[2] = GEN_INT (elt);
     }
 
-  if ((magic & 3) == 3 || GET_MODE_BITSIZE (GET_MODE_INNER (<MODE>mode)) == 32)
-    insn = gen_vec_extract<mode> (operands[0], operands[1], operands[2]);
+  if (GET_MODE_BITSIZE (GET_MODE_INNER (<MODE>mode)) == 32)
+    emit_insn (gen_vec_extract<mode> (operands[0], operands[1], operands[2]));
   else
+    emit_insn (gen_neon_vget_lane<mode>_sext_internal (operands[0],
+						       operands[1],
+						       operands[2]));
+  DONE;
+})
+
+(define_expand "neon_vget_laneu<mode>"
+  [(match_operand:<V_ext> 0 "s_register_operand" "")
+   (match_operand:VDQIW 1 "s_register_operand" "")
+   (match_operand:SI 2 "immediate_operand" "")]
+  "TARGET_NEON"
+{
+  neon_lane_bounds (operands[2], 0, GET_MODE_NUNITS (<MODE>mode));
+
+  if (BYTES_BIG_ENDIAN)
     {
-      if ((magic & 1) != 0)
-	insn = gen_neon_vget_lane<mode>_sext_internal (operands[0], operands[1],
-						       operands[2]);
-      else
-	insn = gen_neon_vget_lane<mode>_zext_internal (operands[0], operands[1],
-						       operands[2]);
+      /* The intrinsics are defined in terms of a model where the
+	 element ordering in memory is vldm order, whereas the generic
+	 RTL is defined in terms of a model where the element ordering
+	 in memory is array order.  Convert the lane number to conform
+	 to this model.  */
+      unsigned int elt = INTVAL (operands[2]);
+      unsigned int reg_nelts
+	= 64 / GET_MODE_BITSIZE (GET_MODE_INNER (<MODE>mode));
+      elt ^= reg_nelts - 1;
+      operands[2] = GEN_INT (elt);
     }
-  emit_insn (insn);
+
+  if (GET_MODE_BITSIZE (GET_MODE_INNER (<MODE>mode)) == 32)
+    emit_insn (gen_vec_extract<mode> (operands[0], operands[1], operands[2]));
+  else
+    emit_insn (gen_neon_vget_lane<mode>_zext_internal (operands[0],
+						       operands[1],
+						       operands[2]));
   DONE;
 })
 
-; Operand 3 (info word) is ignored because it does nothing useful with 64-bit
-; elements.
-
 (define_expand "neon_vget_lanedi"
   [(match_operand:DI 0 "s_register_operand" "=r")
    (match_operand:DI 1 "s_register_operand" "w")
-   (match_operand:SI 2 "immediate_operand" "i")
-   (match_operand:SI 3 "immediate_operand" "i")]
+   (match_operand:SI 2 "immediate_operand" "")]
   "TARGET_NEON"
 {
   neon_lane_bounds (operands[2], 0, 1);
@@ -2852,8 +2792,7 @@
 (define_expand "neon_vget_lanev2di"
   [(match_operand:DI 0 "s_register_operand" "")
    (match_operand:V2DI 1 "s_register_operand" "")
-   (match_operand:SI 2 "immediate_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:SI 2 "immediate_operand" "")]
   "TARGET_NEON"
 {
   switch (INTVAL (operands[2]))
@@ -3110,23 +3049,21 @@
   [(set_attr "type" "neon_fp_to_int_<V_elem_ch><q>")]
 )
 
-(define_insn "neon_vcvt<mode>"
+(define_insn "neon_vcvt<sup><mode>"
   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
-	(unspec:<V_CVTTO> [(match_operand:VCVTF 1 "s_register_operand" "w")
-			   (match_operand:SI 2 "immediate_operand" "i")]
-			  UNSPEC_VCVT))]
+	(unspec:<V_CVTTO> [(match_operand:VCVTF 1 "s_register_operand" "w")]
+			  VCVT_US))]
   "TARGET_NEON"
-  "vcvt.%T2%#32.f32\t%<V_reg>0, %<V_reg>1"
+  "vcvt.<sup>%#32.f32\t%<V_reg>0, %<V_reg>1"
   [(set_attr "type" "neon_fp_to_int_<V_elem_ch><q>")]
 )
 
-(define_insn "neon_vcvt<mode>"
+(define_insn "neon_vcvt<sup><mode>"
   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
-	(unspec:<V_CVTTO> [(match_operand:VCVTI 1 "s_register_operand" "w")
-			   (match_operand:SI 2 "immediate_operand" "i")]
-			  UNSPEC_VCVT))]
+	(unspec:<V_CVTTO> [(match_operand:VCVTI 1 "s_register_operand" "w")]
+			  VCVT_US))]
   "TARGET_NEON"
-  "vcvt.f32.%T2%#32\t%<V_reg>0, %<V_reg>1"
+  "vcvt.f32.<sup>%#32\t%<V_reg>0, %<V_reg>1"
   [(set_attr "type" "neon_int_to_fp_<V_elem_ch><q>")]
 )
 
@@ -3148,71 +3085,65 @@
   [(set_attr "type" "neon_fp_cvt_narrow_s_q")]
 )
 
-(define_insn "neon_vcvt_n<mode>"
+(define_insn "neon_vcvt<sup>_n<mode>"
   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
 	(unspec:<V_CVTTO> [(match_operand:VCVTF 1 "s_register_operand" "w")
-			   (match_operand:SI 2 "immediate_operand" "i")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-			  UNSPEC_VCVT_N))]
+			   (match_operand:SI 2 "immediate_operand" "i")]
+			  VCVT_US_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 1, 33);
-  return "vcvt.%T3%#32.f32\t%<V_reg>0, %<V_reg>1, %2";
+  return "vcvt.<sup>%#32.f32\t%<V_reg>0, %<V_reg>1, %2";
 }
   [(set_attr "type" "neon_fp_to_int_<V_elem_ch><q>")]
 )
 
-(define_insn "neon_vcvt_n<mode>"
+(define_insn "neon_vcvt<sup>_n<mode>"
   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
 	(unspec:<V_CVTTO> [(match_operand:VCVTI 1 "s_register_operand" "w")
-			   (match_operand:SI 2 "immediate_operand" "i")
-                           (match_operand:SI 3 "immediate_operand" "i")]
-			  UNSPEC_VCVT_N))]
+			   (match_operand:SI 2 "immediate_operand" "i")]
+			  VCVT_US_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 1, 33);
-  return "vcvt.f32.%T3%#32\t%<V_reg>0, %<V_reg>1, %2";
+  return "vcvt.f32.<sup>%#32\t%<V_reg>0, %<V_reg>1, %2";
 }
   [(set_attr "type" "neon_int_to_fp_<V_elem_ch><q>")]
 )
 
 (define_insn "neon_vmovn<mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
-	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-			    (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")]
                            UNSPEC_VMOVN))]
   "TARGET_NEON"
   "vmovn.<V_if_elem>\t%P0, %q1"
   [(set_attr "type" "neon_shift_imm_narrow_q")]
 )
 
-(define_insn "neon_vqmovn<mode>"
+(define_insn "neon_vqmovn<sup><mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
-	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-			    (match_operand:SI 2 "immediate_operand" "i")]
-                           UNSPEC_VQMOVN))]
+	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")]
+                           VQMOVN))]
   "TARGET_NEON"
-  "vqmovn.%T2%#<V_sz_elem>\t%P0, %q1"
+  "vqmovn.<sup>%#<V_sz_elem>\t%P0, %q1"
   [(set_attr "type" "neon_sat_shift_imm_narrow_q")]
 )
 
 (define_insn "neon_vqmovun<mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
-	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-			    (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")]
                            UNSPEC_VQMOVUN))]
   "TARGET_NEON"
   "vqmovun.<V_s_elem>\t%P0, %q1"
   [(set_attr "type" "neon_sat_shift_imm_narrow_q")]
 )
 
-(define_insn "neon_vmovl<mode>"
+(define_insn "neon_vmovl<sup><mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
-	(unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")
-			   (match_operand:SI 2 "immediate_operand" "i")]
-                          UNSPEC_VMOVL))]
+	(unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")]
+                          VMOVL))]
   "TARGET_NEON"
-  "vmovl.%T2%#<V_sz_elem>\t%q0, %P1"
+  "vmovl.<sup>%#<V_sz_elem>\t%q0, %P1"
   [(set_attr "type" "neon_shift_imm_long")]
 )
 
@@ -3221,8 +3152,7 @@
 	(unspec:VMD [(match_operand:VMD 1 "s_register_operand" "w")
 		     (match_operand:VMD 2 "s_register_operand"
                                         "<scalar_mul_constraint>")
-                     (match_operand:SI 3 "immediate_operand" "i")
-                     (match_operand:SI 4 "immediate_operand" "i")]
+                     (match_operand:SI 3 "immediate_operand" "i")]
                     UNSPEC_VMUL_LANE))]
   "TARGET_NEON"
 {
@@ -3240,8 +3170,7 @@
 	(unspec:VMQ [(match_operand:VMQ 1 "s_register_operand" "w")
 		     (match_operand:<V_HALF> 2 "s_register_operand"
                                              "<scalar_mul_constraint>")
-                     (match_operand:SI 3 "immediate_operand" "i")
-                     (match_operand:SI 4 "immediate_operand" "i")]
+                     (match_operand:SI 3 "immediate_operand" "i")]
                     UNSPEC_VMUL_LANE))]
   "TARGET_NEON"
 {
@@ -3254,18 +3183,17 @@
                    (const_string "neon_mul_<V_elem_ch>_scalar<q>")))]
 )
 
-(define_insn "neon_vmull_lane<mode>"
+(define_insn "neon_vmull<sup>_lane<mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
 	(unspec:<V_widen> [(match_operand:VMDI 1 "s_register_operand" "w")
 		           (match_operand:VMDI 2 "s_register_operand"
 					       "<scalar_mul_constraint>")
-                           (match_operand:SI 3 "immediate_operand" "i")
-                           (match_operand:SI 4 "immediate_operand" "i")]
-                          UNSPEC_VMULL_LANE))]
+                           (match_operand:SI 3 "immediate_operand" "i")]
+                          VMULL_LANE))]
   "TARGET_NEON"
 {
   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
-  return "vmull.%T4%#<V_sz_elem>\t%q0, %P1, %P2[%c3]";
+  return "vmull.<sup>%#<V_sz_elem>\t%q0, %P1, %P2[%c3]";
 }
   [(set_attr "type" "neon_mul_<V_elem_ch>_scalar_long")]
 )
@@ -3275,8 +3203,7 @@
 	(unspec:<V_widen> [(match_operand:VMDI 1 "s_register_operand" "w")
 		           (match_operand:VMDI 2 "s_register_operand"
 					       "<scalar_mul_constraint>")
-                           (match_operand:SI 3 "immediate_operand" "i")
-                           (match_operand:SI 4 "immediate_operand" "i")]
+                           (match_operand:SI 3 "immediate_operand" "i")]
                           UNSPEC_VQDMULL_LANE))]
   "TARGET_NEON"
 {
@@ -3286,34 +3213,32 @@
   [(set_attr "type" "neon_sat_mul_<V_elem_ch>_scalar_long")]
 )
 
-(define_insn "neon_vqdmulh_lane<mode>"
+(define_insn "neon_vq<r>dmulh_lane<mode>"
   [(set (match_operand:VMQI 0 "s_register_operand" "=w")
 	(unspec:VMQI [(match_operand:VMQI 1 "s_register_operand" "w")
 		      (match_operand:<V_HALF> 2 "s_register_operand"
 					      "<scalar_mul_constraint>")
-                      (match_operand:SI 3 "immediate_operand" "i")
-                      (match_operand:SI 4 "immediate_operand" "i")]
-                      UNSPEC_VQDMULH_LANE))]
+                      (match_operand:SI 3 "immediate_operand" "i")]
+                      VQDMULH_LANE))]
   "TARGET_NEON"
 {
   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
-  return "vq%O4dmulh.%T4%#<V_sz_elem>\t%q0, %q1, %P2[%c3]";
+  return "vq<r>dmulh.<V_s_elem>\t%q0, %q1, %P2[%c3]";
 }
   [(set_attr "type" "neon_sat_mul_<V_elem_ch>_scalar_q")]
 )
 
-(define_insn "neon_vqdmulh_lane<mode>"
+(define_insn "neon_vq<r>dmulh_lane<mode>"
   [(set (match_operand:VMDI 0 "s_register_operand" "=w")
 	(unspec:VMDI [(match_operand:VMDI 1 "s_register_operand" "w")
 		      (match_operand:VMDI 2 "s_register_operand"
 					  "<scalar_mul_constraint>")
-                      (match_operand:SI 3 "immediate_operand" "i")
-                      (match_operand:SI 4 "immediate_operand" "i")]
-                      UNSPEC_VQDMULH_LANE))]
+                      (match_operand:SI 3 "immediate_operand" "i")]
+                      VQDMULH_LANE))]
   "TARGET_NEON"
 {
   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
-  return "vq%O4dmulh.%T4%#<V_sz_elem>\t%P0, %P1, %P2[%c3]";
+  return "vq<r>dmulh.<V_s_elem>\t%P0, %P1, %P2[%c3]";
 }
   [(set_attr "type" "neon_sat_mul_<V_elem_ch>_scalar_q")]
 )
@@ -3324,8 +3249,7 @@
 		     (match_operand:VMD 2 "s_register_operand" "w")
                      (match_operand:VMD 3 "s_register_operand"
 					"<scalar_mul_constraint>")
-                     (match_operand:SI 4 "immediate_operand" "i")
-                     (match_operand:SI 5 "immediate_operand" "i")]
+                     (match_operand:SI 4 "immediate_operand" "i")]
                      UNSPEC_VMLA_LANE))]
   "TARGET_NEON"
 {
@@ -3344,8 +3268,7 @@
 		     (match_operand:VMQ 2 "s_register_operand" "w")
                      (match_operand:<V_HALF> 3 "s_register_operand"
 					     "<scalar_mul_constraint>")
-                     (match_operand:SI 4 "immediate_operand" "i")
-                     (match_operand:SI 5 "immediate_operand" "i")]
+                     (match_operand:SI 4 "immediate_operand" "i")]
                      UNSPEC_VMLA_LANE))]
   "TARGET_NEON"
 {
@@ -3358,19 +3281,18 @@
                    (const_string "neon_mla_<V_elem_ch>_scalar<q>")))]
 )
 
-(define_insn "neon_vmlal_lane<mode>"
+(define_insn "neon_vmlal<sup>_lane<mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
 	(unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
 			   (match_operand:VMDI 2 "s_register_operand" "w")
                            (match_operand:VMDI 3 "s_register_operand"
 					       "<scalar_mul_constraint>")
-                           (match_operand:SI 4 "immediate_operand" "i")
-                           (match_operand:SI 5 "immediate_operand" "i")]
-                          UNSPEC_VMLAL_LANE))]
+                           (match_operand:SI 4 "immediate_operand" "i")]
+                          VMLAL_LANE))]
   "TARGET_NEON"
 {
   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
-  return "vmlal.%T5%#<V_sz_elem>\t%q0, %P2, %P3[%c4]";
+  return "vmlal.<sup>%#<V_sz_elem>\t%q0, %P2, %P3[%c4]";
 }
   [(set_attr "type" "neon_mla_<V_elem_ch>_scalar_long")]
 )
@@ -3381,8 +3303,7 @@
 			   (match_operand:VMDI 2 "s_register_operand" "w")
                            (match_operand:VMDI 3 "s_register_operand"
 					       "<scalar_mul_constraint>")
-                           (match_operand:SI 4 "immediate_operand" "i")
-                           (match_operand:SI 5 "immediate_operand" "i")]
+                           (match_operand:SI 4 "immediate_operand" "i")]
                           UNSPEC_VQDMLAL_LANE))]
   "TARGET_NEON"
 {
@@ -3398,8 +3319,7 @@
 		     (match_operand:VMD 2 "s_register_operand" "w")
                      (match_operand:VMD 3 "s_register_operand"
 					"<scalar_mul_constraint>")
-                     (match_operand:SI 4 "immediate_operand" "i")
-                     (match_operand:SI 5 "immediate_operand" "i")]
+                     (match_operand:SI 4 "immediate_operand" "i")]
                     UNSPEC_VMLS_LANE))]
   "TARGET_NEON"
 {
@@ -3418,8 +3338,7 @@
 		     (match_operand:VMQ 2 "s_register_operand" "w")
                      (match_operand:<V_HALF> 3 "s_register_operand"
 					     "<scalar_mul_constraint>")
-                     (match_operand:SI 4 "immediate_operand" "i")
-                     (match_operand:SI 5 "immediate_operand" "i")]
+                     (match_operand:SI 4 "immediate_operand" "i")]
                     UNSPEC_VMLS_LANE))]
   "TARGET_NEON"
 {
@@ -3432,19 +3351,18 @@
                    (const_string "neon_mla_<V_elem_ch>_scalar<q>")))]
 )
 
-(define_insn "neon_vmlsl_lane<mode>"
+(define_insn "neon_vmlsl<sup>_lane<mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
 	(unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
 			   (match_operand:VMDI 2 "s_register_operand" "w")
                            (match_operand:VMDI 3 "s_register_operand"
 					       "<scalar_mul_constraint>")
-                           (match_operand:SI 4 "immediate_operand" "i")
-                           (match_operand:SI 5 "immediate_operand" "i")]
-                          UNSPEC_VMLSL_LANE))]
+                           (match_operand:SI 4 "immediate_operand" "i")]
+                          VMLSL_LANE))]
   "TARGET_NEON"
 {
   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
-  return "vmlsl.%T5%#<V_sz_elem>\t%q0, %P2, %P3[%c4]";
+  return "vmlsl.<sup>%#<V_sz_elem>\t%q0, %P2, %P3[%c4]";
 }
   [(set_attr "type" "neon_mla_<V_elem_ch>_scalar_long")]
 )
@@ -3455,8 +3373,7 @@
 			   (match_operand:VMDI 2 "s_register_operand" "w")
                            (match_operand:VMDI 3 "s_register_operand"
 					       "<scalar_mul_constraint>")
-                           (match_operand:SI 4 "immediate_operand" "i")
-                           (match_operand:SI 5 "immediate_operand" "i")]
+                           (match_operand:SI 4 "immediate_operand" "i")]
                           UNSPEC_VQDMLSL_LANE))]
   "TARGET_NEON"
 {
@@ -3476,84 +3393,117 @@
 (define_expand "neon_vmul_n<mode>"
   [(match_operand:VMD 0 "s_register_operand" "")
    (match_operand:VMD 1 "s_register_operand" "")
-   (match_operand:<V_elem> 2 "s_register_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
   emit_insn (gen_neon_vmul_lane<mode> (operands[0], operands[1], tmp,
-				       const0_rtx, const0_rtx));
+				       const0_rtx));
   DONE;
 })
 
 (define_expand "neon_vmul_n<mode>"
   [(match_operand:VMQ 0 "s_register_operand" "")
    (match_operand:VMQ 1 "s_register_operand" "")
-   (match_operand:<V_elem> 2 "s_register_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<V_HALF>mode);
   emit_insn (gen_neon_vset_lane<V_half> (tmp, operands[2], tmp, const0_rtx));
   emit_insn (gen_neon_vmul_lane<mode> (operands[0], operands[1], tmp,
-				       const0_rtx, const0_rtx));
+				       const0_rtx));
   DONE;
 })
 
-(define_expand "neon_vmull_n<mode>"
+(define_expand "neon_vmulls_n<mode>"
   [(match_operand:<V_widen> 0 "s_register_operand" "")
    (match_operand:VMDI 1 "s_register_operand" "")
-   (match_operand:<V_elem> 2 "s_register_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
-  emit_insn (gen_neon_vmull_lane<mode> (operands[0], operands[1], tmp,
-				        const0_rtx, operands[3]));
+  emit_insn (gen_neon_vmulls_lane<mode> (operands[0], operands[1], tmp,
+					 const0_rtx));
+  DONE;
+})
+
+(define_expand "neon_vmullu_n<mode>"
+  [(match_operand:<V_widen> 0 "s_register_operand" "")
+   (match_operand:VMDI 1 "s_register_operand" "")
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
+  "TARGET_NEON"
+{
+  rtx tmp = gen_reg_rtx (<MODE>mode);
+  emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
+  emit_insn (gen_neon_vmullu_lane<mode> (operands[0], operands[1], tmp,
+					 const0_rtx));
   DONE;
 })
 
 (define_expand "neon_vqdmull_n<mode>"
   [(match_operand:<V_widen> 0 "s_register_operand" "")
    (match_operand:VMDI 1 "s_register_operand" "")
-   (match_operand:<V_elem> 2 "s_register_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
   emit_insn (gen_neon_vqdmull_lane<mode> (operands[0], operands[1], tmp,
-				          const0_rtx, const0_rtx));
+				          const0_rtx));
   DONE;
 })
 
 (define_expand "neon_vqdmulh_n<mode>"
   [(match_operand:VMDI 0 "s_register_operand" "")
    (match_operand:VMDI 1 "s_register_operand" "")
-   (match_operand:<V_elem> 2 "s_register_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
   emit_insn (gen_neon_vqdmulh_lane<mode> (operands[0], operands[1], tmp,
-				          const0_rtx, operands[3]));
+				          const0_rtx));
+  DONE;
+})
+
+(define_expand "neon_vqrdmulh_n<mode>"
+  [(match_operand:VMDI 0 "s_register_operand" "")
+   (match_operand:VMDI 1 "s_register_operand" "")
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
+  "TARGET_NEON"
+{
+  rtx tmp = gen_reg_rtx (<MODE>mode);
+  emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
+  emit_insn (gen_neon_vqrdmulh_lane<mode> (operands[0], operands[1], tmp,
+				          const0_rtx));
   DONE;
 })
 
 (define_expand "neon_vqdmulh_n<mode>"
   [(match_operand:VMQI 0 "s_register_operand" "")
    (match_operand:VMQI 1 "s_register_operand" "")
-   (match_operand:<V_elem> 2 "s_register_operand" "")
-   (match_operand:SI 3 "immediate_operand" "")]
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<V_HALF>mode);
   emit_insn (gen_neon_vset_lane<V_half> (tmp, operands[2], tmp, const0_rtx));
   emit_insn (gen_neon_vqdmulh_lane<mode> (operands[0], operands[1], tmp,
-				          const0_rtx, operands[3]));
+					  const0_rtx));
+  DONE;
+})
+
+(define_expand "neon_vqrdmulh_n<mode>"
+  [(match_operand:VMQI 0 "s_register_operand" "")
+   (match_operand:VMQI 1 "s_register_operand" "")
+   (match_operand:<V_elem> 2 "s_register_operand" "")]
+  "TARGET_NEON"
+{
+  rtx tmp = gen_reg_rtx (<V_HALF>mode);
+  emit_insn (gen_neon_vset_lane<V_half> (tmp, operands[2], tmp, const0_rtx));
+  emit_insn (gen_neon_vqrdmulh_lane<mode> (operands[0], operands[1], tmp,
+					   const0_rtx));
   DONE;
 })
 
@@ -3561,14 +3511,13 @@
   [(match_operand:VMD 0 "s_register_operand" "")
    (match_operand:VMD 1 "s_register_operand" "")
    (match_operand:VMD 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
   emit_insn (gen_neon_vmla_lane<mode> (operands[0], operands[1], operands[2],
-				       tmp, const0_rtx, operands[4]));
+				       tmp, const0_rtx));
   DONE;
 })
 
@@ -3576,29 +3525,41 @@
   [(match_operand:VMQ 0 "s_register_operand" "")
    (match_operand:VMQ 1 "s_register_operand" "")
    (match_operand:VMQ 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<V_HALF>mode);
   emit_insn (gen_neon_vset_lane<V_half> (tmp, operands[3], tmp, const0_rtx));
   emit_insn (gen_neon_vmla_lane<mode> (operands[0], operands[1], operands[2],
-				       tmp, const0_rtx, operands[4]));
+				       tmp, const0_rtx));
   DONE;
 })
 
-(define_expand "neon_vmlal_n<mode>"
+(define_expand "neon_vmlals_n<mode>"
   [(match_operand:<V_widen> 0 "s_register_operand" "")
    (match_operand:<V_widen> 1 "s_register_operand" "")
    (match_operand:VMDI 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
-  emit_insn (gen_neon_vmlal_lane<mode> (operands[0], operands[1], operands[2],
-					tmp, const0_rtx, operands[4]));
+  emit_insn (gen_neon_vmlals_lane<mode> (operands[0], operands[1], operands[2],
+					 tmp, const0_rtx));
+  DONE;
+})
+
+(define_expand "neon_vmlalu_n<mode>"
+  [(match_operand:<V_widen> 0 "s_register_operand" "")
+   (match_operand:<V_widen> 1 "s_register_operand" "")
+   (match_operand:VMDI 2 "s_register_operand" "")
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
+  "TARGET_NEON"
+{
+  rtx tmp = gen_reg_rtx (<MODE>mode);
+  emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
+  emit_insn (gen_neon_vmlalu_lane<mode> (operands[0], operands[1], operands[2],
+					 tmp, const0_rtx));
   DONE;
 })
 
@@ -3606,14 +3567,13 @@
   [(match_operand:<V_widen> 0 "s_register_operand" "")
    (match_operand:<V_widen> 1 "s_register_operand" "")
    (match_operand:VMDI 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
   emit_insn (gen_neon_vqdmlal_lane<mode> (operands[0], operands[1], operands[2],
-					  tmp, const0_rtx, operands[4]));
+					  tmp, const0_rtx));
   DONE;
 })
 
@@ -3621,14 +3581,13 @@
   [(match_operand:VMD 0 "s_register_operand" "")
    (match_operand:VMD 1 "s_register_operand" "")
    (match_operand:VMD 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
   emit_insn (gen_neon_vmls_lane<mode> (operands[0], operands[1], operands[2],
-				       tmp, const0_rtx, operands[4]));
+				       tmp, const0_rtx));
   DONE;
 })
 
@@ -3636,29 +3595,41 @@
   [(match_operand:VMQ 0 "s_register_operand" "")
    (match_operand:VMQ 1 "s_register_operand" "")
    (match_operand:VMQ 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<V_HALF>mode);
   emit_insn (gen_neon_vset_lane<V_half> (tmp, operands[3], tmp, const0_rtx));
   emit_insn (gen_neon_vmls_lane<mode> (operands[0], operands[1], operands[2],
-				       tmp, const0_rtx, operands[4]));
+				       tmp, const0_rtx));
+  DONE;
+})
+
+(define_expand "neon_vmlsls_n<mode>"
+  [(match_operand:<V_widen> 0 "s_register_operand" "")
+   (match_operand:<V_widen> 1 "s_register_operand" "")
+   (match_operand:VMDI 2 "s_register_operand" "")
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
+  "TARGET_NEON"
+{
+  rtx tmp = gen_reg_rtx (<MODE>mode);
+  emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
+  emit_insn (gen_neon_vmlsls_lane<mode> (operands[0], operands[1], operands[2],
+					tmp, const0_rtx));
   DONE;
 })
 
-(define_expand "neon_vmlsl_n<mode>"
+(define_expand "neon_vmlslu_n<mode>"
   [(match_operand:<V_widen> 0 "s_register_operand" "")
    (match_operand:<V_widen> 1 "s_register_operand" "")
    (match_operand:VMDI 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
-  emit_insn (gen_neon_vmlsl_lane<mode> (operands[0], operands[1], operands[2],
-					tmp, const0_rtx, operands[4]));
+  emit_insn (gen_neon_vmlslu_lane<mode> (operands[0], operands[1], operands[2],
+					tmp, const0_rtx));
   DONE;
 })
 
@@ -3666,14 +3637,13 @@
   [(match_operand:<V_widen> 0 "s_register_operand" "")
    (match_operand:<V_widen> 1 "s_register_operand" "")
    (match_operand:VMDI 2 "s_register_operand" "")
-   (match_operand:<V_elem> 3 "s_register_operand" "")
-   (match_operand:SI 4 "immediate_operand" "")]
+   (match_operand:<V_elem> 3 "s_register_operand" "")]
   "TARGET_NEON"
 {
   rtx tmp = gen_reg_rtx (<MODE>mode);
   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[3], tmp, const0_rtx));
   emit_insn (gen_neon_vqdmlsl_lane<mode> (operands[0], operands[1], operands[2],
-					  tmp, const0_rtx, operands[4]));
+					  tmp, const0_rtx));
   DONE;
 })
 
@@ -3693,8 +3663,7 @@
 
 (define_insn "neon_vrev64<mode>"
   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
-	(unspec:VDQ [(match_operand:VDQ 1 "s_register_operand" "w")
-		     (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:VDQ [(match_operand:VDQ 1 "s_register_operand" "w")]
                     UNSPEC_VREV64))]
   "TARGET_NEON"
   "vrev64.<V_sz_elem>\t%<V_reg>0, %<V_reg>1"
@@ -3703,8 +3672,7 @@
 
 (define_insn "neon_vrev32<mode>"
   [(set (match_operand:VX 0 "s_register_operand" "=w")
-	(unspec:VX [(match_operand:VX 1 "s_register_operand" "w")
-		    (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:VX [(match_operand:VX 1 "s_register_operand" "w")]
                    UNSPEC_VREV32))]
   "TARGET_NEON"
   "vrev32.<V_sz_elem>\t%<V_reg>0, %<V_reg>1"
@@ -3713,8 +3681,7 @@
 
 (define_insn "neon_vrev16<mode>"
   [(set (match_operand:VE 0 "s_register_operand" "=w")
-	(unspec:VE [(match_operand:VE 1 "s_register_operand" "w")
-		    (match_operand:SI 2 "immediate_operand" "i")]
+	(unspec:VE [(match_operand:VE 1 "s_register_operand" "w")]
                    UNSPEC_VREV16))]
   "TARGET_NEON"
   "vrev16.<V_sz_elem>\t%<V_reg>0, %<V_reg>1"
@@ -3755,80 +3722,80 @@
   operands[1] = gen_lowpart (<MODE>mode, operands[1]);
 })
 
-(define_insn "neon_vshl<mode>"
+;; vshl, vrshl
+(define_insn "neon_v<shift_op><sup><mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
 	(unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:VDQIX 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-                      UNSPEC_VSHL))]
+		       (match_operand:VDQIX 2 "s_register_operand" "w")]
+                      VSHL))]
   "TARGET_NEON"
-  "v%O3shl.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "v<shift_op>.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_shift_imm<q>")]
 )
 
-(define_insn "neon_vqshl<mode>"
+;; vqshl, vqrshl
+(define_insn "neon_v<shift_op><sup><mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
 	(unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:VDQIX 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-                      UNSPEC_VQSHL))]
+		       (match_operand:VDQIX 2 "s_register_operand" "w")]
+                      VQSHL))]
   "TARGET_NEON"
-  "vq%O3shl.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
+  "v<shift_op>.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
   [(set_attr "type" "neon_sat_shift_imm<q>")]
 )
 
-(define_insn "neon_vshr_n<mode>"
+;; vshr_n, vrshr_n
+(define_insn "neon_v<shift_op><sup>_n<mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
 	(unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:SI 2 "immediate_operand" "i")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-                      UNSPEC_VSHR_N))]
+		       (match_operand:SI 2 "immediate_operand" "i")]
+                      VSHR_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 1, neon_element_bits (<MODE>mode) + 1);
-  return "v%O3shr.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %2";
+  return "v<shift_op>.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %2";
 }
   [(set_attr "type" "neon_shift_imm<q>")]
 )
 
-(define_insn "neon_vshrn_n<mode>"
+;; vshrn_n, vrshrn_n
+(define_insn "neon_v<shift_op>_n<mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
 	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-			    (match_operand:SI 2 "immediate_operand" "i")
-			    (match_operand:SI 3 "immediate_operand" "i")]
-                           UNSPEC_VSHRN_N))]
+			    (match_operand:SI 2 "immediate_operand" "i")]
+                           VSHRN_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 1, neon_element_bits (<MODE>mode) / 2 + 1);
-  return "v%O3shrn.<V_if_elem>\t%P0, %q1, %2";
+  return "v<shift_op>.<V_if_elem>\t%P0, %q1, %2";
 }
   [(set_attr "type" "neon_shift_imm_narrow_q")]
 )
 
-(define_insn "neon_vqshrn_n<mode>"
+;; vqshrn_n, vqrshrn_n
+(define_insn "neon_v<shift_op><sup>_n<mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
 	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-			    (match_operand:SI 2 "immediate_operand" "i")
-			    (match_operand:SI 3 "immediate_operand" "i")]
-                           UNSPEC_VQSHRN_N))]
+			    (match_operand:SI 2 "immediate_operand" "i")]
+                           VQSHRN_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 1, neon_element_bits (<MODE>mode) / 2 + 1);
-  return "vq%O3shrn.%T3%#<V_sz_elem>\t%P0, %q1, %2";
+  return "v<shift_op>.<sup>%#<V_sz_elem>\t%P0, %q1, %2";
 }
   [(set_attr "type" "neon_sat_shift_imm_narrow_q")]
 )
 
-(define_insn "neon_vqshrun_n<mode>"
+;; vqshrun_n, vqrshrun_n
+(define_insn "neon_v<shift_op>_n<mode>"
   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
 	(unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
-			    (match_operand:SI 2 "immediate_operand" "i")
-			    (match_operand:SI 3 "immediate_operand" "i")]
-                           UNSPEC_VQSHRUN_N))]
+			    (match_operand:SI 2 "immediate_operand" "i")]
+                           VQSHRUN_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 1, neon_element_bits (<MODE>mode) / 2 + 1);
-  return "vq%O3shrun.%T3%#<V_sz_elem>\t%P0, %q1, %2";
+  return "v<shift_op>.<V_s_elem>\t%P0, %q1, %2";
 }
   [(set_attr "type" "neon_sat_shift_imm_narrow_q")]
 )
@@ -3836,8 +3803,7 @@
 (define_insn "neon_vshl_n<mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
 	(unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:SI 2 "immediate_operand" "i")
-                       (match_operand:SI 3 "immediate_operand" "i")]
+		       (match_operand:SI 2 "immediate_operand" "i")]
                       UNSPEC_VSHL_N))]
   "TARGET_NEON"
 {
@@ -3847,16 +3813,15 @@
   [(set_attr "type" "neon_shift_imm<q>")]
 )
 
-(define_insn "neon_vqshl_n<mode>"
+(define_insn "neon_vqshl_<sup>_n<mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
 	(unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:SI 2 "immediate_operand" "i")
-                       (match_operand:SI 3 "immediate_operand" "i")]
-                      UNSPEC_VQSHL_N))]
+		       (match_operand:SI 2 "immediate_operand" "i")]
+                      VQSHL_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 0, neon_element_bits (<MODE>mode));
-  return "vqshl.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %2";
+  return "vqshl.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %2";
 }
   [(set_attr "type" "neon_sat_shift_imm<q>")]
 )
@@ -3864,43 +3829,41 @@
 (define_insn "neon_vqshlu_n<mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
 	(unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
-		       (match_operand:SI 2 "immediate_operand" "i")
-                       (match_operand:SI 3 "immediate_operand" "i")]
+		       (match_operand:SI 2 "immediate_operand" "i")]
                       UNSPEC_VQSHLU_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[2], 0, neon_element_bits (<MODE>mode));
-  return "vqshlu.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %2";
+  return "vqshlu.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %2";
 }
   [(set_attr "type" "neon_sat_shift_imm<q>")]
 )
 
-(define_insn "neon_vshll_n<mode>"
+(define_insn "neon_vshll<sup>_n<mode>"
   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
 	(unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")
-			   (match_operand:SI 2 "immediate_operand" "i")
-			   (match_operand:SI 3 "immediate_operand" "i")]
-			  UNSPEC_VSHLL_N))]
+			   (match_operand:SI 2 "immediate_operand" "i")]
+			  VSHLL_N))]
   "TARGET_NEON"
 {
   /* The boundaries are: 0 < imm <= size.  */
   neon_const_bounds (operands[2], 0, neon_element_bits (<MODE>mode) + 1);
-  return "vshll.%T3%#<V_sz_elem>\t%q0, %P1, %2";
+  return "vshll.<sup>%#<V_sz_elem>\t%q0, %P1, %2";
 }
   [(set_attr "type" "neon_shift_imm_long")]
 )
 
-(define_insn "neon_vsra_n<mode>"
+;; vsra_n, vrsra_n
+(define_insn "neon_v<shift_op><sup>_n<mode>"
   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
 	(unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "0")
 		       (match_operand:VDQIX 2 "s_register_operand" "w")
-                       (match_operand:SI 3 "immediate_operand" "i")
-                       (match_operand:SI 4 "immediate_operand" "i")]
-                      UNSPEC_VSRA_N))]
+                       (match_operand:SI 3 "immediate_operand" "i")]
+                      VSRA_N))]
   "TARGET_NEON"
 {
   neon_const_bounds (operands[3], 1, neon_element_bits (<MODE>mode) + 1);
-  return "v%O4sra.%T4%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2, %3";
+  return "v<shift_op>.<sup>%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2, %3";
 }
   [(set_attr "type" "neon_shift_acc<q>")]
 )
diff --git a/gcc/config/arm/unspecs.md b/gcc/config/arm/unspecs.md
index 147cb80..fcee30b 100644
--- a/gcc/config/arm/unspecs.md
+++ b/gcc/config/arm/unspecs.md
@@ -173,12 +173,18 @@
   UNSPEC_SHA256SU1
   UNSPEC_VMULLP64
   UNSPEC_LOAD_COUNT
-  UNSPEC_VABD
-  UNSPEC_VABDL
+  UNSPEC_VABD_F
+  UNSPEC_VABD_S
+  UNSPEC_VABD_U
+  UNSPEC_VABDL_S
+  UNSPEC_VABDL_U
   UNSPEC_VADD
   UNSPEC_VADDHN
-  UNSPEC_VADDL
-  UNSPEC_VADDW
+  UNSPEC_VRADDHN
+  UNSPEC_VADDL_S
+  UNSPEC_VADDL_U
+  UNSPEC_VADDW_S
+  UNSPEC_VADDW_U
   UNSPEC_VBSL
   UNSPEC_VCAGE
   UNSPEC_VCAGT
@@ -190,10 +196,17 @@
   UNSPEC_VCLS
   UNSPEC_VCONCAT
   UNSPEC_VCVT
-  UNSPEC_VCVT_N
+  UNSPEC_VCVT_S
+  UNSPEC_VCVT_U
+  UNSPEC_VCVT_S_N
+  UNSPEC_VCVT_U_N
   UNSPEC_VEXT
-  UNSPEC_VHADD
-  UNSPEC_VHSUB
+  UNSPEC_VHADD_S
+  UNSPEC_VHADD_U
+  UNSPEC_VRHADD_S
+  UNSPEC_VRHADD_U
+  UNSPEC_VHSUB_S
+  UNSPEC_VHSUB_U
   UNSPEC_VLD1
   UNSPEC_VLD1_LANE
   UNSPEC_VLD2
@@ -210,49 +223,77 @@
   UNSPEC_VLD4_DUP
   UNSPEC_VLD4_LANE
   UNSPEC_VMAX
+  UNSPEC_VMAX_U
   UNSPEC_VMIN
+  UNSPEC_VMIN_U
   UNSPEC_VMLA
-  UNSPEC_VMLAL
   UNSPEC_VMLA_LANE
-  UNSPEC_VMLAL_LANE
+  UNSPEC_VMLAL_S
+  UNSPEC_VMLAL_U
+  UNSPEC_VMLAL_S_LANE
+  UNSPEC_VMLAL_U_LANE
   UNSPEC_VMLS
-  UNSPEC_VMLSL
   UNSPEC_VMLS_LANE
+  UNSPEC_VMLSL_S
+  UNSPEC_VMLSL_U
+  UNSPEC_VMLSL_S_LANE
+  UNSPEC_VMLSL_U_LANE
   UNSPEC_VMLSL_LANE
-  UNSPEC_VMOVL
+  UNSPEC_VMOVL_S
+  UNSPEC_VMOVL_U
   UNSPEC_VMOVN
   UNSPEC_VMUL
-  UNSPEC_VMULL
+  UNSPEC_VMULL_P
+  UNSPEC_VMULL_S
+  UNSPEC_VMULL_U
   UNSPEC_VMUL_LANE
-  UNSPEC_VMULL_LANE
-  UNSPEC_VPADAL
+  UNSPEC_VMULL_S_LANE
+  UNSPEC_VMULL_U_LANE
+  UNSPEC_VPADAL_S
+  UNSPEC_VPADAL_U
   UNSPEC_VPADD
-  UNSPEC_VPADDL
+  UNSPEC_VPADDL_S
+  UNSPEC_VPADDL_U
   UNSPEC_VPMAX
+  UNSPEC_VPMAX_U
   UNSPEC_VPMIN
+  UNSPEC_VPMIN_U
   UNSPEC_VPSMAX
   UNSPEC_VPSMIN
   UNSPEC_VPUMAX
   UNSPEC_VPUMIN
   UNSPEC_VQABS
-  UNSPEC_VQADD
+  UNSPEC_VQADD_S
+  UNSPEC_VQADD_U
   UNSPEC_VQDMLAL
   UNSPEC_VQDMLAL_LANE
   UNSPEC_VQDMLSL
   UNSPEC_VQDMLSL_LANE
   UNSPEC_VQDMULH
   UNSPEC_VQDMULH_LANE
+  UNSPEC_VQRDMULH
+  UNSPEC_VQRDMULH_LANE
   UNSPEC_VQDMULL
   UNSPEC_VQDMULL_LANE
-  UNSPEC_VQMOVN
+  UNSPEC_VQMOVN_S
+  UNSPEC_VQMOVN_U
   UNSPEC_VQMOVUN
   UNSPEC_VQNEG
-  UNSPEC_VQSHL
-  UNSPEC_VQSHL_N
+  UNSPEC_VQSHL_S
+  UNSPEC_VQSHL_U
+  UNSPEC_VQRSHL_S
+  UNSPEC_VQRSHL_U
+  UNSPEC_VQSHL_S_N
+  UNSPEC_VQSHL_U_N
   UNSPEC_VQSHLU_N
-  UNSPEC_VQSHRN_N
+  UNSPEC_VQSHRN_S_N
+  UNSPEC_VQSHRN_U_N
+  UNSPEC_VQRSHRN_S_N
+  UNSPEC_VQRSHRN_U_N
   UNSPEC_VQSHRUN_N
-  UNSPEC_VQSUB
+  UNSPEC_VQRSHRUN_N
+  UNSPEC_VQSUB_S
+  UNSPEC_VQSUB_U
   UNSPEC_VRECPE
   UNSPEC_VRECPS
   UNSPEC_VREV16
@@ -260,13 +301,24 @@
   UNSPEC_VREV64
   UNSPEC_VRSQRTE
   UNSPEC_VRSQRTS
-  UNSPEC_VSHL
-  UNSPEC_VSHLL_N
+  UNSPEC_VSHL_S
+  UNSPEC_VSHL_U
+  UNSPEC_VRSHL_S
+  UNSPEC_VRSHL_U
+  UNSPEC_VSHLL_S_N
+  UNSPEC_VSHLL_U_N
   UNSPEC_VSHL_N
-  UNSPEC_VSHR_N
+  UNSPEC_VSHR_S_N
+  UNSPEC_VSHR_U_N
+  UNSPEC_VRSHR_S_N
+  UNSPEC_VRSHR_U_N
   UNSPEC_VSHRN_N
+  UNSPEC_VRSHRN_N
   UNSPEC_VSLI
-  UNSPEC_VSRA_N
+  UNSPEC_VSRA_S_N
+  UNSPEC_VSRA_U_N
+  UNSPEC_VRSRA_S_N
+  UNSPEC_VRSRA_U_N
   UNSPEC_VSRI
   UNSPEC_VST1
   UNSPEC_VST1_LANE
@@ -283,8 +335,11 @@
   UNSPEC_VSTRUCTDUMMY
   UNSPEC_VSUB
   UNSPEC_VSUBHN
-  UNSPEC_VSUBL
-  UNSPEC_VSUBW
+  UNSPEC_VRSUBHN
+  UNSPEC_VSUBL_S
+  UNSPEC_VSUBL_U
+  UNSPEC_VSUBW_S
+  UNSPEC_VSUBW_U
   UNSPEC_VTBL
   UNSPEC_VTBX
   UNSPEC_VTRN1
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index fbae34c..c893096 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2014-11-18  James Greenhalgh  <james.greenhalgh@arm.com>
+
+	* gcc.target/arm/pr51968.c (foo): Fix call to
+	__builtin_neon_vqmovunv8hi.
+
 2014-11-18  Marat Zakirov  <m.zakirov@samsung.com>
 
 	* c-c++-common/asan/aggressive-opts.c: New test.
diff --git a/gcc/testsuite/gcc.target/arm/pr51968.c b/gcc/testsuite/gcc.target/arm/pr51968.c
index 6cf802b..99bdb96 100644
--- a/gcc/testsuite/gcc.target/arm/pr51968.c
+++ b/gcc/testsuite/gcc.target/arm/pr51968.c
@@ -24,7 +24,7 @@ foo (int8x8_t z, int8x8_t x, int16x8_t b, int8x8_t n)
       int8x16_t g;
       int8x8_t h, j, k;
       struct T m;
-      j = __builtin_neon_vqmovunv8hi (b, 1);
+      j = __builtin_neon_vqmovunv8hi (b);
       g = __builtin_neon_vcombinev8qi (j, h);
       k = __builtin_neon_vget_lowv16qi (g);
       __builtin_neon_vuzpv8qi (&m.val[0], k, n);