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