OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity

[Sema][SVE2] Move/simplify Sema testing for SVE2 ACLE builtins 

Currently for SVE2 ACLE builtins, single tests are used to verify both
clang code generation (when the feature is available) and semantic
error/warning messages (when the feature is unavailable). This WIP
patch moves the semantic testing for the values of immediate arguments
into dedicated Sema tests.
This commit is contained in:
Rosie Sumpter 2022-04-12 13:17:49 +01:00
parent de7e539432
commit f7068c82a2
48 changed files with 613 additions and 2422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_cadd.c
View File

@ -1,85 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svcadd_s8(svint8_t op1, svint8_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s8,,)(op1, op2, 0);
}
svint8_t test_svcadd_s8_1(svint8_t op1, svint8_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s8,,)(op1, op2, 272);
}
svint8_t test_svcadd_s8_2(svint8_t op1, svint8_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s8,,)(op1, op2, 91);
}
svint8_t test_svcadd_s8_3(svint8_t op1, svint8_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s8,,)(op1, op2, 180);
}
svint8_t test_svcadd_s8_4(svint8_t op1, svint8_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s8,,)(op1, op2, 271);
}
svint16_t test_svcadd_s16(svint16_t op1, svint16_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s16,,)(op1, op2, 0);
}
svint32_t test_svcadd_s32(svint32_t op1, svint32_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s32,,)(op1, op2, 0);
}
svint64_t test_svcadd_s64(svint64_t op1, svint64_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_s64,,)(op1, op2, 0);
}
svuint8_t test_svcadd_u8(svuint8_t op1, svuint8_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_u8,,)(op1, op2, 0);
}
svuint16_t test_svcadd_u16(svuint16_t op1, svuint16_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_u16,,)(op1, op2, 0);
}
svuint32_t test_svcadd_u32(svuint32_t op1, svuint32_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_u32,,)(op1, op2, 0);
}
svuint64_t test_svcadd_u64(svuint64_t op1, svuint64_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svcadd,_u64,,)(op1, op2, 0);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_cdot.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=warning %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=warning %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svcdot_s32(svint32_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcdot,_s32,,)(op1, op2, op3, 19);
}
svint64_t test_svcdot_s64(svint64_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcdot,_s64,,)(op1, op2, op3, 19);
}
svint32_t test_svcdot_lane_s32(svint32_t op1, svint8_t op2, svint8_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svcdot_lane,_s32,,)(op1, op2, op3, -1, 0);
}
svint32_t test_svcdot_lane_s32_1(svint32_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcdot_lane,_s32,,)(op1, op2, op3, 0, 19);
}
svint64_t test_svcdot_lane_s64(svint64_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svcdot_lane,_s64,,)(op1, op2, op3, -1, 0);
}
svint64_t test_svcdot_lane_s64_1(svint64_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcdot_lane,_s64,,)(op1, op2, op3, 0, 19);
}

188
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_cmla.c
View File

@ -1,188 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svcmla_s8(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s8,,)(op1, op2, op3, 19);
}
svint8_t test_svcmla_s8_1(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s8,,)(op1, op2, op3, 1);
}
svint8_t test_svcmla_s8_2(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s8,,)(op1, op2, op3, 18);
}
svint8_t test_svcmla_s8_3(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s8,,)(op1, op2, op3, 91);
}
svint8_t test_svcmla_s8_4(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s8,,)(op1, op2, op3, 181);
}
svint16_t test_svcmla_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s16,,)(op1, op2, op3, 19);
}
svint32_t test_svcmla_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s32,,)(op1, op2, op3, 19);
}
svint64_t test_svcmla_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_s64,,)(op1, op2, op3, 19);
}
svuint8_t test_svcmla_u8(svuint8_t op1, svuint8_t op2, svuint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_u8,,)(op1, op2, op3, 19);
}
svuint16_t test_svcmla_u16(svuint16_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_u16,,)(op1, op2, op3, 19);
}
svuint32_t test_svcmla_u32(svuint32_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_u32,,)(op1, op2, op3, 19);
}
svuint64_t test_svcmla_u64(svuint64_t op1, svuint64_t op2, svuint64_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla,_u64,,)(op1, op2, op3, 19);
}
svint16_t test_svcmla_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, -1, 0);
}
svint16_t test_svcmla_lane_s16_1(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, 4, 0);
}
svint16_t test_svcmla_lane_s16_2(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, -1, 90);
}
svint16_t test_svcmla_lane_s16_3(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, -1, 180);
}
svint16_t test_svcmla_lane_s16_4(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, -1, 270);
}
svint16_t test_svcmla_lane_s16_5(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, 0, 19);
}
svint16_t test_svcmla_lane_s16_6(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, 1, 19);
}
svint16_t test_svcmla_lane_s16_7(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, 2, 19);
}
svint16_t test_svcmla_lane_s16_8(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, 3, 19);
}
svint16_t test_svcmla_lane_s16_9(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+2 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_s16,,)(op1, op2, op3, 4, 19);
}
svint32_t test_svcmla_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svcmla_lane,_s32,,)(op1, op2, op3, -1, 0);
}
svint32_t test_svcmla_lane_s32_1(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svcmla_lane,_s32,,)(op1, op2, op3, 2, 0);
}
svint32_t test_svcmla_lane_s32_2(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_s32,,)(op1, op2, op3, 1, 19);
}
svuint16_t test_svcmla_lane_u16(svuint16_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svcmla_lane,_u16,,)(op1, op2, op3, -1, 0);
}
svuint16_t test_svcmla_lane_u16_1(svuint16_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_u16,,)(op1, op2, op3, 0, 19);
}
svuint32_t test_svcmla_lane_u32(svuint32_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svcmla_lane,_u32,,)(op1, op2, op3, -1, 0);
}
svuint32_t test_svcmla_lane_u32_1(svuint32_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svcmla_lane,_u32,,)(op1, op2, op3, 0, 19);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mla.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svmla_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmla_lane,_s16,,)(op1, op2, op3, 8);
}
svint32_t test_svmla_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmla_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svmla_lane_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svmla_lane,_s64,,)(op1, op2, op3, 2);
}
svuint16_t test_svmla_lane_u16(svuint16_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmla_lane,_u16,,)(op1, op2, op3, -1);
}
svuint32_t test_svmla_lane_u32(svuint32_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmla_lane,_u32,,)(op1, op2, op3, 4);
}
svuint64_t test_svmla_lane_u64(svuint64_t op1, svuint64_t op2, svuint64_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svmla_lane,_u64,,)(op1, op2, op3, -1);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mlalb.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svmlalb_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalb_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svmlalb_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlalb_lane,_s64,,)(op1, op2, op3, -1);
}
svuint32_t test_svmlalb_lane_u32(svuint32_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalb_lane,_u32,,)(op1, op2, op3, 8);
}
svuint64_t test_svmlalb_lane_u64(svuint64_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlalb_lane,_u64,,)(op1, op2, op3, 4);
}
svfloat32_t test_svmlalb_lane_f32(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalb_lane,_f32,,)(op1, op2, op3, -1);
}
svfloat32_t test_svmlalb_lane_f32_1(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalb_lane,_f32,,)(op1, op2, op3, 8);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mlalt.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svmlalt_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalt_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svmlalt_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlalt_lane,_s64,,)(op1, op2, op3, -1);
}
svuint32_t test_svmlalt_lane_u32(svuint32_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalt_lane,_u32,,)(op1, op2, op3, 8);
}
svuint64_t test_svmlalt_lane_u64(svuint64_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlalt_lane,_u64,,)(op1, op2, op3, 4);
}
svfloat32_t test_svmlalt_lane_f32(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalt_lane,_f32,,)(op1, op2, op3, -1);
}
svfloat32_t test_svmlalt_lane_f32_1(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlalt_lane,_f32,,)(op1, op2, op3, 8);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mls.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svmls_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmls_lane,_s16,,)(op1, op2, op3, -1);
}
svint32_t test_svmls_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmls_lane,_s32,,)(op1, op2, op3, 4);
}
svint64_t test_svmls_lane_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svmls_lane,_s64,,)(op1, op2, op3, -1);
}
svuint16_t test_svmls_lane_u16(svuint16_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmls_lane,_u16,,)(op1, op2, op3, 8);
}
svuint32_t test_svmls_lane_u32(svuint32_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmls_lane,_u32,,)(op1, op2, op3, -1);
}
svuint64_t test_svmls_lane_u64(svuint64_t op1, svuint64_t op2, svuint64_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svmls_lane,_u64,,)(op1, op2, op3, 2);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mlslb.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svmlslb_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslb_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svmlslb_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlslb_lane,_s64,,)(op1, op2, op3, -1);
}
svuint32_t test_svmlslb_lane_u32(svuint32_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslb_lane,_u32,,)(op1, op2, op3, 8);
}
svuint64_t test_svmlslb_lane_u64(svuint64_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlslb_lane,_u64,,)(op1, op2, op3, 4);
}
svfloat32_t test_svmlslb_lane_f32(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslb_lane,_f32,,)(op1, op2, op3, -1);
}
svfloat32_t test_svmlslb_lane_f32_1(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslb_lane,_f32,,)(op1, op2, op3, 8);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mlslt.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svmlslt_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslt_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svmlslt_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlslt_lane,_s64,,)(op1, op2, op3, -1);
}
svuint32_t test_svmlslt_lane_u32(svuint32_t op1, svuint16_t op2, svuint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslt_lane,_u32,,)(op1, op2, op3, 8);
}
svuint64_t test_svmlslt_lane_u64(svuint64_t op1, svuint32_t op2, svuint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmlslt_lane,_u64,,)(op1, op2, op3, 4);
}
svfloat32_t test_svmlslt_lane_f32(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslt_lane,_f32,,)(op1, op2, op3, -1);
}
svfloat32_t test_svmlslt_lane_f32_1(svfloat32_t op1, svfloat16_t op2, svfloat16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmlslt_lane,_f32,,)(op1, op2, op3, 8);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mul.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svmul_lane_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmul_lane,_s16,,)(op1, op2, 8);
}
svint32_t test_svmul_lane_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmul_lane,_s32,,)(op1, op2, -1);
}
svint64_t test_svmul_lane_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svmul_lane,_s64,,)(op1, op2, 2);
}
svuint16_t test_svmul_lane_u16(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmul_lane,_u16,,)(op1, op2, -1);
}
svuint32_t test_svmul_lane_u32(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmul_lane,_u32,,)(op1, op2, 4);
}
svuint64_t test_svmul_lane_u64(svuint64_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svmul_lane,_u64,,)(op1, op2, -1);
}

37
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mullb.c
View File

@ -1,37 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svmullb_lane_s32(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmullb_lane,_s32,,)(op1, op2, -1);
}
svint64_t test_svmullb_lane_s64(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmullb_lane,_s64,,)(op1, op2, 4);
}
svuint32_t test_svmullb_lane_u32(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmullb_lane,_u32,,)(op1, op2, 8);
}
svuint64_t test_svmullb_lane_u64(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmullb_lane,_u64,,)(op1, op2, -1);
}

37
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_mullt.c
View File

@ -1,37 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svmullt_lane_s32(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmullt_lane,_s32,,)(op1, op2, 8);
}
svint64_t test_svmullt_lane_s64(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmullt_lane,_s64,,)(op1, op2, -1);
}
svuint32_t test_svmullt_lane_u32(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svmullt_lane,_u32,,)(op1, op2, -1);
}
svuint64_t test_svmullt_lane_u64(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svmullt_lane,_u64,,)(op1, op2, 4);
}

37
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qcadd.c
View File

@ -1,37 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svqcadd_s8(svint8_t op1, svint8_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svqcadd,_s8,,)(op1, op2, 0);
}
svint16_t test_svqcadd_s16(svint16_t op1, svint16_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svqcadd,_s16,,)(op1, op2, 91);
}
svint32_t test_svqcadd_s32(svint32_t op1, svint32_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svqcadd,_s32,,)(op1, op2, 269);
}
svint64_t test_svqcadd_s64(svint64_t op1, svint64_t op2)
{
// expected-error@+1 {{argument should be the value 90 or 270}}
return SVE_ACLE_FUNC(svqcadd,_s64,,)(op1, op2, 30);
}

25
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qdmlalb.c
View File

@ -1,25 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svqdmlalb_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqdmlalb_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svqdmlalb_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqdmlalb_lane,_s64,,)(op1, op2, op3, 4);
}

25
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qdmlalt.c
View File

@ -1,25 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svqdmlalt_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqdmlalt_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svqdmlalt_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqdmlalt_lane,_s64,,)(op1, op2, op3, 4);
}

25
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qdmlslb.c
View File

@ -1,25 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svqdmlslb_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqdmlslb_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svqdmlslb_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqdmlslb_lane,_s64,,)(op1, op2, op3, 4);
}

25
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qdmlslt.c
View File

@ -1,25 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svqdmlslt_lane_s32(svint32_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqdmlslt_lane,_s32,,)(op1, op2, op3, -1);
}
svint64_t test_svqdmlslt_lane_s64(svint64_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqdmlslt_lane,_s64,,)(op1, op2, op3, 4);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qdmulh.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svqdmulh_lane_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(op1, op2, -1);
}
svint32_t test_svqdmulh_lane_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s32,,)(op1, op2, 4);
}
svint64_t test_svqdmulh_lane_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s64,,)(op1, op2, 2);
}

25
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qdmullb.c
View File

@ -1,25 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svqdmullb_lane_s32(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqdmullb_lane,_s32,,)(op1, op2, -1);
}
svint64_t test_svqdmullb_lane_s64(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqdmullb_lane,_s64,,)(op1, op2, 4);
}

25
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qdmullt.c
View File

@ -1,25 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint32_t test_svqdmullt_lane_s32(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqdmullt_lane,_s32,,)(op1, op2, -1);
}
svint64_t test_svqdmullt_lane_s64(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqdmullt_lane,_s64,,)(op1, op2, -1);
}

115
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrdcmlah.c
View File

@ -1,115 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svqrdcmlah_s8(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(op1, op2, op3, 19);
}
svint8_t test_svqrdcmlah_s8_1(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(op1, op2, op3, 1);
}
svint8_t test_svqrdcmlah_s8_2(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(op1, op2, op3, 18);
}
svint8_t test_svqrdcmlah_s8_3(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(op1, op2, op3, 91);
}
svint8_t test_svqrdcmlah_s8_4(svint8_t op1, svint8_t op2, svint8_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(op1, op2, op3, 181);
}
svint16_t test_svqrdcmlah_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s16,,)(op1, op2, op3, 19);
}
svint32_t test_svqrdcmlah_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s32,,)(op1, op2, op3, 19);
}
svint64_t test_svqrdcmlah_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah,_s64,,)(op1, op2, op3, 19);
}
svint16_t test_svqrdcmlah_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(op1, op2, op3, -1, 0);
}
svint16_t test_svqrdcmlah_lane_s16_1(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(op1, op2, op3, 4, 0);
}
svint16_t test_svqrdcmlah_lane_s16_2(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(op1, op2, op3, -1, 90);
}
svint16_t test_svqrdcmlah_lane_s16_3(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(op1, op2, op3, -1, 180);
}
svint16_t test_svqrdcmlah_lane_s16_4(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(op1, op2, op3, -1, 270);
}
svint16_t test_svqrdcmlah_lane_s16_5(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(op1, op2, op3, 0, 19);
}
svint16_t test_svqrdcmlah_lane_s16_6(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(op1, op2, op3, 1, 19);
}
svint32_t test_svqrdcmlah_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s32,,)(op1, op2, op3, 2, 0);
}
svint32_t test_svqrdcmlah_lane_s32_1(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
return SVE_ACLE_FUNC(svqrdcmlah_lane,_s32,,)(op1, op2, op3, 0, 19);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrdmlah.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svqrdmlah_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(op1, op2, op3, -1);
}
svint32_t test_svqrdmlah_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s32,,)(op1, op2, op3, 4);
}
svint64_t test_svqrdmlah_lane_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s64,,)(op1, op2, op3, 2);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrdmlsh.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svqrdmlsh_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(op1, op2, op3, -1);
}
svint32_t test_svqrdmlsh_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s32,,)(op1, op2, op3, 4);
}
svint64_t test_svqrdmlsh_lane_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s64,,)(op1, op2, op3, 2);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrdmulh.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svqrdmulh_lane_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(op1, op2, -1);
}
svint32_t test_svqrdmulh_lane_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s32,,)(op1, op2, 4);
}
svint64_t test_svqrdmulh_lane_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s64,,)(op1, op2, 2);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrshrnb.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svqrshrnb_n_s16(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqrshrnb,_n_s16,,)(op1, 0);
}
svint16_t test_svqrshrnb_n_s32(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqrshrnb,_n_s32,,)(op1, 0);
}
svint32_t test_svqrshrnb_n_s64(svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqrshrnb,_n_s64,,)(op1, 0);
}
svuint8_t test_svqrshrnb_n_u16(svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqrshrnb,_n_u16,,)(op1, 0);
}
svuint16_t test_svqrshrnb_n_u32(svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqrshrnb,_n_u32,,)(op1, 0);
}
svuint32_t test_svqrshrnb_n_u64(svuint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqrshrnb,_n_u64,,)(op1, 0);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrshrnt.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svqrshrnt_n_s16(svint8_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqrshrnt,_n_s16,,)(op1, op2, 0);
}
svint16_t test_svqrshrnt_n_s32(svint16_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqrshrnt,_n_s32,,)(op1, op2, 0);
}
svint32_t test_svqrshrnt_n_s64(svint32_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqrshrnt,_n_s64,,)(op1, op2, 0);
}
svuint8_t test_svqrshrnt_n_u16(svuint8_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqrshrnt,_n_u16,,)(op1, op2, 0);
}
svuint16_t test_svqrshrnt_n_u32(svuint16_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqrshrnt,_n_u32,,)(op1, op2, 0);
}
svuint32_t test_svqrshrnt_n_u64(svuint32_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqrshrnt,_n_u64,,)(op1, op2, 0);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrshrunb.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svuint8_t test_svqrshrunb_n_s16(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqrshrunb,_n_s16,,)(op1, 0);
}
svuint16_t test_svqrshrunb_n_s32(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqrshrunb,_n_s32,,)(op1, 0);
}
svuint32_t test_svqrshrunb_n_s64(svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqrshrunb,_n_s64,,)(op1, 0);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qrshrunt.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svuint8_t test_svqrshrunt_n_s16(svuint8_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqrshrunt,_n_s16,,)(op1, op2, 0);
}
svuint16_t test_svqrshrunt_n_s32(svuint16_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqrshrunt,_n_s32,,)(op1, op2, 0);
}
svuint32_t test_svqrshrunt_n_s64(svuint32_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqrshrunt,_n_s64,,)(op1, op2, 0);
}

85
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qshlu.c
View File

@ -1,85 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svuint8_t test_svqshlu_n_s8_z(svbool_t pg, svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, op1, -1);
}
svuint16_t test_svqshlu_n_s16_z(svbool_t pg, svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svqshlu,_n_s16,_z,)(pg, op1, -1);
}
svuint32_t test_svqshlu_n_s32_z(svbool_t pg, svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svqshlu,_n_s32,_z,)(pg, op1, -1);
}
svuint64_t test_svqshlu_n_s64_z(svbool_t pg, svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_z,)(pg, op1, -1);
}
svuint8_t test_svqshlu_n_s8_m(svbool_t pg, svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqshlu,_n_s8,_m,)(pg, op1, -1);
}
svuint16_t test_svqshlu_n_s16_m(svbool_t pg, svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svqshlu,_n_s16,_m,)(pg, op1, -1);
}
svuint32_t test_svqshlu_n_s32_m(svbool_t pg, svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svqshlu,_n_s32,_m,)(pg, op1, -1);
}
svuint64_t test_svqshlu_n_s64_m(svbool_t pg, svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_m,)(pg, op1, -1);
}
svuint8_t test_svqshlu_n_s8_x(svbool_t pg, svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svqshlu,_n_s8,_x,)(pg, op1, -1);
}
svuint16_t test_svqshlu_n_s16_x(svbool_t pg, svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svqshlu,_n_s16,_x,)(pg, op1, -1);
}
svuint32_t test_svqshlu_n_s32_x(svbool_t pg, svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svqshlu,_n_s32,_x,)(pg, op1, -1);
}
svuint64_t test_svqshlu_n_s64_x(svbool_t pg, svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_x,)(pg, op1, -1);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qshrnb.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svqshrnb_n_s16(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqshrnb,_n_s16,,)(op1, 0);
}
svint16_t test_svqshrnb_n_s32(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqshrnb,_n_s32,,)(op1, 0);
}
svint32_t test_svqshrnb_n_s64(svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqshrnb,_n_s64,,)(op1, 0);
}
svuint8_t test_svqshrnb_n_u16(svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqshrnb,_n_u16,,)(op1, 0);
}
svuint16_t test_svqshrnb_n_u32(svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqshrnb,_n_u32,,)(op1, 0);
}
svuint32_t test_svqshrnb_n_u64(svuint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqshrnb,_n_u64,,)(op1, 0);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qshrnt.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svqshrnt_n_s16(svint8_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqshrnt,_n_s16,,)(op1, op2, 0);
}
svint16_t test_svqshrnt_n_s32(svint16_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqshrnt,_n_s32,,)(op1, op2, 0);
}
svint32_t test_svqshrnt_n_s64(svint32_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqshrnt,_n_s64,,)(op1, op2, 0);
}
svuint8_t test_svqshrnt_n_u16(svuint8_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqshrnt,_n_u16,,)(op1, op2, 0);
}
svuint16_t test_svqshrnt_n_u32(svuint16_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqshrnt,_n_u32,,)(op1, op2, 0);
}
svuint32_t test_svqshrnt_n_u64(svuint32_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqshrnt,_n_u64,,)(op1, op2, 0);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qshrunb.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svuint8_t test_svqshrunb_n_s16(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqshrunb,_n_s16,,)(op1, 0);
}
svuint16_t test_svqshrunb_n_s32(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqshrunb,_n_s32,,)(op1, 0);
}
svuint32_t test_svqshrunb_n_s64(svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqshrunb,_n_s64,,)(op1, 0);
}

31
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_qshrunt.c
View File

@ -1,31 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svuint8_t test_svqshrunt_n_s16(svuint8_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svqshrunt,_n_s16,,)(op1, op2, 0);
}
svuint16_t test_svqshrunt_n_s32(svuint16_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svqshrunt,_n_s32,,)(op1, op2, 0);
}
svuint32_t test_svqshrunt_n_s64(svuint32_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svqshrunt,_n_s64,,)(op1, op2, 0);
}

181
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_rshr.c
View File

@ -1,181 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svrshr_n_s8_z(svbool_t pg, svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshr,_n_s8,_z,)(pg, op1, 0);
}
svint8_t test_svrshr_n_s8_z_1(svbool_t pg, svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshr,_n_s8,_z,)(pg, op1, 9);
}
svint16_t test_svrshr_n_s16_z(svbool_t pg, svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshr,_n_s16,_z,)(pg, op1, 0);
}
svint16_t test_svrshr_n_s16_z_1(svbool_t pg, svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshr,_n_s16,_z,)(pg, op1, 17);
}
svint32_t test_svrshr_n_s32_z(svbool_t pg, svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshr,_n_s32,_z,)(pg, op1, 0);
}
svint32_t test_svrshr_n_s32_z_1(svbool_t pg, svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshr,_n_s32,_z,)(pg, op1, 33);
}
svint64_t test_svrshr_n_s64_z(svbool_t pg, svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrshr,_n_s64,_z,)(pg, op1, 0);
}
svint64_t test_svrshr_n_s64_z_1(svbool_t pg, svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrshr,_n_s64,_z,)(pg, op1, 65);
}
svuint8_t test_svrshr_n_u8_z(svbool_t pg, svuint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshr,_n_u8,_z,)(pg, op1, 0);
}
svuint16_t test_svrshr_n_u16_z(svbool_t pg, svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshr,_n_u16,_z,)(pg, op1, 0);
}
svuint32_t test_svrshr_n_u32_z(svbool_t pg, svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshr,_n_u32,_z,)(pg, op1, 0);
}
svuint64_t test_svrshr_n_u64_z(svbool_t pg, svuint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrshr,_n_u64,_z,)(pg, op1, 0);
}
svint8_t test_svrshr_n_s8_m(svbool_t pg, svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshr,_n_s8,_m,)(pg, op1, 0);
}
svint16_t test_svrshr_n_s16_m(svbool_t pg, svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshr,_n_s16,_m,)(pg, op1, 0);
}
svint32_t test_svrshr_n_s32_m(svbool_t pg, svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshr,_n_s32,_m,)(pg, op1, 0);
}
svint64_t test_svrshr_n_s64_m(svbool_t pg, svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrshr,_n_s64,_m,)(pg, op1, 0);
}
svuint8_t test_svrshr_n_u8_m(svbool_t pg, svuint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshr,_n_u8,_m,)(pg, op1, 0);
}
svuint16_t test_svrshr_n_u16_m(svbool_t pg, svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshr,_n_u16,_m,)(pg, op1, 0);
}
svuint32_t test_svrshr_n_u32_m(svbool_t pg, svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshr,_n_u32,_m,)(pg, op1, 0);
}
svuint64_t test_svrshr_n_u64_m(svbool_t pg, svuint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrshr,_n_u64,_m,)(pg, op1, 0);
}
svint8_t test_svrshr_n_s8_x(svbool_t pg, svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshr,_n_s8,_x,)(pg, op1, 0);
}
svint16_t test_svrshr_n_s16_x(svbool_t pg, svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshr,_n_s16,_x,)(pg, op1, 0);
}
svint32_t test_svrshr_n_s32_x(svbool_t pg, svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshr,_n_s32,_x,)(pg, op1, 0);
}
svint64_t test_svrshr_n_s64_x(svbool_t pg, svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrshr,_n_s64,_x,)(pg, op1, 0);
}
svuint8_t test_svrshr_n_u8_x(svbool_t pg, svuint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshr,_n_u8,_x,)(pg, op1, 0);
}
svuint16_t test_svrshr_n_u16_x(svbool_t pg, svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshr,_n_u16,_x,)(pg, op1, 0);
}
svuint32_t test_svrshr_n_u32_x(svbool_t pg, svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshr,_n_u32,_x,)(pg, op1, 0);
}
svuint64_t test_svrshr_n_u64_x(svbool_t pg, svuint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrshr,_n_u64,_x,)(pg, op1, 0);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_rshrnb.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svrshrnb_n_s16(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshrnb,_n_s16,,)(op1, 0);
}
svint16_t test_svrshrnb_n_s32(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshrnb,_n_s32,,)(op1, 0);
}
svint32_t test_svrshrnb_n_s64(svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshrnb,_n_s64,,)(op1, 0);
}
svuint8_t test_svrshrnb_n_u16(svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshrnb,_n_u16,,)(op1, 0);
}
svuint16_t test_svrshrnb_n_u32(svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshrnb,_n_u32,,)(op1, 0);
}
svuint32_t test_svrshrnb_n_u64(svuint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshrnb,_n_u64,,)(op1, 0);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_rshrnt.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svrshrnt_n_s16(svint8_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshrnt,_n_s16,,)(op1, op2, 0);
}
svint16_t test_svrshrnt_n_s32(svint16_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshrnt,_n_s32,,)(op1, op2, 0);
}
svint32_t test_svrshrnt_n_s64(svint32_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshrnt,_n_s64,,)(op1, op2, 0);
}
svuint8_t test_svrshrnt_n_u16(svuint8_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrshrnt,_n_u16,,)(op1, op2, 0);
}
svuint16_t test_svrshrnt_n_u32(svuint16_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrshrnt,_n_u32,,)(op1, op2, 0);
}
svuint32_t test_svrshrnt_n_u64(svuint32_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrshrnt,_n_u64,,)(op1, op2, 0);
}

61
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_rsra.c
View File

@ -1,61 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svrsra_n_s8(svint8_t op1, svint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrsra,_n_s8,,)(op1, op2, 0);
}
svint16_t test_svrsra_n_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrsra,_n_s16,,)(op1, op2, 0);
}
svint32_t test_svrsra_n_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrsra,_n_s32,,)(op1, op2, 0);
}
svint64_t test_svrsra_n_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrsra,_n_s64,,)(op1, op2, 0);
}
svuint8_t test_svrsra_n_u8(svuint8_t op1, svuint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svrsra,_n_u8,,)(op1, op2, 0);
}
svuint16_t test_svrsra_n_u16(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svrsra,_n_u16,,)(op1, op2, 0);
}
svuint32_t test_svrsra_n_u32(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svrsra,_n_u32,,)(op1, op2, 0);
}
svuint64_t test_svrsra_n_u64(svuint64_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svrsra,_n_u64,,)(op1, op2, 0);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_shllb.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svshllb_n_s16(svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svshllb,_n_s16,,)(op1, -1);
}
svint32_t test_svshllb_n_s32(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svshllb,_n_s32,,)(op1, -1);
}
svint64_t test_svshllb_n_s64(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svshllb,_n_s64,,)(op1, -1);
}
svuint16_t test_svshllb_n_u16(svuint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svshllb,_n_u16,,)(op1, -1);
}
svuint32_t test_svshllb_n_u32(svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svshllb,_n_u32,,)(op1, -1);
}
svuint64_t test_svshllb_n_u64(svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svshllb,_n_u64,,)(op1, -1);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_shllt.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint16_t test_svshllt_n_s16(svint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svshllt,_n_s16,,)(op1, -1);
}
svint32_t test_svshllt_n_s32(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svshllt,_n_s32,,)(op1, -1);
}
svint64_t test_svshllt_n_s64(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svshllt,_n_s64,,)(op1, -1);
}
svuint16_t test_svshllt_n_u16(svuint8_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svshllt,_n_u16,,)(op1, -1);
}
svuint32_t test_svshllt_n_u32(svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svshllt,_n_u32,,)(op1, -1);
}
svuint64_t test_svshllt_n_u64(svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svshllt,_n_u64,,)(op1, -1);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_shrnb.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svshrnb_n_s16(svint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svshrnb,_n_s16,,)(op1, 0);
}
svint16_t test_svshrnb_n_s32(svint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svshrnb,_n_s32,,)(op1, 0);
}
svint32_t test_svshrnb_n_s64(svint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svshrnb,_n_s64,,)(op1, 0);
}
svuint8_t test_svshrnb_n_u16(svuint16_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svshrnb,_n_u16,,)(op1, 0);
}
svuint16_t test_svshrnb_n_u32(svuint32_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svshrnb,_n_u32,,)(op1, 0);
}
svuint32_t test_svshrnb_n_u64(svuint64_t op1)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svshrnb,_n_u64,,)(op1, 0);
}

49
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_shrnt.c
View File

@ -1,49 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svshrnt_n_s16(svint8_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svshrnt,_n_s16,,)(op1, op2, 0);
}
svint16_t test_svshrnt_n_s32(svint16_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svshrnt,_n_s32,,)(op1, op2, 0);
}
svint32_t test_svshrnt_n_s64(svint32_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svshrnt,_n_s64,,)(op1, op2, 0);
}
svuint8_t test_svshrnt_n_u16(svuint8_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svshrnt,_n_u16,,)(op1, op2, 0);
}
svuint16_t test_svshrnt_n_u32(svuint16_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svshrnt,_n_u32,,)(op1, op2, 0);
}
svuint32_t test_svshrnt_n_u64(svuint32_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svshrnt,_n_u64,,)(op1, op2, 0);
}

61
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_sli.c
View File

@ -1,61 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svsli_n_s8(svint8_t op1, svint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svsli,_n_s8,,)(op1, op2, -1);
}
svint16_t test_svsli_n_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svsli,_n_s16,,)(op1, op2, -1);
}
svint32_t test_svsli_n_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svsli,_n_s32,,)(op1, op2, -1);
}
svint64_t test_svsli_n_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
return SVE_ACLE_FUNC(svsli,_n_s64,,)(op1, op2, -1);
}
svuint8_t test_svsli_n_u8(svuint8_t op1, svuint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
return SVE_ACLE_FUNC(svsli,_n_u8,,)(op1, op2, -1);
}
svuint16_t test_svsli_n_u16(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
return SVE_ACLE_FUNC(svsli,_n_u16,,)(op1, op2, -1);
}
svuint32_t test_svsli_n_u32(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
return SVE_ACLE_FUNC(svsli,_n_u32,,)(op1, op2, -1);
}
svuint64_t test_svsli_n_u64(svuint64_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
return SVE_ACLE_FUNC(svsli,_n_u64,,)(op1, op2, -1);
}

61
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_sra.c
View File

@ -1,61 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svsra_n_s8(svint8_t op1, svint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svsra,_n_s8,,)(op1, op2, 0);
}
svint16_t test_svsra_n_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svsra,_n_s16,,)(op1, op2, 0);
}
svint32_t test_svsra_n_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svsra,_n_s32,,)(op1, op2, 0);
}
svint64_t test_svsra_n_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svsra,_n_s64,,)(op1, op2, 0);
}
svuint8_t test_svsra_n_u8(svuint8_t op1, svuint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svsra,_n_u8,,)(op1, op2, 0);
}
svuint16_t test_svsra_n_u16(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svsra,_n_u16,,)(op1, op2, 0);
}
svuint32_t test_svsra_n_u32(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svsra,_n_u32,,)(op1, op2, 0);
}
svuint64_t test_svsra_n_u64(svuint64_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svsra,_n_u64,,)(op1, op2, 0);
}

109
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_sri.c
View File

@ -1,109 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svsri_n_s8(svint8_t op1, svint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svsri,_n_s8,,)(op1, op2, 0);
}
svint16_t test_svsri_n_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svsri,_n_s16,,)(op1, op2, 0);
}
svint32_t test_svsri_n_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svsri,_n_s32,,)(op1, op2, 0);
}
svint64_t test_svsri_n_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svsri,_n_s64,,)(op1, op2, 0);
}
svuint8_t test_svsri_n_u8(svuint8_t op1, svuint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svsri,_n_u8,,)(op1, op2, 0);
}
svuint16_t test_svsri_n_u16(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svsri,_n_u16,,)(op1, op2, 0);
}
svuint32_t test_svsri_n_u32(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svsri,_n_u32,,)(op1, op2, 0);
}
svuint64_t test_svsri_n_u64(svuint64_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svsri,_n_u64,,)(op1, op2, 0);
}
svint8_t test_svsri_n_s8_1(svint8_t op1, svint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svsri,_n_s8,,)(op1, op2, 9);
}
svint16_t test_svsri_n_s16_1(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svsri,_n_s16,,)(op1, op2, 17);
}
svint32_t test_svsri_n_s32_1(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svsri,_n_s32,,)(op1, op2, 33);
}
svint64_t test_svsri_n_s64_1(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svsri,_n_s64,,)(op1, op2, 65);
}
svuint8_t test_svsri_n_u8_1(svuint8_t op1, svuint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svsri,_n_u8,,)(op1, op2, 9);
}
svuint16_t test_svsri_n_u16_1(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svsri,_n_u16,,)(op1, op2, 17);
}
svuint32_t test_svsri_n_u32_1(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svsri,_n_u32,,)(op1, op2, 33);
}
svuint64_t test_svsri_n_u64_1(svuint64_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svsri,_n_u64,,)(op1, op2, 65);
}

85
clang/test/CodeGen/aarch64-sve2-intrinsics/negative/acle_sve2_xar.c
View File

@ -1,85 +0,0 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
svint8_t test_svxar_n_s8(svint8_t op1, svint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svxar,_n_s8,,)(op1, op2, 0);
}
svint8_t test_svxar_n_s8_1(svint8_t op1, svint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svxar,_n_s8,,)(op1, op2, 9);
}
svint16_t test_svxar_n_s16(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svxar,_n_s16,,)(op1, op2, 0);
}
svint16_t test_svxar_n_s16_1(svint16_t op1, svint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svxar,_n_s16,,)(op1, op2, 17);
}
svint32_t test_svxar_n_s32(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svxar,_n_s32,,)(op1, op2, 0);
}
svint32_t test_svxar_n_s32_1(svint32_t op1, svint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svxar,_n_s32,,)(op1, op2, 33);
}
svint64_t test_svxar_n_s64(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svxar,_n_s64,,)(op1, op2, 0);
}
svint64_t test_svxar_n_s64_1(svint64_t op1, svint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svxar,_n_s64,,)(op1, op2, 65);
}
svuint8_t test_svxar_n_u8(svuint8_t op1, svuint8_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
return SVE_ACLE_FUNC(svxar,_n_u8,,)(op1, op2, 0);
}
svuint16_t test_svxar_n_u16(svuint16_t op1, svuint16_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
return SVE_ACLE_FUNC(svxar,_n_u16,,)(op1, op2, 0);
}
svuint32_t test_svxar_n_u32(svuint32_t op1, svuint32_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
return SVE_ACLE_FUNC(svxar,_n_u32,,)(op1, op2, 0);
}
svuint64_t test_svxar_n_u64(svuint64_t op1, svuint64_t op2)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
return SVE_ACLE_FUNC(svxar,_n_u64,,)(op1, op2, 0);
}

183
clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_imm_lane.cpp Normal file
View File

@ -0,0 +1,183 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
void test_range_0_7()
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmla_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmla_lane,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlalb_lane,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlalb_lane,_f32,,)(svundef_f32(), svundef_f16(), svundef_f16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlalt_lane,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlalt_lane,_f32,,)(svundef_f32(), svundef_f16(), svundef_f16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmls_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmls_lane,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlslb_lane,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlslb_lane,_f32,,)(svundef_f32(), svundef_f16(), svundef_f16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlslt_lane,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmlslt_lane,_f32,,)(svundef_f32(), svundef_f16(), svundef_f16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmul_lane,_s16,,)(svundef_s16(), svundef_s16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmul_lane,_u16,,)(svundef_u16(), svundef_u16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmullb_lane,_u32,,)(svundef_u16(), svundef_u16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), 8);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svmullt_lane,_u32,,)(svundef_u16(), svundef_u16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqdmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqdmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqdmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqdmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqdmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqdmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), -1);
}
void test_range_0_3()
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svcdot_lane,_s32,,)(svundef_s32(), svundef_s8(), svundef_s8(), -1, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svcmla_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), -1, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svcmla_lane,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16(), -1, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmla_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmla_lane,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlalb_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlalb_lane,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlalt_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlalt_lane,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmls_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmls_lane,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlslb_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlslb_lane,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlslt_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmlslt_lane,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmul_lane,_s32,,)(svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmul_lane,_u32,,)(svundef_u32(), svundef_u32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmullb_lane,_s64,,)(svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmullb_lane,_u64,,)(svundef_u32(), svundef_u32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmullt_lane,_s64,,)(svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svmullt_lane,_u64,,)(svundef_u32(), svundef_u32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqdmulh_lane,_s32,,)(svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), -1, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqrdmlah_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqdmlalb_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqdmlalt_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqrdmlsh_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqdmlslb_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqdmlslt_lane,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqrdmulh_lane,_s32,,)(svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqdmullb_lane,_s64,,)(svundef_s32(), svundef_s32(), 4);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 3]}}
SVE_ACLE_FUNC(svqdmullt_lane,_s64,,)(svundef_s32(), svundef_s32(), -1);
}
void test_range_0_1()
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svcdot_lane,_s64,,)(svundef_s64(), svundef_s16(), svundef_s16(), -1, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svcmla_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), -1, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svcmla_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 2, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svcmla_lane,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32(), -1, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svmla_lane,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64(), 2);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svmla_lane,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svmls_lane,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svmls_lane,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64(), 2);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svmul_lane,_s64,,)(svundef_s64(), svundef_s64(), 2);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svmul_lane,_u64,,)(svundef_u64(), svundef_u64(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svqdmulh_lane,_s64,,)(svundef_s64(), svundef_s64(), 2);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svqrdcmlah_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 2, 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svqrdmlah_lane,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64(), 2);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svqrdmlsh_lane,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64(), 2);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 1]}}
SVE_ACLE_FUNC(svqrdmulh_lane,_s64,,)(svundef_s64(), svundef_s64(), 2);
}

341
clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_imm_n.cpp Normal file
View File

@ -0,0 +1,341 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
void test_range_0_7(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqshlu,_n_s8,_x,)(pg, svundef_s8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, svundef_s8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svqshlu,_n_s8,_m,)(pg, svundef_s8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svshllb,_n_s16,,)(svundef_s8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svshllb,_n_u16,,)(svundef_u8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svshllt,_n_s16,,)(svundef_s8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svshllt,_n_u16,,)(svundef_u8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svsli,_n_s8,,)(svundef_s8(), svundef_s8(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 7]}}
SVE_ACLE_FUNC(svsli,_n_u8,,)(svundef_u8(), svundef_u8(), -1);
}
void test_range_1_8(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqrshrnb,_n_s16,,)(svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqrshrnb,_n_u16,,)(svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqrshrnt,_n_u16,,)(svundef_u8(), svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqrshrunb,_n_s16,,)(svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqrshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqshrnb,_n_s16,,)(svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqshrnb,_n_u16,,)(svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqshrnt,_n_u16,,)(svundef_u8(), svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqshrunb,_n_s16,,)(svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svqshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshr,_n_s8,_x,)(pg, svundef_s8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshr,_n_s8,_z,)(pg, svundef_s8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshr,_n_s8,_m,)(pg, svundef_s8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshr,_n_u8,_x,)(pg, svundef_u8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshr,_n_u8,_z,)(pg, svundef_u8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshr,_n_u8,_m,)(pg, svundef_u8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshrnb,_n_s16,,)(svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshrnb,_n_u16,,)(svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrshrnt,_n_u16,,)(svundef_u8(), svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrsra,_n_s8,,)(svundef_s8(), svundef_s8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svrsra,_n_u8,,)(svundef_u8(), svundef_u8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svshrnb,_n_s16,,)(svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svshrnb,_n_u16,,)(svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svshrnt,_n_u16,,)(svundef_u8(), svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svsra,_n_s8,,)(svundef_s8(), svundef_s8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svsra,_n_u8,,)(svundef_u8(), svundef_u8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svsri,_n_s8,,)(svundef_s8(), svundef_s8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svsri,_n_u8,,)(svundef_u8(), svundef_u8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svxar,_n_s8,,)(svundef_s8(), svundef_s8(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 8]}}
SVE_ACLE_FUNC(svxar,_n_u8,,)(svundef_u8(), svundef_u8(), 0);
}
void test_range_0_15(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svqshlu,_n_s16,_x,)(pg, svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svqshlu,_n_s16,_z,)(pg, svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svqshlu,_n_s16,_m,)(pg, svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svshllb,_n_s32,,)(svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svshllb,_n_u32,,)(svundef_u16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svshllt,_n_s32,,)(svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svshllt,_n_u32,,)(svundef_u16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svsli,_n_s16,,)(svundef_s16(), svundef_s16(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 15]}}
SVE_ACLE_FUNC(svsli,_n_u16,,)(svundef_u16(), svundef_u16(), -1);
}
void test_range_1_16(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqrshrnb,_n_s32,,)(svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqrshrnb,_n_u32,,)(svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqrshrnt,_n_s32,,)(svundef_s16(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqrshrnt,_n_u32,,)(svundef_u16(), svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqrshrunb,_n_s32,,)(svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqrshrunt,_n_s32,,)(svundef_u16(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqshrnb,_n_s32,,)(svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqshrnb,_n_u32,,)(svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqshrnt,_n_s32,,)(svundef_s16(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqshrnt,_n_u32,,)(svundef_u16(), svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqshrunb,_n_s32,,)(svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svqshrunt,_n_s32,,)(svundef_u16(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshr,_n_s16,_x,)(pg, svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshr,_n_s16,_z,)(pg, svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshr,_n_s16,_m,)(pg, svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshr,_n_u16,_x,)(pg, svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshr,_n_u16,_z,)(pg, svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshr,_n_u16,_m,)(pg, svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshrnb,_n_s32,,)(svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshrnb,_n_u32,,)(svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshrnt,_n_s32,,)(svundef_s16(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrshrnt,_n_u32,,)(svundef_u16(), svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrsra,_n_s16,,)(svundef_s16(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svrsra,_n_u16,,)(svundef_u16(), svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svshrnb,_n_s32,,)(svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svshrnb,_n_u32,,)(svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svshrnt,_n_s32,,)(svundef_s16(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svshrnt,_n_u32,,)(svundef_u16(), svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svsra,_n_s16,,)(svundef_s16(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svsra,_n_u16,,)(svundef_u16(), svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svsri,_n_s16,,)(svundef_s16(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svsri,_n_u16,,)(svundef_u16(), svundef_u16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svxar,_n_s16,,)(svundef_s16(), svundef_s16(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 16]}}
SVE_ACLE_FUNC(svxar,_n_u16,,)(svundef_u16(), svundef_u16(), 0);
}
void test_range_0_31(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svqshlu,_n_s32,_x,)(pg, svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svqshlu,_n_s32,_z,)(pg, svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svqshlu,_n_s32,_m,)(pg, svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svshllb,_n_s64,,)(svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svshllb,_n_u64,,)(svundef_u32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svshllt,_n_s64,,)(svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svshllt,_n_u64,,)(svundef_u32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svsli,_n_s32,,)(svundef_s32(), svundef_s32(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 31]}}
SVE_ACLE_FUNC(svsli,_n_u32,,)(svundef_u32(), svundef_u32(), -1);
}
void test_range_1_32(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqrshrnb,_n_s64,,)(svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqrshrnb,_n_u64,,)(svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqrshrnt,_n_s64,,)(svundef_s32(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqrshrnt,_n_u64,,)(svundef_u32(), svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqrshrunb,_n_s64,,)(svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqrshrunt,_n_s64,,)(svundef_u32(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqshrnb,_n_s64,,)(svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqshrnb,_n_u64,,)(svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqshrnt,_n_s64,,)(svundef_s32(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqshrnt,_n_u64,,)(svundef_u32(), svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqshrunb,_n_s64,,)(svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svqshrunt,_n_s64,,)(svundef_u32(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshr,_n_s32,_x,)(pg, svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshr,_n_s32,_z,)(pg, svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshr,_n_s32,_m,)(pg, svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshr,_n_u32,_x,)(pg, svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshr,_n_u32,_z,)(pg, svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshr,_n_u32,_m,)(pg, svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshrnb,_n_s64,,)(svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshrnb,_n_u64,,)(svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshrnt,_n_s64,,)(svundef_s32(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrshrnt,_n_u64,,)(svundef_u32(), svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrsra,_n_s32,,)(svundef_s32(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svrsra,_n_u32,,)(svundef_u32(), svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svshrnb,_n_s64,,)(svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svshrnb,_n_u64,,)(svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svshrnt,_n_s64,,)(svundef_s32(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svshrnt,_n_u64,,)(svundef_u32(), svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svsra,_n_s32,,)(svundef_s32(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svsra,_n_u32,,)(svundef_u32(), svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svsri,_n_s32,,)(svundef_s32(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svsri,_n_u32,,)(svundef_u32(), svundef_u32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svxar,_n_s32,,)(svundef_s32(), svundef_s32(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 32]}}
SVE_ACLE_FUNC(svxar,_n_u32,,)(svundef_u32(), svundef_u32(), 0);
}
void test_range_0_63(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
SVE_ACLE_FUNC(svqshlu,_n_s64,_x,)(pg, svundef_s64(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
SVE_ACLE_FUNC(svqshlu,_n_s64,_z,)(pg, svundef_s64(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
SVE_ACLE_FUNC(svqshlu,_n_s64,_m,)(pg, svundef_s64(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
SVE_ACLE_FUNC(svsli,_n_s64,,)(svundef_s64(), svundef_s64(), -1);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [0, 63]}}
SVE_ACLE_FUNC(svsli,_n_u64,,)(svundef_u64(), svundef_u64(), -1);
}
void test_range_1_64(svbool_t pg)
{
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrshr,_n_s64,_x,)(pg, svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrshr,_n_s64,_z,)(pg, svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrshr,_n_s64,_m,)(pg, svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrshr,_n_u64,_x,)(pg, svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrshr,_n_u64,_z,)(pg, svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrshr,_n_u64,_m,)(pg, svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrsra,_n_s64,,)(svundef_s64(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svrsra,_n_u64,,)(svundef_u64(), svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svsra,_n_s64,,)(svundef_s64(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svsra,_n_u64,,)(svundef_u64(), svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svsri,_n_s64,,)(svundef_s64(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svsri,_n_u64,,)(svundef_u64(), svundef_u64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svxar,_n_s64,,)(svundef_s64(), svundef_s64(), 0);
// expected-error-re@+1 {{argument value {{[0-9]+}} is outside the valid range [1, 64]}}
SVE_ACLE_FUNC(svxar,_n_u64,,)(svundef_u64(), svundef_u64(), 0);
}

89
clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_imm_rotation.cpp Normal file
View File

@ -0,0 +1,89 @@
// REQUIRES: aarch64-registered-target
// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
// RUN: %clang_cc1 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -fsyntax-only -verify %s
#ifdef SVE_OVERLOADED_FORMS
// A simple used,unused... macro, long enough to represent any SVE builtin.
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
#else
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif
#include <arm_sve.h>
void test_90_270()
{
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_s8,,)(svundef_s8(), svundef_s8(), 0);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_u8,,)(svundef_u8(), svundef_u8(), 180);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_s16,,)(svundef_s16(), svundef_s16(), 0);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_u16,,)(svundef_u16(), svundef_u16(), 180);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_s32,,)(svundef_s32(), svundef_s32(), 0);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_u32,,)(svundef_u32(), svundef_u32(), 180);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_s64,,)(svundef_s64(), svundef_s64(), 0);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svcadd,_u64,,)(svundef_u64(), svundef_u64(), 180);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svqcadd,_s8,,)(svundef_s8(), svundef_s8(), 0);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svqcadd,_s16,,)(svundef_s16(), svundef_s16(), 180);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svqcadd,_s32,,)(svundef_s32(), svundef_s32(), 0);
// expected-error@+1 {{argument should be the value 90 or 270}}
SVE_ACLE_FUNC(svqcadd,_s64,,)(svundef_s64(), svundef_s64(), 180);
}
void test_0_90_180_270()
{
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcdot,_s32,,)(svundef_s32(), svundef_s8(), svundef_s8(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcdot_lane,_s32,,)(svundef_s32(), svundef_s8(), svundef_s8(), 0, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcdot,_s64,,)(svundef_s64(), svundef_s16(), svundef_s16(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcdot_lane,_s64,,)(svundef_s64(), svundef_s16(), svundef_s16(), 0, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 0, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla_lane,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16(), 0, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 1, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla_lane,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32(), 0, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svcmla,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svqrdcmlah,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svqrdcmlah_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 0, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svqrdcmlah,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svqrdcmlah_lane,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32(), 0, 19);
// expected-error@+1 {{argument should be the value 0, 90, 180 or 270}}
SVE_ACLE_FUNC(svqrdcmlah,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64(), 19);
}