gcc/testsuite/gcc.dg/builtin-object-size-3.c

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