1 /* { dg-do run } */
2 /* { dg-options "-O2" } */
3 /* { dg-require-effective-target alloca } */
4 
5 typedef __SIZE_TYPE__ size_t;
6 extern void abort (void);
7 extern void exit (int);
8 extern void *malloc (size_t);
9 extern void *calloc (size_t, size_t);
10 extern void *alloca (size_t);
11 extern void *memcpy (void *, const void *, size_t);
12 extern void *memset (void *, int, size_t);
13 extern char *strcpy (char *, const char *);
14 
15 struct A
16 {
17   char a[10];
18   int b;
19   char c[10];
20 } y, w[4];
21 
22 extern char exta[];
23 extern char extb[30];
24 extern struct A zerol[0];
25 
26 void
27 __attribute__ ((noinline))
test1(void * q,int x)28 test1 (void *q, int x)
29 {
30   struct A a;
31   void *p = &a.a[3], *r;
32   char var[x + 10];
33   if (x < 0)
34     r = &a.a[9];
35   else
36     r = &a.c[1];
37   if (__builtin_object_size (p, 2)
38       != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
39     abort ();
40   if (__builtin_object_size (&a.c[9], 2)
41       != sizeof (a) - __builtin_offsetof (struct A, c) - 9)
42     abort ();
43   if (__builtin_object_size (q, 2) != 0)
44     abort ();
45   if (__builtin_object_size (r, 2)
46       != sizeof (a) - __builtin_offsetof (struct A, c) - 1)
47     abort ();
48   if (x < 6)
49     r = &w[2].a[1];
50   else
51     r = &a.a[6];
52   if (__builtin_object_size (&y, 2)
53       != sizeof (y))
54     abort ();
55   if (__builtin_object_size (w, 2)
56       != sizeof (w))
57     abort ();
58   if (__builtin_object_size (&y.b, 2)
59       != sizeof (a) - __builtin_offsetof (struct A, b))
60     abort ();
61   if (__builtin_object_size (r, 2)
62       != sizeof (a) - __builtin_offsetof (struct A, a) - 6)
63     abort ();
64   if (x < 20)
65     r = malloc (30);
66   else
67     r = calloc (2, 16);
68   if (__builtin_object_size (r, 2) != 30)
69     abort ();
70   if (x < 20)
71     r = malloc (30);
72   else
73     r = calloc (2, 14);
74   if (__builtin_object_size (r, 2) != 2 * 14)
75     abort ();
76   if (x < 30)
77     r = malloc (sizeof (a));
78   else
79     r = &a.a[3];
80   if (__builtin_object_size (r, 2)
81       != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
82     abort ();
83   r = memcpy (r, "a", 2);
84   if (__builtin_object_size (r, 2)
85       != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
86     abort ();
87   r = memcpy (r + 2, "b", 2) + 2;
88   if (__builtin_object_size (r, 2)
89       != sizeof (a) - __builtin_offsetof (struct A, a) - 3 - 4)
90     abort ();
91   r = &a.a[4];
92   r = memset (r, 'a', 2);
93   if (__builtin_object_size (r, 2)
94       != sizeof (a) - __builtin_offsetof (struct A, a) - 4)
95     abort ();
96   r = memset (r + 2, 'b', 2) + 2;
97   if (__builtin_object_size (r, 2)
98       != sizeof (a) - __builtin_offsetof (struct A, a) - 8)
99     abort ();
100   r = &a.a[1];
101   r = strcpy (r, "ab");
102   if (__builtin_object_size (r, 2)
103       != sizeof (a) - __builtin_offsetof (struct A, a) - 1)
104     abort ();
105   r = strcpy (r + 2, "cd") + 2;
106   if (__builtin_object_size (r, 2)
107       != sizeof (a) - __builtin_offsetof (struct A, a) - 5)
108     abort ();
109   if (__builtin_object_size (exta, 2) != 0)
110     abort ();
111   if (__builtin_object_size (exta + 10, 2) != 0)
112     abort ();
113   if (__builtin_object_size (&exta[5], 2) != 0)
114     abort ();
115   if (__builtin_object_size (extb, 2) != sizeof (extb))
116     abort ();
117   if (__builtin_object_size (extb + 10, 2) != sizeof (extb) - 10)
118     abort ();
119   if (__builtin_object_size (&extb[5], 2) != sizeof (extb) - 5)
120     abort ();
121   if (__builtin_object_size (var, 2) != 0)
122     abort ();
123   if (__builtin_object_size (var + 10, 2) != 0)
124     abort ();
125   if (__builtin_object_size (&var[5], 2) != 0)
126     abort ();
127   if (__builtin_object_size (zerol, 2) != 0)
128     abort ();
129   if (__builtin_object_size (&zerol, 2) != 0)
130     abort ();
131   if (__builtin_object_size (&zerol[0], 2) != 0)
132     abort ();
133   if (__builtin_object_size (zerol[0].a, 2) != 0)
134     abort ();
135   if (__builtin_object_size (&zerol[0].a[0], 2) != 0)
136     abort ();
137   if (__builtin_object_size (&zerol[0].b, 2) != 0)
138     abort ();
139   if (__builtin_object_size ("abcdefg", 2) != sizeof ("abcdefg"))
140     abort ();
141   if (__builtin_object_size ("abcd\0efg", 2) != sizeof ("abcd\0efg"))
142     abort ();
143   if (__builtin_object_size (&"abcd\0efg", 2) != sizeof ("abcd\0efg"))
144     abort ();
145   if (__builtin_object_size (&"abcd\0efg"[0], 2) != sizeof ("abcd\0efg"))
146     abort ();
147   if (__builtin_object_size (&"abcd\0efg"[4], 2) != sizeof ("abcd\0efg") - 4)
148     abort ();
149   if (__builtin_object_size ("abcd\0efg" + 5, 2) != sizeof ("abcd\0efg") - 5)
150     abort ();
151   if (__builtin_object_size (L"abcdefg", 2) != sizeof (L"abcdefg"))
152     abort ();
153   r = (char *) L"abcd\0efg";
154   if (__builtin_object_size (r + 2, 2) != sizeof (L"abcd\0efg") - 2)
155     abort ();
156 }
157 
158 size_t l1 = 1;
159 
160 void
161 __attribute__ ((noinline))
test2(void)162 test2 (void)
163 {
164   struct B { char buf1[10]; char buf2[10]; } a;
165   char *r, buf3[20];
166   int i;
167 
168   if (sizeof (a) != 20)
169     return;
170 
171   r = buf3;
172   for (i = 0; i < 4; ++i)
173     {
174       if (i == l1 - 1)
175 	r = &a.buf1[1];
176       else if (i == l1)
177 	r = &a.buf2[7];
178       else if (i == l1 + 1)
179 	r = &buf3[5];
180       else if (i == l1 + 2)
181 	r = &a.buf1[9];
182     }
183   if (__builtin_object_size (r, 2) != 3)
184     abort ();
185   r = &buf3[20];
186   for (i = 0; i < 4; ++i)
187     {
188       if (i == l1 - 1)
189 	r = &a.buf1[7];
190       else if (i == l1)
191 	r = &a.buf2[7];
192       else if (i == l1 + 1)
193 	r = &buf3[5];
194       else if (i == l1 + 2)
195 	r = &a.buf1[9];
196     }
197   if (__builtin_object_size (r, 2) != 0)
198     abort ();
199   r = &buf3[2];
200   for (i = 0; i < 4; ++i)
201     {
202       if (i == l1 - 1)
203 	r = &a.buf1[1];
204       else if (i == l1)
205 	r = &a.buf1[2];
206       else if (i == l1 + 1)
207 	r = &buf3[5];
208       else if (i == l1 + 2)
209 	r = &a.buf1[4];
210     }
211   if (__builtin_object_size (r, 2) != 15)
212     abort ();
213   r += 8;
214   if (__builtin_object_size (r, 2) != 7)
215     abort ();
216   if (__builtin_object_size (r + 6, 2) != 1)
217     abort ();
218   r = &buf3[18];
219   for (i = 0; i < 4; ++i)
220     {
221       if (i == l1 - 1)
222 	r = &a.buf1[9];
223       else if (i == l1)
224 	r = &a.buf2[9];
225       else if (i == l1 + 1)
226 	r = &buf3[5];
227       else if (i == l1 + 2)
228 	r = &a.buf1[4];
229     }
230   if (__builtin_object_size (r + 12, 2) != 0)
231     abort ();
232 }
233 
234 void
235 __attribute__ ((noinline))
test3(void)236 test3 (void)
237 {
238   char buf4[10];
239   struct B { struct A a[2]; struct A b; char c[4]; char d; double e;
240 	     _Complex double f; } x;
241   double y;
242   _Complex double z;
243   double *dp;
244 
245   if (__builtin_object_size (buf4, 2) != sizeof (buf4))
246     abort ();
247   if (__builtin_object_size (&buf4, 2) != sizeof (buf4))
248     abort ();
249   if (__builtin_object_size (&buf4[0], 2) != sizeof (buf4))
250     abort ();
251   if (__builtin_object_size (&buf4[1], 2) != sizeof (buf4) - 1)
252     abort ();
253   if (__builtin_object_size (&x, 2) != sizeof (x))
254     abort ();
255   if (__builtin_object_size (&x.a, 2) != sizeof (x))
256     abort ();
257   if (__builtin_object_size (&x.a[0], 2) != sizeof (x))
258     abort ();
259   if (__builtin_object_size (&x.a[0].a, 2) != sizeof (x))
260     abort ();
261   if (__builtin_object_size (&x.a[0].a[0], 2) != sizeof (x))
262     abort ();
263   if (__builtin_object_size (&x.a[0].a[3], 2) != sizeof (x) - 3)
264     abort ();
265   if (__builtin_object_size (&x.a[0].b, 2)
266       != sizeof (x) - __builtin_offsetof (struct A, b))
267     abort ();
268   if (__builtin_object_size (&x.a[1].c, 2)
269       != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
270     abort ();
271   if (__builtin_object_size (&x.a[1].c[0], 2)
272       != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
273     abort ();
274   if (__builtin_object_size (&x.a[1].c[3], 2)
275       != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c) - 3)
276     abort ();
277   if (__builtin_object_size (&x.b, 2)
278       != sizeof (x) - __builtin_offsetof (struct B, b))
279     abort ();
280   if (__builtin_object_size (&x.b.a, 2)
281       != sizeof (x) - __builtin_offsetof (struct B, b))
282     abort ();
283   if (__builtin_object_size (&x.b.a[0], 2)
284       != sizeof (x) - __builtin_offsetof (struct B, b))
285     abort ();
286   if (__builtin_object_size (&x.b.a[3], 2)
287       != sizeof (x) - __builtin_offsetof (struct B, b) - 3)
288     abort ();
289   if (__builtin_object_size (&x.b.b, 2)
290       != sizeof (x) - __builtin_offsetof (struct B, b)
291 	 - __builtin_offsetof (struct A, b))
292     abort ();
293   if (__builtin_object_size (&x.b.c, 2)
294       != sizeof (x) - __builtin_offsetof (struct B, b)
295 	 - __builtin_offsetof (struct A, c))
296     abort ();
297   if (__builtin_object_size (&x.b.c[0], 2)
298       != sizeof (x) - __builtin_offsetof (struct B, b)
299 	 - __builtin_offsetof (struct A, c))
300     abort ();
301   if (__builtin_object_size (&x.b.c[3], 2)
302       != sizeof (x) - __builtin_offsetof (struct B, b)
303 	 - __builtin_offsetof (struct A, c) - 3)
304     abort ();
305   if (__builtin_object_size (&x.c, 2)
306       != sizeof (x) - __builtin_offsetof (struct B, c))
307     abort ();
308   if (__builtin_object_size (&x.c[0], 2)
309       != sizeof (x) - __builtin_offsetof (struct B, c))
310     abort ();
311   if (__builtin_object_size (&x.c[1], 2)
312       != sizeof (x) - __builtin_offsetof (struct B, c) - 1)
313     abort ();
314   if (__builtin_object_size (&x.d, 2)
315       != sizeof (x) - __builtin_offsetof (struct B, d))
316     abort ();
317   if (__builtin_object_size (&x.e, 2)
318       != sizeof (x) - __builtin_offsetof (struct B, e))
319     abort ();
320   if (__builtin_object_size (&x.f, 2)
321       != sizeof (x) - __builtin_offsetof (struct B, f))
322     abort ();
323   dp = &__real__ x.f;
324   if (__builtin_object_size (dp, 2)
325       != sizeof (x) - __builtin_offsetof (struct B, f))
326     abort ();
327   dp = &__imag__ x.f;
328   if (__builtin_object_size (dp, 2)
329       != sizeof (x) - __builtin_offsetof (struct B, f)
330 	 - sizeof (x.f) / 2)
331     abort ();
332   dp = &y;
333   if (__builtin_object_size (dp, 2) != sizeof (y))
334     abort ();
335   if (__builtin_object_size (&z, 2) != sizeof (z))
336     abort ();
337   dp = &__real__ z;
338   if (__builtin_object_size (dp, 2) != sizeof (z))
339     abort ();
340   dp = &__imag__ z;
341   if (__builtin_object_size (dp, 2) != sizeof (z) / 2)
342     abort ();
343 }
344 
345 struct S { unsigned int a; };
346 
347 char *
348 __attribute__ ((noinline))
test4(char * x,int y)349 test4 (char *x, int y)
350 {
351   register int i;
352   struct A *p;
353 
354   for (i = 0; i < y; i++)
355     {
356       p = (struct A *) x;
357       x = (char *) &p[1];
358       if (__builtin_object_size (p, 2) != 0)
359 	abort ();
360     }
361   return x;
362 }
363 
364 void
365 __attribute__ ((noinline))
test5(size_t x)366 test5 (size_t x)
367 {
368   char buf[64];
369   char *p = &buf[8];
370   size_t i;
371 
372   for (i = 0; i < x; ++i)
373     p = p + 4;
374   if (__builtin_object_size (p, 2) != 0)
375     abort ();
376   memset (p, ' ', sizeof (buf) - 8 - 4 * 4);
377 }
378 
379 void
380 __attribute__ ((noinline))
test6(size_t x)381 test6 (size_t x)
382 {
383   struct T { char buf[64]; char buf2[64]; } t;
384   char *p = &t.buf[8];
385   size_t i;
386 
387   for (i = 0; i < x; ++i)
388     p = p + 4;
389   if (__builtin_object_size (p, 2) != 0)
390     abort ();
391   memset (p, ' ', sizeof (t) - 8 - 4 * 4);
392 }
393 
394 void
395 __attribute__ ((noinline))
test7(void)396 test7 (void)
397 {
398   char buf[64];
399   struct T { char buf[64]; char buf2[64]; } t;
400   char *p = &buf[64], *q = &t.buf[64];
401 
402   if (__builtin_object_size (p + 64, 2) != 0)
403     abort ();
404   if (__builtin_object_size (q + 63, 2) != sizeof (t) - 64 - 63)
405     abort ();
406   if (__builtin_object_size (q + 64, 2) != sizeof (t) - 64 - 64)
407     abort ();
408   if (__builtin_object_size (q + 256, 2) != 0)
409     abort ();
410 }
411 
412 void
413 __attribute__ ((noinline))
test8(void)414 test8 (void)
415 {
416   struct T { char buf[10]; char buf2[10]; } t;
417   char *p = &t.buf2[-4];
418   char *q = &t.buf2[0];
419   if (__builtin_object_size (p, 2) != sizeof (t) - 10 + 4)
420     abort ();
421   if (__builtin_object_size (q, 2) != sizeof (t) - 10)
422     abort ();
423   /* GCC only handles additions, not subtractions.  */
424   q = q - 8;
425   if (__builtin_object_size (q, 2) != 0
426       && __builtin_object_size (q, 2) != sizeof (t) - 10 + 8)
427     abort ();
428   p = &t.buf[-4];
429   if (__builtin_object_size (p, 2) != 0)
430     abort ();
431 }
432 
433 int
main(void)434 main (void)
435 {
436   struct S s[10];
437   __asm ("" : "=r" (l1) : "0" (l1));
438   test1 (main, 6);
439   test2 ();
440   test3 ();
441   test4 ((char *) s, 10);
442   test5 (4);
443   test6 (4);
444   test7 ();
445   test8 ();
446   exit (0);
447 }
448