HELPLIB.HLB  —  CC  /OPTIMIZE
     /OPTIMIZE[=option] (D)
     /NOOPTIMIZE

  Controls the level of code optimization that the compiler performs.
  /OPTIMIZE has the following options:

  LEVEL=n           Selects the level of optimization.  Specify an
                    integer from 0 (no optimization) to 5 (full
                    optimization, including pipelining).

  [NO]INLINE[=keyword] Provides inline expansion of functions that
                    yield optimized code when they are expanded.  You
                    can specify one of the following keywords:

                     NONE      No inlining is done, even if requested
                               by the language syntax.
                               /OPTIMIZE=INLINE=NONE is equivalent to
                               /OPTIMIZE=NOINLINE.

                     MANUAL    Inlines only those function calls for
                               which the program explicitly requests
                               inlining.

                     AUTOMATIC Inlines all of the function calls in
                               the MANUAL category, plus additional
                               calls that the compiler determines are
                               appropriate on this platform.  On
                               Alpha systems, this is the same as
                               SIZE; on I64 systems, this is the same
                               as SPEED.  AUTOMATIC is the default.

                     SIZE      Inlines all of the function calls in
                               the MANUAL category plus any
                               additional calls that the compiler
                               determines would improve run-time
                               performance without significantly
                               increasing the size of the program.

                     SPEED     Performs more aggressive inlining for
                               run-time performance, even when it
                               might significantly increase the size
                               of the program.

                     ALL       Inlines every call that can be inlined
                               while still generating correct code.
                               Recursive routines, however, will not
                               cause an infinite loop at compile
                               time.

                               Note that /OPT=INLINE=ALL is not
                               recommended for general use, because
                               it performs very aggressive inlining
                               and can cause the compiler to exhaust
                               virtual memory or take an unacceptably
                               long time to compile

  [NO]INTRINSICS    Controls whether or not certain functions are
                    handled as intrinsic functions without explicitly
                    enabling each of them as an intrinsic through the
                    #pragma intrinsic preprocessor directive.

                    Functions that can be handled as intrinsics are:

                    Main Group - ANSI:

                     abs   atanl  atan2l ceill  cosl  floorf memcpy  sinf
                     atan  atan2  ceil   cos    fabs  floorl memmove sinl
                     atanf atan2f ceilf  cosf   floor labs   memset  strcpy
                                                             sin     strlen

                    Main Group - Non-ANSI:

                     alloca  atand2  bzero  sind
                     atand   bcopy   cosd

                    Printf functions:

                     fprintf printf  sprintf

                    Printf non-ANSI:

                     snprintf

                    ANSI math functions that set errno,
                    thereby requiring /ASSUME=NOMATH_ERRNO:

                     acos   asinf  coshl  log   log10f  powl   sqrt   tanf
                     acosf  asinl  exp    logf  log10l  sinh   sqrtf  tanl
                     acosl  cosh   expf   logl  pow     sinhf  sqrtl  tanh
                     asin   coshf  expl   log10 powf    sinhl  tan    tanhf
                                                                      tanhl

                    Non-ANSI math functions that set errno,
                    thereby requiring /ASSUME=NOMATH_ERRNO:

                     log2
                     tand

                    The /OPTIMZE=INTRINSICS qualifier works together
                    with /OPTIMIZE=LEVEL=n and some other qualifiers
                    to determine how intrinsics are handled:

                     o  If the optimization level specified is less
                        than 4, the intrinsic-function prototypes and
                        call formats are checked, but normal run-time
                        calls are still made.

                     o  If the optimization level is 4 or higher,
                        intrinsic code is generated.

                     o  If /STANDARD=ANSI89 is specified,
                        non-ANSI-Standard functions are not
                        automatically intrinsic and do not even have
                        their prototypes checked.  They are only
                        checked if the non-ANSI-Standard functions
                        are made intrinsic through #pragma intrinsic.

                     o  Intrinsic code is not generated for math
                        functions that set the errno variable unless
                        /ASSUME=NOMATH_ERRNO is specified.  Such math
                        functions, however, do have their prototypes
                        and call formats checked.

                    The default is /OPTIMIZE=INTRINSICS, which turns
                    on this handling.

                    To turn it off, specify /NOOPTIMIZE or
                    /OPTIMIZE=NOINTRINSICS.

  [NO]PIPELINE      Controls Activation of the software pipelining
                    optimization.  The software pipelining
                    optimization applies instruction scheduling to
                    certain innermost loops, allowing instructions
                    within a loop to "wrap around" and execute in a
                    different iteration of the loop.  This can reduce
                    the impact of long-latency operations, resulting
                    in faster loop execution.

                    Software pipelining can be more effective when
                    you combine /OPTIMIZE=PIPELINE with the
                    appropriate /OPTIMIZE=TUNE keyword for the target
                    Alpha processor generation.

                    Software pipelining also enables the prefetching
                    of data to reduce the impact of cache misses.

                    Software pipelining is a subset of the
                    optimizations activated by optimization level 5.

                    To determine whether using /OPTIMIZE=PIPELINE
                    benefits your particular program, you should time
                    program execution for the same program (or
                    subprogram) compiled with and without software
                    pipelining.

                    For programs that contain loops that exhaust
                    available registers, longer execution times can
                    result with optimization level 5, requiring use
                    of /OPTIMIZE=UNROLL=n to limit loop unrolling.

  UNROLL=n          Controls loop unrolling done by the optimizer.
                    UNROLL=n means to unroll loop bodies n times.
                    The default is UNROLL=0, which means the
                    optimizer will use its own default unroll amount.

  TUNE=keyword      Selects processor-specific instruction tuning for
                    implementations of the Alpha or Itanium
                    architecture.  Regardless of the setting of the
                    /OPTIMIZE=TUNE flag, the generated code will run
                    correctly on all implementations of the Alpha
                    architecture.  Tuning for a specific
                    implementation can provide improvements in
                    run-time performance.  Code tuned for a specific
                    target might run slower on another target.

                    For Itanium systems, you can specify the
                    following keyword:

          ITANIUM2 Generates code for the Intel Itanium 2 processor.

  The default is /OPTIMIZE, which is equivalent to
  /OPTIMIZE=(INLINE=AUTOMATIC,LEVEL=4,UNROLL=0,TUNE=GENERIC).
Close Help