DavidTruby updated this revision to Diff 434445.
DavidTruby added a comment.
Clean up code based on review comments
Move additional tests to existing file
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D126380/new/
https://reviews.llvm.org/D126380
Files:
clang/lib/Sema/SemaChecking.cpp
clang/lib/Sema/SemaExpr.cpp
clang/test/CodeGen/aarch64-sve-vector-arith-ops.c
clang/test/Sema/aarch64-sve-vector-arith-ops.c
clang/test/Sema/sizeless-1.c
clang/test/SemaCXX/sizeless-1.cpp
Index: clang/test/SemaCXX/sizeless-1.cpp
===================================================================
--- clang/test/SemaCXX/sizeless-1.cpp
+++ clang/test/SemaCXX/sizeless-1.cpp
@@ -213,23 +213,6 @@
local_int8 &&init_int8; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
local_int8 || init_int8; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
- local_int8 + 0; // expected-error {{invalid operands to binary expression}}
- local_int8 - 0; // expected-error {{invalid operands to binary expression}}
- local_int8 * 0; // expected-error {{invalid operands to binary expression}}
- local_int8 / 0; // expected-error {{invalid operands to binary expression}}
- local_int8 % 0; // expected-error {{invalid operands to binary expression}}
- local_int8 & 0; // expected-error {{invalid operands to binary expression}}
- local_int8 | 0; // expected-error {{invalid operands to binary expression}}
- local_int8 ^ 0; // expected-error {{invalid operands to binary expression}}
- local_int8 < 0; // expected-error {{invalid operands to binary expression}}
- local_int8 <= 0; // expected-error {{invalid operands to binary expression}}
- local_int8 == 0; // expected-error {{invalid operands to binary expression}}
- local_int8 != 0; // expected-error {{invalid operands to binary expression}}
- local_int8 >= 0; // expected-error {{invalid operands to binary expression}}
- local_int8 > 0; // expected-error {{invalid operands to binary expression}}
- local_int8 && 0; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
- local_int8 || 0; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
-
if (local_int8) { // expected-error {{not contextually convertible to 'bool'}}
}
while (local_int8) { // expected-error {{not contextually convertible to 'bool'}}
Index: clang/test/Sema/sizeless-1.c
===================================================================
--- clang/test/Sema/sizeless-1.c
+++ clang/test/Sema/sizeless-1.c
@@ -201,23 +201,6 @@
local_int8 &&init_int8; // expected-error {{invalid operands to binary expression}}
local_int8 || init_int8; // expected-error {{invalid operands to binary expression}}
- local_int8 + 0; // expected-error {{invalid operands to binary expression}}
- local_int8 - 0; // expected-error {{invalid operands to binary expression}}
- local_int8 * 0; // expected-error {{invalid operands to binary expression}}
- local_int8 / 0; // expected-error {{invalid operands to binary expression}}
- local_int8 % 0; // expected-error {{invalid operands to binary expression}}
- local_int8 & 0; // expected-error {{invalid operands to binary expression}}
- local_int8 | 0; // expected-error {{invalid operands to binary expression}}
- local_int8 ^ 0; // expected-error {{invalid operands to binary expression}}
- local_int8 < 0; // expected-error {{invalid operands to binary expression}}
- local_int8 <= 0; // expected-error {{invalid operands to binary expression}}
- local_int8 == 0; // expected-error {{invalid operands to binary expression}}
- local_int8 != 0; // expected-error {{invalid operands to binary expression}}
- local_int8 >= 0; // expected-error {{invalid operands to binary expression}}
- local_int8 > 0; // expected-error {{invalid operands to binary expression}}
- local_int8 && 0; // expected-error {{invalid operands to binary expression}}
- local_int8 || 0; // expected-error {{invalid operands to binary expression}}
-
if (local_int8) { // expected-error {{statement requires expression of scalar type}}
}
while (local_int8) { // expected-error {{statement requires expression of scalar type}}
Index: clang/test/Sema/aarch64-sve-vector-arith-ops.c
===================================================================
--- clang/test/Sema/aarch64-sve-vector-arith-ops.c
+++ clang/test/Sema/aarch64-sve-vector-arith-ops.c
@@ -643,3 +643,11 @@
(void)(f64 % f16); // expected-error{{invalid operands to binary expression}}
(void)(f64 % f32); // expected-error{{invalid operands to binary expression}}
}
+
+svint8_t svi8(svint8_t a) {
+ return a + 256; // expected-error{{cannot convert between scalar type 'int' and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+}
+
+svint8_t svi8_128(svint8_t a) {
+ return a + 128; // expected-warning{{implicit conversion from 'int' to 'svint8_t' (aka '__SVInt8_t') changes value from 128 to -128}}
+}
Index: clang/test/CodeGen/aarch64-sve-vector-arith-ops.c
===================================================================
--- clang/test/CodeGen/aarch64-sve-vector-arith-ops.c
+++ clang/test/CodeGen/aarch64-sve-vector-arith-ops.c
@@ -328,6 +328,132 @@
return a + b;
}
+// CHECK-LABEL: @add_i8_i_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_i_lit(svint8_t a) {
+ return a + 0;
+}
+
+// CHECK-LABEL: @add_i8_il_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_il_lit(svint8_t a) {
+ return a + 0l;
+}
+
+// CHECK-LABEL: @add_i8_ill_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_ill_lit(svint8_t a) {
+ return a + 0ll;
+}
+
+// CHECK-LABEL: @add_i8_u_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_u_lit(svint8_t a) {
+ return a + 0u;
+}
+
+// CHECK-LABEL: @add_i8_ul_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_ul_lit(svint8_t a) {
+ return a + 0ul;
+}
+
+// CHECK-LABEL: @add_i8_ull_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_ull_lit(svint8_t a) {
+ return a + 0ull;
+}
+
+// CHECK-LABEL: @add_f64_i_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_i_lit(svfloat64_t a) {
+ return a + 0;
+}
+
+// CHECK-LABEL: @add_f64_il_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_il_lit(svfloat64_t a) {
+ return a + 0l;
+}
+
+// CHECK-LABEL: @add_f64_ill_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_ill_lit(svfloat64_t a) {
+ return a + 0ll;
+}
+
+// CHECK-LABEL: @add_f64_u_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_u_lit(svfloat64_t a) {
+ return a + 0u;
+}
+
+// CHECK-LABEL: @add_f64_ul_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_ul_lit(svfloat64_t a) {
+ return a + 0ul;
+}
+
+// CHECK-LABEL: @add_f64_ull_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_ull_lit(svfloat64_t a) {
+ return a + 0ull;
+}
+
+// CHECK-LABEL: @add_f64_f_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_f_lit(svfloat64_t a) {
+ return a + 0.f;
+}
+
+// CHECK-LABEL: @add_f64_d_lit(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT: ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_d_lit(svfloat64_t a) {
+ return a + 0.;
+}
+
// SUBTRACTION
// CHECK-LABEL: @sub_i8(
Index: clang/lib/Sema/SemaExpr.cpp
===================================================================
--- clang/lib/Sema/SemaExpr.cpp
+++ clang/lib/Sema/SemaExpr.cpp
@@ -10257,12 +10257,18 @@
ExprResult *Vector) {
QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
QualType VectorTy = Vector->get()->getType().getUnqualifiedType();
- const auto *VT = VectorTy->castAs<VectorType>();
-
- assert(!isa<ExtVectorType>(VT) &&
- "ExtVectorTypes should not be handled here!");
-
- QualType VectorEltTy = VT->getElementType();
+ QualType VectorEltTy;
+
+ if (const auto *VT = VectorTy->getAs<VectorType>()) {
+ assert(!isa<ExtVectorType>(VT) &&
+ "ExtVectorTypes should not be handled here!");
+ VectorEltTy = VT->getElementType();
+ } else if (VectorTy->isVLSTBuiltinType()) {
+ VectorEltTy =
+ VectorTy->castAs<BuiltinType>()->getSveEltType(S.getASTContext());
+ } else {
+ llvm_unreachable("Only Fixed-Length and SVE Vector types are handled here");
+ }
// Reject cases where the vector element type or the scalar element type are
// not integral or floating point types.
@@ -10589,24 +10595,14 @@
if (Context.hasSameType(LHSType, RHSType))
return LHSType;
- auto tryScalableVectorConvert = [this](ExprResult *Src, QualType SrcType,
- QualType DestType) {
- const QualType DestBaseType = DestType->getSveEltType(Context);
- if (DestBaseType->getUnqualifiedDesugaredType() ==
- SrcType->getUnqualifiedDesugaredType()) {
- unsigned DiagID = diag::err_typecheck_invalid_operands;
- if (!tryVectorConvertAndSplat(*this, Src, SrcType, DestBaseType, DestType,
- DiagID))
- return DestType;
- }
- return QualType();
- };
-
if (LHSType->isVLSTBuiltinType() && !RHSType->isVLSTBuiltinType()) {
- auto DestType = tryScalableVectorConvert(&RHS, RHSType, LHSType);
- if (DestType == QualType())
- return InvalidOperands(Loc, LHS, RHS);
- return DestType;
+ if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
+ return LHSType;
+ }
+ if (RHSType->isVLSTBuiltinType() && !LHSType->isVLSTBuiltinType()) {
+ if (LHS.get()->isLValue() ||
+ !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
+ return RHSType;
}
if ((!LHSType->isVLSTBuiltinType() && !LHSType->isRealType()) ||
@@ -10617,7 +10613,7 @@
return QualType();
}
- if (LHSBuiltinTy && RHSBuiltinTy &&
+ if (LHSType->isVLSTBuiltinType() && RHSType->isVLSTBuiltinType() &&
Context.getBuiltinVectorTypeInfo(LHSBuiltinTy).EC !=
Context.getBuiltinVectorTypeInfo(RHSBuiltinTy).EC) {
Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
Index: clang/lib/Sema/SemaChecking.cpp
===================================================================
--- clang/lib/Sema/SemaChecking.cpp
+++ clang/lib/Sema/SemaChecking.cpp
@@ -13576,6 +13576,35 @@
const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
+ // Strip SVE vector types
+ if (SourceBT && SourceBT->isVLSTBuiltinType()) {
+ // Need the original target type for vector type checks
+ const Type *OriginalTarget = S.Context.getCanonicalType(T).getTypePtr();
+ // Handle conversion from scalable to fixed when msve-vector-bits is
+ // specified
+ if (S.Context.areCompatibleSveTypes(QualType(OriginalTarget, 0),
+ QualType(Source, 0)) ||
+ S.Context.areLaxCompatibleSveTypes(QualType(OriginalTarget, 0),
+ QualType(Source, 0)))
+ return;
+
+ if (!Target->isVLSTBuiltinType() && !isa<VectorType>(OriginalTarget)) {
+ if (S.SourceMgr.isInSystemMacro(CC))
+ return;
+ return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_vector_scalar);
+ }
+
+ // If the vector cast is cast between two vectors of the same size, it is
+ // a bitcast, not a conversion.
+ if (S.Context.getTypeSize(Source) == S.Context.getTypeSize(Target))
+ return;
+
+ Source = SourceBT->getSveEltType(S.Context).getTypePtr();
+ }
+
+ if (TargetBT && TargetBT->isVLSTBuiltinType())
+ Target = TargetBT->getSveEltType(S.Context).getTypePtr();
+
// If the source is floating point...
if (SourceBT && SourceBT->isFloatingPoint()) {
// ...and the target is floating point...
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
