From 222e2a7620e6520ffaf4fc4e69d79c18da31542e Mon Sep 17 00:00:00 2001 From: "Zancanaro; Carlo" Date: Mon, 24 Sep 2012 09:58:17 +1000 Subject: Add the clang library to the repo (with some of my changes, too). --- clang/test/SemaCXX/uninitialized.cpp | 169 +++++++++++++++++++++++++++++++++++ 1 file changed, 169 insertions(+) create mode 100644 clang/test/SemaCXX/uninitialized.cpp (limited to 'clang/test/SemaCXX/uninitialized.cpp') diff --git a/clang/test/SemaCXX/uninitialized.cpp b/clang/test/SemaCXX/uninitialized.cpp new file mode 100644 index 0000000..7879e7c --- /dev/null +++ b/clang/test/SemaCXX/uninitialized.cpp @@ -0,0 +1,169 @@ +// RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -std=c++11 -verify %s + +int foo(int x); +int bar(int* x); +int boo(int& x); +int far(const int& x); + +// Test self-references within initializers which are guaranteed to be +// uninitialized. +int a = a; // no-warning: used to signal intended lack of initialization. +int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} +int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}} +void test() { + int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}} +} +int e = static_cast(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} +int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} + +// Thes don't warn as they don't require the value. +int g = sizeof(g); +void* ptr = &ptr; +int h = bar(&h); +int i = boo(i); +int j = far(j); +int k = __alignof__(k); + + +// Test self-references with record types. +class A { + // Non-POD class. + public: + enum count { ONE, TWO, THREE }; + int num; + static int count; + int get() const { return num; } + int get2() { return num; } + void set(int x) { num = x; } + static int zero() { return 0; } + + A() {} + A(A const &a) {} + A(int x) {} + A(int *x) {} + A(A *a) {} + ~A(); +}; + +A getA() { return A(); } +A getA(int x) { return A(); } +A getA(A* a) { return A(); } + +void setupA() { + A a1; + a1.set(a1.get()); + A a2(a1.get()); + A a3(a1); + A a4(&a4); + A a5(a5.zero()); + A a6(a6.ONE); + A a7 = getA(); + A a8 = getA(a8.TWO); + A a9 = getA(&a9); + A a10(a10.count); + + A a11(a11); // expected-warning {{variable 'a11' is uninitialized when used within its own initialization}} + A a12(a12.get()); // expected-warning {{variable 'a12' is uninitialized when used within its own initialization}} + A a13(a13.num); // expected-warning {{variable 'a13' is uninitialized when used within its own initialization}} + A a14 = A(a14); // expected-warning {{variable 'a14' is uninitialized when used within its own initialization}} + A a15 = getA(a15.num); // expected-warning {{variable 'a15' is uninitialized when used within its own initialization}} + A a16(&a16.num); // expected-warning {{variable 'a16' is uninitialized when used within its own initialization}} + A a17(a17.get2()); // expected-warning {{variable 'a17' is uninitialized when used within its own initialization}} +} + +struct B { + // POD struct. + int x; + int *y; +}; + +B getB() { return B(); }; +B getB(int x) { return B(); }; +B getB(int *x) { return B(); }; +B getB(B *b) { return B(); }; + +void setupB() { + B b1; + B b2(b1); + B b3 = { 5, &b3.x }; + B b4 = getB(); + B b5 = getB(&b5); + B b6 = getB(&b6.x); + + // Silence unused warning + (void) b2; + (void) b4; + + B b7(b7); // expected-warning {{variable 'b7' is uninitialized when used within its own initialization}} + B b8 = getB(b8.x); // expected-warning {{variable 'b8' is uninitialized when used within its own initialization}} + B b9 = getB(b9.y); // expected-warning {{variable 'b9' is uninitialized when used within its own initialization}} +} + +// Also test similar constructs in a field's initializer. +struct S { + int x; + void *ptr; + + S(bool (*)[1]) : x(x) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[2]) : x(x + 1) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[3]) : x(x + x) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[4]) : x(static_cast(x) + 1) {} // expected-warning {{field is uninitialized when used here}} + S(bool (*)[5]) : x(foo(x)) {} // FIXME: This should warn! + + // These don't actually require the value of x and so shouldn't warn. + S(char (*)[1]) : x(sizeof(x)) {} // rdar://8610363 + S(char (*)[2]) : ptr(&ptr) {} + S(char (*)[3]) : x(__alignof__(x)) {} + S(char (*)[4]) : x(bar(&x)) {} + S(char (*)[5]) : x(boo(x)) {} + S(char (*)[6]) : x(far(x)) {} +}; + +struct C { char a[100], *e; } car = { .e = car.a }; + +// +namespace rdar10398199 { + class FooBase { protected: ~FooBase() {} }; + class Foo : public FooBase { + public: + operator int&() const; + }; + void stuff(); + template class FooImpl : public Foo { + T val; + public: + FooImpl(const T &x) : val(x) {} + ~FooImpl() { stuff(); } + }; + + template FooImpl makeFoo(const T& x) { + return FooImpl(x); + } + + void test() { + const Foo &x = makeFoo(42); + const int&y = makeFoo(42u); + (void)x; + (void)y; + }; +} + +// PR 12325 - this was a false uninitialized value warning due to +// a broken CFG. +int pr12325(int params) { + int x = ({ + while (false) + ; + int _v = params; + if (false) + ; + _v; // no-warning + }); + return x; +} + +// Test lambda expressions with -Wuninitialized +int test_lambda() { + auto f1 = [] (int x, int y) { int z; return x + y + z; }; // expected-warning {{C++11 requires lambda with omitted result type to consist of a single return statement}} expected-warning{{variable 'z' is uninitialized when used here}} expected-note {{initialize the variable 'z' to silence this warning}} + return f1(1, 2); +} -- cgit v1.2.3