gcc/testsuite/gcc.misc-tests/optbench.c

/* ----------------------------------------------------- * 
 |                                                       | 
 |    PC Tech Journal Benchmark Series                   | 
 |    C Code Optimization Benchmark                      | 
 |                                                       | 
 |    Copyright (c) 1988 Ziff-Davis Publishing Company   | 
 |                                                       | 
 |    This benchmark code is designed to test the        | 
 |    code optimization techniques applied by a C        | 
 |    compiler.  It does not produce meaningful results  | 
 |    when executed, or represent good style.            | 
 |                                                       | 
 * ----------------------------------------------------- */ 
 
#include <string.h> 

#define max_vector   2 
#define constant5    5 
 
typedef    unsigned char   uchar; 
 
int    i,  j,  k , l,  m; 
int    i2, j2, k2; 
int    g3, h3, i3, k3, m3; 
int    i4, j4; 
int    i5, j5, k5; 
 
double flt_1, flt_2, flt_3, flt_4, flt_5, flt_6; 
 
int    ivector[ 3 ]; 
uchar  ivector2[ 3 ]; 
short  ivector4[ 6 ]; 
int    ivector5[ 203 ]; 
 
#ifndef NO_PROTOTYPES 
void   dead_code( int, char * ); 
void   unnecessary_loop( void ); 
void   loop_jamming( int ); 
void   loop_unrolling( int ); 
int    jump_compression ( int, int, int, int, int ); 
#else 
void   dead_code(); 
void   unnecessary_loop(); 
void   loop_jamming(); 
void   loop_unrolling(); 
int    jump_compression(); 
#endif 
 
 
int     main( argc, argv )      /* optbench */ 
        int  argc; 
        char     **argv; 
        { 
        /* ------------------------------ * 
         | Constant and copy propagation  | 
         * ------------------------------ */ 
 
        j4 = 2; 
        if( i2 < j4 && i4 < j4 ) 
           i5 = 2; 
 
        j4 = k5; 
        if( i2 < j4 && i4 < j4 ) 
           i5 = 3; 
        
        /* ---------------------------------------- * 
         |  Constant folding, arithmetic identities | 
         |  and redundant load/store operations     | 
         * ---------------------------------------- */ 
 
        i3 = 1 + 2; 
        flt_1 = 2.4 + 6.3; 
        i2 = 5;               
        j2 = i + 0; 
        k2 = i / 1; 
        i4 = i * 1; 
        i5 = i * 0; 
 
#ifndef NO_ZERO_DIVIDE 
        /* 
         *   Some compilers correctly recognize a zero divide 
         *   error and do not generate any object code. 
         */ 
/*
        i2 = i / 0;            
        flt_2 = flt_1 / 0.0; 
*/
#else    
/*
        printf( "This compiler handles divide-by-zero as an
error\n"); 
*/;
#endif 
        flt_3 = 2.4 / 1.0;  
        flt_4 = 1.0 + 0.0000001; 
        flt_5 = flt_6 * 0.0; 
        flt_6 = flt_2 * flt_3; 
  
        /* ------------ * 
         |  Dead store  | 
         * ------------ */ 
 
         k3 = 1; 
         k3 = 1; 
 
        /* --------------------- * 
         |  Strength reduction   | 
         * --------------------- */ 
 
        k2 = 4 * j5; 
           for( i = 0; i <= 5; i++ )
              ivector4[ i ] = i * 2; 
    
        /* ----------- * 
         | Simple loop | 
         * ----------- */ 
 
        j5 = 0; 
        k5 = 10000; 
        do { 
              k5 = k5 - 1; 
              j5 = j5 + 1; 
              i5 = ( k5 * 3 ) / ( j5 * constant5 ); 
           } while ( k5 > 0 ); 
 
        /* ----------------------------------- * 
         | Loop induction variable handling    | 
         * ----------------------------------- */ 
 
        for( i = 0; i < 100; i++) 
           ivector5[ i * 2 + 3 ] = 5; 
 
        /* ----------------------------- * 
         | Very busy expression handling | 
         * ----------------------------- */ 
 
        if( i < 10 ) 
           j5 = i5 + i2; 
        else 
           k5 = i5 + i2; 
 
        /* -------------------------------------------- * 
         | Check how the compiler generates the address | 
         | of a variable with a constant subscript,     | 
         | copy propagation, and register propagation.  | 
         * -------------------------------------------- */ 
 
         ivector[ 0  ] = 1;  /* constant address generation */ 
         ivector[ i2 ] = 2;  /* i2 should be a propagated value
*/ 
         ivector[ i2 ] = 2;  /* register propagation */ 
         ivector[ 2  ] = 3;  /* constant address generation */ 
     
     
         /* ---------------------------------- * 
          | Common subexpression elimination   | 
          * ---------------------------------- */ 
  
        if(( h3 + k3 ) < 0 || ( h3 + k3 ) > 5 )
        /* 
               printf("Common subexpression elimination\n"); 
        
        */;
        else { 
               m3 = ( h3 + k3 ) / i3; 
               g3 = i3 + (h3 + k3); 
         } 
        /* --------------------------------------- * 
         | Invariant code motion                   | 
         |  (j * k) can be moved outside the loop. |  
         * --------------------------------------- */ 
  
        for( i4 = 0; i4 <= max_vector; i4++ )    
           ivector2[ i4 ] = j * k; 
  
        /* ---------------------------- * 
         | Function call with arguments | 
         * ---------------------------- */ 
 
        dead_code( 1, "This line should not be printed" ); 
 
        /* ------------------------------- * 
         | Function call without arguments | 
         * ------------------------------- */ 
 
        unnecessary_loop(); 

	exit (0);
    
        }  /* end of main */ 
 
            
/* --------------------------------------------- * 
 | Function: dead_code                           | 
 |           Test for dead code and dead stores. | 
 |           NO code should be generated.        | 
 * ----------------------------------------------*/ 
 
void   dead_code( a, b ) 
       int a; 
       char *b; 
       { 
         int idead_store; 
 
         idead_store = a; 
         if( 0 )
         /* 
           printf( "%s\n", b );
          */; 
       }  /* end of dead_code */ 
 
/* ----------------------------------------------- * 
 | Function: unnecessary_loop                      | 
 |           The loop in the following function is | 
 |           not necessary since the value of the  | 
 |           assignment is constant. Ideally, the  | 
 |           loop should be optimized out.         | 
 * ----------------------------------------------- */ 
 
void   unnecessary_loop() 
       { 
           int x;  
 
           x = 0; 
           for( i = 0; i < 5; i++ ) /* loop should not be generated */ 
           k5 = x + j5;                  
       }   /* end of unnecessary_loop */ 
 
/* --------------------------------------------- * 
 | Function: loop_jamming                        | 
 |           The two loop in this function share | 
 |           the same loop conditions and could  | 
 |           be coalesced together.              | 
 * --------------------------------------------- */ 
 
void   loop_jamming( x ) 
       int x; 
       { 
          for( i = 0; i < 5; i++ ) 
             k5 = x + j5 * i; 
          for( i = 0; i < 5; i++ ) 
             i5 = x * k5 * i; 
       }  /* end of loop_jamming */ 
 
/* ------------------------------------------------ * 
 | Function: loop_unrolling                         | 
 |           The loop in this function should be    | 
 |           replaced with three inline word stores | 
 |           using constant array arithmetic or by  | 
 |           specialized machine instructions used  | 
 |           for block memory initializiation.      | 
 * ------------------------------------------------ */ 
 
void  loop_unrolling( x ) 
      int x; 
      { 
         for( i = 0; i < 6; i++ ) 
           ivector4[ i ] = 0; 
       }  /* end of loop_unrolling */ 
 
/* ------------------------------------------------------ * 
 | Function: jump_compression                             | 
 |           This awkward code is useful to illustrate    | 
 |           jump chain compression. The goto 'end_1' can | 
 |           be replaced by a direct jump to 'beg_1'.     | 
 *------------------------------------------------------ */ 
 
int  jump_compression ( i, j, k, l, m ) 
int i,j ,l, m; 
        { 
beg_1: 
           if( i < j ) 
               if( j < k ) 
                   if( k < l ) 
                       if ( l < m ) 
                           l += m; 
                       else 
                           goto end_1;
                   else 
                       k += l; 
               else { 
                   j += k; 
end_1:            goto beg_1; 
               } 
           else 
               i += j; 
          return( i + j + k + l + m ); 
        }   /* end of jump_compression */