Skip to content

Commit 2eb61fa

Browse files
MarkMurrayARMMarkMurrayARM
committed
[ARM][MVE][Intrinsics] Add VMULL[BT]Q_(INT|POLY) intrinsics.
Summary: Add VMULL[BT]Q_(INT|POLY) intrinsics and unit tests. Reviewers: simon_tatham, ostannard, dmgreen Subscribers: kristof.beyls, hiraditya, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71066
1 parent c78726f commit 2eb61fa

File tree

10 files changed

+668
-43
lines changed

10 files changed

+668
-43
lines changed

‎clang/include/clang/Basic/arm_mve.td

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,21 @@ def vmulhq: Intrinsic<Vector, (args Vector:$a, Vector:$b),
5151
(IRInt<"vmulh", [Vector]> $a, $b)>;
5252
def vrmulhq: Intrinsic<Vector, (args Vector:$a, Vector:$b),
5353
(IRInt<"vrmulh", [Vector]> $a, $b)>;
54+
def vmullbq_int: Intrinsic<DblVector, (args Vector:$a, Vector:$b),
55+
(IRInt<"vmull", [DblVector, Vector]>
56+
$a, $b, 0)>;
57+
def vmulltq_int: Intrinsic<DblVector, (args Vector:$a, Vector:$b),
58+
(IRInt<"vmull", [DblVector, Vector]>
59+
$a, $b, 1)>;
60+
}
61+
62+
let params = T.Poly, overrideKindLetter = "p" in {
63+
def vmullbq_poly: Intrinsic<DblVector, (args Vector:$a, Vector:$b),
64+
(IRInt<"vmull_poly", [DblVector, Vector]>
65+
$a, $b, 0)>;
66+
def vmulltq_poly: Intrinsic<DblVector, (args Vector:$a, Vector:$b),
67+
(IRInt<"vmull_poly", [DblVector, Vector]>
68+
$a, $b, 1)>;
5469
}
5570

5671
let params = T.Float in {
@@ -123,6 +138,25 @@ def vmulhq_m: Intrinsic<
123138
def vrmulhq_m: Intrinsic<
124139
Vector, (args Vector:$inactive, Vector:$a, Vector:$b, Predicate:$pred),
125140
(IRInt<"rmulh_predicated", [Vector, Predicate]> $a, $b, $pred, $inactive)>;
141+
def vmullbq_int_m: Intrinsic<
142+
DblVector, (args Vector:$inactive, Vector:$a, Vector:$b, Predicate:$pred),
143+
(IRInt<"mull_int_predicated", [DblVector, Vector, Predicate]> $a, $b, 0,
144+
$pred, $inactive)>;
145+
def vmulltq_int_m: Intrinsic<
146+
DblVector, (args Vector:$inactive, Vector:$a, Vector:$b, Predicate:$pred),
147+
(IRInt<"mull_int_predicated", [DblVector, Vector, Predicate]> $a, $b, 1,
148+
$pred, $inactive)>;
149+
}
150+
151+
let params = T.Poly, overrideKindLetter = "p" in {
152+
def vmullbq_poly_m: Intrinsic<
153+
DblVector, (args Vector:$inactive, Vector:$a, Vector:$b, Predicate:$pred),
154+
(IRInt<"mull_poly_predicated", [DblVector, Vector, Predicate]> $a, $b, 0,
155+
$pred, $inactive)>;
156+
def vmulltq_poly_m: Intrinsic<
157+
DblVector, (args Vector:$inactive, Vector:$a, Vector:$b, Predicate:$pred),
158+
(IRInt<"mull_poly_predicated", [DblVector, Vector, Predicate]> $a, $b, 1,
159+
$pred, $inactive)>;
126160
}
127161

128162
// Predicated intrinsics - Float types only

‎clang/include/clang/Basic/arm_mve_defs.td

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -190,6 +190,7 @@ def CTO_Pred: ComplexTypeOp;
190190
class CTO_Tuple<int n_>: ComplexTypeOp { int n = n_; }
191191
class CTO_Pointer<bit const_>: ComplexTypeOp { bit const = const_; }
192192
def CTO_CopyKind: ComplexTypeOp;
193+
def CTO_DoubleSize: ComplexTypeOp;
193194

194195
// -----------------------------------------------------------------------------
195196
// Instances of Type intended to be used directly in the specification of an
@@ -264,6 +265,11 @@ class CPtr<Type t>: ComplexType<(CTO_Pointer<1> t)>;
264265
// matches that of s.
265266
class CopyKind<Type s, Type k>: ComplexType<(CTO_CopyKind s, k)>;
266267

268+
// DoubleSize<k> expects k to be a scalar type. It returns a scalar type
269+
// whose kind (signed, unsigned or float) matches that of k, and whose size
270+
// is double that of k, if possible.
271+
class DoubleSize<Type k>: ComplexType<(CTO_DoubleSize k)>;
272+
267273
// Unsigned<t> expects t to be a scalar type, and expands to the unsigned
268274
// integer scalar of the same size. So it returns u16 if you give it s16 or
269275
// f16 (or u16 itself).
@@ -274,6 +280,10 @@ class Unsigned<Type t>: ComplexType<(CTO_CopyKind t, u32)>;
274280
def UScalar: Unsigned<Scalar>;
275281
def UVector: VecOf<UScalar>;
276282

283+
// DblVector expands to a vector of scalars of size twice the size of
284+
// Scalar.
285+
def DblVector: VecOf<DoubleSize<Scalar>>;
286+
277287
// -----------------------------------------------------------------------------
278288
// Internal definitions for specifying immediate arguments for an intrinsic.
279289

@@ -405,6 +415,10 @@ class Intrinsic<Type ret_, dag args_, dag codegen_> {
405415

406416
// True if the builtin has to avoid evaluating its arguments.
407417
bit nonEvaluating = 0;
418+
419+
// Use to override the suffix letter to make e.g.vfooq_p16
420+
// with an override suffix letter of "p".
421+
string overrideKindLetter = "";
408422
}
409423

410424
// Sometimes you have to use two separate Intrinsic declarations to
@@ -433,6 +447,7 @@ def T {
433447
list<Type> Int16 = [s16, u16];
434448
list<Type> Int32 = [s32, u32];
435449
list<Type> Int64 = [s64, u64];
450+
list<Type> Poly = [u8, u16]; // Actually p8 and p16
436451
list<Type> All8 = Int8;
437452
list<Type> All16 = Int16 # [f16];
438453
list<Type> All32 = Int32 # [f32];

‎clang/test/CodeGen/arm-mve-intrinsics/vmullbq.c

Lines changed: 125 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,125 @@
1+
// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
2+
// RUN: %clang_cc1 -triple thumbv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -S -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
3+
// RUN: %clang_cc1 -triple thumbv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -DPOLYMORPHIC -S -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
4+
5+
#include <arm_mve.h>
6+
7+
// CHECK-LABEL: @test_vmullbq_int_u8(
8+
// CHECK-NEXT: entry:
9+
// CHECK-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vmull.v8i16.v16i8(<16 x i8> [[A:%.*]], <16 x i8> [[B:%.*]], i32 0)
10+
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
11+
//
12+
int16x8_t test_vmullbq_int_u8(uint8x16_t a, uint8x16_t b)
13+
{
14+
#ifdef POLYMORPHIC
15+
return vmullbq_int(a, b);
16+
#else /* POLYMORPHIC */
17+
return vmullbq_int_u8(a, b);
18+
#endif /* POLYMORPHIC */
19+
}
20+
21+
// CHECK-LABEL: @test_vmullbq_int_s16(
22+
// CHECK-NEXT: entry:
23+
// CHECK-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vmull.v4i32.v8i16(<8 x i16> [[A:%.*]], <8 x i16> [[B:%.*]], i32 0)
24+
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
25+
//
26+
int32x4_t test_vmullbq_int_s16(int16x8_t a, int16x8_t b)
27+
{
28+
#ifdef POLYMORPHIC
29+
return vmullbq_int(a, b);
30+
#else /* POLYMORPHIC */
31+
return vmullbq_int_s16(a, b);
32+
#endif /* POLYMORPHIC */
33+
}
34+
35+
// CHECK-LABEL: @test_vmullbq_int_u32(
36+
// CHECK-NEXT: entry:
37+
// CHECK-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vmull.v2i64.v4i32(<4 x i32> [[A:%.*]], <4 x i32> [[B:%.*]], i32 0)
38+
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
39+
//
40+
uint64x2_t test_vmullbq_int_u32(uint32x4_t a, uint32x4_t b)
41+
{
42+
#ifdef POLYMORPHIC
43+
return vmullbq_int(a, b);
44+
#else /* POLYMORPHIC */
45+
return vmullbq_int_u32(a, b);
46+
#endif /* POLYMORPHIC */
47+
}
48+
49+
// CHECK-LABEL: @test_vmullbq_poly_p16(
50+
// CHECK-NEXT: entry:
51+
// CHECK-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vmull.poly.v4i32.v8i16(<8 x i16> [[A:%.*]], <8 x i16> [[B:%.*]], i32 0)
52+
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
53+
//
54+
uint32x4_t test_vmullbq_poly_p16(uint16x8_t a, uint16x8_t b)
55+
{
56+
#ifdef POLYMORPHIC
57+
return vmullbq_poly(a, b);
58+
#else /* POLYMORPHIC */
59+
return vmullbq_poly_p16(a, b);
60+
#endif /* POLYMORPHIC */
61+
}
62+
63+
// CHECK-LABEL: @test_vmullbq_int_m_s8(
64+
// CHECK-NEXT: entry:
65+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
66+
// CHECK-NEXT: [[TMP1:%.*]] = call <16 x i1> @llvm.arm.mve.pred.i2v.v16i1(i32 [[TMP0]])
67+
// CHECK-NEXT: [[TMP2:%.*]] = call <8 x i16> @llvm.arm.mve.mull.int.predicated.v8i16.v16i8.v16i1(<16 x i8> [[A:%.*]], <16 x i8> [[B:%.*]], i32 0, <16 x i1> [[TMP1]], <16 x i8> [[INACTIVE:%.*]])
68+
// CHECK-NEXT: ret <8 x i16> [[TMP2]]
69+
//
70+
int16x8_t test_vmullbq_int_m_s8(int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
71+
{
72+
#ifdef POLYMORPHIC
73+
return vmullbq_int_m(inactive, a, b, p);
74+
#else /* POLYMORPHIC */
75+
return vmullbq_int_m_s8(inactive, a, b, p);
76+
#endif /* POLYMORPHIC */
77+
}
78+
79+
// CHECK-LABEL: @test_vmullbq_int_m_u16(
80+
// CHECK-NEXT: entry:
81+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
82+
// CHECK-NEXT: [[TMP1:%.*]] = call <8 x i1> @llvm.arm.mve.pred.i2v.v8i1(i32 [[TMP0]])
83+
// CHECK-NEXT: [[TMP2:%.*]] = call <4 x i32> @llvm.arm.mve.mull.int.predicated.v4i32.v8i16.v8i1(<8 x i16> [[A:%.*]], <8 x i16> [[B:%.*]], i32 0, <8 x i1> [[TMP1]], <8 x i16> [[INACTIVE:%.*]])
84+
// CHECK-NEXT: ret <4 x i32> [[TMP2]]
85+
//
86+
uint32x4_t test_vmullbq_int_m_u16(uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
87+
{
88+
#ifdef POLYMORPHIC
89+
return vmullbq_int_m(inactive, a, b, p);
90+
#else /* POLYMORPHIC */
91+
return vmullbq_int_m_u16(inactive, a, b, p);
92+
#endif /* POLYMORPHIC */
93+
}
94+
95+
// CHECK-LABEL: @test_vmullbq_int_m_s32(
96+
// CHECK-NEXT: entry:
97+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
98+
// CHECK-NEXT: [[TMP1:%.*]] = call <4 x i1> @llvm.arm.mve.pred.i2v.v4i1(i32 [[TMP0]])
99+
// CHECK-NEXT: [[TMP2:%.*]] = call <2 x i64> @llvm.arm.mve.mull.int.predicated.v2i64.v4i32.v4i1(<4 x i32> [[A:%.*]], <4 x i32> [[B:%.*]], i32 0, <4 x i1> [[TMP1]], <4 x i32> [[INACTIVE:%.*]])
100+
// CHECK-NEXT: ret <2 x i64> [[TMP2]]
101+
//
102+
int64x2_t test_vmullbq_int_m_s32(int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
103+
{
104+
#ifdef POLYMORPHIC
105+
return vmullbq_int_m(inactive, a, b, p);
106+
#else /* POLYMORPHIC */
107+
return vmullbq_int_m_s32(inactive, a, b, p);
108+
#endif /* POLYMORPHIC */
109+
}
110+
111+
// CHECK-LABEL: @test_vmullbq_poly_m_p8(
112+
// CHECK-NEXT: entry:
113+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
114+
// CHECK-NEXT: [[TMP1:%.*]] = call <16 x i1> @llvm.arm.mve.pred.i2v.v16i1(i32 [[TMP0]])
115+
// CHECK-NEXT: [[TMP2:%.*]] = call <8 x i16> @llvm.arm.mve.mull.poly.predicated.v8i16.v16i8.v16i1(<16 x i8> [[A:%.*]], <16 x i8> [[B:%.*]], i32 0, <16 x i1> [[TMP1]], <16 x i8> [[INACTIVE:%.*]])
116+
// CHECK-NEXT: ret <8 x i16> [[TMP2]]
117+
//
118+
uint16x8_t test_vmullbq_poly_m_p8(uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
119+
{
120+
#ifdef POLYMORPHIC
121+
return vmullbq_poly_m(inactive, a, b, p);
122+
#else /* POLYMORPHIC */
123+
return vmullbq_poly_m_p8(inactive, a, b, p);
124+
#endif /* POLYMORPHIC */
125+
}

‎clang/test/CodeGen/arm-mve-intrinsics/vmulltq.c

Lines changed: 125 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,125 @@
1+
// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
2+
// RUN: %clang_cc1 -triple thumbv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -S -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
3+
// RUN: %clang_cc1 -triple thumbv8.1m.main-arm-none-eabi -target-feature +mve.fp -mfloat-abi hard -fallow-half-arguments-and-returns -O0 -disable-O0-optnone -DPOLYMORPHIC -S -emit-llvm -o - %s | opt -S -mem2reg | FileCheck %s
4+
5+
#include <arm_mve.h>
6+
7+
// CHECK-LABEL: @test_vmulltq_int_u8(
8+
// CHECK-NEXT: entry:
9+
// CHECK-NEXT: [[TMP0:%.*]] = call <8 x i16> @llvm.arm.mve.vmull.v8i16.v16i8(<16 x i8> [[A:%.*]], <16 x i8> [[B:%.*]], i32 1)
10+
// CHECK-NEXT: ret <8 x i16> [[TMP0]]
11+
//
12+
int16x8_t test_vmulltq_int_u8(uint8x16_t a, uint8x16_t b)
13+
{
14+
#ifdef POLYMORPHIC
15+
return vmulltq_int(a, b);
16+
#else /* POLYMORPHIC */
17+
return vmulltq_int_u8(a, b);
18+
#endif /* POLYMORPHIC */
19+
}
20+
21+
// CHECK-LABEL: @test_vmulltq_int_s16(
22+
// CHECK-NEXT: entry:
23+
// CHECK-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vmull.v4i32.v8i16(<8 x i16> [[A:%.*]], <8 x i16> [[B:%.*]], i32 1)
24+
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
25+
//
26+
int32x4_t test_vmulltq_int_s16(int16x8_t a, int16x8_t b)
27+
{
28+
#ifdef POLYMORPHIC
29+
return vmulltq_int(a, b);
30+
#else /* POLYMORPHIC */
31+
return vmulltq_int_s16(a, b);
32+
#endif /* POLYMORPHIC */
33+
}
34+
35+
// CHECK-LABEL: @test_vmulltq_int_u32(
36+
// CHECK-NEXT: entry:
37+
// CHECK-NEXT: [[TMP0:%.*]] = call <2 x i64> @llvm.arm.mve.vmull.v2i64.v4i32(<4 x i32> [[A:%.*]], <4 x i32> [[B:%.*]], i32 1)
38+
// CHECK-NEXT: ret <2 x i64> [[TMP0]]
39+
//
40+
uint64x2_t test_vmulltq_int_u32(uint32x4_t a, uint32x4_t b)
41+
{
42+
#ifdef POLYMORPHIC
43+
return vmulltq_int(a, b);
44+
#else /* POLYMORPHIC */
45+
return vmulltq_int_u32(a, b);
46+
#endif /* POLYMORPHIC */
47+
}
48+
49+
// CHECK-LABEL: @test_vmulltq_poly_p16(
50+
// CHECK-NEXT: entry:
51+
// CHECK-NEXT: [[TMP0:%.*]] = call <4 x i32> @llvm.arm.mve.vmull.poly.v4i32.v8i16(<8 x i16> [[A:%.*]], <8 x i16> [[B:%.*]], i32 1)
52+
// CHECK-NEXT: ret <4 x i32> [[TMP0]]
53+
//
54+
uint32x4_t test_vmulltq_poly_p16(uint16x8_t a, uint16x8_t b)
55+
{
56+
#ifdef POLYMORPHIC
57+
return vmulltq_poly(a, b);
58+
#else /* POLYMORPHIC */
59+
return vmulltq_poly_p16(a, b);
60+
#endif /* POLYMORPHIC */
61+
}
62+
63+
// CHECK-LABEL: @test_vmulltq_int_m_s8(
64+
// CHECK-NEXT: entry:
65+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
66+
// CHECK-NEXT: [[TMP1:%.*]] = call <16 x i1> @llvm.arm.mve.pred.i2v.v16i1(i32 [[TMP0]])
67+
// CHECK-NEXT: [[TMP2:%.*]] = call <8 x i16> @llvm.arm.mve.mull.int.predicated.v8i16.v16i8.v16i1(<16 x i8> [[A:%.*]], <16 x i8> [[B:%.*]], i32 1, <16 x i1> [[TMP1]], <16 x i8> [[INACTIVE:%.*]])
68+
// CHECK-NEXT: ret <8 x i16> [[TMP2]]
69+
//
70+
int16x8_t test_vmulltq_int_m_s8(int8x16_t inactive, int8x16_t a, int8x16_t b, mve_pred16_t p)
71+
{
72+
#ifdef POLYMORPHIC
73+
return vmulltq_int_m(inactive, a, b, p);
74+
#else /* POLYMORPHIC */
75+
return vmulltq_int_m_s8(inactive, a, b, p);
76+
#endif /* POLYMORPHIC */
77+
}
78+
79+
// CHECK-LABEL: @test_vmulltq_int_m_u16(
80+
// CHECK-NEXT: entry:
81+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
82+
// CHECK-NEXT: [[TMP1:%.*]] = call <8 x i1> @llvm.arm.mve.pred.i2v.v8i1(i32 [[TMP0]])
83+
// CHECK-NEXT: [[TMP2:%.*]] = call <4 x i32> @llvm.arm.mve.mull.int.predicated.v4i32.v8i16.v8i1(<8 x i16> [[A:%.*]], <8 x i16> [[B:%.*]], i32 1, <8 x i1> [[TMP1]], <8 x i16> [[INACTIVE:%.*]])
84+
// CHECK-NEXT: ret <4 x i32> [[TMP2]]
85+
//
86+
uint32x4_t test_vmulltq_int_m_u16(uint16x8_t inactive, uint16x8_t a, uint16x8_t b, mve_pred16_t p)
87+
{
88+
#ifdef POLYMORPHIC
89+
return vmulltq_int_m(inactive, a, b, p);
90+
#else /* POLYMORPHIC */
91+
return vmulltq_int_m_u16(inactive, a, b, p);
92+
#endif /* POLYMORPHIC */
93+
}
94+
95+
// CHECK-LABEL: @test_vmulltq_int_m_s32(
96+
// CHECK-NEXT: entry:
97+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
98+
// CHECK-NEXT: [[TMP1:%.*]] = call <4 x i1> @llvm.arm.mve.pred.i2v.v4i1(i32 [[TMP0]])
99+
// CHECK-NEXT: [[TMP2:%.*]] = call <2 x i64> @llvm.arm.mve.mull.int.predicated.v2i64.v4i32.v4i1(<4 x i32> [[A:%.*]], <4 x i32> [[B:%.*]], i32 1, <4 x i1> [[TMP1]], <4 x i32> [[INACTIVE:%.*]])
100+
// CHECK-NEXT: ret <2 x i64> [[TMP2]]
101+
//
102+
int64x2_t test_vmulltq_int_m_s32(int32x4_t inactive, int32x4_t a, int32x4_t b, mve_pred16_t p)
103+
{
104+
#ifdef POLYMORPHIC
105+
return vmulltq_int_m(inactive, a, b, p);
106+
#else /* POLYMORPHIC */
107+
return vmulltq_int_m_s32(inactive, a, b, p);
108+
#endif /* POLYMORPHIC */
109+
}
110+
111+
// CHECK-LABEL: @test_vmulltq_poly_m_p8(
112+
// CHECK-NEXT: entry:
113+
// CHECK-NEXT: [[TMP0:%.*]] = zext i16 [[P:%.*]] to i32
114+
// CHECK-NEXT: [[TMP1:%.*]] = call <16 x i1> @llvm.arm.mve.pred.i2v.v16i1(i32 [[TMP0]])
115+
// CHECK-NEXT: [[TMP2:%.*]] = call <8 x i16> @llvm.arm.mve.mull.poly.predicated.v8i16.v16i8.v16i1(<16 x i8> [[A:%.*]], <16 x i8> [[B:%.*]], i32 1, <16 x i1> [[TMP1]], <16 x i8> [[INACTIVE:%.*]])
116+
// CHECK-NEXT: ret <8 x i16> [[TMP2]]
117+
//
118+
uint16x8_t test_vmulltq_poly_m_p8(uint8x16_t inactive, uint8x16_t a, uint8x16_t b, mve_pred16_t p)
119+
{
120+
#ifdef POLYMORPHIC
121+
return vmulltq_poly_m(inactive, a, b, p);
122+
#else /* POLYMORPHIC */
123+
return vmulltq_poly_m_p8(inactive, a, b, p);
124+
#endif /* POLYMORPHIC */
125+
}

0 commit comments

Comments
 (0)