1// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 2 3int* ret_local() { 4 int x = 1; 5 return &x; // expected-warning {{address of stack memory}} 6} 7 8int* ret_local_array() { 9 int x[10]; 10 return x; // expected-warning {{address of stack memory}} 11} 12 13int* ret_local_array_element(int i) { 14 int x[10]; 15 return &x[i]; // expected-warning {{address of stack memory}} 16} 17 18int *ret_local_array_element_reversed(int i) { 19 int x[10]; 20 return &i[x]; // expected-warning {{address of stack memory}} 21} 22 23int* ret_local_array_element_const_index() { 24 int x[10]; 25 return &x[2]; // expected-warning {{address of stack memory}} 26} 27 28int& ret_local_ref() { 29 int x = 1; 30 return x; // expected-warning {{reference to stack memory}} 31} 32 33int* ret_local_addrOf() { 34 int x = 1; 35 return &*&x; // expected-warning {{address of stack memory}} 36} 37 38int* ret_local_addrOf_paren() { 39 int x = 1; 40 return (&(*(&x))); // expected-warning {{address of stack memory}} 41} 42 43int* ret_local_addrOf_ptr_arith() { 44 int x = 1; 45 return &*(&x+1); // expected-warning {{address of stack memory}} 46} 47 48int* ret_local_addrOf_ptr_arith2() { 49 int x = 1; 50 return &*(&x+1); // expected-warning {{address of stack memory}} 51} 52 53int* ret_local_field() { 54 struct { int x; } a; 55 return &a.x; // expected-warning {{address of stack memory}} 56} 57 58int& ret_local_field_ref() { 59 struct { int x; } a; 60 return a.x; // expected-warning {{reference to stack memory}} 61} 62 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 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 74void* ret_c_cast() { 75 int x = 1; 76 return (void*) &x; // expected-warning {{address of stack memory}} 77} 78 79int* ret_static_var() { 80 static int x = 1; 81 return &x; // no warning. 82} 83 84int z = 1; 85 86int* ret_global() { 87 return &z; // no warning. 88} 89 90int* ret_parameter(int x) { 91 return &x; // expected-warning {{address of stack memory}} 92} 93 94 95void* ret_cpp_static_cast(short x) { 96 return static_cast<void*>(&x); // expected-warning {{address of stack memory}} 97} 98 99int* ret_cpp_reinterpret_cast(double x) { 100 return reinterpret_cast<int*>(&x); // expected-warning {{address of stack me}} 101} 102 103int* ret_cpp_reinterpret_cast_no_warning(long x) { 104 return reinterpret_cast<int*>(x); // no-warning 105} 106 107int* ret_cpp_const_cast(const int x) { 108 return const_cast<int*>(&x); // expected-warning {{address of stack memory}} 109} 110 111struct A { virtual ~A(); }; struct B : A {}; 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. 117template <typename T> struct PR7999 { 118 PR7999(T& t) : value(t) {} 119 T& value; 120}; 121 122struct PR7999_X {}; 123 124PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning 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). 130namespace 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. 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