Intel(R) C++ Compiler 8.0 for Linux --------------------------------------------- Intel(R) C++ compiler options. Used for SGI Altix 3000 and 350 submissions. NAME icc - invokes the Intel(R) C++ compiler SYNOPSIS icc [ options ] file1 [ file2 ...] where: options represents zero or more compiler options. filen is a C/C++ source (.C .c .cc .cpp .cxx .c++ .i .ii), assembly (.s), object (.o), static library (.a), or other linkable file. NOTE: The icpc command uses the same compiler options as the icc command. The icpc invocation assumes any preprocessed source files (.i files) are C++ while the icc command assumes they are C. Commonly used icc options can be placed in the icc.cfg file. Commonly used icpc options can be placed in the icpc.cfg file. DESCRIPTION The Intel(R) C++ Compiler is designed to preprocess, compile, assemble, and link C and C++ programs on systems based on Intel architecture. This man page explains the rudiments of how to use the Intel C++ Compiler to compile and optimize an application. See the Intel C++ Compiler User's Guide for more complete information than is presented here. This man page explains how information and instructions apply differently to IA-32 applications and Itanium(R) architecture-based applications. If a description does not explicitly state a specific architecture, it is appli­ cable to both. gcc* Interoperability C language object files created with the Intel C++ Compiler are binary com­ patible with the GNU* gcc* compiler and glibc, the GNU C language library. This binary compatibility results in the following key features: · C objects generated by icc are interoperable with C objects generated by gcc. · C++ objects generated by icpc using the -cxxlib-gcc option are interop­ erable with C++ objects generated by g++. This means that third-party C++ libraries built by gcc++ will work with C++ objects generated by the Intel C++ Compiler 8.0. · C++ objects generated by icpc without using the -cxxlib-gcc option are not guaranteed to be interoperable with C++ objects generated by g++. · Preprocessor macros predefined by gcc are also predefined by icc. The Intel C++ Compiler 8.0 has made significant improvements towards inter­ operability and compatibility with the GNU gcc compiler. See the Intel C++ Compiler User's Guide for more information. OPTIONS Option Summary All the options listed in the following summary are described in more detail in the sections that follow. Optimization Levels -O1 -O2 -O3 -fast -O -Ob -O0 Floating Point Optimization Options -mp -mp1 -long_double -prec_div -pc{32|64|80} -rcd -fp_port -fpstkchk -ftz -IPF_fma[-] -IPF_fp_specula­ tion{fast|safe|strict|off} -IPF_flt_eval_method0 -IPF_fltacc[-] -falias -fno-alias -ffnalias -fno-fnalias Optimizing Non-Exclusively for Specific Processors -tpp{1|2|5|6|7} -mcpu={pentium|pentiumpro|pentium4|itanium|ita­ nium2} Optimizing Exclusively for Specific Processors -x{K|W|N|B|P} -march={pentium|pentiumpro|pentiumii|pentiumiii|pen­ tium4} Automatic Processor-Specific Optimization (IA-32 Systems Only) -ax{K|W|N|B|P} Interprocedural Optimizations (IPO) -ip -ipo -ipo_c -ipo_S -ip_no_inlining -ip_no_pinlining -ipo_obj -nolib_inline -auto_ilp32 Profile-guided Optimizations (PGO) -prof_gen[x] -prof_use -prof_dir -prof_file -fnsplit[-] High-level Language Optimizations (HLO) -O3 -unroll -ivdep_parallel Vectorization Options (IA-32 Systems Only) -vec_report[{0|1|2|3|4|5}] Auto Parallelization Options -parallel -par_report{0|1|2|3} -par_threshold[] Parallelization with OpenMP* -openmp -openmp_report{0|1|2} -openmp_stubs Optimizer Report Options -opt_report -opt_report_file -opt_report_level[{min|med|max}] -opt_report_routine -opt_report_phase{ipo|hlo|ilo|ecg|omp|all} -opt_report_help Conformance Options -ansi_alias[-] -ansi -strict_ansi -c99[-] -std=c99 -mp Miscellaneous Optimization Options -qp, -p -alias_args[-] -mserialize-volatile -mno-serial­ ize-volatile -complex_limited_range Debugging Options -g -syntax Output Options -P, -F -S -c -use_asm -use_msasm -fcode-asm -fsource-asm -f[no]verbose-asm -fp -o -inline_debug_info Preprocessing Options -A[] -A- -C -D[=] -E -EP -P -I -idirafter -isystem -U -X -nostdinc -no-gcc -H -M -MD -MF -MG -MM -MMD -MX -dM -pch -pch_dir -create_pch -use_pch Specifying Alternate Tools and Paths -Qoption,, -Qlocation,, -Qinstall Precompiled Headers -pch -create_pch -pch_dir -use_pch Language Options -[no]restrict -Kc++ -fno-rtti -[no]align -Zp[n] -fshort-enums -fsyntax-only -funsigned-char -funsigned-bitfields Options for Controlling Compiler Diagnostics -w -w -wn-wd[,,...] -we[,,...] -ww[,,...] -wr[,,...] -Wall -Werror -Wbrief -Wcheck -Wp64 Miscellaneous Options -help -V -dryrun -v -x -sox[-] -fr32 -Kpic, -KPIC -fpic, -fPIC -fvisibility=[extern|default|protected|hidden|internal] -fvisibility-extern= -fvisibility-default= -fvisibil­ ity-protected= -fvisibility-hidden= -fvisibility-inter­ nal= -fwritable-strings -fminshared -fno-common -Knopic, -KNOPIC -nobss_init Linker Options -L -i_dynamic -dynamic-linker -mrelax -mnorelax -no_cpprt -cxxlib-gcc -cxxlib-icc -gcc-name -nodefaultlibs -nos­ tartfiles -nostdlib -static -shared -static-libcxa -shared-libcxa -u -T -Xlinker -Wl,[,,...] Optimization Levels The Intel C++ Compiler applies the following optimizations when you invoke the -O1, -O2, or -O3 options: Constant propagation, copy propagation, dead-code elimination, global register allocation, instruction scheduling, loop unrolling (-O2, -O3 only), loop-invariant code movement, partial redun­ dancy elimination, strength reduction/induction variable simplification, variable renaming, exception handling optimizations, tail recursions, peep­ hole optimizations, structure assignment lowering and optimizations, dead store elimination, and loop-invariant code motion. Depending on the Intel architecture, optimization options can have different effects. To specify optimizations for your target architecture, refer to the following: -O1 Optimize to favor code size and code locality. Disables loop unrolling. -O1 may improve performance for applications with very large code size, many branches, and execution time not dominated by code within loops. In most cases, -O2 is recommended over -O1. IA-32 systems: Disable intrinsics inlining to reduce code size. Itanium architecture-based systems: Disable software pipelining and global code scheduling. -O2 (DEFAULT) Optimize for code speed. This is the generally recommended optimiza­ tion level. Itanium architecture-based systems: Turn software pipelining ON. -O3 Enable -O2 optimizations and in addition, enable more aggressive optimizations such as loop and memory access transformation. The -O3 optimizations may slow down code in some cases compared to -O2 opti­ mizations. Recommended for applications that have loops with heavy use of floating point calculations and process large data sets. IA-32 systems: In conjunction with -ax{K|W|B|P} and -Qx{K|W|B|P} options, this option causes the compiler to perform more aggressive data dependency analysis than for -O2. This may result in longer com­ pilation times. -fast Enhance speed across the entire program. Sets the following command options that can improve run-time performance: -O3, -ipo, and -static. -O Same as -O2 -Ob Control inline expansion, where is one of the following values: 0 -- Disables inlining. 1 -- (DEFAULT) Enables inlining of functions declared with the __inline keyword. Also enables inlining according to the C++ lan­ guage. 2 -- Inlines any function, at the compiler's discretion. Enables interprocedural optimizations and has the same effect as -ip. -O0 Disable optimizations. Floating Point Optimization Options -mp Maintain floating-point precision (disables some optimizations). The -mp option restricts optimization to maintain declared precision and to ensure that floating-point arithmetic conforms more closely to the ANSI and IEEE standards. For most programs, specifying this option adversely affects performance. If you are not sure whether your application needs this option, try compiling and running your program both with and without it to evaluate the effects on both performance and precision. -mp1 Improve floating-point precision. -mp1 disables fewer optimizations and has less impact on performance than -mp. -long_double (IA-32 systems only) Use -long_double to change the size of the long double type to 80 bits. The Intel compiler's default long double type is 64 bits in size, the same as the double type. This option introduces a number of incompatibilities with other files compiled without this option and with calls to library routines. Therefore, Intel recommends that the use of long double variables be local to a single file when you com­ pile with this option. -prec_div (IA-32 systems only) Improve precision of floating-point divides (some speed impact). With some optimizations, such as -xK and -xW, the Intel C++ Compiler changes floating-point division computations into multiplication by the reciprocal of the denominator. For example, A/B is computed as A x (1/B) to improve the speed of the computation. However, for values of B greater than 2126, the value of 1/B is "flushed" (changed) to 0. When it is important to maintain the value of 1/B, use -prec_div to disable the floating-point division-to-multiplication optimization. The result of -prec_div is more accurate, with some loss of perfor­ mance. -pc (IA-32 systems only) Enable floating-point significand precision control. Some float­ ing-point algorithms are sensitive to the accuracy of the signifi­ cand, or fractional part of the floating-point value. For example, iterative operations like division and finding the square root can run faster if you lower the precision with the -pc option. Set to one of the following values to round the significand to the indi­ cated number of bits: 32: 24 bits (single precision) -- Caution: A change of the default precision control or rounding mode (for example, by using the -pc32 flag or by user intervention) may affect the results returned by some of the mathematical functions. 64: 53 bits (single precision) 80: 64 bits (double precision) -- DEFAULT -rcd (IA-32 systems only) Enable fast float-to-int conversions. The Intel compiler uses the -rcd option to improve the performance of code that requires float­ ing-point-to-integer conversions. The system default floating point rounding mode is round-to-nearest. However, the C language requires floating point values to be truncated when a conversion to an integer is involved. To do this, the compiler must change the rounding mode to truncation before each floating-point-to-integer conversion and change it back afterwards. The -rcd option disables the change to truncation of the rounding mode for all floating point calculations, including floating point-to-integer conversions. Turning on this option can improve performance, but floating point conversions to integer will not conform to C semantics. -fp_port (IA-32 systems only) Round floating-point results at assignments and casts (some speed impact). -fpstkchk (IA-32 systems only) Generate extra code after every function call to assure that the FP stack is in the expected state. Generally, when the FP stack over­ flows, a NaN value is put into FP calculations, and the program's results differ. Unfortunately, the overflow point can be far away from the point of the actual bug. The -fpstkchk option places code that would access violate immediately after an incorrect call occurred, thus making it easier to locate these issues. -ftz (Itanium architecture-based systems) Flush denormal results to zero. -IPF_fma[-] (Itanium architecture-based systems) Enable [disable] the combining of floating point multiplies and add/subtract operations. -IPF_fma[-] enables [disables] the contrac­ tion of floating-point multiply and add/subtract operations into a single operation. Unless -mp is specified, the compiler contracts these operations whenever possible. The -mp option disables the con­ tractions. -IPF_fma and -IPF_fma- can be used to override the default compiler behavior. -IPF_fp_speculation (Itanium architecture-based systems) Enable floating point speculations with the following condi­ tions: fast -- Speculate floating point operations safe -- Speculate only when safe strict -- Same as off off -- Disables speculation of floating-point operations -IPF_flt_eval_method0 (Itanium architecture-based systems) Direct the compiler to evaluate the expressions involving float­ ing-point operands in the precision indicated by the variable types declared in the program. -IPF_fltacc[-] (Itanium architecture-based systems) Enable [disable] optimizations that affect floating point accuracy. By default (-IPF_fltacc-) the compiler may apply optimizations that reduce floating-point accuracy. You may use -IPF_fltacc or -mp to improve floating-point accuracy, but at the cost of disabling some optimizations. Optimizing Non-Exclusively for Specific Processors The -tpp options optimize your application's performance for a specific pro­ cessor. The resulting binary will also run on other processors in the same architecture (IA-32 or Itanium architecture). The Intel C++ Compiler includes gcc-compatible versions of the -tpp options. These options are listed below, following the tpp options. -tpp1 (Itanium architecture-based systems only) Target optimization to the Itanium processor. -tpp2 (Itanium architecture-based systems only) Target optimization to the Itanium 2 processor. (DEFAULT on Itanium architecture-based systems) -tpp5 (IA-32 systems only) Optimize for Intel Pentium(R) processor -tpp6 (IA-32 systems only) Optimize for Intel Pentium Pro, Intel Pentium II and Intel Pentium III processors -tpp7 (IA-32 systems only) Optimize for Intel Pentium 4 processors, Intel Xeon(TM) processors, Intel Pentium M processors, and Intel Pentium 4 Processors with Streaming SIMD Extensions 3 (SSE3) instruction support. (DEFAULT on IA-32) The Intel C++ Compiler includes gcc-compatible versions of the -tpp options, listed as follows -mcpu= Optimize for a specific cpu, where is one of the following: pentium -- (IA-32 systems only) Optimize for Intel Pentium processor. pentiumpro -- (IA-32 systems only) Optimize for Intel Pentium Pro, Intel Pentium II and Intel Pentium III processors. pentium4 -- (IA-32 systems only; DEFAULT on IA-32) Optimize for Intel Pentium 4 processors, Intel Xeon processors, Intel Pentium M proces­ sors, and Intel Pentium 4 Processors with Streaming SIMD Extensions 3 (SSE3) instruction support. itanium -- (Itanium architecture-based systems only) Optimize for Intel Itanium processor itanium2 -- (Itanium architecture-based systems only) Optimize for Intel Itanium 2 processor. Optimizing Exclusively for Specific Processors (IA-32 Systems Only) The -x{K|W|N|B|P} options target your program to run on a specific Intel processor. The resulting code might contain unconditional use of features that are not supported on other processors. If these options are used on a non-compatible processor, the program might fail with an illegal instruction exception, or it might display other unexpected behavior. Do not specify this option if the program will be executed on x86 processors not provided by Intel Corporation. For more information, see the Intel C++ Compiler User's Guide. -x (IA-32 systems only) Generate specialized code to run exclusively on processors supporting the extensions indicated by . includes one or more of the following characters: K -- Intel Pentium III processors and compatible Intel processors W -- Intel Pentium 4 processors and compatible Intel processors N -- Intel Pentium 4 processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific optimizations. B -- Intel Pentium M processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific optimizations. P -- Intel Pentium 4 Processors with Streaming SIMD Extensions 3 (SSE3) instruction support. Enables new optimizations in addition to Intel processor-specific optimizations. You can use more than one of the -x options by combining the characters that denote the processor type. For example, you can specify -xKW to gen­ erate code for Intel(R) Pentium(R) III and Intel Pentium 4 processors. NOTE: Programs compiled using option -xN, -xB, or -xP will display a fatal run-time error if executed by an unsupported processor. For more informa­ tion, see the Intel C++ Compiler User's Guide. -march= (IA-32 systems only) Generate code exclusively for a given cpu, where is one of the following: pentiumpro -- Intel Pentium Pro processors and Intel Pentium II pro­ cessors pentiumii -- Intel Pentium processors with MMX Technology pentiumiii -- Intel Pentium III processors pentium4 -- Intel Pentium 4 processors, Intel Xeon processors, and Intel Pentium M processors Automatic Processor-specific Optimization (IA-32 Only) The -ax{K|W|N|B|P} options direct the compiler to find opportunities to gen­ erate separate versions of functions that use instructions supported on the specified processors. If the compiler finds such an opportunity, it first checks whether generating a processor-specific version of a function is likely to result in a performance gain. If so, the compiler generates both a processor-specific version of a function and a generic version of the func­ tion. The generic version will run on any IA-32 processor. At run time, one of the versions is chosen to execute, depending on the cur­ rent processor. In this way, the program can benefit from performance gains on more advanced processors, while still working properly on older proces­ sors. The disadvantages of using -ax{K|W|N|B|P} are: · The size of the compiled binary increases because it contains both a processor-specific version of some of the code and a generic version of the code. · Performance is affected by the run-time checks to determine which code to run. -ax (IA-32 systems only) Generate code specialized for processor extensions specified by while also generating generic IA-32 code. includes one or more of the following characters: K -- Intel Pentium III processors and compatible Intel processors W -- Intel Pentium 4 processors and compatible Intel processors N -- Intel Pentium 4 processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific opti­ mizations. B -- Intel Pentium M processors and compatible Intel processors. Enables new optimizations in addition to Intel processor-specific opti­ mizations. P -- Intel Pentium 4 Processors with Streaming SIMD Extensions 3 (SSE3) instruction support. Enables new optimizations in addition to Intel processor-specific optimizations. Interprocedural Optimizations (IPO) Use -ip and -ipo to enable interprocedural optimizations (IPO), which allow the compiler to analyze your code to determine where to apply the following optimizations: inline function expansion, interprocedural constant propaga­ tion, monitoring module-level static variables, dead code elimination, prop­ agation of function characteristics, and multifile optimization. For IA-32, IPO also passes arguments in registers. Inline function expansion is one of the main optimizations performed by the interprocedural optimizer. For function calls that the compiler believes are frequently executed, the compiler might decide to replace the instructions of the call with code for the function itself (inline the call). See the Intel C++ Compiler User's Guide for more complete information on IPO. Enable and Specify the Scope of IPO -ip Enable single-file IP optimizations (within files). With this option, the compiler performs inline function expansion for calls to func­ tions defined within the current source file. -ipo Enable multi-file IP optimizations (between files). When you use -ipo to specify multifile IPO, the compiler performs inline function expansion for calls to functions defined in separate files. For this reason, it is important to compile the entire application or multi­ ple, related source files together when you specify -ipo. -ipo_c Generate a multi-file object file (ipo_out.o) that can be used in further link steps. -ipo_S Generate a multi-file assembly file (ipo_out.s) that can be used in further link steps. Modify the Behavior of IPO -ip_no_inlining Disable inlining that would result from the -ip interprocedural opti­ mization, but has no effect on other interprocedural optimizations. -ip_no_pinlining (IA-32 systems only) Disable partial inlining (requires -ip or -ipo) -ipo_obj Force the compiler to create real object files when used with ipo (requires -ipo). -nolib_inline Disable inline expansion of intrinsic functions -auto_ilp32 (Itanium architecture-based systems only) Specifies that the application should run within a 32-bit address space. Also tells the compiler to use 32-bit pointers whenever pos­ sible. To use this option, you must specify -ipo. Profile-guided Optimizations (PGO) Profile-guided optimizations (PGO) tell the compiler which areas of an application are most frequently executed. By knowing these areas, the com­ piler is able to use feedback from a previous compilation to be more selec­ tive in optimizing the application. For example, the use of PGO often enables the compiler to make better decisions about function inlining, thereby increasing the effectiveness of interprocedural optimizations. PGO creates an instrumented program from your source code and special code from the compiler. Each time this instrumented code is executed, the instru­ mented program generates a dynamic information file. When you compile a sec­ ond time, the dynamic information files are merged into a summary file. Using the profile information in this file, the compiler attempts to opti­ mize the execution of the most heavily traveled paths in the program. The PGO methodology requires three phases: Phase 1: Instrumentation compilation and linking with -prof_gen[x] Phase 2: Instrumented execution by running the executable Phase 3: Feedback compilation with -prof_use See the Intel C++ Compiler User's Guide for more complete information on PGO. -prof_gen[x] Instruct the compiler to produce instrumented code in your object files in preparation for instrumented execution. With the x quali­ fier, extra information is gathered. This option is used in Phase 1 of PGO to instruct the compiler to produce instrumented code in your object files in preparation for instrumented execution. Parallel make is automatically supported for -prof_genx compilations. -prof_use Instruct the compiler to produce a profile-optimized executable and merge available dynamic information (.dyn) files into a pgopti.dpi file. Use the -prof_use option in Phase 3 of PGO. -prof_dir Specify directory for profiling output files (*.dyn and *.dpi). Use the -prof_dir option with prof_gen as recommended for most pro­ grams, especially if the application includes the source files located in multiple directories. -prof_dir ensures that the profile information is generated in one consistent place. -prof_file Specify file name for profiling summary file -fnsplit[-] (Itanium architecture-based systems only) Enable[disable] function splitting. Function splitting is enabled by -prof_use in Phase 3 to improve code locality by splitting routines into different sections: one section to contain the cold or very infrequently executed code, and one section to contain the rest of the code (hot code). You can use -fnsplit- to disable function splitting for the following reasons: · Most importantly, to get improved debugging capability. In the debug symbol table, it is difficult to represent a split rou­ tine, that is, a routine with some of its code in the hot code section and some of its code in the cold code section. · The -fnsplit- option disables the splitting within a routine but enables function grouping, an optimization in which entire rou­ tines are placed either in the cold code section or the hot code section. Function grouping does not degrade debugging capabil­ ity. · When the profile data does not represent the actual program behavior, that is, when the routine is actually used frequently rather than infrequently. High-level Language Optimizations (HLO) High-level language optimizations (HLO) exploit the properties of source code constructs, such as loops and arrays, in applications developed in high-level programming languages, such as C++. They include loop inter­ change, loop fusion, loop unrolling, loop distribution, unroll-and-jam, blocking, data prefetch, scalar replacement, data layout optimizations, and others. -O3 Turn on high-level optimizations. Enable -O2 plus more aggressive optimizations, such as loop transformation and prefetching. -O3 opti­ mizes for maximum speed, but may not improve performance for some programs. IA-32 systems: In conjunction with the vectorization options, -ax{M|K|W|P} and -x{M|K|W|P}, -O3 causes the compiler to perform more aggressive data dependency analysis than it does for -O2, which may result in longer compilation times. -unroll IA-32 systems: Set maximum number of times to unroll loops. This applies only to loops that the compiler determines should be unrolled. Omit n to let the compiler decide whether to perform unrolling or not. Use n=0 to disable loop unrolling. Itanium architecture-based systems: The only allowed value for n is 0. Disable loop unrolling. -ivdep_parallel (Itanium architecture-based systems) Indicate there is absolutely no loop-carried memory dependency in any loop where IVDEP directive is specified. This technique is useful for some sparse matrix applications. Vectorization Options (IA-32 Systems Only) The vectorizer is a component of the Intel C++ Compiler that automatically uses SIMD instructions in the MMX, SSE, and SSE2 instruction sets. The vec­ torizer detects operations in the program that can be executed in parallel, and then converts the sequential program to process 2, 4, 8, or 16 elements in one operation, depending on the data type. The x{M|K|W|P} and ax{M|K|W|P} options discussed above enable the vector­ izer. -vec_report[] Control the vectorizer's level of diagnostic messages, where is one of the following: 0 -- No diagnostic information 1 -- Indicate vectorized loops (DEFAULT) 2 -- Indicate vectorized/non-vectorized loops 3 -- Indicate vectorized/non-vectorized loops and prohibiting data dependence information 4 -- Indicate non-vectorized loops 5 -- Indicate non-vectorized loops and prohibiting data dependence information If you use -c, -ipo with -vec_report{n} option or -c, -x{M|K|W|P} or -ax{M|K|W|P} with -vec_report[], the compiler issues a warning and no report is generated. To produce a report when using the aforementioned options, you need to add the -ipo_obj option. The combination of -c and -ipo_obj pro­ duces a single file compilation, and hence does generate object code, and eventually a report is generated. Auto Parallelization Options The auto-parallelization feature of the Intel C++ Compiler automatically translates serial portions of the input program into equivalent multi­ threaded code. The auto-parallelizer analyzes the dataflow of the program's loops and generates multithreaded code for those loops which can be safely and efficiently executed in parallel. This enables the potential exploita­ tion of the parallel architecture found in symmetric multiprocessor (SMP) systems. The parallel run-time support provides the same run-time features found in OpenMP*, such as handling the details of loop iteration modification, thread scheduling, and synchronization. While OpenMP directives enable serial applications to transform into paral­ lel applications quickly, the programmer must explicitly identify specific portions of the application code that contain parallelism and add the appro­ priate compiler directives. Auto-parallelization triggered by the -parallel option automatically identifies those loop structures that contain paral­ lelism. During compilation, the compiler automatically attempts to decompose the code sequences into separate threads for parallel processing. No other effort by the programmer is needed. -parallel Enable the auto-parallelizer to generate multi-threaded code for loops that can be safely executed in parallel. The -parallel option enables the auto-parallelizer if either the -O2 or -O3 optimization option is also on (the default is -O2). -par_report[] Control the level of auto-parallelizer diagnostic messages, where is one of the following: 0 -- no diagnostic information is displayed. 1 -- indicates loops successfully auto-parallelized (DEFAULT). Issues a "LOOP AUTO-PARALLELIZED" message for parallel loops. 2 -- indicates successfully auto-parallelized loops as well as unsuc­ cessful loops. 3 -- same as 2 plus additional information about any proven or assumed dependencies inhibiting auto-parallelization (reasons for not parallelizing). -par_threshold[] Set a threshold for the auto-parallelization of loops based on the probability of profitable execution of the loop in parallel. This option is used for loops whose computation work volume cannot be determined at compile-time. The threshold is usually relevant when the loop trip count is unknown at compile-time. =0-100. (DEFAULT: =75) The compiler applies a heuristic that tries to balance the overhead of creating multiple threads versus the amount of work available to be shared amongst the threads. Parallelization with OpenMP* The Intel C++ Compiler supports the OpenMP* C++ version 2.0 API specifica­ tion. The compiler performs transformations to generate multithreaded code based on the user's placement of OpenMP directives in the source program making it easy to add threading to existing software. The Intel compiler supports all of the current industry-standard OpenMP directives, except WORKSHARE, and compiles parallel programs annotated with OpenMP directives. In addition, the compiler provides Intel-specific extensions to the OpenMP C++ version 2.0 specification including run-time library routines and envi­ ronment variables. Note: As with many advanced features of compilers, you must properly under­ stand the functionality of the OpenMP directives in order to use them effec­ tively and avoid unwanted program behavior. -openmp Enable the parallelizer to generate multi-threaded code based on the OpenMP* directives. The code can be executed in parallel on both uniprocessor and multiprocessor systems. The -openmp option works with both -O0 (no optimization) and any optimization level of -O1, -O2 (default) and -O3. Specifying -O0 with -openmp helps to debug OpenMP applications. -openmp_report[] Control the OpenMP parallelizer's level of diagnostic messages, where is one of the following: 0 -- no diagnostic information is displayed. 1 -- Display diagnostics indicating loops, regions, and sections suc­ cessfully parallelized. (DEFAULT) 2 -- same as -openmp_report1 plus diagnostics indicating MASTER con­ structs, SINGLE constructs, CRITICAL constructs, ORDERED constructs, ATOMIC directives, etc. successfully handled. -openmp_stubs Enable the user to compile OpenMP programs in sequential mode. The openmp directives are ignored and a stub OpenMP library is linked (sequential). Optimizer Report Options The Intel C++ Compiler provides the following options to generate and manage optimization reports: -opt_report Generate an optimization report and direct it to stderr. DEFAULT: The compiler does not generate optimization reports. -opt_report_file Specify the filename for the generated report -opt_report_level[] Specify the level of report verbosity, where is one of the following: min -- DEFAULT med max -opt_report_routine Generate reports from all routines with names containing as part of their name. If is not specified, reports from all routines are generated. DEFAULT: The compiler generates reports for all routines. -opt_report_phase Specify the optimizer phase against which reports are generated. The compiler generates reports for the optimizer you specify in the . This option can be used multiple times on the same command line to generate reports for multiple optimizers. Currently, the fol­ lowing optimizer reports are supported: ipo -- Interprocedural Optimizer hlo -- High Level Optimizer ilo -- Intermediate Language Scalar Optimizer ecg -- Code Generator omp -- OpenMP all -- All phases When one of the above logical names for optimizers is specified for , all reports from that optimizer are generated. -opt_report_help List the logical names of optimizers available for report generation. Conformance Options -ansi_alias[-] Enable(DEFAULT)[disable] stating ANSI compliance of the compiled pro­ gram and that optimizations can be based on the ANSI rules (Itanium architecture-based systems: implies -restrict). This option directs the compiler to assume the following: · Arrays are not accessed out of bounds. · Pointers are not cast to non-pointer types, and vice-versa. · References to objects of two different scalar types cannot alias. For example, an object of type int cannot alias with an object of type float, or an object of type float cannot alias with an object of type double. If your program satisfies the above conditions, setting the -ansi_alias flag helps the compiler better optimize the program. How­ ever, if your program does not satisfy one of the above conditions, the -ansi_alias flag may lead the compiler to generate incorrect code. -ansi Support all ANSI standard C programs, equivalent to the -ansi option of gcc. -strict_ansi Select strict ANSI C/C++ conformance dialect -c99[-] Enable(DEFAULT) [disable] C99 support for C programs. -std=c99 Enable C99 support for C programs -mp This option is described above in Floating-point Optimizations. Miscellaneous Optimization Options -qp, -p Compile and link for function profiling with Linux gprof* tool -alias_args[-] Assume arguments may be aliased. (DEFAULT) [not aliased]. -mserialize-volatile (Itanium architecture-based systems) Enable strict memory access ordering for volatile data object refer­ ences. -mno-serialize-volatile (Itanium architecture-based systems) Memory access ordering for volatile data object references may be suppressed. -complex_limited_range Tell the compiler to use the highest performance formulations of com­ plex arithmetic operations, which may not produce acceptable results for input values near the top or bottom of the legal range. Without this option, the compiler uses a better formulation of complex arith­ metic operations, thus producing acceptable results for the full range of input values, though at some loss in performance. Debugging Options -g Produce symbolic debug information in object file. The compiler does not support the generation of debugging information in assemblable files. If you specify the -g option, the resulting object file will contain debugging information, but the assemblable file will not. The -g option changes the default optimization from -O2 to -O0. If you specify -g with -O1, -O2, or -O3, then -fp is disabled and allows the compiler to use the EBP register as a general-purpose reg­ ister in optimizations. However, most debuggers expect EBP to be used as a stack frame pointer, and cannot produce a stack backtrace unless this is so. Using the -fp option can result in slightly less effi­ cient code. IA-32 systems only: Specifying the -g or -O0 option automatically enables the -fp option. -syntax Check the syntax of a program and stop the compilation process after the C or C++ source files and preprocessed source files have been parsed. This option generates no code and produces no output files. Warnings and messages appear on stderr. Output Options By default, the compiler converts source code directly to an executable file. Appropriate options allow you to control the process by directing the compiler to produce preprocessed files (.i), assemblable files (.s), and object files (.o). -E Preprocess to stdout only. See Preprocessing Options below for more information. -P Preprocess to file (.i) only. See Preprocessing Options below for more information. -EP Preprocess to stdout and do not include #line directives in the out­ put See Preprocessing Options below for more information. -S Compile to an assemblable file (.s), then stop the compilation. -c Compile to object (.o) only, do not link. -use_asm Produce objects through the assembler. -use_msasm (IA-32 systems only) Support Microsoft* style assembly language insertion using MASM style syntax and, if requested, output assembly in MASM format. -fcode-asm Produce assembly file with optional code annotations. -fsource-asm Produce assembly file with optional code annotations. -f[no]verbose-asm Produce assembly file with compiler comments (DEFAULT). -fp (IA-32 systems only) Disable using EBP as general purpose register. -o Name output file. -inline_debug_info Preserve the source position of inlined code instead of assigning the call-site source position to inlined code. Preprocessing Options -A[] Associate a symbol with the specified sequence of . Equivalent to an #assert preprocessing directive. -A- Remove all predefined macros. Causes all predefined macros and asser­ tions to be inactive. -C Preserve comments in preprocessed source output. Comments following preprocessing directives are not preserved. -D[=] Define the macro and associate it with the specified . Equivalent to a #define preprocessing directive. DEFAULT: -D defines the macro with a of 1. -E Direct the preprocessor to expand your source module and write the result to standard output. The preprocessed source contains #line directives, which the compiler uses to determine the source file and line number. -EP Direct the preprocessor to expand your source module and write the result to standard output. Does not include #line directives in the output. -EP is equivalent to -E -P. -P Direct the preprocessor to expand your source module and store the result in a .i file in the current directory. Unlike the -E option, the output from -P does not include #line number directives. By default, the preprocessor creates the name of the output file using the prefix of the source file name with a .i extension. Caution: When you use the -P option, any existing files with the same name and extension are overwritten. -I Add directory to include file search path. For multiple search directories, multiple I commands must be used. The compiler searches directories for include files in the following order: 1. Directory of the source file that contains the include. 2. Directo­ ries specified by the -I option. -idirafter Add directory to the second include file search path (after -I). -isystem Add directory to the start of the system include path. -U Remove predefined macro. Equivalent to a #undef preprocessing direc­ tive. -X Remove standard directories from include file search path. You can use the -X option with the -I option to prevent the compiler from searching the default path for include files and direct it to use an alternate path. -nostdinc Same as X. -no-gcc Do not predefine the __GNUC__, __GNUC_MINOR__, and __GNUC_PATCH­ LEVEL__ macros. -H Print "include" file order and continue compilation. -M Generate makefile dependency lines for each source file, based on the #include lines found in the source file. -MD Preprocess and compile. Generate output file (.d extension) contain­ ing dependency information. -MF Generate makefile dependency information in . Must specify -M or -MM. -MG Similar to -M, but treats missing header files as generated files. -MM Similar to -M, but does not include system header files. -MMD Similar to -MD, but does not include system header files. -MX Generate a dependency file (.o extension) containing information used for the Intel workbench tool. -dM Output macro definitions in effect after preprocessing (use with -E). -pch Automatic processing for precompiled headers. -pch_dir Directs the compiler to find and/or create a file for pre-compiled headers in . -create_pch Manual creation of precompiled header (file.pchi). -use_pch Manual use of precompiled header (file.pchi). Specifying Alternate Tools and Paths You can direct the compiler to specify alternate tools for preprocessing, compilation, assembly, and linking. Further, you can invoke options specific to your alternate tools on the command line. -Qoption,, Pass options to the tool specified by . may be cpp, c, asm, or ld. The argument indicates one or more valid argument strings for the designated program. If the argument is a command-line option, you must include the hyphen. If the argument contains a space or tab character, you must enclose the entire argu­ ment in quotation characters (""). You must separate multiple argu­ ments with commas. -Qlocation,, Set as the location of the tool specified by . may be cpp, c, asm, or ld. is the complete path to the tool. -Qinstall Set as the root of the compiler installation. Precompiled Headers The Intel C++ Compiler supports precompiled header (PCH) files to signifi­ cantly reduce compile times using the options described below. If many of your source files include a common set of header files, place the common headers first, followed by the #pragma hdrstop directive. This pragma instructs the compiler to stop generating PCH files. For example, if source1.cpp, source2.cpp, and source3.cpp all include com­ mon.h, then place #pragma hdrstop after common.h to optimize compile times. See the Intel C++ Compiler User's Guide for more complete information on Precompiled Headers. Caution: Depending on how you organize the header files listed in your sources, these options might increase compile time. -pch Direct the compiler to use appropriate PCH files. If none are avail­ able, they are created as sourcefile.pchi. This option supports mul­ tiple source files. Note: The -pch option uses PCH files created from other sources if the headers files are the same. For example, if you compile source1.cpp using -pch, then source1.pchi is created. If you then compile source2.cpp using -pch, the compiler will use source1.pchi if it detects the same headers. -create_pch Manual creation of precompiled header . Use the -create_pch option if you want the compiler to create a PCH file called . The filename parameter must be specified. The filename parameter can be a full path name. The full path to file­ name must exist. The .pchi extension is not automatically appended to filename. This option cannot be used in the same compilation as -use_pch filename. The -create_pch filename option is supported for single source file compilations only. -pch_dir Directs the compiler to find and/or create a file for pre-compiled headers in dirname. Use the -pch_dir option to specify the path (dirname) to the PCH file. You can use this option with -pch, -create_pch filename, and -use_pch filename. -use_pch Manual use of precompiled header (filename.pchi). This option directs the compiler to use the PCH file specified by filename. It cannot be used in the same compilation as -create_pch . The -use_pch option supports full path names and supports multiple source files when all source files use the same .pchi file. Language Options -[no]restrict Enable [disable] the "restrict" keyword for disambiguating pointers. -Kc++ Compile all source or unrecognized file types as C++ source files. -fno-rtti Disable RTTI support. -[no]align (IA-32 systems only) Analyze and reorder memory layout for variables and arrays. -Zp[n] Specify alignment constraint for structure and union types, where n is one of the following: 1,2,4,8,16. -fshort-enums Allocate as many bytes as needed for enumerated types. -fsyntax-only Same as -syntax. -funsigned-char Change default char type to unsigned. -funsigned-bitfields Change default bitfield type to unsigned. Options for Controlling Compiler Diagnostics -w Disable all warnings. Displays error messages only. -w Control diagnostics, where is one of the following: 0 -- Display errors (same as -w) 1 -- Display warnings and errors (DEFAULT) 2 -- Display remarks, warnings, and errors -wn Print a maximum of errors displayed before the compiler aborts. By default, if more than 100 errors are displayed, compilation aborts. Remarks and warnings do not count towards this limit. -wd[,,...] Disable diagnostics L1 through LN. -we[,,...] Change severity of diagnostics L1 through LN to error. -ww[,,...] Change severity of diagnostics L1 through LN to warning. -wr[,,...] Change severity of diagnostics L1 through LN to remark. -Wall Enable all warnings. -Werror Force warnings to be reported as errors. -Wbrief Print brief one-line diagnostics. When enabled, the original source line is not displayed and the error message text is not wrapped when too long to fit on a single line. -Wcheck Enable more strict diagnostics. Performs compile-time code checking for code that exhibits non-portable behavior, represents a possible unintended code sequence, or possibly affects operation of the pro­ gram because of a quiet change in the ANSI C Standard. -Wp64 (Itanium architecture-based systems) Print diagnostics for 64-bit porting. Miscellaneous Options -help Print list of compiler options. -V Display compiler version information. -dryrun Show driver tool commands but do not execute tools. -v Show driver tool commands and execute tools. -x All source files found subsequent to -x will be recognized as one of the following types: c -- C source file c++ -- C++ source file c-header -- C header file cpp-output -- C pre-processed file c++-cpp-output -- C++ pre-processed file assembler -- Assembly file assembler-with-cpp -- Assembly file that needs to be preprocessed none -- Disable recognition, and revert to file extension -sox[-] (IA-32 systems only) Enable (DEFAULT) [disable] saving of compiler options and version in the executable. -falias Assume aliasing in program (DEFAULT). -fno-alias Assume no aliasing in program. -ffnalias Assume aliasing within functions (DEFAULT). -fno-fnalias Assume no aliasing within functions, but assume aliasing across calls. -fr32 (Itanium architecture-based systems only) Disable use of high floating point registers. Use only lower 32 floating-point registers. -Kpic, -KPIC Deprecated option. Use -fpic instead. By default this option is OFF. -fpic, -fPIC IA-32 systems: This option generates position independent code. By default this option is OFF. Itanium architecture-based systems: This option generates code allow­ ing full symbol preemption. By default this option is OFF. -fvisibility=[extern|default|protected|hidden|internal] Global symbols (data and functions) will get the visibility attribute given by default. Symbol visibility attributes explicitly set in the source code or using the symbol visibility attribute file options will override the -fvisibility setting. -fvisibility-extern= Space separated symbols listed in the argument will get visi­ bility set to extern. -fvisibility-default= Space separated symbols listed in the argument will get visi­ bility set to default. -fvisibility-protected= Space separated symbols listed in the argument will get visi­ bility set to protected. -fvisibility-hidden= Space separated symbols listed in the argument will get visi­ bility set to hidden. -fvisibility-internal= Space separated symbols listed in the argument will get visi­ bility set to internal. -fwritable-strings Specifies that string literals should be placed in a writable data section. This option provides compatibility with legacy programs that write into string literals. -fminshared Compilation is for the main executable. Absolute addressing can be used and non-position independent code generated for symbols that are at least protected. -fno-common Enables the compiler to treat common variables as if they were defined, allowing the use of gprel addressing of common data vari­ ables. -Knopic, -KNOPIC (Itanium architecture-based systems) Deprecated. Use fpic instead of this option. -nobss_init Place variables that are initialized with zeroes in the DATA section instead of the BSS section. Linker Options -L Instruct the linker to search for libraries. -i_dynamic Link Intel provided libraries dynamically. -dynamic-linker Select a dynamic linker (filename) other than the default. -mrelax Pass -relax to the linker. -mnorelax Do not pass -relax to the linker. -no_cpprt Do not link in C++ runtime libraries. -cxxlib-gcc Use C++ header files provided by gcc during compilation, and use C++ libraries provided by gcc. Also, see gcc Interoperability above. -cxxlib-icc Use C++ libraries provided by Intel compiler. -gcc-name Use this option to specify the location of g++ when the compiler can­ not locate the gcc C++ libraries. For use with the -cxxlib-gcc con­ figuration. -nodefaultlibs Do not use standard libraries when linking. -nostartfiles Do not use standard startup files when linking. -nostdlib Do not use standard libraries and startup files when linking. -shared Produce a shared object. -shared-libcxa Link Intel libcxa C++ library dynamically, overriding the default behavior when -static is used. This option has the opposite effect of -static-libcxa. When this option is used, the Intel-provided libcxa C++ library is linked in dynamically, allowing the user to override the static linking behavior when the -static option is used. -static Prevent linking with shared libraries. Causes the executable to link all libraries statically, as opposed to dynamically. -static-libcxa Link Intel libcxa C++ library statically. By default, the Intel-pro­ vided libcxa C++ library is linked in dynamically. Use -static-libcxa on the command line to link libcxa statically, while still allowing the standard libraries to be linked in by the default behavior. -u Pretend the is undefined. -T Direct linker to read link commands from . -Xlinker Pass directly to the linker for processing. -Wl,[,,...] Pass options o1, o2, etc. to the linker for processing. PREDEFINED MACROS The predefined macros available for the Intel C++ Compiler are described below. Intel C++ Compiler Predefined Macros __ECC Value on IA-32 -- NA Value on Itanium Architecture -- 800 Notes -- Assigned value refers to the compiler (e.g., 800 is 8.00). Supported for legacy reasons. Use __INTEL_COMPILER instead. __EDG__ Value on IA-32 -- 1 Value on Itanium Architecture -- 1 __ELF__ Value on IA-32 -- 1 Value on Itanium Architecture -- 1 __GNUC__ Value on IA-32 -- 3 Value on Itanium Architecture -- 3 __GNUC_MINOR__ Value on IA-32 -- 2 Value on Itanium Architecture -- 2 __GNUC_PATCHLEVEL__ Value on IA-32 -- 0 Value on Itanium Architecture -- 0 __GXX_ABI_VERSION Value on IA-32 -- 102 Value on Itanium Architecture -- 102 __i386 Value on IA-32 -- 1 Value on Itanium Architecture -- NA __i386__ Value on IA-32 -- 1 Value on Itanium Architecture -- NA i386 Value on IA-32 -- 1 Value on Itanium Architecture -- NA __ia64 Value on IA-32 -- NA Value on Itanium Architecture -- 1 __ia64__ Value on IA-32 -- NA Value on Itanium Architecture -- 1 ia64 Value on IA-32 -- NA Value on Itanium Architecture -- 1 __ICC Value on IA-32 -- 800 Value on Itanium Architecture -- NA Notes -- Assigned value refers to the compiler (e.g., 800 is 8.00). Supported for legacy reasons. Use __INTEL_COMPILER instead. __INTEL_COMPILER Value on IA-32 -- 800 Value on Itanium Architecture -- 800 Notes -- Defines the compiler version. Defined as 800 for the Intel C++ Compiler 8.0. _INTEGRAL_MAX_BITS Value on IA-32 -- NA Value on Itanium Architecture -- 64 Notes -- Indicates support for the __int64 type. __linux Value on IA-32 -- 1 Value on Itanium Architecture -- 1 __linux__ Value on IA-32 -- 1 Value on Itanium Architecture -- 1 linux Value on IA-32 -- 1 Value on Itanium Architecture -- 1 __lp64 Value on IA-32 -- NA Value on Itanium Architecture -- 1 __LP64__ Value on IA-32 -- NA Value on Itanium Architecture -- 1 _OPENMP Value on IA-32 -- 200203 Value on Itanium Architecture -- 200203 Notes -- Defined when -openmp is used. __OPTIMIZE__ Value on IA-32 -- 1 Value on Itanium Architecture -- 1 Notes -- Not enabled if all optimizations are turned off. _PGO_INSTRUMENT Value on IA-32 -- 1 Value on Itanium Architecture -- 1 Notes -- Defined when compiled with either -prof_gen or -prof_genx. __PTRDIFF_TYPE__ Value on IA-32 -- int Value on Itanium Architecture -- long __SIZE_TYPE__ Value on IA-32 -- unsigned Value on Itanium Architecture -- unsigned long __unix Value on IA-32 -- 1 Value on Itanium Architecture -- 1 __unix__ Value on IA-32 -- 1 Value on Itanium Architecture -- 1 unix Value on IA-32 -- 1 Value on Itanium Architecture -- 1 __USER_LABEL_PREFIX__ Value on IA-32 -- (no value) Value on Itanium Architecture -- (no value) ANSI/ISO Macros Included with the Compiler The ANSI/ISO standard for C language requires that certain predefined macros be supplied with conforming compilers. The Intel C++ Compiler supplies the following macros in accordance with this standard, as well as additional predefined macros: __cplusplus The name __cplusplus is defined when compiling a C++ translation unit. __DATE__ The date of compilation as a string literal in the form Mmm dd yyyy. __FILE__ A string literal representing the name of the file being compiled. __LINE__ The current line number as a decimal constant. __STDC__ The name __STDC__ is defined when compiling a C translation unit. __TIME__ The time of compilation. As a string literal in the form hh:mm:ss. gcc Predefined Macros The Intel C++ Compiler 8.0 includes the following new predefined macros also supported by gcc: __GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__ You can specify the -no-gcc option if you do not want these macros defined. If you need gcc interoperability (-cxxlib-gcc), do not use the -no-gcc com­ piler option. Suppress Macro Definition Use the -Uname option to suppress any macro definition currently in effect for the specified name. The -U option performs the same function as an #undef preprocessor directive. ENVIRONMENT VARIABLES You can customize your environment by setting the following environment variables. You can specify paths where the compiler can search for special files such as libraries and include files. LD_LIBRARY_PATH Specifies the location for all Intel-provided libraries. The LD_LIBRARY_PATH environment variable contains a colon-separated list of directories in which the linker will search for library (.a) files. If you want the linker to search additional libraries, you can add their names to LD_LIBRARY_PATH, to the command line, to a response file, or to the configuration file. In each case, the names of these libraries are passed to the linker before the names of the Intel libraries that the driver always specifies. PATH Specifies the directories the system searches for binary executable files. ICCCFG Specifies the configuration file for customizing compilations with the icc compiler. ICPCCFG Specifies the configuration file for customizing compilations with the icpc compiler. TMP Specifies the directory in which to store temporary files. If the directory specified by TMP does not exist, the compiler places the temporary files in the current directory. IA32ROOT (IA32-based systems) Points to the directory containing the bin, lib, include and substi­ tute header directories. IA64ROOT (Itanium architecture-based systems) Points to the directory containing the bin, lib, include and substi­ tute header directories. GNU* Environment Variables The Intel C++ Compiler supports the following GNU environment variables: CPATH Specifies a list of directories to search following the directories specified by -I. C_INCLUDE Specifies a list of directories to search following the directories specified by -isystem. CPLUS_INCLUDE_PATH Same as C_INCLUDE. DEPENDENCIES_OUTPUT Specifies how to output dependencies for Make based on preprocessed, non-system header files. SUNPRO_DEPENDENCIES Same as DEPENDENCIES_OUTPUT, except that system header files are not ignored. Compilation Environment Options The Intel C++ Compiler installation includes shell scripts that you can use to set environment variables. See the Intel C++ User's Guide for more infor­ mation Standard OpenMP Environment Variables OMP_SCHEDULE Specifies the type of runtime scheduling. DEFAULT: static OMP_NUM_THREADS Sets the number of threads to use during execution. DEFAULT: Number of processors currently installed in the system while generating the executable OMP_DYNAMIC Enables (TRUE) or disables (FALSE) the dynamic adjustment of the num­ ber of threads. DEFAULT: FALSE OMP_NESTED Enables (TRUE) or disables (FALSE) nested parallelism. DEFAULT: FALSE Intel Extensions to OpenMP Environment Variables KMP_LIBRARY Selects the OpenMP run-time library throughput. The options for the variable value are: serial, turnaround, or throughput indicating the execution mode. The default value of throughput is used if this vari­ able is not specified. DEFAULT: throughput (execution mode) KMP_STACKSIZE Sets the number of bytes to allocate for each parallel thread to use as its private stack. Use the optional suffix b, k, m, g, or t, to specify bytes, kilobytes, megabytes, gigabytes, or terabytes. DEFAULT: IA-32 systems: 2m Itanium architecture-based systems: 4m PGO Environment Variables The following environment values determine the directory in which to store dynamic information files or whether to overwrite pgopti.dpi. PROF_DIR Specifies the directory in which dynamic information files are cre­ ated. This variable applies to all three phases of the profiling pro­ cess. PROF_NO_CLOBBER Alters the feedback compilation phase slightly. By default, during the feedback compilation phase, the compiler merges the data from all dynamic information files and creates a new pgopti.dpi file if .dyn files are newer than an existing pgopti.dpi file. When this variable is set, the compiler does not overwrite the existing pgopti.dpi file. Instead, the compiler issues a warning and you must remove the pgopti.dpi file if you want to use additional dynamic information files. PROF_DUMP_INTERVAL Initiate Interval Profile Dumping in an instrumented application. The _PGOPTI_Set_Interval_Prof_Dump(int interval) function activates Interval Profile Dumping and sets the approximate frequency at which dumps will occur. The interval parameter is measured in milliseconds and specifies the time interval at which profile dumping will occur. An alternative method of initiating Interval Profile Dumping is by setting this environment variable. Set this environment variable to the desired interval value prior to starting the application. EXAMPLES The following examples demonstrate optimizing across multiple input files: 1. icc ax.cpp This command compiles ax.cpp producing executable file a.out. Optimizations occur by default. 2. icc -o abc ax.cpp bx.cpp cx.cpp This command uses option -o to name the executable file abc and compiles ax.cpp, bx.cpp, and cx.cpp as one program. 3. icc -c ax.cpp bx.cpp cx.cpp This command uses option -c to suppress linking and produce individual object files ax.o, bx.o, and cx.o. Interprocedural optimizations are prevented. 4. icc -c -O1 sub2.cpp icc -c -O1 sub3.cpp icc -o main.exe -g -O0 main.cpp sub2.o sub3.o The first two commands show incremental compilation with minimal optimization. The first command gener- ates an object file of sub2; the second generates an object file of sub3. The last command uses option -O0 to disable all compiler default optimizations. It uses option -g to generate symbolic debugging information and line numbers in the object code, which can be used by a source-level debugger. TECHNICAL SUPPORT The Intel C++ Compiler product web site offers timely and comprehensive product information, including product features, white papers, and technical articles. For the latest information, visit http://developer.intel.com/soft­ ware/products/. Intel also provides a support web site that contains a rich repository of self help information, including getting started tips, known product issues, product errata, license information, user forums, and more. Registering your product entitles you to one year of technical support and product updates through Intel Premier Support. Intel Premier Support is an interactive issue management and communication web site that enables you to submit issues and review their status, and to download product updates any­ time of the day. To register your product, contact Intel, or seek product support, please visit: http://www.intel.com/software/products/support. SEE ALSO The Intel C++ Compiler User's Guide is the definitive source for detailed information on using the Intel C++ Compiler, including a complete Compiler Options Quick Reference, a complete listing of all default options, and much more. In addition, see these other documents provided with the Intel C++ Compiler: · Product Release Notes · Intel Itanium Assembler User's Guide · Intel Itanium Architecture Assembly Language Reference Guide · Enhancing Performance with the Intel Compiler (training) You can access these documents from /doc/ccompindex.htm ( the default path is /opt/intel_cc_80/doc/ccompindex.htm.) COPYRIGHT INFORMATION Copyright (C) 1985-2004, Intel Corporation. All rights reserved. * Other brands and names are the property of their respective owners. Intel(R) Fortran Compiler 8.0 for Linux --------------------------------------------- Intel(R) Fortran compiler options. Used for SGI Altix 3000 and 350 submissions. NAME ifort - invokes the Intel(R) Fortran Compiler SYNOPSIS ifort [ options ] file1 [ file2 ]... options Are zero or more compiler options. fileN Is a Fortran source file, assembly file, object file, object library, or other linkable file. DESCRIPTION The ifort command invokes the Intel(R) Fortran Compiler that is designed to preprocess, compile, assemble, and link Fortran programs on Intel(R) IA-32 systems or Intel(R) Itanium(R) systems. For more information on this com­ piler, see the Intel(R) Fortran Compiler for Linux* Systems User's Guide. The ifort command interprets input files by their filename suffix as fol­ lows: · Filenames with the suffix .f90 are interpreted as free-form Fortran 95/90 source files. · Filenames with the suffix .f, .for, or .ftn are interpreted as fixed- form Fortran source files. · Filenames with the suffix .fpp, .F, .FOR, .FTN, or .FPP are inter­ preted as fixed-form Fortran source files, which must be preprocessed by the fpp preprocessor before being compiled. · Filenames with the suffix .F90 are interpreted as free-form Fortran source files, which must be preprocessed by the fpp preprocessor before being compiled. · Filenames with the suffix .s are interpreted as assembler files and are passed to the assembler. · Filenames with the suffix .a are interpreted as object libraries and are passed to ld(1). · Filenames with the suffix .o are interpreted as compiled object files and are passed to ld(1). You can override some options specified on the command line by using the OPTIONS statement in your Fortran source program. An OPTIONS statement affects only the program unit in which the statement occurs. For more information, see the Intel(R) Fortran Language Reference. Some language features (options, predefined symbols, etc.) are only avail­ able on certain systems. In this document, such language features are labeled. The label "(i32 only)" means the language feature is only defined on IA-32-based systems; label "(i64 only)" means the language feature is only defined on Itanium(R)-based systems. Performance Enhancing Options The following command line options can be used to increase the run-time per­ formance of code generated by the Intel Fortran compiler: · On IA-32 systems: -ax

, -ftz, -ip, -ipo, -O[n], -openmp, -parallel, -prof_use, -tpp, -x

. · On Itanium(R)-based systems: -fnsplit, -ftz, -ip, -ipo, -O[n], -openmp, -parallel, -prof_use, -tpp. Configuration and Indirect Files Command options to be used whenever the compiler is invoked can be put into a system configuration file named ifort.cfg, which resides in the same area as the compiler. The text in this file is processed by ifort before the text on the command line. To use a personal configuration file, set the environment variable IFORTCFG to point to the path and filename to be used. An indirect file contains text that can be included on the ifort command line. Precede the filename with an at symbol (@) on the command line at the point where the options are to be inserted. For example, assume file dou­ ble_size contains options "-i8 -r8" and file my_includes contains options "-I/bld/inc -I/bld/headers". In this case, the following command line: ifort -O3 @double_size myprog.f90 @my_includes passes "-O3 -i8 -r8 myprog.f90 -I/bld/inc -I/bld/headers" to the compiler. OPTIONS Some compiler options have the form -name keyword. -name must be spelled out completely, but keyword can be abbreviated to its shortest unique prefix (4 characters are recommended). For example, -assume buffered_io can be specified as -assume buff. For information on linker and load-time options, see ld(1). For some options, you can (or must) specify additional information, such as a keyword, a directory, a file name, a number, and so forth. When this information is required, it is shown in angle brackets (<>); when it is optional, it is shown in square brackets ([]). For example, in option -align , keyword is required; in option -unroll[n], n (a number) is optional. The ifort command takes the following options: -1 Executes at least one iteration of DO loops (same as the -onetrip option). This option has the same effect as -f66. -66 Enforces FORTRAN-66 semantics (same as the -f66 option). The default is -no66. -72 Treats the statement field of each fixed-form source line as ending in column 72. This is the default. -80 Treats the statement field of each fixed-form source line as ending in column 80. -132 Treats the statement field of each fixed-form source line as ending in column 132 (same as the -extend_source option). -align Tells the compiler to align data items. The following are -align options: · -align all Tells the compiler to add padding bytes whenever possible to obtain the natural alignment of data items in common blocks and struc­ tures. Specifies -align nocommons, -align dcommons, -align records, -align nosequence, -align rec8bytes. · -align commons Aligns all COMMON block entities on natural boundaries up to 4 bytes, instead of on 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 on the default byte boundary. If you specify -stand, this option is ignored. The default is -align nodcommons. · -align none Tells the compiler not to add padding bytes anywhere in common blocks or structures. · -align norecords Aligns fields within record structures and components of derived types on the next available byte boundary instead of the default natural boundaries. The default is -align records. · -align recbyte Aligns fields of records and components of derived types on the smaller of the size boundary specified ( can be 1, 2, 4, 8, or 16) or the boundary that will naturally align them. The default is -align rec8byte, which is the same as specifying -align records. · -align sequence Aligns components of a SEQUENCEd derived type according to the alignment rules that are currently in use. The default alignment rules are to align unsequenced 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 rules set by the user. If you specify -stand, this option is ignored. -ansi_alias Tells the compiler to assume that the program adheres to the Fortran 95 Standard type aliasability rules. The default is -ansi_alias-. -arch (i32 only) Determines the version of the architecture for which the compiler generates instructions. The following are -arch options: · -arch pn1 Optimizes for the Intel(R) Pentium(R) processor. · -arch pn2 Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors. · -arch pn3 Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors. This is the same as speci­ fying the -arch pn2 option. · -arch pn4 Optimizes for the Intel(R) Pentium(R) 4 processor. This is the default. -assume Specifies assumptions made by the compiler. The following are -assume options: · -assume bscc Tells the compiler to treat the backslash character (\) as a C- style control (escape) character syntax in character literals. The default is -assume nobscc, which tells the compiler to treat the backslash character as a normal character instead of a control character in character literals. · -assume buffered_io 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 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 Enables conditional compilation as defined by the OpenMP Fortran API (when "!$space" appears in free-form source or "c$spaces" appears in column 1 of fixed-form source, the rest of the line is accepted as a Fortran line). If -openmp is specified, the default is -assume cc_omp; otherwise, the default is -assume nocc_omp. · -assume dummy_aliases Tells the compiler that dummy (formal) arguments to procedures share memory locations with other dummy arguments or with COMMON variables that are assigned. These program semantics slow perfor­ mance and do not strictly obey the Fortran 95/90 Standards. The default is -assume nodummy_aliases. · -assume minus0 Tells the compiler to use F95 standard semantics for the treatment of IEEE* floating value -0.0 in the SIGN intrinsic, if the proces­ sor is capable of distinguishing the difference between -0.0 and +0.0, and to write a value of -0.0 with a negative sign on format­ ted output. The default is -assume nominus0, 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, and to write a value of -0.0 with no sign on formatted output. · -assume none Disables all the -assume options. This is the default. · -assume noprotect_constants 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 modification. The constant is not modified in the calling routine. The default is -assume pro­ tect_constants, which passes the constant actual argument. Any attempt to modify it results in an error. · -assume nosource_include Tells the compiler to search the default directory for USE modules or INCLUDE files. The default is -assume source_include, which tells the compiler to search the directory the source file is in for any INCLUDE files or modules. · -assume underscore Tells the compiler to append an 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 nounderscore. -auto Places variables, except those declared as SAVE, on the run-time stack (same as -automatic or -nosave). The default is -auto_scalar. However, if you specify -recursive or -openmp, the default is -auto. -auto_ilp32 (i64 only) Specifies that the application cannot exceed a 32-bit address space, which allows the compiler to use 32-bit pointers whenever possible. To use this option, you must also specify -ipo. If you use the -auto_ilp32 option on programs that can exceed a 32-bit address space (2**32), unpredictable results may occur during program execution. -auto_scalar Makes AUTOMATIC all scalar local variables of intrinsic type INTEGER, REAL, COMPLEX, or LOGICAL. You cannot specify -save, -auto, or -auto­ matic with this option. -autodouble Defines real variables to be REAL(KIND=8). This option is the same as specifying -r8. -automatic Places variables, except those declared as SAVE, on the run-time stack (same as -auto or -nosave). The default is -auto_scalar. How­ ever, if you specify -recursive or -openmp, the default is -auto. -ax

(i32 only) Generates processor-specific code as long as there is a performance benefit, while also generating generic IA-32 code. The characters K, W, N, B, and P denote the processor types (

). The following are -ax options: · -axK Generates code for Intel Pentium III processors and compatible Intel processors. · -axW Generates code for Intel Pentium 4 processors and compatible Intel processors. · -axN Generates code for Intel Pentium 4 processors and compatible Intel processors. Also enables new optimizations in addition to Intel processor-specific optimizations. · -axB Generates code for Intel Pentium M processors and compatible Intel processors. Also enables new optimizations in addition to Intel processor-specific optimizations. · -axP Generates code for Intel(R) Pentium(R) 4 processors with Streaming SIMD Extensions 3 (SSE3) instruction support. Also enables new optimizations in addition to Intel processor-specific optimiza­ tions. You can use more than one of the -ax options by combining the charac­ ters that denote the processor type. For example, you can specify -axNB to generate code for Intel(R) Pentium(R) 4 processors and Intel Pentium M processors. If you specify both the -ax and -x options, the generic code will only execute on processors compatible with the processor type speci­ fied by the -x option. -Bdynamic Enables dynamic linking of libraries at runtime. Smaller executables are created than with static linking. -Bstatic Enables static linking of a user's library. -c Causes the compiler to compile to an object (.o) file only and not link. -CB Performs run-time checks on whether array subscript and substring references are within declared bounds (same as the -check bounds option). -ccdefault Specifies the type of carriage control used for units 6 and *. The following are -ccdefault options: · -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 FOR­ TRAN if the file is formatted, and the unit is connected to a ter­ minal; if "-novms -ccdefault default" is specified, carriage con­ trol defaults to LIST. · -ccdefault fortran Specifies normal Fortran interpretation of the first character. · -ccdefault list Specifies one line feed between records. · -ccdefault none Specifies no carriage control processing. -check Checks several run-time conditions. The following are -check options: · -check all Enables all -check options. · -check arg_temp_created Generates code to check if actual arguments are copied into tempo­ rary 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 Performs run-time checks on whether array subscript and substring references are within declared bounds. The default is -check nobounds. · -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 descrip­ tor 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 speci­ fied descriptor unless the length of the item cannot accommodate the descriptor (for example, it is still an error to pass an INTE­ GER*2 item to an E edit descriptor). · -check none Disables all -check options. This is the default. This is the same as specifying -nocheck. · -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; other­ wise, the default is -check nooutput_conversion. -cm Suppresses all messages about questionable programming practices (same as the -warn nousage option). The default is -nocm. -common_args Tells the compiler that dummy (formal) arguments to procedures share memory locations with other dummy arguments or with COMMON variables that are assigned. This is the same as specifying -assume dummy_aliases. The default is -nocommon_args. -complex_limited_range Enables the use of basic algebraic expansions of some arithmetic operations involving data of type COMPLEX. This can cause some per­ formance improvements in programs that use a lot of COMPLEX arith­ metic, but values at the extremes of the exponent range may not com­ pute correctly. The default is -complex_limited_range-, which dis­ ables this option. -convert Specifies the format for unformatted files containing numeric data. The following are -convert options: · -convert big_endian Specifies that the format will be big endian for INTEGER*1, INTE­ GER*2, INTEGER*4, or INTEGER*8, and big endian IEEE floating-point for REAL*4, REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COMPLEX*32. · -convert cray Specifies that the format will be big endian for INTEGER*1, INTE­ GER*2, INTEGER*4, or INTEGER*8, and CRAY* floating-point for REAL*8 or COMPLEX*16. · -convert fdx Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, D_floating for REAL*8 or COMPLEX*16, and X_floating for REAL*16 or COMPLEX*32. · -convert fgx Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, G_floating for REAL*8 or COMPLEX*16, and X_floating for REAL*16 or COMPLEX*32. · -convert ibm Specifies that the format will be big endian for INTEGER*1, INTE­ GER*2, or INTEGER*4, and IBM* System\370 floating-point format for REAL*4 or COMPLEX*8 (IBM short 4) and REAL*8 or COMPLEX*16 (IBM long 8). · -convert little_endian Specifies that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8 and little endian IEEE floating- point for REAL*4, REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COM­ PLEX*32. · -convert native Specifies that unformatted data should not be converted. This is the default. · -convert vaxd Specifies that that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, D_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32. · -convert vaxg Specifies that that the format will be little endian for INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8, VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8, G_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32. -cpp Runs the Fortran preprocessor on source files prior to compilation (same as the -fpp option). The default is -nocpp. -D -D[=] Defines as a definition to use with conditional compilation directives or the Fortran preprocessor (-fpp). can be an integer or it can be a character string delimited by double quotes; for example, -Dname="string". If no definition is given, is defined as "1". -d_lines Compiles debug statements (indicated by D in column 1); this is the same as specifying -DD. The default is -nod_lines. -DD Compiles debug statements (indicated by D in column 1); this is the same as specifying -d_lines. The default is -noDD. -double_size Defines the size of DOUBLE PRECISION and DOUBLE COMPLEX declarations, constants, functions, and intrinsics. can be 64 or 128. The default is -double_size 64. -dryrun Specifies that driver tool commands should be shown but not executed. The default is -nodryrun. -dynamic-linker Specifies a dynamic linker () other than the default. -dyncom "common1,common2,common3" Enables dynamic allocation of the specified COMMON blocks at run time. The quotes must be present. -E Causes the Fortran preprocessor to send output to stdout. -e90 Causes the compiler to issue errors instead of warnings for nonstan­ dard Fortran 90. No such errors or warnings are issued by default. -e95 Causes the compiler to issue errors instead of warnings for nonstan­ dard Fortran 95. No such errors or warnings are issued by default. -EP Causes the Fortran preprocessor to send output to stdout, omitting #line directives. -error_limit Specifies the maximum number of error-level or fatal-level compiler errors allowed for a file specified on the command line. If you specify -noerror_limit, there is no limit to the number of errors that are allowed. The default is -error_limit 30 (a maximum of 30 error-level and fatal-level messages before the compiler stops the compilation). -extend_source Specifies the column number to use to end the statement field in fixed-form source files. can be 72, 80, or 132. The default behavior is -noextend_source, which implies column 72. If you spec­ ify -extend_source with no size, the default is -extend_source 132. Specifying -extend_source sets the -fixed option. -F Causes the Fortran preprocessor to send output to a file (same as the -preprocess_only and -P options). To use this option, you must also specify -fpp. -f66 Tells the compiler to apply FORTRAN-66 semantics: the execution of at least one iteration of DO loops, different EXTERNAL statement syntax and semantics, and different behavior of the BLANK= and STATUS= spec­ ifiers on the OPEN statement. This is the same as specifying the -66 option. The default is -nof66, which applies Fortran 95 semantics. -f77rtl Tells the compiler to use the run-time behavior of Fortran 77 instead of Intel(R) Fortran. This affects some INQUIRE specifiers when the unit is not connected to a file, PAD= defaults to 'NO' for formatted input, NAMELIST input format is different, and NAMELIST and list- directed input of character strings must be delimited by apostrophes or quotes. The default is -nof77rtl. -fast Enhances speed across the entire program. Sets the following command options that can improve run-time performance: -O3, -ipo, and -static. The default is -nofast. -fcode-asm Produces an assembly file with optional code annotations. To use this option, you must also specify -S. -fcommon Tells the compiler to treat common symbols as global definitions and to allocate memory for each symbol at compile time. The default is -fno-common. -FI Specifies source files are in fixed format (same as the -fixed option). -fixed Specifies source files are in fixed format. By default, source file format is determined by the file suffix. -fltconsistency Enables improved floating-point consistency. Floating-point opera­ tions are not reordered and the result of each floating-point opera­ tion is stored in the target variable rather than being kept in the floating-point processor for use in a subsequent calculation. The default, -nofltconsistency, provides better accuracy and run-time performance at the expense of less consistent floating-point results. -fminshared Tells the compiler to treat a compilation unit as a component of a main program and that it will not be linked as a shareable object. -fno-alias Specifies that aliasing should not be assumed in the program. The default is -falias. -fno-fnalias Specifies that aliasing should not be assumed within functions, but should be assumed across calls. The default is -ffnalias. -fnsplit (i64 only) Enables function splitting (enabled with -prof_use). The default is -fnsplit-, which disables the splitting within a routine but leaves function grouping enabled. -fp (i32 only) Disables using EBP as a general purpose register so it can be used as a stack frame printer. The default is -fp-, which uses EBP as a gen­ eral purpose register. -fp_port (i32 only) Rounds floating-point results after floating-point operations, so rounding to user-declared precision happens at assignments and type conversions; this has some impact on speed. The default is to keep results of floating-point operations in higher precision; this pro­ vides better performance but less consistent floating-point results. -fpconstant Tells the compiler to extend the precision to double precision for single-precision constants assigned to double-precision variables. The default is -nofpconstant. -fpe Specifies floating-point exception handling for the main program at run-time. You can specify one of the following values for : 0 - Floating underflow results in zero; all other floating-point exceptions abort execution. 1 - Floating underflow results in zero; all other floating-point exceptions produce exceptional values {signed Infinities or NaNs} and execution continues. 3 - All floating-point exceptions produce exceptional values {signed Infinities, denormals, or NaNs} and execution continues. This is the default; it provides full IEEE support. (Also see -ftz.) -fpic Generates position-independent code. This option can also be speci­ fied as -fPIC. -fpp[n] Runs the Fortran preprocessor on source files prior to compilation. The default is -nofpp. You can specify one of the following values for [n]: 0 - Disables # directives (equivalent to -nofpp). 1 - Same as 2. 2 - Enables # directives. This is equivalent to -fpp and is the default if the Fortran preprocessor is invoked. 3 - Same as 2. -fpscomp Specifies a level of compatibility with Microsoft* Fortran PowerSta­ tion. The following are -fpscomp options: · -fpscomp all Tells the compiler to use all options for Fortran PowerStation com­ patibility. The default is -fpscomp libs. · -fpscomp filesfromcmd Specifies that Fortran PowerStation behavior is used when the OPEN file specifier is blank. The default is -fpscomp nofilesfromcmd. · -fpscomp general Specifies that Fortran PowerStation semantics are used when differ­ ences exist with Intel Fortran. The default is -fpscomp nogeneral. · -fpscomp nolibs Prevents the portability library from being passed to the linker. The default is -fpscomp libs. · -fpscomp ioformat Specifies that Fortran PowerStation semantics and record format for list-directed formatted and unformatted I/O should be used. The default is -fpscomp noioformat. · -fpscomp logicals Specifies that Fortran PowerStation representation of LOGICAL val­ ues should be used. The default is -fpscomp nologicals. · -fpscomp none Specifies that no options for Fortran PowerStation compatibility should be used. -fpstkchk (i32 only) Generates extra code after every function call to ensure that the FP (floating-point) stack is in the expected state. By default, there is no checking. So when the FP stack overflows, a NaN value is put into FP calculations, and the program's results differ. Unfortu­ nately, the overflow point can be far away from the point of the actual bug. The -fpstkchk option places code that would access vio­ late immediately after an incorrect call occurred, thus making it easier to locate these issues. -FR Specifies source files are in free format (same as the -free option). -fr32 (i64 only) Disables use of high floating-point registers. Uses only the lower 32 floating-point registers. -free Specifies source files are in free format. By default, source file format is determined by the file suffix. -fsource-asm Produces an assembly file with optional code annotations. To use this option, you must also specify -S. -ftz Enables floating underflow results set to zero; this is the default if option -O3 is specified. Otherwise, the default is -ftz-. -fverbose-asm Produces an assembly file with compiler comments, including options and version information. To use this option, you must also specify -S, which sets -fverbose-asm. If you do not want this default when you specify -S, specify -fnoverbose-asm. -fvisibility= -fvisibility-= The first form specifies the default visibility for global symbols. The second form specifies the visibility for symbols that are in a file (this form overrides the first form). is the pathname of a file containing the list of symbols whose visibility you want to set; the symbols are separated by whitespace (spaces, tabs, or new­ lines). can be any of the following: default - Sets visibility to default. This means other components can reference the symbol, and the symbol definition can be overridden (preempted) by a definition of the same name in another component. extern - Sets visibility to extern. This means the symbol is treated as though it is defined in another component. It also means that the symbol can be overridden by a definition of the same name in another component. hidden - Sets visibility to hidden. This means other components can­ not directly reference the symbol. However, its address might be passed to other components indirectly. internal - Sets visibility to internal. This means the symbol cannot be referenced outside its defining component, either directly or indirectly. protected - Sets visibility to protected. This means other compo­ nents can reference the symbol, but it cannot be overridden by a def­ inition of the same name in another component. -g Produces symbolic debug information in the object file. The compiler does not support the generation of debugging information in assem­ blable files. If you specify the -g option, the resulting object file will contain debugging information, but the assemblable file will not. On IA-32 systems, specifying the -g or -O0 option automatically sets the -fp option. -help Prints the list of compiler options. -I

Specifies a directory to add to the include path, which is used to search for module files (USE statement) and include files (INCLUDE statement). -i_dynamic Links Intel-provided libraries dynamically. -i2 Makes default integer and logical variables 2 bytes long (same as the integer_size 16 option). The default is -integer_size 32. -i4 Makes default integer and logical variables 4 bytes long (same as the integer_size 32 option). This is the default. -i8 Makes default integer and logical variables 8 bytes long (same as the integer_size 64 option). The default is -integer_size 32. -implicitnone Sets the default type of a variable to undefined (IMPLICIT NONE). This is the same as specifying the -u option. -inline_debug_info Preserves the source position of inlined code instead of assigning the call-site source position to inlined code. -intconstant Tells the compiler to use Fortran 77 semantics, rather than Fortran 95/90 semantics, to determine the KIND for integer constants. The default is -nointconstant. -integer_size Defines the size of INTEGER and LOGICAL variables. can be 16, 32, or 64. The default is -integer_size 32. -ip Enables single-file interprocedural optimizations. If you specify this option, the compiler performs inline function expansion for calls to functions defined within the current source file. -ip_no_inlining Disables full and partial inlining enabled by -ip. To use this option, you must specify -ip or -ipo. -ip_no_pinlining (i32 only) Disables partial inlining. To use this option, you must specify -ip or -ipo. -IPF_fltacc (i64 only) Disables optimizations that affect floating-point accuracy. If the default setting is used (-IPF_fltacc-), the compiler may apply opti­ mizations that reduce floating-point accuracy. You can use -IPF_fltacc or -fltconsistency to improve floating-point accuracy, but at the cost of disabling some optimizations. -IPF_flt_eval_method0 (i64 only) Directs the compiler to evaluate the expressions involving floating- point operands in the precision indicated by the variable types declared in the program. By default, intermediate floating-point expressions are maintained in higher precision. -IPF_fma (i64 only) Enables the combining of floating-point multiplies and add/subtract operations. Also enables the contraction of floating-point multiply and add/subtract operations into a single operation. The compiler contracts these operations whenever possible. However, if -mp is specified, these contractions are disabled. The default is -IPF_fma-. -IPF_fp_speculation (i64 only) Enables floating-point speculations with one of the following conditions: fast - Speculate floating-point operations. This is the default. off - Disables speculation of floating-point operations. safe - Speculate only when safe. strict - This is the same as specifying off. -ipo Enables multifile IP optimizations (between files). When you specify this option, the compiler performs inline function expansion for calls to functions defined in separate files. For this reason, it is important to compile the entire application or multiple, related source files together when you specify -ipo. -ipo_c Generates a multifile object file (ipo_out.o) that can be used in further link steps. -ipo_obj Forces generation of real object files. To use this option, you must specify -ipo. -ipo_S Generates a multifile assembly file (ipo_out.s) that can be used in further link steps. -ivdep_parallel (i64 only) Tells the compiler that there is no loop-carried memory dependency in any loop following an IVDEP directive. -Kpic This is a deprecated option; it can also be specified as -KPIC. Use -fpic instead. -L Tells the linker to search for libraries in before searching the standard directories. -lowercase Causes the compiler to ignore case differences in identifiers and to convert external names to lowercase (same as the -names lowercase option). This is the default. -mixed_str_len_arg Tells the compiler that the hidden length passed for a character argument is to be placed immediately after its corresponding charac­ ter 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 Specifies the directory where module (.mod) files should be placed when created and where they should be searched for (USE state­ ment). -mp Maintains floating-point precision (while disabling some optimiza­ tions). The -mp option restricts optimization to maintain declared precision and to ensure that floating-point arithmetic conforms more closely to the ANSI* and IEEE standards. For most programs, specifying this option adversely affects perfor­ mance. If you are not sure whether your application needs this option, try compiling and running your program both with and without it to evaluate the effects on both performance and precision. -mp1 Improves floating-point precision. This option disables fewer opti­ mizations and has less impact on performance than -mp. -names Specifies how source code identifiers and external names are inter­ preted. The following are -names options: · -names as_is Causes the compiler to distinguish case differences in identifiers and to preserve the case of external names. · -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. -nbs Tells the compiler to treat a backslash (\) as a normal character in character literals, not an escape character (same as the -assume nob­ scc option). This is the default. -no_cpprt Prevents linking of the C++ runtime libraries. -noalign Prevents the alignment of data items. This is the same as specifying -align none. The default is -align. -noaltparam Specifies that the alternate form of parameter constant declarations (without parentheses) should not be recognized (same as the -nodps option). This form has no parentheses surrounding the list, and the form of the constant, rather than implicit or explicit typing, deter­ mines the data type of the variable. The default is -altparam. -nobss_init Places any variables that are explicitly initialized with zeros in the DATA section. By default, variables explicitly initialized with zeros are placed in the BSS section. -nodefaultlibs Prevents the compiler from using standard libraries when linking. -nodefine Specifies that all preprocessor definitions apply only to -fpp and not to Intel Fortran conditional compilation directives. -nodps Specifies that the alternate form of parameter constant declarations (without parentheses) should not be recognized (same as the -noalt­ param option). The default is -dps. -nofor_main Specifies the main program is not written in Fortran, and prevents the compiler from linking for_main.o into applications. The default is -for_main. -noinclude Prevents the compiler from searching in /usr/include for files speci­ fied in an INCLUDE statement. You can specify the -I option along with this option. This option does not affect cpp(1) behavior, and is not related to the Fortran 95 and 90 USE statement. -nolib_inline Disables inline expansion of intrinsic functions. -nologo Specifies whether the compiler version information is displayed. The default is -logo. -nostartfiles Prevents the compiler from using standard startup files when linking. -nostdinc Removes standard directories from the include file search path (same as the -X option). -nostdlib Prevents the compiler from using standard libraries and startup files when linking. -nus Prevents the compiler from appending an underscore character to external user-defined names (opposite of -us). Specifying -nus is the same as specifying the -assume nounderscore option. -o Specifies the name for an output . -O0 Disables all -O optimizations. On IA-32 systems, this option sets the -fp option. -O1 On IA-32 systems, enables optimizations for speed. Also disables intrinsic recognition and the -fp option. This option is the same as the -O2 option. On Itanium(R)-based systems, the -O1 option enables optimizations for server applications (straight-line and branch-like code with a flat profile). Enables optimizations for speed, while being aware of code size. For example, this option disables software pipelining and loop unrolling. -O2 or -O This option is the default for optimizations. However, if -g is specified, the default is -O0. On IA-32 systems, this option is the same as the -O1 option. On Itanium-based systems, the -O2 option enables optimizations for speed, including global code scheduling, software pipelining, predi­ cation, and speculation. It also enables: · Inlining of intrinsics · The following capabilities for performance gain: constant propaga­ tion, copy propagation, dead-code elimination, global register allocation, global instruction scheduling and control speculation, loop unrolling, optimized code selection, partial redundancy elimi­ nation, strength reduction/induction variable simplification, vari­ able renaming, exception handling optimizations, tail recursions, peephole optimizations, structure assignment lowering and optimiza­ tions, and dead store elimination. -O3 Enables -O2 optimizations plus more aggressive optimizations, such as prefetching, scalar replacement, and loop transformations. Enables optimizations for maximum speed, but does not guarantee higher per­ formance unless loop and memory access transformations take place. On IA-32 systems, when the -O3 option is used with the -ax and -x options, it causes the compiler to perform more aggressive data dependency analysis than for -O2, which may result in longer compila­ tion times. On Itanium-based systems, the -O3 option enables optimizations for technical computing applications (loop-intensive code): loop opti­ mizations and data prefetch. -onetrip Executes at least one iteration of DO loops (same as the -1 option). This option has the same effect as -f66. -openmp Enables the parallelizer to generate multithreaded code based on OpenMP* directives. The code can be executed in parallel on both uniprocessor and multiprocessor systems. The -openmp option works with both -O0 (no optimization) and any optimization level of -O. Specifying -O0 with -openmp helps to debug OpenMP applications. -openmp_report[n] Controls the OpenMP parallelizer's level of diagnostic messages. You can specify one of the following values for [n]: 0 - Displays no diagnostic information. 1 - Displays diagnostics indicating loops, regions, and sections suc­ cessfully parallelized. This is the default. 2 - Displays the diagnostics specified by -openmp_report1 plus diag­ nostics indicating successful handling of MASTER constructs, SINGLE constructs, CRITICAL constructs, ORDERED constructs, ATOMIC direc­ tives, etc. -openmp_stubs Enables the compiler to generate sequential code. The OpenMP direc­ tives are ignored and a stub OpenMP library is linked. -opt_report Generates an optimization report to stderr. -opt_report_file Specifies the filename () for the generated report. -opt_report_help Lists the logical names of optimizers available for report genera­ tion. -opt_report_level[level] Specifies the level of report verbosity. The [level] can be min, med, or max. The default is -opt_report_levelmin. -opt_report_phase Specifies the optimizer phase against which reports are generated. The compiler generates reports for the optimizer you specify in . This option can be used multiple times on the same command line to generate reports for multiple optimizers. Currently, the fol­ lowing optimizer reports are supported: ipo - Interprocedural Optimizer hlo - High Level Optimizer ilo - Intermediate Language Scalar Optimizer ecg - Code Generator omp - OpenMP all - All phases When one of the above logical names for optimizers is specified for , all reports from that optimizer are generated. -opt_report_routine Generates a report on the routines containing the specified . If is not specified, reports from all routines are generated. -p Compiles and links for function profiling with gprof(1). This is the same as specifying -pg or -qp. -P Causes the Fortran preprocessor to send output to a file (same as the -preprocess_only and -F options). To use this option, you must also specify -fpp. -pad Enables the changing of the variable and array memory layout. The default is -nopad. -pad_source Specifies that fixed-form source records shorter than the statement field width are to be padded with spaces (on the right) 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. -par_report[n] Controls the auto-parallelizer's level of diagnostic messages. You can specify one of the following values for [n]: 0 - Display no diagnostic information. 1 - Displays diagnostics indicating loops successfully auto-paral­ lelized. This is the default. Issues a "LOOP AUTO-PARALLELIZED" mes­ sage for parallel loops. 2 - Displays diagnostics indicating loops successfully auto-paral­ lelized, as well as unsuccessful loops. 3 - Displays the diagnostics specified by -par_report2 plus addi­ tional information about any proven or assumed dependencies inhibit­ ing auto-parallelization (reasons for not parallelizing). -par_threshold[n] Sets a threshold for the auto-parallelization of loops based on the probability of profitable execution of the loop in parallel. This option is used for loops whose computation work volume cannot be determined at compile-time. The threshold is usually relevant when the loop trip count is unknown at compile-time. [n] is an integer from 0 to 100. The default value is 75. The compiler applies a heuristic that tries to balance the overhead of creating multiple threads versus the amount of work available to be shared amongst the threads. -parallel Enables the auto-parallelizer to generate multithreaded code for loops that can be safely executed in parallel. To use this option, you must also specify -O2 or -O3. -pc (i32 only) Enables control of floating-point significand precision. Some float­ ing-point algorithms are sensitive to the accuracy of the signifi­ cand, or fractional part of the floating-point value. For example, iterative operations like division and finding the square root can run faster if you lower the precision with the -pc option. You can specify one of the following values for : 32 - Rounds the significand to 24 bits (single precision). Note that a change of the default precision control or rounding mode (for exam­ ple, by using the -pc32 option or by user intervention) may affect the results returned by some of the mathematical functions. 64 - Rounds the significand to 53 bits (single precision). This is the default. 80 - Rounds the significand to 64 bits (double precision). -pg Compiles and links for function profiling with gprof(1). This is the same as specifying -p or -qp. -prec_div (i32 only) Improves precision of floating-point divides; it has some speed impact. With some optimizations, such as -xK and -xW, the compiler changes floating-point division computations into multiplication by the reciprocal of the denominator. For example, A/B is computed as A * (1/B) to improve the speed of the computation. However, for values of B greater than 2126, the value of 1/B is "flushed" (changed) to 0. When it is important to maintain the value of 1/B, use -prec_div to disable the floating-point division-to-multiplication optimization. The result of -prec_div is more accurate, with some loss of perfor­ mance. -prefetch- (i32 only) Disables prefetch insertion optimization. To use this option, you must also specify -O3. The default is -prefetch. -preprocess_only Causes the Fortran preprocessor to send output to a file (same as the -F and -P options). To use this option, you must also specify -fpp. -prof_dir Specifies a directory () for profiling output files (*.dyn and *.dpi). -prof_file Specifies a file name () for the profiling summary file. -prof_format_32 Produces profile data with 32-bit counters; this option allows com­ patibility with earlier compilers. The default is to produce profile data with 64-bit counters to handle large numbers of events. -prof_gen Instruments a program for profiling. -prof_use Enables use of profiling information during optimization. -Qinstall Sets as the root directory for compiler installation. -Qlocation,, Sets as the location of the tools specified by . -Qoption,, Passes options to tools specified by . can be fpp, f, c, link, asm (on IA-32 systems), or ias (on Itanium(R)-based sys­ tems). -qp Compiles and links for function profiling with gprof(1). This is the same as specifying -p or -pg. -r8 Defines REAL declarations, constants, functions, and intrinsics as DOUBLE PRECISION (REAL*8), and defines COMPLEX declarations, con­ stants, functions, and intrinsics as DOUBLE COMPLEX (COMPLEX*16). This option is the same as specifying -real_size 64 or -auto_double. -r16 Defines REAL and DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL*16 and defines COMPLEX and DOUBLE COMPLEX dec­ larations, constants, functions, and intrinsics as COMPLEX*32. This option is the same as specifying -real_size 128. -rcd (i32 only) Enables fast float-to-integer conversions. This option can improve the performance of code that requires floating-point-to-integer con­ versions. The system default floating-point rounding mode is round- to-nearest. However, the Fortran language requires floating-point values to be truncated when a conversion to an integer is involved. To do this, the compiler must change the rounding mode to truncation before each floating-point-to-integer conversion and change it back afterwards. The -rcd option disables the change to truncation of the rounding mode for all floating-point calculations, including floating point- to-integer conversions. This option can improve performance, but floating-point conversions to integer will not conform to Fortran semantics. -real_size Defines the size of REAL and COMPLEX declarations, constants, func­ tions, and intrinsics. can be 32, 64, or 128. The default is -real_size 32. -recursive Specifies that all routines should be compiled for possible recursive execution. This option sets the -auto option. The default is -nore­ cursive. -reentrancy Specifies that the compiler should generate reentrant code that sup­ ports a multithreaded application. The following are -reentrancy options: · -reentrancy async Tells the run-time library (RTL) that the program may contain asyn­ chronous (AST) handlers that could call the RTL. This causes the RTL to guard against AST interrupts inside its own critical regions. · -reentrancy none Tells the run-time library (RTL) that the program does not rely on threaded or asynchronous reentrancy. The RTL will not guard against such interrupts inside its own critical regions. This is the default. This option is the same as the -noreentrancy option. · -reentrancy threaded Tells the run-time library (RTL) that the program is multithreaded, such as programs using the POSIX threads library. This causes the RTL to use thread locking to guard its own critical regions. -S Causes the compiler to compile to an assembly file (.s) only and not link. -safe_cray_ptr Specifies that Cray pointers do not alias other variables. -save Places variables, except those declared as AUTOMATIC, in static mem­ ory (same as -noauto or -noautomatic). The default is -auto_scalar. However, if you specify -recursive or -openmp, the default is -auto. -scalar_rep (i32 only) Enables scalar replacement performed during loop transformation. To use this option, you must also specify -O3. The default is -scalar_rep-. -shared Tells the compiler to produce a dynamic shared object instead of an executable. On Itanium-based systems, you must specify -fpic for the compilation of each object file you want to include in the shared library. -shared-libcxa Links the Intel libcxa C++ library dynamically, overriding the default behavior when -static is used. This option is the opposite of -static-libcxa. -sox (i32 only) Enables saving of the compiler options and version in the executable. The default is -sox-. -stand Causes the compiler to issue compile-time messages for nonstandard language elements. The following are -stand options: · -stand f90 Causes the compiler to issue messages for language elements that are not standard in Fortran 90 (same as the -std90 option). · -stand f95 Causes the compiler to issue messages for language elements that are not standard in Fortran 95 (same as the -std95 or -std options). This option is set if you specify -warn stderrors. · -stand none Causes the compiler to issue no messages for nonstandard language elements. This is the same as specifying -nostand. This is the default. -static Prevents linking with shared libraries. Causes the executable to link all libraries statically. -static-libcxa Links the Intel libcxa C++ library statically. This option is the opposite of -shared-libcxa. -std90 Causes the compiler to issue messages for language elements that are not standard in Fortran 90 (same as the -stand f90 option). -std95 or -std Causes the compiler to issue messages for language elements that are not standard in Fortran 95 (same as the -stand f95 option). This option is set if you specify -warn stderrors. -syntax_only Specifies that the source file should be checked only for correct syntax (same as the -syntax and -y options). No code is generated, no object file is produced, and some error checking done by the opti­ mizer is bypassed. This option lets you do a quick syntax check of your source file. The default is -nosyntax_only. -T Tells the linker to read link commands from the specified . -Tf Specifies that should be compiled as a Fortran source file. This option is useful when you have a file with a nonstandard file­ name suffix. -threads Specifies that multithreaded libraries should be linked. This option sets the -reentrancy threaded option. The default is -nothreads. -tpp1 (i64 only) Optimizes for the Intel(R) Itanium(R) processor. -tpp2 (i64 only) Optimizes for the Intel(R) Itanium(R) 2 processor. This is the default on Itanium-based systems. -tpp5 (i32 only) Optimizes for the Intel(R) Pentium(R) processor. -tpp6 (i32 only) Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II and Intel(R) Pentium(R) III processors. -tpp7 (i32 only) Optimizes for the Intel(R) Pentium(R) 4 processors, Intel(R) Xeon(TM) processors, Intel Pentium M processors, and Intel Pentium 4 proces­ sors with Streaming SIMD Extensions 3 (SSE3). This is the default on IA-32 systems. -traceback Tells the compiler to generate extra information in the object file to allow the display of source file traceback information at runtime when a severe error occurs. The default is -notraceback. -tune (i32 only) Determines the version of the architecture for which the compiler generates instructions. The following are -tune options: · -tune pn1 Optimizes for the Intel(R) Pentium(R) processor. · -tune pn2 Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors. · -tune pn3 Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors. This is the same as speci­ fying the -tune pn2 option. · -tune pn4 Optimizes for the Intel(R) Pentium(R) 4 processor. This is the default. -u Sets the default type of a variable to undefined (IMPLICIT NONE). This is the same as specifying the -implicitnone option. -U Removes the predefined macro . -unroll[n] Sets the maximum number of times to unroll loops. Use -unroll0 to disable loop unrolling. The default is -unroll, which tells the com­ piler to use default heuristics. -uppercase Causes the compiler to ignore case differences in identifiers and to convert external names to uppercase (same as the -names uppercase option). The default is -lowercase (or -names lowercase). -us Tells the compiler to append an underscore character to external user-defined names (opposite of -nus). Specifying -us is the same as specifying the -assume underscore option. -use_asm Tells the compiler to produce objects through the assembler. -V Displays the compiler version information. -v Tells the driver that tool commands should be shown and executed. -vec_report[n] (i32 only) Specifies the amount of vectorizer diagnostic information to report. You can specify one of the following values for [n]: 0 - Produces no diagnostic information. 1 - Indicates vectorized loops. This is the default. 2 - Indicates vectorized and non-vectorized loops. 3 - Indicates vectorized and non-vectorized loops and prohibiting data dependence information. 4 - Indicates non-vectorized loops. 5 - Indicates non-vectorized loops and prohibiting data dependence information. -vms Causes the run-time system to behave like HP* Fortran on OpenVMS* Alpha systems and VAX* systems (VAX FORTRAN*) in the following ways: · Modifies certain defaults The -vms option sets the -check format and -check output_conversion options. You can override this by specifying the option on the command line. For example, if you specify -vms -check noformat, you get -check noformat. · Alignment The -vms option 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 HP Fortran on OpenVMS systems. · INCLUDE qualifiers /LIST and /NOLIST are recognized at the end of the file pathname in an INCLUDE statement at compile time. If the file name in the INCLUDE statement does not specify the com­ plete path, the path used is the current directory. · Quotation mark character (") A quotation mark is recognized as starting an octal constant (such as "177) instead of a character literal ("..."). · 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 specified) 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/Z is written to the file. If -vms is not specified, 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/Z. If this is true, it returns EOF. · OPEN statement effects Carriage control defaults to FORTRAN if the file is formatted, 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 character). · Implied logical unit numbers Certain environment variables are recognized at run time for ACCEPT, PRINT, and TYPE statements, and for READ and WRITE state­ ments that do not specify a unit number, such as: READ (*,1000). · Treatment of blanks in input The -vms option 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. · Carriage control default If -vms -ccdefault default is specified, carriage control defaults to FORTRAN if the file is formatted and the unit is connected to a terminal. -w Disables all warning messages (same as the -nowarn and -warn nogen­ eral options). -W Disables warnings (n=0) or enables warnings (n=1). The default is -W1 (same as the -warn general option). -W0 is the same as specify­ ing -warn nogeneral, -nowarn, or -w. -w90 Suppresses warning messages about Fortran features that are depre­ cated or obsolescent in Fortran 95 (same as the -w95 option). -w95 Suppresses warning messages about Fortran features that are depre­ cated or obsolescent in Fortran 95 (same as the -w90 option). -warn Specifies the level of warning messages issued by the compiler. The following are -warn options: · -warn all Enables all warning messages. · -warn none Disables all warning messages. This is the same as specifying -nowarn. This is the default. · -warn alignments Enables warnings about data that is not naturally aligned. The default is -warn noalignments. · -warn declarations Enables error messages about any undeclared symbols. The default is -warn nodeclarations. · -warn errors Tells the compiler to change all warning-level messages into error- level messages. The default is -warn noerrors. · -warn nogeneral Disables all information-level and warning-level messages. The default is -warn general. · -warn ignore_loc Enables warnings when %LOC is stripped from an argument. The default is -warn noignore_loc. · -warn stderrors Tells the compiler to change warnings about Fortran standards vio­ lations into error messages. This option sets the -stand f95 option. If you want Fortran 90 standards violations to become errors, you should specify -warn stderrors and -stand f90. The default is -warn nostderrors. · -warn truncated_source Enables warnings when source exceeds the maximum columm width in fixed-format source files. The default is -warn notrun­ cated_source. · -warn uncalled Enables warnings when a statement function is never called. The default is -warn nouncalled. · -warn unused Enables warnings about variables that are declared but never used. The default is -warn nounused. · -warn usage Enables warnings about questionable program practices. The default is -warn nousage. -what Prints the version strings of the Fortran command and the compiler. -Wl,[,,...] Passes options , , etc. to the linker for processing. -Wp,[,,...] Passes options , , etc. to the preprocessor. -X Removes standard directories from the include file search path (same as the -nostdinc option). You can use the -X option with the -I option to prevent the compiler from searching the default path for include files and direct it to use an alternate path. -x

(i32 only) Generates the minimum set of processor-specific instructions required for the processor that executes your program. The characters K, W, N, B, and P denote the processor types (

). The following are -x options: · -xK Generates code for Intel Pentium III processors and compatible Intel processors. · -xW Generates code for Intel Pentium 4 processors and compatible Intel processors. · -xN Generates code for Intel Pentium 4 processors and compatible Intel processors. Also enables new optimizations in addition to Intel processor-specific optimizations. · -xB Generates code for Intel Pentium M processors and compatible Intel processors. Also enables new optimizations in addition to Intel processor-specific optimizations. · -xP Generates code for Intel(R) Pentium(R) 4 processors with Streaming SIMD Extensions 3 (SSE3) instruction support. Also enables new optimizations in addition to Intel processor-specific optimiza­ tions. You can use more than one of the -x options by combining the charac­ ters that denote the processor type. For example, you can specify -xNB to generate code for Intel(R) Pentium(R) 4 processors and Intel Pentium M processors. Do not use these options if you are executing a program on a non- Intel(R) processor. If you use these options on a non-compatible processor, the program might fail with an illegal instruction excep­ tion, or display other unexpected behavior. If you execute a program using option -xN, -xB, or -xP on an unsup­ ported processor, the compiler will display a fatal run-time error. For more information, see your user's guide. -Xlinker Passes directly to the linker for processing. -y Specifies that the source file should be checked only for correct syntax (same as the -syntax_only and -syntax options). -zero Initializes to zero all local scalar variables of intrinsic type INTEGER, REAL, COMPLEX, or LOGICAL that are saved and not already initialized. The default is -zero-. -Zp[n] Aligns fields of records and components of derived types on the smaller of the size boundary specified or the boundary that will nat­ urally align them (same as the -align recbyte option). The [n] can be: 1, 2, 4, 8, or 16. If you do not specify [n], you get -Zp8, which is the default. EXAMPLES The following examples demonstrate optimizing across multiple input files: 1) ifort ax.f90 This command compiles ax.f90 producing executable file a.out. Optimiza­ tions occur by default. 2) ifort -o abc ax.f90 bx.f90 cx.f90 This command uses option -o to name the executable file abc and compiles ax.f90, bx.f90, and cx.f90 as one program. 3) ifort -c ax.f90 bx.f90 cx.f90 This command uses option -c to suppress linking and produce individual object files ax.o, bx.o, and cx.o. Interprocedural optimizations are prevented. 4) ifort -c -O1 sub2.f90 ifort -c -O1 sub3.f90 ifort -o main.exe -g -O0 main.f90 sub2.obj sub3.obj The first two commands show incremental compilation with minimal opti­ mization. The first command generates an object file of sub2; the second generates an object file of sub3. The last command uses option -O0 to disable all compiler default opti­ mizations. It uses option -g to generate symbolic debugging information and line numbers in the object code, which can be used by a source-level debugger. RESTRICTIONS The standard libraries, like libc, are loaded with the -l loader option and not a full pathname. The wrong library can be loaded if there are files with names like libc.a or libc.so in the directories specified with the -L loader option, or in the default directories searched by the loader. For ifort, when multiple source files are compiled together without the -c option, the first source file's suffix determines the default source form for the entire compilation. DIAGNOSTICS The ifort command produces diagnostic messages that are intended to be self- explanatory. The loader can also produce occasional messages. PREDEFINED SYMBOLS The driver defines symbols (or macros) at the start of compilation and when certain compiler options are specified during compilation. The following symbols are defined at the start of compilation: __INTEL_COMPILER=800 __ELF__ __unix__ __unix __linux__ __linux __gnu_linux__ unix linux __i386 (i32 only) __i386__ (i32 only) i386 (i32 only) __ia64 (i64 only) __ia64__ (i64 only) ia64 (i64 only) The following symbols are defined during compilation if certain compiler options are specified: _OPENMP=200011 Defined if option -openmp is specified. _PGO_INSTRUMENT Defined if option -prof_gen is specified. ENVIRONMENT VARIABLES You can customize your environment by using the following environment vari­ ables. Run-Time Environment Variables The following are run-time environment variables. For more information on these variables, see your user's guide. decfort_dump_flag If set to Y or y, a core dump will be taken when any severe Intel Fortran run-time error occurs. FORTn The file specification for the file opened on unit n. FOR_READ FOR_ACCEPT FOR_PRINT FOR_TYPE For programs compiled with the -vms option, the name of the file to use for the specified operation. FOR_DISABLE_STACK_TRACE If set to true, traceback output is disabled. FORT_BUFFERED If set to true, buffered I/O will be used for sequential output to all I/O units, except those whose output is to the terminal. This provides a run-time mechanism to support the behavior enabled by the -assume buffered_io option. FORT_CONVERTn The -convert option to use on a file opened on unit n. FORT_CONVERT.ext FORT_CONVERT_ext The -convert option to be used when a filename with suffix ext is opened. F_UFMTENDIAN I/O unit numbers to perform -convert on. NLSPATH The path for the Intel Fortran run-time error message catalog. TMPDIR The alternate working directory where scratch files are created. Compile-Time Environment Variables The following are compile-time environment variables. For more information on these variables, see your user's guide. FPATH The path for include files. IFORTCFG The configuration file to use instead of the default configuration file. LD_LIBRARY_PATH The path for shared (.so) library files. PATH The path for compiler executable files. TMPDIR The alternate working directory where scratch files are created. Standard OpenMP Environment Variables The following are standard OpenMP environment variables. For more informa­ tion on these variables, see your user's guide. OMP_DYNAMIC Enables (TRUE) or disables (FALSE) the dynamic adjustment of the num­ ber of threads. The default value is FALSE. OMP_NESTED Enables (TRUE) or disables (FALSE) nested parallelism. The default value is FALSE. OMP_NUM_THREADS Sets the number of threads to use during execution. The default is the number of processors currently installed in the system while gen­ erating the executable. OMP_SCHEDULE Specifies the type of runtime scheduling. The default is static scheduling. Intel(R) Extensions to OpenMP Environment Variables The following are Intel extensions to the OpenMP environment variables. For more information on these variables, see your user's guide. KMP_LIBRARY Selects the OpenMP run-time library throughput. The options for the variable value are: serial, turnaround, or throughput indicating the execution mode. The default value is throughput. KMP_STACKSIZE Sets the number of bytes to allocate for each parallel thread to use as its private stack. Use the optional suffix b, k, m, g, or t, to specify bytes, kilobytes, megabytes, gigabytes, or terabytes. The default on IA-32 systems is 2m; the default on Itanium(R)-based sys­ tems is 4m. Profile Guided Optimization Environment Variables The following are Profile Guided Optimization (PGO) environment variables. For more information on these variables, see your user's guide. PROF_DIR Specifies the directory in which dynamic information files are cre­ ated. This variable applies to all three phases of the profiling pro­ cess. PROF_DUMP_INTERVAL Initiates Interval Profile Dumping in an instrumented application. Normally, the _PGOPTI_Set_Interval_Prof_Dump(int interval) function activates Interval Profile Dumping and sets the approximate frequency at which dumps will occur. The interval parameter is measured in milliseconds and specifies the time interval at which profile dumping will occur. You can use this environment variable as an alternative method of initiating Interval Profile Dumping. Set it to the desired interval value before starting the application. PROF_NO_CLOBBER Alters the feedback compilation phase slightly. By default, during the feedback compilation phase, the compiler merges the data from all dynamic information files and creates a new pgopti.dpi file if .dyn files are newer than an existing pgopti.dpi file. When this variable is set, the compiler does not overwrite the exist­ ing pgopti.dpi file. Instead, the compiler issues a warning and you must remove the pgopti.dpi file if you want to use additional dynamic information files. TECHNICAL SUPPORT The Intel Fortran Compiler product web site offers timely and comprehensive product information, including product features, white papers, and technical articles. For the latest information, visit http://developer.intel.com/soft­ ware/products/. Intel also provides a support web site that contains a rich repository of self-help information, including getting started tips, known product issues, product errata, license information, user forums, and more. Registering your product entitles you to one year of technical support and product updates through Intel Premier Support. Intel Premier Support is an interactive issue management and communication web site that enables you to submit issues and review their status, and to download product updates any­ time of the day. To register your product, to contact Intel, or to seek product support, please visit: http://www.intel.com/software/products/support. SEE ALSO icc(1), gprof(1), ld(1) The Intel(R) Fortran Compiler for Linux* Systems User's Guide is the defini­ tive source for detailed information on using the Intel Fortran Compiler. It consists of 2 volumes: Volume I: Building Applications; Volume II: Opti­ mizing Allpications. In addition, see these other documents provided with the Intel Fortran Com­ piler: · Product Release Notes · Intel Fortran Compiler Options Quick Reference Guide for Linux* Systems · Intel Fortran Language Reference · Intel Fortran Libraries Reference You can access these documents from /doc/ccompindex.htm (the default path is /opt/intel_fc_80/doc/fcompindex.htm). COPYRIGHT INFORMATION Copyright (C) 1985-2004, Intel Corporation. All rights reserved. * Other brands and names are the property of their respective owners. dplace - a tool for controlling placement of processes onto cpus -c Cpu_number(s). Specified as a list of cpu ranges: Example: "-c1", "-c2-4", "-c1,4-8,3". Cpu numbers are NOT physical cpu numbers. They are logical cpu number that are relative to the cpus that are in the set of allowed cpus as specified by the current cpumemset or "runon" command. Cpu numbers start at 0. If this option is not specified, all cpus of the current cpumemset are available. -e Exact placement. As proceses are created, they are bound to cpus in the exact order that the cpus are specified in the cpu list. Cpu numbers may appear multiple times in the list. A cpu value of "x", in the argument list for -c option, indicates that binding should not be done for that the process. If the end of the list is reached, binding starts over at the beginning of the list. -x Provides the ability to skip placement of processes. is a bitmask. If bit N of is set, then the N+1th process that is forked is not placed. For example, setting the mask to 6 will cause the 2nd & 3rd processes from being placed. The first process (the process named by the ) will be assigned to the first cpu. The second & third processes are not placed. The fourth process is assigned to the second cpu, etc.. This option is useful for certain classes of threaded apps that spawn a few helper processes that are not typically do not use much cpu time. (Hint: Intel OpenMP applications currently should be placed using -x2. This could change in future versions of OpenMP). Example: runon 4-7 dplace -e -c0,x,1-3 a.out where a.out is an OpenMP application that has to be run on 4 processors. Pin thread 1 on cpu 4, skip the next two Intel OpenMP compiler helper threads, and bind the next 3 threads on cpus 5,6,7 respectively. Alternatively, the same functionality could be achieved by issuing 'runon 4-7 dplace -x2 -c0-3 a.out'. OpenMP Environment variables: OMP_NUM_THREAD Sets the number of threads to use during execution. Default is the number of processors OMP_DYNAMIC Enables (true) or disables (false) the dynamic adjustment of the number of threads. Default is false. KMP_LIBRARY Selects the OpenMP runtime library throughput. The options for the variable value are: serial, turnaround, or throughput indicating the execution mode. The default value of throughput is used if this variable is not specified. KMP_STACKSIZE Sets the number of bytes to allocate for each parallel thread to use as its private stack. Use the optional suffix b, k, m, g, or t, to specify bytes, kilobytes, megabytes, gigabytes, or terabytes. Default on Itanium compiler:4m KMP_SCHEDULE static,balanced For loops running with OpenMP schedule "static", assign each thread approximately [#iterations / #threads] iterations. This method balances the number of iterations more evenly among all the threads. static,greedy (DEFAULT) For loops running with OpenMP schedule "static", assign each thread approximately [#iterations / #threads] iterations. MPI Environment variables: MPI_COMM_SIZE - determines the size of the group associated with a communicator. MPI_DSM_CPULIST - allows you to manually select processors to use for MPI application. MPI_DSM_MUSTRUN - ensures that each MPI process will get a physical CPU & memory on the node to which it was assigned. Others: mpirun - command to run MPI programs limit [ resource [ max-use ] ] Limit the consumption by the current process or any process it spawns, each not to exceed max-use on the specified resource. If max-use is omitted, print the current limit; if resource is omitted, display all limits. resource may include: stacksize Maximum stack size for the process.