1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2 
ret_local()3 int* ret_local() {
4   int x = 1;
5   return &x; // expected-warning {{address of stack memory}}
6 }
7 
ret_local_array()8 int* ret_local_array() {
9   int x[10];
10   return x; // expected-warning {{address of stack memory}}
11 }
12 
ret_local_array_element(int i)13 int* 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)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 
ret_local_array_element_const_index()23 int* 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()28 int& ret_local_ref() {
29   int x = 1;
30   return x;  // expected-warning {{reference to stack memory}}
31 }
32 
ret_local_addrOf()33 int* ret_local_addrOf() {
34   int x = 1;
35   return &*&x; // expected-warning {{address of stack memory}}
36 }
37 
ret_local_addrOf_paren()38 int* ret_local_addrOf_paren() {
39   int x = 1;
40   return (&(*(&x))); // expected-warning {{address of stack memory}}
41 }
42 
ret_local_addrOf_ptr_arith()43 int* 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()48 int* ret_local_addrOf_ptr_arith2() {
49   int x = 1;
50   return &*(&x+1); // expected-warning {{address of stack memory}}
51 }
52 
ret_local_field()53 int* ret_local_field() {
54   struct { int x; } a;
55   return &a.x; // expected-warning {{address of stack memory}}
56 }
57 
ret_local_field_ref()58 int& 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)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 
ret_conditional_rhs(int * x,bool cond)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 
ret_c_cast()74 void* ret_c_cast() {
75   int x = 1;
76   return (void*) &x;  // expected-warning {{address of stack memory}}
77 }
78 
ret_static_var()79 int* ret_static_var() {
80   static int x = 1;
81   return &x;  // no warning.
82 }
83 
84 int z = 1;
85 
ret_global()86 int* ret_global() {
87   return &z;  // no warning.
88 }
89 
ret_parameter(int x)90 int* ret_parameter(int x) {
91   return &x;  // expected-warning {{address of stack memory}}
92 }
93 
94 
ret_cpp_static_cast(short x)95 void* 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)99 int* 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)103 int* 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)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 {};
ret_cpp_dynamic_cast(B b)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 {
PR7999PR7999118   PR7999(T& t) : value(t) {}
119   T& value;
120 };
121 
122 struct PR7999_X {};
123 
PR7999_f(PR7999<PR7999_X> s)124 PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning
test_PR7999(PR7999_X & x)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 { };
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()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