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 : &y; // expected-warning {{address of stack memory}} 67 } 68 ret_conditional_rhs(int * x,bool cond)69int* ret_conditional_rhs(int *x, bool cond) { 70 int y = 1; 71 return cond ? x : &y; // expected-warning {{address of stack memory}} 72 } 73 ret_c_cast()74void* ret_c_cast() { 75 int x = 1; 76 return (void*) &x; // expected-warning {{address of stack memory}} 77 } 78 ret_static_var()79int* ret_static_var() { 80 static int x = 1; 81 return &x; // no warning. 82 } 83 84 int z = 1; 85 ret_global()86int* ret_global() { 87 return &z; // no warning. 88 } 89 ret_parameter(int x)90int* ret_parameter(int x) { 91 return &x; // expected-warning {{address of stack memory}} 92 } 93 94 ret_cpp_static_cast(short x)95void* ret_cpp_static_cast(short x) { 96 return static_cast<void*>(&x); // expected-warning {{address of stack memory}} 97 } 98 ret_cpp_reinterpret_cast(double x)99int* ret_cpp_reinterpret_cast(double x) { 100 return reinterpret_cast<int*>(&x); // expected-warning {{address of stack me}} 101 } 102 ret_cpp_reinterpret_cast_no_warning(long x)103int* ret_cpp_reinterpret_cast_no_warning(long x) { 104 return reinterpret_cast<int*>(x); // no-warning 105 } 106 ret_cpp_const_cast(const int x)107int* 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 {}; ret_cpp_dynamic_cast(B b)112A* 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 { PR7999PR7999118 PR7999(T& t) : value(t) {} 119 T& value; 120 }; 121 122 struct PR7999_X {}; 123 PR7999_f(PR7999<PR7999_X> s)124PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning test_PR7999(PR7999_X & x)125void 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 { }; f(typename B<V>::type const & v=B<V>::value ())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 }; g()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. ret_from_lambda()147void 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