@@ -413,6 +413,208 @@ double test_ternary_nested_of_literals(double m, double n, double o, double p, d
413413 return output ;
414414}
415415
416+ unsigned int conditional_nested_guards (unsigned int ip ) {
417+ // This tests a combinatorial explosion that can happen from a large number of
418+ // nested linear guards.
419+ unsigned int special_number =
420+ (14 * ip > (2 * ip + 1 ) * 17 + (2 * ip + 1 + 1 ) * 17
421+ ? 14 * ip
422+ : (2 * ip + 1 ) * 14 + (2 * ip + 1 + 1 ) * 17 ) >
423+ (2 * (ip * 14 + 32 ) +
424+ (4 * (ip * 14 + 32 ) +
425+ (2 * ip * 14 + 32 ) +
426+ 2 * (ip * 14 + 64 ) +
427+ ((2 * ip + 1 ) * 14 > (17 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
428+ ? (2 * ip + 1 ) * 14
429+ : 14 * (2 * ip ) > 17 * ip
430+ ? 14 * (2 * ip )
431+ : 14 * ip ) >
432+ 2 * ip * 14 + (2 * ip + 1 ) * 17
433+ ? 4 * (ip * 14 + 32 ) +
434+ (2 * ip * 14 + 32 ) +
435+ 2 * (ip * 14 + 64 ) +
436+ ((2 * ip + 1 ) * 14 >
437+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
438+ ? (2 * ip + 1 ) * 14
439+ : 14 * (2 * ip ) > 17 * ip
440+ ? 14 * (2 * ip )
441+ : 14 * ip )
442+ : 2 * ip * 14 + (2 * ip + 1 ) * 17 ) >
443+ (4 * (ip * 14 + 32 ) +
444+ (2 * ip * 14 + 32 ) +
445+ 2 * (ip * 14 + 64 ) +
446+ ((2 * ip + 1 ) * 14 > (17 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
447+ ? (2 * ip + 1 ) * 14
448+ : 14 * (2 * ip ) > 17 * ip
449+ ? 14 * (2 * ip )
450+ : 14 * ip ) >
451+ (14 * ip > (ip + 1 ) * 17 ? 17 * ip : (ip + 1 ) * 17 )
452+ ? 4 * (ip * 14 + 32 ) +
453+ (2 * ip * 14 + 32 ) +
454+ 2 * (ip * 14 + 64 ) +
455+ ((2 * ip + 1 ) * 14 > (17 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
456+ ? (2 * ip + 1 ) * 14
457+ : 14 * (2 * ip ) > 17 * ip
458+ ? 14 * (2 * ip )
459+ : 14 * ip )
460+ : 14 * ip > (ip + 1 ) * 17
461+ ? 14 * ip
462+ : (ip + 1 ) * 14 )
463+ ? 2 * (ip * 14 + 32 ) +
464+ (4 * (ip * 14 + 32 ) +
465+ (2 * ip * 14 + 32 ) +
466+ 2 * (ip * 14 + 64 ) +
467+ ((2 * ip + 1 ) * 14 >
468+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
469+ ? (2 * ip + 1 ) * 14
470+ : 14 * (2 * ip ) > 17 * ip
471+ ? 14 * (2 * ip )
472+ : 14 * ip ) >
473+ 2 * ip * 14 + (2 * ip + 1 ) * 17
474+ ? 4 * (ip * 14 + 32 ) +
475+ (2 * ip * 14 + 32 ) +
476+ 2 * (ip * 14 + 64 ) +
477+ ((2 * ip + 1 ) * 14 >
478+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
479+ ? (2 * ip + 1 ) * 14
480+ : 14 * (2 * ip ) > 17 * ip
481+ ? 14 * (2 * ip )
482+ : 14 * ip )
483+ : 2 * ip * 14 + (2 * ip + 1 ) * 17 )
484+ : 4 * (ip * 14 + 32 ) +
485+ (2 * ip * 14 + 32 ) +
486+ 2 * (ip * 14 + 64 ) +
487+ ((2 * ip + 1 ) * 14 >
488+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
489+ ? (2 * ip + 1 ) * 14
490+ : 14 * (2 * ip ) > 17 * ip
491+ ? 14 * (2 * ip )
492+ : 14 * ip ) >
493+ (14 * ip > (ip + 1 ) * 17 ? 17 * ip : (ip + 1 ) * 17 )
494+ ? 4 * (ip * 14 + 32 ) +
495+ (2 * ip * 14 + 32 ) +
496+ 2 * (ip * 14 + 64 ) +
497+ ((2 * ip + 1 ) * 14 >
498+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
499+ ? (2 * ip + 1 ) * 14
500+ : 14 * (2 * ip ) > 17 * ip
501+ ? 14 * (2 * ip )
502+ : 14 * ip )
503+ : 14 * ip > (ip + 1 ) * 17
504+ ? 14 * ip
505+ : (ip + 1 ) * 14 )
506+ ? 14 * ip > (2 * ip + 1 ) * 17 + (2 * ip + 1 + 1 ) * 17
507+ ? 14 * ip
508+ : (2 * ip + 1 ) * 14 + (2 * ip + 1 + 1 ) * 17
509+ : 2 * (ip * 14 + 32 ) +
510+ (4 * (ip * 14 + 32 ) +
511+ (2 * ip * 14 + 32 ) +
512+ 2 * (ip * 14 + 64 ) +
513+ ((2 * ip + 1 ) * 14 >
514+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
515+ ? (2 * ip + 1 ) * 14
516+ : 14 * (2 * ip ) > 17 * ip
517+ ? 14 * (2 * ip )
518+ : 14 * ip ) >
519+ 2 * ip * 14 + (2 * ip + 1 ) * 17
520+ ? 4 * (ip * 14 + 32 ) +
521+ (2 * ip * 14 + 32 ) +
522+ 2 * (ip * 14 + 64 ) +
523+ ((2 * ip + 1 ) * 14 >
524+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
525+ ? (2 * ip + 1 ) * 14
526+ : 14 * (2 * ip ) > 17 * ip
527+ ? 14 * (2 * ip )
528+ : 14 * ip )
529+ : 2 * ip * 14 + (2 * ip + 1 ) * 17 ) >
530+ (4 * (ip * 14 + 32 ) +
531+ (2 * ip * 14 + 32 ) +
532+ 2 * (ip * 14 + 64 ) +
533+ ((2 * ip + 1 ) * 14 >
534+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
535+ ? (2 * ip + 1 ) * 14
536+ : 14 * (2 * ip ) > 17 * ip
537+ ? 14 * (2 * ip )
538+ : 14 * ip ) >
539+ (14 * ip > (ip + 1 ) * 17 ? 17 * ip : (ip + 1 ) * 17 )
540+ ? 4 * (ip * 14 + 32 ) +
541+ (2 * ip * 14 + 32 ) +
542+ 2 * (ip * 14 + 64 ) +
543+ ((2 * ip + 1 ) * 14 >
544+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
545+ ? (2 * ip + 1 ) * 14
546+ : 14 * (2 * ip ) > 17 * ip
547+ ? 14 * (2 * ip )
548+ : 14 * ip )
549+ : 14 * ip > (ip + 1 ) * 17
550+ ? 14 * ip
551+ : (ip + 1 ) * 14 )
552+ ? 2 * (ip * 14 + 32 ) +
553+ (4 * (ip * 14 + 32 ) +
554+ (2 * ip * 14 + 32 ) +
555+ 2 * (ip * 14 + 64 ) +
556+ ((2 * ip + 1 ) * 14 >
557+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
558+ ? (2 * ip + 1 ) * 14
559+ : 14 * (2 * ip ) > 17 * ip
560+ ? 14 * (2 * ip )
561+ : 14 * ip ) >
562+ 2 * ip * 14 + (2 * ip + 1 ) * 17
563+ ? 4 * (ip * 14 + 32 ) +
564+ (2 * ip * 14 + 32 ) +
565+ 2 * (ip * 14 + 64 ) +
566+ ((2 * ip + 1 ) * 14 >
567+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
568+ ? (2 * ip + 1 ) * 14
569+ : 14 * (2 * ip ) > 17 * ip
570+ ? 14 * (2 * ip )
571+ : 14 * ip )
572+ : 2 * ip * 14 + (2 * ip + 1 ) * 17 )
573+ : 4 * (ip * 14 + 32 ) +
574+ (2 * ip * 14 + 32 ) +
575+ 2 * (ip * 14 + 64 ) +
576+ ((2 * ip + 1 ) * 14 >
577+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
578+ ? (2 * ip + 1 ) * 14
579+ : 14 * (2 * ip ) > 17 * ip
580+ ? 14 * (2 * ip )
581+ : 14 * ip ) >
582+ (14 * ip > (ip + 1 ) * 17 ? 17 * ip : (ip + 1 ) * 17 )
583+ ? 4 * (ip * 14 + 32 ) +
584+ (2 * ip * 14 + 32 ) +
585+ 2 * (ip * 14 + 64 ) +
586+ ((2 * ip + 1 ) * 14 >
587+ (14 * (2 * ip ) > 17 * ip ? 17 * (2 * ip ) : 17 * ip )
588+ ? (2 * ip + 1 ) * 14
589+ : 14 * (2 * ip ) > 17 * ip
590+ ? 14 * (2 * ip )
591+ : 14 * ip )
592+ : 14 * ip > (ip + 1 ) * 17
593+ ? 14 * ip
594+ : (ip + 1 ) * 14 ;
595+ return special_number ;
596+ }
597+
598+ int many_conditional_assignments (int c1 , int c2 , int c3 , int c4 , int c5 ) {
599+ // This tests a combinatorial explosion that can happen from many conditional
600+ // assignments, since each conditional assignment doubles the number of
601+ // bounds.
602+ int x = 0 ;
603+ if (c1 ) { x += 748596 ; }
604+ if (c2 ) { x += 84652395 ; }
605+ if (c3 ) { x += 3675895 ; }
606+ if (c4 ) { x += 98634 ; }
607+ if (c5 ) { x += 7834985 ; }
608+ if (c1 && c2 ) { x += 938457398 ; }
609+ if (c1 && c3 ) { x += 73895648 ; }
610+ if (c1 && c4 ) { x += 12345432 ; }
611+ if (c1 && c5 ) { x += 38847 ; }
612+ if (c2 && c3 ) { x += 234 ; }
613+ // x now has 2^10 bounds, the 10 additions below give (2^10)^10 bounds
614+ int y = x + x + x + x + x + x + x + x + x + x + x + x ;
615+ return y ;
616+ }
617+
416618// Test the comma expression.
417619unsigned int test_comma01 (unsigned int x ) {
418620 unsigned int y = x < 100 ? x : 100 ;
0 commit comments