Add (hopefully) the last missing lvalue-to-rvalue conversion. Add an assertion

to catch some future implicit lvalue-to-rvalue casts of inappropriate kinds.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@143182 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp
index 9b788a7058b7088129b2db56ac986b8a1cb35050..7d28026402a677484788915419de7cdc477447d4 100644 (file)
--- a/lib/Sema/Sema.cpp
+++ b/lib/Sema/Sema.cpp
@@ -240,6 +240,20 @@ ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
                                    CastKind Kind, ExprValueKind VK,
                                    const CXXCastPath *BasePath,
                                    CheckedConversionKind CCK) {
+#ifndef NDEBUG
+  if (VK == VK_RValue && !E->isRValue()) {
+    switch (Kind) {
+    default:
+      assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind");
+    case CK_LValueToRValue:
+    case CK_ArrayToPointerDecay:
+    case CK_FunctionToPointerDecay:
+    case CK_ToVoid:
+      break;
+    }
+  }
+#endif
+
   QualType ExprTy = Context.getCanonicalType(E->getType());
   QualType TypeTy = Context.getCanonicalType(Ty);
 

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index a733b81361657269d288ea9d5a8e2eafe02a0f15..1e890eef1e33b3611d525ee24b4b9961ecc71fdd 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -5722,6 +5722,15 @@ QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS,
 
 QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                    SourceLocation Loc, bool IsCompAssign) {
+  if (!IsCompAssign) {
+    LHS = DefaultFunctionArrayLvalueConversion(LHS.take());
+    if (LHS.isInvalid())
+      return QualType();
+  }
+  RHS = DefaultFunctionArrayLvalueConversion(RHS.take());
+  if (RHS.isInvalid())
+    return QualType();
+
   // For conversion purposes, we ignore any qualifiers.
   // For example, "const float" and "float" are equivalent.
   QualType LHSType =
@@ -6819,8 +6828,10 @@ QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
   // x == x, x != x, x < x, etc.  These always evaluate to a constant, and
   // often indicate logic errors in the program.
   if (!LHSType->hasFloatingRepresentation()) {
-    if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParens()))
-      if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParens()))
+    if (DeclRefExpr* DRL
+          = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts()))
+      if (DeclRefExpr* DRR
+            = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts()))
         if (DRL->getDecl() == DRR->getDecl())
           DiagRuntimeBehavior(Loc, 0,
                               PDiag(diag::warn_comparison_always)

diff --git a/test/SemaCXX/vector.cpp b/test/SemaCXX/vector.cpp
index 4d3d93974c1695084a74f31ca40fe9e9a46498eb..82245ac29bbd8b10793c931f59ee940d5d14684e 100644 (file)
--- a/test/SemaCXX/vector.cpp
+++ b/test/SemaCXX/vector.cpp
@@ -218,3 +218,52 @@ void test(fltx2 fltx2_val, fltx4 fltx4_val, dblx2 dblx2_val, dblx4 dblx4_val) {
   // Scalar-to-vector conversions.
   accept_fltx2(1.0); // expected-error{{no matching function for call to 'accept_fltx2'}}
 }
+
+typedef int intx4 __attribute__((__vector_size__(16)));
+typedef int inte4 __attribute__((__ext_vector_type__(4)));
+typedef int flte4 __attribute__((__ext_vector_type__(4)));
+
+void test_mixed_vector_types(fltx4 f, intx4 n, flte4 g, flte4 m) {
+  (void)(f == g);
+  (void)(g != f);
+  (void)(f <= g);
+  (void)(g >= f);
+  (void)(f < g);
+  (void)(g > f);
+
+  (void)(+g);
+  (void)(-g);
+
+  (void)(f + g);
+  (void)(f - g);
+  (void)(f * g);
+  (void)(f / g);
+  (void)(f = g);
+  (void)(f += g);
+  (void)(f -= g);
+  (void)(f *= g);
+  (void)(f /= g);
+
+
+  (void)(n == m);
+  (void)(m != n);
+  (void)(n <= m);
+  (void)(m >= n);
+  (void)(n < m);
+  (void)(m > n);
+
+  (void)(+m);
+  (void)(-m);
+  (void)(~m);
+
+  (void)(n + m);
+  (void)(n - m);
+  (void)(n * m);
+  (void)(n / m);
+  (void)(n % m);
+  (void)(n = m);
+  (void)(n += m);
+  (void)(n -= m);
+  (void)(n *= m);
+  (void)(n /= m);
+}