/OPTIMIZE[=LEVEL=n]
  /OPTIMIZE=TUNE=option
  /OPTIMIZE=LEVEL=4      (D)
  /OPTIMIZE=TUNE=GENERIC (D)
  /NOOPTIMIZE

  Controls how the compiler produces optimized code.

  The default is /OPTIMIZE, which is the same as /OPTIMIZE=(LEVEL=4,
  TUNE=GENERIC).  For a debugging session, use the negative form
  (/NOOPTIMIZE or /OPTIMIZE=LEVEL=0) to ensure that the debugger has
  sufficient information to locate errors in the source program.

  In most cases, using /OPTIMIZE will make the program execute
  faster.  As a side effect of getting the fastest execution speeds,
  using /OPTIMIZE can produce larger object modules and longer
  compile times than /NOOPTIMIZE.

  LEVEL=n
    You can select one of the following levels:

    0               Has the same effect as /NOOPTIMIZE.  All
                    optimizations are turned off.

    1               Has some optimizations (such as instruction
                    scheduling).

    2               Adds more optimizations (such as loop unrolling
                    and split lifetime analysis) to those in level 1.

    3               Adds more optimizations (such as decimal
                    shadowing) to those in level 2.  All
                    optimizations are turned on.

    4               Is identical to level 3.  /OPTIMIZE=LEVEL=4 is the
                    equivalent of /OPTIMIZE or not specifying /OPTIMIZE.

    Specify /NOOPTIMIZE if you specify /DEBUG when compiling a program.
    /NOOPTIMIZE expedites and simplifies your debugging session by
    putting the machine code in the same order as the lines in the
    source program.  Optimizations can cause unexpected and confusing
    behavior in a debugging session.  For more information about
    debugging your program with the /NOOPTIMIZE qualifier, see the
    COBOL User Manual.

    Specify /NOOPTIMIZE if you specify /MACHINE_CODE when compiling
    a program to ensure that the machine code listing reflects the
    actual code executed for a given statement as well as the order
    of execution.

    The /NOOPTIMIZE qualifier is also useful in conjunction with
    /CHECK, as optimization can make checking more difficult.

    Specifying /OPTIMIZE, the default, usually makes programs run
    faster.  However, using /OPTIMIZE produces extra instructions
    to perform the optimization, which may result in larger object
    modules and longer compile times than the /NOOPTIMIZE qualifier.

    To speed compilations during program development, you may want
    to compile with the /NOOBJECT qualifier when you want to check
    syntax, with /NOOPTIMIZE when you check for correct execution,
    and later with /OPTIMIZE for your final check.  For more
    information about optimizing your program with the /OPTIMIZE
    qualifier, see the COBOL User Manual.

  TUNE=keyword
    Specifies the kind of optimized code to be generated.  The
    keyword can be any of the following:

      Keyword   Meaning
      -------   -------
      GENERIC   Generates and schedules code that will execute
                well for both generations of Alpha processors.
                This provides generally efficient code for those
                cases where both processor generations are likely
                to be used.

      HOST      Generates and schedules code optimized for the
                processor generation in use on the system being
                used for compilation.

      EV4       Generates and schedules code optimized for the
                21064, 21064A, 21066, and 21068 implementations
                of the Alpha chip.

      EV5       Generates and schedules code optimized for the
                21164 implementation of the Alpha chip. This
                processor generation is faster than EV4.

      EV56      Generates code for some 21164 chip implementations
                that use the byte and word manipulation instruction
                extensions of the Alpha architecture.

                Running programs compiled with the EV56 keyword
                may incur emulation overhead on EV4 and EV5
                processors, but will still run correctly on
                OpenVMS Alpha V7.1 (or later) systems.

      EV6       Generates and schedules code for the 21264 chip
                implementation that uses the following extensions
                to the base Alpha instruction set: BWX (Byte/Word
                manipulation) and MAX (Multimedia) instructions,
                square root and FIX (Floating-point convert) instructions.

                Running programs compiled with the EV6 keyword
                may incur emulation overhead on EV4, EV5, EV56,
                and PCA56 processors, but will still run correctly on
                OpenVMS Alpha V7.1 (or later) systems.

      EV67,EV68 Generates and schedules code for the 21264A chip
                implementation that uses the following extensions
                to the base Alpha instruction set: BWX (Byte/Word
                manipulation) and MAX (Multimedia) instructions,
                square root and FIX (Floating-point convert) instructions,
                and CIX (Count) instructions.

                Running programs compiled with the EV67 or EV68 keywords
                may incur emulation overhead on EV4, EV5, EV56, EV6,
                and PCA56 processors, but will still run correctly on
                OpenVMS Alpha V7.1 (or later) systems.

      PCA56     Generates code for the 21164PC chip implementation
                that uses the byte and word manipulation instruction
                extensions and multimedia instruction extensions
                of the Alpha architecture.

                Running programs compiled with the PCA56 keyword
                may incur emulation overhead on EV4, EV5, and
                EV56 processors, but will still run correctly on
                OpenVMS Alpha V7.1 (or later) systems.

  /OPTIMIZE=TUNE is currently ignored on OpenVMS I64.