gcc/testsuite/gcc.dg/tree-ssa/builtin-sprintf.c

   1 /* Test to verify that the return value of calls to __builtin_sprintf
   2    that produce a known number of bytes on output is available for
   3    constant folding.  With optimization enabled the test will fail to
   4    link if any of the assertions fails.  Without optimization the test
   5    aborts at runtime if any of the assertions fails.  */
   6 /* { dg-do run } */
   7 /* { dg-additional-options "-O2 -Wall -Wno-pedantic -fprintf-return-value" } */
   8
   9 #ifndef LINE
  10 #  define LINE   0
  11 #endif
  12
  13 #if __STDC_VERSION__ < 199901L
  14 #  define __func__   __FUNCTION__
  15 #endif
  16
  17 typedef __SIZE_TYPE__ size_t;
  18
  19 unsigned ntests;
  20 unsigned nfails;
  21
  22 void __attribute__ ((noclone, noinline))
  23 checkv (const char *func, int line, int res, int min, int max,
  24         char *dst, const char *fmt, __builtin_va_list va)
  25 {
  26   int n = __builtin_vsprintf (dst, fmt, va);
  27   int len = __builtin_strlen (dst);
  28
  29   ++ntests;
  30
  31   int fail = 0;
  32   if (n != res)
  33     {
  34       __builtin_printf ("FAIL: %s:%i: \"%s\" expected result for \"%s\" "
  35                         "doesn't match function call return value: ",
  36                         func, line, fmt, dst);
  37       if (min == max)
  38         __builtin_printf ("%i != %i\n", n, min);
  39       else
  40         __builtin_printf ("%i not in [%i, %i]\n", n, min, max);
  41
  42       fail = 1;
  43     }
  44   else
  45     {
  46       if (len < min || max < len)
  47         {
  48           __builtin_printf ("FAIL: %s:%i: \"%s\" expected result for \"%s\" "
  49                             "doesn't match output length: ",
  50                             func, line, fmt, dst);
  51
  52           if (min == max)
  53             __builtin_printf ("%i != %i\n", len, min);
  54           else
  55             __builtin_printf ("%i not in [%i, %i]\n", len, min, max);
  56
  57           fail = 1;
  58         }
  59       else
  60         __builtin_printf ("PASS: %s:%i: \"%s\" result %i: \"%s\"\n",
  61                           func, line, fmt, n, dst);
  62     }
  63
  64   if (fail)
  65     ++nfails;
  66 }
  67
  68 void __attribute__ ((noclone, noinline))
  69 check (const char *func, int line, int res, int min, int max,
  70        char *dst, const char *fmt, ...)
  71 {
  72   __builtin_va_list va;
  73   __builtin_va_start (va, fmt);
  74   checkv (func, line, res, min, max, dst, fmt, va);
  75   __builtin_va_end (va);
  76 }
  77
  78 char buffer[256];
  79 char* volatile dst = buffer;
  80 char* ptr = buffer;
  81
  82 #define concat(a, b)   a ## b
  83 #define CAT(a, b)      concat (a, b)
  84
  85 #if __OPTIMIZE__
  86 /* With optimization references to the following undefined symbol which
  87    is unique for each test case are expected to be eliminated.  */
  88 #  define TEST_FAILURE(line, ignore1, ignore2, ignore3)                 \
  89   do {                                                                  \
  90     extern void CAT (failure_on_line_, line)(void);                     \
  91     CAT (failure_on_line_, line)();                                     \
  92   } while (0)
  93 #else
  94 /* The test is run by DejaGnu with optimization enabled.  When it's run
  95    with it disabled (i.e., at -O0) each test case is verified at runtime
  96    and the test aborts just before exiting if any of them failed.  */
  97 #  define TEST_FAILURE(line, result, min, max)                          \
  98   if (min == max)                                                       \
  99     __builtin_printf ("FAIL: %s:%i: expected %i, got %i\n",             \
 100                       __func__, line, min, result);                     \
 101   else                                                                  \
 102     __builtin_printf ("FAIL: %s:%i: expected range [%i, %i], got %i\n", \
 103                       __func__, line, min, max, result);
 104 #endif
 105
 106 /* Verify that the result is exactly equal to RES.  */
 107 #define EQL(expect, size, fmt, ...)                                     \
 108   if (!LINE || LINE == __LINE__)                                        \
 109     do {                                                                \
 110       char *buf = (size) < 0 ? ptr : buffer + sizeof buffer - (size);   \
 111       int result = __builtin_sprintf (buf, fmt, __VA_ARGS__);           \
 112       if (result != expect)                                             \
 113         {                                                               \
 114           TEST_FAILURE (__LINE__, expect, expect, result);              \
 115         }                                                               \
 116       check (__func__, __LINE__, result, expect, expect, dst, fmt,      \
 117              __VA_ARGS__);                                              \
 118     } while (0)
 119
 120 /* Verify that the result is in the range [MIN, MAX].  */
 121 #define RNG(min, max, size, fmt, ...)                                   \
 122   if (!LINE || LINE == __LINE__)                                        \
 123     do {                                                                \
 124       char *buf = (size) < 0 ? ptr : buffer + sizeof buffer - (size);   \
 125       int result = __builtin_sprintf (buf, fmt, __VA_ARGS__);           \
 126       if (result < min || max < result)                                 \
 127         {                                                               \
 128           TEST_FAILURE (__LINE__, min, max, result);                    \
 129         }                                                               \
 130       check (__func__, __LINE__, result, min, max, dst, fmt,            \
 131              __VA_ARGS__);                                              \
 132     } while (0)
 133
 134 static void __attribute__ ((noinline, noclone))
 135 test_c (char c)
 136 {
 137   EQL (1,  2, "%c",       c);
 138   EQL (1, -1, "%c",       c);
 139   EQL (1,  2, "%1c",      c);
 140   EQL (1, -1, "%1c",      c);
 141   EQL (1,  2, "%*c",      1, c);
 142   EQL (1, -1, "%*c",      1, c);
 143   EQL (2,  3, "%c%c",     '1', '2');
 144   EQL (2, -1, "%c%c",     '1', '2');
 145   EQL (3,  4, "%3c",      c);
 146   EQL (3, -1, "%3c",      c);
 147   EQL (3,  4, "%*c",      3, c);
 148   EQL (3, -1, "%*c",      3, c);
 149
 150   EQL (3,  4, "%*c%*c",     2,  c,  1,  c);
 151   EQL (3,  4, "%*c%*c",     1,  c,  2,  c);
 152   EQL (3,  4, "%c%c%c",        '1',    '2',    '3');
 153   EQL (3,  4, "%*c%c%c",    1, '1',    '2',    '3');
 154   EQL (3,  4, "%*c%*c%c",   1, '1', 1, '2',    '3');
 155   EQL (3,  4, "%*c%*c%*c",  1, '1', 1, '2', 1, '3');
 156
 157   EQL (3, -1, "%*c%*c",     2,  c,  1,  c);
 158   EQL (3, -1, "%*c%*c",     1,  c,  2,  c);
 159   EQL (3, -1, "%c%c%c",        '1',    '2',    '3');
 160   EQL (3, -1, "%*c%c%c",    1, '1',    '2',    '3');
 161   EQL (3, -1, "%*c%*c%c",   1, '1', 1, '2',    '3');
 162   EQL (3, -1, "%*c%*c%*c",  1, '1', 1, '2', 1, '3');
 163
 164   EQL (4,  5, "%c%c %c",  '1', '2', '3');
 165   EQL (5,  6, "%c %c %c", '1', '2', '3');
 166   EQL (5,  6, "%c %c %c",  c,   c,   c);
 167 }
 168
 169 /* Generate a pseudo-random value in the specified range.  The return
 170    value must be unsigned char to work around limitations in the GCC
 171    range information.  Similarly for the declaration of rand() whose
 172    correct return value should be int, but that also prevents the range
 173    information from making it to the printf pass.  */
 174
 175 unsigned char uchar_range (unsigned min, unsigned max)
 176 {
 177   extern unsigned rand (void);
 178
 179   unsigned x;
 180   x = rand ();
 181
 182   if (x < min)
 183     x = min;
 184   else if (max < x)
 185     x = max;
 186
 187   return x;
 188 }
 189
 190 static void __attribute__ ((noinline, noclone))
 191 test_d_i (int i, long li)
 192 {
 193   /*    +-------------------------- expected return value */
 194   /*    |   +---------------------- destination size */
 195   /*    |   |  +------------------- format string */
 196   /*    |   |  |                +-- variable argument(s) */
 197   /*    |   |  |                | */
 198   /*    V   V  V                V */
 199   EQL ( 1,  2, "%d",            0);
 200   EQL ( 2,  3, "%d%d",          0,   1);
 201   EQL ( 3,  4, "%d%d",          9,  10);
 202   EQL ( 4,  5, "%d%d",         11,  12);
 203   EQL ( 5,  6, "%d:%d",        12,  34);
 204   EQL ( 5,  6, "%d",           12345);
 205   EQL ( 6,  7, "%d",          -12345);
 206   EQL (15, 16, "%d:%d:%d:%d", 123, 124, 125, 126);
 207
 208   EQL ( 1,  2, "%i", uchar_range (0, 9));
 209   EQL ( 1, -1, "%i", uchar_range (0, 9));
 210
 211   /* The range information available to passes other than the Value
 212      Range Propoagation pass itself is so bad that the following two
 213      tests fail (the range seen in the test below is [0, 99] rather
 214      than [10, 99].
 215   EQL ( 2,  3, "%i", uchar_range (10, 99));
 216   EQL ( 3,  4, "%i", uchar_range (100, 199));
 217   */
 218
 219   /* Verify that the width allows the return value in the following
 220      calls can be folded despite the unknown value of the argument.  */
 221 #if __SIZEOF_INT__ == 2
 222   EQL ( 6,  7, "%6d",      i);
 223   EQL ( 6,  7, "%+6d",     i);
 224   EQL ( 6,  7, "%-6d",     i);
 225   EQL ( 6,  7, "%06d",     i);
 226 #elif __SIZEOF_INT__ == 4
 227   EQL (11, 12, "%11d",     i);
 228   EQL (11, 12, "%+11d",    i);
 229   EQL (11, 12, "%-11d",    i);
 230   EQL (11, 12, "%011d",    i);
 231 #elif __SIZEOF_INT__ == 8
 232   EQL (20, 21, "%20d",     i);
 233   EQL (20, 21, "%+20d",    i);
 234   EQL (20, 21, "%-29d",    i);
 235   EQL (20, 21, "%020d",    i);
 236 #endif
 237
 238 #if __SIZEOF_LONG__ == 2
 239   EQL ( 6,  7, "%6ld",      li);
 240   EQL ( 6,  7, "%+6ld",     li);
 241   EQL ( 6,  7, "%-6ld",     li);
 242   EQL ( 6,  7, "%06ld",     li);
 243 #elif __SIZEOF_LONG__ == 4
 244   EQL (11, 12, "%11ld",     li);
 245   EQL (11, 12, "%+11ld",    li);
 246   EQL (11, 12, "%-11ld",    li);
 247   EQL (11, 12, "%011ld",    li);
 248 #elif __SIZEOF_LONG__ == 8
 249   EQL (20, 21, "%20ld",     li);
 250   EQL (20, 21, "%+20ld",    li);
 251   EQL (20, 21, "%-20ld",    li);
 252   EQL (20, 21, "%020ld",    li);
 253 #endif
 254
 255   /* Verify that the output of a directive with an unknown argument
 256      is correctly determined at compile time to be in the expected
 257      range.  */
 258
 259   /*    +---------------------------- expected minimum return value */
 260   /*    |   +------------------------ expected maximum return value */
 261   /*    |   |   +-------------------- destination size */
 262   /*    |   |   |  +----------------- format string */
 263   /*    |   |   |  |           +----- variable argument(s) */
 264   /*    |   |   |  |           | */
 265   /*    V   V   V  V           V */
 266   RNG ( 1,  4,  5, "%hhi",     i);
 267   RNG ( 1,  3,  4, "%hhu",     i);
 268
 269 #if __SIZEOF_SHORT__ == 2
 270   RNG ( 1,  6,  7, "%hi",      i);
 271   RNG ( 1,  5,  6, "%hu",      i);
 272 #elif __SIZEOF_SHORT__ == 4
 273   RNG ( 1, 11, 12, "%hi",      i);
 274   RNG ( 1, 10, 11, "%hu",      i);
 275 #endif
 276
 277 #if __SIZEOF_INT__ == 2
 278   RNG ( 1,  6,  7, "%i",       i);
 279   RNG ( 1,  5,  6, "%u",       i);
 280 #elif __SIZEOF_INT__ == 4
 281   RNG ( 1, 11, 12, "%i",       i);
 282   RNG ( 1, 10, 11, "%u",       i);
 283 #elif __SIZEOF_INT__ == 8
 284   RNG ( 1, 20, 21, "%i",       i);
 285   RNG ( 1, 19, 20, "%u",       i);
 286 #endif
 287
 288 #if __SIZEOF_LONG__ == 4
 289   RNG ( 1, 11, 12, "%li",      li);
 290   RNG ( 1, 10, 11, "%lu",      li);
 291 #elif __SIZEOF_LONG__ == 8
 292   RNG ( 1, 20, 21, "%li",      li);
 293   RNG ( 1, 19, 20, "%lu",      li);
 294 #endif
 295 }
 296
 297 static void __attribute__ ((noinline, noclone))
 298 test_x (unsigned char uc, unsigned short us, unsigned ui)
 299 {
 300   EQL ( 1,  2, "%hhx",          0);
 301   EQL ( 2,  3, "%2hhx",         0);
 302   EQL ( 2,  3, "%02hhx",        0);
 303   EQL ( 2,  3, "%#02hhx",       0);
 304
 305   EQL ( 1,  2, "%hhx",          1);
 306   EQL ( 2,  3, "%2hhx",         1);
 307   EQL ( 2,  3, "%02hhx",        1);
 308   EQL ( 3,  4, "%#02hhx",       1);
 309
 310   EQL ( 2,  3, "%2hhx",        uc);
 311   EQL ( 2,  3, "%02hhx",       uc);
 312   EQL ( 5,  6, "%#05hhx",      uc);
 313
 314   EQL ( 2,  3, "%2hhx",        us);
 315   EQL ( 2,  3, "%02hhx",       us);
 316   EQL ( 5,  6, "%#05hhx",      us);
 317
 318   EQL ( 2,  3, "%2hhx",        ui);
 319   EQL ( 2,  3, "%02hhx",       ui);
 320   EQL ( 5,  6, "%#05hhx",      ui);
 321
 322   EQL ( 1,  2, "%x",            0);
 323   EQL ( 1,  2, "%#x",           0);
 324   EQL ( 1,  2, "%#0x",          0);
 325   EQL ( 1,  2, "%x",            1);
 326   EQL ( 1,  2, "%x",          0xf);
 327   EQL ( 2,  3, "%x",         0x10);
 328   EQL ( 2,  3, "%x",         0xff);
 329   EQL ( 3,  4, "%x",        0x100);
 330
 331   EQL (11, 12, "%02x:%02x:%02x:%02x",         0xde, 0xad, 0xbe, 0xef);
 332
 333   /* The following would be optimized if the range information of
 334   the variable's type was made available.  Alas, it's lost due
 335   to the promotion of the actual argument (unsined char) to
 336   the type of the "formal" argument (int in the case of the
 337   ellipsis).
 338   EQL (11, 12, "%02x:%02x:%02x:%02x",   uc,   uc,   uc,   uc);
 339   */
 340   EQL (11, 12, "%02hhx:%02hhx:%02hhx:%02hhx",   uc,   uc,   uc,   uc);
 341
 342 #if __SIZEOF_SHORT__ == 2
 343   EQL ( 4,  5, "%04hx",                   us);
 344   EQL ( 9, 10, "%04hx:%04hx",             us, us);
 345   EQL (14, 15, "%04hx:%04hx:%04hx",       us, us, us);
 346   EQL (19, 20, "%04hx:%04hx:%04hx:%04hx", us, us, us, us);
 347 #endif
 348
 349 #if __SIZEOF_INT__ == 2
 350   EQL ( 4,  5, "%04x", ui);
 351   EQL ( 6,  7, "%#06x", ui);
 352 #elif __SIZEOF_INT__ == 4
 353   EQL ( 8,  9, "%08x", ui);
 354   EQL (10, 10 + 1, "%#010x", ui);
 355 #elif __SIZEOF_INT__ == 8
 356   EQL (16, 17, "%016x", ui);
 357   EQL (18, 19, "%#018x",  ui);
 358 #endif
 359 }
 360
 361 static void __attribute__ ((noinline, noclone))
 362 test_a_double (void)
 363 {
 364   EQL ( 6,  7, "%a",   0.0);        /* 0x0p+0 */
 365   EQL ( 6,  7, "%a",   1.0);        /* 0x8p-3 */
 366   EQL ( 6,  7, "%a",   2.0);        /* 0x8p-2 */
 367
 368   EQL ( 8,  9, "%.1a", 3.0);        /* 0xc.0p-2 */
 369   EQL ( 9, 10, "%.2a", 4.0);        /* 0xa.00p-1 */
 370 }
 371
 372 static void __attribute__ ((noinline, noclone))
 373 test_a_long_double (void)
 374 {
 375   EQL ( 6,  7, "%La",   0.0L);      /* 0x0p+0 */
 376   EQL ( 6,  7, "%La",   1.0L);      /* 0x8p-3 */
 377   EQL ( 6,  7, "%La",   2.0L);      /* 0x8p-2 */
 378
 379   EQL ( 8,  9, "%.1La", 3.0L);      /* 0xc.0p-2 */
 380   EQL ( 9, 10, "%.2La", 4.0L);      /* 0xa.00p-1 */
 381 }
 382
 383 static void __attribute__ ((noinline, noclone))
 384 test_e_double (void)
 385 {
 386   EQL (12, 13, "%e",  1.0e0);
 387   EQL (13, 14, "%e", -1.0e0);
 388   EQL (12, 13, "%e",  1.0e+1);
 389   EQL (13, 14, "%e", -1.0e+1);
 390   EQL (12, 13, "%e",  1.0e+12);
 391   EQL (13, 14, "%e", -1.0e+12);
 392   EQL (13, 14, "%e",  1.0e+123);
 393   EQL (14, 15, "%e", -1.0e+123);
 394
 395   EQL (12, 13, "%e",  9.999e+99);
 396   EQL (12, 13, "%e",  9.9999e+99);
 397   EQL (12, 13, "%e",  9.99999e+99);
 398
 399   /* The actual output of the following directive depends on the rounding
 400      mode.  */
 401   /* EQL (12, "%e",  9.9999994e+99); */
 402
 403   EQL (12, 13, "%e",  1.0e-1);
 404   EQL (12, 13, "%e",  1.0e-12);
 405   EQL (13, 14, "%e",  1.0e-123);
 406 }
 407
 408 static void __attribute__ ((noinline, noclone))
 409 test_e_long_double (void)
 410 {
 411   EQL (12, 13, "%Le",  1.0e0L);
 412   EQL (13, 14, "%Le", -1.0e0L);
 413   EQL (12, 13, "%Le",  1.0e+1L);
 414   EQL (13, 14, "%Le", -1.0e+1L);
 415   EQL (12, 13, "%Le",  1.0e+12L);
 416   EQL (13, 14, "%Le", -1.0e+12L);
 417   EQL (13, 14, "%Le",  1.0e+123L);
 418   EQL (14, 15, "%Le", -1.0e+123L);
 419
 420   EQL (12, 13, "%Le",  9.999e+99L);
 421   EQL (12, 13, "%Le",  9.9999e+99L);
 422   EQL (12, 13, "%Le",  9.99999e+99L);
 423
 424 #if __DBL_DIG__ < __LDBL_DIG__
 425   EQL (12, 13, "%Le",  9.999999e+99L);
 426 #else
 427   RNG (12, 13, 14, "%Le",  9.999999e+99L);
 428 #endif
 429
 430   /* The actual output of the following directive depends on the rounding
 431      mode.  */
 432   /* EQL (12, "%Le",  9.9999994e+99L); */
 433
 434   EQL (12, 13, "%Le",  1.0e-1L);
 435   EQL (12, 13, "%Le",  1.0e-12L);
 436   EQL (13, 14, "%Le",  1.0e-123L);
 437
 438   EQL ( 6,  7, "%.0Le",   1.0e-111L);
 439   EQL ( 8,  9, "%.1Le",   1.0e-111L);
 440   EQL (19, 20, "%.12Le",  1.0e-112L);
 441   EQL (20, 21, "%.13Le",  1.0e-113L);
 442 }
 443
 444 static void __attribute__ ((noinline, noclone))
 445 test_f_double (void)
 446 {
 447   EQL (  8,   9, "%f", 0.0e0);
 448   EQL (  8,   9, "%f", 0.1e0);
 449   EQL (  8,   9, "%f", 0.12e0);
 450   EQL (  8,   9, "%f", 0.123e0);
 451   EQL (  8,   9, "%f", 0.1234e0);
 452   EQL (  8,   9, "%f", 0.12345e0);
 453   EQL (  8,   9, "%f", 0.123456e0);
 454   EQL (  8,   9, "%f", 1.234567e0);
 455
 456   EQL (  9,  10, "%f", 1.0e+1);
 457   EQL ( 20,  21, "%f", 1.0e+12);
 458   EQL (130, 131, "%f", 1.0e+123);
 459
 460   EQL (  8,   9, "%f", 1.0e-1);
 461   EQL (  8,   9, "%f", 1.0e-12);
 462   EQL (  8,   9, "%f", 1.0e-123);
 463 }
 464
 465 static void __attribute__ ((noinline, noclone))
 466 test_f_long_double (void)
 467 {
 468   EQL (  8,   9, "%Lf", 0.0e0L);
 469   EQL (  8,   9, "%Lf", 0.1e0L);
 470   EQL (  8,   9, "%Lf", 0.12e0L);
 471   EQL (  8,   9, "%Lf", 0.123e0L);
 472   EQL (  8,   9, "%Lf", 0.1234e0L);
 473   EQL (  8,   9, "%Lf", 0.12345e0L);
 474   EQL (  8,   9, "%Lf", 0.123456e0L);
 475   EQL (  8,   9, "%Lf", 1.234567e0L);
 476
 477   EQL (  9,  10, "%Lf", 1.0e+1L);
 478   EQL ( 20,  21, "%Lf", 1.0e+12L);
 479   EQL (130, 131, "%Lf", 1.0e+123L);
 480
 481   EQL (  8,   9, "%Lf", 1.0e-1L);
 482   EQL (  8,   9, "%Lf", 1.0e-12L);
 483   EQL (  8,   9, "%Lf", 1.0e-123L);
 484 }
 485
 486 static void __attribute__ ((noinline, noclone))
 487 test_s (int i)
 488 {
 489   EQL (  0,   1, "%s", "");
 490   EQL (  0,   1, "%s", "\0");
 491   EQL (  1,   2, "%1s", "");
 492   EQL (  1,   2, "%s", "1");
 493   EQL (  2,   3, "%2s", "");
 494   EQL (  2,   3, "%s", "12");
 495   EQL (  2,   3, "%s%s", "12", "");
 496   EQL (  2,   3, "%s%s", "", "12");
 497   EQL (  2,   3, "%s%s", "1", "2");
 498   EQL (  3,   4, "%3s", "");
 499   EQL (  3,   4, "%3s", "1");
 500   EQL (  3,   4, "%3s", "12");
 501   EQL (  3,   4, "%3s", "123");
 502   EQL (  3,   4, "%3.3s", "1");
 503   EQL (  3,   4, "%3.3s", "12");
 504   EQL (  3,   4, "%3.3s", "123");
 505   EQL (  3,   4, "%3.3s", "1234");
 506   EQL (  3,   4, "%3.3s", "12345");
 507   EQL (  3,   4, "%s %s", "1", "2");
 508   EQL (  4,   5, "%s %s", "12", "3");
 509   EQL (  5,   6, "%s %s", "12", "34");
 510   EQL (  5,   6, "[%s %s]", "1", "2");
 511   EQL (  6,   7, "[%s %s]", "12", "3");
 512   EQL (  7,   8, "[%s %s]", "12", "34");
 513
 514   /* Verify the result of a conditional expression involving string
 515      literals is in the expected range of their lengths.  */
 516   RNG (  0,   3,   4, "%-s", i ? ""    : "123");
 517   RNG (  1,   4,   5, "%-s", i ? "1"   : "1234");
 518   RNG (  2,   5,   6, "%-s", i ? "12"  : "12345");
 519   RNG (  3,   6,   7, "%-s", i ? "123" : "123456");
 520 }
 521
 522 int main (void)
 523 {
 524   test_c ('?');
 525   test_d_i (0xdeadbeef, 0xdeadbeefL);
 526   test_x ('?', 0xdead, 0xdeadbeef);
 527
 528   test_a_double ();
 529   test_e_double ();
 530   test_f_double ();
 531
 532   test_a_long_double ();
 533   test_e_long_double ();
 534   test_f_long_double ();
 535
 536   test_s (0);
 537
 538   if (nfails)
 539     {
 540       __builtin_printf ("%u out of %u tests failed\n", nfails, ntests);
 541       __builtin_abort ();
 542     }
 543
 544   return 0;
 545 }