Skip to content

Commit bfd90a7

Browse files
CarolineConcattoCarolineConcatto
committed
[CLANG]Add Neon vectors for mfloat8_t
This patch adds these new vector sizes for neon: mfloat8x16_t and mfloat8x8_t According to the ARM ACLE PR#323[1]. [1] ARM-software/acle#323
1 parent de397fb commit bfd90a7

File tree

15 files changed

+240
-17
lines changed

15 files changed

+240
-17
lines changed

‎clang/include/clang/Basic/arm_mfp8.td

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
//===--- arm_mfp8.td - ARM MFP8 compiler interface ------------------------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
//
9+
// This file defines the TableGen definitions from which the ARM MFP8 header
10+
// file will be generated.
11+
//
12+
//===----------------------------------------------------------------------===//
13+
14+
include "arm_neon_incl.td"

‎clang/include/clang/Basic/arm_neon_incl.td

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -216,6 +216,7 @@ def OP_UNAVAILABLE : Operation {
216216
// h: half-float
217217
// d: double
218218
// b: bfloat16
219+
// m: mfloat8
219220
//
220221
// Typespec modifiers
221222
// ------------------
@@ -240,6 +241,7 @@ def OP_UNAVAILABLE : Operation {
240241
// B: change to BFloat16
241242
// P: change to polynomial category.
242243
// p: change polynomial to equivalent integer category. Otherwise nop.
244+
// M: change to MFloat8.
243245
//
244246
// >: double element width (vector size unchanged).
245247
// <: half element width (vector size unchanged).

‎clang/lib/Basic/Targets/AArch64.cpp

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -543,6 +543,9 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
543543
Builder.defineMacro("__ARM_FEATURE_BF16_SCALAR_ARITHMETIC", "1");
544544
}
545545

546+
if (HasMFloat8) {
547+
Builder.defineMacro("__ARM_FEATURE_FP8", "1");
548+
}
546549
if ((FPU & SveMode) && HasBFloat16) {
547550
Builder.defineMacro("__ARM_FEATURE_SVE_BF16", "1");
548551
}

‎clang/lib/Basic/Targets/ARM.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -661,6 +661,8 @@ bool ARMTargetInfo::hasBFloat16Type() const {
661661
return HasBFloat16 || (FPU && !SoftFloat);
662662
}
663663

664+
bool ARMTargetInfo::hasMFloat8Type() const { return true; }
665+
664666
bool ARMTargetInfo::isValidCPUName(StringRef Name) const {
665667
return Name == "generic" ||
666668
llvm::ARM::parseCPUArch(Name) != llvm::ARM::ArchKind::INVALID;

‎clang/lib/Basic/Targets/ARM.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -176,6 +176,8 @@ class LLVM_LIBRARY_VISIBILITY ARMTargetInfo : public TargetInfo {
176176

177177
bool hasBFloat16Type() const override;
178178

179+
bool hasMFloat8Type() const override;
180+
179181
bool isValidCPUName(StringRef Name) const override;
180182
void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
181183

‎clang/lib/CodeGen/CGBuiltin.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6230,6 +6230,8 @@ static llvm::FixedVectorType *GetNeonType(CodeGenFunction *CGF,
62306230
case NeonTypeFlags::Int8:
62316231
case NeonTypeFlags::Poly8:
62326232
return llvm::FixedVectorType::get(CGF->Int8Ty, V1Ty ? 1 : (8 << IsQuad));
6233+
case NeonTypeFlags::MFloat8:
6234+
return llvm::FixedVectorType::get(CGF->MFloat8Ty, V1Ty ? 1 : (8 << IsQuad));
62336235
case NeonTypeFlags::Int16:
62346236
case NeonTypeFlags::Poly16:
62356237
return llvm::FixedVectorType::get(CGF->Int16Ty, V1Ty ? 1 : (4 << IsQuad));

‎clang/lib/Headers/CMakeLists.txt

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -391,6 +391,8 @@ if(ARM IN_LIST LLVM_TARGETS_TO_BUILD OR AArch64 IN_LIST LLVM_TARGETS_TO_BUILD)
391391
clang_generate_header(-gen-arm-sme-header arm_sme.td arm_sme.h)
392392
# Generate arm_bf16.h
393393
clang_generate_header(-gen-arm-bf16 arm_bf16.td arm_bf16.h)
394+
# Generate arm_mfp8.h
395+
clang_generate_header(-gen-arm-mfp8 arm_mfp8.td arm_mfp8.h)
394396
# Generate arm_mve.h
395397
clang_generate_header(-gen-arm-mve-header arm_mve.td arm_mve.h)
396398
# Generate arm_cde.h
@@ -414,6 +416,7 @@ if(ARM IN_LIST LLVM_TARGETS_TO_BUILD OR AArch64 IN_LIST LLVM_TARGETS_TO_BUILD)
414416
"${CMAKE_CURRENT_BINARY_DIR}/arm_sme.h"
415417
"${CMAKE_CURRENT_BINARY_DIR}/arm_bf16.h"
416418
"${CMAKE_CURRENT_BINARY_DIR}/arm_vector_types.h"
419+
"${CMAKE_CURRENT_BINARY_DIR}/arm_mfp8.h"
417420
)
418421
endif()
419422
if(RISCV IN_LIST LLVM_TARGETS_TO_BUILD)

‎clang/lib/Sema/SemaARM.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -385,6 +385,8 @@ static QualType getNeonEltType(NeonTypeFlags Flags, ASTContext &Context,
385385
return Context.DoubleTy;
386386
case NeonTypeFlags::BFloat16:
387387
return Context.BFloat16Ty;
388+
case NeonTypeFlags::MFloat8:
389+
return Context.MFloat8Ty;
388390
}
389391
llvm_unreachable("Invalid NeonTypeFlag!");
390392
}

‎clang/lib/Sema/SemaExpr.cpp

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10215,6 +10215,11 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
1021510215
const VectorType *RHSVecType = RHSType->getAs<VectorType>();
1021610216
assert(LHSVecType || RHSVecType);
1021710217

10218+
// Any operation with MFloat8 type is only possible with C intrinsics
10219+
if ((LHSVecType && LHSVecType->getElementType()->isMFloat8Type()) ||
10220+
(RHSVecType && RHSVecType->getElementType()->isMFloat8Type()))
10221+
return InvalidOperands(Loc, LHS, RHS);
10222+
1021810223
// AltiVec-style "vector bool op vector bool" combinations are allowed
1021910224
// for some operators but not others.
1022010225
if (!AllowBothBool && LHSVecType &&

‎clang/test/CodeGen/arm-mfp8.c

Lines changed: 71 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,34 @@
1-
// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4
2-
// RUN: %clang_cc1 -emit-llvm -triple aarch64-arm-none-eabi -target-feature -fp8 -o - %s | FileCheck %s
1+
// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5
2+
// RUN: %clang_cc1 -emit-llvm -triple aarch64-arm-none-eabi -target-feature -fp8 -target-feature +neon -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-C
3+
// RUN: %clang_cc1 -emit-llvm -triple aarch64-arm-none-eabi -target-feature -fp8 -target-feature +neon -o - -x c++ %s | FileCheck %s --check-prefixes=CHECK,CHECK-CXX
34

45
// REQUIRES: aarch64-registered-target
56

6-
// CHECK-LABEL: define dso_local i8 @func1n(
7-
// CHECK-SAME: i8 noundef [[MFP8:%.*]]) #[[ATTR0:[0-9]+]] {
8-
// CHECK-NEXT: entry:
9-
// CHECK-NEXT: [[MFP8_ADDR:%.*]] = alloca i8, align 1
10-
// CHECK-NEXT: [[F1N:%.*]] = alloca [10 x i8], align 1
11-
// CHECK-NEXT: store i8 [[MFP8]], ptr [[MFP8_ADDR]], align 1
12-
// CHECK-NEXT: [[TMP0:%.*]] = load i8, ptr [[MFP8_ADDR]], align 1
13-
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i8], ptr [[F1N]], i64 0, i64 2
14-
// CHECK-NEXT: store i8 [[TMP0]], ptr [[ARRAYIDX]], align 1
15-
// CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [10 x i8], ptr [[F1N]], i64 0, i64 2
16-
// CHECK-NEXT: [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX1]], align 1
17-
// CHECK-NEXT: ret i8 [[TMP1]]
7+
// CHECK-C-LABEL: define dso_local i8 @func1n(
8+
// CHECK-C-SAME: i8 noundef [[MFP8:%.*]]) #[[ATTR0:[0-9]+]] {
9+
// CHECK-C-NEXT: [[ENTRY:.*:]]
10+
// CHECK-C-NEXT: [[MFP8_ADDR:%.*]] = alloca i8, align 1
11+
// CHECK-C-NEXT: [[F1N:%.*]] = alloca [10 x i8], align 1
12+
// CHECK-C-NEXT: store i8 [[MFP8]], ptr [[MFP8_ADDR]], align 1
13+
// CHECK-C-NEXT: [[TMP0:%.*]] = load i8, ptr [[MFP8_ADDR]], align 1
14+
// CHECK-C-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i8], ptr [[F1N]], i64 0, i64 2
15+
// CHECK-C-NEXT: store i8 [[TMP0]], ptr [[ARRAYIDX]], align 1
16+
// CHECK-C-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [10 x i8], ptr [[F1N]], i64 0, i64 2
17+
// CHECK-C-NEXT: [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX1]], align 1
18+
// CHECK-C-NEXT: ret i8 [[TMP1]]
19+
//
20+
// CHECK-CXX-LABEL: define dso_local noundef i8 @_Z6func1nw(
21+
// CHECK-CXX-SAME: i8 noundef [[MFP8:%.*]]) #[[ATTR0:[0-9]+]] {
22+
// CHECK-CXX-NEXT: [[ENTRY:.*:]]
23+
// CHECK-CXX-NEXT: [[MFP8_ADDR:%.*]] = alloca i8, align 1
24+
// CHECK-CXX-NEXT: [[F1N:%.*]] = alloca [10 x i8], align 1
25+
// CHECK-CXX-NEXT: store i8 [[MFP8]], ptr [[MFP8_ADDR]], align 1
26+
// CHECK-CXX-NEXT: [[TMP0:%.*]] = load i8, ptr [[MFP8_ADDR]], align 1
27+
// CHECK-CXX-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i8], ptr [[F1N]], i64 0, i64 2
28+
// CHECK-CXX-NEXT: store i8 [[TMP0]], ptr [[ARRAYIDX]], align 1
29+
// CHECK-CXX-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [10 x i8], ptr [[F1N]], i64 0, i64 2
30+
// CHECK-CXX-NEXT: [[TMP1:%.*]] = load i8, ptr [[ARRAYIDX1]], align 1
31+
// CHECK-CXX-NEXT: ret i8 [[TMP1]]
1832
//
1933
__mfp8 func1n(__mfp8 mfp8) {
2034
__mfp8 f1n[10];
@@ -23,4 +37,47 @@ __mfp8 func1n(__mfp8 mfp8) {
2337
}
2438

2539

40+
#include <arm_neon.h>
41+
42+
// CHECK-C-LABEL: define dso_local <16 x i8> @test_ret_mfloat8x16_t(
43+
// CHECK-C-SAME: <16 x i8> noundef [[V:%.*]]) #[[ATTR0]] {
44+
// CHECK-C-NEXT: [[ENTRY:.*:]]
45+
// CHECK-C-NEXT: [[V_ADDR:%.*]] = alloca <16 x i8>, align 16
46+
// CHECK-C-NEXT: store <16 x i8> [[V]], ptr [[V_ADDR]], align 16
47+
// CHECK-C-NEXT: [[TMP0:%.*]] = load <16 x i8>, ptr [[V_ADDR]], align 16
48+
// CHECK-C-NEXT: ret <16 x i8> [[TMP0]]
49+
//
50+
// CHECK-CXX-LABEL: define dso_local noundef <16 x i8> @_Z21test_ret_mfloat8x16_t16__MFloat8_tx16_t(
51+
// CHECK-CXX-SAME: <16 x i8> noundef [[V:%.*]]) #[[ATTR0]] {
52+
// CHECK-CXX-NEXT: [[ENTRY:.*:]]
53+
// CHECK-CXX-NEXT: [[V_ADDR:%.*]] = alloca <16 x i8>, align 16
54+
// CHECK-CXX-NEXT: store <16 x i8> [[V]], ptr [[V_ADDR]], align 16
55+
// CHECK-CXX-NEXT: [[TMP0:%.*]] = load <16 x i8>, ptr [[V_ADDR]], align 16
56+
// CHECK-CXX-NEXT: ret <16 x i8> [[TMP0]]
57+
//
58+
mfloat8x16_t test_ret_mfloat8x16_t(mfloat8x16_t v) {
59+
return v;
60+
}
61+
62+
// CHECK-C-LABEL: define dso_local <8 x i8> @test_ret_mfloat8x8_t(
63+
// CHECK-C-SAME: <8 x i8> noundef [[V:%.*]]) #[[ATTR0]] {
64+
// CHECK-C-NEXT: [[ENTRY:.*:]]
65+
// CHECK-C-NEXT: [[V_ADDR:%.*]] = alloca <8 x i8>, align 8
66+
// CHECK-C-NEXT: store <8 x i8> [[V]], ptr [[V_ADDR]], align 8
67+
// CHECK-C-NEXT: [[TMP0:%.*]] = load <8 x i8>, ptr [[V_ADDR]], align 8
68+
// CHECK-C-NEXT: ret <8 x i8> [[TMP0]]
69+
//
70+
// CHECK-CXX-LABEL: define dso_local noundef <8 x i8> @_Z20test_ret_mfloat8x8_t15__MFloat8_tx8_t(
71+
// CHECK-CXX-SAME: <8 x i8> noundef [[V:%.*]]) #[[ATTR0]] {
72+
// CHECK-CXX-NEXT: [[ENTRY:.*:]]
73+
// CHECK-CXX-NEXT: [[V_ADDR:%.*]] = alloca <8 x i8>, align 8
74+
// CHECK-CXX-NEXT: store <8 x i8> [[V]], ptr [[V_ADDR]], align 8
75+
// CHECK-CXX-NEXT: [[TMP0:%.*]] = load <8 x i8>, ptr [[V_ADDR]], align 8
76+
// CHECK-CXX-NEXT: ret <8 x i8> [[TMP0]]
77+
//
78+
mfloat8x8_t test_ret_mfloat8x8_t(mfloat8x8_t v) {
79+
return v;
80+
}
2681

82+
//// NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
83+
// CHECK: {{.*}}

‎clang/test/Sema/arm-fpm8.cpp

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,53 @@
1+
// RUN: %clang_cc1 -fsyntax-only -verify=scalar,neon -triple aarch64-arm-none-eabi \
2+
// RUN: -target-feature -fp8 -target-feature +neon %s
3+
4+
// REQUIRES: aarch64-registered-target
5+
__fpm8 test_static_cast_from_char(char in) {
6+
return static_cast<__fpm8>(in); // scalar-error {{static_cast from 'char' to '__fpm8' is not allowed}}
7+
}
8+
9+
char test_static_cast_to_char(__fpm8 in) {
10+
return static_cast<char>(in); // scalar-error {{static_cast from '__fpm8' to 'char' is not allowed}}
11+
}
12+
void test(bool b) {
13+
__fpm8 fpm8;
14+
15+
fpm8 + fpm8; // scalar-error {{invalid operands to binary expression ('__fpm8' and '__fpm8')}}
16+
fpm8 - fpm8; // scalar-error {{invalid operands to binary expression ('__fpm8' and '__fpm8')}}
17+
fpm8 * fpm8; // scalar-error {{invalid operands to binary expression ('__fpm8' and '__fpm8')}}
18+
fpm8 / fpm8; // scalar-error {{invalid operands to binary expression ('__fpm8' and '__fpm8')}}
19+
++fpm8; // scalar-error {{cannot increment value of type '__fpm8'}}
20+
--fpm8; // scalar-error {{cannot decrement value of type '__fpm8'}}
21+
22+
char u8;
23+
24+
fpm8 + u8; // scalar-error {{invalid operands to binary expression ('__fpm8' and 'char')}}
25+
u8 + fpm8; // scalar-error {{invalid operands to binary expression ('char' and '__fpm8')}}
26+
fpm8 - u8; // scalar-error {{invalid operands to binary expression ('__fpm8' and 'char')}}
27+
u8 - fpm8; // scalar-error {{invalid operands to binary expression ('char' and '__fpm8')}}
28+
fpm8 * u8; // scalar-error {{invalid operands to binary expression ('__fpm8' and 'char')}}
29+
u8 * fpm8; // scalar-error {{invalid operands to binary expression ('char' and '__fpm8')}}
30+
fpm8 / u8; // scalar-error {{invalid operands to binary expression ('__fpm8' and 'char')}}
31+
u8 / fpm8; // scalar-error {{invalid operands to binary expression ('char' and '__fpm8')}}
32+
fpm8 = u8; // scalar-error {{assigning to '__fpm8' from incompatible type 'char'}}
33+
u8 = fpm8; // scalar-error {{assigning to 'char' from incompatible type '__fpm8'}}
34+
fpm8 + (b ? u8 : fpm8); // scalar-error {{incompatible operand types ('char' and '__fpm8')}}
35+
}
36+
37+
#include <arm_neon.h>
38+
39+
void test_vector(fpm8x8_t a, fpm8x8_t b, uint8x8_t c) {
40+
a + b; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'fpm8x8_t')}}
41+
a - b; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'fpm8x8_t')}}
42+
a * b; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'fpm8x8_t')}}
43+
a / b; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'fpm8x8_t')}}
44+
45+
a + c; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
46+
a - c; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
47+
a * c; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
48+
a / c; // neon-error {{invalid operands to binary expression ('fpm8x8_t' (vector of 8 'fpm8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
49+
c + b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'fpm8x8_t' (vector of 8 'fpm8_t' values))}}
50+
c - b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'fpm8x8_t' (vector of 8 'fpm8_t' values))}}
51+
c * b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'fpm8x8_t' (vector of 8 'fpm8_t' values))}}
52+
c / b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'fpm8x8_t' (vector of 8 'fpm8_t' values))}}
53+
}

‎clang/test/Sema/arm-mfp8.cpp

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
// RUN: %clang_cc1 -fsyntax-only -verify=scalar -triple aarch64-arm-none-eabi -target-feature -fp8 %s
1+
// RUN: %clang_cc1 -fsyntax-only -verify=scalar,neon -triple aarch64-arm-none-eabi \
2+
// RUN: -target-feature -fp8 -target-feature +neon %s
23

34
// REQUIRES: aarch64-registered-target
45
__mfp8 test_static_cast_from_char(char in) {
@@ -33,3 +34,20 @@ void test(bool b) {
3334
mfp8 + (b ? u8 : mfp8); // scalar-error {{incompatible operand types ('char' and '__mfp8')}}
3435
}
3536

37+
#include <arm_neon.h>
38+
39+
void test_vector(mfloat8x8_t a, mfloat8x8_t b, uint8x8_t c) {
40+
a + b; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'mfloat8x8_t')}}
41+
a - b; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'mfloat8x8_t')}}
42+
a * b; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'mfloat8x8_t')}}
43+
a / b; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'mfloat8x8_t')}}
44+
45+
a + c; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
46+
a - c; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
47+
a * c; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
48+
a / c; // neon-error {{invalid operands to binary expression ('mfloat8x8_t' (vector of 8 'mfloat8_t' values) and 'uint8x8_t' (vector of 8 'uint8_t' values))}}
49+
c + b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'mfloat8x8_t' (vector of 8 'mfloat8_t' values))}}
50+
c - b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'mfloat8x8_t' (vector of 8 'mfloat8_t' values))}}
51+
c * b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'mfloat8x8_t' (vector of 8 'mfloat8_t' values))}}
52+
c / b; // neon-error {{invalid operands to binary expression ('uint8x8_t' (vector of 8 'uint8_t' values) and 'mfloat8x8_t' (vector of 8 'mfloat8_t' values))}}
53+
}

0 commit comments

Comments
 (0)