/ASSUME

    /ASSUME=(option[,...])

 Controls compiler assumptions.  You may select the following
 options:

    [NO]ACCURACY_SENSITIVE

       Specifies whether certain code transformations that affect
       floating-point operations are allowed.  These changes may or
       may not affect the accuracy of the program's results.

       If you specify NOACCURACY_SENSITIVE, the compiler is free to
       reorder floating-point operations, based on algebraic
       identities (inverses, associativity, and distribution).  This
       allows the compiler to move divide operations outside of
       loops, improving performance.

       The default, ACCURACY_SENSITIVE, directs the compiler to use
       only certain scalar rules for calculations.  This setting can
       prevent some optimization.

    [NO]ALIGNED_OBJECTS

       Controls an optimization for dereferencing pointers.

       On OpenVMS Alpha systems, dereferencing a pointer to a
       longword- or quadword-aligned object is more efficient than
       dereferencing a pointer to a byte- or word-aligned object.
       Therefore, the compiler can generate more optimized code if
       it makes the assumption that a pointer object of an aligned
       pointer type does point to an aligned object.

       Since the compiler determines the alignment of the
       dereferenced object from the type of the pointer, and the
       program is allowed to compute a pointer that references an
       unaligned object (even though the pointer type indicates that
       it references an aligned object), the compiler must assume
       that the dereferenced object's alignment matches or exceeds
       the alignment indicated by the pointer type.

       The default, /ASSUME=ALIGNED_OBJECTS, allows the compiler to
       make such an assumption.  With this assumption made, the
       compiler can generate more efficient code for pointer
       dereferences of aligned pointer types.

       To prevent the compiler from assuming the pointer type's
       alignment for objects that it points to, use the
       /ASSUME=NOALIGNED_OBJECTS qualifier.


    [NO]CLEAN_PARAMETERS

       Controls compiler assumptions about short-integer formal
       parameters.

       The Alpha Calling Standard requires integers less than 64
       bits long that are passed by value to have their upper bits
       either zeroed or sign-extended to make full 64-bit values.
       These are referred to as clean parameters.  Some old code
       does not follow this convention.  This can cause problems if
       the called program assumes that the caller followed the
       Calling Standard by passing only clean parameters.

       Specifying /ASSUME=NOCLEAN_PARAMETERS allows a program to be
       called by old code that might pass unclean integer
       parameters.  It directs the compiler to generate run-time
       code to clean the short integers so they comply with the
       Calling Standard.

       The default is /ASSUME=CLEAN_PARAMETERS.

    [NO]EXACT_CDD_OFFSETS

       Controls the alignment of Control Data Dictionary records.

       If /ASSUME=EXACT_CDD_OFFSETS is specified, the records input
       from the CDD are given the exact alignment (relative to the
       start of the record) specified by the CDD definition.  This
       alignment is independent of the current compiler
       member-alignment setting.

       If /ASSUME=NOEXACT_CDD_OFFSETS is specified, the compiler may
       modify the offsets specified in a CDD record according to the
       current member-alignment setting.

       The default is /ASSUME=NOEXACT_CDD_OFFSETS.

    [NO]HEADER_TYPE_DEFAULT

       Specifies whether the default file-type mechanism (.h) for
       header files is enabled (HEADER_TYPE_DEFAULT) or disabled
       (NOHEADER_TYPE_DEFAULT).

       The default is /ASSUME=HEADER_TYPE_DEFAULT.

    [NO]MATH_ERRNO

       Controls whether or not intrinsic code is generated for math
       functions that set the errno variable.

       The default is /ASSUME=MATH_ERRNO, which does not allow
       intrinsic code for such math functions to be generated, even
       if /OPTIMIZE=INTRINSICS is in effect.  Their prototypes and
       call formats, however, are still checked.


    [NO]POINTERS_TO_GLOBALS

       Controls whether or not the compiler can safely assume that
       global variables have not had their addresses taken in code
       that is not visible to the current compilation.

       The default, /ASSUME=POINTERS_TO_GLOBALS, assumes that global
       variables have had their addresses taken in separately
       compiled modules and that, in general, any pointer
       dereference could be accessing the same memory as any global
       variable.  This is often a significant barrier to
       optimization.

       The /ANSI_ALIAS qualifier allows some resolution based on
       data type, but /ASSUME=NOPOINTER_TO_GLOBALS provides
       significant additional resolution and improved optimization
       in many cases.

    [NO]WEAK_VOLATILE

       Affects the generation of code for assignments to objects
       that are less than or equal to 16 bits in size (for example:
       char, short) that have been declared as volatile.

       Specifying /ASSUME=WEAK_VOLATILE directs the compiler to
       generate code for volatile assignments to single bytes or
       words without using the load-locked store-conditional
       sequences that, in general, are required to assure volatile
       data integrity when direct byte or word memory-access
       instructions are not being used.

       This option is intended for use in special I/O hardware
       access situations, and should not generally be used.

       The default is /ASSUME=NOWEAK_VOLATILE, which uses
       interlocked instructions for sub-longword volatile accesses
       when byte or word instructions are not enabled.


    [NO]WHOLE_PROGRAM

       Asserts to the compiler that except for "well-behaved library
       routines," the whole program consists only of the single
       object module being produced by this compilation.  The
       optimizations enabled by /ASSUME=WHOLE_PROGRAM include all
       those enabled by /ASSUME=NOPOINTER_TO_GLOBALS, and possibly
       additional optimizations as well.

       The default is /ASSUME=NOWHOLE_PROGRAM.

    [NO]WRITABLE_STRING_LITERALS

       Stores string constants in a writable psect.  Otherwise, such
       constants will be placed in non-writable psect.

       For /STANDARD=VAXC or /STANDARD=COMMON, the default is
       /ASSUME=WRITABLE_STRING_LITERALS.  For all other compiler
       modes, the default is /ASSUME=NOWRITABLE_STRING_LITERALS.