Copyright Digital Equipment Corp. All rights reserved.

/OPTIMIZE[=(option[,...])] D=platform-specific

                      D=/OPTIMIZE=ALL (OpenVMS VAX)
                      D=/OPT=(LEV=4,INLI=SPE,TUN=GEN,UNR=0) (OpenVMS Alpha)  
                      D=/OPT=(LEV=4,INLI=SPE,TUN=GEN,UNR=0) (OpenVMS I64)  
 /NOOPTIMIZE

 Directs the compiler to optimize the code  for  the  program  or
 module  being  compiled.  Optimization results in the production
 of more efficient object code.  A single identifier or a list of
 identifiers  may  follow  /OPTIMIZE;  these  identifiers are the
 names of options that tell the compiler  which  aspects  of  the
 compilation unit to optimize.  The options are as follows:


    ALL (OpenVMS VAX only)
      Enables all /OPTIMIZE options.

    NONE           
      Disables all /OPTIMIZE options.

    [NO]INLINE (OpenVMS VAX only)
      Enables inline expansion of user-defined routines.

    INLINE=keyword (OpenVMS Alpha and OpenVMS I64 only)
      Controls the inlining performed by the compiler.  The keyword can
      be any of the following:

        ALL
          Inlines every call that it is possible to inline while still
          generating correct code. However, recursive routines will not
          cause an infinite loop at compile time.

        NONE
          Suppresses all inlining of routines.  The is the default for
          optimization level 0.

        MANUAL
          Inlines only routines that specify the [OPTIMIZE(INLINE)]
          attribute. This is the default for optimization levels 1
          through 3.

        SIZE
          Inlines all routines that specify the [OPTIMIZE(INLINE)]
          attribute plus any additional calls that the compiler
          determines will improve run-time performance without
          significantly increasing the size of the program.  This
          option is only available with optimization levels 4 and 5.

        SPEED
          Inlines all routines that specify the [OPTIMIZE(INLINE)]
          attribute plus any additional calls that the compiler
          determines will improve run-time performance even where it
          may significantly increase the size of the program.  This is
          the default for optimization levels 4 and 5 and is only
          available at those optimization levels.

      /OPTIMIZE=INLINE is equivalent to /OPTIMIZE=INLINE=SPEED.
      /OPTIMIZE=NOINLINE is equavalent to /OPTIMIZE=INLINE=NONE.

    LEVEL=n (OpenVMS Alpha and OpenVMS I64 only)
      Controls the level of optimization performed by the compiler.

        0 Disable all optimizations.

        1 Enable local optimizations and recognition of common
          subexpressions.

        2 Enable all level 1 optimizations and some global
          optimizations that include code motion, strength reduction
          and test replacement, split lifetime analysis, and code
          scheduling.

        3 Enable all level 2 optimizations and additional global
          optimizations that improve speed (at the cost of extra code
          size), such as integer multiplication and division expansion
          (using shifts), loop unrolling, and code replication to
          eliminate branches.

        4 Enable all level 3 optimizations and, in addition, enable
          automatic inline expansion of procedures and functions.
          This is the default for /OPTIMIZE.

        5 Enable all level 4 optimizations and, in addition, enables
          software pipelining using dependency analysis, vectorization
          of some loops on 8-bit and 16-bit data, and insertion of NOP
          instructions to improve scheduling.

    UNROLL=n (OpenVMS Alpha and OpenVMS I64 only)
      Controls loop unrolling done by the optimizer.  UNROLL=n means to
      unroll loop bodies n times, where "n" is an integer in the range
      0 through 16.  The default of 0 means the optimizer will use its
      default unroll amount.

    TUNE=processor (OpenVMS Alpha only)
      Selects processor-specific instruction tuning for a specific
      implementation of the Alpha architecture.  Tuning for a specific
      implementation can provide improvements in run-time performance.

      Regardless of the setting of the TUNE flag, the generated code
      will run correctly on all implementations of the Alpha
      architecture.  Note that code tuned for a specific target may run
      more slowly on another target than generically-tuned code.

      The processor keyword can be one of the following:

        GENERIC
          Selects instruction tuning that is appropriate for all
          implementations of the Alpha architecture. This option is the
          default.

        HOST
          Selects instruction tuning that is appropriate for the
          machine on which the code is being compiled.

        EV4
          Selects instruction tuning for the 21064, 21064A, 21066, and
          21068 implementations of the Alpha architecture.

        EV5,EV56
          Selects instruction tuning for the 21164 implementation of
          the Alpha architecture.

        EV6
          Selects instruction tuning for the 21264 implementation of
          the Alpha architecture.

        EV67, EV68
          Selects instruction tuning for the 21264A implementation of
         the Alpha architecture.  The tuning for EV67 and EV68 is
         identical to the tuning for EV6.

        EV7
          Selects instruction tuning for the 21364 implementation of
          the Alpha architecture.

 On OpenVMS VAX systems, the /OPTIMIZE qualifier without  options
 is  equivalent  to  /OPTIMIZE=ALL.  The /NOOPTIMIZE qualifier is
 equivalent to /OPTIMIZE=NONE.

 On  OpenVMS  Alpha  and  OpenVMS  I64  systems,  the   /OPTIMIZE
 qualifier  is  equivalent  to  /OPTIMIZE=(LEVEL=4, INLINE=SPEED,
 TUNE=GENERIC,  UNROLL=0)  and  /NOOPTIMIZE  is   equivalent   to
 /OPTIMIZE=(LEVEL=0, INLINE=NONE, TUNE=GENERIC, UNROLL=0).

 The OPTIMIZE and NOOPTIMIZE attributes  in  the  source  program
 override the /OPTIMIZE and /NOOPTIMIZE qualifiers on the command
 line.

 The /NOOPTIMIZE qualifier guarantees  full  evaluation  of  both
 operands  of  the  AND  and  OR  Boolean  operators  to  aid  in
 diagnosing all potential programming errors.   If  you  wish  to
 have   short   circuit  evaluation  even  with  the  /NOOPTIMIZE
 qualifier, use the AND_THEN and OR_ELSE Boolean operators.