[analyzer][UninitializedObjectChecker] PR41611: Regard vector types as primitive

[Szelethus]

Summary

https://bugs.llvm.org/show_bug.cgi?id=41611

Similarly to D61106, the checker ran over an llvm_unreachable for vector types:

struct VectorSizeLong {
  VectorSizeLong() {}
  __attribute__((__vector_size__(16))) long x;
};

void __vector_size__LongTest() {
  VectorSizeLong v;
}

Since, according to my short research,

The vector_size attribute is only applicable to integral and float scalars, although arrays, pointers, and function return values are allowed in conjunction with this construct.

vector types are safe to regard as primitive.

[gribozavr]

Thank you for the quick fix!

test/Analysis/cxx-uninitialized-object.cpp

1155

Could you also add tests where the vector member is being subscripted? for example, v.x[0] = 0;

1155

Should there be a warning about the member being uninitialized?

[gribozavr]

test/Analysis/cxx-uninitialized-object.cpp

1155

Just to be clear -- if there should be a warning, I don't think this patch has to necessarily fix everything in the checker and static analyzer core to support vector types, the fix for the crash is valuable by itself. However, if there should be a warning, this test should have a fixme.

[NoQ]

test/Analysis/cxx-uninitialized-object.cpp

1155

Most of the code in the Static Analyzer that deals with vector types is exactly like this patch: "oh, there are also vector types, right, i've no idea what they are but let's suppress everything just in case". Fixing false positives should be fine, but introducing warnings that are specific to vector types would be hard.

[Szelethus]

Add TODO:s about missing warnings.

lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h

bool addFieldToUninits(FieldChainInfo LocalChain,
                          const MemRegion *PointeeR = nullptr);
 };
 
 /// Returns true if T is a primitive type. An object of a primitive type only
 /// needs to be analyzed as much as checking whether their value is undefined.
 inline bool isPrimitiveType(const QualType &T) {
   return T->isBuiltinType() || T->isEnumeralType() ||
          T->isMemberPointerType() || T->isBlockPointerType() ||
-         T->isFunctionType() || T->isAtomicType();
+         T->isFunctionType() || T->isAtomicType() ||
+         T->isVectorType();
 }
 
 inline bool isDereferencableType(const QualType &T) {
   return T->isAnyPointerType() || T->isReferenceType();
 }
 
 // Template method definitions.
 

test/Analysis/cxx-uninitialized-object-ptr-ref.cpp

struct CharPointerTest {
 
   CharPointerTest() : str("") {}
 };
 
 void fCharPointerTest() {
   CharPointerTest();
 }
 
+struct VectorSizePointer {
+  VectorSizePointer() {} // expected-warning{{1 uninitialized field}}
+  __attribute__((__vector_size__(8))) int *x; // expected-note{{uninitialized pointer 'this->x'}}
+  int dontGetFilteredByNonPedanticMode = 0;
+};
+
+void __vector_size__PointerTest() {
+  VectorSizePointer v;
+}
+
+struct VectorSizePointee {
+  using MyVectorType = __attribute__((__vector_size__(8))) int;
+  MyVectorType *x;
+
+  VectorSizePointee(decltype(x) x) : x(x) {}
+};
+
+void __vector_size__PointeeTest() {
+  VectorSizePointee::MyVectorType i;
+  VectorSizePointee v(&i);
+}
+
 struct CyclicPointerTest1 {
   int *ptr; // expected-note{{object references itself 'this->ptr'}}
   int dontGetFilteredByNonPedanticMode = 0;
 
   CyclicPointerTest1() : ptr(reinterpret_cast<int *>(&ptr)) {} // expected-warning{{1 uninitialized field}}
 };
 
 void fCyclicPointerTest1() {

test/Analysis/cxx-uninitialized-object.cpp

 };
 
 void fCXX11MemberInitTest2() {
   // TODO: we'd expect the warning: {{2 uninitializeds field}}
   CXX11MemberInitTest2(); // no-warning
 }
 
 //===----------------------------------------------------------------------===//
-// _Atomic tests.
+// "Esoteric" primitive type tests.
 //===----------------------------------------------------------------------===//
 
 struct MyAtomicInt {
   _Atomic(int) x; // expected-note{{uninitialized field 'this->x'}}
   int dontGetFilteredByNonPedanticMode = 0;
 
   MyAtomicInt() {} // expected-warning{{1 uninitialized field}}
 };
 
-void entry() {
+void _AtomicTest() {
   MyAtomicInt b;
 }
+
+struct VectorSizeLong {
+  VectorSizeLong() {}
+  __attribute__((__vector_size__(16))) long x;
+};
+
+void __vector_size__LongTest() {
+  VectorSizeLong v;
+}