[TBAA] Vector types should (only) alias with their element types

[hfinkel]

Summary

Currently, all of our builtin vector types are equivalent to char for TBAA purposes. It would be useful to make this less conservative. This patch makes vector types equivalent to their element types for type-aliasing purposes. I think it's common for programmers to assume that they can cast freely between the vector types and the scalar types (so long as they're being sufficiently careful about alignments), and we should certainly preserve that model. Given that we assume that int* and float* don't alias, I don't think we need to assume that int* and vec_of_float* alias or vec_of_int* and vec_of_float* alias.

The cases I've seen where I know this would be helpful involve integral scalar pointers and floating-point vector pointers, so I'm generalizing a bit here. If this would break too much code, one option is fall back to doing this only for floating-point types. That having been said, I know that it is common on some platforms to case between floating-point vectors and integer vectors in order to implement operations like fabs, and maybe that makes this untenable on those platforms?

Thoughts?

[hfinkel]

@rjmccall said, on this topic, in D31885:

The root problem there is that the design of vector types and vector interfaces is generally quite bad; you cannot rely on things like vectors being stored with an appropriate element type for whatever value the user is actually trying to work with.

For example, Clang's xmmintrin.h specifies that m128 is a vector of 4 ints. How confident are you that that type is never used to store a vector of 4 floats? Keep in mind that the compiler allows m128 to freely implicitly convert to __v4sf.

And I think he's right; we probably can't do this in general. vector types really are just bags of bits on many platforms ;)

lib/CodeGen/CodeGenTBAA.cpp

if (!Features.Sanitize.has(SanitizerKind::TBAA) &&
       (CodeGenOpts.OptimizationLevel == 0 || CodeGenOpts.RelaxedAliasing))
     return nullptr;
 
   // If the type has the may_alias attribute (even on a typedef), it is
   // effectively in the general char alias class.
   if (TypeHasMayAlias(QTy))
     return getChar();
 
+  // Vector types should alias with their element types.
+  if (auto *VT = QTy->getAs<VectorType>())
+    QTy = VT->getElementType();
+
   const Type *Ty = Context.getCanonicalType(QTy).getTypePtr();
 
   if (llvm::MDNode *N = MetadataCache[Ty])
     return N;
 
   // Handle builtin types.
   if (const BuiltinType *BTy = dyn_cast<BuiltinType>(Ty)) {
     switch (BTy->getKind()) {

test/CodeGen/tbaa-vector.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -no-struct-path-tbaa -disable-llvm-passes %s -emit-llvm -o - | FileCheck %s
+
+typedef double __m256d __attribute__((__vector_size__(32)));
+__m256d foo(double *x, __m256d *y) {
+  *x = 0.0;
+  return *y;
+
+// CHECK-LABEL: define <4 x double> @_Z3fooPdPDv4_d
+// CHECK: store double 0.000000e+00, double* %{{.*}}, align 8, !tbaa [[TAG_double:!.*]]
+// CHECK: load <4 x double>, <4 x double>* %{{.*}}, align {{.*}}, !tbaa [[TAG_double]]
+}
+
+// CHECK: [[TYPE_char:!.*]] = !{!"omnipotent char", [[TAG_cxx_tbaa:!.*]],
+// CHECK: [[TAG_cxx_tbaa]] = !{!"Simple C++ TBAA"}
+// CHECK: [[TAG_double]] = !{[[TYPE_double:!.*]], [[TYPE_double]], i64 0}
+// CHECK: [[TYPE_double]] = !{!"double", [[TYPE_char]],
+