Skip to main content

PWR075: Avoid using compiler-specific Fortran extensions

Issue​

Using compiler-specific extensions, such as those provided by GNU's gfortran or Intel's ifort and ifx, compromises the portability and consistency of code across different development environments.

Actions​

Refactor the code to replace existing compiler-specific extensions with standard-compliant Fortran code. The specific steps for refactoring will depend on the particular features being replaced.

Relevance​

Fortran compilers often extend their support beyond the Fortran standard by introducing additional language features. While these extensions can provide enhanced functionality and convenience for programmers, they also present significant drawbacks.

Even though some extensions may be supported by multiple compilers, there will inevitably be environments where the code is not compilable, complicating future maintenance. Additionally, even when multiple vendors support the same extension, its behavior can vary, as these features are not regulated by the Fortran standard. Ultimately, Fortran code that depends on compiler-specific extensions cannot be guaranteed to be portable and consistent across different development environments.

This issue is particularly problematic when inheriting legacy code. If the code relies on compiler-specific extensions from a now unsupported or inaccessible compiler version, developers are forced to port the code to new environments, further complicating the already challenging task of maintaining legacy code.

Some compiler-specific extensions include:

  • GNU Fortran: shadowing host entities in internal procedures, forward referencing symbols in the specification part, or using REAL expressions in array subscripts.

  • Intel Fortran: calling functions as if they were subroutines, allowing DATA statements that do not fully initialize arrays or derived types, or accessing arrays beyond their declared bounds without triggering any semantic errors.

For more information on which extensions are implemented by different compilers, see the References section below for links to their official documentation.

Code examples​

GNU Fortran extension​

Consider the following code, which checks if the file itself exists:

! example-gnu.f90
program example
  implicit none
  character(len = *), parameter :: file  = "example-gnu.f90"

  if(access(file, " ") == 0) then
    print *, "I exist"
  end if
end program example

This code uses access(), a GNU Fortran extension that compiles successfully with gfortran:

$ gfortran --version
GNU Fortran (Debian 14.2.0-3) 14.2.0
$ gfortran example-gnu.f90 -o example-gnu
$ ./example-gnu
 I exist

However, the same code fails to compile with LLVM's flang compiler:

$ flang-new-18 --version
Debian flang-new version 18.1.8 (9)
$ flang-new-18 example-gnu.f90 -o example-gnu
error: Semantic errors in example-gnu.f90
./example.f90:7:6: error: No explicit type declared for 'access'
    if(access(file, " ") == 0) then
       ^^^^^^

To resolve this issue, the programmer needs to provide a replacement for the functionality of the GNU extension. Fortunately, the Fortran standard provides the built-in inquire:

! solution-gnu.f90
program solution
  implicit none
  character(len = *), parameter :: file  = "solution-gnu.f90"
  logical :: exists

  inquire(file=file, exist=exists)

  if(exists) then
    print *, "I exist"
  end if
end program solution

This revised code compiles and runs successfully with flang:

$ flang-new-18 solution-gnu.f90 -o solution-gnu
$ ./solution-gnu
 I exist

Intel Fortran extension​

Consider the following code:

! example-intel.f90
program main
  implicit none

  type :: foo_t
    integer :: x
  end type

  type(foo_t) :: foo(2)
  integer :: bar(2)

  data foo%x /1/
  data bar /1/

  print *, foo
  print *, bar
end

This code relies on an Intel Fortran extension that allows DATA statements to partially initialize arrays or derived types. In this case, only the first element of foo%x and bar is initialized explicitly, while the remaining elements are implicitly zero-initialized.

When compiled with Intel's ifx compiler, the program produces:

$ ifx --version
ifx (IFX) 2024.0.0 20231017
Copyright (C) 1985-2023 Intel Corporation. All rights reserved.
$ ifx example-intel.f90 -o example-intel
$ ./example-intel
           1           0
           1           0

By contrast, compilers that follow the Fortran standard strictly reject the code:

$ flang-new-18 --version
Debian flang-new version 18.1.8 (9)
$ flang-new-18 example-intel.f90 -o example-intel
error: Semantic errors in example-intel.f90
example-intel.f90:13:3: error: DATA statement set has no value for 'foo(2_8)%x'
    data foo%x /1/
    ^^^^^^^^^^^^^^
example-intel.f90:14:3: error: DATA statement set has no value for 'bar(2_8)'
    data bar /1/
    ^^^^^^^^^^^^

To make the code portable and accepted by all standard-compliant Fortran compilers, each element of the arrays and derived types must be explicitly initialized. The corrected version of the program is:

! solution-intel.f90
program main
  implicit none

  type :: foo_t
    integer :: x
  end type

  type(foo_t) :: foo(2)
  integer :: bar(2)

  data foo%x /1, 0/
  data bar /1, 0/

  print *, foo
  print *, bar
end

Now, the DATA statements provide values for all elements of foo%x and bar, eliminating any reliance on implicit zero initialization by a particular compiler:

$ flang-new-18 solution-intel.f90 -o solution-intel
$ ./solution-intel
 1 0
 1 0

Alternatives to compiler-specific extensions​

The following table lists GNU intrinsic extensions and their corresponding Fortran Standard equivalents. It also includes a subset of GNU extensions. This table is expected to grow as more GNU extensions, as well from other compilers, are included in this PWR075 documentation.

GNU Intrinsic ExtensionFortran Standard
Functions for program termination and error reporting: ABORT, EXIT,PERRORUse the generic control termination statements: STOP or ERROR STOP
Functions to query file status and access information: ACCESS, FSTAT, LSTAT, STATUse the generic I/O statement INQUIRE to check file properties
Function to obtain a program call stack for debugging: BACKTRACEStandard Fortran doesn't have an intrinsic function to generate a backtrace
Non-standard Bessel functions: BESJ0, DBESJ0, BESJ1, DBESJ1, BESY0, DBESY0, BESY1, DBESY1, BESJN, DBESJN, BESYN, DBESYNUse the generic intrinsic procedures: BESSEL_J0, BESSEL_J1, BESSEL_Y0, BESSEL_Y1, BESSEL_JN(N, X) or BESSEL_JN(N1, N2, X), BESSEL_YN (N, X) or BESSEL_YN (N1, N2, X)
Functions to compute the remainder for different integer precisions: BMOD, IMOD, JMOD, KMODUse the generic intrinsic to compute the remainder of division: MOD(A, P)
Bitwise operations: BNOT, INOT, JNOT, KNOT, BIAND, IIAND, JIAND, KIAND, BIEOR, IIEOR, JIEOR. KIEOR, BIOR, IIOR, JIOR, KIOR, BSHFT, IISHFT, JISHFT, KISHFT, BSHFTC, IISHFTC, JISHFTC, KISHFTC, BBTEST, BITEST, BJTEST, BKTEST, BBCLR, IIBCLR, JIBCLEAR, KIBCLR, BBSET, IIBSET, JIBSET, KIBSET, BBITS, IIBITS, JIBITS, KIBITS, BMVBITS, IMVBITS, JMVBITS, KMVBITSUse the standard generic intrinsic procedures: NOT, IAND, IEOR, IOR, ISHFT, ISHFTC, BTEST, IBCLR, IBSET, IBITS and MVBITS
Functions for system operations and environment control: CHDIR,FNUM, ISATTY, SLEEP, CHMOD, ALARM, HOSTNM, KILL, LINK, SYMLNK, SIGNAL, TTYNAM, UMASKThis is usually managed with interoperability of C functions
Intrinsic function to manage complex numbers: COMPLEXUse the standard function to construct complex numbers: CMPLX(X [, KIND]) or CMPLX(X [, Y, KIND])
Non-standard trigonometric functions: COTAN, DCOTAN, COTAND, DCOTAND, CCOTAN, ZCOTANUse the standard to compute the equivalents with variants of: 1.0 / TAN(X)
Non-standard trigonometric functions in degrees: DACOSD, DASIND, DATAND, DCOSD, DSIND, DTAND, DATAN2DStandard Fortran 2023 introduced generic trigonometric functions that accept angles in degrees: ACOSD, ASIND, ATAND, ATAN2D, COSD, SIND, TAND
Non-standard double precision hyperbolic trigonometric functions: DACOSH, DASINH, DATANHUse the generic intrinsic procedures: ACOSH, ASINH, ATANH
Mathematical function to compute the Gamma function for double precision arguments: DGAMMAUse the generic GAMMA that also accepts double precision arguments
Mathematical function for double precision complementary error function: DERFCUse the generic intrinsic function for the complementary error function: ERFC
Functions for processor time measurements: DTIME, SECONDUse the generic intrinsic subroutine CPU_TIME(TIME)
Functions to retrieve date and time information: FDATE, IDATE, ITIME, CTIME, LTIME, GMTIMEUse the generic intrinsic subroutine DATE_AND_TIME([DATE, TIME, ZONE, VALUES])
Functions for low-level file input: FGET, FGETCUse READ or C interoperability
Functions to indicate integers of different precisions: FLOATI, FLOATJ, FLOATKUse the generic REAL(A) function or DBLE(A) function if double precision is required.
Function to flush buffered output to a file or unit: FLUSHUse the standard I/O declaration FLUSH, not the intrinsic procedure (e.g. FLUSH file-unit-number or FLUSH (flush-spec-list))
Functions for low-level file output: FPUT, FPUTCUse WRITE or C interoperability
Function to release an allocated or opened Fortran unit: FREEUse the generic statement to release allocated memory for allocatable arrays or pointers: DEALLOCATE
Function for low-level file positioning: FSEEKUse the generic REWIND, BACKSPACE or POS= specifier for file positioning
Function to obtain the current file position: FTELLUse POS= specifier in the INQUIRE statement
Function to report the last runtime I/O or system error: GERRORUse the generic specifier for retrieving error messages from I/O operations: IOMSG=/
Functions to access command-line arguments: GETARG, IARGCUse the generic intrinsic procedures GET_COMMAND_ARGUMENT and COMMAND_ARGUMENT_COUNT
Functions to access environment variables and logical I/O: GETENV, GETLOGUse the generic intrinsic subroutine GET_ENVIRONMENT_VARIABLE
Function to retrieve the system error number: IERRNOUse the generic specifier for error and status handling in I/O statements: IOSTAT=/
Function to extract the imaginary part of a complex number: IMAGPARTUse the generic intrinsic function AIMAG(Z) that returns the imaginary part of a complex number
Types to convert values to integers of different precisions: INT2, INT8Use the generic intrinsic function INT(A, KIND) along with standard kind type parameters (e.g. C_INT16_T or C_INT64_T)
Mathematical functions to compute the natural logarithm of the Gamma function: LGAMMA, ALGAMA, DLGAMAUse the generic intrinsic function LOG_GAMMA
Function to find the last non-blanck character in a string: LNBLNKUse the generic intrinsic function LEN_TRIM(STRING [, KIND])
Functions for generating random numbers: RAND, RAN,IRAND, SRANDUse the generic intrinsic to generate pseudorandom numbers: RANDOM_NUMBER
Function to extract the real part of a complex number: REALPARTUse the generic intrinsic function REAL(A [, KIND]) or DBLE(A) if double precision is required to obtain the real part
Function to execute a system command from Fortran: SYSTEMUse the generic intrinsic subroutine EXECUTE_COMMAND_LINE
Functions for time measurement and system time: TIME, TIME8, MCLOCK, MCLOCK8, SECNDSUse the generic intrinsic subroutine SYSTEM_CLOCK([COUNT, COUNT_RATE, COUNT_MAX]) that checks the system clock
Function to delete a file from the filesystem: UNLINKUse CLOSE with STATUS='DELETE' or C interoperability
Functions for operations on complex numbers: ZCOS, ZEXP, ZLOG, ZSIN, ZSQRTUse the generic intrinsic procedures as they accept arguments of complex type, including double complex type: COS(X), EXP(X), LOG(X), SIN(X), SQRT(X)

References​