Intel® Fortran Compiler XE 13.1 User and Reference Guides
The command to invoke the compiler is ifort.
For Windows* OS and OS X* systems, you can also use the compiler from within the integrated development environment (IDE).
On Linux* and OS X* operating systems, environment variables that specify locations for compiler components need to be set prior to using the command line. The Intel® Fortran Compiler installation includes a shell script for setting environment variables that can run in the terminal window. For more information, see Using the compilervars File to Specify Location of Components.
On Windows* OS, you typically do not need to set any environment variables prior to using the command line. Each of the Visual Studio* IDE variations has its own compiler command-line window, available from the Intel® Parallel Studio XE 2013 program folder with the appropriate environment variables set for the command-line.
Use the ifort command in a command line or makefile to invoke the Intel® Fortran compiler. The syntax is:
ifort [options]input_file(s)
For a complete listing of compiler options, see the Compiler Options reference.
The ifort command can compile and link projects in one step or compile them then link them as a separate step.
In most cases, a single ifort command will invoke the compiler and linker.
The ifort command invokes a driver program that is the user interface to the compiler and linker. It accepts a list of command options and file names and directs processing for each file.
The driver program does the following:
Calls the Intel(R) Fortran Compiler to process Fortran files.
Passes the linker options to the linker.
Passes object files created by the compiler to the linker.
Passes libraries to the linker.
Calls the linker or librarian to create the executable or library file.
On Linux* OS systems, the compiler recognizes Language Extensions for Offloading in the source program by default and builds a heterogeneous binary that runs on both the target and host when any are present. If your program includes these language extensions and you do not want to build a heterogeneous binary, specify the -no-offload compiler option. For more information, see the Programming for Intel® MIC Architecture: Heterogeneous Programming section and the -no-offload compiler option.
You can also use ld (Linux* OS and OS X*) or link (Windows* OS) to build libraries of object modules. These commands provide syntax instructions at the command line if you request it with the -help(Linux* OS and OS X*) or /? (Windows* OS) option.
The ifort command automatically references the appropriate Intel® Fortran Run-Time Libraries when it invokes the linker. To link one or more object files created by the Intel® Fortran compiler, you should use the ifort command instead of the link command.
Because the driver calls other software components, error messages may be returned by other components. For instance, the linker may return a message if it cannot resolve a global reference. The -watch (Linux* OS and OS X*) or /watch (Windows* OS) command-line option can help clarify which component is generating the error.
Windows* OS systems support characters in Unicode* (multibyte) format; the compiler will process file names containing Unicode* characters.
The following rules apply when specifying ifort on the command line:
An option is specified by one or more letters preceded by a hyphen (-) for Linux* OS and OS X* or a slash (/) for Windows* OS. (You can use a hyphen (-) instead of a slash (/) for Windows* OS, but this is not the preferred method.)
Multipleinput_files can be specified, using a space as a delimiter. When a file is not in PATH or working directory, specify the directory path before the file name. The filename extension specifies the type of file. See Understanding File Extensions.
Some options take arguments in the form of filenames, strings, letters, or numbers. Except where otherwise noted, a space between the option and its argument(s) can be entered or combined. For a complete listing of compiler options, see the Compiler Options reference.
Options on the command line apply to all files. In the following example, the -c and -nowarn options apply to both files x.f and y.f:
ifort -c x.f -nowarn y.f
Options cannot be combined with a single slash or hyphen, you must specify the slash or hyphen for each option specified. For example: /1 /c is correct, but /1c is not.
Some compiler options are case-sensitive. For example, c and C are two different options.
Options can take arguments in the form of filenames, strings, letters, and numbers. If a string includes spaces, they must be enclosed in quotation marks.
All compiler options must precede the -Xlinker (Linux* OS and OS X*) or /link (Windows* OS) options. Options that appear following -Xlinker or /link are passed directly to the linker.
Unless specified with certain options, the command line will both compile and link the files you specify. To compile without linking, specify the -c (Linux* OS and OS X*) or /c (Windows* OS) option.
Option names can be abbreviated, enter as many characters as are needed to uniquely identify the option.
Compiler options remain in effect for the whole compilation unless overridden by a compiler directive.
The following command compiles x.for, links, and creates an executable file. This command generates a temporary object file, which is deleted after linking:
ifort x.for
The following command compiles x.for and generates the object file x.o (Linux* OS and OS X*) or x.obj (Windows* OS). The c option prevents linking (it does not link the object file into an executable file):
ifort -c x.for (Linux* OS and OS X*) ifort x.for /c (Windows* OS)
The following command links x.o or x.obj into an executable file. This command automatically links with the default Intel(R) Fortran libraries:
ifort x.o (Linux* OS and OS X*) ifort x.obj (Windows* OS)
The following command compiles a.for, b.for, and c.for, creating three temporary object files, then linking the object files into an executable file named a.out (on Linux* OS and OS X*) or a.exe (Windows* OS):
ifort a.for b.for c.for
Compile the source files that define modules before the files that reference the modules (in USE statements) when using modules and compile multiple files.
When you use a single ifort command, the order in which files are placed on the command line is significant. For example, if the free-form source file moddef.f90 defines the modules referenced by the file projmain.f90, use the following syntax:
ifort moddef.f90 projmain.f90
To specify a particular name for the executable file, specify the -o (Linux* OS and OS X*) or /exe (Windows* OS) option:
ifort x.for -o myprog.out (Linux* OS and OS X*) ifort x.for /exe:myprog.exe (Windows* OS)
To redirect output to a file and then display the program output (Linux* OS and OS X*):
myprog > results.lis (Linux* OS and OS X*) more results.lis
To place standard output into file one.out and standard error into file two.out (Windows* OS):
ifort filenames /options 1>one.out 2>two.out (Windows* OS)
Or
ifort filenames /options >one.out 2>two.out
To place standard output and standard error into a single file both.out (Windows* OS):
ifort filenames /options 1>both.out 2>&1 (Windows* OS)
Or
ifort filenames /options >both.out 2>&1
Using makefiles from the Command Line: Use makefiles to specify a number of files with various paths and to save this information for multiple compilations. For more information on using makefiles, see Using Makefiles to Compile Your Application.