1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 2 3 int* ret_local() { 4 int x = 1; 5 return &x; // expected-warning {{address of stack memory}} 6 } 7 8 int* ret_local_array() { 9 int x[10]; 10 return x; // expected-warning {{address of stack memory}} 11 } 12 13 int* ret_local_array_element(int i) { 14 int x[10]; 15 return &x[i]; // expected-warning {{address of stack memory}} 16 } 17 18 int *ret_local_array_element_reversed(int i) { 19 int x[10]; 20 return &i[x]; // expected-warning {{address of stack memory}} 21 } 22 23 int* ret_local_array_element_const_index() { 24 int x[10]; 25 return &x[2]; // expected-warning {{address of stack memory}} 26 } 27 28 int& ret_local_ref() { 29 int x = 1; 30 return x; // expected-warning {{reference to stack memory}} 31 } 32 33 int* ret_local_addrOf() { 34 int x = 1; 35 return &*&x; // expected-warning {{address of stack memory}} 36 } 37 38 int* ret_local_addrOf_paren() { 39 int x = 1; 40 return (&(*(&x))); // expected-warning {{address of stack memory}} 41 } 42 43 int* ret_local_addrOf_ptr_arith() { 44 int x = 1; 45 return &*(&x+1); // expected-warning {{address of stack memory}} 46 } 47 48 int* ret_local_addrOf_ptr_arith2() { 49 int x = 1; 50 return &*(&x+1); // expected-warning {{address of stack memory}} 51 } 52 53 int* ret_local_field() { 54 struct { int x; } a; 55 return &a.x; // expected-warning {{address of stack memory}} 56 } 57 58 int& ret_local_field_ref() { 59 struct { int x; } a; 60 return a.x; // expected-warning {{reference to stack memory}} 61 } 62 63 int* ret_conditional(bool cond) { 64 int x = 1; 65 int y = 2; 66 return cond ? &x : &y; // expected-warning {{address of stack memory}} 67 } 68 69 int* ret_conditional_rhs(int *x, bool cond) { 70 int y = 1; 71 return cond ? x : &y; // expected-warning {{address of stack memory}} 72 } 73 74 void* ret_c_cast() { 75 int x = 1; 76 return (void*) &x; // expected-warning {{address of stack memory}} 77 } 78 79 int* ret_static_var() { 80 static int x = 1; 81 return &x; // no warning. 82 } 83 84 int z = 1; 85 86 int* ret_global() { 87 return &z; // no warning. 88 } 89 90 int* ret_parameter(int x) { 91 return &x; // expected-warning {{address of stack memory}} 92 } 93 94 95 void* ret_cpp_static_cast(short x) { 96 return static_cast<void*>(&x); // expected-warning {{address of stack memory}} 97 } 98 99 int* ret_cpp_reinterpret_cast(double x) { 100 return reinterpret_cast<int*>(&x); // expected-warning {{address of stack me}} 101 } 102 103 int* ret_cpp_reinterpret_cast_no_warning(long x) { 104 return reinterpret_cast<int*>(x); // no-warning 105 } 106 107 int* ret_cpp_const_cast(const int x) { 108 return const_cast<int*>(&x); // expected-warning {{address of stack memory}} 109 } 110 111 struct A { virtual ~A(); }; struct B : A {}; 112 A* ret_cpp_dynamic_cast(B b) { 113 return dynamic_cast<A*>(&b); // expected-warning {{address of stack memory}} 114 } 115 116 // PR 7999 - handle the case where a field is itself a reference. 117 template <typename T> struct PR7999 { 118 PR7999(T& t) : value(t) {} 119 T& value; 120 }; 121 122 struct PR7999_X {}; 123 124 PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning 125 void test_PR7999(PR7999_X& x) { (void)PR7999_f(x); } // no-warning 126 127 // PR 8774: Don't try to evaluate parameters with default arguments like 128 // variables with an initializer, especially in templates where the default 129 // argument may not be an expression (yet). 130 namespace PR8774 { 131 template <typename U> struct B { }; 132 template <typename V> V f(typename B<V>::type const &v = B<V>::value()) { 133 return v; 134 } 135 template <> struct B<const char *> { 136 typedef const char *type; 137 static const char *value(); 138 }; 139 void g() { 140 const char *t; 141 f<const char*>(t); 142 } 143 } 144 145 // Don't warn about returning a local variable from a surrounding function if 146 // we're within a lambda-expression. 147 void ret_from_lambda() { 148 int a; 149 int &b = a; 150 (void) [&]() -> int& { return a; }; 151 (void) [&]() -> int& { return b; }; 152 (void) [=]() mutable -> int& { return a; }; 153 (void) [=]() mutable -> int& { return b; }; 154 (void) [&]() -> int& { int a; return a; }; // expected-warning {{reference to stack}} 155 (void) [=]() -> int& { int a; return a; }; // expected-warning {{reference to stack}} 156 (void) [&]() -> int& { int &a = b; return a; }; 157 (void) [=]() mutable -> int& { int &a = b; return a; }; 158 } 159
