[clang] ee0d706 - [clang][bytecode] Implement constexpr vector unary operators +, -, ~, ! (#105996)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Aug 28 15:10:33 PDT 2024
Author: yronglin
Date: 2024-08-29T06:10:30+08:00
New Revision: ee0d70633872a30175cf29f81de7b2dbf771d708
URL: https://github.com/llvm/llvm-project/commit/ee0d70633872a30175cf29f81de7b2dbf771d708
DIFF: https://github.com/llvm/llvm-project/commit/ee0d70633872a30175cf29f81de7b2dbf771d708.diff
LOG: [clang][bytecode] Implement constexpr vector unary operators +, -, ~, ! (#105996)
Implement constexpr vector unary operators +, -, ~ and ! .
- Follow the current constant interpreter. All of our boolean operations
on vector types should be '-1' for the 'truth' type.
- Move the following functions from `Sema` to `ASTContext`, because we
used it in new interpreter.
```C++
QualType GetSignedVectorType(QualType V);
QualType GetSignedSizelessVectorType(QualType V);
```
---------
Signed-off-by: yronglin <yronglin777 at gmail.com>
Added:
clang/test/AST/ByteCode/constexpr-vectors.cpp
Modified:
clang/lib/AST/ByteCode/Compiler.cpp
clang/lib/AST/ByteCode/Compiler.h
Removed:
################################################################################
diff --git a/clang/lib/AST/ByteCode/Compiler.cpp b/clang/lib/AST/ByteCode/Compiler.cpp
index 0fc942a4f1bc4f..6a77323d939791 100644
--- a/clang/lib/AST/ByteCode/Compiler.cpp
+++ b/clang/lib/AST/ByteCode/Compiler.cpp
@@ -4991,6 +4991,8 @@ bool Compiler<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
const Expr *SubExpr = E->getSubExpr();
if (SubExpr->getType()->isAnyComplexType())
return this->VisitComplexUnaryOperator(E);
+ if (SubExpr->getType()->isVectorType())
+ return this->VisitVectorUnaryOperator(E);
std::optional<PrimType> T = classify(SubExpr->getType());
switch (E->getOpcode()) {
@@ -5312,6 +5314,110 @@ bool Compiler<Emitter>::VisitComplexUnaryOperator(const UnaryOperator *E) {
return true;
}
+template <class Emitter>
+bool Compiler<Emitter>::VisitVectorUnaryOperator(const UnaryOperator *E) {
+ const Expr *SubExpr = E->getSubExpr();
+ assert(SubExpr->getType()->isVectorType());
+
+ if (DiscardResult)
+ return this->discard(SubExpr);
+
+ auto UnaryOp = E->getOpcode();
+ if (UnaryOp != UO_Plus && UnaryOp != UO_Minus && UnaryOp != UO_LNot &&
+ UnaryOp != UO_Not)
+ return this->emitInvalid(E);
+
+ // Nothing to do here.
+ if (UnaryOp == UO_Plus)
+ return this->delegate(SubExpr);
+
+ if (!Initializing) {
+ std::optional<unsigned> LocalIndex = allocateLocal(SubExpr);
+ if (!LocalIndex)
+ return false;
+ if (!this->emitGetPtrLocal(*LocalIndex, E))
+ return false;
+ }
+
+ // The offset of the temporary, if we created one.
+ unsigned SubExprOffset =
+ this->allocateLocalPrimitive(SubExpr, PT_Ptr, true, false);
+ if (!this->visit(SubExpr))
+ return false;
+ if (!this->emitSetLocal(PT_Ptr, SubExprOffset, E))
+ return false;
+
+ const auto *VecTy = SubExpr->getType()->getAs<VectorType>();
+ PrimType ElemT = classifyVectorElementType(SubExpr->getType());
+ auto getElem = [=](unsigned Offset, unsigned Index) -> bool {
+ if (!this->emitGetLocal(PT_Ptr, Offset, E))
+ return false;
+ return this->emitArrayElemPop(ElemT, Index, E);
+ };
+
+ switch (UnaryOp) {
+ case UO_Minus:
+ for (unsigned I = 0; I != VecTy->getNumElements(); ++I) {
+ if (!getElem(SubExprOffset, I))
+ return false;
+ if (!this->emitNeg(ElemT, E))
+ return false;
+ if (!this->emitInitElem(ElemT, I, E))
+ return false;
+ }
+ break;
+ case UO_LNot: { // !x
+ // In C++, the logic operators !, &&, || are available for vectors. !v is
+ // equivalent to v == 0.
+ //
+ // The result of the comparison is a vector of the same width and number of
+ // elements as the comparison operands with a signed integral element type.
+ //
+ // https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html
+ QualType ResultVecTy = E->getType();
+ PrimType ResultVecElemT =
+ classifyPrim(ResultVecTy->getAs<VectorType>()->getElementType());
+ for (unsigned I = 0; I != VecTy->getNumElements(); ++I) {
+ if (!getElem(SubExprOffset, I))
+ return false;
+ // operator ! on vectors returns -1 for 'truth', so negate it.
+ if (!this->emitPrimCast(ElemT, PT_Bool, Ctx.getASTContext().BoolTy, E))
+ return false;
+ if (!this->emitInv(E))
+ return false;
+ if (!this->emitPrimCast(PT_Bool, ElemT, VecTy->getElementType(), E))
+ return false;
+ if (!this->emitNeg(ElemT, E))
+ return false;
+ if (ElemT != ResultVecElemT &&
+ !this->emitPrimCast(ElemT, ResultVecElemT, ResultVecTy, E))
+ return false;
+ if (!this->emitInitElem(ResultVecElemT, I, E))
+ return false;
+ }
+ break;
+ }
+ case UO_Not: // ~x
+ for (unsigned I = 0; I != VecTy->getNumElements(); ++I) {
+ if (!getElem(SubExprOffset, I))
+ return false;
+ if (ElemT == PT_Bool) {
+ if (!this->emitInv(E))
+ return false;
+ } else {
+ if (!this->emitComp(ElemT, E))
+ return false;
+ }
+ if (!this->emitInitElem(ElemT, I, E))
+ return false;
+ }
+ break;
+ default:
+ llvm_unreachable("Unsupported unary operators should be handled up front");
+ }
+ return true;
+}
+
template <class Emitter>
bool Compiler<Emitter>::visitDeclRef(const ValueDecl *D, const Expr *E) {
if (DiscardResult)
diff --git a/clang/lib/AST/ByteCode/Compiler.h b/clang/lib/AST/ByteCode/Compiler.h
index 5acfe3c41796c4..939cc0dae3546f 100644
--- a/clang/lib/AST/ByteCode/Compiler.h
+++ b/clang/lib/AST/ByteCode/Compiler.h
@@ -139,6 +139,7 @@ class Compiler : public ConstStmtVisitor<Compiler<Emitter>, bool>,
bool VisitGNUNullExpr(const GNUNullExpr *E);
bool VisitCXXThisExpr(const CXXThisExpr *E);
bool VisitUnaryOperator(const UnaryOperator *E);
+ bool VisitVectorUnaryOperator(const UnaryOperator *E);
bool VisitComplexUnaryOperator(const UnaryOperator *E);
bool VisitDeclRefExpr(const DeclRefExpr *E);
bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E);
@@ -349,6 +350,11 @@ class Compiler : public ConstStmtVisitor<Compiler<Emitter>, bool>,
return *this->classify(ElemType);
}
+ PrimType classifyVectorElementType(QualType T) const {
+ assert(T->isVectorType());
+ return *this->classify(T->getAs<VectorType>()->getElementType());
+ }
+
bool emitComplexReal(const Expr *SubExpr);
bool emitComplexBoolCast(const Expr *E);
bool emitComplexComparison(const Expr *LHS, const Expr *RHS,
diff --git a/clang/test/AST/ByteCode/constexpr-vectors.cpp b/clang/test/AST/ByteCode/constexpr-vectors.cpp
new file mode 100644
index 00000000000000..a738cfe617a0e0
--- /dev/null
+++ b/clang/test/AST/ByteCode/constexpr-vectors.cpp
@@ -0,0 +1,90 @@
+// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -std=c++14 -fsyntax-only -verify
+// RUN: %clang_cc1 %s -triple x86_64-linux-gnu -fexperimental-new-constant-interpreter -std=c++14 -fsyntax-only -verify
+
+using FourCharsVecSize __attribute__((vector_size(4))) = char;
+using FourIntsVecSize __attribute__((vector_size(16))) = int;
+using FourLongLongsVecSize __attribute__((vector_size(32))) = long long;
+using FourFloatsVecSize __attribute__((vector_size(16))) = float;
+using FourDoublesVecSize __attribute__((vector_size(32))) = double;
+using FourI128VecSize __attribute__((vector_size(64))) = __int128;
+
+using FourCharsExtVec __attribute__((ext_vector_type(4))) = char;
+using FourIntsExtVec __attribute__((ext_vector_type(4))) = int;
+using FourI128ExtVec __attribute__((ext_vector_type(4))) = __int128;
+
+// Only int vs float makes a
diff erence here, so we only need to test 1 of each.
+// Test Char to make sure the mixed-nature of shifts around char is evident.
+void CharUsage() {
+ constexpr auto H = FourCharsVecSize{-1, -1, 0, -1};
+ constexpr auto InvH = -H;
+ static_assert(InvH[0] == 1 && InvH[1] == 1 && InvH[2] == 0 && InvH[3] == 1, "");
+
+ constexpr auto ae = ~FourCharsVecSize{1, 2, 10, 20};
+ static_assert(ae[0] == -2 && ae[1] == -3 && ae[2] == -11 && ae[3] == -21, "");
+
+ constexpr auto af = !FourCharsVecSize{0, 1, 8, -1};
+ static_assert(af[0] == -1 && af[1] == 0 && af[2] == 0 && af[3] == 0, "");
+}
+
+void CharExtVecUsage() {
+ constexpr auto H = FourCharsExtVec{-1, -1, 0, -1};
+ constexpr auto InvH = -H;
+ static_assert(InvH[0] == 1 && InvH[1] == 1 && InvH[2] == 0 && InvH[3] == 1, "");
+
+ constexpr auto ae = ~FourCharsExtVec{1, 2, 10, 20};
+ static_assert(ae[0] == -2 && ae[1] == -3 && ae[2] == -11 && ae[3] == -21, "");
+
+ constexpr auto af = !FourCharsExtVec{0, 1, 8, -1};
+ static_assert(af[0] == -1 && af[1] == 0 && af[2] == 0 && af[3] == 0, "");
+}
+
+void FloatUsage() {
+ constexpr auto Y = FourFloatsVecSize{1.200000e+01, 1.700000e+01, -1.000000e+00, -1.000000e+00};
+ constexpr auto Z = -Y;
+ static_assert(Z[0] == -1.200000e+01 && Z[1] == -1.700000e+01 && Z[2] == 1.000000e+00 && Z[3] == 1.000000e+00, "");
+
+ // Operator ~ is illegal on floats.
+ constexpr auto ae = ~FourFloatsVecSize{0, 1, 8, -1}; // expected-error {{invalid argument type}}
+
+ constexpr auto af = !FourFloatsVecSize{0, 1, 8, -1};
+ static_assert(af[0] == -1 && af[1] == 0 && af[2] == 0 && af[3] == 0, "");
+}
+
+void FloatVecUsage() {
+ constexpr auto Y = FourFloatsVecSize{1.200000e+01, 1.700000e+01, -1.000000e+00, -1.000000e+00};
+ constexpr auto Z = -Y;
+ static_assert(Z[0] == -1.200000e+01 && Z[1] == -1.700000e+01 && Z[2] == 1.000000e+00 && Z[3] == 1.000000e+00, "");
+
+ // Operator ~ is illegal on floats.
+ constexpr auto ae = ~FourFloatsVecSize{0, 1, 8, -1}; // expected-error {{invalid argument type}}
+
+ constexpr auto af = !FourFloatsVecSize{0, 1, 8, -1};
+ static_assert(af[0] == -1 && af[1] == 0 && af[2] == 0 && af[3] == 0, "");
+}
+
+void I128Usage() {
+ // Operator ~ is illegal on floats, so no test for that.
+ constexpr auto c = ~FourI128VecSize{1, 2, 10, 20};
+ static_assert(c[0] == -2 && c[1] == -3 && c[2] == -11 && c[3] == -21, "");
+
+ constexpr auto d = !FourI128VecSize{0, 1, 8, -1};
+ static_assert(d[0] == -1 && d[1] == 0 && d[2] == 0 && d[3] == 0, "");
+}
+
+void I128VecUsage() {
+ // Operator ~ is illegal on floats, so no test for that.
+ constexpr auto c = ~FourI128ExtVec{1, 2, 10, 20};
+ static_assert(c[0] == -2 && c[1] == -3 && c[2] == -11 && c[3] == -21, "");
+
+ constexpr auto d = !FourI128ExtVec{0, 1, 8, -1};
+ static_assert(d[0] == -1 && d[1] == 0 && d[2] == 0 && d[3] == 0, "");
+}
+
+using FourBoolsExtVec __attribute__((ext_vector_type(4))) = bool;
+void BoolVecUsage() {
+ constexpr auto j = !FourBoolsExtVec{true, false, true, false};
+ static_assert(j[0] == false && j[1] == true && j[2] == false && j[3] == true, "");
+
+ constexpr auto k = ~FourBoolsExtVec{true, false, true, false};
+ static_assert(k[0] == false && k[1] == true && k[2] == false && k[3] == true, "");
+}
More information about the cfe-commits
mailing list