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

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