Fortran compiler in linux

Ubuntu Documentation

Installing the GNU C compiler and GNU C++ compiler

To install the gcc and g++ compilers, you will need the build-essential package. This will also install GNU make.

build-essential contains a list of packages which are essential for building Ubuntu packages including gcc compiler, make and other required tools.

Now, you should able to compile software using C / C++ compilers.

To install the manpages for c and c++ development, install the manpages-dev package.

Installing the GNU Java compiler

Note that GNU’s Java compiler is not the same as the one developed and distributed by Sun Microsystems, and will not provide Java to the firefox browser. For that, please see Java. To install gcj, the GNU Java compiler, install the following package: gcj.

gcj can be used to:

1. compile .java files to bytecode (.class files).
2. compile .java files to a linux-executable.

To install the GNU Java bytecode interpreter, you need the gij package.

To have gcj compile to executables, install libgcj6-dev (otherwise an error during compilation occurs: libgcj.spec: No such file or directory). Use synaptic to install libgcj6-dev.

Installing the GNU Fortran compilers

To install the GNU Fortran 77 compiler — g77, you need the g77 package.

To install the GNU Fortran 95 compiler — gfortran, the package is: gfortran.

Installing the GNU autotools

To install autoconf and automake, you need the autoconf and automake packages.

Apt-get will tell you to explicitly choose a version of automake. If, for example, you decide to use automake1.9, you need to specify the version, such as the automake1.9 package.

32-bit Builds on AMD64

The GNU compilers have options that allow them to create 32-bit object and executable files on 64-bit operating systems, and vica versa. The critical options are -m32 (to build 32-bit) and -m64 (to build 64-bit).

These options will be present when you install the compiler of your choice. However, they won’t actually work unless you install several additional packages.

The first thing you will need is the multilib package for the compiler you are using. For example, to add multilib support to the default version of g++ (4.1 in gutsy), you would install . For 4.2, you would need .

The multilib packages are compiler runtime packages. Now, you need 32-bit (or 64-bit) versions of whatever libraries you need to link your application program. 64-bit packages have names that start with lib64. Install these on 32-bit systems to support 64-bit builds. 32-bit packages have names that start with lib32. Install these on 64-bit systems to support 32-bit builds. Whatever else you are doing, you will probably need . If you are using g++, you will need .

Installing the Intel Compiler Suite Professional Edition 10.x

Using the Intel compilers for C, C++, and FORTRAN requires installing 32-bit libraries for Ubuntu if you are using a 64-bit system. Please ensure you have these packages:

gcc, build-essential, libc6-dev (see above)

ia32-libs, g++-multilib, and libc6-dev-i386 (for 64-bit systems)

32-bit packages starting with lib32 (for 64-bit systems)

alien and rpm for installing the RPM packages that Intel distributes.

libstdc++5 and libstdc++5-3.3-dev for good measure because Intel’s builds depend on these runtimes.

before you attempt installing the Intel Compiler Suite.

Get the License Number and Extract to a path without spaces

Ensure that you have obtained the license number for your installation and extracted the downloaded installation archive into a path that does not contain any spaces. This last statement is utterly important. The installer script that comes with the package has a bug that does not allow you to install the compiler suite if you have any spaces in the installer script path.

On 64-bit systems you may also need to issue these commands

because the chklic_32_64 license checking utility from Intel dynamically links to these libraries.

Once you’re done preparing to install the compiler suite, it’s time to go to the installer directory and install the compiler (be sure to also read through accompanying documentation; e.g., README, INSTALL.txt):

Run the Installation Script

After installing the compiler, you need to tell your shell the location of these executables by adding their parent paths to the PATH environment variable.

Edit /etc/bash.bashrc to add the installation path to the PATH environment variable

Where 10.1.012 is the version of the compiler suite installed.

Installing the X11 development compilers

Install script for X11 development libs

InstallingCompilers (последним исправлял пользователь andrius-zilenas 2012-08-10 10:18:50)

The material on this wiki is available under a free license, see Copyright / License for details
You can contribute to this wiki, see Wiki Guide for details

Источник

Fortran Compilers

Fortran has over a dozen open source and commercial compilers.

Open source compilers

GNU Fortran Compiler

GNU Fortran Compiler (gfortran) is a mature free and open source compiler, part of the GNU Compiler Collection.

OpenCoarrays is a library and compiler wrapper around gfortran which enables the parallel programming features of Fortran 2018 with gfortran.

LLVM Flang

Flang is a new front-end for Fortran 2018 that has been recently added to LLVM. It is implemented in modern C++ and uses a Fortran-oriented MLIR dialect for lowering to LLVM IR. This project is under active development.

Current Flang

Flang is an open source compiler based on the NVIDIA/PGI commercial compiler.

LFortran

LFortran is a modern, interactive, LLVM-based Fortran compiler.

Commercial compilers

Intel

Intel oneAPI is Intel’s suite of compilers, tools, and libraries for Fortran, C, C++, and Python. Intel oneAPI HPC Toolkit provides two Fortran compilers:

• Intel Fortran Compiler Classic ( ifort ), a mature compiler with full Fortran 2018 support; and
• Intel Fortran Compiler Beta ( ifx ), a new, LLVM-based compiler that supports Fortran 95 and partially newer versions of the standard.

Intel oneAPI is available for free. Currently the compiler supports Linux, MacOS and Windows platforms and x86_64 architectures. Community support is available for the free version at the Intel Developer forum.

The latest NAG Fortran Compiler release (7.0) has extensive support for legacy and modern Fortran features including parallel programming with coarrays, as well as additional support for programming with OpenMP.

The Compiler also provides significant support for Fortran 2018 (atomic operations, events and tasks, plus other smaller features), almost all of Fortran 2008, complete coverage of Fortran 2003, and all of OpenMP 3.1. All platforms include supporting tools for software development: source file polishers, dependency generator for module and include files, call-graph generator, interface builder and a precision unifier.

NVIDIA

The NVIDIA HPC SDK C, C++, and Fortran compilers, former PGI compilers, support GPU acceleration of HPC modeling and simulation applications with standard C++ and Fortran, OpenACC® directives, and CUDA®. GPU-accelerated math libraries maximize performance on common HPC algorithms, and optimized communications libraries enable standards-based multi-GPU and scalable systems programming.

NVHPC compilers are available free of charge. Currently the compiler supports Linux platforms and x86_64, ppc64le and aarch64 architectures. Community support is available at the HPC compiler forum.

HPE / Cray

The Cray Compiling Environment (CCE) is the cornerstone innovation of Cray’s adaptive computing paradigm. CCE builds on a well-developed and sophisticated Cray technology base that identifies regions of computation that are either sequential scalar, vector parallel or highly multithreaded. It includes optimizing compilers that automatically exploit the scalar, vector and multithreading hardware capabilities of the Cray system. CCE supports Fortran, C and C++.

IBM® XL Fortran for Linux is an industry standards-based programming tool used to develop large and complex applications in the Fortran programming language. It generates code that leverages the capabilities of the latest POWER9 architecture and maximizes your hardware utilization. IBM XL Fortran for Linux optimizes your infrastructure on IBM Power Systems™ in support of extensive numerical, scientific and high-performance computing.

A community edition of the IBM XL compilers are available free of charge. The compilers support Linux and AIX platforms and ppc64le architectures.

The AMD Optimizing C/C++ Compiler (AOCC) compiler system is a high performance, production quality code generation tool. The AOCC environment provides various options to developers when building and optimizing C, C++, and Fortran applications targeting 32-bit and 64-bit Linux® platforms. The AOCC compiler system offers a high level of advanced optimizations, multi-threading and processor support that includes global optimization, vectorization, inter-procedural analyses, loop transformations, and code generation. AMD also provides highly optimized libraries, which extract the optimal performance from each x86 processor core when utilized. The AOCC Compiler Suite simplifies and accelerates development and tuning for x86 applications.

The AOCC compilers are available free of charge and support Linux platforms with x86_64 architectures.

Linux user-space Fortran compiler. Tailored for HPC and scientific codes, with support for popular Fortran and OpenMP standards and tuned for leading server-class Arm-based platforms. Built on the open source Flang front-end, and the LLVM‑based optimization and code generation back-end. Available as part of the Arm Compiler for Linux package.

Absoft

Absoft compilers include Pro Fortran delivering Absoft’s exclusive AP load balancing, AVX, OpenMP 3.1, extended Fortran 95 compiler with F2003 and F2008 features, FX3 graphical debugger, native tool suite integration, AMDAL HPC scientific and engineering library, and more. Pro Fortran includes Fast Data Visualization, an Absoft exclusive technology for graphical rendering and data output.

Oracle / Sun

Oracle C, C++, Fortran Compiler is highly optimized for Oracle systems, on-premise and in the cloud

• Advanced code generation technology for the latest Oracle SPARC and x86 based systems
• Support for the latest industry standards, including C++14, C++11, C11 and OpenMP 4.0 and extensive GCC compatibility features
• Automatic code analysis during compilation and automatic stack overflow protection at application runtime

Lahey / Fujitsu

LF Professional v7.8 combines the 32/64-bit LGF Rainier compiler with the classic Lahey/Fujitsu LF95 compiler. LGF Rainier has full Fortran 95/90/77 compliance with extensive support for the Fortran 2003 and 2008 standards. Lahey/Fujitsu LF95 offers best in class diagnostics. Includes the automatic-parallelizing GFortran compiler, Lahey/Fujitsu Fortran 95 compiler, Visual Studio Fortran support, Winteracter WiSK Graphics package, and more.

Silverfrost FTN95

Silverfrost FTN95 is a full Fortran 95 standards compliant compiler, capable of producing fast executables for Win32 and for Microsoft .NET. FTN95 ships with the world’s best runtime checking and a great range of supporting software. All standard and many vendor-specific legacy language features are supported, so that Fortran projects may be any combination of Fortran 77, Fortran 90 and Fortran 95. Some features of Fortran 2003 and 2008 have been added. Silverfrost Fortran runs on Windows / x86_64. There is a free personal edition.

The Fortran compiler conforms to the Fortran-2003 standard (ISO/IEC 1539-1:2004) and supports many features from Fortran-2008 (ISO/IEC 1539-1:2010).

Discontinued

The following is a list of Fortran compilers that seem discontinued, so we do not list them above:

• Apogee
• Edinburgh Portable Compilers
• Hewlett Packard
• Watcom
• PathScale
• G95
• Open64
• Unisys

Please let us know if there is any compiler that is not listed, or if we listed a compiler in the Discontinued section and it is in fact actively maintained.

Fortran newsletter: October 2021	01 Oct 2021
Fortran newsletter: September 2021	01 Sep 2021
Fortran newsletter: August 2021	01 Aug 2021
Fortran newsletter: July 2021	01 Jul 2021
Fortran newsletter: June 2021	01 Jun 2021

Subscribe to our mailing list to discuss anything Fortran related, announce Fortran projects, discuss development of core fortran-lang.org projects (stdlib, fpm), and get the latest news.

Join the discussion about all things Fortran on the fortran-lang discourse.

Источник

Intel® Fortran Compiler for Linux* 19.1 Release Notes for Intel® Parallel Studio XE 2020

Last Updated: 11/20/2020

This document provides a summary of new and changed product features and includes notes about features and problems not described in the product documentation.

Please see the licenses included in the distribution as well as the Disclaimer and Legal Information section of these release notes for details. Please see the following links for information on this release of the Intel® Fortran Compiler 19.1.

Change History

This section highlights important changes from the previous product version and changes in product updates.

Changes in Update 4 (Intel® Fortran Compiler 19.1.3)

• Corrections to reported problems

Changes in Update 3

• No changes to Fortran on Linux*.

NOTE: Intel® Parallel Studio XE 2020 Composer Edition for Fortran and C++ Linux* contains an update to the Intel® C++ Compiler next generation code generator. This is invoked using the -qnextgen option to the ICC and ICPC compilers. This update to the Intel® C++ Compiler next generation code generator includes our latest updates and features for our C++ next generation compiler invoked with the -qnextgen option.

• There are no new features, bug fixes, or security enhancements for the Intel® Fortran Compiler or the Intel® C++ Compiler without the -qnextgen option.
• Intel® Parallel Studio XE 2020 Update 3 is available for the Intel® Parallel Studio XE 2020 Composer Edition for Fortran and C++ Linux*.
• This is a Linux-only release: there is no Update 3 release for either Windows* or macOS* operating systems.
• In addition, it is only a Composer Edition release: there is no Update 3 release for either Professional or Cluster Editions of Intel® Parallel Studio XE 2020.
• There is no update to the Intel® C++ and Fortran Compilers Redistributable Libraries. The Update 2 versions of these libraries are compatible and should be used.
• There is no update for the Intel® Parallel Studio XE Runtime 2020 YUM* and APT* repository packages. Continue to use the Update 2 packages of this runtime.

Changes in Update 2 (Intel® Fortran Compiler 19.1.2)

• Corrections to reported problems

Changes in Update 1 (Intel® Fortran Compiler 19.1.1)

• Corrections to reported problems

Changes since Intel® Fortran Compiler 19.0 (New in Intel® Fortran Compiler 19.1.0)

• New features from Fortran 2018
• New features from OpenMP 5.0*
• New compiler options:
  • assume [no]old_inquire_recl
  • -assume [no]old_ldout_zero
  • -check [no]udio_iostat
  • -warn [no]externals
• Changed compiler behavior
• Corrections to reported problems

System Requirements

• A PC based on an Intel® 64 architecture processor supporting the Intel® Streaming SIMD Extensions 2 (Intel® SSE2) instructions (Intel® 2nd Generation or newer Generation of Intel® Core™ i3, i5, or i7 processors and Intel® Xeon® E3, E5 or E7 processor family, or compatible non-Intel processor)
  • Development for a 32-bit on a 64-bit host may require optional library components (ia32-libs, lib32gcc1, lib32stdc++6, libc6-dev-i386, gcc-multilib, g++-multilib) to be installed from your Linux distribution.
• For the best experience, a multi-core or multi-processor system is recommended
• 2GB of RAM (4GB recommended)
• 14GB free disk space for all features
• For development of IA-32 or Intel® 64 architecture applications, one of the following Linux distributions (this is the list of distributions tested by Intel; other distributions may or may not work and are not recommended — please refer to Technical Support if you have questions):
  • Red Hat Enterprise Linux* 7, 8
  • CentOS 8
  • Ubuntu* 18.04 LTS, 19.04
  • Fedora* 30
  • SuSE LINUX Enterprise Server* 15
  • Debian* 10.0
• Linux Developer tools component installed, including gcc, g++ and related tools. (this is the list of component versions tested by Intel; other versions may or may not work and are not recommended — please refer to Technical Support if you have questions
  • gcc 4.8.5 to gcc 9.0.1
  • binutils 2.27 to binutils 2.31.1
• Library libunwind.so is required in order to use the -traceback option. Some Linux distributions may require that it be obtained and installed separately.

Notes

• The Intel® compilers are tested with a number of different Linux distributions, with different versions of gcc. The version of glibc you use must be consistent with the version of gcc in use. For best results, use only the gcc versions as supplied with distributions listed above.
• Compiling very large source files (several thousands of lines) using advanced optimizations such as -O3, -ipo and -qopenmp, may require substantially larger amounts of RAM.
• Some optimization options have restrictions regarding the processor type on which the application is run. Please see the documentation of these options for more information.

How To Install the Intel® Fortran Compiler

Installation instructions are shipped with all Intel® Software Development Products as part of the documentation. Installation guides for the latest Intel® Parallel Studio XE version are also available online. Please check Intel® Parallel Studio XE getting started page for installation guides. Note that link to Installation Guide is also available on Intel® Registration Center while downloading required installation package. Please refer to Installation FAQ for more details.

How To Use the Intel® Fortran Compiler

Intel® Parallel Studio XE 2020: Getting Started with the Intel® Fortran Compiler 19.1 for Linux* at /documentation_2020/en/compiler_f/ps2020/get_started_lf.htm contains information on how to use the Intel® Fortran Compiler.

Documentation

Product documentation is linked from /documentation_2020/en/compiler_f/ps2020/get_started_lf.htm.

Offline Core Documentation Removed from the Installed Image

Offline core documentation is removed from the Intel® Parallel Studio XE installed image. The core documentation for the components of Intel® Parallel Studio XE are available at the Intel® Software Documentation Library for viewing online. Offline documentation for older versions is also available from the Intel® Software Development Products Registration Center: Product List > Intel® Parallel Studio XE Documentation and from Download Documentation.

User and Reference Guides, What’s New and Release Notes, Installation Guides

Refer to the Intel® Parallel Studio XE Support – Documentation for additional User and Reference Guides, What’s New and Release Notes, and Installation Guides.

Japanese Language Support

Japanese language support is not provided with this release of the product.

If you wish to use Japanese-language support on an English-language operating system, or English-language support on a Japanese-language operating system, you will find instructions at Changing Language Setting to see English on a Japanese OS environment or Vice Versa on Linux*.

Intel-provided Debug Solutions

Intel®-provided debug solutions are based GNU* GDB. Please see Intel® Parallel Studio 2020 Composer Edition Fortran — Debug Solutions Release Notes for further information.

Samples

Product samples are now available online at Intel® Software Product Samples and Tutorials.

Redistributable Libraries

Technical Support

Register your license at the Intel® Software Development Products Registration Center. Registration entitles you to free technical support, product updates and upgrades for the duration of the support term.

For information about how to find Technical Support, Product Updates, User Forums, FAQs, tips and tricks, and other support information, please visit: http://www.intel.com/software/products/support/

Note: If your distributor provides technical support for this product, please contact them for support rather than Intel.

Compatibility

In general, object code and modules compiled with earlier versions of Intel Fortran Compiler for Linux* (8.0 and later) may be used in a build with version 19.1. Exceptions include:

• Sources that use the CLASS keyword to declare polymorphic variables and which were built with a compiler version earlier than 12.0 must be recompiled.
• Objects built with the multi-file interprocedural optimization (-ipo) option must be recompiled with the current version.
• Objects that use the REAL(16), REAL*16, COMPLEX(16) or COMPLEX*32 datatypes and which were compiled with versions earlier than 12.0 must be recompiled.
• Objects built for the Intel® 64 architecture with a compiler version earlier than 10.0 and that have module variables must be recompiled. If non-Fortran sources reference these variables, the external names may need to be changed to remove an incorrect leading underscore.
• Modules that specified an ATTRIBUTES ALIGN directive outside of a derived type and were compiled with versions earlier than 11.0 must be recompiled. The compiler will notify you if this issue is encountered.
• Modules that specified an ATTRIBUTES ALIGN directive inside a derived type declaration cannot be used by compilers older than 13.0.1.
• The implementation of the Fortran 2008 submodules feature required extensive changes to the internal format of binary .mod files. Therefore module files created by the version 16.0 or newer Fortran compiler cannot be used with version 15.0 or older Fortran compilers.
• Objects/libraries compiled/built for the Intel® Xeon Phi™ x100 product family are not compatible with objects/libraries compiled/built for the Intel® Xeon Phi™ x200 product family.
• Objects built with Intel Fortran Compiler version 18.0 and earlier version of regcall calling convention must be recompiled with 19.0 or newer. Intel library libirng uses regcall. Version of this library shipped with 19.0 compiler version or newer is not compatible with older versions. regcall is implicitly used by following attribute:
  !DIR$ ATTRIBUTES [att,] VECTOR [:clause] [, att]. :: routine-name

Stack Alignment Change for REAL(16) and COMPLEX(16) Datatypes

In versions prior to 12.0, when a REAL(16) or COMPLEX(16) (REAL*16 or COMPLEX*32) item was passed by value, the stack address was aligned at 4 bytes. For improved performance, the version 12 and later compilers align such items at 16 bytes and expects received arguments to be aligned on 16-byte boundaries. This change is also compatible with gcc.

This change primarily affects compiler-generated calls to library routines that do computations on REAL(16) values, including intrinsics. If you have code compiled with earlier versions and link it with the version 12 libraries, or have an application linked to the shared version of the Intel run-time libraries, it may give incorrect results.

In order to avoid errors, you must recompile all Fortran sources that use the REAL(16) and COMPLEX(16) datatypes if they were compiled by compiler versions earlier than 12.0.

New and Changed Compiler Features

New features from Fortran 2018

• Enhancements to the IMPLICIT statement allow specifying that all external procedures must declared EXTERNAL
• Enhancements to the GENERIC statement permit it to be used to declare generic interfaces
• The locality of variables may now be specified on a DO CONCURRENT statement
• Enhancements to edit descriptor forms E, D, EN, ES, and G allow a field width of zero, analogous to the F edit descriptor
• The exponent width e in a data edit descriptor may now be zero, analogous to a field width of zero
• The RN edit descriptor now rounds to nearest as specified by Fortran 2018 and ISO/IEC/IEEE 60559:2011
• The EX edit descriptor allows for hexadecimal format output of floating point values. Hexadecimal format floating point values are allowed on input.
• SIZE= may be specified for non-advancing I/O
• The values for SIZE= and POS= in an INQUIRE statement for pending asynchronous operations have been standardized
• The value assigned to the RECL= specifier in an INQUIRE statement now has standardized values
• A new form of the intrinsic function CMPLX does not require the KIND= keyword if the first argument is type COMPLEX
• The arguments to the SIGN function may be of different kinds
• INTEGER and LOGICAL arguments to intrinsic procedures are no longer required to be of default kind
• The named constants STAT_FAILED_IMAGE and STAT_UNLOCKED_FAILED_IMAGE have been defined in the intrinsic
  ISO_FORTRAN_ENV module
• The non-block DO statement and the arithmetic IF statement are now deleted in Fortran 2018. Intel® Fortran fully supports features deleted in the FORTRAN standard
• COMMON, EQUIVALENCE and BLOCKDATA statements are now obsolescent
• The labeled form of DO loops is now obsolescent
• Locality of variables in DO CONCURRENT constructs can now be declared on the DO CONCURRENT statement
• Specific names of intrinsic procedures are now obsolescent
• FAIL IMAGE statement allows debugging recovery code for failed images without having to wait for an actual image failure
• The named constants STAT_FAILED_IMAGE and STAT_UNLOCKED_FAILED_IMAGE have been defined in the intrinsic
  ISO_FORTRAN_ENV module
• An optional argument STAT= has been added to ATOMIC_REF and ATOMIC_DEFINE intrinsic procedures
• Optional STAT= and ERRMSG= specifiers have been added to the MOVE_ALLOC intrinsic procedure, to image selectors, and to the CRITICAL statement and construct
• Atomic subroutines ATOMIC_ADD, ATOMIC_AND, ATOMIC_CAS, ATOMIC_FETCH_ADD, ATOMIC_FETCH_AND, ATOMIC_FETCH_OR, ATOMIC_FETCH_XOR, ATOMIC_OR, and ATOMIC_XOR have been implemented
• Collective subroutines CO_BROADCAST, CO_MAX, CO_MIN, CO_REDUCE, and CO_SUM have been implemented
• The SELECT RANK construct has been implemented allowing manipulation of assumed rank dummy arguments
• The compiler will now diagnose the use of nonstandard intrinsic procedures and modules as required by Fortran 2018
• Transformational intrinsic functions from the intrinsic modules ISO_C_BINDING, IEEE_ARITHMETIC, and IEEE_EXCEPTIONS are now allowed in specification expressions
• You can now specify the optional argument RADIX for the IEEE_GET_ROUNDING_MODE and IEEE_SET_ROUNDING_MODE intrinsic module procedures
• The optional ROUND argument has been added to the IEEE_RINT function in the intrinsic module IEEE_ARITHMETIC
• The intrinsic module IEEE_ARITHMETIC now includes the functions IEEE_FMA, IEEE_SIGN_BIT, IEEE_NEXT_UP and IEEE_NEXT_DOWN
• The intrinsic module procedures IEEE_MAX, IEEE_MIN, IEEE_MAX_MAG, and IEEE_MIN_MAG have been implemented
• The intrinsic module procedures IEEE_INT and IEEE_REAL have been implemented
• The intrinsic module IEEE_EXCEPTIONS now contains a new derived type, IEEE_MODES_TYPE, which can be used to save and restore the IEEE_MODES using the IEEE_GET_MODES and the IEEE_SET_MODES intrinsic module procedures
• A new rounding mode, IEEE_AWAY has been added
• SUBNORMAL is now synonymous with DENORMAL
• IEEE_QUIET_EQ, IEEE_QUIET_NE, IEEE_QUIET_LT, IEEE_QUIET_LE, IEEE_QUIET_GT, IEEE_QUIET_GE, IEEE_SIGNALING_EQ, IEEE_SIGNALING_NE, IEEE_SIGNALING_GT, IEEE_SIGNALING_GE, IEEE_SIGNALING_LT, and IEEE_SIGNALING_LE intrinsic module procedures have been implemented

New Features From OpenMP 5.0*

• IF clause on SIMD directive
• NONTEMPORAL clause on SIMD directive
• Inclusive/exclusive scan operations in SIMD and TARGET SIMD constructs.

Changed Compiler Behavior

• Previous compiler versions erroneously permitted a PRIVATE or SEQUENCE statement to appear prior to the declaration of any type parameters in a derived type declaration. Intel® Fortran Compiler 19.1 no longer permits this behavior.
• The INQUIRE statement now uses realpath() function with argument ’/’’GetFullPathNameA’ and uses the resulting canonicallized file-paths if the calls succeeds. An example of the change is:
  Open file as “bar/foo”.
  Before:
  Inquire whether “./bar/foo”, “bar//foo” or “bar/../bar/foo” is open – it is not.
  After:
  Inquire whether “./bar/foo”, “bar//foo” or “bar/../bar/foo” is open – it is.
• In 19.0 compiler version, all procedures with the exception of C_F_POINTER from the intrinsic module ISO_C_BINDING were made PURE per the Fortran 2018 standard. Interpretation 18/007 declared that making C_F_PROCPOINTER PURE was a mistake. 19.1 complies with this interpretation and makes C_F_PROCPOINTER IMPURE.

New and Changed Compiler Options

Please refer to the compiler documentation for details. Following new compiler options added:

For a list of deprecated compiler options, see the Compiler Options section of the documentation.

-assume [no]old_inquire_recl

Determines the value of the RECL= specifier on an INQUIRE statement for an unconnected unit or a unit connected for stream access.

-assume [no]old_ldout_zero

Determines the format of a floating-point zero produced by list-directed output. old_ldout_zero uses exponential format, no_old_ldout_zero uses fractional format.

-check [no]udio_iostat

Determines whether standard conformance checking occurs when user defined derived type input/output procedures are executed.

-warn [no]externals

-m[no-]branches-within-32B-boundaries

This option is supported in versions 19.0 update 8 of the compiler and above. The details about this option can be found in the Intel® Fortran Compiler 19.1 Developer Guide and Reference. To find more information, see https://www.intel.com/content/dam/support/us/en/documents/processors/mitigations-jump-conditional-code-erratum.pdf

Support Deprecated

The compiler option -stand f15 will be removed in next update. Use -stand f18 instead.

Support Removed

Loop Profiler

The Loop Profiler feature is removed in Intel® Fortran Compiler 19.1. The following compiler options related to Loop Profiler are removed: -profile-loops=keyword, -profile-loops-report=value -profile-functions, -guide-profile.

Installation on 32-bit hosts has been removed

Installation on 32-bit hosts was removed in Intel® Parallel Studio XE 2018 versions. Support for generating code for 32-bit targets is supported on 64-bit hosts (only) via compiler option -m32.

Intel® Xeon Phi™ x100 product family coprocessor (formerly code name Knights Corner) is not supported

The Intel® Xeon Phi™ x100 product family coprocessor (formerly code name Knights Corner) was officially announced end of life in January 2017. As part of the end of life process, the support for this family will only be available in the Intel® Parallel Studio XE 2017 version. Intel® Parallel Studio XE 2017 will be supported for a period of 3 years ending in January 2020 for the Intel® Xeon Phi™ x100 product family. Support will be provided for those customers with active support.

Known Issues

Fortran Coarray Application Hang After Executing FAIL IMAGE

The current FAIL IMAGE implementation has a known issue that manifests after the FAIL IMAGE statement is executed. Please refer to the article for more details.

If you use a FAIL IMAGE statement to make an image fail, you should use a STAT= specifier or a STAT argument in all coarray operations that might encounter that failed image if the statement or operation permits, or you should specify either the assume failed_images or standard-semantics compiler option. If you do not use a STAT= specifier, a STAT argument, or specify one of the compiler options, those operations will not check for failed images. They may then try to coordinate with the failed image, waiting for a response from it. The response would never happen and so the application would hang.

The following example demonstrates using the STAT= specifier to prevent an application hang.

Using the Coarray Feature with Red Hat 8

Applications that use the coarray feature and are running on Red Hat 8.0 or later should have Intel MPI 2019 Update 7 or later installed. With earlier versions of MPI, applications will not complete successfully and give little information about the failure.

Fortran 2008 and Fortran 2018 Feature Summary

The Intel® Fortran Compiler supports full Fortran 2008 standard and most features from the Fortran 2018 standard. New Fortran 2018 features supported by the current version are listed in the ‘New features from Fortran 2018’ section.

Please refer to the Fortran 2008 Standard (PDF) and the Fortran 2018 Standard (PDF) if necessary.

Disclaimer and Legal Information

Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked «reserved» or «undefined.» Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.

INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL(R) PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL’S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR.

The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.

Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.

Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or go to: http://www.intel.com/design/literature.htm

Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. Go to:

The Intel® Fortran Compiler is provided under Intel’s End User License Agreement (EULA).

Please consult the licenses included in the distribution for details.

Intel, the Intel logo, the Intel Inside logo, Xeon, and Intel Xeon Phi are trademarks of Intel Corporation or its subsidiaries in the U.S. and/or other countries.

* Other names and brands may be claimed as the property of others.

Источник