[Sema] Support implicit scalar to vector conversions

[sdardis]

Summary

This patch teaches clang to perform implicit scalar to vector conversions
when one of the operands of a binary vector expression is a scalar which
can be converted to the element type of the vector without truncation
following GCC's implementation.

If the (constant) scalar is can be casted safely, it is implicitly casted to the
vector elements type and splatted to produce a vector of the same type.

Contributions from: Petar Jovanovic

[ahatanak]

lib/Sema/SemaExpr.cpp

8180–8181

Is this the same as "!RHSVecType && LHSVecType" in this context?

[ahatanak]

lib/Sema/SemaExpr.cpp

8180–8181

Actually, LHS's type should be a vector here if RHS isn't a vector since CheckVectorOperands is called only when at least one operand is a vector.

[sdardis]

Extra testing for cases where the operand on the left of an operation is a vector.
Removed two spurious checks for vector types.

[bruno]

Hi,

Nice, thanks for working on this!

lib/Sema/SemaExpr.cpp

8191

tryVectorConvertAndSplat does more than plain scalar splat; it supports a more general type of CK_IntegralCast, see the comment on one of your changes to the tests below.

I suggest that instead of reusing this function, you should create another one that only handles the cases we actually want to support for non-ext vectors (i.e. for GCC compat).

test/Sema/vector-scalar-implict-conv.c

2 ↗

(On Diff #75708)

Can you rename this to vector-gcc-compat.c? It would also be nice to split functionality being tested within their own function, e.g.: arithmetic, logic, vector comparisons.

[bruno]

test/Sema/vector-cast.c

57

This is not right. The fact that we don't have the appropriate diagnostics here doesn't mean we should accept this. For instance, this is what we get with GCC:

error: conversion of scalar 'double' to vector 'float2 {aka __vector(2) float}' involves truncation

[sdardis]

Split out a variant of tryVectorConvertAndSplat called tryGCCVectorConvertAndSplat. This variant checks the types more strictly than tryVectorConvertAndSplat and handles implicit conversion of constants which can be safely demoted to a smaller type.
Added more testing to vector-gcc-compat.c

[sdardis]

Ping.

[bruno]

lib/Sema/SemaExpr.cpp

7978

Remove this empty line.

7991

This can be simplified by checking isArithmeticType() for each instead.

8005

You already checked this condition in the if above, this will never trigger.

8043

I don't see how VectorEltTy != ScalarTy is possible here.

8064

I don't see why it's necessary to check for all specific cases where the scalar is a constant. For all the others scenarios it should be enough to get the right answer via getIntegerTypeOrder or getFloatTypeOrder. For this is specific condition, the else part for the CstScalar below should also handle the constant case, right?

8267

This change seems orthogonal to this patch. Can you make it a separated patch with the changes from test/Sema/vector-cast.c?

test/Sema/vector-gcc-compat.c

2

These are really nice tests. Some cosmetic cleanups: can you run it through clang-format and also remove (a) newlines between comments and codes, (b) places with double newlines?

[sdardis]

Addressed review comments.

[sdardis]

lib/Sema/SemaExpr.cpp

8064

If we have a scalar constant, it is necessary to examine it's actual value to see if it can be casted without truncation. The scalar constant's type is somewhat irrelevant. Consider:

v4f32 f(v4f32 a) {
  return a + (double)1.0;
}

In this case examining the order only works if the vector's order is greater than or equal to the scalar constant's order. Instead, if we ask whether the scalar constant can be represented as a constant scalar of the vector's element type, then we know if we can convert without the loss of precision.

For integers, the case is a little more contrived due to native integer width, but the question is the same. Can a scalar constant X be represented as a given floating point type. Consider:

v4f32 f(v4f32 a) {
  return a + (signed int)1;
 }

This would rejected for platforms where a signed integer's width is greater than the precision of float if we examined it based purely on types and their sizes. Instead, if we convert the integer to the float point's type with APFloat and convert back to see if we have the same value, we can determine if the scalar constant can be safely converted without the loss of precision.

I based the logic examining the value of the constant scalar based on GCC's behaviour, which implicitly converts scalars regardless of their type if they can be represented in the same type of the vector's element type without the loss of precision. If the scalar cannot be evaluated to a constant at compile time, then the size in bits for the scalar's type determines if it can be converted safely.

8267

This change is a necessary part of this patch and it can't be split out in sensible fashion.

For example, line 329 of test/Sema/zvector.c adds a scalar signed character to a vector of signed characters. With just this change we would report "cannot convert between scalar type 'signed char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation".

This is heavily misleading for C and C++ code as we don't perform implicit conversions and signed char could be implicitly converted to a vector of signed char without the loss of precision.

To make this diagnostic precise without performing implicit conversions requires determining cases where implicit conversion would cause truncation and reporting that failure reason, or defaulting to the generic diagnostic.

Keeping this change as part of this patch is cleaner and simpler as it covers both implicit conversions and more precise diagnostics.

[bruno]

lib/Sema/SemaExpr.cpp

8034

Please also early return !CstScalar && Order < 0 like you did below.

8064

Right. Can you split the scalarTy <-> vectorEltTy checking logic into separate functions; one for cst-scalar-int-to-vec-elt-int and another for scalar-int-to-vec-elt-float?

8078

ignored => Ignored

8189

It's not clear to me whether clang should support the GCC semantics when in getLangOpts().AltiVec || getLangOpts().ZVector, do you?

You can remove the curly braces for the if and else here.

8200

Also remove braces here.

8267

Can you double check whether we should support these GCC semantics for getLangOpts().ZVector? If not, then this should be introduced in a separate patch/commit.

[sdardis]

Addressed review comments, fixed assertion issue with expressions like scalar -= vector.

[sdardis]

lib/Sema/SemaExpr.cpp

8189

We should, GCC performs scalar to vector conversions regardless of what cpu features are available. If the target machine doesn't have vector support, GCC silently scalarizes the operation.

https://gcc.gnu.org/onlinedocs/gcc-6.2.0/gcc/Vector-Extensions.html#Vector-Extensions

8191

(ignore this, phabricator's web interface is acting up)

8267

See my comment above.

[sdardis]

Ping.

[sdardis]

Ping.

[bruno]

Hey, really sorry for the delay here.

lib/Sema/SemaExpr.cpp

7977

This doesn't look clang-formated.

8004

Instead of the else here, you can:

....
   return (IntSigned != OtherIntSigned &&
       NumBits > S.Context.getIntWidth(OtherIntTy))
}

return (Order < 0);

8062

Can you please add an assertion to the beginning of this function to guarantee that the vector is never a ext-vector type? I wanna make sure we don't accidentally use this in the future for ext-vectors.

test/Sema/vector-gcc-compat.c

62

Can you double check where 'long attribute((ext_vector_type(2)))' comes from?

We have regressed in the past year in the way ext-vector interacts with non-ext-vectors, and I don't wanna make it worse until we actually have time to fix that; there's a lot of code out there relying on bitcasts between ext-vectors and non-ext-vectors to bridge between intrinsics headers and ext-vector code.

[sdardis]

Thanks for getting back to this. I've traced the appearance of the ext_vector type to a piece of code that only produces ext-vector types for comparisons. I'm presuming that's wrong when clang is producing vectors implicitly in the non-OpenCL case. I'll update the diff once I've changed that.

test/Sema/vector-gcc-compat.c

62

Sema::CheckVectorCompareOperands calls Sema::GetSignedVectorType which only returns ext-vector types. I presume that is now incorrect if we're producing vectors from literal scalars in the non OpenCL case.

[sdardis]

Addressed review comments, add C++ specific test.

[bruno]

test/Sema/vector-gcc-compat.c

62

Nice catch, can you please submit these specific changes as a separated patch and mark it as a prerequisite of this one?

[sdardis]

Factored out the changes from D31337.

[bruno]

lib/Sema/SemaExpr.cpp

7942

Double checking here: are there tests for the InvalidOperands case above?

8055

Spalt -> Splat

8080

Is this something that GCC is going to support at some point? Regardless of GCC, do we want this behavior?

9820

Why !getLangOpts().CPlusPlus is a requirement here?

test/Sema/vector-g++-compat.cpp

1 ↗

(On Diff #94070)

Can you rename this file to vector-gcc-compat.cpp instead?

155 ↗

(On Diff #94070)

Remove all these extra new lines after the function signature here, in the functions below and in the other added test file for c++.

[sdardis]

Thanks for sticking with this.

I've held off updating the diff until D31667 (not D31337 as previously posted) is finished. Responses inlined.

lib/Sema/SemaExpr.cpp

8080

Is this something that GCC is going to support at some point?

I've reread GCC's source for conversions of scalar to vectors types and it appears that GCC does attempt to convert constant real expressions to integers but it appears to only work for C++. It's a little odd.

Regardless of GCC, do we want this behavior?

Given my oversight of the support of implicit safe conversions of floating point constants to integer types, I believe we should do this in general. I'll rework the comment to be more accurate and add the necessary conversion checks.

9820

GCC only supports the logical operators &&, ||, ! when compiling C++.

It's noted near the bottom half of this page: https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html

test/Sema/vector-g++-compat.cpp

155 ↗

(On Diff #94070)

Will do.

[bruno]

lib/Sema/SemaExpr.cpp

8080

Ok, improving the FIXME sounds good to me. We can add this extra functionality in a future patch.

9820

Ok. It would be nice to find out if there's any actual good reason for it, otherwise we might as well support it for non C++. But no need to block on that; just make sure to annotate these places with FIXMEs so we can work on it in the future.

[ahatanak]

lib/Sema/SemaExpr.cpp

7934

I think "!=" is easier to understand than "^" here.

8179

"a vector"

[sdardis]

Addressed review comments.

I've changed InvalidVectorOperands() to not use InvalidOperands() after updating some tests. InvalidOperands() was receiving expressions with implicit casts, leading to misleading error messages.

[bruno]

lib/Sema/SemaExpr.cpp

9821

Please mention in the comment the list of logical ops that this applies to: "!, &&, ||"

test/Sema/vector-gcc-compat.c

102

Is this because of && and others only working in C++? If so, we need a better error message here, along the lines of "logical expression with vector only support in C++". If later on we decide to support it in non-C++, we then get rid of the warning.

[sdardis]

Addressed review comments. I've highlighted the relevant places with FIXME:s where we don't support GCC vector operations.

[sdardis]

Realised I've some comments to submit.

lib/Sema/SemaExpr.cpp

7942

Yes, this case is covered in the new diff in test/Sema/vector-ops.c and in test/Sema/vector-gcc-compat.c .

9821

I've updated the relevant Check* functions with FIXME:s noting that they should handle vector types for compatibility with GCC.

test/Sema/vector-gcc-compat.c

102

Yes, these operators are oddly only available in C++.

I've changed the error message to "logical expression with vector type[s] '<typedef'd name>' (vector of <N> '<element type>' values) [and '<other type>'] is only supported in C++".

[sdardis]

Rebase + ping.

[bruno]

Thanks for your patience! LGTM with a minor comment below.

test/Sema/vector-gcc-compat.c

102

Great, can you also mention the type of the other hand side when it's not a vector?

[sdardis]

Updated error message for logical operations where one operand is a vector and the other isn't.

Updated summary.

I'll commit this shortly.

[sdardis]

Thanks for the review.

include/clang/Basic/DiagnosticSemaKinds.td

def err_format_attribute_implicit_this_format_string : Error<
   "format attribute cannot specify the implicit this argument as the format "
   "string">;
 def err_init_method_bad_return_type : Error<
   "init methods must return an object pointer type, not %0">;
 def err_attribute_invalid_size : Error<
   "vector size not an integral multiple of component size">;
 def err_attribute_zero_size : Error<"zero vector size">;
 def err_attribute_size_too_large : Error<"vector size too large">;
+def err_typecheck_vector_not_convertable_implict_truncation : Error<
+   "cannot convert between %select{scalar|vector}0 type %1 and vector type"
+   " %2 as implicit conversion would cause truncation">;
 def err_typecheck_vector_not_convertable : Error<
   "cannot convert between vector values of different size (%0 and %1)">;
 def err_typecheck_vector_not_convertable_non_scalar : Error<
   "cannot convert between vector and non-scalar values (%0 and %1)">;
 def err_typecheck_vector_lengths_not_equal : Error<
   "vector operands do not have the same number of elements (%0 and %1)">;
 def warn_typecheck_vector_element_sizes_not_equal : Warning<
   "vector operands do not have the same elements sizes (%0 and %1)">,

lib/Sema/SemaExpr.cpp

 
 /// Try to convert a value of non-vector type to a vector type by converting
 /// the type to the element type of the vector and then performing a splat.
 /// If the language is OpenCL, we only use conversions that promote scalar
 /// rank; for C, Obj-C, and C++ we allow any real scalar conversion except
 /// for float->int.
 ///
 /// \param scalar - if non-null, actually perform the conversions
 /// \return true if the operation fails (but without diagnosing the failure)
 static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
                                      QualType scalarTy,
                                      QualType vectorEltTy,
                                      QualType vectorTy) {
   // The conversion to apply to the scalar before splatting it,
   // if necessary.
   CastKind scalarCast = CK_Invalid;
   
   if (vectorEltTy->isIntegralType(S.Context)) {
     if (!scalarTy->isIntegralType(S.Context))
       return true;
     if (S.getLangOpts().OpenCL &&
         S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0)
       return true;
     scalarCast = CK_IntegralCast;
   } else if (vectorEltTy->isRealFloatingType()) {
static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
   if (scalar) {
     if (scalarCast != CK_Invalid)
       *scalar = S.ImpCastExprToType(scalar->get(), vectorEltTy, scalarCast);
     *scalar = S.ImpCastExprToType(scalar->get(), vectorTy, CK_VectorSplat);
   }
   return false;
 }
 
+/// Attempt to convert and splat Scalar into a vector whose types matches
+/// Vector following GCC conversion rules. The main rule is that implicit
+/// conversion occurs when Scalar can be casted to match Vector's element type
+/// without causing truncation of Scalar.
+
+static bool tryGCCVectorConvertAndSpalt(Sema &S, ExprResult *Scalar,
+                                        ExprResult *Vector) {
+  QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
+  QualType VectorTy = Vector->get()->getType().getUnqualifiedType();
+  const VectorType *VT = VectorTy->getAs<VectorType>();
+  QualType VectorEltTy = VT->getElementType();
+
+  // Reject cases where the vector element type or the scalar element type are
+  // not integral or floating point types.
+  if ((!VectorEltTy->isIntegralType(S.Context) &&
+       !VectorEltTy->isRealFloatingType()) ||
+      (!ScalarTy->isIntegralType(S.Context) &&
+       !ScalarTy->isRealFloatingType()))
+    return true;
+
+  // The conversion to apply to the scalar before splatting it,
+  // if necessary.
+  CastKind ScalarCast = CK_Invalid;
+  if (VectorEltTy->isIntegralType(S.Context) &&
+      ScalarTy->isIntegralType(S.Context) &&
+      S.Context.getIntegerTypeOrder(VectorEltTy, ScalarTy)) {
+    // Reject cases where the scalar is not an integer.
+    //
+    // Notionally if the scalar was a floating point value with a precise
+    // integral representation, we could cast it to an appropriate integer
+    // type and then perform the rest of the checks here.
+    if (!ScalarTy->isIntegralType(S.Context))
+      return true;
+
+    // Reject cases where the value of the scalar is unknown as that would
+    // possibly cause truncation, but accept cases where the scalar can be
+    // demoted without loss of precision.
+    llvm::APSInt Result;
+    bool CstScalar = Scalar->get()->EvaluateAsInt(Result, S.Context);
+    int Order = S.Context.getIntegerTypeOrder(VectorEltTy, ScalarTy);
+    bool ScalarSigned = ScalarTy->hasSignedIntegerRepresentation();
+    bool VectorSigned = VectorTy->hasSignedIntegerRepresentation();
+
+    if (CstScalar) {
+      // If the scalar is constant and is of a higher order and has more active
+      // bits that the vector element type, reject it.
+      unsigned NumBits = ScalarSigned
+                             ? (Result.isNegative() ? Result.getMinSignedBits()
+                                                    : Result.getActiveBits())
+                             : Result.getActiveBits();
+      if (Order < 0 && S.Context.getIntWidth(VectorEltTy) < NumBits)
+        return true;
+
+      // If the signedness of the scalar type and the vector element type
+      // differs and the number of bits is greater than that of the vector
+      // element reject it.
+      if (ScalarSigned != VectorSigned &&
+          NumBits > S.Context.getIntWidth(VectorEltTy))
+        return true;
+    } else {
+
+      // Reject cases where the value of the scalar is not constant and it's
+      // order is greater than that of the vector element type.
+      if (Order < 0)
+        return true;
+    }
+
+    ScalarCast = CK_IntegralCast;
+  } else if (VectorEltTy->isRealFloatingType()) {
+    if (ScalarTy->isRealFloatingType() && VectorEltTy != ScalarTy) {
+
+      // Reject cases where the scalar type is not a constant and has a higher
+      // Order than the vector element type.
+      llvm::APFloat Result(0.0);
+      bool CstScalar = Scalar->get()->EvaluateAsFloat(Result, S.Context);
+      int Order = S.Context.getFloatingTypeOrder(VectorEltTy, ScalarTy);
+      if (!CstScalar && Order < 0)
+        return true;
+
+      // If the scalar cannot be safely casted to the vector element type,
+      // reject it.
+      if (CstScalar) {
+        bool Truncated = false;
+        Result.convert(S.Context.getFloatTypeSemantics(VectorEltTy),
+                       llvm::APFloat::rmNearestTiesToEven, &Truncated);
+        if (Truncated)
+          return true;
+      }
+
+      ScalarCast = CK_FloatingCast;
+    } else if (ScalarTy->isIntegralType(S.Context)) {
+      // Determine if the integer constant can be expressed as a floating point
+      // number of the appropiate type.
+      llvm::APSInt Result;
+      bool CstScalar = Scalar->get()->EvaluateAsInt(Result, S.Context);
+      uint64_t Bits = 0;
+      if (CstScalar) {
+        // Reject constants that cannot would be truncated if convert to the
+        // the floating point type. Test by simple to/from conversion.
+        // FIXME: Ideally the conversion to an APFloat and from an APFloat
+        //        could be avoided if there was a convertFromAPInt method
+        //        which could signal back if implicit truncation occurred.
+        llvm::APFloat Float(S.Context.getFloatTypeSemantics(VectorEltTy));
+        Float.convertFromAPInt(Result,
+                               ScalarTy->hasSignedIntegerRepresentation(),
+                               llvm::APFloat::rmTowardZero);
+        llvm::APSInt ConvertBack(S.Context.getIntWidth(ScalarTy),
+                                 !ScalarTy->hasSignedIntegerRepresentation());
+        bool ignored = false;
+        Float.convertToInteger(
+            ConvertBack, llvm::APFloat::rmNearestTiesToEven, &ignored);
+        if (Result != ConvertBack)
+          return true;
+      } else {
+        // Reject types that cannot be fully encoded into the mantissa of
+        // the float.
+        Bits = S.Context.getTypeSize(ScalarTy);
+        unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
+            S.Context.getFloatTypeSemantics(VectorEltTy));
+        if (Bits > FloatPrec)
+          return true;
+      }
+
+      ScalarCast = CK_IntegralToFloating;
+    } else
+      return true;
+  }
+
+  // Adjust scalar if desired.
+  if (Scalar) {
+    if (ScalarCast != CK_Invalid)
+      *Scalar = S.ImpCastExprToType(Scalar->get(), VectorEltTy, ScalarCast);
+    *Scalar = S.ImpCastExprToType(Scalar->get(), VectorTy, CK_VectorSplat);
+  }
+  return false;
+}
+
 QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                    SourceLocation Loc, bool IsCompAssign,
                                    bool AllowBothBool,
                                    bool AllowBoolConversions) {
   if (!IsCompAssign) {
     LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
     if (LHS.isInvalid())
       return QualType();
if (!IsCompAssign &&
         LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
         RHSVecType->getVectorKind() == VectorType::AltiVecVector &&
         RHSVecType->getElementType()->isIntegerType()) {
       LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
       return RHSType;
     }
   }
 
-  // If there's an ext-vector type and a scalar, try to convert the scalar to
+  // If there's an vector type and a scalar, try to convert the scalar to
   // the vector element type and splat.
-  // FIXME: this should also work for regular vector types as supported in GCC.
-  if (!RHSVecType && isa<ExtVectorType>(LHSVecType)) {
+  if (!RHSVecType) {
+    if (isa<ExtVectorType>(LHSVecType)) {
       if (!tryVectorConvertAndSplat(*this, &RHS, RHSType,
                                     LHSVecType->getElementType(), LHSType))
         return LHSType;
+    } else {
+      if (!tryGCCVectorConvertAndSpalt(*this, &RHS, &LHS))
+        return LHSType;
     }
-  if (!LHSVecType && isa<ExtVectorType>(RHSVecType)) {
+  }
+  if (!LHSVecType) {
+    if (isa<ExtVectorType>(RHSVecType)) {
       if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS),
                                     LHSType, RHSVecType->getElementType(),
                                     RHSType))
         return RHSType;
+    } else {
+      if (!tryGCCVectorConvertAndSpalt(*this, &LHS, &RHS))
+        return RHSType;
+    }
   }
 
   // FIXME: The code below also handles convertion between vectors and
   // non-scalars, we should break this down into fine grained specific checks
   // and emit proper diagnostics.
   QualType VecType = LHSVecType ? LHSType : RHSType;
   const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
   QualType OtherType = LHSVecType ? RHSType : LHSType;
QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
   if (getLangOpts().OpenCL &&
       RHSVecType && isa<ExtVectorType>(RHSVecType) &&
       LHSVecType && isa<ExtVectorType>(LHSVecType)) {
     Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
                                                            << RHSType;
     return QualType();
   }
 
+  // If there is a vector type that is not a ExtVector and a LHS, we reach
+  // this point if scalar count not be convert to the vector's element type
+  // without truncation.
+  if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
+      (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
+    QualType Scalar = LHSVecType ? RHSType : LHSType;
+    QualType Vector = LHSVecType ? LHSType : RHSType;
+    unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
+    Diag(Loc,
+         diag::err_typecheck_vector_not_convertable_implict_truncation)
+        << ScalarOrVector << Scalar << Vector;
+
+    return QualType();
+  }
+
   // Otherwise, use the generic diagnostic.
   Diag(Loc, diag::err_typecheck_vector_not_convertable)
     << LHSType << RHSType
     << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
   return QualType();
 }
 
 // checkArithmeticNull - Detect when a NULL constant is used improperly in an
QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
   QualType vType = CheckVectorOperands(LHS, RHS, Loc, false,
                                        /*AllowBothBool*/true,
                                        /*AllowBoolConversions*/false);
   if (vType.isNull())
     return InvalidOperands(Loc, LHS, RHS);
   if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion < 120 &&
       vType->hasFloatingRepresentation())
     return InvalidOperands(Loc, LHS, RHS);
   
   return GetSignedVectorType(LHS.get()->getType());
 }
 
 inline QualType Sema::CheckBitwiseOperands(
   ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
   checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
 
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType()) {

test/Sema/vector-cast.c

 typedef __attribute__((vector_size(8))) double float64x1_t;
 typedef __attribute__((vector_size(16))) double float64x2_t;
 float64x1_t vget_low_f64(float64x2_t __p0);
 
 void f4() {
   float2 f2;
   double d, a, b, c;
   float64x2_t v = {0.0, 1.0};
-  // FIXME: These diagnostics are inaccurate: should complain that 'double' to vector 'float2' involves truncation
-  f2 += d; // expected-error {{cannot convert between vector values of different size ('float2' (vector of 2 'float' values) and 'double')}}
-  d += f2; // expected-error {{cannot convert between vector values of different size}}
+  f2 += d; // expected-error {{cannot convert between scalar type 'double' and vector type 'float2' (vector of 2 'float' values) as implicit conversion would cause truncation}}
+  d += f2; // expected-error {{cannot convert between scalar type 'double' and vector type 'float2' (vector of 2 'float' values) as implicit conversion would cause truncation}}
   a = 3.0 + vget_low_f64(v);
   b = vget_low_f64(v) + 3.0;
   c = vget_low_f64(v);
   c -= vget_low_f64(v);
   // LAX conversions between scalar and vector types require same size and one element sized vectors.
   d = f2; // expected-error {{assigning to 'double' from incompatible type 'float2'}}
   d = d + f2; // expected-error {{assigning to 'double' from incompatible type 'float2'}}
 }

test/Sema/vector-gcc-compat.c

+// RUN: %clang_cc1 %s -verify -fsyntax-only -Weverything
+
+typedef long long v2i64 __attribute__((vector_size(16)));
+typedef int v2i32 __attribute__((vector_size(8)));
+typedef short v2i16 __attribute__((vector_size(4)));
+typedef char v2i8 __attribute__((vector_size(2)));
+
+typedef unsigned long long v2u64 __attribute__((vector_size(16)));
+typedef unsigned int v2u32 __attribute__((vector_size(8)));
+typedef unsigned short v2u16 __attribute__((vector_size(4)));
+typedef unsigned char v2u8 __attribute__((vector_size(2)));
+
+typedef float v4f32 __attribute__((vector_size(16)));
+typedef double v4f64 __attribute__((vector_size(32)));
+
+void arithmeticTest (void);
+void logicTest (void);
+void comparisonTest (void);
+void floatTestSignedType (char a, short b, int c, long long d);
+void floatTestUnsignedType (unsigned char a, unsigned short b, unsigned int c, unsigned long long d);
+void floatTestConstant (void);
+void intTestType (char a, short b, int c, long long d);
+void intTestTypeUnsigned (unsigned char a, unsigned short b, unsigned int c, unsigned long long d);
+void uintTestType (char a, short b, int c, long long d);
+void uintTestTypeUnsigned (unsigned char a, unsigned short b, unsigned int c, unsigned long long d);
+void uintTestConstant (v2u64 v2u64_a, v2u32 v2u32_a, v2u16 v2u16_a, v2u8 v2u8_a);
+void intTestConstant (v2i64 v2i64_a, v2i32 v2i32_a, v2i16 v2i16_a, v2i8 v2i8_a);
+
+
+void arithmeticTest (void){
+  v2i64 v2i64_a = (v2i64) {0, 1};
+  v2i64 v2i64_r;
+
+  v2i64_r = v2i64_a + 1;
+  v2i64_r = v2i64_a - 1;
+  v2i64_r = v2i64_a * 1;
+  v2i64_r = v2i64_a / 1;
+  v2i64_r = v2i64_a % 1;
+
+  v2i64_r = 1 + v2i64_a;
+  v2i64_r = 1 - v2i64_a;
+  v2i64_r = 1 * v2i64_a;
+  v2i64_r = 1 / v2i64_a;
+  v2i64_r = 1 % v2i64_a;
+
+
+  v2i64_a += 1;
+  v2i64_a -= 1;
+  v2i64_a *= 1;
+  v2i64_a /= 1;
+  v2i64_a %= 1;
+}
+
+void comparisonTest (void) {
+  v2i64 v2i64_a = (v2i64) {0, 1};
+  v2i64 v2i64_r;
+
+  // FIXME: -Wall is showing that the type is somehow being converted to
+  //        "long __attribute__((ext_vector_type(2)))" when the types should
+  //        match.
+  v2i64_r = v2i64_a == 1; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = v2i64_a != 1; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = v2i64_a < 1; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = v2i64_a > 1; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = v2i64_a <= 1; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = v2i64_a >= 1; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+
+  v2i64_r = 1 == v2i64_a; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = 1 != v2i64_a; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = 1 < v2i64_a; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = 1 > v2i64_a; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = 1 <= v2i64_a; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = 1 >= v2i64_a; // expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+}
+
+void logicTest (void) {
+  v2i64 v2i64_a = (v2i64) {0, 1};
+  v2i64 v2i64_r;
+
+  v2i64_r = v2i64_a & 1;
+  v2i64_r = v2i64_a | 1;
+  v2i64_r = v2i64_a ^ 1;
+
+  v2i64_r = 1 & v2i64_a;
+  v2i64_r = 1 | v2i64_a;
+  v2i64_r = 1 ^ v2i64_a;
+
+  v2i64_a &= 1;
+  v2i64_a |= 1;
+  v2i64_a ^= 1;
+
+  // FIXME: -Wall is showing that the type is somehow being converted to
+  //        "long __attribute__((ext_vector_type(2)))" when the types should
+  //        match.
+  v2i64_r = v2i64_a && 1; // expected-warning {{implicit conversion turns vector to scalar: 'v2i64' (vector of 2 'long long' values) to '_Bool'}} expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+  v2i64_r = v2i64_a || 1; // expected-warning {{implicit conversion turns vector to scalar: 'v2i64' (vector of 2 'long long' values) to '_Bool'}} expected-warning {{incompatible vector types assigning to 'v2i64' (vector of 2 'long long' values) from 'long __attribute__((ext_vector_type(2)))' (vector of 2 'long' values)}}
+
+
+  v2i64_r = v2i64_a << 1;
+  v2i64_r = v2i64_a >> 1;
+
+  v2i64_r = 1 << v2i64_a;
+  v2i64_r = 1 >> v2i64_a;
+
+  v2i64_a <<= 1;
+  v2i64_a >>= 1;
+
+}
+
+// For operations with floating point types, we check that constants can be
+// respresented, or failing that, types.
+
+void floatTestConstant (void) {
+  // Test that constants added to floats must be expressible as floating point
+  // numbers.
+  v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f};
+  v4f32_a = v4f32_a + 1;
+  v4f32_a = v4f32_a + 0xFFFFFF;
+  v4f32_a = v4f32_a + (-1567563LL);
+  v4f32_a = v4f32_a + (16777208);
+  v4f32_a = v4f32_a + (16777219); // expected-error {{cannot convert between scalar type 'int' and vector type 'v4f32' (vector of 4 'float' values) as implicit conversion would cause truncation}}
+}
+
+void floatTestUnsignedType (unsigned char a, unsigned short b, unsigned int c, unsigned long long d) {
+
+  v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f};
+  v4f64 v4f64_b = {0.4, 0.4, 0.4, 0.4};
+
+  v4f32_a = v4f32_a + a;
+  v4f32_a = v4f32_a + b;
+  v4f32_a = v4f32_a + c; // expected-error {{cannot convert between scalar type 'unsigned int' and vector type 'v4f32' (vector of 4 'float' values) as implicit conversion would cause truncation}}
+  v4f32_a = v4f32_a + d; // expected-error {{cannot convert between scalar type 'unsigned long long' and vector type 'v4f32' (vector of 4 'float' values) as implicit conversion would cause truncation}}
+
+  v4f64_b = v4f64_b + a;
+  v4f64_b = v4f64_b + b;
+  v4f64_b = v4f64_b + c;
+  v4f64_b = v4f64_b + d; // expected-error {{cannot convert between scalar type 'unsigned long long' and vector type 'v4f64' (vector of 4 'double' values) as implicit conversion would cause truncation}}
+
+}
+
+void floatTestSignedType (char a, short b, int c, long long d) {
+
+  v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f};
+  v4f64 v4f64_b = {0.4, 0.4, 0.4, 0.4};
+
+  v4f32_a = v4f32_a + a;
+  v4f32_a = v4f32_a + b;
+  v4f32_a = v4f32_a + c; // expected-error {{cannot convert between scalar type 'int' and vector type 'v4f32' (vector of 4 'float' values) as implicit conversion would cause truncation}}
+  v4f32_a = v4f32_a + d; // expected-error {{cannot convert between scalar type 'long long' and vector type 'v4f32' (vector of 4 'float' values) as implicit conversion would cause truncation}}
+
+  v4f64_b = v4f64_b + a;
+  v4f64_b = v4f64_b + b;
+  v4f64_b = v4f64_b + c;
+  v4f64_b = v4f64_b + d; // expected-error {{cannot convert between scalar type 'long long' and vector type 'v4f64' (vector of 4 'double' values) as implicit conversion would cause truncation}}
+
+}
+
+
+void intTestType (char a, short b, int c, long long d) {
+
+ v2i64  v2i64_a = { 1, 2};
+ v2i32  v2i32_a = { 1, 2};
+ v2i16  v2i16_a = { 1, 2};
+ v2i8  v2i8_a = { 1, 2};
+
+ v2i64_a = v2i64_a + d;
+ v2i64_a = v2i64_a + c;
+ v2i64_a = v2i64_a + b;
+ v2i64_a = v2i64_a + a;
+
+ v2i32_a = v2i32_a + d; // expected-warning {{implicit conversion loses integer precision: 'long long' to 'v2i32' (vector of 2 'int' values)}}
+ v2i32_a = v2i32_a + c;
+ v2i32_a = v2i32_a + b;
+ v2i32_a = v2i32_a + a;
+
+ v2i16_a = v2i16_a + d; // expected-error {{cannot convert between scalar type 'long long' and vector type 'v2i16' (vector of 2 'short' values) as implicit conversion would cause truncation}}
+ v2i16_a = v2i16_a + c; // expected-warning {{implicit conversion loses integer precision: 'int' to 'v2i16' (vector of 2 'short' values)}}
+ v2i16_a = v2i16_a + b;
+ v2i16_a = v2i16_a + a;
+
+ v2i8_a = v2i8_a + d; // expected-error {{cannot convert between scalar type 'long long' and vector type 'v2i8' (vector of 2 'char' values) as implicit conversion would cause truncation}}
+ v2i8_a = v2i8_a + c; // expected-error {{cannot convert between scalar type 'int' and vector type 'v2i8' (vector of 2 'char' values) as implicit conversion would cause truncation}}
+ v2i8_a = v2i8_a + b; // expected-warning {{implicit conversion loses integer precision: 'short' to 'v2i8' (vector of 2 'char' values)}}
+ v2i8_a = v2i8_a + a;
+
+}
+void intTestTypeUnsigned (unsigned char a, unsigned short b, unsigned int c, unsigned long long d) {
+
+ v2i64  v2i64_a = { 1, 2};
+ v2i32  v2i32_a = { 1, 2};
+ v2i16  v2i16_a = { 1, 2};
+ v2i8  v2i8_a = { 1, 2};
+
+ v2i64_a = v2i64_a + d; // expected-error {{cannot convert between scalar type 'unsigned long long' and vector type 'v2i64' (vector of 2 'long long' values) as implicit conversion would cause truncation}}
+
+ v2i64_a = v2i64_a + c;
+ v2i64_a = v2i64_a + b;
+ v2i64_a = v2i64_a + a;
+
+ v2i32_a = v2i32_a + d; // expected-warning {{implicit conversion loses integer precision: 'unsigned long long' to 'v2i32' (vector of 2 'int' values)}}
+ v2i32_a = v2i32_a + c; // expected-error {{cannot convert between scalar type 'unsigned int' and vector type 'v2i32' (vector of 2 'int' values) as implicit conversion would cause truncation}}
+ v2i32_a = v2i32_a + b;
+ v2i32_a = v2i32_a + a;
+
+ v2i16_a = v2i16_a + d; // expected-error {{cannot convert between scalar type 'unsigned long long' and vector type 'v2i16' (vector of 2 'short' values) as implicit conversion would cause truncation}}
+ v2i16_a = v2i16_a + c; // expected-warning {{implicit conversion loses integer precision: 'unsigned int' to 'v2i16' (vector of 2 'short' values)}}
+ v2i16_a = v2i16_a + b; // expected-error {{cannot convert between scalar type 'unsigned short' and vector type 'v2i16' (vector of 2 'short' values) as implicit conversion would cause truncation}}
+ v2i16_a = v2i16_a + a;
+
+ v2i8_a = v2i8_a + d; // expected-error {{cannot convert between scalar type 'unsigned long long' and vector type 'v2i8' (vector of 2 'char' values) as implicit conversion would cause truncation}}
+ v2i8_a = v2i8_a + c; // expected-error {{cannot convert between scalar type 'unsigned int' and vector type 'v2i8' (vector of 2 'char' values) as implicit conversion would cause truncation}}
+ v2i8_a = v2i8_a + b; // expected-warning {{implicit conversion loses integer precision: 'unsigned short' to 'v2i8' (vector of 2 'char' values)}}
+ v2i8_a = v2i8_a + a; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type 'v2i8' (vector of 2 'char' values) as implicit conversion would cause truncation}}
+
+}
+
+void uintTestType (char a, short b, int c, long long d) {
+
+ v2u64  v2u64_a = { 1, 2};
+ v2u32  v2u32_a = { 1, 2};
+ v2u16  v2u16_a = { 1, 2};
+ v2u8  v2u8_a = { 1, 2};
+
+ v2u64_a = v2u64_a + d; // expected-warning {{implicit conversion changes signedness: 'long long' to 'v2u64' (vector of 2 'unsigned long long' values)}}
+ v2u64_a = v2u64_a + c; // expected-warning {{implicit conversion changes signedness: 'int' to 'v2u64' (vector of 2 'unsigned long long' values)}}
+ v2u64_a = v2u64_a + b; // expected-warning {{implicit conversion changes signedness: 'short' to 'v2u64' (vector of 2 'unsigned long long' values)}}
+ v2u64_a = v2u64_a + a; // expected-warning {{implicit conversion changes signedness: 'char' to 'v2u64' (vector of 2 'unsigned long long' values)}}
+
+ v2u32_a = v2u32_a + d; // expected-warning {{implicit conversion loses integer precision: 'long long' to 'v2u32' (vector of 2 'unsigned int' values)}}
+ v2u32_a = v2u32_a + c; // expected-warning {{implicit conversion changes signedness: 'int' to 'v2u32' (vector of 2 'unsigned int' values)}}
+ v2u32_a = v2u32_a + b; // expected-warning {{implicit conversion changes signedness: 'short' to 'v2u32' (vector of 2 'unsigned int' values)}}
+ v2u32_a = v2u32_a + a; // expected-warning {{implicit conversion changes signedness: 'char' to 'v2u32' (vector of 2 'unsigned int' values)}}
+
+ v2u16_a = v2u16_a + d; // expected-error {{cannot convert between scalar type 'long long' and vector type 'v2u16' (vector of 2 'unsigned short' values) as implicit conversion would cause truncation}}
+ v2u16_a = v2u16_a + c; // expected-warning {{implicit conversion loses integer precision: 'int' to 'v2u16' (vector of 2 'unsigned short' values)}}
+ v2u16_a = v2u16_a + b; // expected-warning {{implicit conversion changes signedness: 'short' to 'v2u16' (vector of 2 'unsigned short' values)}}
+ v2u16_a = v2u16_a + a; // expected-warning {{implicit conversion changes signedness: 'char' to 'v2u16' (vector of 2 'unsigned short' values)}}
+
+ v2u8_a = v2u8_a + d; // expected-error {{cannot convert between scalar type 'long long' and vector type 'v2u8' (vector of 2 'unsigned char' values) as implicit conversion would cause truncation}}
+ v2u8_a = v2u8_a + c; // expected-error {{cannot convert between scalar type 'int' and vector type 'v2u8' (vector of 2 'unsigned char' values) as implicit conversion would cause truncation}}
+ v2u8_a = v2u8_a + b; // expected-warning {{implicit conversion loses integer precision: 'short' to 'v2u8' (vector of 2 'unsigned char' values)}}
+ v2u8_a = v2u8_a + a; // expected-warning {{implicit conversion changes signedness: 'char' to 'v2u8' (vector of 2 'unsigned char' values)}}
+
+}
+
+void uintTestTypeUnsigned (unsigned char a, unsigned short b, unsigned int c, unsigned long long d) {
+
+ v2u64  v2u64_a = { 1, 2};
+ v2u32  v2u32_a = { 1, 2};
+ v2u16  v2u16_a = { 1, 2};
+ v2u8  v2u8_a = { 1, 2};
+
+ v2u64_a = v2u64_a + d;
+ v2u64_a = v2u64_a + c;
+ v2u64_a = v2u64_a + b;
+ v2u64_a = v2u64_a + a;
+
+ v2u32_a = v2u32_a + d; // expected-warning {{implicit conversion loses integer precision: 'unsigned long long' to 'v2u32' (vector of 2 'unsigned int' values)}}
+ v2u32_a = v2u32_a + c;
+ v2u32_a = v2u32_a + b;
+ v2u32_a = v2u32_a + a;
+
+ v2u16_a = v2u16_a + d; // expected-error {{cannot convert between scalar type 'unsigned long long' and vector type 'v2u16' (vector of 2 'unsigned short' values) as implicit conversion would cause truncation}}
+ v2u16_a = v2u16_a + c; // expected-warning {{implicit conversion loses integer precision: 'unsigned int' to 'v2u16' (vector of 2 'unsigned short' values)}}
+ v2u16_a = v2u16_a + b;
+ v2u16_a = v2u16_a + a;
+
+ v2u8_a = v2u8_a + d; // expected-error {{cannot convert between scalar type 'unsigned long long' and vector type 'v2u8' (vector of 2 'unsigned char' values) as implicit conversion would cause truncation}}
+ v2u8_a = v2u8_a + c; // expected-error {{cannot convert between scalar type 'unsigned int' and vector type 'v2u8' (vector of 2 'unsigned char' values) as implicit conversion would cause truncation}}
+ v2u8_a = v2u8_a + b; // expected-warning {{implicit conversion loses integer precision: 'unsigned short' to 'v2u8' (vector of 2 'unsigned char' values)}}
+ v2u8_a = v2u8_a + a;
+
+}
+
+void uintTestConstant (v2u64 v2u64_a, v2u32 v2u32_a, v2u16 v2u16_a, v2u8 v2u8_a) {
+
+ v2u64_a = v2u64_a + 0xFFFFFFFFFFFFFFFF;
+ v2u32_a = v2u32_a + 0xFFFFFFFF;
+ v2u16_a = v2u16_a + 0xFFFF;
+ v2u8_a = v2u8_a   + 0xFF;
+
+ v2u32_a = v2u32_a + 0x1FFFFFFFF; // expected-warning {{implicit conversion from 'long' to 'v2u32' (vector of 2 'unsigned int' values) changes value from 8589934591 to 4294967295}}
+ v2u16_a = v2u16_a + 0x1FFFF; // expected-warning {{implicit conversion from 'int' to 'v2u16' (vector of 2 'unsigned short' values) changes value from 131071 to 65535}}
+ v2u8_a = v2u8_a   + 0x1FF; // expected-error {{cannot convert between scalar type 'int' and vector type 'v2u8' (vector of 2 'unsigned char' values) as implicit conversion would cause truncation}}
+}
+
+void intTestConstant (v2i64 v2i64_a, v2i32 v2i32_a, v2i16 v2i16_a, v2i8 v2i8_a) {
+
+ // Legal upper bounds.
+
+ v2i64_a = v2i64_a + (long long)0x7FFFFFFFFFFFFFFF;
+ v2i32_a = v2i32_a + (int)0x7FFFFFFF;
+ v2i16_a = v2i16_a + (short)0x7FFF;
+ v2i8_a = v2i8_a   + (char)0x7F;
+
+ // Legal lower bounds.
+
+ v2i64_a = v2i64_a + (-9223372036854775807);
+ v2i32_a = v2i32_a + (-2147483648);
+ v2i16_a = v2i16_a + (-32768);
+ v2i8_a = v2i8_a   + (-128);
+
+ // One increment/decrement more than the type can hold
+
+ v2i32_a = v2i32_a + 2147483648;// expected-warning {{implicit conversion from 'long' to 'v2i32' (vector of 2 'int' values) changes value from 2147483648 to -2147483648}}
+ v2i16_a = v2i16_a + 32768; // expected-warning {{implicit conversion from 'int' to 'v2i16' (vector of 2 'short' values) changes value from 32768 to -32768}}
+ v2i8_a = v2i8_a   + 128; // expected-warning {{implicit conversion from 'int' to 'v2i8' (vector of 2 'char' values) changes value from 128 to -128}}
+
+ v2i32_a = v2i32_a + (-2147483649); // expected-warning {{implicit conversion from 'long' to 'v2i32' (vector of 2 'int' values) changes value from -2147483649 to 2147483647}}
+ v2i16_a = v2i16_a + (-32769); // expected-warning {{implicit conversion from 'int' to 'v2i16' (vector of 2 'short' values) changes value from -32769 to 32767}}
+ v2i8_a = v2i8_a   + (-129) ; // expected-error {{cannot convert between scalar type 'int' and vector type 'v2i8' (vector of 2 'char' values) as implicit conversion would cause truncation}}
+}

test/Sema/zvector.c

void foo(void)
   uc = uc + bc2;
 
   bc = bc + bc2; // expected-error {{invalid operands}}
   bc = bc + uc2; // expected-error {{incompatible type}}
   bc = uc + bc2; // expected-error {{incompatible type}}
   bc = bc + sc2; // expected-error {{incompatible type}}
   bc = sc + bc2; // expected-error {{incompatible type}}
 
-  sc = sc + sc_scalar; // expected-error {{cannot convert}}
-  sc = sc + uc_scalar; // expected-error {{cannot convert}}
-  sc = sc_scalar + sc; // expected-error {{cannot convert}}
-  sc = uc_scalar + sc; // expected-error {{cannot convert}}
-  uc = uc + sc_scalar; // expected-error {{cannot convert}}
-  uc = uc + uc_scalar; // expected-error {{cannot convert}}
-  uc = sc_scalar + uc; // expected-error {{cannot convert}}
-  uc = uc_scalar + uc; // expected-error {{cannot convert}}
+  sc = sc + sc_scalar;
+  sc = sc + uc_scalar; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
+  sc = sc_scalar + sc;
+  sc = uc_scalar + sc; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
+  uc = uc + sc_scalar; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
+  uc = uc + uc_scalar;
+  uc = sc_scalar + uc; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
+  uc = uc_scalar + uc;
 
   ss = ss + ss2;
   us = us + us2;
   bs = bs + bs2; // expected-error {{invalid operands}}
 
   si = si + si2;
   ui = ui + ui2;
   bi = bi + bi2; // expected-error {{invalid operands}}
void foo(void)
   bc += sc2; // expected-error {{cannot convert}}
   bc += uc2; // expected-error {{cannot convert}}
 
   sc += ss2; // expected-error {{cannot convert}}
   sc += si2; // expected-error {{cannot convert}}
   sc += sl2; // expected-error {{cannot convert}}
   sc += fd2; // expected-error {{cannot convert}}
 
-  sc += sc_scalar; // expected-error {{cannot convert}}
-  sc += uc_scalar; // expected-error {{cannot convert}}
-  uc += sc_scalar; // expected-error {{cannot convert}}
-  uc += uc_scalar; // expected-error {{cannot convert}}
+  sc += sc_scalar;
+  sc += uc_scalar; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
+  uc += sc_scalar; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
+  uc += uc_scalar;
 
   ss += ss2;
   us += us2;
   bs += bs2; // expected-error {{invalid operands}}
 
   si += si2;
   ui += ui2;
   bi += bi2; // expected-error {{invalid operands}}

test/SemaCXX/vector-no-lax.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -fno-lax-vector-conversions -verify %s
 typedef unsigned int __attribute__((vector_size (16))) vUInt32;
 typedef int __attribute__((vector_size (16))) vSInt32;
 
 vSInt32 foo (vUInt32 a) {
   vSInt32 b = { 0, 0, 0, 0 };
-  b += a; // expected-error{{cannot convert between vector values}}
+  b += a; // expected-error{{cannot convert between vector type 'vUInt32' (vector of 4 'unsigned int' values) and vector type 'vSInt32' (vector of 4 'int' values) as implicit conversion would cause truncation}}
   return b;
 }