Clang Project

clang_source_code/test/SemaCXX/array-bounds.cpp
1// RUN: %clang_cc1 -verify -std=c++11 %s
2
3int foo() {
4  int x[2]; // expected-note 4 {{array 'x' declared here}}
5  int y[2]; // expected-note 2 {{array 'y' declared here}}
6  int z[1]; // expected-note {{array 'z' declared here}}
7  int w[1][1]; // expected-note {{array 'w' declared here}}
8  int v[1][1][1]; // expected-note {{array 'v' declared here}}
9  int *p = &y[2]; // no-warning
10  (void) sizeof(x[2]); // no-warning
11  y[2] = 2; // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
12  z[1] = 'x'; // expected-warning {{array index 1 is past the end of the array (which contains 1 element)}}
13  w[0][2] = 0; // expected-warning {{array index 2 is past the end of the array (which contains 1 element)}}
14  v[0][0][2] = 0; // expected-warning {{array index 2 is past the end of the array (which contains 1 element)}}
15  return x[2] +  // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
16         y[-1] + // expected-warning {{array index -1 is before the beginning of the array}}
17         x[sizeof(x)] +  // expected-warning {{array index 8 is past the end of the array (which contains 2 elements)}}
18         x[sizeof(x) / sizeof(x[0])] +  // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
19         x[sizeof(x) / sizeof(x[0]) - 1] + // no-warning
20         x[sizeof(x[2])]; // expected-warning {{array index 4 is past the end of the array (which contains 2 elements)}}
21}
22
23// This code example tests that -Warray-bounds works with arrays that
24// are template parameters.
25template <char *sz> class Qux {
26  bool test() { return sz[0] == 'a'; }
27};
28
29void f1(int a[1]) {
30  int val = a[3]; // no warning for function argumnet
31}
32
33void f2(const int (&a)[2]) { // expected-note {{declared here}}
34  int val = a[3];  // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}}
35}
36
37void test() {
38  struct {
39    int a[0];
40  } s2;
41  s2.a[3] = 0; // no warning for 0-sized array
42
43  union {
44    short a[2]; // expected-note 4 {{declared here}}
45    char c[4];
46  } u;
47  u.a[3] = 1; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}}
48  u.c[3] = 1; // no warning
49  short *p = &u.a[2]; // no warning
50  p = &u.a[3]; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}}
51  *(&u.a[2]) = 1; // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
52  *(&u.a[3]) = 1; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}}
53  *(&u.c[3]) = 1; // no warning
54
55  const int const_subscript = 3;
56  int array[2]; // expected-note {{declared here}}
57  array[const_subscript] = 0;  // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}}
58
59  int *ptr;
60  ptr[3] = 0; // no warning for pointer references
61  int array2[] = { 0, 1, 2 }; // expected-note 2 {{declared here}}
62
63  array2[3] = 0; // expected-warning {{array index 3 is past the end of the array (which contains 3 elements)}}
64  array2[2+2] = 0; // expected-warning {{array index 4 is past the end of the array (which contains 3 elements)}}
65
66  const char *str1 = "foo";
67  char c1 = str1[5]; // no warning for pointers
68
69  const char str2[] = "foo"; // expected-note {{declared here}}
70  char c2 = str2[5]; // expected-warning {{array index 5 is past the end of the array (which contains 4 elements)}}
71
72  int (*array_ptr)[2];
73  (*array_ptr)[3] = 1; // expected-warning {{array index 3 is past the end of the array (which contains 2 elements)}}
74}
75
76template <int I> struct S {
77  char arr[I]; // expected-note 3 {{declared here}}
78};
79template <int I> void f() {
80  S<3> s;
81  s.arr[4] = 0; // expected-warning 2 {{array index 4 is past the end of the array (which contains 3 elements)}}
82  s.arr[I] = 0; // expected-warning {{array index 5 is past the end of the array (which contains 3 elements)}}
83}
84
85void test_templates() {
86  f<5>(); // expected-note {{in instantiation}}
87}
88
89#define SIZE 10
90#define ARR_IN_MACRO(flag, arr, idx) flag ? arr[idx] : 1
91
92int test_no_warn_macro_unreachable() {
93  int arr[SIZE]; // expected-note {{array 'arr' declared here}}
94  return ARR_IN_MACRO(0, arr, SIZE) + // no-warning
95         ARR_IN_MACRO(1, arr, SIZE); // expected-warning{{array index 10 is past the end of the array (which contains 10 elements)}}
96}
97
98// This exhibited an assertion failure for a 32-bit build of Clang.
99int test_pr9240() {
100  short array[100]; // expected-note {{array 'array' declared here}}
101  return array[(unsigned long long) 100]; // expected-warning {{array index 100 is past the end of the array (which contains 100 elements)}}
102}
103
104// PR 9284 - a template parameter can cause an array bounds access to be
105// infeasible.
106template <bool extendArray>
107void pr9284() {
108    int arr[3 + (extendArray ? 1 : 0)];
109
110    if (extendArray)
111        arr[3] = 42; // no-warning
112}
113
114template <bool extendArray>
115void pr9284b() {
116    int arr[3 + (extendArray ? 1 : 0)]; // expected-note {{array 'arr' declared here}}
117
118    if (!extendArray)
119        arr[3] = 42; // expected-warning{{array index 3 is past the end of the array (which contains 3 elements)}}
120}
121
122void test_pr9284() {
123    pr9284<true>();
124    pr9284<false>();
125    pr9284b<true>();
126    pr9284b<false>(); // expected-note{{in instantiation of function template specialization 'pr9284b<false>' requested here}}
127}
128
129int test_pr9296() {
130    int array[2];
131    return array[true]; // no-warning
132}
133
134int test_sizeof_as_condition(int flag) {
135  int arr[2] = { 0, 0 }; // expected-note {{array 'arr' declared here}}
136  if (flag) 
137    return sizeof(char) != sizeof(char) ? arr[2] : arr[1];
138  return sizeof(char) == sizeof(char) ? arr[2] : arr[1]; // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
139}
140
141void test_switch() {
142  switch (4) {
143    case 1: {
144      int arr[2];
145      arr[2] = 1; // no-warning
146      break;
147    }
148    case 4: {
149      int arr[2]; // expected-note {{array 'arr' declared here}}
150      arr[2] = 1; // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
151      break;
152    }
153    default: {
154      int arr[2];
155      arr[2] = 1; // no-warning
156      break;
157    }
158  }
159}
160
161// Test nested switch statements.
162enum enumA { enumA_A, enumA_B, enumA_C, enumA_D, enumA_E };
163enum enumB { enumB_X, enumB_Y, enumB_Z };
164static enum enumB myVal = enumB_X;
165void test_nested_switch() {
166  switch (enumA_E) { // expected-warning {{no case matching constant}}
167    switch (myVal) { // expected-warning {{enumeration values 'enumB_X' and 'enumB_Z' not handled in switch}}
168      case enumB_Y: ;
169    }
170  }
171}
172
173// Test that if all the values of an enum covered, that the 'default' branch
174// is unreachable.
175enum Values { A, B, C, D };
176void test_all_enums_covered(enum Values v) {
177  int x[2];
178  switch (v) {
179  case A: return;
180  case B: return;
181  case C: return;
182  case D: return;
183  }
184  x[2] = 0; // no-warning
185}
186
187namespace tailpad {
188  struct foo {
189    char c1[1]; // expected-note {{declared here}}
190    int x;
191    char c2[1];
192  };
193
194  class baz {
195   public:
196    char c1[1]; // expected-note {{declared here}}
197    int x;
198    char c2[1];
199  };
200
201  char bar(struct foo *F, baz *B) {
202    return F->c1[3] + // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}}
203           F->c2[3] + // no warning, foo could have tail padding allocated.
204           B->c1[3] + // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}}
205           B->c2[3]; // no warning, baz could have tail padding allocated.
206  }
207}
208
209namespace metaprogramming {
210#define ONE 1
211  struct foo { char c[ONE]; }; // expected-note {{declared here}}
212  template <int N> struct bar { char c[N]; }; // expected-note {{declared here}}
213
214  char test(foo *F, bar<1> *B) {
215    return F->c[3] + // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}}
216           B->c[3]; // expected-warning {{array index 3 is past the end of the array (which contains 1 element)}}
217  }
218}
219
220void bar(int x) {}
221int test_more() {
222  int foo[5]; // expected-note 5 {{array 'foo' declared here}}
223  bar(foo[5]); // expected-warning {{array index 5 is past the end of the array (which contains 5 elements)}}
224  ++foo[5]; // expected-warning {{array index 5 is past the end of the array (which contains 5 elements)}}
225  if (foo[6]) // expected-warning {{array index 6 is past the end of the array (which contains 5 elements)}}
226    return --foo[6]; // expected-warning {{array index 6 is past the end of the array (which contains 5 elements)}}
227  else
228    return foo[5]; // expected-warning {{array index 5 is past the end of the array (which contains 5 elements)}}
229}
230
231void test_pr10771() {
232    double foo[4096];  // expected-note {{array 'foo' declared here}}
233
234    ((char*)foo)[sizeof(foo) - 1] = '\0';  // no-warning
235    *(((char*)foo) + sizeof(foo) - 1) = '\0';  // no-warning
236
237    ((char*)foo)[sizeof(foo)] = '\0';  // expected-warning {{array index 32768 is past the end of the array (which contains 32768 elements)}}
238
239    // TODO: This should probably warn, too.
240    *(((char*)foo) + sizeof(foo)) = '\0';  // no-warning
241}
242
243int test_pr11007_aux(const char * restrict, ...);
244  
245// Test checking with varargs.
246void test_pr11007() {
247  double a[5]; // expected-note {{array 'a' declared here}}
248  test_pr11007_aux("foo", a[1000]); // expected-warning {{array index 1000 is past the end of the array}}
249}
250
251void test_rdar10916006(void)
252{
253 int a[128]; // expected-note {{array 'a' declared here}}
254 a[(unsigned char)'\xA1'] = 1; // expected-warning {{array index 161 is past the end of the array}}
255}
256
257struct P {
258  int a;
259  int b;
260};
261
262void test_struct_array_index() {
263  struct P p[10]; // expected-note {{array 'p' declared here}}
264  p[11] = {0, 1}; // expected-warning {{array index 11 is past the end of the array (which contains 10 elements)}}
265}
266
267int operator+(const struct P &s1, const struct P &s2);
268int test_operator_overload_struct_array_index() {
269  struct P x[10] = {0}; // expected-note {{array 'x' declared here}}
270  return x[1] + x[11]; // expected-warning {{array index 11 is past the end of the array (which contains 10 elements)}}
271}
272
273int multi[2][2][2]; // expected-note 3 {{array 'multi' declared here}}
274int test_multiarray() {
275  return multi[2][0][0] + // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
276         multi[0][2][0] + // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
277         multi[0][0][2];  // expected-warning {{array index 2 is past the end of the array (which contains 2 elements)}}
278}
279
280struct multi_s {
281  int arr[4];
282};
283struct multi_s multi2[4]; // expected-note {{array 'multi2' declared here}}
284int test_struct_multiarray() {
285  return multi2[4].arr[0]; // expected-warning {{array index 4 is past the end of the array (which contains 4 elements)}}
286}
287
288namespace PR39746 {
289  struct S;
290  extern S xxx[2]; // expected-note {{array 'xxx' declared here}}
291  class C {};
292
293  C &f() { return reinterpret_cast<C *>(xxx)[1]; } // no-warning
294  // We have no info on whether this is out-of-bounds.
295  C &g() { return reinterpret_cast<C *>(xxx)[2]; } // no-warning
296  // We can still diagnose this.
297  C &h() { return reinterpret_cast<C *>(xxx)[-1]; } // expected-warning {{array index -1 is before the beginning of the array}}
298}
299
300namespace PR41087 {
301  template <typename Ty> void foo() {
302    Ty buffer[2]; // expected-note 3{{array 'buffer' declared here}}
303    ((char *)buffer)[2] = 'A'; // expected-warning 1{{array index 2 is past the end of the array (which contains 2 elements)}}
304    ((char *)buffer)[-1] = 'A'; // expected-warning 2{{array index -1 is before the beginning of the array}}
305  }
306
307  void f() {
308    foo<char>(); // expected-note 1{{in instantiation of function template specialization}}
309    foo<int>(); // expected-note 1{{in instantiation of function template specialization}}
310  };
311}
312
CodeThinker, Enjoy your reading code