Clang Project

clang_source_code/test/SemaCXX/return-stack-addr.cpp
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 // 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
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
75void* ret_c_cast() {
76  int x = 1;
77  return (void*) &x;  // expected-warning {{address of stack memory}}
78}
79
80int* ret_static_var() {
81  static int x = 1;
82  return &x;  // no warning.
83}
84
85int z = 1;
86
87int* ret_global() {
88  return &z;  // no warning.
89}
90
91int* ret_parameter(int x) {
92  return &x;  // expected-warning {{address of stack memory}}
93}
94
95
96void* ret_cpp_static_cast(short x) {
97  return static_cast<void*>(&x); // expected-warning {{address of stack memory}}
98}
99
100int* ret_cpp_reinterpret_cast(double x) {
101  return reinterpret_cast<int*>(&x); // expected-warning {{address of stack me}}
102}
103
104int* ret_cpp_reinterpret_cast_no_warning(long x) {
105  return reinterpret_cast<int*>(x); // no-warning
106}
107
108int* ret_cpp_const_cast(const int x) {
109  return const_cast<int*>(&x);  // expected-warning {{address of stack memory}}
110}
111
112struct A { virtual ~A(); }; struct B : A {};
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.
118template <typename T> struct PR7999 {
119  PR7999(T& t) : value(t) {}
120  T& value;
121};
122
123struct PR7999_X {};
124
125PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning
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).
131namespace PR8774 {
132  template <typename U> struct B { };
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  };
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.
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
161namespace mem_ptr {
162  struct X {};
163  int X::*f();
164  int &r(X *p) { return p->*f(); }
165}
166
CodeThinker, Enjoy your reading code