VMS Help PASCAL, /OPTIMIZE[=(option[,...])] D=platform-specific  *Conan The Librarian (sorry for the slow response - running on an old VAX)

                       D=/OPTIMIZE=ALL (OpenVMS VAX)
                       D=/OPT=(LEV=4,INLI=SPE,TUN=GEN,UNR=0) (OpenVMS Alpha)
  /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 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 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 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
           Selects instruction tuning for the 21264A implementation of
          the Alpha architecture.  At this point, the tuning for EV67
          is identical to tuning for EV6.

  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 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.