1 /* { dg-do run } */
2 /* { dg-options "-O2 -Wno-stringop-overread" } */
3 /* { dg-require-effective-target alloca } */
4
5 #include "builtin-object-size-common.h"
6
7 struct A
8 {
9 char a[10];
10 int b;
11 char c[10];
12 } y, w[4];
13
14 extern char exta[];
15 extern char extb[30];
16 extern struct A extc[];
17 struct A zerol[0];
18
19 void
20 __attribute__ ((noinline))
21 test1 (void *q, int x)
22 {
23 struct A a;
24 void *p = &a.a[3], *r;
25 char var[x + 10];
26 struct A vara[x + 10];
27 if (x < 0)
28 r = &a.a[9];
29 else
30 r = &a.c[1];
31 if (__builtin_object_size (p, 1) != sizeof (a.a) - 3)
32 FAIL ();
33 if (__builtin_object_size (&a.c[9], 1)
34 != sizeof (a.c) - 9)
35 FAIL ();
36 if (__builtin_object_size (q, 1) != (size_t) -1)
37 FAIL ();
38 #ifdef __builtin_object_size
39 if (x < 0
40 ? __builtin_object_size (r, 1) != sizeof (a.a) - 9
41 : __builtin_object_size (r, 1) != sizeof (a.c) - 1)
42 FAIL ();
43 #else
44 if (__builtin_object_size (r, 1) != sizeof (a.c) - 1)
45 FAIL ();
46 #endif
47 if (x < 6)
48 r = &w[2].a[1];
49 else
50 r = &a.a[6];
51 if (__builtin_object_size (&y, 1) != sizeof (y))
52 FAIL ();
53 if (__builtin_object_size (w, 1) != sizeof (w))
54 FAIL ();
55 if (__builtin_object_size (&y.b, 1) != sizeof (a.b))
56 FAIL ();
57 #ifdef __builtin_object_size
58 if (x < 6
59 ? __builtin_object_size (r, 1) != sizeof (a.a) - 1
60 : __builtin_object_size (r, 1) != sizeof (a.a) - 6)
61 FAIL ();
62 #else
63 if (__builtin_object_size (r, 1) != sizeof (a.a) - 1)
64 FAIL ();
65 #endif
66 if (x < 20)
67 r = malloc (30);
68 else
69 r = calloc (2, 16);
70 #ifdef __builtin_object_size
71 if (__builtin_object_size (r, 1) != (x < 20 ? 30 : 2 * 16))
72 FAIL ();
73 #else
74 /* We may duplicate this test onto the two exit paths. On one path
75 the size will be 32, the other it will be 30. If we don't duplicate
76 this test, then the size will be 32. */
77 if (__builtin_object_size (r, 1) != 2 * 16
78 && __builtin_object_size (r, 1) != 30)
79 FAIL ();
80 #endif
81 if (x < 20)
82 r = malloc (30);
83 else
84 r = calloc (2, 14);
85 #ifdef __builtin_object_size
86 if (__builtin_object_size (r, 1) != (x < 20 ? 30 : 2 * 14))
87 FAIL ();
88 #else
89 if (__builtin_object_size (r, 1) != 30)
90 FAIL ();
91 #endif
92 if (x < 30)
93 r = malloc (sizeof (a));
94 else
95 r = &a.a[3];
96 #ifdef __builtin_object_size
97 if (__builtin_object_size (r, 1) != (x < 30 ? sizeof (a) : sizeof (a) - 3))
98 FAIL ();
99 #else
100 if (__builtin_object_size (r, 1) != sizeof (a))
101 FAIL ();
102 #endif
103 r = memcpy (r, "a", 2);
104 #ifdef __builtin_object_size
105 if (__builtin_object_size (r, 1) != (x < 30 ? sizeof (a) : sizeof (a) - 3))
106 FAIL ();
107 #else
108 if (__builtin_object_size (r, 1) != sizeof (a))
109 FAIL ();
110 #endif
111 r = memcpy (r + 2, "b", 2) + 2;
112 #ifdef __builtin_object_size
113 if (__builtin_object_size (r, 0)
114 != (x < 30 ? sizeof (a) - 4 : sizeof (a) - 7))
115 FAIL ();
116 #else
117 if (__builtin_object_size (r, 1) != sizeof (a) - 4)
118 FAIL ();
119 #endif
120 r = &a.a[4];
121 r = memset (r, 'a', 2);
122 if (__builtin_object_size (r, 1) != sizeof (a.a) - 4)
123 FAIL ();
124 r = memset (r + 2, 'b', 2) + 2;
125 if (__builtin_object_size (r, 1) != sizeof (a.a) - 8)
126 FAIL ();
127 r = &a.a[1];
128 r = strcpy (r, "ab");
129 if (__builtin_object_size (r, 1) != sizeof (a.a) - 1)
130 FAIL ();
131 r = strcpy (r + 2, "cd") + 2;
132 if (__builtin_object_size (r, 1) != sizeof (a.a) - 5)
133 FAIL ();
134 if (__builtin_object_size (exta, 1) != (size_t) -1)
135 FAIL ();
136 if (__builtin_object_size (exta + 10, 1) != (size_t) -1)
137 FAIL ();
138 if (__builtin_object_size (&exta[5], 1) != (size_t) -1)
139 FAIL ();
140 if (__builtin_object_size (extb, 1) != sizeof (extb))
141 FAIL ();
142 if (__builtin_object_size (extb + 10, 1) != sizeof (extb) - 10)
143 FAIL ();
144 if (__builtin_object_size (&extb[5], 1) != sizeof (extb) - 5)
145 FAIL ();
146 if (__builtin_object_size (extc, 1) != (size_t) -1)
147 FAIL ();
148 if (__builtin_object_size (extc + 10, 1) != (size_t) -1)
149 FAIL ();
150 if (__builtin_object_size (&extc[5], 1) != (size_t) -1)
151 FAIL ();
152 if (__builtin_object_size (&extc->a, 1) != (size_t) -1)
153 FAIL ();
154 if (__builtin_object_size (&(extc + 10)->b, 1) != (size_t) -1)
155 FAIL ();
156 if (__builtin_object_size (&extc[5].c[3], 1) != (size_t) -1)
157 FAIL ();
158 #ifdef __builtin_object_size
159 if (__builtin_object_size (var, 1) != x + 10)
160 FAIL ();
161 if (__builtin_object_size (var + 10, 1) != x)
162 FAIL ();
163 if (__builtin_object_size (&var[5], 1) != x + 5)
164 FAIL ();
165 if (__builtin_object_size (vara, 1) != (x + 10) * sizeof (struct A))
166 FAIL ();
167 if (__builtin_object_size (vara + 10, 1) != x * sizeof (struct A))
168 FAIL ();
169 if (__builtin_object_size (&vara[5], 1) != (x + 5) * sizeof (struct A))
170 FAIL ();
171 #else
172 if (__builtin_object_size (var, 1) != (size_t) -1)
173 FAIL ();
174 if (__builtin_object_size (var + 10, 1) != (size_t) -1)
175 FAIL ();
176 if (__builtin_object_size (&var[5], 1) != (size_t) -1)
177 FAIL ();
178 if (__builtin_object_size (vara, 1) != (size_t) -1)
179 FAIL ();
180 if (__builtin_object_size (vara + 10, 1) != (size_t) -1)
181 FAIL ();
182 if (__builtin_object_size (&vara[5], 1) != (size_t) -1)
183 FAIL ();
184 #endif
185 if (__builtin_object_size (&vara[0].a, 1) != sizeof (vara[0].a))
186 FAIL ();
187 if (__builtin_object_size (&vara[10].a[0], 1) != sizeof (vara[0].a))
188 FAIL ();
189 if (__builtin_object_size (&vara[5].a[4], 1) != sizeof (vara[0].a) - 4)
190 FAIL ();
191 if (__builtin_object_size (&vara[5].b, 1) != sizeof (vara[0].b))
192 FAIL ();
193 if (__builtin_object_size (&vara[7].c[7], 1) != sizeof (vara[0].c) - 7)
194 FAIL ();
195 if (__builtin_object_size (zerol, 1) != 0)
196 FAIL ();
197 if (__builtin_object_size (&zerol, 1) != 0)
198 FAIL ();
199 if (__builtin_object_size (&zerol[0], 1) != 0)
200 FAIL ();
201 if (__builtin_object_size (zerol[0].a, 1) != 0)
202 FAIL ();
203 if (__builtin_object_size (&zerol[0].a[0], 1) != 0)
204 FAIL ();
205 if (__builtin_object_size (&zerol[0].b, 1) != 0)
206 FAIL ();
207 if (__builtin_object_size ("abcdefg", 1) != sizeof ("abcdefg"))
208 FAIL ();
209 if (__builtin_object_size ("abcd\0efg", 1) != sizeof ("abcd\0efg"))
210 FAIL ();
211 if (__builtin_object_size (&"abcd\0efg", 1) != sizeof ("abcd\0efg"))
212 FAIL ();
213 if (__builtin_object_size (&"abcd\0efg"[0], 1) != sizeof ("abcd\0efg"))
214 FAIL ();
215 if (__builtin_object_size (&"abcd\0efg"[4], 1) != sizeof ("abcd\0efg") - 4)
216 FAIL ();
217 if (__builtin_object_size ("abcd\0efg" + 5, 1) != sizeof ("abcd\0efg") - 5)
218 FAIL ();
219 if (__builtin_object_size (L"abcdefg", 1) != sizeof (L"abcdefg"))
220 FAIL ();
221 r = (char *) L"abcd\0efg";
222 if (__builtin_object_size (r + 2, 1) != sizeof (L"abcd\0efg") - 2)
223 FAIL ();
224 }
225
226 size_t l1 = 1;
227
228 void
229 __attribute__ ((noinline))
230 test2 (void)
231 {
232 struct B { char buf1[10]; char buf2[10]; } a;
233 char *r, buf3[20];
234 int i;
235 #ifdef __builtin_object_size
236 size_t dyn_res;
237 #endif
238
239 if (sizeof (a) != 20)
240 return;
241
242 r = buf3;
243 for (i = 0; i < 4; ++i)
244 {
245 if (i == l1 - 1)
246 r = &a.buf1[1];
247 else if (i == l1)
248 r = &a.buf2[7];
249 else if (i == l1 + 1)
250 r = &buf3[5];
251 else if (i == l1 + 2)
252 r = &a.buf1[9];
253 }
254 #ifdef __builtin_object_size
255 dyn_res = sizeof (buf3);
256
257 for (i = 0; i < 4; ++i)
258 {
259 if (i == l1 - 1)
260 dyn_res = sizeof (a.buf1) - 1;
261 else if (i == l1)
262 dyn_res = sizeof (a.buf2) - 7;
263 else if (i == l1 + 1)
264 dyn_res = sizeof (buf3) - 5;
265 else if (i == l1 + 2)
266 dyn_res = sizeof (a.buf1) - 9;
267 }
268 if (__builtin_object_size (r, 1) != dyn_res)
269 FAIL ();
270 #else
271 if (__builtin_object_size (r, 1) != sizeof (buf3))
272 FAIL ();
273 #endif
274 r = &buf3[20];
275 for (i = 0; i < 4; ++i)
276 {
277 if (i == l1 - 1)
278 r = &a.buf1[7];
279 else if (i == l1)
280 r = &a.buf2[7];
281 else if (i == l1 + 1)
282 r = &buf3[5];
283 else if (i == l1 + 2)
284 r = &a.buf1[9];
285 }
286 #ifdef __builtin_object_size
287 dyn_res = sizeof (buf3) - 20;
288
289 for (i = 0; i < 4; ++i)
290 {
291 if (i == l1 - 1)
292 dyn_res = sizeof (a.buf1) - 7;
293 else if (i == l1)
294 dyn_res = sizeof (a.buf2) - 7;
295 else if (i == l1 + 1)
296 dyn_res = sizeof (buf3) - 5;
297 else if (i == l1 + 2)
298 dyn_res = sizeof (a.buf1) - 9;
299 }
300 if (__builtin_object_size (r, 1) != dyn_res)
301 FAIL ();
302 #else
303 if (__builtin_object_size (r, 1) != sizeof (buf3) - 5)
304 FAIL ();
305 #endif
306 r += 8;
307 #ifdef __builtin_object_size
308 if (dyn_res >= 8)
309 {
310 dyn_res -= 8;
311 if (__builtin_object_size (r, 1) != dyn_res)
312 FAIL ();
313
314 if (dyn_res >= 6)
315 {
316 if (__builtin_object_size (r + 6, 1) != dyn_res - 6)
317 FAIL ();
318 }
319 else if (__builtin_object_size (r + 6, 1) != 0)
320 FAIL ();
321 }
322 else if (__builtin_object_size (r, 1) != 0)
323 FAIL ();
324 #else
325 if (__builtin_object_size (r, 1) != sizeof (buf3) - 13)
326 FAIL ();
327 if (__builtin_object_size (r + 6, 1) != sizeof (buf3) - 19)
328 FAIL ();
329 #endif
330 }
331
332 void
333 __attribute__ ((noinline))
334 test3 (void)
335 {
336 char buf4[10];
337 struct B { struct A a[2]; struct A b; char c[4]; char d; double e;
338 _Complex double f; } x;
339 double y;
340 _Complex double z;
341 double *dp;
342
343 if (__builtin_object_size (buf4, 1) != sizeof (buf4))
344 FAIL ();
345 if (__builtin_object_size (&buf4, 1) != sizeof (buf4))
346 FAIL ();
347 if (__builtin_object_size (&buf4[0], 1) != sizeof (buf4))
348 FAIL ();
349 if (__builtin_object_size (&buf4[1], 1) != sizeof (buf4) - 1)
350 FAIL ();
351 if (__builtin_object_size (&x, 1) != sizeof (x))
352 FAIL ();
353 if (__builtin_object_size (&x.a, 1) != sizeof (x.a))
354 FAIL ();
355 if (__builtin_object_size (&x.a[0], 1) != sizeof (x.a))
356 FAIL ();
357 if (__builtin_object_size (&x.a[0].a, 1) != sizeof (x.a[0].a))
358 FAIL ();
359 if (__builtin_object_size (&x.a[0].a[0], 1) != sizeof (x.a[0].a))
360 FAIL ();
361 if (__builtin_object_size (&x.a[0].a[3], 1) != sizeof (x.a[0].a) - 3)
362 FAIL ();
363 if (__builtin_object_size (&x.a[0].b, 1) != sizeof (x.a[0].b))
364 FAIL ();
365 if (__builtin_object_size (&x.a[1].c, 1) != sizeof (x.a[1].c))
366 FAIL ();
367 if (__builtin_object_size (&x.a[1].c[0], 1) != sizeof (x.a[1].c))
368 FAIL ();
369 if (__builtin_object_size (&x.a[1].c[3], 1) != sizeof (x.a[1].c) - 3)
370 FAIL ();
371 if (__builtin_object_size (&x.b, 1) != sizeof (x.b))
372 FAIL ();
373 if (__builtin_object_size (&x.b.a, 1) != sizeof (x.b.a))
374 FAIL ();
375 if (__builtin_object_size (&x.b.a[0], 1) != sizeof (x.b.a))
376 FAIL ();
377 if (__builtin_object_size (&x.b.a[3], 1) != sizeof (x.b.a) - 3)
378 FAIL ();
379 if (__builtin_object_size (&x.b.b, 1) != sizeof (x.b.b))
380 FAIL ();
381 if (__builtin_object_size (&x.b.c, 1) != sizeof (x.b.c))
382 FAIL ();
383 if (__builtin_object_size (&x.b.c[0], 1) != sizeof (x.b.c))
384 FAIL ();
385 if (__builtin_object_size (&x.b.c[3], 1) != sizeof (x.b.c) - 3)
386 FAIL ();
387 if (__builtin_object_size (&x.c, 1) != sizeof (x.c))
388 FAIL ();
389 if (__builtin_object_size (&x.c[0], 1) != sizeof (x.c))
390 FAIL ();
391 if (__builtin_object_size (&x.c[1], 1) != sizeof (x.c) - 1)
392 FAIL ();
393 if (__builtin_object_size (&x.d, 1) != sizeof (x.d))
394 FAIL ();
395 if (__builtin_object_size (&x.e, 1) != sizeof (x.e))
396 FAIL ();
397 if (__builtin_object_size (&x.f, 1) != sizeof (x.f))
398 FAIL ();
399 dp = &__real__ x.f;
400 if (__builtin_object_size (dp, 1) != sizeof (x.f) / 2)
401 FAIL ();
402 dp = &__imag__ x.f;
403 if (__builtin_object_size (dp, 1) != sizeof (x.f) / 2)
404 FAIL ();
405 dp = &y;
406 if (__builtin_object_size (dp, 1) != sizeof (y))
407 FAIL ();
408 if (__builtin_object_size (&z, 1) != sizeof (z))
409 FAIL ();
410 dp = &__real__ z;
411 if (__builtin_object_size (dp, 1) != sizeof (z) / 2)
412 FAIL ();
413 dp = &__imag__ z;
414 if (__builtin_object_size (dp, 1) != sizeof (z) / 2)
415 FAIL ();
416 }
417
418 struct S { unsigned int a; };
419
420 char *
421 __attribute__ ((noinline))
422 test4 (char *x, int y)
423 {
424 register int i;
425 struct A *p;
426
427 for (i = 0; i < y; i++)
428 {
429 p = (struct A *) x;
430 x = (char *) &p[1];
431 if (__builtin_object_size (p, 1) != (size_t) -1)
432 FAIL ();
433 }
434 return x;
435 }
436
437 void
438 __attribute__ ((noinline))
439 test5 (size_t x)
440 {
441 struct T { char buf[64]; char buf2[64]; } t;
442 char *p = &t.buf[8];
443 size_t i;
444
445 for (i = 0; i < x; ++i)
446 p = p + 4;
447 #ifdef __builtin_object_size
448 if (__builtin_object_size (p, 1) != sizeof (t.buf) - 8 - 4 * x)
449 FAIL ();
450 #else
451 if (__builtin_object_size (p, 1) != sizeof (t.buf) - 8)
452 FAIL ();
453 #endif
454 memset (p, ' ', sizeof (t.buf) - 8 - 4 * 4);
455 }
456
457 void
458 __attribute__ ((noinline))
459 test6 (void)
460 {
461 char buf[64];
462 struct T { char buf[64]; char buf2[64]; } t;
463 char *p = &buf[64], *q = &t.buf[64];
464
465 if (__builtin_object_size (p + 64, 1) != 0)
466 FAIL ();
467 if (__builtin_object_size (q + 0, 1) != 0)
468 FAIL ();
469 if (__builtin_object_size (q + 64, 1) != 0)
470 FAIL ();
471 }
472
473 void
474 __attribute__ ((noinline))
475 test7 (void)
476 {
477 struct T { char buf[10]; char buf2[10]; } t;
478 char *p = &t.buf2[-4];
479 char *q = &t.buf2[0];
480 if (__builtin_object_size (p, 1) != 0)
481 FAIL ();
482 if (__builtin_object_size (q, 1) != sizeof (t.buf2))
483 FAIL ();
484 q = &t.buf[10];
485 if (__builtin_object_size (q, 1) != 0)
486 FAIL ();
487 q = &t.buf[11];
488 if (__builtin_object_size (q, 1) != 0)
489 FAIL ();
490 p = &t.buf[-4];
491 if (__builtin_object_size (p, 1) != 0)
492 FAIL ();
493 }
494
495 void
496 __attribute__ ((noinline))
497 test8 (unsigned cond)
498 {
499 char *buf2 = malloc (10);
500 char *p;
501
502 if (cond)
503 p = &buf2[8];
504 else
505 p = &buf2[4];
506
507 #ifdef __builtin_object_size
508 if (__builtin_object_size (&p[-4], 1) != (cond ? 6 : 10))
509 FAIL ();
510 #else
511 if (__builtin_object_size (&p[-4], 1) != 10)
512 FAIL ();
513 #endif
514
515 for (unsigned i = cond; i > 0; i--)
516 p--;
517
518 #ifdef __builtin_object_size
519 if (__builtin_object_size (p, 1) != ((cond ? 2 : 6) + cond))
520 FAIL ();
521 #else
522 if (__builtin_object_size (p, 1) != 10)
523 FAIL ();
524 #endif
525
526 p = &y.c[8];
527 for (unsigned i = cond; i > 0; i--)
528 p--;
529
530 #ifdef __builtin_object_size
531 if (__builtin_object_size (p, 1) != sizeof (y.c) - 8 + cond)
532 FAIL ();
533 #else
534 if (__builtin_object_size (p, 1) != sizeof (y.c))
535 FAIL ();
536 #endif
537 }
538
539 /* Tests for strdup/strndup. */
540 size_t
541 __attribute__ ((noinline))
542 test9 (void)
543 {
544 const char *ptr = "abcdefghijklmnopqrstuvwxyz";
545 char *res = strndup (ptr, 21);
546 if (__builtin_object_size (res, 1) != 22)
547 FAIL ();
548
549 free (res);
550
551 res = strndup (ptr, 32);
552 if (__builtin_object_size (res, 1) != 27)
553 FAIL ();
554
555 free (res);
556
557 res = strdup (ptr);
558 if (__builtin_object_size (res, 1) != 27)
559 FAIL ();
560
561 free (res);
562
563 char *ptr2 = malloc (64);
564 strcpy (ptr2, ptr);
565
566 res = strndup (ptr2, 21);
567 if (__builtin_object_size (res, 1) != 22)
568 FAIL ();
569
570 free (res);
571
572 res = strndup (ptr2, 32);
573 if (__builtin_object_size (res, 1) != 33)
574 FAIL ();
575
576 free (res);
577
578 res = strndup (ptr2, 128);
579 if (__builtin_object_size (res, 1) != 64)
580 FAIL ();
581
582 free (res);
583
584 res = strdup (ptr2);
585 #ifdef __builtin_object_size
586 if (__builtin_object_size (res, 1) != 27)
587 #else
588 if (__builtin_object_size (res, 1) != (size_t) -1)
589 #endif
590 FAIL ();
591
592 free (res);
593 free (ptr2);
594
595 ptr = "abcd\0efghijklmnopqrstuvwxyz";
596 res = strdup (ptr);
597 if (__builtin_object_size (res, 1) != 5)
598 FAIL ();
599 free (res);
600
601 res = strndup (ptr, 24);
602 if (__builtin_object_size (res, 1) != 5)
603 FAIL ();
604 free (res);
605
606 res = strndup (ptr, 2);
607 if (__builtin_object_size (res, 1) != 3)
608 FAIL ();
609 free (res);
610
611 res = strdup (&ptr[4]);
612 if (__builtin_object_size (res, 1) != 1)
613 FAIL ();
614 free (res);
615
616 res = strndup (&ptr[4], 4);
617 if (__builtin_object_size (res, 1) != 1)
618 FAIL ();
619 free (res);
620
621 res = strndup (&ptr[4], 1);
622 if (__builtin_object_size (res, 1) != 1)
623 FAIL ();
624 free (res);
625 }
626
627 int
628 main (void)
629 {
630 struct S s[10];
631 __asm ("" : "=r" (l1) : "0" (l1));
632 test1 (main, 6);
633 test2 ();
634 test3 ();
635 test4 ((char *) s, 10);
636 test5 (4);
637 test6 ();
638 test7 ();
639 test8 (1);
640 test9 ();
641 DONE ();
642 }