clang/test/SemaCXX/return-stack-addr.cpp

   1 // RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b          %s
   2 // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20       %s
   3 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11 %s
   4
   5 int* ret_local() {
   6   int x = 1;
   7   return &x; // expected-warning {{address of stack memory}}
   8 }
   9
  10 int* ret_local_array() {
  11   int x[10];
  12   return x; // expected-warning {{address of stack memory}}
  13 }
  14
  15 int* ret_local_array_element(int i) {
  16   int x[10];
  17   return &x[i]; // expected-warning {{address of stack memory}}
  18 }
  19
  20 int *ret_local_array_element_reversed(int i) {
  21   int x[10];
  22   return &i[x]; // expected-warning {{address of stack memory}}
  23 }
  24
  25 int* ret_local_array_element_const_index() {
  26   int x[10];
  27   return &x[2];  // expected-warning {{address of stack memory}}
  28 }
  29
  30 int& ret_local_ref() {
  31   int x = 1;
  32   return x; // cxx11_20-warning {{reference to stack memory}}
  33   // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
  34 }
  35
  36 int* ret_local_addrOf() {
  37   int x = 1;
  38   return &*&x; // expected-warning {{address of stack memory}}
  39 }
  40
  41 int* ret_local_addrOf_paren() {
  42   int x = 1;
  43   return (&(*(&x))); // expected-warning {{address of stack memory}}
  44 }
  45
  46 int* ret_local_addrOf_ptr_arith() {
  47   int x = 1;
  48   return &*(&x+1); // expected-warning {{address of stack memory}}
  49 }
  50
  51 int* ret_local_addrOf_ptr_arith2() {
  52   int x = 1;
  53   return &*(&x+1); // expected-warning {{address of stack memory}}
  54 }
  55
  56 int* ret_local_field() {
  57   struct { int x; } a;
  58   return &a.x; // expected-warning {{address of stack memory}}
  59 }
  60
  61 int& ret_local_field_ref() {
  62   struct { int x; } a;
  63   return a.x; // expected-warning {{reference to stack memory}}
  64 }
  65
  66 int* ret_conditional(bool cond) {
  67   int x = 1;
  68   int y = 2;
  69   return cond ? &x // expected-warning {{address of stack memory associated with local variable 'x' returned}}
  70               : &y; // expected-warning {{address of stack memory associated with local variable 'y' returned}}
  71 }
  72
  73 int* ret_conditional_rhs(int *x, bool cond) {
  74   int y = 1;
  75   return cond ? x : &y;  // expected-warning {{address of stack memory}}
  76 }
  77
  78 void* ret_c_cast() {
  79   int x = 1;
  80   return (void*) &x;  // expected-warning {{address of stack memory}}
  81 }
  82
  83 int* ret_static_var() {
  84   static int x = 1;
  85   return &x;  // no warning.
  86 }
  87
  88 int z = 1;
  89
  90 int* ret_global() {
  91   return &z;  // no warning.
  92 }
  93
  94 int* ret_parameter(int x) {
  95   return &x;  // expected-warning {{address of stack memory}}
  96 }
  97
  98
  99 void* ret_cpp_static_cast(short x) {
 100   return static_cast<void*>(&x); // expected-warning {{address of stack memory}}
 101 }
 102
 103 int* ret_cpp_reinterpret_cast(double x) {
 104   return reinterpret_cast<int*>(&x); // expected-warning {{address of stack me}}
 105 }
 106
 107 int* ret_cpp_reinterpret_cast_no_warning(long x) {
 108   return reinterpret_cast<int*>(x); // no-warning
 109 }
 110
 111 int* ret_cpp_const_cast(const int x) {
 112   return const_cast<int*>(&x);  // expected-warning {{address of stack memory}}
 113 }
 114
 115 struct A { virtual ~A(); }; struct B : A {};
 116 A* ret_cpp_dynamic_cast(B b) {
 117   return dynamic_cast<A*>(&b); // expected-warning {{address of stack memory}}
 118 }
 119
 120 // PR 7999 - handle the case where a field is itself a reference.
 121 template <typename T> struct PR7999 {
 122   PR7999(T& t) : value(t) {}
 123   T& value;
 124 };
 125
 126 struct PR7999_X {};
 127
 128 PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning
 129 void test_PR7999(PR7999_X& x) { (void)PR7999_f(x); } // no-warning
 130
 131 // PR 8774: Don't try to evaluate parameters with default arguments like
 132 // variables with an initializer, especially in templates where the default
 133 // argument may not be an expression (yet).
 134 namespace PR8774 {
 135   template <typename U> struct B { };
 136   template <typename V> V f(typename B<V>::type const &v = B<V>::value()) {
 137     return v;
 138   }
 139   template <> struct B<const char *> {
 140     typedef const char *type;
 141     static const char *value();
 142   };
 143   void g() {
 144     const char *t;
 145     f<const char*>(t);
 146   }
 147 }
 148
 149 // Don't warn about returning a local variable from a surrounding function if
 150 // we're within a lambda-expression.
 151 void ret_from_lambda() {
 152   int a;
 153   int &b = a;
 154   (void) [&]() -> int& { return a; };
 155   (void) [&]() -> int& { return b; };
 156   (void) [=]() mutable -> int& { return a; };
 157   (void) [=]() mutable -> int& { return b; };
 158   (void) [&]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
 159   // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 160   (void) [=]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
 161   // cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
 162   (void) [&]() -> int& { int &a = b; return a; };
 163   (void) [=]() mutable -> int& { int &a = b; return a; };
 164
 165   (void) [] {
 166     int a;
 167     return [&] { // expected-warning {{address of stack memory associated with local variable 'a' returned}}
 168       return a; // expected-note {{implicitly captured by reference due to use here}}
 169     };
 170   };
 171   (void) [] {
 172     int a;
 173     return [&a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured by reference here}}
 174   };
 175   (void) [] {
 176     int a;
 177     return [=] {
 178       return a;
 179     };
 180   };
 181   (void) [] {
 182     int a;
 183     return [a] {};
 184   };
 185   (void) [] {
 186     int a;
 187     // cxx11-warning@+1 {{C++14}}
 188     return [&b = a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured by reference via initialization of lambda capture 'b'}}
 189   };
 190   (void) [] {
 191     int a;
 192     // cxx11-warning@+1 {{C++14}}
 193     return [b = &a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured via initialization of lambda capture 'b'}}
 194   };
 195 }
 196
 197 struct HoldsPointer { int *p; };
 198
 199 HoldsPointer ret_via_member_1() {
 200   int n;
 201   return {&n}; // expected-warning {{address of stack memory associated with local variable 'n' returned}}
 202 }
 203 HoldsPointer ret_via_member_2() {
 204   int n;
 205   return HoldsPointer(HoldsPointer{&n}); // cxx11-warning {{address of stack memory associated with local variable 'n' returned}}
 206 }
 207 // FIXME: We could diagnose this too.
 208 HoldsPointer ret_via_member_3() {
 209   int n;
 210   const HoldsPointer hp = HoldsPointer{&n};
 211   return hp;
 212 }
 213
 214 namespace mem_ptr {
 215   struct X {};
 216   int X::*f();
 217   int &r(X *p) { return p->*f(); }
 218 }
 219
 220 namespace PR47861 {
 221   struct A {
 222     A(int i);
 223     A &operator+=(int i);
 224   };
 225   A const &b = A(5) += 5; // expected-warning {{temporary bound to local reference 'b' will be destroyed at the end of the full-expression}}
 226 }