clsq客户端android,Android NDK开发之 arm_neon.h文件ABI说明

这里是官网的指令说明：

http://infocenter.arm.com/help/basic/help.jsp?topic=/com.arm.doc.dui0204ic/

下面是对应arm_neon头文件中，对应的ABI说明。

//后期不断维护更新

//2016_1_5 14:30

#ifndef __ARM_NEON__

#error You must enable NEON instructions (e.g. -mfloat-abi=softfp -mfpu=neon) to use arm_neon.h

#endif

/*(1)、正常指令：生成大小相同且类型通常与操作数向量相同的结果向量；

(2)、长指令：对双字向量操作数执行运算，生成四字向量的结果。所生成的元素一般是操作数元素宽度的两倍，

并属于同一类型；

(3)、宽指令：一个双字向量操作数和一个四字向量操作数执行运算，生成四字向量结果。所生成的元素和第一个

操作数的元素是第二个操作数元素宽度的两倍；

(4)、窄指令：四字向量操作数执行运算，并生成双字向量结果，所生成的元素一般是操作数元素宽度的一半；

(5)、饱和指令：当超过数据类型指定的范围则自动限制在该范围内。*/

/******************************************************Addition*************************/

/*--1、Vector add(正常指令): vadd -> ri = ai + bi; r, a, b have equal lane sizes--*/

int8x8_t vadd_s8 (int8x8_t __a, int8x8_t __b);//_mm_add_epi8

int16x4_t vadd_s16 (int16x4_t __a, int16x4_t __b);//_mm_add_epi16

int32x2_t vadd_s32 (int32x2_t __a, int32x2_t __b);//_mm_add_epi32

int64x1_t vadd_s64 (int64x1_t __a, int64x1_t __b);//_mm_add_epi64

//_mm_add_ps, SSE, use only low 64 bits

float32x2_t vadd_f32 (float32x2_t __a, float32x2_t __b);

uint8x8_t vadd_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_add_epi8

uint16x4_t vadd_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_add_epi16

uint32x2_t vadd_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_add_epi32

uint64x1_t vadd_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_add_epi64

int8x16_t vaddq_s8 (int8x16_t __a, int8x16_t __b);//_mm_add_epi8

int16x8_t vaddq_s16 (int16x8_t __a, int16x8_t __b);//_mm_add_epi16

int32x4_t vaddq_s32 (int32x4_t __a, int32x4_t __b);//_mm_add_epi32

int64x2_t vaddq_s64 (int64x2_t __a, int64x2_t __b);//_mm_add_epi64

float32x4_t vaddq_f32 (float32x4_t __a, float32x4_t __b);//_mm_add_ps

uint8x16_t vaddq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_add_epi8

uint16x8_t vaddq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_add_epi16

uint32x4_t vaddq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_add_epi32

uint64x2_t vaddq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_add_epi64

/*--2、Vector long add(长指令): vaddl -> ri = ai + bi; a, b have equal lane sizes,

result is a 128 bit vector of lanes that are twice the width--*/

int16x8_t vaddl_s8 (int8x8_t __a, int8x8_t __b);

int32x4_t vaddl_s16 (int16x4_t __a, int16x4_t __b);

int64x2_t vaddl_s32 (int32x2_t __a, int32x2_t __b);

uint16x8_t vaddl_u8 (uint8x8_t __a, uint8x8_t __b);

uint32x4_t vaddl_u16 (uint16x4_t __a, uint16x4_t __b);

uint64x2_t vaddl_u32 (uint32x2_t __a, uint32x2_t __b);

/*--3、Vector wide add(宽指令): vaddw -> ri = ai + bi--*/

int16x8_t vaddw_s8 (int16x8_t __a, int8x8_t __b);

int32x4_t vaddw_s16 (int32x4_t __a, int16x4_t __b);

int64x2_t vaddw_s32 (int64x2_t __a, int32x2_t __b);

uint16x8_t vaddw_u8 (uint16x8_t __a, uint8x8_t __b);

uint32x4_t vaddw_u16 (uint32x4_t __a, uint16x4_t __b);

uint64x2_t vaddw_u32 (uint64x2_t __a, uint32x2_t __b);

/*--4、Vector halving add: vhadd -> ri = (ai + bi) >> 1;

shifts each result right one bit, Results are truncated--*/

int8x8_t vhadd_s8 (int8x8_t __a, int8x8_t __b);

int16x4_t vhadd_s16 (int16x4_t __a, int16x4_t __b);

int32x2_t vhadd_s32 (int32x2_t __a, int32x2_t __b);

uint8x8_t vhadd_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vhadd_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vhadd_u32 (uint32x2_t __a, uint32x2_t __b);

int8x16_t vhaddq_s8 (int8x16_t __a, int8x16_t __b);

int16x8_t vhaddq_s16 (int16x8_t __a, int16x8_t __b)

int32x4_t vhaddq_s32 (int32x4_t __a, int32x4_t __b)

uint8x16_t vhaddq_u8 (uint8x16_t __a, uint8x16_t __b)

uint16x8_t vhaddq_u16 (uint16x8_t __a, uint16x8_t __b)

uint32x4_t vhaddq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--5、Vector rounding halving add: vrhadd -> ri = (ai + bi + 1) >> 1;

shifts each result right one bit, Results are rounded(四舍五入)--*/

int8x8_t vrhadd_s8 (int8x8_t __a, int8x8_t __b);

int16x4_t vrhadd_s16 (int16x4_t __a, int16x4_t __b);

int32x2_t vrhadd_s32 (int32x2_t __a, int32x2_t __b);

uint8x8_t vrhadd_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_avg_epu8

uint16x4_t vrhadd_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_avg_epu16

uint32x2_t vrhadd_u32 (uint32x2_t __a, uint32x2_t __b);

int8x16_t vrhaddq_s8 (int8x16_t __a, int8x16_t __b);

int16x8_t vrhaddq_s16 (int16x8_t __a, int16x8_t __b);

int32x4_t vrhaddq_s32 (int32x4_t __a, int32x4_t __b);

uint8x16_t vrhaddq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_avg_epu8

uint16x8_t vrhaddq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_avg_epu16

uint32x4_t vrhaddq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--6、Vector saturating add(饱和指令): vqadd -> ri = sat(ai + bi);

the results are saturated if they overflow--*/

int8x8_t vqadd_s8 (int8x8_t __a, int8x8_t __b);//_mm_adds_epi8

int16x4_t vqadd_s16 (int16x4_t __a, int16x4_t __b);//_mm_adds_epi16

int32x2_t vqadd_s32 (int32x2_t __a, int32x2_t __b);

int64x1_t vqadd_s64 (int64x1_t __a, int64x1_t __b);

uint8x8_t vqadd_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_adds_epu8

uint16x4_t vqadd_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_adds_epu16

uint32x2_t vqadd_u32 (uint32x2_t __a, uint32x2_t __b);

uint64x1_t vqadd_u64 (uint64x1_t __a, uint64x1_t __b);

int8x16_t vqaddq_s8 (int8x16_t __a, int8x16_t __b);//_mm_adds_epi8

int16x8_t vqaddq_s16 (int16x8_t __a, int16x8_t __b);//_mm_adds_epi16

int32x4_t vqaddq_s32 (int32x4_t __a, int32x4_t __b);

int64x2_t vqaddq_s64 (int64x2_t __a, int64x2_t __b);

uint8x16_t vqaddq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_adds_epu8

uint16x8_t vqaddq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_adds_epu16

uint32x4_t vqaddq_u32 (uint32x4_t __a, uint32x4_t __b);

uint64x2_t vqaddq_u64 (uint64x2_t __a, uint64x2_t __b);

/*--7、Vector add high half(窄指令): vaddhn -> ri = sat(ai + bi);

selecting High half, The results are truncated--*/

int8x8_t vaddhn_s16 (int16x8_t __a, int16x8_t __b);

int16x4_t vaddhn_s32 (int32x4_t __a, int32x4_t __b);

int32x2_t vaddhn_s64 (int64x2_t __a, int64x2_t __b);

uint8x8_t vaddhn_u16 (uint16x8_t __a, uint16x8_t __b);

uint16x4_t vaddhn_u32 (uint32x4_t __a, uint32x4_t __b);

uint32x2_t vaddhn_u64 (uint64x2_t __a, uint64x2_t __b);

/*--8、Vector rounding add high half(窄指令): vraddhn -> ri = ai + bi;

selecting High half, The results are rounded--*/

int8x8_t vraddhn_s16 (int16x8_t __a, int16x8_t __b);

int16x4_t vraddhn_s32 (int32x4_t __a, int32x4_t __b)

int32x2_t vraddhn_s64 (int64x2_t __a, int64x2_t __b)

uint8x8_t vraddhn_u16 (uint16x8_t __a, uint16x8_t __b)

uint16x4_t vraddhn_u32 (uint32x4_t __a, uint32x4_t __b)

uint32x2_t vraddhn_u64 (uint64x2_t __a, uint64x2_t __b);

/*******************************************Multiplication******************************/

/*--1、Vector multiply(正常指令): vmul -> ri = ai * bi;--*/

int8x8_t vmul_s8 (int8x8_t __a, int8x8_t __b);

int16x4_t vmul_s16 (int16x4_t __a, int16x4_t __b);//_mm_mullo_epi16

int32x2_t vmul_s32 (int32x2_t __a, int32x2_t __b);

float32x2_t vmul_f32 (float32x2_t __a, float32x2_t __b);//_mm_mul_ps

uint8x8_t vmul_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vmul_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_mullo_epi16

uint32x2_t vmul_u32 (uint32x2_t __a, uint32x2_t __b);

poly8x8_t vmul_p8 (poly8x8_t __a, poly8x8_t __b);

int8x16_t vmulq_s8 (int8x16_t __a, int8x16_t __b);

int16x8_t vmulq_s16 (int16x8_t __a, int16x8_t __b);//_mm_mullo_epi16

int32x4_t vmulq_s32 (int32x4_t __a, int32x4_t __b);

float32x4_t vmulq_f32 (float32x4_t __a, float32x4_t __b);//_mm_mul_ps

uint8x16_t vmulq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vmulq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_mullo_epi16

uint32x4_t vmulq_u32 (uint32x4_t __a, uint32x4_t __b);

poly8x16_t vmulq_p8 (poly8x16_t __a, poly8x16_t __b);

/*--2、Vector multiply accumulate: vmla -> ri = ai + bi * ci; --*/

int8x8_t vmla_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);

int16x4_t vmla_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c);

int32x2_t vmla_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);

float32x2_t vmla_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c);

uint8x8_t vmla_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c);

uint16x4_t vmla_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c);

uint32x2_t vmla_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c);

int8x16_t vmlaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c);

int16x8_t vmlaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c);

int32x4_t vmlaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c);

float32x4_t vmlaq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);

uint8x16_t vmlaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c);

uint16x8_t vmlaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c);

uint32x4_t vmlaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c);

/*--3、Vector multiply accumulate long: vmlal -> ri = ai + bi * ci --*/

int16x8_t vmlal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c);

int32x4_t vmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);

int64x2_t vmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);

uint16x8_t vmlal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c);

uint32x4_t vmlal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c);

uint64x2_t vmlal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c);

/*--4、Vector multiply subtract: vmls -> ri = ai - bi * ci --*/

int8x8_t vmls_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);

int16x4_t vmls_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c);

int32x2_t vmls_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);

float32x2_t vmls_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c);

uint8x8_t vmls_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c);

uint16x4_t vmls_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c);

uint32x2_t vmls_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c);

int8x16_t vmlsq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c);

int16x8_t vmlsq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c);

int32x4_t vmlsq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c);

float32x4_t vmlsq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);

uint8x16_t vmlsq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c);

uint16x8_t vmlsq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c);

uint32x4_t vmlsq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c);

/*--5、Vector multiply subtract long：vmlsl -> ri = ai - bi * ci --*/

int16x8_t vmlsl_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c);

int32x4_t vmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);

int64x2_t vmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);

uint16x8_t vmlsl_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c);

uint32x4_t vmlsl_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c);

uint64x2_t vmlsl_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c);

/*--6、Vector saturating doubling multiply high: vqdmulh -> ri = sat(ai * bi);

doubles the results and returns only the high half of the truncated results--*/

int16x4_t vqdmulh_s16 (int16x4_t __a, int16x4_t __b);

int32x2_t vqdmulh_s32 (int32x2_t __a, int32x2_t __b);

int16x8_t vqdmulhq_s16 (int16x8_t __a, int16x8_t __b);

int32x4_t vqdmulhq_s32 (int32x4_t __a, int32x4_t __b);

/*--7、Vector saturating rounding doubling multiply high vqrdmulh -> ri = ai * bi:

doubles the results and returns only the high half of the rounded results.

The results are saturated if they overflow--*/

int16x4_t vqrdmulh_s16 (int16x4_t __a, int16x4_t __b);

int32x2_t vqrdmulh_s32 (int32x2_t __a, int32x2_t __b);

int16x8_t vqrdmulhq_s16 (int16x8_t __a, int16x8_t __b);

int32x4_t vqrdmulhq_s32 (int32x4_t __a, int32x4_t __b);

/*--8、Vector saturating doubling multiply accumulate long: vqdmlal -> ri = ai + bi * ci;

multiplies the elements in the second and third vectors, doubles the results and adds the

results to the values in the first vector. The results are saturated if they overflow--*/

int32x4_t vqdmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);

int64x2_t vqdmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);

/*--9、Vector saturating doubling multiply subtract long: vqdmlsl -> ri = ai - bi * ci;

multiplies the elements in the second and third vectors, doubles the results and subtracts

the results from the elements in the first vector.

The results are saturated if they overflow--*/

int32x4_t vqdmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);

int64x2_t vqdmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);

/*--10、Vector long multiply(长指令): vmull -> ri = ai * bi;--*/

int16x8_t vmull_s8 (int8x8_t __a, int8x8_t __b);

int32x4_t vmull_s16 (int16x4_t __a, int16x4_t __b);

int64x2_t vmull_s32 (int32x2_t __a, int32x2_t __b);

uint16x8_t vmull_u8 (uint8x8_t __a, uint8x8_t __b);

uint32x4_t vmull_u16 (uint16x4_t __a, uint16x4_t __b);

uint64x2_t vmull_u32 (uint32x2_t __a, uint32x2_t __b);

poly16x8_t vmull_p8 (poly8x8_t __a, poly8x8_t __b);

/*--11、Vector saturating doubling long multiply: vqdmull -> ri = ai * bi;

If any of the results overflow, they are saturated--*/

int32x4_t vqdmull_s16 (int16x4_t __a, int16x4_t __b);

int64x2_t vqdmull_s32 (int32x2_t __a, int32x2_t __b);

/*--12、Fused multiply accumulate: vfma -> ri = ai + bi * ci;

The result of the multiply is not rounded before the accumulation--*/

float32x2_t vfma_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)

float32x4_t vfmaq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);

/*--13、Fused multiply subtract: vfms -> ri = ai - bi * ci;

The result of the multiply is not rounded before the subtraction--*/

float32x2_t vfms_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c);

float32x4_t vfmsq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);

/******************************************************Round to integral****************/

/*--1、to nearest, ties to even--*/

float32x2_t vrndn_f32 (float32x2_t __a);

float32x4_t vrndqn_f32 (float32x4_t __a);

/*--2、to nearest, ties away from zero--*/

float32x2_t vrnda_f32 (float32x2_t __a);

float32x4_t vrndqa_f32 (float32x4_t __a);

/*--3、towards +Inf--*/

float32x2_t vrndp_f32 (float32x2_t __a);

float32x4_t vrndqp_f32 (float32x4_t __a);

/*--4、towards -Inf--*/

float32x2_t vrndm_f32 (float32x2_t __a);

float32x4_t vrndqm_f32 (float32x4_t __a);

/*--5、towards 0--*/

float32x2_t vrnd_f32 (float32x2_t __a);

float32x4_t vrndq_f32 (float32x4_t __a);

/**********************************************Subtraction******************************/

/*--1、Vector subtract(正常指令):vsub -> ri = ai - bi;--*/

int8x8_t vsub_s8 (int8x8_t __a, int8x8_t __b);//_mm_sub_epi8

int16x4_t vsub_s16 (int16x4_t __a, int16x4_t __b);//_mm_sub_epi16

int32x2_t vsub_s32 (int32x2_t __a, int32x2_t __b);//_mm_sub_epi32

int64x1_t vsub_s64 (int64x1_t __a, int64x1_t __b);//_mm_sub_epi64

float32x2_t vsub_f32 (float32x2_t __a, float32x2_t __b);//_mm_sub_ps

uint8x8_t vsub_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_sub_epi8

uint16x4_t vsub_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_sub_epi16

uint32x2_t vsub_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_sub_epi32

uint64x1_t vsub_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_sub_epi64

int8x16_t vsubq_s8 (int8x16_t __a, int8x16_t __b);//_mm_sub_epi8

int16x8_t vsubq_s16 (int16x8_t __a, int16x8_t __b);//_mm_sub_epi16

int32x4_t vsubq_s32 (int32x4_t __a, int32x4_t __b);//_mm_sub_epi32

int64x2_t vsubq_s64 (int64x2_t __a, int64x2_t __b);//_mm_sub_epi64

float32x4_t vsubq_f32 (float32x4_t __a, float32x4_t __b);//_mm_sub_ps

uint8x16_t vsubq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_sub_epi8

uint16x8_t vsubq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_sub_epi16

uint32x4_t vsubq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_sub_epi32

uint64x2_t vsubq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_sub_epi64

/*--2、Vector long subtract(长指令): vsubl -> ri = ai - bi; --*/

int16x8_t vsubl_s8 (int8x8_t __a, int8x8_t __b);

int32x4_t vsubl_s16 (int16x4_t __a, int16x4_t __b);

int64x2_t vsubl_s32 (int32x2_t __a, int32x2_t __b);

uint16x8_t vsubl_u8 (uint8x8_t __a, uint8x8_t __b);

uint32x4_t vsubl_u16 (uint16x4_t __a, uint16x4_t __b);

uint64x2_t vsubl_u32 (uint32x2_t __a, uint32x2_t __b);

/*--3、Vector wide subtract(宽指令): vsubw -> ri = ai - bi;--*/

int16x8_t vsubw_s8 (int16x8_t __a, int8x8_t __b);

int32x4_t vsubw_s16 (int32x4_t __a, int16x4_t __b);

int64x2_t vsubw_s32 (int64x2_t __a, int32x2_t __b);

uint16x8_t vsubw_u8 (uint16x8_t __a, uint8x8_t __b);

uint32x4_t vsubw_u16 (uint32x4_t __a, uint16x4_t __b);

uint64x2_t vsubw_u32 (uint64x2_t __a, uint32x2_t __b);

/*--4、Vector saturating subtract(饱和指令): vqsub -> ri = sat(ai - bi);

If any of the results overflow, they are saturated--*/

int8x8_t vqsub_s8 (int8x8_t __a, int8x8_t __b);//_mm_subs_epi8

int16x4_t vqsub_s16 (int16x4_t __a, int16x4_t __b);//_mm_subs_epi16

int32x2_t vqsub_s32 (int32x2_t __a, int32x2_t __b);//_mm_subs_epi32

int64x1_t vqsub_s64 (int64x1_t __a, int64x1_t __b);

uint8x8_t vqsub_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_subs_epu8

uint16x4_t vqsub_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_subs_epu16

uint32x2_t vqsub_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_subs_epu32

uint64x1_t vqsub_u64 (uint64x1_t __a, uint64x1_t __b);

int8x16_t vqsubq_s8 (int8x16_t __a, int8x16_t __b);//_mm_subs_epi8

int16x8_t vqsubq_s16 (int16x8_t __a, int16x8_t __b);//_mm_subs_epi16

int32x4_t vqsubq_s32 (int32x4_t __a, int32x4_t __b);//_mm_subs_epi32

int64x2_t vqsubq_s64 (int64x2_t __a, int64x2_t __b);

uint8x16_t vqsubq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_subs_epu8

uint16x8_t vqsubq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_subs_epu16

uint32x4_t vqsubq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_subs_epu32

uint64x2_t vqsubq_u64 (uint64x2_t __a, uint64x2_t __b);

/*--5、Vector halving subtract: vhsub -> ri = (ai - bi) >> 1;

shifts each result right one bit, The results are truncated.--*/

int8x8_t vhsub_s8 (int8x8_t __a, int8x8_t __b);

int16x4_t vhsub_s16 (int16x4_t __a, int16x4_t __b);

int32x2_t vhsub_s32 (int32x2_t __a, int32x2_t __b);

uint8x8_t vhsub_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vhsub_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vhsub_u32 (uint32x2_t __a, uint32x2_t __b);

int8x16_t vhsubq_s8 (int8x16_t __a, int8x16_t __b);

int16x8_t vhsubq_s16 (int16x8_t __a, int16x8_t __b);

int32x4_t vhsubq_s32 (int32x4_t __a, int32x4_t __b);

uint8x16_t vhsubq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vhsubq_u16 (uint16x8_t __a, uint16x8_t __b);

uint32x4_t vhsubq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--6、Vector subtract high half(窄指令): vsubhn -> ri = ai - bi;

It returns the most significant halves of the results. The results are truncated--*/

int8x8_t vsubhn_s16 (int16x8_t __a, int16x8_t __b);

int16x4_t vsubhn_s32 (int32x4_t __a, int32x4_t __b);

int32x2_t vsubhn_s64 (int64x2_t __a, int64x2_t __b);

uint8x8_t vsubhn_u16 (uint16x8_t __a, uint16x8_t __b);

uint16x4_t vsubhn_u32 (uint32x4_t __a, uint32x4_t __b);

uint32x2_t vsubhn_u64 (uint64x2_t __a, uint64x2_t __b);

/*--7、Vector rounding subtract high half(窄指令): vrsubhn -> ai - bi;

It returns the most significant halves of the results. The results are rounded--*/

int8x8_t vrsubhn_s16 (int16x8_t __a, int16x8_t __b);

int16x4_t vrsubhn_s32 (int32x4_t __a, int32x4_t __b);

int32x2_t vrsubhn_s64 (int64x2_t __a, int64x2_t __b)

uint8x8_t vrsubhn_u16 (uint16x8_t __a, uint16x8_t __b);

uint16x4_t vrsubhn_u32 (uint32x4_t __a, uint32x4_t __b);

uint32x2_t vrsubhn_u64 (uint64x2_t __a, uint64x2_t __b);

/******************************************************Comparison***********************/

/*--1、Vector compare equal(正常指令): vceq -> ri = ai == bi ? 1...1 : 0...0;

If they are equal, the corresponding element in the destination vector is set to all ones.

Otherwise, it is set to all zeros--*/

uint8x8_t vceq_s8 (int8x8_t __a, int8x8_t __b);//_mm_cmpeq_epi8

uint16x4_t vceq_s16 (int16x4_t __a, int16x4_t __b);//_mm_cmpeq_epi16

uint32x2_t vceq_s32 (int32x2_t __a, int32x2_t __b);//_mm_cmpeq_epi32

uint32x2_t vceq_f32 (float32x2_t __a, float32x2_t __b);

uint8x8_t vceq_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_cmpeq_epi8

uint16x4_t vceq_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_cmpeq_epi16

uint32x2_t vceq_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_cmpeq_epi32

uint8x8_t vceq_p8 (poly8x8_t __a, poly8x8_t __b);//_mm_cmpeq_epi8

uint8x16_t vceqq_s8 (int8x16_t __a, int8x16_t __b);//_mm_cmpeq_epi8

uint16x8_t vceqq_s16 (int16x8_t __a, int16x8_t __b);//_mm_cmpeq_epi16

uint32x4_t vceqq_s32 (int32x4_t __a, int32x4_t __b);//_mm_cmpeq_epi32

uint32x4_t vceqq_f32 (float32x4_t __a, float32x4_t __b);

uint8x16_t vceqq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_cmpeq_epi8

uint16x8_t vceqq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_cmpeq_epi16

uint32x4_t vceqq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_cmpeq_epi32

uint8x16_t vceqq_p8 (poly8x16_t __a, poly8x16_t __b);//_mm_cmpeq_epi8

/*--2、Vector compare greater-than or equal(正常指令): vcge-> ri = ai >= bi ? 1...1:0...0;

If it is greater than or equal to it, the corresponding element in the destination

vector is set to all ones. Otherwise, it is set to all zeros.--*/

uint8x8_t vcge_s8 (int8x8_t __a, int8x8_t __b);

uint16x4_t vcge_s16 (int16x4_t __a, int16x4_t __b);

uint32x2_t vcge_s32 (int32x2_t __a, int32x2_t __b);

uint32x2_t vcge_f32 (float32x2_t __a, float32x2_t __b);

uint8x8_t vcge_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vcge_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vcge_u32 (uint32x2_t __a, uint32x2_t __b);

uint8x16_t vcgeq_s8 (int8x16_t __a, int8x16_t __b);

uint16x8_t vcgeq_s16 (int16x8_t __a, int16x8_t __b);

uint32x4_t vcgeq_s32 (int32x4_t __a, int32x4_t __b);

uint32x4_t vcgeq_f32 (float32x4_t __a, float32x4_t __b);

uint8x16_t vcgeq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vcgeq_u16 (uint16x8_t __a, uint16x8_t __b);

uint32x4_t vcgeq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--3、Vector compare less-than or equal(正常指令): vcle -> ri = ai <= bi ? 1...1:0...0;

If it is less than or equal to it, the corresponding element in the destination vector

is set to all ones. Otherwise, it is set to all zeros.--*/

uint8x8_t vcle_s8 (int8x8_t __a, int8x8_t __b);

uint16x4_t vcle_s16 (int16x4_t __a, int16x4_t __b);

uint32x2_t vcle_s32 (int32x2_t __a, int32x2_t __b);

uint32x2_t vcle_f32 (float32x2_t __a, float32x2_t __b);

uint8x8_t vcle_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vcle_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vcle_u32 (uint32x2_t __a, uint32x2_t __b);

uint8x16_t vcleq_s8 (int8x16_t __a, int8x16_t __b);

uint16x8_t vcleq_s16 (int16x8_t __a, int16x8_t __b);

uint32x4_t vcleq_s32 (int32x4_t __a, int32x4_t __b);

uint32x4_t vcleq_f32 (float32x4_t __a, float32x4_t __b);

uint8x16_t vcleq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vcleq_u16 (uint16x8_t __a, uint16x8_t __b);

uint32x4_t vcleq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--4、Vector compare greater-than(正常指令): vcgt -> ri = ai > bi ? 1...1:0...0;

If it is greater than it, the corresponding element in the destination vector is

set to all ones. Otherwise, it is set to all zeros--*/

uint8x8_t vcgt_s8 (int8x8_t __a, int8x8_t __b);

uint16x4_t vcgt_s16 (int16x4_t __a, int16x4_t __b);

uint32x2_t vcgt_s32 (int32x2_t __a, int32x2_t __b);

uint32x2_t vcgt_f32 (float32x2_t __a, float32x2_t __b);

uint8x8_t vcgt_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vcgt_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vcgt_u32 (uint32x2_t __a, uint32x2_t __b);

uint8x16_t vcgtq_s8 (int8x16_t __a, int8x16_t __b);

uint16x8_t vcgtq_s16 (int16x8_t __a, int16x8_t __b);

uint32x4_t vcgtq_s32 (int32x4_t __a, int32x4_t __b);

uint32x4_t vcgtq_f32 (float32x4_t __a, float32x4_t __b);

uint8x16_t vcgtq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vcgtq_u16 (uint16x8_t __a, uint16x8_t __b);

uint32x4_t vcgtq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--5、Vector compare less-than(正常指令): vclt -> ri = ai < bi ? 1...1:0...0;

If it is less than it, the corresponding element in the destination vector is set

to all ones.Otherwise, it is set to all zeros--*/

uint8x8_t vclt_s8 (int8x8_t __a, int8x8_t __b);

uint16x4_t vclt_s16 (int16x4_t __a, int16x4_t __b);

uint32x2_t vclt_s32 (int32x2_t __a, int32x2_t __b);

uint32x2_t vclt_f32 (float32x2_t __a, float32x2_t __b);

uint8x8_t vclt_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vclt_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vclt_u32 (uint32x2_t __a, uint32x2_t __b);

uint8x16_t vcltq_s8 (int8x16_t __a, int8x16_t __b);

uint16x8_t vcltq_s16 (int16x8_t __a, int16x8_t __b);

uint32x4_t vcltq_s32 (int32x4_t __a, int32x4_t __b);

uint32x4_t vcltq_f32 (float32x4_t __a, float32x4_t __b);

uint8x16_t vcltq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vcltq_u16 (uint16x8_t __a, uint16x8_t __b);

uint32x4_t vcltq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--6、Vector compare absolute greater-than or equal(正常指令):

vcage -> ri = |ai| >= |bi| ? 1...1:0...0;

compares the absolute value of each element in a vector with the absolute value of the

corresponding element of a second vector. If it is greater than or equal to it,

the corresponding element in the destination vector is set to all ones.

Otherwise, it is set to all zeros.--*/

uint32x2_t vcage_f32 (float32x2_t __a, float32x2_t __b);

uint32x4_t vcageq_f32 (float32x4_t __a, float32x4_t __b);

/*--7、Vector compare absolute less-than or equal(正常指令):

vcale -> ri = |ai| <= |bi| ? 1...1:0...0;

compares the absolute value of each element in a vector with the absolute value of the

corresponding element of a second vector. If it is less than or equal to it,

the corresponding element in the destination vector is set to all ones.

Otherwise, it is set to all zeros--*/

uint32x2_t vcale_f32 (float32x2_t __a, float32x2_t __b);

uint32x4_t vcaleq_f32 (float32x4_t __a, float32x4_t __b);

/*--8、Vector compare absolute greater-than(正常指令):

vcage -> ri = |ai| > |bi| ? 1...1:0...0;

compares the absolute value of each element in a vector with the absolute value of the

corresponding element of a second vector. If it is greater than it,

the corresponding element in the destination vector is set to all ones.

Otherwise, it is set to all zeros.--*/

uint32x2_t vcagt_f32 (float32x2_t __a, float32x2_t __b);

uint32x4_t vcagtq_f32 (float32x4_t __a, float32x4_t __b);

/*--9、Vector compare absolute less-than(正常指令):

vcalt -> ri = |ai| < |bi| ? 1...1:0...0;

compares the absolute value of each element in a vector with the absolute value of the

corresponding element of a second vector.If it is less than it, the corresponding

element in the destination vector is set to all ones. Otherwise,it is set to all zeros--*/

uint32x2_t vcalt_f32 (float32x2_t __a, float32x2_t __b);

uint32x4_t vcaltq_f32 (float32x4_t __a, float32x4_t __b);

/**********************************************Vector test bits*************************/

/*--正常指令，vtst -> ri = (ai & bi != 0) ? 1...1:0...0;

bitwise logical ANDs each element in a vector with the corresponding element of a second

vector.If the result is not zero, the corresponding element in the destination vector

is set to all ones. Otherwise, it is set to all zeros--*/

uint8x8_t vtst_s8 (int8x8_t __a, int8x8_t __b);

uint16x4_t vtst_s16 (int16x4_t __a, int16x4_t __b);

uint32x2_t vtst_s32 (int32x2_t __a, int32x2_t __b);

uint8x8_t vtst_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vtst_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vtst_u32 (uint32x2_t __a, uint32x2_t __b);

uint8x8_t vtst_p8 (poly8x8_t __a, poly8x8_t __b);

uint8x16_t vtstq_s8 (int8x16_t __a, int8x16_t __b);

uint16x8_t vtstq_s16 (int16x8_t __a, int16x8_t __b);

uint32x4_t vtstq_s32 (int32x4_t __a, int32x4_t __b);

uint8x16_t vtstq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vtstq_u16 (uint16x8_t __a, uint16x8_t __b);

uint32x4_t vtstq_u32 (uint32x4_t __a, uint32x4_t __b);

uint8x16_t vtstq_p8 (poly8x16_t __a, poly8x16_t __b);

/**********************************************Absolute difference**********************/

/*--1、Absolute difference between the arguments(正常指令): vabd -> ri = |ai - bi|;

returns the absolute values of the results--*/

int8x8_t vabd_s8 (int8x8_t __a, int8x8_t __b);

int16x4_t vabd_s16 (int16x4_t __a, int16x4_t __b);

int32x2_t vabd_s32 (int32x2_t __a, int32x2_t __b);

float32x2_t vabd_f32 (float32x2_t __a, float32x2_t __b);

uint8x8_t vabd_u8 (uint8x8_t __a, uint8x8_t __b);

uint16x4_t vabd_u16 (uint16x4_t __a, uint16x4_t __b);

uint32x2_t vabd_u32 (uint32x2_t __a, uint32x2_t __b);

int8x16_t vabdq_s8 (int8x16_t __a, int8x16_t __b);

int16x8_t vabdq_s16 (int16x8_t __a, int16x8_t __b);

int32x4_t vabdq_s32 (int32x4_t __a, int32x4_t __b);

float32x4_t vabdq_f32 (float32x4_t __a, float32x4_t __b);

uint8x16_t vabdq_u8 (uint8x16_t __a, uint8x16_t __b);

uint16x8_t vabdq_u16 (uint16x8_t __a, uint16x8_t __b);

uint32x4_t vabdq_u32 (uint32x4_t __a, uint32x4_t __b);

/*--2、Absolute difference - long(长指令): vabdl -> ri = |ai - bi|;

The elements in the result vector are wider--*/

int16x8_t vabdl_s8 (int8x8_t __a, int8x8_t __b);

int32x4_t vabdl_s16 (int16x4_t __a, int16x4_t __b);

int64x2_t vabdl_s32 (int32x2_t __a, int32x2_t __b);

uint16x8_t vabdl_u8 (uint8x8_t __a, uint8x8_t __b);

uint32x4_t vabdl_u16 (uint16x4_t __a, uint16x4_t __b);

uint64x2_t vabdl_u32 (uint32x2_t __a, uint32x2_t __b);

/*--3、Absolute difference and accumulate: vaba -> ri = ai + |bi - ci|;--*/

int8x8_t vaba_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);

int16x4_t vaba_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c);

int32x2_t vaba_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);

uint8x8_t vaba_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c);

uint16x4_t vaba_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c);

uint32x2_t vaba_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c);

int8x16_t vabaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __