C compiler flags -accept option1[,option2,...] options are available: [no]vaxc_keywords The default compilation mode on OpenVMS systems includes recogni- tion of the following keywords that are not available on Tru64 UNIX except in -vaxc mode: _align, globaldef, globalref, globalvalue, noshare, readonly, variant_struct, and variant_union. This option causes these keywords to be recognized. It may help in porting applications from OpenVMS systems. [no]restrict_keyword Cause the compiler to recognize the restrict keyword (from the C9X review draft). -arch option Specifies which version of the Alpha architecture to generate instruc- tions for. All Alpha processors implement a core set of instructions and, in some cases, the following extensions: BWX (byte/word- manipulation extension), MVI (multimedia extension), FIX (square root and floating-point convert extension), and CIX (count extension). (The Alpha Architecture Reference Manual describes the extensions in detail.) The option specified by the -arch option determines which instructions the compiler can generate:e -arch option determines which instructions generic Generate instructions that are appropriate for all Alpha proces- sors. This option is the default. host Generate instructions for the processor that the compiler is run- ning on (for example, EV6 instructions on an EV6 processor). ev4,ev5 Generate instructions for the EV4 processor (21064, 21064A, 21066, and 21068 chips) and EV5 processor (some 21164 chips). (Note that chip number 21164 is used for both EV5 and EV56 processors.) Applications compiled with this option will not incur any emulation overhead on any Alpha processor. ev56 Generate instructions for EV56 processors (some 21164 chips). plus any instructions contained in the BWX extension. Applications compiled with this option may incur emulation overhead on EV4 and EV5 processors. ev6 Generate instructions for EV6 processors (21264 chips). This option permits the compiler to generate any EV6 instruction, plus any instructions contained in the following extensions: BWX, MVI, and FIX. Applications compiled with this option may incur emulation overhead on EV4, EV5, EV56, and PCA56 processors. ev67 Generate instructions for EV67 processors (21264A chips). This option is the same as the ev6 option except that it also per- mits the compiler to generate any instructions contained in the CIX extension. If your application uses CIX instructions, it may incur emulation. pca56 Generate instructions for PCA56 processors (21164PC chips). This option permits the compiler to generate any EV4 instruction, plus any instructions contained in the BWX and MVI extensions. Applications compiled with this option may incur emulation overhead on EV4, EV5, and EV56 processors. A program compiled with any of the options will run on any Alpha pro- cessor. Beginning with DIGITAL UNIX V4.0 and continuing with subse- quent versions, the operating system kernel includes an instruction emulator. This capability allows any Alpha chip to execute and produce correct results from Alpha instructions--even if the some of the instructions are not implemented on the chip. Applications using emu- lated instructions will run correctly, but may incur significant emula- tion overhead at run time. The psrinfo -v command can be used to determine which type of processor is installed on any given Alpha system. Note the following differences between the -arch evx and -tune evx options (where x designates a specific processor): + -arch evx implies -tune evx, but -tune evx does not imply -arch evx. + -arch evx can generate unguarded evx-specific instructions. If you run that application on a pre-evx processor, those instruc- tions may get emulated (and emulated instructions can be up to 1000 times slower than actual instructions). + -tune evx can generate evx-specific instructions, but those are always amask-guarded. That expands the code size but avoids instruction emulation. + If you want the best performance possible on an evx processor and are not concerned about performance on earlier processors, the best choice would be -arch evx (which implies -tune evx). + If you want good performance on an evx processor but also want the application to run reasonably fast on earlier processors, the best choice would probably be -tune evx. -c Suppresses the loading phase of the compilation and forces the creation of an object file. -[no]check_bounds Generates runtime code to check the values of array subscripts (and equivalent pointer arithmetic involving pointers produced by converting an array name to a pointer) to verify that the resulting address lies within the range for which the C standard requires well-defined behavior. The exact source code constructs that trigger these checks, and the values used for a given bounds check, are not simple to describe. In some cases the checks will trap on a partial address com- putation even though the final result of the computation is within bounds. A failed bounds check at runtime produces a Trace/BPT trap, which may be caught by signal(SIGTRAP, handler). See the Programmer's Guide for more details. The -nocheck_bounds option (the default) disables the runtime checking of array bounds. -edit[0-9] When syntactic or semantic errors are detected by the compiler's front end, invokes the editor defined by the environment variable EDITOR (or vi if EDITOR is undefined). Two files are opened for editing: the error message file, which indicates the location of the error, and the source file. When you exit from the editor, the compilation is res- tarted. The n argument specifies the number of times a compilation can be interrupted in this way. If no number is specified, the compile-edit- compile cycle repeats indefinitely until all errors are corrected. The -edit0 option turns off this feature. To abort the cycle, you must press Ctrl-C while the process is in the compilation phase (that is, while it is not in the editor). When compiling on a character-based terminal, the compile job has to be in the foreground for this option to take effect. When compiling on a workstation, this option takes effect whether it is in the foreground or background. -[no]error_limit nn Sets a limit on the number of error-level diagnostics that the compiler will emit. The default is 30. -FIfilename Specifies a file that is to be included before the first line in a source file is actually compiled. This enables users to develop include files containing sets of pragmas that control a particular aspect of a compilation (for example, optimizations or diagnostics). -granularity size Controls the size of shared data in memory that can be safely accessed from different threads. The possible size values are byte, longword, and quadword. Specifying byte allows single bytes to be accessed from different threads sharing data in memory without corrupting surrounding bytes. This option will slow runtime performance. Specifying longword allows naturally aligned 4-byte longwords to be accessed safely from different threads sharing data in memory. Access- ing data items of 3 bytes or less, or unaligned data, may result in data items written from multiple threads being inconsistently updated. Specifying quadword allows naturally aligned 8-byte quadwords to be accessed safely from different threads sharing data in memory. Access- ing data items of 7 bytes or less, or unaligned data, may result in data items written from multiple threads being inconsistently updated. This is the default. -nestlevel=n Sets the nesting-level limit for include files. The default is 50. -machine_code Includes the generated machine code in the listing file. By default, machine code is not listed. To produce the listing file, you must also specify -source_listing. -noobject Suppresses creation of an object file. By default, an object module file is created with the same name as that of the first source file of a compilation unit and with the .o file extension. Use the -noobject option when you need only a listing of a program or when you want the compiler to check a source file for errors. -o output Names the final output file output. -protect_headers keyword Ensures that the compiler's assumptions about pointer sizes and data alignments are not in conflict with the default values that were in effect when the system libraries were created. The keywords for the -protect_headers option are as follows: all Enables the protect headers feature. This is the default if the file being compiled is a C source file. none Disables the protect headers feature. This is the default if the file being compiled is a non-C source file. default Cancels any previous -protect_headers options and places the compiler's default behavior in effect. If more than one -protect_headers option appears on the command line, only the last one is applied. See protect_headers_setup(8) for details. -S Compiles the specified source files and generates symbolic assembly language output in corresponding files suffixed with .s. -show keyword[,keyword,...] Specifies one or more items to be included in the listing file. When specifying multiple keywords, separate them by commas and no interven- ing blanks. To use any of the -show keywords, you must also specify the -source_listing option. The keywords for the -show option are as follows: none Turns off all show options. all Turns on all show options. [no]brief Produces a brief macro and symbol table map in the program listing, omitting most macros and symbols that are unreferenced. Attributes such as line number of declaration, size, alignment, storage class, and type are shown for each symbol. [no]cross_reference Adds a list of line numbers to each identifier produced by the brief or symbol show options, identifying the listing lines that contain references to that identifier. If neither brief nor symbol is specified, the default is brief. Listing line numbers are the sequential numbers that span included files, and appear just before the text of each source line in the source listing. When appropri- ate, the line number designating a reference to a symbol is anno- tated with one or more suffixes indicating the way in which the symbol was used on that line, as follows:g the way in which the = Assigned or initialized & Address taken () Function called * Simple dereference -> Member dereference . Member selection (no indirection) [] Subscripted (that is, using [] syntax) b Invoked as a builtin function [no]expansion Places final macro expansions in the program listing. When you specify expansion, the number printed in the margin indicates the maximum depth of macro substitutions that occur on each line. [no]header Produces header lines at the top of each page of listing. [no]include Places contents of header files in program listing. [no]source Places source program statements in program listing. [no]statistics Places compile-time performance statistics in the program listing. [no]symbols Same as [no]brief, except that unreferenced macros and symbols are not suppressed. If you specify -source_listing but do not specify -show keywords, the compiler includes header lines and source statements in the program listing (-show header,source). -source_listing Produces a source program listing file with the same name as the source file and with a .lis file extension. You must specify this qualifier to get a listing. The default is to not produce a listing file. -v Prints the compilation phases as they execute with their arguments and their input and output files. Prints resource usage in the C-shell time format. Prints the macros defined at the start of the compilation -V Prints the version of the compiler driver. Compiler Diagnostic Controls Options -check Performs compile-time code checking. With this option, the compiler checks for code that exhibits nonportable behavior, represents a possible unintended code sequence, or possibly affects operation of the program because of a quiet change in the ANSI C Standard. Some of these checks have traditionally been associated with the lint utility. The -check option is equivalent to -msg_enable level5. The cc driver converts -check into -msg_enable level5 (the -v option noti- fies you of this transformation). -msg_dump Causes the compiler to dump, to stdout, all messages enabled by any given cc command line. The compiler then exits, without doing a compilation. -msg_actiontype msg_list Provides users with the ability to control the diagnostic message issued by the compiler. The message output can be tuned in groups (based on message level or message group) or individually (based on the message ID strings enclosed in parentheses at the end of mes- sage text strings). The -msg_actiontype option has eight different forms, each result- ing in a different action that changes the status, severity, or frequency that will be applied to the messages identified by the msg_list argument. The following message-control options are sup- ported: -msg_enable Enable a specific message or group of messages. -msg_disable Disable a specific message or group of messages. (Note that messages with error or fatal severity cannot be disabled; only warning and informational messages can be disabled.) -msg_always Always emit the messages identified by the msg_list argument. -msg_once Emit the identified messages only once. -msg_fatal Change the identified messages to be fatal, compilation-ending errors. -msg_warn Change the identified messages to be warnings. (Note that error- or fatal-severity messages cannot be changed to warning-severity messages.) -msg_inform Change the identified messages to be informational messages. (Note that error- or fatal-severity messages cannot be changed to informational-severity messages.) -msg_error Change the identified messages to be error messages. (Note that fatal-severity messages cannot be changed to error-severity messages.) The msg_list argument to the -msg_actiontype option is a comma- separated list of one or more message levels, message groups, or message IDs. Enabling a message level also enables all lower lev- els, and disabling a level also disables all higher levels. For example, disabling level 3 messages disables levels 3 - 6. Opera- tions other than enabling or disabling apply only to the specified (or default) level, not to lower levels. The following message levels and message groups are supported: Message Levels: level0 Very important messages that are enabled by default. Level 0 messages cannot be disabled as a class (level0), but individual level 0 messages can be disabled if they are warning- or informational-severity messages. (Error- or fatal-severity messages cannot be disabled.) Messages at this level correspond to messages covered by pragma nostandard. These include all messages that should be displayed for code in header files. level1 Important messages, but less important than level 0 messages. These messages are not displayed if pragma nostandard is active. Level 1 is the default for DIGITAL UNIX releases prior to V4.0E. level2 Moderately important messages. Level 2 is the default for DIGI- TAL UNIX V4.0E and later (Tru64 UNIX) versions. level3 Less important messages. (The -w0 option enables level 3 mes- sages.) level4 Useful messages associated with the -check and -portable options. level5 Less useful -check and -portable messages than the messages associated with level 4. The -check option is equivalent to -msg_enable level5. level6 All messages, including all messages not in any of the lower levels. Disabling level 6 messages does not affect the lower- level messages; it affects only the messages added by level 6. Message Groups: -portable Directs the compiler to issue diagnostics for certain constructs that may not be portable to other compilers or platforms. -port- able is equivalent to -msg_enable portable. -SD[directory] Suppresses certain warning- and informational-level diagnostic mes sages that are inappropriate for system header files. The suppressed messages relate to non-portable constructs in header files whose pathnames are prefixed by string directory. The default is -SD/usr/include. Specifying -SD without a directory string cancels the effect of any previous -SD options on the command line (including the default, -SD/usr/include). It also disables the -protect_headers feature's suppression of diagnostic messages by defining the macro __DECC_EMPTY_SD_OPTION. (The -protect-headers feature provides message suppression in the file __DECC_include_prologue.h.) -verbose Produces longer error and warning messages. Messages in this form may give the user more hints about why the compilation failed. -w[n] Controls the display of messages as well as the actions that occur as a result of the messages. The value of n can be one of the fol- lowing: 0 Displays compiler messages for less important issues. This is equivalent to -msg_enable level3. For Tru64 UNIX V4.0E and later versions, -msg_enable level2 is the default. 1 Suppresses warning and informational messages and displays error and fatal messages. This is equivalent to specifying -w. 2 If the compiler encounters an error that generates a warning- level diagnostic message, the compiler displays the message and then aborts. 3 Does not print warning messages. However, when warnings occur, exits with nonzero status. -warnprotos Causes the compiler to produce warning messages when a function is called that is not declared with a full prototype. This checking is more strict than required by ANSI C. C Preprocessor Options -C Passes all comments directly to the preprocessor output, except com- ments on preprocessor directive lines. -[no]cpp Determines whether to call the C macro preprocessor on C and assembly source files before compiling. C macro preprocessor on C and assembly -cpp is the default. -Dname[=def] Defines the name as if with a #define statement. If no definition is given, the name is defined as 1. -E Runs only the C macro preprocessor on the files and sends the result to the standard output device. -I[dir] Specifies a search path for header files whose names do not indicate a specific directory path (that is, whose names do not begin with a /). The actual search path depends upon the form of the #include directive used for the file: + If the #include "filename" form of the directive is used, the C macro preprocessor searches for the file first in the directory in which it found the file that contains the directive, then in the search path indicated by the -I option, then in the directory /usr/include.dtk, and finally in the standard directory, /usr/include. + If the #include form of the directive is used, the preprocessor searches for the file first in the search path indi- cated by the -I option, then in the directory /usr/include.dtk, and then in the standard directory, /usr/include. You can specify multiple iterations of the -I[dir] option in the cc command line; each instance of the -[dir] option appends locations to the previously established -I[dir] search path. If no dir is specified in any instance of the -I[dir] option, the C macro preprocessor never searches the directory /usr/include.dtk, nor the standard directory, /usr/include, for header files. The -nocurrent_include option can also modify the search path. -M Outputs a set of make dependency rules to standard output for each source file on the command line (and suppresses compilation). The make dependencies include all of the header files upon which each source file depends. The make targets are the object files for those source files. The output lines are indented to show header file nesting. -MD Requests dependency files from the preprocessor (and linker if it is also run). It does not suppress compilation like the -M option. This option is passed directly to the preprocessor and linker. For moreis information, see cpp(1) and ld(1). -nocurrent_include Changes the behavior of the #include "filename" directive to not search the source file's directory for filename. This option causes the #include "filename" directives to behave like #include directives. This option allows makefiles to control the search order for header files by using -I options. -oldcomment Directs the preprocessor to delete comments (replacing them with noth- ing at all). This allows traditional token concatenation. This is the default in -std0 mode. In -std and -std1 mode, the default is to replace comments with a single space. -P Runs only the C preprocessor and puts the result for each .c or .s source file in a corresponding .i file. The .i file has no #line_number preprocessor directives in it. -proto[is] Extracts prototype declarations for function definitions and puts them in a .H suffixed file. The suboption i includes identifiers in the pro- totype, and the suboption s generates prototypes for static functions as well. -Q Directs the preprocessor to use single quotes in __FILE__ expansions instead of double quotes. See cpp(1) for details. -Uname Removes any macro definition of name at the start of the compilation. name could have been defined with a -D option or predefined by the com- piler. If no name is specified or if name is not defined, the -U option is ignored. (To display a list of predefined macros, use the -v option.) Options that Affect the Linker or Loader -call_shared Produces a dynamic executable file that uses shareable objects during run time. This is the default. The loader uses shareable objects to resolve undefined symbols. The run-time loader (/sbin/loader) is invoked to bring in all required shareable objects and to resolve any -compress Passes the -compress option to the compilation phase (if the -c option is present) or passes the -compress_r option to ld (if the -r option is present). Use of this option causes the output object file to be pro- duced in compressed object file format, resulting in a substantially smaller object file. -cord Runs the procedure rearranger, cord, on the resulting file after link- ing. The rearrangement is done to reduce the cache conflicts associated with accessing the program's text. The output of cord is left in the file specified by the -o output option or a.out by default. At least one -feedback file must be specified. See prof(1) for information on creating feedback files. -expect_unresolved pattern Causes any unresolved symbols matching pattern to be ignored. Such sym- bols are not displayed and are not treated as errors or warnings. You can enter this option multiple times on a command line. The patterns use shell wildcard characters (?, *, [, ]). The wildcard characters must be properly quoted to prevent them from being expanded by the shell. For more information, see sh(1). -exact_version Used in conjunction with -call_shared to request strict dependency testing for the executable file produced. Executable files built in this manner can be executed only if the shared libraries that they use were not modified after the executable was built. -fini symbol Makes the procedure represented by the symbol into a termination rou- tine. A termination routine is a routine that is called without an argument when either the file that contains the routine is unloaded or the program that contains the routine exits. -init symbol Makes the procedure represented by the symbol into an initialization routine. An initialization routine is a routine that is called without an argument when either the file that contains the routine is loaded or the program that contains the routine is started. -input_to_ld filename Directs the linker to read the contents of file filename as if the con- tents had been supplied on the ld command line. Inside file filename, lines ending with \ are treated as continuation lines, and lines starting with # are treated as comment lines andtion ignored. The -v option can be used to display the expansion of files specified in a -input file. The files can be nested up to 20 levels. -noarchive Prevents the linker from using archive libraries to resolve symbols. This option is used in conjunction with -call_shared. The -noarchive option is position sensitive; it affects only those options and vari- ables that follow it on the command line. This option can also be used more than once on the command line. -non_shared Directs the linker to produce a static executable. The output object created by the linker will not use any shared objects during execution. -pthread Directs the linker to use the threadsafe version of any library speci- fied with the -l option when linking programs. This option also tells the linker to include the POSIX 1003.1c-conformant DECthreads inter- faces in libpthread when linking the program. This option also defines the _REENTRANT macro. -shared Produces dynamic shareable objects. The loader will produce a shareable object that other dynamic executables can use at run time. The following options are used with -shared: -check_registry location_file Checks the location of this shared object's segments and make sure they stay out of the way of other object's segments in the location_file. Multiple instances of this option are allowed. -rpath path Creates an rpath record containing the specified path string. The path string is a colon-separated list of directories that is mean- ingful only when creating an executable with shared linkage. If an item in the path supplied to -rpath is of the form $VARNAME or ${VARNAME}, the linker interprets it as an environment variable. Additional rpath directories found in shared objects on the link command line are appended to path. Duplicate entries are excluded. The loader uses the rpath record to search for shared libraries at run time. -set_version version-string Establishes the version identifier (or identifiers) associated with a shared library. The string version-string is either a single version identifier or a colon-separated list of version identif- iers. No restrictions are placed on the names of version identif- iers; however, it is highly recommended that UNIX directory naming conventions be followed. If a shared library is built with this option, any executable built against it will record a dependency on the specified version or, if a list of version identifiers is specified, the rightmost version specified in the list. If a shared library is built with a list of version identifiers, the loader will allow any executable to run that has a shared library dependency on any of the listed versions. -soname shared_object_name Sets DT_SONAME for a shared object. The name can be a single com- ponent name (for example, libc.a), a full pathname (starting with a slash), or a relative pathname (containing a slash). The default DT_SONAME used for shared objects is the filename component of the output file name. Specify the output file name using the -o option as described previously. -update_registry location_file Registers the location of this shared object's segments and makes sure they stay out of the way of others in the location_file. Location_file is updated if it is writable. -taso Directs the linker to load the executable file in the lower 31-bit addressable virtual address range. The -T and -D options to the ld command can also be used, respectively, to ensure that the text and data segments are loaded into low memory. The -taso option, however, in addition to setting default addresses for text and data segments, also causes shared libraries linked outside the 31-bit address space to be appropriately relocated by the loader. If you specify -taso and also specify text and data segment addresses with -T and -D, those addresses override the -taso default addresses. The -taso option can be helpful when porting programs that assume address values can be stored in 32-bit variables (that is, programs that assume that pointers are the same length as int variables). -threads Directs the linker to use the threadsafe version of any library speci- fied with the -l option when linking programs. This option also tells the linker to include the POSIX 1003.4a Draft 4 conformant DECthreads interfaces. It is supported only for compatibility with earlierhreads releases of Tru64 UNIX. New designs should use the -pthread option. Optimization Options -[no]ansi_alias Directs the compiler to assume the ANSI C aliasing rules, and thus allows the optimizer to be more aggressive in its optimizations. The aliasing rules are explained in Section 3.3, paragraphs 20 and 25 of the ANSI C Standard, reprinted as follows: "An object shall have its stored value accessed only by an lvalue that has one of the following types: + The declared type of the object, + A qualified version of the declared type of the object, + A type that is the signed or unsigned type corresponding to the declared type of the object, + An aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or + A character type." If your program does not access the same data through pointers that have different types (and for this purpose, signed and qualified ver- sions of an otherwise same type are considered to be the same type), then assuming ANSI C aliasing rules allows the compiler to generate better optimized code. If your program does access the same data through pointers that have different types (for example, by a "pointer to int" and a "pointer to float"), you must not allow the compiler to assume ANSI C aliasing rules because these rules can result in the generation of incorrect code. The -noansi_alias option turns off ANSI C aliasing rules. The default is -noansi_alias except when compiling with -std1 (when combined with -O3 or higher) or -fast. -[no]ansi_args Tells the compiler whether the source code follows all ANSI rules about arguments, that is, whether the type of an argument matches the type of the parameter in the called function or whether a function prototype is present so the compiler can automatically perform the expected type conversion. Specifying -noansi_args means that the argument type may not match the expected parameter type. This option is important, for example, when the caller passes a parameter of type long and the called routine expects an int. The -noansi_args option forces the compiler to gen- erate argument cleaning code to convert the argument to the appropriate type. Except when the -std1 option is specified, -noansi_args is the default. Note that it is safe to specify -ansi_args if you use ANSI- style function prototypes at all call sites. Specifying -ansi_args means that your code meets the ANSI C require- ments, so no special argument cleaning code is generated. This is a performance gain. When -std1 is specified, -ansi_args is the default. -assume [no]array_parameter_restricted_pointers Specifies the assumption that all array parameters are or are not res- tricted. The default is -assume noarray_parameter_restricted_pointers. For the sample declaration: foo(int * __restrict p1, int p2[], int * p3, int **p4); The following statements apply: + By default, only p1 is restricted. + If you specify -assume array_parameter_restricted_pointers, p1 and p2 are restricted. + If you specify -assume parameter_restricted_pointers, p1, p2, p3 and p4 are restricted, but *p4 is not restricted + If you specify -assume restricted_pointers, p1, p2, p3, p4, and *p4 are restricted. + If you specify -assume ignore_restricted_pointers, no pointers are restricted, not even p1. Each of these assumptions is negatable independently by prefixing a no to the assumption name. By default, all of the assumptions are in this negated state. The state of each assumption is resolved separately bys processing negations in left-to-right order. For example, -assume norestricted_pointers -assume restricted_pointers is resolved to -assume restricted_pointers. At the same time, the four assumptions have strictly-increasing strength in the order shown, such that the behavior is determined only by the strongest assumption in effect at the end of the command line, regardless of their relative placement. Thus if -ignore_restricted_pointers is in effect, the state of any other assumption is ignored. For the other assumptions, this "strength" effect is a natural result of supersetting. The -assume norestricted_pointers option disables the __restrict key- word from all pointers. This can help detect inappropriate use of __restrict. If the code works correctly at high optimization with __restrict turned off, but breaks with it turned on, it is likely that the compiler encountered a pointer that was restricted in error. Res- tricted pointers are an assertion by the programmer to aid optimiza- tion; the compiler cannot detect erroneous assertions. -assume [no]ignore_restricted_pointers Specifies the assumption that the restricted attribute is or is not ignored for all pointers. The default is -assumeribute is or is not noignore_restricted_pointers. For more information, see -assume [no]array_parameter_restricted_pointers. -assume [no]math_errno Controls the compiler's assumption about a program's dependence on the setting of errno by math library routines: + By default (-assume math_errno), the compiler assumes that the program might interrogate errno after any call to a math libarry routine that is capable of setting errno. The definition of the ANSI C math library allows programs to depend on this behavior, which unfortunately restricts optimization because this causes most math functions to be treated as having side effects. + Specifying -assume nomath_errno instructs the compiler to assume that the program does not look at the value of errno after calls to math functions. This assumption allows the compiler to reorder or combine computations to improve the performance of those math functions that it recognizes as intrinsic functions. In practice, robust floating-point code seldom relies on errno to detect domain. or range errors, so -assume nomath_errno can often be safely used to improve performance. -assume [no]parameter_restricted_pointers Specifies the assumption that all pointer parameters are or are not restricted. The default is -assume noparameter_restricted_pointers. For more information, see -assume [no]array_parameter_restricted_pointers. -assume [no]restricted_pointers Specifies the assumption that all pointers are or are not restricted. The default is -assume norestricted_pointers. For more information, see -assume [no]array_parameter_restricted_pointers. -assume whole_program Specifies that no occurrences of the address-of operator (&) are being applied outside the current compilation unit to extern variables that are declared inside the current compilation unit. Making this asser- tion allows the compiler to perform better optimizations. This option is often suitable for use with the -ifo option, which presents a group of source files to the compiler as a single compila- tion unit. -check_omp -check_omp Enables runtime checking of certain OpenMP constructs. This includes runtime detection of invalid nesting and other invalid OpenMP cases. When invalid nesting is discovered at runtime and this option is set, the executable will fail with a Trace/BPT trap. If this option is not set and invalid nesting is discovered, the behavior is indeterminate (the executable may hang, and so on). See also the -mp and -omp options. -fast Provides a single method for turning on a collection of optimizations for increased performance. Note that the -fast option can produce different results for floating- point arithmetic and math functions, although most programs are not sensitive to these differences. The -fast option defines the following compiler options and symbols to improve run-time performance. You can adjust the optimizations by specifying the negation of any given option. -ansi_alias Directs the compiler to assume the ANSI C aliasing rules, and thus allows the optimizer to be more aggressive in its optimizations. See the description of this option elsewhere in this reference page for more detailed information about this operation. -ansi_args Tells the compiler that the source code follows all ANSI rules about arguments; that is, whether the type of an argument matches the type of the parameter in the called function, or whether a function prototype is present so the compiler can automatically perform the expected type conversion. See the description of this option elsewhere in this reference page for more detailed information about this operation. -assume nomath_errno Allows the compiler to reorder or combine computations to improve the performance of those math functions that it recognizes as intrinsic functions. See the description of this option elsewhere in this reference page for more detailed information about this operation. -assume trusted_short_alignment Specifies that this is a strictly-conforming ANSI C program with respect to the dereferencing of pointer-to-short variables. This allows the compiler to assume that any short accessed through a pointer is naturally aligned (as the C language requires). It typi- cally produces the fastest code but can silently generate the wrong results if any such short object crosses a quadword boundary. See the description of this option elsewhere in this reference page for more detailed information about this operation. -D_INTRINSICS This option affects the compilation of a number of system header files, causing them to compile #pragma intrinsic directives for certain functions that they declare. The exact functions affected may vary depending on the language mode and other macro defini- tions. See the header files math.h, stdio.h, stdlib.h, string.h, and strings.h for details. The exact effect of each #pragma intrin- sic varies by function, by optimization options, and by other compile-time options. The basic effect is to inform the compiler that the function specified in the pragma is the one by that name whose behavior is known to the compiler (that is, it is a standard C or commonly-used library function rather than a user-written external function). This gives the compiler license to perform additional checks on the usage of the function and issue diagnos- tics, and to optimize and/or rewrite calls to it based on thenos- compiler's understanding of what the function does. Some possible optimizations include generating complete inline code, generating partial inline code with calls to one or more different functions, or just using characteristics of the function to move the call site or avoid some of the overhead triggered by an external call. -D_INLINE_INTRINSICS This option affects the compilation of stdio.h in two ways: + Whenever the header file would otherwise define getc and putc as preprocessor macros expanding into code to access the _cnt and _ptr members of the referenced FILE object directly, instead these macros are defined to invoke inlined static functions defined in the header file. The use of an inlined static function instead of a simple macro prevents the argu- ment from being evaluated more than once (so arguments con- taining side effects do not cause a problem), and the function generally will produce better code because it uses local declarations to avoid aliasing assumptions that the compiler has to make when analyzing the traditional macro expansions of getc and putc. Note that getc and putc are not expanded inline when i/o locking is required, as is normally the case for reentrant or thread-safe compilations. normally the case + If -D_INTRINSICS was also specified, making printf and fprintf intrinsic functions, then certain of the low-level runtime support routines that may be called for special cases of for- mat strings are defined as inline static functions in the header file, avoiding external calls to these routines in libc. -D_FASTMATH Causes the /usr/include/math.h file to redefine the names of cer- tain common math routines, including sqrt and exp, so that faster but slightly less accurate functions are used. The fast math rou- tines do not support IEEE exceptional behavior. -float Tells the compiler that it is not necessary to promote expressions of type float to type double. See the description of this option elsewhere in this reference page for more detailed information about this operation. -fp_reorder -f Allows floating-point operations to be reordered during optimiza- tion. See the description of this option elsewhere in this reference page for more detailed information about this operation. -ifo Performs inter-file optimizations, but only if more than one file is specified on the command line. See the description of this option elsewhere in this reference page for more detailed information about this operation. -intrinsics Controls whether the compiler recognizes certain functions as intrinsic functions. See the description of this option elsewhere in this reference page for more detailed information about this operation. -O3 Sets the optimization level. See the description of this option elsewhere in this reference page for more detailed information about this operation.s reference page -readonly_strings Makes string literals read-only for improved performance. See the description of this option elsewhere in this reference page for more detailed information about this operation. [V4 Systems] -feedback file Specifies the name of a feedback file (typically produced by prof after running a pixie-instrumented version of the program). The feedback file contains information that the compiler can use when performing optimi- zations. You can also use a feedback file as input to the cord utility, using -feedback and the -cord options to link the program. [V5 Systems] -feedback file Specifies that the compiler should use the profile information con- tained in file when performing optimizations. There are two forms of this option. One form is selected if file is a data file, typically produced by prof after running a pixie- instrumented version of the program. The other form is selected if file is an executable program file. The -feedback option automatically determines whether file is a data file or an executable file and processes it accordingly. If file is a data file, the -feedback option uses the data in file to guide the compiler optimizer (and cord if -cord is also specified). The -g1 debug level is recommended here in either case. If file is an executable file, the -feedback option uses the data in file to guide the compiler optimizer (and spike if -spike is also specified). If file does not exist, this compilation step prepares it to receive profiling data in the future. See Spike and Profile-Directed Optimization in the Programmer's Guide for details. The compiler defaults to the -g1 debug level here, overriding any explicit -g0, but honoring any -g, -g2, or -g3 option. While both the cord and spike post-link optimizers reorder procedures to reduce cache thrashing, spike is typically more effective. When employing both -feedback and spike, use the second (executable) form of file, which allows both the compiler and spike to use data derived from a single profile training run. -[no]fp_reorder Specifies whether certain code transformations that affect floating- point operations are allowed. These changes can affect the accuracy of the program's results. The -nofp_reorder option, the default, directs the compiler to use only certain scalar rules for calculations. This setting can prevent some optimizations. The -fp_reorder option frees the compiler to reorder floating-point operations based on algebraic identities (inverses, associativity, and distribution). For instance, this allows the com- piler to move divide operations outside of loops, thus improving per- formance. If you specify -fp_reorder and the compiler reorders code to improve performance, the results can differ from the default, for example, due to the way intermediate results are rounded. However, the -fp_reorder results are not categorically less accurate than those gained by the default. -ifo Provide improved optimization (inter-file optimization) and code gen- eration across file boundaries that would not be possible if the files were compiled separately. were compiled separately. When you specify -ifo on the command line in conjunction with a series of file specifications, the compiler does not concatenate each of the specified source files. Instead, each file is treated separately for purposes of parsing, except that the compiler will issue diagnostics about conflicting external declarations and function definitions that occur in different files. For purposes of code generation, the compiler treats the files as one application. The default is to not provide inter-file optimization. -[no]inline keyword Specifies whether to provide inline expansion of functions. This is the default for -O2, -O3, -O4. The -noinline option disables this optimization. When choosing calls to expand inline, the compiler also considers the function size, how often the call is executed, how many registers the inline expansion will require, and other factors. You can specify one of the following as the keyword to control inlin- ing: none no No inlining is done, even if requested by a #pragma inline prepro- cessor directive. This is the default when compiling with the -O0 option. manual Inlines only those function calls explicitly requested for inlining by a #pragma inline directive. This is the default when compiling with the -O1 option. 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. This is the default when compiling with the -O2 or -O3 option. speed Inlines all of the function calls in the manual category, plus any additional calls that the compiler determines would improve run- time performance, even where it may significantly increase the size of the program. all Inlines every call that can be inlined while still generating al correct code. Recursive routines, however, will not cause an infin- ite loop at compile time. For optimization level 0 (-O0), the -inline option is ignored and no inlining is done. The #pragma noinline preprocessor directive can also prevent inlining of any function. -[no]intrinsics The -intrinsics option causes the compiler to recognize intrinsic func- tions wherever it can automatically, based only on name and call signa- ture. Unlike -D_INTRINSICS, this option can treat library function calls as intrinsic even when the appropriate header file is not included. Any function declaration or call site (in the case of impli- cit declaration) with a name matching the name of an intrinsic function is examined to see if its parameters and return result are consistent with the intrinsic function of that name. If so, calls are treated as being intrinsic. If not, a diagnostic is issued and calls are treated as ordinary external function calls. When the compiler identifies a function as an intrinsic function, it is then free to make code optimizations (transformations) based on what it knows about the operations performed by the standardized version of that function--given an optimization level (-On) that enables the intrinsic treatment of that particular function.dardized version of The optimization level determines which functions can be treated as intrinsics: -O0 or -O1 No intrinsic functions. The -intrinsics option has no effect at this optimization level. -O2 (or -O) Memory and string functions: alloca, bcopy, bzero, memcpy, memmove, memset, strcpy, strlen Math functions: abs, fabs, labs, atan, atan2, atan2f, atand, atand2, atanf, ceil, ceilf, cos, cosd, cosf, floor, floorf, sin, sind, sinf. -fast (due to its supplying -assume nomath_errno ) acos, acosf, asin, asinf, cosh,coshf, exp, expf, log, log10, log10f , logf, log2, pow, powf, sqrt, sqrtf, sinh, sinhf, tan, tand, tanf, tanh. The effects of the various optimization levels are cumulative; for example, -fast causes the functions at the -02 (or -O) and -O3 optimi- zation levels to be treated as intrinsics--in addition to the intrinsic function treatment that is triggered by -fast itself. The -intrinsics option is in effect by default. To disable the default, specify the -nointrinsics option. To disable the intrinsic treatment of individual functions, specify the function names in a pragma function directive in either your source code or a file associated with a -FI option ("file include" option). Although -intrinsics is the default (and it will generally treat calls to [f]printf as intrinsic), in order to have the low-level support rou- tines for intrinsic [f]printf inlined, the compilation must include and also specify both -D_INTRINSICS and -D_INLINE_INTRINSICS on the command line. -mp Causes the compiler to recognize an older form of parallel programming directives, as well as OpenMP directives, and pass libots3 and appropriate thread libraries to the linker. It also predefines the macro _OPENMP with a value of 0. Programs may use both forms of direc- tives if they are in sections of code that do not interact with each other -- the purpose being to ease migration from the older form to OpenMP. See also the -omp and -check_omp options. OpenMP. See also the -omp and -check_omp options. -O[n] Determines the level of optimization. The following table lists the types of optimizations that can be performed at each level: _______________________________________________________________________ Level Optimization _______________________________________________________________________ -O0 None -O1 Local optimizations and recognition of common subexpressions. Global optimizations, including code motion, strength reduction and test replace- ment, split lifetime analysis, and code scheduling. -O2, -O Inline expansion of static procedures. Additional global optimizations that improve speed (at the cost of extra code size), such as integer multipli- cation and division expansion (using shifts), loop unrolling, and code replication to eliminate branches. -O3 Inline expansion of global procedures. -O4 Software pipelining using dependency analysis, vec- torization of some loops on 8-bit and 16-bit data (char and short), and insertion of NOP instructions to improve scheduling. _______________________________________________________________________ If your application will be built into a shared library, avoid using the -O3 and -O4 options, because these levels may inhibit the ability to preempt symbols. Also, benchmarking is recommended to determine if -O4 is better than -O3 for your particular application, as this is not always true. -om Performs code optimization after linking, including nop (no operation) removal, .lita removal, and reallocation of common symbols. This option also positions the $gp register so that the maximum number of addresses fall in the $gp-accessible window. [V5 Systems] The -om option is most effective when used with the -non_shared option -- that is, with executables. [V4 Systems] The -om option should be used only with the -non_shared option. When you specify -om by itself, you get the full range of postlink optimizations. You can request a particular optimization by specifying -om followed by one of the following options:ptimization by specifying -WL,-om_compress_lita Removes unused .lita entries after optimization, and then compresses the .lita section. -WL,-om_dead_code Removes dead code (unreachable instructions) generated after apply- ing optimizations. The .lita section is not compressed by this option. -WL,-om_Gcommon,num Sets the size threshold of "common" symbols. Every "common" symbol whose size is less than or equal to num will be allocated close to each other. This option can be used to improve the probability that the symbol can be accessed directly from the $gp register. (Nor- mally, om tries to collect all "common" symbols together, not just symbols that conform to certain size constraints.) -WL,-om_ireorg_feedback,file Uses the pixie-produced information in file.Counts and file.Addrs to reorganize the instructions to reduce cache thrashing. -WL,-om_no_inst_sched Turns off instruction scheduling. -WL,-om_no_align_labels Turns off alignment of labels. Normally, the -om option will align the targets of all branches on quadword boundaries to improve loop performance. -WL,-om_split_procedures Splits frequently accessed routines into "hot" and "cold" code seg- ments, and stores these segments in different parts of the image. The hot segments are the most frequently executed parts of the code, as determined by feedback data produced by a representative run of the program. The hot segments are stored near other parts of the program that are also executed frequently. In this way, the most frequently executed parts of the program are compacted in a way that makes them more likely to fit into the cache. This speeds up the execution time of that code. For additional information on om, send email to wrl- techreports@decwrl.dec.com, specifying help on the subject line. Then, follow the instructions in the reply you receive to obtain report number 94/1. -omp Causes the compiler to recognize the OpenMP (http://www.openmp.org) shared memory parallel programming API pragmas and pass libots3 and appropriate thread libraries to the linker. It also predefines the macro _OPENMP with a nonzero value. Note that under this option, the older parallel programming directives enabled by the -mp option are ignored. See also the -mp and -check_omp options. -preempt_module Supports symbol preemption on a module-by-module basis. During optimi- zation, inlining is performed only on functions within a single compi- lation unit. This is the default in the following cases: + At optimization levels -O3 and -O4. + When -ifo is used. + When the compilation is proceeding directly to an a.out executable file, that is, when none of the following options are specified on the command line: -c, -r, or -shared. In all other cases, -preempt_symbol is the default. -preempt_symbol Preserves full symbol preemption; that is, supports symbol preemption on a symbol-by-symbol basis within a module as well as between modules. Restricts the optimizer so that calls to extern functions are ineligi- ble for inline replacement. The default taken for a compilation is either -preempt_symbol or -preempt_module. See the description of the -preempt_module option for details on the conditions that determine which option is taken as the default. -speculate all Specifies that speculation may occur anywhere in the executable image. Speculation is a compiler optimization that causes the hardware to begin executing an operation before it determines that the flow of con- trol will actually reach that operation. If the flow of control does reach that operation, the result will be available sooner than it would have been without speculative execution. If the flow of control does not reach that operation, the result will simply be ignored. Since unsuccessful speculative operations can generate exceptions, all exceptions are dismissed when any module that contributes to the appli- cation is compiled with the -speculate all option (though floating- point instructions specifying software completion are still handled normally). This optimization is therefore inappropriate for codes that use any form of local exception handling (or is linked to other codes that do). -speculate by_routine Specifies that speculation is allowed only in the code in the source module that is being compiled. A module compiled with -speculate by_routine cannot use any form of local exception handling, but can be linked with other modules that do. The run-time system checks each exception to see if it occurred in a speculative routine. It dismisses exceptions from routines that are speculatively executed, but signals exceptions from other routines. (Note, though, that floating-pointing instructions specifying software completion [/S] are still given normal exception handling.) As a result, you should use the -speculate by_routine option only for modules that are known to be error-free and that do not depend on fault and trap handling. If code compiled speculatively incurs a lot of exceptions, it may result in an overall performance loss. If this is so, you should discontinue use of this feature. so, you should discontinue use of this feature. The -speculate by_routine option yields somewhat slower execution than the -speculate all option, but does not restrict trap and fault han- dling in other modules with which it is linked. -spike Invokes the spike tool to perform code optimization after linking a program. -spike is a replacement for -om and does similar optimiza- tions. See spike(1) for complete information on the spike command, its options, and its relationship to -spike. -spike is particularly useful with -feedback. All of the spike command's options can be passed directly to -spike by using the -WS compiler option. The following example shows the syntax: % cc -spike -feedback prog -o prog *.c \ -WS,-splitThresh,.999,-noaggressiveAlign For detailed examples using the -spike option and spike command, see spike(1) and the Programmer's Guide. -tune option Instructs the optimizer to tune the application for a specific version of the Alpha hardware. This will not prevent the application from run- ning correctly on other versions of Alpha but it may run more slowly than generically-tuned code on those versions.it may run more slowly The option argument can be one of the following, which selects instruc- tion tuning appropriate for the listed processor(s): generic All Alpha processors. This is the default. host The processor on which the code is compiled. ev4 The 21064, 21064A, and 21068 processors. ev5,ev56 The 21164 processor. (Both EV5 and EV56 are numbered 21164.) ev6 The 21264 processor. ev67 The 21264A processor. pca56 The 21164PC processor. The 21164PC processor. See also the -arch option for an explanation of the differences between -tune and -arch. -unroll n Controls the loop-unrolling optimization (available only at levels -O2 and higher). -unroll n allows the compiler to unroll loops up to n times. -unroll 1 disables the optimization. -unroll 0 (the default) allows the compiler to decide what is best. Feedback-directed Optimization Options -gen_feedback Generates accurate profile information to be used with -feedback optim- izations, as follows: 1. Compile the source code with the -gen_feedback option. 2. Run pixie on the executable file. 3. Execute the pixie version of the program to generate execution statistics on the program. 4. Use prof to create a feedback file from the execution statistics. 5. Recompile the program with the -feedback option and optimization level -O1 or above. This provides the compiler with execution information that the compiler can use to improve certain optimiza- tions. -prof_gen Generates an executable image that has profiling code added to it. Using this option is equivalent to running the pixie command on an existing image. The pixie-instrumented file is called a.out (or as specified with the -o option). The uninstrumented file is given an extension of .non_pixie. See also the descriptions of the -prof_use_om_feedback, -prof_dir, and -pids options. -prof_gen_noopt Generate a non-optimized executable image that, when run, will generate profiling data that the compiler can use to improve its optimization choices (with -prof_use_feedback). This switch is equivalent to the combination -prof_gen -gen_feedback and does not require the direct use of the pixie or prof tools or the -feedback option. It is the simplest way to use feedback-directed com- piler optimization.. It is the simplest way to use feedback-directed com- The recommended usage is as follows: 1. Compile the source code with -prof_gen_noopt. 2. Run the program. 3. Recompile the source code with -prof_use_feedback. For more information, see pixie(1) and prof(1), and -prof_gen, -gen_feedback, and -prof_use_feedback. For information about manipulat- ing the name and location of the feedback data files, see -pids and prof_dir. -prof_use_feedback Uses profiling feedback to improve compiler optimization. Using this option is equivalent to using the prof(1) command to produce a feedback file, and then using the cc -feedback command to recompile the program. To use the -prof_use_feedback option, first compile your program with either the -prof_gen_noopt option or the -prof_gen and -gen_feedback options and then run the program to generate the needed profiling data. options and then run the program to generate the needed profiling data. -prof_use_om_feedback Uses profiling feedback to rearrange the resulting image to reduce cache conflicts of the program text. This option uses the -om postlink optimizer, and is equivalent to using the -om -WL,-om_ireorg_feedback options. If the -pids option is also specified, this option merges the .Counts performance data files using the prof -pixie -merge command. To use the -prof_use_om_feedback option, first compile your program with the -prof_gen option and then run the program to generate the pro- filing data. -prof_dir Specifies a location to which the profiling data files (.Counts and .Addrs) are written. Use this option in conjunction with -prof_gen, -prof_gen_noopt, -prof_use_feedback, or -prof_use_om_feedback to specify the location of the profiling data files. If you do not specify this option, the profiling files are written to the current directory. Specifying the -prof_dir option also enables the -pids option. -[no]pids [Disables] or enables the addition of the process-id to the filename of the basic block counts file (.Counts). This facilitates collecting information from multiple invocations of the pixie output file. Unless the -prof_dir option is specified, the default is -nopids. Source-code Debugging Options -g[n] Produces symbol table information for debugging. When no value is specified for n, the compiler produces symbol table information for full symbolic debugging and suppresses optimizations that limit full symbolic debugging (same as -g2). The value of n can be one of the following (-g is the same as -g2): 0 Produces only enough symbol table information for linking. Names and addresses of external symbols, and the addresses and basic lay- out of the stack-frame are available. Profiling tools work, but the names of local procedures, source lines, and source file names are not available. The debugger allows procedure traceback and all instruction-level commands. However, line-oriented commands do not work. No symbol types are available, and the names of stack-frame and static variables are not available. All optimizations are sup- ported.tic variables are not available. All optimizations are sup- 1 Produces limited symbol table information. Profiling and debugging tools provide line numbers, source file names, and the names of local procedures, when appropriate. Line-oriented debugging com- mands work, but symbol types and the names of stack-frame variables are not available. Most profiling tools work to their fullest ability, but some advanced Atom tools may provide more information at higher debug levels. All optimizations are supported. 2 Produces symbol table information for full symbolic debugging and suppress some optimizations. Symbol types and stack-frame vari- ables names are available. Optimization is suppressed (-g2 implies -O0). 3 Produces symbol table information for fully optimized code. This level of debugging supplies the same information as -g2, but it also allows all compiler optimizations. As a result, some of the correlation is lost between the source code and the executable pro- gram. Program Profiling Options -p[n] Determines the level of profiling. The -p option prepares for profiling by periodically sampling the value of the program counter. This option affects linking only, so that when linking occurs, the standard run- time startup routine is replaced by the profiling run-time startup rou- tine (mcrt0.o) and the level 1 profiling library (libprof1.a) is searched. When you use the -p option together with either the -pthread option or the -threads option, the profiling library libprof1_r.a is used. When profiling begins, the startup routine calls monstartup (see moni- tor(3)) and produces, in file mon.out, execution-profiling data for use with the postprocessor prof(1). The value n can be one of the following: 0 Do not permit any profiling. This is the default. If linking occurs, the standard run-time startup routine (crt0.o) is used, and no profiling library is searched. 1 Same as -p. -[no]pg Turns gprof profiling on or off when compiling and linking the file immediately following this option. The gprof profiler produces a call graph showing the execution of a C program. When this option is turned on, the standard run-time startup routine is replaced by the gcrt0.o routine. Programs that are linked with the -pg option and then run will produce, in file gmon.out, a dynamic call graph and profile. You then run gprof on the gmon.out file to display the output. When you use the -pg option together with either the -pthread option or the -threads option, the profiling library libprof1_r.a is used. For more information, see the gprof(1) reference page. Data Alignment Options -assume [no]aligned_objects Controls the alignment assumptions for code generated for indirect load and store instructions. The -assume aligned_objects option causes the compiler to assume that a dereferenced object's alignment matches or exceeds the alignment indi- cated by the pointer to the object. On Alpha systems, dereferencing a pointer to a longword- or quadword-aligned object is more efficientg a than dereferencing a pointer to a byte- or word-aligned object. Therefore, when the compiler assumes that a pointer object of an aligned pointer type does point to an aligned object, it can generate better code for pointer dereferences of aligned pointer types. The -assume noaligned_objects option causes the compiler to generate longer code sequences to perform indirect load and store operations in order to avoid hardware alignment faults for arbitrarily aligned addresses. Although the -assume noaligned_objects option may generate less efficient code than -assume aligned_objects, by avoiding hardware alignment faults, it speeds the execution of programs that reference unaligned data. The -assume aligned_objects option is the default. The compiler assumes that the alignment of pointers meets or exceeds that of the objects to which they point. The following rules apply: + A pointer of type short points to objects that are at least short-aligned. + A pointer of type int points to objects that are at least int- aligned. aligned. + A pointer of type struct points to objects that have an alignment of struct (that is, the alignment of the strictest member align- ment, or byte alignment if you have specified #pragma nomember_alignment for struct). If your module breaks one of these rules, you must use the -assume noaligned_objects option to compile the module; otherwise, your program may get alignment faults during execution, which will degrade perfor- mance. The -assume aligned_objects and -assume noaligned_objects options can be used in the same cc command, allowing you to turn this option on and off as needed by individual source files. The -misalign option is a synonym for -assume noaligned_objects and the -nomisalign option is a synonym for -assume aligned_objects. -assume [no]trusted_short_alignment Controls whether the compiler can assume that this is a strictly- conforming ANSI C program with respect to the dereferencing of pointer-to-short variables. Specifying -assume trusted_short_alignment allows the compiler to assume that any short object accessed through a pointer is naturally aligned. This may produce the fastest code but can silently generate the wrong results if any such short object crosses a quadword boundary. Specifying -assume notrusted_short_alignment tells the compiler that dereferenced short objects may not be naturally aligned (as both ANSI C and K&R C require). This may produce slightly slower code, but that code will produce the correct results regardless of data alignment. This is the default. Note that -assume notrusted_short_alignment does not override the __unaligned type qualifier, the -misalign option, or the -assume noaligned_objects option. -[no]misalign Controls the compiler's alignment assumptions for code generated for indirect load and store instructions. The -misalign option is a synonym for -assume noaligned_objects and the -nomisalign option is a synonym for -assume aligned_objects. The -assume [no]aligned_objects option is discussed earlier in this reference page. -[no]member_alignment Directs the compiler to byte-align data structure members (with the exception of bit-field members). By default, data structure members are aligned on natural boundaries (that is, on the next boundary appropriate to the type of the member) instead of the next byte. For example, an int variable member is aligned on the next longword boundary, and a short variable member is aligned on the next word boundary. Any use of the #pragma member_alignment, #pragma nomember_alignment, or #pragma pack directives within the source code overrides the setting established by this option. The use of the -nomember_alignment option can cause conflicts between the compiler's assumptions about data layouts and the default values that were in effect when the system libraries were created. See protect_headers_setup(8) for details on how to avoid this conflict. -Zp[n] Aligns structure members and entire structures based on the integer n, where n can be 1, 2, 4, or 8. This option sets a limit on the alignment given to structure members so that each member after the first isgnment stored on a maximum of an n-byte boundary. For example, a 4-byte int member is aligned on a 4-byte boundary under either -Zp8 or -Zp4. But under -Zp2 it is aligned to the next 2-byte boundary, and under -Zp1 it begins at the next byte (that is, it is unaligned). -Zp is equivalent to -Zp1. This option can also affect the alignment of the entire structure, which is computed by default as the maximum alignment requirement of any of its members. For example, if a structure contains an 8-byte pointer followed by a 4-byte int, the entire structure is assumed to be 8-byte aligned and padded to 16 bytes, by default (effectively - Zp8). Therefore, in an array of such structures each array element starts on an 8-byte boundary. Under -Zp4, the layout of members within the structure is unchanged (the pointer is still at offset 0 and the int is at offset 8), but now the entire structure is assumed to be only 4-byte aligned, and there is no padding added after the int, so the size of the entire structure is only 12 bytes. The use of the -Zpn option (where n!=8) can cause conflicts between the compiler's assumptions about data layouts and the default values that were in effect when the system libraries were created. See protect_headers_setup(8) for details on how to avoid this conflict. Data Volatility Options -strong_volatile Affects the generation of code for assignments to objects that are less than or equal to 16 bits in size (for instance char, short) that have been declared as volatile. The generated code includes a load-locked instruction for the enclosing longword or quadword, an insertion of the new value of the object, and a store-conditional instruction for the enclosing longword or quadword. By using this locked instruction sequence for byte and word stores, the -strong_volatile option allows byte and word access of data at byte granularity. This means that assignments to adjacent volatile small objects by different threads in a multithreaded program will not cause one of the objects to receive an incorrect value. -weak_volatile Affects the generation of code for assignments to objects that are less than or equal to 16 bits in size (for instance char, short) that have been declared as volatile. The generated code includes a read of the enclosing longword or quadword, an insertion of the new value of the object, and a store of the enclosing longword or quadword. This is the default. The -weak_volatile option does not generate locked instructions for this sequence. This allows byte or word access to memory-like I/O dev- ices for which larger accesses will not cause read or write side effects. Because the sequence does not access byte or word data independently directly in memory (that is, ensure byte granularity), adjacent volatile data can be corrupted when such byte or word accesses are performed in a multithreaded environment (for example, two volatile shorts stored in a longword and accessed asynchronously). C Language Options -double Promotes expressions of type float to double. This is the default when -std0 is used. -float Prevents the compiler from promoting expressions of type float to type double. This is the default except in -std0 mode. -float_const Causes the compiler to assign the type float (rather than double) to floating-point constants if their values can be represented in single precision. This option is not available in -std1 mode. -readonly_strings Allows the compiler to assume that string literals are read-only. This may improve application performance. This option overrides -writable_strings, which is the default. Attempting to modify string literals when -readonly_strings is speci- fied may yield unpredictable results (for example, a segmentation fault). -signed Causes all char declarations to have the same representation and range of values as signed char declarations. This is used to override a pre- vious -unsigned option. This is the default. -unsigned Causes all char declarations to have the same representation and range of values as unsigned char declarations. -varargs Prints warnings for all lines that may require the macros. -volatile Causes all variables to be treated as volatile. -writable_strings Causes all string literals to be writable. This is the default. This option overrides -readonly_strings. Stack-handling and Pointer-handling Options -trapuv Forces all uninitialized stack variables to be initialized with 0xfff58005fff58005. When this value is used as a floating-point vari- able, it is treated as a floating-point NaN and causes a floating-point trap. When it is used as a pointer, an address or segmentation viola- tion usually occurs. -xtaso Causes the compiler to respect #pragma pointer_size directives, which control the size of pointers. These directives are ignored otherwise. Also causes the -taso option to be passed to the linker (if linking). Pointers are 64 bits by default. This option, when used in conjuction with the pointer_size pragmas, allows applications to use 32-bitction pointers. Images built with this option must be linked with the -taso option in order to run correctly. See the Programmer's Guide for infor- mation on #pragma pointer_size. -xtaso_short Same as the -xtaso option, except -xtaso_short also directs the com- piler to allocate 32-bit pointers by default. You can still use 64-bit pointers, but only by the use of pointer_size pragmas. The use of the -xtaso_short option can cause conflicts between the compiler's assumptions about pointer sizes and data layouts and the default values that were in effect when the system libraries were created. See protect_headers_setup(8) for details on how to avoid this conflict. -framepointer Makes all procedures in the source file use $fp (register 15) as the frame pointer. IEEE Floating-point Support Options -fprm c Specifies chopped rounding mode (round toward zero). -fprm d Dynamically sets rounding mode for IEEE floating-point instructions. The dynamic rounding mode is determined from the contents of the floating-point control register and can be changed or read at execution time by a call to write_rnd(3) or read_rnd(3). If you specify -fprm d, the IEEE floating-point rounding mode defaults to round to nearest. -fprm n Specifies normal rounding mode (unbiased round to nearest). This is the default. -fprm m Specifies round toward minus infinity mode. -fptm n Generates instructions that do not trigger floating-point underflow or inexact trapping modes. Any floating point overflow, divide-by-zero, or invalid operation will unconditionally generate a trap. The -fptm n option is the default. -fptm u Generates traps on floating-point underflow as well as overflow, divide-by-zero, and invalid operation. -ieee Ensure support of all portable features of the IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985), including the treatment of denormalized numbers, NaNs, and infinities and the han- dling of error cases. This option also sets the _IEEE_FP C preprocessor macro. If your program must use IEEE signaling features that are not portable across different IEEE implementations, see the ieee(3) reference page for a discussion of how to access them under the Tru64 UNIX operating system. -scope_safe Ensures that any trap (such as floating-point overflow) is reported to have occurred in the procedure or guarded scope that caused the trap. Any trap occurring outside that scope is not reported to have occurred in the procedure or guarded scope, with the exception of well-defined trapb instructions following jsr instructions. F90 flags -1 Executes at least one iteration of DO loops. (FORTRAN 77 DO loops are not executed if the upper limit is smaller than the lower limit.) This option has the same effect as -nof77. -66 Allows extensions that enhance FORTRAN-66 compatibility. This option has the same effect as -nof77. -align commons Aligns all COMMON block entities on natural boundaries up to 4-bytes instead of the default byte boundary. The default is -align nocommons. -align dcommons Aligns all COMMON block entities on natural boundaries up to 8-bytes instead of the default byte boundary. The default is specify -align records (the default) and -align dcommons. -align norecords Aligns fields within record structures and components of derived types (Fortran 90 only) on the next available byte boundary instead of the default natural boundaries. The default is -align records. -align recNbyte Fortran 90 only. Aligns fields of records and components of derived types on the smaller of the size boundary specified (N can be 1, 2, 4, or 8) or the boundary that will naturally align them. Specifying -align recNbyte does not affect whether com- mon blocks are naturally aligned or packed. -align sequence Fortran 90 only. Specifies that components of a SEQUENCEd derived type are to be aligned according to the alignment rules set by the user. The default alignment rules are to align unse- quenced components on natural boundaries. The default is -align nosequence, which causes components of a SEQUENCEd derived type to be packed, regardless of the current alignment -annotations Fortran 90 only. Requests that annotations be added to the source listing indicating which of a set of optimizations were applied to particular parts of the source. Annotation keywords may exist for optimizations not supported on this platform. Annotations can be helpful in understanding why the compiler was unable to optimize a particular code sequence or to see what optimizations were performed. The following are -annotations options: + -annotations all + -annotations none + -annotations code + -annotations detail + -annotations inlining + -annotations loop_transforms + -annotations loop_unrolling + -annotations prefetching + -annotations shrinkwrapping + -annotations software_pipelining + -annotations tail_calls + -annotations tail_recursion The default is -annotations none. -arch Determines which version of the Alpha architecture the compiler generates instructions for. The format is: -arch generic | host | ev4 | ev5 | ev56 | ev6 | ev67 | pca56 All Alpha processors implement a core set of instructions, with possible extensions. Some of the instruction set extensions are: BWX - Byte/Word manipulation instructions MAX - Multimedia instructions The Alpha Architecture reference manual describes these exten- sions in detail. The -arch option selected determines whether or not the com- piler can generate instructions that are part of these exten- sions. The operating system kernel includes an instruction emulator that allows new instructions, not implemented on the host pro- cessor chip, to execute and produce correct results. Applications using emulated instructions will run correctly, but may incur significant emulation overhead at runtime. The following are -arch options: + -arch generic Generates instructions that are appropriate for most Alpha processors. This is the default. + -arch host Generates instructions for the machine the compiler is run- ning on (for example, ev56 instructions on an ev56 proces- sor and ev4 instructions on an ev4 processor). + -arch ev4 Generates instructions for ev4 processors (for 21064, 20164A, 21066, and 21068 chips). Applications compiled with this option will not incur any emulation overhead on any Alpha processor. + -arch ev5 Applications compiled with this option will not incur any emulation overhead on any Alpha processor. + -arch ev56 Generates instructions for ev56 processors (some 21164 chips). This option permits the compiler to generate any ev4 instruction plus any instruction contained in the BWX extension. Applications compiled with this option may incur emulation overhead on ev4 and ev5 processors, but will still run correctly. + -arch ev6 Generates instructions for ev6 processors (21264 chips). This option permits the compiler to generate any ev6 MAX extension, and square root and floating-point convert extension (FIX). Applications compiled with this option may incur emulation overhead on ev4, ev5, ev56, and pca56 processors, but will still run correctly. + -arch ev67 Generates instructions for ev67 processors (21264A chips). This option permits the compiler to generate any ev67 instruction, including instructions contained in the BWX or MAX extension, the square root and floating-point convert extension (FIX), and count extension (CIX). Applications compiled with this option may incur emulation overhead on ev4, ev5, ev56, ev6, and pca56 processors, but will still run correctly. + -arch pca56 Generates instructions for pca56 processors (21164PC chips). This option permits the compiler to generate any EV4 instruction plus any instruction contained in the BWX or MAX extension. Applications compiled with this option may incur emulation overhead on ev4, ev5, and ev56 processors, but will still run correctly. -assume backslash Fortran 77 only. Treats the backslash (\) character literally in character literals. The default is -assume nobackslash, which treats the backslash character as C-style control (escape) character syntax. -assume bigarrays Fortran 90 only. Suppresses run-time checking for distributed small array dimensions; this increases run-time performance and reduces compile time with the -hpf option. In programs compiled with both the -hpf and -assume bigarrays options, nearest-neighbor computations that reference small arrays will fail. An array is big enough when every dimension that has BLOCK distribution has a shadow edge width that is no bigger than the block size. The default is -assume nobigarrays. -assume buffered_io Fortran 90 only. Tells the compiler to set the default for opening sequential output files to BUFFERED='YES', so that writes to disk will be buffered. The default is -assume nobuffered_io, which means that data will be immediately written to disk. -assume byterecl Specifies (for unformatted data files) that the units for the OPEN statement RECL specifier (record length) value are in bytes, not longwords (four-byte units). For formatted files, the RECL unit is always in bytes. The default is -assume nobyterecl. INQUIRE returns RECL in bytes if the unit is not open. INQUIRE data (and -assume byterecl is not specified); otherwise, it returns RECL in longwords if the file is open for unformatted data (and -assume byterecl is not specified); otherwise, it returns RECL in bytes. -assume cc_omp Fortran 90 only. Enables conditional compilation as defined by the OpenMP Fortran API (when "!$space" appears in free-form source or "!$spaces" appears in column 1 of fixed-form source, the rest of the line is accepted as a Fortran line). If -omp is specified, the default is -assume cc_omp; otherwise, the default is -assume nocc_omp. -assume dummy_aliases Assumes that dummy (formal) arguments to procedures share memory locations with other dummy arguments or with COMMON variables that are assigned. These program semantics slow per- formance and do not strictly obey the FORTRAN 77 Standard. The default is -assume nodummy_aliases. -assume gfullpath Fortran 90 only. Causes the full source file path to be included in the debug information. The default is -assume nog- fullpath. -assume minus0 Fortran 90 only. Tells the compiler to use F95 standard seman- tics for the treatment of IEEE floating value -0.0 in the SIGNrd seman- intrinsic, if the processor is capable of distinguishing the difference between -0.0 and +0.0. The default is -assume nom- inus0, which tells the compiler to use Fortran 90/77 standard semantics in the SIGN intrinsic to treat -0.0 and +0.0 as 0.0. -assume noaccuracy_sensitive Reorders floating-point operations, based on algebraic identi- ties (inverses, associativity, and distribution), to improve performance. The default is -assume accuracy_sensitive. -assume noprotect_constants Fortran 90 only. Specifies that a copy of a constant actual argument is to be passed, so it can be modified by the called routine, even though the Fortran standard prohibits such modif- ication. The constant is not modified in the calling routine. The default is -assume protect_constants, which passes the con- stant actual argument. Any attempt to modify it results in an error. -assume nosource_include files (same as when -vms is used). The default is -assume source_include, which tells the compiler to search the direc- tory the source file is in for any INCLUDEs. -assume nounderscore Does not append a trailing underscore character to external user-defined names: the main program name, named COMMON, BLOCK DATA, and names implicitly or explicitly declared EXTERNAL. The name of blank COMMON remains _BLNK__, and Fortran intrinsic names are not affected. The default is -assume underscore. -assume nozsize Fortran 90 only. Omits run-time checking for zero-sized array sections for increased performance with the -hpf option. In programs compiled with both the -hpf and -assume nozsize options, references to zero-sized array sections cause the exe- cutable to fail or produce incorrect results. The default is -assume zsize. -assume pthreads_lock Fortran 90 only. Tells the compiler to use restrictive locking for unnamed critical sections. Other pthreads are also locked and much faster. It does not lock out other pthreads, but pro- vides a single lock for all unnamed critical sections. -automatic Places local variables on the run-time stack. This option sets the -recursive option. The default is -noautomatic. -C Generates code to perform run-time checks on array subscript and character substring expressions (same as the -check bounds option). An error is reported if the expression is outside the dimension of the array or the length of the string. The default is -check nobounds. -c Suppresses the loading phase of the compilation and forces an object file to be produced even if only one program is com- piled. If you specify multiple files and want full interpro- cedural optimizations, you must also specify the -o option. (This creates a single .o file.) -call_shared Tells ld(1) to produce a dynamic executable that uses shareable objects during run-time. The linker searches for unresolved references in shared library (.so) files before searching in bring in all required shareable objects and resolve any symbols that remained undefined during static link-time. This is the default. -ccdefault Fortran 90 only. Specifies the type of carriage control used when a file is displayed at a terminal. The format is: -ccdefault fortran | list | none | default The following are -ccdefault options: + -ccdefault fortran Specifies normal Fortran interpretation of the first char- acter. + -ccdefault list Specifies one line feed between records. + -ccdefault none + -ccdefault default Specifies that the compiler is to use the default carriage-control setting. This is the default. The default setting can be affected by the -vms option: if "-vms -ccdefault default" is specified, carriage control defaults to FORTRAN if the file is formatted, and the unit is connected to a terminal; if "-novms -ccdefault default" is specified, carriage control defaults to LIST. -check arg_temp_created Fortran 90 only. Generates code to check if actual arguments are copied into temporary storage before routine calls. If a copy is made at run-time, an informative message is displayed. The default is -check noarg_temp_created. -check bounds Generates code to perform run-time checks on array subscript and character substring expressions. An error is reported if the expression is outside the dimension of the array or the -check format Issues the run-time FORVARMIS fatal error when the data type of an item being formatted for output does not match the format descriptor being used (for example, a REAL*4 item formatted with an I edit descriptor). If -vms is specified, the default is -check format; otherwise, the default is -check noformat. With -check noformat, the data item is formatted using the specified descriptor unless the length of the item cannot accommodate the descriptor (for example, it is still an error to pass an INTEGER*2 item to an E edit descriptor). -check nopower Suppresses the run-time errors for 0.0**0.0 and **, so 0.0**0.0 is 1.0 and (-3.0)**3.0 is -27.0. The default is -check power, which causes fatal run-time errors for these cases. -check omp_bindings Fortran 90 only. Provides run-time checking to enforce the OpenMP binding rules. The default is -check noomp_bindings. -check output_conversion Issues the run-time OUTCONERR continuable error message when a data item is too large to fit in a designated format descriptor field. The field is filled with asterisks (*) and execution continues. If -vms is specified, the default is -check output_conversion; otherwise, the default is -check nooutput_conversion. -check overflow Generates code to trap on integer overflow. The default is -check nooverflow. -check underflow Produces a message at run time to warn that floating-point underflow has occurred. Floating-point underflow replaces the result with 0, unless you specify the -fpe3 or -fpe4 option. The default is -check nounderflow. -check_bounds Generates code to perform run-time checks on subscript and sub- string expressions (same as the -check bounds option). An error is reported if the expression is outside the dimension of the array or the length of the string. The default suppresses range checking. range checking. -col72 Treats the statement field of each source line as ending in column 72 (same as the -noextend_source option). -convert Determines which format is used to read and write unformatted files. The -convert options are described below. For more information on these options, see your user manual. The default is -convert native. The following are -convert options: + -convert big_endian Specifies that unformatted data will be in big endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; and IEEE floating point format of the appropriate size: REAL*4, REAL*8, COMPLEX*8, or COM- PLEX*16. Note that INTEGER*1 data is the same for little endian and big endian. + -convert cray Specifies that unformatted data will be in big endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; and CRAY (TM) floating-point for- mat of size REAL*8 or COMPLEX*16. + -convert fdx Specifies that unformatted data will be in little endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; Compaq VAX floating-point format F_floating for size REAL*4 or COMPLEX*8, D_floating for size REAL*8 or COMPLEX*16, and X_floating for REAL*16. + -convert fgx Specifies that unformatted data will be in little endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; Compaq VAX floating-point format F_floating for size REAL*4 or COMPLEX*8, floating-point format G_floating of size REAL*8 or COMPLEX*16, and X_floating for REAL*16. + -convert ibm Specifies that unformatted data will be in big endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; and IBM (TM) System\370 floating- point format of size REAL*4 or COMPLEX*8 (IBM short 4) and size REAL*8 or COMPLEX*16 (IBM long 8). + -convert little_endian Specifies that unformatted data will be in native RISC lit- tle endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; and IEEE floating-point format of the appropriate size: REAL*4, REAL*8, REAL*16, COMPLEX*8, or COMPLEX*16. Note that INTEGER*1 data is the same for little endian and big endian. + -convert native Specifies that unformatted data should not be converted. This is the default. + -convert vaxd Specifies that unformatted data will be in little endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; and Compaq VAX floating-point format F_floating for size REAL*4 or COMPLEX*8, D_floating for size REAL*8 or COMPLEX*16, and H_floating for REAL*16. + -convert vaxg Specifies that unformatted data will be in little endian integer format of the appropriate size: INTEGER*1, INTEGER*2, or INTEGER*4; and Compaq VAX floating-point for- mat F_floating for size REAL*4 or COMPLEX*8, floating-point format G_floating of size REAL*8 or COMPLEX*16, and H_floating for REAL*16. -cord Runs the cord(1) procedure-rearranger on the resulting file after linking. This rearrangement reduces the cache conflicts of the program's text. The output of cord(1) is left in the file specified by the -o output option (or a.out, by default). At least one -feedback file must be specified. -cross_reference Fortran 77 only. Includes in the listing (if one is generated with -V), a cross-reference of all symbols used in the source program, along with line numbers of definitions and uses (same as the -show xref option). The default is -nocross_reference. -Dname=def -Dname Defines the name as def for use by either cpp(1) or Fortran conditional compilation (Fortran 90 only). def can be an integer or it can be a character string delimited by double quotes; for example, -Dname="string". For cpp(1), the defini- tion is interpreted as if by #define. If no definition is given, the name is defined as "1". -distribute num Fortran 90 only. Specifies the number of processors that do not share memory on which the program will execute. Option -hpf must also be set. Specifying "-hpf -distribute num" is the same as specifying -hpf num. -double_size 64 and intrinsics as REAL*8. It also defines DOUBLE COMPLEX declarations, constants, functions, and intrinsics as COM- PLEX*16. This is the default. -double_size 128 Defines DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL*16. For f90 and f95, it also defines DOUBLE COMPLEX declarations, constants, functions, and intrin- sics as COMPLEX*32. The default is -double_size 64. -d_lines Compiles lines having a D in column 1 of the source program. The default is to treat such lines as comments. -error_limit num Specifies the maximum number of error-level or fatal-level com- piler errors allowed for a file specified on the command line. If you specify -noerror_limit, there is no limit on the number of errors that are allowed. The default is -error_limit 30 (a maximum of 30 error-level and fatal-level messages). If -c is specified on the command line and the maximum number of errors is reached, a warning message is issued and the next specified, a warning message is issued and compilation terminates. -extend_source Treats the statement field of each source line as ending in column 132, instead of column 72. The default is -noextend_source. In Fortran 90, specifying -extend_source sets the -fixed option. -f66 Applies FORTRAN-66 semantics, such as the execution of at least one iteration of DO loops. This the same as specifying the -nof77 option. The default is -nof66. -f77 Fortran 77 only. Enforces FORTRAN 77 semantics instead of FORTRAN-66 semantics. In Fortran 77, this is the default. -f77rtl Fortran 90 only. Tells the compiler to use the run-time behavior of Compaq Fortran 77 instead of Compaq Fortran. For example, this affects the output form for NAMELIST. The default is -nof77rtl. -fast Sets the following command options that can improve run-time. noaccuracy_sensitive, -math_library fast, -O4 (the default), and -tune host. For f90 and f95, -fast also sets -align sequence, -assume bigarrays, and -assume nozsize. The default is -nofast. If any of the -std options are specified, -align dcommons and -align sequence are not set. -feedback file Specifies the file to be used by cord(1) or the compiler for further optimizations. This file is produced by prof(1) with its -feedback option from an execution of the program produced by pixie(1). -fixed Fortran 90 only. Interprets Fortran source files as fixed (FORTRAN 77 style) source format. By default, source files with the suffix .f90, .F90, or .i90 are assumed to be free format and files with the suffix .f, .for, .FOR, .F, or .i are assumed to be fixed format. -fpconstant Fortran 90 only. Extends the precision of single-precision constants assigned to double-precision variables, to double. -fpe0 or -fpe Terminates a program during run time if a floating-point opera- tion results in overflow, division by zero, or if the operands are denormalized numbers or other exceptional values. Before termination, the compiler issues a message, and creates a core dump file. Calculated denormalized numbers are set to zero. This is the default. In the case of floating-point underflow, the program does not terminate, but continues with the underflow value set to zero. The compiler issues a warning message if -check underflow is set. -fpe1 Continues program execution and generates an Infinity or Nan if a floating-point operation results in overflow, division by zero, invalid data, or underflow. Calculated denormalized numbers are set to zero. In the case of floating-point underflow, the underflow value is set to zero. The compiler issues a warning message if -check underflow is set. -fpe2 Continues program execution if a floating-point operation results in overflow, division by zero, invalid data, or under- flow. Generates a warning message for the first two occurrences. Calculated denormalized numbers are set to zero. In the case of floating-point underflow, the underflow value is set to zero. Upon program completion, the compiler provides a count of how many times each exception occurred. -fpe3 Continues program execution if a floating-point operation results in overflow, division by zero, invalid data, or under- flow. Calculated denormalized numbers are left as is. For underflow, the underflow value is not set to zero, and gra- dual underflow occurs. The compiler issues a warning message if -check underflow is set. -fpe4 Continues program execution if a floating-point operation results in overflow, division by zero, invalid data, or under- flow. Generates a warning message for the first two occurrences. Calculated denormalized numbers are left as is. In the case of floating-point underflow, the underflow value is not set to zero and gradual underflow occurs. Upon program completion, the compiler provides a count of how many times each exception occurred. -fpp Runs fpp(1) on all Fortran files before compiling; it has no effect on compilation of C programs. fpp(1) handles a subset of the functionality of cpp(1). -fprm chopped Causes the compiler to round results of floating-point opera- tions toward zero. -fprm dynamic Allows run-time selection of a rounding mode by calling the write_rnd(3) routine. The read_rnd(3) routine can be used to find the current rounding mode (which is stored in the floating-point control register (fpcr)). If you specify -fprm dynamic without calling the write_rnd(3) routine, the default setting ( -fprm nearest ) is used. -fprm minus_infinity tions toward the next smallest representative value. -fprm nearest Causes the compiler to round results of floating-point opera- tions toward the nearest representable value. This is the default. If the unrounded value is halfway between two representable values, the even value is chosen. -fp_reorder Reorders floating-point operations, based on algebraic identi- ties (inverses, associativity, and distribution), to improve performance. The default is -no_fp_reorder. This option is the same as the -assume noaccuracy_sensitive option. -free Fortran 90 only. Interprets Fortran source files as free so urce format. By default, source files with the suffix .f90, .F90, or .i90 are assumed to be free format and files with the suffix .f, .for, .FOR, .F, or .i are assumed to be fixed for- mat. -fuse_xref Fortran 90 only. Directs the compiler to generate a data file reference database file. This improves the performance of the DEC FUSE Call Graph Browse and Cross-Referencer, which use the database file for their operations. -g0 Prevents symbolic debugging information from appearing in the object file. -g1 Produces traceback information (showing pc to line correlation) in the object file, substantially increasing its size. This is the default. -g2 or -g Produces traceback and symbolic debugging information in the object file. Unless an explicit optimization level has been specified, these options set the -O0 option, which turns off all compiler optimizations and makes debugging more accurate. -g3 Produces traceback and symbolic debugging information in the object file, but does not set an optimization level. This option can produce additional debugging information describing the effects of optimizations, but debugger inaccuracies can occur as a result of the optimizations that have been per- formed. -gen_feedback Directs the compiler to generate code that will produce accu- rate feedback information when profiled. The steps are: 1. f77 -gen_feedback -o x x.f 2. pixie x 3. x.pixie 4. prof x -pixie -feedback x.fb x.Addrs x.Counts 5. f77 -feedback x.fb -O5 -fast -o x x.f -granularity byte Ensures that data of byte size can be accessed from different threads sharing data in memory. The data must be aligned on the natural boundary and declared VOLATILE. -granularity longword Ensures that naturally aligned data of longword size (4 bytes) can be accessed from different threads sharing data in memory. The data must be aligned on the natural boundary and declared VOLATILE. When this option is in effect, attempts to access smaller size data or misaligned data can result in data items that are inconsistently updated for multiple threads. -granularity quadword Ensures that naturally aligned data of quadword size (8 bytes) can be accessed from different threads sharing data in memory. The data must be aligned on the natural boundary and declared VOLATILE. This is the default. When this option is in effect, attempts to access smaller size data or misaligned data can result in data items that are inconsistently updated for multiple threads. -hpf [num] Fortran 90 only. Compiles the program to run in parallel using the Compaq Parallel Software Environment. The optional num parameter specifies the number of processors on which the pro- gram is intended to execute. If a number is not specified, the program will be compiled to execute on any number of proces- sors. More efficient code is generated when num is specified. The following options are relevant to the -hpf option ( for more information on these options, see the Compaq Fortran Parallel Processing Manual for Tru64 UNIX Systems ): -assume bigarrays -assume nozsize -fast -nearest_neighbor -nohpf_main -pprof -show hpf The following options are not compatible with the -hpf option: -cord, -double_size 128, -feedback, -fpe1, -fpe2, -fpe3, -fpe4, -gen_feedback, -om, -omp, -p1, (or -p), -pg. The -C (or -check_bounds or -check bounds) option is compatible with the -hpf option only when optional parameter num is set to 1. When -hpf is used, the hpf_target must be specified either by using the -hpf_target option or by setting the DECF90_HPF_TARGET environment variable. If neither is used, the driver will issue an error message and abort the compila- -hpf_target Fortran 90 only. Specifies the message passing protocol to use between processors for programs running in parallel. The for- mat is: -hpf_target smpi | cmpi | gmpi | pse If this option is used, option -hpf must also be set. The fol- lowing are -hpf_target options: + -hpf_target smpi Refers to the Message Passing Interface (MPI) that comes installed on SC-series systems. It is used in conjunction with the SC's "RMS" software, which provides a set of com- mands for launching MPI jobs, scheduling those jobs on SC clusters, and other miscellaneous tasks. + -hpf_target cmpi Refers to the Compaq MPI, a version of MPI specifically tuned for Alpha; it is distributed as a Compaq layered pro- duct. The Compaq MPI supports only Memory Channel clusters and shared-memory (SMP) machines. + -hpf_target gmpi Causes the compiler to target generic MPI, specifically MPICH 1.2.0 or other libraries compatible with that version of MPICH. MPICH is a public-domain implementation of the MPI specification that is available for many platforms; it can be obtained from: http://www-unix.mcs.anl.gov/mpi/mpich/ MPICH supports many interconnection networks, including Ethernet, FDDI, and other hardware. The use of the gmpi target is officially unsupported. + -hpf_target pse Refers to PSE v1.6 communication. Support for PSE may not be available in future releases. -I Prevents cpp(1) from searching for #include files in the stan- dard directory /usr/include. It also prevents the compiler from searching there for files specified in an INCLUDE state- ment. This option is not related to the Fortran 90 and 95 USE statement. -Idir Directs the search for cpp(1) #include files, files specified in an INCLUDE statement, and files (.mod) for Fortran 90 and 95 module information. The file names must not begin with slash (/). Directories are searched in the following order: (1) the direc- tory preceding the input file name on the command line; (2) the directory specified by the -Idir option; (3) the standard directory /usr/include. (See also the -noinclude option.) -i2 Makes default integer and logical variables 2-bytes long (same as the -integer_size 16 option). The default is -integer_size 32. For optimal performance on Alpha systems, use 4- or 8-byte integer or logical values instead of 2-byte values. -i4 Makes default integer and logical variables 4-bytes long (same asthe -integer_size 32 option). -i8 Makes default integer and logical variables 8-bytes long (same as the -integer_size 64 option). The default is -integer_size 32. -ident Fortran 77 only. Specifies that what(1) style identification strings should be placed in the .o object file. The formats of the strings are: (c)compiler-identification (m)module-name (d)date These strings are always created for Fortran main programs, and when the CDEC$ IDENT statement in source creates a what(1) module identification string. The default is -noident. -inline all Inlines every procedure call that can be inlined while still generating correct code. However, recursive routines will not cause an infinite loop at compile time. This option is meaningful only at optimization levels -O1 and higher -inline manual For Fortran 77, inlines only statement functions. This is the default for optimization levels -O2 and -O3. For Fortran 90, this is the same as the -inline none option. -inline none Suppresses all inlining of routines (same as the -noinline option). For Fortran 77, this is the default for optimization levels -O0 and -O1. For Fortran 90, this is the default for optimization levels -O0, -O1, -O2, and -O3. -inline size Inlines calls where inlining will not significantly increase program size, plus any additional calls that the compiler determines will improve run-time performance. This option was previously called -inline automatic (and -inline space ). This option is meaningful only at optimization levels -O1 and higher. -inline speed Inlines calls that will likely improve run-time performance, even where it may significantly increase the size of the pro- gram. This is the default for optimization levels -O4 and -O5. This option is meaningful only at optimization levels -O1 and higher. -intconstant Fortran 90 only. Uses Fortran 77 rather than Fortran 90 seman- tics to determine kind for integer constants. -integer_size 16 Makes default integer and logical variables 2-bytes long. The default is -integer_size 32. For optimal performance on Alpha systems, use 4- or 8-byte integer or logical values instead of 2-byte values. -integer_size 32 Makes default integer and logical variables 4-bytes long. This is the default. -integer_size 64 Makes default integer and logical variables 8-bytes long. The default is -integer_size 32.gical variables 8-bytes long. The -K Keeps temporary files produced by cpp(1) or the compiler. This option does not affect the naming of temporary files. To see the names and locations of the temporary files, specify -v. -L Prevents the linker from searching for libraries in the stan- dard directories. -Ldir Directs the linker to search for libraries in dir before searching the standard directories. -lstring Searches libstring libraries for ld (see ld(1)). This option should be placed at the end of the command line. -ladebug Fortran 90 only. Includes additional symbolic information in the object file for the ladebug(1) debugger. This option enables DECladebug to print and assign to dynamic arrays using standard Fortran syntax, including array sections. -M Tells cpp(1) to generate dependency lists suitable for make(1), instead of the normal output. -machine_code Includes in the listing (if one is generated) a machine language representation of the compiled code. This machine language cannot be assembled. This option is the same as -show code. The default is -nomachine_code. -math_library accurate Specifies that the compiler is to select the version of the math library routine which provides the most accurate result for mathematical intrinsic functions. This is the default. For certain ranges of input values, the selected routine may execute more slowly than if you used -math_library fast. -math_library fast Specifies that the compiler is to select the version of the math library routine which provides the highest execution per- formance for certain mathematical intrinsic functions, such as EXP and SQRT. For certain ranges of input values, the selected routine may not provide a result that is as accurate as -math_library accu- rate (the default setting) provides. -mixed_str_len_arg Fortran 90 only. Tells the compiler that the hidden length passed for a character argument is to be placed immediately after its corresponding character argument in the argument list. The default is -nomixed_str_len_arg, which places the hidden lengths in sequential order at the end of the argument list. -module directory Fortran 90 only. Outputs .mod files to directory. -mp Fortran 90 only. Enables parallel processing using directed decomposition. Parallel processing is directed by inserting !$PAR directives in your source code. This type of parallel processing is for shared memory multiprocessor systems. This option sets the -automatic option. The default is -nomp. -names as_is Causes the compiler to distinguish case differences in identif- iers and to preserve the case of external names. The default is -names lowercase. -names lowercase Causes the compiler to ignore case differences in identifiers and to convert external names to lowercase. This is the default. -names uppercase Causes the compiler to ignore case differences in identifiers and to convert external names to uppercase. The default is -names lowercase. -nearest_neighbor num Fortran 90 only. Enables the nearest neighbor parallel optimi- zation. The optional num parameter specifies the maximum width of the shadow edge to use. If num is not specified, it is set to 10 (the default). This option is only valid if the -hpf option is specified. -noaltparam Disallows the alternate non-standard syntax for PARAMETER statements. This form has no parentheses surrounding the list, and the form of the constant, rather than implicit or explicit typing, determines the data type of the variable. The default is -altparam. -nocpp Does not run cpp(1) on any Fortran source files before compil- ing. -noD Fortran 90 only. Tells the driver not to pass any -Dname or -Uname options to the compiler. The default is to pass these to the compiler. These options are always passed to cpp(1). -noerror_limit Specifies that there is no limit to the number of error-level or fatal-level compiler errors allowed for a file specified on the command line. -nof77 Allows extensions that enhance FORTRAN-66 compatibility. This option is the same as the -f66 option. -nofor_main Specifies that the main program is not written in Fortran, and prevents the compiler from linking for_main.o into applica- tions. The default is -for_main. -nofpp Does not run fpp(1) (or cpp(1)) on Fortran source files before compiling. -no_fp_reorder This option is the same as the -assume accuracy_sensitive option. -nohpf_main Fortran 90 only. Specifies that the HPF global routine being compiled will be linked with a main program that was not com- piled with -hpf. The main program can be a Fortran program compiled without -hpf, or it can be written in an entirely dif- ferent language. -noi4 Makes default integer and logical variables 2-bytes long (same as the -integer_size 16 option). For optimal performance on Al pha systems, use 4- or 8-byte integer or logical values instead of 2-byte values. -noinclude Prevents the compiler from searching in /usr/include for files specified in a Compaq Fortran INCLUDE statement. You can specify the -Idir option along with this option. This option does not affect cpp(1) behavior, and is not related to the For- tran 90 and 95 USE statement. -non_shared Prevents ld(1) from producing a dynamic executable. The linker will search regular archive library (.a) files to resolve unde- fined references; .so files are not searched. Object files (.o suffix) from archives are included in the executable pro- duced. The default is -call_shared. -nonearest_neighbor Fortran 90 only. Disables the nearest neighbor parallel optim- ization. -nopipeline Disables the use of instruction scheduling for certain inner- most loops. Also disables prefetching of data to reduce the impact of cache misses. This option must be specified if you want this type of optimi- zation disabled and you are also specifying -O5, since -pipe- line is performed by default at the -O5 level of optimization. -norun Directs the driver not to execute the compiler and other phases of the process. If you use this option with the -v option, you can see what would have been executed. -notransform_loops Disables a group of loop transformation optimizations that apply to array references within loops. This group of optimi- zations includes loop blocking, loop distribution, loop fusion, loop interchange, loop scalar replacement, and outer loopt unrolling. This option must be specified if you want this type of optimi- zation disabled and you are also specifying -O5, since -transform_loops is performed by default at the -O5 level of optimization. -nowsf_main Fortran 90 only. This option is the same as -nohpf_main. -O0 Disables all optimizations. Does not check for unassigned vari- ables. -O1 Enables local optimizations and recognition of common subex- pressions. Optimizations include integer multiplication and division expansion using shifts. The call graph determines the order of compilation of procedures. -O2 Enables global optimization and all -O1 optimizations. This includes code motion, strength reduction and test replacement, split lifetime analysis, code scheduling, and inlining of arithmetic statement functions. -O3 Enables global optimizations that improve speed at the cost of increased code size, and all -O2 optimizations. Optimizations include integer multiplication and division expansion (using shifts), loop unrolling, and code replication to eliminate branches. (See also the -unroll option.) -O4 or -O Enables inline expansion of small procedures, software pipelin- ing, and all -O3 optimizations. This is the default. However, if you specify the -g option, the default is -O0. (See also the -g2 or -g option, and the -inline option.) Software pipelining 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. This type of optimization can also be specified by using the -pipeline option. (See also the -pipe- line option.) -O5 Enables loop transformation optimizations, all -O4 optimiza- tions, and other optimizations, including byte-vectorization, and insertion of additional NOPs (No Operations) for alignment of multi-issue sequences. (See also the -speculate options.) Loop transformation optimizations are a group of optimizations that apply to array references within loops. These optimiza- tions can improve the performance of the memory system and can apply to multiple nested loops. This type of optimization can also be specified by using the -transform_loops option. (See also the -transform_loops option.) To determine whether using -O5 benefits your particular pro- gram, time program execution for the same program compiled with -O4 and -O5. -o output Names the final output file output. The a.out file is unaf- fected. -old_f77 Fortran 77 only. Tells the f77 driver to execute the Compaq Fortran 77 compiler instead of the Compaq Fortran ( f90 ) compiler. -old_f77 must be the first option on the f77 command line. The default is for the f77 command to execute the f90 compiler and use the f90 environment variables. The f77 command now executes the Compaq Fortran 90 compiler by default. If you want to use the Compaq Fortran 77 compiler, you must use the -old_f77 option with the f77 command. To make the f77 command execute the Compaq Fortran 77 compiler by default, change the /usr/bin/f77 link to point to /usr/lib/cmplrs/fort/fort . -om Performs code optimization after linking, including NOP (No Operation) removal, .lita removal, and reallocation of common symbols. This option also positions the global pointer register so the maximum addresses fall in the gp-accessible window. The -om option is supported only for programs compiled with the -non_shared option. The following options can be passed directly to -om by using the -WL compiler option: + -WL,-om_compress_lita Removes unused .lita entries after optimization, and then compresses the .lita section. + -WL,-om_dead_code Removes dead code (unreachable instructions) generated after applying optimizations. The .lita section is not compressed by this option. + -WL,-om_no_inst_sched Turns off instruction scheduling. + -WL,-om_no_align_labels Turns off alignment of labels. Normally, the -om option quadword aligns the targets of all branches to improve loop performance. + -WL,-om_Gcommon,num Sets the size threshold of common symbols. Every common symbol whose size is less than or equal to "num" will be allocated close to each other. This option can be used to improve the probability that the symbol can be accessed directory from the global pointer register. Normally, the -om option tries to collect all common symbols together. -omp Fortran 90 only. Enables parallel processing using directed decomposition following the OpenMP application program inter-irected face (API). Parallel processing is indicated by inserting !$OMP directives in your source code. This type of parallel processing is for shared memory multiprocessor systems. This option sets the -automatic option. The default is -noomp. -onetrip Executes at least one iteration of DO loops. (FORTRAN 77 DO loops are not executed if the upper limit is smaller than the lower limit.) This option has the same effect as -nof77. -P Runs only cpp(1) and puts the result for each source file in a corresponding .i (or Fortran 90 .i90) file, after processing by any appropriate preprocessors. The .i (or .i90) file does not have line numbers (#) in it. This option sets the -cpp option. -p0 Does not permit profiling. If loading occurs, the standard run-time startup routine (crt0.o) is used, and the profiling libraries are not searched. This is the default. -p1 or -p Sets up profiling by periodically sampling the value of the program counter for use with the postprocessor prof(1). This option only effects loading. When loading occurs, this option replaces the standard run-time startup routine with the profil- ing run-time startup routine (mcrt0.o) and searches the level 1 profiling library (libprof1.a). When profiling occurs, the startup routine calls monstartup(3) (see monitor(3)) and produces the file mon.out, which contains execution-profiling data for use with the postprocessor prof(l). If you specify -p1 or -p, you should also specify -g1 or higher. -pad_source Specifies that source records shorter than the statement field width are to be padded with spaces on the right, out to the end of the statement field. This affects the interpretation of character and Hollerith literals that are continued across source records. The default is -nopad_source. -pg Sets up profiling for gprof(1), which produces a call graph showing the execution of the program. With this option, the standard run-time startup routine is replaced by the gcrt0.o routine, and ld(1) inserts calls to _mcount at each entry label. Programs that are linked with the -pg option and then run, pro- duce the files gmon.out and gmon.sum. File gmon.out contains a dynamic call graph and profile; file gmon.sum contains a sum- a marized dynamic call graph and profile. To display the output, run gprof on the gmon.out file. -pipeline Applies instruction scheduling to certain innermost loops, allowing instructions within a loop to "wrap around" and exe- cute in a different iteration of the loop. This can reduce the impact of long-latency operations, resulting in faster loop execution. This option also enables prefetching of data to reduce the impact of cache misses. It may increase compilation time and/or program size. For pro- grams that contain loops that exhaust available registers, longer execution times may occur. In this case, specify options -unroll 1 or -unroll 2 with the -pipeline option. This option is meaningful only at optimization levels -O2 and higher; it is performed by default if level -O5 is in effect. -pprof string Fortran 90 only. Profiles a parallel application. This option is valid only if the -hpf option is specified, the hpf_target is pse, the -non_shared option is specified, and the -p1 option is not specified. The string can be either of two profilinge -p1 option methods: s - sampling i - interval -pthread Informs the linker to use threaded libraries (see also -reen- trancy keyword options). This option is the same as the -threads option. -r8 Defines REAL declarations, constants, functions, and intrinsics as DOUBLE PRECISION (REAL*8), and defines COMPLEX declarations, constants, functions, and intrinsics as DOUBLE COMPLEX (COM- PLEX*16). This option is the same as the -real_size 64 option. -r16 Defines REAL and DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL*16. For f90 and f95, it also defines COMPLEX and DOUBLE COMPLEX declarations, constants, functions, and intrinsics as COMPLEX*32. This option is the same as the -real_size 128 option. -real_size 32 Defines REAL declarations, constants, functions, and intrinsics as REAL*4, and defines COMPLEX declarations, constants, func-cs tions, and intrinsics as COMPLEX (COMPLEX*8). This is the default. -real_size 64 Defines REAL declarations, constants, functions, and intrinsics as DOUBLE PRECISION (REAL*8), and defines COMPLEX declarations, constants, functions, and intrinsics as DOUBLE COMPLEX (COM- PLEX*16). The default is -real_size 32. -real_size 128 Defines REAL and DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL*16. For f90 and f95, it also defines COMPLEX and DOUBLE COMPLEX declarations, constants, functions, and intrinsics as COMPLEX*32. The default is -real_size 32. -recursive Compiles all FUNCTION and SUBROUTINE procedures for possible recursive execution. The default is -norecursive. For f90 and f95, this option sets the -automatic option. -reentrancy asynch Tells the Compaq Fortran RTL that the program may contain asyn- chronous (AST) handlers that could call the RTL. This causesyn- the RTL to guard against AST interrupts inside its own critical regions. -reentrancy none Tells the Compaq Fortran RTL that the program will not be rely- ing on threaded or asynchronous (AST) reentrancy. So, the RTL will not guard against such interrupts inside the RTL. This is the default. This option is the same as the -noreentrancy option. -reentrancy threaded Tells the Compaq Fortran RTL that the program is multithreaded, such as programs using the DECthreads library. This causes the RTL to use thread locking to guard its own critical regions. -S Creates an assembleable listing file of the compiled source. The name of this listing file is the base name of the source file with a .s substituted for the .f90, .F90, .f, .for, .FOR, or .F. No link step occurs. You cannot generate a -S listing and a -V or -source_listing listing in the same compilation. -shared Produces a dynamic shareable object for inclusion in a shared library. This includes creating all of the tables for run-time linking and resolving references to other specified shared objects. The object created can be used by the linker to pro- duce a shareable object that other dynamic executables can use at run-time. If you also specify the -c option, a .o file is created; other- wise, a .so file is created. The default is -call_shared. -show code Includes in the listing (if one is generated) a machine language representation of the compiled code (same as the -machine_code option). This machine language cannot be assem- bled. The default is -show nocode. -show hpf[option] Fortran 90 only. Sends information related to parallelization to standard error and to the listing (if one is generated). These options are not valid unless option -hpf is also in effect. The following options are available: + -show hpf Includes a selected subset of the messages generated by all the other -show hpf_* options. It is usually best to try using this option first. Use the others only when a more detailed listing is needed. + -show hpf_comm Includes information about statements which cause interpro- cessor communication to be generated. + -show hpf_indep Includes information about the optimization of loops marked with the INDEPENDENT directive. + -show hpf_nearest Includes information about arrays and statements involved in optimized nearest-neighbor computations. + -show hpf_punt Includes information about distribution directives that were ignored and statements that were not handled in parallel. + -show hpf_temps Includes information about temporaries that were created at procedure interfaces. + -show hpf_all This option is the same as specifying all the other -show hpf_* options. -show can take only one argument. However, the -show options can be combined by specifying -show multiple times. For exam- ple: % f90 -hpf -hpf_target cmpi -show hpf_near -show hpf_punt foo.f90 -show hpfinfo Fortran 90 only. This option is the same as -show hpf_all. -show include Includes in the listing (if one is generated) any text file specified with INCLUDE in the source program. The default is -show noinclude. -show nomap Excludes from the listing (if one is generated) information about the symbols used in the source program. The default is -show map. -show wsfinfo Fortran 90 only. This option is the same as -show hpfinfo (and -show hpf_all). -show xref Fortran 77 only. Includes in the listing (if one is generated) a cross-reference of all symbols used in the source program, along with line numbers of definitions and uses (same as the -cross_reference option). The default is -show noxref. -source_listing Creates a source listing file with various compile-time infor- mation appended, like -V. The name of the listing file is the basename of the source file with a .lis suffix. The default is is the -nosource_listing. -speculate all Performs speculative execution optimization on all routines in the program. Speculation occurs when a conditionally executed instruction is moved to a position before a test instruction so that the moved instruction is then executed unconditionally. This reduces instruction latency stalls, but performance can be reduced because the run-time system must dismiss exceptions caused by speculative instructions. Speculation affects code most noticeably at optimization levels -O3 and higher. Any exception (for example: SIGSEGV, SIGBUS, or SIGFPE), any- where in the entire program, is assumed to be speculative. All of these exceptions are quietly dismissed without calling any user-mode signal handler. If a module is compiled using -speculate all, it cannot be linked with any other module or library that does its own exception processing. Since speculation turns off some run-time error checking, this option should not be used while debugging or while testing for errors. The default is -speculate none. -speculate by_routine Performs speculative execution optimization on all routines in the current module, but this optimization will not effect rou- tines in other modules in the program. Requires DIGITAL UNIX Version 4.0 or higher. -speculate none Suppresses all speculative execution optimization (same as the -nospeculate option). This is the default. -stand mia Fortran 77 only. Controls whether the compiler suppresses diagnostic messages for extensions to the ANSI FORTRAN 77 standard that are included in the NTT Technical Requirement TR550001, Multivendor Integration Architecture (MIA) Version 1.1, Division 2, Part 3-2, Programming Language FORTRAN. This option enables syntax checking ( -stand syntax ) to be per- formed. The default is -stand nomia. -stand semantic Fortran 77 only. Causes the compiler to issue informational messages for statements that conform to the ANSI Standard but become nonstandard because of how they are used. This option sets the -stand syntax option. The default is -stand noseman- tic. -stand source_form Fortran 77 only. Causes the compiler to issue informational messages for statements that use tab formatting or contain lowercase characters outside of character literals and com- ments. The default is -stand nosource_form. -stand syntax Fortran 77 only. Causes the compiler to issue informational messages for syntax extensions to the ANSI Standard. The default is -stand nosyntax. -static Causes all local variables to be statically allocated (same as the -noautomatic option). This is the default. -std Produces warnings for things that are not standard in the Produces warnings for things that are not standard in the language. The default is -nostd. For Fortran 77, specifying -std is the same as specifying options -stand semantic -standecifying syntax. When -std is specified, the compiler being used determines the standard checked; for example: specifying "f95 -std" is the same as specifying "f90 -std95". -std90 Fortran 90 only. Produces warnings for things that are not standard in the Fortran 90 language. -std95 Fortran 90 only. Produces warnings for things that are not standard in the Fortran 95 language. -synchronous_exceptions Causes the compiler to generate TRAPB instructions after every floating-point instruction. -fpe0 must also be enabled. This is a very expensive but effective way to synchronize the instruction stream containing floating-point exceptions so the failing instruction can be accurately located by the debugger or a handler. The default is -nosynchronous_exceptions. -syntax_only Specifies that the source file will be checked only for correct syntax. No code is generated, no object file is produced, and some error checking done by the optimizer is bypassed (for example, checking for uninitialized variables). This option lets you do a quick syntax check of your source file. The default is -nosyntax_only. -threads Informs the linker to use threaded libraries (see also -reen- trancy keyword options). This option is the same as the -pthread option. -transform_loops Specifies a group of loop transformation optimizations that apply to array references within loops. These optimizations can improve the performance of the memory system and usually apply to multiply nested loops. These optimizations include: Loop blocking Loop distribution Loop fusion Loop interchange Loop scalar replacement Outer loop unrolling The loops chosen for loop transformation optimizations are always "counted" loops (which include DO or IF loops, but not DO WHILE loops). Conditions that typically prevent the loop transformation optimizations from occurring include subprogram references that are not inlined (such as an external function call), compli- cated exit conditions, and uncounted loops. This type of optimization can be specified for optimization levels -O2 and higher; it is performed by default if -O5 is in effect. To determine whether using -transform_loops benefits your par- ticular program, you should time program execution for the same program (or subprogram) compiled at -O4. -tune Selects processor-specific instruction tuning for implementa- -tune generic | host | ev4 | ev5 | ev56 | ev6 | ev67 | pca56 Regardless of the setting of the -tune option, the generated code will run correctly on all implementations of the Alpha architecture. Tuning for a specific implementation can improve run-time performance; it is also possible that code tuned for a specific target may run slower on another target. The fol- lowing are -tune options: + -tune generic Selects instruction tuning that is appropriate for all implementations of the Alpha architecture. This is the default. + -tune host Selects instruction tuning that is appropriate for the machine the compilation is occurring on. + -tune ev4 Selects instruction tuning for the 21064, 20164A, 21066, and 21068 implementations of the Alpha architecture. + -tune ev5 Selects instruction tuning for the 21164 implementation of the Alpha architecture. + -tune ev56 Selects instruction tuning for ev56 processors (some 21164 chips). + -tune ev6 Selects instruction tuning for ev6 processors (21264 chips). + -tune ev67 Selects instruction tuning for ev67 processors (21264A chips). + -tune pca56 + -tune pca56 Selects instruction tuning for pca56 processors (21164PC chips). When -arch name is specified and no -tune option is specified, the following occurs: if -fast is specified, then -tune is host and -arch is name; if -fast is not specified, then both -tune and -arch are name. If you set -tune to an architecture that has fewer features than what -arch specifies, the compiler will reset -tune to the same architecture as -arch. -U Causes the compiler to distinguish between uppercase and lower- case letters in identifiers and external names. This option is the same as the -names as_is option. -Uname Tells cpp(1) to remove any initial definition of name. -u Sets the default type of a variable as undefined (IMPLICIT NONE), which causes the compiler to issue a warning for any undeclared symbols (same as the -warn declarations option). This behavior differs from default FORTRAN 77 rules. This behavior differs from default FORTRAN 77 rules. -unroll num Sets the depth of loop unrolling done by the optimizer (at lev- els -O3 and above) to num. It must be an integer in the range 0 through 16. -nounroll is not allowed. The default is -unroll 0 (where the optimizer uses its default unroll amount). -V Creates a source listing file with various compile-time infor- mation appended. The name of the listing file is the basename of the source file with a .l suffix. The default is -noV. How you compile source files determines how the listing file is created. If you compile several source files together, one listing file is created (named with the basename of the first input file and the .l suffix). If you compile source files one at a time, a separate listing file is created for each input file (named with the basename of the input file and the .l suf- fix). -v Prints the passes as they execute with their arguments and their input and output files. Also prints final resource usage in the C-shell time format. The default is -nov. -version Prints the version strings of the Fortran command and compiler. -versi If -version only is specified on the command line, the compiler is not executed. The default is -noversion. This option has the same affect as -what. -vms Causes the run-time system to behave like Compaq Fortran on OpenVMS VAX systems (VAX FORTRAN) in the following ways: + Reinforces certain defaults Reinforces the following Compaq Fortran 77 defaults: -fpe0, -static, -names lowercase (so A is equivalent to a), and -norecursive. You can override this by specifying the option on the command line. For example, if you specify -vms -fpe2, you get -fpe2. The -vms option also forces -check format and -check output_conversion. + Alignment -vms does not affect the alignment of fields in records or items in COMMON. Use -align norecords to pack fields of records on the next byte boundary for compatibility with Compaq Fortran on OpenVMS VAX systems. + INCLUDE qualifiers Recognizes /LIST and /NOLIST at the end of the file path- name in an INCLUDE statement at compile time. If the file name in the INCLUDE statement does not specify the complete path, the path used is the current directory. + Quotation mark character (") Recognizes a quotation mark as starting an octal constant (such as "177) instead of a character literal ("..."). + Control character syntax Does not recognize the \n control character syntax in char- acter literals (same as the -assume backslash option). + Deleted records in relative files When a record in a relative file is deleted, the first byte of that record is set to a known character (currently '@'). Attempts to read that record later result in ATTACCNON errors. The rest of the record (the whole record, if -vms is not set) is set to nulls for unformatted files and spaces for formatted files. + ENDFILE records When an ENDFILE is performed on a sequential unit, an actual one byte record containing a Ctrl/D is written to the file. If -vms is not set, an internal ENDFILE flag is set and the file is truncated. The -vms option does not affect ENDFILE on relative files; such files are truncated. + Reading deleted records and ENDFILE records The run-time direct access READ routine checks the first byte of the retrieved record. If this byte is '@' or NULL ("\0"), then ATTACCNON is returned. The run-time sequential access READ routine checks to see if the record it just read is one byte long and contains a Ctrl/D. If this is true, it returns EOF. + OPEN effects Carriage control defaults to FORTRAN if the file is format- ted, and the unit is connected to a terminal (checked by means of isatty(3) ). Otherwise, carriage control defaults to LIST. The -vms option affects the record length for direct access and relative organization files. The buffer size is increased by one (to accommodate the deleted record charac- ter). + Implied logical unit numbers Recognizes certain environment variables at run time for ACCEPT, PRINT, and TYPE statements, and for READ and WRITE statements that do not specify a unit number, such as: READ (*,1000). For more information, see your user manual. + Treatment of blanks in input Causes the defaults for keyword BLANK in OPEN statements to become 'NULL' for an explicit OPEN, and 'ZERO' for an implicit OPEN of an external or internal file. -Wl,arg1[,arg2]... Passes options arg1[ arg2]... to cc(1) for ld(1). -Wp,arg1[,arg2]... Passes options arg1[ arg2]... to cpp(1) that the driver does not normally pass to the preprocessor. For example: -Wp,-C,-M passes -C -M to cpp(1). -Wp,... does not invoke cpp(1); use -cpp to force the execution of cpp(1). -w Disables all warning messages (same as the -nowarn and -warn -nogeneral options). -w1 Disables warnings about unused variables (same as the -warn nounused option). -warn argument_checking Enables warnings about mismatched procedure arguments. The default is -warn noargument_checking. -warn declarations Sets the default type of a variable as undefined (IMPLICIT NONE), which enables warnings about any undeclared symbols. This behavior differs from default FORTRAN 77 rules. The default is -warn nodeclarations. -warn ignore_loc Enables warnings when %loc is stripped from an argument. The default is -warn noignore_loc. -warn hpf Fortran 90 only. Tells the compiler to do both syntactic and semantics checking on HPF directives. The default is -warn nohpf, unless -hpf is specified, in which case -warn hpf is assumed. -warn noalignments Disables warnings about data that is not naturally aligned. The default is -warn alignments. -warn nogeneral Disables all warning messages (same as the -nowarn and -w options). The default is -warn general. -warn nogranularity Fortran 90 only. Disables warnings when the compiler cannot generate code for a requested granularity. The default is -warn granularity. -warn noinformational Fortran 77 only. Disables all informational messages. The default is -warn informational, unless you also specify -warn nogeneral. In this case, no warning or informational messages are displayed. -warn nouncalled Disables warnings about a statement function that is never called. The default is -warn uncalled. -warn nouninitialized Disables warnings about a variable that is used before a value is assigned to it. The default is -warn uninitialized. -warn nounreachable Fortran 77 only. Disables warnings about a section of code that is unreachable (no path to it). The default is -warn unreachable. -warn nousage Disables warnings about questionable programming practices which, although allowed, often are the result of programming errors. For example, a continued character or Hollerith literal whose first part ends before the statement field and appears to end with trailing spaces. The default is -warn usage. -warn truncated_source Enables warnings at compile time about source characters to the right of column 80 (or column 132 if -extend_source is speci- fied) in a non-comment line. The default is -warn notruncated_source. -warn unused Enables warnings about unused variables. The default is -warn nounused. -warning_severity error Fortran 90 only. Turns all messages that are normally warnings into errors. -warning_severity stderror in Fortran 90 only. Issues an error message instead of a warning for standard violations. Standard violations are detected when the -std option is specified. -what Prints the version strings of the Fortran command and the com- piler. If -what appears alone on the command line, the com- piler is not executed. -wsf [num] Fortran 90 only. This option is the same as -hpf. -wsf_target Fortran 90 only. This option is the same as -hpf_target. The driver ignores the following options and displays an informative mes- sage saying they are unsupported: -align8 -align16 -align32 Allows misalignment in COMMON. -col120 Truncates source after column 120. Pixie Flags Essential Options Some or all of these options may be needed to prevent the instrumented pro- gram malfunctioning: -pthread Specify -pthread if the program or any of its libraries calls pthread_create(3)--for example if it was compiled with either the -pthread option or the -threads compatibility option. This will make the collection of profile data thread-safe. -fork Specify -fork if the program calls any variant of fork(2). It is not usually needed if the subprocesses also call any variant of exec(2). The -fork option ensures that forked multi-threaded programs are pro- file names as if -pids was specified. Failure to use -fork might lead to deadlock in the forked child processes. On Tru64 UNIX V4.0* systems, deadlock can still occur even when -fork is used. -heapbase addr By default the pixie code running in the program's process allocates memory for its own use at address 38000000000. If the program needs to use memory between 38000000000 and 3ff00000000, specify the hexadecimal address that the pixie code should use. -sigdump signal Specify -sigdump to force the instrumented program to write the current profile data to its file(s) on receipt of the named signal. By default, the program writes the profiling data file(s) only when the process terminates, but some processes never terminate normally, so this option lets you generate the file(s) on demand. After a file is written, the instruction-counts of the profile are all set to zero, so by sending two signals, any interval of a test run can be profiled, with the second signal's file(s) overwriting the first. For example, to purpose. -E proc Does not instrument the procedure proc, and excludes its instruction execution count from the total for the program--for example, to exclude uninteresting procedures or procedures (such as non-standard assembly code) that instrumentation would interfere with. If you tell pixie to display the profile, prof's -Exclude option is implied. File Generating Options -quiet Prevents informational and progress messages from being printed. -v Prints the command lines used to instrument the program and to execute the instrumented program. -output file Names the instrumented program file instead of the default program.pixie. -dirname path Specifies the directory to which the instrumented program writes the profiling data file(s) for each test run. The default is the current directory. -pids Adds the process-id of the instrumented program's test run to the name of the profiling data file produced (that is, program.Counts.pid). By default, the file is named program.Counts. -threads When profiling a threaded program, specify -threads to produce a separate profile for each pthread in the program. The files are named program.Counts[.pid].sequence, where sequence is the thread sequence number assigned by pthread_create(3). The -threads option implies the -pthread option for thread-safe profiling.If -sigdump is needed, -pthread is recommended instead of -threads, to avoid possible syn- chronization problems. Shared-Library Profiling Options -all Profiles all the shared libraries in addition to the program's execut- able. -excobj lib If -all was specified, does not profile the shared library lib. Can be repeated, to exclude multiple libraries. -incobj lib Profiles the shared library lib. Can be repeated to include multiple libraries. -Lpath Searches for shared-libraries in the named directory before searching the default directories. Can be repeated to make a search path. Use the same options that were used when linking the program with ld. Execution Control Options -version Prints the tool's version number. -run Executes the instrumented program, even if no arguments are specified. By default, the program is just instrumented for later execution. -display Executes the instrumented program, and runs prof with default options on the resulting .Counts file(s). prof-option Executes the instrumented program, and runs prof on the resulting .Counts file(s). The following prof options are supported: -asm Reports the profile as an annotated disassembly. -exclude proc Excludes procedure proc from the profile, but totals all pro- cedures. -feedback file Generates file for cc -feedback optimization. -heavy Reports the lines that executed the most instructions. -invocations -lines Reports the profile per source line within each procedure. -merge file Merges all .Counts files into file. -numbers Prints each procedure's starting line number. -only proc Includes only procedure proc in the profile, but totals all pro- cedures. -Only proc Includes only procedure proc in the profile and in the total. -procedures Profiles the instructions executed in each procedure and the calls to procedures. -quit n [[cum]%] Truncates the report after n lines or after (cumulative) n percent of the whole. -testcoverage Reports lines that were not executed. -totals Profiles the whole executable and any shared libraries. -truecycles n Estimates cycles, assuming cached memory (n=0-2). -update Updates the original program executable (program) with the profil- ing information, for use in future cc -feedback program command(s). This option is not available on Tru64 UNIX V4.0* systems. -zero Reports procedures that were never called. Compatibility Options This syntax (option names and options after program name) is recognized only if no other options and no program arguments are specified, for compa- tibility with DIGITAL UNIX V3 and V4 systems: -[no]quiet [Permits] or suppresses messages summarizing the binary-to-binary translation process. Default: -noquiet. -bbaddrs name Specifies the name of the basic block addresses file. Default: program.Addrs. -bbcounts name Specifies the name of the basic block counts file. Default: program.Counts. -[no]pids [Disables] or enables the addition of the process-id number to the filename of the basic block counts file. This is useful for collecting data for multiple invocations of the instrumented program. Default: -nopids. -o file Specifies the name of the instrumented program. The default is to remove any leading directory names from program and append .pixie. Spike Flags -o output_file Names the optimized binary output file. The default file name is a.out. -feedback file Causes spike to use the feedback database stored in file, where file is the name of the input executable. This database is created by first compiling the program with the -feedback option (for example, cc -feed- back prog) and then instrumenting and running the program with the pixie -update or prof -pixie -update command (see cc(1), pixie(1), and prof(1)). -fb file Causes spike to use file.Addrs (basic block addresses file) and file.Counts (basic block counts file) for profile-based optimization. These files are produced by the pixie tool (see pixie(1) and prof(1)). spike can be applied only to V5.1 or later kernels. -kernel Use this option when applying spike to the UNIX kernel (vmunix). -nosplit Disables code layout optimization that splits procedures into multiple parts. -nochain Disables basic block chaining, which arranges code so that the fall through path is the commonly taken path. -noporder Disables procedure ordering. -noaggressiveAlign Reduces the number of padding nops inserted into the code to align -splitThresh n Adjusts the threshold used by procedure splitting in code layout to decide which code is frequently and infrequently executed. The default is .99, which means that the most frequently executed basic blocks that make up at least 99 percent of the estimated execution time are con- sidered frequently executed and the rest are marked as infrequently executed. Increasing the threshold can help when the profile is not representative. For example, try a value of .999. -V Displays the version number of spike.