reimplement vector comparisons as [fi]cmp+sext instead of using v[if]cmp.

Also, enable them in sema so that they are tested, and now that the x86 backend
has stablized.

llvm-svn: 74983

clang/lib/CodeGen/CGExprScalar.cpp

@@ -49,7 +49,6 @@ class VISIBILITY_HIDDEN ScalarExprEmitter
   CodeGenFunction &CGF;
   CGBuilderTy &Builder;
   bool IgnoreResultAssign;
-
 public:
 
   ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
@@ -61,8 +60,10 @@ public:
   //===--------------------------------------------------------------------===//
 
   bool TestAndClearIgnoreResultAssign() {
-    bool I = IgnoreResultAssign; IgnoreResultAssign = false;
-    return I; }
+    bool I = IgnoreResultAssign;
+    IgnoreResultAssign = false;
+    return I;
+  }
 
   const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
   LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
@@ -1181,7 +1182,7 @@ Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
   TestAndClearIgnoreResultAssign();
   Value *Result;
   QualType LHSTy = E->getLHS()->getType();
-  if (!LHSTy->isAnyComplexType() && !LHSTy->isVectorType()) {
+  if (!LHSTy->isAnyComplexType()) {
     Value *LHS = Visit(E->getLHS());
     Value *RHS = Visit(E->getRHS());
     
@@ -1196,22 +1197,12 @@ Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
       Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
                                   LHS, RHS, "cmp");
     }
-  } else if (LHSTy->isVectorType()) {
-    Value *LHS = Visit(E->getLHS());
-    Value *RHS = Visit(E->getRHS());
+
+    // If this is a vector comparison, sign extend the result to the appropriate
+    // vector integer type and return it (don't convert to bool).
+    if (LHSTy->isVectorType())
+      return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
     
-    if (LHS->getType()->isFPOrFPVector()) {
-      Result = Builder.CreateVFCmp((llvm::CmpInst::Predicate)FCmpOpc,
-                                  LHS, RHS, "cmp");
-    } else if (LHSTy->isUnsignedIntegerType()) {
-      Result = Builder.CreateVICmp((llvm::CmpInst::Predicate)UICmpOpc,
-                                  LHS, RHS, "cmp");
-    } else {
-      // Signed integers and pointers.
-      Result = Builder.CreateVICmp((llvm::CmpInst::Predicate)SICmpOpc,
-                                  LHS, RHS, "cmp");
-    }
-    return Result;
   } else {
     // Complex Comparison: can only be an equality comparison.
     CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());

clang/lib/Sema/SemaExpr.cpp

@@ -4305,14 +4305,6 @@ QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex,
     CheckFloatComparison(Loc,lex,rex);
   }
 
-  // FIXME: Vector compare support in the LLVM backend is not fully reliable,
-  // just reject all vector comparisons for now.
-  if (1) {
-    Diag(Loc, diag::err_typecheck_vector_comparison)
-      << lType << rType << lex->getSourceRange() << rex->getSourceRange();
-    return QualType();
-  }
-
   // Return the type for the comparison, which is the same as vector type for
   // integer vectors, or an integer type of identical size and number of
   // elements for floating point vectors.

clang/test/CodeGen/ext-vector.c

@@ -115,9 +115,7 @@ void test7(int4 *ap, int4 *bp, int c) {
   a /= c;
   a %= c;
 
-  // Vector comparisons can sometimes crash the x86 backend: rdar://6326239,
-  // reject them until the implementation is stable.
-#if 0
+  // Vector comparisons.
   int4 cmp;
   cmp = a < b;
   cmp = a <= b;
@@ -125,5 +123,4 @@ void test7(int4 *ap, int4 *bp, int c) {
   cmp = a >= b;
   cmp = a == b;
   cmp = a != b;
-#endif
 }

clang/test/Sema/exprs.c

@@ -94,15 +94,12 @@ void test13(
   P = ^(){}; // expected-error {{blocks support disabled - compile with -fblocks}}
 }
 
-
-// rdar://6326239 - Vector comparisons are not fully trusted yet, until the
-// backend is known to work, just unconditionally reject them.
 void test14() {
   typedef long long __m64 __attribute__((__vector_size__(8)));
   typedef short __v4hi __attribute__((__vector_size__(8)));
 
+  // Ok.
   __v4hi a;
-  __m64 mask = (__m64)((__v4hi)a >  // expected-error {{comparison of vector types ('__v4hi' and '__v4hi') not supported yet}}
-                      (__v4hi)a);
+  __m64 mask = (__m64)((__v4hi)a > (__v4hi)a);
 }