| // RUN: %clang_cc1 -triple thumbv7s-apple-darwin -target-abi apcs-gnu\ |
| // RUN: -target-cpu swift -ffreestanding -Os -S -o - %s\ |
| // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SWIFT |
| // RUN: %clang_cc1 -triple armv8-linux-gnu \ |
| // RUN: -target-cpu cortex-a57 -mfloat-abi soft -ffreestanding -Os -S -o - %s\ |
| // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-A57 |
| |
| // REQUIRES: long_tests |
| |
| #include <arm_neon.h> |
| |
| // CHECK-LABEL: test_vaba_s8 |
| // CHECK: vaba.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vaba_s8(int8x8_t a, int8x8_t b, int8x8_t c) { |
| return vaba_s8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vaba_s16 |
| // CHECK: vaba.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vaba_s16(int16x4_t a, int16x4_t b, int16x4_t c) { |
| return vaba_s16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vaba_s32 |
| // CHECK: vaba.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vaba_s32(int32x2_t a, int32x2_t b, int32x2_t c) { |
| return vaba_s32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vaba_u8 |
| // CHECK: vaba.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vaba_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { |
| return vaba_u8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vaba_u16 |
| // CHECK: vaba.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vaba_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { |
| return vaba_u16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vaba_u32 |
| // CHECK: vaba.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vaba_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { |
| return vaba_u32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabaq_s8 |
| // CHECK: vaba.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vabaq_s8(int8x16_t a, int8x16_t b, int8x16_t c) { |
| return vabaq_s8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabaq_s16 |
| // CHECK: vaba.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vabaq_s16(int16x8_t a, int16x8_t b, int16x8_t c) { |
| return vabaq_s16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabaq_s32 |
| // CHECK: vaba.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vabaq_s32(int32x4_t a, int32x4_t b, int32x4_t c) { |
| return vabaq_s32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabaq_u8 |
| // CHECK: vaba.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vabaq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { |
| return vabaq_u8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabaq_u16 |
| // CHECK: vaba.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vabaq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { |
| return vabaq_u16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabaq_u32 |
| // CHECK: vaba.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vabaq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { |
| return vabaq_u32(a, b, c); |
| } |
| |
| |
| // CHECK-LABEL: test_vabal_s8 |
| // CHECK: vabal.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x8_t test_vabal_s8(int16x8_t a, int8x8_t b, int8x8_t c) { |
| return vabal_s8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabal_s16 |
| // CHECK: vabal.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x4_t test_vabal_s16(int32x4_t a, int16x4_t b, int16x4_t c) { |
| return vabal_s16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabal_s32 |
| // CHECK: vabal.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x2_t test_vabal_s32(int64x2_t a, int32x2_t b, int32x2_t c) { |
| return vabal_s32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabal_u8 |
| // CHECK: vabal.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x8_t test_vabal_u8(uint16x8_t a, uint8x8_t b, uint8x8_t c) { |
| return vabal_u8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabal_u16 |
| // CHECK: vabal.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x4_t test_vabal_u16(uint32x4_t a, uint16x4_t b, uint16x4_t c) { |
| return vabal_u16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vabal_u32 |
| // CHECK: vabal.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x2_t test_vabal_u32(uint64x2_t a, uint32x2_t b, uint32x2_t c) { |
| return vabal_u32(a, b, c); |
| } |
| |
| |
| // CHECK-LABEL: test_vabd_s8 |
| // CHECK: vabd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vabd_s8(int8x8_t a, int8x8_t b) { |
| return vabd_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabd_s16 |
| // CHECK: vabd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vabd_s16(int16x4_t a, int16x4_t b) { |
| return vabd_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabd_s32 |
| // CHECK: vabd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vabd_s32(int32x2_t a, int32x2_t b) { |
| return vabd_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabd_u8 |
| // CHECK: vabd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vabd_u8(uint8x8_t a, uint8x8_t b) { |
| return vabd_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabd_u16 |
| // CHECK: vabd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vabd_u16(uint16x4_t a, uint16x4_t b) { |
| return vabd_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabd_u32 |
| // CHECK: vabd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vabd_u32(uint32x2_t a, uint32x2_t b) { |
| return vabd_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabd_f32 |
| // CHECK: vabd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| float32x2_t test_vabd_f32(float32x2_t a, float32x2_t b) { |
| return vabd_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdq_s8 |
| // CHECK: vabd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vabdq_s8(int8x16_t a, int8x16_t b) { |
| return vabdq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdq_s16 |
| // CHECK: vabd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vabdq_s16(int16x8_t a, int16x8_t b) { |
| return vabdq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdq_s32 |
| // CHECK: vabd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vabdq_s32(int32x4_t a, int32x4_t b) { |
| return vabdq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdq_u8 |
| // CHECK: vabd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vabdq_u8(uint8x16_t a, uint8x16_t b) { |
| return vabdq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdq_u16 |
| // CHECK: vabd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vabdq_u16(uint16x8_t a, uint16x8_t b) { |
| return vabdq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdq_u32 |
| // CHECK: vabd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vabdq_u32(uint32x4_t a, uint32x4_t b) { |
| return vabdq_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdq_f32 |
| // CHECK: vabd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| float32x4_t test_vabdq_f32(float32x4_t a, float32x4_t b) { |
| return vabdq_f32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vabdl_s8 |
| // CHECK: vabdl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x8_t test_vabdl_s8(int8x8_t a, int8x8_t b) { |
| return vabdl_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdl_s16 |
| // CHECK: vabdl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x4_t test_vabdl_s16(int16x4_t a, int16x4_t b) { |
| return vabdl_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdl_s32 |
| // CHECK: vabdl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x2_t test_vabdl_s32(int32x2_t a, int32x2_t b) { |
| return vabdl_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdl_u8 |
| // CHECK: vabdl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x8_t test_vabdl_u8(uint8x8_t a, uint8x8_t b) { |
| return vabdl_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdl_u16 |
| // CHECK: vabdl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x4_t test_vabdl_u16(uint16x4_t a, uint16x4_t b) { |
| return vabdl_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vabdl_u32 |
| // CHECK: vabdl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x2_t test_vabdl_u32(uint32x2_t a, uint32x2_t b) { |
| return vabdl_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vabs_s8 |
| // CHECK: vabs.s8 d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vabs_s8(int8x8_t a) { |
| return vabs_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vabs_s16 |
| // CHECK: vabs.s16 d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vabs_s16(int16x4_t a) { |
| return vabs_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vabs_s32 |
| // CHECK: vabs.s32 d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vabs_s32(int32x2_t a) { |
| return vabs_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vabs_f32 |
| // CHECK: vabs.f32 d{{[0-9]+}}, d{{[0-9]+}} |
| float32x2_t test_vabs_f32(float32x2_t a) { |
| return vabs_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vabsq_s8 |
| // CHECK: vabs.s8 q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vabsq_s8(int8x16_t a) { |
| return vabsq_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vabsq_s16 |
| // CHECK: vabs.s16 q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vabsq_s16(int16x8_t a) { |
| return vabsq_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vabsq_s32 |
| // CHECK: vabs.s32 q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vabsq_s32(int32x4_t a) { |
| return vabsq_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vabsq_f32 |
| // CHECK: vabs.f32 q{{[0-9]+}}, q{{[0-9]+}} |
| float32x4_t test_vabsq_f32(float32x4_t a) { |
| return vabsq_f32(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vadd_s8 |
| // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vadd_s8(int8x8_t a, int8x8_t b) { |
| return vadd_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_s16 |
| // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vadd_s16(int16x4_t a, int16x4_t b) { |
| return vadd_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_s32 |
| // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vadd_s32(int32x2_t a, int32x2_t b) { |
| return vadd_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_s64 |
| // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x1_t test_vadd_s64(int64x1_t a, int64x1_t b) { |
| return vadd_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_f32 |
| // CHECK: vadd.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| float32x2_t test_vadd_f32(float32x2_t a, float32x2_t b) { |
| return vadd_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_u8 |
| // CHECK: vadd.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vadd_u8(uint8x8_t a, uint8x8_t b) { |
| return vadd_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_u16 |
| // CHECK: vadd.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vadd_u16(uint16x4_t a, uint16x4_t b) { |
| return vadd_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_u32 |
| // CHECK: vadd.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vadd_u32(uint32x2_t a, uint32x2_t b) { |
| return vadd_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vadd_u64 |
| // CHECK: vadd.i64 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x1_t test_vadd_u64(uint64x1_t a, uint64x1_t b) { |
| return vadd_u64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_s8 |
| // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vaddq_s8(int8x16_t a, int8x16_t b) { |
| return vaddq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_s16 |
| // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vaddq_s16(int16x8_t a, int16x8_t b) { |
| return vaddq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_s32 |
| // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vaddq_s32(int32x4_t a, int32x4_t b) { |
| return vaddq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_s64 |
| // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int64x2_t test_vaddq_s64(int64x2_t a, int64x2_t b) { |
| return vaddq_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_f32 |
| // CHECK: vadd.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| float32x4_t test_vaddq_f32(float32x4_t a, float32x4_t b) { |
| return vaddq_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_u8 |
| // CHECK: vadd.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vaddq_u8(uint8x16_t a, uint8x16_t b) { |
| return vaddq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_u16 |
| // CHECK: vadd.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vaddq_u16(uint16x8_t a, uint16x8_t b) { |
| return vaddq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_u32 |
| // CHECK: vadd.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vaddq_u32(uint32x4_t a, uint32x4_t b) { |
| return vaddq_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddq_u64 |
| // CHECK: vadd.i64 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint64x2_t test_vaddq_u64(uint64x2_t a, uint64x2_t b) { |
| return vaddq_u64(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vaddhn_s16 |
| // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x8_t test_vaddhn_s16(int16x8_t a, int16x8_t b) { |
| return vaddhn_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddhn_s32 |
| // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x4_t test_vaddhn_s32(int32x4_t a, int32x4_t b) { |
| return vaddhn_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddhn_s64 |
| // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x2_t test_vaddhn_s64(int64x2_t a, int64x2_t b) { |
| return vaddhn_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddhn_u16 |
| // CHECK: vaddhn.i16 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x8_t test_vaddhn_u16(uint16x8_t a, uint16x8_t b) { |
| return vaddhn_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddhn_u32 |
| // CHECK: vaddhn.i32 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x4_t test_vaddhn_u32(uint32x4_t a, uint32x4_t b) { |
| return vaddhn_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddhn_u64 |
| // CHECK: vaddhn.i64 d{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x2_t test_vaddhn_u64(uint64x2_t a, uint64x2_t b) { |
| return vaddhn_u64(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vaddl_s8 |
| // CHECK: vaddl.s8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x8_t test_vaddl_s8(int8x8_t a, int8x8_t b) { |
| return vaddl_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddl_s16 |
| // CHECK: vaddl.s16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x4_t test_vaddl_s16(int16x4_t a, int16x4_t b) { |
| return vaddl_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddl_s32 |
| // CHECK: vaddl.s32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x2_t test_vaddl_s32(int32x2_t a, int32x2_t b) { |
| return vaddl_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddl_u8 |
| // CHECK: vaddl.u8 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x8_t test_vaddl_u8(uint8x8_t a, uint8x8_t b) { |
| return vaddl_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddl_u16 |
| // CHECK: vaddl.u16 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x4_t test_vaddl_u16(uint16x4_t a, uint16x4_t b) { |
| return vaddl_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddl_u32 |
| // CHECK: vaddl.u32 q{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x2_t test_vaddl_u32(uint32x2_t a, uint32x2_t b) { |
| return vaddl_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vaddw_s8 |
| // CHECK: vaddw.s8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} |
| int16x8_t test_vaddw_s8(int16x8_t a, int8x8_t b) { |
| return vaddw_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddw_s16 |
| // CHECK: vaddw.s16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} |
| int32x4_t test_vaddw_s16(int32x4_t a, int16x4_t b) { |
| return vaddw_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddw_s32 |
| // CHECK: vaddw.s32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} |
| int64x2_t test_vaddw_s32(int64x2_t a, int32x2_t b) { |
| return vaddw_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddw_u8 |
| // CHECK: vaddw.u8 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} |
| uint16x8_t test_vaddw_u8(uint16x8_t a, uint8x8_t b) { |
| return vaddw_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddw_u16 |
| // CHECK: vaddw.u16 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} |
| uint32x4_t test_vaddw_u16(uint32x4_t a, uint16x4_t b) { |
| return vaddw_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vaddw_u32 |
| // CHECK: vaddw.u32 q{{[0-9]+}}, q{{[0-9]+}}, d{{[0-9]+}} |
| uint64x2_t test_vaddw_u32(uint64x2_t a, uint32x2_t b) { |
| return vaddw_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vand_s8 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vand_s8(int8x8_t a, int8x8_t b) { |
| return vand_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vand_s16 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vand_s16(int16x4_t a, int16x4_t b) { |
| return vand_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vand_s32 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vand_s32(int32x2_t a, int32x2_t b) { |
| return vand_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vand_s64 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x1_t test_vand_s64(int64x1_t a, int64x1_t b) { |
| return vand_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vand_u8 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vand_u8(uint8x8_t a, uint8x8_t b) { |
| return vand_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vand_u16 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vand_u16(uint16x4_t a, uint16x4_t b) { |
| return vand_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vand_u32 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vand_u32(uint32x2_t a, uint32x2_t b) { |
| return vand_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vand_u64 |
| // CHECK: vand d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x1_t test_vand_u64(uint64x1_t a, uint64x1_t b) { |
| return vand_u64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_s8 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vandq_s8(int8x16_t a, int8x16_t b) { |
| return vandq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_s16 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vandq_s16(int16x8_t a, int16x8_t b) { |
| return vandq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_s32 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vandq_s32(int32x4_t a, int32x4_t b) { |
| return vandq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_s64 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int64x2_t test_vandq_s64(int64x2_t a, int64x2_t b) { |
| return vandq_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_u8 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vandq_u8(uint8x16_t a, uint8x16_t b) { |
| return vandq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_u16 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vandq_u16(uint16x8_t a, uint16x8_t b) { |
| return vandq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_u32 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vandq_u32(uint32x4_t a, uint32x4_t b) { |
| return vandq_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vandq_u64 |
| // CHECK: vand q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint64x2_t test_vandq_u64(uint64x2_t a, uint64x2_t b) { |
| return vandq_u64(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vbic_s8 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vbic_s8(int8x8_t a, int8x8_t b) { |
| return vbic_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbic_s16 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vbic_s16(int16x4_t a, int16x4_t b) { |
| return vbic_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbic_s32 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vbic_s32(int32x2_t a, int32x2_t b) { |
| return vbic_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbic_s64 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x1_t test_vbic_s64(int64x1_t a, int64x1_t b) { |
| return vbic_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbic_u8 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vbic_u8(uint8x8_t a, uint8x8_t b) { |
| return vbic_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbic_u16 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vbic_u16(uint16x4_t a, uint16x4_t b) { |
| return vbic_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbic_u32 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vbic_u32(uint32x2_t a, uint32x2_t b) { |
| return vbic_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbic_u64 |
| // CHECK: vbic d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x1_t test_vbic_u64(uint64x1_t a, uint64x1_t b) { |
| return vbic_u64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_s8 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vbicq_s8(int8x16_t a, int8x16_t b) { |
| return vbicq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_s16 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vbicq_s16(int16x8_t a, int16x8_t b) { |
| return vbicq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_s32 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vbicq_s32(int32x4_t a, int32x4_t b) { |
| return vbicq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_s64 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int64x2_t test_vbicq_s64(int64x2_t a, int64x2_t b) { |
| return vbicq_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_u8 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vbicq_u8(uint8x16_t a, uint8x16_t b) { |
| return vbicq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_u16 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vbicq_u16(uint16x8_t a, uint16x8_t b) { |
| return vbicq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_u32 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vbicq_u32(uint32x4_t a, uint32x4_t b) { |
| return vbicq_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vbicq_u64 |
| // CHECK: vbic q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint64x2_t test_vbicq_u64(uint64x2_t a, uint64x2_t b) { |
| return vbicq_u64(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vbsl_s8 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vbsl_s8(uint8x8_t a, int8x8_t b, int8x8_t c) { |
| return vbsl_s8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_s16 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vbsl_s16(uint16x4_t a, int16x4_t b, int16x4_t c) { |
| return vbsl_s16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_s32 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vbsl_s32(uint32x2_t a, int32x2_t b, int32x2_t c) { |
| return vbsl_s32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_s64 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x1_t test_vbsl_s64(uint64x1_t a, int64x1_t b, int64x1_t c) { |
| return vbsl_s64(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_u8 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vbsl_u8(uint8x8_t a, uint8x8_t b, uint8x8_t c) { |
| return vbsl_u8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_u16 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vbsl_u16(uint16x4_t a, uint16x4_t b, uint16x4_t c) { |
| return vbsl_u16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_u32 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vbsl_u32(uint32x2_t a, uint32x2_t b, uint32x2_t c) { |
| return vbsl_u32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_u64 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x1_t test_vbsl_u64(uint64x1_t a, uint64x1_t b, uint64x1_t c) { |
| return vbsl_u64(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_f32 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| float32x2_t test_vbsl_f32(uint32x2_t a, float32x2_t b, float32x2_t c) { |
| return vbsl_f32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_p8 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| poly8x8_t test_vbsl_p8(uint8x8_t a, poly8x8_t b, poly8x8_t c) { |
| return vbsl_p8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbsl_p16 |
| // CHECK: vbsl d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| poly16x4_t test_vbsl_p16(uint16x4_t a, poly16x4_t b, poly16x4_t c) { |
| return vbsl_p16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_s8 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vbslq_s8(uint8x16_t a, int8x16_t b, int8x16_t c) { |
| return vbslq_s8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_s16 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vbslq_s16(uint16x8_t a, int16x8_t b, int16x8_t c) { |
| return vbslq_s16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_s32 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vbslq_s32(uint32x4_t a, int32x4_t b, int32x4_t c) { |
| return vbslq_s32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_s64 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int64x2_t test_vbslq_s64(uint64x2_t a, int64x2_t b, int64x2_t c) { |
| return vbslq_s64(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_u8 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vbslq_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) { |
| return vbslq_u8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_u16 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vbslq_u16(uint16x8_t a, uint16x8_t b, uint16x8_t c) { |
| return vbslq_u16(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_u32 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vbslq_u32(uint32x4_t a, uint32x4_t b, uint32x4_t c) { |
| return vbslq_u32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_u64 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint64x2_t test_vbslq_u64(uint64x2_t a, uint64x2_t b, uint64x2_t c) { |
| return vbslq_u64(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_f32 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| float32x4_t test_vbslq_f32(uint32x4_t a, float32x4_t b, float32x4_t c) { |
| return vbslq_f32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_p8 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| poly8x16_t test_vbslq_p8(uint8x16_t a, poly8x16_t b, poly8x16_t c) { |
| return vbslq_p8(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vbslq_p16 |
| // CHECK: vbsl q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| poly16x8_t test_vbslq_p16(uint16x8_t a, poly16x8_t b, poly16x8_t c) { |
| return vbslq_p16(a, b, c); |
| } |
| |
| |
| // CHECK-LABEL: test_vcage_f32 |
| // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcage_f32(float32x2_t a, float32x2_t b) { |
| return vcage_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcageq_f32 |
| // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcageq_f32(float32x4_t a, float32x4_t b) { |
| return vcageq_f32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcagt_f32 |
| // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcagt_f32(float32x2_t a, float32x2_t b) { |
| return vcagt_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcagtq_f32 |
| // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcagtq_f32(float32x4_t a, float32x4_t b) { |
| return vcagtq_f32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcale_f32 |
| // CHECK: vacge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcale_f32(float32x2_t a, float32x2_t b) { |
| return vcale_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcaleq_f32 |
| // CHECK: vacge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcaleq_f32(float32x4_t a, float32x4_t b) { |
| return vcaleq_f32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcalt_f32 |
| // CHECK: vacgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcalt_f32(float32x2_t a, float32x2_t b) { |
| return vcalt_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcaltq_f32 |
| // CHECK: vacgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcaltq_f32(float32x4_t a, float32x4_t b) { |
| return vcaltq_f32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vceq_s8 |
| // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vceq_s8(int8x8_t a, int8x8_t b) { |
| return vceq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceq_s16 |
| // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vceq_s16(int16x4_t a, int16x4_t b) { |
| return vceq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceq_s32 |
| // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vceq_s32(int32x2_t a, int32x2_t b) { |
| return vceq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceq_f32 |
| // CHECK: vceq.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vceq_f32(float32x2_t a, float32x2_t b) { |
| return vceq_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceq_u8 |
| // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vceq_u8(uint8x8_t a, uint8x8_t b) { |
| return vceq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceq_u16 |
| // CHECK: vceq.i16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vceq_u16(uint16x4_t a, uint16x4_t b) { |
| return vceq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceq_u32 |
| // CHECK: vceq.i32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vceq_u32(uint32x2_t a, uint32x2_t b) { |
| return vceq_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceq_p8 |
| // CHECK: vceq.i8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vceq_p8(poly8x8_t a, poly8x8_t b) { |
| return vceq_p8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_s8 |
| // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vceqq_s8(int8x16_t a, int8x16_t b) { |
| return vceqq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_s16 |
| // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vceqq_s16(int16x8_t a, int16x8_t b) { |
| return vceqq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_s32 |
| // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vceqq_s32(int32x4_t a, int32x4_t b) { |
| return vceqq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_f32 |
| // CHECK: vceq.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vceqq_f32(float32x4_t a, float32x4_t b) { |
| return vceqq_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_u8 |
| // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vceqq_u8(uint8x16_t a, uint8x16_t b) { |
| return vceqq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_u16 |
| // CHECK: vceq.i16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vceqq_u16(uint16x8_t a, uint16x8_t b) { |
| return vceqq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_u32 |
| // CHECK: vceq.i32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vceqq_u32(uint32x4_t a, uint32x4_t b) { |
| return vceqq_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vceqq_p8 |
| // CHECK: vceq.i8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vceqq_p8(poly8x16_t a, poly8x16_t b) { |
| return vceqq_p8(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcge_s8 |
| // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vcge_s8(int8x8_t a, int8x8_t b) { |
| return vcge_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcge_s16 |
| // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vcge_s16(int16x4_t a, int16x4_t b) { |
| return vcge_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcge_s32 |
| // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcge_s32(int32x2_t a, int32x2_t b) { |
| return vcge_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcge_f32 |
| // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcge_f32(float32x2_t a, float32x2_t b) { |
| return vcge_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcge_u8 |
| // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vcge_u8(uint8x8_t a, uint8x8_t b) { |
| return vcge_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcge_u16 |
| // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vcge_u16(uint16x4_t a, uint16x4_t b) { |
| return vcge_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcge_u32 |
| // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcge_u32(uint32x2_t a, uint32x2_t b) { |
| return vcge_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgeq_s8 |
| // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcgeq_s8(int8x16_t a, int8x16_t b) { |
| return vcgeq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgeq_s16 |
| // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcgeq_s16(int16x8_t a, int16x8_t b) { |
| return vcgeq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgeq_s32 |
| // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcgeq_s32(int32x4_t a, int32x4_t b) { |
| return vcgeq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgeq_f32 |
| // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcgeq_f32(float32x4_t a, float32x4_t b) { |
| return vcgeq_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgeq_u8 |
| // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcgeq_u8(uint8x16_t a, uint8x16_t b) { |
| return vcgeq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgeq_u16 |
| // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcgeq_u16(uint16x8_t a, uint16x8_t b) { |
| return vcgeq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgeq_u32 |
| // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcgeq_u32(uint32x4_t a, uint32x4_t b) { |
| return vcgeq_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcgt_s8 |
| // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vcgt_s8(int8x8_t a, int8x8_t b) { |
| return vcgt_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgt_s16 |
| // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vcgt_s16(int16x4_t a, int16x4_t b) { |
| return vcgt_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgt_s32 |
| // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcgt_s32(int32x2_t a, int32x2_t b) { |
| return vcgt_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgt_f32 |
| // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcgt_f32(float32x2_t a, float32x2_t b) { |
| return vcgt_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgt_u8 |
| // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vcgt_u8(uint8x8_t a, uint8x8_t b) { |
| return vcgt_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgt_u16 |
| // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vcgt_u16(uint16x4_t a, uint16x4_t b) { |
| return vcgt_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgt_u32 |
| // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcgt_u32(uint32x2_t a, uint32x2_t b) { |
| return vcgt_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgtq_s8 |
| // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcgtq_s8(int8x16_t a, int8x16_t b) { |
| return vcgtq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgtq_s16 |
| // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcgtq_s16(int16x8_t a, int16x8_t b) { |
| return vcgtq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgtq_s32 |
| // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcgtq_s32(int32x4_t a, int32x4_t b) { |
| return vcgtq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgtq_f32 |
| // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcgtq_f32(float32x4_t a, float32x4_t b) { |
| return vcgtq_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgtq_u8 |
| // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcgtq_u8(uint8x16_t a, uint8x16_t b) { |
| return vcgtq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgtq_u16 |
| // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcgtq_u16(uint16x8_t a, uint16x8_t b) { |
| return vcgtq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcgtq_u32 |
| // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcgtq_u32(uint32x4_t a, uint32x4_t b) { |
| return vcgtq_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcle_s8 |
| // CHECK: vcge.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vcle_s8(int8x8_t a, int8x8_t b) { |
| return vcle_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcle_s16 |
| // CHECK: vcge.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vcle_s16(int16x4_t a, int16x4_t b) { |
| return vcle_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcle_s32 |
| // CHECK: vcge.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcle_s32(int32x2_t a, int32x2_t b) { |
| return vcle_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcle_f32 |
| // CHECK: vcge.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcle_f32(float32x2_t a, float32x2_t b) { |
| return vcle_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcle_u8 |
| // CHECK: vcge.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vcle_u8(uint8x8_t a, uint8x8_t b) { |
| return vcle_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcle_u16 |
| // CHECK: vcge.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vcle_u16(uint16x4_t a, uint16x4_t b) { |
| return vcle_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcle_u32 |
| // CHECK: vcge.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcle_u32(uint32x2_t a, uint32x2_t b) { |
| return vcle_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcleq_s8 |
| // CHECK: vcge.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcleq_s8(int8x16_t a, int8x16_t b) { |
| return vcleq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcleq_s16 |
| // CHECK: vcge.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcleq_s16(int16x8_t a, int16x8_t b) { |
| return vcleq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcleq_s32 |
| // CHECK: vcge.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcleq_s32(int32x4_t a, int32x4_t b) { |
| return vcleq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcleq_f32 |
| // CHECK: vcge.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcleq_f32(float32x4_t a, float32x4_t b) { |
| return vcleq_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcleq_u8 |
| // CHECK: vcge.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcleq_u8(uint8x16_t a, uint8x16_t b) { |
| return vcleq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcleq_u16 |
| // CHECK: vcge.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcleq_u16(uint16x8_t a, uint16x8_t b) { |
| return vcleq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcleq_u32 |
| // CHECK: vcge.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcleq_u32(uint32x4_t a, uint32x4_t b) { |
| return vcleq_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcls_s8 |
| // CHECK: vcls.s8 d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vcls_s8(int8x8_t a) { |
| return vcls_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vcls_s16 |
| // CHECK: vcls.s16 d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vcls_s16(int16x4_t a) { |
| return vcls_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vcls_s32 |
| // CHECK: vcls.s32 d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vcls_s32(int32x2_t a) { |
| return vcls_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vclsq_s8 |
| // CHECK: vcls.s8 q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vclsq_s8(int8x16_t a) { |
| return vclsq_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vclsq_s16 |
| // CHECK: vcls.s16 q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vclsq_s16(int16x8_t a) { |
| return vclsq_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vclsq_s32 |
| // CHECK: vcls.s32 q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vclsq_s32(int32x4_t a) { |
| return vclsq_s32(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vclt_s8 |
| // CHECK: vcgt.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vclt_s8(int8x8_t a, int8x8_t b) { |
| return vclt_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vclt_s16 |
| // CHECK: vcgt.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vclt_s16(int16x4_t a, int16x4_t b) { |
| return vclt_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vclt_s32 |
| // CHECK: vcgt.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vclt_s32(int32x2_t a, int32x2_t b) { |
| return vclt_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vclt_f32 |
| // CHECK: vcgt.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vclt_f32(float32x2_t a, float32x2_t b) { |
| return vclt_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vclt_u8 |
| // CHECK: vcgt.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vclt_u8(uint8x8_t a, uint8x8_t b) { |
| return vclt_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vclt_u16 |
| // CHECK: vcgt.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vclt_u16(uint16x4_t a, uint16x4_t b) { |
| return vclt_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vclt_u32 |
| // CHECK: vcgt.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vclt_u32(uint32x2_t a, uint32x2_t b) { |
| return vclt_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcltq_s8 |
| // CHECK: vcgt.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcltq_s8(int8x16_t a, int8x16_t b) { |
| return vcltq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcltq_s16 |
| // CHECK: vcgt.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcltq_s16(int16x8_t a, int16x8_t b) { |
| return vcltq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcltq_s32 |
| // CHECK: vcgt.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcltq_s32(int32x4_t a, int32x4_t b) { |
| return vcltq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcltq_f32 |
| // CHECK: vcgt.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcltq_f32(float32x4_t a, float32x4_t b) { |
| return vcltq_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcltq_u8 |
| // CHECK: vcgt.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcltq_u8(uint8x16_t a, uint8x16_t b) { |
| return vcltq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcltq_u16 |
| // CHECK: vcgt.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vcltq_u16(uint16x8_t a, uint16x8_t b) { |
| return vcltq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcltq_u32 |
| // CHECK: vcgt.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcltq_u32(uint32x4_t a, uint32x4_t b) { |
| return vcltq_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vclz_s8 |
| // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vclz_s8(int8x8_t a) { |
| return vclz_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vclz_s16 |
| // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vclz_s16(int16x4_t a) { |
| return vclz_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vclz_s32 |
| // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vclz_s32(int32x2_t a) { |
| return vclz_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vclz_u8 |
| // CHECK: vclz.i8 d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vclz_u8(uint8x8_t a) { |
| return vclz_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vclz_u16 |
| // CHECK: vclz.i16 d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vclz_u16(uint16x4_t a) { |
| return vclz_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vclz_u32 |
| // CHECK: vclz.i32 d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vclz_u32(uint32x2_t a) { |
| return vclz_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vclzq_s8 |
| // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vclzq_s8(int8x16_t a) { |
| return vclzq_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vclzq_s16 |
| // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vclzq_s16(int16x8_t a) { |
| return vclzq_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vclzq_s32 |
| // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vclzq_s32(int32x4_t a) { |
| return vclzq_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vclzq_u8 |
| // CHECK: vclz.i8 q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vclzq_u8(uint8x16_t a) { |
| return vclzq_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vclzq_u16 |
| // CHECK: vclz.i16 q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vclzq_u16(uint16x8_t a) { |
| return vclzq_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vclzq_u32 |
| // CHECK: vclz.i32 q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vclzq_u32(uint32x4_t a) { |
| return vclzq_u32(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vcnt_u8 |
| // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vcnt_u8(uint8x8_t a) { |
| return vcnt_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vcnt_s8 |
| // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vcnt_s8(int8x8_t a) { |
| return vcnt_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vcnt_p8 |
| // CHECK: vcnt.8 d{{[0-9]+}}, d{{[0-9]+}} |
| poly8x8_t test_vcnt_p8(poly8x8_t a) { |
| return vcnt_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vcntq_u8 |
| // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vcntq_u8(uint8x16_t a) { |
| return vcntq_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vcntq_s8 |
| // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vcntq_s8(int8x16_t a) { |
| return vcntq_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vcntq_p8 |
| // CHECK: vcnt.8 q{{[0-9]+}}, q{{[0-9]+}} |
| poly8x16_t test_vcntq_p8(poly8x16_t a) { |
| return vcntq_p8(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vcombine_s8 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| int8x16_t test_vcombine_s8(int8x8_t a, int8x8_t b) { |
| return vcombine_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_s16 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| int16x8_t test_vcombine_s16(int16x4_t a, int16x4_t b) { |
| return vcombine_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_s32 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| int32x4_t test_vcombine_s32(int32x2_t a, int32x2_t b) { |
| return vcombine_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_s64 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| int64x2_t test_vcombine_s64(int64x1_t a, int64x1_t b) { |
| return vcombine_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_f16 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| float16x8_t test_vcombine_f16(float16x4_t a, float16x4_t b) { |
| return vcombine_f16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_f32 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| float32x4_t test_vcombine_f32(float32x2_t a, float32x2_t b) { |
| return vcombine_f32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_u8 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| uint8x16_t test_vcombine_u8(uint8x8_t a, uint8x8_t b) { |
| return vcombine_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_u16 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| uint16x8_t test_vcombine_u16(uint16x4_t a, uint16x4_t b) { |
| return vcombine_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_u32 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| uint32x4_t test_vcombine_u32(uint32x2_t a, uint32x2_t b) { |
| return vcombine_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_u64 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| uint64x2_t test_vcombine_u64(uint64x1_t a, uint64x1_t b) { |
| return vcombine_u64(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_p8 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| poly8x16_t test_vcombine_p8(poly8x8_t a, poly8x8_t b) { |
| return vcombine_p8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vcombine_p16 |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| // CHECK: vmov d{{[0-9]+}}, r{{[0-9]+}}, r{{[0-9]+}} |
| poly16x8_t test_vcombine_p16(poly16x4_t a, poly16x4_t b) { |
| return vcombine_p16(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vcreate_s8 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| // CHECK: vclz.i8 d{{[0-9]+}}, [[REG]] |
| int8x8_t test_vcreate_s8(uint64_t a) { |
| return vclz_s8(vcreate_s8(a)); |
| } |
| |
| // CHECK-LABEL: test_vcreate_s16 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| // CHECK: vclz.i16 d{{[0-9]+}}, [[REG]] |
| int16x4_t test_vcreate_s16(uint64_t a) { |
| return vclz_s16(vcreate_s16(a)); |
| } |
| |
| // CHECK-LABEL: test_vcreate_s32 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| // CHECK: vclz.i32 d{{[0-9]+}}, [[REG]] |
| int32x2_t test_vcreate_s32(uint64_t a) { |
| return vclz_s32(vcreate_s32(a)); |
| } |
| |
| // CHECK-LABEL: test_vcreate_f16 |
| float16x4_t test_vcreate_f16(uint64_t a) { |
| return vcreate_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vcreate_f32 |
| float32x2_t test_vcreate_f32(uint64_t a) { |
| return vcreate_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vcreate_u8 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| // CHECK: vclz.i8 d{{[0-9]+}}, [[REG]] |
| uint8x8_t test_vcreate_u8(uint64_t a) { |
| return vclz_s8(vcreate_u8(a)); |
| } |
| |
| // CHECK-LABEL: test_vcreate_u16 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| // CHECK: vclz.i16 d{{[0-9]+}}, [[REG]] |
| uint16x4_t test_vcreate_u16(uint64_t a) { |
| return vclz_s16(vcreate_u16(a)); |
| } |
| |
| // CHECK-LABEL: test_vcreate_u32 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| // CHECK: vclz.i32 d{{[0-9]+}}, [[REG]] |
| uint32x2_t test_vcreate_u32(uint64_t a) { |
| return vclz_s32(vcreate_u32(a)); |
| } |
| |
| |
| // We have two ways of lowering that. Either with one 'vmov d, r, r' or |
| // with two 'vmov d[],r'. LLVM does the latter. We may want to be less |
| // strict about the matching pattern if it starts causing problem. |
| // CHECK-LABEL: test_vcreate_u64 |
| // CHECK: vmov.32 [[REG:d[0-9]+]][0], r0 |
| // CHECK: vmov.32 [[REG]][1], r1 |
| uint64x1_t test_vcreate_u64(uint64_t a) { |
| uint64x1_t tmp = vcreate_u64(a); |
| return vadd_u64(tmp, tmp); |
| |
| } |
| |
| // CHECK-LABEL: test_vcreate_p8 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| // CHECK: vcnt.8 d{{[0-9]+}}, [[REG]] |
| poly8x8_t test_vcreate_p8(uint64_t a) { |
| return vcnt_p8(vcreate_p8(a)); |
| } |
| |
| // CHECK-LABEL: test_vcreate_p16 |
| // CHECK: vmov [[REG:d[0-9]+]], r0, r1 |
| poly16x4_t test_vcreate_p16(uint64_t a) { |
| poly16x4_t tmp = vcreate_p16(a); |
| return vbsl_p16(tmp, tmp, tmp); |
| } |
| |
| // CHECK-LABEL: test_vcreate_s64 |
| // CHECK: vmov.32 [[REG:d[0-9]+]][0], r0 |
| // CHECK: vmov.32 [[REG]][1], r1 |
| int64x1_t test_vcreate_s64(uint64_t a) { |
| int64x1_t tmp = vcreate_s64(a); |
| return vadd_s64(tmp, tmp); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_f16_f32 |
| // CHECK: vcvt.f16.f32 d{{[0-9]+}}, q{{[0-9]+}} |
| float16x4_t test_vcvt_f16_f32(float32x4_t a) { |
| return vcvt_f16_f32(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_f32_s32 |
| // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}} |
| float32x2_t test_vcvt_f32_s32(int32x2_t a) { |
| return vcvt_f32_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vcvt_f32_u32 |
| // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}} |
| float32x2_t test_vcvt_f32_u32(uint32x2_t a) { |
| return vcvt_f32_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_f32_s32 |
| // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}} |
| float32x4_t test_vcvtq_f32_s32(int32x4_t a) { |
| return vcvtq_f32_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_f32_u32 |
| // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}} |
| float32x4_t test_vcvtq_f32_u32(uint32x4_t a) { |
| return vcvtq_f32_u32(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_f32_f16 |
| // CHECK: vcvt.f32.f16 |
| float32x4_t test_vcvt_f32_f16(float16x4_t a) { |
| return vcvt_f32_f16(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_n_f32_s32 |
| // CHECK: vcvt.f32.s32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| float32x2_t test_vcvt_n_f32_s32(int32x2_t a) { |
| return vcvt_n_f32_s32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vcvt_n_f32_u32 |
| // CHECK: vcvt.f32.u32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| float32x2_t test_vcvt_n_f32_u32(uint32x2_t a) { |
| return vcvt_n_f32_u32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_n_f32_s32 |
| // CHECK: vcvt.f32.s32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| float32x4_t test_vcvtq_n_f32_s32(int32x4_t a) { |
| return vcvtq_n_f32_s32(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_n_f32_u32 |
| // CHECK: vcvt.f32.u32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| float32x4_t test_vcvtq_n_f32_u32(uint32x4_t a) { |
| return vcvtq_n_f32_u32(a, 3); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_n_s32_f32 |
| // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| int32x2_t test_vcvt_n_s32_f32(float32x2_t a) { |
| return vcvt_n_s32_f32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_n_s32_f32 |
| // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| int32x4_t test_vcvtq_n_s32_f32(float32x4_t a) { |
| return vcvtq_n_s32_f32(a, 3); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_n_u32_f32 |
| // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| uint32x2_t test_vcvt_n_u32_f32(float32x2_t a) { |
| return vcvt_n_u32_f32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_n_u32_f32 |
| // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| uint32x4_t test_vcvtq_n_u32_f32(float32x4_t a) { |
| return vcvtq_n_u32_f32(a, 3); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_s32_f32 |
| // CHECK: vcvt.s32.f32 d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vcvt_s32_f32(float32x2_t a) { |
| return vcvt_s32_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_s32_f32 |
| // CHECK: vcvt.s32.f32 q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vcvtq_s32_f32(float32x4_t a) { |
| return vcvtq_s32_f32(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vcvt_u32_f32 |
| // CHECK: vcvt.u32.f32 d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vcvt_u32_f32(float32x2_t a) { |
| return vcvt_u32_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vcvtq_u32_f32 |
| // CHECK: vcvt.u32.f32 q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vcvtq_u32_f32(float32x4_t a) { |
| return vcvtq_u32_f32(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vdup_lane_u8 |
| // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| uint8x8_t test_vdup_lane_u8(uint8x8_t a) { |
| return vdup_lane_u8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_u16 |
| // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| uint16x4_t test_vdup_lane_u16(uint16x4_t a) { |
| return vdup_lane_u16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_u32 |
| // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| uint32x2_t test_vdup_lane_u32(uint32x2_t a) { |
| return vdup_lane_u32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_s8 |
| // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| int8x8_t test_vdup_lane_s8(int8x8_t a) { |
| return vdup_lane_s8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_s16 |
| // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| int16x4_t test_vdup_lane_s16(int16x4_t a) { |
| return vdup_lane_s16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_s32 |
| // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| int32x2_t test_vdup_lane_s32(int32x2_t a) { |
| return vdup_lane_s32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_p8 |
| // CHECK: vdup.8 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| poly8x8_t test_vdup_lane_p8(poly8x8_t a) { |
| return vdup_lane_p8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_p16 |
| // CHECK: vdup.16 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| poly16x4_t test_vdup_lane_p16(poly16x4_t a) { |
| return vdup_lane_p16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_f32 |
| // CHECK: vdup.32 d{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| float32x2_t test_vdup_lane_f32(float32x2_t a) { |
| return vdup_lane_f32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_u8 |
| // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| uint8x16_t test_vdupq_lane_u8(uint8x8_t a) { |
| return vdupq_lane_u8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_u16 |
| // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| uint16x8_t test_vdupq_lane_u16(uint16x4_t a) { |
| return vdupq_lane_u16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_u32 |
| // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| uint32x4_t test_vdupq_lane_u32(uint32x2_t a) { |
| return vdupq_lane_u32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_s8 |
| // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| int8x16_t test_vdupq_lane_s8(int8x8_t a) { |
| return vdupq_lane_s8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_s16 |
| // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| int16x8_t test_vdupq_lane_s16(int16x4_t a) { |
| return vdupq_lane_s16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_s32 |
| // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| int32x4_t test_vdupq_lane_s32(int32x2_t a) { |
| return vdupq_lane_s32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_p8 |
| // CHECK: vdup.8 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| poly8x16_t test_vdupq_lane_p8(poly8x8_t a) { |
| return vdupq_lane_p8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_p16 |
| // CHECK: vdup.16 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| poly16x8_t test_vdupq_lane_p16(poly16x4_t a) { |
| return vdupq_lane_p16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_f32 |
| // CHECK: vdup.32 q{{[0-9]+}}, d{{[0-9]+}}[{{[0-9]}}] |
| float32x4_t test_vdupq_lane_f32(float32x2_t a) { |
| return vdupq_lane_f32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_s64 |
| int64x1_t test_vdup_lane_s64(int64x1_t a) { |
| return vdup_lane_s64(a, 0); |
| } |
| |
| // CHECK-LABEL: test_vdup_lane_u64 |
| uint64x1_t test_vdup_lane_u64(uint64x1_t a) { |
| return vdup_lane_u64(a, 0); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_s64 |
| // CHECK: {{vmov|vdup}} |
| int64x2_t test_vdupq_lane_s64(int64x1_t a) { |
| return vdupq_lane_s64(a, 0); |
| } |
| |
| // CHECK-LABEL: test_vdupq_lane_u64 |
| // CHECK: {{vmov|vdup}} |
| uint64x2_t test_vdupq_lane_u64(uint64x1_t a) { |
| return vdupq_lane_u64(a, 0); |
| } |
| |
| |
| // CHECK-LABEL: test_vdup_n_u8 |
| // CHECK: vmov |
| uint8x8_t test_vdup_n_u8(uint8_t a) { |
| return vdup_n_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_u16 |
| // CHECK: vmov |
| uint16x4_t test_vdup_n_u16(uint16_t a) { |
| return vdup_n_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_u32 |
| // CHECK: mov |
| uint32x2_t test_vdup_n_u32(uint32_t a) { |
| return vdup_n_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_s8 |
| // CHECK: vmov |
| int8x8_t test_vdup_n_s8(int8_t a) { |
| return vdup_n_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_s16 |
| // CHECK: vmov |
| int16x4_t test_vdup_n_s16(int16_t a) { |
| return vdup_n_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_s32 |
| // CHECK: mov |
| int32x2_t test_vdup_n_s32(int32_t a) { |
| return vdup_n_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_p8 |
| // CHECK: vmov |
| poly8x8_t test_vdup_n_p8(poly8_t a) { |
| return vdup_n_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_p16 |
| // CHECK: vmov |
| poly16x4_t test_vdup_n_p16(poly16_t a) { |
| return vdup_n_p16(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_f16 |
| // CHECK: vld1.16 {{{d[0-9]+\[\]}}} |
| float16x4_t test_vdup_n_f16(float16_t *a) { |
| return vdup_n_f16(*a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_f32 |
| // CHECK: mov |
| float32x2_t test_vdup_n_f32(float32_t a) { |
| return vdup_n_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_u8 |
| // CHECK: vmov |
| uint8x16_t test_vdupq_n_u8(uint8_t a) { |
| return vdupq_n_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_u16 |
| // CHECK: vmov |
| uint16x8_t test_vdupq_n_u16(uint16_t a) { |
| return vdupq_n_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_u32 |
| // CHECK: vmov |
| uint32x4_t test_vdupq_n_u32(uint32_t a) { |
| return vdupq_n_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_s8 |
| // CHECK: vmov |
| int8x16_t test_vdupq_n_s8(int8_t a) { |
| return vdupq_n_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_s16 |
| // CHECK: vmov |
| int16x8_t test_vdupq_n_s16(int16_t a) { |
| return vdupq_n_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_s32 |
| // CHECK: vmov |
| int32x4_t test_vdupq_n_s32(int32_t a) { |
| return vdupq_n_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_p8 |
| // CHECK: vmov |
| poly8x16_t test_vdupq_n_p8(poly8_t a) { |
| return vdupq_n_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_p16 |
| // CHECK: vmov |
| poly16x8_t test_vdupq_n_p16(poly16_t a) { |
| return vdupq_n_p16(a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_f16 |
| // CHECK: vld1.16 {{{d[0-9]+\[\], d[0-9]+\[\]}}} |
| float16x8_t test_vdupq_n_f16(float16_t *a) { |
| return vdupq_n_f16(*a); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_f32 |
| // CHECK: vmov |
| float32x4_t test_vdupq_n_f32(float32_t a) { |
| return vdupq_n_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_s64 |
| // CHECK: vmov |
| int64x1_t test_vdup_n_s64(int64_t a) { |
| int64x1_t tmp = vdup_n_s64(a); |
| return vadd_s64(tmp, tmp); |
| } |
| |
| // CHECK-LABEL: test_vdup_n_u64 |
| // CHECK: vmov |
| uint64x1_t test_vdup_n_u64(uint64_t a) { |
| int64x1_t tmp = vdup_n_u64(a); |
| return vadd_s64(tmp, tmp); |
| |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_s64 |
| // CHECK: vmov |
| int64x2_t test_vdupq_n_s64(int64_t a) { |
| int64x2_t tmp = vdupq_n_s64(a); |
| return vaddq_s64(tmp, tmp); |
| } |
| |
| // CHECK-LABEL: test_vdupq_n_u64 |
| // CHECK: vmov |
| uint64x2_t test_vdupq_n_u64(uint64_t a) { |
| int64x2_t tmp = vdupq_n_u64(a); |
| return vaddq_u64(tmp, tmp); |
| } |
| |
| |
| // CHECK-LABEL: test_veor_s8 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_veor_s8(int8x8_t a, int8x8_t b) { |
| return veor_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_veor_s16 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_veor_s16(int16x4_t a, int16x4_t b) { |
| return veor_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_veor_s32 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_veor_s32(int32x2_t a, int32x2_t b) { |
| return veor_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_veor_s64 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int64x1_t test_veor_s64(int64x1_t a, int64x1_t b) { |
| return veor_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_veor_u8 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_veor_u8(uint8x8_t a, uint8x8_t b) { |
| return veor_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_veor_u16 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_veor_u16(uint16x4_t a, uint16x4_t b) { |
| return veor_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_veor_u32 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_veor_u32(uint32x2_t a, uint32x2_t b) { |
| return veor_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_veor_u64 |
| // CHECK: veor d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint64x1_t test_veor_u64(uint64x1_t a, uint64x1_t b) { |
| return veor_u64(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_s8 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_veorq_s8(int8x16_t a, int8x16_t b) { |
| return veorq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_s16 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_veorq_s16(int16x8_t a, int16x8_t b) { |
| return veorq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_s32 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_veorq_s32(int32x4_t a, int32x4_t b) { |
| return veorq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_s64 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int64x2_t test_veorq_s64(int64x2_t a, int64x2_t b) { |
| return veorq_s64(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_u8 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_veorq_u8(uint8x16_t a, uint8x16_t b) { |
| return veorq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_u16 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_veorq_u16(uint16x8_t a, uint16x8_t b) { |
| return veorq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_u32 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_veorq_u32(uint32x4_t a, uint32x4_t b) { |
| return veorq_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_veorq_u64 |
| // CHECK: veor q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint64x2_t test_veorq_u64(uint64x2_t a, uint64x2_t b) { |
| return veorq_u64(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vext_s8 |
| // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| int8x8_t test_vext_s8(int8x8_t a, int8x8_t b) { |
| return vext_s8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vext_u8 |
| // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| uint8x8_t test_vext_u8(uint8x8_t a, uint8x8_t b) { |
| return vext_u8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vext_p8 |
| // CHECK: vext.8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| poly8x8_t test_vext_p8(poly8x8_t a, poly8x8_t b) { |
| return vext_p8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vext_s16 |
| // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| int16x4_t test_vext_s16(int16x4_t a, int16x4_t b) { |
| return vext_s16(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vext_u16 |
| // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| uint16x4_t test_vext_u16(uint16x4_t a, uint16x4_t b) { |
| return vext_u16(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vext_p16 |
| // CHECK: vext.16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| poly16x4_t test_vext_p16(poly16x4_t a, poly16x4_t b) { |
| return vext_p16(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vext_s32 |
| // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| int32x2_t test_vext_s32(int32x2_t a, int32x2_t b) { |
| return vext_s32(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vext_u32 |
| // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| uint32x2_t test_vext_u32(uint32x2_t a, uint32x2_t b) { |
| return vext_u32(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vext_s64 |
| int64x1_t test_vext_s64(int64x1_t a, int64x1_t b) { |
| return vext_s64(a, b, 0); |
| } |
| |
| // CHECK-LABEL: test_vext_u64 |
| uint64x1_t test_vext_u64(uint64x1_t a, uint64x1_t b) { |
| return vext_u64(a, b, 0); |
| } |
| |
| // CHECK-LABEL: test_vext_f32 |
| // CHECK: vext.32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, #{{[0-9]+}} |
| float32x2_t test_vext_f32(float32x2_t a, float32x2_t b) { |
| return vext_f32(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vextq_s8 |
| // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| int8x16_t test_vextq_s8(int8x16_t a, int8x16_t b) { |
| return vextq_s8(a, b, 15); |
| } |
| |
| // CHECK-LABEL: test_vextq_u8 |
| // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| uint8x16_t test_vextq_u8(uint8x16_t a, uint8x16_t b) { |
| return vextq_u8(a, b, 15); |
| } |
| |
| // CHECK-LABEL: test_vextq_p8 |
| // CHECK: vext.8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| poly8x16_t test_vextq_p8(poly8x16_t a, poly8x16_t b) { |
| return vextq_p8(a, b, 15); |
| } |
| |
| // CHECK-LABEL: test_vextq_s16 |
| // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| int16x8_t test_vextq_s16(int16x8_t a, int16x8_t b) { |
| return vextq_s16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vextq_u16 |
| // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| uint16x8_t test_vextq_u16(uint16x8_t a, uint16x8_t b) { |
| return vextq_u16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vextq_p16 |
| // CHECK: vext.16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| poly16x8_t test_vextq_p16(poly16x8_t a, poly16x8_t b) { |
| return vextq_p16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vextq_s32 |
| // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| int32x4_t test_vextq_s32(int32x4_t a, int32x4_t b) { |
| return vextq_s32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vextq_u32 |
| // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| uint32x4_t test_vextq_u32(uint32x4_t a, uint32x4_t b) { |
| return vextq_u32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vextq_s64 |
| // CHECK: {{vmov|vdup}} |
| int64x2_t test_vextq_s64(int64x2_t a, int64x2_t b) { |
| return vextq_s64(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vextq_u64 |
| // CHECK: {{vmov|vdup}} |
| uint64x2_t test_vextq_u64(uint64x2_t a, uint64x2_t b) { |
| return vextq_u64(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vextq_f32 |
| // CHECK: vext.32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}, #{{[0-9]+}} |
| float32x4_t test_vextq_f32(float32x4_t a, float32x4_t b) { |
| return vextq_f32(a, b, 3); |
| } |
| |
| |
| // CHECK-LABEL: test_vfma_f32 |
| // CHECK: vfma.f32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| float32x2_t test_vfma_f32(float32x2_t a, float32x2_t b, float32x2_t c) { |
| return vfma_f32(a, b, c); |
| } |
| |
| // CHECK-LABEL: test_vfmaq_f32 |
| // CHECK: vfma.f32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| float32x4_t test_vfmaq_f32(float32x4_t a, float32x4_t b, float32x4_t c) { |
| return vfmaq_f32(a, b, c); |
| } |
| |
| |
| // CHECK-LABEL: test_vget_high_s8 |
| int8x8_t test_vget_high_s8(int8x16_t a) { |
| return vget_high_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_s16 |
| int16x4_t test_vget_high_s16(int16x8_t a) { |
| return vget_high_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_s32 |
| int32x2_t test_vget_high_s32(int32x4_t a) { |
| return vget_high_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_s64 |
| int64x1_t test_vget_high_s64(int64x2_t a) { |
| return vget_high_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_f16 |
| float16x4_t test_vget_high_f16(float16x8_t a) { |
| return vget_high_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_f32 |
| float32x2_t test_vget_high_f32(float32x4_t a) { |
| return vget_high_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_u8 |
| uint8x8_t test_vget_high_u8(uint8x16_t a) { |
| return vget_high_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_u16 |
| uint16x4_t test_vget_high_u16(uint16x8_t a) { |
| return vget_high_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_u32 |
| uint32x2_t test_vget_high_u32(uint32x4_t a) { |
| return vget_high_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_u64 |
| uint64x1_t test_vget_high_u64(uint64x2_t a) { |
| return vget_high_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_p8 |
| poly8x8_t test_vget_high_p8(poly8x16_t a) { |
| return vget_high_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vget_high_p16 |
| poly16x4_t test_vget_high_p16(poly16x8_t a) { |
| return vget_high_p16(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vget_lane_u8 |
| // CHECK: vmov |
| uint8_t test_vget_lane_u8(uint8x8_t a) { |
| return vget_lane_u8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_u16 |
| // CHECK: vmov |
| uint16_t test_vget_lane_u16(uint16x4_t a) { |
| return vget_lane_u16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_u32 |
| // CHECK: mov |
| uint32_t test_vget_lane_u32(uint32x2_t a) { |
| return vget_lane_u32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_s8 |
| // CHECK: vmov |
| int8_t test_vget_lane_s8(int8x8_t a) { |
| return vget_lane_s8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_s16 |
| // CHECK: vmov |
| int16_t test_vget_lane_s16(int16x4_t a) { |
| return vget_lane_s16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_s32 |
| // CHECK: mov |
| int32_t test_vget_lane_s32(int32x2_t a) { |
| return vget_lane_s32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_p8 |
| // CHECK: vmov |
| poly8_t test_vget_lane_p8(poly8x8_t a) { |
| return vget_lane_p8(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_p16 |
| // CHECK: vmov |
| poly16_t test_vget_lane_p16(poly16x4_t a) { |
| return vget_lane_p16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_f32 |
| // CHECK: vmov |
| float32_t test_vget_lane_f32(float32x2_t a) { |
| return vget_lane_f32(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_f16 |
| // CHECK: vmov |
| float32_t test_vget_lane_f16(float16x4_t a) { |
| return vget_lane_f16(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_u8 |
| // CHECK: vmov |
| uint8_t test_vgetq_lane_u8(uint8x16_t a) { |
| return vgetq_lane_u8(a, 15); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_u16 |
| // CHECK: vmov |
| uint16_t test_vgetq_lane_u16(uint16x8_t a) { |
| return vgetq_lane_u16(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_u32 |
| // CHECK: vmov |
| uint32_t test_vgetq_lane_u32(uint32x4_t a) { |
| return vgetq_lane_u32(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_s8 |
| // CHECK: vmov |
| int8_t test_vgetq_lane_s8(int8x16_t a) { |
| return vgetq_lane_s8(a, 15); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_s16 |
| // CHECK: vmov |
| int16_t test_vgetq_lane_s16(int16x8_t a) { |
| return vgetq_lane_s16(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_s32 |
| // CHECK: vmov |
| int32_t test_vgetq_lane_s32(int32x4_t a) { |
| return vgetq_lane_s32(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_p8 |
| // CHECK: vmov |
| poly8_t test_vgetq_lane_p8(poly8x16_t a) { |
| return vgetq_lane_p8(a, 15); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_p16 |
| // CHECK: vmov |
| poly16_t test_vgetq_lane_p16(poly16x8_t a) { |
| return vgetq_lane_p16(a, 7); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_f32 |
| // CHECK: vmov |
| float32_t test_vgetq_lane_f32(float32x4_t a) { |
| return vgetq_lane_f32(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_f16 |
| // CHECK: vmov |
| float32_t test_vgetq_lane_f16(float16x8_t a) { |
| return vgetq_lane_f16(a, 3); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_s64 |
| // The optimizer is able to remove all moves now. |
| int64_t test_vget_lane_s64(int64x1_t a) { |
| return vget_lane_s64(a, 0); |
| } |
| |
| // CHECK-LABEL: test_vget_lane_u64 |
| // The optimizer is able to remove all moves now. |
| uint64_t test_vget_lane_u64(uint64x1_t a) { |
| return vget_lane_u64(a, 0); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_s64 |
| // CHECK: vmov |
| int64_t test_vgetq_lane_s64(int64x2_t a) { |
| return vgetq_lane_s64(a, 1); |
| } |
| |
| // CHECK-LABEL: test_vgetq_lane_u64 |
| // CHECK: vmov |
| uint64_t test_vgetq_lane_u64(uint64x2_t a) { |
| return vgetq_lane_u64(a, 1); |
| } |
| |
| |
| // CHECK-LABEL: test_vget_low_s8 |
| int8x8_t test_vget_low_s8(int8x16_t a) { |
| return vget_low_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_s16 |
| int16x4_t test_vget_low_s16(int16x8_t a) { |
| return vget_low_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_s32 |
| int32x2_t test_vget_low_s32(int32x4_t a) { |
| return vget_low_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_s64 |
| int64x1_t test_vget_low_s64(int64x2_t a) { |
| return vget_low_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_f16 |
| float16x4_t test_vget_low_f16(float16x8_t a) { |
| return vget_low_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_f32 |
| float32x2_t test_vget_low_f32(float32x4_t a) { |
| return vget_low_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_u8 |
| uint8x8_t test_vget_low_u8(uint8x16_t a) { |
| return vget_low_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_u16 |
| uint16x4_t test_vget_low_u16(uint16x8_t a) { |
| return vget_low_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_u32 |
| uint32x2_t test_vget_low_u32(uint32x4_t a) { |
| return vget_low_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_u64 |
| uint64x1_t test_vget_low_u64(uint64x2_t a) { |
| return vget_low_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_p8 |
| poly8x8_t test_vget_low_p8(poly8x16_t a) { |
| return vget_low_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vget_low_p16 |
| poly16x4_t test_vget_low_p16(poly16x8_t a) { |
| return vget_low_p16(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vhadd_s8 |
| // CHECK: vhadd.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vhadd_s8(int8x8_t a, int8x8_t b) { |
| return vhadd_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhadd_s16 |
| // CHECK: vhadd.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vhadd_s16(int16x4_t a, int16x4_t b) { |
| return vhadd_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhadd_s32 |
| // CHECK: vhadd.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vhadd_s32(int32x2_t a, int32x2_t b) { |
| return vhadd_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhadd_u8 |
| // CHECK: vhadd.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vhadd_u8(uint8x8_t a, uint8x8_t b) { |
| return vhadd_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhadd_u16 |
| // CHECK: vhadd.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vhadd_u16(uint16x4_t a, uint16x4_t b) { |
| return vhadd_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhadd_u32 |
| // CHECK: vhadd.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vhadd_u32(uint32x2_t a, uint32x2_t b) { |
| return vhadd_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhaddq_s8 |
| // CHECK: vhadd.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vhaddq_s8(int8x16_t a, int8x16_t b) { |
| return vhaddq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhaddq_s16 |
| // CHECK: vhadd.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vhaddq_s16(int16x8_t a, int16x8_t b) { |
| return vhaddq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhaddq_s32 |
| // CHECK: vhadd.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vhaddq_s32(int32x4_t a, int32x4_t b) { |
| return vhaddq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhaddq_u8 |
| // CHECK: vhadd.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vhaddq_u8(uint8x16_t a, uint8x16_t b) { |
| return vhaddq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhaddq_u16 |
| // CHECK: vhadd.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vhaddq_u16(uint16x8_t a, uint16x8_t b) { |
| return vhaddq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhaddq_u32 |
| // CHECK: vhadd.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vhaddq_u32(uint32x4_t a, uint32x4_t b) { |
| return vhaddq_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vhsub_s8 |
| // CHECK: vhsub.s8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int8x8_t test_vhsub_s8(int8x8_t a, int8x8_t b) { |
| return vhsub_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsub_s16 |
| // CHECK: vhsub.s16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int16x4_t test_vhsub_s16(int16x4_t a, int16x4_t b) { |
| return vhsub_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsub_s32 |
| // CHECK: vhsub.s32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| int32x2_t test_vhsub_s32(int32x2_t a, int32x2_t b) { |
| return vhsub_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsub_u8 |
| // CHECK: vhsub.u8 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint8x8_t test_vhsub_u8(uint8x8_t a, uint8x8_t b) { |
| return vhsub_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsub_u16 |
| // CHECK: vhsub.u16 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint16x4_t test_vhsub_u16(uint16x4_t a, uint16x4_t b) { |
| return vhsub_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsub_u32 |
| // CHECK: vhsub.u32 d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}} |
| uint32x2_t test_vhsub_u32(uint32x2_t a, uint32x2_t b) { |
| return vhsub_u32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsubq_s8 |
| // CHECK: vhsub.s8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int8x16_t test_vhsubq_s8(int8x16_t a, int8x16_t b) { |
| return vhsubq_s8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsubq_s16 |
| // CHECK: vhsub.s16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int16x8_t test_vhsubq_s16(int16x8_t a, int16x8_t b) { |
| return vhsubq_s16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsubq_s32 |
| // CHECK: vhsub.s32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| int32x4_t test_vhsubq_s32(int32x4_t a, int32x4_t b) { |
| return vhsubq_s32(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsubq_u8 |
| // CHECK: vhsub.u8 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint8x16_t test_vhsubq_u8(uint8x16_t a, uint8x16_t b) { |
| return vhsubq_u8(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsubq_u16 |
| // CHECK: vhsub.u16 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint16x8_t test_vhsubq_u16(uint16x8_t a, uint16x8_t b) { |
| return vhsubq_u16(a, b); |
| } |
| |
| // CHECK-LABEL: test_vhsubq_u32 |
| // CHECK: vhsub.u32 q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} |
| uint32x4_t test_vhsubq_u32(uint32x4_t a, uint32x4_t b) { |
| return vhsubq_u32(a, b); |
| } |
| |
| |
| // CHECK-LABEL: test_vld1q_u8 |
| // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint8x16_t test_vld1q_u8(uint8_t const * a) { |
| return vld1q_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_u16 |
| // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint16x8_t test_vld1q_u16(uint16_t const * a) { |
| return vld1q_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_u32 |
| // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint32x4_t test_vld1q_u32(uint32_t const * a) { |
| return vld1q_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_u64 |
| // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] |
| uint64x2_t test_vld1q_u64(uint64_t const * a) { |
| return vld1q_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_s8 |
| // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int8x16_t test_vld1q_s8(int8_t const * a) { |
| return vld1q_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_s16 |
| // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int16x8_t test_vld1q_s16(int16_t const * a) { |
| return vld1q_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_s32 |
| // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int32x4_t test_vld1q_s32(int32_t const * a) { |
| return vld1q_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_s64 |
| // CHECK: vld1.64 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] |
| int64x2_t test_vld1q_s64(int64_t const * a) { |
| return vld1q_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_f16 |
| // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float16x8_t test_vld1q_f16(float16_t const * a) { |
| return vld1q_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_f32 |
| // CHECK: vld1.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float32x4_t test_vld1q_f32(float32_t const * a) { |
| return vld1q_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_p8 |
| // CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly8x16_t test_vld1q_p8(poly8_t const * a) { |
| return vld1q_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_p16 |
| // CHECK: vld1.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly16x8_t test_vld1q_p16(poly16_t const * a) { |
| return vld1q_p16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_u8 |
| // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint8x8_t test_vld1_u8(uint8_t const * a) { |
| return vld1_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_u16 |
| // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint16x4_t test_vld1_u16(uint16_t const * a) { |
| return vld1_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_u32 |
| // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint32x2_t test_vld1_u32(uint32_t const * a) { |
| return vld1_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_u64 |
| // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] |
| uint64x1_t test_vld1_u64(uint64_t const * a) { |
| return vld1_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_s8 |
| // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int8x8_t test_vld1_s8(int8_t const * a) { |
| return vld1_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_s16 |
| // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int16x4_t test_vld1_s16(int16_t const * a) { |
| return vld1_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_s32 |
| // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int32x2_t test_vld1_s32(int32_t const * a) { |
| return vld1_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_s64 |
| // CHECK: vld1.64 {d{{[0-9]+}}}, [r{{[0-9]+}}{{(:64)?}}] |
| int64x1_t test_vld1_s64(int64_t const * a) { |
| return vld1_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_f16 |
| // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float16x4_t test_vld1_f16(float16_t const * a) { |
| return vld1_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_f32 |
| // CHECK: vld1.32 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float32x2_t test_vld1_f32(float32_t const * a) { |
| return vld1_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_p8 |
| // CHECK: vld1.8 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly8x8_t test_vld1_p8(poly8_t const * a) { |
| return vld1_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_p16 |
| // CHECK: vld1.16 {d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly16x4_t test_vld1_p16(poly16_t const * a) { |
| return vld1_p16(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vld1q_dup_u8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| uint8x16_t test_vld1q_dup_u8(uint8_t const * a) { |
| return vld1q_dup_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_u16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| uint16x8_t test_vld1q_dup_u16(uint16_t const * a) { |
| return vld1q_dup_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_u32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] |
| uint32x4_t test_vld1q_dup_u32(uint32_t const * a) { |
| return vld1q_dup_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_u64 |
| // CHECK: {{ldr|vldr|vmov}} |
| uint64x2_t test_vld1q_dup_u64(uint64_t const * a) { |
| return vld1q_dup_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_s8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| int8x16_t test_vld1q_dup_s8(int8_t const * a) { |
| return vld1q_dup_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_s16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| int16x8_t test_vld1q_dup_s16(int16_t const * a) { |
| return vld1q_dup_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_s32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] |
| int32x4_t test_vld1q_dup_s32(int32_t const * a) { |
| return vld1q_dup_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_s64 |
| // CHECK: {{ldr|vldr|vmov}} |
| int64x2_t test_vld1q_dup_s64(int64_t const * a) { |
| return vld1q_dup_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_f16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| float16x8_t test_vld1q_dup_f16(float16_t const * a) { |
| return vld1q_dup_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_f32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] |
| float32x4_t test_vld1q_dup_f32(float32_t const * a) { |
| return vld1q_dup_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_p8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| poly8x16_t test_vld1q_dup_p8(poly8_t const * a) { |
| return vld1q_dup_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1q_dup_p16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| poly16x8_t test_vld1q_dup_p16(poly16_t const * a) { |
| return vld1q_dup_p16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_u8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| uint8x8_t test_vld1_dup_u8(uint8_t const * a) { |
| return vld1_dup_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_u16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| uint16x4_t test_vld1_dup_u16(uint16_t const * a) { |
| return vld1_dup_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_u32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] |
| uint32x2_t test_vld1_dup_u32(uint32_t const * a) { |
| return vld1_dup_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_u64 |
| // CHECK: {{ldr|vldr|vmov}} |
| uint64x1_t test_vld1_dup_u64(uint64_t const * a) { |
| return vld1_dup_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_s8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| int8x8_t test_vld1_dup_s8(int8_t const * a) { |
| return vld1_dup_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_s16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| int16x4_t test_vld1_dup_s16(int16_t const * a) { |
| return vld1_dup_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_s32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] |
| int32x2_t test_vld1_dup_s32(int32_t const * a) { |
| return vld1_dup_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_s64 |
| // CHECK: {{ldr|vldr|vmov}} |
| int64x1_t test_vld1_dup_s64(int64_t const * a) { |
| return vld1_dup_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_f16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| float16x4_t test_vld1_dup_f16(float16_t const * a) { |
| return vld1_dup_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_f32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:32] |
| float32x2_t test_vld1_dup_f32(float32_t const * a) { |
| return vld1_dup_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_p8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| poly8x8_t test_vld1_dup_p8(poly8_t const * a) { |
| return vld1_dup_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vld1_dup_p16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[]}, [r{{[0-9]+}}:16] |
| poly16x4_t test_vld1_dup_p16(poly16_t const * a) { |
| return vld1_dup_p16(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vld1q_lane_u8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| uint8x16_t test_vld1q_lane_u8(uint8_t const * a, uint8x16_t b) { |
| return vld1q_lane_u8(a, b, 15); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_u16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| uint16x8_t test_vld1q_lane_u16(uint16_t const * a, uint16x8_t b) { |
| return vld1q_lane_u16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_u32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] |
| uint32x4_t test_vld1q_lane_u32(uint32_t const * a, uint32x4_t b) { |
| return vld1q_lane_u32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_u64 |
| // CHECK: {{ldr|vldr|vmov}} |
| uint64x2_t test_vld1q_lane_u64(uint64_t const * a, uint64x2_t b) { |
| return vld1q_lane_u64(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_s8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| int8x16_t test_vld1q_lane_s8(int8_t const * a, int8x16_t b) { |
| return vld1q_lane_s8(a, b, 15); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_s16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| int16x8_t test_vld1q_lane_s16(int16_t const * a, int16x8_t b) { |
| return vld1q_lane_s16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_s32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] |
| int32x4_t test_vld1q_lane_s32(int32_t const * a, int32x4_t b) { |
| return vld1q_lane_s32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_s64 |
| // CHECK: {{ldr|vldr|vmov}} |
| int64x2_t test_vld1q_lane_s64(int64_t const * a, int64x2_t b) { |
| return vld1q_lane_s64(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_f16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| float16x8_t test_vld1q_lane_f16(float16_t const * a, float16x8_t b) { |
| return vld1q_lane_f16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_f32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] |
| float32x4_t test_vld1q_lane_f32(float32_t const * a, float32x4_t b) { |
| return vld1q_lane_f32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_p8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| poly8x16_t test_vld1q_lane_p8(poly8_t const * a, poly8x16_t b) { |
| return vld1q_lane_p8(a, b, 15); |
| } |
| |
| // CHECK-LABEL: test_vld1q_lane_p16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| poly16x8_t test_vld1q_lane_p16(poly16_t const * a, poly16x8_t b) { |
| return vld1q_lane_p16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_u8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| uint8x8_t test_vld1_lane_u8(uint8_t const * a, uint8x8_t b) { |
| return vld1_lane_u8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_u16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| uint16x4_t test_vld1_lane_u16(uint16_t const * a, uint16x4_t b) { |
| return vld1_lane_u16(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_u32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] |
| uint32x2_t test_vld1_lane_u32(uint32_t const * a, uint32x2_t b) { |
| return vld1_lane_u32(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_u64 |
| // CHECK: {{ldr|vldr|vmov}} |
| uint64x1_t test_vld1_lane_u64(uint64_t const * a, uint64x1_t b) { |
| return vld1_lane_u64(a, b, 0); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_s8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| int8x8_t test_vld1_lane_s8(int8_t const * a, int8x8_t b) { |
| return vld1_lane_s8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_s16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| int16x4_t test_vld1_lane_s16(int16_t const * a, int16x4_t b) { |
| return vld1_lane_s16(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_s32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] |
| int32x2_t test_vld1_lane_s32(int32_t const * a, int32x2_t b) { |
| return vld1_lane_s32(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_s64 |
| // CHECK: {{ldr|vldr|vmov}} |
| int64x1_t test_vld1_lane_s64(int64_t const * a, int64x1_t b) { |
| return vld1_lane_s64(a, b, 0); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_f16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| float16x4_t test_vld1_lane_f16(float16_t const * a, float16x4_t b) { |
| return vld1_lane_f16(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_f32 |
| // CHECK: vld1.32 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:32] |
| float32x2_t test_vld1_lane_f32(float32_t const * a, float32x2_t b) { |
| return vld1_lane_f32(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_p8 |
| // CHECK: vld1.8 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| poly8x8_t test_vld1_lane_p8(poly8_t const * a, poly8x8_t b) { |
| return vld1_lane_p8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld1_lane_p16 |
| // CHECK: vld1.16 {d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}:16] |
| poly16x4_t test_vld1_lane_p16(poly16_t const * a, poly16x4_t b) { |
| return vld1_lane_p16(a, b, 3); |
| } |
| |
| |
| // CHECK-LABEL: test_vld2q_u8 |
| // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint8x16x2_t test_vld2q_u8(uint8_t const * a) { |
| return vld2q_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_u16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint16x8x2_t test_vld2q_u16(uint16_t const * a) { |
| return vld2q_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_u32 |
| // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint32x4x2_t test_vld2q_u32(uint32_t const * a) { |
| return vld2q_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_s8 |
| // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int8x16x2_t test_vld2q_s8(int8_t const * a) { |
| return vld2q_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_s16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int16x8x2_t test_vld2q_s16(int16_t const * a) { |
| return vld2q_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_s32 |
| // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int32x4x2_t test_vld2q_s32(int32_t const * a) { |
| return vld2q_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_f16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float16x8x2_t test_vld2q_f16(float16_t const * a) { |
| return vld2q_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_f32 |
| // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float32x4x2_t test_vld2q_f32(float32_t const * a) { |
| return vld2q_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_p8 |
| // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly8x16x2_t test_vld2q_p8(poly8_t const * a) { |
| return vld2q_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2q_p16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly16x8x2_t test_vld2q_p16(poly16_t const * a) { |
| return vld2q_p16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_u8 |
| // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint8x8x2_t test_vld2_u8(uint8_t const * a) { |
| return vld2_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_u16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint16x4x2_t test_vld2_u16(uint16_t const * a) { |
| return vld2_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_u32 |
| // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| uint32x2x2_t test_vld2_u32(uint32_t const * a) { |
| return vld2_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_u64 |
| // CHECK: vld1.64 |
| uint64x1x2_t test_vld2_u64(uint64_t const * a) { |
| return vld2_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_s8 |
| // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int8x8x2_t test_vld2_s8(int8_t const * a) { |
| return vld2_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_s16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int16x4x2_t test_vld2_s16(int16_t const * a) { |
| return vld2_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_s32 |
| // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| int32x2x2_t test_vld2_s32(int32_t const * a) { |
| return vld2_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_s64 |
| // CHECK: vld1.64 |
| int64x1x2_t test_vld2_s64(int64_t const * a) { |
| return vld2_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_f16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float16x4x2_t test_vld2_f16(float16_t const * a) { |
| return vld2_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_f32 |
| // CHECK: vld2.32 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| float32x2x2_t test_vld2_f32(float32_t const * a) { |
| return vld2_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_p8 |
| // CHECK: vld2.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly8x8x2_t test_vld2_p8(poly8_t const * a) { |
| return vld2_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_p16 |
| // CHECK: vld2.16 {d{{[0-9]+}}, d{{[0-9]+}}}, [r{{[0-9]+}}] |
| poly16x4x2_t test_vld2_p16(poly16_t const * a) { |
| return vld2_p16(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vld2_dup_u8 |
| // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| uint8x8x2_t test_vld2_dup_u8(uint8_t const * a) { |
| return vld2_dup_u8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_u16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| uint16x4x2_t test_vld2_dup_u16(uint16_t const * a) { |
| return vld2_dup_u16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_u32 |
| // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| uint32x2x2_t test_vld2_dup_u32(uint32_t const * a) { |
| return vld2_dup_u32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_u64 |
| // CHECK: vld1.64 |
| uint64x1x2_t test_vld2_dup_u64(uint64_t const * a) { |
| return vld2_dup_u64(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_s8 |
| // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| int8x8x2_t test_vld2_dup_s8(int8_t const * a) { |
| return vld2_dup_s8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_s16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| int16x4x2_t test_vld2_dup_s16(int16_t const * a) { |
| return vld2_dup_s16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_s32 |
| // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| int32x2x2_t test_vld2_dup_s32(int32_t const * a) { |
| return vld2_dup_s32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_s64 |
| // CHECK: vld1.64 |
| int64x1x2_t test_vld2_dup_s64(int64_t const * a) { |
| return vld2_dup_s64(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_f16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| float16x4x2_t test_vld2_dup_f16(float16_t const * a) { |
| return vld2_dup_f16(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_f32 |
| // CHECK: vld2.32 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| float32x2x2_t test_vld2_dup_f32(float32_t const * a) { |
| return vld2_dup_f32(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_p8 |
| // CHECK: vld2.8 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| poly8x8x2_t test_vld2_dup_p8(poly8_t const * a) { |
| return vld2_dup_p8(a); |
| } |
| |
| // CHECK-LABEL: test_vld2_dup_p16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[], d{{[0-9]+}}[]}, [r{{[0-9]+}}] |
| poly16x4x2_t test_vld2_dup_p16(poly16_t const * a) { |
| return vld2_dup_p16(a); |
| } |
| |
| |
| // CHECK-LABEL: test_vld2q_lane_u16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| uint16x8x2_t test_vld2q_lane_u16(uint16_t const * a, uint16x8x2_t b) { |
| return vld2q_lane_u16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld2q_lane_u32 |
| // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| uint32x4x2_t test_vld2q_lane_u32(uint32_t const * a, uint32x4x2_t b) { |
| return vld2q_lane_u32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld2q_lane_s16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| int16x8x2_t test_vld2q_lane_s16(int16_t const * a, int16x8x2_t b) { |
| return vld2q_lane_s16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld2q_lane_s32 |
| // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| int32x4x2_t test_vld2q_lane_s32(int32_t const * a, int32x4x2_t b) { |
| return vld2q_lane_s32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld2q_lane_f16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| float16x8x2_t test_vld2q_lane_f16(float16_t const * a, float16x8x2_t b) { |
| return vld2q_lane_f16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld2q_lane_f32 |
| // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| float32x4x2_t test_vld2q_lane_f32(float32_t const * a, float32x4x2_t b) { |
| return vld2q_lane_f32(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld2q_lane_p16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| poly16x8x2_t test_vld2q_lane_p16(poly16_t const * a, poly16x8x2_t b) { |
| return vld2q_lane_p16(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld2_lane_u8 |
| // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| uint8x8x2_t test_vld2_lane_u8(uint8_t const * a, uint8x8x2_t b) { |
| return vld2_lane_u8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld2_lane_u16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| uint16x4x2_t test_vld2_lane_u16(uint16_t const * a, uint16x4x2_t b) { |
| return vld2_lane_u16(a, b, 3); |
| } |
| |
| // CHECK-LABEL: test_vld2_lane_u32 |
| // CHECK: vld2.32 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| uint32x2x2_t test_vld2_lane_u32(uint32_t const * a, uint32x2x2_t b) { |
| return vld2_lane_u32(a, b, 1); |
| } |
| |
| // CHECK-LABEL: test_vld2_lane_s8 |
| // CHECK: vld2.8 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| int8x8x2_t test_vld2_lane_s8(int8_t const * a, int8x8x2_t b) { |
| return vld2_lane_s8(a, b, 7); |
| } |
| |
| // CHECK-LABEL: test_vld2_lane_s16 |
| // CHECK: vld2.16 {d{{[0-9]+}}[{{[0-9]+}}], d{{[0-9]+}}[{{[0-9]+}}]}, [r{{[0-9]+}}] |
| int16x4x2_t test_vld2_lane_s16(int16_t const * a, int16x4x2_t b) { |
| return vld2_lane_s16(a, b, 3); |
| } |
| |
|
