tests/torture.at

   1 # Torturing Bison.                                    -*- Autotest -*-
   2
   3 # Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009, 2010 Free
   4 # Software Foundation, Inc.
   5
   6 # This program is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 AT_BANNER([[Torture Tests.]])
  20
  21
  22 # AT_INCREASE_DATA_SIZE(SIZE)
  23 # ---------------------------
  24 # Try to increase the data size to SIZE KiB if possible.
  25 m4_define([AT_INCREASE_DATA_SIZE],
  26 [data_limit=`(ulimit -S -d) 2>/dev/null`
  27 case $data_limit in
  28 [[0-9]]*)
  29   if test "$data_limit" -lt $1; then
  30     AT_CHECK([ulimit -S -d $1 || exit 77])
  31     ulimit -S -d $1
  32   fi
  33 esac])
  34
  35
  36 ## ------------------------------------- ##
  37 ## Creating a large artificial grammar.  ##
  38 ## ------------------------------------- ##
  39
  40 # AT_DATA_TRIANGULAR_GRAMMAR(FILE-NAME, SIZE)
  41 # -------------------------------------------
  42 # Create FILE-NAME, containing a self checking parser for a huge
  43 # triangular grammar.
  44 m4_define([AT_DATA_TRIANGULAR_GRAMMAR],
  45 [AT_DATA([[gengram.pl]],
  46 [[#! /usr/bin/perl -w
  47
  48 use strict;
  49 my $max = $ARGV[0] || 10;
  50
  51 print <<EOF;
  52 ]AT_DATA_GRAMMAR_PROLOGUE[
  53 %error-verbose
  54 %debug
  55 %{
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58
  59 static int yylex (void);
  60 static void yyerror (const char *msg);
  61 %}
  62 %union
  63 {
  64   int val;
  65 };
  66
  67 %token END "end"
  68 %type <val> exp input
  69 EOF
  70
  71 for my $size (1 .. $max)
  72   {
  73     print "%token t$size $size \"$size\"\n";
  74   };
  75
  76 print <<EOF;
  77 %%
  78 input:
  79   exp        { if (\@S|@1 != 0) abort (); \$\$ = \@S|@1; }
  80 | input exp  { if (\@S|@2 != \@S|@1 + 1) abort (); \$\$ = \@S|@2; }
  81 ;
  82
  83 exp:
  84   END
  85     { \$\$ = 0; }
  86 EOF
  87
  88 for my $size (1 .. $max)
  89   {
  90     use Text::Wrap;
  91     print wrap ("| ", "   ",
  92                 (map { "\"$_\"" } (1 .. $size)),
  93                 " END \n"),
  94                   "    { \$\$ = $size; }\n";
  95   };
  96 print ";\n";
  97
  98 print <<EOF;
  99 %%
 100 static int
 101 yylex (void)
 102 {
 103   static int inner = 1;
 104   static int outer = 0;
 105   if (outer > $max)
 106     return 0;
 107   else if (inner > outer)
 108     {
 109       inner = 1;
 110       ++outer;
 111       return END;
 112     }
 113   return inner++;
 114 }
 115
 116 static void
 117 yyerror (const char *msg)
 118 {
 119   fprintf (stderr, "%s\\n", msg);
 120 }
 121
 122 int
 123 main (void)
 124 {
 125   yydebug = !!getenv ("YYDEBUG");
 126   return yyparse ();
 127 }
 128 EOF
 129 ]])
 130
 131 AT_CHECK([perl -w ./gengram.pl $2 || exit 77], 0, [stdout])
 132 mv stdout $1
 133 ])
 134
 135
 136 ## -------------- ##
 137 ## Big triangle.  ##
 138 ## -------------- ##
 139
 140 AT_SETUP([Big triangle])
 141
 142 # I have been able to go up to 2000 on my machine.
 143 # I tried 3000, a 29Mb grammar file, but then my system killed bison.
 144 # With 500 and the new parser, which consume far too much memory,
 145 # it gets killed too.  Of course the parser is to be cleaned.
 146 AT_DATA_TRIANGULAR_GRAMMAR([input.y], [200])
 147 AT_BISON_CHECK_NO_XML([-v -o input.c input.y])
 148 AT_COMPILE([input])
 149 AT_PARSER_CHECK([./input])
 150
 151 AT_CLEANUP
 152
 153
 154
 155 # AT_DATA_HORIZONTAL_GRAMMAR(FILE-NAME, SIZE)
 156 # -------------------------------------------
 157 # Create FILE-NAME, containing a self checking parser for a huge
 158 # horizontal grammar.
 159 m4_define([AT_DATA_HORIZONTAL_GRAMMAR],
 160 [AT_DATA([[gengram.pl]],
 161 [[#! /usr/bin/perl -w
 162
 163 use strict;
 164 my $max = $ARGV[0] || 10;
 165
 166 print <<EOF;
 167 ]AT_DATA_GRAMMAR_PROLOGUE[
 168 %error-verbose
 169 %debug
 170 %{
 171 #include <stdio.h>
 172 #include <stdlib.h>
 173
 174 static int yylex (void);
 175 static void yyerror (const char *msg);
 176 %}
 177
 178 %token
 179 EOF
 180 for my $size (1 .. $max)
 181   {
 182     print "    t$size $size \"$size\"\n";
 183   };
 184
 185 print <<EOF;
 186
 187 %%
 188 EOF
 189
 190 use Text::Wrap;
 191 print
 192   wrap ("exp: ", "  ",
 193         (map { "\"$_\"" } (1 .. $max)), ";"),
 194   "\n";
 195
 196 print <<EOF;
 197 %%
 198 static int
 199 yylex (void)
 200 {
 201   static int counter = 1;
 202   if (counter <= $max)
 203     return counter++;
 204   if (counter++ != $max + 1)
 205     abort ();
 206   return 0;
 207 }
 208
 209 static void
 210 yyerror (const char *msg)
 211 {
 212   fprintf (stderr, "%s\\n", msg);
 213 }
 214
 215 int
 216 main (void)
 217 {
 218   yydebug = !!getenv ("YYDEBUG");
 219   return yyparse ();
 220 }
 221 EOF
 222 ]])
 223
 224 AT_CHECK([perl -w ./gengram.pl $2 || exit 77], 0, [stdout])
 225 mv stdout $1
 226 ])
 227
 228
 229 ## ---------------- ##
 230 ## Big horizontal.  ##
 231 ## ---------------- ##
 232
 233 AT_SETUP([Big horizontal])
 234
 235 # I have been able to go up to 10000 on my machine, but I had to
 236 # increase the maximum stack size (* 100).  It gave:
 237 #
 238 # input.y      263k
 239 # input.tab.c  1.3M
 240 # input        453k
 241 #
 242 # gengram.pl 10000                 0.70s user 0.01s sys  99% cpu    0.711 total
 243 # bison input.y                  730.56s user 0.53s sys  99% cpu 12:12.34 total
 244 # gcc -Wall input.tab.c -o input   5.81s user 0.20s sys 100% cpu     6.01 total
 245 # ./input                          0.00s user 0.01s sys 108% cpu     0.01 total
 246 #
 247 AT_DATA_HORIZONTAL_GRAMMAR([input.y], [1000])
 248
 249 # GNU m4 requires about 70 MiB for this test on a 32-bit host.
 250 # Ask for 200 MiB, which should be plenty even on a 64-bit host.
 251 AT_INCREASE_DATA_SIZE(204000)
 252
 253 AT_BISON_CHECK_NO_XML([-v -o input.c input.y])
 254 AT_COMPILE([input])
 255 AT_PARSER_CHECK([./input])
 256
 257 AT_CLEANUP
 258
 259
 260
 261 # AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR(FILE-NAME, SIZE)
 262 # --------------------------------------------------
 263 # Create FILE-NAME, containing a self checking parser for a grammar
 264 # requiring SIZE lookahead tokens.
 265 m4_define([AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR],
 266 [AT_DATA([[gengram.pl]],
 267 [[#! /usr/bin/perl -w
 268
 269 use strict;
 270 use Text::Wrap;
 271 my $max = $ARGV[0] || 10;
 272
 273 print <<EOF;
 274 %error-verbose
 275 %debug
 276 %{
 277 # include <stdio.h>
 278 # include <stdlib.h>
 279 # include <assert.h>
 280
 281 static int yylex (void);
 282 static void yyerror (const char *msg);
 283 %}
 284 %union
 285 {
 286   int val;
 287 };
 288
 289 %type <val> input exp
 290 %token token
 291 EOF
 292
 293 print
 294   wrap ("%type <val> ",
 295         "            ",
 296         map { "n$_" } (1 .. $max)),
 297   "\n";
 298
 299 print "%token\n";
 300 for my $count (1 .. $max)
 301   {
 302     print "    t$count $count \"$count\"\n";
 303   };
 304
 305 print <<EOF;
 306 %%
 307 input:
 308   exp        { assert (\@S|@1 == 1); \$\$ = \@S|@1; }
 309 | input exp  { assert (\@S|@2 == \@S|@1 + 1); \$\$ = \@S|@2; }
 310 ;
 311
 312 exp:
 313   n1 "1" { assert (\@S|@1 == 1); \@S|@\@S|@ = \@S|@1; }
 314 EOF
 315
 316 for my $count (2 .. $max)
 317   {
 318     print "| n$count \"$count\" { assert (\@S|@1 == $count); \@S|@\@S|@ = \@S|@1; }\n";
 319   };
 320 print ";\n";
 321
 322 for my $count (1 .. $max)
 323   {
 324     print "n$count: token { \$\$ = $count; };\n";
 325   };
 326
 327 print <<EOF;
 328 %%
 329 static int
 330 yylex (void)
 331 {
 332   static int return_token = 1;
 333   static int counter = 1;
 334   if (counter > $max)
 335     {
 336       if (counter++ != $max + 1)
 337         abort ();
 338       return 0;
 339     }
 340   if (return_token)
 341     {
 342       return_token = 0;
 343       return token;
 344     }
 345   return_token = 1;
 346   return counter++;
 347 }
 348
 349 static void
 350 yyerror (const char *msg)
 351 {
 352   fprintf (stderr, "%s\\n", msg);
 353 }
 354
 355 int
 356 main (void)
 357 {
 358   yydebug = !!getenv ("YYDEBUG");
 359   return yyparse ();
 360 }
 361 EOF
 362 ]])
 363
 364 AT_CHECK([perl -w ./gengram.pl $2 || exit 77], 0, [stdout])
 365 mv stdout $1
 366 ])
 367
 368
 369 ## ------------------------ ##
 370 ## Many lookahead tokens.   ##
 371 ## ------------------------ ##
 372
 373 AT_SETUP([Many lookahead tokens])
 374
 375 AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR([input.y], [1000])
 376
 377 # GNU m4 requires about 70 MiB for this test on a 32-bit host.
 378 # Ask for 200 MiB, which should be plenty even on a 64-bit host.
 379 AT_INCREASE_DATA_SIZE(204000)
 380
 381 AT_BISON_CHECK([-v -o input.c input.y])
 382 AT_COMPILE([input])
 383 AT_PARSER_CHECK([./input])
 384
 385 AT_CLEANUP
 386
 387
 388
 389 # AT_DATA_STACK_TORTURE(C-PROLOGUE, [BISON-DECLS])
 390 # ------------------------------------------------
 391 # A parser specialized in torturing the stack size.
 392 m4_define([AT_DATA_STACK_TORTURE],
 393 [# A grammar of parens growing the stack thanks to right recursion.
 394 # exp:
 395 AT_DATA([input.y],
 396 [[%{
 397 #include <errno.h>
 398 #include <limits.h>
 399 #include <stdio.h>
 400 #include <stdlib.h>
 401 ]$1[
 402   static int yylex (void);
 403   static void yyerror (const char *msg);
 404 %}
 405 ]$2[
 406 %error-verbose
 407 %debug
 408 %token WAIT_FOR_EOF
 409 %%
 410 exp: WAIT_FOR_EOF exp | ;
 411 %%
 412 static void
 413 yyerror (const char *msg)
 414 {
 415   fprintf (stderr, "%s\n", msg);
 416 }
 417
 418 static int
 419 yylex (void)
 420 {
 421   if (yylval < 0)
 422     abort ();
 423   if (yylval--)
 424     return WAIT_FOR_EOF;
 425   else
 426     return EOF;
 427 }
 428
 429 int
 430 main (int argc, const char **argv)
 431 {
 432   char *endp;
 433   YYSTYPE yylval_init;
 434   if (argc != 2)
 435     abort ();
 436   yylval_init = strtol (argv[1], &endp, 10);
 437   if (! (argv[1] != endp
 438          && 0 <= yylval_init && yylval_init <= INT_MAX
 439          && errno != ERANGE))
 440     abort ();
 441   yydebug = 1;
 442   {
 443     int count;
 444     int status;
 445 ]m4_bmatch([$2], [%push-],
 446 [[    yypstate *ps = yypstate_new ();
 447 ]])[    for (count = 0; count < 2; ++count)
 448       {
 449         int new_status;
 450         yylval = yylval_init;
 451 ]m4_bmatch([$2], [%push-],
 452 [[        new_status = yypull_parse (ps);
 453 ]],
 454 [[        new_status = yyparse ();
 455 ]])[        if (count > 0 && new_status != status)
 456           abort ();
 457         status = new_status;
 458       }
 459 ]m4_bmatch([$2], [%push-],
 460 [[    yypstate_delete (ps);
 461 ]])[    return status;
 462   }
 463 }
 464 ]])
 465 AT_BISON_CHECK([-o input.c input.y])
 466 AT_COMPILE([input])
 467 ])
 468
 469
 470 ## -------------------------------------- ##
 471 ## Exploding the Stack Size with Alloca.  ##
 472 ## -------------------------------------- ##
 473
 474 AT_SETUP([Exploding the Stack Size with Alloca])
 475
 476 m4_pushdef([AT_USE_ALLOCA], [[
 477 #if (defined __GNUC__ || defined __BUILTIN_VA_ARG_INCR \
 478      || defined _AIX || defined _MSC_VER || defined _ALLOCA_H)
 479 # define YYSTACK_USE_ALLOCA 1
 480 #endif
 481 ]])
 482
 483 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA])
 484
 485 # Below the limit of 200.
 486 AT_PARSER_CHECK([./input 20], 0, [], [ignore],
 487                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 488 # Two enlargements: 2 * 2 * 200.
 489 AT_PARSER_CHECK([./input 900], 0, [], [ignore],
 490                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 491 # Fails: beyond the limit of 10,000 (which we don't reach anyway since we
 492 # multiply by two starting at 200 => 5120 is the last possible).
 493 AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
 494                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 495
 496 # The push parser can't use alloca since the stacks can't be locals.  This test
 497 # just helps guarantee we don't let the YYSTACK_USE_ALLOCA feature affect
 498 # push parsers.
 499 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA],
 500 [[%define api.push-pull both
 501 ]])
 502 AT_PARSER_CHECK([./input 20], 0, [], [ignore],
 503                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 504 AT_PARSER_CHECK([./input 900], 0, [], [ignore],
 505                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 506 AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
 507                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 508
 509 m4_popdef([AT_USE_ALLOCA])
 510
 511 AT_CLEANUP
 512
 513
 514
 515
 516 ## -------------------------------------- ##
 517 ## Exploding the Stack Size with Malloc.  ##
 518 ## -------------------------------------- ##
 519
 520 AT_SETUP([Exploding the Stack Size with Malloc])
 521
 522 m4_pushdef([AT_USE_ALLOCA], [[#define YYSTACK_USE_ALLOCA 0]])
 523
 524 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA])
 525
 526 # Below the limit of 200.
 527 AT_PARSER_CHECK([./input 20], 0, [], [ignore],
 528                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 529 # Two enlargements: 2 * 2 * 200.
 530 AT_PARSER_CHECK([./input 900], 0, [], [ignore],
 531                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 532 # Fails: beyond the limit of 10,000 (which we don't reach anyway since we
 533 # multiply by two starting at 200 => 5120 is the possible).
 534 AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
 535                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 536
 537 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA],
 538 [[%define api.push-pull both
 539 ]])
 540 AT_PARSER_CHECK([./input 20], 0, [], [ignore],
 541                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 542 AT_PARSER_CHECK([./input 900], 0, [], [ignore],
 543                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 544 AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
 545                 [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 546
 547 m4_popdef([AT_USE_ALLOCA])
 548
 549 AT_CLEANUP