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