Prevent implicit re-interpret casts between ExtVector and Scalar types.

Previously, in certain cases lax vector conversions could occur between scalar floating-point values and ExtVector types; these conversions would be simple bitcasts.  We need to allow them with other vector types to support some common headers, but we don't need them for ExtVector.  Preventing them here makes them behave like other operations involving scalars and ExtVectors.

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

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index d55ac5ee8335c6dd64c58c603470fa83a3ec3ef1..6b20f59046dadb98db61a319a4ef96d833d0f662 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -5562,6 +5562,14 @@ static bool breakDownVectorType(QualType type, uint64_t &len,
 /// vector nor a real type.
 bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
   assert(destTy->isVectorType() || srcTy->isVectorType());
+  
+  // Disallow lax conversions between scalars and ExtVectors (these
+  // conversions are allowed for other vector types because common headers
+  // depend on them).  Most scalar OP ExtVector cases are handled by the
+  // splat path anyway, which does what we want (convert, not bitcast).
+  // What this rules out for ExtVectors is crazy things like char4*float.
+  if (srcTy->isScalarType() && destTy->isExtVectorType()) return false;
+  if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;
 
   uint64_t srcLen, destLen;
   QualType srcElt, destElt;

diff --git a/test/Sema/ext_vector_conversions.c b/test/Sema/ext_vector_conversions.c
new file mode 100644 (file)
index 0000000..aa57e2b
--- /dev/null
+++ b/test/Sema/ext_vector_conversions.c
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -fsyntax-only -verify -Wconversion %s
+
+typedef __attribute__((ext_vector_type(4))) char char4;
+typedef __attribute__((ext_vector_type(4))) short short4;
+typedef __attribute__((ext_vector_type(1))) float float1;
+
+static void test() {
+  char4 vc4;
+  float f;
+  // Not allowed.  There's no splatting conversion between float and int vector,
+  // and we don't want to bitcast f to vector-of-char (as would happen with the
+  // old-style vector types).
+  vc4 += f; // expected-error {{cannot convert between vector values of different size}}
+  short4 vs4;
+  long long ll;
+  // This one is OK; we don't re-interpret ll as short4, rather we splat its
+  // value, which should produce a warning about clamping.
+  vs4 += ll; // expected-warning {{implicit conversion loses integer precision}}
+}