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, 0 insertions, 288 deletions
diff --git a/gcc/testsuite/gcc.misc-tests/optbench.c b/gcc/testsuite/gcc.misc-tests/optbench.c deleted file mode 100644 index 9cee4305b64..00000000000 --- a/gcc/testsuite/gcc.misc-tests/optbench.c +++ /dev/null @@ -1,288 +0,0 @@ -/* ----------------------------------------------------- * - | | - | 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 */ |