// RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +neon -ffreestanding -fsyntax-only -verify %s
#include <arm_neon.h>
// REQUIRES: aarch64-registered-target
// Widening left-shifts should have a range of 0..(sizeinbits(arg)-1), this range has had
// to be weakened to 0..((sizeinbits(arg)*2)-1) due to a use of vshll_n_s16 with an
// out-of-bounds immediate in the defintiion of vcvt_f32_bf16. As a result, the upper bounds
// of widening left-shift intrinsics are not currently tested here.
void test_vector_shift_left_s8(int8x8_t arg_i8x8, int8x16_t arg_i8x16) {
vshl_n_s8(arg_i8x8, 0);
vshl_n_s8(arg_i8x8, 7);
vshl_n_s8(arg_i8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_s8(arg_i8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s8(arg_i8x16, 0);
vshlq_n_s8(arg_i8x16, 7);
vshlq_n_s8(arg_i8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s8(arg_i8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_s16(int16x4_t arg_i16x4, int16x8_t arg_i16x8) {
vshl_n_s16(arg_i16x4, 0);
vshl_n_s16(arg_i16x4, 15);
vshl_n_s16(arg_i16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_s16(arg_i16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s16(arg_i16x8, 0);
vshlq_n_s16(arg_i16x8, 15);
vshlq_n_s16(arg_i16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s16(arg_i16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_s32(int32x2_t arg_i32x2, int32x4_t arg_i32x4) {
vshl_n_s32(arg_i32x2, 0);
vshl_n_s32(arg_i32x2, 31);
vshl_n_s32(arg_i32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_s32(arg_i32x2, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s32(arg_i32x4, 0);
vshlq_n_s32(arg_i32x4, 31);
vshlq_n_s32(arg_i32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s32(arg_i32x4, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_s64(int64_t arg_i64, int64x2_t arg_i64x2, int64x1_t arg_i64x1) {
vshl_n_s64(arg_i64x1, 0);
vshl_n_s64(arg_i64x1, 63);
vshl_n_s64(arg_i64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_s64(arg_i64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s64(arg_i64x2, 0);
vshlq_n_s64(arg_i64x2, 63);
vshlq_n_s64(arg_i64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_s64(arg_i64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshld_n_s64(arg_i64, 0);
vshld_n_s64(arg_i64, 63);
vshld_n_s64(arg_i64, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshld_n_s64(arg_i64, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_u8(uint8x8_t arg_u8x8, uint8x16_t arg_u8x16) {
vshl_n_u8(arg_u8x8, 0);
vshl_n_u8(arg_u8x8, 7);
vshl_n_u8(arg_u8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_u8(arg_u8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u8(arg_u8x16, 0);
vshlq_n_u8(arg_u8x16, 7);
vshlq_n_u8(arg_u8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u8(arg_u8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_u16(uint16x4_t arg_u16x4, uint16x8_t arg_u16x8) {
vshl_n_u16(arg_u16x4, 0);
vshl_n_u16(arg_u16x4, 15);
vshl_n_u16(arg_u16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_u16(arg_u16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u16(arg_u16x8, 0);
vshlq_n_u16(arg_u16x8, 15);
vshlq_n_u16(arg_u16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u16(arg_u16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_u32(uint32x2_t arg_u32x2, uint32x4_t arg_u32x4) {
vshl_n_u32(arg_u32x2, 0);
vshl_n_u32(arg_u32x2, 31);
vshl_n_u32(arg_u32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_u32(arg_u32x2, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u32(arg_u32x4, 0);
vshlq_n_u32(arg_u32x4, 31);
vshlq_n_u32(arg_u32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u32(arg_u32x4, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_u64(uint64x1_t arg_u64x1, uint64_t arg_u64, uint64x2_t arg_u64x2) {
vshl_n_u64(arg_u64x1, 0);
vshl_n_u64(arg_u64x1, 63);
vshl_n_u64(arg_u64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshl_n_u64(arg_u64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u64(arg_u64x2, 0);
vshlq_n_u64(arg_u64x2, 63);
vshlq_n_u64(arg_u64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshlq_n_u64(arg_u64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshld_n_u64(arg_u64, 0);
vshld_n_u64(arg_u64, 63);
vshld_n_u64(arg_u64, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshld_n_u64(arg_u64, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_s8(int8x8_t arg_i8x8, int8x16_t arg_i8x16, int8_t arg_i8) {
vqshl_n_s8(arg_i8x8, 0);
vqshl_n_s8(arg_i8x8, 7);
vqshl_n_s8(arg_i8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_s8(arg_i8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s8(arg_i8x16, 0);
vqshlq_n_s8(arg_i8x16, 7);
vqshlq_n_s8(arg_i8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s8(arg_i8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlb_n_s8(arg_i8, 0);
vqshlb_n_s8(arg_i8, 7);
vqshlb_n_s8(arg_i8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlb_n_s8(arg_i8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s8(arg_i8x8, 0);
vqshlu_n_s8(arg_i8x8, 7);
vqshlu_n_s8(arg_i8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s8(arg_i8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s8(arg_i8x16, 0);
vqshluq_n_s8(arg_i8x16, 7);
vqshluq_n_s8(arg_i8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s8(arg_i8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlub_n_s8(arg_i8, 0);
vqshlub_n_s8(arg_i8, 7);
vqshlub_n_s8(arg_i8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlub_n_s8(arg_i8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_s16(int16x4_t arg_i16x4, int16_t arg_i16, int16x8_t arg_i16x8) {
vqshl_n_s16(arg_i16x4, 0);
vqshl_n_s16(arg_i16x4, 15);
vqshl_n_s16(arg_i16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_s16(arg_i16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s16(arg_i16x8, 0);
vqshlq_n_s16(arg_i16x8, 15);
vqshlq_n_s16(arg_i16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s16(arg_i16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlh_n_s16(arg_i16, 0);
vqshlh_n_s16(arg_i16, 15);
vqshlh_n_s16(arg_i16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlh_n_s16(arg_i16, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s16(arg_i16x4, 0);
vqshlu_n_s16(arg_i16x4, 15);
vqshlu_n_s16(arg_i16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s16(arg_i16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s16(arg_i16x8, 0);
vqshluq_n_s16(arg_i16x8, 15);
vqshluq_n_s16(arg_i16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s16(arg_i16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluh_n_s16(arg_i16, 0);
vqshluh_n_s16(arg_i16, 15);
vqshluh_n_s16(arg_i16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluh_n_s16(arg_i16, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_s32(int32x2_t arg_i32x2, int32_t arg_i32, int32x4_t arg_i32x4) {
vqshl_n_s32(arg_i32x2, 0);
vqshl_n_s32(arg_i32x2, 31);
vqshl_n_s32(arg_i32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_s32(arg_i32x2, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s32(arg_i32x4, 0);
vqshlq_n_s32(arg_i32x4, 31);
vqshlq_n_s32(arg_i32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s32(arg_i32x4, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshls_n_s32(arg_i32, 0);
vqshls_n_s32(arg_i32, 31);
vqshls_n_s32(arg_i32, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshls_n_s32(arg_i32, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s32(arg_i32x2, 0);
vqshlu_n_s32(arg_i32x2, 31);
vqshlu_n_s32(arg_i32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s32(arg_i32x2, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s32(arg_i32x4, 0);
vqshluq_n_s32(arg_i32x4, 31);
vqshluq_n_s32(arg_i32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s32(arg_i32x4, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlus_n_s32(arg_i32, 0);
vqshlus_n_s32(arg_i32, 31);
vqshlus_n_s32(arg_i32, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlus_n_s32(arg_i32, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_s64(int64_t arg_i64, int64x2_t arg_i64x2, int64x1_t arg_i64x1) {
vqshl_n_s64(arg_i64x1, 0);
vqshl_n_s64(arg_i64x1, 63);
vqshl_n_s64(arg_i64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_s64(arg_i64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s64(arg_i64x2, 0);
vqshlq_n_s64(arg_i64x2, 63);
vqshlq_n_s64(arg_i64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_s64(arg_i64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshld_n_s64(arg_i64, 0);
vqshld_n_s64(arg_i64, 63);
vqshld_n_s64(arg_i64, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshld_n_s64(arg_i64, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s64(arg_i64x1, 0);
vqshlu_n_s64(arg_i64x1, 63);
vqshlu_n_s64(arg_i64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlu_n_s64(arg_i64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s64(arg_i64x2, 0);
vqshluq_n_s64(arg_i64x2, 63);
vqshluq_n_s64(arg_i64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshluq_n_s64(arg_i64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlud_n_s64(arg_i64, 0);
vqshlud_n_s64(arg_i64, 63);
vqshlud_n_s64(arg_i64, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlud_n_s64(arg_i64, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_u8(uint8x8_t arg_u8x8, uint8_t arg_u8, uint8x16_t arg_u8x16) {
vqshl_n_u8(arg_u8x8, 0);
vqshl_n_u8(arg_u8x8, 7);
vqshl_n_u8(arg_u8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_u8(arg_u8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u8(arg_u8x16, 0);
vqshlq_n_u8(arg_u8x16, 7);
vqshlq_n_u8(arg_u8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u8(arg_u8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlb_n_u8(arg_u8, 0);
vqshlb_n_u8(arg_u8, 7);
vqshlb_n_u8(arg_u8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlb_n_u8(arg_u8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_u16(uint16_t arg_u16, uint16x4_t arg_u16x4, uint16x8_t arg_u16x8) {
vqshl_n_u16(arg_u16x4, 0);
vqshl_n_u16(arg_u16x4, 15);
vqshl_n_u16(arg_u16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_u16(arg_u16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u16(arg_u16x8, 0);
vqshlq_n_u16(arg_u16x8, 15);
vqshlq_n_u16(arg_u16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u16(arg_u16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlh_n_u16(arg_u16, 0);
vqshlh_n_u16(arg_u16, 15);
vqshlh_n_u16(arg_u16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlh_n_u16(arg_u16, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_u32(uint32x2_t arg_u32x2, uint32x4_t arg_u32x4, uint32_t arg_u32) {
vqshl_n_u32(arg_u32x2, 0);
vqshl_n_u32(arg_u32x2, 31);
vqshl_n_u32(arg_u32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_u32(arg_u32x2, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u32(arg_u32x4, 0);
vqshlq_n_u32(arg_u32x4, 31);
vqshlq_n_u32(arg_u32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u32(arg_u32x4, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshls_n_u32(arg_u32, 0);
vqshls_n_u32(arg_u32, 31);
vqshls_n_u32(arg_u32, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshls_n_u32(arg_u32, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_saturating_shift_left_u64(uint64x1_t arg_u64x1, uint64_t arg_u64, uint64x2_t arg_u64x2) {
vqshl_n_u64(arg_u64x1, 0);
vqshl_n_u64(arg_u64x1, 63);
vqshl_n_u64(arg_u64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshl_n_u64(arg_u64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u64(arg_u64x2, 0);
vqshlq_n_u64(arg_u64x2, 63);
vqshlq_n_u64(arg_u64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshlq_n_u64(arg_u64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshld_n_u64(arg_u64, 0);
vqshld_n_u64(arg_u64, 63);
vqshld_n_u64(arg_u64, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vqshld_n_u64(arg_u64, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_widen_s8(int8x8_t arg_i8x8, int8x16_t arg_i8x16) {
vshll_n_s8(arg_i8x8, 0);
vshll_n_s8(arg_i8x8, 7);
vshll_n_s8(arg_i8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshll_high_n_s8(arg_i8x16, 0);
vshll_high_n_s8(arg_i8x16, 7);
vshll_high_n_s8(arg_i8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_widen_s16(int16x4_t arg_i16x4, int16x8_t arg_i16x8) {
vshll_n_s16(arg_i16x4, 0);
vshll_n_s16(arg_i16x4, 15);
vshll_n_s16(arg_i16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshll_high_n_s16(arg_i16x8, 0);
vshll_high_n_s16(arg_i16x8, 15);
vshll_high_n_s16(arg_i16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_widen_s32(int32x2_t arg_i32x2, int32x4_t arg_i32x4) {
vshll_n_s32(arg_i32x2, 0);
vshll_n_s32(arg_i32x2, 31);
vshll_n_s32(arg_i32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshll_high_n_s32(arg_i32x4, 0);
vshll_high_n_s32(arg_i32x4, 31);
vshll_high_n_s32(arg_i32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_widen_u8(uint8x8_t arg_u8x8, uint8x16_t arg_u8x16) {
vshll_n_u8(arg_u8x8, 0);
vshll_n_u8(arg_u8x8, 7);
vshll_n_u8(arg_u8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshll_high_n_u8(arg_u8x16, 0);
vshll_high_n_u8(arg_u8x16, 7);
vshll_high_n_u8(arg_u8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_widen_u16(uint16x4_t arg_u16x4, uint16x8_t arg_u16x8) {
vshll_n_u16(arg_u16x4, 0);
vshll_n_u16(arg_u16x4, 15);
vshll_n_u16(arg_u16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshll_high_n_u16(arg_u16x8, 0);
vshll_high_n_u16(arg_u16x8, 15);
vshll_high_n_u16(arg_u16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_widen_u32(uint32x2_t arg_u32x2, uint32x4_t arg_u32x4) {
vshll_n_u32(arg_u32x2, 0);
vshll_n_u32(arg_u32x2, 31);
vshll_n_u32(arg_u32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vshll_high_n_u32(arg_u32x4, 0);
vshll_high_n_u32(arg_u32x4, 31);
vshll_high_n_u32(arg_u32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_s8(int8x8_t arg_i8x8, int8x16_t arg_i8x16) {
vsli_n_s8(arg_i8x8, arg_i8x8, 0);
vsli_n_s8(arg_i8x8, arg_i8x8, 7);
vsli_n_s8(arg_i8x8, arg_i8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_s8(arg_i8x8, arg_i8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s8(arg_i8x16, arg_i8x16, 0);
vsliq_n_s8(arg_i8x16, arg_i8x16, 7);
vsliq_n_s8(arg_i8x16, arg_i8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s8(arg_i8x16, arg_i8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_s16(int16x4_t arg_i16x4, int16x8_t arg_i16x8) {
vsli_n_s16(arg_i16x4, arg_i16x4, 0);
vsli_n_s16(arg_i16x4, arg_i16x4, 15);
vsli_n_s16(arg_i16x4, arg_i16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_s16(arg_i16x4, arg_i16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s16(arg_i16x8, arg_i16x8, 0);
vsliq_n_s16(arg_i16x8, arg_i16x8, 15);
vsliq_n_s16(arg_i16x8, arg_i16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s16(arg_i16x8, arg_i16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_s32(int32x2_t arg_i32x2, int32x4_t arg_i32x4) {
vsli_n_s32(arg_i32x2, arg_i32x2, 0);
vsli_n_s32(arg_i32x2, arg_i32x2, 31);
vsli_n_s32(arg_i32x2, arg_i32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_s32(arg_i32x2, arg_i32x2, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s32(arg_i32x4, arg_i32x4, 0);
vsliq_n_s32(arg_i32x4, arg_i32x4, 31);
vsliq_n_s32(arg_i32x4, arg_i32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s32(arg_i32x4, arg_i32x4, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_s64(int64_t arg_i64, int64x2_t arg_i64x2, int64x1_t arg_i64x1) {
vsli_n_s64(arg_i64x1, arg_i64x1, 0);
vsli_n_s64(arg_i64x1, arg_i64x1, 63);
vsli_n_s64(arg_i64x1, arg_i64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_s64(arg_i64x1, arg_i64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s64(arg_i64x2, arg_i64x2, 0);
vsliq_n_s64(arg_i64x2, arg_i64x2, 63);
vsliq_n_s64(arg_i64x2, arg_i64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_s64(arg_i64x2, arg_i64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vslid_n_s64(arg_i64, arg_i64, 0);
vslid_n_s64(arg_i64, arg_i64, 63);
vslid_n_s64(arg_i64, arg_i64, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vslid_n_s64(arg_i64, arg_i64, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_u8(uint8x8_t arg_u8x8, uint8x16_t arg_u8x16) {
vsli_n_u8(arg_u8x8, arg_u8x8, 0);
vsli_n_u8(arg_u8x8, arg_u8x8, 7);
vsli_n_u8(arg_u8x8, arg_u8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_u8(arg_u8x8, arg_u8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u8(arg_u8x16, arg_u8x16, 0);
vsliq_n_u8(arg_u8x16, arg_u8x16, 7);
vsliq_n_u8(arg_u8x16, arg_u8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u8(arg_u8x16, arg_u8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_u16(uint16x4_t arg_u16x4, uint16x8_t arg_u16x8) {
vsli_n_u16(arg_u16x4, arg_u16x4, 0);
vsli_n_u16(arg_u16x4, arg_u16x4, 15);
vsli_n_u16(arg_u16x4, arg_u16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_u16(arg_u16x4, arg_u16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u16(arg_u16x8, arg_u16x8, 0);
vsliq_n_u16(arg_u16x8, arg_u16x8, 15);
vsliq_n_u16(arg_u16x8, arg_u16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u16(arg_u16x8, arg_u16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_u32(uint32x2_t arg_u32x2, uint32x4_t arg_u32x4) {
vsli_n_u32(arg_u32x2, arg_u32x2, 0);
vsli_n_u32(arg_u32x2, arg_u32x2, 31);
vsli_n_u32(arg_u32x2, arg_u32x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_u32(arg_u32x2, arg_u32x2, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u32(arg_u32x4, arg_u32x4, 0);
vsliq_n_u32(arg_u32x4, arg_u32x4, 31);
vsliq_n_u32(arg_u32x4, arg_u32x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u32(arg_u32x4, arg_u32x4, 32); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_u64(uint64x1_t arg_u64x1, uint64_t arg_u64, uint64x2_t arg_u64x2) {
vsli_n_u64(arg_u64x1, arg_u64x1, 0);
vsli_n_u64(arg_u64x1, arg_u64x1, 63);
vsli_n_u64(arg_u64x1, arg_u64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_u64(arg_u64x1, arg_u64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u64(arg_u64x2, arg_u64x2, 0);
vsliq_n_u64(arg_u64x2, arg_u64x2, 63);
vsliq_n_u64(arg_u64x2, arg_u64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_u64(arg_u64x2, arg_u64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vslid_n_u64(arg_u64, arg_u64, 0);
vslid_n_u64(arg_u64, arg_u64, 63);
vslid_n_u64(arg_u64, arg_u64, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vslid_n_u64(arg_u64, arg_u64, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_p64(poly64x2_t arg_p64x2, poly64x1_t arg_p64x1) {
vsli_n_p64(arg_p64x1, arg_p64x1, 0);
vsli_n_p64(arg_p64x1, arg_p64x1, 63);
vsli_n_p64(arg_p64x1, arg_p64x1, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_p64(arg_p64x1, arg_p64x1, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_p64(arg_p64x2, arg_p64x2, 0);
vsliq_n_p64(arg_p64x2, arg_p64x2, 63);
vsliq_n_p64(arg_p64x2, arg_p64x2, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_p64(arg_p64x2, arg_p64x2, 64); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_p8(poly8x16_t arg_p8x16, poly8x8_t arg_p8x8) {
vsli_n_p8(arg_p8x8, arg_p8x8, 0);
vsli_n_p8(arg_p8x8, arg_p8x8, 7);
vsli_n_p8(arg_p8x8, arg_p8x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_p8(arg_p8x8, arg_p8x8, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_p8(arg_p8x16, arg_p8x16, 0);
vsliq_n_p8(arg_p8x16, arg_p8x16, 7);
vsliq_n_p8(arg_p8x16, arg_p8x16, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_p8(arg_p8x16, arg_p8x16, 8); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
void test_vector_shift_left_and_insert_p16(poly16x4_t arg_p16x4, poly16x8_t arg_p16x8) {
vsli_n_p16(arg_p16x4, arg_p16x4, 0);
vsli_n_p16(arg_p16x4, arg_p16x4, 15);
vsli_n_p16(arg_p16x4, arg_p16x4, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsli_n_p16(arg_p16x4, arg_p16x4, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_p16(arg_p16x8, arg_p16x8, 0);
vsliq_n_p16(arg_p16x8, arg_p16x8, 15);
vsliq_n_p16(arg_p16x8, arg_p16x8, -1); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vsliq_n_p16(arg_p16x8, arg_p16x8, 16); // expected-error-re {{argument value {{.*}} is outside the valid range}}
}
Codebase Browser
llvm