diff options
Diffstat (limited to 'gcc/testsuite/gcc.misc-tests/optbench.c')
| -rw-r--r-- | gcc/testsuite/gcc.misc-tests/optbench.c | 288 |
1 files changed, 288 insertions, 0 deletions
diff --git a/gcc/testsuite/gcc.misc-tests/optbench.c b/gcc/testsuite/gcc.misc-tests/optbench.c new file mode 100644 index 00000000000..9cee4305b64 --- /dev/null +++ b/gcc/testsuite/gcc.misc-tests/optbench.c @@ -0,0 +1,288 @@ +/* ----------------------------------------------------- * + | | + | 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 */ |