205 changes: 205 additions & 0 deletions clang/test/CodeGen/aarch64-sve-intrinsics/acle_sve_qdecp.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,205 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s

#include <arm_sve.h>

#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

int32_t test_svqdecp_n_s32_b8(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s32_b8
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqdecp.n32.nxv16i1(i32 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s32,_b8,)(op, pg);
}

int32_t test_svqdecp_n_s32_b16(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s32_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqdecp.n32.nxv8i1(i32 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s32,_b16,)(op, pg);
}

int32_t test_svqdecp_n_s32_b32(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s32_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqdecp.n32.nxv4i1(i32 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s32,_b32,)(op, pg);
}

int32_t test_svqdecp_n_s32_b64(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s32_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqdecp.n32.nxv2i1(i32 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s32,_b64,)(op, pg);
}

int64_t test_svqdecp_n_s64_b8(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s64_b8
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqdecp.n64.nxv16i1(i64 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s64,_b8,)(op, pg);
}

int64_t test_svqdecp_n_s64_b16(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s64_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqdecp.n64.nxv8i1(i64 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s64,_b16,)(op, pg);
}

int64_t test_svqdecp_n_s64_b32(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s64_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqdecp.n64.nxv4i1(i64 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s64,_b32,)(op, pg);
}

int64_t test_svqdecp_n_s64_b64(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_s64_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqdecp.n64.nxv2i1(i64 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_s64,_b64,)(op, pg);
}

uint32_t test_svqdecp_n_u32_b8(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u32_b8
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqdecp.n32.nxv16i1(i32 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u32,_b8,)(op, pg);
}

uint32_t test_svqdecp_n_u32_b16(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u32_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqdecp.n32.nxv8i1(i32 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u32,_b16,)(op, pg);
}

uint32_t test_svqdecp_n_u32_b32(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u32_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqdecp.n32.nxv4i1(i32 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u32,_b32,)(op, pg);
}

uint32_t test_svqdecp_n_u32_b64(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u32_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqdecp.n32.nxv2i1(i32 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u32,_b64,)(op, pg);
}

uint64_t test_svqdecp_n_u64_b8(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u64_b8
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqdecp.n64.nxv16i1(i64 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u64,_b8,)(op, pg);
}

uint64_t test_svqdecp_n_u64_b16(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u64_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqdecp.n64.nxv8i1(i64 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u64,_b16,)(op, pg);
}

uint64_t test_svqdecp_n_u64_b32(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u64_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqdecp.n64.nxv4i1(i64 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u64,_b32,)(op, pg);
}

uint64_t test_svqdecp_n_u64_b64(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_n_u64_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqdecp.n64.nxv2i1(i64 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_n_u64,_b64,)(op, pg);
}

svint16_t test_svqdecp_s16(svint16_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_s16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqdecp.nxv8i16(<vscale x 8 x i16> %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_s16,,)(op, pg);
}

svint32_t test_svqdecp_s32(svint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_s32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqdecp.nxv4i32(<vscale x 4 x i32> %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_s32,,)(op, pg);
}

svint64_t test_svqdecp_s64(svint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_s64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqdecp.nxv2i64(<vscale x 2 x i64> %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_s64,,)(op, pg);
}

svuint16_t test_svqdecp_u16(svuint16_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_u16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.uqdecp.nxv8i16(<vscale x 8 x i16> %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_u16,,)(op, pg);
}

svuint32_t test_svqdecp_u32(svuint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_u32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.uqdecp.nxv4i32(<vscale x 4 x i32> %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_u32,,)(op, pg);
}

svuint64_t test_svqdecp_u64(svuint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqdecp_u64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.uqdecp.nxv2i64(<vscale x 2 x i64> %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqdecp,_u64,,)(op, pg);
}
205 changes: 205 additions & 0 deletions clang/test/CodeGen/aarch64-sve-intrinsics/acle_sve_qincp.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,205 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s

#include <arm_sve.h>

#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

int32_t test_svqincp_n_s32_b8(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s32_b8
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqincp.n32.nxv16i1(i32 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s32,_b8,)(op, pg);
}

int32_t test_svqincp_n_s32_b16(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s32_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqincp.n32.nxv8i1(i32 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s32,_b16,)(op, pg);
}

int32_t test_svqincp_n_s32_b32(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s32_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqincp.n32.nxv4i1(i32 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s32,_b32,)(op, pg);
}

int32_t test_svqincp_n_s32_b64(int32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s32_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.sqincp.n32.nxv2i1(i32 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s32,_b64,)(op, pg);
}

int64_t test_svqincp_n_s64_b8(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s64_b8
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqincp.n64.nxv16i1(i64 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s64,_b8,)(op, pg);
}

int64_t test_svqincp_n_s64_b16(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s64_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqincp.n64.nxv8i1(i64 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s64,_b16,)(op, pg);
}

int64_t test_svqincp_n_s64_b32(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s64_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqincp.n64.nxv4i1(i64 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s64,_b32,)(op, pg);
}

int64_t test_svqincp_n_s64_b64(int64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_s64_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.sqincp.n64.nxv2i1(i64 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_s64,_b64,)(op, pg);
}

uint32_t test_svqincp_n_u32_b8(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u32_b8
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqincp.n32.nxv16i1(i32 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u32,_b8,)(op, pg);
}

uint32_t test_svqincp_n_u32_b16(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u32_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqincp.n32.nxv8i1(i32 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u32,_b16,)(op, pg);
}

uint32_t test_svqincp_n_u32_b32(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u32_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqincp.n32.nxv4i1(i32 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u32,_b32,)(op, pg);
}

uint32_t test_svqincp_n_u32_b64(uint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u32_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.uqincp.n32.nxv2i1(i32 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i32 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u32,_b64,)(op, pg);
}

uint64_t test_svqincp_n_u64_b8(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u64_b8
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqincp.n64.nxv16i1(i64 %op, <vscale x 16 x i1> %pg)
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u64,_b8,)(op, pg);
}

uint64_t test_svqincp_n_u64_b16(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u64_b16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqincp.n64.nxv8i1(i64 %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u64,_b16,)(op, pg);
}

uint64_t test_svqincp_n_u64_b32(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u64_b32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqincp.n64.nxv4i1(i64 %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u64,_b32,)(op, pg);
}

uint64_t test_svqincp_n_u64_b64(uint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_n_u64_b64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.uqincp.n64.nxv2i1(i64 %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret i64 %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_n_u64,_b64,)(op, pg);
}

svint16_t test_svqincp_s16(svint16_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_s16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqincp.nxv8i16(<vscale x 8 x i16> %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_s16,,)(op, pg);
}

svint32_t test_svqincp_s32(svint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_s32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqincp.nxv4i32(<vscale x 4 x i32> %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_s32,,)(op, pg);
}

svint64_t test_svqincp_s64(svint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_s64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqincp.nxv2i64(<vscale x 2 x i64> %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_s64,,)(op, pg);
}

svuint16_t test_svqincp_u16(svuint16_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_u16
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.uqincp.nxv8i16(<vscale x 8 x i16> %op, <vscale x 8 x i1> %[[PG]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_u16,,)(op, pg);
}

svuint32_t test_svqincp_u32(svuint32_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_u32
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.uqincp.nxv4i32(<vscale x 4 x i32> %op, <vscale x 4 x i1> %[[PG]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_u32,,)(op, pg);
}

svuint64_t test_svqincp_u64(svuint64_t op, svbool_t pg)
{
// CHECK-LABEL: test_svqincp_u64
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.uqincp.nxv2i64(<vscale x 2 x i64> %op, <vscale x 2 x i1> %[[PG]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
return SVE_ACLE_FUNC(svqincp,_u64,,)(op, pg);
}
181 changes: 181 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_aba.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,181 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=error %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify=overload -verify-ignore-unexpected=error %s

#include <arm_sve.h>

#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

svint8_t test_svaba_s8(svint8_t op1, svint8_t op2, svint8_t op3)
{
// CHECK-LABEL: test_svaba_s8
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.saba.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %op3)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_s8'}}
return SVE_ACLE_FUNC(svaba,_s8,,)(op1, op2, op3);
}

svint16_t test_svaba_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// CHECK-LABEL: test_svaba_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.saba.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_s16'}}
return SVE_ACLE_FUNC(svaba,_s16,,)(op1, op2, op3);
}

svint32_t test_svaba_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// CHECK-LABEL: test_svaba_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.saba.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_s32'}}
return SVE_ACLE_FUNC(svaba,_s32,,)(op1, op2, op3);
}

svint64_t test_svaba_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// CHECK-LABEL: test_svaba_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.saba.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_s64'}}
return SVE_ACLE_FUNC(svaba,_s64,,)(op1, op2, op3);
}

svuint8_t test_svaba_u8(svuint8_t op1, svuint8_t op2, svuint8_t op3)
{
// CHECK-LABEL: test_svaba_u8
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.uaba.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %op3)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_u8'}}
return SVE_ACLE_FUNC(svaba,_u8,,)(op1, op2, op3);
}

svuint16_t test_svaba_u16(svuint16_t op1, svuint16_t op2, svuint16_t op3)
{
// CHECK-LABEL: test_svaba_u16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.uaba.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_u16'}}
return SVE_ACLE_FUNC(svaba,_u16,,)(op1, op2, op3);
}

svuint32_t test_svaba_u32(svuint32_t op1, svuint32_t op2, svuint32_t op3)
{
// CHECK-LABEL: test_svaba_u32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.uaba.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_u32'}}
return SVE_ACLE_FUNC(svaba,_u32,,)(op1, op2, op3);
}

svuint64_t test_svaba_u64(svuint64_t op1, svuint64_t op2, svuint64_t op3)
{
// CHECK-LABEL: test_svaba_u64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.uaba.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_u64'}}
return SVE_ACLE_FUNC(svaba,_u64,,)(op1, op2, op3);
}

svint8_t test_svaba_n_s8(svint8_t op1, svint8_t op2, int8_t op3)
{
// CHECK-LABEL: test_svaba_n_s8
// CHECK: %[[DUP:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.dup.x.nxv16i8(i8 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.saba.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %[[DUP]])
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_s8'}}
return SVE_ACLE_FUNC(svaba,_n_s8,,)(op1, op2, op3);
}

svint16_t test_svaba_n_s16(svint16_t op1, svint16_t op2, int16_t op3)
{
// CHECK-LABEL: test_svaba_n_s16
// CHECK: %[[DUP:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.dup.x.nxv8i16(i16 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.saba.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %[[DUP]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_s16'}}
return SVE_ACLE_FUNC(svaba,_n_s16,,)(op1, op2, op3);
}

svint32_t test_svaba_n_s32(svint32_t op1, svint32_t op2, int32_t op3)
{
// CHECK-LABEL: test_svaba_n_s32
// CHECK: %[[DUP:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.saba.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %[[DUP]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_s32'}}
return SVE_ACLE_FUNC(svaba,_n_s32,,)(op1, op2, op3);
}

svint64_t test_svaba_n_s64(svint64_t op1, svint64_t op2, int64_t op3)
{
// CHECK-LABEL: test_svaba_n_s64
// CHECK: %[[DUP:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.dup.x.nxv2i64(i64 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.saba.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %[[DUP]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_s64'}}
return SVE_ACLE_FUNC(svaba,_n_s64,,)(op1, op2, op3);
}

svuint8_t test_svaba_n_u8(svuint8_t op1, svuint8_t op2, uint8_t op3)
{
// CHECK-LABEL: test_svaba_n_u8
// CHECK: %[[DUP:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.dup.x.nxv16i8(i8 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.uaba.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %[[DUP]])
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_u8'}}
return SVE_ACLE_FUNC(svaba,_n_u8,,)(op1, op2, op3);
}

svuint16_t test_svaba_n_u16(svuint16_t op1, svuint16_t op2, uint16_t op3)
{
// CHECK-LABEL: test_svaba_n_u16
// CHECK: %[[DUP:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.dup.x.nxv8i16(i16 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.uaba.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %[[DUP]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_u16'}}
return SVE_ACLE_FUNC(svaba,_n_u16,,)(op1, op2, op3);
}

svuint32_t test_svaba_n_u32(svuint32_t op1, svuint32_t op2, uint32_t op3)
{
// CHECK-LABEL: test_svaba_n_u32
// CHECK: %[[DUP:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.uaba.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %[[DUP]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_u32'}}
return SVE_ACLE_FUNC(svaba,_n_u32,,)(op1, op2, op3);
}

svuint64_t test_svaba_n_u64(svuint64_t op1, svuint64_t op2, uint64_t op3)
{
// CHECK-LABEL: test_svaba_n_u64
// CHECK: %[[DUP:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.dup.x.nxv2i64(i64 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.uaba.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %[[DUP]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svaba'}}
// expected-warning@+1 {{implicit declaration of function 'svaba_n_u64'}}
return SVE_ACLE_FUNC(svaba,_n_u64,,)(op1, op2, op3);
}
569 changes: 569 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_hadd.c
View file

Large diffs are not rendered by default.

569 changes: 569 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_hsub.c
View file

Large diffs are not rendered by default.

568 changes: 568 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_hsubr.c
View file

Large diffs are not rendered by default.

142 changes: 142 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qabs.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,142 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=error %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify=overload -verify-ignore-unexpected=error %s

#include <arm_sve.h>

#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

svint8_t test_svqabs_s8_z(svbool_t pg, svint8_t op)
{
// CHECK-LABEL: test_svqabs_s8_z
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqabs.nxv16i8(<vscale x 16 x i8> zeroinitializer, <vscale x 16 x i1> %pg, <vscale x 16 x i8> %op)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s8_z'}}
return SVE_ACLE_FUNC(svqabs,_s8,_z,)(pg, op);
}

svint16_t test_svqabs_s16_z(svbool_t pg, svint16_t op)
{
// CHECK-LABEL: test_svqabs_s16_z
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqabs.nxv8i16(<vscale x 8 x i16> zeroinitializer, <vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s16_z'}}
return SVE_ACLE_FUNC(svqabs,_s16,_z,)(pg, op);
}

svint32_t test_svqabs_s32_z(svbool_t pg, svint32_t op)
{
// CHECK-LABEL: test_svqabs_s32_z
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqabs.nxv4i32(<vscale x 4 x i32> zeroinitializer, <vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s32_z'}}
return SVE_ACLE_FUNC(svqabs,_s32,_z,)(pg, op);
}

svint64_t test_svqabs_s64_z(svbool_t pg, svint64_t op)
{
// CHECK-LABEL: test_svqabs_s64_z
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqabs.nxv2i64(<vscale x 2 x i64> zeroinitializer, <vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s64_z'}}
return SVE_ACLE_FUNC(svqabs,_s64,_z,)(pg, op);
}

svint8_t test_svqabs_s8_m(svint8_t inactive, svbool_t pg, svint8_t op)
{
// CHECK-LABEL: test_svqabs_s8_m
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqabs.nxv16i8(<vscale x 16 x i8> %inactive, <vscale x 16 x i1> %pg, <vscale x 16 x i8> %op)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s8_m'}}
return SVE_ACLE_FUNC(svqabs,_s8,_m,)(inactive, pg, op);
}

svint16_t test_svqabs_s16_m(svint16_t inactive, svbool_t pg, svint16_t op)
{
// CHECK-LABEL: test_svqabs_s16_m
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqabs.nxv8i16(<vscale x 8 x i16> %inactive, <vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s16_m'}}
return SVE_ACLE_FUNC(svqabs,_s16,_m,)(inactive, pg, op);
}

svint32_t test_svqabs_s32_m(svint32_t inactive, svbool_t pg, svint32_t op)
{
// CHECK-LABEL: test_svqabs_s32_m
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqabs.nxv4i32(<vscale x 4 x i32> %inactive, <vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s32_m'}}
return SVE_ACLE_FUNC(svqabs,_s32,_m,)(inactive, pg, op);
}

svint64_t test_svqabs_s64_m(svint64_t inactive, svbool_t pg, svint64_t op)
{
// CHECK-LABEL: test_svqabs_s64_m
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqabs.nxv2i64(<vscale x 2 x i64> %inactive, <vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s64_m'}}
return SVE_ACLE_FUNC(svqabs,_s64,_m,)(inactive, pg, op);
}

svint8_t test_svqabs_s8_x(svbool_t pg, svint8_t op)
{
// CHECK-LABEL: test_svqabs_s8_x
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqabs.nxv16i8(<vscale x 16 x i8> undef, <vscale x 16 x i1> %pg, <vscale x 16 x i8> %op)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s8_x'}}
return SVE_ACLE_FUNC(svqabs,_s8,_x,)(pg, op);
}

svint16_t test_svqabs_s16_x(svbool_t pg, svint16_t op)
{
// CHECK-LABEL: test_svqabs_s16_x
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqabs.nxv8i16(<vscale x 8 x i16> undef, <vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s16_x'}}
return SVE_ACLE_FUNC(svqabs,_s16,_x,)(pg, op);
}

svint32_t test_svqabs_s32_x(svbool_t pg, svint32_t op)
{
// CHECK-LABEL: test_svqabs_s32_x
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqabs.nxv4i32(<vscale x 4 x i32> undef, <vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s32_x'}}
return SVE_ACLE_FUNC(svqabs,_s32,_x,)(pg, op);
}

svint64_t test_svqabs_s64_x(svbool_t pg, svint64_t op)
{
// CHECK-LABEL: test_svqabs_s64_x
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqabs.nxv2i64(<vscale x 2 x i64> undef, <vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqabs_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqabs_s64_x'}}
return SVE_ACLE_FUNC(svqabs,_s64,_x,)(pg, op);
}
568 changes: 568 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qadd.c
View file

Large diffs are not rendered by default.

157 changes: 157 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qdmulh.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,157 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=error %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify=overload -verify-ignore-unexpected=error %s

#include <arm_sve.h>

#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

svint8_t test_svqdmulh_s8(svint8_t op1, svint8_t op2)
{
// CHECK-LABEL: test_svqdmulh_s8
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqdmulh.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_s8'}}
return SVE_ACLE_FUNC(svqdmulh,_s8,,)(op1, op2);
}

svint16_t test_svqdmulh_s16(svint16_t op1, svint16_t op2)
{
// CHECK-LABEL: test_svqdmulh_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqdmulh.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_s16'}}
return SVE_ACLE_FUNC(svqdmulh,_s16,,)(op1, op2);
}

svint32_t test_svqdmulh_s32(svint32_t op1, svint32_t op2)
{
// CHECK-LABEL: test_svqdmulh_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqdmulh.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_s32'}}
return SVE_ACLE_FUNC(svqdmulh,_s32,,)(op1, op2);
}

svint64_t test_svqdmulh_s64(svint64_t op1, svint64_t op2)
{
// CHECK-LABEL: test_svqdmulh_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqdmulh.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_s64'}}
return SVE_ACLE_FUNC(svqdmulh,_s64,,)(op1, op2);
}

svint8_t test_svqdmulh_n_s8(svint8_t op1, int8_t op2)
{
// CHECK-LABEL: test_svqdmulh_n_s8
// CHECK: %[[DUP:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.dup.x.nxv16i8(i8 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqdmulh.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %[[DUP]])
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_n_s8'}}
return SVE_ACLE_FUNC(svqdmulh,_n_s8,,)(op1, op2);
}

svint16_t test_svqdmulh_n_s16(svint16_t op1, int16_t op2)
{
// CHECK-LABEL: test_svqdmulh_n_s16
// CHECK: %[[DUP:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.dup.x.nxv8i16(i16 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqdmulh.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %[[DUP]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_n_s16'}}
return SVE_ACLE_FUNC(svqdmulh,_n_s16,,)(op1, op2);
}

svint32_t test_svqdmulh_n_s32(svint32_t op1, int32_t op2)
{
// CHECK-LABEL: test_svqdmulh_n_s32
// CHECK: %[[DUP:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqdmulh.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %[[DUP]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_n_s32'}}
return SVE_ACLE_FUNC(svqdmulh,_n_s32,,)(op1, op2);
}

svint64_t test_svqdmulh_n_s64(svint64_t op1, int64_t op2)
{
// CHECK-LABEL: test_svqdmulh_n_s64
// CHECK: %[[DUP:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.dup.x.nxv2i64(i64 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqdmulh.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %[[DUP]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_n_s64'}}
return SVE_ACLE_FUNC(svqdmulh,_n_s64,,)(op1, op2);
}

svint16_t test_svqdmulh_lane_s16(svint16_t op1, svint16_t op2)
{
// CHECK-LABEL: test_svqdmulh_lane_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqdmulh.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, i32 0)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_lane_s16'}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(op1, op2, 0);
}

svint16_t test_svqdmulh_lane_s16_1(svint16_t op1, svint16_t op2)
{
// CHECK-LABEL: test_svqdmulh_lane_s16_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqdmulh.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, i32 7)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_lane_s16'}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(op1, op2, 7);
}

svint32_t test_svqdmulh_lane_s32(svint32_t op1, svint32_t op2)
{
// CHECK-LABEL: test_svqdmulh_lane_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqdmulh.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, i32 0)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_lane_s32'}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s32,,)(op1, op2, 0);
}

svint32_t test_svqdmulh_lane_s32_1(svint32_t op1, svint32_t op2)
{
// CHECK-LABEL: test_svqdmulh_lane_s32_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqdmulh.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, i32 3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_lane_s32'}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s32,,)(op1, op2, 3);
}

svint64_t test_svqdmulh_lane_s64(svint64_t op1, svint64_t op2)
{
// CHECK-LABEL: test_svqdmulh_lane_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqdmulh.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, i32 0)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_lane_s64'}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s64,,)(op1, op2, 0);
}

svint64_t test_svqdmulh_lane_s64_1(svint64_t op1, svint64_t op2)
{
// CHECK-LABEL: test_svqdmulh_lane_s64_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqdmulh.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, i32 1)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqdmulh_lane_s64'}}
return SVE_ACLE_FUNC(svqdmulh_lane,_s64,,)(op1, op2, 1);
}
142 changes: 142 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qneg.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,142 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=error %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify=overload -verify-ignore-unexpected=error %s

#include <arm_sve.h>

#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

svint8_t test_svqneg_s8_z(svbool_t pg, svint8_t op)
{
// CHECK-LABEL: test_svqneg_s8_z
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqneg.nxv16i8(<vscale x 16 x i8> zeroinitializer, <vscale x 16 x i1> %pg, <vscale x 16 x i8> %op)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s8_z'}}
return SVE_ACLE_FUNC(svqneg,_s8,_z,)(pg, op);
}

svint16_t test_svqneg_s16_z(svbool_t pg, svint16_t op)
{
// CHECK-LABEL: test_svqneg_s16_z
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqneg.nxv8i16(<vscale x 8 x i16> zeroinitializer, <vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s16_z'}}
return SVE_ACLE_FUNC(svqneg,_s16,_z,)(pg, op);
}

svint32_t test_svqneg_s32_z(svbool_t pg, svint32_t op)
{
// CHECK-LABEL: test_svqneg_s32_z
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqneg.nxv4i32(<vscale x 4 x i32> zeroinitializer, <vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s32_z'}}
return SVE_ACLE_FUNC(svqneg,_s32,_z,)(pg, op);
}

svint64_t test_svqneg_s64_z(svbool_t pg, svint64_t op)
{
// CHECK-LABEL: test_svqneg_s64_z
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqneg.nxv2i64(<vscale x 2 x i64> zeroinitializer, <vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s64_z'}}
return SVE_ACLE_FUNC(svqneg,_s64,_z,)(pg, op);
}

svint8_t test_svqneg_s8_m(svint8_t inactive, svbool_t pg, svint8_t op)
{
// CHECK-LABEL: test_svqneg_s8_m
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqneg.nxv16i8(<vscale x 16 x i8> %inactive, <vscale x 16 x i1> %pg, <vscale x 16 x i8> %op)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s8_m'}}
return SVE_ACLE_FUNC(svqneg,_s8,_m,)(inactive, pg, op);
}

svint16_t test_svqneg_s16_m(svint16_t inactive, svbool_t pg, svint16_t op)
{
// CHECK-LABEL: test_svqneg_s16_m
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqneg.nxv8i16(<vscale x 8 x i16> %inactive, <vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s16_m'}}
return SVE_ACLE_FUNC(svqneg,_s16,_m,)(inactive, pg, op);
}

svint32_t test_svqneg_s32_m(svint32_t inactive, svbool_t pg, svint32_t op)
{
// CHECK-LABEL: test_svqneg_s32_m
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqneg.nxv4i32(<vscale x 4 x i32> %inactive, <vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s32_m'}}
return SVE_ACLE_FUNC(svqneg,_s32,_m,)(inactive, pg, op);
}

svint64_t test_svqneg_s64_m(svint64_t inactive, svbool_t pg, svint64_t op)
{
// CHECK-LABEL: test_svqneg_s64_m
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqneg.nxv2i64(<vscale x 2 x i64> %inactive, <vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_m'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s64_m'}}
return SVE_ACLE_FUNC(svqneg,_s64,_m,)(inactive, pg, op);
}

svint8_t test_svqneg_s8_x(svbool_t pg, svint8_t op)
{
// CHECK-LABEL: test_svqneg_s8_x
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqneg.nxv16i8(<vscale x 16 x i8> undef, <vscale x 16 x i1> %pg, <vscale x 16 x i8> %op)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s8_x'}}
return SVE_ACLE_FUNC(svqneg,_s8,_x,)(pg, op);
}

svint16_t test_svqneg_s16_x(svbool_t pg, svint16_t op)
{
// CHECK-LABEL: test_svqneg_s16_x
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqneg.nxv8i16(<vscale x 8 x i16> undef, <vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s16_x'}}
return SVE_ACLE_FUNC(svqneg,_s16,_x,)(pg, op);
}

svint32_t test_svqneg_s32_x(svbool_t pg, svint32_t op)
{
// CHECK-LABEL: test_svqneg_s32_x
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqneg.nxv4i32(<vscale x 4 x i32> undef, <vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s32_x'}}
return SVE_ACLE_FUNC(svqneg,_s32,_x,)(pg, op);
}

svint64_t test_svqneg_s64_x(svbool_t pg, svint64_t op)
{
// CHECK-LABEL: test_svqneg_s64_x
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqneg.nxv2i64(<vscale x 2 x i64> undef, <vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqneg_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqneg_s64_x'}}
return SVE_ACLE_FUNC(svqneg,_s64,_x,)(pg, op);
}
157 changes: 157 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qrdmlah.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,157 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=error %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify=overload -verify-ignore-unexpected=error %s

#include <arm_sve.h>

#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

svint8_t test_svqrdmlah_s8(svint8_t op1, svint8_t op2, svint8_t op3)
{
// CHECK-LABEL: test_svqrdmlah_s8
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqrdmlah.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %op3)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_s8'}}
return SVE_ACLE_FUNC(svqrdmlah,_s8,,)(op1, op2, op3);
}

svint16_t test_svqrdmlah_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// CHECK-LABEL: test_svqrdmlah_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlah.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_s16'}}
return SVE_ACLE_FUNC(svqrdmlah,_s16,,)(op1, op2, op3);
}

svint32_t test_svqrdmlah_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// CHECK-LABEL: test_svqrdmlah_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlah.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_s32'}}
return SVE_ACLE_FUNC(svqrdmlah,_s32,,)(op1, op2, op3);
}

svint64_t test_svqrdmlah_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// CHECK-LABEL: test_svqrdmlah_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlah.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_s64'}}
return SVE_ACLE_FUNC(svqrdmlah,_s64,,)(op1, op2, op3);
}

svint8_t test_svqrdmlah_n_s8(svint8_t op1, svint8_t op2, int8_t op3)
{
// CHECK-LABEL: test_svqrdmlah_n_s8
// CHECK: %[[DUP:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.dup.x.nxv16i8(i8 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqrdmlah.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %[[DUP]])
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_n_s8'}}
return SVE_ACLE_FUNC(svqrdmlah,_n_s8,,)(op1, op2, op3);
}

svint16_t test_svqrdmlah_n_s16(svint16_t op1, svint16_t op2, int16_t op3)
{
// CHECK-LABEL: test_svqrdmlah_n_s16
// CHECK: %[[DUP:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.dup.x.nxv8i16(i16 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlah.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %[[DUP]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_n_s16'}}
return SVE_ACLE_FUNC(svqrdmlah,_n_s16,,)(op1, op2, op3);
}

svint32_t test_svqrdmlah_n_s32(svint32_t op1, svint32_t op2, int32_t op3)
{
// CHECK-LABEL: test_svqrdmlah_n_s32
// CHECK: %[[DUP:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlah.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %[[DUP]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_n_s32'}}
return SVE_ACLE_FUNC(svqrdmlah,_n_s32,,)(op1, op2, op3);
}

svint64_t test_svqrdmlah_n_s64(svint64_t op1, svint64_t op2, int64_t op3)
{
// CHECK-LABEL: test_svqrdmlah_n_s64
// CHECK: %[[DUP:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.dup.x.nxv2i64(i64 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlah.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %[[DUP]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_n_s64'}}
return SVE_ACLE_FUNC(svqrdmlah,_n_s64,,)(op1, op2, op3);
}

svint16_t test_svqrdmlah_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// CHECK-LABEL: test_svqrdmlah_lane_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlah.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3, i32 0)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_lane_s16'}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(op1, op2, op3, 0);
}

svint16_t test_svqrdmlah_lane_s16_1(svint16_t op1, svint16_t op2, svint16_t op3)
{
// CHECK-LABEL: test_svqrdmlah_lane_s16_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlah.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3, i32 7)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_lane_s16'}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(op1, op2, op3, 7);
}

svint32_t test_svqrdmlah_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// CHECK-LABEL: test_svqrdmlah_lane_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlah.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3, i32 0)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_lane_s32'}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s32,,)(op1, op2, op3, 0);
}

svint32_t test_svqrdmlah_lane_s32_1(svint32_t op1, svint32_t op2, svint32_t op3)
{
// CHECK-LABEL: test_svqrdmlah_lane_s32_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlah.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3, i32 3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_lane_s32'}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s32,,)(op1, op2, op3, 3);
}

svint64_t test_svqrdmlah_lane_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// CHECK-LABEL: test_svqrdmlah_lane_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlah.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3, i32 0)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_lane_s64'}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s64,,)(op1, op2, op3, 0);
}

svint64_t test_svqrdmlah_lane_s64_1(svint64_t op1, svint64_t op2, svint64_t op3)
{
// CHECK-LABEL: test_svqrdmlah_lane_s64_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlah.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3, i32 1)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlah_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlah_lane_s64'}}
return SVE_ACLE_FUNC(svqrdmlah_lane,_s64,,)(op1, op2, op3, 1);
}
157 changes: 157 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qrdmlsh.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,157 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=error %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify=overload -verify-ignore-unexpected=error %s

#include <arm_sve.h>

#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

svint8_t test_svqrdmlsh_s8(svint8_t op1, svint8_t op2, svint8_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_s8
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqrdmlsh.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %op3)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_s8'}}
return SVE_ACLE_FUNC(svqrdmlsh,_s8,,)(op1, op2, op3);
}

svint16_t test_svqrdmlsh_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlsh.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_s16'}}
return SVE_ACLE_FUNC(svqrdmlsh,_s16,,)(op1, op2, op3);
}

svint32_t test_svqrdmlsh_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlsh.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_s32'}}
return SVE_ACLE_FUNC(svqrdmlsh,_s32,,)(op1, op2, op3);
}

svint64_t test_svqrdmlsh_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlsh.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_s64'}}
return SVE_ACLE_FUNC(svqrdmlsh,_s64,,)(op1, op2, op3);
}

svint8_t test_svqrdmlsh_n_s8(svint8_t op1, svint8_t op2, int8_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_n_s8
// CHECK: %[[DUP:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.dup.x.nxv16i8(i8 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqrdmlsh.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2, <vscale x 16 x i8> %[[DUP]])
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_n_s8'}}
return SVE_ACLE_FUNC(svqrdmlsh,_n_s8,,)(op1, op2, op3);
}

svint16_t test_svqrdmlsh_n_s16(svint16_t op1, svint16_t op2, int16_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_n_s16
// CHECK: %[[DUP:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.dup.x.nxv8i16(i16 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlsh.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %[[DUP]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_n_s16'}}
return SVE_ACLE_FUNC(svqrdmlsh,_n_s16,,)(op1, op2, op3);
}

svint32_t test_svqrdmlsh_n_s32(svint32_t op1, svint32_t op2, int32_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_n_s32
// CHECK: %[[DUP:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlsh.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %[[DUP]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_n_s32'}}
return SVE_ACLE_FUNC(svqrdmlsh,_n_s32,,)(op1, op2, op3);
}

svint64_t test_svqrdmlsh_n_s64(svint64_t op1, svint64_t op2, int64_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_n_s64
// CHECK: %[[DUP:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.dup.x.nxv2i64(i64 %op3)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlsh.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %[[DUP]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_n_s64'}}
return SVE_ACLE_FUNC(svqrdmlsh,_n_s64,,)(op1, op2, op3);
}

svint16_t test_svqrdmlsh_lane_s16(svint16_t op1, svint16_t op2, svint16_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_lane_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlsh.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3, i32 0)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_lane_s16'}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(op1, op2, op3, 0);
}

svint16_t test_svqrdmlsh_lane_s16_1(svint16_t op1, svint16_t op2, svint16_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_lane_s16_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmlsh.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, <vscale x 8 x i16> %op3, i32 7)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_lane_s16'}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(op1, op2, op3, 7);
}

svint32_t test_svqrdmlsh_lane_s32(svint32_t op1, svint32_t op2, svint32_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_lane_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlsh.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3, i32 0)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_lane_s32'}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s32,,)(op1, op2, op3, 0);
}

svint32_t test_svqrdmlsh_lane_s32_1(svint32_t op1, svint32_t op2, svint32_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_lane_s32_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmlsh.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, <vscale x 4 x i32> %op3, i32 3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_lane_s32'}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s32,,)(op1, op2, op3, 3);
}

svint64_t test_svqrdmlsh_lane_s64(svint64_t op1, svint64_t op2, svint64_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_lane_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlsh.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3, i32 0)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_lane_s64'}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s64,,)(op1, op2, op3, 0);
}

svint64_t test_svqrdmlsh_lane_s64_1(svint64_t op1, svint64_t op2, svint64_t op3)
{
// CHECK-LABEL: test_svqrdmlsh_lane_s64_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmlsh.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, <vscale x 2 x i64> %op3, i32 1)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmlsh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmlsh_lane_s64'}}
return SVE_ACLE_FUNC(svqrdmlsh_lane,_s64,,)(op1, op2, op3, 1);
}
157 changes: 157 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qrdmulh.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,157 @@
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -D__ARM_FEATURE_SVE2 -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve2 -fallow-half-arguments-and-returns -S -O1 -Werror -Wall -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify -verify-ignore-unexpected=error %s
// RUN: %clang_cc1 -D__ARM_FEATURE_SVE -DSVE_OVERLOADED_FORMS -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only -verify=overload -verify-ignore-unexpected=error %s

#include <arm_sve.h>

#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

svint8_t test_svqrdmulh_s8(svint8_t op1, svint8_t op2)
{
// CHECK-LABEL: test_svqrdmulh_s8
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqrdmulh.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %op2)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_s8'}}
return SVE_ACLE_FUNC(svqrdmulh,_s8,,)(op1, op2);
}

svint16_t test_svqrdmulh_s16(svint16_t op1, svint16_t op2)
{
// CHECK-LABEL: test_svqrdmulh_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmulh.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_s16'}}
return SVE_ACLE_FUNC(svqrdmulh,_s16,,)(op1, op2);
}

svint32_t test_svqrdmulh_s32(svint32_t op1, svint32_t op2)
{
// CHECK-LABEL: test_svqrdmulh_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmulh.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_s32'}}
return SVE_ACLE_FUNC(svqrdmulh,_s32,,)(op1, op2);
}

svint64_t test_svqrdmulh_s64(svint64_t op1, svint64_t op2)
{
// CHECK-LABEL: test_svqrdmulh_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmulh.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_s64'}}
return SVE_ACLE_FUNC(svqrdmulh,_s64,,)(op1, op2);
}

svint8_t test_svqrdmulh_n_s8(svint8_t op1, int8_t op2)
{
// CHECK-LABEL: test_svqrdmulh_n_s8
// CHECK: %[[DUP:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.dup.x.nxv16i8(i8 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqrdmulh.nxv16i8(<vscale x 16 x i8> %op1, <vscale x 16 x i8> %[[DUP]])
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_n_s8'}}
return SVE_ACLE_FUNC(svqrdmulh,_n_s8,,)(op1, op2);
}

svint16_t test_svqrdmulh_n_s16(svint16_t op1, int16_t op2)
{
// CHECK-LABEL: test_svqrdmulh_n_s16
// CHECK: %[[DUP:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.dup.x.nxv8i16(i16 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmulh.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %[[DUP]])
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_n_s16'}}
return SVE_ACLE_FUNC(svqrdmulh,_n_s16,,)(op1, op2);
}

svint32_t test_svqrdmulh_n_s32(svint32_t op1, int32_t op2)
{
// CHECK-LABEL: test_svqrdmulh_n_s32
// CHECK: %[[DUP:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.dup.x.nxv4i32(i32 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmulh.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %[[DUP]])
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_n_s32'}}
return SVE_ACLE_FUNC(svqrdmulh,_n_s32,,)(op1, op2);
}

svint64_t test_svqrdmulh_n_s64(svint64_t op1, int64_t op2)
{
// CHECK-LABEL: test_svqrdmulh_n_s64
// CHECK: %[[DUP:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.dup.x.nxv2i64(i64 %op2)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmulh.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %[[DUP]])
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_n_s64'}}
return SVE_ACLE_FUNC(svqrdmulh,_n_s64,,)(op1, op2);
}

svint16_t test_svqrdmulh_lane_s16(svint16_t op1, svint16_t op2)
{
// CHECK-LABEL: test_svqrdmulh_lane_s16
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmulh.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, i32 0)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_lane_s16'}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(op1, op2, 0);
}

svint16_t test_svqrdmulh_lane_s16_1(svint16_t op1, svint16_t op2)
{
// CHECK-LABEL: test_svqrdmulh_lane_s16_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqrdmulh.lane.nxv8i16(<vscale x 8 x i16> %op1, <vscale x 8 x i16> %op2, i32 7)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_lane_s16'}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(op1, op2, 7);
}

svint32_t test_svqrdmulh_lane_s32(svint32_t op1, svint32_t op2)
{
// CHECK-LABEL: test_svqrdmulh_lane_s32
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmulh.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, i32 0)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_lane_s32'}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s32,,)(op1, op2, 0);
}

svint32_t test_svqrdmulh_lane_s32_1(svint32_t op1, svint32_t op2)
{
// CHECK-LABEL: test_svqrdmulh_lane_s32_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqrdmulh.lane.nxv4i32(<vscale x 4 x i32> %op1, <vscale x 4 x i32> %op2, i32 3)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_lane_s32'}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s32,,)(op1, op2, 3);
}

svint64_t test_svqrdmulh_lane_s64(svint64_t op1, svint64_t op2)
{
// CHECK-LABEL: test_svqrdmulh_lane_s64
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmulh.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, i32 0)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_lane_s64'}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s64,,)(op1, op2, 0);
}

svint64_t test_svqrdmulh_lane_s64_1(svint64_t op1, svint64_t op2)
{
// CHECK-LABEL: test_svqrdmulh_lane_s64_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqrdmulh.lane.nxv2i64(<vscale x 2 x i64> %op1, <vscale x 2 x i64> %op2, i32 1)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqrdmulh_lane'}}
// expected-warning@+1 {{implicit declaration of function 'svqrdmulh_lane_s64'}}
return SVE_ACLE_FUNC(svqrdmulh_lane,_s64,,)(op1, op2, 1);
}
569 changes: 569 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qrshl.c
View file

Large diffs are not rendered by default.

569 changes: 569 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qshl.c
View file

Large diffs are not rendered by default.

180 changes: 180 additions & 0 deletions clang/test/CodeGen/aarch64-sve2-intrinsics/acle_sve2_qshlu.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,100 @@
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
#endif

svuint8_t test_svqshlu_n_s8_z(svbool_t pg, svint8_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s8_z
// CHECK: %[[SEL:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sel.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %op1, <vscale x 16 x i8> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqshlu.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %[[SEL]], i32 0)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s8_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, op1, 0);
}

svuint8_t test_svqshlu_n_s8_z_1(svbool_t pg, svint8_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s8_z_1
// CHECK: %[[SEL:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sel.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %op1, <vscale x 16 x i8> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqshlu.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %[[SEL]], i32 7)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s8_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, op1, 7);
}

svuint16_t test_svqshlu_n_s16_z(svbool_t pg, svint16_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s16_z
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[SEL:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sel.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op1, <vscale x 8 x i16> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqshlu.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %[[SEL]], i32 0)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s16_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s16,_z,)(pg, op1, 0);
}

svuint16_t test_svqshlu_n_s16_z_1(svbool_t pg, svint16_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s16_z_1
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[SEL:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sel.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op1, <vscale x 8 x i16> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqshlu.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %[[SEL]], i32 15)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s16_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s16,_z,)(pg, op1, 15);
}

svuint32_t test_svqshlu_n_s32_z(svbool_t pg, svint32_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s32_z
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[SEL:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sel.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op1, <vscale x 4 x i32> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqshlu.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %[[SEL]], i32 0)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s32_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s32,_z,)(pg, op1, 0);
}

svuint32_t test_svqshlu_n_s32_z_1(svbool_t pg, svint32_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s32_z_1
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[SEL:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sel.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op1, <vscale x 4 x i32> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqshlu.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %[[SEL]], i32 31)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s32_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s32,_z,)(pg, op1, 31);
}

svuint64_t test_svqshlu_n_s64_z(svbool_t pg, svint64_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s64_z
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[SEL:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sel.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op1, <vscale x 2 x i64> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqshlu.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %[[SEL]], i32 0)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s64_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_z,)(pg, op1, 0);
}

svuint64_t test_svqshlu_n_s64_z_1(svbool_t pg, svint64_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s64_z_1
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[SEL:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sel.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op1, <vscale x 2 x i64> zeroinitializer)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqshlu.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %[[SEL]], i32 63)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_z'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s64_z'}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_z,)(pg, op1, 63);
}

svuint8_t test_svqshlu_n_s8_m(svbool_t pg, svint8_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s8_m
Expand Down Expand Up @@ -97,3 +191,89 @@ svuint64_t test_svqshlu_n_s64_m_1(svbool_t pg, svint64_t op1)
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s64_m'}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_m,)(pg, op1, 63);
}

svuint8_t test_svqshlu_n_s8_x(svbool_t pg, svint8_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s8_x
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqshlu.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %op1, i32 0)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s8_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s8,_x,)(pg, op1, 0);
}

svuint8_t test_svqshlu_n_s8_x_1(svbool_t pg, svint8_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s8_x_1
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.sqshlu.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %op1, i32 7)
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s8_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s8,_x,)(pg, op1, 7);
}

svuint16_t test_svqshlu_n_s16_x(svbool_t pg, svint16_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s16_x
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqshlu.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op1, i32 0)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s16_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s16,_x,)(pg, op1, 0);
}

svuint16_t test_svqshlu_n_s16_x_1(svbool_t pg, svint16_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s16_x_1
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.sqshlu.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %op1, i32 15)
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s16_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s16,_x,)(pg, op1, 15);
}

svuint32_t test_svqshlu_n_s32_x(svbool_t pg, svint32_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s32_x
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqshlu.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op1, i32 0)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s32_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s32,_x,)(pg, op1, 0);
}

svuint32_t test_svqshlu_n_s32_x_1(svbool_t pg, svint32_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s32_x_1
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.sqshlu.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %op1, i32 31)
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s32_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s32,_x,)(pg, op1, 31);
}

svuint64_t test_svqshlu_n_s64_x(svbool_t pg, svint64_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s64_x
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqshlu.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op1, i32 0)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s64_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_x,)(pg, op1, 0);
}

svuint64_t test_svqshlu_n_s64_x_1(svbool_t pg, svint64_t op1)
{
// CHECK-LABEL: test_svqshlu_n_s64_x_1
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.sqshlu.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %op1, i32 63)
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
// overload-warning@+2 {{implicit declaration of function 'svqshlu_x'}}
// expected-warning@+1 {{implicit declaration of function 'svqshlu_n_s64_x'}}
return SVE_ACLE_FUNC(svqshlu,_n_s64,_x,)(pg, op1, 63);
}
Loading