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