[clang] Implement VectorType logic not operator.

[junparser]

Summary

As title. This patch implement unary operator ! of vector type.

TestPlan: check-clang

[junparser]

@erichkeane @aaron.ballman , kindly ping :)

[erichkeane]

Write some codegen tests please, I'd like to have a better idea of what you want ! to do here. Additionally, I'm not sure as to the limits you've placed on this patch. Please justifiy them.C

clang/lib/CodeGen/CGExprScalar.cpp

2746

Why limit this to just the base vector type? Doesn't this remove the ext-vector implementation?

clang/lib/Sema/SemaExpr.cpp

14448

Why C++ only? It seems if we're doing this, it should be for all language modes.

clang/test/CodeGen/vector.c

90 ↗

(On Diff #267788)

Can you clarify what this is doing here? It doesn't seem clear to me what the output of this is.

Additionally, what about FP types? What do we expect this to emit?

98 ↗

(On Diff #267788)

Why is the IR so different between int and long long (here and the above test)? It would seem to me the IR should be basically identical, perhaps with a cast somewhere, but not completely different IR.

[junparser]

clang/lib/CodeGen/CGExprScalar.cpp

2746

the kind of ext-vector is GenericVector as well. so it also includes ext-vector.

clang/lib/Sema/SemaExpr.cpp

14448

Here we keep the behavior as same as gcc since ! of vector only allows with C++ in gcc

clang/test/CodeGen/vector.c

90 ↗

(On Diff #267788)

sorry for the confusing. it seems i add the wrong code which test the != rather than !. I'll add the new testcases

[junparser]

This patch implement the logic not operation of vector type. it keeps same behavior as gcc does (only allows in C++). I'll update the wrong testcases

[junparser]

address the comment.
hi @erichkeane, most of the function in vector-1.cpp are copied from ext-vector.c with vector type changed to gcc vector type, they should emit same ir. I add test7 and test8 which test logic operation of gcc vector type.

[junparser]

clang/test/CodeGen/vector-1.cpp

183 ↗

(On Diff #268366)

logic operation with vector int

201 ↗

(On Diff #268366)

logic operation with vector float

[erichkeane]

clang/lib/CodeGen/CGExprScalar.cpp

2746

"isVectorType" also includes ExtVectorType. My question is which vector types are you attempting to exclude here?

Can the ExtVectorKind ever be a AltiVec* or Neon Vector type? If so, this change would break code for those.

[erichkeane]

clang/lib/CodeGen/CGExprScalar.cpp

2746

Just dug in and answered my own question, ExtVector is always created as Generic, see ASTContext::getExtVectorType. So I think the check for GenericVector (here and in Sema) properly constrains this patch to only adding C++-mode standard vector-types.

clang/test/CodeGen/vector-1.cpp

2 ↗

(On Diff #268366)

I don't think copying the whole test from the other file is the right idea. We already validate the rest of the operations on normal vectors in a number of places. If any of those are C++ tests, just add your tests there. Otherwise this test should only validate the logical-not operator.

[junparser]

clang/test/CodeGen/vector-1.cpp

2 ↗

(On Diff #268366)

ok, I'll only add the logical-not operator test

[junparser]

address the comment.

[thakis]

This breaks tests on Windows: http://45.33.8.238/win/17077/step_7.txt

Please take a look and revert if it takes a while to fix.

[thakis]

Reverted in abca3b7b2ce539ce22c9d3ebdd3cb6c02bb4c009.

clang/docs/LanguageExtensions.rst

============================== ======= ======= ============= =======
          Operator              OpenCL  AltiVec     GCC        NEON
 ============================== ======= ======= ============= =======
 []                               yes     yes       yes         --
 unary operators +, --            yes     yes       yes         --
 ++, -- --                        yes     yes       yes         --
 +,--,*,/,%                       yes     yes       yes         --
 bitwise operators &,|,^,~        yes     yes       yes         --
 >>,<<                            yes     yes       yes         --
-!, &&, ||                        yes     --        yes [#]_    --
+!, &&, ||                        yes     --        yes         --
 ==, !=, >, <, >=, <=             yes     yes       yes         --
 =                                yes     yes       yes         yes
 ?: [#]_                          yes     --        yes         --
 sizeof                           yes     yes       yes         yes
 C-style cast                     yes     yes       yes         no
 reinterpret_cast                 yes     no        yes         no
 static_cast                      yes     no        yes         no
 const_cast                       no      no        no          no
 ============================== ======= ======= ============= =======
 
 See also :ref:`langext-__builtin_shufflevector`, :ref:`langext-__builtin_convertvector`.
 
-.. [#] unary operator ! is not implemented, however && and || are.
 .. [#] ternary operator(?:) has different behaviors depending on condition
   operand's vector type. If the condition is a GNU vector (i.e. __vector_size__),
   it's only available in C++ and uses normal bool conversions (that is, != 0).
   If it's an extension (OpenCL) vector, it's only available in C and OpenCL C.
   And it selects base on signedness of the condition operands (OpenCL v1.1 s6.3.9).
 
 Matrix Types
 ============

clang/lib/CodeGen/CGExprScalar.cpp

 Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
   TestAndClearIgnoreResultAssign();
   Value *Op = Visit(E->getSubExpr());
   return Builder.CreateNot(Op, "neg");
 }
 
 Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
   // Perform vector logical not on comparison with zero vector.
-  if (E->getType()->isExtVectorType()) {
+  if (E->getType()->isVectorType() &&
+      E->getType()->castAs<VectorType>()->getVectorKind() ==
+          VectorType::GenericVector) {
     Value *Oper = Visit(E->getSubExpr());
     Value *Zero = llvm::Constant::getNullValue(Oper->getType());
     Value *Result;
     if (Oper->getType()->isFPOrFPVectorTy()) {
       llvm::IRBuilder<>::FastMathFlagGuard FMFG(Builder);
       setBuilderFlagsFromFPFeatures(Builder, CGF,
                                     E->getFPFeatures(CGF.getLangOpts()));
       Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero, "cmp");

clang/lib/Sema/SemaExpr.cpp

if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) {
         QualType T = resultType->castAs<ExtVectorType>()->getElementType();
         if (!T->isIntegerType())
           return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
                            << resultType << Input.get()->getSourceRange());
       }
       // Vector logical not returns the signed variant of the operand type.
       resultType = GetSignedVectorType(resultType);
       break;
+    } else if (Context.getLangOpts().CPlusPlus && resultType->isVectorType()) {
+      const VectorType *VTy = resultType->castAs<VectorType>();
+      if (VTy->getVectorKind() != VectorType::GenericVector)
+        return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
+                         << resultType << Input.get()->getSourceRange());
+
+      // Vector logical not returns the signed variant of the operand type.
+      resultType = GetSignedVectorType(resultType);
+      break;
     } else {
-      // FIXME: GCC's vector extension permits the usage of '!' with a vector
-      //        type in C++. We should allow that here too.
       return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
         << resultType << Input.get()->getSourceRange());
     }
 
     // LNot always has type int. C99 6.5.3.3p5.
     // In C++, it's bool. C++ 5.3.1p8
     resultType = Context.getLogicalOperationType();
     break;

clang/test/CodeGen/vector-logic-not.cpp

+// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
+
+typedef __attribute__((__vector_size__(16))) float float4;
+typedef __attribute__((__vector_size__(16))) int int4;
+typedef __attribute__((__vector_size__(16))) unsigned int uint4;
+
+// CHECK: @_Z5test1Dv4_j
+int4 test1(uint4 V0) {
+  // CHECK: [[CMP0:%.*]] = icmp eq <4 x i32> [[V0:%.*]], zeroinitializer
+  // CHECK-NEXT: [[V1:%.*]] = sext <4 x i1> [[CMP0]] to <4 x i32>
+  int4 V = !V0;
+  return V;
+}
+
+// CHECK: @_Z5test2Dv4_fS_
+int4 test2(float4 V0, float4 V1) {
+  // CHECK: [[CMP0:%.*]] = fcmp oeq <4 x float> [[V0:%.*]], zeroinitializer
+  // CHECK-NEXT: [[V1:%.*]] = sext <4 x i1> [[CMP0]] to <4 x i32>
+  int4 V = !V0;
+  return V;
+}

clang/test/Sema/vector-gcc-compat.cpp

 }
 
 void logicTest(void) {
   v2i64 v2i64_a = (v2i64){0, 1}; // expected-warning {{compound literals are a C99-specific feature}}
   v2i64 v2i64_b = (v2i64){2, 1}; // expected-warning {{compound literals are a C99-specific feature}}
   v2i64 v2i64_c = (v2i64){3, 1}; // expected-warning {{compound literals are a C99-specific feature}}
   v2i64 v2i64_r;
 
-  v2i64_r = !v2i64_a;  // expected-error {{invalid argument type 'v2i64' (vector of 2 'long long' values) to unary expression}}
+  v2i64_r = !v2i64_a;
   v2i64_r = ~v2i64_a;
 
   v2i64_r = v2i64_a ? v2i64_b : v2i64_c;
 
   v2i64_r = v2i64_a & 1;
   v2i64_r = v2i64_a | 1;
   v2i64_r = v2i64_a ^ 1;