Skip to content

Commit 6f588c6

Browse files
sdesmalen-armsdesmalen-arm
committed
[SveEmitter] Add builtins for permutations and selection
This patch adds builtins for: - svlasta and svlastb - svclasta and svclastb - svunpkhi and svunpklo - svuzp1 and svuzp2 - svzip1 and svzip2 - svrev - svsel - svcompact - svsplice - svtbl
1 parent 8f24c4b commit 6f588c6

18 files changed

+2165
-3
lines changed

‎clang/include/clang/Basic/arm_sve.td

Lines changed: 38 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -626,9 +626,6 @@ defm SVMAD : SInstZPZZZ<"svmad", "csilUcUsUiUl", "aarch64_sve_mad">;
626626
defm SVMLA : SInstZPZZZ<"svmla", "csilUcUsUiUl", "aarch64_sve_mla">;
627627
defm SVMLS : SInstZPZZZ<"svmls", "csilUcUsUiUl", "aarch64_sve_mls">;
628628
defm SVMSB : SInstZPZZZ<"svmsb", "csilUcUsUiUl", "aarch64_sve_msb">;
629-
////////////////////////////////////////////////////////////////////////////////
630-
// Permutations and selection
631-
def SVEXT : SInst<"svext[_{d}]", "dddi", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_ext", [], [ImmCheck<2, ImmCheckExtract, 1>]>;
632629

633630
////////////////////////////////////////////////////////////////////////////////
634631
// Shifts
@@ -856,6 +853,44 @@ def SVCVTXNT_F32 : SInst<"svcvtxnt_f32[_f64]", "MMPd", "d", MergeOp1, "aarch6
856853
def SVCADD_M : SInst<"svcadd[_{d}]", "dPddi", "hfd", MergeOp1, "aarch64_sve_fcadd", [], [ImmCheck<3, ImmCheckComplexRot90_270>]>;
857854
def SVCMLA_M : SInst<"svcmla[_{d}]", "dPdddi", "hfd", MergeOp1, "aarch64_sve_fcmla", [], [ImmCheck<4, ImmCheckComplexRotAll90>]>;
858855

856+
////////////////////////////////////////////////////////////////////////////////
857+
// Permutations and selection
858+
859+
def SVCLASTA : SInst<"svclasta[_{d}]", "dPdd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_clasta">;
860+
def SVCLASTA_N : SInst<"svclasta[_n_{d}]", "sPsd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_clasta_n">;
861+
def SVCLASTB : SInst<"svclastb[_{d}]", "dPdd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_clastb">;
862+
def SVCLASTB_N : SInst<"svclastb[_n_{d}]", "sPsd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_clastb_n">;
863+
def SVCOMPACT : SInst<"svcompact[_{d}]", "dPd", "ilUiUlfd", MergeNone, "aarch64_sve_compact">;
864+
// SVDUP_LANE (to land in D78750)
865+
// SVDUPQ_LANE (to land in D78750)
866+
def SVEXT : SInst<"svext[_{d}]", "dddi", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_ext", [], [ImmCheck<2, ImmCheckExtract, 1>]>;
867+
def SVLASTA : SInst<"svlasta[_{d}]", "sPd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_lasta">;
868+
def SVLASTB : SInst<"svlastb[_{d}]", "sPd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_lastb">;
869+
def SVREV : SInst<"svrev[_{d}]", "dd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_rev">;
870+
def SVSEL : SInst<"svsel[_{d}]", "dPdd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_sel">;
871+
def SVSPLICE : SInst<"svsplice[_{d}]", "dPdd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_splice">;
872+
def SVTBL : SInst<"svtbl[_{d}]", "ddu", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_tbl">;
873+
def SVTRN1 : SInst<"svtrn1[_{d}]", "ddd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_trn1">;
874+
def SVTRN2 : SInst<"svtrn2[_{d}]", "ddd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_trn2">;
875+
def SVUNPKHI_S : SInst<"svunpkhi[_{d}]", "dh", "sil", MergeNone, "aarch64_sve_sunpkhi">;
876+
def SVUNPKHI_U : SInst<"svunpkhi[_{d}]", "dh", "UsUiUl", MergeNone, "aarch64_sve_uunpkhi">;
877+
def SVUNPKLO_S : SInst<"svunpklo[_{d}]", "dh", "sil", MergeNone, "aarch64_sve_sunpklo">;
878+
def SVUNPKLO_U : SInst<"svunpklo[_{d}]", "dh", "UsUiUl", MergeNone, "aarch64_sve_uunpklo">;
879+
def SVUZP1 : SInst<"svuzp1[_{d}]", "ddd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_uzp1">;
880+
def SVUZP2 : SInst<"svuzp2[_{d}]", "ddd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_uzp2">;
881+
def SVZIP1 : SInst<"svzip1[_{d}]", "ddd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_zip1">;
882+
def SVZIP2 : SInst<"svzip2[_{d}]", "ddd", "csilUcUsUiUlhfd", MergeNone, "aarch64_sve_zip2">;
883+
884+
def SVREV_B : SInst<"svrev_{d}", "PP", "PcPsPiPl", MergeNone, "aarch64_sve_rev">;
885+
def SVSEL_B : SInst<"svsel[_b]", "PPPP", "Pc", MergeNone, "aarch64_sve_sel">;
886+
def SVTRN1_B : SInst<"svtrn1_{d}", "PPP", "PcPsPiPl", MergeNone, "aarch64_sve_trn1">;
887+
def SVTRN2_B : SInst<"svtrn2_{d}", "PPP", "PcPsPiPl", MergeNone, "aarch64_sve_trn2">;
888+
def SVPUNPKHI : SInst<"svunpkhi[_b]", "PP", "Pc", MergeNone, "aarch64_sve_punpkhi">;
889+
def SVPUNPKLO : SInst<"svunpklo[_b]", "PP", "Pc", MergeNone, "aarch64_sve_punpklo">;
890+
def SVUZP1_B : SInst<"svuzp1_{d}", "PPP", "PcPsPiPl", MergeNone, "aarch64_sve_uzp1">;
891+
def SVUZP2_B : SInst<"svuzp2_{d}", "PPP", "PcPsPiPl", MergeNone, "aarch64_sve_uzp2">;
892+
def SVZIP1_B : SInst<"svzip1_{d}", "PPP", "PcPsPiPl", MergeNone, "aarch64_sve_zip1">;
893+
def SVZIP2_B : SInst<"svzip2_{d}", "PPP", "PcPsPiPl", MergeNone, "aarch64_sve_zip2">;
859894

860895
////////////////////////////////////////////////////////////////////////////////
861896
// Predicate creation

‎clang/test/CodeGen/aarch64-sve-intrinsics/acle_sve_clasta.c

Lines changed: 205 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,205 @@
1+
// 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
2+
// 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
3+
4+
#include <arm_sve.h>
5+
6+
#ifdef SVE_OVERLOADED_FORMS
7+
// A simple used,unused... macro, long enough to represent any SVE builtin.
8+
#define SVE_ACLE_FUNC(A1,A2_UNUSED,A3,A4_UNUSED) A1##A3
9+
#else
10+
#define SVE_ACLE_FUNC(A1,A2,A3,A4) A1##A2##A3##A4
11+
#endif
12+
13+
svint8_t test_svclasta_s8(svbool_t pg, svint8_t fallback, svint8_t data)
14+
{
15+
// CHECK-LABEL: test_svclasta_s8
16+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.clasta.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %fallback, <vscale x 16 x i8> %data)
17+
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
18+
return SVE_ACLE_FUNC(svclasta,_s8,,)(pg, fallback, data);
19+
}
20+
21+
svint16_t test_svclasta_s16(svbool_t pg, svint16_t fallback, svint16_t data)
22+
{
23+
// CHECK-LABEL: test_svclasta_s16
24+
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
25+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.clasta.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %fallback, <vscale x 8 x i16> %data)
26+
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
27+
return SVE_ACLE_FUNC(svclasta,_s16,,)(pg, fallback, data);
28+
}
29+
30+
svint32_t test_svclasta_s32(svbool_t pg, svint32_t fallback, svint32_t data)
31+
{
32+
// CHECK-LABEL: test_svclasta_s32
33+
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
34+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.clasta.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %fallback, <vscale x 4 x i32> %data)
35+
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
36+
return SVE_ACLE_FUNC(svclasta,_s32,,)(pg, fallback, data);
37+
}
38+
39+
svint64_t test_svclasta_s64(svbool_t pg, svint64_t fallback, svint64_t data)
40+
{
41+
// CHECK-LABEL: test_svclasta_s64
42+
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
43+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.clasta.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %fallback, <vscale x 2 x i64> %data)
44+
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
45+
return SVE_ACLE_FUNC(svclasta,_s64,,)(pg, fallback, data);
46+
}
47+
48+
svuint8_t test_svclasta_u8(svbool_t pg, svuint8_t fallback, svuint8_t data)
49+
{
50+
// CHECK-LABEL: test_svclasta_u8
51+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.clasta.nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %fallback, <vscale x 16 x i8> %data)
52+
// CHECK: ret <vscale x 16 x i8> %[[INTRINSIC]]
53+
return SVE_ACLE_FUNC(svclasta,_u8,,)(pg, fallback, data);
54+
}
55+
56+
svuint16_t test_svclasta_u16(svbool_t pg, svuint16_t fallback, svuint16_t data)
57+
{
58+
// CHECK-LABEL: test_svclasta_u16
59+
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
60+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x i16> @llvm.aarch64.sve.clasta.nxv8i16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x i16> %fallback, <vscale x 8 x i16> %data)
61+
// CHECK: ret <vscale x 8 x i16> %[[INTRINSIC]]
62+
return SVE_ACLE_FUNC(svclasta,_u16,,)(pg, fallback, data);
63+
}
64+
65+
svuint32_t test_svclasta_u32(svbool_t pg, svuint32_t fallback, svuint32_t data)
66+
{
67+
// CHECK-LABEL: test_svclasta_u32
68+
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
69+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x i32> @llvm.aarch64.sve.clasta.nxv4i32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x i32> %fallback, <vscale x 4 x i32> %data)
70+
// CHECK: ret <vscale x 4 x i32> %[[INTRINSIC]]
71+
return SVE_ACLE_FUNC(svclasta,_u32,,)(pg, fallback, data);
72+
}
73+
74+
svuint64_t test_svclasta_u64(svbool_t pg, svuint64_t fallback, svuint64_t data)
75+
{
76+
// CHECK-LABEL: test_svclasta_u64
77+
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
78+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x i64> @llvm.aarch64.sve.clasta.nxv2i64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x i64> %fallback, <vscale x 2 x i64> %data)
79+
// CHECK: ret <vscale x 2 x i64> %[[INTRINSIC]]
80+
return SVE_ACLE_FUNC(svclasta,_u64,,)(pg, fallback, data);
81+
}
82+
83+
svfloat16_t test_svclasta_f16(svbool_t pg, svfloat16_t fallback, svfloat16_t data)
84+
{
85+
// CHECK-LABEL: test_svclasta_f16
86+
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
87+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 8 x half> @llvm.aarch64.sve.clasta.nxv8f16(<vscale x 8 x i1> %[[PG]], <vscale x 8 x half> %fallback, <vscale x 8 x half> %data)
88+
// CHECK: ret <vscale x 8 x half> %[[INTRINSIC]]
89+
return SVE_ACLE_FUNC(svclasta,_f16,,)(pg, fallback, data);
90+
}
91+
92+
svfloat32_t test_svclasta_f32(svbool_t pg, svfloat32_t fallback, svfloat32_t data)
93+
{
94+
// CHECK-LABEL: test_svclasta_f32
95+
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
96+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 4 x float> @llvm.aarch64.sve.clasta.nxv4f32(<vscale x 4 x i1> %[[PG]], <vscale x 4 x float> %fallback, <vscale x 4 x float> %data)
97+
// CHECK: ret <vscale x 4 x float> %[[INTRINSIC]]
98+
return SVE_ACLE_FUNC(svclasta,_f32,,)(pg, fallback, data);
99+
}
100+
101+
svfloat64_t test_svclasta_f64(svbool_t pg, svfloat64_t fallback, svfloat64_t data)
102+
{
103+
// CHECK-LABEL: test_svclasta_f64
104+
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
105+
// CHECK: %[[INTRINSIC:.*]] = call <vscale x 2 x double> @llvm.aarch64.sve.clasta.nxv2f64(<vscale x 2 x i1> %[[PG]], <vscale x 2 x double> %fallback, <vscale x 2 x double> %data)
106+
// CHECK: ret <vscale x 2 x double> %[[INTRINSIC]]
107+
return SVE_ACLE_FUNC(svclasta,_f64,,)(pg, fallback, data);
108+
}
109+
110+
int8_t test_svclasta_n_s8(svbool_t pg, int8_t fallback, svint8_t data)
111+
{
112+
// CHECK-LABEL: test_svclasta_n_s8
113+
// CHECK: %[[INTRINSIC:.*]] = call i8 @llvm.aarch64.sve.clasta.n.nxv16i8(<vscale x 16 x i1> %pg, i8 %fallback, <vscale x 16 x i8> %data)
114+
// CHECK: ret i8 %[[INTRINSIC]]
115+
return SVE_ACLE_FUNC(svclasta,_n_s8,,)(pg, fallback, data);
116+
}
117+
118+
int16_t test_svclasta_n_s16(svbool_t pg, int16_t fallback, svint16_t data)
119+
{
120+
// CHECK-LABEL: test_svclasta_n_s16
121+
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
122+
// CHECK: %[[INTRINSIC:.*]] = call i16 @llvm.aarch64.sve.clasta.n.nxv8i16(<vscale x 8 x i1> %[[PG]], i16 %fallback, <vscale x 8 x i16> %data)
123+
// CHECK: ret i16 %[[INTRINSIC]]
124+
return SVE_ACLE_FUNC(svclasta,_n_s16,,)(pg, fallback, data);
125+
}
126+
127+
int32_t test_svclasta_n_s32(svbool_t pg, int32_t fallback, svint32_t data)
128+
{
129+
// CHECK-LABEL: test_svclasta_n_s32
130+
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
131+
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.clasta.n.nxv4i32(<vscale x 4 x i1> %[[PG]], i32 %fallback, <vscale x 4 x i32> %data)
132+
// CHECK: ret i32 %[[INTRINSIC]]
133+
return SVE_ACLE_FUNC(svclasta,_n_s32,,)(pg, fallback, data);
134+
}
135+
136+
int64_t test_svclasta_n_s64(svbool_t pg, int64_t fallback, svint64_t data)
137+
{
138+
// CHECK-LABEL: test_svclasta_n_s64
139+
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
140+
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.clasta.n.nxv2i64(<vscale x 2 x i1> %[[PG]], i64 %fallback, <vscale x 2 x i64> %data)
141+
// CHECK: ret i64 %[[INTRINSIC]]
142+
return SVE_ACLE_FUNC(svclasta,_n_s64,,)(pg, fallback, data);
143+
}
144+
145+
uint8_t test_svclasta_n_u8(svbool_t pg, uint8_t fallback, svuint8_t data)
146+
{
147+
// CHECK-LABEL: test_svclasta_n_u8
148+
// CHECK: %[[INTRINSIC:.*]] = call i8 @llvm.aarch64.sve.clasta.n.nxv16i8(<vscale x 16 x i1> %pg, i8 %fallback, <vscale x 16 x i8> %data)
149+
// CHECK: ret i8 %[[INTRINSIC]]
150+
return SVE_ACLE_FUNC(svclasta,_n_u8,,)(pg, fallback, data);
151+
}
152+
153+
uint16_t test_svclasta_n_u16(svbool_t pg, uint16_t fallback, svuint16_t data)
154+
{
155+
// CHECK-LABEL: test_svclasta_n_u16
156+
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
157+
// CHECK: %[[INTRINSIC:.*]] = call i16 @llvm.aarch64.sve.clasta.n.nxv8i16(<vscale x 8 x i1> %[[PG]], i16 %fallback, <vscale x 8 x i16> %data)
158+
// CHECK: ret i16 %[[INTRINSIC]]
159+
return SVE_ACLE_FUNC(svclasta,_n_u16,,)(pg, fallback, data);
160+
}
161+
162+
uint32_t test_svclasta_n_u32(svbool_t pg, uint32_t fallback, svuint32_t data)
163+
{
164+
// CHECK-LABEL: test_svclasta_n_u32
165+
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
166+
// CHECK: %[[INTRINSIC:.*]] = call i32 @llvm.aarch64.sve.clasta.n.nxv4i32(<vscale x 4 x i1> %[[PG]], i32 %fallback, <vscale x 4 x i32> %data)
167+
// CHECK: ret i32 %[[INTRINSIC]]
168+
return SVE_ACLE_FUNC(svclasta,_n_u32,,)(pg, fallback, data);
169+
}
170+
171+
uint64_t test_svclasta_n_u64(svbool_t pg, uint64_t fallback, svuint64_t data)
172+
{
173+
// CHECK-LABEL: test_svclasta_n_u64
174+
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
175+
// CHECK: %[[INTRINSIC:.*]] = call i64 @llvm.aarch64.sve.clasta.n.nxv2i64(<vscale x 2 x i1> %[[PG]], i64 %fallback, <vscale x 2 x i64> %data)
176+
// CHECK: ret i64 %[[INTRINSIC]]
177+
return SVE_ACLE_FUNC(svclasta,_n_u64,,)(pg, fallback, data);
178+
}
179+
180+
float16_t test_svclasta_n_f16(svbool_t pg, float16_t fallback, svfloat16_t data)
181+
{
182+
// CHECK-LABEL: test_svclasta_n_f16
183+
// CHECK: %[[PG:.*]] = call <vscale x 8 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv8i1(<vscale x 16 x i1> %pg)
184+
// CHECK: %[[INTRINSIC:.*]] = call half @llvm.aarch64.sve.clasta.n.nxv8f16(<vscale x 8 x i1> %[[PG]], half %fallback, <vscale x 8 x half> %data)
185+
// CHECK: ret half %[[INTRINSIC]]
186+
return SVE_ACLE_FUNC(svclasta,_n_f16,,)(pg, fallback, data);
187+
}
188+
189+
float32_t test_svclasta_n_f32(svbool_t pg, float32_t fallback, svfloat32_t data)
190+
{
191+
// CHECK-LABEL: test_svclasta_n_f32
192+
// CHECK: %[[PG:.*]] = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %pg)
193+
// CHECK: %[[INTRINSIC:.*]] = call float @llvm.aarch64.sve.clasta.n.nxv4f32(<vscale x 4 x i1> %[[PG]], float %fallback, <vscale x 4 x float> %data)
194+
// CHECK: ret float %[[INTRINSIC]]
195+
return SVE_ACLE_FUNC(svclasta,_n_f32,,)(pg, fallback, data);
196+
}
197+
198+
float64_t test_svclasta_n_f64(svbool_t pg, float64_t fallback, svfloat64_t data)
199+
{
200+
// CHECK-LABEL: test_svclasta_n_f64
201+
// CHECK: %[[PG:.*]] = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %pg)
202+
// CHECK: %[[INTRINSIC:.*]] = call double @llvm.aarch64.sve.clasta.n.nxv2f64(<vscale x 2 x i1> %[[PG]], double %fallback, <vscale x 2 x double> %data)
203+
// CHECK: ret double %[[INTRINSIC]]
204+
return SVE_ACLE_FUNC(svclasta,_n_f64,,)(pg, fallback, data);
205+
}

0 commit comments

Comments
 (0)